mirror of
https://github.com/garrytan/gstack.git
synced 2026-09-15 17:35:29 +02:00
Merge origin/main (v1.64.0.0) into garrytan/time-attack-fork-review
Both waves fixed several of the same bugs; resolutions keep whichever shape this branch's tests pin (#2018 jq bind, #1798 set-- pattern, stop-ack, lock errors, polyfill windowsHide) and take main's richer codex Step 2A (it absorbed the same mktemp fix). True unions: memory- ingest keeps main's capability-probed --include-gitignored inside our GIT_CEILING defense; setup wraps main's Playwright platform override in our stale-healing install lock; package.json takes main's diff@^9 and the combined test glob (design/test + ios-qa/daemon/test, 30s timeout). Generated SKILL.md files regenerated from resolved templates, never hand-picked. Ship goldens refreshed; parity/carve budgets re-measured for the summed preamble growth of both waves (itemized per entry).
This commit is contained in:
Garry Tan
+14
-6
@@ -80,13 +80,15 @@ if [ "$_EXPLAIN_LEVEL" != "default" ] && [ "$_EXPLAIN_LEVEL" != "terse" ]; then
|
||||
echo "EXPLAIN_LEVEL: $_EXPLAIN_LEVEL"
|
||||
_QUESTION_TUNING=$(~/.claude/skills/gstack/bin/gstack-config get question_tuning 2>/dev/null || echo "false")
|
||||
echo "QUESTION_TUNING: $_QUESTION_TUNING"
|
||||
_UPDATE_CHECK=$(~/.claude/skills/gstack/bin/gstack-config get update_check 2>/dev/null || echo "true")
|
||||
echo "UPDATE_CHECK: $_UPDATE_CHECK"
|
||||
mkdir -p ~/.gstack/analytics
|
||||
if [ "$_TEL" != "off" ]; then
|
||||
echo '{"skill":"browse","ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","repo":"'$(_repo=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null | tr -cd 'a-zA-Z0-9._-'); echo "${_repo:-unknown}")'"}' >> ~/.gstack/analytics/skill-usage.jsonl 2>/dev/null || true
|
||||
fi
|
||||
for _PF in $(find ~/.gstack/analytics -maxdepth 1 -name '.pending-*' 2>/dev/null); do
|
||||
if [ -f "$_PF" ]; then
|
||||
if [ "$_TEL" != "off" ] && [ -x "~/.claude/skills/gstack/bin/gstack-telemetry-log" ]; then
|
||||
if [ "$_TEL" != "off" ] && [ -x "$HOME/.claude/skills/gstack/bin/gstack-telemetry-log" ]; then
|
||||
~/.claude/skills/gstack/bin/gstack-telemetry-log --event-type skill_run --skill _pending_finalize --outcome unknown --session-id "$_SESSION_ID" 2>/dev/null || true
|
||||
fi
|
||||
rm -f "$_PF" 2>/dev/null || true
|
||||
@@ -152,6 +154,8 @@ If `PROACTIVE` is `"false"`, do not auto-invoke or proactively suggest skills. I
|
||||
|
||||
If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`.
|
||||
|
||||
If `UPDATE_CHECK` is `"false"`, skip the next two lines — the update-check binary emits nothing in that mode, so there is no `UPGRADE_AVAILABLE` / `JUST_UPGRADED` output to act on.
|
||||
|
||||
If output shows `UPGRADE_AVAILABLE <old> <new>`: read `~/.claude/skills/gstack/gstack-upgrade/SKILL.md` and follow the "Inline upgrade flow" (auto-upgrade if configured, otherwise AskUserQuestion with 4 options, write snooze state if declined).
|
||||
|
||||
If output shows `JUST_UPGRADED <from> <to>`: print "Running gstack v{to} (just updated!)". If `SPAWNED_SESSION` is true, skip feature discovery.
|
||||
@@ -339,8 +343,8 @@ if [ -f "$HOME/.gstack-artifacts-remote.txt" ]; then
|
||||
else
|
||||
_BRAIN_REMOTE_FILE="$HOME/.gstack-brain-remote.txt"
|
||||
fi
|
||||
_BRAIN_SYNC_BIN="~/.claude/skills/gstack/bin/gstack-brain-sync"
|
||||
_BRAIN_CONFIG_BIN="~/.claude/skills/gstack/bin/gstack-config"
|
||||
_BRAIN_SYNC_BIN="$HOME/.claude/skills/gstack/bin/gstack-brain-sync"
|
||||
_BRAIN_CONFIG_BIN="$HOME/.claude/skills/gstack/bin/gstack-config"
|
||||
|
||||
# /sync-gbrain context-load: teach the agent to use gbrain when it's available.
|
||||
# Per-worktree pin: post-spike redesign uses kubectl-style `.gbrain-source` in the
|
||||
@@ -449,8 +453,8 @@ If A/B and `~/.gstack/.git` is missing, ask whether to run `gstack-artifacts-ini
|
||||
At skill END before telemetry:
|
||||
|
||||
```bash
|
||||
"~/.claude/skills/gstack/bin/gstack-brain-sync" --discover-new 2>/dev/null || true
|
||||
"~/.claude/skills/gstack/bin/gstack-brain-sync" --once 2>/dev/null || true
|
||||
"$HOME/.claude/skills/gstack/bin/gstack-brain-sync" --discover-new 2>/dev/null || true
|
||||
"$HOME/.claude/skills/gstack/bin/gstack-brain-sync" --once 2>/dev/null || true
|
||||
```
|
||||
|
||||
|
||||
@@ -523,11 +527,15 @@ fi
|
||||
if [ "$_TEL" != "off" ] && [ -x ~/.claude/skills/gstack/bin/gstack-telemetry-log ]; then
|
||||
~/.claude/skills/gstack/bin/gstack-telemetry-log \
|
||||
--skill "SKILL_NAME" --duration "$_TEL_DUR" --outcome "OUTCOME" \
|
||||
--used-browse "USED_BROWSE" --session-id "$_SESSION_ID" 2>/dev/null &
|
||||
--used-browse "USED_BROWSE" --session-id "$_SESSION_ID" \
|
||||
--error-message "ERROR_MESSAGE" --failed-step "FAILED_STEP" 2>/dev/null &
|
||||
fi
|
||||
```
|
||||
|
||||
Replace `SKILL_NAME`, `OUTCOME`, and `USED_BROWSE` before running.
|
||||
Replace `ERROR_MESSAGE` with a short description of the error (if outcome is error,
|
||||
otherwise use empty string ""), and `FAILED_STEP` with the step name or number where
|
||||
the failure occurred (if outcome is error, otherwise use empty string "").
|
||||
|
||||
## Plan Status Footer
|
||||
|
||||
|
||||
@@ -32,7 +32,7 @@ bun build "$SRC_DIR/server.ts" \
|
||||
# Replace import.meta.dir with a resolvable reference
|
||||
perl -pi -e 's/import\.meta\.dir/__browseNodeSrcDir/g' "$DIST_DIR/server-node.mjs"
|
||||
# Stub out bun:sqlite (macOS-only cookie import, not needed on Windows)
|
||||
perl -pi -e 's|import { Database } from "bun:sqlite";|const Database = null; // bun:sqlite stubbed on Node|g' "$DIST_DIR/server-node.mjs"
|
||||
perl -pi -e 's|import \{ Database \} from "bun:sqlite";|const Database = null; // bun:sqlite stubbed on Node|g' "$DIST_DIR/server-node.mjs"
|
||||
|
||||
# Step 3: Create the final file with polyfill header injected after the first line
|
||||
{
|
||||
|
||||
@@ -167,7 +167,11 @@ export function probePoisonedChromiumBundle(chromiumExecutablePath: string): voi
|
||||
* restarts on backoff.
|
||||
*/
|
||||
export async function resolveDisconnectCause(browser: Browser | null): Promise<'clean' | 'crash'> {
|
||||
const proc = browser?.process();
|
||||
// `.process()` only exists on browsers we launched ourselves. A browser
|
||||
// obtained via connectOverCDP() (or a stub in tests) has no such method —
|
||||
// calling it blind throws inside the disconnect handler, which killed the
|
||||
// whole daemon with "browser?.process is not a function".
|
||||
const proc = typeof browser?.process === 'function' ? browser.process() : null;
|
||||
if (proc && proc.exitCode === null && proc.signalCode === null) {
|
||||
await new Promise<void>((resolve) => {
|
||||
const timer = setTimeout(resolve, 1000);
|
||||
@@ -869,19 +873,31 @@ export class BrowserManager {
|
||||
const page = this.pages.get(tabId);
|
||||
if (!page) throw new Error(`Tab ${tabId} not found`);
|
||||
|
||||
// Capture BEFORE close(): the page 'close' event handler wired in
|
||||
// wirePageEvents() can fire while page.close() is awaited. It removes
|
||||
// the tab from the maps and reassigns activeTabId (to 0 when no tabs
|
||||
// remain), so a post-close `tabId === this.activeTabId` check is
|
||||
// order-dependent — whether the event dispatches before or after
|
||||
// close() resolves varies across Playwright/Chromium versions and
|
||||
// machines, and losing the race means the last-tab auto-create below
|
||||
// never runs, leaving the manager with zero tabs.
|
||||
const wasActive = tabId === this.activeTabId;
|
||||
|
||||
await page.close();
|
||||
this.pages.delete(tabId);
|
||||
this.tabSessions.delete(tabId);
|
||||
this.tabOwnership.delete(tabId);
|
||||
|
||||
// Switch to another tab if we closed the active one
|
||||
if (tabId === this.activeTabId) {
|
||||
if (wasActive) {
|
||||
const remaining = [...this.pages.keys()];
|
||||
if (remaining.length > 0) {
|
||||
this.activeTabId = remaining[remaining.length - 1];
|
||||
} else {
|
||||
if (remaining.length === 0) {
|
||||
// No tabs left — create a new blank one
|
||||
await this.newTab();
|
||||
} else if (!this.pages.has(this.activeTabId)) {
|
||||
// The 'close' handler may have already switched to a valid tab;
|
||||
// only reassign when activeTabId no longer points at a live tab.
|
||||
this.activeTabId = remaining[remaining.length - 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+23
-1
@@ -34,7 +34,12 @@ export function getGitRoot(): string | null {
|
||||
const proc = Bun.spawnSync(['git', 'rev-parse', '--show-toplevel'], {
|
||||
stdout: 'pipe',
|
||||
stderr: 'pipe',
|
||||
timeout: 2_000, // Don't hang if .git is broken
|
||||
// Raised from 2s: under heavy machine load `git rev-parse` routinely
|
||||
// takes >2s (measured 6.3s spikes). Timing out here returns null →
|
||||
// resolveConfig falls back to process.cwd() → state files scatter across
|
||||
// cwds (split-brain daemons; `goto` and `url` hit different servers). 8s
|
||||
// still bounds a genuinely broken .git from hanging the CLI forever.
|
||||
timeout: 8_000,
|
||||
});
|
||||
if (proc.exitCode !== 0) return null;
|
||||
return proc.stdout.toString().trim() || null;
|
||||
@@ -78,6 +83,20 @@ export function resolveConfig(
|
||||
};
|
||||
}
|
||||
|
||||
function isIgnoredByGit(projectDir: string, relPath: string): boolean {
|
||||
try {
|
||||
const proc = Bun.spawnSync(['git', 'check-ignore', '-q', '--', relPath], {
|
||||
cwd: projectDir, stdout: 'pipe', stderr: 'pipe',
|
||||
timeout: 2_000,
|
||||
});
|
||||
return proc.exitCode === 0;
|
||||
} catch {
|
||||
// git not found, timed out, or not a repo (exit 128). Fall through to
|
||||
// the text-check path — appending is the safe default when unsure.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create the .gstack/ state directory if it doesn't exist.
|
||||
* Throws with a clear message on permission errors.
|
||||
@@ -96,6 +115,9 @@ export function ensureStateDir(config: BrowseConfig): void {
|
||||
}
|
||||
|
||||
// Ensure .gstack/ is in the project's .gitignore
|
||||
// First, check if git already ignores .gstack/ (via global excludes, .git/info/exclude, or parent .gitignore)
|
||||
if (isIgnoredByGit(config.projectDir, '.gstack/')) return;
|
||||
|
||||
const gitignorePath = path.join(config.projectDir, '.gitignore');
|
||||
try {
|
||||
const content = fs.readFileSync(gitignorePath, 'utf-8');
|
||||
|
||||
@@ -42,6 +42,52 @@ import * as os from 'os';
|
||||
|
||||
let warnedOnce = false;
|
||||
|
||||
let cachedSid: string | null | undefined;
|
||||
|
||||
/**
|
||||
* Resolve the current user's SID, cached for the process lifetime.
|
||||
*
|
||||
* Returns null if `whoami` is unavailable or its output cannot be parsed,
|
||||
* in which case callers fall back to a domain-qualified account name.
|
||||
*/
|
||||
function currentUserSid(): string | null {
|
||||
if (cachedSid !== undefined) return cachedSid;
|
||||
try {
|
||||
// Pin to the System32 binary. A bare `whoami` resolves to the MSYS/Git
|
||||
// Bash build under a bash-flavoured PATH, which rejects `/user` — the
|
||||
// lookup would then silently fail on one of the most common Windows
|
||||
// setups for this tool.
|
||||
const systemRoot = process.env.SystemRoot || process.env.windir || 'C:\\Windows';
|
||||
const out = execFileSync(`${systemRoot}\\System32\\whoami.exe`, ['/user', '/fo', 'csv', '/nh'], {
|
||||
encoding: 'utf8',
|
||||
});
|
||||
const match = out.match(/S-1-[\d-]+/);
|
||||
cachedSid = match ? match[0] : null;
|
||||
} catch {
|
||||
cachedSid = null;
|
||||
}
|
||||
return cachedSid;
|
||||
}
|
||||
|
||||
/**
|
||||
* The principal to hand icacls for "the current user".
|
||||
*
|
||||
* An unqualified username is ambiguous: on a machine whose hostname equals
|
||||
* the username, it fails to resolve to the user account and icacls silently
|
||||
* writes an ACE for the machine SID instead. Combined with `/inheritance:r`
|
||||
* that leaves a directory whose only ACE matches nobody — locking out the
|
||||
* process that just created it.
|
||||
*
|
||||
* `*<SID>` is icacls' literal-SID form and is immune to that ambiguity.
|
||||
* The domain-qualified name is the fallback.
|
||||
*/
|
||||
function currentUserPrincipal(): string {
|
||||
const sid = currentUserSid();
|
||||
if (sid) return `*${sid}`;
|
||||
const domain = process.env.USERDOMAIN || os.hostname();
|
||||
return `${domain}\\${os.userInfo().username}`;
|
||||
}
|
||||
|
||||
function warnIcaclsFailure(fsPath: string, err: unknown): void {
|
||||
if (warnedOnce) return;
|
||||
warnedOnce = true;
|
||||
@@ -67,7 +113,7 @@ function warnIcaclsFailure(fsPath: string, err: unknown): void {
|
||||
export function restrictFilePermissions(filePath: string): void {
|
||||
if (process.platform === 'win32') {
|
||||
try {
|
||||
const user = os.userInfo().username;
|
||||
const user = currentUserPrincipal();
|
||||
execFileSync(
|
||||
'icacls',
|
||||
[filePath, '/inheritance:r', '/grant:r', `${user}:(F)`],
|
||||
@@ -97,7 +143,7 @@ export function restrictFilePermissions(filePath: string): void {
|
||||
export function restrictDirectoryPermissions(dirPath: string): void {
|
||||
if (process.platform === 'win32') {
|
||||
try {
|
||||
const user = os.userInfo().username;
|
||||
const user = currentUserPrincipal();
|
||||
execFileSync(
|
||||
'icacls',
|
||||
[dirPath, '/inheritance:r', '/grant:r', `${user}:(OI)(CI)(F)`],
|
||||
|
||||
+12
-1
@@ -1592,8 +1592,18 @@ export function buildFetchHandler(cfg: ServerConfig): ServerHandle {
|
||||
process.env.GSTACK_AGENT_WATCHDOG_TICK_MS || '60000',
|
||||
10,
|
||||
);
|
||||
const RESPAWN_GUARD_WINDOW_MS = 60_000;
|
||||
const RESPAWN_GUARD_MAX = 3;
|
||||
// The guard window MUST span enough ticks for RESPAWN_GUARD_MAX respawns to
|
||||
// land inside it. This was a fixed 60_000 against a 60_000 tick, so at most
|
||||
// ONE respawn could ever be in the window and `respawnHistory.length >= 3`
|
||||
// was unreachable — the guard could not fire at the default tick rate, and a
|
||||
// steady one-per-tick leak ran unbounded instead of stopping after 3. Scale
|
||||
// with the tick so the intent ("3 crashes in quick succession → stop") holds
|
||||
// at any tick value: 3 respawns within 5 ticks trips it.
|
||||
const RESPAWN_GUARD_WINDOW_MS = Math.max(
|
||||
60_000,
|
||||
AGENT_WATCHDOG_TICK_MS * (RESPAWN_GUARD_MAX + 2),
|
||||
);
|
||||
let agentRespawnGuardTripped = false;
|
||||
|
||||
if (ownsTerminalAgent) {
|
||||
@@ -1626,6 +1636,7 @@ export function buildFetchHandler(cfg: ServerConfig): ServerHandle {
|
||||
const pid = spawnTerminalAgent({
|
||||
stateFile: cfg.config.stateFile,
|
||||
serverPort: cfg.browsePort,
|
||||
ownerPid: process.pid,
|
||||
cwd: cfg.config.projectDir,
|
||||
});
|
||||
if (pid) {
|
||||
|
||||
@@ -48,12 +48,13 @@ export function resolveTerminalAgentScript(searchHints: { metaDir?: string; exec
|
||||
*
|
||||
* Used by both the CLI cold-start path (cli.ts) and the v1.44 watchdog in
|
||||
* server.ts. Centralizing here removes a copy-paste between them and means
|
||||
* future spawn-env additions (e.g. BROWSE_OWNER_PID for the generation
|
||||
* counter rollout) land in one place.
|
||||
* spawn-env additions (BROWSE_OWNER_PID being the first) land in one place.
|
||||
*/
|
||||
export function spawnTerminalAgent(opts: {
|
||||
stateFile: string;
|
||||
serverPort: number;
|
||||
/** PID of the browse server that owns this agent. */
|
||||
ownerPid: number;
|
||||
cwd?: string;
|
||||
/** Optional extra env vars to add to the agent's process env. */
|
||||
extraEnv?: Record<string, string>;
|
||||
@@ -74,6 +75,7 @@ export function spawnTerminalAgent(opts: {
|
||||
...process.env,
|
||||
BROWSE_STATE_FILE: opts.stateFile,
|
||||
BROWSE_SERVER_PORT: String(opts.serverPort),
|
||||
BROWSE_OWNER_PID: String(opts.ownerPid),
|
||||
...(opts.extraEnv || {}),
|
||||
},
|
||||
stdio: ['ignore', 'ignore', 'ignore'],
|
||||
|
||||
@@ -30,6 +30,11 @@ import { writeAgentRecord, clearAgentRecord } from './terminal-agent-control';
|
||||
const STATE_FILE = process.env.BROWSE_STATE_FILE || path.join(process.env.HOME || '/tmp', '.gstack', 'browse.json');
|
||||
const PORT_FILE = path.join(path.dirname(STATE_FILE), 'terminal-port');
|
||||
const BROWSE_SERVER_PORT = parseInt(process.env.BROWSE_SERVER_PORT || '0', 10);
|
||||
const BROWSE_OWNER_PID = parseInt(process.env.BROWSE_OWNER_PID || '0', 10);
|
||||
const OWNER_WATCHDOG_MS = parseInt(
|
||||
process.env.GSTACK_TERMINAL_OWNER_WATCHDOG_MS || '15000',
|
||||
10,
|
||||
);
|
||||
const EXTENSION_ID = process.env.BROWSE_EXTENSION_ID || ''; // optional: tighten Origin check
|
||||
const INTERNAL_TOKEN = crypto.randomBytes(32).toString('base64url'); // shared with parent server via env at spawn
|
||||
/**
|
||||
@@ -598,12 +603,10 @@ function buildServer() {
|
||||
// first that matches a known token.
|
||||
const protoHeader = req.headers.get('sec-websocket-protocol') || '';
|
||||
let token: string | null = null;
|
||||
let acceptedProtocol: string | null = null;
|
||||
for (const raw of protoHeader.split(',').map(s => s.trim()).filter(Boolean)) {
|
||||
const candidate = raw.startsWith('gstack-pty.') ? raw.slice('gstack-pty.'.length) : raw;
|
||||
if (validTokens.has(candidate)) {
|
||||
token = candidate;
|
||||
acceptedProtocol = raw;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -632,13 +635,13 @@ function buildServer() {
|
||||
// sessionsById so /internal/restart and (Commit 3) re-attach
|
||||
// lookups can find it.
|
||||
const sessionId = validTokens.get(token) ?? null;
|
||||
// No explicit Sec-WebSocket-Protocol echo: Bun >= 1.3 auto-echoes the
|
||||
// first offered protocol in the 101 response, so setting the header
|
||||
// here produced a DUPLICATE header — strict clients (Chromium, python
|
||||
// websockets) reject the handshake per RFC 6455 and the sidebar
|
||||
// terminal could never connect. Verified on Bun 1.3.6.
|
||||
const upgraded = server.upgrade(req, {
|
||||
data: { cookie: token, sessionId },
|
||||
// Echo the protocol back so the browser accepts the upgrade.
|
||||
// Required when the client sends Sec-WebSocket-Protocol — the
|
||||
// server MUST select one of the offered protocols, otherwise
|
||||
// the browser closes the connection immediately.
|
||||
...(acceptedProtocol ? { headers: { 'Sec-WebSocket-Protocol': acceptedProtocol } } : {}),
|
||||
});
|
||||
return upgraded ? undefined : new Response('upgrade failed', { status: 500 });
|
||||
}
|
||||
@@ -987,13 +990,33 @@ function main() {
|
||||
console.log(`[terminal-agent] listening on 127.0.0.1:${port} pid=${process.pid} gen=${CURRENT_GEN}`);
|
||||
|
||||
// Cleanup port file + agent record on exit.
|
||||
let cleaningUp = false;
|
||||
const cleanup = () => {
|
||||
if (cleaningUp) return;
|
||||
cleaningUp = true;
|
||||
safeUnlink(PORT_FILE);
|
||||
safeUnlink(INTERNAL_TOKEN_FILE);
|
||||
clearAgentRecord(dir);
|
||||
process.exit(0);
|
||||
};
|
||||
process.on('SIGTERM', cleanup);
|
||||
process.on('SIGINT', cleanup);
|
||||
|
||||
// The terminal agent is intentionally detached so it survives the short-lived
|
||||
// CLI launcher, but its real owner is the persistent browse server. If that
|
||||
// server crashes or is killed before running normal shutdown, the agent would
|
||||
// otherwise be adopted by PID 1 and live forever. Poll the server PID and use
|
||||
// the same cleanup path as an intentional shutdown when it disappears.
|
||||
if (BROWSE_OWNER_PID > 0) {
|
||||
const ownerWatchdog = setInterval(() => {
|
||||
try {
|
||||
process.kill(BROWSE_OWNER_PID, 0);
|
||||
} catch {
|
||||
cleanup();
|
||||
}
|
||||
}, OWNER_WATCHDOG_MS);
|
||||
(ownerWatchdog as any)?.unref?.();
|
||||
}
|
||||
}
|
||||
|
||||
// Export the internal token so cli.ts can pass the SAME value to the parent
|
||||
|
||||
@@ -269,9 +269,24 @@ export async function validateNavigationUrl(url: string): Promise<string> {
|
||||
return pathToFileURL(fsPath).href + parsed.search + parsed.hash;
|
||||
}
|
||||
|
||||
// about:blank ONLY — the canonical empty page, and the one the daemon opens its own
|
||||
// first tab on. Blocking it meant `browse newtab about:blank` failed, which is what
|
||||
// `make-pdf setup` runs as its Chromium smoke test: make-pdf reported "Chromium failed
|
||||
// to launch" against a perfectly healthy Chromium, and any browse session whose daemon
|
||||
// restarted could never recreate the blank tab it starts from.
|
||||
//
|
||||
// Deliberately not the whole `about:` scheme. about:blank has no origin, loads nothing
|
||||
// and runs nothing; about:config, about:net-internals and friends are real surfaces.
|
||||
// Exact href match, not a prefix test, so `about:blankfoo` stays blocked.
|
||||
// Compared lower-cased: the URL parser normalises the PROTOCOL but not the opaque part,
|
||||
// so `ABOUT:BLANK` parses to href `about:BLANK` and an exact === would reject it.
|
||||
if (parsed.protocol === 'about:' && parsed.href.toLowerCase() === 'about:blank') {
|
||||
return 'about:blank';
|
||||
}
|
||||
|
||||
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
|
||||
throw new Error(
|
||||
`Blocked: scheme "${parsed.protocol}" is not allowed. Only http:, https:, and file: URLs are permitted.`
|
||||
`Blocked: scheme "${parsed.protocol}" is not allowed. Only http:, https:, file:, and about:blank URLs are permitted.`
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -249,11 +249,11 @@ export async function handleWriteCommand(
|
||||
if (!filePath) throw new Error('Usage: browse load-html <file> [--wait-until load|domcontentloaded|networkidle] [--tab-id <N>] | load-html --from-file <payload.json> [--tab-id <N>]');
|
||||
|
||||
// Extension allowlist
|
||||
const ALLOWED_EXT = ['.html', '.htm', '.xhtml', '.svg'];
|
||||
const ALLOWED_EXT = ['.html', '.htm', '.xhtml'];
|
||||
const ext = path.extname(filePath).toLowerCase();
|
||||
if (!ALLOWED_EXT.includes(ext)) {
|
||||
throw new Error(
|
||||
`load-html: file does not appear to be HTML. Expected .html/.htm/.xhtml/.svg, got ${ext || '(no extension)'}. Rename the file if it's really HTML.`
|
||||
`load-html: file does not appear to be HTML. Expected .html/.htm/.xhtml, got ${ext || '(no extension)'}. Rename the file if it's really HTML.`
|
||||
);
|
||||
}
|
||||
|
||||
@@ -377,11 +377,14 @@ export async function handleWriteCommand(
|
||||
const value = valueParts.join(' ');
|
||||
if (!selector || !value) throw new Error('Usage: browse fill <selector> <value>');
|
||||
const resolved = await session.resolveRef(selector);
|
||||
if ('locator' in resolved) {
|
||||
await resolved.locator.fill(value, { timeout: 5000 });
|
||||
} else {
|
||||
await target.locator(resolved.selector).fill(value, { timeout: 5000 });
|
||||
}
|
||||
const locator = 'locator' in resolved ? resolved.locator : target.locator(resolved.selector);
|
||||
await locator.fill(value, { timeout: 5000 });
|
||||
// Playwright's fill() only dispatches an `input` event. Frameworks that
|
||||
// validate on `change` (AngularJS ng-change, debounced strength/match
|
||||
// checks — e.g. cPanel's Jupiter theme) never see the update, so a value
|
||||
// that's correct in the DOM can still fail the framework's own
|
||||
// validation. Dispatch `change` too so those listeners fire.
|
||||
await locator.dispatchEvent('change');
|
||||
// Wait for network to settle (form validation XHRs)
|
||||
await page.waitForLoadState('networkidle', { timeout: 2000 }).catch(() => {});
|
||||
return `Filled ${selector}`;
|
||||
|
||||
@@ -42,9 +42,14 @@ beforeAll(async () => {
|
||||
// The test needs to start a server. Let's use the existing server infrastructure.
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test runs
|
||||
// all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
// We need a running browse server for HTTP tests.
|
||||
|
||||
@@ -18,7 +18,7 @@ import { withCdpSession, getOrCreateCdpSession } from '../src/cdp-bridge';
|
||||
// browse/test/server-sanitize-surrogates.test.ts: read source files
|
||||
// directly, assert an invariant on their contents.
|
||||
|
||||
const SRC_DIR = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src');
|
||||
const SRC_DIR = path.resolve(import.meta.path, '..', '..', 'src');
|
||||
|
||||
function readAllSourceFiles(): Array<{ file: string; content: string }> {
|
||||
const out: Array<{ file: string; content: string }> = [];
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
import { describe, expect, test } from 'bun:test';
|
||||
import * as fs from 'node:fs';
|
||||
import * as os from 'node:os';
|
||||
import * as path from 'node:path';
|
||||
import { acquireServerLock } from '../src/cli';
|
||||
|
||||
function withTempDir<T>(fn: (dir: string) => T): T {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-lock-'));
|
||||
try {
|
||||
return fn(dir);
|
||||
} finally {
|
||||
fs.rmSync(dir, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
function captureErrors<T>(fn: () => T): { result: T; messages: string[] } {
|
||||
const original = console.error;
|
||||
const messages: string[] = [];
|
||||
console.error = (...args: unknown[]) => {
|
||||
messages.push(args.map(String).join(' '));
|
||||
};
|
||||
try {
|
||||
return { result: fn(), messages };
|
||||
} finally {
|
||||
console.error = original;
|
||||
}
|
||||
}
|
||||
|
||||
describe('browse CLI server lock diagnostics (#1084)', () => {
|
||||
test('logs non-EEXIST open failures instead of reporting phantom lock contention', () => {
|
||||
withTempDir((dir) => {
|
||||
const lockPath = path.join(dir, 'missing-parent', 'browse.json.lock');
|
||||
const { result, messages } = captureErrors(() => acquireServerLock(lockPath));
|
||||
|
||||
expect(result).toBeNull();
|
||||
expect(messages.join('\n')).toContain('unexpected ENOENT while opening');
|
||||
expect(messages.join('\n')).toContain(lockPath);
|
||||
});
|
||||
});
|
||||
|
||||
test('returns null silently when a live process holds the lock', () => {
|
||||
withTempDir((dir) => {
|
||||
const lockPath = path.join(dir, 'browse.json.lock');
|
||||
fs.writeFileSync(lockPath, `${process.pid}\n`);
|
||||
|
||||
const { result, messages } = captureErrors(() => acquireServerLock(lockPath));
|
||||
|
||||
expect(result).toBeNull();
|
||||
expect(messages).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
test('logs holder PID read failures with code and lock path', () => {
|
||||
withTempDir((dir) => {
|
||||
const lockPath = path.join(dir, 'browse.json.lock');
|
||||
fs.mkdirSync(lockPath);
|
||||
|
||||
const { result, messages } = captureErrors(() => acquireServerLock(lockPath));
|
||||
|
||||
expect(result).toBeNull();
|
||||
expect(messages.join('\n')).toContain('unexpected EISDIR while reading holder PID from');
|
||||
expect(messages.join('\n')).toContain(lockPath);
|
||||
});
|
||||
});
|
||||
|
||||
test('removes stale lock and reacquires it', () => {
|
||||
withTempDir((dir) => {
|
||||
const lockPath = path.join(dir, 'browse.json.lock');
|
||||
fs.writeFileSync(lockPath, 'not-a-pid\n');
|
||||
|
||||
const release = acquireServerLock(lockPath);
|
||||
|
||||
expect(release).toBeFunction();
|
||||
expect(fs.readFileSync(lockPath, 'utf-8').trim()).toBe(String(process.pid));
|
||||
release?.();
|
||||
expect(fs.existsSync(lockPath)).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,77 @@
|
||||
/**
|
||||
* Coverage for #1846 — `browse` CLI must not report "Server failed to start
|
||||
* within Ns" when the detached daemon actually came up healthy a moment later.
|
||||
*
|
||||
* The spawned server is `detached: true` + `.unref()`'d, so it keeps booting
|
||||
* independently of the CLI's poll loop. On a loaded machine (the issue repro is
|
||||
* Windows under load) the loop's budget can elapse in the gap between its last
|
||||
* health tick and the daemon becoming ready — the very next `browse status`
|
||||
* then shows a healthy, listening server. #1732 only widened the budget; the
|
||||
* throw site itself still fired on timeout regardless of real health.
|
||||
*
|
||||
* Two invariants are defended here:
|
||||
* 1. `startServer` does a final readState()+isServerHealthy() re-check before
|
||||
* the timeout throw (structural — removes the false negative at any budget).
|
||||
* 2. The startup budget is env-overridable via BROWSE_START_TIMEOUT, matching
|
||||
* the BROWSE_* tunable convention (BROWSE_PORT, BROWSE_IDLE_TIMEOUT, ...).
|
||||
*
|
||||
* (1) is a static source invariant (live spawn cycles belong in the e2e tier);
|
||||
* (2) is exercised behaviorally against the exported pure helper.
|
||||
*/
|
||||
import { describe, expect, test } from 'bun:test';
|
||||
import * as fs from 'node:fs';
|
||||
import * as path from 'node:path';
|
||||
import { resolveStartTimeout } from '../src/cli';
|
||||
|
||||
const CLI = path.join(import.meta.dir, '..', 'src', 'cli.ts');
|
||||
const read = (): string => fs.readFileSync(CLI, 'utf-8');
|
||||
|
||||
describe('#1846 startServer false-negative on a late-healthy detached daemon', () => {
|
||||
test('a final health re-check sits between the poll loop and the timeout throw', () => {
|
||||
const src = read();
|
||||
const throwIdx = src.indexOf('Server failed to start within');
|
||||
expect(throwIdx).toBeGreaterThan(-1);
|
||||
|
||||
// The startServer poll loop ends at its `await Bun.sleep(100)`; the final
|
||||
// re-check must live AFTER that loop and BEFORE the timeout throw.
|
||||
const loopEnd = src.lastIndexOf('await Bun.sleep(100)', throwIdx);
|
||||
expect(loopEnd).toBeGreaterThan(-1);
|
||||
const between = src.slice(loopEnd, throwIdx);
|
||||
|
||||
// It must re-read state and re-probe health, then be able to return — i.e.
|
||||
// a genuine recovery path, not just a comment.
|
||||
expect(between).toContain('readState()');
|
||||
expect(between).toMatch(/isServerHealthy\([^)]*\)/);
|
||||
expect(between).toMatch(/return\s+\w+;/);
|
||||
});
|
||||
|
||||
test('the re-check returns the recovered state rather than swallowing it', () => {
|
||||
const src = read();
|
||||
// Guard against a refactor that probes health but forgets to return the
|
||||
// state (which would re-introduce the false negative).
|
||||
expect(src).toMatch(/if\s*\([^)]*await\s+isServerHealthy\([^)]*\)\)\s*\{\s*return\s+\w+;/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('#1846 BROWSE_START_TIMEOUT env override (resolveStartTimeout)', () => {
|
||||
const platformDefault = resolveStartTimeout({} as NodeJS.ProcessEnv);
|
||||
|
||||
test('platform default is a positive millisecond budget when unset', () => {
|
||||
expect(platformDefault).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('honors a positive BROWSE_START_TIMEOUT override', () => {
|
||||
expect(resolveStartTimeout({ BROWSE_START_TIMEOUT: '42000' } as NodeJS.ProcessEnv)).toBe(42000);
|
||||
});
|
||||
|
||||
test('falls back to the platform default for non-positive / unparseable values', () => {
|
||||
for (const bad of ['0', '-5', 'abc', '', ' ']) {
|
||||
expect(resolveStartTimeout({ BROWSE_START_TIMEOUT: bad } as NodeJS.ProcessEnv)).toBe(platformDefault);
|
||||
}
|
||||
});
|
||||
|
||||
test('MAX_START_WAIT is wired through resolveStartTimeout (no stray hardcoded constant)', () => {
|
||||
const src = read();
|
||||
expect(src).toMatch(/const\s+MAX_START_WAIT\s*=\s*resolveStartTimeout\(\)/);
|
||||
});
|
||||
});
|
||||
@@ -15,7 +15,7 @@ import * as path from 'path';
|
||||
// 3-8s each). These tripwires defend the load-bearing invariants:
|
||||
// opt-in by default, signal handlers wired, crash-loop guard, env knobs.
|
||||
|
||||
const CLI_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'cli.ts');
|
||||
const CLI_TS = path.resolve(import.meta.path, '..', '..', 'src', 'cli.ts');
|
||||
|
||||
describe('CLI outer supervisor (v1.44+)', () => {
|
||||
test('1. supervisor is opt-in via --supervise flag or BROWSE_SUPERVISE env', () => {
|
||||
|
||||
@@ -94,11 +94,14 @@ beforeAll(async () => {
|
||||
await bm.launch();
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
// Force kill browser instead of graceful close (avoids hang)
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
// bm.close() can hang — just let process exit handle it
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test runs
|
||||
// all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
// ─── Navigation ─────────────────────────────────────────────────
|
||||
@@ -881,7 +884,10 @@ describe('CLI lifecycle', () => {
|
||||
cliEnv.BROWSE_STATE_FILE = stateFile;
|
||||
const result = await new Promise<{ code: number; stdout: string; stderr: string }>((resolve) => {
|
||||
const proc = spawn('bun', ['run', cliPath, 'status'], {
|
||||
timeout: 15000,
|
||||
// Must exceed the CLI's startup budget (resolveStartTimeout, 15s
|
||||
// non-CI POSIX) or a slow cold boot under full-suite load gets the
|
||||
// child killed at the exact moment the CLI would have succeeded.
|
||||
timeout: 18000,
|
||||
env: cliEnv,
|
||||
});
|
||||
let stdout = '';
|
||||
@@ -2298,6 +2304,19 @@ describe('load-html', () => {
|
||||
}
|
||||
});
|
||||
|
||||
test('load-html rejects .svg files', async () => {
|
||||
const svgPath = path.join(tmpDir, `load-html-test-${Date.now()}.svg`);
|
||||
fs.writeFileSync(svgPath, '<svg xmlns="http://www.w3.org/2000/svg"><text>hi</text></svg>');
|
||||
try {
|
||||
await handleWriteCommand('load-html', [svgPath], bm);
|
||||
expect(true).toBe(false);
|
||||
} catch (err: any) {
|
||||
expect(err.message).toMatch(/does not appear to be HTML/);
|
||||
} finally {
|
||||
try { fs.unlinkSync(svgPath); } catch {}
|
||||
}
|
||||
});
|
||||
|
||||
test('load-html rejects file outside safe dirs', async () => {
|
||||
try {
|
||||
await handleWriteCommand('load-html', ['/etc/passwd.html'], bm);
|
||||
|
||||
@@ -69,10 +69,15 @@ beforeAll(async () => {
|
||||
await handleWriteCommand('goto', [boardUrl], bm);
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
afterAll(async () => {
|
||||
try { server.stop(); } catch {}
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test runs
|
||||
// all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
// ─── DOM Structure ──────────────────────────────────────────────
|
||||
|
||||
@@ -124,6 +124,41 @@ describe('config', () => {
|
||||
expect(fs.existsSync(path.join(tmpDir, '.gitignore'))).toBe(false);
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test('leaves .gitignore alone when git already ignores .gstack/ globally', () => {
|
||||
const { spawnSync } = require('child_process');
|
||||
const tmpDir = path.join(os.tmpdir(), `browse-gitignore-global-${Date.now()}`);
|
||||
fs.mkdirSync(tmpDir, { recursive: true });
|
||||
|
||||
// Set up a real git repo
|
||||
spawnSync('git', ['init', '-q'], { cwd: tmpDir });
|
||||
spawnSync('git', ['config', 'user.email', 'test@test.com'], { cwd: tmpDir });
|
||||
spawnSync('git', ['config', 'user.name', 'Test'], { cwd: tmpDir });
|
||||
|
||||
// Write a global excludes file that ignores .gstack/
|
||||
const excludesFile = path.join(tmpDir, 'global-gitignore');
|
||||
fs.writeFileSync(excludesFile, '.gstack/\n');
|
||||
spawnSync('git', ['config', 'core.excludesFile', excludesFile], { cwd: tmpDir });
|
||||
|
||||
// .gitignore exists but does NOT contain .gstack/
|
||||
fs.writeFileSync(path.join(tmpDir, '.gitignore'), 'node_modules/\n');
|
||||
spawnSync('git', ['add', '.gitignore'], { cwd: tmpDir });
|
||||
spawnSync('git', ['commit', '-qm', 'init'], { cwd: tmpDir });
|
||||
|
||||
// Verify git knows .gstack/ is ignored
|
||||
const check = spawnSync('git', ['check-ignore', '-q', '.gstack/'], { cwd: tmpDir });
|
||||
expect(check.status).toBe(0);
|
||||
|
||||
const config = resolveConfig({ BROWSE_STATE_FILE: path.join(tmpDir, '.gstack', 'browse.json') });
|
||||
ensureStateDir(config);
|
||||
|
||||
// .gitignore must NOT have been modified
|
||||
const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
|
||||
expect(content).toBe('node_modules/\n');
|
||||
expect(fs.existsSync(path.join(tmpDir, '.gstack'))).toBe(true);
|
||||
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
});
|
||||
});
|
||||
|
||||
describe('getRemoteSlug', () => {
|
||||
|
||||
@@ -460,9 +460,14 @@ describe('Hidden element stripping', () => {
|
||||
await bm.launch();
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test
|
||||
// runs all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
test('detects CSS-hidden elements on injection-hidden page', async () => {
|
||||
|
||||
@@ -220,7 +220,9 @@ describe('/command tunnel command allowlist', () => {
|
||||
'return handleCommand(body, tokenInfo)'
|
||||
);
|
||||
expect(commandBlock).toContain("surface === 'tunnel'");
|
||||
expect(commandBlock).toContain('canDispatchOverTunnel(body?.command)');
|
||||
// Args-aware since the --out (disk write) tunnel ban: the dispatch gate
|
||||
// takes both the command and its args.
|
||||
expect(commandBlock).toContain('canDispatchOverTunnel(body?.command, body?.args)');
|
||||
expect(commandBlock).toContain('disallowed_command');
|
||||
expect(commandBlock).toContain('is not allowed over the tunnel surface');
|
||||
expect(commandBlock).toContain('status: 403');
|
||||
|
||||
@@ -0,0 +1,271 @@
|
||||
/**
|
||||
* Sender authorization for privileged extension messages.
|
||||
*
|
||||
* A content script runs in web-page context and can be influenced by page
|
||||
* content; a foreign extension is not us. Neither may read or spend the
|
||||
* browse server's auth token or port through background.js's message
|
||||
* surface. PR #1822 (@punksterlabs) found getPort handing the token to any
|
||||
* caller that passed the type allowlist; this suite pins the reimplemented
|
||||
* gate BEHAVIORALLY — it drives the real background.js onMessage listener
|
||||
* under a chrome stub with four sender shapes (own extension page, own
|
||||
* content script, foreign extension, url-less) and asserts denied responses
|
||||
* are { error: 'unauthorized' } with no token/port fields at all.
|
||||
*/
|
||||
import { describe, expect, test } from 'bun:test';
|
||||
import * as fs from 'node:fs';
|
||||
import * as path from 'node:path';
|
||||
|
||||
const EXT_DIR = path.join(import.meta.dir, '..', '..', 'extension');
|
||||
const BG_SRC = fs.readFileSync(path.join(EXT_DIR, 'background.js'), 'utf-8');
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
const senderAuth = require(path.join(EXT_DIR, 'sender-auth.js'));
|
||||
|
||||
// The pinned production id (derivable via browse/scripts/extension-id.ts) —
|
||||
// the policy only compares it against sender.id, so any stable value works.
|
||||
const OWN_ID = 'dgbkdbjebeiblbajiilljmhjdpmiglep';
|
||||
const FOREIGN_ID = 'ffffffffffffffffffffffffffffffff';
|
||||
|
||||
// ─── The four sender shapes ─────────────────────────────────────
|
||||
const PAGE_SENDER = { id: OWN_ID, url: `chrome-extension://${OWN_ID}/sidepanel.html` };
|
||||
const CONTENT_SCRIPT_SENDER = { id: OWN_ID, url: 'https://evil.example/page', tab: { id: 42 } };
|
||||
const FOREIGN_SENDER = { id: FOREIGN_ID, url: `chrome-extension://${FOREIGN_ID}/background.html` };
|
||||
const NO_URL_SENDER = { id: OWN_ID };
|
||||
|
||||
const PRIVILEGED = [
|
||||
'getPort', 'setPort', 'getServerUrl', 'getToken', 'fetchRefs',
|
||||
'command', 'sidebar-command', 'getTabState',
|
||||
];
|
||||
// Content-script-originated flows that must keep working.
|
||||
const CONTENT_SCRIPT_TYPES = ['openSidePanel', 'elementPicked', 'pickerCancelled', 'inspectResult'];
|
||||
// Sidepanel-originated, non-privileged (page effects only, no token/port).
|
||||
const PAGE_EFFECT_TYPES = ['sidebarOpened', 'startInspector', 'stopInspector', 'applyStyle', 'toggleClass', 'injectCSS', 'resetAll'];
|
||||
|
||||
const LEAK_FIELDS = ['token', 'authToken', 'port', 'url', 'connected', 'tabs', 'active', 'ok'];
|
||||
|
||||
// ─── Unit: the policy predicate ─────────────────────────────────
|
||||
|
||||
describe('sender-auth policy (unit)', () => {
|
||||
test('own extension page is allowed for every privileged type', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
expect(senderAuth.denialFor(type, PAGE_SENDER, OWN_ID)).toBeNull();
|
||||
}
|
||||
expect(senderAuth.isExtensionPageSender(PAGE_SENDER, OWN_ID)).toBe(true);
|
||||
});
|
||||
|
||||
test('own popup page is allowed (any own-extension page path)', () => {
|
||||
const popup = { id: OWN_ID, url: `chrome-extension://${OWN_ID}/popup.html` };
|
||||
expect(senderAuth.denialFor('getPort', popup, OWN_ID)).toBeNull();
|
||||
});
|
||||
|
||||
test('own content script (sender.tab + page URL) is denied for every privileged type', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
const denial = senderAuth.denialFor(type, CONTENT_SCRIPT_SENDER, OWN_ID);
|
||||
expect(denial).toEqual({ error: 'unauthorized' });
|
||||
expect(Object.keys(denial)).toEqual(['error']);
|
||||
}
|
||||
});
|
||||
|
||||
test('foreign extension id is denied for every privileged type', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
expect(senderAuth.denialFor(type, FOREIGN_SENDER, OWN_ID)).toEqual({ error: 'unauthorized' });
|
||||
}
|
||||
});
|
||||
|
||||
test('missing sender.url is denied (no provenance)', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
expect(senderAuth.denialFor(type, NO_URL_SENDER, OWN_ID)).toEqual({ error: 'unauthorized' });
|
||||
}
|
||||
expect(senderAuth.denialFor('getToken', undefined, OWN_ID)).toEqual({ error: 'unauthorized' });
|
||||
});
|
||||
|
||||
test('own extension page opened inside a TAB is denied (conservative: sender.tab wins)', () => {
|
||||
const pageInTab = { id: OWN_ID, url: `chrome-extension://${OWN_ID}/sidepanel.html`, tab: { id: 7 } };
|
||||
expect(senderAuth.denialFor('getToken', pageInTab, OWN_ID)).toEqual({ error: 'unauthorized' });
|
||||
});
|
||||
|
||||
test('non-privileged types are never gated here — content-script flows stay reachable', () => {
|
||||
for (const type of [...CONTENT_SCRIPT_TYPES, ...PAGE_EFFECT_TYPES]) {
|
||||
expect(senderAuth.denialFor(type, CONTENT_SCRIPT_SENDER, OWN_ID)).toBeNull();
|
||||
expect(senderAuth.denialFor(type, PAGE_SENDER, OWN_ID)).toBeNull();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Behavioral: the real background.js listener ────────────────
|
||||
|
||||
type Listener = (msg: unknown, sender: unknown, sendResponse: (r: unknown) => void) => unknown;
|
||||
|
||||
function loadBackground() {
|
||||
const captured: { listener?: Listener } = {};
|
||||
const calls = { storageSet: [] as unknown[], fetch: [] as unknown[] };
|
||||
const never = new Promise(() => {}); // storage.get never settles → startup health polling never starts
|
||||
const chromeStub = {
|
||||
runtime: {
|
||||
id: OWN_ID,
|
||||
onMessage: { addListener: (fn: Listener) => { captured.listener = fn; } },
|
||||
onInstalled: { addListener: () => {} },
|
||||
sendMessage: () => Promise.resolve(),
|
||||
},
|
||||
storage: {
|
||||
local: {
|
||||
get: () => never,
|
||||
set: (obj: unknown) => { calls.storageSet.push(obj); return Promise.resolve(); },
|
||||
},
|
||||
},
|
||||
tabs: {
|
||||
onActivated: { addListener: () => {} },
|
||||
onCreated: { addListener: () => {} },
|
||||
onRemoved: { addListener: () => {} },
|
||||
onUpdated: { addListener: () => {} },
|
||||
query: (_opts: unknown, cb?: (tabs: unknown[]) => void) => {
|
||||
if (cb) { cb([]); return; }
|
||||
return Promise.resolve([]);
|
||||
},
|
||||
sendMessage: () => Promise.resolve(),
|
||||
get: () => {},
|
||||
},
|
||||
action: { setBadgeBackgroundColor: () => {}, setBadgeText: () => {} },
|
||||
scripting: { executeScript: () => Promise.resolve(), insertCSS: () => Promise.resolve() },
|
||||
// no chrome.sidePanel: autoOpenSidePanel exits immediately (no retry timers)
|
||||
};
|
||||
const fetchSpy = (...args: unknown[]) => {
|
||||
calls.fetch.push(args);
|
||||
return Promise.reject(new Error('no network in tests'));
|
||||
};
|
||||
// background.js is a classic (non-module) service worker script — evaluate
|
||||
// it with its globals injected. importScripts is satisfied by passing the
|
||||
// already-required sender-auth module under the global name it registers.
|
||||
const run = new Function('chrome', 'importScripts', 'gstackSenderAuth', 'fetch', BG_SRC);
|
||||
run(chromeStub, () => {}, senderAuth, fetchSpy);
|
||||
if (!captured.listener) throw new Error('background.js did not register an onMessage listener');
|
||||
return { listener: captured.listener, calls };
|
||||
}
|
||||
|
||||
function dispatch(listener: Listener, msg: unknown, sender: unknown) {
|
||||
const result = { responded: false, response: undefined as Record<string, unknown> | undefined };
|
||||
listener(msg, sender, (resp: unknown) => {
|
||||
result.responded = true;
|
||||
result.response = resp as Record<string, unknown>;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
// Denied senders get { error: 'unauthorized' } and nothing else — or no
|
||||
// response at all (the pre-existing foreign-sender early return). Either
|
||||
// way: never a token, port, or tab-state field.
|
||||
function expectDenied(result: ReturnType<typeof dispatch>) {
|
||||
if (result.responded) {
|
||||
expect(result.response).toEqual({ error: 'unauthorized' });
|
||||
expect(Object.keys(result.response!)).toEqual(['error']);
|
||||
}
|
||||
const resp = result.response ?? {};
|
||||
for (const leak of LEAK_FIELDS) {
|
||||
expect(resp[leak]).toBeUndefined();
|
||||
}
|
||||
}
|
||||
|
||||
describe('background.js onMessage listener (behavioral)', () => {
|
||||
const { listener, calls } = loadBackground();
|
||||
|
||||
test('own sidepanel page: getPort responds with port/connected/token fields, no error', () => {
|
||||
const r = dispatch(listener, { type: 'getPort' }, PAGE_SENDER);
|
||||
expect(r.responded).toBe(true);
|
||||
expect('port' in r.response!).toBe(true);
|
||||
expect('connected' in r.response!).toBe(true);
|
||||
// The sidepanel's tryConnect reads resp.token — the field must exist for
|
||||
// extension pages (value is null until the token bootstrap completes).
|
||||
expect('token' in r.response!).toBe(true);
|
||||
expect(r.response!.error).toBeUndefined();
|
||||
});
|
||||
|
||||
test('own sidepanel page: getToken responds with a token field', () => {
|
||||
const r = dispatch(listener, { type: 'getToken' }, PAGE_SENDER);
|
||||
expect(r.responded).toBe(true);
|
||||
expect('token' in r.response!).toBe(true);
|
||||
expect(r.response!.error).toBeUndefined();
|
||||
});
|
||||
|
||||
test('own content script: every privileged type is denied with no token/port fields', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
const r = dispatch(listener, { type }, CONTENT_SCRIPT_SENDER);
|
||||
expect(r.responded).toBe(true); // the gate answers, it does not go silent
|
||||
expectDenied(r);
|
||||
}
|
||||
});
|
||||
|
||||
test('foreign extension: every privileged type yields no token/port fields', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
expectDenied(dispatch(listener, { type }, FOREIGN_SENDER));
|
||||
}
|
||||
});
|
||||
|
||||
test('missing sender.url: every privileged type is denied', () => {
|
||||
for (const type of PRIVILEGED) {
|
||||
const r = dispatch(listener, { type }, NO_URL_SENDER);
|
||||
expect(r.responded).toBe(true);
|
||||
expectDenied(r);
|
||||
}
|
||||
});
|
||||
|
||||
test('denied setPort never persists the attacker port', () => {
|
||||
const before = calls.storageSet.length;
|
||||
const r = dispatch(listener, { type: 'setPort', port: 6666 }, CONTENT_SCRIPT_SENDER);
|
||||
expectDenied(r);
|
||||
expect(calls.storageSet.length).toBe(before);
|
||||
});
|
||||
|
||||
test('denied command never reaches the network and fails at the gate, not the handler', () => {
|
||||
const before = calls.fetch.length;
|
||||
const r = dispatch(listener, { type: 'command', command: 'goto', args: ['https://evil.example'] }, CONTENT_SCRIPT_SENDER);
|
||||
// 'unauthorized' proves the gate fired; the handler's own failure mode is
|
||||
// 'Not connected to browse server'.
|
||||
expect(r.response).toEqual({ error: 'unauthorized' });
|
||||
expect(calls.fetch.length).toBe(before);
|
||||
});
|
||||
|
||||
test('content script can still run the inspector flow (elementPicked → ok)', async () => {
|
||||
const r = dispatch(
|
||||
listener,
|
||||
{ type: 'elementPicked', selector: '#hero', tagName: 'div', classes: [], id: null, dimensions: { width: 1, height: 1 } },
|
||||
CONTENT_SCRIPT_SENDER,
|
||||
);
|
||||
await new Promise((res) => setTimeout(res, 10));
|
||||
expect(r.response).toEqual({ ok: true });
|
||||
});
|
||||
|
||||
test('content script can still request openSidePanel (not rejected as unauthorized)', () => {
|
||||
const r = dispatch(listener, { type: 'openSidePanel' }, CONTENT_SCRIPT_SENDER);
|
||||
// chrome.sidePanel is absent in the stub so the handler is a no-op — the
|
||||
// load-bearing assertion is that the gate did not deny it.
|
||||
expect(r.response?.error).toBeUndefined();
|
||||
});
|
||||
|
||||
test('sidepanel getTabState still works (terminal pane tab sync)', async () => {
|
||||
const r = dispatch(listener, { type: 'getTabState' }, PAGE_SENDER);
|
||||
await new Promise((res) => setTimeout(res, 10));
|
||||
expect(r.responded).toBe(true);
|
||||
expect(r.response).toEqual({ active: null, tabs: [] });
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Wiring tripwire ────────────────────────────────────────────
|
||||
// The behavioral suite injects senderAuth directly, so pin that the real
|
||||
// worker actually loads it: importScripts of the helper file plus a
|
||||
// denialFor call in the listener. A refactor that drops either fails here.
|
||||
|
||||
describe('background.js ↔ sender-auth.js wiring', () => {
|
||||
test('background.js importScripts sender-auth.js (classic worker load path)', () => {
|
||||
expect(BG_SRC).toContain("importScripts('sender-auth.js')");
|
||||
});
|
||||
|
||||
test('background.js consults gstackSenderAuth.denialFor in the message listener', () => {
|
||||
expect(BG_SRC).toContain('gstackSenderAuth.denialFor(msg.type, sender, chrome.runtime.id)');
|
||||
});
|
||||
|
||||
test('manifest keeps a classic (non-module) service worker — importScripts requires it', () => {
|
||||
const manifest = JSON.parse(fs.readFileSync(path.join(EXT_DIR, 'manifest.json'), 'utf-8'));
|
||||
expect(manifest.background.service_worker).toBe('background.js');
|
||||
expect(manifest.background.type).toBeUndefined();
|
||||
});
|
||||
});
|
||||
@@ -78,6 +78,26 @@ describe('restrictDirectoryPermissions', () => {
|
||||
fs.mkdirSync(d);
|
||||
expect(() => restrictDirectoryPermissions(d)).not.toThrow();
|
||||
});
|
||||
|
||||
test('on Windows, the directory stays usable by the calling process', () => {
|
||||
if (process.platform !== 'win32') return;
|
||||
const d = path.join(tmpDir, 'still-usable');
|
||||
fs.mkdirSync(d);
|
||||
fs.writeFileSync(path.join(d, 'before'), 'x');
|
||||
|
||||
restrictDirectoryPermissions(d);
|
||||
|
||||
// Regression: an unqualified username passed to icacls can resolve to
|
||||
// the machine SID rather than the user account. Combined with
|
||||
// /inheritance:r that leaves a directory whose only ACE matches nobody,
|
||||
// so the process that just "secured" it can no longer enumerate or
|
||||
// write to it. icacls still reports success, so a not-toThrow assertion
|
||||
// sails straight past it — hence these access checks.
|
||||
expect(() => fs.readdirSync(d)).not.toThrow();
|
||||
expect(fs.readdirSync(d)).toContain('before');
|
||||
expect(() => fs.writeFileSync(path.join(d, 'after'), 'y')).not.toThrow();
|
||||
expect(fs.readFileSync(path.join(d, 'after'), 'utf8')).toBe('y');
|
||||
});
|
||||
});
|
||||
|
||||
describe('writeSecureFile', () => {
|
||||
@@ -139,6 +159,16 @@ describe('mkdirSecure', () => {
|
||||
expect(() => mkdirSecure(d)).not.toThrow();
|
||||
});
|
||||
|
||||
test('on Windows, the created directory stays usable by the caller', () => {
|
||||
if (process.platform !== 'win32') return;
|
||||
// The state-dir path that broke: mkdirSecure() creates .gstack/, hardens
|
||||
// it, and the very next thing the daemon does is write a lockfile inside.
|
||||
const d = path.join(tmpDir, 'state', '.gstack');
|
||||
mkdirSecure(d);
|
||||
expect(() => fs.writeFileSync(path.join(d, 'browse.json.lock'), '1')).not.toThrow();
|
||||
expect(fs.readdirSync(d)).toContain('browse.json.lock');
|
||||
});
|
||||
|
||||
test('recursive behavior: creates intermediate directories', () => {
|
||||
const d = path.join(tmpDir, 'a', 'b', 'c');
|
||||
mkdirSecure(d);
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
/**
|
||||
* Regression test for `browse fill` on change-only validators.
|
||||
*
|
||||
* Playwright's Locator.fill() dispatches an `input` event but not `change`.
|
||||
* Frameworks that validate on `change` (AngularJS ng-change, debounced
|
||||
* strength/match checks — e.g. cPanel's Jupiter theme "Add FTP Account"
|
||||
* password-match check) never see the update: the DOM value is correct but
|
||||
* the framework's own validator still reports a mismatch.
|
||||
*/
|
||||
|
||||
import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
|
||||
import { startTestServer } from './test-server';
|
||||
import { BrowserManager } from '../src/browser-manager';
|
||||
import { handleWriteCommand as _handleWriteCommand } from '../src/write-commands';
|
||||
|
||||
const handleWriteCommand = (cmd: string, args: string[], b: BrowserManager) =>
|
||||
_handleWriteCommand(cmd, args, b.getActiveSession(), b);
|
||||
|
||||
let testServer: ReturnType<typeof startTestServer>;
|
||||
let bm: BrowserManager;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
testServer = startTestServer(0);
|
||||
baseUrl = testServer.url;
|
||||
bm = new BrowserManager();
|
||||
await bm.launch();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
// Close only this file's own browser — never process.exit(): bun test runs
|
||||
// all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, so race it at 3s and abandon; the child is reaped at exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
describe('fill dispatches change event', () => {
|
||||
test('a change-only validator sees the filled value', async () => {
|
||||
await handleWriteCommand('goto', [baseUrl + '/change-only-validator.html'], bm);
|
||||
await handleWriteCommand('fill', ['#password', 'hello123'], bm);
|
||||
await handleWriteCommand('fill', ['#password2', 'hello123'], bm);
|
||||
|
||||
const status = await bm.getPage().locator('#match-status').textContent();
|
||||
expect(status).toBe('match');
|
||||
});
|
||||
|
||||
test('a change-only validator still catches a real mismatch', async () => {
|
||||
await handleWriteCommand('goto', [baseUrl + '/change-only-validator.html'], bm);
|
||||
await handleWriteCommand('fill', ['#password', 'hello123'], bm);
|
||||
await handleWriteCommand('fill', ['#password2', 'different'], bm);
|
||||
|
||||
const status = await bm.getPage().locator('#match-status').textContent();
|
||||
expect(status).toBe('no-match');
|
||||
});
|
||||
});
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<title>Test Page - Change-Only Validator</title>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Change-Only Validator</h1>
|
||||
|
||||
<!--
|
||||
Minimal repro of AngularJS ng-change / debounced cross-field validators
|
||||
(e.g. cPanel's Jupiter theme "Add FTP Account" password-match check):
|
||||
the listener only reacts to `change`, never `input`. A page like this
|
||||
silently "loses" a Playwright-style value-set-without-a-change-event.
|
||||
-->
|
||||
<input type="password" id="password" name="password">
|
||||
<input type="password" id="password2" name="password2">
|
||||
<div id="match-status">unknown</div>
|
||||
|
||||
<script>
|
||||
function checkMatch() {
|
||||
var a = document.getElementById('password').value;
|
||||
var b = document.getElementById('password2').value;
|
||||
document.getElementById('match-status').textContent =
|
||||
a && a === b ? 'match' : 'no-match';
|
||||
}
|
||||
document.getElementById('password').addEventListener('change', checkMatch);
|
||||
document.getElementById('password2').addEventListener('change', checkMatch);
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
File diff suppressed because one or more lines are too long
@@ -42,6 +42,14 @@ beforeEach(() => {
|
||||
const binDir = join(gstackDir, 'bin');
|
||||
mkdirSync(binDir);
|
||||
symlinkSync(join(import.meta.dir, '..', '..', 'bin', 'gstack-config'), join(binDir, 'gstack-config'));
|
||||
// v1.63+: the script sources bin/gstack-egress-lib.sh unconditionally
|
||||
// (receipted fetch helpers). A real install always has it beside
|
||||
// gstack-config; without this link every test failed at the source line —
|
||||
// masked until the suite-truncation fix because the runner died first.
|
||||
symlinkSync(
|
||||
join(import.meta.dir, '..', '..', 'bin', 'gstack-egress-lib.sh'),
|
||||
join(binDir, 'gstack-egress-lib.sh'),
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
|
||||
@@ -26,9 +26,14 @@ beforeAll(async () => {
|
||||
await bm.launch();
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test runs
|
||||
// all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
// ─── Unit Tests: Failure Tracking (no browser needed) ────────────
|
||||
@@ -172,8 +177,15 @@ describe('handoff edge cases', () => {
|
||||
// Each handoff test creates its own BrowserManager since handoff swaps the browser.
|
||||
// These tests run sequentially (one browser at a time) to avoid resource issues.
|
||||
|
||||
// Headed-mode launch is broken on current macOS (the rebrand invalidates the
|
||||
// Chrome-for-Testing bundle signature and XProtect kills the relaunch —
|
||||
// #2242, #2554, #2138). These three integration tests drive a real headed
|
||||
// handoff and fail ~5s in on any darwin box. They stay ENABLED on Linux CI.
|
||||
// Un-skip when the browse-daemon lifecycle wave lands the signature fix.
|
||||
const HEADED_BROKEN_ON_DARWIN = process.platform === 'darwin';
|
||||
|
||||
describe('handoff integration', () => {
|
||||
test('full handoff: cookies preserved, headed mode active, commands work', async () => {
|
||||
test.skipIf(HEADED_BROKEN_ON_DARWIN)('full handoff: cookies preserved, headed mode active, commands work', async () => {
|
||||
const hbm = new BrowserManager();
|
||||
await hbm.launch();
|
||||
|
||||
@@ -206,7 +218,7 @@ describe('handoff integration', () => {
|
||||
}
|
||||
}, 45000);
|
||||
|
||||
test('multi-tab handoff preserves all tabs', async () => {
|
||||
test.skipIf(HEADED_BROKEN_ON_DARWIN)('multi-tab handoff preserves all tabs', async () => {
|
||||
const hbm = new BrowserManager();
|
||||
await hbm.launch();
|
||||
|
||||
@@ -223,7 +235,7 @@ describe('handoff integration', () => {
|
||||
}
|
||||
}, 45000);
|
||||
|
||||
test('handoff meta command joins args as message', async () => {
|
||||
test.skipIf(HEADED_BROKEN_ON_DARWIN)('handoff meta command joins args as message', async () => {
|
||||
const hbm = new BrowserManager();
|
||||
await hbm.launch();
|
||||
|
||||
|
||||
@@ -0,0 +1,138 @@
|
||||
import { describe, test, expect } from 'bun:test';
|
||||
import * as fs from 'fs';
|
||||
import * as os from 'os';
|
||||
import * as path from 'path';
|
||||
import { isProcessAlive } from '../src/error-handling';
|
||||
import { spawnTerminalAgent } from '../src/terminal-agent-control';
|
||||
|
||||
// REGRESSION TEST for the Windows terminal-agent leak.
|
||||
//
|
||||
// Symptom (reported on Windows 11, 48GB box under a heavy parallel build):
|
||||
// a console window popped to the foreground every 60 seconds, and orphaned
|
||||
// `bun run terminal-agent.ts` processes accumulated at one per minute until
|
||||
// the machine ran out of committable memory.
|
||||
//
|
||||
// Root cause was a three-bug chain, each of which this file pins:
|
||||
//
|
||||
// 1. `isProcessAlive` shelled out to `tasklist` on Windows with a 3s
|
||||
// timeout. A Bun.spawnSync that hits its timeout STILL RETURNS, carrying
|
||||
// partial stdout — so the `.includes()` PID match came back false and a
|
||||
// LIVE agent was reported dead. Measured tasklist latency was 700-1700ms
|
||||
// idle, and far worse under memory pressure, so the timeout was reachable
|
||||
// in ordinary use.
|
||||
// 2. That false negative made `killAgentByRecord` skip the kill (it
|
||||
// validates liveness first) while the watchdog respawned anyway —
|
||||
// leaking the survivor. Each orphan added memory pressure, slowing the
|
||||
// next tasklist, producing the next false negative. Self-reinforcing.
|
||||
// 3. Neither the tasklist probe nor the agent spawn passed `windowsHide`,
|
||||
// so every tick allocated a visible console and stole focus.
|
||||
//
|
||||
// The guard-window arithmetic bug that let this run unbounded instead of
|
||||
// tripping the crash-loop guard is pinned separately, in test 6.
|
||||
|
||||
const SRC_DIR = path.resolve(import.meta.dir, '..', 'src');
|
||||
|
||||
function readAllSourceFiles(): Array<{ file: string; content: string }> {
|
||||
return fs
|
||||
.readdirSync(SRC_DIR)
|
||||
.filter((e) => e.endsWith('.ts'))
|
||||
.map((e) => ({ file: e, content: fs.readFileSync(path.join(SRC_DIR, e), 'utf-8') }));
|
||||
}
|
||||
|
||||
/** Strip line and block comments so static greps only see real code. */
|
||||
function stripComments(src: string): string {
|
||||
return src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
|
||||
}
|
||||
|
||||
describe('process liveness probe (Windows terminal-agent leak)', () => {
|
||||
test('1. isProcessAlive reports the current process alive', () => {
|
||||
expect(isProcessAlive(process.pid)).toBe(true);
|
||||
});
|
||||
|
||||
test('2. isProcessAlive reports an unused PID dead', () => {
|
||||
// Below Linux PID_MAX_LIMIT, far above any realistic Windows/macOS PID.
|
||||
expect(isProcessAlive(2147483646)).toBe(false);
|
||||
});
|
||||
|
||||
test('3. isProcessAlive spawns NO subprocess', () => {
|
||||
// The heart of the bug: a liveness probe that forks is slow enough to
|
||||
// time out, and a timed-out probe silently answers "dead". Signal 0
|
||||
// cannot time out because it never leaves the process.
|
||||
const origSpawn = (Bun as any).spawn;
|
||||
const origSpawnSync = (Bun as any).spawnSync;
|
||||
const spawns: string[] = [];
|
||||
(Bun as any).spawn = (...args: any[]) => { spawns.push(`spawn:${JSON.stringify(args[0])}`); return origSpawn(...args); };
|
||||
(Bun as any).spawnSync = (...args: any[]) => { spawns.push(`spawnSync:${JSON.stringify(args[0])}`); return origSpawnSync(...args); };
|
||||
try {
|
||||
isProcessAlive(process.pid);
|
||||
isProcessAlive(2147483646);
|
||||
expect(spawns).toEqual([]);
|
||||
} finally {
|
||||
(Bun as any).spawn = origSpawn;
|
||||
(Bun as any).spawnSync = origSpawnSync;
|
||||
}
|
||||
});
|
||||
|
||||
test('4. no source file probes liveness via tasklist', () => {
|
||||
// Static tripwire: re-introducing a tasklist-based existence check
|
||||
// anywhere in src/ resurrects the false-negative class.
|
||||
const offenders: string[] = [];
|
||||
for (const { file, content } of readAllSourceFiles()) {
|
||||
const code = stripComments(content);
|
||||
// `PID eq` is the existence-probe form specifically. Other tasklist
|
||||
// uses (e.g. IMAGENAME filters for browser detection) are unaffected.
|
||||
if (/tasklist/.test(code) && /PID eq/.test(code)) offenders.push(file);
|
||||
}
|
||||
expect(offenders).toEqual([]);
|
||||
});
|
||||
|
||||
test('5. spawnTerminalAgent passes windowsHide so no console is shown', () => {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-hide-'));
|
||||
const script = path.join(tmpDir, 'fake-agent.ts');
|
||||
fs.writeFileSync(script, '// no-op\n');
|
||||
const origSpawn = (Bun as any).spawn;
|
||||
let captured: any = null;
|
||||
(Bun as any).spawn = (_cmd: any, opts: any) => {
|
||||
captured = opts;
|
||||
return { pid: 4242, unref() {} };
|
||||
};
|
||||
try {
|
||||
const pid = spawnTerminalAgent({
|
||||
stateFile: path.join(tmpDir, 'state.json'),
|
||||
serverPort: 12345,
|
||||
ownerPid: process.pid,
|
||||
cwd: tmpDir,
|
||||
scriptPath: script,
|
||||
});
|
||||
expect(pid).toBe(4242);
|
||||
expect(captured).not.toBeNull();
|
||||
expect(captured.windowsHide).toBe(true);
|
||||
// Owner-PID lifetime tie (#2019): the agent polls this and exits when
|
||||
// its owning browse server dies, so it can't be adopted by PID 1.
|
||||
expect(captured.env.BROWSE_OWNER_PID).toBe(String(process.pid));
|
||||
// Detached background daemon — must not inherit a terminal either.
|
||||
expect(captured.stdio).toEqual(['ignore', 'ignore', 'ignore']);
|
||||
} finally {
|
||||
(Bun as any).spawn = origSpawn;
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('6. respawn guard window spans enough ticks for the guard to fire', () => {
|
||||
// The guard was `RESPAWN_GUARD_WINDOW_MS = 60_000` against a 60_000ms
|
||||
// tick, allowing at most ONE respawn in the window — so the
|
||||
// `>= RESPAWN_GUARD_MAX (3)` trip condition was unreachable and a steady
|
||||
// one-per-tick leak never self-limited. Assert the window is derived from
|
||||
// the tick rather than fixed.
|
||||
const src = fs.readFileSync(path.join(SRC_DIR, 'server.ts'), 'utf-8');
|
||||
const match = src.match(/const RESPAWN_GUARD_WINDOW_MS =([\s\S]{0,160}?);/);
|
||||
expect(match).not.toBeNull();
|
||||
expect(match![1]).toContain('AGENT_WATCHDOG_TICK_MS');
|
||||
|
||||
// Pin the arithmetic itself: at the default tick, three respawns must fit.
|
||||
const tick = 60_000;
|
||||
const guardMax = 3;
|
||||
const windowMs = Math.max(60_000, tick * (guardMax + 2));
|
||||
expect(windowMs).toBeGreaterThanOrEqual(tick * guardMax);
|
||||
});
|
||||
});
|
||||
@@ -56,9 +56,14 @@ describe('defense-in-depth — live Playwright fixture', () => {
|
||||
await bm.launch();
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test
|
||||
// runs all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
test('L2 — content-security.ts hidden-element stripper detects the .sneaky div', async () => {
|
||||
|
||||
@@ -217,7 +217,7 @@ describe('buildFetchHandler ownsTerminalAgent gate', () => {
|
||||
// Resolves browse/src/server.ts relative to this test file so the test
|
||||
// works regardless of cwd. import.meta.url is the test file's URL.
|
||||
const serverTsPath = path.resolve(
|
||||
new URL(import.meta.url).pathname,
|
||||
import.meta.path,
|
||||
'..',
|
||||
'..',
|
||||
'src',
|
||||
|
||||
@@ -7,7 +7,7 @@ import * as path from 'path';
|
||||
// loopback to be live (e2e-tier); these static-grep tripwires pin the
|
||||
// load-bearing protocol invariants.
|
||||
|
||||
const SERVER_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'server.ts');
|
||||
const SERVER_TS = path.resolve(import.meta.path, '..', '..', 'src', 'server.ts');
|
||||
|
||||
describe('server: PTY lease routes (v1.44+ Commit 2)', () => {
|
||||
test('1. /pty-session returns the 4-tuple shape (sessionId, attachToken, leaseExpiresAt)', () => {
|
||||
|
||||
@@ -1,328 +0,0 @@
|
||||
/**
|
||||
* Layer 2: Server HTTP integration tests for sidebar endpoints.
|
||||
* Starts the browse server as a subprocess (no browser via BROWSE_HEADLESS_SKIP),
|
||||
* exercises sidebar HTTP endpoints with fetch(). No Chrome, no Claude, no sidebar-agent.
|
||||
*/
|
||||
|
||||
import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
|
||||
import { spawn, type Subprocess } from 'bun';
|
||||
import * as fs from 'fs';
|
||||
import * as os from 'os';
|
||||
import * as path from 'path';
|
||||
|
||||
let serverProc: Subprocess | null = null;
|
||||
let serverPort: number = 0;
|
||||
let authToken: string = '';
|
||||
let tmpDir: string = '';
|
||||
let stateFile: string = '';
|
||||
let queueFile: string = '';
|
||||
|
||||
async function api(pathname: string, opts: RequestInit & { noAuth?: boolean } = {}): Promise<Response> {
|
||||
const { noAuth, ...fetchOpts } = opts;
|
||||
const headers: Record<string, string> = {
|
||||
'Content-Type': 'application/json',
|
||||
...(fetchOpts.headers as Record<string, string> || {}),
|
||||
};
|
||||
if (!noAuth && !headers['Authorization'] && authToken) {
|
||||
headers['Authorization'] = `Bearer ${authToken}`;
|
||||
}
|
||||
return fetch(`http://127.0.0.1:${serverPort}${pathname}`, { ...fetchOpts, headers });
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sidebar-integ-'));
|
||||
stateFile = path.join(tmpDir, 'browse.json');
|
||||
queueFile = path.join(tmpDir, 'sidebar-queue.jsonl');
|
||||
|
||||
// Ensure queue dir exists
|
||||
fs.mkdirSync(path.dirname(queueFile), { recursive: true });
|
||||
|
||||
const serverScript = path.resolve(__dirname, '..', 'src', 'server.ts');
|
||||
serverProc = spawn(['bun', 'run', serverScript], {
|
||||
env: {
|
||||
...process.env,
|
||||
BROWSE_STATE_FILE: stateFile,
|
||||
BROWSE_HEADLESS_SKIP: '1',
|
||||
BROWSE_PORT: '0',
|
||||
SIDEBAR_QUEUE_PATH: queueFile,
|
||||
BROWSE_IDLE_TIMEOUT: '300',
|
||||
},
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
});
|
||||
|
||||
// Wait for state file
|
||||
const deadline = Date.now() + 15000;
|
||||
while (Date.now() < deadline) {
|
||||
if (fs.existsSync(stateFile)) {
|
||||
try {
|
||||
const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
|
||||
if (state.port && state.token) {
|
||||
serverPort = state.port;
|
||||
authToken = state.token;
|
||||
break;
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
}
|
||||
if (!serverPort) throw new Error('Server did not start in time');
|
||||
}, 20000);
|
||||
|
||||
afterAll(() => {
|
||||
if (serverProc) { try { serverProc.kill(); } catch {} }
|
||||
try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
|
||||
});
|
||||
|
||||
// Reset state between tests — creates a fresh session, clears all queues
|
||||
async function resetState() {
|
||||
await api('/sidebar-session/new', { method: 'POST' });
|
||||
fs.writeFileSync(queueFile, '');
|
||||
}
|
||||
|
||||
describe('sidebar auth', () => {
|
||||
test('rejects request without auth token', async () => {
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
noAuth: true,
|
||||
body: JSON.stringify({ message: 'test' }),
|
||||
});
|
||||
expect(resp.status).toBe(401);
|
||||
});
|
||||
|
||||
test('rejects request with wrong token', async () => {
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
headers: { 'Authorization': 'Bearer wrong-token' },
|
||||
body: JSON.stringify({ message: 'test' }),
|
||||
});
|
||||
expect(resp.status).toBe(401);
|
||||
});
|
||||
|
||||
test('accepts request with correct token', async () => {
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'hello' }),
|
||||
});
|
||||
expect(resp.status).toBe(200);
|
||||
// Clean up
|
||||
await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
});
|
||||
});
|
||||
|
||||
describe('sidebar-command → queue', () => {
|
||||
test('writes queue entry with activeTabUrl', async () => {
|
||||
await resetState();
|
||||
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({
|
||||
message: 'what is on this page?',
|
||||
activeTabUrl: 'https://example.com/test-page',
|
||||
}),
|
||||
});
|
||||
expect(resp.status).toBe(200);
|
||||
const data = await resp.json();
|
||||
expect(data.ok).toBe(true);
|
||||
|
||||
// Give server a moment to write queue
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
|
||||
const content = fs.readFileSync(queueFile, 'utf-8').trim();
|
||||
const lines = content.split('\n').filter(Boolean);
|
||||
expect(lines.length).toBeGreaterThan(0);
|
||||
const entry = JSON.parse(lines[lines.length - 1]);
|
||||
// Active tab URL is carried on the queue entry metadata (entry.pageUrl),
|
||||
// NOT inlined into the prompt. The system prompt deliberately tells
|
||||
// Claude to run `browse url` instead of trusting any URL in the prompt
|
||||
// body — that's the prompt-injection-via-URL defense. See spawnClaude
|
||||
// in browse/src/server.ts.
|
||||
expect(entry.pageUrl).toBe('https://example.com/test-page');
|
||||
|
||||
await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
});
|
||||
|
||||
test('falls back when activeTabUrl is null', async () => {
|
||||
await resetState();
|
||||
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'test', activeTabUrl: null }),
|
||||
});
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
|
||||
const lines = fs.readFileSync(queueFile, 'utf-8').trim().split('\n').filter(Boolean);
|
||||
expect(lines.length).toBeGreaterThan(0);
|
||||
const entry = JSON.parse(lines[lines.length - 1]);
|
||||
// No browser → playwright URL is 'about:blank'
|
||||
expect(entry.pageUrl).toBe('about:blank');
|
||||
|
||||
await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
});
|
||||
|
||||
test('rejects chrome:// activeTabUrl and falls back', async () => {
|
||||
await resetState();
|
||||
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'test', activeTabUrl: 'chrome://extensions' }),
|
||||
});
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
|
||||
const lines = fs.readFileSync(queueFile, 'utf-8').trim().split('\n').filter(Boolean);
|
||||
expect(lines.length).toBeGreaterThan(0);
|
||||
const entry = JSON.parse(lines[lines.length - 1]);
|
||||
expect(entry.pageUrl).toBe('about:blank');
|
||||
|
||||
await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
});
|
||||
|
||||
test('rejects empty message', async () => {
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: '' }),
|
||||
});
|
||||
expect(resp.status).toBe(400);
|
||||
});
|
||||
});
|
||||
|
||||
describe('sidebar-agent/event → chat buffer', () => {
|
||||
test('agent events appear in /sidebar-chat', async () => {
|
||||
await resetState();
|
||||
|
||||
// Post pre-processed agent event. The server's processAgentEvent
|
||||
// handles the simplified types that sidebar-agent.ts emits (text,
|
||||
// text_delta, tool_use, result, agent_error, security_event), NOT
|
||||
// the raw Claude streaming format — pre-processing lives in
|
||||
// sidebar-agent.ts, not in the server.
|
||||
await api('/sidebar-agent/event', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({
|
||||
type: 'text',
|
||||
text: 'Hello from mock agent',
|
||||
}),
|
||||
});
|
||||
|
||||
const chatData = await (await api('/sidebar-chat?after=0')).json();
|
||||
const textEntry = chatData.entries.find((e: any) => e.type === 'text');
|
||||
expect(textEntry).toBeDefined();
|
||||
expect(textEntry.text).toBe('Hello from mock agent');
|
||||
});
|
||||
|
||||
test('agent_done transitions status to idle', async () => {
|
||||
await resetState();
|
||||
// Start a command so agent is processing
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'test' }),
|
||||
});
|
||||
|
||||
// Verify processing
|
||||
let session = await (await api('/sidebar-session')).json();
|
||||
expect(session.agent.status).toBe('processing');
|
||||
|
||||
// Send agent_done
|
||||
await api('/sidebar-agent/event', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ type: 'agent_done' }),
|
||||
});
|
||||
|
||||
session = await (await api('/sidebar-session')).json();
|
||||
expect(session.agent.status).toBe('idle');
|
||||
});
|
||||
});
|
||||
|
||||
describe('message queuing', () => {
|
||||
test('queues message when agent is processing', async () => {
|
||||
await resetState();
|
||||
|
||||
// First message starts processing
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'first' }),
|
||||
});
|
||||
|
||||
// Second message gets queued
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'second' }),
|
||||
});
|
||||
const data = await resp.json();
|
||||
expect(data.ok).toBe(true);
|
||||
expect(data.queued).toBe(true);
|
||||
expect(data.position).toBe(1);
|
||||
|
||||
await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
});
|
||||
|
||||
test('returns 429 when queue is full', async () => {
|
||||
await resetState();
|
||||
|
||||
// First message starts processing
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'first' }),
|
||||
});
|
||||
|
||||
// Fill queue (max 5)
|
||||
for (let i = 0; i < 5; i++) {
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: `fill-${i}` }),
|
||||
});
|
||||
}
|
||||
|
||||
// 7th message should be rejected
|
||||
const resp = await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'overflow' }),
|
||||
});
|
||||
expect(resp.status).toBe(429);
|
||||
|
||||
await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
});
|
||||
});
|
||||
|
||||
describe('chat clear', () => {
|
||||
test('clears chat buffer', async () => {
|
||||
await resetState();
|
||||
// Add some entries
|
||||
await api('/sidebar-agent/event', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ type: 'text', text: 'to be cleared' }),
|
||||
});
|
||||
|
||||
await api('/sidebar-chat/clear', { method: 'POST' });
|
||||
|
||||
const data = await (await api('/sidebar-chat?after=0')).json();
|
||||
expect(data.entries.length).toBe(0);
|
||||
expect(data.total).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('agent kill', () => {
|
||||
test('kill adds error entry and returns to idle', async () => {
|
||||
await resetState();
|
||||
|
||||
// Start a command so agent is processing
|
||||
await api('/sidebar-command', {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ message: 'kill me' }),
|
||||
});
|
||||
|
||||
let session = await (await api('/sidebar-session')).json();
|
||||
expect(session.agent.status).toBe('processing');
|
||||
|
||||
// Kill the agent
|
||||
const killResp = await api('/sidebar-agent/kill', { method: 'POST' });
|
||||
expect(killResp.status).toBe(200);
|
||||
|
||||
// Check chat for error entry
|
||||
const chatData = await (await api('/sidebar-chat?after=0')).json();
|
||||
const errorEntry = chatData.entries.find((e: any) => e.error === 'Killed by user');
|
||||
expect(errorEntry).toBeDefined();
|
||||
|
||||
// Agent should be idle (no queue items to auto-process)
|
||||
session = await (await api('/sidebar-session')).json();
|
||||
expect(session.agent.status).toBe('idle');
|
||||
});
|
||||
});
|
||||
@@ -157,7 +157,9 @@ describe('sidepanel-terminal.js: eager auto-connect + injection API', () => {
|
||||
test('forceRestart helper closes ws, disposes xterm, returns to IDLE', () => {
|
||||
expect(TERM_JS).toContain('function forceRestart');
|
||||
const fn = TERM_JS.slice(TERM_JS.indexOf('function forceRestart'));
|
||||
expect(fn).toContain('ws && ws.close()');
|
||||
// close() carries an intentional-restart close code so the agent's
|
||||
// close handler can distinguish user restarts from network drops.
|
||||
expect(fn).toContain("ws && ws.close(4001, 'intentional-restart')");
|
||||
expect(fn).toContain('term.dispose()');
|
||||
expect(fn).toContain('STATE.IDLE');
|
||||
expect(fn).toContain('tryAutoConnect()');
|
||||
@@ -222,8 +224,17 @@ describe('cli.ts: sidebar-agent is no longer spawned', () => {
|
||||
});
|
||||
|
||||
test('Terminal-agent spawn survives', () => {
|
||||
expect(CLI_SRC).toContain('terminal-agent.ts');
|
||||
expect(CLI_SRC).toMatch(/Bun\.spawn\(\['bun',\s*'run',\s*termAgentScript\]/);
|
||||
// v1.44 moved the raw Bun.spawn into the shared spawnTerminalAgent
|
||||
// helper (terminal-agent-control.ts) so cli.ts, the supervisor respawn
|
||||
// loop, and the watchdog all share identity-based process control.
|
||||
// cli.ts must still route through that helper.
|
||||
expect(CLI_SRC).toContain('spawnTerminalAgent');
|
||||
const CONTROL_SRC = fs.readFileSync(
|
||||
path.join(import.meta.dir, '../src/terminal-agent-control.ts'),
|
||||
'utf-8',
|
||||
);
|
||||
expect(CONTROL_SRC).toContain('terminal-agent.ts');
|
||||
expect(CONTROL_SRC).toMatch(/\.spawn\(\['bun',\s*'run',\s*script\]/);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
+97
-769
File diff suppressed because it is too large
Load Diff
@@ -12,7 +12,7 @@ import * as path from 'path';
|
||||
// explicit unrecoverable signals (401 auth invalid).
|
||||
|
||||
const CLIENT_JS = path.resolve(
|
||||
new URL(import.meta.url).pathname,
|
||||
import.meta.path,
|
||||
'..',
|
||||
'..',
|
||||
'..',
|
||||
|
||||
@@ -13,7 +13,7 @@ import * as path from 'path';
|
||||
// in the e2e tier.
|
||||
|
||||
const TERMINAL_JS = path.resolve(
|
||||
new URL(import.meta.url).pathname, '..', '..', '..', 'extension', 'sidepanel-terminal.js',
|
||||
import.meta.path, '..', '..', '..', 'extension', 'sidepanel-terminal.js',
|
||||
);
|
||||
|
||||
describe('sidepanel re-attach loop (v1.44+ Commit 3)', () => {
|
||||
|
||||
@@ -16,10 +16,10 @@ import * as path from 'path';
|
||||
// doesn't leak a 60s-zombie claude.
|
||||
|
||||
const TERMINAL_JS = path.resolve(
|
||||
new URL(import.meta.url).pathname, '..', '..', '..', 'extension', 'sidepanel-terminal.js',
|
||||
import.meta.path, '..', '..', '..', 'extension', 'sidepanel-terminal.js',
|
||||
);
|
||||
const SIDEPANEL_JS = path.resolve(
|
||||
new URL(import.meta.url).pathname, '..', '..', '..', 'extension', 'sidepanel.js',
|
||||
import.meta.path, '..', '..', '..', 'extension', 'sidepanel.js',
|
||||
);
|
||||
|
||||
describe('sidepanel-terminal: forceRestart via /pty-restart (v1.44+)', () => {
|
||||
|
||||
@@ -31,9 +31,14 @@ beforeAll(async () => {
|
||||
await bm.launch();
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
afterAll(async () => {
|
||||
try { testServer.server.stop(); } catch {}
|
||||
setTimeout(() => process.exit(0), 500);
|
||||
// Close only this file's own browser — never process.exit(): bun test runs
|
||||
// all files in one process, so a delayed exit kills the whole suite
|
||||
// (see test/no-suicide-exit.test.ts). close() can hang when the browser
|
||||
// already died, and its internal 5s timeout ties bun's 5s hook timeout —
|
||||
// so race it at 3s and abandon; the child is reaped at process exit.
|
||||
try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
|
||||
});
|
||||
|
||||
// ─── Snapshot Output ────────────────────────────────────────────
|
||||
|
||||
@@ -10,7 +10,7 @@ import * as path from 'path';
|
||||
// in the e2e tier; these static-grep tripwires defend the load-bearing
|
||||
// protocol + correctness properties.
|
||||
|
||||
const AGENT_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'terminal-agent.ts');
|
||||
const AGENT_TS = path.resolve(import.meta.path, '..', '..', 'src', 'terminal-agent.ts');
|
||||
|
||||
describe('terminal-agent detach + re-attach (v1.44+ Commit 3)', () => {
|
||||
test('1. PtySession carries ring buffer + alt-screen + detach state', () => {
|
||||
|
||||
@@ -227,6 +227,45 @@ describe('terminal-agent: PTY round-trip via real WebSocket (Cookie auth)', () =
|
||||
expect(resp.headers.get('sec-websocket-protocol')).toBe(`gstack-pty.${token}`);
|
||||
});
|
||||
|
||||
test('upgrade response contains exactly ONE Sec-WebSocket-Protocol header', async () => {
|
||||
// RFC 6455: the server MUST select at most one subprotocol. Bun >= 1.3
|
||||
// auto-echoes the first offered protocol in server.upgrade(), so a
|
||||
// manual echo on top of that produced TWO Sec-WebSocket-Protocol
|
||||
// headers — and strict clients (Chromium, python websockets) reject the
|
||||
// handshake, leaving the sidebar terminal permanently disconnected.
|
||||
//
|
||||
// Headers.get() normalizes duplicates away, so this test handshakes
|
||||
// over a raw socket and counts header lines in the response head.
|
||||
const token = 'dup-proto-token-must-be-at-least-seventeen-chars';
|
||||
await grantToken(token);
|
||||
|
||||
const head = await new Promise<string>((resolve, reject) => {
|
||||
const req =
|
||||
'GET /ws HTTP/1.1\r\n' +
|
||||
`Host: 127.0.0.1:${agentPort}\r\n` +
|
||||
'Connection: Upgrade\r\n' +
|
||||
'Upgrade: websocket\r\n' +
|
||||
'Sec-WebSocket-Version: 13\r\n' +
|
||||
'Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n' +
|
||||
`Sec-WebSocket-Protocol: gstack-pty.${token}\r\n` +
|
||||
'Origin: chrome-extension://test-extension-id\r\n' +
|
||||
'\r\n';
|
||||
let buf = '';
|
||||
const socket = require('net').connect(agentPort, '127.0.0.1', () => socket.write(req));
|
||||
socket.setTimeout(5000, () => { socket.destroy(); reject(new Error('handshake timeout')); });
|
||||
socket.on('data', (chunk: Buffer) => {
|
||||
buf += chunk.toString('utf8');
|
||||
const end = buf.indexOf('\r\n\r\n');
|
||||
if (end !== -1) { socket.destroy(); resolve(buf.slice(0, end)); }
|
||||
});
|
||||
socket.on('error', reject);
|
||||
});
|
||||
|
||||
expect(head).toContain('101');
|
||||
const protoLines = head.split('\r\n').filter(l => l.toLowerCase().startsWith('sec-websocket-protocol:'));
|
||||
expect(protoLines).toEqual([`Sec-WebSocket-Protocol: gstack-pty.${token}`]);
|
||||
});
|
||||
|
||||
test('Sec-WebSocket-Protocol auth: rejects unknown token even with valid Origin', async () => {
|
||||
const resp = await fetch(`http://127.0.0.1:${agentPort}/ws`, {
|
||||
headers: {
|
||||
|
||||
@@ -12,7 +12,7 @@ import * as path from 'path';
|
||||
// (token grant/revoke behavior) already live in
|
||||
// browse/test/terminal-agent-integration.test.ts.
|
||||
|
||||
const AGENT_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'terminal-agent.ts');
|
||||
const AGENT_TS = path.resolve(import.meta.path, '..', '..', 'src', 'terminal-agent.ts');
|
||||
|
||||
describe('terminal-agent internalHandler refactor (v1.44+)', () => {
|
||||
test('1. internalHandler<T> exists with the documented signature', () => {
|
||||
|
||||
@@ -11,8 +11,8 @@ import * as path from 'path';
|
||||
// regressed by a refactor. These tests fail CI if either side stops sending
|
||||
// or stops accepting the protocol frames.
|
||||
|
||||
const AGENT_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'terminal-agent.ts');
|
||||
const CLIENT_JS = path.resolve(new URL(import.meta.url).pathname, '..', '..', '..', 'extension', 'sidepanel-terminal.js');
|
||||
const AGENT_TS = path.resolve(import.meta.path, '..', '..', 'src', 'terminal-agent.ts');
|
||||
const CLIENT_JS = path.resolve(import.meta.path, '..', '..', '..', 'extension', 'sidepanel-terminal.js');
|
||||
|
||||
describe('terminal-agent WS keepalive (v1.44+)', () => {
|
||||
test('1. agent has a KEEPALIVE_INTERVAL_MS env knob, default 25000', () => {
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
import { afterEach, describe, expect, test } from 'bun:test';
|
||||
import * as fs from 'fs';
|
||||
import * as os from 'os';
|
||||
import * as path from 'path';
|
||||
|
||||
const AGENT_SCRIPT = path.join(import.meta.dir, '../src/terminal-agent.ts');
|
||||
const spawned: any[] = [];
|
||||
const tempDirs: string[] = [];
|
||||
|
||||
function isAlive(pid: number): boolean {
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async function waitFor(predicate: () => boolean, timeoutMs = 5_000): Promise<boolean> {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
if (predicate()) return true;
|
||||
await Bun.sleep(25);
|
||||
}
|
||||
return predicate();
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
for (const proc of spawned.splice(0)) {
|
||||
try { proc.kill?.('SIGKILL'); } catch {}
|
||||
}
|
||||
for (const dir of tempDirs.splice(0)) {
|
||||
try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
|
||||
}
|
||||
});
|
||||
|
||||
describe('terminal-agent owner lifecycle', () => {
|
||||
test('exits after its owning browse server process exits', async () => {
|
||||
const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-term-owner-'));
|
||||
tempDirs.push(stateDir);
|
||||
const stateFile = path.join(stateDir, 'browse.json');
|
||||
fs.writeFileSync(stateFile, JSON.stringify({ token: 'test-token' }));
|
||||
|
||||
// process.execPath (the running bun) instead of `sleep`: coreutils are
|
||||
// not guaranteed on a bare windows-latest runner, and this test is on the
|
||||
// Windows CI curated list — the owner-orphan leak it pins is a Windows bug.
|
||||
const owner = Bun.spawn(
|
||||
[process.execPath, '-e', 'await Bun.sleep(30000)'],
|
||||
{ stdio: ['ignore', 'ignore', 'ignore'] },
|
||||
);
|
||||
spawned.push(owner);
|
||||
const agent = Bun.spawn(['bun', 'run', AGENT_SCRIPT], {
|
||||
env: {
|
||||
...process.env,
|
||||
BROWSE_STATE_FILE: stateFile,
|
||||
BROWSE_SERVER_PORT: '0',
|
||||
BROWSE_OWNER_PID: String(owner.pid),
|
||||
GSTACK_TERMINAL_OWNER_WATCHDOG_MS: '25',
|
||||
},
|
||||
stdio: ['ignore', 'ignore', 'ignore'],
|
||||
});
|
||||
spawned.push(agent);
|
||||
|
||||
expect(await waitFor(() => fs.existsSync(path.join(stateDir, 'terminal-agent-pid')))).toBe(true);
|
||||
expect(isAlive(agent.pid)).toBe(true);
|
||||
|
||||
owner.kill('SIGTERM');
|
||||
await owner.exited;
|
||||
|
||||
expect(await waitFor(() => !isAlive(agent.pid))).toBe(true);
|
||||
expect(fs.existsSync(path.join(stateDir, 'terminal-agent-pid'))).toBe(false);
|
||||
expect(fs.existsSync(path.join(stateDir, 'terminal-port'))).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -30,7 +30,7 @@ import {
|
||||
// and browse/test/server-sanitize-surrogates.test.ts: read source files
|
||||
// directly, assert an invariant on their contents.
|
||||
|
||||
const SRC_DIR = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src');
|
||||
const SRC_DIR = path.resolve(import.meta.path, '..', '..', 'src');
|
||||
|
||||
function readAllSourceFiles(): Array<{ file: string; content: string }> {
|
||||
const out: Array<{ file: string; content: string }> = [];
|
||||
|
||||
@@ -13,7 +13,7 @@ import * as path from 'path';
|
||||
// - {type:"start"} triggers spawn for eager UX after forceRestart
|
||||
// - maybeSpawnPty helper is the single entry point for both spawn paths
|
||||
|
||||
const AGENT_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'terminal-agent.ts');
|
||||
const AGENT_TS = path.resolve(import.meta.path, '..', '..', 'src', 'terminal-agent.ts');
|
||||
|
||||
describe('terminal-agent session routing (v1.44+ Commit 2)', () => {
|
||||
test('1. validTokens is a Map binding token → sessionId', () => {
|
||||
|
||||
@@ -10,8 +10,8 @@ import * as path from 'path';
|
||||
// load-bearing properties: identity-based liveness check (not name match),
|
||||
// crash-loop guard, gated on ownsTerminalAgent, and cleared on shutdown.
|
||||
|
||||
const SERVER_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'server.ts');
|
||||
const CONTROL_TS = path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'terminal-agent-control.ts');
|
||||
const SERVER_TS = path.resolve(import.meta.path, '..', '..', 'src', 'server.ts');
|
||||
const CONTROL_TS = path.resolve(import.meta.path, '..', '..', 'src', 'terminal-agent-control.ts');
|
||||
|
||||
describe('terminal-agent watchdog (v1.44+)', () => {
|
||||
test('1. spawnTerminalAgent helper exists with PID return type', () => {
|
||||
@@ -50,7 +50,13 @@ describe('terminal-agent watchdog (v1.44+)', () => {
|
||||
test('4. crash-loop guard with rolling window', () => {
|
||||
const src = fs.readFileSync(SERVER_TS, 'utf-8');
|
||||
const block = sliceBetween(src, '─── Terminal-Agent Watchdog', 'Factory-scoped validateAuth');
|
||||
expect(block).toContain('RESPAWN_GUARD_WINDOW_MS = 60_000');
|
||||
// The window MUST be derived from the tick, not a fixed 60_000. It was
|
||||
// hardcoded to 60_000 against a 60_000ms tick, so at most ONE respawn
|
||||
// could ever sit inside the window and the `>= RESPAWN_GUARD_MAX` trip
|
||||
// was unreachable — a steady one-respawn-per-tick leak ran unbounded
|
||||
// instead of self-limiting after 3. Pinning the literal is what let that
|
||||
// ship, so pin the relationship instead.
|
||||
expect(block).toMatch(/RESPAWN_GUARD_WINDOW_MS =[\s\S]{0,200}AGENT_WATCHDOG_TICK_MS/);
|
||||
expect(block).toContain('RESPAWN_GUARD_MAX = 3');
|
||||
expect(block).toContain('respawnHistory');
|
||||
expect(block).toContain('agentRespawnGuardTripped');
|
||||
@@ -72,7 +78,7 @@ describe('terminal-agent watchdog (v1.44+)', () => {
|
||||
|
||||
test('7. CLI cold-start path uses the same spawnTerminalAgent helper', () => {
|
||||
const cli = fs.readFileSync(
|
||||
path.resolve(new URL(import.meta.url).pathname, '..', '..', 'src', 'cli.ts'),
|
||||
path.resolve(import.meta.path, '..', '..', 'src', 'cli.ts'),
|
||||
'utf-8',
|
||||
);
|
||||
// Otherwise the CLI and watchdog could drift on spawn env/cwd, and
|
||||
|
||||
@@ -131,30 +131,51 @@ describe('Source-level guard: terminal-agent', () => {
|
||||
expect(wsHandler).toContain('validTokens.has');
|
||||
});
|
||||
|
||||
test('Sec-WebSocket-Protocol auth: strips gstack-pty. prefix and echoes back', () => {
|
||||
test('Sec-WebSocket-Protocol auth: strips gstack-pty. prefix, no manual echo', () => {
|
||||
const wsHandler = AGENT_SRC.slice(AGENT_SRC.indexOf("if (url.pathname === '/ws')"));
|
||||
// Browsers send `Sec-WebSocket-Protocol: gstack-pty.<token>`. The agent
|
||||
// must strip the prefix before checking validTokens, AND echo the
|
||||
// protocol back in the upgrade response — without the echo, the
|
||||
// browser closes the connection immediately.
|
||||
// must strip the prefix before checking validTokens. The protocol echo
|
||||
// is Bun's job: Bun >= 1.3 auto-echoes the first offered protocol in the
|
||||
// 101 response. A manual echo on top produced a DUPLICATE
|
||||
// Sec-WebSocket-Protocol header, which strict clients (Chromium, python
|
||||
// websockets) reject per RFC 6455 — the sidebar terminal could never
|
||||
// connect. Pin the invariant: no manual echo in the upgrade call.
|
||||
expect(wsHandler).toContain("'gstack-pty.'");
|
||||
expect(wsHandler).toContain('Sec-WebSocket-Protocol');
|
||||
expect(wsHandler).toContain('acceptedProtocol');
|
||||
expect(wsHandler).toContain('sec-websocket-protocol');
|
||||
expect(wsHandler).not.toContain("headers: { 'Sec-WebSocket-Protocol'");
|
||||
});
|
||||
|
||||
test('lazy spawn: claude PTY is spawned in message handler, not on upgrade', () => {
|
||||
// The whole point of lazy-spawn (codex finding #8) is that the WS
|
||||
// upgrade itself does NOT call spawnClaude. Spawn happens on first
|
||||
// message frame.
|
||||
// upgrade itself does NOT spawn claude. Spawn happens on first
|
||||
// message frame (binary input or the v1.44 explicit `start` frame),
|
||||
// routed through the maybeSpawnPty helper, which is the only caller
|
||||
// of spawnClaude.
|
||||
const upgradeBlock = AGENT_SRC.slice(
|
||||
AGENT_SRC.indexOf("if (url.pathname === '/ws')"),
|
||||
AGENT_SRC.indexOf("websocket: {"),
|
||||
);
|
||||
expect(upgradeBlock).not.toContain('spawnClaude(');
|
||||
expect(upgradeBlock).not.toContain('maybeSpawnPty(');
|
||||
// Spawn must be invoked from the message handler (lazy on first byte).
|
||||
// v1.44 routes both spawn triggers (explicit {type:"start"} text frame
|
||||
// and the lazy binary-frame path) through the maybeSpawnPty helper.
|
||||
const messageHandler = AGENT_SRC.slice(AGENT_SRC.indexOf('message(ws, raw)'));
|
||||
expect(messageHandler).toContain('spawnClaude(');
|
||||
expect(messageHandler).toContain('maybeSpawnPty(');
|
||||
expect(messageHandler).toContain('!session.spawned');
|
||||
// The open() upgrade handler must not spawn — it only creates the
|
||||
// (spawned: false) session record or re-attaches a detached one.
|
||||
const openBlock = AGENT_SRC.slice(
|
||||
AGENT_SRC.indexOf('open(ws)'),
|
||||
AGENT_SRC.indexOf('message(ws, raw)'),
|
||||
);
|
||||
expect(openBlock).not.toContain('spawnClaude(');
|
||||
expect(openBlock).not.toContain('maybeSpawnPty(');
|
||||
// And the helper itself is where spawnClaude actually happens, gated
|
||||
// on session.spawned so it stays a single-shot lazy spawn.
|
||||
const helperBlock = AGENT_SRC.slice(AGENT_SRC.indexOf('function maybeSpawnPty'));
|
||||
expect(helperBlock).toContain('spawnClaude(');
|
||||
expect(helperBlock).toContain('if (session.spawned) return true;');
|
||||
});
|
||||
|
||||
test('process.on uncaughtException + unhandledRejection handlers exist', () => {
|
||||
|
||||
@@ -47,6 +47,28 @@ describe('validateNavigationUrl', () => {
|
||||
await expect(validateNavigationUrl('file://host.example.com/foo.html')).rejects.toThrow(/Unsupported file URL host/i);
|
||||
});
|
||||
|
||||
// The daemon opens its own first tab on about:blank, so blocking it meant a restarted
|
||||
// daemon could never initialise — and `make-pdf setup`, whose Chromium smoke test is
|
||||
// `browse newtab about:blank`, reported "Chromium failed to launch" on a healthy browser.
|
||||
it('allows about:blank — the daemon opens its own first tab there', async () => {
|
||||
await expect(validateNavigationUrl('about:blank')).resolves.toBe('about:blank');
|
||||
});
|
||||
|
||||
it('allows about:blank regardless of case, since URL parsing normalises it', async () => {
|
||||
await expect(validateNavigationUrl('ABOUT:BLANK')).resolves.toBe('about:blank');
|
||||
});
|
||||
|
||||
// The allowance is about:blank EXACTLY, not the about: scheme. about:blank has no
|
||||
// origin and loads nothing; the rest of the scheme is a real surface.
|
||||
it('still blocks other about: URLs', async () => {
|
||||
await expect(validateNavigationUrl('about:config')).rejects.toThrow(/scheme.*not allowed/i);
|
||||
await expect(validateNavigationUrl('about:net-internals')).rejects.toThrow(/scheme.*not allowed/i);
|
||||
});
|
||||
|
||||
it('blocks about:blankfoo — exact match, never a prefix test', async () => {
|
||||
await expect(validateNavigationUrl('about:blankfoo')).rejects.toThrow(/scheme.*not allowed/i);
|
||||
});
|
||||
|
||||
it('blocks javascript: scheme', async () => {
|
||||
await expect(validateNavigationUrl('javascript:alert(1)')).rejects.toThrow(/scheme.*not allowed/i);
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user