diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0b3864b6c..30bfa4a6f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -113,9 +113,15 @@ jobs: - name: Install dependencies run: npm ci + - name: Install web host dependencies + run: npm --prefix web ci + - name: Build run: npm run build + - name: Build web host + run: npm run build:web-host + - name: Typecheck extensions run: npm run typecheck:extensions diff --git a/.gitignore b/.gitignore index 11d0ea16d..465c44380 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ package-lock.json .claude/ RELEASE-GUIDE.md *.tgz +*.tsbuildinfo .DS_Store Thumbs.db *.swp @@ -58,3 +59,6 @@ docs/coherence-audit/ # ── Stale lock files (npm is canonical) ── pnpm-lock.yaml bun.lock + +# ── GSD baseline (auto-generated) ── +.gsd diff --git a/.secretscanignore b/.secretscanignore index 6c08b9a7e..f81ab4813 100644 --- a/.secretscanignore +++ b/.secretscanignore @@ -17,9 +17,15 @@ tests/*:AKIA_EXAMPLE tests/*:test-secret-value tests/*:fake[-_]?(password|secret|token|key) +# Web contract/integration test dummy API keys (not real secrets) +src/tests/integration/web-mode-assembled.test.ts:sk-assembled-test-key +src/tests/integration/web-mode-runtime-fixtures.ts:sk-runtime-recovery-secret +src/tests/web-onboarding-contract.test.ts:sk-test-secret + # Doctor environment tests use dummy localhost DB URLs src/resources/extensions/gsd/tests/doctor-environment.test.ts:postgres://localhost + # Documentation examples *.md:AKIA[0-9A-Z]{16} *.md:sk_(live|test)_ diff --git a/CHANGELOG.md b/CHANGELOG.md index 913e5fe94..e6ca5e3f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -239,6 +239,7 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). ### Fixed - prevent false-positive 'Session lock lost' during auto-mode (#1257) + ## [2.31.0] - 2026-03-18 ### Added diff --git a/native/crates/engine/Cargo.toml b/native/crates/engine/Cargo.toml index b6a0e3af7..20b39e349 100644 --- a/native/crates/engine/Cargo.toml +++ b/native/crates/engine/Cargo.toml @@ -8,7 +8,9 @@ repository.workspace = true description = "N-API native addon for GSD — exposes high-performance Rust modules to Node.js" [lib] -crate-type = ["cdylib"] +crate-type = ["cdylib", "rlib"] +test = false +doctest = false [dependencies] gsd-ast = { path = "../ast" } diff --git a/native/crates/engine/src/lib.rs b/native/crates/engine/src/lib.rs index ed314b5f7..32ee9a418 100644 --- a/native/crates/engine/src/lib.rs +++ b/native/crates/engine/src/lib.rs @@ -6,6 +6,7 @@ //! ``` #![allow(clippy::needless_pass_by_value)] +#![cfg_attr(test, allow(dead_code))] mod ast; mod clipboard; diff --git a/package-lock.json b/package-lock.json index f23ad20f4..c5d64fb9d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "gsd-pi", - "version": "2.33.1", + "version": "2.40.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "gsd-pi", - "version": "2.33.1", + "version": "2.40.0", "hasInstallScript": true, "license": "MIT", "workspaces": [ @@ -9166,7 +9166,7 @@ }, "packages/pi-coding-agent": { "name": "@gsd/pi-coding-agent", - "version": "2.33.1", + "version": "2.40.0", "dependencies": { "@mariozechner/jiti": "^2.6.2", "@silvia-odwyer/photon-node": "^0.3.4", diff --git a/package.json b/package.json index d2c6b0908..b7134ff3a 100644 --- a/package.json +++ b/package.json @@ -22,6 +22,7 @@ }, "files": [ "dist", + "dist/web", "packages", "pkg", "src/resources", @@ -47,6 +48,8 @@ "build:native-pkg": "npm run build -w @gsd/native", "build:pi": "npm run build:native-pkg && npm run build:pi-tui && npm run build:pi-ai && npm run build:pi-agent-core && npm run build:pi-coding-agent", "build": "npm run build:pi && tsc && npm run copy-resources && npm run copy-themes && npm run copy-export-html", + "stage:web-host": "node scripts/stage-web-standalone.cjs", + "build:web-host": "npm --prefix web run build && npm run stage:web-host", "copy-resources": "node scripts/copy-resources.cjs", "copy-themes": "node scripts/copy-themes.cjs", "copy-export-html": "node scripts/copy-export-html.cjs", @@ -67,6 +70,10 @@ "build:native": "node native/scripts/build.js", "build:native:dev": "node native/scripts/build.js --dev", "dev": "node scripts/dev.js", + "gsd": "node scripts/dev-cli.js", + "gsd:web": "npm run build:pi && npm run copy-resources && node scripts/build-web-if-stale.cjs && node scripts/dev-cli.js --web", + "gsd:web:stop": "node scripts/dev-cli.js web stop", + "gsd:web:stop:all": "node scripts/dev-cli.js web stop all", "postinstall": "node scripts/link-workspace-packages.cjs && node scripts/ensure-workspace-builds.cjs && node scripts/postinstall.js", "pi:install-global": "node scripts/install-pi-global.js", "pi:uninstall-global": "node scripts/uninstall-pi-global.js", diff --git a/packages/native/package.json b/packages/native/package.json index e14c3eebd..1bb3b009d 100644 --- a/packages/native/package.json +++ b/packages/native/package.json @@ -9,7 +9,7 @@ "build": "tsc -p tsconfig.json", "build:native": "node ../../native/scripts/build.js", "build:native:dev": "node ../../native/scripts/build.js --dev", - "test": "node --test src/__tests__/grep.test.mjs src/__tests__/ps.test.mjs src/__tests__/glob.test.mjs src/__tests__/clipboard.test.mjs src/__tests__/highlight.test.mjs src/__tests__/html.test.mjs src/__tests__/text.test.mjs src/__tests__/fd.test.mjs src/__tests__/image.test.mjs" + "test": "npm run build:native:dev && node --test src/__tests__/grep.test.mjs src/__tests__/ps.test.mjs src/__tests__/glob.test.mjs src/__tests__/clipboard.test.mjs src/__tests__/highlight.test.mjs src/__tests__/html.test.mjs src/__tests__/text.test.mjs src/__tests__/fd.test.mjs src/__tests__/image.test.mjs" }, "exports": { ".": { diff --git a/packages/pi-ai/src/web-runtime-env-api-keys.ts b/packages/pi-ai/src/web-runtime-env-api-keys.ts new file mode 100644 index 000000000..d97c101cc --- /dev/null +++ b/packages/pi-ai/src/web-runtime-env-api-keys.ts @@ -0,0 +1,86 @@ +import { existsSync } from "node:fs"; +import { homedir } from "node:os"; +import { join } from "node:path"; + +import type { KnownProvider } from "./types.js"; + +let cachedVertexAdcCredentialsExists: boolean | null = null; + +function hasVertexAdcCredentials(): boolean { + if (cachedVertexAdcCredentialsExists !== null) { + return cachedVertexAdcCredentialsExists; + } + + const gacPath = process.env.GOOGLE_APPLICATION_CREDENTIALS; + cachedVertexAdcCredentialsExists = gacPath + ? existsSync(gacPath) + : existsSync(join(homedir(), ".config", "gcloud", "application_default_credentials.json")); + + return cachedVertexAdcCredentialsExists; +} + +/** + * Node-only env-key lookup for the standalone web host. + * + * This intentionally avoids the browser-safe dynamic-import pattern from the + * shared pi-ai runtime because the packaged Next standalone server turns that + * pattern into a failing "Cannot find module as expression is too dynamic" + * runtime branch. + */ +export function getEnvApiKey(provider: KnownProvider): string | undefined; +export function getEnvApiKey(provider: string): string | undefined; +export function getEnvApiKey(provider: string): string | undefined { + if (provider === "github-copilot") { + return process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN; + } + + if (provider === "anthropic") { + return process.env.ANTHROPIC_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY; + } + + if (provider === "google-vertex") { + const hasCredentials = hasVertexAdcCredentials(); + const hasProject = !!(process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT); + const hasLocation = !!process.env.GOOGLE_CLOUD_LOCATION; + if (hasCredentials && hasProject && hasLocation) { + return ""; + } + } + + if ( + provider === "amazon-bedrock" && + ( + process.env.AWS_PROFILE || + (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) || + process.env.AWS_BEARER_TOKEN_BEDROCK || + process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || + process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI || + process.env.AWS_WEB_IDENTITY_TOKEN_FILE + ) + ) { + return ""; + } + + const envMap: Record = { + openai: "OPENAI_API_KEY", + "azure-openai-responses": "AZURE_OPENAI_API_KEY", + google: "GEMINI_API_KEY", + groq: "GROQ_API_KEY", + cerebras: "CEREBRAS_API_KEY", + xai: "XAI_API_KEY", + openrouter: "OPENROUTER_API_KEY", + "vercel-ai-gateway": "AI_GATEWAY_API_KEY", + zai: "ZAI_API_KEY", + mistral: "MISTRAL_API_KEY", + minimax: "MINIMAX_API_KEY", + "minimax-cn": "MINIMAX_CN_API_KEY", + huggingface: "HF_TOKEN", + opencode: "OPENCODE_API_KEY", + "opencode-go": "OPENCODE_API_KEY", + "kimi-coding": "KIMI_API_KEY", + "alibaba-coding-plan": "ALIBABA_API_KEY", + }; + + const envVar = envMap[provider]; + return envVar ? process.env[envVar] : undefined; +} diff --git a/packages/pi-ai/src/web-runtime-oauth.ts b/packages/pi-ai/src/web-runtime-oauth.ts new file mode 100644 index 000000000..91b7f83f1 --- /dev/null +++ b/packages/pi-ai/src/web-runtime-oauth.ts @@ -0,0 +1,9 @@ +export { + getOAuthProvider, + getOAuthProviders, + type OAuthAuthInfo, + type OAuthCredentials, + type OAuthLoginCallbacks, + type OAuthPrompt, + type OAuthProviderInterface, +} from "./oauth.js"; diff --git a/packages/pi-coding-agent/src/core/agent-session.ts b/packages/pi-coding-agent/src/core/agent-session.ts index 859ab1a7f..03389954f 100644 --- a/packages/pi-coding-agent/src/core/agent-session.ts +++ b/packages/pi-coding-agent/src/core/agent-session.ts @@ -108,8 +108,22 @@ export function parseSkillBlock(text: string): ParsedSkillBlock | null { } /** Session-specific events that extend the core AgentEvent */ +export type SessionStateChangeReason = + | "set_model" + | "set_thinking_level" + | "set_steering_mode" + | "set_follow_up_mode" + | "set_auto_compaction" + | "set_auto_retry" + | "abort_retry" + | "new_session" + | "switch_session" + | "set_session_name" + | "fork"; + export type AgentSessionEvent = | AgentEvent + | { type: "session_state_changed"; reason: SessionStateChangeReason } | { type: "auto_compaction_start"; reason: "threshold" | "overflow" } | { type: "auto_compaction_end"; @@ -356,6 +370,10 @@ export class AgentSession { } } + private _emitSessionStateChanged(reason: SessionStateChangeReason): void { + this._emit({ type: "session_state_changed", reason }); + } + // Track last assistant message for auto-compaction check private _lastAssistantMessage: AssistantMessage | undefined = undefined; @@ -1543,6 +1561,7 @@ export class AgentSession { } // Emit session event to custom tools + this._emitSessionStateChanged("new_session"); return true; } @@ -1583,6 +1602,7 @@ export class AgentSession { } this.setThinkingLevel(thinkingLevel); await this._emitModelSelect(model, previousModel, source); + this._emitSessionStateChanged("set_model"); } /** @@ -1701,6 +1721,7 @@ export class AgentSession { if (this.supportsThinking() || effectiveLevel !== "off") { this.settingsManager.setDefaultThinkingLevel(effectiveLevel); } + this._emitSessionStateChanged("set_thinking_level"); } } @@ -1782,6 +1803,7 @@ export class AgentSession { setSteeringMode(mode: "all" | "one-at-a-time"): void { this.agent.setSteeringMode(mode); this.settingsManager.setSteeringMode(mode); + this._emitSessionStateChanged("set_steering_mode"); } /** @@ -1791,6 +1813,7 @@ export class AgentSession { setFollowUpMode(mode: "all" | "one-at-a-time"): void { this.agent.setFollowUpMode(mode); this.settingsManager.setFollowUpMode(mode); + this._emitSessionStateChanged("set_follow_up_mode"); } // ========================================================================= @@ -1819,6 +1842,7 @@ export class AgentSession { /** Toggle auto-compaction setting */ setAutoCompactionEnabled(enabled: boolean): void { this._compactionOrchestrator.setAutoCompactionEnabled(enabled); + this._emitSessionStateChanged("set_auto_compaction"); } /** Whether auto-compaction is enabled */ @@ -2188,7 +2212,11 @@ export class AgentSession { /** Cancel in-progress retry */ abortRetry(): void { + const hadRetry = this._retryHandler.isRetrying; this._retryHandler.abortRetry(); + if (hadRetry) { + this._emitSessionStateChanged("abort_retry"); + } } /** Whether auto-retry is currently in progress */ @@ -2204,6 +2232,7 @@ export class AgentSession { /** Toggle auto-retry setting */ setAutoRetryEnabled(enabled: boolean): void { this._retryHandler.setAutoRetryEnabled(enabled); + this._emitSessionStateChanged("set_auto_retry"); } // ========================================================================= @@ -2393,6 +2422,7 @@ export class AgentSession { } this._reconnectToAgent(); + this._emitSessionStateChanged("switch_session"); return true; } @@ -2401,6 +2431,7 @@ export class AgentSession { */ setSessionName(name: string): void { this.sessionManager.appendSessionInfo(name); + this._emitSessionStateChanged("set_session_name"); } /** @@ -2464,6 +2495,7 @@ export class AgentSession { this.agent.replaceMessages(sessionContext.messages); } + this._emitSessionStateChanged("fork"); return { selectedText, cancelled: false }; } diff --git a/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts b/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts index f1ec8dd6e..32f10d339 100644 --- a/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts +++ b/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts @@ -18,6 +18,9 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & { showStatus: (message: string) => void; showError: (message: string) => void; updatePendingMessagesDisplay: () => void; + updateTerminalTitle: () => void; + updateEditorBorderColor: () => void; + pendingMessagesContainer: { clear: () => void }; }, event: InteractiveModeEvent): Promise { if (!host.isInitialized) { await host.init(); @@ -26,6 +29,35 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & { host.footer.invalidate(); switch (event.type) { + case "session_state_changed": + switch (event.reason) { + case "new_session": + case "switch_session": + case "fork": + host.streamingComponent = undefined; + host.streamingMessage = undefined; + host.pendingTools.clear(); + host.pendingMessagesContainer.clear(); + host.compactionQueuedMessages = []; + host.rebuildChatFromMessages(); + host.updatePendingMessagesDisplay(); + host.updateTerminalTitle(); + host.updateEditorBorderColor(); + host.ui.requestRender(); + return; + case "set_session_name": + host.updateTerminalTitle(); + host.ui.requestRender(); + return; + case "set_model": + case "set_thinking_level": + host.updateEditorBorderColor(); + host.ui.requestRender(); + return; + default: + host.ui.requestRender(); + return; + } case "agent_start": if (host.retryEscapeHandler) { host.defaultEditor.onEscape = host.retryEscapeHandler; diff --git a/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts b/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts index 9473da995..0bb073044 100644 --- a/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts +++ b/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts @@ -5,11 +5,13 @@ export function setupEditorSubmitHandler(host: InteractiveModeStateHost & { getSlashCommandContext: () => any; handleBashCommand: (command: string, excludeFromContext?: boolean) => Promise; showWarning: (message: string) => void; + showError: (message: string) => void; updateEditorBorderColor: () => void; isExtensionCommand: (text: string) => boolean; queueCompactionMessage: (text: string, mode: "steer" | "followUp") => void; updatePendingMessagesDisplay: () => void; flushPendingBashComponents: () => void; + options?: { submitPromptsDirectly?: boolean }; }): void { host.defaultEditor.onSubmit = async (text: string) => { text = text.trim(); @@ -61,8 +63,24 @@ export function setupEditorSubmitHandler(host: InteractiveModeStateHost & { } host.flushPendingBashComponents(); - host.onInputCallback?.(text); + + if (host.onInputCallback) { + host.onInputCallback(text); + host.editor.addToHistory?.(text); + return; + } + + if (host.options?.submitPromptsDirectly) { + host.editor.addToHistory?.(text); + try { + await host.session.prompt(text); + } catch (error: unknown) { + const errorMessage = error instanceof Error ? error.message : "Unknown error occurred"; + host.showError(errorMessage); + } + return; + } + host.editor.addToHistory?.(text); }; } - diff --git a/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts b/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts index 6795d2064..469e11515 100644 --- a/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts +++ b/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts @@ -29,6 +29,7 @@ import { matchesKey, ProcessTerminal, Spacer, + type Terminal as TuiTerminal, Text, TruncatedText, TUI, @@ -144,6 +145,14 @@ export interface InteractiveModeOptions { initialMessages?: string[]; /** Force verbose startup (overrides quietStartup setting) */ verbose?: boolean; + /** Override the terminal implementation used by the TUI. */ + terminal?: TuiTerminal; + /** When false, reuse the session's existing extension bindings instead of rebinding them for TUI mode. */ + bindExtensions?: boolean; + /** Submit editor prompts directly to AgentSession instead of using the interactive prompt loop. */ + submitPromptsDirectly?: boolean; + /** Control what happens when the user requests shutdown from the TUI. */ + shutdownBehavior?: "exit_process" | "stop_ui" | "ignore"; } export class InteractiveMode { @@ -257,7 +266,7 @@ export class InteractiveMode { ) { this.session = session; this.version = VERSION; - this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor()); + this.ui = new TUI(options.terminal ?? new ProcessTerminal(), this.settingsManager.getShowHardwareCursor()); this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink()); this.headerContainer = new Container(); this.chatContainer = new Container(); @@ -1086,89 +1095,91 @@ export class InteractiveMode { * Initialize the extension system with TUI-based UI context. */ private async initExtensions(): Promise { - const uiContext = this.createExtensionUIContext(); - await this.session.bindExtensions({ - uiContext, - commandContextActions: { - waitForIdle: () => this.session.agent.waitForIdle(), - newSession: async (options) => { - if (this.loadingAnimation) { - this.loadingAnimation.stop(); - this.loadingAnimation = undefined; - } - this.statusContainer.clear(); + if (this.options.bindExtensions !== false) { + const uiContext = this.createExtensionUIContext(); + await this.session.bindExtensions({ + uiContext, + commandContextActions: { + waitForIdle: () => this.session.agent.waitForIdle(), + newSession: async (options) => { + if (this.loadingAnimation) { + this.loadingAnimation.stop(); + this.loadingAnimation = undefined; + } + this.statusContainer.clear(); - // Delegate to AgentSession (handles setup + agent state sync) - const success = await this.session.newSession(options); - if (!success) { - return { cancelled: true }; - } + // Delegate to AgentSession (handles setup + agent state sync) + const success = await this.session.newSession(options); + if (!success) { + return { cancelled: true }; + } - // Clear UI state - this.chatContainer.clear(); - this.pendingMessagesContainer.clear(); - this.compactionQueuedMessages = []; - this.streamingComponent = undefined; - this.streamingMessage = undefined; - this.pendingTools.clear(); + // Clear UI state + this.chatContainer.clear(); + this.pendingMessagesContainer.clear(); + this.compactionQueuedMessages = []; + this.streamingComponent = undefined; + this.streamingMessage = undefined; + this.pendingTools.clear(); - // Render any messages added via setup, or show empty session - this.renderInitialMessages(); - this.ui.requestRender(); + // Render any messages added via setup, or show empty session + this.renderInitialMessages(); + this.ui.requestRender(); - return { cancelled: false }; + return { cancelled: false }; + }, + fork: async (entryId) => { + const result = await this.session.fork(entryId); + if (result.cancelled) { + return { cancelled: true }; + } + + this.chatContainer.clear(); + this.renderInitialMessages(); + this.editor.setText(result.selectedText); + this.showStatus("Forked to new session"); + + return { cancelled: false }; + }, + navigateTree: async (targetId, options) => { + const result = await this.session.navigateTree(targetId, { + summarize: options?.summarize, + customInstructions: options?.customInstructions, + replaceInstructions: options?.replaceInstructions, + label: options?.label, + }); + if (result.cancelled) { + return { cancelled: true }; + } + + this.chatContainer.clear(); + this.renderInitialMessages(); + if (result.editorText && !this.editor.getText().trim()) { + this.editor.setText(result.editorText); + } + this.showStatus("Navigated to selected point"); + + return { cancelled: false }; + }, + switchSession: async (sessionPath) => { + await this.handleResumeSession(sessionPath); + return { cancelled: false }; + }, + reload: async () => { + await this.handleReloadCommand(); + }, }, - fork: async (entryId) => { - const result = await this.session.fork(entryId); - if (result.cancelled) { - return { cancelled: true }; + shutdownHandler: () => { + this.shutdownRequested = true; + if (!this.session.isStreaming) { + void this.shutdown(); } - - this.chatContainer.clear(); - this.renderInitialMessages(); - this.editor.setText(result.selectedText); - this.showStatus("Forked to new session"); - - return { cancelled: false }; }, - navigateTree: async (targetId, options) => { - const result = await this.session.navigateTree(targetId, { - summarize: options?.summarize, - customInstructions: options?.customInstructions, - replaceInstructions: options?.replaceInstructions, - label: options?.label, - }); - if (result.cancelled) { - return { cancelled: true }; - } - - this.chatContainer.clear(); - this.renderInitialMessages(); - if (result.editorText && !this.editor.getText().trim()) { - this.editor.setText(result.editorText); - } - this.showStatus("Navigated to selected point"); - - return { cancelled: false }; + onError: (error) => { + this.showExtensionError(error.extensionPath, error.error, error.stack); }, - switchSession: async (sessionPath) => { - await this.handleResumeSession(sessionPath); - return { cancelled: false }; - }, - reload: async () => { - await this.handleReloadCommand(); - }, - }, - shutdownHandler: () => { - this.shutdownRequested = true; - if (!this.session.isStreaming) { - void this.shutdown(); - } - }, - onError: (error) => { - this.showExtensionError(error.extensionPath, error.error, error.stack); - }, - }); + }); + } setRegisteredThemes(this.session.resourceLoader.getThemes().themes); this.setupAutocomplete(); @@ -1496,6 +1507,10 @@ export class InteractiveMode { return buildExtensionUIContext(this); } + getExtensionUIContext(): ExtensionUIContext { + return this.createExtensionUIContext(); + } + /** * Show a selector for extensions. */ @@ -2262,6 +2277,12 @@ export class InteractiveMode { private isShuttingDown = false; private async shutdown(): Promise { + const shutdownBehavior = this.options.shutdownBehavior ?? "exit_process"; + if (shutdownBehavior === "ignore") { + this.showStatus("Quit is unavailable in the browser-attached terminal"); + return; + } + if (this.isShuttingDown) return; this.isShuttingDown = true; @@ -2285,6 +2306,9 @@ export class InteractiveMode { await this.ui.terminal.drainInput(1000); this.stop(); + if (shutdownBehavior === "stop_ui") { + return; + } process.exit(0); } @@ -3761,6 +3785,11 @@ export class InteractiveMode { return result; } + requestRender(force = false): void { + if (!this.isInitialized) return; + this.ui.requestRender(force); + } + stop(): void { if (this.loadingAnimation) { this.loadingAnimation.stop(); diff --git a/packages/pi-coding-agent/src/modes/rpc/remote-terminal.ts b/packages/pi-coding-agent/src/modes/rpc/remote-terminal.ts new file mode 100644 index 000000000..84f78f950 --- /dev/null +++ b/packages/pi-coding-agent/src/modes/rpc/remote-terminal.ts @@ -0,0 +1,103 @@ +import type { Terminal } from "@gsd/pi-tui"; + +export interface RemoteTerminalOptions { + onWrite: (data: string) => void; + initialColumns?: number; + initialRows?: number; +} + +/** + * Browser-backed terminal transport for the bridge-hosted native TUI. + * It implements the pi-tui Terminal contract but forwards output over the + * RPC bridge instead of writing to process stdout. + */ +export class RemoteTerminal implements Terminal { + private inputHandler?: (data: string) => void; + private resizeHandler?: () => void; + private _columns: number; + private _rows: number; + + constructor(private readonly options: RemoteTerminalOptions) { + this._columns = Math.max(1, options.initialColumns ?? 120); + this._rows = Math.max(1, options.initialRows ?? 30); + } + + start(onInput: (data: string) => void, onResize: () => void): void { + this.inputHandler = onInput; + this.resizeHandler = onResize; + } + + stop(): void { + this.inputHandler = undefined; + this.resizeHandler = undefined; + } + + async drainInput(): Promise { + // Browser transport has no local stdin buffer to drain. + } + + write(data: string): void { + if (!data) return; + this.options.onWrite(data); + } + + get columns(): number { + return this._columns; + } + + get rows(): number { + return this._rows; + } + + get kittyProtocolActive(): boolean { + return false; + } + + pushInput(data: string): void { + if (!data) return; + this.inputHandler?.(data); + } + + resize(columns: number, rows: number): void { + const nextColumns = Math.max(1, Math.floor(columns)); + const nextRows = Math.max(1, Math.floor(rows)); + const changed = nextColumns !== this._columns || nextRows !== this._rows; + this._columns = nextColumns; + this._rows = nextRows; + if (changed) { + this.resizeHandler?.(); + } + } + + moveBy(lines: number): void { + if (lines > 0) { + this.write(`\x1b[${lines}B`); + } else if (lines < 0) { + this.write(`\x1b[${-lines}A`); + } + } + + hideCursor(): void { + this.write("\x1b[?25l"); + } + + showCursor(): void { + this.write("\x1b[?25h"); + } + + clearLine(): void { + this.write("\x1b[K"); + } + + clearFromCursor(): void { + this.write("\x1b[J"); + } + + clearScreen(): void { + this.write("\x1b[2J\x1b[H"); + } + + setTitle(title: string): void { + this.write(`\x1b]0;${title}\x07`); + } +} diff --git a/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts b/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts index 5d076fcd5..e15c81ae3 100644 --- a/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts +++ b/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts @@ -18,9 +18,11 @@ import type { ExtensionUIDialogOptions, ExtensionWidgetOptions, } from "../../core/extensions/index.js"; +import { InteractiveMode } from "../interactive/interactive-mode.js"; import { type Theme, theme } from "../interactive/theme/theme.js"; import { createDefaultCommandContextActions } from "../shared/command-context-actions.js"; import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js"; +import { RemoteTerminal } from "./remote-terminal.js"; import type { RpcCommand, RpcExtensionUIRequest, @@ -72,6 +74,84 @@ export async function runRpcMode(session: AgentSession): Promise { // Shutdown request flag let shutdownRequested = false; + const embeddedTerminalEnabled = process.env.GSD_WEB_BRIDGE_TUI === "1"; + const remoteTerminal = embeddedTerminalEnabled + ? new RemoteTerminal({ + onWrite: (data) => { + output({ type: "terminal_output", data }); + }, + }) + : null; + let embeddedInteractiveMode: InteractiveMode | null = null; + let embeddedInteractiveInitPromise: Promise | null = null; + const startupNotifications: Array<{ message: string; type?: "info" | "warning" | "error" | "success" }> = []; + const statusState = new Map(); + const widgetState = new Map(); + let footerFactory: Parameters[0] | undefined; + let headerFactory: Parameters[0] | undefined; + let workingMessageState: string | undefined; + let titleState: string | undefined; + let editorTextState: string | undefined; + + const withEmbeddedUiContext = async (apply: (ui: ExtensionUIContext) => void | Promise): Promise => { + if (!embeddedInteractiveMode) { + return; + } + await apply(embeddedInteractiveMode.getExtensionUIContext()); + }; + + const replayEmbeddedUiState = async (interactiveMode: InteractiveMode): Promise => { + const ui = interactiveMode.getExtensionUIContext(); + ui.setHeader(headerFactory); + ui.setFooter(footerFactory); + for (const [key, text] of statusState.entries()) { + ui.setStatus(key, text); + } + for (const [key, widget] of widgetState.entries()) { + ui.setWidget(key, widget.content as any, widget.options); + } + ui.setWorkingMessage(workingMessageState); + if (titleState) { + ui.setTitle(titleState); + } + if (editorTextState !== undefined) { + ui.setEditorText(editorTextState); + } + for (const { message, type } of startupNotifications) { + ui.notify(message, type); + } + }; + + const ensureEmbeddedInteractiveMode = async (): Promise => { + if (!embeddedTerminalEnabled || !remoteTerminal) { + throw new Error("Embedded terminal is not enabled for this RPC host"); + } + + if (embeddedInteractiveMode) { + return embeddedInteractiveMode; + } + + if (!embeddedInteractiveInitPromise) { + embeddedInteractiveMode = new InteractiveMode(session, { + terminal: remoteTerminal, + bindExtensions: false, + submitPromptsDirectly: true, + shutdownBehavior: "ignore", + }); + embeddedInteractiveInitPromise = embeddedInteractiveMode.init().then(async () => { + await replayEmbeddedUiState(embeddedInteractiveMode!); + }).catch((error) => { + embeddedInteractiveMode = null; + throw error; + }).finally(() => { + embeddedInteractiveInitPromise = null; + }); + } + + await embeddedInteractiveInitPromise; + return embeddedInteractiveMode!; + }; + /** Helper for dialog methods with signal/timeout support */ function createDialogPromise( opts: ExtensionUIDialogOptions | undefined, @@ -135,6 +215,10 @@ export async function runRpcMode(session: AgentSession): Promise { ), notify(message: string, type?: "info" | "warning" | "error" | "success"): void { + startupNotifications.push({ message, type }); + if (startupNotifications.length > 20) { + startupNotifications.splice(0, startupNotifications.length - 20); + } // Fire and forget - no response needed output({ type: "extension_ui_request", @@ -143,6 +227,9 @@ export async function runRpcMode(session: AgentSession): Promise { message, notifyType: type, } as RpcExtensionUIRequest); + void withEmbeddedUiContext((ui) => { + ui.notify(message, type); + }); }, onTerminalInput(): () => void { @@ -151,6 +238,7 @@ export async function runRpcMode(session: AgentSession): Promise { }, setStatus(key: string, text: string | undefined): void { + statusState.set(key, text); // Fire and forget - no response needed output({ type: "extension_ui_request", @@ -159,13 +247,20 @@ export async function runRpcMode(session: AgentSession): Promise { statusKey: key, statusText: text, } as RpcExtensionUIRequest); + void withEmbeddedUiContext((ui) => { + ui.setStatus(key, text); + }); }, - setWorkingMessage(_message?: string): void { - // Working message not supported in RPC mode - requires TUI loader access + setWorkingMessage(message?: string): void { + workingMessageState = message; + void withEmbeddedUiContext((ui) => { + ui.setWorkingMessage(message); + }); }, setWidget(key: string, content: unknown, options?: ExtensionWidgetOptions): void { + widgetState.set(key, { content, options }); if (content === undefined || Array.isArray(content)) { output({ type: "extension_ui_request", @@ -187,17 +282,27 @@ export async function runRpcMode(session: AgentSession): Promise { widgetPlacement: options?.placement, } as RpcExtensionUIRequest); } + void withEmbeddedUiContext((ui) => { + ui.setWidget(key, content as any, options); + }); }, - setFooter(_factory: unknown): void { - // Custom footer not supported in RPC mode - requires TUI access + setFooter(factory: Parameters[0]): void { + footerFactory = factory; + void withEmbeddedUiContext((ui) => { + ui.setFooter(factory); + }); }, - setHeader(_factory: unknown): void { - // Custom header not supported in RPC mode - requires TUI access + setHeader(factory: Parameters[0]): void { + headerFactory = factory; + void withEmbeddedUiContext((ui) => { + ui.setHeader(factory); + }); }, setTitle(title: string): void { + titleState = title; // Fire and forget - host can implement terminal title control output({ type: "extension_ui_request", @@ -205,6 +310,9 @@ export async function runRpcMode(session: AgentSession): Promise { method: "setTitle", title, } as RpcExtensionUIRequest); + void withEmbeddedUiContext((ui) => { + ui.setTitle(title); + }); }, async custom() { @@ -218,6 +326,7 @@ export async function runRpcMode(session: AgentSession): Promise { }, setEditorText(text: string): void { + editorTextState = text; // Fire and forget - host can implement editor control output({ type: "extension_ui_request", @@ -225,6 +334,9 @@ export async function runRpcMode(session: AgentSession): Promise { method: "set_editor_text", text, } as RpcExtensionUIRequest); + void withEmbeddedUiContext((ui) => { + ui.setEditorText(text); + }); }, getEditorText(): string { @@ -283,8 +395,13 @@ export async function runRpcMode(session: AgentSession): Promise { }, }); - // Set up extensions with RPC-based UI context - await session.bindExtensions({ + // Set up extensions with RPC-based UI context. + // Do not block the initial RPC handshake on extension session_start hooks: + // browser boot only needs get_state, and several startup-only notifications + // (MCP availability, web-search status, etc.) can complete in the background. + // Track readiness so consumers can know when extension commands are available. + let extensionsReady = false; + const extensionsReadyPromise = session.bindExtensions({ uiContext: createExtensionUIContext(), commandContextActions: createDefaultCommandContextActions(session), shutdownHandler: () => { @@ -293,7 +410,18 @@ export async function runRpcMode(session: AgentSession): Promise { onError: (err) => { output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error }); }, + }).then(() => { + extensionsReady = true; + output({ type: "extensions_ready" }); + }).catch((error) => { + extensionsReady = true; // Mark ready even on failure so consumers don't wait forever + output({ + type: "extension_error", + event: "session_start", + error: error instanceof Error ? error.message : String(error), + }); }); + void extensionsReadyPromise; // Output all agent events as JSON session.subscribe((event) => { @@ -360,8 +488,12 @@ export async function runRpcMode(session: AgentSession): Promise { sessionId: session.sessionId, sessionName: session.sessionName, autoCompactionEnabled: session.autoCompactionEnabled, + autoRetryEnabled: session.autoRetryEnabled, + retryInProgress: session.isRetrying, + retryAttempt: session.retryAttempt, messageCount: session.messages.length, pendingMessageCount: session.pendingMessageCount, + extensionsReady, }; return success(id, "get_state", state); } @@ -559,6 +691,24 @@ export async function runRpcMode(session: AgentSession): Promise { return success(id, "get_commands", { commands }); } + case "terminal_input": { + await ensureEmbeddedInteractiveMode(); + remoteTerminal!.pushInput(command.data); + return success(id, "terminal_input"); + } + + case "terminal_resize": { + await ensureEmbeddedInteractiveMode(); + remoteTerminal!.resize(command.cols, command.rows); + return success(id, "terminal_resize"); + } + + case "terminal_redraw": { + const interactiveMode = await ensureEmbeddedInteractiveMode(); + interactiveMode.requestRender(true); + return success(id, "terminal_redraw"); + } + default: { const unknownCommand = command as { type: string }; return error(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`); @@ -580,6 +730,7 @@ export async function runRpcMode(session: AgentSession): Promise { await currentRunner.emit({ type: "session_shutdown" }); } + embeddedInteractiveMode?.stop(); detachInput(); process.stdin.pause(); process.exit(0); diff --git a/packages/pi-coding-agent/src/modes/rpc/rpc-types.ts b/packages/pi-coding-agent/src/modes/rpc/rpc-types.ts index b014640ad..a1b7a7711 100644 --- a/packages/pi-coding-agent/src/modes/rpc/rpc-types.ts +++ b/packages/pi-coding-agent/src/modes/rpc/rpc-types.ts @@ -64,7 +64,12 @@ export type RpcCommand = | { id?: string; type: "get_messages" } // Commands (available for invocation via prompt) - | { id?: string; type: "get_commands" }; + | { id?: string; type: "get_commands" } + + // Bridge-hosted native terminal + | { id?: string; type: "terminal_input"; data: string } + | { id?: string; type: "terminal_resize"; cols: number; rows: number } + | { id?: string; type: "terminal_redraw" }; // ============================================================================ // RPC Slash Command (for get_commands response) @@ -99,8 +104,13 @@ export interface RpcSessionState { sessionId: string; sessionName?: string; autoCompactionEnabled: boolean; + autoRetryEnabled: boolean; + retryInProgress: boolean; + retryAttempt: number; messageCount: number; pendingMessageCount: number; + /** Whether extension loading has completed. Commands from `get_commands` may be incomplete until true. */ + extensionsReady: boolean; } // ============================================================================ @@ -201,6 +211,11 @@ export type RpcResponse = data: { commands: RpcSlashCommand[] }; } + // Bridge-hosted native terminal + | { id?: string; type: "response"; command: "terminal_input"; success: true } + | { id?: string; type: "response"; command: "terminal_resize"; success: true } + | { id?: string; type: "response"; command: "terminal_redraw"; success: true } + // Error response (any command can fail) | { id?: string; type: "response"; command: string; success: false; error: string }; diff --git a/scripts/build-web-if-stale.cjs b/scripts/build-web-if-stale.cjs new file mode 100644 index 000000000..d7d241d03 --- /dev/null +++ b/scripts/build-web-if-stale.cjs @@ -0,0 +1,104 @@ +#!/usr/bin/env node +/** + * Rebuild the Next.js web host only when web source files are newer than the + * staged standalone build. Skips the build when nothing has changed. + * + * Also self-heals a missing/incomplete web dependency install so `npm run gsd:web` + * doesn't fail with bare `next` command-not-found errors. + * + * Exit codes: + * 0 — build was up-to-date or successfully rebuilt + * 1 — build failed + */ + +'use strict' + +const { execSync } = require('node:child_process') +const { existsSync, readdirSync, statSync } = require('node:fs') +const { join, resolve } = require('node:path') + +const root = resolve(__dirname, '..') +const webRoot = join(root, 'web') +// Also watch src/ because api routes import directly from src/web/* and src/resources/* +const srcRoot = join(root, 'src') +const stagedSentinel = join(root, 'dist', 'web', 'standalone', 'server.js') + +// Directories inside web/ that are not source and should be ignored for +// staleness comparison. +const IGNORED_DIRS = new Set(['node_modules', '.next', '.turbo', 'dist', 'out', '.cache']) + +/** + * Walk a directory tree, yield the mtime of every file, skipping ignored dirs. + * Returns the maximum mtime found (ms since epoch), or 0 if nothing found. + */ +function newestMtime(dir) { + let max = 0 + let stack = [dir] + while (stack.length > 0) { + const current = stack.pop() + let entries + try { + entries = readdirSync(current, { withFileTypes: true }) + } catch { + continue + } + for (const entry of entries) { + if (entry.isDirectory()) { + if (!IGNORED_DIRS.has(entry.name)) { + stack.push(join(current, entry.name)) + } + continue + } + try { + const mt = statSync(join(current, entry.name)).mtimeMs + if (mt > max) max = mt + } catch { + // skip unreadable files + } + } + } + return max +} + +function sentinelMtime() { + try { + return statSync(stagedSentinel).mtimeMs + } catch { + return 0 + } +} + +function hasWebBuildDependencies() { + return existsSync(join(webRoot, 'node_modules', '.bin', 'next')) +} + +function ensureWebBuildDependencies() { + if (hasWebBuildDependencies()) { + return + } + + console.log('[gsd] Web build dependencies are missing or incomplete — running npm --prefix web ci...') + execSync('npm --prefix web ci', { cwd: root, stdio: 'inherit' }) +} + +const sourceMtime = Math.max(newestMtime(webRoot), newestMtime(srcRoot)) +const builtMtime = sentinelMtime() + +if (builtMtime > 0 && builtMtime >= sourceMtime) { + console.log('[gsd] Web build is up-to-date, skipping rebuild.') + process.exit(0) +} + +if (builtMtime === 0) { + console.log('[gsd] No staged web build found — building now...') +} else { + console.log('[gsd] Web/src source has changed since last build — rebuilding...') +} + +try { + ensureWebBuildDependencies() + execSync('npm run build:web-host', { cwd: root, stdio: 'inherit' }) +} catch (err) { + console.error('[gsd] Web build failed:', err.message) + process.exit(1) +} diff --git a/scripts/dev-cli.js b/scripts/dev-cli.js new file mode 100644 index 000000000..fd4ec0a0c --- /dev/null +++ b/scripts/dev-cli.js @@ -0,0 +1,33 @@ +#!/usr/bin/env node + +import { spawn } from 'node:child_process' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' + +const __dirname = dirname(fileURLToPath(import.meta.url)) +const root = resolve(__dirname, '..') +const srcLoaderPath = resolve(root, 'src', 'loader.ts') +const resolveTsPath = resolve(root, 'src', 'resources', 'extensions', 'gsd', 'tests', 'resolve-ts.mjs') + +const child = spawn( + process.execPath, + ['--import', resolveTsPath, '--experimental-strip-types', srcLoaderPath, ...process.argv.slice(2)], + { + cwd: process.cwd(), + stdio: 'inherit', + env: process.env, + }, +) + +child.on('error', (error) => { + console.error(`[gsd] Failed to launch local dev CLI: ${error instanceof Error ? error.message : String(error)}`) + process.exit(1) +}) + +child.on('exit', (code, signal) => { + if (signal) { + process.kill(process.pid, signal) + return + } + process.exit(code ?? 0) +}) diff --git a/scripts/stage-web-standalone.cjs b/scripts/stage-web-standalone.cjs new file mode 100644 index 000000000..85800473b --- /dev/null +++ b/scripts/stage-web-standalone.cjs @@ -0,0 +1,73 @@ +#!/usr/bin/env node + +const { cpSync, existsSync, mkdirSync, readdirSync, rmSync } = require('node:fs') +const { join, resolve } = require('node:path') + +const root = resolve(__dirname, '..') +const webRoot = join(root, 'web') +const standaloneRoot = join(webRoot, '.next', 'standalone') +const standaloneAppRoot = join(standaloneRoot, 'web') +const standaloneNodeModulesRoot = join(standaloneRoot, 'node_modules') +const staticRoot = join(webRoot, '.next', 'static') +const publicRoot = join(webRoot, 'public') +const distWebRoot = join(root, 'dist', 'web') +const distStandaloneRoot = join(distWebRoot, 'standalone') +const sourceNodePtyRoot = join(webRoot, 'node_modules', 'node-pty') + +const COPY_OPTIONS = { + recursive: true, + force: true, + dereference: true, +} + +function overlayNodePty(targetRoot) { + if (!existsSync(sourceNodePtyRoot)) return [] + + const hydrated = [] + const directTarget = join(targetRoot, 'node_modules', 'node-pty') + mkdirSync(join(targetRoot, 'node_modules'), { recursive: true }) + cpSync(sourceNodePtyRoot, directTarget, COPY_OPTIONS) + hydrated.push(directTarget) + + const hashedNodeModulesRoot = join(targetRoot, '.next', 'node_modules') + if (!existsSync(hashedNodeModulesRoot)) return hydrated + + for (const entry of readdirSync(hashedNodeModulesRoot, { withFileTypes: true })) { + if (!entry.isDirectory() || !entry.name.startsWith('node-pty-')) continue + const target = join(hashedNodeModulesRoot, entry.name) + cpSync(sourceNodePtyRoot, target, COPY_OPTIONS) + hydrated.push(target) + } + + return hydrated +} + +if (!existsSync(standaloneAppRoot)) { + console.error('[gsd] Web standalone build not found at web/.next/standalone/web. Run `npm --prefix web run build` first.') + process.exit(1) +} + +rmSync(distWebRoot, { recursive: true, force: true }) +mkdirSync(distStandaloneRoot, { recursive: true }) + +cpSync(standaloneAppRoot, distStandaloneRoot, COPY_OPTIONS) + +if (existsSync(standaloneNodeModulesRoot)) { + cpSync(standaloneNodeModulesRoot, join(distStandaloneRoot, 'node_modules'), COPY_OPTIONS) +} + +if (existsSync(staticRoot)) { + mkdirSync(join(distStandaloneRoot, '.next'), { recursive: true }) + cpSync(staticRoot, join(distStandaloneRoot, '.next', 'static'), COPY_OPTIONS) +} + +if (existsSync(publicRoot)) { + cpSync(publicRoot, join(distStandaloneRoot, 'public'), COPY_OPTIONS) +} + +const hydratedTargets = overlayNodePty(distStandaloneRoot) + +console.log(`[gsd] Staged web standalone host at ${distStandaloneRoot}`) +if (hydratedTargets.length > 0) { + console.log(`[gsd] Hydrated node-pty native assets in ${hydratedTargets.length} location(s).`) +} diff --git a/scripts/validate-pack.js b/scripts/validate-pack.js index d89fb9f34..3ecd195ca 100644 --- a/scripts/validate-pack.js +++ b/scripts/validate-pack.js @@ -66,6 +66,7 @@ try { 'dist/loader.js', 'packages/pi-coding-agent/dist/index.js', 'scripts/link-workspace-packages.cjs', + 'dist/web/standalone/server.js', ]; let missing = false; diff --git a/src/app-paths.js b/src/app-paths.js new file mode 100644 index 000000000..22be2b89d --- /dev/null +++ b/src/app-paths.js @@ -0,0 +1,8 @@ +import { homedir } from 'os' +import { join } from 'path' + +export const appRoot = join(homedir(), '.gsd') +export const agentDir = join(appRoot, 'agent') +export const sessionsDir = join(appRoot, 'sessions') +export const authFilePath = join(agentDir, 'auth.json') +export const webPidFilePath = join(appRoot, 'web-server.pid') diff --git a/src/app-paths.ts b/src/app-paths.ts index d6e171d99..49760897c 100644 --- a/src/app-paths.ts +++ b/src/app-paths.ts @@ -5,3 +5,5 @@ export const appRoot = process.env.GSD_HOME || join(homedir(), '.gsd') export const agentDir = join(appRoot, 'agent') export const sessionsDir = join(appRoot, 'sessions') export const authFilePath = join(agentDir, 'auth.json') +export const webPidFilePath = join(appRoot, 'web-server.pid') +export const webPreferencesPath = join(appRoot, 'web-preferences.json') diff --git a/src/cli-web-branch.ts b/src/cli-web-branch.ts new file mode 100644 index 000000000..b0c9cc979 --- /dev/null +++ b/src/cli-web-branch.ts @@ -0,0 +1,286 @@ +import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync } from 'node:fs' +import { join, resolve, sep } from 'node:path' +import { agentDir as defaultAgentDir, sessionsDir as defaultSessionsDir, webPreferencesPath as defaultWebPreferencesPath } from './app-paths.js' +import { getProjectSessionsDir } from './project-sessions.js' +import { launchWebMode, stopWebMode, type WebModeLaunchStatus, type WebModeStopOptions, type WebModeStopResult } from './web-mode.js' + +export interface CliFlags { + mode?: 'text' | 'json' | 'rpc' + print?: boolean + continue?: boolean + noSession?: boolean + model?: string + listModels?: string | true + extensions: string[] + appendSystemPrompt?: string + tools?: string[] + messages: string[] + web?: boolean + /** Optional project path for web mode: `gsd --web ` or `gsd web start ` */ + webPath?: string + help?: boolean + version?: boolean +} + +type WritableLike = Pick + +export interface RunWebCliBranchDeps { + runWebMode?: typeof launchWebMode + stopWebMode?: (deps: Parameters[0], options?: WebModeStopOptions) => WebModeStopResult + cwd?: () => string + stderr?: WritableLike + baseSessionsDir?: string + agentDir?: string + webPreferencesPath?: string +} + +export function parseCliArgs(argv: string[]): CliFlags { + const flags: CliFlags = { extensions: [], messages: [] } + const args = argv.slice(2) + for (let i = 0; i < args.length; i++) { + const arg = args[i] + if (arg === '--mode' && i + 1 < args.length) { + const mode = args[++i] + if (mode === 'text' || mode === 'json' || mode === 'rpc') flags.mode = mode + } else if (arg === '--print' || arg === '-p') { + flags.print = true + } else if (arg === '--continue' || arg === '-c') { + flags.continue = true + } else if (arg === '--no-session') { + flags.noSession = true + } else if (arg === '--web') { + flags.web = true + // Peek at next arg — if it looks like a path (not another flag), capture it + if (i + 1 < args.length && !args[i + 1].startsWith('-')) { + flags.webPath = args[++i] + } + } else if (arg === '--model' && i + 1 < args.length) { + flags.model = args[++i] + } else if (arg === '--extension' && i + 1 < args.length) { + flags.extensions.push(args[++i]) + } else if (arg === '--append-system-prompt' && i + 1 < args.length) { + flags.appendSystemPrompt = args[++i] + } else if (arg === '--tools' && i + 1 < args.length) { + flags.tools = args[++i].split(',') + } else if (arg === '--list-models') { + flags.listModels = (i + 1 < args.length && !args[i + 1].startsWith('-')) ? args[++i] : true + } else if (arg === '--version' || arg === '-v') { + flags.version = true + } else if (arg === '--help' || arg === '-h') { + flags.help = true + } else if (!arg.startsWith('--') && !arg.startsWith('-')) { + flags.messages.push(arg) + } + } + return flags +} + +export { getProjectSessionsDir } from './project-sessions.js' + +export function migrateLegacyFlatSessions(baseSessionsDir: string, projectSessionsDir: string): void { + if (!existsSync(baseSessionsDir)) return + + try { + const entries = readdirSync(baseSessionsDir) + const flatJsonl = entries.filter((file) => file.endsWith('.jsonl')) + if (flatJsonl.length === 0) return + + mkdirSync(projectSessionsDir, { recursive: true }) + for (const file of flatJsonl) { + const src = join(baseSessionsDir, file) + const dst = join(projectSessionsDir, file) + if (!existsSync(dst)) { + renameSync(src, dst) + } + } + } catch { + // Non-fatal — don't block startup if migration fails + } +} + +function emitWebModeFailure(stderr: WritableLike, status: WebModeLaunchStatus): void { + if (status.ok) return + stderr.write(`[gsd] Web mode launch failed: ${status.failureReason}\n`) +} + +/** + * Resolve the working directory for context-aware launch detection. + * + * If the user has configured a dev root via onboarding and their cwd is inside + * a project under that dev root, return the one-level-deep project directory. + * Otherwise, return the cwd unchanged (browser picker handles selection). + * + * Edge cases handled: + * - Missing or unreadable prefs file → cwd unchanged + * - No devRoot field in prefs → cwd unchanged + * - devRoot path doesn't exist (stale) → cwd unchanged + * - cwd IS the devRoot → cwd unchanged (picker selects) + * - cwd outside devRoot → cwd unchanged + */ +export function resolveContextAwareCwd(currentCwd: string, prefsPath: string): string { + // 1. Read preferences file + let prefs: Record + try { + const raw = readFileSync(prefsPath, 'utf-8') + prefs = JSON.parse(raw) + } catch { + return currentCwd + } + + // 2. Extract devRoot + const devRoot = prefs.devRoot + if (typeof devRoot !== 'string' || !devRoot) { + return currentCwd + } + + // 3. Resolve both paths to absolute + const resolvedCwd = resolve(currentCwd) + const resolvedDevRoot = resolve(devRoot) + + // 4. Check devRoot still exists + if (!existsSync(resolvedDevRoot)) { + return currentCwd + } + + // 5. If cwd IS the devRoot → unchanged (picker handles selection) + if (resolvedCwd === resolvedDevRoot) { + return currentCwd + } + + // 6. If cwd is inside devRoot, extract one-level-deep project directory + const prefix = resolvedDevRoot + sep + if (resolvedCwd.startsWith(prefix)) { + const relative = resolvedCwd.slice(prefix.length) + const firstSegment = relative.split(sep)[0] + if (firstSegment) { + return join(resolvedDevRoot, firstSegment) + } + } + + // 7. cwd outside devRoot → unchanged + return currentCwd +} + +export type RunWebCliBranchResult = + | { handled: false } + | { + handled: true + exitCode: number + action: 'start' + status: WebModeLaunchStatus + launchInputs: { cwd: string; projectSessionsDir: string; agentDir: string } + } + | { + handled: true + exitCode: number + action: 'stop' + stopResult: WebModeStopResult + } + +export async function runWebCliBranch( + flags: CliFlags, + deps: RunWebCliBranchDeps = {}, +): Promise { + // Handle `gsd web stop [path|--all]` subcommand + if (flags.messages[0] === 'web' && flags.messages[1] === 'stop') { + const stderr = deps.stderr ?? process.stderr + const stopArg = flags.messages[2] + const isAll = stopArg === 'all' + const stopCwd = stopArg && !isAll ? resolve((deps.cwd ?? (() => process.cwd()))(), stopArg) : undefined + const stopResult = (deps.stopWebMode ?? stopWebMode)({ stderr }, { + projectCwd: stopCwd, + all: isAll, + }) + return { + handled: true, + exitCode: stopResult.ok ? 0 : 1, + action: 'stop', + stopResult, + } + } + + // `gsd web [start] [path]` is an alias for `gsd --web [path]` + // Matches: `gsd web`, `gsd web start`, `gsd web start `, `gsd web ` + const isWebSubcommand = flags.messages[0] === 'web' && flags.messages[1] !== 'stop' + if (!flags.web && !isWebSubcommand) { + return { handled: false } + } + + const stderr = deps.stderr ?? process.stderr + const defaultCwd = (deps.cwd ?? (() => process.cwd()))() + + // Resolve project path from multiple forms: + // gsd --web → flags.webPath + // gsd web start → messages[2] + // gsd web → messages[1] (when not "start") + let webPath = flags.webPath + if (!webPath && isWebSubcommand) { + if (flags.messages[1] === 'start') { + webPath = flags.messages[2] + } else if (flags.messages[1]) { + webPath = flags.messages[1] + } + } + + let currentCwd: string + if (webPath) { + currentCwd = resolve(defaultCwd, webPath) + const checkExists = existsSync + if (!checkExists(currentCwd)) { + stderr.write(`[gsd] Project path does not exist: ${currentCwd}\n`) + return { + handled: true, + exitCode: 1, + action: 'start', + status: { + mode: 'web', + ok: false, + cwd: currentCwd, + projectSessionsDir: '', + host: '127.0.0.1', + port: null, + url: null, + hostKind: 'unresolved', + hostPath: null, + hostRoot: null, + failureReason: `project path does not exist: ${currentCwd}`, + }, + launchInputs: { cwd: currentCwd, projectSessionsDir: '', agentDir: deps.agentDir ?? defaultAgentDir }, + } + } + stderr.write(`[gsd] Using project path: ${currentCwd}\n`) + } else { + currentCwd = defaultCwd + } + + // Context-aware launch: if cwd is inside a project under the configured dev root, + // resolve to the project directory so the browser opens directly into it + currentCwd = resolveContextAwareCwd(currentCwd, deps.webPreferencesPath ?? defaultWebPreferencesPath) + + const baseSessionsDir = deps.baseSessionsDir ?? defaultSessionsDir + const agentDir = deps.agentDir ?? defaultAgentDir + const projectSessionsDir = getProjectSessionsDir(currentCwd, baseSessionsDir) + + migrateLegacyFlatSessions(baseSessionsDir, projectSessionsDir) + const status = await (deps.runWebMode ?? launchWebMode)({ + cwd: currentCwd, + projectSessionsDir, + agentDir, + }) + + if (!status.ok) { + emitWebModeFailure(stderr, status) + } + + return { + handled: true, + exitCode: status.ok ? 0 : 1, + action: 'start', + status, + launchInputs: { + cwd: currentCwd, + projectSessionsDir, + agentDir, + }, + } +} diff --git a/src/cli.ts b/src/cli.ts index 32b19a43f..91c51dec8 100644 --- a/src/cli.ts +++ b/src/cli.ts @@ -9,7 +9,7 @@ import { runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent' -import { existsSync, readdirSync, renameSync, readFileSync } from 'node:fs' +import { readFileSync } from 'node:fs' import { join } from 'node:path' import { agentDir, sessionsDir, authFilePath } from './app-paths.js' import { initResources, buildResourceLoader, getNewerManagedResourceVersion } from './resource-loader.js' @@ -20,6 +20,13 @@ import { shouldRunOnboarding, runOnboarding } from './onboarding.js' import chalk from 'chalk' import { checkForUpdates } from './update-check.js' import { printHelp, printSubcommandHelp } from './help-text.js' +import { + parseCliArgs as parseWebCliArgs, + runWebCliBranch, + migrateLegacyFlatSessions, +} from './cli-web-branch.js' +import { stopWebMode } from './web-mode.js' +import { getProjectSessionsDir } from './project-sessions.js' import { markStartup, printStartupTimings } from './startup-timings.js' // --------------------------------------------------------------------------- @@ -37,6 +44,9 @@ interface CliFlags { appendSystemPrompt?: string tools?: string[] messages: string[] + web?: boolean + webPath?: string + /** Set by `gsd sessions` when the user picks a specific session to resume */ _selectedSessionPath?: string } @@ -93,6 +103,12 @@ function parseCliArgs(argv: string[]): CliFlags { } else if (arg === '--help' || arg === '-h') { printHelp(process.env.GSD_VERSION || '0.0.0') process.exit(0) + } else if (arg === '--web') { + flags.web = true + // Capture optional project path after --web (not a flag) + if (i + 1 < args.length && !args[i + 1].startsWith('-')) { + flags.webPath = args[++i] + } } else if (!arg.startsWith('--') && !arg.startsWith('-')) { flags.messages.push(arg) } @@ -110,7 +126,7 @@ exitIfManagedResourcesAreNewer(agentDir) // Early TTY check — must come before heavy initialization to avoid dangling // handles that prevent process.exit() from completing promptly. const hasSubcommand = cliFlags.messages.length > 0 -if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels) { +if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) { process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n') process.stderr.write('[gsd] Non-interactive alternatives:\n') process.stderr.write('[gsd] gsd --print "your message" Single-shot prompt\n') @@ -143,6 +159,34 @@ if (cliFlags.messages[0] === 'update') { process.exit(0) } +// `gsd web stop [path|all]` — stop web server before anything else +if (cliFlags.messages[0] === 'web' && cliFlags.messages[1] === 'stop') { + const webFlags = parseWebCliArgs(process.argv) + const webBranch = await runWebCliBranch(webFlags, { + stopWebMode, + stderr: process.stderr, + baseSessionsDir: sessionsDir, + agentDir, + }) + if (webBranch.handled) { + process.exit(webBranch.exitCode) + } +} + +// `gsd --web [path]` or `gsd web [start] [path]` — launch browser-only web mode +if (cliFlags.web || (cliFlags.messages[0] === 'web' && cliFlags.messages[1] !== 'stop')) { + const webFlags = parseWebCliArgs(process.argv) + const webBranch = await runWebCliBranch(webFlags, { + stderr: process.stderr, + baseSessionsDir: sessionsDir, + agentDir, + }) + if (webBranch.handled) { + process.exit(webBranch.exitCode) + } +} + + // `gsd sessions` — list past sessions and pick one to resume if (cliFlags.messages[0] === 'sessions') { const cwd = process.cwd() @@ -478,31 +522,12 @@ if (!cliFlags.worktree && !isPrintMode) { // Per-directory session storage — same encoding as the upstream SDK so that // /resume only shows sessions from the current working directory. const cwd = process.cwd() -const safePath = `--${cwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--` -const projectSessionsDir = join(sessionsDir, safePath) +const projectSessionsDir = getProjectSessionsDir(cwd) // Migrate legacy flat sessions: before per-directory scoping, all .jsonl session // files lived directly in ~/.gsd/sessions/. Move them into the correct per-cwd // subdirectory so /resume can find them. -if (existsSync(sessionsDir)) { - try { - const entries = readdirSync(sessionsDir) - const flatJsonl = entries.filter(f => f.endsWith('.jsonl')) - if (flatJsonl.length > 0) { - const { mkdirSync } = await import('node:fs') - mkdirSync(projectSessionsDir, { recursive: true }) - for (const file of flatJsonl) { - const src = join(sessionsDir, file) - const dst = join(projectSessionsDir, file) - if (!existsSync(dst)) { - renameSync(src, dst) - } - } - } - } catch { - // Non-fatal — don't block startup if migration fails - } -} +migrateLegacyFlatSessions(sessionsDir, projectSessionsDir) const sessionManager = cliFlags._selectedSessionPath ? SessionManager.open(cliFlags._selectedSessionPath, projectSessionsDir) @@ -577,6 +602,17 @@ if (enabledModelPatterns && enabledModelPatterns.length > 0) { } } +if (!process.stdin.isTTY) { + process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n') + process.stderr.write('[gsd] Non-interactive alternatives:\n') + process.stderr.write('[gsd] gsd --print "your message" Single-shot prompt\n') + process.stderr.write('[gsd] gsd --web [path] Browser-only web mode\n') + process.stderr.write('[gsd] gsd --mode rpc JSON-RPC over stdin/stdout\n') + process.stderr.write('[gsd] gsd --mode mcp MCP server over stdin/stdout\n') + process.stderr.write('[gsd] gsd --mode text "message" Text output mode\n') + process.exit(1) +} + // Welcome screen — shown on every fresh interactive session before TUI takes over { const { printWelcomeScreen } = await import('./welcome-screen.js') diff --git a/src/project-sessions.ts b/src/project-sessions.ts new file mode 100644 index 000000000..1674c8e31 --- /dev/null +++ b/src/project-sessions.ts @@ -0,0 +1,8 @@ +import { join } from "node:path" + +import { sessionsDir as defaultSessionsDir } from "./app-paths.js" + +export function getProjectSessionsDir(cwd: string, baseSessionsDir = defaultSessionsDir): string { + const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--` + return join(baseSessionsDir, safePath) +} diff --git a/src/resource-loader.ts b/src/resource-loader.ts index 97327d50c..0571ac272 100644 --- a/src/resource-loader.ts +++ b/src/resource-loader.ts @@ -386,6 +386,8 @@ export function initResources(agentDir: string): void { } } + // Sync bundled resources — overwrite so updates land on next launch. + syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions')) syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents')) syncResourceDir(join(resourcesDir, 'skills'), join(agentDir, 'skills')) diff --git a/src/resources/extensions/gsd/auto-dispatch.ts b/src/resources/extensions/gsd/auto-dispatch.ts index 36df025a7..986c295db 100644 --- a/src/resources/extensions/gsd/auto-dispatch.ts +++ b/src/resources/extensions/gsd/auto-dispatch.ts @@ -160,6 +160,35 @@ const DISPATCH_RULES: DispatchRule[] = [ }; }, }, + { + name: "uat-verdict-gate (non-PASS blocks progression)", + match: async ({ mid, basePath, prefs }) => { + // Only applies when UAT dispatch is enabled + if (!prefs?.uat_dispatch) return null; + + const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP"); + const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null; + if (!roadmapContent) return null; + + const roadmap = parseRoadmap(roadmapContent); + for (const slice of roadmap.slices.filter(s => s.done)) { + const resultFile = resolveSliceFile(basePath, mid, slice.id, "UAT-RESULT"); + if (!resultFile) continue; + const content = await loadFile(resultFile); + if (!content) continue; + const verdictMatch = content.match(/verdict:\s*([\w-]+)/i); + const verdict = verdictMatch?.[1]?.toLowerCase(); + if (verdict && verdict !== "pass" && verdict !== "passed") { + return { + action: "stop" as const, + reason: `UAT verdict for ${slice.id} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`, + level: "warning" as const, + }; + } + } + return null; + }, + }, { name: "reassess-roadmap (post-completion)", match: async ({ state, mid, midTitle, basePath, prefs }) => { diff --git a/src/resources/extensions/gsd/commands/context.ts b/src/resources/extensions/gsd/commands/context.ts index c098b285d..07f237592 100644 --- a/src/resources/extensions/gsd/commands/context.ts +++ b/src/resources/extensions/gsd/commands/context.ts @@ -35,6 +35,18 @@ export async function guardRemoteSession( const unitLabel = remote.unitType && remote.unitId ? `${remote.unitType} (${remote.unitId})` : "unknown unit"; + + // In RPC/web bridge mode, interactive TUI prompts (showNextAction) block + // forever because there is no terminal to answer them. Notify and bail. + if (process.env.GSD_WEB_BRIDGE_TUI === "1") { + ctx.ui.notify( + `Another auto-mode session (PID ${remote.pid}) is running on this project (${unitLabel}). ` + + `Stop it first with /gsd stop, or use /gsd steer to redirect it.`, + "warning", + ); + return false; + } + const unitsMsg = remote.completedUnits != null ? `${remote.completedUnits} units completed` : ""; diff --git a/src/resources/extensions/gsd/forensics.ts b/src/resources/extensions/gsd/forensics.ts index 2dcda6549..a239c87c8 100644 --- a/src/resources/extensions/gsd/forensics.ts +++ b/src/resources/extensions/gsd/forensics.ts @@ -123,7 +123,7 @@ export async function handleForensics( // ─── Report Builder ─────────────────────────────────────────────────────────── -async function buildForensicReport(basePath: string): Promise { +export async function buildForensicReport(basePath: string): Promise { const anomalies: ForensicAnomaly[] = []; // 1. Derive current state diff --git a/src/resources/extensions/gsd/git-service.ts b/src/resources/extensions/gsd/git-service.ts index 4fd0d4218..10900a138 100644 --- a/src/resources/extensions/gsd/git-service.ts +++ b/src/resources/extensions/gsd/git-service.ts @@ -15,6 +15,7 @@ import { gsdRoot } from "./paths.js"; import { GIT_NO_PROMPT_ENV } from "./git-constants.js"; import { loadEffectiveGSDPreferences } from "./preferences.js"; + import { detectWorktreeName, SLICE_BRANCH_RE, diff --git a/src/resources/extensions/gsd/milestone-id-utils.ts b/src/resources/extensions/gsd/milestone-id-utils.ts new file mode 100644 index 000000000..c2d4e2c0d --- /dev/null +++ b/src/resources/extensions/gsd/milestone-id-utils.ts @@ -0,0 +1,32 @@ +import { readdirSync } from "node:fs"; + +import { milestonesDir } from "./paths.js"; + +/** Matches both classic `M001` and unique `M001-abc123` formats (anchored). */ +export const MILESTONE_ID_RE = /^M\d{3}(?:-[a-z0-9]{6})?$/; + +/** Extract the trailing sequential number from a milestone ID. Returns 0 for non-matches. */ +export function extractMilestoneSeq(id: string): number { + const match = id.match(/^M(\d{3})(?:-[a-z0-9]{6})?$/); + return match ? parseInt(match[1], 10) : 0; +} + +/** Comparator for sorting milestone IDs by sequential number. */ +export function milestoneIdSort(a: string, b: string): number { + return extractMilestoneSeq(a) - extractMilestoneSeq(b); +} + +export function findMilestoneIds(basePath: string): string[] { + const dir = milestonesDir(basePath); + try { + return readdirSync(dir, { withFileTypes: true }) + .filter((entry) => entry.isDirectory()) + .map((entry) => { + const match = entry.name.match(/^(M\d+(?:-[a-z0-9]{6})?)/); + return match ? match[1] : entry.name; + }) + .sort(milestoneIdSort); + } catch { + return []; + } +} diff --git a/src/resources/extensions/gsd/preferences-types.ts b/src/resources/extensions/gsd/preferences-types.ts index e14ca4a03..d1c81f250 100644 --- a/src/resources/extensions/gsd/preferences-types.ts +++ b/src/resources/extensions/gsd/preferences-types.ts @@ -98,6 +98,7 @@ export const KNOWN_UNIT_TYPES = [ ] as const; export type UnitType = (typeof KNOWN_UNIT_TYPES)[number]; + export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]); export interface GSDSkillRule { diff --git a/src/resources/extensions/gsd/preferences-validation.ts b/src/resources/extensions/gsd/preferences-validation.ts index ac3ac95d8..d19468a68 100644 --- a/src/resources/extensions/gsd/preferences-validation.ts +++ b/src/resources/extensions/gsd/preferences-validation.ts @@ -15,6 +15,7 @@ import { normalizeStringArray } from "../shared/format-utils.js"; import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_TYPES, + SKILL_ACTIONS, type WorkflowMode, type GSDPreferences, diff --git a/src/resources/extensions/gsd/tests/dist-redirect.mjs b/src/resources/extensions/gsd/tests/dist-redirect.mjs index 56e7d50c2..6188d54a4 100644 --- a/src/resources/extensions/gsd/tests/dist-redirect.mjs +++ b/src/resources/extensions/gsd/tests/dist-redirect.mjs @@ -1,3 +1,9 @@ +import { existsSync, readFileSync } from 'node:fs'; +import { createRequire } from 'node:module'; +import { fileURLToPath } from 'node:url'; + +const require = createRequire(import.meta.url); + const ROOT = new URL("../../../../../", import.meta.url); export function resolve(specifier, context, nextResolve) { @@ -14,6 +20,8 @@ export function resolve(specifier, context, nextResolve) { specifier = new URL("packages/pi-tui/dist/index.js", ROOT).href; } // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types + // Also handles local imports — skip rewrite for dist/ paths that are real compiled artifacts. + else if (specifier.endsWith('.js') && (specifier.startsWith('./') || specifier.startsWith('../'))) { if (context.parentURL && context.parentURL.includes('/src/')) { if (specifier.includes('/dist/')) { @@ -23,6 +31,44 @@ export function resolve(specifier, context, nextResolve) { } } } + // 3. Extensionless relative imports from web/ (Next.js convention). + // Transpiled .tsx files emit extensionless imports — try .ts then .tsx. + else if ( + (specifier.startsWith('./') || specifier.startsWith('../')) && + !specifier.match(/\.\w+$/) && + context.parentURL && + context.parentURL.includes('/web/') + ) { + const baseUrl = new URL(specifier, context.parentURL); + for (const ext of ['.ts', '.tsx']) { + const candidate = fileURLToPath(baseUrl) + ext; + if (existsSync(candidate)) { + specifier = baseUrl.href + ext; + break; + } + + } + } return nextResolve(specifier, context); } + +export function load(url, context, nextLoad) { + // Node's --experimental-strip-types handles .ts but not .tsx (which may contain JSX). + // Use TypeScript to transpile .tsx → JS with react-jsx transform, then serve as module. + if (url.endsWith('.tsx')) { + const ts = require('typescript'); + const source = readFileSync(fileURLToPath(url), 'utf-8'); + const { outputText } = ts.transpileModule(source, { + fileName: fileURLToPath(url), + compilerOptions: { + jsx: ts.JsxEmit.ReactJSX, + module: ts.ModuleKind.ESNext, + target: ts.ScriptTarget.ESNext, + esModuleInterop: true, + }, + }); + return { format: 'module', source: outputText, shortCircuit: true }; + } + return nextLoad(url, context); +} diff --git a/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts b/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts index d4ba9ede6..36c9370a3 100644 --- a/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts +++ b/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts @@ -122,6 +122,7 @@ function mockData(overrides: Partial = {}): VisualizerData { providers: [], skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null }, environmentIssues: [], + }, discussion: [], stats: { missingCount: 0, missingSlices: [], updatedCount: 0, updatedSlices: [], recentEntries: [] }, diff --git a/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts b/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts new file mode 100644 index 000000000..6abb0e8e6 --- /dev/null +++ b/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts @@ -0,0 +1,53 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs"; +import { join } from "node:path"; +import { tmpdir } from "node:os"; + +const { deriveState } = await import("../state.js"); + +test("deriveState reports complete when all milestone slices are done", async () => { + const base = mkdtempSync(join(tmpdir(), "gsd-smart-entry-complete-")); + + try { + const milestoneDir = join(base, ".gsd", "milestones", "M001"); + mkdirSync(milestoneDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + [ + "# M001: Complete Milestone", + "", + "## Slices", + "- [x] **S01: Done slice** `risk:low` `depends:[]`", + " > Done.", + ].join("\n"), + ); + + writeFileSync( + join(milestoneDir, "M001-SUMMARY.md"), + "# M001 Summary\n\nComplete.", + ); + + const state = await deriveState(base); + assert.equal(state.phase, "complete"); + assert.equal(state.activeMilestone?.id, "M001"); + } finally { + rmSync(base, { recursive: true, force: true }); + } +}); + +test("guided-flow complete branch offers a chooser for next milestone or status", () => { + const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8"); + const branchIdx = guidedFlowSource.indexOf('state.phase === "complete"'); + + assert.ok(branchIdx > -1, "guided-flow.ts should have a complete-phase smart-entry branch"); + + const nextBranchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"', branchIdx); + const branchChunk = guidedFlowSource.slice(branchIdx, nextBranchIdx === -1 ? branchIdx + 1600 : nextBranchIdx); + + assert.match(branchChunk, /showNextAction\(/, "complete branch should present a chooser"); + assert.match(branchChunk, /findMilestoneIds\(basePath\)/, "complete branch should compute the next milestone id"); + assert.match(branchChunk, /nextMilestoneId(?:Reserved)?\(milestoneIds, uniqueMilestoneIds\)/, "complete branch should derive the next milestone id"); + assert.match(branchChunk, /dispatchWorkflow\(pi, buildDiscussPrompt\(/, "complete branch should dispatch the discuss prompt"); +}); diff --git a/src/resources/extensions/gsd/tests/stop-auto-remote.test.ts b/src/resources/extensions/gsd/tests/stop-auto-remote.test.ts index e10b9020c..082827e0c 100644 --- a/src/resources/extensions/gsd/tests/stop-auto-remote.test.ts +++ b/src/resources/extensions/gsd/tests/stop-auto-remote.test.ts @@ -25,7 +25,7 @@ function cleanup(base: string): void { try { rmSync(base, { recursive: true, force: true }); } catch { /* */ } } -function waitForChildExit(child: ChildProcess, timeoutMs = 5000): Promise { +function waitForChildExit(child: ChildProcess, timeoutMs = 10000): Promise { return new Promise((resolve) => { if (child.exitCode !== null) { resolve(child.exitCode); @@ -80,7 +80,10 @@ test("stopAutoRemote cleans up stale lock (dead PID) and returns found:false", ( } }); -test("stopAutoRemote sends SIGTERM to a live process and returns found:true", async () => { +// KNOWN FLAKE: This test is timing-sensitive — it spawns a child, writes a lock file, +// sends SIGTERM, and asserts the child exited. Under heavy CI load the child may +// not be ready when SIGTERM is sent. Mitigations: 500ms startup delay, 10s exit timeout. +test("stopAutoRemote sends SIGTERM to a live process and returns found:true", { timeout: 15000 }, async () => { const base = makeTmpBase(); // Spawn a child process that prints "ready" then sleeps, acting as a fake auto-mode session diff --git a/src/resources/extensions/gsd/workspace-index.ts b/src/resources/extensions/gsd/workspace-index.ts index f3c3be47a..b736ac5b3 100644 --- a/src/resources/extensions/gsd/workspace-index.ts +++ b/src/resources/extensions/gsd/workspace-index.ts @@ -10,6 +10,7 @@ import { } from "./paths.js"; import { deriveState } from "./state.js"; import { milestoneIdSort, findMilestoneIds } from "./guided-flow.js"; +import type { RiskLevel } from "./types.js"; import { type ValidationIssue, validateCompleteBoundary, validatePlanBoundary } from "./observability-validator.js"; import { getSliceBranchName, detectWorktreeName } from "./worktree.js"; @@ -30,6 +31,9 @@ export interface WorkspaceSliceTarget { uatPath?: string; tasksDir?: string; branch?: string; + risk?: RiskLevel; + depends?: string[]; + demo?: string; tasks: WorkspaceTaskTarget[]; } @@ -64,7 +68,7 @@ function titleFromRoadmapHeader(content: string, fallbackId: string): string { return roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, "") || fallbackId; } -async function indexSlice(basePath: string, milestoneId: string, sliceId: string, fallbackTitle: string, done: boolean): Promise { +async function indexSlice(basePath: string, milestoneId: string, sliceId: string, fallbackTitle: string, done: boolean, roadmapMeta?: { risk?: RiskLevel; depends?: string[]; demo?: string }): Promise { const planPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN") ?? undefined; const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY") ?? undefined; const uatPath = resolveSliceFile(basePath, milestoneId, sliceId, "UAT") ?? undefined; @@ -99,6 +103,9 @@ async function indexSlice(basePath: string, milestoneId: string, sliceId: string uatPath, tasksDir, branch: getSliceBranchName(milestoneId, sliceId, detectWorktreeName(basePath)), + risk: roadmapMeta?.risk, + depends: roadmapMeta?.depends, + demo: roadmapMeta?.demo, tasks, }; } @@ -136,13 +143,13 @@ export async function indexWorkspace(basePath: string, opts: IndexWorkspaceOptio roadmap.slices.map(async (slice) => { if (runValidation) { const [indexedSlice, planIssues, completeIssues] = await Promise.all([ - indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done), + indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo }), validatePlanBoundary(basePath, milestoneId, slice.id), validateCompleteBoundary(basePath, milestoneId, slice.id), ]); return { indexedSlice, issues: [...planIssues, ...completeIssues] }; } - const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done); + const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo }); return { indexedSlice, issues: [] as ValidationIssue[] }; }), ); diff --git a/src/tests/gsd-web-launcher-contract.test.ts b/src/tests/gsd-web-launcher-contract.test.ts new file mode 100644 index 000000000..bac43e26e --- /dev/null +++ b/src/tests/gsd-web-launcher-contract.test.ts @@ -0,0 +1,15 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { readFileSync } from "node:fs"; +import { resolve } from "node:path"; + +const packageJsonPath = resolve(import.meta.dirname, "../../package.json"); +const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { + scripts?: Record; +}; + +test("gsd:web rebuilds bundled resources before launching the packaged web host", () => { + const script = packageJson.scripts?.["gsd:web"]; + assert.ok(script, "package.json must define a gsd:web script"); + assert.match(script, /npm run copy-resources/, "gsd:web must refresh dist/resources so packaged web hosts do not serve stale GSD extensions"); +}); diff --git a/src/tests/initial-gsd-header-filter.test.ts b/src/tests/initial-gsd-header-filter.test.ts new file mode 100644 index 000000000..eb9f0f3a3 --- /dev/null +++ b/src/tests/initial-gsd-header-filter.test.ts @@ -0,0 +1,60 @@ +import test from "node:test"; +import assert from "node:assert/strict"; + +const { filterInitialGsdHeader } = await import("../../web/lib/initial-gsd-header-filter.ts"); + +const GSD_LOGO_LINES = [ + " ██████╗ ███████╗██████╗ ", + " ██╔════╝ ██╔════╝██╔══██╗", + " ██║ ███╗███████╗██║ ██║", + " ██║ ██║╚════██║██║ ██║", + " ╚██████╔╝███████║██████╔╝", + " ╚═════╝ ╚══════╝╚═════╝ ", +] as const; + +test("filterInitialGsdHeader strips a plain startup banner and keeps real terminal content", () => { + const warning = "Warning: Google Search is not configured."; + const raw = [...GSD_LOGO_LINES, " Get Shit Done v2.33.1", "", warning].join("\n"); + + const result = filterInitialGsdHeader(raw); + + assert.equal(result.status, "matched"); + assert.equal(result.text, warning); +}); + +test("filterInitialGsdHeader strips ANSI-colored startup banner output", () => { + const cyan = "\u001b[36m"; + const reset = "\u001b[39m"; + const bold = "\u001b[1m"; + const boldReset = "\u001b[22m"; + const dim = "\u001b[2m"; + const dimReset = "\u001b[22m"; + const warning = "Warning: terminal content starts here.\r\n"; + + const raw = + GSD_LOGO_LINES.map((line) => `${cyan}${line}${reset}\r\n`).join("") + + ` ${bold}Get Shit Done${boldReset} ${dim}v2.33.1${dimReset}\r\n\r\n` + + warning; + + const result = filterInitialGsdHeader(raw); + + assert.equal(result.status, "matched"); + assert.equal(result.text, warning); +}); + +test("filterInitialGsdHeader waits for more data when the startup banner is incomplete", () => { + const partial = `${GSD_LOGO_LINES[0]}\n${GSD_LOGO_LINES[1]}\n${GSD_LOGO_LINES[2]}`; + + const result = filterInitialGsdHeader(partial); + + assert.deepEqual(result, { status: "needs-more", text: "" }); +}); + +test("filterInitialGsdHeader passes normal terminal output through untouched", () => { + const raw = "Warning: already in the shell\r\n$ "; + + const result = filterInitialGsdHeader(raw); + + assert.equal(result.status, "passthrough"); + assert.equal(result.text, raw); +}); diff --git a/src/tests/integration/e2e-smoke.test.ts b/src/tests/integration/e2e-smoke.test.ts index 598d2f6f7..3f09b196d 100644 --- a/src/tests/integration/e2e-smoke.test.ts +++ b/src/tests/integration/e2e-smoke.test.ts @@ -518,7 +518,10 @@ test("gsd headless query returns JSON from the built CLI", async () => { try { mkdirSync(join(tmpDir, ".gsd", "milestones"), { recursive: true }); - const result = await runGsd(["headless", "query"], 10_000, {}, tmpDir); + // Cold packaged startup in a fresh temp repo is now regularly >10s because + // the built CLI loads bundled TS resources through jiti before answering. + // This command is still healthy; it just needs a realistic timeout budget. + const result = await runGsd(["headless", "query"], 30_000, {}, tmpDir); assert.ok(!result.timedOut, "process should not hang"); assert.strictEqual(result.code, 0, `expected exit 0, got ${result.code}`); @@ -537,7 +540,9 @@ test("gsd worktree list loads the built worktree CLI without module errors", asy const tmpDir = createTempGitRepo("gsd-e2e-worktree-"); try { - const result = await runGsd(["worktree", "list"], 10_000, {}, tmpDir); + // Cold packaged startup in a fresh temp repo is now regularly >10s because + // the built CLI loads bundled TS resources through jiti before listing. + const result = await runGsd(["worktree", "list"], 30_000, {}, tmpDir); assert.ok(!result.timedOut, "process should not hang"); assert.strictEqual(result.code, 0, `expected exit 0, got ${result.code}`); diff --git a/src/tests/integration/web-mode-assembled.test.ts b/src/tests/integration/web-mode-assembled.test.ts new file mode 100644 index 000000000..5e658ce51 --- /dev/null +++ b/src/tests/integration/web-mode-assembled.test.ts @@ -0,0 +1,1042 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); + +const bridge = await import("../../web/bridge-service.ts"); +const onboarding = await import("../../web/onboarding-service.ts"); +const bootRoute = await import("../../../web/app/api/boot/route.ts"); +const onboardingRoute = await import("../../../web/app/api/onboarding/route.ts"); +const recoveryRoute = await import("../../../web/app/api/recovery/route.ts"); +const commandRoute = await import("../../../web/app/api/session/command/route.ts"); +const eventsRoute = await import("../../../web/app/api/session/events/route.ts"); +const { + dispatchBrowserSlashCommand, + getBrowserSlashCommandTerminalNotice, +} = await import("../../../web/lib/browser-slash-command-dispatch.ts"); +const { AuthStorage } = await import("@gsd/pi-coding-agent"); + +// --------------------------------------------------------------------------- +// Test infrastructure (shared with web-mode-onboarding.test.ts) +// --------------------------------------------------------------------------- + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-assembled-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo\n\n## Slices\n- [ ] **S01: Demo** \`risk:low\` \`depends:[]\`\n`, + ); + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + `# S01: Demo\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Work** \`est:5m\`\n`, + ); + writeFileSync(join(tasksDir, "T01-PLAN.md"), `# T01: Work\n\n## Steps\n- do it\n`); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile(projectCwd: string, sessionsDir: string, sessionId: string, name: string): string { + const sessionPath = join(sessionsDir, `2026-03-14T18-00-00-000Z_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp: "2026-03-14T18:00:00.000Z", + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: "info-1", + parentId: null, + timestamp: "2026-03-14T18:00:01.000Z", + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function fakeAutoDashboardData() { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S01", + title: "Demo", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S01/tasks", + tasks: [{ id: "T01", title: "Work", done: false, planPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md" }], + }, + ], + }, + ], + active: { milestoneId: "M001", sliceId: "S01", taskId: "T01", phase: "executing" }, + scopes: [{ scope: "project", label: "project", kind: "project" }], + validationIssues: [], + }; +} + +function fakeSessionState(sessionId: string, sessionPath: string) { + return { + sessionId, + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }; +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)); +} + +/** + * Read SSE events from a Response stream, collecting up to `count` events. + * Returns early (without throwing) if no new data arrives within `perReadTimeoutMs`. + * This allows tests to request a generous count without failing on exact event counts. + */ +async function readSseEvents(response: Response, count: number, perReadTimeoutMs = 3_000): Promise { + const reader = response.body?.getReader(); + assert.ok(reader, "SSE response has a body reader"); + const decoder = new TextDecoder(); + const events: any[] = []; + let buffer = ""; + + while (events.length < count) { + let timedOut = false; + const result = await Promise.race([ + reader.read(), + new Promise<{ done: true; value: undefined }>((resolve) => { + setTimeout(() => { + timedOut = true; + resolve({ done: true, value: undefined }); + }, perReadTimeoutMs); + }), + ]); + + if (timedOut || result.done) break; + buffer += decoder.decode(result.value as Uint8Array, { stream: true }); + + while (true) { + const boundary = buffer.indexOf("\n\n"); + if (boundary === -1) break; + const chunk = buffer.slice(0, boundary); + buffer = buffer.slice(boundary + 2); + const dataLine = chunk.split("\n").find((line) => line.startsWith("data: ")); + if (!dataLine) continue; + events.push(JSON.parse(dataLine.slice(6))); + } + } + + await reader.cancel(); + return events; +} + +// --------------------------------------------------------------------------- +// Assembled lifecycle test +// --------------------------------------------------------------------------- + +test("assembled lifecycle: boot → onboard → prompt → streaming text → tool execution → blocking UI request → UI response → turn boundary", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-assembled", "Assembled Lifecycle Session"); + + // Track state across spawn generations + let spawnCount = 0; + let receivedUiResponse: any = null; + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn(command: string, args: readonly string[], options: Record) { + void command; + void args; + void options; + spawnCount += 1; + const child = new FakeRpcChild(); + + attachJsonLineReader(child.stdin, (line) => { + const message = JSON.parse(line) as any; + + switch (message.type) { + case "get_state": { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-assembled", sessionPath), + }), + ); + return; + } + + case "prompt": { + // Respond with success immediately + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "prompt", + success: true, + }), + ); + + // Then emit the streaming event sequence after a tick + setTimeout(() => { + // 1. Streaming text delta + child.stdout.write( + serializeJsonLine({ + type: "message_update", + assistantMessageEvent: { + type: "text_delta", + delta: "Deploying to production...", + contentIndex: 0, + }, + }), + ); + + // 2. Tool execution start + child.stdout.write( + serializeJsonLine({ + type: "tool_execution_start", + toolCallId: "tc-deploy-1", + toolName: "bash", + args: { command: "deploy --prod" }, + }), + ); + + // 3. Tool execution end + child.stdout.write( + serializeJsonLine({ + type: "tool_execution_end", + toolCallId: "tc-deploy-1", + toolName: "bash", + result: { exitCode: 0 }, + isError: false, + }), + ); + + // 4. Blocking UI request — waits for user confirmation + child.stdout.write( + serializeJsonLine({ + type: "extension_ui_request", + id: "ui-confirm-deploy", + method: "confirm", + title: "Confirm deployment", + message: "Proceed with deploying to production?", + }), + ); + // agent_end/turn_end are withheld until the UI response arrives + }, 10); + return; + } + + case "extension_ui_response": { + // Record the round-trip proof + receivedUiResponse = message; + + // Now emit turn boundary events + setTimeout(() => { + child.stdout.write(serializeJsonLine({ type: "agent_end" })); + child.stdout.write(serializeJsonLine({ type: "turn_end" })); + }, 10); + return; + } + + default: + // Ignore unexpected commands (e.g. abort, steer) + return; + } + }); + + return child as any; + }, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + }); + + onboarding.configureOnboardingServiceForTests({ + authStorage, + validateApiKey: async () => ({ ok: true, message: "openai credentials validated" }), + }); + + try { + // ----------------------------------------------------------------------- + // Stage 1: Boot — verify bridge ready, onboarding locked + // ----------------------------------------------------------------------- + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200, "boot endpoint should respond 200"); + const bootPayload = (await bootResponse.json()) as any; + assert.equal(bootPayload.bridge.phase, "ready", "bridge should be ready after boot"); + assert.equal(bootPayload.onboarding.locked, true, "onboarding should be locked before setup"); + assert.equal(bootPayload.onboarding.lockReason, "required_setup", "lock reason should be required_setup"); + assert.equal(spawnCount, 1, "bridge should have spawned once during boot"); + + // Verify prompt is blocked while locked + const blockedPrompt = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "prompt", message: "should be rejected" }), + }), + ); + assert.equal(blockedPrompt.status, 423, "prompt should be locked (423) before onboarding"); + + // ----------------------------------------------------------------------- + // Stage 2: Onboard — save API key, unlock workspace + // ----------------------------------------------------------------------- + const onboardResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "save_api_key", + providerId: "openai", + apiKey: "sk-assembled-test-key", + }), + }), + ); + assert.equal(onboardResponse.status, 200, "onboarding save_api_key should succeed"); + const onboardPayload = (await onboardResponse.json()) as any; + assert.equal(onboardPayload.onboarding.locked, false, "onboarding should be unlocked after setup"); + assert.equal(onboardPayload.onboarding.lockReason, null, "lock reason should be null after setup"); + assert.equal(onboardPayload.onboarding.bridgeAuthRefresh.phase, "succeeded", "bridge auth refresh should succeed"); + assert.equal(spawnCount, 2, "bridge should have been restarted (spawned again) during auth refresh"); + + // ----------------------------------------------------------------------- + // Stage 3: Subscribe SSE + send prompt + // ----------------------------------------------------------------------- + const sseResponse = await eventsRoute.GET( + new Request("http://localhost/api/session/events", { signal: AbortSignal.timeout(10_000) }), + ); + assert.equal(sseResponse.status, 200, "SSE endpoint should respond 200"); + assert.equal( + sseResponse.headers.get("content-type"), + "text/event-stream; charset=utf-8", + "SSE should have correct content type", + ); + + // Start reading SSE events in background (reads until count or timeout) + const phase1EventsPromise = readSseEvents(sseResponse, 15, 3_000); + + // Send the prompt — triggers fake child's streaming event sequence + const promptResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "prompt", message: "deploy the application" }), + }), + ); + assert.equal(promptResponse.status, 200, "prompt should succeed after onboarding"); + const promptPayload = (await promptResponse.json()) as any; + assert.equal(promptPayload.success, true, "prompt RPC response should indicate success"); + assert.equal(promptPayload.command, "prompt", "prompt RPC response should echo command type"); + + // Collect Phase 1 SSE events + const phase1Events = await phase1EventsPromise; + await waitForMicrotasks(); + + // ----------------------------------------------------------------------- + // Stage 4: Verify streaming events arrived via SSE + // ----------------------------------------------------------------------- + const nonStatusEvents = phase1Events.filter((e) => e.type !== "bridge_status"); + const eventTypes = nonStatusEvents.map((e) => e.type); + + const messageUpdate = nonStatusEvents.find((e) => e.type === "message_update"); + assert.ok( + messageUpdate, + `message_update event should arrive via SSE (got types: ${eventTypes.join(", ")})`, + ); + assert.equal( + messageUpdate.assistantMessageEvent.type, + "text_delta", + "message_update should contain a text_delta", + ); + assert.equal( + messageUpdate.assistantMessageEvent.delta, + "Deploying to production...", + "text_delta should carry the expected content", + ); + + const toolStart = nonStatusEvents.find((e) => e.type === "tool_execution_start"); + assert.ok( + toolStart, + `tool_execution_start event should arrive via SSE (got types: ${eventTypes.join(", ")})`, + ); + assert.equal(toolStart.toolCallId, "tc-deploy-1", "tool start should have correct toolCallId"); + assert.equal(toolStart.toolName, "bash", "tool start should identify the tool name"); + + const toolEnd = nonStatusEvents.find((e) => e.type === "tool_execution_end"); + assert.ok( + toolEnd, + `tool_execution_end event should arrive via SSE (got types: ${eventTypes.join(", ")})`, + ); + assert.equal(toolEnd.toolCallId, "tc-deploy-1", "tool end should match the tool start"); + assert.equal(toolEnd.isError, false, "tool execution should not be an error"); + + const uiRequest = nonStatusEvents.find((e) => e.type === "extension_ui_request"); + assert.ok( + uiRequest, + `extension_ui_request event should arrive via SSE (got types: ${eventTypes.join(", ")})`, + ); + assert.equal(uiRequest.id, "ui-confirm-deploy", "UI request should have the expected id"); + assert.equal(uiRequest.method, "confirm", "UI request should be a confirm dialog"); + assert.equal(uiRequest.title, "Confirm deployment", "UI request should have the expected title"); + assert.equal( + uiRequest.message, + "Proceed with deploying to production?", + "UI request should have the expected message", + ); + + // Verify correct event ordering: message_update → tool_start → tool_end → ui_request + const msgIdx = nonStatusEvents.indexOf(messageUpdate); + const toolStartIdx = nonStatusEvents.indexOf(toolStart); + const toolEndIdx = nonStatusEvents.indexOf(toolEnd); + const uiReqIdx = nonStatusEvents.indexOf(uiRequest); + assert.ok(msgIdx < toolStartIdx, "message_update should precede tool_execution_start"); + assert.ok(toolStartIdx < toolEndIdx, "tool_execution_start should precede tool_execution_end"); + assert.ok(toolEndIdx < uiReqIdx, "tool_execution_end should precede extension_ui_request"); + + // Verify bridge_status events were also delivered (proves SSE fanout is working) + const statusEvents = phase1Events.filter((e) => e.type === "bridge_status"); + assert.ok(statusEvents.length >= 1, "at least one bridge_status event should arrive via SSE"); + + // ----------------------------------------------------------------------- + // Stage 5: Respond to UI request — prove the round-trip + // ----------------------------------------------------------------------- + const sseResponse2 = await eventsRoute.GET( + new Request("http://localhost/api/session/events", { signal: AbortSignal.timeout(10_000) }), + ); + + // Start reading Phase 2 events in background + const phase2EventsPromise = readSseEvents(sseResponse2, 10, 3_000); + + // Send the UI response + const uiResponseResult = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ + type: "extension_ui_response", + id: "ui-confirm-deploy", + value: true, + }), + }), + ); + assert.equal(uiResponseResult.status, 202, "extension_ui_response should return 202 (fire-and-forget)"); + + // Wait for microtasks to let the stdin write propagate + await waitForMicrotasks(); + + // Verify the UI response reached the fake child's stdin (round-trip proof) + assert.ok(receivedUiResponse, "UI response should have reached the fake child via bridge stdin"); + assert.equal(receivedUiResponse.id, "ui-confirm-deploy", "UI response id should match the request"); + assert.equal(receivedUiResponse.value, true, "UI response value should be delivered intact"); + + // Collect Phase 2 SSE events (agent_end + turn_end) + const phase2Events = await phase2EventsPromise; + await waitForMicrotasks(); + + // ----------------------------------------------------------------------- + // Stage 6: Verify turn boundary events + // ----------------------------------------------------------------------- + const phase2NonStatus = phase2Events.filter((e) => e.type !== "bridge_status"); + const phase2Types = phase2NonStatus.map((e) => e.type); + + const agentEnd = phase2NonStatus.find((e) => e.type === "agent_end"); + assert.ok( + agentEnd, + `agent_end event should arrive via SSE after UI response (got types: ${phase2Types.join(", ")})`, + ); + + const turnEnd = phase2NonStatus.find((e) => e.type === "turn_end"); + assert.ok( + turnEnd, + `turn_end event should arrive via SSE after UI response (got types: ${phase2Types.join(", ")})`, + ); + + // Verify agent_end precedes turn_end + const agentEndIdx = phase2NonStatus.indexOf(agentEnd); + const turnEndIdx = phase2NonStatus.indexOf(turnEnd); + assert.ok(agentEndIdx < turnEndIdx, "agent_end should precede turn_end"); + + // ----------------------------------------------------------------------- + // Summary assertion: the complete assembled pipeline is proven + // ----------------------------------------------------------------------- + const allEventTypes = [ + ...nonStatusEvents.map((e) => e.type), + ...phase2NonStatus.map((e) => e.type), + ]; + const requiredTypes = [ + "message_update", + "tool_execution_start", + "tool_execution_end", + "extension_ui_request", + "agent_end", + "turn_end", + ]; + for (const required of requiredTypes) { + assert.ok( + allEventTypes.includes(required), + `complete pipeline must include ${required} (got: ${allEventTypes.join(", ")})`, + ); + } + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("assembled settings controls keep retry visibility and daily-use mutations authoritative", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-settings", "Settings Session"); + const bridgeCommands: any[] = []; + let sessionState = { + ...fakeSessionState("sess-settings", sessionPath), + retryInProgress: true, + retryAttempt: 2, + }; + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn(command: string, args: readonly string[], options: Record) { + void command; + void args; + void options; + const child = new FakeRpcChild(); + + attachJsonLineReader(child.stdin, (line) => { + const message = JSON.parse(line) as any; + bridgeCommands.push(message); + + if (message.type === "get_state") { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "get_state", + success: true, + data: sessionState, + }), + ); + return; + } + + if (message.type === "set_steering_mode") { + sessionState = { ...sessionState, steeringMode: message.mode }; + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "set_steering_mode", + success: true, + }), + ); + return; + } + + if (message.type === "set_follow_up_mode") { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "set_follow_up_mode", + success: false, + error: "follow-up mode rejected by the live session", + }), + ); + return; + } + + if (message.type === "set_auto_compaction") { + sessionState = { ...sessionState, autoCompactionEnabled: message.enabled }; + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "set_auto_compaction", + success: true, + }), + ); + return; + } + + if (message.type === "set_auto_retry") { + sessionState = { ...sessionState, autoRetryEnabled: message.enabled }; + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "set_auto_retry", + success: true, + }), + ); + return; + } + + if (message.type === "abort_retry") { + sessionState = { ...sessionState, retryInProgress: false, retryAttempt: 0 }; + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "abort_retry", + success: true, + }), + ); + return; + } + }); + + return child as any; + }, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + anthropic: { type: "api_key", key: "sk-test-assembled-settings" }, + } as any), + }); + + try { + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200); + const bootPayload = (await bootResponse.json()) as any; + assert.equal(bootPayload.bridge.sessionState.autoRetryEnabled, false); + assert.equal(bootPayload.bridge.sessionState.retryInProgress, true); + assert.equal(bootPayload.bridge.sessionState.retryAttempt, 2); + + const steeringResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "set_steering_mode", mode: "one-at-a-time" }), + }), + ); + assert.equal(steeringResponse.status, 200); + const steeringBody = (await steeringResponse.json()) as any; + assert.equal(steeringBody.success, true); + + const followUpResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "set_follow_up_mode", mode: "one-at-a-time" }), + }), + ); + assert.equal(followUpResponse.status, 502); + const followUpBody = (await followUpResponse.json()) as any; + assert.equal(followUpBody.success, false); + assert.match(followUpBody.error, /follow-up mode rejected/i); + + const autoCompactionResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "set_auto_compaction", enabled: true }), + }), + ); + assert.equal(autoCompactionResponse.status, 200); + const autoCompactionBody = (await autoCompactionResponse.json()) as any; + assert.equal(autoCompactionBody.success, true); + + const autoRetryResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "set_auto_retry", enabled: true }), + }), + ); + assert.equal(autoRetryResponse.status, 200); + const autoRetryBody = (await autoRetryResponse.json()) as any; + assert.equal(autoRetryBody.success, true); + + const abortRetryResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "abort_retry" }), + }), + ); + assert.equal(abortRetryResponse.status, 200); + const abortRetryBody = (await abortRetryResponse.json()) as any; + assert.equal(abortRetryBody.success, true); + + await waitForMicrotasks(); + + const refreshedBootResponse = await bootRoute.GET(); + assert.equal(refreshedBootResponse.status, 200); + const refreshedBootPayload = (await refreshedBootResponse.json()) as any; + assert.equal(refreshedBootPayload.bridge.sessionState.steeringMode, "one-at-a-time"); + assert.equal(refreshedBootPayload.bridge.sessionState.followUpMode, "all"); + assert.equal(refreshedBootPayload.bridge.sessionState.autoCompactionEnabled, true); + assert.equal(refreshedBootPayload.bridge.sessionState.autoRetryEnabled, true); + assert.equal(refreshedBootPayload.bridge.sessionState.retryInProgress, false); + assert.equal(refreshedBootPayload.bridge.sessionState.retryAttempt, 0); + + assert.deepEqual( + bridgeCommands.filter((entry) => entry.type !== "get_state").map((entry) => entry.type), + ["set_steering_mode", "set_follow_up_mode", "set_auto_compaction", "set_auto_retry", "abort_retry"], + "settings parity must route through the live bridge instead of browser-local toggles", + ); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("assembled recovery route exposes actionable browser diagnostics without raw transcript leakage", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-recovery", "Recovery Session"); + + writeFileSync( + sessionPath, + [ + JSON.stringify({ type: "session", version: 3, id: "sess-recovery", timestamp: "2026-03-14T18:00:00.000Z", cwd: fixture.projectCwd }), + JSON.stringify({ type: "session_info", id: "info-1", parentId: null, timestamp: "2026-03-14T18:00:01.000Z", name: "Recovery Session" }), + JSON.stringify({ + type: "message", + message: { + role: "assistant", + content: [{ type: "toolCall", id: "tool-1", name: "bash", arguments: { command: "echo hi" } }], + }, + }), + JSON.stringify({ + type: "message", + message: { + role: "toolResult", + toolCallId: "tool-1", + toolName: "bash", + isError: true, + content: "authentication failed for sk-assembled-recovery-secret-0001", + }, + }), + ].join("\n") + "\n", + ); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn(command: string, args: readonly string[], options: Record) { + void command; + void args; + void options; + const child = new FakeRpcChild(); + + attachJsonLineReader(child.stdin, (line) => { + const message = JSON.parse(line) as any; + if (message.type === "get_state") { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "get_state", + success: true, + data: { + ...fakeSessionState("sess-recovery", sessionPath), + autoRetryEnabled: true, + retryInProgress: true, + retryAttempt: 2, + }, + }), + ); + } + }); + + return child as any; + }, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingState: async () => ({ + status: "ready", + locked: true, + lockReason: "bridge_refresh_failed", + required: { + blocking: true, + skippable: false, + satisfied: true, + satisfiedBy: { providerId: "anthropic", source: "auth_file" }, + providers: [], + }, + optional: { + blocking: false, + skippable: true, + sections: [], + }, + lastValidation: null, + activeFlow: null, + bridgeAuthRefresh: { + phase: "failed", + strategy: "restart", + startedAt: "2026-03-15T03:31:00.000Z", + completedAt: "2026-03-15T03:31:05.000Z", + error: "Bridge refresh failed for sk-assembled-auth-secret-0002", + }, + }), + }); + + try { + const response = await recoveryRoute.GET(); + assert.equal(response.status, 200); + const payload = (await response.json()) as any; + + assert.equal(payload.status, "ready"); + assert.equal(payload.bridge.retry.inProgress, true); + assert.equal(payload.bridge.retry.attempt, 2); + assert.equal(payload.bridge.authRefresh.phase, "failed"); + assert.ok(payload.actions.browser.some((action: { id: string }) => action.id === "refresh_diagnostics")); + assert.ok(payload.actions.browser.some((action: { id: string }) => action.id === "open_retry_controls")); + assert.ok(payload.actions.browser.some((action: { id: string }) => action.id === "open_auth_controls")); + assert.equal(payload.interruptedRun.detected, true); + assert.doesNotMatch(JSON.stringify(payload), /sk-assembled-recovery-secret-0001|sk-assembled-auth-secret-0002/); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("assembled slash-command behavior keeps built-ins safe while preserving GSD prompt commands", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-slash", "Slash Session"); + const bridgeCommands: any[] = []; + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn(command: string, args: readonly string[], options: Record) { + void command; + void args; + void options; + const child = new FakeRpcChild(); + + attachJsonLineReader(child.stdin, (line) => { + const message = JSON.parse(line) as any; + bridgeCommands.push(message); + + if (message.type === "get_state") { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-slash", sessionPath), + }), + ); + return; + } + + if (message.type === "new_session") { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "new_session", + success: true, + data: { cancelled: false }, + }), + ); + return; + } + + if (message.type === "prompt") { + child.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "prompt", + success: true, + }), + ); + } + }); + + return child as any; + }, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + anthropic: { type: "api_key", key: "sk-test-assembled-slash" }, + } as any), + }); + + try { + async function submitBrowserInput(input: string): Promise<{ outcome: any; status: number | null; body: any; notice: string | null }> { + const outcome = dispatchBrowserSlashCommand(input); + + if (outcome.kind === "prompt" || outcome.kind === "rpc") { + const response = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify(outcome.command), + }), + ); + return { + outcome, + status: response.status, + body: await response.json(), + notice: null, + }; + } + + const notice = getBrowserSlashCommandTerminalNotice(outcome)?.message ?? null; + return { + outcome, + status: null, + body: null, + notice, + }; + } + + const builtInExecution = await submitBrowserInput("/new"); + assert.equal(builtInExecution.outcome.kind, "rpc"); + assert.equal(builtInExecution.status, 200); + assert.equal(builtInExecution.body.command, "new_session"); + + const builtInSurface = await submitBrowserInput("/model"); + assert.equal(builtInSurface.outcome.kind, "surface"); + assert.equal(builtInSurface.outcome.surface, "model"); + assert.equal(builtInSurface.status, null); + + const builtInNameSurface = await submitBrowserInput("/name Ship It"); + assert.equal(builtInNameSurface.outcome.kind, "surface"); + assert.equal(builtInNameSurface.outcome.surface, "name"); + assert.equal(builtInNameSurface.status, null); + + const builtInReject = await submitBrowserInput("/share"); + assert.equal(builtInReject.outcome.kind, "reject"); + assert.match(builtInReject.notice ?? "", /blocked instead of falling through to the model/i); + assert.equal(builtInReject.status, null); + + // /gsd status is now a browser surface (S02), verify that + const gsdSurface = await submitBrowserInput("/gsd status"); + assert.equal(gsdSurface.outcome.kind, "surface"); + assert.equal(gsdSurface.outcome.surface, "gsd-status"); + assert.equal(gsdSurface.status, null); + + // /gsd auto is a passthrough subcommand — reaches the bridge as a prompt + const gsdPrompt = await submitBrowserInput("/gsd auto"); + assert.equal(gsdPrompt.outcome.kind, "prompt"); + assert.equal(gsdPrompt.status, 200); + assert.equal(gsdPrompt.body.command, "prompt"); + + const sentTypes = bridgeCommands.map((command) => command.type); + assert.deepEqual( + sentTypes.filter((type) => type !== "get_state"), + ["new_session", "prompt"], + "only browser-executable slash commands should reach the live bridge; built-in surfaces/rejects must stay out of prompt text", + ); + const promptCommand = bridgeCommands.find((command) => command.type === "prompt"); + assert.equal(promptCommand?.message, "/gsd auto", "GSD passthrough commands must stay on the extension prompt path"); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); diff --git a/src/tests/integration/web-mode-onboarding.test.ts b/src/tests/integration/web-mode-onboarding.test.ts new file mode 100644 index 000000000..58370a925 --- /dev/null +++ b/src/tests/integration/web-mode-onboarding.test.ts @@ -0,0 +1,509 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +import { chromium } from "playwright"; + +import { + killProcessOnPort, + launchPackagedWebHost, + runtimeAuthHeaders, + waitForHttpOk, +} from "./web-mode-runtime-harness.ts"; + +const repoRoot = process.cwd(); + +const bridge = await import("../../web/bridge-service.ts"); +const onboarding = await import("../../web/onboarding-service.ts"); +const bootRoute = await import("../../../web/app/api/boot/route.ts"); +const onboardingRoute = await import("../../../web/app/api/onboarding/route.ts"); +const commandRoute = await import("../../../web/app/api/session/command/route.ts"); +const { AuthStorage } = await import("@gsd/pi-coding-agent"); + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-onboarding-integration-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S02"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo Milestone\n\n## Slices\n- [ ] **S02: First-run setup wizard** \`risk:medium\` \`depends:[S01]\`\n > Browser onboarding\n`, + ); + writeFileSync( + join(sliceDir, "S02-PLAN.md"), + `# S02: First-run setup wizard\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T02: Enforce the gate and refresh bridge auth after successful setup** \`est:1h\`\n Do the work.\n`, + ); + writeFileSync( + join(tasksDir, "T02-PLAN.md"), + `# T02: Enforce the gate and refresh bridge auth after successful setup\n\n## Steps\n- do it\n`, + ); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile(projectCwd: string, sessionsDir: string, sessionId: string, name: string): string { + const sessionPath = join(sessionsDir, `2026-03-14T18-00-00-000Z_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp: "2026-03-14T18:00:00.000Z", + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: "info-1", + parentId: null, + timestamp: "2026-03-14T18:00:01.000Z", + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function fakeAutoDashboardData() { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo Milestone", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S02", + title: "First-run setup wizard", + done: false, + planPath: ".gsd/milestones/M001/slices/S02/S02-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S02/tasks", + tasks: [ + { + id: "T02", + title: "Enforce the gate and refresh bridge auth after successful setup", + done: false, + planPath: ".gsd/milestones/M001/slices/S02/tasks/T02-PLAN.md", + }, + ], + }, + ], + }, + ], + active: { + milestoneId: "M001", + sliceId: "S02", + taskId: "T02", + phase: "executing", + }, + scopes: [ + { scope: "project", label: "project", kind: "project" }, + { scope: "M001", label: "M001: Demo Milestone", kind: "milestone" }, + { scope: "M001/S02", label: "M001/S02: First-run setup wizard", kind: "slice" }, + { + scope: "M001/S02/T02", + label: "M001/S02/T02: Enforce the gate and refresh bridge auth after successful setup", + kind: "task", + }, + ], + validationIssues: [], + }; +} + +type BridgeRuntimeHarness = ReturnType; + +function configureBridgeRuntime( + fixture: { projectCwd: string; sessionsDir: string }, + authStorage: InstanceType, + options: { failRestart?: boolean } = {}, +) { + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-web-onboarding", "Web Onboarding Session"); + const generations: Array<{ authVisibleAtStart: boolean; promptMessages: string[] }> = []; + let spawnCalls = 0; + let child: FakeRpcChild | null = null; + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn(command: string, args: readonly string[], optionsArg: Record) { + void command; + void args; + void optionsArg; + spawnCalls += 1; + const generation = { + authVisibleAtStart: authStorage.hasAuth("openai"), + promptMessages: [] as string[], + }; + generations.push(generation); + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + const message = JSON.parse(line) as any; + switch (message.type) { + case "get_state": { + if (options.failRestart && spawnCalls >= 2) { + child!.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "get_state", + success: false, + error: "bridge auth refresh could not attach to a live session", + }), + ); + return; + } + child!.stdout.write( + serializeJsonLine({ + id: message.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-web-onboarding", + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: generation.promptMessages.length, + pendingMessageCount: 0, + }, + }), + ); + return; + } + case "prompt": { + generation.promptMessages.push(String(message.message ?? "")); + child!.stdout.write( + serializeJsonLine( + generation.authVisibleAtStart + ? { + id: message.id, + type: "response", + command: "prompt", + success: true, + } + : { + id: message.id, + type: "response", + command: "prompt", + success: false, + error: "prompt reached bridge without refreshed auth", + }, + ), + ); + return; + } + default: + assert.fail(`unexpected command during integration test: ${message.type}`); + } + }); + return child as any; + }, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + }); + + return { + get spawnCalls() { + return spawnCalls; + }, + get generations() { + return generations; + }, + get promptCount() { + return generations.reduce((count, generation) => count + generation.promptMessages.length, 0); + }, + }; +} + + +test("successful browser onboarding restarts the stale bridge child and unlocks the first prompt", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const harness = configureBridgeRuntime(fixture, authStorage); + onboarding.configureOnboardingServiceForTests({ + authStorage, + validateApiKey: async () => ({ ok: true, message: "openai credentials validated" }), + }); + + try { + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200); + const bootPayload = (await bootResponse.json()) as any; + assert.equal(bootPayload.onboarding.locked, true); + assert.equal(bootPayload.onboarding.lockReason, "required_setup"); + assert.equal(harness.spawnCalls, 1); + assert.equal(harness.generations[0]?.authVisibleAtStart, false); + + const blockedPrompt = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "prompt", message: "should stay locked" }), + }), + ); + assert.equal(blockedPrompt.status, 423); + const blockedPayload = (await blockedPrompt.json()) as any; + assert.equal(blockedPayload.code, "onboarding_locked"); + assert.equal(blockedPayload.details.reason, "required_setup"); + assert.equal(harness.promptCount, 0); + + const validationResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "save_api_key", + providerId: "openai", + apiKey: "sk-valid-123456", + }), + }), + ); + assert.equal(validationResponse.status, 200); + const validationPayload = (await validationResponse.json()) as any; + assert.equal(validationPayload.onboarding.locked, false); + assert.equal(validationPayload.onboarding.lockReason, null); + assert.equal(validationPayload.onboarding.bridgeAuthRefresh.phase, "succeeded"); + assert.equal(harness.spawnCalls, 2); + assert.equal(harness.generations[1]?.authVisibleAtStart, true); + + const firstPrompt = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "prompt", message: "first unlocked prompt" }), + }), + ); + assert.equal(firstPrompt.status, 200); + const firstPromptPayload = (await firstPrompt.json()) as any; + assert.equal(firstPromptPayload.success, true); + assert.equal(firstPromptPayload.command, "prompt"); + assert.equal(harness.promptCount, 1); + assert.deepEqual(harness.generations[1]?.promptMessages, ["first unlocked prompt"]); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("refresh failures keep the workspace locked and expose the failed bridge-refresh reason", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const harness = configureBridgeRuntime(fixture, authStorage, { failRestart: true }); + onboarding.configureOnboardingServiceForTests({ + authStorage, + validateApiKey: async () => ({ ok: true, message: "openai credentials validated" }), + }); + + try { + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200); + assert.equal(harness.spawnCalls, 1); + + const validationResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "save_api_key", + providerId: "openai", + apiKey: "sk-valid-123456", + }), + }), + ); + assert.equal(validationResponse.status, 503); + const validationPayload = (await validationResponse.json()) as any; + assert.equal(validationPayload.onboarding.required.satisfied, true); + assert.equal(validationPayload.onboarding.locked, true); + assert.equal(validationPayload.onboarding.lockReason, "bridge_refresh_failed"); + assert.equal(validationPayload.onboarding.lastValidation.status, "succeeded"); + assert.equal(validationPayload.onboarding.bridgeAuthRefresh.phase, "failed"); + assert.match(validationPayload.onboarding.bridgeAuthRefresh.error, /could not attach/i); + assert.equal(harness.spawnCalls, 2); + assert.equal(harness.generations[1]?.authVisibleAtStart, true); + + const blockedPrompt = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "prompt", message: "still locked after failed refresh" }), + }), + ); + assert.equal(blockedPrompt.status, 423); + const blockedPayload = (await blockedPrompt.json()) as any; + assert.equal(blockedPayload.code, "onboarding_locked"); + assert.equal(blockedPayload.details.reason, "bridge_refresh_failed"); + assert.equal(harness.promptCount, 0); + + const failedBootResponse = await bootRoute.GET(); + assert.equal(failedBootResponse.status, 200); + const failedBootPayload = (await failedBootResponse.json()) as any; + assert.equal(failedBootPayload.onboarding.locked, true); + assert.equal(failedBootPayload.onboarding.lockReason, "bridge_refresh_failed"); + assert.equal(failedBootPayload.onboarding.bridgeAuthRefresh.phase, "failed"); + assert.match(failedBootPayload.onboarding.bridgeAuthRefresh.error, /could not attach/i); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("fresh gsd --web browser onboarding stays locked on failed validation and unlocks after a successful retry", async (t) => { + if (process.platform === "win32") { + t.skip("runtime launch test uses POSIX browser-open stubs") + return + } + + const tempRoot = mkdtempSync(join(tmpdir(), "gsd-web-onboarding-runtime-")) + const tempHome = join(tempRoot, "home") + const browserLogPath = join(tempRoot, "browser-open.log") + let port: number | null = null + + try { + const launch = await launchPackagedWebHost({ + launchCwd: repoRoot, + tempHome, + browserLogPath, + env: { + GSD_WEB_TEST_FAKE_API_KEY_VALIDATION: "1", + ANTHROPIC_API_KEY: "", + OPENAI_API_KEY: "", + GOOGLE_API_KEY: "", + }, + }) + port = launch.port + + assert.equal(launch.exitCode, 0, `expected the web launcher to exit cleanly:\n${launch.stderr}`) + assert.match(launch.stderr, /status=started/, "expected a started diagnostic line on stderr") + + const auth = runtimeAuthHeaders(launch) + await waitForHttpOk(`${launch.url}/api/boot`, undefined, auth) + + // 1. Boot reports locked before any credentials are saved + const bootBefore = await fetch(`${launch.url}/api/boot`, { + method: "GET", + headers: { Accept: "application/json", ...auth }, + signal: AbortSignal.timeout(10_000), + }) + assert.equal(bootBefore.ok, true, `expected boot endpoint to respond successfully: ${bootBefore.status}`) + const bootBeforePayload = await bootBefore.json() as any + assert.equal(bootBeforePayload.onboarding.locked, true) + assert.equal(bootBeforePayload.onboarding.lockReason, "required_setup") + + // 2. Invalid key → stays locked with failed validation + const invalidValidation = await fetch(`${launch.url}/api/onboarding`, { + method: "POST", + headers: { "Content-Type": "application/json", Accept: "application/json", ...auth }, + body: JSON.stringify({ action: "save_api_key", providerId: "openai", apiKey: "invalid-demo-key" }), + signal: AbortSignal.timeout(10_000), + }) + assert.equal(invalidValidation.status, 422) + const invalidPayload = await invalidValidation.json() as any + assert.equal(invalidPayload.onboarding.locked, true) + assert.equal(invalidPayload.onboarding.lastValidation.status, "failed") + assert.match(invalidPayload.onboarding.lastValidation.message ?? "", /rejected/i) + + // 3. Valid key → unlocks + const validValidation = await fetch(`${launch.url}/api/onboarding`, { + method: "POST", + headers: { "Content-Type": "application/json", Accept: "application/json", ...auth }, + body: JSON.stringify({ action: "save_api_key", providerId: "openai", apiKey: "valid-demo-key" }), + signal: AbortSignal.timeout(60_000), + }) + assert.equal(validValidation.status, 200, `expected successful retry to unlock onboarding: ${validValidation.status}`) + const validPayload = await validValidation.json() as any + assert.equal(validPayload.onboarding.locked, false) + assert.equal(validPayload.onboarding.bridgeAuthRefresh.phase, "succeeded") + + // 4. Boot confirms unlocked + const bootAfter = await fetch(`${launch.url}/api/boot`, { + method: "GET", + headers: { Accept: "application/json", ...auth }, + signal: AbortSignal.timeout(10_000), + }) + assert.equal(bootAfter.ok, true) + const bootAfterPayload = await bootAfter.json() as any + assert.equal(bootAfterPayload.onboarding.locked, false) + assert.equal(bootAfterPayload.onboarding.lockReason, null) + } finally { + if (port !== null) { + await killProcessOnPort(port) + } + rmSync(tempRoot, { recursive: true, force: true }) + } +}) diff --git a/src/tests/integration/web-mode-runtime-fixtures.ts b/src/tests/integration/web-mode-runtime-fixtures.ts new file mode 100644 index 000000000..7778a3482 --- /dev/null +++ b/src/tests/integration/web-mode-runtime-fixtures.ts @@ -0,0 +1,341 @@ +import { mkdtempSync, mkdirSync, realpathSync, rmSync, utimesSync, writeFileSync } from "node:fs" +import { tmpdir } from "node:os" +import { dirname, join } from "node:path" + +import { getProjectSessionsDir } from "../../cli-web-branch.ts" + +export type RuntimeWorkspaceFixture = { + projectCwd: string + expectedScope: string + cleanup: () => void +} + +export type SeededRuntimeSession = { + sessionId: string + name: string + sessionPath: string +} + +export type SeededInterruptedRunRecovery = { + sessionsDir: string + alternateSession: SeededRuntimeSession + activeSession: SeededRuntimeSession + leakedSecret: string +} + +type SessionMessageSeed = Record + +function canonicalizePath(path: string): string { + try { + return realpathSync.native?.(path) ?? realpathSync(path) + } catch { + return path + } +} + +function sessionBaseVariants(baseSessionsDir: string): string[] { + const variants = new Set([baseSessionsDir]) + const normalized = baseSessionsDir.replace(/\\/g, "/") + if (normalized.endsWith("/.gsd/sessions")) { + variants.add(join(dirname(baseSessionsDir), "agent", "sessions")) + } + if (normalized.endsWith("/.gsd/agent/sessions")) { + variants.add(join(dirname(dirname(baseSessionsDir)), "sessions")) + } + return [...variants] +} + +function resolveSeedTargetSessionDirs(projectCwd: string, baseSessionsDir: string): string[] { + const cwdVariants = new Set([projectCwd, canonicalizePath(projectCwd)]) + const targets = new Set() + + for (const cwd of cwdVariants) { + for (const baseDir of sessionBaseVariants(baseSessionsDir)) { + targets.add(getProjectSessionsDir(cwd, baseDir)) + } + } + + return [...targets] +} + +function timestampForFilename(timestamp: string): string { + return timestamp.replace(/[:.]/g, "-") +} + +function offsetTimestamp(baseTimestamp: string, offsetSeconds: number): string { + return new Date(new Date(baseTimestamp).getTime() + offsetSeconds * 1_000).toISOString() +} + +function writeSeededSessionFile(options: { + projectCwd: string + sessionsDir: string + sessionId: string + name: string + baseTimestamp: string + messages: SessionMessageSeed[] +}): SeededRuntimeSession { + const sessionPath = join(options.sessionsDir, `${timestampForFilename(options.baseTimestamp)}_${options.sessionId}.jsonl`) + const lines: string[] = [] + let parentId: string | null = null + + lines.push( + JSON.stringify({ + type: "session", + version: 3, + id: options.sessionId, + timestamp: options.baseTimestamp, + cwd: options.projectCwd, + }), + ) + + const infoId = `${options.sessionId}-info` + lines.push( + JSON.stringify({ + type: "session_info", + id: infoId, + parentId, + timestamp: offsetTimestamp(options.baseTimestamp, 1), + name: options.name, + }), + ) + parentId = infoId + + for (const [index, message] of options.messages.entries()) { + const entryId = `${options.sessionId}-entry-${index + 1}` + lines.push( + JSON.stringify({ + type: "message", + id: entryId, + parentId, + timestamp: offsetTimestamp(options.baseTimestamp, index + 2), + message, + }), + ) + parentId = entryId + } + + writeFileSync(sessionPath, `${lines.join("\n")}\n`) + const sessionTime = new Date(options.baseTimestamp) + utimesSync(sessionPath, sessionTime, sessionTime) + + return { + sessionId: options.sessionId, + name: options.name, + sessionPath, + } +} + +export function makeRuntimeWorkspaceFixture(): RuntimeWorkspaceFixture { + const root = mkdtempSync(join(tmpdir(), "gsd-web-runtime-fixture-")) + const projectCwd = join(root, "project") + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001") + const sliceDir = join(milestoneDir, "slices", "S02") + const tasksDir = join(sliceDir, "tasks") + + mkdirSync(tasksDir, { recursive: true }) + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Fixture Milestone\n\n## Slices\n- [ ] **S02: Fixture browser continuity** \`risk:low\` \`depends:[]\`\n`, + ) + writeFileSync( + join(sliceDir, "S02-PLAN.md"), + `# S02: Fixture browser continuity\n\n**Goal:** Fixture proof\n**Demo:** Fixture proof\n\n## Tasks\n- [ ] **T02: Preserve current-project truth across the launched host** \`est:5m\`\n`, + ) + writeFileSync( + join(tasksDir, "T02-PLAN.md"), + `# T02: Preserve current-project truth across the launched host\n\n## Steps\n- prove fixture cwd launch truth\n`, + ) + + return { + projectCwd, + expectedScope: "M001/S02/T02", + cleanup: () => rmSync(root, { recursive: true, force: true }), + } +} + +export function makeInterruptedRunRuntimeFixture(): RuntimeWorkspaceFixture { + const root = mkdtempSync(join(tmpdir(), "gsd-web-runtime-recovery-")) + const projectCwd = join(root, "project") + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M002") + const sliceDir = join(milestoneDir, "slices", "S04") + const tasksDir = join(sliceDir, "tasks") + + mkdirSync(tasksDir, { recursive: true }) + + writeFileSync( + join(milestoneDir, "M002-ROADMAP.md"), + [ + "# M002: Recovery Runtime Fixture", + "", + "## Slices", + "- [ ] **S04: Browser recovery continuity** `risk:high` `depends:[]`", + " > After this: launched-host recovery diagnostics stay truthful after reconnect.", + ].join("\n"), + ) + writeFileSync( + join(sliceDir, "S04-PLAN.md"), + [ + "# S04: Browser recovery continuity", + "", + "**Goal:** Keep launched-host recovery diagnostics truthful across reconnects.", + "**Demo:** A seeded interrupted-run project shows redacted browser recovery state without opening the TUI.", + "", + "## Tasks", + "- [x] **T02: Earlier recovery pass** `est:10m`", + "- [ ] **T03: Validate interrupted-run browser recovery** `est:15m`", + ].join("\n"), + ) + writeFileSync( + join(tasksDir, "T02-PLAN.md"), + [ + "# T02: Earlier recovery pass", + "", + "## Steps", + "- leave the summary missing so doctor diagnostics stay inspectable in the browser fixture", + ].join("\n"), + ) + writeFileSync( + join(tasksDir, "T03-PLAN.md"), + [ + "# T03: Validate interrupted-run browser recovery", + "", + "## Steps", + "- prove refresh, reload, and reopen against the seeded interrupted-run fixture", + ].join("\n"), + ) + + return { + projectCwd, + expectedScope: "M002/S04/T03", + cleanup: () => rmSync(root, { recursive: true, force: true }), + } +} + +export function seedCurrentProjectSession(options: { + projectCwd: string + baseSessionsDir: string + sessionId: string + name: string + baseTimestamp: string +}): { sessionsDir: string; session: SeededRuntimeSession } { + const targetSessionDirs = resolveSeedTargetSessionDirs(options.projectCwd, options.baseSessionsDir) + let session: SeededRuntimeSession | null = null + + for (const sessionsDir of targetSessionDirs) { + mkdirSync(sessionsDir, { recursive: true }) + const written = writeSeededSessionFile({ + projectCwd: canonicalizePath(options.projectCwd), + sessionsDir, + sessionId: options.sessionId, + name: options.name, + baseTimestamp: options.baseTimestamp, + messages: [ + { + role: "user", + content: "Review the current browser proof before starting a fresh live session.", + }, + { + role: "assistant", + content: "Queued the browser proof review and ready to continue.", + }, + ], + }) + session ??= written + } + + return { sessionsDir: targetSessionDirs[0]!, session: session! } +} + +export function seedInterruptedRunRecoverySessions(options: { + projectCwd: string + baseSessionsDir: string +}): SeededInterruptedRunRecovery { + const targetSessionDirs = resolveSeedTargetSessionDirs(options.projectCwd, options.baseSessionsDir) + + let alternateSession: SeededRuntimeSession | null = null + let activeSession: SeededRuntimeSession | null = null + const leakedSecret = "sk-runtime-recovery-secret-4321" + + for (const sessionsDir of targetSessionDirs) { + mkdirSync(sessionsDir, { recursive: true }) + + const writtenAlternate = writeSeededSessionFile({ + projectCwd: canonicalizePath(options.projectCwd), + sessionsDir, + sessionId: "sess-warmup", + name: "Warmup Session", + baseTimestamp: "2026-03-15T03:20:00.000Z", + messages: [ + { + role: "user", + content: "Check the previous workspace continuity proof.", + }, + { + role: "assistant", + content: "Workspace continuity proof was recorded and closed.", + }, + ], + }) + alternateSession ??= writtenAlternate + + const writtenActive = writeSeededSessionFile({ + projectCwd: canonicalizePath(options.projectCwd), + sessionsDir, + sessionId: "sess-recovery", + name: "Interrupted Recovery Session", + baseTimestamp: "2026-03-15T03:30:00.000Z", + messages: [ + { + role: "user", + content: "Resume the interrupted browser recovery proof and keep the diagnostics redacted.", + }, + { + role: "assistant", + content: [ + { + type: "toolCall", + id: "tool-read-1", + name: "read", + arguments: { path: ".gsd/milestones/M002/slices/S04/S04-PLAN.md" }, + }, + { + type: "toolCall", + id: "tool-write-1", + name: "write", + arguments: { + path: "notes/recovery-proof.md", + content: "interrupted recovery notes", + }, + }, + { + type: "toolCall", + id: "tool-bash-1", + name: "bash", + arguments: { command: "npm run verify:recovery" }, + }, + ], + }, + { + role: "toolResult", + toolCallId: "tool-bash-1", + toolName: "bash", + isError: true, + content: `authentication failed for ${leakedSecret}`, + }, + { + role: "assistant", + content: "The recovery proof stopped after the auth failure and needs a browser-visible follow-up path.", + }, + ], + }) + activeSession ??= writtenActive + } + + return { + sessionsDir: targetSessionDirs[0]!, + alternateSession: alternateSession!, + activeSession: activeSession!, + leakedSecret, + } +} diff --git a/src/tests/integration/web-mode-runtime-harness.ts b/src/tests/integration/web-mode-runtime-harness.ts new file mode 100644 index 000000000..fed508e34 --- /dev/null +++ b/src/tests/integration/web-mode-runtime-harness.ts @@ -0,0 +1,550 @@ +import assert from "node:assert/strict" +import { execFileSync, spawn } from "node:child_process" +import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs" +import { join } from "node:path" + +import type { Page, Request, Response } from "playwright" + +const projectRoot = process.cwd() +const resolveTsPath = join(projectRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +const loaderPath = join(projectRoot, "src", "loader.ts") +const builtAgentEntryPath = join(projectRoot, "packages", "pi-coding-agent", "dist", "index.js") +const packagedWebHostPath = join(projectRoot, "dist", "web", "standalone", "server.js") + +let runtimeArtifactsReady = false + +type RuntimeEndpoint = "boot" | "events" + +type RuntimeRequestDiagnostic = { + url: string + method: string + status: number | null + failure: string | null +} + +export type RuntimeLaunchResult = { + exitCode: number | null + stderr: string + stdout: string + url: string + port: number + /** Auth token extracted from the browser URL fragment, if present. */ + authToken: string | null + launchCwd: string + tempHome: string + browserLogPath: string +} + +export type BrowserBootResult = { + ok: boolean + status: number + boot: TBoot +} + +export type RuntimeNetworkDiagnostics = { + bootRequests: RuntimeRequestDiagnostic[] + sseRequests: RuntimeRequestDiagnostic[] +} + +export type RuntimeReadyProof = { + bootResult: BrowserBootResult + firstEvent: Record + diagnostics: RuntimeNetworkDiagnostics + visible: { + connectionStatus: string | null + scopeLabel: string | null + unitLabel: string | null + sessionBanner: string | null + projectPathTitle: string | null + sidebarRecoveryEntrypoint: string | null + recoveryPanelState: string | null + } +} + +export function writePreseededAuthFile(tempHome: string): void { + const agentDir = join(tempHome, ".gsd", "agent") + mkdirSync(agentDir, { recursive: true, mode: 0o700 }) + const authPath = join(agentDir, "auth.json") + const fakeCredential = { type: "api_key", key: "sk-ant-test-fake-key-for-runtime-test" } + writeFileSync(authPath, JSON.stringify({ anthropic: fakeCredential }, null, 2), { encoding: "utf-8", mode: 0o600 }) +} + +function createBrowserOpenStub(binDir: string, logPath: string): void { + const command = process.platform === "darwin" ? "open" : "xdg-open" + const script = `#!/bin/sh\nprintf '%s\n' "$1" >> "${logPath}"\nexit 0\n` + const scriptPath = join(binDir, command) + writeFileSync(scriptPath, script, "utf-8") + chmodSync(scriptPath, 0o755) +} + +function runNpmScript(args: string[], label: string): void { + try { + execFileSync("npm", args, { + cwd: projectRoot, + encoding: "utf-8", + env: { + ...process.env, + PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1", + }, + stdio: ["ignore", "pipe", "pipe"], + }) + } catch (error) { + const failure = error as { stdout?: string; stderr?: string; message: string } + throw new Error(`${label} failed: ${failure.message}\n${failure.stdout ?? ""}\n${failure.stderr ?? ""}`.trim()) + } +} + +export function ensureRuntimeArtifacts(): void { + if (runtimeArtifactsReady) return + + if (!existsSync(builtAgentEntryPath)) { + runNpmScript(["run", "build:pi"], "npm run build:pi") + } + + if (!existsSync(packagedWebHostPath)) { + runNpmScript(["run", "build:web-host"], "npm run build:web-host") + } + + runtimeArtifactsReady = true +} + +export function parseStartedUrl(stderr: string): string { + const match = stderr.match(/\[gsd\] Web mode startup: status=started[^\n]*url=(http:\/\/[^\s]+)/) + if (!match) { + throw new Error(`Did not find successful web startup line in stderr:\n${stderr}`) + } + return match[1] +} + +export async function launchPackagedWebHost(options: { + launchCwd: string + tempHome: string + browserLogPath?: string + env?: NodeJS.ProcessEnv + timeoutMs?: number +}): Promise { + ensureRuntimeArtifacts() + + mkdirSync(join(options.tempHome, ".gsd"), { recursive: true }) + const browserLogPath = options.browserLogPath ?? join(options.tempHome, "browser-open.log") + const fakeBin = join(options.tempHome, "fake-bin") + mkdirSync(fakeBin, { recursive: true }) + createBrowserOpenStub(fakeBin, browserLogPath) + + return await new Promise((resolve, reject) => { + let stdout = "" + let stderr = "" + let settled = false + + const child = spawn( + process.execPath, + ["--import", resolveTsPath, "--experimental-strip-types", loaderPath, "--web"], + { + cwd: options.launchCwd, + env: { + ...process.env, + HOME: options.tempHome, + PATH: `${fakeBin}:${process.env.PATH || ""}`, + CI: "1", + FORCE_COLOR: "0", + ...options.env, + }, + stdio: ["ignore", "pipe", "pipe"], + }, + ) + + const finish = (result: RuntimeLaunchResult | Error) => { + if (settled) return + settled = true + clearTimeout(timeout) + if (result instanceof Error) { + reject(result) + return + } + resolve(result) + } + + const timeout = setTimeout(() => { + child.kill("SIGTERM") + finish(new Error(`Timed out waiting for gsd --web to exit. stderr so far:\n${stderr}`)) + }, options.timeoutMs ?? 180_000) + + child.stdout.on("data", (chunk: Buffer) => { + stdout += chunk.toString() + }) + + child.stderr.on("data", (chunk: Buffer) => { + stderr += chunk.toString() + }) + + child.once("error", (error) => finish(error)) + child.once("close", (code) => { + try { + const url = parseStartedUrl(stderr) + const parsed = new URL(url) + // Extract the auth token from the browser-open stub log. + // The launcher passes `http://host:port/#token=` to `open`. + let authToken: string | null = null + try { + if (existsSync(browserLogPath)) { + const openedUrl = readFileSync(browserLogPath, "utf-8").trim() + const tokenMatch = openedUrl.match(/#token=([a-fA-F0-9]+)/) + if (tokenMatch) authToken = tokenMatch[1] + } + } catch { + // Non-fatal — tests that don't need the token can proceed without it + } + finish({ + exitCode: code, + stderr, + stdout, + url, + port: Number(parsed.port), + authToken, + launchCwd: options.launchCwd, + tempHome: options.tempHome, + browserLogPath, + }) + } catch (error) { + finish(error as Error) + } + }) + }) +} + +export async function waitForHttpOk(url: string, timeoutMs = 60_000, headers?: Record): Promise { + const deadline = Date.now() + timeoutMs + let lastError: unknown = null + + while (Date.now() < deadline) { + try { + const remainingMs = Math.max(5_000, deadline - Date.now()) + const requestTimeoutMs = Math.min(15_000, remainingMs) + const response = await fetch(url, { method: "GET", headers, signal: AbortSignal.timeout(requestTimeoutMs) }) + if (response.ok) return + lastError = new Error(`Unexpected ${response.status} for ${url}`) + } catch (error) { + lastError = error + } + + await new Promise((resolve) => setTimeout(resolve, 500)) + } + + throw new Error(`Timed out waiting for ${url}: ${lastError instanceof Error ? lastError.message : String(lastError)}`) +} + +/** + * Build an Authorization header object from a launch result's auth token. + * Returns an empty object if no token is present (server launched without auth). + */ +export function runtimeAuthHeaders(launch: RuntimeLaunchResult): Record { + if (!launch.authToken) return {} + return { Authorization: `Bearer ${launch.authToken}` } +} + +export async function killProcessOnPort(port: number): Promise { + const readListenerPids = (): number[] => { + try { + const output = execFileSync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"], { + encoding: "utf-8", + stdio: ["ignore", "pipe", "ignore"], + }).trim() + return output + .split(/\s+/) + .filter(Boolean) + .map((pid) => Number(pid)) + .filter((pid) => Number.isFinite(pid) && pid !== process.pid) + } catch { + return [] + } + } + + const initialPids = readListenerPids() + for (const pid of initialPids) { + try { + process.kill(pid, "SIGTERM") + } catch { + // Best-effort cleanup only. + } + } + + const deadline = Date.now() + 5_000 + while (Date.now() < deadline) { + if (readListenerPids().length === 0) { + return + } + await new Promise((resolve) => setTimeout(resolve, 100)) + } +} + +export async function assertBrowserOpenAttempt(browserLogPath: string, expectedUrl: string, timeoutMs = 5_000): Promise { + const expectedUrlPattern = new RegExp(escapeRegExp(expectedUrl)) + const deadline = Date.now() + timeoutMs + let openedUrls = "" + + while (Date.now() < deadline) { + if (existsSync(browserLogPath)) { + openedUrls = readFileSync(browserLogPath, "utf-8") + if (expectedUrlPattern.test(openedUrls)) { + return + } + } + + await new Promise((resolve) => setTimeout(resolve, 100)) + } + + assert.ok(existsSync(browserLogPath), `expected the launcher to attempt opening the browser within ${timeoutMs}ms`) + openedUrls = readFileSync(browserLogPath, "utf-8") + assert.match(openedUrls, expectedUrlPattern) +} + +export async function fetchBootInPage(page: Page): Promise> { + return await page.evaluate(async () => { + const response = await fetch("/api/boot", { + method: "GET", + headers: { + Accept: "application/json", + }, + }) + + return { + ok: response.ok, + status: response.status, + boot: await response.json(), + } + }) +} + +export async function readFirstSseEventInPage(page: Page, timeoutMs = 15_000): Promise> { + return await page.evaluate( + async ({ timeoutMs }) => { + return await new Promise>((resolve, reject) => { + const source = new EventSource("/api/session/events") + const timer = window.setTimeout(() => { + source.close() + reject(new Error("Timed out waiting for the first SSE event")) + }, timeoutMs) + + source.onmessage = (event) => { + window.clearTimeout(timer) + source.close() + try { + resolve(JSON.parse(event.data) as Record) + } catch (error) { + reject(error instanceof Error ? error : new Error(String(error))) + } + } + + source.onerror = () => { + window.clearTimeout(timer) + source.close() + reject(new Error("EventSource failed before the first SSE payload")) + } + }) + }, + { timeoutMs }, + ) +} + +function createRuntimeNetworkDiagnostics(page: Page): { + snapshot: () => RuntimeNetworkDiagnostics + dispose: () => void +} { + const bootRequests: RuntimeRequestDiagnostic[] = [] + const sseRequests: RuntimeRequestDiagnostic[] = [] + const trackedRequests = new Map() + + const classifyEndpoint = (url: string): RuntimeEndpoint | null => { + const pathname = new URL(url).pathname + if (pathname === "/api/boot") return "boot" + if (pathname === "/api/session/events") return "events" + return null + } + + const onRequest = (request: Request) => { + const endpoint = classifyEndpoint(request.url()) + if (!endpoint) return + + const entry: RuntimeRequestDiagnostic = { + url: request.url(), + method: request.method(), + status: null, + failure: null, + } + + trackedRequests.set(request, entry) + if (endpoint === "boot") { + bootRequests.push(entry) + return + } + sseRequests.push(entry) + } + + const onResponse = (response: Response) => { + const entry = trackedRequests.get(response.request()) + if (!entry) return + entry.status = response.status() + } + + const onRequestFailed = (request: Request) => { + const entry = trackedRequests.get(request) + if (!entry) return + entry.failure = request.failure()?.errorText ?? "request failed" + } + + page.on("request", onRequest) + page.on("response", onResponse) + page.on("requestfailed", onRequestFailed) + + return { + snapshot: () => ({ + bootRequests: bootRequests.map((entry) => ({ ...entry })), + sseRequests: sseRequests.map((entry) => ({ ...entry })), + }), + dispose: () => { + page.off("request", onRequest) + page.off("response", onResponse) + page.off("requestfailed", onRequestFailed) + }, + } +} + +function formatRequestDiagnostics(diagnostics: RuntimeNetworkDiagnostics): string { + const formatEntries = (entries: RuntimeRequestDiagnostic[]) => { + if (entries.length === 0) return "none" + return entries + .map((entry) => { + const status = entry.status === null ? "pending" : String(entry.status) + return `${entry.method} ${entry.url} status=${status}${entry.failure ? ` failure=${entry.failure}` : ""}` + }) + .join(" | ") + } + + return `browser /api/boot: ${formatEntries(diagnostics.bootRequests)}\nbrowser /api/session/events: ${formatEntries(diagnostics.sseRequests)}` +} + +function buildFailureContext(label: string, diagnostics: RuntimeNetworkDiagnostics, launchStderr?: string): string { + return [ + `${label} diagnostics:`, + formatRequestDiagnostics(diagnostics), + launchStderr ? `launcher stderr:\n${launchStderr}` : null, + ] + .filter(Boolean) + .join("\n") +} + +function normalizeComparablePath(path: string | null | undefined): string | null { + if (!path) return path ?? null + try { + return realpathSync.native?.(path) ?? realpathSync(path) + } catch { + return path + } +} + +function escapeRegExp(value: string): string { + return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") +} + +export async function waitForLaunchedHostReady( + page: Page, + options: { + label: string + expectedProjectCwd: string + expectedSessionsDir?: string | string[] + launchStderr?: string + navigation?: () => Promise + timeoutMs?: number + }, +): Promise> { + const markerTimeout = options.timeoutMs ?? 60_000 + const requestProbe = createRuntimeNetworkDiagnostics(page) + + try { + await options.navigation?.() + + const bootResult = await fetchBootInPage(page) + const firstEvent = await readFirstSseEventInPage(page) + + await page.waitForFunction( + () => { + const node = document.querySelector('[data-testid="sidebar-current-scope"]') + return Boolean(node?.textContent?.match(/M\d+(?:\/S\d+(?:\/T\d+)?)?/)) + }, + null, + { timeout: markerTimeout }, + ) + await page.waitForSelector('[data-testid="sidebar-recovery-summary-entrypoint"]', { + state: "visible", + timeout: markerTimeout, + }) + + const diagnostics = requestProbe.snapshot() + const failureContext = buildFailureContext(options.label, diagnostics, options.launchStderr) + + assert.equal(bootResult.ok, true, `${options.label}: expected /api/boot to respond successfully, got ${bootResult.status}\n${failureContext}`) + assert.ok(diagnostics.bootRequests.length > 0, `${options.label}: expected browser-visible /api/boot traffic\n${failureContext}`) + assert.ok(diagnostics.bootRequests.some((entry) => entry.status === 200), `${options.label}: browser never saw a 200 /api/boot response\n${failureContext}`) + assert.ok(diagnostics.bootRequests.every((entry) => entry.failure === null), `${options.label}: browser /api/boot request failed\n${failureContext}`) + assert.ok(diagnostics.sseRequests.length > 0, `${options.label}: expected browser-visible /api/session/events traffic\n${failureContext}`) + assert.ok(diagnostics.sseRequests.some((entry) => entry.status === 200), `${options.label}: browser never saw a 200 /api/session/events response\n${failureContext}`) + assert.ok( + diagnostics.sseRequests.every((entry) => entry.failure === null || /ERR_ABORTED/i.test(entry.failure)), + `${options.label}: browser /api/session/events hit an unexpected network failure\n${failureContext}`, + ) + + const boot = bootResult.boot + const normalizedExpectedProjectCwd = normalizeComparablePath(options.expectedProjectCwd) + const normalizedBootProjectCwd = normalizeComparablePath(boot.project.cwd) + assert.equal(normalizedBootProjectCwd, normalizedExpectedProjectCwd, `${options.label}: boot project cwd drifted\n${failureContext}`) + if (options.expectedSessionsDir) { + const expectedSessionsDirs = (Array.isArray(options.expectedSessionsDir) ? options.expectedSessionsDir : [options.expectedSessionsDir]) + .map((entry) => normalizeComparablePath(entry)) + const normalizedBootSessionsDir = normalizeComparablePath(boot.project.sessionsDir) + assert.ok( + expectedSessionsDirs.includes(normalizedBootSessionsDir), + `${options.label}: boot sessions dir drifted\nexpected one of ${JSON.stringify(expectedSessionsDirs)}\nreceived ${JSON.stringify(normalizedBootSessionsDir)}\n${failureContext}`, + ) + } + assert.equal(boot.bridge.phase, "ready", `${options.label}: boot bridge phase was not ready\n${failureContext}`) + assert.equal(typeof boot.bridge.activeSessionId, "string", `${options.label}: boot missed activeSessionId\n${failureContext}`) + assert.ok((boot.bridge.activeSessionId ?? "").length > 0, `${options.label}: boot activeSessionId was empty\n${failureContext}`) + + const bridgeEvent = firstEvent as { + type?: string + bridge?: { phase?: string; activeSessionId?: string; connectionCount?: number } + } + assert.equal(bridgeEvent.type, "bridge_status", `${options.label}: first SSE payload drifted away from bridge_status\n${failureContext}`) + assert.equal(bridgeEvent.bridge?.phase, "ready", `${options.label}: first SSE bridge phase was not ready\n${failureContext}`) + assert.equal(typeof bridgeEvent.bridge?.activeSessionId, "string", `${options.label}: first SSE payload missed activeSessionId\n${failureContext}`) + assert.ok((bridgeEvent.bridge?.activeSessionId ?? "").length > 0, `${options.label}: first SSE activeSessionId was empty\n${failureContext}`) + assert.ok((bridgeEvent.bridge?.connectionCount ?? 0) >= 1, `${options.label}: first SSE connection count never became active\n${failureContext}`) + + const visible = { + scopeLabel: await page.locator('[data-testid="sidebar-current-scope"]').textContent(), + unitLabel: await page.locator('[data-testid="status-bar-unit"]').textContent(), + sessionBanner: await page.locator('[data-testid="terminal-session-banner"]').textContent().catch(() => null), + projectPathTitle: await page.locator('[data-testid="workspace-project-cwd"]').getAttribute("title"), + sidebarRecoveryEntrypoint: await page.locator('[data-testid="sidebar-recovery-summary-entrypoint"]').textContent(), + recoveryPanelState: null as string | null, + } + + assert.match(visible.scopeLabel ?? "", /M\d+(?:\/S\d+(?:\/T\d+)?)?/, `${options.label}: current scope marker never became visible\n${failureContext}`) + assert.match(visible.unitLabel ?? "", /M\d+(?:\/S\d+(?:\/T\d+)?)?|project\s+—/, `${options.label}: status-bar unit marker drifted\n${failureContext}`) + assert.equal( + normalizeComparablePath(visible.projectPathTitle), + normalizedExpectedProjectCwd, + `${options.label}: browser shell showed the wrong current project path\n${failureContext}`, + ) + assert.ok((visible.sidebarRecoveryEntrypoint ?? "").trim().length > 0, `${options.label}: sidebar recovery entrypoint was empty\n${failureContext}`) + + return { + bootResult, + firstEvent, + diagnostics, + visible, + } + } finally { + requestProbe.dispose() + } +} diff --git a/src/tests/pty-chat-parser.test.ts b/src/tests/pty-chat-parser.test.ts new file mode 100644 index 000000000..5ed060fb0 --- /dev/null +++ b/src/tests/pty-chat-parser.test.ts @@ -0,0 +1,21 @@ +import test from "node:test"; +import assert from "node:assert/strict"; + +const { PtyChatParser } = await import("../../web/lib/pty-chat-parser.ts"); + +test("PtyChatParser.flush emits a trailing partial line without waiting for a newline", () => { + const parser = new PtyChatParser("test"); + let latest = parser.getMessages(); + parser.onMessage(() => { + latest = parser.getMessages(); + }); + + parser.feed("All slices are complete — nothing to discuss."); + assert.equal(latest.length, 0, "partial line should stay buffered before flush"); + + parser.flush(); + + assert.equal(latest.length, 1); + assert.equal(latest[0]?.role, "assistant"); + assert.equal(latest[0]?.content, "All slices are complete — nothing to discuss.\n"); +}); diff --git a/src/tests/web-bridge-contract.test.ts b/src/tests/web-bridge-contract.test.ts new file mode 100644 index 000000000..1f29ad4ab --- /dev/null +++ b/src/tests/web-bridge-contract.test.ts @@ -0,0 +1,661 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); +const bridge = await import("../web/bridge-service.ts"); +const onboarding = await import("../web/onboarding-service.ts"); +const { AuthStorage } = await import("@gsd/pi-coding-agent"); +const bootRoute = await import("../../web/app/api/boot/route.ts"); +const commandRoute = await import("../../web/app/api/session/command/route.ts"); +const eventsRoute = await import("../../web/app/api/session/events/route.ts"); + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-bridge-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo Milestone\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n > After this: demo works\n`, + ); + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- real bridge\n\n## Tasks\n- [ ] **T01: Wire boot** \`est:10m\`\n Do the work.\n`, + ); + writeFileSync( + join(tasksDir, "T01-PLAN.md"), + `# T01: Wire boot\n\n## Steps\n- do it\n`, + ); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile(projectCwd: string, sessionsDir: string, sessionId: string, name: string): string { + const sessionPath = join(sessionsDir, `2026-03-14T18-00-00-000Z_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp: "2026-03-14T18:00:00.000Z", + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: "info-1", + parentId: null, + timestamp: "2026-03-14T18:00:01.000Z", + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)); +} + +function fakeAutoDashboardData() { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function writeAutoDashboardModule(root: string, payload: Record): string { + const modulePath = join(root, "fake-auto-dashboard.mjs"); + writeFileSync( + modulePath, + `export function getAutoDashboardData() { return ${JSON.stringify(payload)}; }\n`, + ); + return modulePath; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo Milestone", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S01", + title: "Demo Slice", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S01/tasks", + tasks: [ + { + id: "T01", + title: "Wire boot", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md", + }, + ], + }, + ], + }, + ], + active: { + milestoneId: "M001", + sliceId: "S01", + taskId: "T01", + phase: "executing", + }, + scopes: [ + { scope: "project", label: "project", kind: "project" }, + { scope: "M001", label: "M001: Demo Milestone", kind: "milestone" }, + { scope: "M001/S01", label: "M001/S01: Demo Slice", kind: "slice" }, + { scope: "M001/S01/T01", label: "M001/S01/T01: Wire boot", kind: "task" }, + ], + validationIssues: [], + }; +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let spawnCalls = 0; + let child: FakeRpcChild | null = null; + const commands: any[] = []; + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + spawnCalls += 1; + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + const parsed = JSON.parse(line); + commands.push(parsed); + onCommand(parsed, harness); + }); + void command; + void args; + void options; + return child as any; + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started"); + child.stdout.write(serializeJsonLine(payload)); + }, + stderr(text: string) { + if (!child) throw new Error("fake child not started"); + child.stderr.write(text); + }, + exit(code = 1, signal: NodeJS.Signals | null = null) { + if (!child) throw new Error("fake child not started"); + child.exitCode = code; + queueMicrotask(() => { + child?.emit("exit", code, signal); + }); + }, + get spawnCalls() { + return spawnCalls; + }, + get commands() { + return commands; + }, + get child() { + return child; + }, + }; + + return harness; +} + +async function readSseEvents(response: Response, count: number): Promise { + const reader = response.body?.getReader(); + assert.ok(reader, "SSE response has a body reader"); + const decoder = new TextDecoder(); + const events: any[] = []; + let buffer = ""; + + while (events.length < count) { + const result = await Promise.race([ + reader.read(), + new Promise((_, reject) => setTimeout(() => reject(new Error("Timed out reading SSE events")), 1_500)), + ]); + + if (result.done) break; + buffer += decoder.decode(result.value, { stream: true }); + + while (true) { + const boundary = buffer.indexOf("\n\n"); + if (boundary === -1) break; + const chunk = buffer.slice(0, boundary); + buffer = buffer.slice(boundary + 2); + const dataLine = chunk.split("\n").find((line) => line.startsWith("data: ")); + if (!dataLine) continue; + events.push(JSON.parse(dataLine.slice(6))); + if (events.length >= count) { + return events; + } + } + } + + await reader.cancel(); + return events; +} + +test("/api/boot returns current-project workspace data, resumable sessions, onboarding seam, and bridge snapshot", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-boot", "Resume Me"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-boot", + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + assert.fail(`unexpected command during boot: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const response = await bootRoute.GET(); + assert.equal(response.status, 200); + const payload = await response.json() as any; + + assert.equal(payload.project.cwd, fixture.projectCwd); + assert.equal(payload.project.sessionsDir, fixture.sessionsDir); + assert.equal(payload.workspace.active.milestoneId, "M001"); + assert.equal(payload.workspace.active.sliceId, "S01"); + assert.equal(payload.workspace.active.taskId, "T01"); + assert.equal(payload.onboardingNeeded, false); + assert.equal(payload.resumableSessions.length, 1); + assert.equal(payload.resumableSessions[0].id, "sess-boot"); + assert.equal(payload.resumableSessions[0].path, sessionPath); + assert.equal(payload.resumableSessions[0].isActive, true); + assert.equal("firstMessage" in payload.resumableSessions[0], false); + assert.equal("allMessagesText" in payload.resumableSessions[0], false); + assert.equal("parentSessionPath" in payload.resumableSessions[0], false); + assert.equal("depth" in payload.resumableSessions[0], false); + assert.equal(payload.bridge.phase, "ready"); + assert.equal(payload.bridge.activeSessionId, "sess-boot"); + assert.equal(payload.bridge.sessionState.sessionId, "sess-boot"); + assert.equal(payload.bridge.sessionState.autoRetryEnabled, false); + assert.equal(payload.bridge.sessionState.retryInProgress, false); + assert.equal(payload.bridge.sessionState.retryAttempt, 0); + assert.equal(harness.spawnCalls, 1); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("/api/boot uses the authoritative auto helper by default and stays snapshot-shaped", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-auto", "Authoritative Auto"); + const authoritativeAuto = { + active: true, + paused: false, + stepMode: true, + startTime: 1_111, + elapsed: 2_222, + currentUnit: { type: "execute-task", id: "M002/S03/T01", startedAt: 3_333 }, + completedUnits: [{ type: "plan-slice", id: "M002/S03", startedAt: 444, finishedAt: 555 }], + basePath: fixture.projectCwd, + totalCost: 12.34, + totalTokens: 4_242, + }; + const autoModulePath = writeAutoDashboardModule(fixture.projectCwd, authoritativeAuto); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-auto", + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + assert.fail(`unexpected command during authoritative auto boot: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + GSD_WEB_TEST_AUTO_DASHBOARD_MODULE: autoModulePath, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getOnboardingNeeded: () => false, + }); + + try { + const response = await bootRoute.GET(); + assert.equal(response.status, 200); + const payload = await response.json() as any; + + assert.deepEqual( + Object.keys(payload).sort(), + ["auto", "bridge", "onboarding", "onboardingNeeded", "project", "projectDetection", "resumableSessions", "workspace"], + "/api/boot must remain snapshot-shaped while auto truth becomes authoritative", + ); + assert.deepEqual(payload.auto, authoritativeAuto, "default boot path should read authoritative auto dashboard data"); + assert.notEqual(payload.auto.startTime, 0, "authoritative auto helper must replace the all-zero fallback payload"); + assert.equal("recovery" in payload, false, "/api/boot should not grow a recovery diagnostics payload in T01"); + assert.equal("liveState" in payload, false, "/api/boot should not expose live invalidation payloads directly"); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("bridge service is a singleton for the project runtime and /api/session/command forwards real RPC responses", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-shared", "Shared Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-shared", + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const serviceA = bridge.getProjectBridgeService(); + const serviceB = bridge.getProjectBridgeService(); + assert.strictEqual(serviceA, serviceB); + + const first = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "get_state" }), + }), + ); + const firstBody = await first.json() as any; + assert.equal(first.status, 200); + assert.equal(firstBody.success, true); + assert.equal(firstBody.command, "get_state"); + assert.equal(firstBody.data.sessionId, "sess-shared"); + + const second = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "get_state" }), + }), + ); + const secondBody = await second.json() as any; + assert.equal(second.status, 200); + assert.equal(secondBody.data.sessionId, "sess-shared"); + assert.equal(harness.spawnCalls, 1); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("/api/session/events streams bridge status, agent events, and extension_ui_request payloads over SSE", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-events", "Events Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-events", + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const controller = new AbortController(); + const response = await eventsRoute.GET( + new Request("http://localhost/api/session/events", { signal: controller.signal }), + ); + + harness.emit({ type: "agent_start" }); + harness.emit({ + type: "extension_ui_request", + id: "ui-1", + method: "confirm", + title: "Need approval", + message: "Continue?", + }); + + const events = await readSseEvents(response, 3); + assert.equal(events[0].type, "bridge_status"); + assert.equal(events[0].bridge.connectionCount, 1); + assert.ok(events.some((event) => event.type === "agent_start")); + assert.ok(events.some((event) => event.type === "extension_ui_request")); + + assert.equal(bridge.getProjectBridgeService().getSnapshot().connectionCount, 1); + controller.abort(); + await waitForMicrotasks(); + assert.equal(bridge.getProjectBridgeService().getSnapshot().connectionCount, 0); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("bridge command/runtime failures are inspectable and redact secret material", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-failure", "Failure Session"); + + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + anthropic: { type: "api_key", key: "sk-test-bridge-failure" }, + } as any), + }); + + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-failure", + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + if (command.type === "bash") { + current.emit({ + id: command.id, + type: "response", + command: "bash", + success: false, + error: "authentication failed for sk-test-command-secret-9999", + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const response = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "bash", command: "echo test" }), + }), + ); + const body = await response.json() as any; + + assert.equal(response.status, 502); + assert.equal(body.success, false); + assert.match(body.error, /authentication failed/i); + assert.doesNotMatch(body.error, /sk-test-command-secret-9999/); + + harness.stderr("fatal runtime error: sk-after-attach-12345"); + harness.exit(1); + await waitForMicrotasks(); + + const snapshot = bridge.getProjectBridgeService().getSnapshot(); + assert.equal(snapshot.phase, "failed"); + assert.equal(snapshot.lastError?.afterSessionAttachment, true); + assert.doesNotMatch(snapshot.lastError?.message ?? "", /sk-after-attach-12345|sk-test-command-secret-9999/); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); diff --git a/src/tests/web-bridge-terminal-contract.test.ts b/src/tests/web-bridge-terminal-contract.test.ts new file mode 100644 index 000000000..8ac38db2d --- /dev/null +++ b/src/tests/web-bridge-terminal-contract.test.ts @@ -0,0 +1,367 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); +const bridge = await import("../web/bridge-service.ts"); +const streamRoute = await import("../../web/app/api/bridge-terminal/stream/route.ts"); +const inputRoute = await import("../../web/app/api/bridge-terminal/input/route.ts"); +const resizeRoute = await import("../../web/app/api/bridge-terminal/resize/route.ts"); + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)); +} + +async function waitFor(check: () => T | null | undefined, timeoutMs = 1500): Promise { + const started = Date.now(); + while (Date.now() - started < timeoutMs) { + const value = check(); + if (value != null) { + return value; + } + await waitForMicrotasks(); + } + throw new Error("Timed out waiting for condition"); +} + +async function readSseEvents(response: Response, count: number): Promise { + const reader = response.body?.getReader(); + assert.ok(reader, "SSE response has a body reader"); + const decoder = new TextDecoder(); + const events: any[] = []; + let buffer = ""; + + while (events.length < count) { + const result = await Promise.race([ + reader.read(), + new Promise((_, reject) => setTimeout(() => reject(new Error("Timed out reading SSE events")), 1_500)), + ]); + + if (result.done) break; + buffer += decoder.decode(result.value, { stream: true }); + + while (true) { + const boundary = buffer.indexOf("\n\n"); + if (boundary === -1) break; + const chunk = buffer.slice(0, boundary); + buffer = buffer.slice(boundary + 2); + const dataLine = chunk.split("\n").find((line) => line.startsWith("data: ")); + if (!dataLine) continue; + events.push(JSON.parse(dataLine.slice(6))); + if (events.length >= count) { + await reader.cancel(); + return events; + } + } + } + + await reader.cancel(); + return events; +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-bridge-terminal-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + mkdirSync(projectCwd, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let child: FakeRpcChild | null = null; + const commands: any[] = []; + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + void command; + void args; + void options; + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + const parsed = JSON.parse(line); + commands.push(parsed); + onCommand(parsed, harness); + }); + return child as any; + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started"); + child.stdout.write(serializeJsonLine(payload)); + }, + get commands() { + return commands; + }, + }; + + return harness; +} + +test("/api/bridge-terminal/stream attaches to the main bridge runtime and forwards native terminal output", async () => { + const fixture = makeWorkspaceFixture(); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-main", + sessionFile: join(fixture.sessionsDir, "sess-main.jsonl"), + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + if (command.type === "terminal_resize") { + current.emit({ id: command.id, type: "response", command: "terminal_resize", success: true }); + return; + } + + if (command.type === "terminal_redraw") { + current.emit({ id: command.id, type: "response", command: "terminal_redraw", success: true }); + queueMicrotask(() => { + current.emit({ type: "terminal_output", data: "\u001b[2J\u001b[Hnative main session" }); + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + }); + + try { + const response = await streamRoute.GET( + new Request("http://localhost/api/bridge-terminal/stream?cols=132&rows=41"), + ); + + const events = await readSseEvents(response, 2); + assert.equal(events[0].type, "connected"); + assert.equal(events[1].type, "output"); + assert.match(events[1].data, /native main session/); + + assert.ok(harness.commands.some((command) => command.type === "terminal_resize" && command.cols === 132 && command.rows === 41)); + assert.ok(harness.commands.some((command) => command.type === "terminal_redraw")); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("bridge-terminal input and resize routes forward browser terminal traffic onto the authoritative bridge session", async () => { + const fixture = makeWorkspaceFixture(); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-main", + sessionFile: join(fixture.sessionsDir, "sess-main.jsonl"), + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + if (command.type === "terminal_input") { + current.emit({ id: command.id, type: "response", command: "terminal_input", success: true }); + return; + } + + if (command.type === "terminal_resize") { + current.emit({ id: command.id, type: "response", command: "terminal_resize", success: true }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + }); + + try { + const inputResponse = await inputRoute.POST( + new Request("http://localhost/api/bridge-terminal/input", { + method: "POST", + body: JSON.stringify({ data: "hello from xterm" }), + }), + ); + assert.equal(inputResponse.status, 200); + + const resizeResponse = await resizeRoute.POST( + new Request("http://localhost/api/bridge-terminal/resize", { + method: "POST", + body: JSON.stringify({ cols: 140, rows: 48 }), + }), + ); + assert.equal(resizeResponse.status, 200); + + assert.ok(harness.commands.some((command) => command.type === "terminal_input" && command.data === "hello from xterm")); + assert.ok(harness.commands.some((command) => command.type === "terminal_resize" && command.cols === 140 && command.rows === 48)); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("session_state_changed from the native main-session TUI refreshes bridge state and emits matching live invalidations", async () => { + const fixture = makeWorkspaceFixture(); + const sessionAPath = join(fixture.sessionsDir, "sess-a.jsonl"); + const sessionBPath = join(fixture.sessionsDir, "sess-b.jsonl"); + let activeSessionId = "sess-a"; + let activeSessionFile = sessionAPath; + const seenEvents: Array<{ type?: string; reason?: string }> = []; + + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: activeSessionId, + sessionFile: activeSessionFile, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + }); + + try { + const service = bridge.getProjectBridgeService(); + const unsubscribe = service.subscribe((event) => { + seenEvents.push(event as { type?: string; reason?: string }); + }); + + await service.ensureStarted(); + activeSessionId = "sess-b"; + activeSessionFile = sessionBPath; + harness.emit({ type: "session_state_changed", reason: "switch_session" }); + + await waitFor(() => { + const snapshot = service.getSnapshot(); + return snapshot.activeSessionId === "sess-b" ? snapshot : null; + }); + + assert.ok( + seenEvents.some((event) => event.type === "live_state_invalidation" && event.reason === "switch_session"), + "switch_session live_state_invalidation should be emitted when the native TUI changes the active session", + ); + + unsubscribe(); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); diff --git a/src/tests/web-cli-entry.test.ts b/src/tests/web-cli-entry.test.ts new file mode 100644 index 000000000..09eafb3f4 --- /dev/null +++ b/src/tests/web-cli-entry.test.ts @@ -0,0 +1,105 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { join } from "node:path"; +import { tmpdir } from "node:os"; +import { pathToFileURL } from "node:url"; + +const { resolveGsdCliEntry } = await import("../web/cli-entry.ts"); + +function makeFixture(paths: string[]): string { + const root = mkdtempSync(join(tmpdir(), "gsd-cli-entry-")); + for (const relativePath of paths) { + const fullPath = join(root, relativePath); + mkdirSync(join(fullPath, ".."), { recursive: true }); + writeFileSync(fullPath, "// fixture\n"); + } + return root; +} + +test("resolveGsdCliEntry prefers the built loader for packaged standalone interactive sessions", () => { + const packageRoot = makeFixture([ + "dist/loader.js", + "src/loader.ts", + "src/resources/extensions/gsd/tests/resolve-ts.mjs", + ]); + + try { + const entry = resolveGsdCliEntry({ + packageRoot, + cwd: "/tmp/project-a", + execPath: "/custom/node", + hostKind: "packaged-standalone", + mode: "interactive", + }); + + assert.deepEqual(entry, { + command: "/custom/node", + args: [join(packageRoot, "dist", "loader.js")], + cwd: "/tmp/project-a", + }); + } finally { + rmSync(packageRoot, { recursive: true, force: true }); + } +}); + +test("resolveGsdCliEntry prefers the source loader for source-dev interactive sessions", () => { + const packageRoot = makeFixture([ + "dist/loader.js", + "src/loader.ts", + "src/resources/extensions/gsd/tests/resolve-ts.mjs", + ]); + + try { + const entry = resolveGsdCliEntry({ + packageRoot, + cwd: "/tmp/project-b", + execPath: "/custom/node", + hostKind: "source-dev", + mode: "interactive", + }); + + assert.deepEqual(entry, { + command: "/custom/node", + args: [ + "--import", + pathToFileURL(join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs")).href, + "--experimental-strip-types", + join(packageRoot, "src", "loader.ts"), + ], + cwd: "/tmp/project-b", + }); + } finally { + rmSync(packageRoot, { recursive: true, force: true }); + } +}); + +test("resolveGsdCliEntry appends rpc arguments for bridge sessions", () => { + const packageRoot = makeFixture(["dist/loader.js"]); + + try { + const entry = resolveGsdCliEntry({ + packageRoot, + cwd: "/tmp/project-c", + execPath: "/custom/node", + hostKind: "packaged-standalone", + mode: "rpc", + sessionDir: "/tmp/.gsd/sessions/project-c", + }); + + assert.deepEqual(entry, { + command: "/custom/node", + args: [ + join(packageRoot, "dist", "loader.js"), + "--mode", + "rpc", + "--continue", + "--session-dir", + "/tmp/.gsd/sessions/project-c", + ], + cwd: "/tmp/project-c", + }); + } finally { + rmSync(packageRoot, { recursive: true, force: true }); + } +}); diff --git a/src/tests/web-command-parity-contract.test.ts b/src/tests/web-command-parity-contract.test.ts new file mode 100644 index 000000000..ada364c77 --- /dev/null +++ b/src/tests/web-command-parity-contract.test.ts @@ -0,0 +1,692 @@ +import test from "node:test" +import assert from "node:assert/strict" +import { readFileSync } from "node:fs" +import { resolve } from "node:path" + +const { BUILTIN_SLASH_COMMANDS } = await import("../../packages/pi-coding-agent/src/core/slash-commands.ts") +const { + dispatchBrowserSlashCommand, + getBrowserSlashCommandTerminalNotice, +} = await import("../../web/lib/browser-slash-command-dispatch.ts") +const { + applyCommandSurfaceActionResult, + createInitialCommandSurfaceState, + openCommandSurfaceState, + setCommandSurfacePending, + surfaceOutcomeToOpenRequest, +} = await import("../../web/lib/command-surface-contract.ts") +const gsdExtension = await import("../resources/extensions/gsd/index.ts") + +const EXPECTED_BUILTIN_OUTCOMES = new Map([ + ["settings", "surface"], + ["model", "surface"], + ["scoped-models", "reject"], + ["export", "surface"], + ["share", "reject"], + ["copy", "reject"], + ["name", "surface"], + ["session", "surface"], + ["changelog", "reject"], + ["hotkeys", "reject"], + ["fork", "surface"], + ["tree", "reject"], + ["provider", "reject"], + ["login", "surface"], + ["logout", "surface"], + ["new", "rpc"], + ["compact", "surface"], + ["resume", "surface"], + ["reload", "reject"], + ["thinking", "surface"], + ["edit-mode", "reject"], + ["quit", "reject"], +]) + +const BUILTIN_DESCRIPTIONS = new Map(BUILTIN_SLASH_COMMANDS.map((command) => [command.name, command.description])) +const DEFERRED_BROWSER_REJECTS = ["share", "copy", "changelog", "hotkeys", "tree", "provider", "reload", "edit-mode", "quit"] as const + +async function collectRegisteredGsdCommandRoots(): Promise { + const commands = new Map() + + await gsdExtension.default({ + registerCommand(name: string, options: unknown) { + commands.set(name, options) + }, + registerTool() { + // not needed for this contract test + }, + registerShortcut() { + // not needed for this contract test + }, + on() { + // not needed for this contract test + }, + } as any) + + return [...commands.keys()].sort() +} + +function assertPromptPassthrough( + input: string, + options: { isStreaming?: boolean; expectedType?: "prompt" | "follow_up" } = {}, +): void { + const outcome = dispatchBrowserSlashCommand(input, { isStreaming: options.isStreaming }) + assert.equal(outcome.kind, "prompt", `${input} should stay on the prompt/extension path, got ${outcome.kind}`) + assert.equal( + outcome.command.type, + options.expectedType ?? (options.isStreaming ? "follow_up" : "prompt"), + `${input} should preserve its prompt command type`, + ) + assert.equal(outcome.command.message, input, `${input} should preserve the exact prompt text for extension dispatch`) +} + +test("authoritative built-ins never fall through to prompt/follow_up in browser mode", async (t) => { + assert.equal( + EXPECTED_BUILTIN_OUTCOMES.size, + BUILTIN_SLASH_COMMANDS.length, + "update EXPECTED_BUILTIN_OUTCOMES when slash-commands.ts changes so browser parity stays explicit", + ) + + for (const builtin of BUILTIN_SLASH_COMMANDS) { + await t.test(`/${builtin.name} -> ${EXPECTED_BUILTIN_OUTCOMES.get(builtin.name)}`, () => { + const outcome = dispatchBrowserSlashCommand(`/${builtin.name}`) + const expectedKind = EXPECTED_BUILTIN_OUTCOMES.get(builtin.name) + + assert.ok(expectedKind, `missing explicit browser expectation for /${builtin.name}`) + assert.notEqual( + outcome.kind, + "prompt", + `/${builtin.name} must not fall through to prompt/follow_up in browser mode`, + ) + assert.equal(outcome.kind, expectedKind, `/${builtin.name} resolved to ${outcome.kind}`) + + if (outcome.kind === "reject") { + const notice = getBrowserSlashCommandTerminalNotice(outcome) + assert.ok(notice, `/${builtin.name} should produce a browser-visible reject notice`) + assert.equal(notice.type, "error", `/${builtin.name} reject notice should be an error line`) + assert.match(notice.message, new RegExp(`/${builtin.name}`), `/${builtin.name} notice should name the command`) + assert.match(notice.message, /blocked instead of falling through to the model/i) + } + }) + } +}) + +test("browser-local aliases and legacy helpers stay explicit", async (t) => { + const explicitCases = [ + { input: "/state", expectedKind: "rpc", expectedCommandType: "get_state" }, + { input: "/new-session", expectedKind: "rpc", expectedCommandType: "new_session" }, + { input: "/refresh", expectedKind: "local", expectedAction: "refresh_workspace" }, + { input: "/clear", expectedKind: "local", expectedAction: "clear_terminal" }, + ] as const + + for (const scenario of explicitCases) { + await t.test(scenario.input, () => { + const outcome = dispatchBrowserSlashCommand(scenario.input) + assert.equal(outcome.kind, scenario.expectedKind, `${scenario.input} resolved to ${outcome.kind}`) + + if (outcome.kind === "rpc") { + assert.equal(outcome.command.type, scenario.expectedCommandType) + } + + if (outcome.kind === "local") { + assert.equal(outcome.action, scenario.expectedAction) + } + }) + } +}) + +test("registered GSD command roots stay on the prompt/extension path", async () => { + const registeredRoots = await collectRegisteredGsdCommandRoots() + assert.deepEqual( + registeredRoots, + ["exit", "gsd", "kill", "worktree", "wt"], + "browser parity contract only expects the current GSD command roots", + ) + + // Non-gsd roots are extension commands that pass through to the bridge + for (const root of registeredRoots.filter((r) => r !== "gsd")) { + assertPromptPassthrough(`/${root}`) + } + + // Bare /gsd passes through to bridge (equivalent to /gsd next) + const bareGsd = dispatchBrowserSlashCommand("/gsd") + assert.equal(bareGsd.kind, "prompt", "bare /gsd should pass through to bridge") + assert.equal(bareGsd.command.message, "/gsd", "bare /gsd should preserve exact input") +}) + +test("current GSD command family samples dispatch to correct outcomes after S02", async (t) => { + await t.test("/gsd (bare) still passes through to bridge", () => { + assertPromptPassthrough("/gsd") + }) + + await t.test("/gsd status now dispatches to surface", () => { + const outcome = dispatchBrowserSlashCommand("/gsd status") + assert.equal(outcome.kind, "surface", "/gsd status should dispatch to surface after T01") + assert.equal(outcome.surface, "gsd-status") + }) + + await t.test("/worktree list, /wt list, /kill, /exit still pass through", () => { + assertPromptPassthrough("/worktree list") + assertPromptPassthrough("/wt list") + assertPromptPassthrough("/kill") + assertPromptPassthrough("/exit") + }) + + await t.test("/gsd status dispatches to surface regardless of streaming state", () => { + const streaming = dispatchBrowserSlashCommand("/gsd status", { isStreaming: true }) + assert.equal(streaming.kind, "surface", "/gsd status should be surface even when streaming") + assert.equal(streaming.surface, "gsd-status") + + const idle = dispatchBrowserSlashCommand("/gsd status", { isStreaming: false }) + assert.equal(idle.kind, "surface") + assert.equal(idle.surface, "gsd-status") + }) +}) + +const EXPECTED_GSD_OUTCOMES = new Map([ + // Surface commands (19) + ["status", "surface"], + ["visualize", "view-navigate"], + ["forensics", "surface"], + ["doctor", "surface"], + ["skill-health", "surface"], + ["knowledge", "surface"], + ["capture", "surface"], + ["triage", "surface"], + ["quick", "surface"], + ["history", "surface"], + ["undo", "surface"], + ["inspect", "surface"], + ["prefs", "surface"], + ["config", "surface"], + ["hooks", "surface"], + ["mode", "surface"], + ["steer", "surface"], + ["export", "surface"], + ["cleanup", "surface"], + ["queue", "surface"], + // Bridge passthrough (9) + ["auto", "prompt"], + ["next", "prompt"], + ["stop", "prompt"], + ["pause", "prompt"], + ["skip", "prompt"], + ["discuss", "prompt"], + ["run-hook", "prompt"], + ["migrate", "prompt"], + ["remote", "prompt"], + // Inline help + ["help", "local"], +]) + +test("every registered /gsd subcommand has an explicit browser dispatch outcome", async (t) => { + assert.equal( + EXPECTED_GSD_OUTCOMES.size, + 30, + "EXPECTED_GSD_OUTCOMES must cover all 30 GSD subcommands (19 surface + 1 view-navigate + 9 passthrough + 1 help)", + ) + + for (const [subcommand, expectedKind] of EXPECTED_GSD_OUTCOMES) { + await t.test(`/gsd ${subcommand} -> ${expectedKind}`, () => { + const outcome = dispatchBrowserSlashCommand(`/gsd ${subcommand}`) + assert.equal( + outcome.kind, + expectedKind, + `/gsd ${subcommand} should dispatch to ${expectedKind}, got ${outcome.kind}`, + ) + + if (expectedKind === "surface") { + assert.equal( + outcome.surface, + `gsd-${subcommand}`, + `/gsd ${subcommand} should open the gsd-${subcommand} surface`, + ) + } + + if (expectedKind === "prompt") { + assert.equal( + outcome.command.message, + `/gsd ${subcommand}`, + `/gsd ${subcommand} should preserve exact input text for bridge delivery`, + ) + } + + if (expectedKind === "local") { + assert.equal( + outcome.action, + "gsd_help", + `/gsd ${subcommand} should dispatch to gsd_help action`, + ) + } + + if (expectedKind === "view-navigate") { + assert.equal( + outcome.view, + subcommand, + `/gsd ${subcommand} should navigate to the ${subcommand} view`, + ) + } + }) + } +}) + +test("GSD dispatch edge cases", async (t) => { + await t.test("/gsd (bare, no subcommand) passes through to bridge", () => { + const outcome = dispatchBrowserSlashCommand("/gsd") + assert.equal(outcome.kind, "prompt") + assert.equal(outcome.command.message, "/gsd") + }) + + await t.test("/gsd help dispatches to local gsd_help action", () => { + const outcome = dispatchBrowserSlashCommand("/gsd help") + assert.equal(outcome.kind, "local") + assert.equal(outcome.action, "gsd_help") + }) + + await t.test("/gsd unknown-xyz passes through to bridge", () => { + const outcome = dispatchBrowserSlashCommand("/gsd unknown-xyz") + assert.equal(outcome.kind, "prompt", "unknown subcommand should pass through to bridge") + assert.equal(outcome.command.message, "/gsd unknown-xyz", "unknown subcommand should preserve exact input") + assert.equal(outcome.slashCommandName, "gsd", "unknown subcommand should identify as gsd command") + }) + + await t.test("/export is built-in session export, not gsd-export", () => { + const outcome = dispatchBrowserSlashCommand("/export") + assert.equal(outcome.kind, "surface") + assert.equal(outcome.surface, "export", "/export should be the built-in session export surface") + }) + + await t.test("/gsd export is GSD milestone export, distinct from built-in /export", () => { + const outcome = dispatchBrowserSlashCommand("/gsd export") + assert.equal(outcome.kind, "surface") + assert.equal(outcome.surface, "gsd-export", "/gsd export should be the GSD milestone export surface") + }) + + await t.test("/gsd forensics detailed preserves sub-args", () => { + const outcome = dispatchBrowserSlashCommand("/gsd forensics detailed") + assert.equal(outcome.kind, "surface") + assert.equal(outcome.surface, "gsd-forensics") + assert.equal(outcome.args, "detailed", "sub-args after subcommand should be preserved") + }) + + await t.test("GSD surface commands produce system terminal notice", () => { + const outcome = dispatchBrowserSlashCommand("/gsd status") + const notice = getBrowserSlashCommandTerminalNotice(outcome) + assert.ok(notice, "surface outcome should produce a terminal notice") + assert.equal(notice.type, "system") + }) + + await t.test("GSD passthrough commands produce no terminal notice", () => { + const outcome = dispatchBrowserSlashCommand("/gsd auto") + const notice = getBrowserSlashCommandTerminalNotice(outcome) + assert.equal(notice, null, "passthrough outcome should produce no terminal notice") + }) +}) + +test("every GSD surface dispatches through the contract wiring end-to-end", async (t) => { + const gsdSurfaces = [...EXPECTED_GSD_OUTCOMES.entries()].filter(([, kind]) => kind === "surface") + + assert.equal(gsdSurfaces.length, 19, "should have exactly 19 GSD surface subcommands") + + for (const [subcommand] of gsdSurfaces) { + await t.test(`/gsd ${subcommand} -> dispatch -> open request -> surface state`, () => { + const outcome = dispatchBrowserSlashCommand(`/gsd ${subcommand}`) + assert.equal(outcome.kind, "surface") + + const openRequest = surfaceOutcomeToOpenRequest(outcome, {}) + const state = openCommandSurfaceState(createInitialCommandSurfaceState(), openRequest) + + assert.equal(state.open, true, `surface state should be open for gsd-${subcommand}`) + assert.ok(state.section, `surface state should have a non-null section for gsd-${subcommand}`) + assert.equal(state.section, `gsd-${subcommand}`, `section should match gsd-${subcommand}`) + assert.ok(state.selectedTarget, `surface state should have a non-null selectedTarget for gsd-${subcommand}`) + assert.equal(state.selectedTarget.kind, "gsd", `target kind should be "gsd" for gsd-${subcommand}`) + assert.equal(state.selectedTarget.subcommand, subcommand, `target subcommand should be "${subcommand}"`) + }) + } +}) + +test("/gsd visualize dispatches as view-navigate to the visualizer view", () => { + const outcome = dispatchBrowserSlashCommand("/gsd visualize") + assert.equal(outcome.kind, "view-navigate") + assert.equal(outcome.view, "visualize") +}) + +test("slash /settings and sidebar settings click open the same shared surface contract", () => { + const currentContext = { + onboardingLocked: false, + currentModel: { provider: "openai", modelId: "gpt-5.4" }, + currentThinkingLevel: "medium", + preferredProviderId: "openai", + } as const + + const slashOutcome = dispatchBrowserSlashCommand("/settings") + assert.equal(slashOutcome.kind, "surface") + + const slashState = openCommandSurfaceState( + createInitialCommandSurfaceState(), + surfaceOutcomeToOpenRequest(slashOutcome, currentContext), + ) + const clickState = openCommandSurfaceState(createInitialCommandSurfaceState(), { + surface: "settings", + source: "sidebar", + ...currentContext, + }) + + assert.equal(slashState.open, true) + assert.equal(clickState.open, true) + assert.equal(slashState.activeSurface, "settings") + assert.equal(clickState.activeSurface, "settings") + assert.equal(slashState.section, clickState.section) + assert.deepEqual(slashState.selectedTarget, clickState.selectedTarget) + assert.equal(slashState.selectedTarget?.kind, "settings") +}) + +test("session-oriented slash surfaces open the correct sections and carry actionable targets", async (t) => { + const context = { + onboardingLocked: false, + currentModel: { provider: "openai", modelId: "gpt-5.4" }, + currentThinkingLevel: "medium", + preferredProviderId: "openai", + currentSessionPath: "/tmp/sessions/active.jsonl", + currentSessionName: "Active session", + projectCwd: "/tmp/project", + projectSessionsDir: "/tmp/sessions", + resumableSessions: [ + { id: "sess-active", path: "/tmp/sessions/active.jsonl", name: "Active session", isActive: true }, + { id: "sess-next", path: "/tmp/sessions/next.jsonl", name: "Next session", isActive: false }, + ], + } as const + + const cases = [ + { + input: "/resume", + expectedSection: "resume", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "resume", sessionPath: "/tmp/sessions/next.jsonl" }) + }, + }, + { + input: "/resume next", + expectedSection: "resume", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "resume", sessionPath: "/tmp/sessions/next.jsonl" }) + }, + }, + { + input: "/name", + expectedSection: "name", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "name", sessionPath: "/tmp/sessions/active.jsonl", name: "Active session" }) + }, + }, + { + input: "/name Ship It", + expectedSection: "name", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "name", sessionPath: "/tmp/sessions/active.jsonl", name: "Ship It" }) + }, + }, + { + input: "/fork", + expectedSection: "fork", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "fork", entryId: undefined }) + }, + }, + { + input: "/session", + expectedSection: "session", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "session", outputPath: undefined }) + }, + }, + { + input: "/export ./artifacts/session.html", + expectedSection: "session", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "session", outputPath: "./artifacts/session.html" }) + }, + }, + { + input: "/compact preserve the open blockers", + expectedSection: "compact", + assertTarget(target: unknown) { + assert.deepEqual(target, { kind: "compact", customInstructions: "preserve the open blockers" }) + }, + }, + ] as const + + for (const scenario of cases) { + await t.test(scenario.input, () => { + const outcome = dispatchBrowserSlashCommand(scenario.input) + assert.equal(outcome.kind, "surface") + + const state = openCommandSurfaceState( + createInitialCommandSurfaceState(), + surfaceOutcomeToOpenRequest(outcome, context), + ) + + assert.equal(state.section, scenario.expectedSection) + scenario.assertTarget(state.selectedTarget) + }) + } +}) + +test("session browser surfaces seed current-project query state and rename draft state", () => { + const resumeState = openCommandSurfaceState(createInitialCommandSurfaceState(), { + surface: "resume", + source: "slash", + args: "next", + currentSessionPath: "/tmp/sessions/active.jsonl", + currentSessionName: "Active session", + projectCwd: "/tmp/project", + projectSessionsDir: "/tmp/sessions", + resumableSessions: [ + { id: "sess-active", path: "/tmp/sessions/active.jsonl", name: "Active session", isActive: true }, + { id: "sess-next", path: "/tmp/sessions/next.jsonl", name: "Next session", isActive: false }, + ], + }) + + assert.equal(resumeState.sessionBrowser.query, "next") + assert.equal(resumeState.sessionBrowser.sortMode, "relevance") + assert.equal(resumeState.sessionBrowser.nameFilter, "all") + assert.equal(resumeState.sessionBrowser.projectCwd, "/tmp/project") + assert.equal(resumeState.resumeRequest.pending, false) + + const renameState = openCommandSurfaceState(createInitialCommandSurfaceState(), { + surface: "name", + source: "slash", + args: "Ship It", + currentSessionPath: "/tmp/sessions/active.jsonl", + currentSessionName: "Active session", + projectCwd: "/tmp/project", + projectSessionsDir: "/tmp/sessions", + }) + + assert.equal(renameState.sessionBrowser.query, "") + assert.equal(renameState.sessionBrowser.sortMode, "threaded") + assert.equal(renameState.sessionBrowser.projectSessionsDir, "/tmp/sessions") + assert.deepEqual(renameState.selectedTarget, { + kind: "name", + sessionPath: "/tmp/sessions/active.jsonl", + name: "Ship It", + }) + assert.equal(renameState.renameRequest.pending, false) +}) + +test("session browser action state keeps resume and rename mutations inspectable", () => { + const opened = openCommandSurfaceState(createInitialCommandSurfaceState(), { + surface: "name", + source: "slash", + currentSessionPath: "/tmp/sessions/active.jsonl", + currentSessionName: "Active session", + }) + + const renameTarget = { kind: "name", sessionPath: "/tmp/sessions/active.jsonl", name: "Ship It" } as const + const renamePending = setCommandSurfacePending(opened, "rename_session", renameTarget) + assert.deepEqual(renamePending.renameRequest, { + pending: true, + sessionPath: "/tmp/sessions/active.jsonl", + result: null, + error: null, + }) + + const renameFailed = applyCommandSurfaceActionResult(renamePending, { + action: "rename_session", + success: false, + message: "Bridge rename failed", + selectedTarget: renameTarget, + }) + assert.equal(renameFailed.renameRequest.pending, false) + assert.equal(renameFailed.renameRequest.error, "Bridge rename failed") + + const resumeTarget = { kind: "resume", sessionPath: "/tmp/sessions/next.jsonl" } as const + const resumePending = setCommandSurfacePending(renameFailed, "switch_session", resumeTarget) + assert.deepEqual(resumePending.resumeRequest, { + pending: true, + sessionPath: "/tmp/sessions/next.jsonl", + result: null, + error: null, + }) + + const resumed = applyCommandSurfaceActionResult(resumePending, { + action: "switch_session", + success: true, + message: "Switched to Next session", + selectedTarget: resumeTarget, + }) + assert.equal(resumed.resumeRequest.pending, false) + assert.equal(resumed.resumeRequest.result, "Switched to Next session") + assert.equal(resumed.renameRequest.error, "Bridge rename failed") +}) + +test("deferred built-ins expose explicit rejection reasons in the browser", async (t) => { + for (const commandName of DEFERRED_BROWSER_REJECTS) { + await t.test(`/${commandName}`, () => { + const outcome = dispatchBrowserSlashCommand(`/${commandName}`) + assert.equal(outcome.kind, "reject") + assert.equal( + outcome.reason, + `/${commandName} is a built-in pi command (${BUILTIN_DESCRIPTIONS.get(commandName)}) that is not available in the browser yet.`, + ) + assert.equal(outcome.guidance, "It was blocked instead of falling through to the model.") + + const notice = getBrowserSlashCommandTerminalNotice(outcome) + assert.ok(notice) + assert.match(notice.message, new RegExp(`/${commandName}`)) + assert.match(notice.message, /not available in the browser yet/i) + }) + } +}) + +test("surface action state keeps session failures and recoveries inspectable", () => { + const opened = openCommandSurfaceState(createInitialCommandSurfaceState(), { + surface: "session", + source: "slash", + }) + + const pending = setCommandSurfacePending(opened, "load_session_stats", { + kind: "session", + outputPath: "./session.html", + }) + const failed = applyCommandSurfaceActionResult(pending, { + action: "load_session_stats", + success: false, + message: "Bridge unavailable while loading session stats", + selectedTarget: { + kind: "session", + outputPath: "./session.html", + }, + sessionStats: null, + }) + + assert.equal(failed.pendingAction, null) + assert.equal(failed.lastResult, null) + assert.equal(failed.lastError, "Bridge unavailable while loading session stats") + assert.equal(failed.sessionStats, null) + assert.deepEqual(failed.selectedTarget, { + kind: "session", + outputPath: "./session.html", + }) + + const recovered = applyCommandSurfaceActionResult( + setCommandSurfacePending(failed, "load_session_stats", failed.selectedTarget), + { + action: "load_session_stats", + success: true, + message: "Loaded session details for sess-1", + selectedTarget: failed.selectedTarget, + sessionStats: { + sessionFile: "/tmp/sessions/sess-1.jsonl", + sessionId: "sess-1", + userMessages: 4, + assistantMessages: 4, + toolCalls: 2, + toolResults: 2, + totalMessages: 12, + tokens: { + input: 1200, + output: 3400, + cacheRead: 0, + cacheWrite: 0, + total: 4600, + }, + cost: 0.34, + }, + }, + ) + + assert.equal(recovered.lastError, null) + assert.equal(recovered.lastResult, "Loaded session details for sess-1") + assert.equal(recovered.sessionStats?.sessionId, "sess-1") + assert.equal(recovered.sessionStats?.tokens.total, 4600) +}) + +test("surface action state keeps compaction summaries inspectable", () => { + const opened = openCommandSurfaceState(createInitialCommandSurfaceState(), { + surface: "compact", + source: "slash", + args: "preserve blockers", + }) + + const pending = setCommandSurfacePending(opened, "compact_session", { + kind: "compact", + customInstructions: "preserve blockers", + }) + const succeeded = applyCommandSurfaceActionResult(pending, { + action: "compact_session", + success: true, + message: "Compacted 14,200 tokens into a fresh summary with custom instructions.", + selectedTarget: { + kind: "compact", + customInstructions: "preserve blockers", + }, + lastCompaction: { + summary: "Summary of the kept work", + firstKeptEntryId: "entry-17", + tokensBefore: 14_200, + }, + }) + + assert.equal(succeeded.lastError, null) + assert.equal(succeeded.lastResult, "Compacted 14,200 tokens into a fresh summary with custom instructions.") + assert.equal(succeeded.lastCompaction?.firstKeptEntryId, "entry-17") + assert.equal(succeeded.lastCompaction?.summary, "Summary of the kept work") +}) + +test("command-surface session affordances use the shared store action path", () => { + const commandSurfacePath = resolve(import.meta.dirname, "../../web/components/gsd/command-surface.tsx") + const commandSurfaceSource = readFileSync(commandSurfacePath, "utf-8") + + assert.match( + commandSurfaceSource, + /void switchSessionFromSurface\(selectedResumeTarget\.sessionPath\)/, + "command-surface resume apply button should reuse the shared session-switch store action", + ) + assert.match( + commandSurfaceSource, + /void renameSessionFromSurface\(selectedNameTarget\.sessionPath, selectedNameTarget\.name\)/, + "command-surface rename apply button should reuse the shared session-rename store action", + ) +}) diff --git a/src/tests/web-continuity-contract.test.ts b/src/tests/web-continuity-contract.test.ts new file mode 100644 index 000000000..5bc1b9b0d --- /dev/null +++ b/src/tests/web-continuity-contract.test.ts @@ -0,0 +1,304 @@ +import test from "node:test"; +import assert from "node:assert/strict"; + +// ─── Constants mirrored from gsd-workspace-store.tsx ───────────────── +// These MUST match the exported values in the store. The final test +// case verifies the store's actual exported values if the runtime +// supports .tsx imports; otherwise we trust these mirrors. +const MAX_TRANSCRIPT_BLOCKS = 100; +const COMMAND_TIMEOUT_MS = 90_000; +const VISIBILITY_REFRESH_THRESHOLD_MS = 30_000; + +// --------------------------------------------------------------------------- +// Inline routing harness — mirrors GSDWorkspaceStore logic for the +// four continuity/safety mechanisms under test. +// --------------------------------------------------------------------------- + +interface ContinuityState { + liveTranscript: string[]; + streamingAssistantText: string; + commandInFlight: string | null; + lastClientError: string | null; + terminalErrorLines: string[]; + connectionState: string; + refreshBootCalls: Array<{ soft: boolean }>; + lastBootRefreshAt: number; + commandTimeoutTimer: ReturnType | null; +} + +function createContinuityState(): ContinuityState { + return { + liveTranscript: [], + streamingAssistantText: "", + commandInFlight: null, + lastClientError: null, + terminalErrorLines: [], + connectionState: "idle", + refreshBootCalls: [], + lastBootRefreshAt: 0, + commandTimeoutTimer: null, + }; +} + +/** Mirrors handleTurnBoundary with the MAX_TRANSCRIPT_BLOCKS cap */ +function handleTurnBoundary(state: ContinuityState): ContinuityState { + if (state.streamingAssistantText.length > 0) { + const next = [...state.liveTranscript, state.streamingAssistantText]; + return { + ...state, + liveTranscript: + next.length > MAX_TRANSCRIPT_BLOCKS + ? next.slice(next.length - MAX_TRANSCRIPT_BLOCKS) + : next, + streamingAssistantText: "", + }; + } + return state; +} + +/** Mirrors message_update accumulation */ +function accumulateText(state: ContinuityState, delta: string): ContinuityState { + return { ...state, streamingAssistantText: state.streamingAssistantText + delta }; +} + +/** Mirrors the command timeout mechanism from sendCommand */ +function startCommandWithTimeout( + state: ContinuityState, + commandType: string, + timeoutMs: number = COMMAND_TIMEOUT_MS, +): ContinuityState { + // Clear any existing timer + if (state.commandTimeoutTimer) clearTimeout(state.commandTimeoutTimer); + + const s = { ...state, commandInFlight: commandType }; + + s.commandTimeoutTimer = setTimeout(() => { + if (s.commandInFlight) { + s.commandInFlight = null; + s.lastClientError = "Command timed out — controls re-enabled"; + s.terminalErrorLines = [...s.terminalErrorLines, "Command timed out — controls re-enabled"]; + } + }, timeoutMs); + + return s; +} + +/** Mirrors the finally block that clears commandInFlight on normal completion */ +function completeCommand(state: ContinuityState): ContinuityState { + if (state.commandTimeoutTimer) { + clearTimeout(state.commandTimeoutTimer); + } + return { ...state, commandInFlight: null, commandTimeoutTimer: null }; +} + +/** Mirrors SSE onopen reconnect logic */ +function handleSseOpen(state: ContinuityState, previousStreamState: string): ContinuityState { + const wasDisconnected = + previousStreamState === "reconnecting" || + previousStreamState === "disconnected" || + previousStreamState === "error"; + + const s = { ...state, connectionState: "connected" }; + + if (wasDisconnected) { + s.refreshBootCalls = [...s.refreshBootCalls, { soft: true }]; + } + + return s; +} + +/** Mirrors visibilitychange listener logic */ +function handleVisibilityReturn(state: ContinuityState, now: number): ContinuityState { + if (now - state.lastBootRefreshAt >= VISIBILITY_REFRESH_THRESHOLD_MS) { + return { + ...state, + refreshBootCalls: [...state.refreshBootCalls, { soft: true }], + lastBootRefreshAt: now, + }; + } + return state; +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +test("Transcript cap: pushing 110 blocks keeps only the last 100, oldest dropped", () => { + let state = createContinuityState(); + + // Push 110 turns + for (let i = 0; i < 110; i++) { + state = accumulateText(state, `block-${i}`); + state = handleTurnBoundary(state); + } + + assert.ok( + state.liveTranscript.length <= MAX_TRANSCRIPT_BLOCKS, + `Transcript length ${state.liveTranscript.length} should be ≤ ${MAX_TRANSCRIPT_BLOCKS}`, + ); + assert.equal(state.liveTranscript.length, MAX_TRANSCRIPT_BLOCKS); + + // Oldest blocks (0-9) should be dropped; newest (10-109) should remain + assert.equal(state.liveTranscript[0], "block-10"); + assert.equal(state.liveTranscript[99], "block-109"); +}); + +test("Transcript cap: exactly at cap does not trim", () => { + let state = createContinuityState(); + + for (let i = 0; i < MAX_TRANSCRIPT_BLOCKS; i++) { + state = accumulateText(state, `block-${i}`); + state = handleTurnBoundary(state); + } + + assert.equal(state.liveTranscript.length, MAX_TRANSCRIPT_BLOCKS); + assert.equal(state.liveTranscript[0], "block-0"); + assert.equal(state.liveTranscript[99], "block-99"); +}); + +test("Command timeout: stuck command is cleared after timeout with error visibility", async () => { + let state = createContinuityState(); + + // Start a command with a very short timeout for testing + const shortTimeout = 50; // 50ms for test speed + state = startCommandWithTimeout(state, "prompt", shortTimeout); + + assert.equal(state.commandInFlight, "prompt"); + + // Wait for the timeout to fire + await new Promise((resolve) => setTimeout(resolve, shortTimeout + 50)); + + // The timeout callback mutates the state object directly (as the real store does) + assert.equal(state.commandInFlight, null, "commandInFlight should be cleared after timeout"); + assert.equal( + state.lastClientError, + "Command timed out — controls re-enabled", + "lastClientError should be set with timeout message", + ); + assert.ok( + state.terminalErrorLines.includes("Command timed out — controls re-enabled"), + "Error terminal line should be emitted", + ); +}); + +test("Command timeout: normal completion clears the timer before it fires", async () => { + let state = createContinuityState(); + + // Start a command with a short timeout + state = startCommandWithTimeout(state, "prompt", 100); + assert.equal(state.commandInFlight, "prompt"); + + // Complete normally before timeout + state = completeCommand(state); + assert.equal(state.commandInFlight, null); + + // Wait past when the timeout would have fired + await new Promise((resolve) => setTimeout(resolve, 200)); + + // No error should have been set + assert.equal(state.lastClientError, null, "No timeout error after normal completion"); + assert.equal(state.terminalErrorLines.length, 0, "No error terminal lines after normal completion"); +}); + +test("Reconnect triggers soft refresh: SSE reconnect from reconnecting state", () => { + let state = createContinuityState(); + state.connectionState = "reconnecting"; + + state = handleSseOpen(state, "reconnecting"); + + assert.equal(state.connectionState, "connected"); + assert.equal(state.refreshBootCalls.length, 1); + assert.deepEqual(state.refreshBootCalls[0], { soft: true }); +}); + +test("Reconnect triggers soft refresh: SSE reconnect from disconnected state", () => { + let state = createContinuityState(); + state.connectionState = "disconnected"; + + state = handleSseOpen(state, "disconnected"); + + assert.equal(state.connectionState, "connected"); + assert.equal(state.refreshBootCalls.length, 1); + assert.deepEqual(state.refreshBootCalls[0], { soft: true }); +}); + +test("Reconnect triggers soft refresh: SSE reconnect from error state", () => { + let state = createContinuityState(); + state.connectionState = "error"; + + state = handleSseOpen(state, "error"); + + assert.equal(state.connectionState, "connected"); + assert.equal(state.refreshBootCalls.length, 1); + assert.deepEqual(state.refreshBootCalls[0], { soft: true }); +}); + +test("Reconnect does NOT trigger refresh when previous state was connected", () => { + let state = createContinuityState(); + state.connectionState = "connected"; + + state = handleSseOpen(state, "connected"); + + assert.equal(state.connectionState, "connected"); + assert.equal(state.refreshBootCalls.length, 0); +}); + +test("Reconnect does NOT trigger refresh when previous state was idle (first connect)", () => { + let state = createContinuityState(); + state.connectionState = "idle"; + + state = handleSseOpen(state, "idle"); + + assert.equal(state.connectionState, "connected"); + assert.equal(state.refreshBootCalls.length, 0); +}); + +test("Visibility return triggers soft refresh when ≥30s since last boot refresh", () => { + let state = createContinuityState(); + state.lastBootRefreshAt = Date.now() - VISIBILITY_REFRESH_THRESHOLD_MS - 1000; // 31s ago + + const now = Date.now(); + state = handleVisibilityReturn(state, now); + + assert.equal(state.refreshBootCalls.length, 1); + assert.deepEqual(state.refreshBootCalls[0], { soft: true }); + assert.equal(state.lastBootRefreshAt, now); +}); + +test("Visibility return skipped when <30s since last boot refresh", () => { + let state = createContinuityState(); + const now = Date.now(); + state.lastBootRefreshAt = now - 10_000; // 10s ago — well within threshold + + state = handleVisibilityReturn(state, now); + + assert.equal(state.refreshBootCalls.length, 0, "No refresh when recent"); +}); + +test("Visibility return skipped when exactly at threshold boundary", () => { + let state = createContinuityState(); + const now = Date.now(); + // Exactly at threshold — not past it, so should NOT trigger + state.lastBootRefreshAt = now - VISIBILITY_REFRESH_THRESHOLD_MS + 1; + + state = handleVisibilityReturn(state, now); + + assert.equal(state.refreshBootCalls.length, 0, "No refresh at threshold boundary"); +}); + +test("Visibility return triggers when exactly at threshold", () => { + let state = createContinuityState(); + const now = Date.now(); + // Exactly at threshold — elapsed equals threshold + state.lastBootRefreshAt = now - VISIBILITY_REFRESH_THRESHOLD_MS; + + state = handleVisibilityReturn(state, now); + + assert.equal(state.refreshBootCalls.length, 1, "Refresh when exactly at threshold"); +}); + +test("Mirrored constants match expected values", () => { + assert.equal(MAX_TRANSCRIPT_BLOCKS, 100, "MAX_TRANSCRIPT_BLOCKS should be 100"); + assert.equal(COMMAND_TIMEOUT_MS, 90_000, "COMMAND_TIMEOUT_MS should be 90s"); + assert.equal(VISIBILITY_REFRESH_THRESHOLD_MS, 30_000, "VISIBILITY_REFRESH_THRESHOLD_MS should be 30s"); +}); diff --git a/src/tests/web-diagnostics-contract.test.ts b/src/tests/web-diagnostics-contract.test.ts new file mode 100644 index 000000000..9e6b8c469 --- /dev/null +++ b/src/tests/web-diagnostics-contract.test.ts @@ -0,0 +1,347 @@ +/** + * Contract tests for S04 diagnostics panels pipeline. + * + * Validates: type exports, contract state shape, dispatch→surface routing, + * surface→section mapping, and store method existence. + * + * Requirements covered: + * R103 — Forensics panel (type exports, dispatch, section, state, store) + * R104 — Doctor panel (type exports, dispatch, section, state, store + fix action) + * R105 — Skill-health panel (type exports, dispatch, section, state, store) + */ +import test, { describe, it } from "node:test" +import assert from "node:assert/strict" +import type { + ForensicReport, + ForensicAnomaly, + ForensicUnitTrace, + ForensicCrashLock, + ForensicMetricsSummary, + ForensicRecentUnit, + DoctorReport, + DoctorIssue, + DoctorFixResult, + DoctorSummary, + SkillHealthReport, + SkillHealthEntry, + SkillHealSuggestion, +} from "../../web/lib/diagnostics-types.ts" + +const { + createInitialCommandSurfaceState, + commandSurfaceSectionForRequest, +} = await import("../../web/lib/command-surface-contract.ts") + +const { + dispatchBrowserSlashCommand, +} = await import("../../web/lib/browser-slash-command-dispatch.ts") + +const { GSDWorkspaceStore } = await import("../../web/lib/gsd-workspace-store.tsx") + +// ─── Block 1: Type exports (R103, R104, R105) ─────────────────────────────── + +describe("diagnostics type exports", () => { + it("ForensicAnomaly has required fields", () => { + const anomaly: ForensicAnomaly = { + type: "crash", + severity: "error", + summary: "test crash", + details: "details here", + } + assert.equal(anomaly.type, "crash") + assert.equal(anomaly.severity, "error") + assert.equal(typeof anomaly.summary, "string") + assert.equal(typeof anomaly.details, "string") + }) + + it("ForensicReport has all required fields", () => { + const report: ForensicReport = { + gsdVersion: "1.0.0", + timestamp: new Date().toISOString(), + basePath: "/tmp/test", + activeMilestone: "M001", + activeSlice: "S01", + anomalies: [], + recentUnits: [], + crashLock: null, + doctorIssueCount: 0, + unitTraceCount: 0, + unitTraces: [], + completedKeyCount: 0, + metrics: null, + } + assert.equal(typeof report.gsdVersion, "string") + assert.equal(typeof report.timestamp, "string") + assert.ok(Array.isArray(report.anomalies)) + assert.ok(Array.isArray(report.recentUnits)) + assert.ok(Array.isArray(report.unitTraces)) + assert.equal(report.crashLock, null) + assert.equal(typeof report.doctorIssueCount, "number") + assert.equal(typeof report.unitTraceCount, "number") + assert.equal(typeof report.completedKeyCount, "number") + }) + + it("ForensicMetricsSummary has required fields", () => { + const m: ForensicMetricsSummary = { totalUnits: 5, totalCost: 1.23, totalDuration: 100 } + assert.equal(typeof m.totalUnits, "number") + assert.equal(typeof m.totalCost, "number") + assert.equal(typeof m.totalDuration, "number") + }) + + it("ForensicRecentUnit has required fields", () => { + const u: ForensicRecentUnit = { type: "task", id: "T01", cost: 0.5, duration: 30, model: "claude-4", finishedAt: Date.now() } + assert.equal(typeof u.type, "string") + assert.equal(typeof u.id, "string") + assert.equal(typeof u.cost, "number") + assert.equal(typeof u.duration, "number") + assert.equal(typeof u.model, "string") + assert.equal(typeof u.finishedAt, "number") + }) + + it("ForensicUnitTrace has required fields", () => { + const t: ForensicUnitTrace = { file: "/tmp/trace.json", unitType: "task", unitId: "T01", seq: 1, mtime: Date.now() } + assert.equal(typeof t.file, "string") + assert.equal(typeof t.unitType, "string") + assert.equal(typeof t.seq, "number") + }) + + it("ForensicCrashLock has required fields", () => { + const lock: ForensicCrashLock = { + pid: 1234, + startedAt: new Date().toISOString(), + unitType: "task", + unitId: "T01", + unitStartedAt: new Date().toISOString(), + completedUnits: 3, + } + assert.equal(typeof lock.pid, "number") + assert.equal(typeof lock.startedAt, "string") + assert.equal(typeof lock.completedUnits, "number") + }) + + it("DoctorIssue has required fields", () => { + const issue: DoctorIssue = { + severity: "warning", + code: "MISSING_SUMMARY", + scope: "M001", + unitId: "T01", + message: "Summary file missing", + fixable: true, + } + assert.equal(issue.severity, "warning") + assert.equal(typeof issue.code, "string") + assert.equal(typeof issue.scope, "string") + assert.equal(typeof issue.fixable, "boolean") + }) + + it("DoctorReport has required fields", () => { + const report: DoctorReport = { + ok: true, + issues: [], + fixesApplied: [], + summary: { total: 0, errors: 0, warnings: 0, infos: 0, fixable: 0, byCode: [] }, + } + assert.equal(typeof report.ok, "boolean") + assert.ok(Array.isArray(report.issues)) + assert.ok(Array.isArray(report.fixesApplied)) + assert.equal(typeof report.summary.total, "number") + assert.equal(typeof report.summary.fixable, "number") + assert.ok(Array.isArray(report.summary.byCode)) + }) + + it("DoctorFixResult has required fields", () => { + const fix: DoctorFixResult = { ok: true, fixesApplied: ["fix1"] } + assert.equal(typeof fix.ok, "boolean") + assert.ok(Array.isArray(fix.fixesApplied)) + assert.equal(fix.fixesApplied.length, 1) + }) + + it("SkillHealthEntry has required fields", () => { + const entry: SkillHealthEntry = { + name: "test-skill", + totalUses: 10, + successRate: 0.9, + avgTokens: 500, + tokenTrend: "stable", + lastUsed: Date.now(), + staleDays: 2, + avgCost: 0.01, + flagged: false, + } + assert.equal(typeof entry.name, "string") + assert.equal(typeof entry.successRate, "number") + assert.equal(typeof entry.avgTokens, "number") + assert.equal(entry.tokenTrend, "stable") + assert.equal(typeof entry.staleDays, "number") + assert.equal(typeof entry.flagged, "boolean") + }) + + it("SkillHealSuggestion has required fields", () => { + const suggestion: SkillHealSuggestion = { + skillName: "test-skill", + trigger: "stale", + message: "Skill is stale", + severity: "info", + } + assert.equal(typeof suggestion.skillName, "string") + assert.equal(suggestion.trigger, "stale") + assert.equal(typeof suggestion.message, "string") + assert.equal(suggestion.severity, "info") + }) + + it("SkillHealthReport has required fields", () => { + const report: SkillHealthReport = { + generatedAt: new Date().toISOString(), + totalUnitsWithSkills: 5, + skills: [], + staleSkills: [], + decliningSkills: [], + suggestions: [], + } + assert.equal(typeof report.generatedAt, "string") + assert.equal(typeof report.totalUnitsWithSkills, "number") + assert.ok(Array.isArray(report.skills)) + assert.ok(Array.isArray(report.staleSkills)) + assert.ok(Array.isArray(report.decliningSkills)) + assert.ok(Array.isArray(report.suggestions)) + }) +}) + +// ─── Block 2: Contract state (R103, R104, R105) ───────────────────────────── + +describe("diagnostics contract state", () => { + it("initial state has diagnostics field with all sub-states", () => { + const state = createInitialCommandSurfaceState() + assert.ok(state.diagnostics, "diagnostics field must exist on initial state") + assert.ok(state.diagnostics.forensics, "forensics sub-state must exist") + assert.ok(state.diagnostics.doctor, "doctor sub-state must exist") + assert.ok(state.diagnostics.skillHealth, "skillHealth sub-state must exist") + }) + + it("forensics sub-state has idle defaults", () => { + const { forensics } = createInitialCommandSurfaceState().diagnostics + assert.equal(forensics.phase, "idle") + assert.equal(forensics.data, null) + assert.equal(forensics.error, null) + assert.equal(forensics.lastLoadedAt, null) + }) + + it("doctor sub-state has idle defaults with fix fields", () => { + const { doctor } = createInitialCommandSurfaceState().diagnostics + assert.equal(doctor.phase, "idle") + assert.equal(doctor.data, null) + assert.equal(doctor.error, null) + assert.equal(doctor.lastLoadedAt, null) + // Doctor-specific fix lifecycle fields + assert.equal(doctor.fixPending, false) + assert.equal(doctor.lastFixResult, null) + assert.equal(doctor.lastFixError, null) + }) + + it("skillHealth sub-state has idle defaults", () => { + const { skillHealth } = createInitialCommandSurfaceState().diagnostics + assert.equal(skillHealth.phase, "idle") + assert.equal(skillHealth.data, null) + assert.equal(skillHealth.error, null) + assert.equal(skillHealth.lastLoadedAt, null) + }) +}) + +// ─── Block 3: Dispatch→surface pipeline (R103, R104, R105) ────────────────── + +describe("diagnostics dispatch→surface pipeline", () => { + it("/gsd forensics dispatches to gsd-forensics surface", () => { + const outcome = dispatchBrowserSlashCommand("/gsd forensics", {}) + assert.equal(outcome.kind, "surface") + if (outcome.kind === "surface") { + assert.equal(outcome.surface, "gsd-forensics") + } + }) + + it("/gsd doctor dispatches to gsd-doctor surface", () => { + const outcome = dispatchBrowserSlashCommand("/gsd doctor", {}) + assert.equal(outcome.kind, "surface") + if (outcome.kind === "surface") { + assert.equal(outcome.surface, "gsd-doctor") + } + }) + + it("/gsd skill-health dispatches to gsd-skill-health surface", () => { + const outcome = dispatchBrowserSlashCommand("/gsd skill-health", {}) + assert.equal(outcome.kind, "surface") + if (outcome.kind === "surface") { + assert.equal(outcome.surface, "gsd-skill-health") + } + }) + + it("/gsd doctor fix dispatches to gsd-doctor surface with args", () => { + const outcome = dispatchBrowserSlashCommand("/gsd doctor fix", {}) + assert.equal(outcome.kind, "surface") + if (outcome.kind === "surface") { + assert.equal(outcome.surface, "gsd-doctor") + } + }) +}) + +// ─── Block 4: Surface→section mapping (R103, R104, R105) ──────────────────── + +describe("diagnostics surface→section mapping", () => { + it("gsd-forensics surface maps to gsd-forensics section", () => { + const section = commandSurfaceSectionForRequest({ surface: "gsd-forensics" as any } as any) + assert.equal(section, "gsd-forensics") + }) + + it("gsd-doctor surface maps to gsd-doctor section", () => { + const section = commandSurfaceSectionForRequest({ surface: "gsd-doctor" as any } as any) + assert.equal(section, "gsd-doctor") + }) + + it("gsd-skill-health surface maps to gsd-skill-health section", () => { + const section = commandSurfaceSectionForRequest({ surface: "gsd-skill-health" as any } as any) + assert.equal(section, "gsd-skill-health") + }) +}) + +// ─── Block 5: Store method existence (R103, R104, R105) ────────────────────── +// +// These methods are arrow-function class fields (instance properties, not on +// the prototype). We verify via compile-time type assertion that the method +// names exist on GSDWorkspaceStore, then do a runtime check that the class +// constructor itself is exported and usable. + +// Compile-time assertion: if any of these method names were removed from the +// class, TypeScript would error on these type aliases. +type _AssertLoadForensics = GSDWorkspaceStore["loadForensicsDiagnostics"] +type _AssertLoadDoctor = GSDWorkspaceStore["loadDoctorDiagnostics"] +type _AssertApplyFixes = GSDWorkspaceStore["applyDoctorFixes"] +type _AssertLoadSkillHealth = GSDWorkspaceStore["loadSkillHealthDiagnostics"] + +describe("diagnostics store methods", () => { + it("GSDWorkspaceStore is a constructable class export", () => { + assert.equal(typeof GSDWorkspaceStore, "function", "GSDWorkspaceStore should be a class/function export") + }) + + it("loadForensicsDiagnostics is a recognized method name on the store type", () => { + // The compile-time type alias _AssertLoadForensics above already proves the + // field exists. At runtime, arrow-field methods are on instances, not + // prototype. We verify the field name appears in the actions Pick type by + // checking the useGSDWorkspaceActions hook references it in the exports. + const methodName: keyof Pick = "loadForensicsDiagnostics" + assert.equal(methodName, "loadForensicsDiagnostics") + }) + + it("loadDoctorDiagnostics is a recognized method name on the store type", () => { + const methodName: keyof Pick = "loadDoctorDiagnostics" + assert.equal(methodName, "loadDoctorDiagnostics") + }) + + it("applyDoctorFixes is a recognized method name on the store type", () => { + const methodName: keyof Pick = "applyDoctorFixes" + assert.equal(methodName, "applyDoctorFixes") + }) + + it("loadSkillHealthDiagnostics is a recognized method name on the store type", () => { + const methodName: keyof Pick = "loadSkillHealthDiagnostics" + assert.equal(methodName, "loadSkillHealthDiagnostics") + }) +}) diff --git a/src/tests/web-live-interaction-contract.test.ts b/src/tests/web-live-interaction-contract.test.ts new file mode 100644 index 000000000..432c7d238 --- /dev/null +++ b/src/tests/web-live-interaction-contract.test.ts @@ -0,0 +1,1120 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); +const bridge = await import("../web/bridge-service.ts"); +const onboarding = await import("../web/onboarding-service.ts"); +const { AuthStorage } = await import("@gsd/pi-coding-agent"); +const commandRoute = await import("../../web/app/api/session/command/route.ts"); +const eventsRoute = await import("../../web/app/api/session/events/route.ts"); + +// --------------------------------------------------------------------------- +// Test infrastructure (reused from web-bridge-contract.test.ts) +// --------------------------------------------------------------------------- + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-live-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo\n\n## Slices\n- [ ] **S01: Demo** \`risk:low\` \`depends:[]\`\n`, + ); + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + `# S01: Demo\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- test\n\n## Tasks\n- [ ] **T01: Work** \`est:5m\`\n`, + ); + writeFileSync(join(tasksDir, "T01-PLAN.md"), `# T01: Work\n\n## Steps\n- do it\n`); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile(projectCwd: string, sessionsDir: string, sessionId: string, name: string): string { + const sessionPath = join(sessionsDir, `2026-03-14T18-00-00-000Z_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp: "2026-03-14T18:00:00.000Z", + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: "info-1", + parentId: null, + timestamp: "2026-03-14T18:00:01.000Z", + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)); +} + +function fakeAutoDashboardData() { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S01", + title: "Demo", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S01/tasks", + tasks: [{ id: "T01", title: "Work", done: false, planPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md" }], + }, + ], + }, + ], + active: { milestoneId: "M001", sliceId: "S01", taskId: "T01", phase: "executing" }, + scopes: [ + { scope: "project", label: "project", kind: "project" }, + ], + validationIssues: [], + }; +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let spawnCalls = 0; + let child: FakeRpcChild | null = null; + const commands: any[] = []; + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + spawnCalls += 1; + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + const parsed = JSON.parse(line); + commands.push(parsed); + onCommand(parsed, harness); + }); + void command; + void args; + void options; + return child as any; + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started"); + child.stdout.write(serializeJsonLine(payload)); + }, + get commands() { + return commands; + }, + get child() { + return child; + }, + }; + + return harness; +} + +function fakeSessionState(sessionId: string, sessionPath: string) { + return { + sessionId, + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }; +} + +function setupBridge(harness: ReturnType, fixture: ReturnType) { + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + anthropic: { type: "api_key", key: "sk-test-live-interaction" }, + } as any), + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); +} + +async function readSseEvents(response: Response, count: number): Promise { + const reader = response.body?.getReader(); + assert.ok(reader, "SSE response has a body reader"); + const decoder = new TextDecoder(); + const events: any[] = []; + let buffer = ""; + + while (events.length < count) { + const result = await Promise.race([ + reader.read(), + new Promise((_, reject) => setTimeout(() => reject(new Error("Timed out reading SSE events")), 2_000)), + ]); + + if (result.done) break; + buffer += decoder.decode(result.value, { stream: true }); + + while (true) { + const boundary = buffer.indexOf("\n\n"); + if (boundary === -1) break; + const chunk = buffer.slice(0, boundary); + buffer = buffer.slice(boundary + 2); + const dataLine = chunk.split("\n").find((line) => line.startsWith("data: ")); + if (!dataLine) continue; + events.push(JSON.parse(dataLine.slice(6))); + if (events.length >= count) { + await reader.cancel(); + return events; + } + } + } + + await reader.cancel(); + return events; +} + +// --------------------------------------------------------------------------- +// Inline store event routing harness +// +// This mirrors the GSDWorkspaceStore's handleEvent routing logic +// so we can verify state transitions without importing .tsx. +// The contract test verifies this logic matches the real store behavior +// by testing the same event shapes the SSE bridge produces. +// --------------------------------------------------------------------------- + +interface MinimalLiveState { + pendingUiRequests: any[]; + streamingAssistantText: string; + liveTranscript: string[]; + activeToolExecution: { id: string; name: string } | null; + statusTexts: Record; + widgetContents: Record; + titleOverride: string | null; + editorTextBuffer: string | null; +} + +function createMinimalLiveState(): MinimalLiveState { + return { + pendingUiRequests: [], + streamingAssistantText: "", + liveTranscript: [], + activeToolExecution: null, + statusTexts: {}, + widgetContents: {}, + titleOverride: null, + editorTextBuffer: null, + }; +} + +function consumeEditorTextBuffer(state: MinimalLiveState): { state: MinimalLiveState; value: string | null } { + const value = state.editorTextBuffer; + if (value === null) { + return { state, value: null }; + } + + return { + value, + state: { + ...state, + editorTextBuffer: null, + }, + }; +} + +/** Mirrors GSDWorkspaceStore.routeLiveInteractionEvent */ +function routeEvent(state: MinimalLiveState, event: any): MinimalLiveState { + const s = { ...state }; + + switch (event.type) { + case "extension_ui_request": { + const method = event.method; + if (method === "select" || method === "confirm" || method === "input" || method === "editor") { + s.pendingUiRequests = [...s.pendingUiRequests, event]; + } else if (method === "setStatus") { + s.statusTexts = { ...s.statusTexts }; + if (event.statusText === undefined) { + delete s.statusTexts[event.statusKey]; + } else { + s.statusTexts[event.statusKey] = event.statusText; + } + } else if (method === "setWidget") { + s.widgetContents = { ...s.widgetContents }; + if (event.widgetLines === undefined) { + delete s.widgetContents[event.widgetKey]; + } else { + s.widgetContents[event.widgetKey] = { lines: event.widgetLines, placement: event.widgetPlacement }; + } + } else if (method === "setTitle") { + const nextTitle = typeof event.title === "string" ? event.title.trim() : ""; + s.titleOverride = nextTitle.length > 0 ? nextTitle : null; + } else if (method === "set_editor_text") { + s.editorTextBuffer = event.text; + } + // notify: no state change (produces terminal line only) + break; + } + case "message_update": { + const ae = event.assistantMessageEvent; + if (ae && ae.type === "text_delta" && typeof ae.delta === "string") { + s.streamingAssistantText = s.streamingAssistantText + ae.delta; + } + break; + } + case "agent_end": + case "turn_end": { + if (s.streamingAssistantText.length > 0) { + s.liveTranscript = [...s.liveTranscript, s.streamingAssistantText]; + s.streamingAssistantText = ""; + } + break; + } + case "tool_execution_start": { + s.activeToolExecution = { id: event.toolCallId, name: event.toolName }; + break; + } + case "tool_execution_end": { + s.activeToolExecution = null; + break; + } + } + + return s; +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +test("(a) SSE emits extension_ui_request with method 'select' → typed payload with options and allowMultiple", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-ui", "UI Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-ui", sessionPath), + }); + return; + } + assert.fail(`unexpected command: ${command.type}`); + }); + + setupBridge(harness, fixture); + + try { + const controller = new AbortController(); + const response = await eventsRoute.GET( + new Request("http://localhost/api/session/events", { signal: controller.signal }), + ); + + harness.emit({ + type: "extension_ui_request", + id: "req-select-1", + method: "select", + title: "Choose a file", + options: ["file-a.ts", "file-b.ts", "file-c.ts"], + allowMultiple: true, + }); + + const events = await readSseEvents(response, 2); // bridge_status + the UI request + controller.abort(); + await waitForMicrotasks(); + + const uiEvent = events.find((e) => e.type === "extension_ui_request"); + assert.ok(uiEvent, "extension_ui_request event received via SSE"); + assert.equal(uiEvent.id, "req-select-1"); + assert.equal(uiEvent.method, "select"); + assert.equal(uiEvent.title, "Choose a file"); + assert.deepEqual(uiEvent.options, ["file-a.ts", "file-b.ts", "file-c.ts"]); + assert.equal(uiEvent.allowMultiple, true); + + // Verify store routing: select is a blocking method → should queue + let state = createMinimalLiveState(); + state = routeEvent(state, uiEvent); + assert.equal(state.pendingUiRequests.length, 1); + assert.equal(state.pendingUiRequests[0].id, "req-select-1"); + assert.equal(state.pendingUiRequests[0].method, "select"); + assert.deepEqual(state.pendingUiRequests[0].options, ["file-a.ts", "file-b.ts", "file-c.ts"]); + assert.equal(state.pendingUiRequests[0].allowMultiple, true); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("(b) Multiple concurrent UI requests queue correctly keyed by id", async () => { + let state = createMinimalLiveState(); + + state = routeEvent(state, { + type: "extension_ui_request", + id: "req-1", + method: "select", + title: "First", + options: ["a", "b"], + }); + state = routeEvent(state, { + type: "extension_ui_request", + id: "req-2", + method: "confirm", + title: "Second", + message: "Are you sure?", + }); + state = routeEvent(state, { + type: "extension_ui_request", + id: "req-3", + method: "input", + title: "Third", + placeholder: "Enter value", + }); + state = routeEvent(state, { + type: "extension_ui_request", + id: "req-4", + method: "editor", + title: "Fourth", + prefill: "initial text", + }); + + assert.equal(state.pendingUiRequests.length, 4); + assert.equal(state.pendingUiRequests[0].id, "req-1"); + assert.equal(state.pendingUiRequests[0].method, "select"); + assert.equal(state.pendingUiRequests[1].id, "req-2"); + assert.equal(state.pendingUiRequests[1].method, "confirm"); + assert.equal(state.pendingUiRequests[1].message, "Are you sure?"); + assert.equal(state.pendingUiRequests[2].id, "req-3"); + assert.equal(state.pendingUiRequests[2].method, "input"); + assert.equal(state.pendingUiRequests[2].placeholder, "Enter value"); + assert.equal(state.pendingUiRequests[3].id, "req-4"); + assert.equal(state.pendingUiRequests[3].method, "editor"); + assert.equal(state.pendingUiRequests[3].prefill, "initial text"); +}); + +test("(c) Responding to a UI request posts extension_ui_response with correct id and value to the bridge", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-respond", "Respond Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-respond", sessionPath), + }); + return; + } + // extension_ui_response is a fire-and-forget write to stdin — no RPC response expected + }); + + setupBridge(harness, fixture); + + try { + // Post an extension_ui_response via the command route + const response = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "extension_ui_response", id: "req-42", value: "option-b" }), + }), + ); + + // extension_ui_response returns { ok: true } (202) because it's fire-and-forget + assert.equal(response.status, 202); + + await waitForMicrotasks(); + + // Verify the command was written to the bridge's stdin + const uiResponseCmd = harness.commands.find((c) => c.type === "extension_ui_response"); + assert.ok(uiResponseCmd, "extension_ui_response was sent to the bridge"); + assert.equal(uiResponseCmd.id, "req-42"); + assert.equal(uiResponseCmd.value, "option-b"); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("(d) Dismissing a UI request posts cancelled: true and removes from pending", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-dismiss", "Dismiss Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-dismiss", sessionPath), + }); + return; + } + }); + + setupBridge(harness, fixture); + + try { + // Post a cancel response + const response = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "extension_ui_response", id: "req-99", cancelled: true }), + }), + ); + + assert.equal(response.status, 202); + await waitForMicrotasks(); + + const cancelCmd = harness.commands.find((c) => c.type === "extension_ui_response" && c.cancelled === true); + assert.ok(cancelCmd, "cancellation extension_ui_response was sent to the bridge"); + assert.equal(cancelCmd.id, "req-99"); + assert.equal(cancelCmd.cancelled, true); + + // Verify store routing: removing from pending queue + let state = createMinimalLiveState(); + state = routeEvent(state, { + type: "extension_ui_request", + id: "req-99", + method: "confirm", + title: "Confirm?", + message: "Really?", + }); + assert.equal(state.pendingUiRequests.length, 1); + + // Simulate removal (mirrors store's dismissUiRequest behavior) + state = { + ...state, + pendingUiRequests: state.pendingUiRequests.filter((r: any) => r.id !== "req-99"), + }; + assert.equal(state.pendingUiRequests.length, 0); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("(e) SSE emits message_update with text delta → streamingAssistantText accumulates", async () => { + let state = createMinimalLiveState(); + + state = routeEvent(state, { + type: "message_update", + assistantMessageEvent: { type: "text_delta", delta: "Hello ", contentIndex: 0 }, + }); + assert.equal(state.streamingAssistantText, "Hello "); + + state = routeEvent(state, { + type: "message_update", + assistantMessageEvent: { type: "text_delta", delta: "world!", contentIndex: 0 }, + }); + assert.equal(state.streamingAssistantText, "Hello world!"); + + // Non-text_delta events should not accumulate + state = routeEvent(state, { + type: "message_update", + assistantMessageEvent: { type: "text_start", contentIndex: 0 }, + }); + assert.equal(state.streamingAssistantText, "Hello world!"); + + // Verify via SSE that message_update events flow through the bridge + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-stream", "Stream Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-stream", sessionPath), + }); + return; + } + assert.fail(`unexpected command: ${command.type}`); + }); + + setupBridge(harness, fixture); + + try { + const controller = new AbortController(); + const response = await eventsRoute.GET( + new Request("http://localhost/api/session/events", { signal: controller.signal }), + ); + + harness.emit({ + type: "message_update", + message: { role: "assistant", content: [] }, + assistantMessageEvent: { type: "text_delta", delta: "streamed text", contentIndex: 0, partial: {} }, + }); + + const events = await readSseEvents(response, 2); // bridge_status + message_update + controller.abort(); + await waitForMicrotasks(); + + const msgEvent = events.find((e) => e.type === "message_update"); + assert.ok(msgEvent, "message_update event received via SSE"); + assert.equal(msgEvent.assistantMessageEvent.type, "text_delta"); + assert.equal(msgEvent.assistantMessageEvent.delta, "streamed text"); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("(f) agent_end moves streaming text to transcript and resets streaming text", async () => { + let state = createMinimalLiveState(); + + // Accumulate some text + state = routeEvent(state, { + type: "message_update", + assistantMessageEvent: { type: "text_delta", delta: "First turn output" }, + }); + assert.equal(state.streamingAssistantText, "First turn output"); + assert.equal(state.liveTranscript.length, 0); + + // Agent end → moves to transcript + state = routeEvent(state, { type: "agent_end" }); + assert.equal(state.streamingAssistantText, ""); + assert.equal(state.liveTranscript.length, 1); + assert.equal(state.liveTranscript[0], "First turn output"); + + // Second turn + state = routeEvent(state, { + type: "message_update", + assistantMessageEvent: { type: "text_delta", delta: "Second turn" }, + }); + state = routeEvent(state, { type: "turn_end" }); + assert.equal(state.streamingAssistantText, ""); + assert.equal(state.liveTranscript.length, 2); + assert.equal(state.liveTranscript[1], "Second turn"); + + // Agent end with no streaming text → no empty transcript entry + state = routeEvent(state, { type: "agent_end" }); + assert.equal(state.liveTranscript.length, 2); +}); + +test("(g) setStatus/setWidget/setTitle/set_editor_text fire-and-forget events update correct store state", async () => { + let state = createMinimalLiveState(); + + // setStatus + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-1", + method: "setStatus", + statusKey: "build", + statusText: "Building…", + }); + assert.equal(state.statusTexts["build"], "Building…"); + + // setStatus with undefined clears the key + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-2", + method: "setStatus", + statusKey: "build", + statusText: undefined, + }); + assert.equal(state.statusTexts["build"], undefined); + assert.equal("build" in state.statusTexts, false); + + // setWidget + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-3", + method: "setWidget", + widgetKey: "progress", + widgetLines: ["Step 1/3", "Building module…"], + widgetPlacement: "belowEditor", + }); + assert.ok(state.widgetContents["progress"]); + assert.deepEqual(state.widgetContents["progress"].lines, ["Step 1/3", "Building module…"]); + assert.equal(state.widgetContents["progress"].placement, "belowEditor"); + + // setWidget with undefined lines clears the widget + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-4", + method: "setWidget", + widgetKey: "progress", + widgetLines: undefined, + }); + assert.equal("progress" in state.widgetContents, false); + + // setTitle + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-5", + method: "setTitle", + title: "Custom Title", + }); + assert.equal(state.titleOverride, "Custom Title"); + + // blank setTitle clears the visible override instead of leaving an empty string behind + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-5-clear", + method: "setTitle", + title: " ", + }); + assert.equal(state.titleOverride, null); + + // set_editor_text + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-6", + method: "set_editor_text", + text: "prefilled editor content", + }); + assert.equal(state.editorTextBuffer, "prefilled editor content"); + + // Browser terminal consumes editor text once, then clears the buffer so it doesn't replay forever + let consumed = consumeEditorTextBuffer(state); + assert.equal(consumed.value, "prefilled editor content"); + assert.equal(consumed.state.editorTextBuffer, null); + + consumed = consumeEditorTextBuffer(consumed.state); + assert.equal(consumed.value, null); + assert.equal(consumed.state.editorTextBuffer, null); + + // Empty editor text is still a valid consume-once prefill because it clears the visible input + state = routeEvent(consumed.state, { + type: "extension_ui_request", + id: "ff-6-clear", + method: "set_editor_text", + text: "", + }); + assert.equal(state.editorTextBuffer, ""); + consumed = consumeEditorTextBuffer(state); + assert.equal(consumed.value, ""); + assert.equal(consumed.state.editorTextBuffer, null); + + // notify does NOT queue — only produces a terminal line + state = routeEvent(state, { + type: "extension_ui_request", + id: "ff-7", + method: "notify", + message: "Operation completed", + notifyType: "info", + }); + assert.equal(state.pendingUiRequests.length, 0, "notify should not queue a pending request"); +}); + +test("(g-2) tool_execution_start/end update activeToolExecution", async () => { + let state = createMinimalLiveState(); + + state = routeEvent(state, { + type: "tool_execution_start", + toolCallId: "tc-1", + toolName: "bash", + args: { command: "ls" }, + }); + assert.ok(state.activeToolExecution); + assert.equal(state.activeToolExecution.id, "tc-1"); + assert.equal(state.activeToolExecution.name, "bash"); + + state = routeEvent(state, { + type: "tool_execution_end", + toolCallId: "tc-1", + toolName: "bash", + result: {}, + isError: false, + }); + assert.equal(state.activeToolExecution, null); +}); + +test("(h) steer and abort commands post the correct RPC command type", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-steer", "Steer Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-steer", sessionPath), + }); + return; + } + + if (command.type === "steer") { + current.emit({ + id: command.id, + type: "response", + command: "steer", + success: true, + }); + return; + } + + if (command.type === "abort") { + current.emit({ + id: command.id, + type: "response", + command: "abort", + success: true, + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + setupBridge(harness, fixture); + + try { + // Send steer command + const steerResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "steer", message: "focus on the login flow" }), + }), + ); + assert.equal(steerResponse.status, 200); + const steerBody = await steerResponse.json() as any; + assert.equal(steerBody.success, true); + assert.equal(steerBody.command, "steer"); + + // Verify steer command reached the bridge with the correct shape + const steerCmd = harness.commands.find((c) => c.type === "steer"); + assert.ok(steerCmd, "steer command was sent to the bridge"); + assert.equal(steerCmd.message, "focus on the login flow"); + + // Send abort command + const abortResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "abort" }), + }), + ); + assert.equal(abortResponse.status, 200); + const abortBody = await abortResponse.json() as any; + assert.equal(abortBody.success, true); + assert.equal(abortBody.command, "abort"); + + const abortCmd = harness.commands.find((c) => c.type === "abort"); + assert.ok(abortCmd, "abort command was sent to the bridge"); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("(failure-path) UI response errors are visible as lastClientError and pending requests persist on failure", async () => { + // Test the store-level behavior: if respondToUiRequest fails, the request stays in the queue + let state = createMinimalLiveState(); + + // Queue a request + state = routeEvent(state, { + type: "extension_ui_request", + id: "req-fail", + method: "confirm", + title: "Confirm action", + message: "Proceed?", + }); + assert.equal(state.pendingUiRequests.length, 1); + + // Simulate failed removal (on error, the store does NOT remove the request) + // Only successful responses remove from the queue + const failedState = { ...state }; // no filter applied on error + assert.equal(failedState.pendingUiRequests.length, 1, "request stays in queue on response failure"); + assert.equal(failedState.pendingUiRequests[0].id, "req-fail"); + + // Simulate successful removal + const successState = { + ...state, + pendingUiRequests: state.pendingUiRequests.filter((r: any) => r.id !== "req-fail"), + }; + assert.equal(successState.pendingUiRequests.length, 0, "request removed on success"); +}); + +test("(session-controls) browser session RPCs round-trip through /api/session/command", async () => { + const fixture = makeWorkspaceFixture(); + const activeSessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-session", "Session Surface"); + const nextSessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-next", "Next Session"); + const stats = { + sessionFile: activeSessionPath, + sessionId: "sess-session", + userMessages: 4, + assistantMessages: 4, + toolCalls: 2, + toolResults: 2, + totalMessages: 12, + tokens: { + input: 1200, + output: 3400, + cacheRead: 0, + cacheWrite: 0, + total: 4600, + }, + cost: 0.42, + }; + const forkMessages = [ + { entryId: "entry-1", text: "Investigate the login flow" }, + { entryId: "entry-2", text: "Fix the slash-command dispatcher" }, + ]; + const exportPath = join(fixture.projectCwd, "artifacts", "session.html"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-session", activeSessionPath), + }); + return; + } + + if (command.type === "get_session_stats") { + current.emit({ + id: command.id, + type: "response", + command: "get_session_stats", + success: true, + data: stats, + }); + return; + } + + if (command.type === "export_html") { + current.emit({ + id: command.id, + type: "response", + command: "export_html", + success: true, + data: { path: exportPath }, + }); + return; + } + + if (command.type === "switch_session") { + assert.equal(command.sessionPath, nextSessionPath); + current.emit({ + id: command.id, + type: "response", + command: "switch_session", + success: true, + data: { cancelled: false }, + }); + return; + } + + if (command.type === "get_fork_messages") { + current.emit({ + id: command.id, + type: "response", + command: "get_fork_messages", + success: true, + data: { messages: forkMessages }, + }); + return; + } + + if (command.type === "fork") { + assert.equal(command.entryId, "entry-2"); + current.emit({ + id: command.id, + type: "response", + command: "fork", + success: true, + data: { text: "Fix the slash-command dispatcher", cancelled: false }, + }); + return; + } + + if (command.type === "compact") { + assert.equal(command.customInstructions, "Preserve blockers and current task state"); + current.emit({ + id: command.id, + type: "response", + command: "compact", + success: true, + data: { + summary: "Compacted summary", + firstKeptEntryId: "entry-9", + tokensBefore: 14200, + }, + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + setupBridge(harness, fixture); + + try { + const sessionResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "get_session_stats" }), + }), + ); + assert.equal(sessionResponse.status, 200); + const sessionBody = await sessionResponse.json() as any; + assert.equal(sessionBody.success, true); + assert.equal(sessionBody.command, "get_session_stats"); + assert.equal(sessionBody.data.sessionId, "sess-session"); + assert.equal(sessionBody.data.tokens.total, 4600); + + const exportResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "export_html", outputPath: exportPath }), + }), + ); + assert.equal(exportResponse.status, 200); + const exportBody = await exportResponse.json() as any; + assert.equal(exportBody.success, true); + assert.equal(exportBody.data.path, exportPath); + + const switchResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "switch_session", sessionPath: nextSessionPath }), + }), + ); + assert.equal(switchResponse.status, 200); + const switchBody = await switchResponse.json() as any; + assert.equal(switchBody.success, true); + assert.equal(switchBody.data.cancelled, false); + + const forkMessagesResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "get_fork_messages" }), + }), + ); + assert.equal(forkMessagesResponse.status, 200); + const forkMessagesBody = await forkMessagesResponse.json() as any; + assert.equal(forkMessagesBody.success, true); + assert.deepEqual(forkMessagesBody.data.messages, forkMessages); + + const forkResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "fork", entryId: "entry-2" }), + }), + ); + assert.equal(forkResponse.status, 200); + const forkBody = await forkResponse.json() as any; + assert.equal(forkBody.success, true); + assert.equal(forkBody.data.cancelled, false); + assert.equal(forkBody.data.text, "Fix the slash-command dispatcher"); + + const compactResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "compact", customInstructions: "Preserve blockers and current task state" }), + }), + ); + assert.equal(compactResponse.status, 200); + const compactBody = await compactResponse.json() as any; + assert.equal(compactBody.success, true); + assert.equal(compactBody.data.summary, "Compacted summary"); + assert.equal(compactBody.data.tokensBefore, 14200); + + assert.deepEqual( + harness.commands.filter((command) => command.type !== "get_state").map((command) => command.type), + ["get_session_stats", "export_html", "switch_session", "get_fork_messages", "fork", "compact"], + "browser session controls should hit the live command route with the expected RPC sequence", + ); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); diff --git a/src/tests/web-live-state-contract.test.ts b/src/tests/web-live-state-contract.test.ts new file mode 100644 index 000000000..0edf91425 --- /dev/null +++ b/src/tests/web-live-state-contract.test.ts @@ -0,0 +1,587 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); +const bridge = await import("../web/bridge-service.ts"); +const onboarding = await import("../web/onboarding-service.ts"); +const { AuthStorage } = await import("@gsd/pi-coding-agent"); +const commandRoute = await import("../../web/app/api/session/command/route.ts"); +const manageRoute = await import("../../web/app/api/session/manage/route.ts"); +const eventsRoute = await import("../../web/app/api/session/events/route.ts"); +const liveStateRoute = await import("../../web/app/api/live-state/route.ts"); + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-live-state-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo Milestone\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n > After this: demo works\n`, + ); + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- real bridge\n\n## Tasks\n- [ ] **T01: Wire boot** \`est:10m\`\n Do the work.\n`, + ); + writeFileSync( + join(tasksDir, "T01-PLAN.md"), + `# T01: Wire boot\n\n## Steps\n- do it\n`, + ); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile( + projectCwd: string, + sessionsDir: string, + sessionId: string, + name: string, + timestamp: string, +): string { + const safeTimestamp = timestamp.replace(/[:.]/g, "-"); + const sessionPath = join(sessionsDir, `${safeTimestamp}_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp, + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: `${sessionId}-info`, + parentId: null, + timestamp, + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)); +} + +function fakeAutoDashboardData() { + return { + active: true, + paused: false, + stepMode: false, + startTime: 111, + elapsed: 222, + currentUnit: { type: "execute-task", id: "M001/S01/T01", startedAt: 333 }, + completedUnits: [], + basePath: "/tmp/demo", + totalCost: 4.5, + totalTokens: 678, + }; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo Milestone", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S01", + title: "Demo Slice", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S01/tasks", + tasks: [ + { + id: "T01", + title: "Wire boot", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md", + }, + ], + }, + ], + }, + ], + active: { + milestoneId: "M001", + sliceId: "S01", + taskId: "T01", + phase: "executing", + }, + scopes: [ + { scope: "project", label: "project", kind: "project" }, + { scope: "M001", label: "M001: Demo Milestone", kind: "milestone" }, + { scope: "M001/S01", label: "M001/S01: Demo Slice", kind: "slice" }, + { scope: "M001/S01/T01", label: "M001/S01/T01: Wire boot", kind: "task" }, + ], + validationIssues: [], + }; +} + +function fakeSessionState(sessionId: string, sessionPath: string) { + return { + sessionId, + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }; +} + +function fakeBootPayload(sessionPath: string) { + return { + project: { + cwd: "/tmp/demo-project", + sessionsDir: "/tmp/demo-project/.gsd/sessions", + packageRoot: repoRoot, + }, + workspace: fakeWorkspaceIndex(), + auto: fakeAutoDashboardData(), + onboarding: { + status: "ready", + locked: false, + lockReason: null, + required: { + blocking: true, + skippable: false, + satisfied: true, + satisfiedBy: { providerId: "anthropic", source: "auth_file" }, + providers: [], + }, + optional: { + blocking: false, + skippable: true, + sections: [], + }, + lastValidation: null, + activeFlow: null, + bridgeAuthRefresh: { + phase: "idle", + strategy: null, + startedAt: null, + completedAt: null, + error: null, + }, + }, + onboardingNeeded: false, + resumableSessions: [ + { + id: "sess-live", + path: sessionPath, + cwd: "/tmp/demo-project", + name: "Live Session", + createdAt: "2026-03-15T03:30:00.000Z", + modifiedAt: "2026-03-15T03:30:00.000Z", + messageCount: 2, + isActive: true, + }, + ], + bridge: { + phase: "ready", + projectCwd: "/tmp/demo-project", + projectSessionsDir: "/tmp/demo-project/.gsd/sessions", + packageRoot: repoRoot, + startedAt: "2026-03-15T03:30:00.000Z", + updatedAt: "2026-03-15T03:30:01.000Z", + connectionCount: 0, + lastCommandType: "get_state", + activeSessionId: "sess-live", + activeSessionFile: sessionPath, + sessionState: fakeSessionState("sess-live", sessionPath), + lastError: null, + }, + }; +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let child: FakeRpcChild | null = null; + const commands: any[] = []; + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + const parsed = JSON.parse(line); + commands.push(parsed); + onCommand(parsed, harness); + }); + void command; + void args; + void options; + return child as any; + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started"); + child.stdout.write(serializeJsonLine(payload)); + }, + get commands() { + return commands; + }, + }; + + return harness; +} + +function setupBridge( + harness: ReturnType, + fixture: { projectCwd: string; sessionsDir: string }, + overrides: Record = {}, +): void { + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + anthropic: { type: "api_key", key: "sk-test-live-state" }, + } as any), + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + ...overrides, + }); +} + +async function readSseEventsUntil( + response: Response, + predicate: (events: any[]) => boolean, + timeoutMs = 2_000, +): Promise { + const reader = response.body?.getReader(); + assert.ok(reader, "SSE response has a body reader"); + const decoder = new TextDecoder(); + const events: any[] = []; + let buffer = ""; + const deadline = Date.now() + timeoutMs; + + while (Date.now() < deadline) { + const remaining = Math.max(1, deadline - Date.now()); + const result = await Promise.race([ + reader.read(), + new Promise((_, reject) => setTimeout(() => reject(new Error("Timed out reading SSE events")), remaining)), + ]); + + if (result.done) break; + buffer += decoder.decode(result.value, { stream: true }); + + while (true) { + const boundary = buffer.indexOf("\n\n"); + if (boundary === -1) break; + const chunk = buffer.slice(0, boundary); + buffer = buffer.slice(boundary + 2); + const dataLine = chunk.split("\n").find((line) => line.startsWith("data: ")); + if (!dataLine) continue; + events.push(JSON.parse(dataLine.slice(6))); + if (predicate(events)) { + await reader.cancel(); + return events; + } + } + } + + await reader.cancel(); + throw new Error("Timed out waiting for the expected SSE contract events"); +} + +test("/api/session/events exposes explicit live_state_invalidation events for agent and auto recovery boundaries", async () => { + const fixture = makeWorkspaceFixture(); + const sessionPath = createSessionFile( + fixture.projectCwd, + fixture.sessionsDir, + "sess-live", + "Live Session", + "2026-03-15T03:30:00.000Z", + ); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-live", sessionPath), + }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + setupBridge(harness, fixture); + + try { + const controller = new AbortController(); + const response = await eventsRoute.GET( + new Request("http://localhost/api/session/events", { signal: controller.signal }), + ); + + harness.emit({ type: "agent_end" }); + harness.emit({ type: "auto_retry_start", attempt: 1, maxAttempts: 3, delayMs: 250, errorMessage: "retry me" }); + harness.emit({ type: "auto_retry_end", success: false, attempt: 1, finalError: "still failing" }); + harness.emit({ type: "auto_compaction_start", reason: "threshold" }); + harness.emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false }); + + const events = await readSseEventsUntil( + response, + (seen) => seen.filter((event) => event.type === "live_state_invalidation").length >= 5, + ); + const invalidations = events.filter((event) => event.type === "live_state_invalidation"); + + assert.deepEqual( + invalidations.map((event) => ({ + reason: event.reason, + source: event.source, + workspaceIndexCacheInvalidated: event.workspaceIndexCacheInvalidated, + })), + [ + { reason: "agent_end", source: "bridge_event", workspaceIndexCacheInvalidated: true }, + { reason: "auto_retry_start", source: "bridge_event", workspaceIndexCacheInvalidated: false }, + { reason: "auto_retry_end", source: "bridge_event", workspaceIndexCacheInvalidated: false }, + { reason: "auto_compaction_start", source: "bridge_event", workspaceIndexCacheInvalidated: false }, + { reason: "auto_compaction_end", source: "bridge_event", workspaceIndexCacheInvalidated: false }, + ], + "live_state_invalidation reasons/sources should stay inspectable on /api/session/events", + ); + assert.deepEqual(invalidations[0].domains, ["auto", "workspace", "recovery"]); + assert.deepEqual(invalidations[1].domains, ["auto", "recovery"]); + assert.deepEqual(invalidations[2].domains, ["auto", "recovery"]); + assert.deepEqual(invalidations[3].domains, ["auto", "recovery"]); + assert.deepEqual(invalidations[4].domains, ["auto", "recovery"]); + + controller.abort(); + await waitForMicrotasks(); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); + +test("workspace cache only busts on real boundaries and session mutations emit targeted invalidations", async () => { + const fixture = makeWorkspaceFixture(); + const activeSessionPath = createSessionFile( + fixture.projectCwd, + fixture.sessionsDir, + "sess-active", + "Active Session", + "2026-03-15T03:31:00.000Z", + ); + const otherSessionPath = createSessionFile( + fixture.projectCwd, + fixture.sessionsDir, + "sess-other", + "Other Session", + "2026-03-15T03:31:01.000Z", + ); + let workspaceIndexCalls = 0; + + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-active", activeSessionPath), + }); + return; + } + + if (command.type === "switch_session") { + current.emit({ id: command.id, type: "response", command: "switch_session", success: true, data: { cancelled: false } }); + return; + } + + if (command.type === "new_session") { + current.emit({ id: command.id, type: "response", command: "new_session", success: true, data: { cancelled: false } }); + return; + } + + if (command.type === "fork") { + current.emit({ id: command.id, type: "response", command: "fork", success: true, data: { text: "Fork me", cancelled: false } }); + return; + } + + if (command.type === "set_session_name") { + current.emit({ id: command.id, type: "response", command: "set_session_name", success: true }); + return; + } + + assert.fail(`unexpected command: ${command.type}`); + }); + + setupBridge(harness, fixture, { + indexWorkspace: async () => { + workspaceIndexCalls += 1; + return fakeWorkspaceIndex(); + }, + }); + + try { + const service = bridge.getProjectBridgeService(); + await service.ensureStarted(); + const seenEvents: any[] = []; + const unsubscribe = service.subscribe((event) => { + seenEvents.push(event); + }); + + await bridge.collectBootPayload(); + await bridge.collectBootPayload(); + assert.equal(workspaceIndexCalls, 1, "boot snapshot should stay cached before any invalidation boundary fires"); + + harness.emit({ type: "agent_end" }); + await waitForMicrotasks(); + await bridge.collectBootPayload(); + assert.equal(workspaceIndexCalls, 2, "agent_end should invalidate the cached workspace snapshot"); + + harness.emit({ type: "auto_retry_start", attempt: 1, maxAttempts: 3, delayMs: 100, errorMessage: "retry me" }); + await waitForMicrotasks(); + await bridge.collectBootPayload(); + assert.equal(workspaceIndexCalls, 2, "auto_retry_start should not invalidate the workspace snapshot cache"); + + harness.emit({ type: "auto_compaction_start", reason: "threshold" }); + await waitForMicrotasks(); + await bridge.collectBootPayload(); + assert.equal(workspaceIndexCalls, 2, "auto_compaction_start should not invalidate the workspace snapshot cache"); + + const switchResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "switch_session", sessionPath: otherSessionPath }), + }), + ); + assert.equal(switchResponse.status, 200); + + const newSessionResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "new_session" }), + }), + ); + assert.equal(newSessionResponse.status, 200); + + const forkResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "fork", entryId: "entry-1" }), + }), + ); + assert.equal(forkResponse.status, 200); + + const renameResponse = await manageRoute.POST( + new Request("http://localhost/api/session/manage", { + method: "POST", + body: JSON.stringify({ + action: "rename", + sessionPath: otherSessionPath, + name: "Renamed Session", + }), + }), + ); + const renamePayload = await renameResponse.json() as any; + assert.equal(renameResponse.status, 200); + assert.equal(renamePayload.success, true); + assert.equal(renamePayload.mutation, "session_file"); + + await waitForMicrotasks(); + + const invalidations = seenEvents.filter((event) => event.type === "live_state_invalidation"); + const reasons = invalidations.map((event) => event.reason); + assert.ok(reasons.includes("agent_end"), "missing agent_end live_state_invalidation trigger"); + assert.ok(reasons.includes("auto_retry_start"), "missing auto_retry_start live_state_invalidation trigger"); + assert.ok(reasons.includes("auto_compaction_start"), "missing auto_compaction_start live_state_invalidation trigger"); + assert.ok(reasons.includes("switch_session"), "missing switch_session live_state_invalidation trigger"); + assert.ok(reasons.includes("new_session"), "missing new_session live_state_invalidation trigger"); + assert.ok(reasons.includes("fork"), "missing fork live_state_invalidation trigger"); + + const switchInvalidation = invalidations.find((event) => event.reason === "switch_session"); + assert.ok(switchInvalidation, "switch_session should emit a targeted freshness event"); + assert.deepEqual(switchInvalidation.domains, ["resumable_sessions", "recovery"]); + assert.equal(switchInvalidation.workspaceIndexCacheInvalidated, false); + + const renameInvalidation = invalidations.find( + (event) => event.reason === "set_session_name" && event.source === "session_manage", + ); + assert.ok(renameInvalidation, "inactive rename should emit an inspectable set_session_name invalidation"); + assert.deepEqual(renameInvalidation.domains, ["resumable_sessions"]); + assert.equal(renameInvalidation.workspaceIndexCacheInvalidated, false); + + unsubscribe(); + } finally { + await bridge.resetBridgeServiceForTests(); + onboarding.resetOnboardingServiceForTests(); + fixture.cleanup(); + } +}); diff --git a/src/tests/web-mode-cli.test.ts b/src/tests/web-mode-cli.test.ts new file mode 100644 index 000000000..8634618e1 --- /dev/null +++ b/src/tests/web-mode-cli.test.ts @@ -0,0 +1,667 @@ +import test from 'node:test' +import assert from 'node:assert/strict' +import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs' +import { join, resolve } from 'node:path' +import { tmpdir } from 'node:os' + +const projectRoot = process.cwd() + +const cliWeb = await import('../cli-web-branch.ts') +const webMode = await import('../web-mode.ts') + +test('parseCliArgs recognizes --web explicitly', () => { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web']) + assert.equal(flags.web, true) + assert.equal(flags.print, undefined) + assert.equal(flags.mode, undefined) +}) + +test('package hooks declare a concrete staged web host', () => { + const rootPackage = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf-8')) + assert.equal(rootPackage.scripts['stage:web-host'], 'node scripts/stage-web-standalone.cjs') + assert.equal(rootPackage.scripts['build:web-host'], 'npm --prefix web run build && npm run stage:web-host') + assert.equal(rootPackage.scripts['gsd'], 'node scripts/dev-cli.js') + assert.equal(rootPackage.scripts['gsd:web'], 'npm run build:pi && npm run copy-resources && node scripts/build-web-if-stale.cjs && node scripts/dev-cli.js --web') + assert.equal(rootPackage.scripts['gsd:web:stop'], 'node scripts/dev-cli.js web stop') + assert.ok(rootPackage.files.includes('dist/web')) + + const webPackage = JSON.parse(readFileSync(join(projectRoot, 'web', 'package.json'), 'utf-8')) + assert.equal(webPackage.scripts['start:standalone'], 'node .next/standalone/web/server.js') +}) + +test('web mode launcher defines or imports a browser opener', () => { + const source = readFileSync(join(projectRoot, 'src', 'web-mode.ts'), 'utf-8') + // openBrowser is now defined directly in web-mode.ts (was previously imported from onboarding.js) + assert.match(source, /openBrowser/) +}) + +test('cli.ts branches to web mode before interactive startup and preserves cwd-scoped launch inputs', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-cli-')) + const cwd = join(tmp, 'project space') + mkdirSync(cwd, { recursive: true }) + + let launchInputs: { cwd: string; projectSessionsDir: string; agentDir: string } | undefined + + try { + const cliSource = readFileSync(join(projectRoot, 'src', 'cli.ts'), 'utf-8') + const branchIndex = cliSource.indexOf('const webBranch = await runWebCliBranch') + const modelRegistryIndex = cliSource.indexOf('const modelRegistry =') + assert.ok(branchIndex !== -1, 'cli.ts contains an explicit web branch handoff') + assert.ok(modelRegistryIndex !== -1, 'cli.ts still contains the model-registry startup path') + assert.ok(branchIndex < modelRegistryIndex, 'web branch runs before interactive startup state is constructed') + + const result = await cliWeb.runWebCliBranch(cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web']), { + cwd: () => cwd, + runWebMode: async (options) => { + launchInputs = options + return { + mode: 'web', + ok: true, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host: '127.0.0.1', + port: 43123, + url: 'http://127.0.0.1:43123', + hostKind: 'source-dev', + hostPath: '/tmp/fake-web/package.json', + hostRoot: '/tmp/fake-web', + } + }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected --web branch to be handled') + assert.equal(result.exitCode, 0) + assert.deepEqual(launchInputs, { + cwd, + projectSessionsDir: cliWeb.getProjectSessionsDir(cwd), + agentDir: join(process.env.HOME || '', '.gsd', 'agent'), + }) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('launchWebMode prefers the packaged standalone host and opens the resolved URL', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-host-')) + const standaloneRoot = join(tmp, 'dist', 'web', 'standalone') + const serverPath = join(standaloneRoot, 'server.js') + mkdirSync(standaloneRoot, { recursive: true }) + writeFileSync(serverPath, 'console.log("stub")\n') + + let initResourcesCalled = false + let unrefCalled = false + let openedUrl = '' + let stderrOutput = '' + let spawnInvocation: + | { command: string; args: readonly string[]; options: Record } + | undefined + let writtenPid: { path: string; pid: number } | undefined + + const pidFilePath = join(tmp, 'web-server.pid') + + try { + const status = await webMode.launchWebMode( + { + cwd: '/tmp/current-project', + projectSessionsDir: '/tmp/.gsd/sessions/--tmp-current-project--', + agentDir: '/tmp/.gsd/agent', + packageRoot: tmp, + }, + { + initResources: () => { + initResourcesCalled = true + }, + resolvePort: async () => 45123, + execPath: '/custom/node', + env: { TEST_ENV: '1' }, + spawn: (command, args, options) => { + spawnInvocation = { command, args, options: options as Record } + return { + pid: 99999, + once: () => undefined, + unref: () => { + unrefCalled = true + }, + } as any + }, + waitForBootReady: async () => undefined, + openBrowser: (url) => { + openedUrl = url + }, + pidFilePath, + writePidFile: (path, pid) => { + writtenPid = { path, pid } + webMode.writePidFile(path, pid) + }, + stderr: { + write(chunk: string) { + stderrOutput += chunk + return true + }, + }, + }, + ) + + assert.equal(status.ok, true) + if (!status.ok) throw new Error('expected successful web launch status') + assert.equal(status.hostKind, 'packaged-standalone') + assert.equal(status.hostPath, serverPath) + assert.equal(status.url, 'http://127.0.0.1:45123') + assert.equal(initResourcesCalled, true) + assert.equal(unrefCalled, true) + // The browser URL now includes a random auth token as a fragment + assert.match(openedUrl, /^http:\/\/127\.0\.0\.1:45123\/#token=[a-f0-9]{64}$/) + // Extract the auth token the launcher generated so we can verify it was + // passed consistently to both the env and the browser URL. + const authToken = openedUrl.replace('http://127.0.0.1:45123/#token=', '') + assert.deepEqual(spawnInvocation, { + command: '/custom/node', + args: [serverPath], + options: { + cwd: standaloneRoot, + detached: true, + stdio: 'ignore', + env: { + TEST_ENV: '1', + HOSTNAME: '127.0.0.1', + PORT: '45123', + GSD_WEB_HOST: '127.0.0.1', + GSD_WEB_PORT: '45123', + GSD_WEB_AUTH_TOKEN: authToken, + GSD_WEB_PROJECT_CWD: '/tmp/current-project', + GSD_WEB_PROJECT_SESSIONS_DIR: '/tmp/.gsd/sessions/--tmp-current-project--', + GSD_WEB_PACKAGE_ROOT: tmp, + GSD_WEB_HOST_KIND: 'packaged-standalone', + }, + }, + }) + assert.match(stderrOutput, /status=started/) + assert.match(stderrOutput, /port=45123/) + // PID file must be written with the spawned process's PID + assert.deepEqual(writtenPid, { path: pidFilePath, pid: 99999 }) + assert.equal(webMode.readPidFile(pidFilePath), 99999) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('stopWebMode kills process by PID and removes PID file', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-stop-')) + const pidFilePath = join(tmp, 'web-server.pid') + let stderrOutput = '' + let killedPid: number | undefined + + try { + webMode.writePidFile(pidFilePath, 12345) + + const result = webMode.stopWebMode({ + pidFilePath, + readPidFile: webMode.readPidFile, + deletePidFile: webMode.deletePidFile, + stderr: { write: (chunk: string) => { stderrOutput += chunk; return true } }, + // Override process.kill to avoid killing a real process in tests + }) + + // Since PID 12345 is almost certainly dead, stopWebMode should succeed by treating ESRCH as "already gone" + assert.equal(result.ok, true) + assert.match(stderrOutput, /pid=12345/) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('stopWebMode reports error when no PID file exists', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-stop-nopid-')) + const pidFilePath = join(tmp, 'web-server.pid') + let stderrOutput = '' + + try { + const result = webMode.stopWebMode({ + pidFilePath, + readPidFile: webMode.readPidFile, + deletePidFile: webMode.deletePidFile, + stderr: { write: (chunk: string) => { stderrOutput += chunk; return true } }, + }) + + assert.equal(result.ok, false) + assert.equal(result.reason, 'no-pid-file') + assert.match(stderrOutput, /not running/) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('runWebCliBranch handles "web stop" subcommand without --web flag', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-branch-stop-')) + const pidFilePath = join(tmp, 'web-server.pid') + let stderrOutput = '' + + try { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', 'web', 'stop']) + assert.equal(flags.web, undefined) + assert.deepEqual(flags.messages, ['web', 'stop']) + + const result = await cliWeb.runWebCliBranch(flags, { + stopWebMode: (deps) => { + return webMode.stopWebMode({ ...deps, pidFilePath }) + }, + stderr: { write: (chunk: string) => { stderrOutput += chunk; return true } }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected web stop to be handled') + assert.equal(result.exitCode, 1) // no PID file — expected failure + if (result.action !== 'stop') throw new Error('expected action=stop') + assert.equal(result.stopResult.ok, false) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +// ─── Path argument tests ────────────────────────────────────────────── + +test('parseCliArgs captures --web ', () => { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web', '/tmp/my-project']) + assert.equal(flags.web, true) + assert.equal(flags.webPath, '/tmp/my-project') + assert.deepEqual(flags.messages, []) +}) + +test('parseCliArgs captures --web with relative path', () => { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web', '../other-project']) + assert.equal(flags.web, true) + assert.equal(flags.webPath, '../other-project') +}) + +test('parseCliArgs does not capture --web followed by a flag as path', () => { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web', '--model', 'test']) + assert.equal(flags.web, true) + assert.equal(flags.webPath, undefined) + assert.equal(flags.model, 'test') +}) + +test('gsd web is handled as web start with path', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-path-')) + const projectDir = join(tmp, 'my-project') + mkdirSync(projectDir, { recursive: true }) + let launchedCwd = '' + + try { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', 'web', projectDir]) + assert.deepEqual(flags.messages, ['web', projectDir]) + + const result = await cliWeb.runWebCliBranch(flags, { + runWebMode: async (options) => { + launchedCwd = options.cwd + return { + mode: 'web', + ok: true, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host: '127.0.0.1', + port: 43124, + url: 'http://127.0.0.1:43124', + hostKind: 'source-dev', + hostPath: '/tmp/fake-web/package.json', + hostRoot: '/tmp/fake-web', + } + }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected web branch to be handled') + assert.equal(result.exitCode, 0) + assert.equal(launchedCwd, projectDir) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('gsd web start resolves path and launches', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-start-path-')) + const projectDir = join(tmp, 'another-project') + mkdirSync(projectDir, { recursive: true }) + let launchedCwd = '' + + try { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', 'web', 'start', projectDir]) + assert.deepEqual(flags.messages, ['web', 'start', projectDir]) + + const result = await cliWeb.runWebCliBranch(flags, { + runWebMode: async (options) => { + launchedCwd = options.cwd + return { + mode: 'web', + ok: true, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host: '127.0.0.1', + port: 43125, + url: 'http://127.0.0.1:43125', + hostKind: 'source-dev', + hostPath: '/tmp/fake-web/package.json', + hostRoot: '/tmp/fake-web', + } + }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected web branch to be handled') + assert.equal(result.exitCode, 0) + assert.equal(launchedCwd, projectDir) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('gsd --web resolves path and launches', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-flag-path-')) + const projectDir = join(tmp, 'flagged-project') + mkdirSync(projectDir, { recursive: true }) + let launchedCwd = '' + + try { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web', projectDir]) + assert.equal(flags.web, true) + assert.equal(flags.webPath, projectDir) + + const result = await cliWeb.runWebCliBranch(flags, { + runWebMode: async (options) => { + launchedCwd = options.cwd + return { + mode: 'web', + ok: true, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host: '127.0.0.1', + port: 43126, + url: 'http://127.0.0.1:43126', + hostKind: 'source-dev', + hostPath: '/tmp/fake-web/package.json', + hostRoot: '/tmp/fake-web', + } + }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected web branch to be handled') + assert.equal(result.exitCode, 0) + assert.equal(launchedCwd, projectDir) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('gsd --web fails with clear error', async () => { + let stderrOutput = '' + + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', '--web', '/tmp/nonexistent-gsd-test-path-xyz']) + const result = await cliWeb.runWebCliBranch(flags, { + stderr: { write: (chunk: string) => { stderrOutput += chunk; return true } }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected web branch to be handled') + assert.equal(result.exitCode, 1) + if (result.action !== 'start') throw new Error('expected action=start') + assert.equal(result.status.ok, false) + if (result.status.ok) throw new Error('expected failed status') + assert.match(result.status.failureReason, /does not exist/) + assert.match(stderrOutput, /does not exist/) +}) + +test('launch failure surfaces status and reason before browser open', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-missing-host-')) + let openedUrl = '' + let stderrOutput = '' + + try { + const status = await webMode.launchWebMode( + { + cwd: '/tmp/current-project', + projectSessionsDir: '/tmp/.gsd/sessions/--tmp-current-project--', + agentDir: '/tmp/.gsd/agent', + packageRoot: tmp, + }, + { + openBrowser: (url) => { + openedUrl = url + }, + stderr: { + write(chunk: string) { + stderrOutput += chunk + return true + }, + }, + }, + ) + + assert.equal(status.ok, false) + if (status.ok) throw new Error('expected failed web launch status') + assert.equal(status.hostPath, null) + assert.equal(status.url, null) + assert.equal(openedUrl, '') + assert.match(status.failureReason, /host bootstrap not found/) + assert.match(stderrOutput, /status=failed/) + assert.match(stderrOutput, /reason=host bootstrap not found/) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +// ─── Instance registry tests ───────────────────────────────────────── + +test('registerInstance and readInstanceRegistry round-trip', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-registry-')) + const registryPath = join(tmp, 'web-instances.json') + + try { + webMode.registerInstance('/tmp/project-a', { pid: 1001, port: 3000, url: 'http://127.0.0.1:3000' }, registryPath) + webMode.registerInstance('/tmp/project-b', { pid: 1002, port: 3001, url: 'http://127.0.0.1:3001' }, registryPath) + + const registry = webMode.readInstanceRegistry(registryPath) + assert.equal(Object.keys(registry).length, 2) + assert.equal(registry[resolve('/tmp/project-a')]?.pid, 1001) + assert.equal(registry[resolve('/tmp/project-b')]?.port, 3001) + assert.ok(registry[resolve('/tmp/project-a')]?.startedAt) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('unregisterInstance removes a single entry', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-unreg-')) + const registryPath = join(tmp, 'web-instances.json') + + try { + webMode.registerInstance('/tmp/project-a', { pid: 1001, port: 3000, url: 'http://127.0.0.1:3000' }, registryPath) + webMode.registerInstance('/tmp/project-b', { pid: 1002, port: 3001, url: 'http://127.0.0.1:3001' }, registryPath) + webMode.unregisterInstance('/tmp/project-a', registryPath) + + const registry = webMode.readInstanceRegistry(registryPath) + assert.equal(Object.keys(registry).length, 1) + assert.equal(registry[resolve('/tmp/project-a')], undefined) + assert.equal(registry[resolve('/tmp/project-b')]?.pid, 1002) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('stopWebMode with projectCwd reports not-found when not in registry', () => { + let stderrOutput = '' + + const result = webMode.stopWebMode( + { stderr: { write: (chunk: string) => { stderrOutput += chunk; return true } } }, + { projectCwd: '/tmp/nonexistent-project-for-stop-test' }, + ) + + assert.equal(result.ok, false) + assert.equal(result.reason, 'not-found') + assert.match(stderrOutput, /No web server running/) +}) + +test('gsd web stop all is parsed and dispatched', async () => { + let stopOptions: { projectCwd?: string; all?: boolean } | undefined + + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', 'web', 'stop', 'all']) + assert.deepEqual(flags.messages, ['web', 'stop', 'all']) + + const result = await cliWeb.runWebCliBranch(flags, { + stopWebMode: (_deps, opts) => { + stopOptions = opts + return { ok: true, stoppedCount: 2 } + }, + stderr: { write: () => true }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected handled') + assert.equal(result.exitCode, 0) + assert.equal(stopOptions?.all, true) + assert.equal(stopOptions?.projectCwd, undefined) +}) + +test('gsd web stop is parsed and dispatched with resolved path', async () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-web-stop-path-')) + let stopOptions: { projectCwd?: string; all?: boolean } | undefined + + try { + const flags = cliWeb.parseCliArgs(['node', 'dist/loader.js', 'web', 'stop', tmp]) + const result = await cliWeb.runWebCliBranch(flags, { + cwd: () => '/', + stopWebMode: (_deps, opts) => { + stopOptions = opts + return { ok: true, stoppedCount: 1 } + }, + stderr: { write: () => true }, + }) + + assert.equal(result.handled, true) + if (!result.handled) throw new Error('expected handled') + assert.equal(result.exitCode, 0) + assert.equal(stopOptions?.projectCwd, tmp) + assert.equal(stopOptions?.all, false) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +// ─── Context-aware launch detection tests ────────────────────────────── + +test('resolveContextAwareCwd returns project cwd when inside a project under dev root', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const devRoot = join(tmp, 'devroot') + const projectA = join(devRoot, 'projectA') + const prefsPath = join(tmp, 'web-preferences.json') + + try { + mkdirSync(projectA, { recursive: true }) + writeFileSync(prefsPath, JSON.stringify({ devRoot })) + + const result = cliWeb.resolveContextAwareCwd(projectA, prefsPath) + assert.equal(result, projectA) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('resolveContextAwareCwd returns cwd unchanged when AT dev root', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const devRoot = join(tmp, 'devroot') + const prefsPath = join(tmp, 'web-preferences.json') + + try { + mkdirSync(devRoot, { recursive: true }) + writeFileSync(prefsPath, JSON.stringify({ devRoot })) + + const result = cliWeb.resolveContextAwareCwd(devRoot, prefsPath) + assert.equal(result, devRoot) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('resolveContextAwareCwd returns cwd unchanged when no dev root configured', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const prefsPath = join(tmp, 'web-preferences.json') + const cwd = join(tmp, 'somedir') + + try { + mkdirSync(cwd, { recursive: true }) + writeFileSync(prefsPath, JSON.stringify({ theme: 'dark' })) + + const result = cliWeb.resolveContextAwareCwd(cwd, prefsPath) + assert.equal(result, cwd) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('resolveContextAwareCwd returns cwd unchanged when prefs file missing', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const prefsPath = join(tmp, 'nonexistent-prefs.json') + const cwd = join(tmp, 'somedir') + + try { + mkdirSync(cwd, { recursive: true }) + + const result = cliWeb.resolveContextAwareCwd(cwd, prefsPath) + assert.equal(result, cwd) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('resolveContextAwareCwd returns cwd unchanged when dev root path is stale', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const prefsPath = join(tmp, 'web-preferences.json') + const cwd = join(tmp, 'somedir') + const staleDevRoot = join(tmp, 'nonexistent-devroot') + + try { + mkdirSync(cwd, { recursive: true }) + writeFileSync(prefsPath, JSON.stringify({ devRoot: staleDevRoot })) + + const result = cliWeb.resolveContextAwareCwd(cwd, prefsPath) + assert.equal(result, cwd) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('resolveContextAwareCwd resolves nested cwd to one-level-deep project', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const devRoot = join(tmp, 'devroot') + const projectA = join(devRoot, 'projectA') + const nested = join(projectA, 'src', 'components', 'deep') + const prefsPath = join(tmp, 'web-preferences.json') + + try { + mkdirSync(nested, { recursive: true }) + writeFileSync(prefsPath, JSON.stringify({ devRoot })) + + const result = cliWeb.resolveContextAwareCwd(nested, prefsPath) + assert.equal(result, projectA) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) + +test('resolveContextAwareCwd returns cwd unchanged when outside dev root', () => { + const tmp = mkdtempSync(join(tmpdir(), 'gsd-ctx-aware-')) + const devRoot = join(tmp, 'devroot') + const outsideDir = join(tmp, 'elsewhere') + const prefsPath = join(tmp, 'web-preferences.json') + + try { + mkdirSync(devRoot, { recursive: true }) + mkdirSync(outsideDir, { recursive: true }) + writeFileSync(prefsPath, JSON.stringify({ devRoot })) + + const result = cliWeb.resolveContextAwareCwd(outsideDir, prefsPath) + assert.equal(result, outsideDir) + } finally { + rmSync(tmp, { recursive: true, force: true }) + } +}) diff --git a/src/tests/web-multi-project-contract.test.ts b/src/tests/web-multi-project-contract.test.ts new file mode 100644 index 000000000..25ac4e02d --- /dev/null +++ b/src/tests/web-multi-project-contract.test.ts @@ -0,0 +1,540 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); +const bridge = await import("../web/bridge-service.ts"); + +// --------------------------------------------------------------------------- +// Helpers (same shape as web-bridge-contract.test.ts) +// --------------------------------------------------------------------------- + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(label: string): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), `gsd-multi-project-${label}-`)); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo Milestone\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n > After this: demo works\n`, + ); + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- real bridge\n\n## Tasks\n- [ ] **T01: Wire boot** \`est:10m\`\n Do the work.\n`, + ); + writeFileSync( + join(tasksDir, "T01-PLAN.md"), + `# T01: Wire boot\n\n## Steps\n- do it\n`, + ); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile(projectCwd: string, sessionsDir: string, sessionId: string, name: string): string { + const sessionPath = join(sessionsDir, `2026-03-14T18-00-00-000Z_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp: "2026-03-14T18:00:00.000Z", + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: "info-1", + parentId: null, + timestamp: "2026-03-14T18:00:01.000Z", + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo Milestone", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S01", + title: "Demo Slice", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S01/tasks", + tasks: [ + { + id: "T01", + title: "Wire boot", + done: false, + planPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md", + }, + ], + }, + ], + }, + ], + active: { + milestoneId: "M001", + sliceId: "S01", + taskId: "T01", + phase: "executing", + }, + scopes: [ + { scope: "project", label: "project", kind: "project" }, + { scope: "M001", label: "M001: Demo Milestone", kind: "milestone" }, + { scope: "M001/S01", label: "M001/S01: Demo Slice", kind: "slice" }, + { scope: "M001/S01/T01", label: "M001/S01/T01: Wire boot", kind: "task" }, + ], + validationIssues: [], + }; +} + +function fakeAutoDashboardData() { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)); +} + +function createHarness(sessionId: string) { + let spawnCalls = 0; + let child: FakeRpcChild | null = null; + const commands: any[] = []; + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + spawnCalls += 1; + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + const parsed = JSON.parse(line); + commands.push(parsed); + if (parsed.type === "get_state") { + harness.emit({ + id: parsed.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId, + sessionFile: `/tmp/fake-session-${sessionId}.jsonl`, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + } + }); + void command; + void args; + void options; + return child as any; + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started"); + child.stdout.write(serializeJsonLine(payload)); + }, + get spawnCalls() { + return spawnCalls; + }, + get commands() { + return commands; + }, + get child() { + return child; + }, + }; + + return harness; +} + +// --------------------------------------------------------------------------- +// Tests — multi-project bridge coexistence +// --------------------------------------------------------------------------- + +test("multi-project: getProjectBridgeServiceForCwd returns distinct instances for different project paths", async () => { + const fixtureA = makeWorkspaceFixture("A"); + const fixtureB = makeWorkspaceFixture("B"); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixtureA.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixtureA.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: createHarness("unused").spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const bridgeA = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + const bridgeB = bridge.getProjectBridgeServiceForCwd(fixtureB.projectCwd); + assert.notStrictEqual(bridgeA, bridgeB, "bridges for different paths must be distinct instances"); + + const snapA = bridgeA.getSnapshot(); + const snapB = bridgeB.getSnapshot(); + assert.equal(snapA.projectCwd, fixtureA.projectCwd); + assert.equal(snapB.projectCwd, fixtureB.projectCwd); + } finally { + await bridge.resetBridgeServiceForTests(); + fixtureA.cleanup(); + fixtureB.cleanup(); + } +}); + +test("multi-project: getProjectBridgeServiceForCwd returns same instance for same path", async () => { + const fixtureA = makeWorkspaceFixture("idempotent"); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixtureA.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixtureA.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: createHarness("unused").spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const first = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + const second = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + assert.strictEqual(first, second, "same path must return the same instance"); + } finally { + await bridge.resetBridgeServiceForTests(); + fixtureA.cleanup(); + } +}); + +test("multi-project: each bridge receives commands independently", async () => { + const fixtureA = makeWorkspaceFixture("cmd-A"); + const fixtureB = makeWorkspaceFixture("cmd-B"); + const sessionPathA = createSessionFile(fixtureA.projectCwd, fixtureA.sessionsDir, "sess-A", "Session A"); + const sessionPathB = createSessionFile(fixtureB.projectCwd, fixtureB.sessionsDir, "sess-B", "Session B"); + + const harnessA = createHarness("sess-A"); + const harnessB = createHarness("sess-B"); + + // Track which harness was used for which project path + const spawnRouter = (command: string, args: readonly string[], options: Record) => { + const cwd = (options as any).cwd as string; + if (cwd === fixtureA.projectCwd) return harnessA.spawn(command, args, options); + if (cwd === fixtureB.projectCwd) return harnessB.spawn(command, args, options); + // Fallback — use A for the default env-based project + return harnessA.spawn(command, args, options); + }; + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixtureA.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixtureA.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: spawnRouter as any, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const bridgeA = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + const bridgeB = bridge.getProjectBridgeServiceForCwd(fixtureB.projectCwd); + + // Start both bridges + await bridgeA.ensureStarted(); + await bridgeB.ensureStarted(); + + // Send get_state to bridge A + const responseA = await bridgeA.sendInput({ type: "get_state" } as any); + assert.equal(responseA?.success, true); + assert.equal((responseA as any).data.sessionId, "sess-A"); + + // Send get_state to bridge B + const responseB = await bridgeB.sendInput({ type: "get_state" } as any); + assert.equal(responseB?.success, true); + assert.equal((responseB as any).data.sessionId, "sess-B"); + + // Each harness only got its own commands + assert.ok(harnessA.commands.length >= 1, "harness A received commands"); + assert.ok(harnessB.commands.length >= 1, "harness B received commands"); + assert.ok( + harnessA.commands.every((c: any) => c.type === "get_state"), + "harness A only got get_state commands", + ); + assert.ok( + harnessB.commands.every((c: any) => c.type === "get_state"), + "harness B only got get_state commands", + ); + } finally { + await bridge.resetBridgeServiceForTests(); + fixtureA.cleanup(); + fixtureB.cleanup(); + } +}); + +test("multi-project: SSE subscribers are isolated per bridge", async () => { + const fixtureA = makeWorkspaceFixture("sse-A"); + const fixtureB = makeWorkspaceFixture("sse-B"); + + const harnessA = createHarness("sess-sse-A"); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixtureA.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixtureA.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harnessA.spawn as any, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const bridgeA = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + const bridgeB = bridge.getProjectBridgeServiceForCwd(fixtureB.projectCwd); + + const eventsA: any[] = []; + const eventsB: any[] = []; + + const unsubA = bridgeA.subscribe((event) => eventsA.push(event)); + const unsubB = bridgeB.subscribe((event) => eventsB.push(event)); + + // Subscribe fires an initial bridge_status event for each + const initialA = eventsA.length; + const initialB = eventsB.length; + + // Start bridge A so it has a child process + await bridgeA.ensureStarted(); + await waitForMicrotasks(); + + // Filter to only non-bridge_status events that we emit manually + const agentEventsA: any[] = []; + const agentEventsB: any[] = []; + + const unsubA2 = bridgeA.subscribe((event) => { + if (event.type !== "bridge_status") agentEventsA.push(event); + }); + const unsubB2 = bridgeB.subscribe((event) => { + if (event.type !== "bridge_status") agentEventsB.push(event); + }); + + // Emit an agent event on bridge A's child process + harnessA.emit({ type: "agent_start" }); + await waitForMicrotasks(); + + // Bridge A's subscriber should see it; bridge B's should not + assert.ok(agentEventsA.length > 0, "bridge A subscriber should see agent_start"); + assert.equal(agentEventsB.length, 0, "bridge B subscriber should NOT see events from bridge A"); + + unsubA(); + unsubB(); + unsubA2(); + unsubB2(); + } finally { + await bridge.resetBridgeServiceForTests(); + fixtureA.cleanup(); + fixtureB.cleanup(); + } +}); + +test("multi-project: resolveProjectCwd reads ?project= from request URL", () => { + const result = bridge.resolveProjectCwd( + new Request("http://localhost/api/boot?project=%2Ftmp%2Fmy-project"), + ); + assert.equal(result, "/tmp/my-project"); +}); + +test("multi-project: resolveProjectCwd falls back to GSD_WEB_PROJECT_CWD when no ?project= present", () => { + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: "/fallback/path", + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: createHarness("unused").spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const result = bridge.resolveProjectCwd( + new Request("http://localhost/api/boot"), + ); + assert.equal(result, "/fallback/path"); + } finally { + bridge.configureBridgeServiceForTests(null); + } +}); + +test("multi-project: getProjectBridgeService backward compat shim works", async () => { + const fixture = makeWorkspaceFixture("compat"); + const harness = createHarness("sess-compat"); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + const service = bridge.getProjectBridgeService(); + assert.ok(service, "getProjectBridgeService() should return a BridgeService"); + const snapshot = service.getSnapshot(); + assert.equal(snapshot.projectCwd, fixture.projectCwd, "backward compat shim should use env-resolved projectCwd"); + assert.equal(snapshot.phase, "idle"); + + // Same instance as getProjectBridgeServiceForCwd with the same path + const directService = bridge.getProjectBridgeServiceForCwd(fixture.projectCwd); + assert.strictEqual(service, directService, "backward compat shim should return same instance as direct lookup"); + } finally { + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("multi-project: resetBridgeServiceForTests clears all registry entries", async () => { + const fixtureA = makeWorkspaceFixture("reset-A"); + const fixtureB = makeWorkspaceFixture("reset-B"); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixtureA.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixtureA.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: createHarness("unused").spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + try { + // Create two bridge instances + const beforeA = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + const beforeB = bridge.getProjectBridgeServiceForCwd(fixtureB.projectCwd); + assert.notStrictEqual(beforeA, beforeB); + + // Reset clears the registry + await bridge.resetBridgeServiceForTests(); + + // Re-configure after reset (reset clears overrides too) + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixtureA.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixtureA.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: createHarness("unused").spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + getOnboardingNeeded: () => false, + }); + + // Should get new instances + const afterA = bridge.getProjectBridgeServiceForCwd(fixtureA.projectCwd); + const afterB = bridge.getProjectBridgeServiceForCwd(fixtureB.projectCwd); + assert.notStrictEqual(afterA, beforeA, "reset must create fresh instances for path A"); + assert.notStrictEqual(afterB, beforeB, "reset must create fresh instances for path B"); + assert.notStrictEqual(afterA, afterB, "new instances should still be distinct"); + } finally { + await bridge.resetBridgeServiceForTests(); + fixtureA.cleanup(); + fixtureB.cleanup(); + } +}); diff --git a/src/tests/web-onboarding-contract.test.ts b/src/tests/web-onboarding-contract.test.ts new file mode 100644 index 000000000..5d0be31af --- /dev/null +++ b/src/tests/web-onboarding-contract.test.ts @@ -0,0 +1,606 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { EventEmitter } from "node:events"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PassThrough } from "node:stream"; +import { StringDecoder } from "node:string_decoder"; + +const repoRoot = process.cwd(); +const bridge = await import("../web/bridge-service.ts"); +const onboarding = await import("../web/onboarding-service.ts"); +const bootRoute = await import("../../web/app/api/boot/route.ts"); +const onboardingRoute = await import("../../web/app/api/onboarding/route.ts"); +const commandRoute = await import("../../web/app/api/session/command/route.ts"); +const { AuthStorage } = await import("@gsd/pi-coding-agent"); + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough(); + stdout = new PassThrough(); + stderr = new PassThrough(); + exitCode: number | null = null; + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0; + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal); + }); + return true; + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + const line = buffer.slice(0, newlineIndex); + buffer = buffer.slice(newlineIndex + 1); + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + } + }); +} + +function makeWorkspaceFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-web-onboarding-")); + const projectCwd = join(root, "project"); + const sessionsDir = join(root, "sessions"); + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S02"); + const tasksDir = join(sliceDir, "tasks"); + + mkdirSync(tasksDir, { recursive: true }); + mkdirSync(sessionsDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + `# M001: Demo Milestone\n\n## Slices\n- [ ] **S02: First-run setup wizard** \`risk:medium\` \`depends:[S01]\`\n > Browser onboarding\n`, + ); + writeFileSync( + join(sliceDir, "S02-PLAN.md"), + `# S02: First-run setup wizard\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Establish shared onboarding auth truth and browser setup API** \`est:1h\`\n Do the work.\n`, + ); + writeFileSync( + join(tasksDir, "T01-PLAN.md"), + `# T01: Establish shared onboarding auth truth and browser setup API\n\n## Steps\n- do it\n`, + ); + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +function createSessionFile(projectCwd: string, sessionsDir: string, sessionId: string, name: string): string { + const sessionPath = join(sessionsDir, `2026-03-14T18-00-00-000Z_${sessionId}.jsonl`); + writeFileSync( + sessionPath, + [ + JSON.stringify({ + type: "session", + version: 3, + id: sessionId, + timestamp: "2026-03-14T18:00:00.000Z", + cwd: projectCwd, + }), + JSON.stringify({ + type: "session_info", + id: "info-1", + parentId: null, + timestamp: "2026-03-14T18:00:01.000Z", + name, + }), + ].join("\n") + "\n", + ); + return sessionPath; +} + +function fakeAutoDashboardData() { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function fakeWorkspaceIndex() { + return { + milestones: [ + { + id: "M001", + title: "Demo Milestone", + roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md", + slices: [ + { + id: "S02", + title: "First-run setup wizard", + done: false, + planPath: ".gsd/milestones/M001/slices/S02/S02-PLAN.md", + tasksDir: ".gsd/milestones/M001/slices/S02/tasks", + tasks: [ + { + id: "T01", + title: "Establish shared onboarding auth truth and browser setup API", + done: false, + planPath: ".gsd/milestones/M001/slices/S02/tasks/T01-PLAN.md", + }, + ], + }, + ], + }, + ], + active: { + milestoneId: "M001", + sliceId: "S02", + taskId: "T01", + phase: "executing", + }, + scopes: [ + { scope: "project", label: "project", kind: "project" }, + { scope: "M001", label: "M001: Demo Milestone", kind: "milestone" }, + { scope: "M001/S02", label: "M001/S02: First-run setup wizard", kind: "slice" }, + { + scope: "M001/S02/T01", + label: "M001/S02/T01: Establish shared onboarding auth truth and browser setup API", + kind: "task", + }, + ], + validationIssues: [], + }; +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let spawnCalls = 0; + let child: FakeRpcChild | null = null; + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + spawnCalls += 1; + child = new FakeRpcChild(); + attachJsonLineReader(child.stdin, (line) => { + onCommand(JSON.parse(line), harness); + }); + void command; + void args; + void options; + return child as any; + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started"); + child.stdout.write(serializeJsonLine(payload)); + }, + get spawnCalls() { + return spawnCalls; + }, + }; + + return harness; +} + +function configureBridgeFixture(fixture: { projectCwd: string; sessionsDir: string }, sessionId: string) { + const sessionPath = createSessionFile(fixture.projectCwd, fixture.sessionsDir, sessionId, "Onboarding Session"); + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId, + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }); + return; + } + + assert.fail(`unexpected bridge command during onboarding contract test: ${command.type}`); + }); + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + indexWorkspace: async () => fakeWorkspaceIndex(), + getAutoDashboardData: () => fakeAutoDashboardData(), + }); + + return harness; +} + +test("boot and onboarding routes expose locked required state plus explicitly skippable optional setup when auth is missing", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + configureBridgeFixture(fixture, "sess-missing-auth"); + onboarding.configureOnboardingServiceForTests({ authStorage }); + + try { + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200); + const bootPayload = (await bootResponse.json()) as any; + + assert.equal(bootPayload.onboardingNeeded, true); + assert.equal(bootPayload.onboarding.status, "blocked"); + assert.equal(bootPayload.onboarding.locked, true); + assert.equal(bootPayload.onboarding.lockReason, "required_setup"); + assert.equal(bootPayload.onboarding.bridgeAuthRefresh.phase, "idle"); + assert.equal(bootPayload.onboarding.required.satisfied, false); + assert.equal(bootPayload.onboarding.required.satisfiedBy, null); + assert.equal(bootPayload.onboarding.optional.skippable, true); + assert.ok(bootPayload.onboarding.optional.sections.every((section: any) => section.blocking === false)); + + const providerIds = bootPayload.onboarding.required.providers.map((provider: any) => provider.id); + assert.deepEqual(providerIds, [ + "anthropic", + "openai", + "github-copilot", + "openai-codex", + "google-gemini-cli", + "google-antigravity", + "google", + "groq", + "xai", + "openrouter", + "mistral", + ]); + const anthropicProvider = bootPayload.onboarding.required.providers.find((provider: any) => provider.id === "anthropic"); + assert.equal(anthropicProvider.supports.apiKey, true); + assert.equal(anthropicProvider.supports.oauthAvailable, true); + + const onboardingResponse = await onboardingRoute.GET(); + assert.equal(onboardingResponse.status, 200); + const onboardingPayload = (await onboardingResponse.json()) as any; + assert.equal(onboardingPayload.onboarding.locked, true); + assert.equal(onboardingPayload.onboarding.optional.skippable, true); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("runtime env-backed auth unlocks boot onboarding state and reports the environment source", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const previousGithubToken = process.env.GITHUB_TOKEN; + process.env.GITHUB_TOKEN = "ghu_runtime_env_token"; + configureBridgeFixture(fixture, "sess-env-auth"); + onboarding.configureOnboardingServiceForTests({ authStorage }); + + try { + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200); + const bootPayload = (await bootResponse.json()) as any; + + assert.equal(bootPayload.onboardingNeeded, false); + assert.equal(bootPayload.onboarding.locked, false); + assert.equal(bootPayload.onboarding.lockReason, null); + assert.equal(bootPayload.onboarding.bridgeAuthRefresh.phase, "idle"); + assert.deepEqual(bootPayload.onboarding.required.satisfiedBy, { + providerId: "github-copilot", + source: "environment", + }); + const copilotProvider = bootPayload.onboarding.required.providers.find((provider: any) => provider.id === "github-copilot"); + assert.equal(copilotProvider.configured, true); + assert.equal(copilotProvider.configuredVia, "environment"); + } finally { + if (previousGithubToken === undefined) { + delete process.env.GITHUB_TOKEN; + } else { + process.env.GITHUB_TOKEN = previousGithubToken; + } + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("failed API-key validation stays locked, redacts the error, and is reflected in boot state without persisting auth", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + configureBridgeFixture(fixture, "sess-validation-failure"); + onboarding.configureOnboardingServiceForTests({ + authStorage, + validateApiKey: async () => ({ + ok: false, + message: "OpenAI rejected sk-test-secret-123456 because Bearer sk-test-secret-123456 is invalid", + }), + }); + + try { + const validationResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "save_api_key", + providerId: "openai", + apiKey: "sk-test-secret-123456", + }), + }), + ); + + assert.equal(validationResponse.status, 422); + const validationPayload = (await validationResponse.json()) as any; + assert.equal(validationPayload.onboarding.locked, true); + assert.equal(validationPayload.onboarding.required.satisfied, false); + assert.equal(validationPayload.onboarding.lastValidation.status, "failed"); + assert.equal(validationPayload.onboarding.lastValidation.providerId, "openai"); + assert.equal(validationPayload.onboarding.lastValidation.persisted, false); + assert.equal(validationPayload.onboarding.lockReason, "required_setup"); + assert.equal(validationPayload.onboarding.bridgeAuthRefresh.phase, "idle"); + assert.match(validationPayload.onboarding.lastValidation.message, /OpenAI rejected/i); + assert.doesNotMatch(validationPayload.onboarding.lastValidation.message, /sk-test-secret-123456/); + assert.equal(authStorage.hasAuth("openai"), false); + + const bootResponse = await bootRoute.GET(); + assert.equal(bootResponse.status, 200); + const bootPayload = (await bootResponse.json()) as any; + assert.equal(bootPayload.onboarding.locked, true); + assert.equal(bootPayload.onboarding.lastValidation.status, "failed"); + assert.doesNotMatch(bootPayload.onboarding.lastValidation.message, /sk-test-secret-123456/); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("direct prompt commands cannot bypass onboarding while required setup is still locked", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const harness = configureBridgeFixture(fixture, "sess-command-locked"); + onboarding.configureOnboardingServiceForTests({ authStorage }); + + try { + const response = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "prompt", message: "hello from bypass attempt" }), + }), + ); + + assert.equal(response.status, 423); + const payload = (await response.json()) as any; + assert.equal(payload.success, false); + assert.equal(payload.command, "prompt"); + assert.equal(payload.code, "onboarding_locked"); + assert.equal(payload.details.reason, "required_setup"); + assert.equal(payload.details.onboarding.locked, true); + assert.equal(harness.spawnCalls, 0); + + const stateResponse = await commandRoute.POST( + new Request("http://localhost/api/session/command", { + method: "POST", + body: JSON.stringify({ type: "get_state" }), + }), + ); + assert.equal(stateResponse.status, 200); + const statePayload = (await stateResponse.json()) as any; + assert.equal(statePayload.success, true); + assert.equal(statePayload.command, "get_state"); + assert.equal(harness.spawnCalls, 1); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("bridge auth refresh failures remain inspectable and keep the workspace locked after credentials validate", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + configureBridgeFixture(fixture, "sess-refresh-failure"); + onboarding.configureOnboardingServiceForTests({ + authStorage, + validateApiKey: async () => ({ ok: true, message: "openai credentials validated" }), + refreshBridgeAuth: async () => { + throw new Error("bridge restart failed for sk-refresh-secret-123456"); + }, + }); + + try { + const validationResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "save_api_key", + providerId: "openai", + apiKey: "sk-valid-123456", + }), + }), + ); + + assert.equal(validationResponse.status, 503); + const validationPayload = (await validationResponse.json()) as any; + assert.equal(validationPayload.onboarding.required.satisfied, true); + assert.equal(validationPayload.onboarding.locked, true); + assert.equal(validationPayload.onboarding.lockReason, "bridge_refresh_failed"); + assert.equal(validationPayload.onboarding.lastValidation.status, "succeeded"); + assert.equal(validationPayload.onboarding.bridgeAuthRefresh.phase, "failed"); + assert.match(validationPayload.onboarding.bridgeAuthRefresh.error, /bridge restart failed/i); + assert.doesNotMatch(validationPayload.onboarding.bridgeAuthRefresh.error, /sk-refresh-secret-123456/); + assert.equal(authStorage.hasAuth("openai"), true); + + const bootResponse = await bootRoute.GET(); + const bootPayload = (await bootResponse.json()) as any; + assert.equal(bootPayload.onboarding.locked, true); + assert.equal(bootPayload.onboarding.lockReason, "bridge_refresh_failed"); + assert.equal(bootPayload.onboarding.bridgeAuthRefresh.phase, "failed"); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("successful API-key validation persists the credential and unlocks onboarding", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const harness = configureBridgeFixture(fixture, "sess-validation-success"); + onboarding.configureOnboardingServiceForTests({ + authStorage, + validateApiKey: async () => ({ ok: true, message: "openai credentials validated" }), + }); + + try { + const validationResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "save_api_key", + providerId: "openai", + apiKey: "sk-valid-123456", + }), + }), + ); + + assert.equal(validationResponse.status, 200); + const validationPayload = (await validationResponse.json()) as any; + assert.equal(validationPayload.onboarding.locked, false); + assert.deepEqual(validationPayload.onboarding.required.satisfiedBy, { + providerId: "openai", + source: "auth_file", + }); + assert.equal(validationPayload.onboarding.lastValidation.status, "succeeded"); + assert.equal(validationPayload.onboarding.lastValidation.persisted, true); + assert.equal(validationPayload.onboarding.lockReason, null); + assert.equal(validationPayload.onboarding.bridgeAuthRefresh.phase, "succeeded"); + assert.equal(authStorage.hasAuth("openai"), true); + assert.equal(harness.spawnCalls, 1); + + const bootResponse = await bootRoute.GET(); + const bootPayload = (await bootResponse.json()) as any; + assert.equal(bootPayload.onboarding.locked, false); + assert.equal(bootPayload.onboarding.lockReason, null); + assert.equal(bootPayload.onboarding.bridgeAuthRefresh.phase, "succeeded"); + assert.equal(bootPayload.onboardingNeeded, false); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("logout_provider removes saved auth, refreshes the bridge, and relocks onboarding when it was the only provider", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({ + openai: { type: "api_key", key: "sk-saved-logout" }, + } as any); + const harness = configureBridgeFixture(fixture, "sess-logout-success"); + onboarding.configureOnboardingServiceForTests({ authStorage }); + + try { + const bootBefore = await bootRoute.GET(); + const bootBeforePayload = (await bootBefore.json()) as any; + assert.equal(bootBeforePayload.onboarding.locked, false); + assert.equal(bootBeforePayload.onboarding.required.satisfiedBy.providerId, "openai"); + assert.equal(harness.spawnCalls, 1); + + const logoutResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "logout_provider", + providerId: "openai", + }), + }), + ); + + assert.equal(logoutResponse.status, 200); + const logoutPayload = (await logoutResponse.json()) as any; + assert.equal(logoutPayload.onboarding.locked, true); + assert.equal(logoutPayload.onboarding.lockReason, "required_setup"); + assert.equal(logoutPayload.onboarding.bridgeAuthRefresh.phase, "succeeded"); + assert.equal(logoutPayload.onboarding.lastValidation, null); + assert.equal(authStorage.hasAuth("openai"), false); + assert.equal(harness.spawnCalls, 2); + + const bootAfter = await bootRoute.GET(); + const bootAfterPayload = (await bootAfter.json()) as any; + assert.equal(bootAfterPayload.onboarding.locked, true); + assert.equal(bootAfterPayload.onboarding.lockReason, "required_setup"); + assert.equal(bootAfterPayload.onboarding.bridgeAuthRefresh.phase, "succeeded"); + assert.equal(bootAfterPayload.onboarding.required.satisfied, false); + } finally { + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); + +test("logout_provider fails clearly for environment-backed auth that the browser cannot remove", async () => { + const fixture = makeWorkspaceFixture(); + const authStorage = AuthStorage.inMemory({}); + const previousGithubToken = process.env.GITHUB_TOKEN; + process.env.GITHUB_TOKEN = "ghu_env_only_token"; + configureBridgeFixture(fixture, "sess-logout-env"); + onboarding.configureOnboardingServiceForTests({ authStorage }); + + try { + const bootBefore = await bootRoute.GET(); + const bootBeforePayload = (await bootBefore.json()) as any; + assert.equal(bootBeforePayload.onboarding.locked, false); + assert.equal(bootBeforePayload.onboarding.required.satisfiedBy.providerId, "github-copilot"); + assert.equal(bootBeforePayload.onboarding.required.satisfiedBy.source, "environment"); + + const logoutResponse = await onboardingRoute.POST( + new Request("http://localhost/api/onboarding", { + method: "POST", + body: JSON.stringify({ + action: "logout_provider", + providerId: "github-copilot", + }), + }), + ); + + assert.equal(logoutResponse.status, 400); + const logoutPayload = (await logoutResponse.json()) as any; + assert.match(logoutPayload.error, /cannot be logged out from the browser surface/i); + assert.equal(logoutPayload.onboarding.locked, false); + assert.equal(logoutPayload.onboarding.required.satisfiedBy.providerId, "github-copilot"); + assert.equal(logoutPayload.onboarding.required.satisfiedBy.source, "environment"); + } finally { + if (previousGithubToken === undefined) { + delete process.env.GITHUB_TOKEN; + } else { + process.env.GITHUB_TOKEN = previousGithubToken; + } + onboarding.resetOnboardingServiceForTests(); + await bridge.resetBridgeServiceForTests(); + fixture.cleanup(); + } +}); diff --git a/src/tests/web-onboarding-presentation.test.ts b/src/tests/web-onboarding-presentation.test.ts new file mode 100644 index 000000000..f74a0ff59 --- /dev/null +++ b/src/tests/web-onboarding-presentation.test.ts @@ -0,0 +1,129 @@ +import test from "node:test" +import assert from "node:assert/strict" + +const { getOnboardingPresentation } = await import("../../web/lib/gsd-workspace-store.tsx") + +function makeOnboardingState(overrides: Record = {}) { + return { + status: "blocked", + locked: true, + lockReason: "required_setup", + required: { + blocking: true, + skippable: false, + satisfied: false, + satisfiedBy: null, + providers: [ + { + id: "openai", + label: "OpenAI", + required: true, + recommended: false, + configured: false, + configuredVia: null, + supports: { + apiKey: true, + oauth: false, + oauthAvailable: false, + usesCallbackServer: false, + }, + }, + ], + }, + optional: { + blocking: false, + skippable: true, + sections: [], + }, + lastValidation: null, + activeFlow: null, + bridgeAuthRefresh: { + phase: "idle", + strategy: null, + startedAt: null, + completedAt: null, + error: null, + }, + ...overrides, + } +} + +function makeState(overrides: Record = {}) { + return { + bootStatus: "ready", + onboardingRequestState: "idle", + boot: { + onboarding: makeOnboardingState(), + }, + ...overrides, + } as Parameters[0] +} + +test("getOnboardingPresentation prefers bridge refresh pending over saving_api_key", () => { + const presentation = getOnboardingPresentation( + makeState({ + onboardingRequestState: "saving_api_key", + boot: { + onboarding: makeOnboardingState({ + status: "blocked", + locked: true, + lockReason: "bridge_refresh_pending", + required: { + blocking: true, + skippable: false, + satisfied: true, + satisfiedBy: { providerId: "openai", source: "auth_file" }, + providers: [ + { + id: "openai", + label: "OpenAI", + required: true, + recommended: false, + configured: true, + configuredVia: "auth_file", + supports: { + apiKey: true, + oauth: false, + oauthAvailable: false, + usesCallbackServer: false, + }, + }, + ], + }, + lastValidation: { + status: "succeeded", + providerId: "openai", + method: "api_key", + checkedAt: new Date().toISOString(), + message: "OpenAI credentials validated", + persisted: true, + }, + bridgeAuthRefresh: { + phase: "pending", + strategy: "restart", + startedAt: new Date().toISOString(), + completedAt: null, + error: null, + }, + }), + }, + }), + ) + + assert.equal(presentation.phase, "refreshing") + assert.equal(presentation.label, "Refreshing bridge auth") +}) + +test("getOnboardingPresentation still shows validating when save is in flight and onboarding has not advanced", () => { + const presentation = getOnboardingPresentation( + makeState({ + onboardingRequestState: "saving_api_key", + boot: { + onboarding: makeOnboardingState(), + }, + }), + ) + + assert.equal(presentation.phase, "validating") + assert.equal(presentation.label, "Validating credentials") +}) diff --git a/src/tests/web-project-discovery-contract.test.ts b/src/tests/web-project-discovery-contract.test.ts new file mode 100644 index 000000000..351a75426 --- /dev/null +++ b/src/tests/web-project-discovery-contract.test.ts @@ -0,0 +1,124 @@ +import test, { after, describe } from "node:test"; +import assert from "node:assert/strict"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; + +import { discoverProjects } from "../web/project-discovery-service.ts"; + +// --------------------------------------------------------------------------- +// Fixture setup +// --------------------------------------------------------------------------- + +const tempRoot = mkdtempSync(join(tmpdir(), "gsd-project-discovery-")); + +// project-a: brownfield (package.json + .git) +const projectA = join(tempRoot, "project-a"); +mkdirSync(projectA); +mkdirSync(join(projectA, ".git")); +writeFileSync(join(projectA, "package.json"), "{}"); + +// project-b: empty-gsd (.gsd folder, no milestones) +const projectB = join(tempRoot, "project-b"); +mkdirSync(projectB); +mkdirSync(join(projectB, ".gsd")); + +// project-c: brownfield (Cargo.toml) +const projectC = join(tempRoot, "project-c"); +mkdirSync(projectC); +writeFileSync(join(projectC, "Cargo.toml"), ""); + +// project-d: blank (empty) +const projectD = join(tempRoot, "project-d"); +mkdirSync(projectD); + +// .hidden: should be excluded +mkdirSync(join(tempRoot, ".hidden")); + +// node_modules: should be excluded +mkdirSync(join(tempRoot, "node_modules")); + +// --------------------------------------------------------------------------- +// Teardown +// --------------------------------------------------------------------------- + +after(() => { + rmSync(tempRoot, { recursive: true, force: true }); +}); + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +describe("project-discovery", () => { + test("discovers exactly 4 project directories (excludes hidden + node_modules)", () => { + const results = discoverProjects(tempRoot); + assert.equal(results.length, 4, `Expected 4 projects, got ${results.length}: ${results.map(r => r.name).join(", ")}`); + }); + + test("results are sorted alphabetically by name", () => { + const results = discoverProjects(tempRoot); + const names = results.map(r => r.name); + assert.deepStrictEqual(names, ["project-a", "project-b", "project-c", "project-d"]); + }); + + test("project-a is detected as brownfield with correct signals", () => { + const results = discoverProjects(tempRoot); + const a = results.find(r => r.name === "project-a"); + assert.ok(a, "project-a not found"); + assert.equal(a.kind, "brownfield"); + assert.equal(a.signals.hasPackageJson, true); + assert.equal(a.signals.hasGitRepo, true); + }); + + test("project-b is detected as empty-gsd", () => { + const results = discoverProjects(tempRoot); + const b = results.find(r => r.name === "project-b"); + assert.ok(b, "project-b not found"); + assert.equal(b.kind, "empty-gsd"); + assert.equal(b.signals.hasGsdFolder, true); + }); + + test("project-c is detected as brownfield with hasCargo signal", () => { + const results = discoverProjects(tempRoot); + const c = results.find(r => r.name === "project-c"); + assert.ok(c, "project-c not found"); + assert.equal(c.kind, "brownfield"); + assert.equal(c.signals.hasCargo, true); + }); + + test("project-d is detected as blank", () => { + const results = discoverProjects(tempRoot); + const d = results.find(r => r.name === "project-d"); + assert.ok(d, "project-d not found"); + assert.equal(d.kind, "blank"); + }); + + test("excludes .hidden and node_modules directories", () => { + const results = discoverProjects(tempRoot); + const names = results.map(r => r.name); + assert.ok(!names.includes(".hidden"), ".hidden should be excluded"); + assert.ok(!names.includes("node_modules"), "node_modules should be excluded"); + }); + + test("all entries have lastModified as a number > 0", () => { + const results = discoverProjects(tempRoot); + for (const entry of results) { + assert.equal(typeof entry.lastModified, "number"); + assert.ok(entry.lastModified > 0, `${entry.name} lastModified should be > 0`); + } + }); + + test("all entries have valid path and name", () => { + const results = discoverProjects(tempRoot); + for (const entry of results) { + assert.ok(entry.path.startsWith(tempRoot), `${entry.name} path should start with tempRoot`); + assert.ok(entry.name.length > 0, "name should not be empty"); + } + }); + + test("nonexistent path returns empty array", () => { + const results = discoverProjects("/nonexistent/path/that/does/not/exist"); + assert.deepStrictEqual(results, []); + }); +}); diff --git a/src/tests/web-project-url.test.ts b/src/tests/web-project-url.test.ts new file mode 100644 index 000000000..350b94354 --- /dev/null +++ b/src/tests/web-project-url.test.ts @@ -0,0 +1,32 @@ +import test from "node:test" +import assert from "node:assert/strict" + +import { buildProjectAbsoluteUrl, buildProjectPath } from "../../web/lib/project-url.ts" + +test("buildProjectPath leaves non-project routes unchanged", () => { + assert.equal(buildProjectPath("/api/terminal/input"), "/api/terminal/input") +}) + +test("buildProjectPath appends project while preserving existing query params", () => { + const path = buildProjectPath("/api/bridge-terminal/stream?cols=132&rows=41", "/tmp/Project With Spaces") + const url = new URL(path, "http://localhost") + + assert.equal(url.pathname, "/api/bridge-terminal/stream") + assert.equal(url.searchParams.get("cols"), "132") + assert.equal(url.searchParams.get("rows"), "41") + assert.equal(url.searchParams.get("project"), "/tmp/Project With Spaces") +}) + +test("buildProjectAbsoluteUrl produces a same-origin URL with the active project scope", () => { + const url = buildProjectAbsoluteUrl( + "/api/terminal/stream?id=gsd-interactive&command=gsd", + "http://localhost:3000", + "/Users/sn0w/Documents/dev/Other Project", + ) + + assert.equal(url.origin, "http://localhost:3000") + assert.equal(url.pathname, "/api/terminal/stream") + assert.equal(url.searchParams.get("id"), "gsd-interactive") + assert.equal(url.searchParams.get("command"), "gsd") + assert.equal(url.searchParams.get("project"), "/Users/sn0w/Documents/dev/Other Project") +}) diff --git a/src/tests/web-recovery-diagnostics-contract.test.ts b/src/tests/web-recovery-diagnostics-contract.test.ts new file mode 100644 index 000000000..b3cace09d --- /dev/null +++ b/src/tests/web-recovery-diagnostics-contract.test.ts @@ -0,0 +1,380 @@ +import test from "node:test" +import assert from "node:assert/strict" +import { EventEmitter } from "node:events" +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs" +import { tmpdir } from "node:os" +import { join } from "node:path" +import { PassThrough } from "node:stream" +import { StringDecoder } from "node:string_decoder" + +const repoRoot = process.cwd() +const bridge = await import("../web/bridge-service.ts") +const recoveryRoute = await import("../../web/app/api/recovery/route.ts") + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough() + stdout = new PassThrough() + stderr = new PassThrough() + exitCode: number | null = null + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0 + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal) + }) + return true + } +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8") + let buffer = "" + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk) + while (true) { + const newlineIndex = buffer.indexOf("\n") + if (newlineIndex === -1) return + const line = buffer.slice(0, newlineIndex) + buffer = buffer.slice(newlineIndex + 1) + onLine(line.endsWith("\r") ? line.slice(0, -1) : line) + } + }) +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n` +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let child: FakeRpcChild | null = null + + const harness = { + spawn(command: string, args: readonly string[], options: Record) { + child = new FakeRpcChild() + attachJsonLineReader(child.stdin, (line) => { + onCommand(JSON.parse(line), harness) + }) + void command + void args + void options + return child as any + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started") + child.stdout.write(serializeJsonLine(payload)) + }, + } + + return harness +} + +function readyOnboardingState(overrides: Record = {}) { + return { + status: "ready", + locked: false, + lockReason: null, + required: { + blocking: true, + skippable: false, + satisfied: true, + satisfiedBy: { providerId: "anthropic", source: "auth_file" }, + providers: [], + }, + optional: { + blocking: false, + skippable: true, + sections: [], + }, + lastValidation: null, + activeFlow: null, + bridgeAuthRefresh: { + phase: "idle", + strategy: null, + startedAt: null, + completedAt: null, + error: null, + }, + ...overrides, + } +} + +function makeRecoveryFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-recovery-contract-")) + const projectCwd = join(root, "project") + const sessionsDir = join(root, "sessions") + const milestoneDir = join(projectCwd, ".gsd", "milestones", "M001") + const sliceDir = join(milestoneDir, "slices", "S01") + const tasksDir = join(sliceDir, "tasks") + + mkdirSync(tasksDir, { recursive: true }) + mkdirSync(sessionsDir, { recursive: true }) + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + "# M001: Recovery Demo\n\n## Slices\n- [ ] **S01: Recovery Slice** `risk:high` `depends:[]`\n > After this: recovery route exists\n", + ) + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + [ + "# S01: Recovery Slice", + "", + "**Goal:** Recovery diagnostics demo", + "**Demo:** Recovery diagnostics load in browser", + "", + "## Must-Haves", + "- Recovery diagnostics exist", + "", + "## Tasks", + "- [x] **T01: Broken task for doctor coverage** `est:10m`", + " Intentionally missing a summary to surface doctor diagnostics.", + ].join("\n"), + ) + writeFileSync( + join(tasksDir, "T01-PLAN.md"), + [ + "# T01: Broken task for doctor coverage", + "", + "## Steps", + "- leave this task incomplete on purpose", + ].join("\n"), + ) + + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + } +} + +function makeEmptyProjectFixture(): { projectCwd: string; sessionsDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-recovery-empty-")) + const projectCwd = join(root, "project") + const sessionsDir = join(root, "sessions") + mkdirSync(projectCwd, { recursive: true }) + mkdirSync(sessionsDir, { recursive: true }) + return { + projectCwd, + sessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + } +} + +function createRecoverySessionFile(projectCwd: string, sessionsDir: string, sessionId: string): string { + const sessionPath = join(sessionsDir, `2026-03-15T03-30-00-000Z_${sessionId}.jsonl`) + writeFileSync( + sessionPath, + [ + JSON.stringify({ type: "session", version: 3, id: sessionId, timestamp: "2026-03-15T03:30:00.000Z", cwd: projectCwd }), + JSON.stringify({ type: "session_info", id: `${sessionId}-info`, parentId: null, timestamp: "2026-03-15T03:30:01.000Z", name: "Recovery Session" }), + JSON.stringify({ + type: "message", + message: { + role: "assistant", + content: [{ type: "toolCall", id: "tool-1", name: "bash", arguments: { command: "echo hi" } }], + }, + }), + JSON.stringify({ + type: "message", + message: { + role: "toolResult", + toolCallId: "tool-1", + toolName: "bash", + isError: true, + content: "authentication failed for sk-test-recovery-secret-9999", + }, + }), + ].join("\n") + "\n", + ) + return sessionPath +} + +function fakeSessionState(sessionId: string, sessionPath?: string) { + return { + sessionId, + sessionFile: sessionPath, + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: true, + retryInProgress: true, + retryAttempt: 2, + messageCount: 3, + pendingMessageCount: 0, + } +} + +test("/api/recovery returns structured recovery diagnostics and redacts secrets", async () => { + const fixture = makeRecoveryFixture() + const sessionPath = createRecoverySessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-recovery") + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-recovery", sessionPath), + }) + return + } + assert.fail(`unexpected command: ${command.type}`) + }) + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + getOnboardingState: async () => readyOnboardingState({ + locked: true, + lockReason: "bridge_refresh_failed", + bridgeAuthRefresh: { + phase: "failed", + strategy: "restart", + startedAt: "2026-03-15T03:31:00.000Z", + completedAt: "2026-03-15T03:31:05.000Z", + error: "Bridge refresh failed for sk-onboarding-secret-1234", + }, + }), + }) + + try { + const response = await recoveryRoute.GET() + assert.equal(response.status, 200) + const payload = await response.json() as any + + assert.equal(payload.status, "ready") + assert.equal(payload.project.activeSessionPath, sessionPath) + assert.equal(payload.project.activeSessionId, "sess-recovery") + assert.equal(payload.bridge.retry.inProgress, true) + assert.equal(payload.bridge.retry.attempt, 2) + assert.equal(payload.bridge.authRefresh.phase, "failed") + assert.match(payload.bridge.authRefresh.label, /failed/i) + assert.ok(typeof payload.doctor.total === "number") + assert.ok(Array.isArray(payload.doctor.codes)) + assert.ok(typeof payload.validation.total === "number") + assert.equal(payload.interruptedRun.detected, true) + assert.match(payload.interruptedRun.lastError ?? "", /\[redacted\]/) + assert.deepEqual( + payload.actions.browser.map((action: { id: string }) => action.id), + ["refresh_diagnostics", "refresh_workspace", "open_retry_controls", "open_resume_controls", "open_auth_controls"], + ) + assert.ok(payload.actions.commands.some((entry: { command: string }) => entry.command.includes("/gsd doctor"))) + + const serialized = JSON.stringify(payload) + assert.doesNotMatch(serialized, /sk-test-recovery-secret-9999|sk-onboarding-secret-1234/) + assert.doesNotMatch(serialized, /Crash Recovery Briefing|Completed Tool Calls|toolCallId/) + } finally { + await bridge.resetBridgeServiceForTests() + fixture.cleanup() + } +}) + +test("/api/recovery prefers the current-project resumable session when the live bridge session is out of scope", async () => { + const fixture = makeRecoveryFixture() + const sessionPath = createRecoverySessionFile(fixture.projectCwd, fixture.sessionsDir, "sess-recovery") + const externalSessionPath = join(fixture.projectCwd, "..", "agent-sessions", "2026-03-15T03-40-00-000Z_sess-external.jsonl") + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: fakeSessionState("sess-external", externalSessionPath), + }) + return + } + assert.fail(`unexpected command: ${command.type}`) + }) + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + getOnboardingState: async () => readyOnboardingState(), + }) + + try { + const response = await recoveryRoute.GET() + assert.equal(response.status, 200) + const payload = await response.json() as any + + assert.equal(payload.project.activeSessionPath, sessionPath) + assert.equal(payload.project.activeSessionId, "sess-recovery") + assert.equal(payload.interruptedRun.detected, true) + assert.match(payload.interruptedRun.lastError ?? "", /\[redacted\]/) + assert.deepEqual( + payload.actions.browser.map((action: { id: string }) => action.id), + ["refresh_diagnostics", "refresh_workspace", "open_retry_controls", "open_resume_controls"], + ) + } finally { + await bridge.resetBridgeServiceForTests() + fixture.cleanup() + } +}) + +test("/api/recovery returns a structured empty-project payload without leaking raw diagnostics", async () => { + const fixture = makeEmptyProjectFixture() + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + ...fakeSessionState("sess-empty"), + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + }, + }) + return + } + assert.fail(`unexpected command: ${command.type}`) + }) + + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + getOnboardingState: async () => readyOnboardingState(), + }) + + try { + const response = await recoveryRoute.GET() + assert.equal(response.status, 200) + const payload = await response.json() as any + + assert.ok(["ready", "unavailable"].includes(payload.status)) + assert.equal(payload.project.activeScope, null) + assert.equal(payload.validation.total, 0) + assert.ok(typeof payload.doctor.total === "number") + assert.ok(typeof payload.interruptedRun.available === "boolean") + assert.deepEqual( + payload.actions.browser.map((action: { id: string }) => action.id), + ["refresh_diagnostics", "refresh_workspace"], + ) + } finally { + await bridge.resetBridgeServiceForTests() + fixture.cleanup() + } +}) diff --git a/src/tests/web-session-parity-contract.test.ts b/src/tests/web-session-parity-contract.test.ts new file mode 100644 index 000000000..0b52a6504 --- /dev/null +++ b/src/tests/web-session-parity-contract.test.ts @@ -0,0 +1,691 @@ +import test from "node:test" +import assert from "node:assert/strict" +import { execFileSync } from "node:child_process" +import { EventEmitter } from "node:events" +import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs" +import { tmpdir } from "node:os" +import { join, resolve } from "node:path" +import { PassThrough } from "node:stream" +import { StringDecoder } from "node:string_decoder" + +const repoRoot = process.cwd() +const bridge = await import("../web/bridge-service.ts") +const onboarding = await import("../web/onboarding-service.ts") +const browserRoute = await import("../../web/app/api/session/browser/route.ts") +const manageRoute = await import("../../web/app/api/session/manage/route.ts") +const gitRoute = await import("../../web/app/api/git/route.ts") +const { AuthStorage } = await import("@gsd/pi-coding-agent") + +class FakeRpcChild extends EventEmitter { + stdin = new PassThrough() + stdout = new PassThrough() + stderr = new PassThrough() + exitCode: number | null = null + + kill(signal: NodeJS.Signals = "SIGTERM"): boolean { + if (this.exitCode === null) { + this.exitCode = 0 + } + queueMicrotask(() => { + this.emit("exit", this.exitCode, signal) + }) + return true + } +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n` +} + +function attachJsonLineReader(stream: PassThrough, onLine: (line: string) => void): void { + const decoder = new StringDecoder("utf8") + let buffer = "" + + stream.on("data", (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk) + while (true) { + const newlineIndex = buffer.indexOf("\n") + if (newlineIndex === -1) return + const line = buffer.slice(0, newlineIndex) + buffer = buffer.slice(newlineIndex + 1) + onLine(line.endsWith("\r") ? line.slice(0, -1) : line) + } + }) +} + +function waitForMicrotasks(): Promise { + return new Promise((resolve) => setTimeout(resolve, 0)) +} + +function makeWorkspaceFixture(): { + root: string + projectCwd: string + sessionsDir: string + otherProjectCwd: string + otherSessionsDir: string + cleanup: () => void +} { + const root = mkdtempSync(join(tmpdir(), "gsd-web-session-parity-")) + const projectCwd = join(root, "project") + const sessionsDir = join(root, "sessions") + const otherProjectCwd = join(root, "other-project") + const otherSessionsDir = join(root, "other-sessions") + + mkdirSync(projectCwd, { recursive: true }) + mkdirSync(sessionsDir, { recursive: true }) + mkdirSync(otherProjectCwd, { recursive: true }) + mkdirSync(otherSessionsDir, { recursive: true }) + + return { + root, + projectCwd, + sessionsDir, + otherProjectCwd, + otherSessionsDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + } +} + +type SessionFixtureOptions = { + projectCwd: string + sessionsDir: string + sessionId: string + fileStamp: string + createdAt: string + assistantAt: string + userText: string + assistantText: string + name?: string + parentSessionPath?: string +} + +function createSessionFile(options: SessionFixtureOptions): string { + const sessionPath = join(options.sessionsDir, `${options.fileStamp}_${options.sessionId}.jsonl`) + const entries: unknown[] = [ + { + type: "session", + version: 3, + id: options.sessionId, + timestamp: options.createdAt, + cwd: options.projectCwd, + ...(options.parentSessionPath ? { parentSession: options.parentSessionPath } : {}), + }, + ] + + let parentId: string | null = null + + if (options.name) { + parentId = `${options.sessionId}-info` + entries.push({ + type: "session_info", + id: parentId, + parentId: null, + timestamp: options.createdAt, + name: options.name, + }) + } + + const userId = `${options.sessionId}-user` + entries.push({ + type: "message", + id: userId, + parentId, + timestamp: options.createdAt, + message: { + role: "user", + content: options.userText, + timestamp: new Date(options.createdAt).getTime(), + }, + }) + + const assistantId = `${options.sessionId}-assistant` + entries.push({ + type: "message", + id: assistantId, + parentId: userId, + timestamp: options.assistantAt, + message: { + role: "assistant", + content: options.assistantText, + timestamp: new Date(options.assistantAt).getTime(), + provider: "openai", + model: "gpt-test", + }, + }) + + writeFileSync(sessionPath, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`) + return sessionPath +} + +function getLatestSessionName(sessionPath: string): string | undefined { + const lines = readFileSync(sessionPath, "utf8") + .trim() + .split("\n") + .filter(Boolean) + + for (let index = lines.length - 1; index >= 0; index--) { + const parsed = JSON.parse(lines[index]!) as { type?: string; name?: string } + if (parsed.type === "session_info" && typeof parsed.name === "string") { + return parsed.name + } + } + + return undefined +} + +function git(basePath: string, args: string[]): string { + return execFileSync("git", args, { + cwd: basePath, + encoding: "utf8", + }).trim() +} + +function withProjectGitEnv(projectCwd: string, run: () => Promise): Promise { + const previousProjectCwd = process.env.GSD_WEB_PROJECT_CWD + process.env.GSD_WEB_PROJECT_CWD = projectCwd + + return run().finally(() => { + if (previousProjectCwd === undefined) { + delete process.env.GSD_WEB_PROJECT_CWD + return + } + process.env.GSD_WEB_PROJECT_CWD = previousProjectCwd + }) +} + +function createHarness(onCommand: (command: any, harness: ReturnType) => void) { + let child: FakeRpcChild | null = null + const commands: any[] = [] + + const harness = { + spawn() { + child = new FakeRpcChild() + attachJsonLineReader(child.stdin, (line) => { + const parsed = JSON.parse(line) + commands.push(parsed) + onCommand(parsed, harness) + }) + return child as any + }, + emit(payload: unknown) { + if (!child) throw new Error("fake child not started") + child.stdout.write(serializeJsonLine(payload)) + }, + get commands() { + return commands + }, + } + + return harness +} + +function configureBridgeFixture( + fixture: ReturnType, + harness: ReturnType, +): void { + bridge.configureBridgeServiceForTests({ + env: { + ...process.env, + GSD_WEB_PROJECT_CWD: fixture.projectCwd, + GSD_WEB_PROJECT_SESSIONS_DIR: fixture.sessionsDir, + GSD_WEB_PACKAGE_ROOT: repoRoot, + }, + spawn: harness.spawn, + }) +} + +test("/api/session/browser stays current-project scoped and carries threaded/search metadata outside /api/boot", async () => { + const fixture = makeWorkspaceFixture() + const rootPath = createSessionFile({ + projectCwd: fixture.projectCwd, + sessionsDir: fixture.sessionsDir, + sessionId: "sess-root", + fileStamp: "2026-03-14T18-00-00-000Z", + createdAt: "2026-03-14T18:00:00.000Z", + assistantAt: "2026-03-14T18:05:00.000Z", + userText: "Plan the deploy checklist", + assistantText: "Baseline deploy context", + }) + const childPath = createSessionFile({ + projectCwd: fixture.projectCwd, + sessionsDir: fixture.sessionsDir, + sessionId: "sess-child", + fileStamp: "2026-03-14T18-10-00-000Z", + createdAt: "2026-03-14T18:10:00.000Z", + assistantAt: "2026-03-14T18:20:00.000Z", + userText: "Investigate the branch rename", + assistantText: "No dedicated browser notes here", + name: "Deploy Child", + parentSessionPath: rootPath, + }) + createSessionFile({ + projectCwd: fixture.projectCwd, + sessionsDir: fixture.sessionsDir, + sessionId: "sess-named", + fileStamp: "2026-03-14T18-30-00-000Z", + createdAt: "2026-03-14T18:30:00.000Z", + assistantAt: "2026-03-14T18:35:00.000Z", + userText: "Write release notes", + assistantText: "api-session-browser appears only in this searchable assistant message", + name: "Release Notes", + }) + const outsidePath = createSessionFile({ + projectCwd: fixture.otherProjectCwd, + sessionsDir: fixture.otherSessionsDir, + sessionId: "sess-outside", + fileStamp: "2026-03-14T18-40-00-000Z", + createdAt: "2026-03-14T18:40:00.000Z", + assistantAt: "2026-03-14T18:45:00.000Z", + userText: "Outside scope", + assistantText: "api-session-browser should stay hidden from the current project route", + name: "Outside", + }) + + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-child", + sessionFile: childPath, + sessionName: "Deploy Child", + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }) + return + } + + assert.fail(`unexpected command: ${command.type}`) + }) + + configureBridgeFixture(fixture, harness) + + try { + const response = await browserRoute.GET(new Request("http://localhost/api/session/browser")) + assert.equal(response.status, 200) + const payload = await response.json() as any + + assert.equal(payload.project.scope, "current_project") + assert.equal(payload.project.cwd, fixture.projectCwd) + assert.equal(payload.project.sessionsDir, fixture.sessionsDir) + assert.equal(payload.project.activeSessionPath, childPath) + assert.equal(payload.totalSessions, 3) + assert.equal(payload.returnedSessions, 3) + assert.equal(payload.sessions.some((session: any) => session.path === outsidePath), false) + + const child = payload.sessions.find((session: any) => session.id === "sess-child") + assert.ok(child) + assert.equal(child.parentSessionPath, rootPath) + assert.equal(child.firstMessage, "Investigate the branch rename") + assert.equal(child.isActive, true) + assert.equal(child.depth, 1) + assert.deepEqual(child.ancestorHasNextSibling, [false]) + assert.equal("allMessagesText" in child, false) + + const searchResponse = await browserRoute.GET( + new Request("http://localhost/api/session/browser?query=api-session-browser&sortMode=relevance&nameFilter=named"), + ) + assert.equal(searchResponse.status, 200) + const searchPayload = await searchResponse.json() as any + + assert.equal(searchPayload.totalSessions, 3) + assert.equal(searchPayload.returnedSessions, 1) + assert.equal(searchPayload.query.sortMode, "relevance") + assert.equal(searchPayload.query.nameFilter, "named") + assert.equal(searchPayload.sessions[0].id, "sess-named") + assert.equal(searchPayload.sessions[0].name, "Release Notes") + } finally { + await bridge.resetBridgeServiceForTests() + onboarding.resetOnboardingServiceForTests() + fixture.cleanup() + } +}) + +test("/api/session/manage renames the active session through bridge-aware RPC instead of mutating the file directly", async () => { + const fixture = makeWorkspaceFixture() + const activePath = createSessionFile({ + projectCwd: fixture.projectCwd, + sessionsDir: fixture.sessionsDir, + sessionId: "sess-active", + fileStamp: "2026-03-14T19-00-00-000Z", + createdAt: "2026-03-14T19:00:00.000Z", + assistantAt: "2026-03-14T19:05:00.000Z", + userText: "Name this session", + assistantText: "Active rename should go through rpc", + name: "Before Active Rename", + }) + + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-active", + sessionFile: activePath, + sessionName: "Before Active Rename", + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }) + return + } + + if (command.type === "set_session_name") { + current.emit({ + id: command.id, + type: "response", + command: "set_session_name", + success: true, + }) + return + } + + assert.fail(`unexpected command: ${command.type}`) + }) + + configureBridgeFixture(fixture, harness) + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + openai: { type: "api_key", key: "sk-active-rename" }, + } as any), + }) + + try { + const response = await manageRoute.POST( + new Request("http://localhost/api/session/manage", { + method: "POST", + body: JSON.stringify({ + action: "rename", + sessionPath: activePath, + name: "Active Renamed", + }), + }), + ) + const payload = await response.json() as any + await waitForMicrotasks() + + assert.equal(response.status, 200) + assert.equal(payload.success, true) + assert.equal(payload.sessionPath, activePath) + assert.equal(payload.isActiveSession, true) + assert.equal(payload.mutation, "rpc") + assert.ok(harness.commands.some((command) => command.type === "set_session_name" && command.name === "Active Renamed")) + assert.equal(getLatestSessionName(activePath), "Before Active Rename") + } finally { + await bridge.resetBridgeServiceForTests() + onboarding.resetOnboardingServiceForTests() + fixture.cleanup() + } +}) + +test("/api/session/manage renames inactive sessions via authoritative session-file mutation and rejects out-of-scope paths", async () => { + const fixture = makeWorkspaceFixture() + const activePath = createSessionFile({ + projectCwd: fixture.projectCwd, + sessionsDir: fixture.sessionsDir, + sessionId: "sess-active", + fileStamp: "2026-03-14T20-00-00-000Z", + createdAt: "2026-03-14T20:00:00.000Z", + assistantAt: "2026-03-14T20:05:00.000Z", + userText: "Keep this active", + assistantText: "This session stays active", + name: "Active Session", + }) + const inactivePath = createSessionFile({ + projectCwd: fixture.projectCwd, + sessionsDir: fixture.sessionsDir, + sessionId: "sess-inactive", + fileStamp: "2026-03-14T20-10-00-000Z", + createdAt: "2026-03-14T20:10:00.000Z", + assistantAt: "2026-03-14T20:15:00.000Z", + userText: "Rename this stored session", + assistantText: "Inactive rename should append session_info", + name: "Before Inactive Rename", + }) + const outsidePath = createSessionFile({ + projectCwd: fixture.otherProjectCwd, + sessionsDir: fixture.otherSessionsDir, + sessionId: "sess-outside", + fileStamp: "2026-03-14T20-20-00-000Z", + createdAt: "2026-03-14T20:20:00.000Z", + assistantAt: "2026-03-14T20:25:00.000Z", + userText: "Outside scope", + assistantText: "This file should not be renameable from the current project route", + name: "Outside Session", + }) + + const harness = createHarness((command, current) => { + if (command.type === "get_state") { + current.emit({ + id: command.id, + type: "response", + command: "get_state", + success: true, + data: { + sessionId: "sess-active", + sessionFile: activePath, + sessionName: "Active Session", + thinkingLevel: "off", + isStreaming: false, + isCompacting: false, + steeringMode: "all", + followUpMode: "all", + autoCompactionEnabled: false, + autoRetryEnabled: false, + retryInProgress: false, + retryAttempt: 0, + messageCount: 0, + pendingMessageCount: 0, + }, + }) + return + } + + if (command.type === "set_session_name") { + assert.fail("inactive rename should not go through set_session_name") + } + + assert.fail(`unexpected command: ${command.type}`) + }) + + configureBridgeFixture(fixture, harness) + onboarding.configureOnboardingServiceForTests({ + authStorage: AuthStorage.inMemory({ + openai: { type: "api_key", key: "sk-inactive-rename" }, + } as any), + }) + + try { + const renameResponse = await manageRoute.POST( + new Request("http://localhost/api/session/manage", { + method: "POST", + body: JSON.stringify({ + action: "rename", + sessionPath: inactivePath, + name: "Inactive Renamed", + }), + }), + ) + const renamePayload = await renameResponse.json() as any + + assert.equal(renameResponse.status, 200) + assert.equal(renamePayload.success, true) + assert.equal(renamePayload.isActiveSession, false) + assert.equal(renamePayload.mutation, "session_file") + assert.equal(getLatestSessionName(inactivePath), "Inactive Renamed") + assert.equal(harness.commands.some((command) => command.type === "set_session_name"), false) + + const outsideResponse = await manageRoute.POST( + new Request("http://localhost/api/session/manage", { + method: "POST", + body: JSON.stringify({ + action: "rename", + sessionPath: outsidePath, + name: "Should Fail", + }), + }), + ) + const outsidePayload = await outsideResponse.json() as any + + assert.equal(outsideResponse.status, 404) + assert.equal(outsidePayload.success, false) + assert.equal(outsidePayload.code, "not_found") + assert.equal(getLatestSessionName(outsidePath), "Outside Session") + } finally { + await bridge.resetBridgeServiceForTests() + onboarding.resetOnboardingServiceForTests() + fixture.cleanup() + } +}) + +test("/api/git returns a current-project-scoped repo summary and ignores changes outside the current project subtree", async () => { + const root = mkdtempSync(join(tmpdir(), "gsd-web-git-summary-")) + const repoRoot = join(root, "repo") + const projectCwd = join(repoRoot, "apps", "current-project") + const docsDir = join(repoRoot, "docs") + + try { + mkdirSync(projectCwd, { recursive: true }) + mkdirSync(docsDir, { recursive: true }) + + writeFileSync(join(projectCwd, "staged.txt"), "baseline staged\n") + writeFileSync(join(projectCwd, "dirty.txt"), "baseline dirty\n") + writeFileSync(join(docsDir, "outside.txt"), "baseline outside\n") + + git(repoRoot, ["init"]) + git(repoRoot, ["config", "user.name", "GSD Test"]) + git(repoRoot, ["config", "user.email", "gsd-test@example.com"]) + git(repoRoot, ["add", "."]) + git(repoRoot, ["commit", "-m", "initial"]) + + writeFileSync(join(projectCwd, "staged.txt"), "baseline staged\nnext staged line\n") + git(repoRoot, ["add", "apps/current-project/staged.txt"]) + writeFileSync(join(projectCwd, "dirty.txt"), "baseline dirty\nnext dirty line\n") + writeFileSync(join(projectCwd, "untracked.txt"), "brand new\n") + writeFileSync(join(docsDir, "outside.txt"), "baseline outside\noutside change\n") + + const authoritativeRepoRoot = resolve(git(projectCwd, ["rev-parse", "--show-toplevel"])) + + await withProjectGitEnv(projectCwd, async () => { + const response = await gitRoute.GET() + assert.equal(response.status, 200) + + const payload = await response.json() as any + assert.equal(payload.kind, "repo") + assert.equal(payload.project.scope, "current_project") + assert.equal(payload.project.cwd, projectCwd) + assert.equal(payload.project.repoRoot, authoritativeRepoRoot) + assert.equal(payload.project.repoRelativePath, "apps/current-project") + assert.equal(payload.hasChanges, true) + assert.equal(payload.counts.changed, 3) + assert.equal(payload.counts.staged, 1) + assert.equal(payload.counts.dirty, 1) + assert.equal(payload.counts.untracked, 1) + assert.equal(payload.counts.conflicts, 0) + assert.equal(payload.changedFiles.some((file: any) => file.repoPath === "docs/outside.txt"), false) + assert.deepEqual( + payload.changedFiles.map((file: any) => file.path).sort(), + ["dirty.txt", "staged.txt", "untracked.txt"], + ) + }) + } finally { + rmSync(root, { recursive: true, force: true }) + } +}) + +test("/api/git exposes an explicit not-a-repo state instead of failing silently", async () => { + const projectCwd = mkdtempSync(join(tmpdir(), "gsd-web-not-repo-")) + + try { + await withProjectGitEnv(projectCwd, async () => { + const response = await gitRoute.GET() + assert.equal(response.status, 200) + + const payload = await response.json() as any + assert.equal(payload.kind, "not_repo") + assert.equal(payload.project.scope, "current_project") + assert.equal(payload.project.cwd, projectCwd) + assert.equal(payload.project.repoRoot, null) + assert.match(payload.message, /not inside a Git repository/i) + }) + } finally { + rmSync(projectCwd, { recursive: true, force: true }) + } +}) + +test("browser session, settings, and git surfaces keep inspectable browse/manage/state markers on the shared surface", () => { + const rpcTypesSource = readFileSync(resolve(import.meta.dirname, "../../packages/pi-coding-agent/src/modes/rpc/rpc-types.ts"), "utf8") + const contractSource = readFileSync(resolve(import.meta.dirname, "../../web/lib/command-surface-contract.ts"), "utf8") + const storeSource = readFileSync(resolve(import.meta.dirname, "../../web/lib/gsd-workspace-store.tsx"), "utf8") + const surfaceSource = readFileSync(resolve(import.meta.dirname, "../../web/components/gsd/command-surface.tsx"), "utf8") + const sidebarSource = readFileSync(resolve(import.meta.dirname, "../../web/components/gsd/sidebar.tsx"), "utf8") + const gitRouteSource = readFileSync(resolve(import.meta.dirname, "../../web/app/api/git/route.ts"), "utf8") + + assert.match(rpcTypesSource, /autoRetryEnabled: boolean/, "rpc-types.ts must expose retry-enabled state in get_state") + assert.match(rpcTypesSource, /retryInProgress: boolean/, "rpc-types.ts must expose retry-in-progress state in get_state") + assert.match(rpcTypesSource, /retryAttempt: number/, "rpc-types.ts must expose retry attempt visibility in get_state") + + assert.match(contractSource, /gitSummary:/, "command-surface-contract.ts must keep inspectable git-summary state on commandSurface") + assert.match(contractSource, /load_git_summary/, "command-surface-contract.ts must model git-summary loading state") + assert.match(contractSource, /sessionBrowser:/, "command-surface-contract.ts must keep inspectable session-browser state on commandSurface") + assert.match(contractSource, /resumeRequest:/, "command-surface-contract.ts must expose inspectable resume mutation state") + assert.match(contractSource, /renameRequest:/, "command-surface-contract.ts must expose inspectable rename mutation state") + assert.match(contractSource, /settingsRequests:/, "command-surface-contract.ts must expose inspectable settings mutation state") + assert.match(contractSource, /set_steering_mode/, "command-surface-contract.ts must model steering-mode mutations") + assert.match(contractSource, /set_follow_up_mode/, "command-surface-contract.ts must model follow-up-mode mutations") + assert.match(contractSource, /set_auto_compaction/, "command-surface-contract.ts must model auto-compaction mutations") + assert.match(contractSource, /set_auto_retry/, "command-surface-contract.ts must model auto-retry mutations") + assert.match(contractSource, /abort_retry/, "command-surface-contract.ts must model retry-cancellation mutations") + + assert.match(storeSource, /\/api\/git/, "gsd-workspace-store.tsx must load the current-project git summary route") + assert.match(storeSource, /loadGitSummary/, "gsd-workspace-store.tsx must expose a shared git-summary browser action") + assert.match(storeSource, /\/api\/session\/browser/, "gsd-workspace-store.tsx must load the dedicated current-project session browser route") + assert.match(storeSource, /\/api\/session\/manage/, "gsd-workspace-store.tsx must call the session manage route for browser renames") + assert.match(storeSource, /setSteeringModeFromSurface/, "gsd-workspace-store.tsx must expose a shared steering-mode browser action") + assert.match(storeSource, /setFollowUpModeFromSurface/, "gsd-workspace-store.tsx must expose a shared follow-up-mode browser action") + assert.match(storeSource, /setAutoCompactionFromSurface/, "gsd-workspace-store.tsx must expose a shared auto-compaction browser action") + assert.match(storeSource, /setAutoRetryFromSurface/, "gsd-workspace-store.tsx must expose a shared auto-retry browser action") + assert.match(storeSource, /abortRetryFromSurface/, "gsd-workspace-store.tsx must expose a shared retry-cancellation browser action") + + assert.match(surfaceSource, /data-testid="command-surface-git-summary"/, "command-surface.tsx must expose the git summary panel") + assert.match(surfaceSource, /data-testid="command-surface-git-state"/, "command-surface.tsx must expose inspectable git-summary state text") + assert.match(surfaceSource, /data-testid="command-surface-git-not-repo"/, "command-surface.tsx must expose a browser-visible not-a-repo state") + assert.match(surfaceSource, /data-testid="command-surface-git-error"/, "command-surface.tsx must expose a browser-visible git load-error state") + assert.match(surfaceSource, /data-testid="command-surface-session-browser-query"/, "command-surface.tsx must expose a query marker for the session browser") + assert.match(surfaceSource, /data-testid="command-surface-session-browser-meta"/, "command-surface.tsx must expose current-project session-browser metadata") + assert.match(surfaceSource, /data-testid="command-surface-apply-resume"/, "command-surface.tsx must expose an inspectable resume action marker") + assert.match(surfaceSource, /data-testid="command-surface-apply-rename"/, "command-surface.tsx must expose an inspectable rename action marker") + assert.match(surfaceSource, /data-testid="command-surface-queue-settings"/, "command-surface.tsx must expose the queue settings panel") + assert.match(surfaceSource, /data-testid="command-surface-auto-compaction-settings"/, "command-surface.tsx must expose the auto-compaction settings panel") + assert.match(surfaceSource, /data-testid="command-surface-retry-settings"/, "command-surface.tsx must expose the retry settings panel") + assert.match(surfaceSource, /data-testid="command-surface-auto-retry-state"/, "command-surface.tsx must expose inspectable auto-retry state") + assert.match(surfaceSource, /data-testid="command-surface-abort-retry-state"/, "command-surface.tsx must expose inspectable retry-cancellation state") + assert.match(sidebarSource, /data-testid="sidebar-git-button"/, "sidebar.tsx must expose an inspectable Git affordance") + assert.match(sidebarSource, /openCommandSurface\("git", \{ source: "sidebar" \}\)/, "sidebar.tsx must open the shared git surface instead of leaving the Git button inert") + assert.match(gitRouteSource, /collectCurrentProjectGitSummary/, "web\/app\/api\/git\/route.ts must route the sidebar surface through the current-project git summary service") +}) diff --git a/src/tests/web-state-surfaces-contract.test.ts b/src/tests/web-state-surfaces-contract.test.ts new file mode 100644 index 000000000..d69390036 --- /dev/null +++ b/src/tests/web-state-surfaces-contract.test.ts @@ -0,0 +1,607 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join, resolve } from "node:path"; + +// ─── Imports ────────────────────────────────────────────────────────── +const workspaceIndex = await import( + "../resources/extensions/gsd/workspace-index.ts" +); +const filesRoute = await import("../../web/app/api/files/route.ts"); + +// Re-import status helpers from the web-side module +const workspaceStatus = await import("../../web/lib/workspace-status.ts"); + +// ─── Helpers ────────────────────────────────────────────────────────── +function makeGsdFixture(): { root: string; gsdDir: string; cleanup: () => void } { + const root = mkdtempSync(join(tmpdir(), "gsd-state-surfaces-")); + const gsdDir = join(root, ".gsd"); + mkdirSync(gsdDir, { recursive: true }); + return { + root, + gsdDir, + cleanup: () => rmSync(root, { recursive: true, force: true }), + }; +} + +// ─── Group 1: Workspace index — risk/depends/demo fields ───────────── +test("indexWorkspace extracts risk, depends, and demo from roadmap", async () => { + const { root, gsdDir, cleanup } = makeGsdFixture(); + + try { + const milestoneDir = join(gsdDir, "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + const tasksDir = join(sliceDir, "tasks"); + mkdirSync(tasksDir, { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + [ + "# M001: Test Milestone", + "", + "## Slices", + "- [ ] **S01: Feature slice** `risk:high` `depends:[S00]`", + " > After this: users can see the dashboard", + ].join("\n"), + ); + + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + [ + "# S01: Feature slice", + "", + "**Goal:** Build the feature", + "**Demo:** Dashboard renders", + "", + "## Tasks", + "- [ ] **T01: Build thing** `est:30m`", + " Do the work.", + ].join("\n"), + ); + + writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01: Build thing\n\n## Steps\n- do it\n"); + + const index = await workspaceIndex.indexWorkspace(root); + + assert.equal(index.milestones.length, 1); + assert.equal(index.milestones[0].id, "M001"); + + const slice = index.milestones[0].slices[0]; + assert.equal(slice.id, "S01"); + assert.equal(slice.risk, "high"); + assert.deepEqual(slice.depends, ["S00"]); + assert.equal(slice.demo, "users can see the dashboard"); + assert.equal(slice.done, false); + assert.equal(slice.tasks.length, 1); + assert.equal(slice.tasks[0].id, "T01"); + assert.equal(slice.tasks[0].done, false); + } finally { + cleanup(); + } +}); + +test("indexWorkspace handles slices without risk/depends/demo", async () => { + const { root, gsdDir, cleanup } = makeGsdFixture(); + + try { + const milestoneDir = join(gsdDir, "milestones", "M001"); + const sliceDir = join(milestoneDir, "slices", "S01"); + mkdirSync(join(sliceDir, "tasks"), { recursive: true }); + + writeFileSync( + join(milestoneDir, "M001-ROADMAP.md"), + "# M001: Minimal\n\n## Slices\n- [x] **S01: Done slice**\n", + ); + + writeFileSync( + join(sliceDir, "S01-PLAN.md"), + "# S01: Done slice\n\n**Goal:** Done\n\n## Tasks\n", + ); + + const index = await workspaceIndex.indexWorkspace(root); + + const slice = index.milestones[0].slices[0]; + // Parser defaults risk to "low" when not specified, demo to "" when no blockquote + assert.equal(slice.risk, "low"); + assert.deepEqual(slice.depends, []); + assert.equal(slice.demo, ""); + assert.equal(slice.done, true); + } finally { + cleanup(); + } +}); + +// ─── Group 2: Shared status helpers ────────────────────────────────── +test("getMilestoneStatus returns correct statuses", () => { + const { getMilestoneStatus } = workspaceStatus; + + // All slices done → done + const doneMilestone = { + id: "M001", + title: "Done", + slices: [ + { id: "S01", title: "S01", done: true, tasks: [] }, + { id: "S02", title: "S02", done: true, tasks: [] }, + ], + }; + assert.equal(getMilestoneStatus(doneMilestone, {}), "done"); + + // Active milestone with some done slices → in-progress + const activeMilestone = { + id: "M001", + title: "Active", + slices: [ + { id: "S01", title: "S01", done: true, tasks: [] }, + { id: "S02", title: "S02", done: false, tasks: [] }, + ], + }; + assert.equal(getMilestoneStatus(activeMilestone, { milestoneId: "M001" }), "in-progress"); + + // Not active, no done slices → pending + const pendingMilestone = { + id: "M002", + title: "Pending", + slices: [ + { id: "S01", title: "S01", done: false, tasks: [] }, + ], + }; + assert.equal(getMilestoneStatus(pendingMilestone, { milestoneId: "M001" }), "pending"); +}); + +test("getSliceStatus returns correct statuses", () => { + const { getSliceStatus } = workspaceStatus; + + // Done slice + assert.equal( + getSliceStatus("M001", { id: "S01", title: "S01", done: true, tasks: [] }, { milestoneId: "M001", sliceId: "S01" }), + "done", + ); + + // Active slice + assert.equal( + getSliceStatus("M001", { id: "S01", title: "S01", done: false, tasks: [] }, { milestoneId: "M001", sliceId: "S01" }), + "in-progress", + ); + + // Pending slice (different milestone active) + assert.equal( + getSliceStatus("M002", { id: "S01", title: "S01", done: false, tasks: [] }, { milestoneId: "M001", sliceId: "S01" }), + "pending", + ); +}); + +test("getTaskStatus returns correct statuses", () => { + const { getTaskStatus } = workspaceStatus; + const active = { milestoneId: "M001", sliceId: "S01", taskId: "T01" }; + + // Done task + assert.equal( + getTaskStatus("M001", "S01", { id: "T01", title: "T01", done: true }, active), + "done", + ); + + // Active task + assert.equal( + getTaskStatus("M001", "S01", { id: "T01", title: "T01", done: false }, active), + "in-progress", + ); + + // Pending task (different task active) + assert.equal( + getTaskStatus("M001", "S01", { id: "T02", title: "T02", done: false }, active), + "pending", + ); +}); + +// ─── Group 3: Files API — tree listing ─────────────────────────────── +test("files API returns tree listing of .gsd/ directory", async () => { + const { root, gsdDir, cleanup } = makeGsdFixture(); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + // Create some files + writeFileSync(join(gsdDir, "STATE.md"), "# State\nactive"); + writeFileSync(join(gsdDir, "PROJECT.md"), "# Project"); + const msDir = join(gsdDir, "milestones", "M001"); + mkdirSync(msDir, { recursive: true }); + writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap"); + + const request = new Request("http://localhost:3000/api/files"); + const response = await filesRoute.GET(request); + assert.equal(response.status, 200); + + const data = await response.json(); + assert.ok(Array.isArray(data.tree)); + assert.ok(data.tree.length > 0); + + // Should have files at root level + const names = data.tree.map((n: { name: string }) => n.name); + assert.ok(names.includes("STATE.md"), `Expected STATE.md in tree, got: ${names}`); + assert.ok(names.includes("PROJECT.md"), `Expected PROJECT.md in tree, got: ${names}`); + assert.ok(names.includes("milestones"), `Expected milestones in tree, got: ${names}`); + + // milestones should be a directory with children + const milestones = data.tree.find((n: { name: string }) => n.name === "milestones"); + assert.equal(milestones.type, "directory"); + assert.ok(Array.isArray(milestones.children)); + assert.ok(milestones.children.length > 0); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + cleanup(); + } +}); + +// ─── Group 4: Files API — file content ─────────────────────────────── +test("files API returns file content for valid path", async () => { + const { root, gsdDir, cleanup } = makeGsdFixture(); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + const fileContent = "# State\n\nCurrent milestone: M001"; + writeFileSync(join(gsdDir, "STATE.md"), fileContent); + + const request = new Request("http://localhost:3000/api/files?path=STATE.md"); + const response = await filesRoute.GET(request); + assert.equal(response.status, 200); + + const data = await response.json(); + assert.equal(data.content, fileContent); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + cleanup(); + } +}); + +test("files API returns content for nested files", async () => { + const { root, gsdDir, cleanup } = makeGsdFixture(); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + const msDir = join(gsdDir, "milestones", "M001"); + mkdirSync(msDir, { recursive: true }); + writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap content"); + + const request = new Request( + "http://localhost:3000/api/files?path=milestones/M001/M001-ROADMAP.md", + ); + const response = await filesRoute.GET(request); + assert.equal(response.status, 200); + + const data = await response.json(); + assert.equal(data.content, "# Roadmap content"); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + cleanup(); + } +}); + +// ─── Group 5: Files API — security: path traversal rejection ───────── +test("files API rejects path traversal with ../", async () => { + const { root, cleanup } = makeGsdFixture(); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + const request = new Request( + "http://localhost:3000/api/files?path=../etc/passwd", + ); + const response = await filesRoute.GET(request); + assert.equal(response.status, 400); + + const data = await response.json(); + assert.ok(data.error, "Expected error message in response"); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + cleanup(); + } +}); + +test("files API rejects absolute paths", async () => { + const { root, cleanup } = makeGsdFixture(); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + const request = new Request( + "http://localhost:3000/api/files?path=/etc/passwd", + ); + const response = await filesRoute.GET(request); + assert.equal(response.status, 400); + + const data = await response.json(); + assert.ok(data.error); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + cleanup(); + } +}); + +test("files API returns 404 for missing files", async () => { + const { root, cleanup } = makeGsdFixture(); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + const request = new Request( + "http://localhost:3000/api/files?path=nonexistent.md", + ); + const response = await filesRoute.GET(request); + assert.equal(response.status, 404); + + const data = await response.json(); + assert.ok(data.error); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + cleanup(); + } +}); + +test("files API returns empty tree when .gsd/ does not exist", async () => { + const root = mkdtempSync(join(tmpdir(), "gsd-state-surfaces-empty-")); + const origEnv = process.env.GSD_WEB_PROJECT_CWD; + + try { + process.env.GSD_WEB_PROJECT_CWD = root; + + const request = new Request("http://localhost:3000/api/files"); + const response = await filesRoute.GET(request); + assert.equal(response.status, 200); + + const data = await response.json(); + assert.deepEqual(data.tree, []); + } finally { + process.env.GSD_WEB_PROJECT_CWD = origEnv; + rmSync(root, { recursive: true, force: true }); + } +}); + +// ─── Group 6: Mock-free invariant — no static mock data ────────────── + +const VIEW_FILES = [ + "web/components/gsd/dashboard.tsx", + "web/components/gsd/roadmap.tsx", + "web/components/gsd/activity-view.tsx", + "web/components/gsd/files-view.tsx", + "web/components/gsd/dual-terminal.tsx", +]; + +// Patterns that indicate hardcoded mock data arrays +const MOCK_DATA_PATTERNS = [ + /const\s+\w+Data\s*=\s*\[/, // const roadmapData = [, const activityLog = [, etc. + /const\s+activityLog\s*=/, // const activityLog = ... + /const\s+recentActivity\s*=\s*\[/, // const recentActivity = [...] + /const\s+currentSliceTasks\s*=\s*\[/, // const currentSliceTasks = [...] + /const\s+modelUsage\s*=\s*\[/, // const modelUsage = [...] + /const\s+gsdFiles\s*=\s*\[/, // const gsdFiles = [...] + /AutoModeState.*idle.*working/, // old enum-style mock state + /Lorem\s+ipsum/i, // lorem placeholder text + /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*Z["'](?:.*,\s*$)/m, // hardcoded ISO timestamps in array literals +]; + +const webRoot = resolve(import.meta.dirname, "../../web"); + +test("view components contain no static mock data arrays", () => { + for (const filePath of VIEW_FILES) { + const fullPath = resolve(import.meta.dirname, "../..", filePath); + const source = readFileSync(fullPath, "utf-8"); + for (const pattern of MOCK_DATA_PATTERNS) { + const match = source.match(pattern); + assert.equal( + match, + null, + `${filePath} contains mock data pattern: ${pattern} — matched: "${match?.[0]}"`, + ); + } + } +}); + +test("view components read from real data sources (store or API)", () => { + // Views that derive state from the workspace store + const STORE_VIEWS = [ + "web/components/gsd/dashboard.tsx", + "web/components/gsd/roadmap.tsx", + "web/components/gsd/activity-view.tsx", + "web/components/gsd/terminal.tsx", + ]; + + // FilesView fetches from /api/files (real endpoint), not the workspace store — that's correct + const API_VIEWS = [ + { path: "web/components/gsd/files-view.tsx", apiPattern: "/api/files" }, + ]; + + for (const filePath of STORE_VIEWS) { + const fullPath = resolve(import.meta.dirname, "../..", filePath); + const source = readFileSync(fullPath, "utf-8"); + assert.ok( + source.includes("gsd-workspace-store"), + `${filePath} does not import from gsd-workspace-store — store-backed views must read real store state`, + ); + } + + for (const { path: filePath, apiPattern } of API_VIEWS) { + const fullPath = resolve(import.meta.dirname, "../..", filePath); + const source = readFileSync(fullPath, "utf-8"); + assert.ok( + source.includes(apiPattern), + `${filePath} does not reference ${apiPattern} — API-backed views must fetch from real endpoints`, + ); + } +}); + +// Session card (with activeToolExecution and streamingAssistantText) was removed +// from the dashboard. Live signals are visible in the terminal/power mode instead. + +test("status bar consumes statusTexts from store", () => { + const statusBarPath = resolve(import.meta.dirname, "../../web/components/gsd/status-bar.tsx"); + const source = readFileSync(statusBarPath, "utf-8"); + + assert.ok( + source.includes("statusTexts"), + "status-bar.tsx must reference statusTexts for extension status display", + ); + assert.ok( + source.includes("titleOverride"), + "status-bar.tsx must reference titleOverride so the shell title override is visible outside the header", + ); +}); + +test("browser shell renders title overrides, widgets, and editor prefills from store-backed state", () => { + const storePath = resolve(import.meta.dirname, "../../web/lib/gsd-workspace-store.tsx"); + const appShellPath = resolve(import.meta.dirname, "../../web/components/gsd/app-shell.tsx"); + const statusBarPath = resolve(import.meta.dirname, "../../web/components/gsd/status-bar.tsx"); + const terminalPath = resolve(import.meta.dirname, "../../web/components/gsd/terminal.tsx"); + + const storeSource = readFileSync(storePath, "utf-8"); + const appShellSource = readFileSync(appShellPath, "utf-8"); + const statusBarSource = readFileSync(statusBarPath, "utf-8"); + const terminalSource = readFileSync(terminalPath, "utf-8"); + + assert.match(appShellSource, /data-testid="workspace-title-override"/, "app-shell.tsx must render an inspectable title-override marker in the header"); + assert.match(appShellSource, /document\.title = titleOverride \?/, "app-shell.tsx must project the override into browser chrome"); + assert.match(statusBarSource, /data-testid="status-bar-title-override"/, "status-bar.tsx must keep the active title override browser-visible in the shell footer"); + + assert.match(terminalSource, /terminal-widgets-above-editor/, "terminal.tsx must render above-editor widgets with a stable marker"); + assert.match(terminalSource, /terminal-widgets-below-editor/, "terminal.tsx must render below-editor widgets with a stable marker"); + assert.match(terminalSource, /data-testid="terminal-widget"/, "terminal.tsx must render inspectable widget entries"); + assert.match(terminalSource, /MAX_VISIBLE_WIDGET_LINES = 6/, "terminal.tsx must bound widget rendering so extension widgets cannot grow without limit"); + assert.match(terminalSource, /widget\.placement \?\? "aboveEditor"/, "terminal.tsx must preserve the existing default above-editor placement semantics"); + + assert.match(storeSource, /consumeEditorTextBuffer = \(\): string \| null =>/, "gsd-workspace-store.tsx must expose a consume-once editor prefill action"); + assert.match(terminalSource, /consumeEditorTextBuffer/, "terminal.tsx must consume editor prefill state instead of replaying it forever"); + assert.match(terminalSource, /setInput\(buffer\)/, "terminal.tsx must visibly prefill the command input from editorTextBuffer"); +}); + +test("terminal consumes activeToolExecution from store", () => { + const terminalPath = resolve(import.meta.dirname, "../../web/components/gsd/terminal.tsx"); + const source = readFileSync(terminalPath, "utf-8"); + + assert.ok( + source.includes("activeToolExecution"), + "terminal.tsx must reference activeToolExecution for tool execution display", + ); +}); + +test("live browser panels consume live selectors and expose inspectable freshness markers", () => { + const contractPath = resolve(import.meta.dirname, "../../web/lib/command-surface-contract.ts") + const storePath = resolve(import.meta.dirname, "../../web/lib/gsd-workspace-store.tsx") + const dashboardPath = resolve(import.meta.dirname, "../../web/components/gsd/dashboard.tsx") + const sidebarPath = resolve(import.meta.dirname, "../../web/components/gsd/sidebar.tsx") + const roadmapPath = resolve(import.meta.dirname, "../../web/components/gsd/roadmap.tsx") + const statusBarPath = resolve(import.meta.dirname, "../../web/components/gsd/status-bar.tsx") + + const contractSource = readFileSync(contractPath, "utf-8") + const storeSource = readFileSync(storePath, "utf-8") + const dashboardSource = readFileSync(dashboardPath, "utf-8") + const sidebarSource = readFileSync(sidebarPath, "utf-8") + const roadmapSource = readFileSync(roadmapPath, "utf-8") + const statusBarSource = readFileSync(statusBarPath, "utf-8") + + assert.match(contractSource, /export interface WorkspaceRecoverySummary/, "command-surface-contract.ts must expose a shared recovery summary shape for live panels") + assert.match(storeSource, /live_state_invalidation/, "gsd-workspace-store.tsx must handle typed live_state_invalidation events") + assert.match(storeSource, /\/api\/live-state/, "gsd-workspace-store.tsx must use the narrow live-state route for targeted refreshes") + assert.match(storeSource, /softBootRefreshCount/, "gsd-workspace-store.tsx must expose a soft boot refresh counter for observability") + assert.match(storeSource, /targetedRefreshCount/, "gsd-workspace-store.tsx must expose a targeted refresh counter for observability") + assert.match(storeSource, /getLiveWorkspaceIndex/, "gsd-workspace-store.tsx must expose a live workspace selector") + assert.match(storeSource, /getLiveAutoDashboard/, "gsd-workspace-store.tsx must expose a live auto selector") + assert.match(storeSource, /getLiveResumableSessions/, "gsd-workspace-store.tsx must expose a live resumable-sessions selector") + + assert.match(dashboardSource, /getLiveWorkspaceIndex/, "dashboard.tsx must derive roadmap state from the live workspace selector") + assert.match(dashboardSource, /getLiveAutoDashboard/, "dashboard.tsx must derive auto metrics from the live auto selector") + assert.match(dashboardSource, /data-testid="dashboard-current-unit"/, "dashboard.tsx must expose a current-unit marker") + + assert.match(sidebarSource, /getLiveWorkspaceIndex/, "sidebar.tsx must derive explorer state from the live workspace selector") + assert.match(sidebarSource, /data-testid="sidebar-validation-count"/, "sidebar.tsx must expose a validation-count marker") + assert.match(sidebarSource, /data-testid="sidebar-recovery-summary-entrypoint"/, "sidebar.tsx must expose a recovery-summary entrypoint") + + assert.match(roadmapSource, /getLiveWorkspaceIndex/, "roadmap.tsx must derive milestones from live workspace state") + assert.match(roadmapSource, /data-testid="roadmap-workspace-freshness"/, "roadmap.tsx must expose workspace freshness") + + assert.match(statusBarSource, /getLiveWorkspaceIndex/, "status-bar.tsx must derive the unit label from live workspace state") + assert.match(statusBarSource, /getLiveAutoDashboard/, "status-bar.tsx must derive current-unit metrics from live auto state") + assert.match(statusBarSource, /data-testid="status-bar-retry-compaction"/, "status-bar.tsx must expose retry\/compaction freshness state") +}) + +test("workflow action surfaces route new-milestone CTAs through the shared command path", () => { + const dashboardPath = resolve(import.meta.dirname, "../../web/components/gsd/dashboard.tsx") + const sidebarPath = resolve(import.meta.dirname, "../../web/components/gsd/sidebar.tsx") + const chatPath = resolve(import.meta.dirname, "../../web/components/gsd/chat-mode.tsx") + + const dashboardSource = readFileSync(dashboardPath, "utf-8") + const sidebarSource = readFileSync(sidebarPath, "utf-8") + const chatSource = readFileSync(chatPath, "utf-8") + + assert.match(dashboardSource, /executeWorkflowActionInPowerMode/, "dashboard.tsx must use the shared power-mode workflow executor") + assert.match(sidebarSource, /executeWorkflowActionInPowerMode/, "sidebar.tsx must use the shared power-mode workflow executor") + assert.match(dashboardSource, /handleWorkflowAction\(workflowAction\.primary\.command\)/, "dashboard.tsx must route the primary CTA through the shared workflow executor") + assert.match(sidebarSource, /handleCommand\(workflowAction\.primary\.command\)/, "sidebar.tsx must route the primary CTA through the shared workflow executor") + assert.match(chatSource, /buildPromptCommand\(workflowAction\.primary\.command, bridge\)/, "chat-mode.tsx must send the new-milestone CTA through the same command path as other chat CTAs") + + assert.doesNotMatch(dashboardSource, /NewMilestoneDialog/, "dashboard.tsx must not import or render the deprecated new-milestone dialog") + assert.doesNotMatch(sidebarSource, /NewMilestoneDialog/, "sidebar.tsx must not import or render the deprecated new-milestone dialog") + assert.doesNotMatch(chatSource, /NewMilestoneDialog/, "chat-mode.tsx must not import or render the deprecated new-milestone dialog") + assert.doesNotMatch(chatSource, /buildPromptCommand\("\/gsd auto", bridge\)/, "chat-mode.tsx must not hardcode a special /gsd auto path for new-milestone CTA dispatch") +}) + +test("sidebar Git affordance opens a real git-summary surface with visible repo/not-repo/error states", () => { + const contractPath = resolve(import.meta.dirname, "../../web/lib/command-surface-contract.ts"); + const storePath = resolve(import.meta.dirname, "../../web/lib/gsd-workspace-store.tsx"); + const surfacePath = resolve(import.meta.dirname, "../../web/components/gsd/command-surface.tsx"); + const sidebarPath = resolve(import.meta.dirname, "../../web/components/gsd/sidebar.tsx"); + + const contractSource = readFileSync(contractPath, "utf-8"); + const storeSource = readFileSync(storePath, "utf-8"); + const surfaceSource = readFileSync(surfacePath, "utf-8"); + const sidebarSource = readFileSync(sidebarPath, "utf-8"); + + assert.match(contractSource, /gitSummary:/, "command-surface-contract.ts must retain git-summary state on the shared surface"); + assert.match(contractSource, /load_git_summary/, "command-surface-contract.ts must model git-summary loading as an explicit action"); + + assert.match(storeSource, /loadGitSummary/, "gsd-workspace-store.tsx must expose loadGitSummary so the Git surface is not inert"); + assert.match(storeSource, /\/api\/git/, "gsd-workspace-store.tsx must fetch the current-project git route for the Git surface"); + + assert.match(surfaceSource, /data-testid="command-surface-git-summary"/, "command-surface.tsx must render a git-summary panel"); + assert.match(surfaceSource, /data-testid="command-surface-git-not-repo"/, "command-surface.tsx must keep not-a-repo state browser-visible"); + assert.match(surfaceSource, /data-testid="command-surface-git-error"/, "command-surface.tsx must keep git load errors browser-visible"); + assert.match(sidebarSource, /data-testid="sidebar-git-button"/, "sidebar.tsx must expose the Git affordance by a stable test id"); + assert.match(sidebarSource, /openCommandSurface\("git", \{ source: "sidebar" \}\)/, "sidebar.tsx must open the shared git surface when the Git button is clicked"); +}); + +test("recovery diagnostics surface stays on a dedicated route with explicit stale and action state", () => { + const contractPath = resolve(import.meta.dirname, "../../web/lib/command-surface-contract.ts"); + const storePath = resolve(import.meta.dirname, "../../web/lib/gsd-workspace-store.tsx"); + const surfacePath = resolve(import.meta.dirname, "../../web/components/gsd/command-surface.tsx"); + const dashboardPath = resolve(import.meta.dirname, "../../web/components/gsd/dashboard.tsx"); + const sidebarPath = resolve(import.meta.dirname, "../../web/components/gsd/sidebar.tsx"); + + const contractSource = readFileSync(contractPath, "utf-8"); + const storeSource = readFileSync(storePath, "utf-8"); + const surfaceSource = readFileSync(surfacePath, "utf-8"); + const dashboardSource = readFileSync(dashboardPath, "utf-8"); + const sidebarSource = readFileSync(sidebarPath, "utf-8"); + + assert.match(contractSource, /export interface WorkspaceRecoveryDiagnostics/, "command-surface-contract.ts must expose a typed recovery diagnostics payload"); + assert.match(contractSource, /export interface CommandSurfaceRecoveryState/, "command-surface-contract.ts must expose explicit recovery load state"); + assert.match(contractSource, /load_recovery_diagnostics/, "command-surface-contract.ts must model recovery loading as an explicit action"); + + assert.match(storeSource, /loadRecoveryDiagnostics = async/, "gsd-workspace-store.tsx must expose a recovery diagnostics loader"); + assert.match(storeSource, /\/api\/recovery/, "gsd-workspace-store.tsx must call the dedicated recovery route"); + assert.match(storeSource, /markRecoveryStateInvalidated/, "gsd-workspace-store.tsx must keep recovery diagnostics stale state inspectable after invalidation"); + + assert.match(surfaceSource, /data-testid="command-surface-recovery"/, "command-surface.tsx must render a recovery diagnostics panel"); + assert.match(surfaceSource, /data-testid="command-surface-recovery-state"/, "command-surface.tsx must expose a recovery load-state marker"); + assert.match(surfaceSource, /data-testid="command-surface-recovery-error"/, "command-surface.tsx must keep recovery route failures browser-visible"); + assert.match(surfaceSource, /data-testid="command-surface-recovery-last-failure"/, "command-surface.tsx must expose structured bridge failure metadata"); + assert.match(surfaceSource, /data-testid={`command-surface-recovery-action-\$\{action.id\}`}/, "command-surface.tsx must expose stable action wiring for recovery controls"); + + assert.match(sidebarSource, /setCommandSurfaceSection\("recovery"\)/, "sidebar.tsx must route the recovery entrypoint into the dedicated recovery section"); +}); diff --git a/src/tests/web-workflow-action-execution.test.ts b/src/tests/web-workflow-action-execution.test.ts new file mode 100644 index 000000000..d06c44182 --- /dev/null +++ b/src/tests/web-workflow-action-execution.test.ts @@ -0,0 +1,81 @@ +import test from "node:test" +import assert from "node:assert/strict" + +const { + derivePendingWorkflowCommandLabel, + executeWorkflowActionInPowerMode, + navigateToGSDView, +} = await import("../../web/lib/workflow-action-execution.ts") + +test("derivePendingWorkflowCommandLabel prefers the latest input line while a command is in flight", () => { + const label = derivePendingWorkflowCommandLabel({ + commandInFlight: "prompt", + terminalLines: [ + { id: "1", timestamp: "12:00", type: "system", content: "Bridge ready" }, + { id: "2", timestamp: "12:01", type: "input", content: "/gsd" }, + { id: "3", timestamp: "12:02", type: "system", content: "Working…" }, + ], + }) + + assert.equal(label, "/gsd") +}) + +test("derivePendingWorkflowCommandLabel falls back to the command type when no input line exists", () => { + const label = derivePendingWorkflowCommandLabel({ + commandInFlight: "abort", + terminalLines: [], + }) + + assert.equal(label, "/abort") +}) + +test("navigateToGSDView dispatches the shared browser navigation event", () => { + const originalWindow = (globalThis as { window?: EventTarget }).window + const fakeWindow = new EventTarget() + const seen: string[] = [] + + fakeWindow.addEventListener("gsd:navigate-view", (event: Event) => { + seen.push((event as CustomEvent<{ view: string }>).detail.view) + }) + + ;(globalThis as { window?: EventTarget }).window = fakeWindow + + try { + navigateToGSDView("power") + } finally { + ;(globalThis as { window?: EventTarget }).window = originalWindow + } + + assert.deepEqual(seen, ["power"]) +}) + +test("executeWorkflowActionInPowerMode calls dispatch and navigates to the appropriate view", async () => { + const originalWindow = (globalThis as { window?: EventTarget }).window + const originalLocalStorage = (globalThis as any).localStorage + const fakeWindow = new EventTarget() + const seenViews: string[] = [] + let dispatchCalled = false + + fakeWindow.addEventListener("gsd:navigate-view", (event: Event) => { + seenViews.push((event as CustomEvent<{ view: string }>).detail.view) + }) + + ;(globalThis as { window?: EventTarget }).window = fakeWindow + ;(globalThis as any).localStorage = { getItem: () => null, setItem: () => {} } + + try { + executeWorkflowActionInPowerMode({ + dispatch: async () => { + dispatchCalled = true + }, + }) + // dispatch is fire-and-forget, give it a tick to resolve + await new Promise((resolve) => setTimeout(resolve, 10)) + } finally { + ;(globalThis as { window?: EventTarget }).window = originalWindow + ;(globalThis as any).localStorage = originalLocalStorage + } + + assert.equal(dispatchCalled, true, "dispatch should have been called") + assert.ok(seenViews.length > 0, "should navigate to a view") +}) diff --git a/src/tests/web-workflow-controls-contract.test.ts b/src/tests/web-workflow-controls-contract.test.ts new file mode 100644 index 000000000..7e91ca9cd --- /dev/null +++ b/src/tests/web-workflow-controls-contract.test.ts @@ -0,0 +1,157 @@ +import test from "node:test"; +import assert from "node:assert/strict"; + +// ─── Import ────────────────────────────────────────────────────────── +const { deriveWorkflowAction } = await import("../../web/lib/workflow-actions.ts"); + +// ─── Helpers ────────────────────────────────────────────────────────── +function baseInput(overrides: Partial[0]> = {}) { + return { + phase: "executing" as string, + autoActive: false, + autoPaused: false, + onboardingLocked: false, + commandInFlight: null as string | null, + bootStatus: "ready" as string, + hasMilestones: true, + ...overrides, + }; +} + +// ─── Group 1: Phase → action mapping ────────────────────────────────── +test("planning + no auto → primary is /gsd with label Plan", () => { + const result = deriveWorkflowAction(baseInput({ phase: "planning" })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd"); + assert.equal(result.primary.label, "Plan"); + assert.equal(result.primary.variant, "default"); + assert.equal(result.disabled, false); +}); + +test("executing + no auto → primary is /gsd auto with label Start Auto", () => { + const result = deriveWorkflowAction(baseInput({ phase: "executing" })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd auto"); + assert.equal(result.primary.label, "Start Auto"); +}); + +test("summarizing + no auto → primary is /gsd auto with label Start Auto", () => { + const result = deriveWorkflowAction(baseInput({ phase: "summarizing" })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd auto"); + assert.equal(result.primary.label, "Start Auto"); +}); + +test("auto active (not paused) → primary is /gsd stop with destructive variant", () => { + const result = deriveWorkflowAction(baseInput({ autoActive: true, autoPaused: false })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd stop"); + assert.equal(result.primary.label, "Stop Auto"); + assert.equal(result.primary.variant, "destructive"); +}); + +test("auto paused → primary is /gsd auto with label Resume Auto", () => { + const result = deriveWorkflowAction(baseInput({ autoPaused: true })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd auto"); + assert.equal(result.primary.label, "Resume Auto"); + assert.equal(result.primary.variant, "default"); +}); + +test("pre-planning + no milestones → primary is /gsd with label Initialize Project", () => { + const result = deriveWorkflowAction(baseInput({ phase: "pre-planning", hasMilestones: false })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd"); + assert.equal(result.primary.label, "Initialize Project"); +}); + +test("pre-planning + has milestones → primary is /gsd with label Continue", () => { + const result = deriveWorkflowAction(baseInput({ phase: "pre-planning", hasMilestones: true })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd"); + assert.equal(result.primary.label, "Continue"); +}); + +test("other phases (e.g. researching) without auto → primary is Continue /gsd", () => { + const result = deriveWorkflowAction(baseInput({ phase: "researching" })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd"); + assert.equal(result.primary.label, "Continue"); +}); + +test("verifying phase without auto → primary is Continue /gsd", () => { + const result = deriveWorkflowAction(baseInput({ phase: "verifying" })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd"); + assert.equal(result.primary.label, "Continue"); +}); + +test("complete phase without auto → primary is New Milestone /gsd with no step secondary", () => { + const result = deriveWorkflowAction(baseInput({ phase: "complete" })); + assert.ok(result.primary); + assert.equal(result.primary.command, "/gsd"); + assert.equal(result.primary.label, "New Milestone"); + assert.equal(result.isNewMilestone, true); + assert.deepEqual(result.secondaries, []); +}); + +// ─── Group 2: Secondary actions ─────────────────────────────────────── +test("secondaries include Step when auto is not active", () => { + const result = deriveWorkflowAction(baseInput({ phase: "executing" })); + assert.ok(result.secondaries.length > 0); + const step = result.secondaries.find((s) => s.command === "/gsd next"); + assert.ok(step, "Expected a Step secondary action"); + assert.equal(step.label, "Step"); +}); + +test("no secondaries when auto is active", () => { + const result = deriveWorkflowAction(baseInput({ autoActive: true })); + assert.equal(result.secondaries.length, 0); +}); + +test("no secondaries when auto is paused", () => { + const result = deriveWorkflowAction(baseInput({ autoPaused: true })); + assert.equal(result.secondaries.length, 0); +}); + +// ─── Group 3: Disabled conditions ───────────────────────────────────── +test("commandInFlight non-null → disabled with reason", () => { + const result = deriveWorkflowAction(baseInput({ commandInFlight: "prompt" })); + assert.equal(result.disabled, true); + assert.equal(result.disabledReason, "Command in progress"); +}); + +test("bootStatus not ready → disabled with reason", () => { + const result = deriveWorkflowAction(baseInput({ bootStatus: "loading" })); + assert.equal(result.disabled, true); + assert.equal(result.disabledReason, "Workspace not ready"); +}); + +test("bootStatus error → disabled with reason", () => { + const result = deriveWorkflowAction(baseInput({ bootStatus: "error" })); + assert.equal(result.disabled, true); + assert.equal(result.disabledReason, "Workspace not ready"); +}); + +test("onboardingLocked → disabled with reason", () => { + const result = deriveWorkflowAction(baseInput({ onboardingLocked: true })); + assert.equal(result.disabled, true); + assert.equal(result.disabledReason, "Setup required"); +}); + +test("all conditions met → not disabled", () => { + const result = deriveWorkflowAction(baseInput()); + assert.equal(result.disabled, false); + assert.equal(result.disabledReason, undefined); +}); + +// ─── Group 4: Disabled priority ─────────────────────────────────────── +test("commandInFlight takes priority over bootStatus", () => { + const result = deriveWorkflowAction(baseInput({ commandInFlight: "prompt", bootStatus: "loading" })); + assert.equal(result.disabledReason, "Command in progress"); +}); + +test("bootStatus takes priority over onboardingLocked", () => { + const result = deriveWorkflowAction(baseInput({ bootStatus: "loading", onboardingLocked: true })); + assert.equal(result.disabledReason, "Workspace not ready"); +}); diff --git a/src/web-mode.ts b/src/web-mode.ts new file mode 100644 index 000000000..0b8b9de28 --- /dev/null +++ b/src/web-mode.ts @@ -0,0 +1,669 @@ +import { randomBytes } from 'node:crypto' +import { exec, spawn, type ChildProcess, type SpawnOptions } from 'node:child_process' +import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs' +import { request as httpRequest } from 'node:http' +import { createServer } from 'node:net' +import { dirname, join, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' +import { appRoot, webPidFilePath as defaultWebPidFilePath } from './app-paths.js' + +const DEFAULT_HOST = '127.0.0.1' +const DEFAULT_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..') + +/** Open a URL in the user's default browser. */ +function openBrowser(url: string): void { + const cmd = process.platform === 'darwin' ? 'open' : + process.platform === 'win32' ? 'start' : + 'xdg-open' + exec(`${cmd} "${url}"`, () => { + // Ignore errors — user can manually open the URL + }) +} + +type WritableLike = Pick + +type ResourceBootstrapLike = { + initResources: (agentDir: string) => void +} + +type SpawnedChildLike = Pick + +export interface WebModeLaunchOptions { + cwd: string + projectSessionsDir: string + agentDir: string + packageRoot?: string + host?: string + port?: number +} + +export interface ResolvedWebHostBootstrap { + ok: true + kind: 'packaged-standalone' | 'source-dev' + packageRoot: string + hostRoot: string + entryPath: string +} + +export interface UnresolvedWebHostBootstrap { + ok: false + packageRoot: string + reason: string + candidates: string[] +} + +export type WebHostBootstrap = ResolvedWebHostBootstrap | UnresolvedWebHostBootstrap + +export interface WebModeLaunchSuccess { + mode: 'web' + ok: true + cwd: string + projectSessionsDir: string + host: string + port: number + url: string + hostKind: ResolvedWebHostBootstrap['kind'] + hostPath: string + hostRoot: string +} + +export interface WebModeLaunchFailure { + mode: 'web' + ok: false + cwd: string + projectSessionsDir: string + host: string + port: number | null + url: string | null + hostKind: ResolvedWebHostBootstrap['kind'] | 'unresolved' + hostPath: string | null + hostRoot: string | null + failureReason: string + candidates?: string[] +} + +export type WebModeLaunchStatus = WebModeLaunchSuccess | WebModeLaunchFailure + +export interface WebModeDeps { + existsSync?: (path: string) => boolean + initResources?: (agentDir: string) => void + resolvePort?: (host: string) => Promise + spawn?: (command: string, args: readonly string[], options: SpawnOptions) => SpawnedChildLike + waitForBootReady?: (url: string) => Promise + openBrowser?: (url: string) => void + stderr?: WritableLike + env?: NodeJS.ProcessEnv + platform?: NodeJS.Platform + execPath?: string + pidFilePath?: string + writePidFile?: (path: string, pid: number) => void + readPidFile?: (path: string) => number | null + deletePidFile?: (path: string) => void +} + +export interface WebModeStopResult { + ok: boolean + reason?: string + /** How many instances were stopped (relevant for --all) */ + stoppedCount?: number +} + +// ─── Instance Registry ────────────────────────────────────────────────────── + +export interface WebInstanceEntry { + pid: number + port: number + url: string + cwd: string + startedAt: string +} + +export type WebInstanceRegistry = Record + +const WEB_INSTANCES_PATH = join(appRoot, 'web-instances.json') + +export function readInstanceRegistry(registryPath = WEB_INSTANCES_PATH): WebInstanceRegistry { + try { + return JSON.parse(readFileSync(registryPath, 'utf8')) as WebInstanceRegistry + } catch { + return {} + } +} + +export function writeInstanceRegistry(registry: WebInstanceRegistry, registryPath = WEB_INSTANCES_PATH): void { + writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8') +} + +export function registerInstance(cwd: string, entry: Omit, registryPath = WEB_INSTANCES_PATH): void { + const registry = readInstanceRegistry(registryPath) + registry[resolve(cwd)] = { + ...entry, + cwd: resolve(cwd), + startedAt: new Date().toISOString(), + } + writeInstanceRegistry(registry, registryPath) +} + +export function unregisterInstance(cwd: string, registryPath = WEB_INSTANCES_PATH): void { + const registry = readInstanceRegistry(registryPath) + delete registry[resolve(cwd)] + writeInstanceRegistry(registry, registryPath) +} + +function killPid(pid: number): 'killed' | 'already-dead' | { error: string } { + try { + process.kill(pid, 'SIGTERM') + return 'killed' + } catch (error) { + const isAlreadyDead = error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'ESRCH' + if (isAlreadyDead) return 'already-dead' + return { error: error instanceof Error ? error.message : String(error) } + } +} + +export function writePidFile(filePath: string, pid: number): void { + writeFileSync(filePath, String(pid), 'utf8') +} + +export function readPidFile(filePath: string): number | null { + try { + const content = readFileSync(filePath, 'utf8').trim() + const pid = parseInt(content, 10) + return Number.isFinite(pid) && pid > 0 ? pid : null + } catch { + return null + } +} + +export function deletePidFile(filePath: string): void { + try { + unlinkSync(filePath) + } catch { + // Non-fatal — file may already be gone + } +} + +export interface WebModeStopOptions { + /** Stop instance for a specific project path */ + projectCwd?: string + /** Stop all running instances */ + all?: boolean +} + +export function stopWebMode(deps: Pick = {}, options: WebModeStopOptions = {}): WebModeStopResult { + const stderr = deps.stderr ?? process.stderr + + // ── Stop all instances ────────────────────────────────────────────── + if (options.all) { + const registry = readInstanceRegistry() + const entries = Object.entries(registry) + if (entries.length === 0) { + // Fall back to legacy PID file + return stopLegacyPidFile(deps) + } + let stopped = 0 + for (const [cwd, entry] of entries) { + const result = killPid(entry.pid) + if (result === 'killed') { + stderr.write(`[gsd] Stopped web server for ${cwd} (pid=${entry.pid})\n`) + stopped++ + } else if (result === 'already-dead') { + stderr.write(`[gsd] Web server for ${cwd} was already stopped (pid=${entry.pid})\n`) + stopped++ + } else { + stderr.write(`[gsd] Failed to stop web server for ${cwd}: ${result.error}\n`) + } + unregisterInstance(cwd) + } + // Also clean up legacy PID file + const deletePid = deps.deletePidFile ?? deletePidFile + const pidFilePath = deps.pidFilePath ?? defaultWebPidFilePath + deletePid(pidFilePath) + stderr.write(`[gsd] Stopped ${stopped} instance${stopped === 1 ? '' : 's'}.\n`) + return { ok: true, stoppedCount: stopped } + } + + // ── Stop specific project ────────────────────────────────────────── + if (options.projectCwd) { + const resolvedCwd = resolve(options.projectCwd) + const registry = readInstanceRegistry() + const entry = registry[resolvedCwd] + if (!entry) { + stderr.write(`[gsd] No web server running for ${resolvedCwd}\n`) + return { ok: false, reason: 'not-found' } + } + const result = killPid(entry.pid) + unregisterInstance(resolvedCwd) + if (result === 'killed') { + stderr.write(`[gsd] Stopped web server for ${resolvedCwd} (pid=${entry.pid})\n`) + return { ok: true, stoppedCount: 1 } + } else if (result === 'already-dead') { + stderr.write(`[gsd] Web server for ${resolvedCwd} was already stopped — cleared stale entry.\n`) + return { ok: true, stoppedCount: 1 } + } else { + stderr.write(`[gsd] Failed to stop web server for ${resolvedCwd}: ${result.error}\n`) + return { ok: false, reason: result.error } + } + } + + // ── Default: stop via legacy PID file (backward compat) ───────────── + return stopLegacyPidFile(deps) +} + +function stopLegacyPidFile(deps: Pick): WebModeStopResult { + const stderr = deps.stderr ?? process.stderr + const pidFilePath = deps.pidFilePath ?? defaultWebPidFilePath + const readPid = deps.readPidFile ?? readPidFile + const deletePid = deps.deletePidFile ?? deletePidFile + + const pid = readPid(pidFilePath) + if (pid === null) { + stderr.write(`[gsd] Web server is not running (no PID file found)\n`) + return { ok: false, reason: 'no-pid-file' } + } + + stderr.write(`[gsd] Stopping web server (pid=${pid})…\n`) + + const result = killPid(pid) + deletePid(pidFilePath) + if (result === 'killed') { + stderr.write(`[gsd] Web server stopped.\n`) + return { ok: true } + } else if (result === 'already-dead') { + stderr.write(`[gsd] Web server was already stopped — cleared stale PID file.\n`) + return { ok: true } + } else { + stderr.write(`[gsd] Failed to stop web server: ${result.error}\n`) + return { ok: false, reason: result.error } + } +} + +async function loadResourceBootstrap(): Promise { + const mod = await import('./resource-loader.js') + return { + initResources: mod.initResources, + } +} + +export function resolveWebHostBootstrap(options: { + packageRoot?: string + existsSync?: (path: string) => boolean +} = {}): WebHostBootstrap { + const packageRoot = options.packageRoot ?? DEFAULT_PACKAGE_ROOT + const checkExists = options.existsSync ?? existsSync + const packagedStandaloneServer = join(packageRoot, 'dist', 'web', 'standalone', 'server.js') + if (checkExists(packagedStandaloneServer)) { + return { + ok: true, + kind: 'packaged-standalone', + packageRoot, + hostRoot: join(packageRoot, 'dist', 'web', 'standalone'), + entryPath: packagedStandaloneServer, + } + } + + const sourceWebRoot = join(packageRoot, 'web') + const sourceManifest = join(sourceWebRoot, 'package.json') + if (checkExists(sourceManifest)) { + return { + ok: true, + kind: 'source-dev', + packageRoot, + hostRoot: sourceWebRoot, + entryPath: sourceManifest, + } + } + + return { + ok: false, + packageRoot, + reason: 'host bootstrap not found', + candidates: [packagedStandaloneServer, sourceManifest], + } +} + +export async function reserveWebPort(host = DEFAULT_HOST): Promise { + return await new Promise((resolvePort, reject) => { + const server = createServer() + server.unref() + server.once('error', reject) + server.listen(0, host, () => { + const address = server.address() + if (!address || typeof address === 'string') { + server.close(() => reject(new Error('failed to determine reserved web port'))) + return + } + server.close((error) => { + if (error) { + reject(error) + return + } + resolvePort(address.port) + }) + }) + }) +} + +function getSpawnCommandForSourceHost(platform: NodeJS.Platform): string { + return platform === 'win32' ? 'npm.cmd' : 'npm' +} + +function formatLaunchStatus(status: WebModeLaunchStatus): string { + if (status.ok) { + return `[gsd] Web mode startup: status=started cwd=${status.cwd} port=${status.port} host=${status.hostPath} kind=${status.hostKind} url=${status.url}\n` + } + + return `[gsd] Web mode startup: status=failed cwd=${status.cwd} port=${status.port ?? 'n/a'} host=${status.hostPath ?? 'unresolved'} kind=${status.hostKind} reason=${status.failureReason}\n` +} + +function emitLaunchStatus(stderr: WritableLike, status: WebModeLaunchStatus): void { + stderr.write(formatLaunchStatus(status)) +} + +function buildSpawnSpec( + resolution: ResolvedWebHostBootstrap, + host: string, + port: number, + platform: NodeJS.Platform, + execPath: string, +): { command: string; args: string[]; cwd: string } { + if (resolution.kind === 'packaged-standalone') { + return { + command: execPath, + args: [resolution.entryPath], + cwd: resolution.hostRoot, + } + } + + return { + command: getSpawnCommandForSourceHost(platform), + args: ['run', 'dev', '--', '--hostname', host, '--port', String(port)], + cwd: resolution.hostRoot, + } +} + +async function spawnDetachedProcess( + spawnCommand: (command: string, args: readonly string[], options: SpawnOptions) => SpawnedChildLike, + command: string, + args: string[], + options: SpawnOptions, +): Promise<{ ok: true; child: SpawnedChildLike } | { ok: false; error: unknown }> { + return await new Promise((resolve) => { + try { + const child = spawnCommand(command, args, options) + let settled = false + const finish = (result: { ok: true; child: SpawnedChildLike } | { ok: false; error: unknown }) => { + if (settled) return + settled = true + resolve(result) + } + + child.once?.('error', (error) => finish({ ok: false, error })) + setImmediate(() => finish({ ok: true, child })) + } catch (error) { + resolve({ ok: false, error }) + } + }) +} + +async function requestLocalJson(url: string, timeoutMs: number, authToken?: string): Promise<{ statusCode: number; body: string }> { + return await new Promise((resolve, reject) => { + const headers: Record = { + Accept: 'application/json', + // Keep launch readiness on the cheapest uncompressed path. The + // packaged host can spend noticeable time compressing the large boot + // snapshot, which adds avoidable startup jitter for a local health + // check that only needs the JSON payload itself. + 'Accept-Encoding': 'identity', + } + if (authToken) { + headers['Authorization'] = `Bearer ${authToken}` + } + const request = httpRequest( + url, + { + method: 'GET', + headers, + }, + (response) => { + const statusCode = response.statusCode ?? 0 + let body = '' + response.setEncoding('utf8') + response.on('data', (chunk) => { + body += chunk + }) + response.on('end', () => resolve({ statusCode, body })) + }, + ) + + request.setTimeout(timeoutMs, () => { + request.destroy(new Error(`request timed out after ${timeoutMs}ms`)) + }) + request.once('error', reject) + request.end() + }) +} + +async function waitForBootReady(url: string, timeoutMs = 180_000, stderr?: WritableLike, authToken?: string): Promise { + const deadline = Date.now() + timeoutMs + const startedAt = Date.now() + let lastError: string | null = null + let hostUp = false + // Print a progress dot every N ms while waiting so the terminal isn't silent + const TICKER_INTERVAL_MS = 5_000 + let lastTickAt = startedAt + + const elapsed = () => `${Math.round((Date.now() - startedAt) / 1000)}s` + + while (Date.now() < deadline) { + try { + // Give the packaged host enough time to finish a cold /api/boot render. + const response = await requestLocalJson(`${url}/api/boot`, 45_000, authToken) + + if (response.statusCode >= 200 && response.statusCode < 300) { + if (!hostUp) { + hostUp = true + stderr?.write(`[gsd] Web host ready.\n`) + } + // Host responded successfully — it's ready for the browser + return + } else { + lastError = `http ${response.statusCode}` + } + } catch (error) { + lastError = error instanceof Error ? error.message : String(error) + } + + // Emit a heartbeat line every TICKER_INTERVAL_MS to show we're alive + const now = Date.now() + if (now - lastTickAt >= TICKER_INTERVAL_MS) { + lastTickAt = now + if (hostUp) { + stderr?.write(`[gsd] Still waiting… (${elapsed()})\n`) + } else { + stderr?.write(`[gsd] Waiting for web host… (${elapsed()})\n`) + } + } + + await new Promise((resolve) => setTimeout(resolve, 250)) + } + + throw new Error(lastError ?? 'timed out waiting for boot readiness') +} + +export async function launchWebMode( + options: WebModeLaunchOptions, + deps: WebModeDeps = {}, +): Promise { + const stderr = deps.stderr ?? process.stderr + const host = options.host ?? DEFAULT_HOST + const resolution = resolveWebHostBootstrap({ + packageRoot: options.packageRoot, + existsSync: deps.existsSync, + }) + + if (!resolution.ok) { + const failure: WebModeLaunchFailure = { + mode: 'web', + ok: false, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host, + port: null, + url: null, + hostKind: 'unresolved', + hostPath: null, + hostRoot: null, + failureReason: `${resolution.reason}; checked=${resolution.candidates.join(',')}`, + candidates: resolution.candidates, + } + emitLaunchStatus(stderr, failure) + return failure + } + + stderr.write(`[gsd] Starting web mode…\n`) + + const port = options.port ?? await (deps.resolvePort ?? reserveWebPort)(host) + const authToken = randomBytes(32).toString('hex') + const url = `http://${host}:${port}` + const env = { + ...(deps.env ?? process.env), + HOSTNAME: host, + PORT: String(port), + GSD_WEB_HOST: host, + GSD_WEB_PORT: String(port), + GSD_WEB_AUTH_TOKEN: authToken, + GSD_WEB_PROJECT_CWD: options.cwd, + GSD_WEB_PROJECT_SESSIONS_DIR: options.projectSessionsDir, + GSD_WEB_PACKAGE_ROOT: resolution.packageRoot, + GSD_WEB_HOST_KIND: resolution.kind, + ...(resolution.kind === 'source-dev' ? { NEXT_PUBLIC_GSD_DEV: '1' } : {}), + } + + try { + stderr.write(`[gsd] Initialising resources…\n`) + const bootstrap = deps.initResources ? { initResources: deps.initResources } : await loadResourceBootstrap() + bootstrap.initResources(options.agentDir) + } catch (error) { + const failure: WebModeLaunchFailure = { + mode: 'web', + ok: false, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host, + port, + url, + hostKind: resolution.kind, + hostPath: resolution.entryPath, + hostRoot: resolution.hostRoot, + failureReason: `bootstrap:${error instanceof Error ? error.message : String(error)}`, + } + emitLaunchStatus(stderr, failure) + return failure + } + + const spawnSpec = buildSpawnSpec( + resolution, + host, + port, + deps.platform ?? process.platform, + deps.execPath ?? process.execPath, + ) + + stderr.write(`[gsd] Launching web host on port ${port}…\n`) + + const spawnResult = await spawnDetachedProcess( + deps.spawn ?? ((command, args, spawnOptions) => spawn(command, args, spawnOptions)), + spawnSpec.command, + spawnSpec.args, + { + cwd: spawnSpec.cwd, + detached: true, + stdio: 'ignore', + env, + }, + ) + + if (!spawnResult.ok) { + const failure: WebModeLaunchFailure = { + mode: 'web', + ok: false, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host, + port, + url, + hostKind: resolution.kind, + hostPath: resolution.entryPath, + hostRoot: resolution.hostRoot, + failureReason: `launch:${spawnResult.error instanceof Error ? spawnResult.error.message : String(spawnResult.error)}`, + } + emitLaunchStatus(stderr, failure) + return failure + } + + try { + const bootReadyFn = deps.waitForBootReady ?? ((u: string) => waitForBootReady(u, 180_000, stderr, authToken)) + await bootReadyFn(url) + } catch (error) { + const failure: WebModeLaunchFailure = { + mode: 'web', + ok: false, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host, + port, + url, + hostKind: resolution.kind, + hostPath: resolution.entryPath, + hostRoot: resolution.hostRoot, + failureReason: `boot-ready:${error instanceof Error ? error.message : String(error)}`, + } + emitLaunchStatus(stderr, failure) + return failure + } + + try { + spawnResult.child.unref?.() + const pid = spawnResult.child.pid + if (pid !== undefined) { + const pidFilePath = deps.pidFilePath ?? defaultWebPidFilePath + ;(deps.writePidFile ?? writePidFile)(pidFilePath, pid) + // Register in multi-instance registry + registerInstance(options.cwd, { pid, port, url }) + } + ;(deps.openBrowser ?? openBrowser)(`${url}/#token=${authToken}`) + } catch (error) { + const failure: WebModeLaunchFailure = { + mode: 'web', + ok: false, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host, + port, + url, + hostKind: resolution.kind, + hostPath: resolution.entryPath, + hostRoot: resolution.hostRoot, + failureReason: `browser-open:${error instanceof Error ? error.message : String(error)}`, + } + emitLaunchStatus(stderr, failure) + return failure + } + + const success: WebModeLaunchSuccess = { + mode: 'web', + ok: true, + cwd: options.cwd, + projectSessionsDir: options.projectSessionsDir, + host, + port, + url, + hostKind: resolution.kind, + hostPath: resolution.entryPath, + hostRoot: resolution.hostRoot, + } + stderr.write(`[gsd] Ready → ${url}\n`) + emitLaunchStatus(stderr, success) + return success +} diff --git a/src/web/auto-dashboard-service.ts b/src/web/auto-dashboard-service.ts new file mode 100644 index 000000000..9b377c632 --- /dev/null +++ b/src/web/auto-dashboard-service.ts @@ -0,0 +1,107 @@ +import { execFile } from "node:child_process"; +import { existsSync } from "node:fs"; +import { join } from "node:path"; +import { pathToFileURL } from "node:url"; + +import type { AutoDashboardData } from "./bridge-service.ts"; + +const AUTO_DASHBOARD_MAX_BUFFER = 1024 * 1024; +const TEST_AUTO_DASHBOARD_MODULE_ENV = "GSD_WEB_TEST_AUTO_DASHBOARD_MODULE"; +const TEST_AUTO_DASHBOARD_FALLBACK_ENV = "GSD_WEB_TEST_USE_FALLBACK_AUTO_DASHBOARD"; +const AUTO_DASHBOARD_MODULE_ENV = "GSD_AUTO_DASHBOARD_MODULE"; + +export interface AutoDashboardServiceOptions { + execPath?: string; + env?: NodeJS.ProcessEnv; + existsSync?: (path: string) => boolean; +} + +function fallbackAutoDashboardData(): AutoDashboardData { + return { + active: false, + paused: false, + stepMode: false, + startTime: 0, + elapsed: 0, + currentUnit: null, + completedUnits: [], + basePath: "", + totalCost: 0, + totalTokens: 0, + }; +} + +function resolveAutoDashboardModulePath(packageRoot: string, env: NodeJS.ProcessEnv): string { + return env[TEST_AUTO_DASHBOARD_MODULE_ENV] || join(packageRoot, "src", "resources", "extensions", "gsd", "auto.ts"); +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs"); +} + +export function collectTestOnlyFallbackAutoDashboardData(): AutoDashboardData { + return fallbackAutoDashboardData(); +} + +export async function collectAuthoritativeAutoDashboardData( + packageRoot: string, + options: AutoDashboardServiceOptions = {}, +): Promise { + const env = options.env ?? process.env; + if (env[TEST_AUTO_DASHBOARD_FALLBACK_ENV] === "1") { + return fallbackAutoDashboardData(); + } + + const checkExists = options.existsSync ?? existsSync; + const resolveTsLoader = resolveTsLoaderPath(packageRoot); + const autoModulePath = resolveAutoDashboardModulePath(packageRoot, env); + + if (!checkExists(resolveTsLoader) || !checkExists(autoModulePath)) { + throw new Error(`authoritative auto dashboard provider not found; checked=${resolveTsLoader},${autoModulePath}`); + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${AUTO_DASHBOARD_MODULE_ENV}).href);`, + 'const result = await mod.getAutoDashboardData();', + 'process.stdout.write(JSON.stringify(result));', + ].join(" "); + + return await new Promise((resolveResult, reject) => { + execFile( + options.execPath ?? process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...env, + [AUTO_DASHBOARD_MODULE_ENV]: autoModulePath, + }, + maxBuffer: AUTO_DASHBOARD_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`authoritative auto dashboard subprocess failed: ${stderr || error.message}`)); + return; + } + + try { + resolveResult(JSON.parse(stdout) as AutoDashboardData); + } catch (parseError) { + reject( + new Error( + `authoritative auto dashboard subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ); + } + }, + ); + }); +} diff --git a/src/web/bridge-service.ts b/src/web/bridge-service.ts new file mode 100644 index 000000000..771a51211 --- /dev/null +++ b/src/web/bridge-service.ts @@ -0,0 +1,2276 @@ +import { execFile, spawn, type ChildProcess, type SpawnOptions } from "node:child_process"; +import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"; +import { StringDecoder } from "node:string_decoder"; +import type { Readable } from "node:stream"; +import { join, resolve, dirname } from "node:path"; +import { fileURLToPath, pathToFileURL } from "node:url"; + +import type { AgentSessionEvent, SessionStateChangeReason } from "../../packages/pi-coding-agent/src/core/agent-session.ts"; +import type { + RpcCommand, + RpcExtensionUIRequest, + RpcExtensionUIResponse, + RpcResponse, + RpcSessionState, +} from "../../packages/pi-coding-agent/src/modes/rpc/rpc-types.ts"; +import { + SESSION_BROWSER_SCOPE, + normalizeSessionBrowserQuery, + type RenameSessionRequest, + type SessionBrowserQuery, + type SessionBrowserResponse, + type SessionBrowserSession, + type SessionManageErrorCode, + type SessionManageErrorResponse, + type SessionManageResponse, +} from "../../web/lib/session-browser-contract.ts"; +import { authFilePath } from "../app-paths.ts"; +import { getProjectSessionsDir } from "../project-sessions.ts"; +import { + collectOnboardingState, + registerOnboardingBridgeAuthRefresher, + type OnboardingLockReason, + type OnboardingState, +} from "./onboarding-service.ts"; +import { + collectAuthoritativeAutoDashboardData, + collectTestOnlyFallbackAutoDashboardData, +} from "./auto-dashboard-service.ts"; +import { resolveGsdCliEntry } from "./cli-entry.ts"; + +const DEFAULT_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../.."); +const RESPONSE_TIMEOUT_MS = 30_000; +const START_TIMEOUT_MS = 150_000; +const MAX_STDERR_BUFFER = 8_000; +const WORKSPACE_INDEX_CACHE_TTL_MS = 30_000; + +type BridgeLifecyclePhase = "idle" | "starting" | "ready" | "failed"; +type BridgeInput = RpcCommand | RpcExtensionUIResponse; +type BridgeTerminalCommand = Extract; +type BridgeTerminalOutputEvent = { type: "terminal_output"; data: string }; +type BridgeSessionStateChangedEvent = { type: "session_state_changed"; reason: SessionStateChangeReason }; + +type BridgeCommandFailureResponse = RpcResponse & { + code?: "onboarding_locked"; + details?: { + reason: OnboardingLockReason; + onboarding: Pick< + OnboardingState, + "locked" | "lockReason" | "required" | "lastValidation" | "bridgeAuthRefresh" + >; + }; +}; + +const READ_ONLY_RPC_COMMAND_TYPES = new Set([ + "get_state", + "get_available_models", + "get_session_stats", + "get_messages", + "get_last_assistant_text", + "get_fork_messages", + "get_commands", +]); + +type BridgeExtensionErrorEvent = { + type: "extension_error"; + extensionPath?: string; + event?: string; + error: string; +}; + +type LocalSessionInfo = { + path: string; + id: string; + cwd: string; + name?: string; + created: Date; + modified: Date; + messageCount: number; +}; + +type SessionInfo = { + path: string; + id: string; + cwd: string; + name?: string; + parentSessionPath?: string; + created: Date; + modified: Date; + messageCount: number; + firstMessage: string; + allMessagesText: string; +}; + +type SessionBrowserTreeNode = { + session: SessionInfo; + children: SessionBrowserTreeNode[]; +}; + +type FlatSessionBrowserNode = { + session: SessionInfo; + depth: number; + isLastInThread: boolean; + ancestorHasNextSibling: boolean[]; +}; + +type ParsedSessionSearchQuery = { + mode: "tokens" | "regex"; + tokens: Array<{ kind: "fuzzy" | "phrase"; value: string }>; + regex: RegExp | null; + error?: string; +}; + +function fuzzyMatch(query: string, text: string): { matches: boolean; score: number } { + const queryLower = query.toLowerCase(); + const textLower = text.toLowerCase(); + + const matchQuery = (normalizedQuery: string): { matches: boolean; score: number } => { + if (normalizedQuery.length === 0) { + return { matches: true, score: 0 }; + } + + if (normalizedQuery.length > textLower.length) { + return { matches: false, score: 0 }; + } + + let queryIndex = 0; + let score = 0; + let lastMatchIndex = -1; + let consecutiveMatches = 0; + + for (let index = 0; index < textLower.length && queryIndex < normalizedQuery.length; index++) { + if (textLower[index] !== normalizedQuery[queryIndex]) continue; + + const isWordBoundary = index === 0 || /[\s\-_./:]/.test(textLower[index - 1]!); + if (lastMatchIndex === index - 1) { + consecutiveMatches++; + score -= consecutiveMatches * 5; + } else { + consecutiveMatches = 0; + if (lastMatchIndex >= 0) { + score += (index - lastMatchIndex - 1) * 2; + } + } + + if (isWordBoundary) { + score -= 10; + } + + score += index * 0.1; + lastMatchIndex = index; + queryIndex++; + } + + if (queryIndex < normalizedQuery.length) { + return { matches: false, score: 0 }; + } + + return { matches: true, score }; + }; + + const primaryMatch = matchQuery(queryLower); + if (primaryMatch.matches) { + return primaryMatch; + } + + const alphaNumericMatch = queryLower.match(/^(?[a-z]+)(?[0-9]+)$/); + const numericAlphaMatch = queryLower.match(/^(?[0-9]+)(?[a-z]+)$/); + const swappedQuery = alphaNumericMatch + ? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}` + : numericAlphaMatch + ? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}` + : ""; + + if (!swappedQuery) { + return primaryMatch; + } + + const swappedMatch = matchQuery(swappedQuery); + if (!swappedMatch.matches) { + return primaryMatch; + } + + return { matches: true, score: swappedMatch.score + 5 }; +} + +function normalizeWhitespaceLower(text: string): string { + return text.toLowerCase().replace(/\s+/g, " ").trim(); +} + +function getSessionSearchText(session: SessionInfo): string { + return `${session.id} ${session.name ?? ""} ${session.allMessagesText} ${session.cwd}`; +} + +function hasSessionName(session: SessionInfo): boolean { + return Boolean(session.name?.trim()); +} + +function parseSessionSearchQuery(query: string): ParsedSessionSearchQuery { + const trimmed = query.trim(); + if (!trimmed) { + return { mode: "tokens", tokens: [], regex: null }; + } + + if (trimmed.startsWith("re:")) { + const pattern = trimmed.slice(3).trim(); + if (!pattern) { + return { mode: "regex", tokens: [], regex: null, error: "Empty regex" }; + } + + try { + return { mode: "regex", tokens: [], regex: new RegExp(pattern, "i") }; + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + return { mode: "regex", tokens: [], regex: null, error: message }; + } + } + + const tokens: Array<{ kind: "fuzzy" | "phrase"; value: string }> = []; + let buffer = ""; + let inQuote = false; + let hadUnclosedQuote = false; + + const flush = (kind: "fuzzy" | "phrase") => { + const value = buffer.trim(); + buffer = ""; + if (!value) return; + tokens.push({ kind, value }); + }; + + for (let index = 0; index < trimmed.length; index++) { + const character = trimmed[index]; + if (!character) continue; + + if (character === '"') { + if (inQuote) { + flush("phrase"); + inQuote = false; + } else { + flush("fuzzy"); + inQuote = true; + } + continue; + } + + if (!inQuote && /\s/.test(character)) { + flush("fuzzy"); + continue; + } + + buffer += character; + } + + if (inQuote) { + hadUnclosedQuote = true; + } + + if (hadUnclosedQuote) { + return { + mode: "tokens", + tokens: trimmed + .split(/\s+/) + .map((value) => value.trim()) + .filter((value) => value.length > 0) + .map((value) => ({ kind: "fuzzy" as const, value })), + regex: null, + }; + } + + flush(inQuote ? "phrase" : "fuzzy"); + return { mode: "tokens", tokens, regex: null }; +} + +function matchSessionSearch(session: SessionInfo, parsed: ParsedSessionSearchQuery): { matches: boolean; score: number } { + const text = getSessionSearchText(session); + + if (parsed.mode === "regex") { + if (!parsed.regex) { + return { matches: false, score: 0 }; + } + + const index = text.search(parsed.regex); + if (index < 0) { + return { matches: false, score: 0 }; + } + + return { matches: true, score: index * 0.1 }; + } + + if (parsed.tokens.length === 0) { + return { matches: true, score: 0 }; + } + + let totalScore = 0; + let normalizedText: string | null = null; + + for (const token of parsed.tokens) { + if (token.kind === "phrase") { + if (normalizedText === null) { + normalizedText = normalizeWhitespaceLower(text); + } + const phrase = normalizeWhitespaceLower(token.value); + if (!phrase) continue; + const index = normalizedText.indexOf(phrase); + if (index < 0) { + return { matches: false, score: 0 }; + } + totalScore += index * 0.1; + continue; + } + + const fuzzy = fuzzyMatch(token.value, text); + if (!fuzzy.matches) { + return { matches: false, score: 0 }; + } + totalScore += fuzzy.score; + } + + return { matches: true, score: totalScore }; +} + +function filterAndSortSessions( + sessions: SessionInfo[], + query: string, + sortMode: ReturnType["sortMode"], + nameFilter: ReturnType["nameFilter"], +): SessionInfo[] { + const nameFiltered = nameFilter === "all" ? sessions : sessions.filter((session) => hasSessionName(session)); + const trimmed = query.trim(); + if (!trimmed) { + return nameFiltered; + } + + const parsed = parseSessionSearchQuery(query); + if (parsed.error) { + return []; + } + + if (sortMode === "recent") { + const filtered: SessionInfo[] = []; + for (const session of nameFiltered) { + const result = matchSessionSearch(session, parsed); + if (result.matches) { + filtered.push(session); + } + } + return filtered; + } + + const scored: Array<{ session: SessionInfo; score: number }> = []; + for (const session of nameFiltered) { + const result = matchSessionSearch(session, parsed); + if (!result.matches) continue; + scored.push({ session, score: result.score }); + } + + scored.sort((left, right) => { + if (left.score !== right.score) { + return left.score - right.score; + } + return right.session.modified.getTime() - left.session.modified.getTime(); + }); + + return scored.map((entry) => entry.session); +} + +export interface AutoDashboardData { + active: boolean; + paused: boolean; + stepMode: boolean; + startTime: number; + elapsed: number; + currentUnit: { type: string; id: string; startedAt: number } | null; + completedUnits: { type: string; id: string; startedAt: number; finishedAt: number }[]; + basePath: string; + totalCost: number; + totalTokens: number; +} + +export interface BridgeLastError { + message: string; + at: string; + phase: BridgeLifecyclePhase; + afterSessionAttachment: boolean; + commandType?: string; +} + +export interface BridgeRuntimeSnapshot { + phase: BridgeLifecyclePhase; + projectCwd: string; + projectSessionsDir: string; + packageRoot: string; + startedAt: string | null; + updatedAt: string; + connectionCount: number; + lastCommandType: string | null; + activeSessionId: string | null; + activeSessionFile: string | null; + sessionState: RpcSessionState | null; + lastError: BridgeLastError | null; +} + +export interface BridgeRuntimeConfig { + projectCwd: string; + projectSessionsDir: string; + packageRoot: string; +} + +export interface BootResumableSession { + id: string; + path: string; + cwd: string; + name?: string; + createdAt: string; + modifiedAt: string; + messageCount: number; + isActive: boolean; +} + +export interface GSDWorkspaceTaskTarget { + id: string; + title: string; + done: boolean; + planPath?: string; + summaryPath?: string; +} + +export interface GSDWorkspaceSliceTarget { + id: string; + title: string; + done: boolean; + planPath?: string; + summaryPath?: string; + uatPath?: string; + tasksDir?: string; + branch?: string; + tasks: GSDWorkspaceTaskTarget[]; +} + +export interface GSDWorkspaceMilestoneTarget { + id: string; + title: string; + roadmapPath?: string; + slices: GSDWorkspaceSliceTarget[]; +} + +export interface GSDWorkspaceScopeTarget { + scope: string; + label: string; + kind: "project" | "milestone" | "slice" | "task"; +} + +export interface GSDWorkspaceIndex { + milestones: GSDWorkspaceMilestoneTarget[]; + active: { + milestoneId?: string; + sliceId?: string; + taskId?: string; + phase: string; + }; + scopes: GSDWorkspaceScopeTarget[]; + validationIssues: Array>; +} + +// ─── Project Detection ────────────────────────────────────────────────────── + +export type ProjectDetectionKind = + | "active-gsd" // .gsd with milestones — normal operation + | "empty-gsd" // .gsd exists but no milestones (freshly bootstrapped) + | "v1-legacy" // .planning/ exists, no .gsd + | "brownfield" // existing code (git, package.json, files) but no .gsd + | "blank"; // empty/near-empty folder + +export interface ProjectDetectionSignals { + hasGsdFolder: boolean; + hasPlanningFolder: boolean; + hasGitRepo: boolean; + hasPackageJson: boolean; + hasCargo?: boolean; + hasGoMod?: boolean; + hasPyproject?: boolean; + fileCount: number; +} + +export interface ProjectDetection { + kind: ProjectDetectionKind; + signals: ProjectDetectionSignals; +} + +export function detectProjectKind(projectCwd: string): ProjectDetection { + const checkExists = getBridgeDeps().existsSync ?? existsSync; + + const hasGsdFolder = checkExists(join(projectCwd, ".gsd")); + const hasPlanningFolder = checkExists(join(projectCwd, ".planning")); + const hasGitRepo = checkExists(join(projectCwd, ".git")); + const hasPackageJson = checkExists(join(projectCwd, "package.json")); + const hasCargo = checkExists(join(projectCwd, "Cargo.toml")); + const hasGoMod = checkExists(join(projectCwd, "go.mod")); + const hasPyproject = checkExists(join(projectCwd, "pyproject.toml")); + + // Count top-level non-dot entries (cheap heuristic for "has code") + let fileCount = 0; + try { + const entries = readdirSync(projectCwd); + fileCount = entries.filter(e => !e.startsWith(".")).length; + } catch { + // Can't read dir — treat as blank + } + + const signals: ProjectDetectionSignals = { + hasGsdFolder, + hasPlanningFolder, + hasGitRepo, + hasPackageJson, + hasCargo, + hasGoMod, + hasPyproject, + fileCount, + }; + + let kind: ProjectDetectionKind; + + if (hasGsdFolder) { + // Check if milestones exist + const milestonesDir = join(projectCwd, ".gsd", "milestones"); + let hasMilestones = false; + try { + const dirs = readdirSync(milestonesDir, { withFileTypes: true }); + hasMilestones = dirs.some(d => d.isDirectory()); + } catch { + // No milestones dir or can't read it + } + kind = hasMilestones ? "active-gsd" : "empty-gsd"; + } else if (hasPlanningFolder) { + kind = "v1-legacy"; + } else if (hasPackageJson || hasCargo || hasGoMod || hasPyproject || fileCount > 2 || (hasGitRepo && fileCount > 0)) { + kind = "brownfield"; + } else { + kind = "blank"; + } + + return { kind, signals }; +} + +// ─── Boot Payload ─────────────────────────────────────────────────────────── + +export interface BridgeBootPayload { + project: { + cwd: string; + sessionsDir: string; + packageRoot: string; + }; + workspace: GSDWorkspaceIndex; + auto: AutoDashboardData; + onboarding: OnboardingState; + onboardingNeeded: boolean; + resumableSessions: BootResumableSession[]; + bridge: BridgeRuntimeSnapshot; + projectDetection: ProjectDetection; +} + +export type BridgeStatusEvent = { + type: "bridge_status"; + bridge: BridgeRuntimeSnapshot; +}; + +export type BridgeLiveStateDomain = "auto" | "workspace" | "recovery" | "resumable_sessions"; +export type BridgeLiveStateInvalidationSource = "bridge_event" | "rpc_command" | "session_manage"; +export type BridgeLiveStateInvalidationReason = + | "agent_end" + | "auto_retry_start" + | "auto_retry_end" + | "auto_compaction_start" + | "auto_compaction_end" + | "new_session" + | "switch_session" + | "fork" + | "set_session_name"; + +export interface BridgeLiveStateInvalidationEvent { + type: "live_state_invalidation"; + at: string; + reason: BridgeLiveStateInvalidationReason; + source: BridgeLiveStateInvalidationSource; + domains: BridgeLiveStateDomain[]; + workspaceIndexCacheInvalidated: boolean; +} + +export type BridgeEvent = + | AgentSessionEvent + | RpcExtensionUIRequest + | BridgeExtensionErrorEvent + | BridgeStatusEvent + | BridgeLiveStateInvalidationEvent; + +interface BridgeCliEntry { + command: string; + args: string[]; + cwd: string; +} + +interface SpawnedRpcChild extends ChildProcess { + stdin: NonNullable; + stdout: NonNullable; + stderr: NonNullable; +} + +interface PendingRpcRequest { + resolve: (response: RpcResponse) => void; + reject: (error: Error) => void; + timeout: ReturnType; +} + +interface BridgeServiceDeps { + spawn?: (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess; + existsSync?: (path: string) => boolean; + execPath?: string; + env?: NodeJS.ProcessEnv; + indexWorkspace?: (basePath: string) => Promise; + getAutoDashboardData?: () => AutoDashboardData | Promise; + listSessions?: (projectSessionsDir: string) => Promise; + getOnboardingState?: () => OnboardingState | Promise; + getOnboardingNeeded?: (authPath: string, env: NodeJS.ProcessEnv) => boolean | Promise; +} + +type WorkspaceIndexCacheEntry = { + value: GSDWorkspaceIndex | null; + expiresAt: number; + promise: Promise | null; +}; + +const defaultBridgeServiceDeps: BridgeServiceDeps = { + spawn: (command, args, options) => spawn(command, args, options), + existsSync, + execPath: process.execPath, + env: process.env, + indexWorkspace: (basePath: string) => fallbackWorkspaceIndex(basePath), + getAutoDashboardData: async () => { + const deps = getBridgeDeps(); + const env = deps.env ?? process.env; + const config = resolveBridgeRuntimeConfig(env); + return await collectAuthoritativeAutoDashboardData(config.packageRoot, { + execPath: deps.execPath ?? process.execPath, + env, + existsSync: deps.existsSync ?? existsSync, + }); + }, + listSessions: async (projectSessionsDir: string) => listProjectSessions(projectSessionsDir), +}; + +let bridgeServiceOverrides: Partial | null = null; +const projectBridgeRegistry = new Map(); +const workspaceIndexCache = new Map(); + +async function loadSessionBrowserSessionsViaChildProcess(config: BridgeRuntimeConfig): Promise { + const deps = getBridgeDeps(); + const sessionManagerModulePath = join(config.packageRoot, "packages", "pi-coding-agent", "dist", "core", "session-manager.js"); + const checkExists = deps.existsSync ?? existsSync; + if (!checkExists(sessionManagerModulePath)) { + throw new Error(`session manager module not found; checked=${sessionManagerModulePath}`); + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + 'const mod = await import(pathToFileURL(process.env.GSD_SESSION_MANAGER_MODULE).href);', + 'const sessions = await mod.SessionManager.list(process.env.GSD_SESSION_BROWSER_CWD, process.env.GSD_SESSION_BROWSER_DIR);', + 'process.stdout.write(JSON.stringify(sessions.map((session) => ({ ...session, created: session.created.toISOString(), modified: session.modified.toISOString() }))));', + ].join(" "); + + return await new Promise((resolveResult, reject) => { + execFile( + deps.execPath ?? process.execPath, + ["--input-type=module", "--eval", script], + { + cwd: config.packageRoot, + env: { + ...(deps.env ?? process.env), + GSD_SESSION_MANAGER_MODULE: sessionManagerModulePath, + GSD_SESSION_BROWSER_CWD: config.projectCwd, + GSD_SESSION_BROWSER_DIR: config.projectSessionsDir, + }, + maxBuffer: 1024 * 1024, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`session list subprocess failed: ${stderr || error.message}`)); + return; + } + + try { + const parsed = JSON.parse(stdout) as Array & { created: string; modified: string }>; + resolveResult( + parsed.map((session) => ({ + ...session, + created: new Date(session.created), + modified: new Date(session.modified), + })), + ); + } catch (parseError) { + reject( + new Error( + `session list subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ); + } + }, + ); + }); +} + +async function appendSessionInfoViaChildProcess( + config: BridgeRuntimeConfig, + sessionPath: string, + name: string, +): Promise { + const deps = getBridgeDeps(); + const sessionManagerModulePath = join(config.packageRoot, "packages", "pi-coding-agent", "dist", "core", "session-manager.js"); + const checkExists = deps.existsSync ?? existsSync; + if (!checkExists(sessionManagerModulePath)) { + throw new Error(`session manager module not found; checked=${sessionManagerModulePath}`); + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + 'const mod = await import(pathToFileURL(process.env.GSD_SESSION_MANAGER_MODULE).href);', + 'const manager = mod.SessionManager.open(process.env.GSD_TARGET_SESSION_PATH, process.env.GSD_SESSION_BROWSER_DIR);', + 'manager.appendSessionInfo(process.env.GSD_TARGET_SESSION_NAME);', + ].join(" "); + + await new Promise((resolveResult, reject) => { + execFile( + deps.execPath ?? process.execPath, + ["--input-type=module", "--eval", script], + { + cwd: config.packageRoot, + env: { + ...(deps.env ?? process.env), + GSD_SESSION_MANAGER_MODULE: sessionManagerModulePath, + GSD_SESSION_BROWSER_DIR: config.projectSessionsDir, + GSD_TARGET_SESSION_PATH: sessionPath, + GSD_TARGET_SESSION_NAME: name, + }, + maxBuffer: 1024 * 1024, + }, + (error, _stdout, stderr) => { + if (error) { + reject(new Error(`session rename subprocess failed: ${stderr || error.message}`)); + return; + } + resolveResult(); + }, + ); + }); +} + +function nowIso(): string { + return new Date().toISOString(); +} + +function serializeJsonLine(value: unknown): string { + return `${JSON.stringify(value)}\n`; +} + +function attachJsonLineReader(stream: Readable, onLine: (line: string) => void): () => void { + const decoder = new StringDecoder("utf8"); + let buffer = ""; + + const emitLine = (line: string) => { + onLine(line.endsWith("\r") ? line.slice(0, -1) : line); + }; + + const onData = (chunk: string | Buffer) => { + buffer += typeof chunk === "string" ? chunk : decoder.write(chunk); + while (true) { + const newlineIndex = buffer.indexOf("\n"); + if (newlineIndex === -1) return; + emitLine(buffer.slice(0, newlineIndex)); + buffer = buffer.slice(newlineIndex + 1); + } + }; + + const onEnd = () => { + buffer += decoder.end(); + if (buffer.length > 0) { + emitLine(buffer); + buffer = ""; + } + }; + + stream.on("data", onData); + stream.on("end", onEnd); + + return () => { + stream.off("data", onData); + stream.off("end", onEnd); + }; +} + +function redactSensitiveText(value: string): string { + return value + .replace(/sk-[A-Za-z0-9_-]{6,}/g, "[redacted]") + .replace(/xox[baprs]-[A-Za-z0-9-]+/g, "[redacted]") + .replace(/Bearer\s+[^\s]+/gi, "Bearer [redacted]") + .replace(/([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET)["'=:\s]+)([^\s,;"']+)/gi, "$1[redacted]"); +} + +function sanitizeErrorMessage(error: unknown): string { + const raw = error instanceof Error ? error.message : String(error); + return redactSensitiveText(raw).replace(/\s+/g, " ").trim(); +} + +function captureStderr(buffer: string, chunk: string): string { + const next = `${buffer}${chunk}`; + return next.length <= MAX_STDERR_BUFFER ? next : next.slice(next.length - MAX_STDERR_BUFFER); +} + +function buildExitMessage(code: number | null, signal: NodeJS.Signals | null, stderrBuffer: string): string { + const base = `RPC bridge exited${code !== null ? ` with code ${code}` : ""}${signal ? ` (${signal})` : ""}`; + const stderr = redactSensitiveText(stderrBuffer).trim(); + return stderr ? `${base}. stderr=${stderr}` : base; +} + +function destroyChildStreams(child: Partial | null | undefined): void { + try { + child?.stdin?.destroy(); + } catch { + // Ignore cleanup failures. + } + try { + child?.stdout?.destroy(); + } catch { + // Ignore cleanup failures. + } + try { + child?.stderr?.destroy(); + } catch { + // Ignore cleanup failures. + } +} + +function getBridgeDeps(): BridgeServiceDeps { + return { ...defaultBridgeServiceDeps, ...(bridgeServiceOverrides ?? {}) }; +} + +function cloneWorkspaceIndex(index: GSDWorkspaceIndex): GSDWorkspaceIndex { + return structuredClone(index); +} + +function invalidateWorkspaceIndexCache(basePath?: string): void { + if (basePath) { + workspaceIndexCache.delete(basePath); + return; + } + + workspaceIndexCache.clear(); +} + +async function loadCachedWorkspaceIndex( + basePath: string, + loader: () => Promise, +): Promise { + const cached = workspaceIndexCache.get(basePath); + const now = Date.now(); + + if (cached?.value && cached.expiresAt > now) { + return cloneWorkspaceIndex(cached.value); + } + + if (cached?.promise) { + return cloneWorkspaceIndex(await cached.promise); + } + + const promise = loader() + .then((index) => { + workspaceIndexCache.set(basePath, { + value: cloneWorkspaceIndex(index), + expiresAt: Date.now() + WORKSPACE_INDEX_CACHE_TTL_MS, + promise: null, + }); + return index; + }) + .catch((error) => { + workspaceIndexCache.delete(basePath); + throw error; + }); + + workspaceIndexCache.set(basePath, { + value: cached?.value ?? null, + expiresAt: 0, + promise, + }); + + return cloneWorkspaceIndex(await promise); +} + +async function loadWorkspaceIndexViaChildProcess(basePath: string, packageRoot: string): Promise { + const deps = getBridgeDeps(); + const resolveTsLoader = join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs"); + const workspaceModulePath = join(packageRoot, "src", "resources", "extensions", "gsd", "workspace-index.ts"); + const checkExists = deps.existsSync ?? existsSync; + if (!checkExists(resolveTsLoader) || !checkExists(workspaceModulePath)) { + throw new Error(`workspace index loader not found; checked=${resolveTsLoader},${workspaceModulePath}`); + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + 'const mod = await import(pathToFileURL(process.env.GSD_WORKSPACE_MODULE).href);', + 'const result = await mod.indexWorkspace(process.env.GSD_WORKSPACE_BASE);', + 'process.stdout.write(JSON.stringify(result));', + ].join(' '); + + return await new Promise((resolveResult, reject) => { + execFile( + deps.execPath ?? process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...(deps.env ?? process.env), + GSD_WORKSPACE_MODULE: workspaceModulePath, + GSD_WORKSPACE_BASE: basePath, + }, + maxBuffer: 1024 * 1024, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`workspace index subprocess failed: ${stderr || error.message}`)); + return; + } + + try { + resolveResult(JSON.parse(stdout) as GSDWorkspaceIndex); + } catch (parseError) { + reject(new Error(`workspace index subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`)); + } + }, + ); + }); +} + +function legacyOnboardingStateFromNeeded(onboardingNeeded: boolean): OnboardingState { + return { + status: onboardingNeeded ? "blocked" : "ready", + locked: onboardingNeeded, + lockReason: onboardingNeeded ? "required_setup" : null, + required: { + blocking: true, + skippable: false, + satisfied: !onboardingNeeded, + satisfiedBy: onboardingNeeded ? null : { providerId: "legacy", source: "runtime" }, + providers: [], + }, + optional: { + blocking: false, + skippable: true, + sections: [], + }, + lastValidation: null, + activeFlow: null, + bridgeAuthRefresh: { + phase: "idle", + strategy: null, + startedAt: null, + completedAt: null, + error: null, + }, + }; +} + +function parseSessionInfo(path: string): LocalSessionInfo | null { + try { + const lines = readFileSync(path, "utf-8") + .split("\n") + .map((line) => line.trim()) + .filter(Boolean); + + let id = ""; + let cwd = ""; + let name: string | undefined; + let created = statSync(path).birthtime; + let messageCount = 0; + + for (const line of lines) { + const parsed = JSON.parse(line) as Record; + if (parsed.type === "session") { + id = typeof parsed.id === "string" ? parsed.id : id; + cwd = typeof parsed.cwd === "string" ? parsed.cwd : cwd; + if (typeof parsed.timestamp === "string") { + created = new Date(parsed.timestamp); + } + } else if (parsed.type === "session_info" && typeof parsed.name === "string") { + name = parsed.name; + } else if (parsed.type === "message") { + messageCount += 1; + } + } + + if (!id) return null; + + return { + path, + id, + cwd, + name, + created, + modified: statSync(path).mtime, + messageCount, + }; + } catch { + return null; + } +} + +function listProjectSessions(projectSessionsDir: string): LocalSessionInfo[] { + if (!existsSync(projectSessionsDir)) return []; + const sessions = readdirSync(projectSessionsDir) + .filter((entry) => entry.endsWith(".jsonl")) + .map((entry) => parseSessionInfo(join(projectSessionsDir, entry))) + .filter((entry): entry is LocalSessionInfo => entry !== null); + + sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime()); + return sessions; +} + +async function fallbackWorkspaceIndex(basePath: string): Promise { + const packageRoot = resolveBridgeRuntimeConfig().packageRoot; + return await loadWorkspaceIndexViaChildProcess(basePath, packageRoot); +} + +export function resolveBridgeRuntimeConfig(env: NodeJS.ProcessEnv = getBridgeDeps().env ?? process.env, projectCwdOverride?: string): BridgeRuntimeConfig { + const projectCwd = projectCwdOverride || env.GSD_WEB_PROJECT_CWD || process.cwd(); + const projectSessionsDir = env.GSD_WEB_PROJECT_SESSIONS_DIR || getProjectSessionsDir(projectCwd); + const packageRoot = env.GSD_WEB_PACKAGE_ROOT || DEFAULT_PACKAGE_ROOT; + return { projectCwd, projectSessionsDir, packageRoot }; +} + +function resolveBridgeCliEntry(config: BridgeRuntimeConfig, deps: BridgeServiceDeps): BridgeCliEntry { + return resolveGsdCliEntry({ + packageRoot: config.packageRoot, + cwd: config.projectCwd, + execPath: deps.execPath ?? process.execPath, + hostKind: (deps.env ?? process.env).GSD_WEB_HOST_KIND, + mode: "rpc", + sessionDir: config.projectSessionsDir, + existsSync: deps.existsSync ?? existsSync, + }); +} + +function isRpcExtensionUiResponse(input: BridgeInput): input is RpcExtensionUIResponse { + return input.type === "extension_ui_response"; +} + +function isReadOnlyBridgeInput(input: BridgeInput): boolean { + if (isRpcExtensionUiResponse(input)) { + return false; + } + return READ_ONLY_RPC_COMMAND_TYPES.has(input.type); +} + +function buildBridgeLockedResponse(input: BridgeInput, onboarding: OnboardingState): BridgeCommandFailureResponse { + const reason = onboarding.lockReason ?? "required_setup"; + const error = + reason === "bridge_refresh_failed" + ? "Workspace is locked because bridge auth refresh failed after setup" + : reason === "bridge_refresh_pending" + ? "Workspace is still locked while bridge auth refresh completes" + : "Workspace is locked until required onboarding completes"; + + return { + type: "response", + command: input.type, + success: false, + error, + code: "onboarding_locked", + details: { + reason, + onboarding: { + locked: onboarding.locked, + lockReason: onboarding.lockReason, + required: onboarding.required, + lastValidation: onboarding.lastValidation, + bridgeAuthRefresh: onboarding.bridgeAuthRefresh, + }, + }, + }; +} + +function sanitizeRpcResponse(response: RpcResponse): RpcResponse { + if (response.success) return response; + return { ...response, error: redactSensitiveText(response.error) } satisfies RpcResponse; +} + +function sanitizeEventPayload(payload: unknown): BridgeEvent { + if ( + typeof payload === "object" && + payload !== null && + "type" in payload && + (payload as { type?: string }).type === "extension_error" + ) { + const extensionError = payload as BridgeExtensionErrorEvent; + return { ...extensionError, error: redactSensitiveText(extensionError.error) }; + } + return payload as BridgeEvent; +} + +type BridgeLiveStateInvalidationDescriptor = { + reason: BridgeLiveStateInvalidationReason; + source: BridgeLiveStateInvalidationSource; + domains: BridgeLiveStateDomain[]; + workspaceIndexCacheInvalidated?: boolean; +}; + +function uniqueLiveStateDomains(domains: BridgeLiveStateDomain[]): BridgeLiveStateDomain[] { + return [...new Set(domains)]; +} + +function buildLiveStateInvalidationEvent( + descriptor: BridgeLiveStateInvalidationDescriptor, +): BridgeLiveStateInvalidationEvent { + return { + type: "live_state_invalidation", + at: nowIso(), + reason: descriptor.reason, + source: descriptor.source, + domains: uniqueLiveStateDomains(descriptor.domains), + workspaceIndexCacheInvalidated: Boolean(descriptor.workspaceIndexCacheInvalidated), + }; +} + +function createLiveStateInvalidationFromBridgeEvent( + event: BridgeEvent, +): BridgeLiveStateInvalidationDescriptor | null { + if (typeof event !== "object" || event === null || !("type" in event)) { + return null; + } + + switch (event.type) { + case "agent_end": + return { + reason: "agent_end", + source: "bridge_event", + domains: ["auto", "workspace", "recovery"], + workspaceIndexCacheInvalidated: true, + }; + case "auto_retry_start": + return { + reason: "auto_retry_start", + source: "bridge_event", + domains: ["auto", "recovery"], + }; + case "auto_retry_end": + return { + reason: "auto_retry_end", + source: "bridge_event", + domains: ["auto", "recovery"], + }; + case "auto_compaction_start": + return { + reason: "auto_compaction_start", + source: "bridge_event", + domains: ["auto", "recovery"], + }; + case "auto_compaction_end": + return { + reason: "auto_compaction_end", + source: "bridge_event", + domains: ["auto", "recovery"], + }; + default: + return null; + } +} + +function createLiveStateInvalidationFromCommand( + input: RpcCommand, + response: RpcResponse, +): BridgeLiveStateInvalidationDescriptor | null { + if (!response.success) { + return null; + } + + switch (input.type) { + case "new_session": + return response.command === "new_session" && response.data.cancelled === false + ? { + reason: "new_session", + source: "rpc_command", + domains: ["resumable_sessions", "recovery"], + } + : null; + case "switch_session": + return response.command === "switch_session" && response.data.cancelled === false + ? { + reason: "switch_session", + source: "rpc_command", + domains: ["resumable_sessions", "recovery"], + } + : null; + case "fork": + return response.command === "fork" && response.data.cancelled === false + ? { + reason: "fork", + source: "rpc_command", + domains: ["resumable_sessions", "recovery"], + } + : null; + case "set_session_name": + return response.command === "set_session_name" + ? { + reason: "set_session_name", + source: "rpc_command", + domains: ["resumable_sessions"], + } + : null; + default: + return null; + } +} + +function isBridgeTerminalOutputEvent(value: unknown): value is BridgeTerminalOutputEvent { + return ( + typeof value === "object" && + value !== null && + "type" in value && + (value as { type?: unknown }).type === "terminal_output" && + typeof (value as { data?: unknown }).data === "string" + ); +} + +function isBridgeSessionStateChangedEvent(value: unknown): value is BridgeSessionStateChangedEvent { + return ( + typeof value === "object" && + value !== null && + "type" in value && + (value as { type?: unknown }).type === "session_state_changed" && + typeof (value as { reason?: unknown }).reason === "string" + ); +} + +function createLiveStateInvalidationFromSessionStateChange( + reason: SessionStateChangeReason, +): BridgeLiveStateInvalidationDescriptor | null { + switch (reason) { + case "new_session": + return { + reason: "new_session", + source: "bridge_event", + domains: ["resumable_sessions", "recovery"], + }; + case "switch_session": + return { + reason: "switch_session", + source: "bridge_event", + domains: ["resumable_sessions", "recovery"], + }; + case "fork": + return { + reason: "fork", + source: "bridge_event", + domains: ["resumable_sessions", "recovery"], + }; + case "set_session_name": + return { + reason: "set_session_name", + source: "bridge_event", + domains: ["resumable_sessions"], + }; + default: + return null; + } +} + +export class BridgeService { + private readonly subscribers = new Set<(event: BridgeEvent) => void>(); + private readonly terminalSubscribers = new Set<(data: string) => void>(); + private readonly pendingRequests = new Map(); + private readonly config: BridgeRuntimeConfig; + private readonly deps: BridgeServiceDeps; + private process: SpawnedRpcChild | null = null; + private detachStdoutReader: (() => void) | null = null; + private startPromise: Promise | null = null; + private refreshPromise: Promise | null = null; + private authRefreshPromise: Promise | null = null; + private requestCounter = 0; + private stderrBuffer = ""; + private snapshot: BridgeRuntimeSnapshot; + + constructor(config: BridgeRuntimeConfig, deps: BridgeServiceDeps) { + this.config = config; + this.deps = deps; + this.snapshot = { + phase: "idle", + projectCwd: config.projectCwd, + projectSessionsDir: config.projectSessionsDir, + packageRoot: config.packageRoot, + startedAt: null, + updatedAt: nowIso(), + connectionCount: 0, + lastCommandType: null, + activeSessionId: null, + activeSessionFile: null, + sessionState: null, + lastError: null, + }; + } + + getSnapshot(): BridgeRuntimeSnapshot { + return structuredClone(this.snapshot); + } + + publishLiveStateInvalidation( + descriptor: BridgeLiveStateInvalidationDescriptor, + ): BridgeLiveStateInvalidationEvent { + const event = buildLiveStateInvalidationEvent(descriptor); + if (event.workspaceIndexCacheInvalidated) { + invalidateWorkspaceIndexCache(this.config.projectCwd); + } + this.emit(event); + return event; + } + + async ensureStarted(): Promise { + if (this.process && this.snapshot.phase === "ready") return; + if (this.startPromise) return await this.startPromise; + + this.startPromise = this.startInternal(); + try { + await this.startPromise; + } finally { + this.startPromise = null; + } + } + + async sendInput(input: BridgeInput): Promise { + await this.ensureStarted(); + if (!this.process?.stdin) { + throw new Error(this.snapshot.lastError?.message || "RPC bridge is not connected"); + } + + if (isRpcExtensionUiResponse(input)) { + this.process.stdin.write(serializeJsonLine(input)); + return null; + } + + const response = sanitizeRpcResponse(await this.requestResponse(input)); + this.snapshot.lastCommandType = input.type; + this.snapshot.updatedAt = nowIso(); + + if (!response.success) { + this.recordError(response.error, this.snapshot.phase, { commandType: input.type }); + this.broadcastStatus(); + return response; + } + + if (input.type === "get_state" && response.success && response.command === "get_state") { + this.applySessionState(response.data); + this.broadcastStatus(); + return response; + } + + const liveStateInvalidation = createLiveStateInvalidationFromCommand(input, response); + if (liveStateInvalidation) { + this.publishLiveStateInvalidation(liveStateInvalidation); + } + + void this.queueStateRefresh(); + this.broadcastStatus(); + return response; + } + + async refreshAuth(): Promise { + if (this.authRefreshPromise) { + return await this.authRefreshPromise; + } + + this.authRefreshPromise = this.refreshAuthInternal().finally(() => { + this.authRefreshPromise = null; + }); + + await this.authRefreshPromise; + } + + private async refreshAuthInternal(): Promise { + if (this.startPromise) { + await this.startPromise; + } + + if (this.process && this.snapshot.phase === "ready") { + this.resetProcessForAuthRefresh(); + } + + await this.ensureStarted(); + } + + private resetProcessForAuthRefresh(): void { + const child = this.process; + this.process = null; + this.detachStdoutReader?.(); + this.detachStdoutReader = null; + this.stderrBuffer = ""; + + for (const pending of this.pendingRequests.values()) { + clearTimeout(pending.timeout); + pending.reject(new Error("RPC bridge restarting to reload auth")); + } + this.pendingRequests.clear(); + + if (child) { + child.removeAllListeners("exit"); + child.removeAllListeners("error"); + child.kill("SIGTERM"); + destroyChildStreams(child); + } + + this.snapshot.phase = "idle"; + this.snapshot.updatedAt = nowIso(); + this.snapshot.lastError = null; + this.broadcastStatus(); + } + + subscribe(listener: (event: BridgeEvent) => void): () => void { + this.subscribers.add(listener); + this.snapshot.connectionCount = this.subscribers.size; + this.snapshot.updatedAt = nowIso(); + this.broadcastStatus(); + + return () => { + this.subscribers.delete(listener); + this.snapshot.connectionCount = this.subscribers.size; + this.snapshot.updatedAt = nowIso(); + if (this.subscribers.size > 0) { + this.broadcastStatus(); + } + }; + } + + subscribeTerminal(listener: (data: string) => void): () => void { + this.terminalSubscribers.add(listener); + return () => { + this.terminalSubscribers.delete(listener); + }; + } + + async sendTerminalInput(data: string): Promise { + await this.sendTerminalCommand({ type: "terminal_input", data }); + } + + async resizeTerminal(cols: number, rows: number): Promise { + await this.sendTerminalCommand({ type: "terminal_resize", cols, rows }); + } + + async redrawTerminal(): Promise { + await this.sendTerminalCommand({ type: "terminal_redraw" }); + } + + private async sendTerminalCommand(command: BridgeTerminalCommand): Promise { + await this.ensureStarted(); + const response = sanitizeRpcResponse(await this.requestResponse(command)); + if (!response.success) { + this.recordError(response.error, this.snapshot.phase, { commandType: command.type }); + this.broadcastStatus(); + throw new Error(response.error); + } + } + + async dispose(): Promise { + this.detachStdoutReader?.(); + this.detachStdoutReader = null; + this.terminalSubscribers.clear(); + for (const pending of this.pendingRequests.values()) { + clearTimeout(pending.timeout); + pending.reject(new Error("RPC bridge disposed")); + } + this.pendingRequests.clear(); + if (this.process) { + this.process.removeAllListeners(); + this.process.kill("SIGTERM"); + this.process = null; + } + this.snapshot.phase = "idle"; + this.snapshot.connectionCount = 0; + this.snapshot.updatedAt = nowIso(); + } + + private async startInternal(): Promise { + this.snapshot.phase = "starting"; + this.snapshot.startedAt = nowIso(); + this.snapshot.updatedAt = this.snapshot.startedAt; + this.snapshot.lastError = null; + this.broadcastStatus(); + + let cliEntry: BridgeCliEntry; + try { + cliEntry = resolveBridgeCliEntry(this.config, this.deps); + } catch (error) { + this.snapshot.phase = "failed"; + this.recordError(error, "starting"); + throw error; + } + + const spawnChild = this.deps.spawn ?? ((command, args, options) => spawn(command, args, options)); + const childEnv = { ...(this.deps.env ?? process.env) }; + delete childEnv.GSD_CODING_AGENT_DIR; + childEnv.GSD_WEB_BRIDGE_TUI = "1"; + + const child = spawnChild(cliEntry.command, cliEntry.args, { + cwd: cliEntry.cwd, + env: childEnv, + stdio: ["pipe", "pipe", "pipe"], + }) as SpawnedRpcChild; + + this.process = child; + this.stderrBuffer = ""; + child.stderr.on("data", (chunk) => { + this.stderrBuffer = captureStderr(this.stderrBuffer, chunk.toString()); + }); + this.detachStdoutReader = attachJsonLineReader(child.stdout, (line) => this.handleStdoutLine(line)); + child.once("exit", (code, signal) => this.handleProcessExit(code, signal)); + child.once("error", (error) => this.handleProcessExit(null, null, error)); + + let startupTimeout: ReturnType | undefined; + const timeout = new Promise((_, reject) => { + startupTimeout = setTimeout(() => reject(new Error(`RPC bridge startup timed out after ${START_TIMEOUT_MS}ms`)), START_TIMEOUT_MS); + }); + + try { + await Promise.race([this.refreshState(true), timeout]); + this.snapshot.phase = "ready"; + this.snapshot.updatedAt = nowIso(); + this.snapshot.lastError = null; + this.broadcastStatus(); + } catch (error) { + this.snapshot.phase = "failed"; + this.recordError(error, "starting"); + this.broadcastStatus(); + throw error; + } finally { + if (startupTimeout) { + clearTimeout(startupTimeout); + } + } + } + + private async queueStateRefresh(): Promise { + if (this.refreshPromise) return await this.refreshPromise; + this.refreshPromise = this.refreshState(false) + .catch((error) => { + this.recordError(error, this.snapshot.phase, { commandType: "get_state" }); + }) + .finally(() => { + this.refreshPromise = null; + }); + await this.refreshPromise; + } + + private async refreshState(strict: boolean): Promise { + // During startup (strict=true), the RPC child may need significant time to + // initialise — loading extensions, creating the agent session, etc. Use + // the overall START_TIMEOUT_MS instead of the short per-request timeout so + // the first get_state doesn't race against cold-start initialisation. + const timeout = strict ? START_TIMEOUT_MS : undefined; + const response = sanitizeRpcResponse(await this.requestResponse({ type: "get_state" }, timeout)); + if (!response.success) { + throw new Error(response.error); + } + if (response.command === "get_state") { + this.applySessionState(response.data); + } + this.snapshot.updatedAt = nowIso(); + if (!strict) { + this.broadcastStatus(); + } + } + + private applySessionState(state: RpcSessionState): void { + this.snapshot.sessionState = state; + this.snapshot.activeSessionId = state.sessionId; + this.snapshot.activeSessionFile = state.sessionFile ?? null; + } + + private requestResponse(command: RpcCommand, timeoutMs?: number): Promise { + if (!this.process?.stdin) { + return Promise.reject(new Error("RPC bridge is not connected")); + } + + const id = command.id ?? `web_${++this.requestCounter}`; + const payload = { ...command, id } satisfies RpcCommand; + const effectiveTimeout = timeoutMs ?? RESPONSE_TIMEOUT_MS; + + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + this.pendingRequests.delete(id); + reject(new Error(`Timed out waiting for RPC response to ${payload.type}`)); + }, effectiveTimeout); + + this.pendingRequests.set(id, { + resolve: (response) => { + clearTimeout(timeout); + resolve(response); + }, + reject: (error) => { + clearTimeout(timeout); + reject(error); + }, + timeout, + }); + + this.process!.stdin.write(serializeJsonLine(payload)); + }); + } + + private handleStdoutLine(line: string): void { + let parsed: unknown; + try { + parsed = JSON.parse(line); + } catch { + return; + } + + if (isBridgeTerminalOutputEvent(parsed)) { + this.emitTerminal(parsed.data); + return; + } + + if ( + typeof parsed === "object" && + parsed !== null && + "type" in parsed && + (parsed as { type?: string }).type === "response" + ) { + const response = sanitizeRpcResponse(parsed as RpcResponse); + if (response.id && this.pendingRequests.has(response.id)) { + const pending = this.pendingRequests.get(response.id)!; + this.pendingRequests.delete(response.id); + pending.resolve(response); + return; + } + } + + const event = sanitizeEventPayload(parsed); + this.emit(event); + + if (isBridgeSessionStateChangedEvent(event)) { + const liveStateInvalidation = createLiveStateInvalidationFromSessionStateChange(event.reason); + if (liveStateInvalidation) { + this.publishLiveStateInvalidation(liveStateInvalidation); + } + void this.queueStateRefresh(); + return; + } + + const liveStateInvalidation = createLiveStateInvalidationFromBridgeEvent(event); + if (liveStateInvalidation) { + this.publishLiveStateInvalidation(liveStateInvalidation); + } + + if ( + typeof event === "object" && + event !== null && + "type" in event + ) { + const eventType = (event as { type?: string }).type; + if ( + eventType === "agent_end" || + eventType === "auto_retry_start" || + eventType === "auto_retry_end" || + eventType === "auto_compaction_start" || + eventType === "auto_compaction_end" + ) { + void this.queueStateRefresh(); + } + } + } + + private handleProcessExit(code: number | null, signal: NodeJS.Signals | null, error?: unknown): void { + this.detachStdoutReader?.(); + this.detachStdoutReader = null; + this.process = null; + + const exitError = new Error(buildExitMessage(code, signal, this.stderrBuffer)); + for (const pending of this.pendingRequests.values()) { + clearTimeout(pending.timeout); + pending.reject(exitError); + } + this.pendingRequests.clear(); + + this.snapshot.phase = "failed"; + this.snapshot.updatedAt = nowIso(); + this.recordError(error ?? exitError, this.snapshot.activeSessionId ? "ready" : "starting"); + this.broadcastStatus(); + } + + private recordError(error: unknown, phase: BridgeLifecyclePhase, options: { commandType?: string } = {}): void { + this.snapshot.lastError = { + message: sanitizeErrorMessage(error), + at: nowIso(), + phase, + afterSessionAttachment: Boolean(this.snapshot.activeSessionId), + commandType: options.commandType, + }; + this.snapshot.updatedAt = this.snapshot.lastError.at; + } + + private emit(event: BridgeEvent): void { + for (const subscriber of this.subscribers) { + try { + subscriber(event); + } catch { + // Subscriber failures should not break delivery. + } + } + } + + private emitTerminal(data: string): void { + for (const subscriber of this.terminalSubscribers) { + try { + subscriber(data); + } catch { + // Subscriber failures should not break delivery. + } + } + } + + private broadcastStatus(): void { + if (this.subscribers.size === 0) return; + this.emit({ type: "bridge_status", bridge: this.getSnapshot() }); + } +} + +export function getProjectBridgeServiceForCwd(projectCwd: string): BridgeService { + const resolvedPath = resolve(projectCwd); + const existing = projectBridgeRegistry.get(resolvedPath); + if (existing) return existing; + + const config = resolveBridgeRuntimeConfig(undefined, resolvedPath); + const deps = getBridgeDeps(); + const service = new BridgeService(config, deps); + projectBridgeRegistry.set(resolvedPath, service); + return service; +} + +/** + * Resolve the project CWD from the request query param or env. + * Returns null when no project is configured (pre-project-selection state). + */ +export function resolveProjectCwd(request: Request): string | null { + try { + const url = new URL(request.url); + const projectParam = url.searchParams.get("project"); + if (projectParam) return decodeURIComponent(projectParam); + } catch { + // Malformed URL — fall through to env-based default. + } + return (getBridgeDeps().env ?? process.env).GSD_WEB_PROJECT_CWD || null; +} + +/** + * Like resolveProjectCwd but throws a 400-style error when no project is set. + * Use in API routes that require a project context. + */ +export function requireProjectCwd(request: Request): string { + const cwd = resolveProjectCwd(request); + if (!cwd) { + throw new NoProjectError(); + } + return cwd; +} + +export class NoProjectError extends Error { + constructor() { + super("No project selected"); + this.name = "NoProjectError"; + } +} + +export function getProjectBridgeService(): BridgeService { + const config = resolveBridgeRuntimeConfig(); + return getProjectBridgeServiceForCwd(config.projectCwd); +} + +function toBootResumableSession(session: LocalSessionInfo, activeSessionFile: string | null): BootResumableSession { + return { + id: session.id, + path: session.path, + cwd: session.cwd, + name: session.name, + createdAt: session.created.toISOString(), + modifiedAt: session.modified.toISOString(), + messageCount: session.messageCount, + isActive: Boolean(activeSessionFile && session.path === activeSessionFile), + }; +} + +function buildSessionBrowserTree(sessions: SessionInfo[]): SessionBrowserTreeNode[] { + const byPath = new Map(); + + for (const session of sessions) { + byPath.set(session.path, { session, children: [] }); + } + + const roots: SessionBrowserTreeNode[] = []; + + for (const session of sessions) { + const node = byPath.get(session.path); + if (!node) continue; + + const parentPath = session.parentSessionPath; + if (parentPath && byPath.has(parentPath)) { + byPath.get(parentPath)!.children.push(node); + continue; + } + + roots.push(node); + } + + const sortNodes = (nodes: SessionBrowserTreeNode[]): void => { + nodes.sort((a, b) => b.session.modified.getTime() - a.session.modified.getTime()); + for (const node of nodes) { + sortNodes(node.children); + } + }; + + sortNodes(roots); + return roots; +} + +function flattenSessionBrowserTree(roots: SessionBrowserTreeNode[]): FlatSessionBrowserNode[] { + const result: FlatSessionBrowserNode[] = []; + + const walk = ( + node: SessionBrowserTreeNode, + depth: number, + ancestorHasNextSibling: boolean[], + isLastInThread: boolean, + ): void => { + result.push({ + session: node.session, + depth, + isLastInThread, + ancestorHasNextSibling, + }); + + for (let index = 0; index < node.children.length; index++) { + const child = node.children[index]; + if (!child) continue; + const childIsLast = index === node.children.length - 1; + const continues = depth > 0 ? !isLastInThread : false; + walk(child, depth + 1, [...ancestorHasNextSibling, continues], childIsLast); + } + }; + + for (let index = 0; index < roots.length; index++) { + const root = roots[index]; + if (!root) continue; + walk(root, 0, [], index === roots.length - 1); + } + + return result; +} + +function toSessionBrowserSession( + node: FlatSessionBrowserNode, + activeSessionFile: string | null, +): SessionBrowserSession { + const { session } = node; + const isActive = Boolean(activeSessionFile && resolve(session.path) === resolve(activeSessionFile)); + return { + id: session.id, + path: session.path, + cwd: session.cwd, + name: session.name, + createdAt: session.created.toISOString(), + modifiedAt: session.modified.toISOString(), + messageCount: session.messageCount, + parentSessionPath: session.parentSessionPath, + firstMessage: session.firstMessage, + isActive, + depth: node.depth, + isLastInThread: node.isLastInThread, + ancestorHasNextSibling: [...node.ancestorHasNextSibling], + }; +} + +function buildFlatSessionBrowserNodes( + sessions: SessionInfo[], + query: ReturnType, +): FlatSessionBrowserNode[] { + if (query.sortMode === "threaded" && !query.query) { + const filteredSessions = query.nameFilter === "named" ? sessions.filter((session) => hasSessionName(session)) : sessions; + return flattenSessionBrowserTree(buildSessionBrowserTree(filteredSessions)); + } + + return filterAndSortSessions(sessions, query.query, query.sortMode, query.nameFilter).map((session) => ({ + session, + depth: 0, + isLastInThread: true, + ancestorHasNextSibling: [], + })); +} + +function findCurrentProjectSession(sessions: SessionInfo[], sessionPath: string): SessionInfo | undefined { + const normalizedPath = resolve(sessionPath); + return sessions.find((session) => resolve(session.path) === normalizedPath); +} + +function buildSessionManageError( + code: SessionManageErrorCode, + error: string, + details: Omit, "success" | "code" | "error" | "action" | "scope"> = {}, +): SessionManageErrorResponse { + return { + success: false, + action: "rename", + scope: SESSION_BROWSER_SCOPE, + code, + error, + ...details, + }; +} + +export async function collectSessionBrowserPayload(query: SessionBrowserQuery = {}, projectCwd?: string): Promise { + const deps = getBridgeDeps(); + const env = deps.env ?? process.env; + const config = resolveBridgeRuntimeConfig(env, projectCwd); + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + + try { + await bridge.ensureStarted(); + } catch { + // Session browsing can still fall back to the current project session directory. + } + + const bridgeSnapshot = bridge.getSnapshot(); + const sessions = await loadSessionBrowserSessionsViaChildProcess(config); + const normalizedQuery = normalizeSessionBrowserQuery(query); + const browserSessions = buildFlatSessionBrowserNodes(sessions, normalizedQuery).map((node) => + toSessionBrowserSession(node, bridgeSnapshot.activeSessionFile), + ); + + return { + project: { + scope: SESSION_BROWSER_SCOPE, + cwd: config.projectCwd, + sessionsDir: config.projectSessionsDir, + activeSessionPath: bridgeSnapshot.activeSessionFile, + }, + query: normalizedQuery, + totalSessions: sessions.length, + returnedSessions: browserSessions.length, + sessions: browserSessions, + }; +} + +export async function renameSessionInCurrentProject(request: RenameSessionRequest, projectCwd?: string): Promise { + const deps = getBridgeDeps(); + const env = deps.env ?? process.env; + const config = resolveBridgeRuntimeConfig(env, projectCwd); + const nextName = request.name.trim(); + + if (!nextName) { + return buildSessionManageError("invalid_request", "Session name cannot be empty", { + sessionPath: request.sessionPath, + name: request.name, + }); + } + + const sessions = await loadSessionBrowserSessionsViaChildProcess(config); + const targetSession = findCurrentProjectSession(sessions, request.sessionPath); + if (!targetSession) { + return buildSessionManageError("not_found", "Session is not available in the current project browser", { + sessionPath: request.sessionPath, + name: nextName, + }); + } + + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + try { + await bridge.ensureStarted(); + } catch (error) { + return buildSessionManageError("rename_failed", sanitizeErrorMessage(error), { + sessionPath: targetSession.path, + name: nextName, + }); + } + + const activeSessionFile = bridge.getSnapshot().activeSessionFile; + const isActiveSession = Boolean(activeSessionFile && resolve(activeSessionFile) === resolve(targetSession.path)); + + if (isActiveSession) { + const response = await sendBridgeInput({ type: "set_session_name", name: nextName }, projectCwd); + if (response === null) { + return buildSessionManageError("rename_failed", "Active session rename did not return a response", { + sessionPath: targetSession.path, + name: nextName, + isActiveSession: true, + mutation: "rpc", + }); + } + + if (!response.success) { + const failureCode = (response as { code?: string }).code + return buildSessionManageError( + failureCode === "onboarding_locked" ? "onboarding_locked" : "rename_failed", + response.error, + { + sessionPath: targetSession.path, + name: nextName, + isActiveSession: true, + mutation: "rpc", + }, + ); + } + + return { + success: true, + action: "rename", + scope: SESSION_BROWSER_SCOPE, + sessionPath: targetSession.path, + name: nextName, + isActiveSession: true, + mutation: "rpc", + }; + } + + try { + await appendSessionInfoViaChildProcess(config, targetSession.path, nextName); + bridge.publishLiveStateInvalidation({ + reason: "set_session_name", + source: "session_manage", + domains: ["resumable_sessions"], + }); + return { + success: true, + action: "rename", + scope: SESSION_BROWSER_SCOPE, + sessionPath: targetSession.path, + name: nextName, + isActiveSession: false, + mutation: "session_file", + }; + } catch (error) { + return buildSessionManageError("rename_failed", sanitizeErrorMessage(error), { + sessionPath: targetSession.path, + name: nextName, + isActiveSession: false, + mutation: "session_file", + }); + } +} + +async function resolveBootOnboardingState(deps: BridgeServiceDeps, env: NodeJS.ProcessEnv): Promise { + if (deps.getOnboardingState) { + return await deps.getOnboardingState(); + } + if (deps.getOnboardingNeeded) { + return legacyOnboardingStateFromNeeded(await deps.getOnboardingNeeded(authFilePath, env)); + } + return await collectOnboardingState(); +} + +export async function collectCurrentProjectOnboardingState(projectCwd?: string): Promise { + const deps = getBridgeDeps(); + const env = deps.env ?? process.env; + return await resolveBootOnboardingState(deps, env); +} + +export type BridgeSelectiveLiveStateDomain = "auto" | "workspace" | "resumable_sessions"; + +export interface BridgeSelectiveLiveStatePayload { + auto?: AutoDashboardData; + workspace?: GSDWorkspaceIndex; + resumableSessions?: BootResumableSession[]; + bridge: BridgeRuntimeSnapshot; +} + +export async function collectSelectiveLiveStatePayload( + domains: BridgeSelectiveLiveStateDomain[] = ["auto", "workspace", "resumable_sessions"], + projectCwd?: string, +): Promise { + const deps = getBridgeDeps(); + const env = deps.env ?? process.env; + const config = resolveBridgeRuntimeConfig(env, projectCwd); + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + + try { + await bridge.ensureStarted(); + } catch { + // Selective live state still returns the latest bridge failure snapshot for inspection. + } + + const bridgeSnapshot = bridge.getSnapshot(); + const uniqueDomains = [...new Set(domains)]; + const payload: BridgeSelectiveLiveStatePayload = { + bridge: bridgeSnapshot, + }; + + if (uniqueDomains.includes("workspace")) { + payload.workspace = await loadCachedWorkspaceIndex( + config.projectCwd, + async () => await (deps.indexWorkspace ?? fallbackWorkspaceIndex)(config.projectCwd), + ); + } + + if (uniqueDomains.includes("auto")) { + const getAutoDashboardData = deps.getAutoDashboardData ?? (() => collectTestOnlyFallbackAutoDashboardData()); + payload.auto = await Promise.resolve(getAutoDashboardData()); + } + + if (uniqueDomains.includes("resumable_sessions")) { + const sessions = await (deps.listSessions ?? (async (dir: string) => listProjectSessions(dir)))(config.projectSessionsDir); + payload.resumableSessions = sessions.map((session) => toBootResumableSession(session, bridgeSnapshot.activeSessionFile)); + } + + return payload; +} + +export async function collectBootPayload(projectCwd?: string): Promise { + const deps = getBridgeDeps(); + const env = deps.env ?? process.env; + const config = resolveBridgeRuntimeConfig(env, projectCwd); + const getAutoDashboardData = deps.getAutoDashboardData ?? (() => collectTestOnlyFallbackAutoDashboardData()); + const listSessions = deps.listSessions ?? (async (dir: string) => listProjectSessions(dir)); + const projectDetection = detectProjectKind(config.projectCwd); + + const onboarding = await resolveBootOnboardingState(deps, env); + + if (onboarding.locked && env.GSD_WEB_HOST_KIND === "packaged-standalone") { + return { + project: { + cwd: config.projectCwd, + sessionsDir: config.projectSessionsDir, + packageRoot: config.packageRoot, + }, + workspace: { + milestones: [], + active: { + phase: "pre-planning", + }, + scopes: [ + { + scope: "project", + label: "project", + kind: "project", + }, + ], + validationIssues: [], + }, + auto: collectTestOnlyFallbackAutoDashboardData(), + onboarding, + onboardingNeeded: true, + resumableSessions: [], + bridge: { + phase: "idle", + projectCwd: config.projectCwd, + projectSessionsDir: config.projectSessionsDir, + packageRoot: config.packageRoot, + startedAt: null, + updatedAt: new Date().toISOString(), + connectionCount: 0, + lastCommandType: null, + activeSessionId: null, + activeSessionFile: null, + sessionState: null, + lastError: null, + }, + projectDetection, + }; + } + + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + + const workspacePromise = loadCachedWorkspaceIndex( + config.projectCwd, + async () => await (deps.indexWorkspace ?? fallbackWorkspaceIndex)(config.projectCwd), + ); + const autoPromise = Promise.resolve(getAutoDashboardData()); + const sessionsPromise = listSessions(config.projectSessionsDir); + + try { + await bridge.ensureStarted(); + } catch { + // Boot still returns the bridge failure snapshot for inspection. + } + + const bridgeSnapshot = bridge.getSnapshot(); + const [workspace, auto, sessions] = await Promise.all([ + workspacePromise, + autoPromise, + sessionsPromise, + ]); + + return { + project: { + cwd: config.projectCwd, + sessionsDir: config.projectSessionsDir, + packageRoot: config.packageRoot, + }, + workspace, + auto, + onboarding, + onboardingNeeded: onboarding.locked, + resumableSessions: sessions.map((session) => toBootResumableSession(session, bridgeSnapshot.activeSessionFile)), + bridge: bridgeSnapshot, + projectDetection, + }; +} + +export function buildBridgeFailureResponse(commandType: string, error: unknown): BridgeCommandFailureResponse { + return { + type: "response", + command: commandType, + success: false, + error: sanitizeErrorMessage(error), + }; +} + +export async function refreshProjectBridgeAuth(projectCwd?: string): Promise { + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + await bridge.refreshAuth(); +} + +registerOnboardingBridgeAuthRefresher(async () => { + await refreshProjectBridgeAuth(); +}); + +export function emitProjectLiveStateInvalidation( + descriptor: BridgeLiveStateInvalidationDescriptor, + projectCwd?: string, +): BridgeLiveStateInvalidationEvent { + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + return bridge.publishLiveStateInvalidation(descriptor); +} + +export async function sendBridgeInput(input: BridgeInput, projectCwd?: string): Promise { + if (!isReadOnlyBridgeInput(input)) { + const onboarding = await collectOnboardingState(); + if (onboarding.locked) { + return buildBridgeLockedResponse(input, onboarding); + } + } + + const bridge = projectCwd ? getProjectBridgeServiceForCwd(projectCwd) : getProjectBridgeService(); + return await bridge.sendInput(input); +} + +export function configureBridgeServiceForTests(overrides: Partial | null): void { + bridgeServiceOverrides = overrides; + invalidateWorkspaceIndexCache(); +} + +export async function resetBridgeServiceForTests(): Promise { + const disposePromises: Promise[] = []; + for (const service of projectBridgeRegistry.values()) { + disposePromises.push(service.dispose()); + } + await Promise.all(disposePromises); + projectBridgeRegistry.clear(); + bridgeServiceOverrides = null; + invalidateWorkspaceIndexCache(); +} diff --git a/src/web/captures-service.ts b/src/web/captures-service.ts new file mode 100644 index 000000000..003591845 --- /dev/null +++ b/src/web/captures-service.ts @@ -0,0 +1,155 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { CapturesData, CaptureResolveRequest, CaptureResolveResult } from "../../web/lib/knowledge-captures-types.ts" + +const CAPTURES_MAX_BUFFER = 2 * 1024 * 1024 +const CAPTURES_MODULE_ENV = "GSD_CAPTURES_MODULE" + +function resolveCapturesModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "captures.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Loads all capture entries via a child process. The child imports the upstream + * captures module, calls loadAllCaptures() and loadActionableCaptures(), and + * writes a CapturesData JSON to stdout. + */ +export async function collectCapturesData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const capturesModulePath = resolveCapturesModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(capturesModulePath)) { + throw new Error( + `captures data provider not found; checked=${resolveTsLoader},${capturesModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${CAPTURES_MODULE_ENV}).href);`, + `const all = mod.loadAllCaptures(process.env.GSD_CAPTURES_BASE);`, + 'const pending = all.filter(c => c.status === "pending");', + `const actionable = mod.loadActionableCaptures(process.env.GSD_CAPTURES_BASE);`, + 'const result = { entries: all, pendingCount: pending.length, actionableCount: actionable.length };', + 'process.stdout.write(JSON.stringify(result));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [CAPTURES_MODULE_ENV]: capturesModulePath, + GSD_CAPTURES_BASE: projectCwd, + }, + maxBuffer: CAPTURES_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`captures data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as CapturesData) + } catch (parseError) { + reject( + new Error( + `captures data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} + +/** + * Resolves (triages) a single capture by calling markCaptureResolved() in a + * child process. Returns { ok: true, captureId } on success. + */ +export async function resolveCaptureAction(request: CaptureResolveRequest, projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const capturesModulePath = resolveCapturesModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(capturesModulePath)) { + throw new Error( + `captures data provider not found; checked=${resolveTsLoader},${capturesModulePath}`, + ) + } + + const safeId = JSON.stringify(request.captureId) + const safeClassification = JSON.stringify(request.classification) + const safeResolution = JSON.stringify(request.resolution) + const safeRationale = JSON.stringify(request.rationale) + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${CAPTURES_MODULE_ENV}).href);`, + `mod.markCaptureResolved(process.env.GSD_CAPTURES_BASE, ${safeId}, ${safeClassification}, ${safeResolution}, ${safeRationale});`, + `process.stdout.write(JSON.stringify({ ok: true, captureId: ${safeId} }));`, + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [CAPTURES_MODULE_ENV]: capturesModulePath, + GSD_CAPTURES_BASE: projectCwd, + }, + maxBuffer: CAPTURES_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`capture resolve subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as CaptureResolveResult) + } catch (parseError) { + reject( + new Error( + `capture resolve subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/cleanup-service.ts b/src/web/cleanup-service.ts new file mode 100644 index 000000000..02f7d414e --- /dev/null +++ b/src/web/cleanup-service.ts @@ -0,0 +1,189 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { CleanupData, CleanupResult } from "../../web/lib/remaining-command-types.ts" + +const CLEANUP_MAX_BUFFER = 2 * 1024 * 1024 +const CLEANUP_MODULE_ENV = "GSD_CLEANUP_MODULE" + +function resolveCleanupModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "native-git-bridge.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Collects cleanup data (GSD branches and snapshot refs) via a child process. + * Child-process pattern required because native-git-bridge.ts uses .ts imports + * that need the resolve-ts.mjs loader. + */ +export async function collectCleanupData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const cleanupModulePath = resolveCleanupModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(cleanupModulePath)) { + throw new Error( + `cleanup data provider not found; checked=${resolveTsLoader},${cleanupModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${CLEANUP_MODULE_ENV}).href);`, + 'const basePath = process.env.GSD_CLEANUP_BASE;', + // Get all GSD branches + 'let branches = [];', + 'try { branches = mod.nativeBranchList(basePath, "gsd/*"); } catch {}', + // Detect main branch and find which GSD branches are merged + 'let mainBranch = "main";', + 'try { mainBranch = mod.nativeDetectMainBranch(basePath); } catch {}', + 'let merged = [];', + 'try { merged = mod.nativeBranchListMerged(basePath, mainBranch, "gsd/*"); } catch {}', + 'const mergedSet = new Set(merged);', + 'const branchList = branches.map(b => ({ name: b, merged: mergedSet.has(b) }));', + // Get snapshot refs + 'let refs = [];', + 'try { refs = mod.nativeForEachRef(basePath, "refs/gsd/snapshots/"); } catch {}', + 'const snapshotList = refs.map(r => {', + ' const parts = r.split(" ");', + ' return { ref: parts[0] || r, date: parts.length > 1 ? parts.slice(1).join(" ") : "" };', + '});', + 'process.stdout.write(JSON.stringify({ branches: branchList, snapshots: snapshotList }));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [CLEANUP_MODULE_ENV]: cleanupModulePath, + GSD_CLEANUP_BASE: projectCwd, + }, + maxBuffer: CLEANUP_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`cleanup data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as CleanupData) + } catch (parseError) { + reject( + new Error( + `cleanup data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} + +/** + * Executes cleanup operations (branch deletion and snapshot pruning) via a child process. + * Child-process pattern required because nativeBranchDelete and nativeUpdateRef + * modify git state using .ts imports. + */ +export async function executeCleanup( + deleteBranches: string[], + pruneSnapshots: string[], + projectCwdOverride?: string, +): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const cleanupModulePath = resolveCleanupModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(cleanupModulePath)) { + throw new Error( + `cleanup service modules not found; checked=${resolveTsLoader},${cleanupModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${CLEANUP_MODULE_ENV}).href);`, + 'const basePath = process.env.GSD_CLEANUP_BASE;', + 'const branches = JSON.parse(process.env.GSD_CLEANUP_BRANCHES || "[]");', + 'const snapshots = JSON.parse(process.env.GSD_CLEANUP_SNAPSHOTS || "[]");', + 'let deletedBranches = 0;', + 'let prunedSnapshots = 0;', + 'const errors = [];', + 'for (const branch of branches) {', + ' try { mod.nativeBranchDelete(basePath, branch, true); deletedBranches++; }', + ' catch (e) { errors.push(`Branch ${branch}: ${e.message}`); }', + '}', + 'for (const ref of snapshots) {', + ' try { mod.nativeUpdateRef(basePath, ref); prunedSnapshots++; }', + ' catch (e) { errors.push(`Ref ${ref}: ${e.message}`); }', + '}', + 'const parts = [];', + 'if (deletedBranches > 0) parts.push(`Deleted ${deletedBranches} branch(es)`);', + 'if (prunedSnapshots > 0) parts.push(`Pruned ${prunedSnapshots} snapshot(s)`);', + 'if (errors.length > 0) parts.push(`Errors: ${errors.join("; ")}`);', + 'const message = parts.length > 0 ? parts.join(". ") : "No items to clean up";', + 'process.stdout.write(JSON.stringify({ deletedBranches, prunedSnapshots, message }));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [CLEANUP_MODULE_ENV]: cleanupModulePath, + GSD_CLEANUP_BASE: projectCwd, + GSD_CLEANUP_BRANCHES: JSON.stringify(deleteBranches), + GSD_CLEANUP_SNAPSHOTS: JSON.stringify(pruneSnapshots), + }, + maxBuffer: CLEANUP_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`cleanup subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as CleanupResult) + } catch (parseError) { + reject( + new Error( + `cleanup subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/cli-entry.ts b/src/web/cli-entry.ts new file mode 100644 index 000000000..77422d2eb --- /dev/null +++ b/src/web/cli-entry.ts @@ -0,0 +1,75 @@ +import { existsSync } from "node:fs"; +import { join } from "node:path"; +import { pathToFileURL } from "node:url"; + +export interface GsdCliEntry { + command: string; + args: string[]; + cwd: string; +} + +export interface ResolveGsdCliEntryOptions { + packageRoot: string; + cwd: string; + execPath?: string; + hostKind?: string; + mode?: "interactive" | "rpc"; + sessionDir?: string; + messages?: string[]; + existsSync?: (path: string) => boolean; +} + +function buildExtraArgs(options: ResolveGsdCliEntryOptions): string[] { + if (options.mode !== "rpc") return []; + + if (!options.sessionDir) { + throw new Error("RPC CLI entry requires sessionDir"); + } + + return ["--mode", "rpc", "--continue", "--session-dir", options.sessionDir]; +} + +export function resolveGsdCliEntry(options: ResolveGsdCliEntryOptions): GsdCliEntry { + const checkExists = options.existsSync ?? existsSync; + const execPath = options.execPath ?? process.execPath; + const extraArgs = buildExtraArgs(options); + const messageArgs = options.mode === "interactive" ? options.messages ?? [] : []; + + const sourceEntry = join(options.packageRoot, "src", "loader.ts"); + const resolveTsLoader = join(options.packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs"); + const builtEntry = join(options.packageRoot, "dist", "loader.js"); + + const sourceCliEntry = + checkExists(sourceEntry) && checkExists(resolveTsLoader) + ? { + command: execPath, + args: [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + sourceEntry, + ...extraArgs, + ...messageArgs, + ], + cwd: options.cwd, + } satisfies GsdCliEntry + : null; + + const builtCliEntry = checkExists(builtEntry) + ? { + command: execPath, + args: [builtEntry, ...extraArgs, ...messageArgs], + cwd: options.cwd, + } satisfies GsdCliEntry + : null; + + if (options.hostKind === "packaged-standalone") { + if (builtCliEntry) return builtCliEntry; + if (sourceCliEntry) return sourceCliEntry; + } else { + if (sourceCliEntry) return sourceCliEntry; + if (builtCliEntry) return builtCliEntry; + } + + throw new Error(`GSD CLI entry not found; checked=${sourceEntry},${builtEntry}`); +} diff --git a/src/web/doctor-service.ts b/src/web/doctor-service.ts new file mode 100644 index 000000000..cdbb0fc2e --- /dev/null +++ b/src/web/doctor-service.ts @@ -0,0 +1,148 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { DoctorReport, DoctorFixResult } from "../../web/lib/diagnostics-types.ts" + +const DOCTOR_MAX_BUFFER = 2 * 1024 * 1024 +const DOCTOR_MODULE_ENV = "GSD_DOCTOR_MODULE" + +function resolveDoctorModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "doctor.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +function validateModulePaths( + resolveTsLoader: string, + doctorModulePath: string, +): void { + if (!existsSync(resolveTsLoader) || !existsSync(doctorModulePath)) { + throw new Error( + `doctor data provider not found; checked=${resolveTsLoader},${doctorModulePath}`, + ) + } +} + +function runDoctorChild( + packageRoot: string, + projectCwd: string, + script: string, + resolveTsLoader: string, + doctorModulePath: string, + scope?: string, +): Promise { + return new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [DOCTOR_MODULE_ENV]: doctorModulePath, + GSD_DOCTOR_BASE: projectCwd, + GSD_DOCTOR_SCOPE: scope ?? "", + }, + maxBuffer: DOCTOR_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`doctor subprocess failed: ${stderr || error.message}`)) + return + } + resolveResult(stdout) + }, + ) + }) +} + +/** + * Loads doctor diagnostic data (GET — read-only, no fixes applied). + * Returns full issues array + summary for the doctor panel. + */ +export async function collectDoctorData(scope?: string, projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const doctorModulePath = resolveDoctorModulePath(packageRoot) + validateModulePaths(resolveTsLoader, doctorModulePath) + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${DOCTOR_MODULE_ENV}).href);`, + 'const basePath = process.env.GSD_DOCTOR_BASE;', + 'const scope = process.env.GSD_DOCTOR_SCOPE || undefined;', + 'const report = await mod.runGSDDoctor(basePath, { fix: false, scope });', + 'const summary = mod.summarizeDoctorIssues(report.issues);', + 'const result = {', + ' ok: report.ok,', + ' issues: report.issues,', + ' fixesApplied: report.fixesApplied,', + ' summary,', + '};', + 'process.stdout.write(JSON.stringify(result));', + ].join(" ") + + const stdout = await runDoctorChild( + packageRoot, projectCwd, script, resolveTsLoader, doctorModulePath, scope, + ) + + try { + return JSON.parse(stdout) as DoctorReport + } catch (parseError) { + throw new Error( + `doctor subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ) + } +} + +/** + * Applies doctor fixes (POST — mutating action). + * Returns fix result with list of applied fixes. + */ +export async function applyDoctorFixes(scope?: string, projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const doctorModulePath = resolveDoctorModulePath(packageRoot) + validateModulePaths(resolveTsLoader, doctorModulePath) + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${DOCTOR_MODULE_ENV}).href);`, + 'const basePath = process.env.GSD_DOCTOR_BASE;', + 'const scope = process.env.GSD_DOCTOR_SCOPE || undefined;', + 'const report = await mod.runGSDDoctor(basePath, { fix: true, scope });', + 'const result = {', + ' ok: report.ok,', + ' fixesApplied: report.fixesApplied,', + '};', + 'process.stdout.write(JSON.stringify(result));', + ].join(" ") + + const stdout = await runDoctorChild( + packageRoot, projectCwd, script, resolveTsLoader, doctorModulePath, scope, + ) + + try { + return JSON.parse(stdout) as DoctorFixResult + } catch (parseError) { + throw new Error( + `doctor fix subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ) + } +} diff --git a/src/web/export-service.ts b/src/web/export-service.ts new file mode 100644 index 000000000..dd3b13a32 --- /dev/null +++ b/src/web/export-service.ts @@ -0,0 +1,96 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { ExportResult } from "../../web/lib/remaining-command-types.ts" + +const EXPORT_MAX_BUFFER = 4 * 1024 * 1024 +const EXPORT_MODULE_ENV = "GSD_EXPORT_MODULE" + +function resolveExportModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "export.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Generates an export file via a child process and returns its content. + * The child calls writeExportFile() which creates a timestamped file in .gsd/, + * then reads its content back for browser display. + */ +export async function collectExportData( + format: "markdown" | "json" = "markdown", + projectCwdOverride?: string, +): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const exportModulePath = resolveExportModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(exportModulePath)) { + throw new Error( + `export data provider not found; checked=${resolveTsLoader},${exportModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${EXPORT_MODULE_ENV}).href);`, + 'const format = process.env.GSD_EXPORT_FORMAT || "markdown";', + 'const basePath = process.env.GSD_EXPORT_BASE;', + 'const filePath = mod.writeExportFile(basePath, format);', + 'if (filePath) {', + ' const { readFileSync } = await import("node:fs");', + ' const { basename } = await import("node:path");', + ' const content = readFileSync(filePath, "utf-8");', + ' process.stdout.write(JSON.stringify({ content, format, filename: basename(filePath) }));', + '} else {', + ' process.stdout.write(JSON.stringify({ content: "No metrics data available for export.", format, filename: "export." + (format === "json" ? "json" : "md") }));', + '}', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [EXPORT_MODULE_ENV]: exportModulePath, + GSD_EXPORT_BASE: projectCwd, + GSD_EXPORT_FORMAT: format, + }, + maxBuffer: EXPORT_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`export data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as ExportResult) + } catch (parseError) { + reject( + new Error( + `export data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/forensics-service.ts b/src/web/forensics-service.ts new file mode 100644 index 000000000..6d1220540 --- /dev/null +++ b/src/web/forensics-service.ts @@ -0,0 +1,114 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { ForensicReport } from "../../web/lib/diagnostics-types.ts" + +const FORENSICS_MAX_BUFFER = 2 * 1024 * 1024 +const FORENSICS_MODULE_ENV = "GSD_FORENSICS_MODULE" + +function resolveForensicsModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "forensics.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Loads forensic report data via a child process. Converts the full upstream + * ForensicReport into a browser-safe subset: deep ExecutionTrace objects are + * replaced with trace counts and simplified entries, MetricsLedger is flattened + * to summary totals, and doctorIssues is replaced with a count (doctor panel + * has its own dedicated API route). + */ +export async function collectForensicsData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const forensicsModulePath = resolveForensicsModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(forensicsModulePath)) { + throw new Error( + `forensics data provider not found; checked=${resolveTsLoader},${forensicsModulePath}`, + ) + } + + // The child script loads the upstream module, calls buildForensicReport(), + // simplifies the output for browser consumption, and writes JSON to stdout. + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${FORENSICS_MODULE_ENV}).href);`, + `const report = await mod.buildForensicReport(process.env.GSD_FORENSICS_BASE);`, + // Simplify unitTraces: strip deep ExecutionTrace, keep file/unitType/unitId/seq/mtime + 'const unitTraces = (report.unitTraces || []).map(t => ({', + ' file: t.file, unitType: t.unitType, unitId: t.unitId, seq: t.seq, mtime: t.mtime,', + '}));', + // Flatten metrics to summary + 'let metrics = null;', + 'if (report.metrics && report.metrics.units) {', + ' const units = report.metrics.units;', + ' const totalCost = units.reduce((s, u) => s + u.cost, 0);', + ' const totalDuration = units.reduce((s, u) => s + (u.finishedAt - u.startedAt), 0);', + ' metrics = { totalUnits: units.length, totalCost, totalDuration };', + '}', + 'const result = {', + ' gsdVersion: report.gsdVersion,', + ' timestamp: report.timestamp,', + ' basePath: report.basePath,', + ' activeMilestone: report.activeMilestone,', + ' activeSlice: report.activeSlice,', + ' anomalies: report.anomalies,', + ' recentUnits: report.recentUnits,', + ' crashLock: report.crashLock,', + ' doctorIssueCount: (report.doctorIssues || []).length,', + ' unitTraceCount: unitTraces.length,', + ' unitTraces,', + ' completedKeyCount: (report.completedKeys || []).length,', + ' metrics,', + '};', + 'process.stdout.write(JSON.stringify(result));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [FORENSICS_MODULE_ENV]: forensicsModulePath, + GSD_FORENSICS_BASE: projectCwd, + }, + maxBuffer: FORENSICS_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`forensics data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as ForensicReport) + } catch (parseError) { + reject( + new Error( + `forensics data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/git-summary-service.ts b/src/web/git-summary-service.ts new file mode 100644 index 000000000..649baf378 --- /dev/null +++ b/src/web/git-summary-service.ts @@ -0,0 +1,198 @@ +import { execFileSync } from "node:child_process" +import { relative, resolve, sep } from "node:path" + +import { + nativeDetectMainBranch, + nativeHasChanges, + nativeHasMergeConflicts, + nativeGetCurrentBranch, +} from "../resources/extensions/gsd/native-git-bridge.ts" +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import { + GIT_SUMMARY_SCOPE, + type GitSummaryCounts, + type GitSummaryFile, + type GitSummaryResponse, +} from "../../web/lib/git-summary-contract.ts" + +const MAX_CHANGED_FILES = 25 +const CONFLICT_STATUS_CODES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]) + +function sanitizeGitError(error: unknown): string { + const raw = error instanceof Error ? error.message : String(error) + return raw.replace(/\s+/g, " ").trim() +} + +function gitExecTrim(basePath: string, args: string[], allowFailure = false): string { + try { + return execFileSync("git", args, { + cwd: basePath, + encoding: "utf8", + stdio: ["ignore", "pipe", "pipe"], + env: { + ...process.env, + GIT_TERMINAL_PROMPT: "0", + GIT_ASKPASS: "", + GIT_SVN_ID: "", + }, + }).trim() + } catch { + if (allowFailure) return "" + throw new Error(`git ${args.join(" ")} failed in ${basePath}`) + } +} + +function readGitStatusPorcelain(basePath: string): string { + try { + return execFileSync("git", ["status", "--porcelain", "--untracked-files=all"], { + cwd: basePath, + encoding: "utf8", + stdio: ["ignore", "pipe", "pipe"], + env: { + ...process.env, + GIT_TERMINAL_PROMPT: "0", + GIT_ASKPASS: "", + GIT_SVN_ID: "", + }, + }) + } catch { + return "" + } +} + +function toGitPath(value: string): string { + return value.split(sep).join("/") +} + +function repoRelativeProjectPath(projectCwd: string, repoRoot: string): string | null { + const gitPrefix = gitExecTrim(projectCwd, ["rev-parse", "--show-prefix"], true).replace(/\/$/, "") + if (gitPrefix) { + return gitPrefix + } + + const relativePath = toGitPath(relative(repoRoot, projectCwd)) + if (!relativePath || relativePath === ".") return "" + if (relativePath === ".." || relativePath.startsWith("../")) return null + return relativePath +} + +function pathInsideProject(repoPath: string, projectPath: string | null): boolean { + if (projectPath === null || projectPath === "") return true + return repoPath === projectPath || repoPath.startsWith(`${projectPath}/`) +} + +function toProjectPath(repoPath: string, projectPath: string | null): string { + if (projectPath === null || projectPath === "") return repoPath + if (repoPath === projectPath) return "." + return repoPath.startsWith(`${projectPath}/`) ? repoPath.slice(projectPath.length + 1) : repoPath +} + +function parsePorcelainPath(rawPath: string): string { + const renameArrow = " -> " + const arrowIndex = rawPath.lastIndexOf(renameArrow) + const value = arrowIndex >= 0 ? rawPath.slice(arrowIndex + renameArrow.length) : rawPath + return value.trim() +} + +function parseStatusLine(line: string, projectPath: string | null): GitSummaryFile | null { + if (line.length < 3) return null + + const status = line.slice(0, 2) + const repoPath = parsePorcelainPath(line.slice(3)) + if (!repoPath || !pathInsideProject(repoPath, projectPath)) return null + + const untracked = status === "??" + const conflict = CONFLICT_STATUS_CODES.has(status) + const staged = !untracked && !conflict && status[0] !== " " + const dirty = !untracked && !conflict && status[1] !== " " + + return { + path: toProjectPath(repoPath, projectPath), + repoPath, + status, + staged, + dirty, + untracked, + conflict, + } +} + +function summarizeChangedFiles(changedFiles: GitSummaryFile[]): GitSummaryCounts { + return changedFiles.reduce( + (counts, file) => ({ + changed: counts.changed + 1, + staged: counts.staged + Number(file.staged), + dirty: counts.dirty + Number(file.dirty), + untracked: counts.untracked + Number(file.untracked), + conflicts: counts.conflicts + Number(file.conflict), + }), + { + changed: 0, + staged: 0, + dirty: 0, + untracked: 0, + conflicts: 0, + }, + ) +} + +function collectChangedFiles(repoRoot: string, projectPath: string | null): GitSummaryFile[] { + const porcelain = readGitStatusPorcelain(repoRoot) + if (!porcelain.trim()) return [] + + return porcelain + .split(/\r?\n/) + .map((line) => line.trimEnd()) + .filter(Boolean) + .map((line) => parseStatusLine(line, projectPath)) + .filter((file): file is GitSummaryFile => file !== null) +} + +export async function collectCurrentProjectGitSummary(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const projectCwd = resolve(config.projectCwd) + + const repoRoot = gitExecTrim(projectCwd, ["rev-parse", "--show-toplevel"], true) + if (!repoRoot) { + return { + kind: "not_repo", + project: { + scope: GIT_SUMMARY_SCOPE, + cwd: projectCwd, + repoRoot: null, + repoRelativePath: null, + }, + message: "Current project is not inside a Git repository.", + } + } + + try { + const resolvedRepoRoot = resolve(repoRoot) + const projectPath = repoRelativeProjectPath(projectCwd, resolvedRepoRoot) + const allChangedFiles = collectChangedFiles(resolvedRepoRoot, projectPath) + const counts = summarizeChangedFiles(allChangedFiles) + const branch = nativeGetCurrentBranch(resolvedRepoRoot) || null + const mainBranch = nativeDetectMainBranch(resolvedRepoRoot) || null + const hasChanges = projectPath === "" ? nativeHasChanges(resolvedRepoRoot) : counts.changed > 0 + const hasConflicts = projectPath === "" ? nativeHasMergeConflicts(resolvedRepoRoot) : counts.conflicts > 0 + + return { + kind: "repo", + project: { + scope: GIT_SUMMARY_SCOPE, + cwd: projectCwd, + repoRoot: resolvedRepoRoot, + repoRelativePath: projectPath, + }, + branch, + mainBranch, + hasChanges, + hasConflicts, + counts, + changedFiles: allChangedFiles.slice(0, MAX_CHANGED_FILES), + truncatedFileCount: Math.max(0, allChangedFiles.length - MAX_CHANGED_FILES), + } + } catch (error) { + throw new Error(`Current-project git summary failed: ${sanitizeGitError(error)}`) + } +} diff --git a/src/web/history-service.ts b/src/web/history-service.ts new file mode 100644 index 000000000..4bb556beb --- /dev/null +++ b/src/web/history-service.ts @@ -0,0 +1,88 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { HistoryData } from "../../web/lib/remaining-command-types.ts" + +const HISTORY_MAX_BUFFER = 2 * 1024 * 1024 +const HISTORY_MODULE_ENV = "GSD_HISTORY_MODULE" + +function resolveHistoryModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "metrics.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Loads history/metrics data via a child process. + * Reads the metrics ledger from disk and computes aggregation views + * (totals, byPhase, bySlice, byModel) for browser consumption. + */ +export async function collectHistoryData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const historyModulePath = resolveHistoryModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(historyModulePath)) { + throw new Error( + `history data provider not found; checked=${resolveTsLoader},${historyModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${HISTORY_MODULE_ENV}).href);`, + `const ledger = mod.loadLedgerFromDisk(process.env.GSD_HISTORY_BASE);`, + 'const units = ledger ? ledger.units : [];', + 'const totals = mod.getProjectTotals(units);', + 'const byPhase = mod.aggregateByPhase(units);', + 'const bySlice = mod.aggregateBySlice(units);', + 'const byModel = mod.aggregateByModel(units);', + 'process.stdout.write(JSON.stringify({ units, totals, byPhase, bySlice, byModel }));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [HISTORY_MODULE_ENV]: historyModulePath, + GSD_HISTORY_BASE: projectCwd, + }, + maxBuffer: HISTORY_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`history data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as HistoryData) + } catch (parseError) { + reject( + new Error( + `history data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/hooks-service.ts b/src/web/hooks-service.ts new file mode 100644 index 000000000..769f4e541 --- /dev/null +++ b/src/web/hooks-service.ts @@ -0,0 +1,88 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { HooksData } from "../../web/lib/remaining-command-types.ts" + +const HOOKS_MAX_BUFFER = 512 * 1024 +const HOOKS_MODULE_ENV = "GSD_HOOKS_MODULE" + +function resolveHooksModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "post-unit-hooks.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Collects hook configuration and status via a child process. + * Runtime state (active cycles, hook queue) is not available in a cold child + * process, so activeCycles will be empty. The child calls getHookStatus() which + * reads from preferences to build entries, then formatHookStatus() for display. + */ +export async function collectHooksData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const hooksModulePath = resolveHooksModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(hooksModulePath)) { + throw new Error( + `hooks data provider not found; checked=${resolveTsLoader},${hooksModulePath}`, + ) + } + + // getHookStatus() internally calls resolvePostUnitHooks() and resolvePreDispatchHooks() + // from preferences.ts, which read from process.cwd()/.gsd/preferences.md. + // We set cwd to projectCwd so preferences resolution finds the right files. + // In a cold child process, cycleCounts is empty, so activeCycles will be {}. + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${HOOKS_MODULE_ENV}).href);`, + 'const entries = mod.getHookStatus();', + 'const formattedStatus = mod.formatHookStatus();', + 'process.stdout.write(JSON.stringify({ entries, formattedStatus }));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: projectCwd, + env: { + ...process.env, + [HOOKS_MODULE_ENV]: hooksModulePath, + }, + maxBuffer: HOOKS_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`hooks data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as HooksData) + } catch (parseError) { + reject( + new Error( + `hooks data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/inspect-service.ts b/src/web/inspect-service.ts new file mode 100644 index 000000000..fc21cd460 --- /dev/null +++ b/src/web/inspect-service.ts @@ -0,0 +1,56 @@ +import { existsSync, readFileSync } from "node:fs" +import { join } from "node:path" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { InspectData } from "../../web/lib/remaining-command-types.ts" + +/** + * Collects project inspection data by reading gsd-db.json directly. + * No child process needed — gsd-db.json is plain JSON with no .js imports. + */ +export async function collectInspectData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { projectCwd } = config + + const gsdDir = join(projectCwd, ".gsd") + const dbPath = join(gsdDir, "gsd-db.json") + + let schemaVersion: number | null = null + let decisions: Array<{ id: string; decision: string; choice: string; [k: string]: unknown }> = [] + let requirements: Array<{ + id: string + status: string + description: string + [k: string]: unknown + }> = [] + let artifacts: unknown[] = [] + + if (existsSync(dbPath)) { + try { + const db = JSON.parse(readFileSync(dbPath, "utf-8")) + schemaVersion = db.schema_version ?? null + decisions = db.decisions || [] + requirements = db.requirements || [] + artifacts = db.artifacts || [] + } catch { + // Corrupt or unreadable — return empty state + } + } + + return { + schemaVersion, + counts: { + decisions: decisions.length, + requirements: requirements.length, + artifacts: artifacts.length, + }, + recentDecisions: decisions + .slice(-5) + .reverse() + .map((d) => ({ id: d.id, decision: d.decision, choice: d.choice })), + recentRequirements: requirements + .slice(-5) + .reverse() + .map((r) => ({ id: r.id, status: r.status, description: r.description })), + } +} diff --git a/src/web/knowledge-service.ts b/src/web/knowledge-service.ts new file mode 100644 index 000000000..acb13f99e --- /dev/null +++ b/src/web/knowledge-service.ts @@ -0,0 +1,113 @@ +import { existsSync, readFileSync, statSync } from "node:fs" +import { join } from "node:path" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { KnowledgeEntry, KnowledgeData } from "../../web/lib/knowledge-captures-types.ts" + +/** + * Reads and parses KNOWLEDGE.md directly from disk. No child process needed + * because KNOWLEDGE.md is a plain markdown file with a deterministic path + * and no Node ESM .js-extension imports. + */ +export async function collectKnowledgeData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { projectCwd } = config + + const filePath = join(projectCwd, ".gsd", "KNOWLEDGE.md") + + if (!existsSync(filePath)) { + return { entries: [], filePath, lastModified: null } + } + + const content = readFileSync(filePath, "utf-8") + const stat = statSync(filePath) + const entries = parseKnowledgeFile(content) + + return { + entries, + filePath, + lastModified: stat.mtime.toISOString(), + } +} + +/** + * Parse KNOWLEDGE.md content into KnowledgeEntry array. + * + * Handles two formats: + * 1. **Freeform**: `## Title` followed by prose paragraphs + * 2. **Table**: `## Title` followed by a markdown table with rows matching + * `| K001 |`, `| P001 |`, or `| L001 |` patterns + */ +export function parseKnowledgeFile(content: string): KnowledgeEntry[] { + const entries: KnowledgeEntry[] = [] + let freeformCounter = 0 + + // Split on ## headings, keeping the heading text + const sections = content.split(/^## /m) + + for (const section of sections) { + const trimmed = section.trim() + if (!trimmed) continue + + // Skip the top-level heading section (# Knowledge Base, # Project Knowledge, etc.) + if (/^#\s+/m.test(trimmed) && !trimmed.includes("\n## ")) { + // This is content before the first ## heading — skip if it's just the H1 + const firstLine = trimmed.split("\n")[0]?.trim() ?? "" + if (firstLine.startsWith("# ")) continue + } + + // Extract heading (first line) and body (rest) + const newlineIndex = trimmed.indexOf("\n") + if (newlineIndex === -1) { + // Heading-only section with no body — skip + continue + } + + const title = trimmed.slice(0, newlineIndex).trim() + const body = trimmed.slice(newlineIndex + 1).trim() + + if (!title || !body) continue + + // Check for table rows with K/P/L prefixed IDs + const tableRowRegex = /^\|\s*([KPL]\d{3})\s*\|(.+)\|/gm + const tableMatches: Array<{ id: string; rest: string }> = [] + let match: RegExpExecArray | null + + while ((match = tableRowRegex.exec(body)) !== null) { + tableMatches.push({ id: match[1], rest: match[2] }) + } + + if (tableMatches.length > 0) { + // Table format: parse each row as a structured entry + for (const row of tableMatches) { + const prefix = row.id.charAt(0) + const type: KnowledgeEntry["type"] = + prefix === "K" ? "rule" : prefix === "P" ? "pattern" : "lesson" + + // Extract columns from the rest of the row + const columns = row.rest + .split("|") + .map((col) => col.trim()) + .filter(Boolean) + + entries.push({ + id: row.id, + title: columns[0] ?? title, + content: columns.slice(1).join(" — ") || title, + type, + }) + } + } else { + // Freeform format: entire section is one entry + freeformCounter++ + entries.push({ + id: `freeform-${freeformCounter}`, + title, + content: body, + type: "freeform", + }) + } + } + + return entries +} diff --git a/src/web/onboarding-service.ts b/src/web/onboarding-service.ts new file mode 100644 index 000000000..9c5c6af34 --- /dev/null +++ b/src/web/onboarding-service.ts @@ -0,0 +1,837 @@ +import { randomUUID } from "node:crypto"; + +import { getEnvApiKey } from "../../packages/pi-ai/src/web-runtime-env-api-keys.ts"; +import type { OAuthAuthInfo, OAuthPrompt, OAuthProviderInterface } from "../../packages/pi-ai/dist/oauth.js"; +import { authFilePath } from "../app-paths.ts"; +import { createOnboardingAuthStorage, type OnboardingAuthStorage as AuthStorageInstance } from "./web-auth-storage.ts"; + +type RequiredProviderCatalogEntry = { + id: string; + label: string; + supportsApiKey: boolean; + supportsOAuth: boolean; + recommended?: boolean; +}; + +type OptionalSectionCatalogEntry = { + id: string; + label: string; + providers: Array<{ id: string; label: string; envVar?: string }>; +}; + +type ValidationProbeResult = + | { ok: true; message?: string } + | { ok: false; message: string }; + +type GetEnvApiKeyFn = typeof getEnvApiKey; +type BridgeAuthRefresher = () => Promise; + +let onboardingBridgeAuthRefresher: BridgeAuthRefresher | null = null; + +type OnboardingServiceDeps = { + env?: NodeJS.ProcessEnv; + authPath?: string; + authStorage?: AuthStorageInstance; + createAuthStorage?: (authPath: string) => AuthStorageInstance | Promise; + validateApiKey?: (providerId: string, apiKey: string) => Promise; + fetch?: typeof fetch; + now?: () => Date; + createFlowId?: () => string; + getEnvApiKey?: GetEnvApiKeyFn; + refreshBridgeAuth?: () => Promise; +}; + +export type OnboardingCredentialSource = "auth_file" | "environment" | "runtime"; +export type OnboardingValidationStatus = "succeeded" | "failed"; +export type OnboardingFlowStatus = + | "idle" + | "running" + | "awaiting_browser_auth" + | "awaiting_input" + | "succeeded" + | "failed" + | "cancelled"; +export type OnboardingLockReason = "required_setup" | "bridge_refresh_pending" | "bridge_refresh_failed"; +export type OnboardingBridgeAuthRefreshPhase = "idle" | "pending" | "succeeded" | "failed"; + +export interface OnboardingProviderState { + id: string; + label: string; + required: true; + recommended: boolean; + configured: boolean; + configuredVia: OnboardingCredentialSource | null; + supports: { + apiKey: boolean; + oauth: boolean; + oauthAvailable: boolean; + usesCallbackServer: boolean; + }; +} + +export interface OnboardingOptionalSectionState { + id: string; + label: string; + blocking: false; + skippable: true; + configured: boolean; + configuredItems: string[]; +} + +export interface OnboardingValidationResult { + status: OnboardingValidationStatus; + providerId: string; + method: "api_key" | "oauth"; + checkedAt: string; + message: string; + persisted: boolean; +} + +export interface OnboardingFlowPromptState { + kind: "text" | "manual_code"; + message: string; + placeholder?: string; + allowEmpty?: boolean; +} + +export interface OnboardingProviderFlowState { + flowId: string; + providerId: string; + providerLabel: string; + status: OnboardingFlowStatus; + updatedAt: string; + auth: OAuthAuthInfo | null; + prompt: OnboardingFlowPromptState | null; + progress: string[]; + error: string | null; +} + +export interface OnboardingBridgeAuthRefreshState { + phase: OnboardingBridgeAuthRefreshPhase; + strategy: "restart" | null; + startedAt: string | null; + completedAt: string | null; + error: string | null; +} + +export interface OnboardingState { + status: "blocked" | "ready"; + locked: boolean; + lockReason: OnboardingLockReason | null; + required: { + blocking: true; + skippable: false; + satisfied: boolean; + satisfiedBy: { providerId: string; source: OnboardingCredentialSource } | null; + providers: OnboardingProviderState[]; + }; + optional: { + blocking: false; + skippable: true; + sections: OnboardingOptionalSectionState[]; + }; + lastValidation: OnboardingValidationResult | null; + activeFlow: OnboardingProviderFlowState | null; + bridgeAuthRefresh: OnboardingBridgeAuthRefreshState; +} + +type ProviderFlowRuntime = { + state: OnboardingProviderFlowState; + awaitingInput: ((value: string) => void) | null; + abortController: AbortController; +}; + +const REQUIRED_PROVIDER_CATALOG: RequiredProviderCatalogEntry[] = [ + { id: "anthropic", label: "Anthropic (Claude)", supportsApiKey: true, supportsOAuth: true, recommended: true }, + { id: "openai", label: "OpenAI", supportsApiKey: true, supportsOAuth: false }, + { id: "github-copilot", label: "GitHub Copilot", supportsApiKey: false, supportsOAuth: true }, + { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex Subscription)", supportsApiKey: false, supportsOAuth: true }, + { id: "google-gemini-cli", label: "Google Cloud Code Assist (Gemini CLI)", supportsApiKey: false, supportsOAuth: true }, + { id: "google-antigravity", label: "Antigravity (Gemini 3, Claude, GPT-OSS)", supportsApiKey: false, supportsOAuth: true }, + { id: "google", label: "Google (Gemini API)", supportsApiKey: true, supportsOAuth: false }, + { id: "groq", label: "Groq", supportsApiKey: true, supportsOAuth: false }, + { id: "xai", label: "xAI (Grok)", supportsApiKey: true, supportsOAuth: false }, + { id: "openrouter", label: "OpenRouter", supportsApiKey: true, supportsOAuth: false }, + { id: "mistral", label: "Mistral", supportsApiKey: true, supportsOAuth: false }, +]; + +const OPTIONAL_SECTION_CATALOG: OptionalSectionCatalogEntry[] = [ + { + id: "web_search", + label: "Web search", + providers: [ + { id: "brave", label: "Brave Search", envVar: "BRAVE_API_KEY" }, + { id: "tavily", label: "Tavily", envVar: "TAVILY_API_KEY" }, + ], + }, + { + id: "tool_keys", + label: "Tool API keys", + providers: [ + { id: "context7", label: "Context7", envVar: "CONTEXT7_API_KEY" }, + { id: "jina", label: "Jina AI", envVar: "JINA_API_KEY" }, + { id: "groq", label: "Groq", envVar: "GROQ_API_KEY" }, + ], + }, + { + id: "remote_questions", + label: "Remote questions", + providers: [ + { id: "discord_bot", label: "Discord", envVar: "DISCORD_BOT_TOKEN" }, + { id: "slack_bot", label: "Slack", envVar: "SLACK_BOT_TOKEN" }, + ], + }, +]; + +let onboardingServiceOverrides: Partial | null = null; +let onboardingServiceSingleton: OnboardingService | null = null; + +function nowIso(now: () => Date): string { + return now().toISOString(); +} + +function redactSensitiveText(value: string): string { + return value + .replace(/sk-[A-Za-z0-9_-]{6,}/g, "[redacted]") + .replace(/xox[baprs]-[A-Za-z0-9-]+/g, "[redacted]") + .replace(/Bearer\s+[^\s]+/gi, "Bearer [redacted]") + .replace(/([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET)["'=:\s]+)([^\s,;"']+)/gi, "$1[redacted]"); +} + +function sanitizeMessage(message: unknown): string { + const raw = message instanceof Error ? message.message : String(message); + return redactSensitiveText(raw).replace(/\s+/g, " ").trim(); +} + +function createIdleBridgeAuthRefreshState(): OnboardingBridgeAuthRefreshState { + return { + phase: "idle", + strategy: null, + startedAt: null, + completedAt: null, + error: null, + }; +} + +function resolveOnboardingLockReason( + requiredSatisfied: boolean, + bridgeAuthRefresh: OnboardingBridgeAuthRefreshState, +): OnboardingLockReason | null { + if (!requiredSatisfied) { + return "required_setup"; + } + if (bridgeAuthRefresh.phase === "pending") { + return "bridge_refresh_pending"; + } + if (bridgeAuthRefresh.phase === "failed") { + return "bridge_refresh_failed"; + } + return null; +} + +function hasStoredCredentialValue(authStorage: AuthStorageInstance, providerId: string): boolean { + return authStorage.getCredentialsForProvider(providerId).some((credential) => { + if (credential.type === "oauth") return true; + return typeof credential.key === "string" && credential.key.trim().length > 0; + }); +} + +function resolveCredentialSource( + authStorage: AuthStorageInstance, + providerId: string, + getEnvApiKeyFn: GetEnvApiKeyFn, +): OnboardingCredentialSource | null { + if (hasStoredCredentialValue(authStorage, providerId)) { + return "auth_file"; + } + if (getEnvApiKeyFn(providerId)) { + return "environment"; + } + if (authStorage.hasAuth(providerId)) { + return "runtime"; + } + return null; +} + +function extractErrorDetail(payload: unknown): string | null { + if (!payload) return null; + if (typeof payload === "string") return payload; + if (typeof payload !== "object") return null; + + const record = payload as Record; + const candidates = [record.message, record.error, record.detail, record.error_description]; + for (const candidate of candidates) { + if (typeof candidate === "string" && candidate.trim().length > 0) { + return candidate; + } + const nested = extractErrorDetail(candidate); + if (nested) return nested; + } + return null; +} + +async function parseFailureMessage(providerId: string, response: Response): Promise { + let detail = ""; + + try { + const contentType = response.headers.get("content-type") || ""; + if (contentType.includes("application/json")) { + const payload = await response.json(); + detail = extractErrorDetail(payload) ?? JSON.stringify(payload); + } else { + detail = await response.text(); + } + } catch { + detail = ""; + } + + const sanitizedDetail = sanitizeMessage(detail); + return sanitizedDetail + ? `${providerId} validation failed (${response.status}): ${sanitizedDetail}` + : `${providerId} validation failed (${response.status})`; +} + +async function validateBearerRequest( + fetchImpl: typeof fetch, + providerId: string, + url: string, + apiKey: string, + extraHeaders: Record = {}, +): Promise { + try { + const response = await fetchImpl(url, { + headers: { + Authorization: `Bearer ${apiKey}`, + ...extraHeaders, + }, + signal: AbortSignal.timeout(15_000), + }); + + if (!response.ok) { + return { ok: false, message: await parseFailureMessage(providerId, response) }; + } + + return { ok: true, message: `${providerId} credentials validated` }; + } catch (error) { + return { ok: false, message: `${providerId} validation failed: ${sanitizeMessage(error)}` }; + } +} + +async function validateGoogleApiKey(fetchImpl: typeof fetch, apiKey: string): Promise { + try { + const url = new URL("https://generativelanguage.googleapis.com/v1beta/models"); + url.searchParams.set("key", apiKey); + const response = await fetchImpl(url, { signal: AbortSignal.timeout(15_000) }); + if (!response.ok) { + return { ok: false, message: await parseFailureMessage("google", response) }; + } + return { ok: true, message: "google credentials validated" }; + } catch (error) { + return { ok: false, message: `google validation failed: ${sanitizeMessage(error)}` }; + } +} + +async function validateAnthropicApiKey(fetchImpl: typeof fetch, apiKey: string): Promise { + try { + const response = await fetchImpl("https://api.anthropic.com/v1/models", { + headers: { + "x-api-key": apiKey, + "anthropic-version": "2023-06-01", + }, + signal: AbortSignal.timeout(15_000), + }); + + if (!response.ok) { + return { ok: false, message: await parseFailureMessage("anthropic", response) }; + } + + return { ok: true, message: "anthropic credentials validated" }; + } catch (error) { + return { ok: false, message: `anthropic validation failed: ${sanitizeMessage(error)}` }; + } +} + +async function defaultValidateApiKey( + providerId: string, + apiKey: string, + fetchImpl: typeof fetch, +): Promise { + switch (providerId) { + case "anthropic": + return await validateAnthropicApiKey(fetchImpl, apiKey); + case "openai": + return await validateBearerRequest(fetchImpl, providerId, "https://api.openai.com/v1/models", apiKey); + case "google": + return await validateGoogleApiKey(fetchImpl, apiKey); + case "groq": + return await validateBearerRequest(fetchImpl, providerId, "https://api.groq.com/openai/v1/models", apiKey); + case "xai": + return await validateBearerRequest(fetchImpl, providerId, "https://api.x.ai/v1/models", apiKey); + case "openrouter": + return await validateBearerRequest(fetchImpl, providerId, "https://openrouter.ai/api/v1/models", apiKey, { + "HTTP-Referer": "https://localhost", + "X-Title": "GSD onboarding", + }); + case "mistral": + return await validateBearerRequest(fetchImpl, providerId, "https://api.mistral.ai/v1/models", apiKey); + default: + return { ok: false, message: `${providerId} does not support API-key validation via onboarding` }; + } +} + +function resolveRuntimeTestValidateApiKey(env: NodeJS.ProcessEnv): OnboardingServiceDeps["validateApiKey"] | undefined { + if (env.GSD_WEB_TEST_FAKE_API_KEY_VALIDATION !== "1") { + return undefined; + } + + return async (providerId: string, apiKey: string) => { + const providerLabel = REQUIRED_PROVIDER_CATALOG.find((entry) => entry.id === providerId)?.label ?? providerId; + const candidate = apiKey.trim().toLowerCase(); + if (!candidate || candidate.includes("invalid") || candidate.includes("reject") || candidate.includes("fail")) { + return { + ok: false, + message: `${providerLabel} rejected the supplied key`, + }; + } + + return { + ok: true, + message: `${providerLabel} credentials validated`, + }; + }; +} + +function getOnboardingDeps(): OnboardingServiceDeps { + return { + env: process.env, + authPath: authFilePath, + fetch, + now: () => new Date(), + createFlowId: () => randomUUID(), + validateApiKey: resolveRuntimeTestValidateApiKey(process.env), + refreshBridgeAuth: onboardingBridgeAuthRefresher ?? undefined, + ...(onboardingServiceOverrides ?? {}), + }; +} + +export class OnboardingService { + private readonly deps: OnboardingServiceDeps; + private authStorage: AuthStorageInstance | null = null; + private lastValidation: OnboardingValidationResult | null = null; + private activeFlow: ProviderFlowRuntime | null = null; + private bridgeAuthRefresh: OnboardingBridgeAuthRefreshState = createIdleBridgeAuthRefreshState(); + + constructor(deps: OnboardingServiceDeps) { + this.deps = deps; + } + + async getState(): Promise { + return this.buildState(); + } + + async validateAndSaveApiKey(providerId: string, apiKey: string): Promise { + const provider = REQUIRED_PROVIDER_CATALOG.find((entry) => entry.id === providerId); + if (!provider) { + throw new Error(`Unknown onboarding provider: ${providerId}`); + } + if (!provider.supportsApiKey) { + throw new Error(`${providerId} must be configured with browser sign-in`); + } + + const trimmedKey = apiKey.trim(); + if (!trimmedKey) { + throw new Error("API key is required"); + } + + const validateApiKey = + this.deps.validateApiKey ?? + (async (candidateProviderId: string, candidateApiKey: string) => + await defaultValidateApiKey(candidateProviderId, candidateApiKey, this.deps.fetch ?? fetch)); + + const validation = await validateApiKey(providerId, trimmedKey); + const checkedAt = nowIso(this.deps.now ?? (() => new Date())); + + if (!validation.ok) { + this.lastValidation = { + status: "failed", + providerId, + method: "api_key", + checkedAt, + message: sanitizeMessage(validation.message), + persisted: false, + }; + return await this.buildState(); + } + + const authStorage = await this.getAuthStorage(); + authStorage.reload(); + authStorage.set(providerId, { type: "api_key", key: trimmedKey }); + this.lastValidation = { + status: "succeeded", + providerId, + method: "api_key", + checkedAt, + message: sanitizeMessage(validation.message || `${providerId} credentials validated`), + persisted: true, + }; + await this.refreshBridgeAuth(); + + return await this.buildState(); + } + + async startProviderFlow(providerId: string): Promise { + const authStorage = await this.getAuthStorage(); + authStorage.reload(); + + const oauthProvider = authStorage.getOAuthProviders().find((provider) => provider.id === providerId); + if (!oauthProvider) { + throw new Error(`OAuth provider not available for onboarding: ${providerId}`); + } + + if (this.activeFlow && ["running", "awaiting_browser_auth", "awaiting_input"].includes(this.activeFlow.state.status)) { + this.cancelActiveFlow(); + } + + const runtime: ProviderFlowRuntime = { + state: { + flowId: (this.deps.createFlowId ?? (() => randomUUID()))(), + providerId, + providerLabel: oauthProvider.name, + status: "running", + updatedAt: nowIso(this.deps.now ?? (() => new Date())), + auth: null, + prompt: null, + progress: [], + error: null, + }, + awaitingInput: null, + abortController: new AbortController(), + }; + + this.activeFlow = runtime; + void this.runOAuthFlow(runtime, oauthProvider, authStorage); + return await this.buildState(); + } + + async submitProviderFlowInput(flowId: string, input: string): Promise { + const runtime = this.activeFlow; + if (!runtime || runtime.state.flowId !== flowId) { + throw new Error(`Unknown onboarding flow: ${flowId}`); + } + if (!runtime.awaitingInput) { + throw new Error(`Onboarding flow ${flowId} is not waiting for input`); + } + + const resolveInput = runtime.awaitingInput; + runtime.awaitingInput = null; + runtime.state.prompt = null; + runtime.state.status = "running"; + runtime.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + resolveInput(input); + + return await this.buildState(); + } + + async cancelProviderFlow(flowId: string): Promise { + const runtime = this.activeFlow; + if (!runtime || runtime.state.flowId !== flowId) { + throw new Error(`Unknown onboarding flow: ${flowId}`); + } + + this.cancelActiveFlow(); + return await this.buildState(); + } + + async logoutProvider(providerId: string): Promise { + const authStorage = await this.getAuthStorage(); + authStorage.reload(); + + const currentState = await this.buildState(); + const requestedProviderId = providerId.trim(); + const resolvedProviderId = + requestedProviderId || + currentState.required.satisfiedBy?.providerId || + currentState.required.providers.find((provider) => provider.configured)?.id; + + if (!resolvedProviderId) { + throw new Error("No configured provider is available to log out"); + } + + const providerState = currentState.required.providers.find((provider) => provider.id === resolvedProviderId); + const providerLabel = providerState?.label ?? resolvedProviderId; + + if (!providerState?.configured) { + throw new Error(`${providerLabel} is not configured in this workspace`); + } + + if (providerState.configuredVia !== "auth_file") { + throw new Error(`${providerLabel} is configured via ${providerState.configuredVia} and cannot be logged out from the browser surface`); + } + + if ( + this.activeFlow && + this.activeFlow.state.providerId === resolvedProviderId && + ["running", "awaiting_browser_auth", "awaiting_input"].includes(this.activeFlow.state.status) + ) { + this.cancelActiveFlow(); + } + + authStorage.logout(resolvedProviderId); + this.lastValidation = null; + await this.refreshBridgeAuth(); + return await this.buildState(); + } + + private async refreshBridgeAuth(): Promise { + const refreshBridgeAuth = this.deps.refreshBridgeAuth; + if (!refreshBridgeAuth) { + this.bridgeAuthRefresh = createIdleBridgeAuthRefreshState(); + return; + } + + const startedAt = nowIso(this.deps.now ?? (() => new Date())); + this.bridgeAuthRefresh = { + phase: "pending", + strategy: "restart", + startedAt, + completedAt: null, + error: null, + }; + + try { + await refreshBridgeAuth(); + this.bridgeAuthRefresh = { + phase: "succeeded", + strategy: "restart", + startedAt, + completedAt: nowIso(this.deps.now ?? (() => new Date())), + error: null, + }; + } catch (error) { + this.bridgeAuthRefresh = { + phase: "failed", + strategy: "restart", + startedAt, + completedAt: nowIso(this.deps.now ?? (() => new Date())), + error: sanitizeMessage(error), + }; + } + } + + private async getAuthStorage(): Promise { + if (!this.authStorage) { + if (this.deps.authStorage) { + this.authStorage = this.deps.authStorage; + } else if (this.deps.createAuthStorage) { + this.authStorage = await this.deps.createAuthStorage(this.deps.authPath ?? authFilePath); + } else { + this.authStorage = createOnboardingAuthStorage(this.deps.authPath ?? authFilePath); + } + } + return this.authStorage; + } + + private buildOptionalSectionState(authStorage: AuthStorageInstance): OnboardingOptionalSectionState[] { + const env = this.deps.env ?? process.env; + + return OPTIONAL_SECTION_CATALOG.map((section) => { + const configuredItems = section.providers + .filter((provider) => { + const envConfigured = provider.envVar ? typeof env[provider.envVar] === "string" && env[provider.envVar]!.trim().length > 0 : false; + const storedConfigured = hasStoredCredentialValue(authStorage, provider.id); + return envConfigured || storedConfigured; + }) + .map((provider) => provider.label); + + return { + id: section.id, + label: section.label, + blocking: false, + skippable: true, + configured: configuredItems.length > 0, + configuredItems, + }; + }); + } + + private buildProviderState( + authStorage: AuthStorageInstance, + getEnvApiKeyFn: GetEnvApiKeyFn, + ): OnboardingProviderState[] { + const oauthProviders = new Map(authStorage.getOAuthProviders().map((provider) => [provider.id, provider])); + + return REQUIRED_PROVIDER_CATALOG.map((provider) => { + const oauthProvider = oauthProviders.get(provider.id); + const configuredVia = resolveCredentialSource(authStorage, provider.id, getEnvApiKeyFn); + return { + id: provider.id, + label: oauthProvider?.name ?? provider.label, + required: true, + recommended: Boolean(provider.recommended), + configured: configuredVia !== null, + configuredVia, + supports: { + apiKey: provider.supportsApiKey, + oauth: provider.supportsOAuth, + oauthAvailable: provider.supportsOAuth ? Boolean(oauthProvider) : false, + usesCallbackServer: Boolean(oauthProvider?.usesCallbackServer), + }, + }; + }); + } + + private async buildState(): Promise { + const authStorage = await this.getAuthStorage(); + const getEnvApiKeyFn = this.deps.getEnvApiKey ?? getEnvApiKey; + authStorage.reload(); + + const providers = this.buildProviderState(authStorage, getEnvApiKeyFn); + const satisfiedByProvider = providers.find((provider) => provider.configured) ?? null; + const optionalSections = this.buildOptionalSectionState(authStorage); + const lockReason = resolveOnboardingLockReason(Boolean(satisfiedByProvider), this.bridgeAuthRefresh); + + return { + status: lockReason ? "blocked" : "ready", + locked: lockReason !== null, + lockReason, + required: { + blocking: true, + skippable: false, + satisfied: Boolean(satisfiedByProvider), + satisfiedBy: satisfiedByProvider + ? { + providerId: satisfiedByProvider.id, + source: satisfiedByProvider.configuredVia ?? "runtime", + } + : null, + providers, + }, + optional: { + blocking: false, + skippable: true, + sections: optionalSections, + }, + lastValidation: this.lastValidation ? { ...this.lastValidation } : null, + activeFlow: this.activeFlow ? structuredClone(this.activeFlow.state) : null, + bridgeAuthRefresh: { ...this.bridgeAuthRefresh }, + }; + } + + private cancelActiveFlow(): void { + if (!this.activeFlow) return; + this.activeFlow.abortController.abort(); + if (this.activeFlow.awaitingInput) { + this.activeFlow.awaitingInput(""); + this.activeFlow.awaitingInput = null; + } + this.activeFlow.state.status = "cancelled"; + this.activeFlow.state.prompt = null; + this.activeFlow.state.error = null; + this.activeFlow.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + } + + private async runOAuthFlow( + runtime: ProviderFlowRuntime, + provider: OAuthProviderInterface, + authStorage: AuthStorageInstance, + ): Promise { + try { + await authStorage.login(provider.id, { + onAuth: (info) => { + runtime.state.auth = info; + runtime.state.status = "awaiting_browser_auth"; + runtime.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + }, + onPrompt: async (prompt) => await this.waitForFlowInput(runtime, "text", prompt), + onProgress: (message) => { + runtime.state.progress = [...runtime.state.progress, sanitizeMessage(message)].slice(-20); + if (runtime.state.status !== "awaiting_input") { + runtime.state.status = "running"; + } + runtime.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + }, + onManualCodeInput: async () => + await this.waitForFlowInput(runtime, "manual_code", { + message: "Paste the redirect URL from your browser:", + placeholder: "http://localhost:...", + }), + signal: runtime.abortController.signal, + }); + + runtime.state.status = "succeeded"; + runtime.state.prompt = null; + runtime.state.error = null; + runtime.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + this.lastValidation = { + status: "succeeded", + providerId: provider.id, + method: "oauth", + checkedAt: runtime.state.updatedAt, + message: `${provider.id} sign-in complete`, + persisted: true, + }; + await this.refreshBridgeAuth(); + } catch (error) { + const cancelled = runtime.abortController.signal.aborted; + runtime.state.status = cancelled ? "cancelled" : "failed"; + runtime.state.prompt = null; + runtime.state.error = cancelled ? null : sanitizeMessage(error); + runtime.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + if (!cancelled) { + this.lastValidation = { + status: "failed", + providerId: provider.id, + method: "oauth", + checkedAt: runtime.state.updatedAt, + message: runtime.state.error || `${provider.id} sign-in failed`, + persisted: false, + }; + } + } + } + + private async waitForFlowInput( + runtime: ProviderFlowRuntime, + kind: OnboardingFlowPromptState["kind"], + prompt: OAuthPrompt, + ): Promise { + runtime.state.status = "awaiting_input"; + runtime.state.prompt = { + kind, + message: prompt.message, + placeholder: prompt.placeholder, + allowEmpty: prompt.allowEmpty, + }; + runtime.state.updatedAt = nowIso(this.deps.now ?? (() => new Date())); + + return await new Promise((resolve) => { + runtime.awaitingInput = resolve; + }); + } +} + +export function getOnboardingService(): OnboardingService { + if (!onboardingServiceSingleton) { + onboardingServiceSingleton = new OnboardingService(getOnboardingDeps()); + } + return onboardingServiceSingleton; +} + +export async function collectOnboardingState(): Promise { + return await getOnboardingService().getState(); +} + +export function registerOnboardingBridgeAuthRefresher(refresher: BridgeAuthRefresher | null): void { + onboardingBridgeAuthRefresher = refresher; + onboardingServiceSingleton = null; +} + +export function configureOnboardingServiceForTests(overrides: Partial | null): void { + onboardingServiceOverrides = overrides; + onboardingServiceSingleton = null; +} + +export function resetOnboardingServiceForTests(): void { + onboardingServiceOverrides = null; + onboardingServiceSingleton = null; +} diff --git a/src/web/project-discovery-service.ts b/src/web/project-discovery-service.ts new file mode 100644 index 000000000..c2b450e6c --- /dev/null +++ b/src/web/project-discovery-service.ts @@ -0,0 +1,108 @@ +import { readdirSync, readFileSync, statSync } from "node:fs"; +import { join } from "node:path"; +import type { ProjectDetectionKind, ProjectDetectionSignals } from "./bridge-service.ts"; +import { detectProjectKind } from "./bridge-service.ts"; + +// ─── Project Discovery ───────────────────────────────────────────────────── + +export interface ProjectProgressInfo { + activeMilestone: string | null; + activeSlice: string | null; + phase: string | null; + milestonesCompleted: number; + milestonesTotal: number; +} + +export interface ProjectMetadata { + name: string; // directory name + path: string; // absolute path + kind: ProjectDetectionKind; + signals: ProjectDetectionSignals; + lastModified: number; // mtime epoch ms + progress?: ProjectProgressInfo | null; +} + +/** Excluded directory names when scanning a dev root. */ +const EXCLUDED_DIRS = new Set(["node_modules", ".git"]); + +/** + * Parse a project's `.gsd/STATE.md` for active milestone, slice, phase, + * and milestone completion tally. + * + * Returns `null` when the file is missing or unreadable. + * Individual fields return `null` when the corresponding line isn't found. + */ +export function readProjectProgress(projectPath: string): ProjectProgressInfo | null { + try { + const content = readFileSync(join(projectPath, ".gsd", "STATE.md"), "utf-8"); + const lines = content.split("\n"); + + let activeMilestone: string | null = null; + let activeSlice: string | null = null; + let phase: string | null = null; + let milestonesCompleted = 0; + let milestonesTotal = 0; + + for (const line of lines) { + const trimmed = line.trim(); + + if (trimmed.startsWith("**Active Milestone:**")) { + activeMilestone = trimmed.replace("**Active Milestone:**", "").trim() || null; + } else if (trimmed.startsWith("**Active Slice:**")) { + activeSlice = trimmed.replace("**Active Slice:**", "").trim() || null; + } else if (trimmed.startsWith("**Phase:**")) { + phase = trimmed.replace("**Phase:**", "").trim() || null; + } else if (trimmed.startsWith("- ✅")) { + milestonesCompleted++; + milestonesTotal++; + } else if (trimmed.startsWith("- 🔄")) { + milestonesTotal++; + } + } + + return { activeMilestone, activeSlice, phase, milestonesCompleted, milestonesTotal }; + } catch { + // File missing or unreadable — no progress available + return null; + } +} + +/** + * Scan one directory level under `devRootPath` and return metadata for each + * discovered project directory. Hidden dirs (starting with `.`), `node_modules`, + * and `.git` are excluded. + * + * Returns an empty array if `devRootPath` doesn't exist or isn't readable. + * Results are sorted alphabetically by name. + */ +export function discoverProjects(devRootPath: string, includeProgress?: boolean): ProjectMetadata[] { + try { + const entries = readdirSync(devRootPath, { withFileTypes: true }); + const projects: ProjectMetadata[] = []; + + for (const entry of entries) { + if (!entry.isDirectory()) continue; + if (entry.name.startsWith(".")) continue; + if (EXCLUDED_DIRS.has(entry.name)) continue; + + const fullPath = join(devRootPath, entry.name); + const { kind, signals } = detectProjectKind(fullPath); + const stat = statSync(fullPath); + + projects.push({ + name: entry.name, + path: fullPath, + kind, + signals, + lastModified: stat.mtimeMs, + ...(includeProgress ? { progress: readProjectProgress(fullPath) } : {}), + }); + } + + projects.sort((a, b) => a.name.localeCompare(b.name)); + return projects; + } catch { + // devRootPath doesn't exist or isn't readable + return []; + } +} diff --git a/src/web/recovery-diagnostics-service.ts b/src/web/recovery-diagnostics-service.ts new file mode 100644 index 000000000..39ed245aa --- /dev/null +++ b/src/web/recovery-diagnostics-service.ts @@ -0,0 +1,695 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join, resolve } from "node:path" +import { pathToFileURL } from "node:url" + +import { + collectCurrentProjectOnboardingState, + collectSelectiveLiveStatePayload, + resolveBridgeRuntimeConfig, +} from "./bridge-service.ts" +import type { + WorkspaceRecoveryBrowserAction, + WorkspaceRecoveryCodeSummary, + WorkspaceRecoveryCommandSuggestion, + WorkspaceRecoveryDiagnostics, + WorkspaceRecoveryIssueDigest, + WorkspaceRecoverySummaryTone, +} from "../../web/lib/command-surface-contract.ts" + +const RECOVERY_DIAGNOSTICS_MAX_BUFFER = 1024 * 1024 + +type RecoveryDiagnosticsSeverity = "info" | "warning" | "error" + +interface RecoveryDiagnosticsServiceOptions { + execPath?: string + env?: NodeJS.ProcessEnv + existsSync?: (path: string) => boolean +} + +interface RecoveryDiagnosticsChildIssue { + code: string + severity: RecoveryDiagnosticsSeverity + scope: string + message: string + file?: string + suggestion?: string + unitId?: string +} + +interface RecoveryDiagnosticsChildPayload { + doctor: { + scope: string | null + total: number + errors: number + warnings: number + infos: number + fixable: number + codes: Array<{ code: string; count: number }> + topIssues: RecoveryDiagnosticsChildIssue[] + } + interruptedRun: { + available: boolean + detected: boolean + label: string + detail: string + unit: { + type: string + id: string + } | null + counts: { + toolCalls: number + filesWritten: number + commandsRun: number + errors: number + } + gitChangesDetected: boolean + lastError: string | null + } +} + +function redactSensitiveText(value: string): string { + return value + .replace(/sk-[A-Za-z0-9_-]{6,}/g, "[redacted]") + .replace(/xox[baprs]-[A-Za-z0-9-]+/g, "[redacted]") + .replace(/Bearer\s+[^\s]+/gi, "Bearer [redacted]") + .replace(/([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET)["'=:\s]+)([^\s,;"']+)/gi, "$1[redacted]") +} + +function sanitizeText(value: unknown): string { + const raw = value instanceof Error ? value.message : String(value ?? "") + return redactSensitiveText(raw).replace(/\s+/g, " ").trim() +} + +function humanizeCode(code: string): string { + return code.replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase()) +} + +function activeScopeFromWorkspace(workspace: Awaited>["workspace"]): string | null { + if (!workspace?.active.milestoneId) return null + if (workspace.active.taskId && workspace.active.sliceId) { + return `${workspace.active.milestoneId}/${workspace.active.sliceId}/${workspace.active.taskId}` + } + if (workspace.active.sliceId) { + return `${workspace.active.milestoneId}/${workspace.active.sliceId}` + } + return workspace.active.milestoneId +} + +function recoveryUnitFromWorkspace(workspace: Awaited>["workspace"]): { type: string; id: string } | null { + const scope = activeScopeFromWorkspace(workspace) + if (!scope) return null + + if (workspace?.active.taskId) { + return { type: "execute-task", id: scope } + } + if (workspace?.active.sliceId) { + return { type: "execute-slice", id: scope } + } + return { type: "execute-milestone", id: scope } +} + +function selectRecoverySessionFile( + activeSessionFile: string | null | undefined, + resumableSessions: Array<{ id: string; path: string }>, +): string | null { + if (!activeSessionFile) { + return resumableSessions[0]?.path ?? null + } + + const normalizedActiveSessionFile = resolve(activeSessionFile) + const matchingCurrentProjectSession = resumableSessions.find((session) => resolve(session.path) === normalizedActiveSessionFile) + if (matchingCurrentProjectSession) { + return matchingCurrentProjectSession.path + } + + return resumableSessions[0]?.path ?? activeSessionFile +} + +function selectRecoverySessionId( + activeSessionId: string | null | undefined, + sessionFile: string | null, + resumableSessions: Array<{ id: string; path: string }>, +): string | null { + if (!sessionFile) return activeSessionId ?? null + + const normalizedSessionFile = resolve(sessionFile) + return resumableSessions.find((session) => resolve(session.path) === normalizedSessionFile)?.id ?? activeSessionId ?? null +} + +function summarizeSeverityCounts(issues: Array<{ severity: RecoveryDiagnosticsSeverity }>): { + errors: number + warnings: number + infos: number +} { + return issues.reduce( + (counts, issue) => ({ + errors: counts.errors + Number(issue.severity === "error"), + warnings: counts.warnings + Number(issue.severity === "warning"), + infos: counts.infos + Number(issue.severity === "info"), + }), + { errors: 0, warnings: 0, infos: 0 }, + ) +} + +function summarizeCodes( + issues: Array<{ code: string; severity: RecoveryDiagnosticsSeverity }>, +): WorkspaceRecoveryCodeSummary[] { + const map = new Map() + const severityRank: Record = { info: 0, warning: 1, error: 2 } + + for (const issue of issues) { + const current = map.get(issue.code) + if (!current) { + map.set(issue.code, { count: 1, severity: issue.severity }) + continue + } + + map.set(issue.code, { + count: current.count + 1, + severity: severityRank[issue.severity] > severityRank[current.severity] ? issue.severity : current.severity, + }) + } + + return [...map.entries()] + .map(([code, data]) => ({ + code, + count: data.count, + label: humanizeCode(code), + severity: data.severity, + })) + .sort((left, right) => right.count - left.count || left.code.localeCompare(right.code)) +} + +function sanitizeIssueDigest(issue: RecoveryDiagnosticsChildIssue): WorkspaceRecoveryIssueDigest { + return { + code: issue.code, + severity: issue.severity, + scope: issue.scope, + message: sanitizeText(issue.message), + file: issue.file, + suggestion: issue.suggestion ? sanitizeText(issue.suggestion) : undefined, + unitId: issue.unitId, + } +} + +function buildCommandSuggestions( + activeScope: string | null, + phase: string | undefined, + validationCount: number, +): WorkspaceRecoveryCommandSuggestion[] { + const suggestions = new Map() + const add = (command: string, label: string) => { + if (!suggestions.has(command)) { + suggestions.set(command, { command, label }) + } + } + + if (phase === "planning") add("/gsd", "Open GSD planning") + if (phase === "executing" || phase === "summarizing") add("/gsd auto", "Resume GSD auto mode") + if (activeScope) add(`/gsd doctor ${activeScope}`, "Inspect scoped doctor report") + if (activeScope) add(`/gsd doctor fix ${activeScope}`, "Apply scoped doctor fixes") + if (validationCount > 0 && activeScope) add(`/gsd doctor audit ${activeScope}`, "Audit validation diagnostics") + add("/gsd status", "Check current-project status") + + return [...suggestions.values()] +} + +function buildBrowserActions(options: { + hasSessions: boolean + retryActive: boolean + autoRetryEnabled: boolean + bridgeFailure: boolean + compactionActive: boolean + authAttentionNeeded: boolean +}): WorkspaceRecoveryBrowserAction[] { + const actions = new Map() + const add = (action: WorkspaceRecoveryBrowserAction) => { + actions.set(action.id, action) + } + + add({ + id: "refresh_diagnostics", + label: "Refresh diagnostics", + detail: "Reload the on-demand recovery route without refreshing the entire workspace.", + emphasis: "primary", + }) + add({ + id: "refresh_workspace", + label: "Refresh workspace", + detail: "Run one soft workspace refresh so the browser re-syncs boot, bridge, and onboarding state.", + }) + + if (options.retryActive || options.autoRetryEnabled || options.bridgeFailure || options.compactionActive) { + add({ + id: "open_retry_controls", + label: "Open retry controls", + detail: "Inspect or change live retry and compaction controls on the authoritative browser surface.", + }) + } + + if (options.hasSessions) { + add({ + id: "open_resume_controls", + label: "Open resume controls", + detail: "Switch to another current-project session if recovery should continue elsewhere.", + }) + } + + if (options.authAttentionNeeded) { + add({ + id: "open_auth_controls", + label: "Open auth controls", + detail: "Inspect provider setup and bridge auth refresh failures from the shared browser surface.", + emphasis: "danger", + }) + } + + return [...actions.values()] +} + +function resolveSummary(options: { + status: WorkspaceRecoveryDiagnostics["status"] + validationCount: number + validationErrors: number + doctorTotal: number + doctorErrors: number + retryAttempt: number + retryInProgress: boolean + compactionActive: boolean + currentUnitId: string | null + lastFailurePhase: string | null + bridgeFailureMessage: string | null + authFailureMessage: string | null + interruptedRunDetected: boolean + interruptedRunDetail: string +}): { tone: WorkspaceRecoverySummaryTone; label: string; detail: string } { + if (options.authFailureMessage) { + return { + tone: "danger", + label: "Bridge auth refresh failed", + detail: options.authFailureMessage, + } + } + + if (options.bridgeFailureMessage) { + return { + tone: "danger", + label: options.lastFailurePhase ? `Bridge recovery failed during ${options.lastFailurePhase}` : "Bridge recovery failed", + detail: options.bridgeFailureMessage, + } + } + + if (options.doctorErrors > 0 || options.validationErrors > 0) { + return { + tone: "danger", + label: `Recovery blockers detected (${options.doctorErrors + options.validationErrors})`, + detail: `Doctor and validation surfaced blocking issues for ${options.currentUnitId ?? "the current project"}.`, + } + } + + if (options.retryInProgress) { + return { + tone: "warning", + label: `Retry attempt ${Math.max(1, options.retryAttempt)} is active`, + detail: "The bridge is retrying work right now; inspect retry controls before issuing more recovery actions.", + } + } + + if (options.compactionActive) { + return { + tone: "warning", + label: "Compaction is active", + detail: "The live session is compacting context before work continues.", + } + } + + if (options.validationCount > 0 || options.doctorTotal > 0) { + return { + tone: "warning", + label: `Recovery diagnostics found ${options.validationCount + options.doctorTotal} actionable issue${options.validationCount + options.doctorTotal === 1 ? "" : "s"}`, + detail: `Review the doctor and validation sections below before resuming work on ${options.currentUnitId ?? "the current project"}.`, + } + } + + if (options.interruptedRunDetected) { + return { + tone: "warning", + label: "Interrupted-run evidence is available", + detail: options.interruptedRunDetail, + } + } + + if (options.status === "unavailable") { + return { + tone: "healthy", + label: "Recovery diagnostics unavailable", + detail: "No current-project recovery evidence has been captured yet. Start or resume a session to populate diagnostics.", + } + } + + return { + tone: "healthy", + label: "Recovery diagnostics healthy", + detail: "No bridge, validation, doctor, or interrupted-run recovery issues are currently active.", + } +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +function resolveDoctorModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "doctor.ts") +} + +function resolveSessionForensicsModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "session-forensics.ts") +} + +async function collectRecoveryDiagnosticsChildPayload( + packageRoot: string, + basePath: string, + scope: string | null, + unit: { type: string; id: string } | null, + sessionFile: string | null, + options: RecoveryDiagnosticsServiceOptions, +): Promise { + const env = options.env ?? process.env + const checkExists = options.existsSync ?? existsSync + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const doctorModulePath = resolveDoctorModulePath(packageRoot) + const sessionForensicsModulePath = resolveSessionForensicsModulePath(packageRoot) + + if (!checkExists(resolveTsLoader) || !checkExists(doctorModulePath) || !checkExists(sessionForensicsModulePath)) { + throw new Error( + `recovery diagnostics providers not found; checked=${resolveTsLoader},${doctorModulePath},${sessionForensicsModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + 'const doctor = await import(pathToFileURL(process.env.GSD_RECOVERY_DOCTOR_MODULE).href);', + 'const forensics = await import(pathToFileURL(process.env.GSD_RECOVERY_FORENSICS_MODULE).href);', + 'const basePath = process.env.GSD_RECOVERY_BASE;', + 'const scope = process.env.GSD_RECOVERY_SCOPE || undefined;', + 'const unitType = process.env.GSD_RECOVERY_UNIT_TYPE || "execute-project";', + 'const unitId = process.env.GSD_RECOVERY_UNIT_ID || "project";', + 'const sessionFile = process.env.GSD_RECOVERY_SESSION_FILE || undefined;', + 'const activityDir = process.env.GSD_RECOVERY_ACTIVITY_DIR || undefined;', + 'const report = await doctor.runGSDDoctor(basePath, { fix: false, scope, fixLevel: "task" });', + 'const summary = doctor.summarizeDoctorIssues(report.issues);', + 'const briefing = forensics.synthesizeCrashRecovery(basePath, unitType, unitId, sessionFile, activityDir);', + 'const trace = briefing?.trace;', + 'const available = Boolean(sessionFile || trace?.toolCallCount || briefing?.gitChanges);', + 'const detected = Boolean((trace?.toolCallCount ?? 0) > 0 || (trace?.errors?.length ?? 0) > 0 || (trace?.commandsRun?.length ?? 0) > 0 || (trace?.filesWritten?.length ?? 0) > 0 || briefing?.gitChanges);', + 'const interruptedRun = available', + ' ? detected', + ' ? {', + ' available: true,', + ' detected: true,', + ' label: "Interrupted-run recovery available",', + ' detail: "Recent session forensics captured unfinished work or errors that may need resume or retry follow-up.",', + ' unit: { type: briefing?.unitType ?? unitType, id: briefing?.unitId ?? unitId },', + ' counts: {', + ' toolCalls: trace?.toolCallCount ?? 0,', + ' filesWritten: trace?.filesWritten?.length ?? 0,', + ' commandsRun: trace?.commandsRun?.length ?? 0,', + ' errors: trace?.errors?.length ?? 0,', + ' },', + ' gitChangesDetected: Boolean(briefing?.gitChanges),', + ' lastError: trace?.errors?.at(-1) ?? null,', + ' }', + ' : {', + ' available: true,', + ' detected: false,', + ' label: "Session forensics available",', + ' detail: "A current-project session was inspected, but it did not show unfinished tool or error activity.",', + ' unit: { type: briefing?.unitType ?? unitType, id: briefing?.unitId ?? unitId },', + ' counts: {', + ' toolCalls: trace?.toolCallCount ?? 0,', + ' filesWritten: trace?.filesWritten?.length ?? 0,', + ' commandsRun: trace?.commandsRun?.length ?? 0,', + ' errors: trace?.errors?.length ?? 0,', + ' },', + ' gitChangesDetected: Boolean(briefing?.gitChanges),', + ' lastError: trace?.errors?.at(-1) ?? null,', + ' }', + ' : {', + ' available: false,', + ' detected: false,', + ' label: "No interrupted-run evidence",', + ' detail: "No current-project session or activity log is available for interrupted-run forensics yet.",', + ' unit: null,', + ' counts: { toolCalls: 0, filesWritten: 0, commandsRun: 0, errors: 0 },', + ' gitChangesDetected: false,', + ' lastError: null,', + ' };', + 'process.stdout.write(JSON.stringify({', + ' doctor: {', + ' scope: scope ?? null,', + ' total: summary.total,', + ' errors: summary.errors,', + ' warnings: summary.warnings,', + ' infos: summary.infos,', + ' fixable: summary.fixable,', + ' codes: summary.byCode,', + ' topIssues: report.issues.slice(0, 6).map((issue) => ({', + ' code: issue.code,', + ' severity: issue.severity,', + ' scope: issue.scope,', + ' message: issue.message,', + ' file: issue.file,', + ' unitId: issue.unitId,', + ' })),', + ' },', + ' interruptedRun,', + '}));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + options.execPath ?? process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...env, + GSD_RECOVERY_BASE: basePath, + GSD_RECOVERY_SCOPE: scope ?? "", + GSD_RECOVERY_UNIT_TYPE: unit?.type ?? "execute-project", + GSD_RECOVERY_UNIT_ID: unit?.id ?? "project", + GSD_RECOVERY_SESSION_FILE: sessionFile ?? "", + GSD_RECOVERY_ACTIVITY_DIR: join(basePath, ".gsd", "activity"), + GSD_RECOVERY_DOCTOR_MODULE: doctorModulePath, + GSD_RECOVERY_FORENSICS_MODULE: sessionForensicsModulePath, + }, + maxBuffer: RECOVERY_DIAGNOSTICS_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`recovery diagnostics subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as RecoveryDiagnosticsChildPayload) + } catch (parseError) { + reject( + new Error( + `recovery diagnostics subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} + +export async function collectCurrentProjectRecoveryDiagnostics( + options: RecoveryDiagnosticsServiceOptions = {}, + projectCwdOverride?: string, +): Promise { + const env = options.env ?? process.env + const config = resolveBridgeRuntimeConfig(options.env, projectCwdOverride) + const [{ bridge: bridgeSnapshot, workspace, resumableSessions: resumableSessionsRaw }, onboarding] = await Promise.all([ + collectSelectiveLiveStatePayload(["workspace", "resumable_sessions"], projectCwdOverride), + collectCurrentProjectOnboardingState(projectCwdOverride), + ]) + const resumableSessions = resumableSessionsRaw ?? [] + + const activeScope = activeScopeFromWorkspace(workspace) + const unit = recoveryUnitFromWorkspace(workspace) + const sessionFile = selectRecoverySessionFile(bridgeSnapshot.activeSessionFile, resumableSessions) + const recoverySessionId = selectRecoverySessionId(bridgeSnapshot.activeSessionId, sessionFile, resumableSessions) + const recoveryChild = await collectRecoveryDiagnosticsChildPayload( + config.packageRoot, + config.projectCwd, + activeScope, + unit, + sessionFile, + options, + ) + + const validationIssues = (workspace?.validationIssues ?? []).map((issue) => { + const typedIssue = issue as { + ruleId?: string + severity?: RecoveryDiagnosticsSeverity + scope?: string + message?: string + file?: string + suggestion?: string + } + return { + code: typedIssue.ruleId ?? "unknown_validation_issue", + severity: (typedIssue.severity ?? "warning") as RecoveryDiagnosticsSeverity, + scope: typedIssue.scope ?? "workspace", + message: sanitizeText(typedIssue.message ?? "Validation issue"), + file: typedIssue.file, + suggestion: typedIssue.suggestion ? sanitizeText(typedIssue.suggestion) : undefined, + } satisfies WorkspaceRecoveryIssueDigest + }) + const validationCounts = summarizeSeverityCounts(validationIssues) + const validationCodes = summarizeCodes(validationIssues) + + const doctorTopIssues = recoveryChild.doctor.topIssues.map(sanitizeIssueDigest) + const interruptedRun = { + ...recoveryChild.interruptedRun, + label: sanitizeText(recoveryChild.interruptedRun.label), + detail: sanitizeText(recoveryChild.interruptedRun.detail), + lastError: recoveryChild.interruptedRun.lastError ? sanitizeText(recoveryChild.interruptedRun.lastError) : null, + } + + const bridgeFailure = bridgeSnapshot.lastError + ? { + message: sanitizeText(bridgeSnapshot.lastError.message), + phase: bridgeSnapshot.lastError.phase, + at: bridgeSnapshot.lastError.at, + commandType: bridgeSnapshot.lastError.commandType ?? null, + afterSessionAttachment: bridgeSnapshot.lastError.afterSessionAttachment, + } + : null + + const authRefreshPhase = onboarding.bridgeAuthRefresh.phase + const authRefreshError = onboarding.bridgeAuthRefresh.error ? sanitizeText(onboarding.bridgeAuthRefresh.error) : null + const authRefreshLabel = + authRefreshPhase === "failed" + ? "Bridge auth refresh failed" + : authRefreshPhase === "pending" + ? "Bridge auth refresh pending" + : authRefreshPhase === "succeeded" + ? "Bridge auth refresh succeeded" + : "Bridge auth refresh idle" + + const status: WorkspaceRecoveryDiagnostics["status"] = + bridgeFailure || + authRefreshPhase === "failed" || + validationIssues.length > 0 || + recoveryChild.doctor.total > 0 || + interruptedRun.available || + resumableSessions.length > 0 || + Boolean(bridgeSnapshot.sessionState?.retryInProgress) || + Boolean(bridgeSnapshot.sessionState?.isCompacting) + ? "ready" + : "unavailable" + + const currentUnitId = unit?.id ?? activeScope + const summary = resolveSummary({ + status, + validationCount: validationIssues.length, + validationErrors: validationCounts.errors, + doctorTotal: recoveryChild.doctor.total, + doctorErrors: recoveryChild.doctor.errors, + retryAttempt: bridgeSnapshot.sessionState?.retryAttempt ?? 0, + retryInProgress: Boolean(bridgeSnapshot.sessionState?.retryInProgress), + compactionActive: Boolean(bridgeSnapshot.sessionState?.isCompacting), + currentUnitId: currentUnitId ?? null, + lastFailurePhase: authRefreshPhase === "failed" ? "bridge_auth_refresh" : bridgeFailure?.phase ?? null, + bridgeFailureMessage: bridgeFailure?.message ?? null, + authFailureMessage: authRefreshPhase === "failed" ? authRefreshError : null, + interruptedRunDetected: interruptedRun.detected, + interruptedRunDetail: interruptedRun.detail, + }) + + return { + status, + loadedAt: new Date().toISOString(), + project: { + cwd: config.projectCwd, + activeScope, + activeSessionPath: sessionFile, + activeSessionId: recoverySessionId, + }, + summary: { + tone: summary.tone, + label: summary.label, + detail: summary.detail, + validationCount: validationIssues.length, + doctorIssueCount: recoveryChild.doctor.total, + lastFailurePhase: authRefreshPhase === "failed" ? "bridge_auth_refresh" : bridgeFailure?.phase ?? null, + currentUnitId: currentUnitId ?? null, + retryAttempt: bridgeSnapshot.sessionState?.retryAttempt ?? 0, + retryInProgress: Boolean(bridgeSnapshot.sessionState?.retryInProgress), + compactionActive: Boolean(bridgeSnapshot.sessionState?.isCompacting), + }, + bridge: { + phase: bridgeSnapshot.phase, + retry: { + enabled: Boolean(bridgeSnapshot.sessionState?.autoRetryEnabled), + inProgress: Boolean(bridgeSnapshot.sessionState?.retryInProgress), + attempt: bridgeSnapshot.sessionState?.retryAttempt ?? 0, + label: bridgeSnapshot.sessionState?.retryInProgress + ? `Attempt ${Math.max(1, bridgeSnapshot.sessionState?.retryAttempt ?? 0)}` + : bridgeSnapshot.sessionState?.autoRetryEnabled + ? "Enabled" + : "Disabled", + }, + compaction: { + active: Boolean(bridgeSnapshot.sessionState?.isCompacting), + label: bridgeSnapshot.sessionState?.isCompacting ? "Compaction active" : "Compaction idle", + }, + lastFailure: bridgeFailure, + authRefresh: { + phase: authRefreshPhase, + error: authRefreshError, + label: authRefreshLabel, + }, + }, + validation: { + total: validationIssues.length, + bySeverity: validationCounts, + codes: validationCodes, + topIssues: validationIssues.slice(0, 6), + }, + doctor: { + scope: recoveryChild.doctor.scope, + total: recoveryChild.doctor.total, + errors: recoveryChild.doctor.errors, + warnings: recoveryChild.doctor.warnings, + infos: recoveryChild.doctor.infos, + fixable: recoveryChild.doctor.fixable, + codes: recoveryChild.doctor.codes, + topIssues: doctorTopIssues, + }, + interruptedRun, + actions: { + browser: buildBrowserActions({ + hasSessions: resumableSessions.length > 0, + retryActive: Boolean(bridgeSnapshot.sessionState?.retryInProgress), + autoRetryEnabled: Boolean(bridgeSnapshot.sessionState?.autoRetryEnabled), + bridgeFailure: Boolean(bridgeFailure), + compactionActive: Boolean(bridgeSnapshot.sessionState?.isCompacting), + authAttentionNeeded: + onboarding.locked || authRefreshPhase === "failed" || onboarding.lastValidation?.status === "failed", + }), + commands: buildCommandSuggestions(activeScope, workspace?.active.phase, validationIssues.length), + }, + } +} diff --git a/src/web/settings-service.ts b/src/web/settings-service.ts new file mode 100644 index 000000000..3af7a78ad --- /dev/null +++ b/src/web/settings-service.ts @@ -0,0 +1,149 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { SettingsData } from "../../web/lib/settings-types.ts" + +const SETTINGS_MAX_BUFFER = 2 * 1024 * 1024 + +function resolveModulePath(packageRoot: string, moduleName: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", moduleName) +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Loads settings data via a child process. Calls upstream extension modules + * for preferences, routing config, budget allocation, routing history, and + * project totals, then combines results into a single SettingsData payload. + * + * Uses the same child-process pattern as forensics-service.ts — Turbopack + * cannot resolve the .js extension imports these upstream modules use, so + * execFile + resolve-ts.mjs is required. + */ +export async function collectSettingsData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const prefsPath = resolveModulePath(packageRoot, "preferences.ts") + const routerPath = resolveModulePath(packageRoot, "model-router.ts") + const budgetPath = resolveModulePath(packageRoot, "context-budget.ts") + const historyPath = resolveModulePath(packageRoot, "routing-history.ts") + const metricsPath = resolveModulePath(packageRoot, "metrics.ts") + + const requiredPaths = [resolveTsLoader, prefsPath, routerPath, budgetPath, historyPath, metricsPath] + for (const p of requiredPaths) { + if (!existsSync(p)) { + throw new Error(`settings data provider not found; missing=${p}`) + } + } + + // The child script loads all upstream modules, calls the 5 data functions, + // and writes a combined JSON payload to stdout. + const script = [ + 'const { pathToFileURL } = await import("node:url");', + 'const prefsMod = await import(pathToFileURL(process.env.GSD_SETTINGS_PREFS_MODULE).href);', + 'const routerMod = await import(pathToFileURL(process.env.GSD_SETTINGS_ROUTER_MODULE).href);', + 'const budgetMod = await import(pathToFileURL(process.env.GSD_SETTINGS_BUDGET_MODULE).href);', + 'const historyMod = await import(pathToFileURL(process.env.GSD_SETTINGS_HISTORY_MODULE).href);', + 'const metricsMod = await import(pathToFileURL(process.env.GSD_SETTINGS_METRICS_MODULE).href);', + + // 1. Effective preferences (may be null if no preferences files exist) + 'const loaded = prefsMod.loadEffectiveGSDPreferences();', + 'let preferences = null;', + 'if (loaded) {', + ' const p = loaded.preferences;', + ' preferences = {', + ' mode: p.mode,', + ' budgetCeiling: p.budget_ceiling,', + ' budgetEnforcement: p.budget_enforcement,', + ' tokenProfile: p.token_profile,', + ' dynamicRouting: p.dynamic_routing,', + ' customInstructions: p.custom_instructions,', + ' alwaysUseSkills: p.always_use_skills,', + ' preferSkills: p.prefer_skills,', + ' avoidSkills: p.avoid_skills,', + ' autoSupervisor: p.auto_supervisor ? {', + ' enabled: true,', + ' softTimeoutMinutes: p.auto_supervisor.soft_timeout_minutes,', + ' } : undefined,', + ' uatDispatch: p.uat_dispatch,', + ' autoVisualize: p.auto_visualize,', + ' remoteQuestions: p.remote_questions ? {', + ' channel: p.remote_questions.channel,', + ' channelId: String(p.remote_questions.channel_id),', + ' timeoutMinutes: p.remote_questions.timeout_minutes,', + ' pollIntervalSeconds: p.remote_questions.poll_interval_seconds,', + ' } : undefined,', + ' scope: loaded.scope,', + ' path: loaded.path,', + ' warnings: loaded.warnings,', + ' };', + '}', + + // 2. Resolved dynamic routing config (always returns a config with defaults) + 'const routingConfig = prefsMod.resolveDynamicRoutingConfig();', + + // 3. Budget allocation (use 200K as default context window) + 'const budgetAllocation = budgetMod.computeBudgets(200000);', + + // 4. Routing history (must init before reading) + 'historyMod.initRoutingHistory(process.env.GSD_SETTINGS_BASE);', + 'const routingHistory = historyMod.getRoutingHistory();', + + // 5. Project totals (null if no metrics ledger exists) + 'const ledger = metricsMod.loadLedgerFromDisk(process.env.GSD_SETTINGS_BASE);', + 'const projectTotals = ledger ? metricsMod.getProjectTotals(ledger.units) : null;', + + // Write combined payload + 'process.stdout.write(JSON.stringify({ preferences, routingConfig, budgetAllocation, routingHistory, projectTotals }));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + GSD_SETTINGS_PREFS_MODULE: prefsPath, + GSD_SETTINGS_ROUTER_MODULE: routerPath, + GSD_SETTINGS_BUDGET_MODULE: budgetPath, + GSD_SETTINGS_HISTORY_MODULE: historyPath, + GSD_SETTINGS_METRICS_MODULE: metricsPath, + GSD_SETTINGS_BASE: projectCwd, + }, + maxBuffer: SETTINGS_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`settings data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as SettingsData) + } catch (parseError) { + reject( + new Error( + `settings data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/skill-health-service.ts b/src/web/skill-health-service.ts new file mode 100644 index 000000000..72ae3802b --- /dev/null +++ b/src/web/skill-health-service.ts @@ -0,0 +1,83 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { SkillHealthReport } from "../../web/lib/diagnostics-types.ts" + +const SKILL_HEALTH_MAX_BUFFER = 2 * 1024 * 1024 +const SKILL_HEALTH_MODULE_ENV = "GSD_SKILL_HEALTH_MODULE" + +function resolveSkillHealthModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "skill-health.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Loads skill health report via a child process. + * SkillHealthReport is already all plain objects — no Map/Set conversion needed. + */ +export async function collectSkillHealthData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const skillHealthModulePath = resolveSkillHealthModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(skillHealthModulePath)) { + throw new Error( + `skill-health data provider not found; checked=${resolveTsLoader},${skillHealthModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${SKILL_HEALTH_MODULE_ENV}).href);`, + 'const basePath = process.env.GSD_SKILL_HEALTH_BASE;', + 'const report = mod.generateSkillHealthReport(basePath);', + 'process.stdout.write(JSON.stringify(report));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [SKILL_HEALTH_MODULE_ENV]: skillHealthModulePath, + GSD_SKILL_HEALTH_BASE: projectCwd, + }, + maxBuffer: SKILL_HEALTH_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`skill-health subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as SkillHealthReport) + } catch (parseError) { + reject( + new Error( + `skill-health subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/undo-service.ts b/src/web/undo-service.ts new file mode 100644 index 000000000..42a953051 --- /dev/null +++ b/src/web/undo-service.ts @@ -0,0 +1,218 @@ +import { execFile } from "node:child_process" +import { existsSync, readFileSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" +import type { UndoInfo, UndoResult } from "../../web/lib/remaining-command-types.ts" + +const UNDO_MAX_BUFFER = 2 * 1024 * 1024 +const UNDO_MODULE_ENV = "GSD_UNDO_MODULE" +const PATHS_MODULE_ENV = "GSD_PATHS_MODULE" + +function resolveUndoModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "undo.ts") +} + +function resolvePathsModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "paths.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Collects information about the last completed unit for display in the undo panel. + * Reads completed-units.json directly (plain JSON, no child process needed) + * and scans the activity log directory for associated commits. + */ +export async function collectUndoInfo(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { projectCwd } = config + + const gsdDir = join(projectCwd, ".gsd") + const completedPath = join(gsdDir, "completed-units.json") + + const empty: UndoInfo = { + lastUnitType: null, + lastUnitId: null, + lastUnitKey: null, + completedCount: 0, + commits: [], + } + + if (!existsSync(completedPath)) return empty + + let entries: Array<{ type: string; id: string; key?: string }> + try { + entries = JSON.parse(readFileSync(completedPath, "utf-8")) + } catch { + return empty + } + + if (!Array.isArray(entries) || entries.length === 0) return empty + + const last = entries[entries.length - 1] + const unitType = last.type ?? null + const unitId = last.id ?? null + const unitKey = last.key ?? (unitType && unitId ? `${unitType}:${unitId}` : null) + + // Scan activity log for associated commits + const activityDir = join(gsdDir, "activity") + let commits: string[] = [] + if (unitType && unitId && existsSync(activityDir)) { + try { + const { readdirSync } = await import("node:fs") + const safeUnitId = unitId.replace(/\//g, "-") + const files = readdirSync(activityDir) + .filter((f: string) => f.includes(unitType) && f.includes(safeUnitId) && f.endsWith(".jsonl")) + .sort() + .reverse() + + if (files.length > 0) { + const content = readFileSync(join(activityDir, files[0]), "utf-8") + const shaRegex = /\b[0-9a-f]{7,40}\b/g + const commitSet = new Set() + for (const line of content.split("\n")) { + if (!line.trim()) continue + try { + const entry = JSON.parse(line) + if (entry?.message?.content) { + const blocks = Array.isArray(entry.message.content) ? entry.message.content : [] + for (const block of blocks) { + if (block.type === "tool_result" && typeof block.content === "string") { + const matches = block.content.match(shaRegex) + if (matches) { + for (const sha of matches) { + if (sha.length >= 7 && !commitSet.has(sha)) { + commitSet.add(sha) + commits.push(sha) + } + } + } + } + } + } + } catch { + // Skip malformed lines + } + } + } + } catch { + // Activity log scanning is best-effort + } + } + + return { + lastUnitType: unitType, + lastUnitId: unitId, + lastUnitKey: unitKey, + completedCount: entries.length, + commits, + } +} + +/** + * Executes the undo operation via a child process. + * Child-process pattern required because undo calls upstream functions that + * modify git state, completed-units.json, and plan files — all of which + * use .ts imports that need the resolve-ts.mjs loader. + */ +export async function executeUndo(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const undoModulePath = resolveUndoModulePath(packageRoot) + const pathsModulePath = resolvePathsModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(undoModulePath) || !existsSync(pathsModulePath)) { + throw new Error( + `undo service modules not found; checked=${resolveTsLoader},${undoModulePath},${pathsModulePath}`, + ) + } + + const script = [ + 'const { pathToFileURL } = await import("node:url");', + 'const { existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync } = await import("node:fs");', + 'const { join } = await import("node:path");', + `const undoMod = await import(pathToFileURL(process.env.${UNDO_MODULE_ENV}).href);`, + `const pathsMod = await import(pathToFileURL(process.env.${PATHS_MODULE_ENV}).href);`, + 'const basePath = process.env.GSD_UNDO_BASE;', + 'const gsdDir = pathsMod.gsdRoot(basePath);', + 'const completedPath = join(gsdDir, "completed-units.json");', + 'if (!existsSync(completedPath)) { process.stdout.write(JSON.stringify({ success: false, message: "No completed units to undo" })); process.exit(0); }', + 'let entries;', + 'try { entries = JSON.parse(readFileSync(completedPath, "utf-8")); } catch { process.stdout.write(JSON.stringify({ success: false, message: "Could not parse completed-units.json" })); process.exit(0); }', + 'if (!Array.isArray(entries) || entries.length === 0) { process.stdout.write(JSON.stringify({ success: false, message: "No completed units to undo" })); process.exit(0); }', + 'const last = entries[entries.length - 1];', + 'const unitType = last.type;', + 'const unitId = last.id;', + 'const parts = unitId ? unitId.split("/") : [];', + // Uncheck task in plan if execute-task + 'let planUpdated = false;', + 'if (unitType === "execute-task" && parts.length === 3) { const [mid, sid, tid] = parts; planUpdated = undoMod.uncheckTaskInPlan(basePath, mid, sid, tid); }', + // Find and revert commits + 'let commitsReverted = 0;', + 'const activityDir = join(gsdDir, "activity");', + 'if (existsSync(activityDir)) {', + ' const commits = undoMod.findCommitsForUnit(activityDir, unitType, unitId);', + ' if (commits.length > 0) {', + ' const { execSync } = await import("node:child_process");', + ' for (const sha of commits.reverse()) {', + ' try { execSync(`git revert --no-commit ${sha}`, { cwd: basePath, stdio: "pipe" }); commitsReverted++; }', + ' catch { try { execSync("git revert --abort", { cwd: basePath, stdio: "pipe" }); } catch {} break; }', + ' }', + ' }', + '}', + // Remove the entry from completed-units.json + 'entries.pop();', + 'writeFileSync(completedPath, JSON.stringify(entries, null, 2), "utf-8");', + 'const results = [`Undone: ${unitType} (${unitId})`];', + 'results.push(" - Removed from completed-units.json");', + 'if (planUpdated) results.push(" - Unchecked task in PLAN");', + 'if (commitsReverted > 0) { results.push(` - Reverted ${commitsReverted} commit(s) (staged, not committed)`); }', + 'process.stdout.write(JSON.stringify({ success: true, message: results.join("\\n") }));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [UNDO_MODULE_ENV]: undoModulePath, + [PATHS_MODULE_ENV]: pathsModulePath, + GSD_UNDO_BASE: projectCwd, + }, + maxBuffer: UNDO_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`undo subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as UndoResult) + } catch (parseError) { + reject( + new Error( + `undo subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/update-service.ts b/src/web/update-service.ts new file mode 100644 index 000000000..1ec44aa1a --- /dev/null +++ b/src/web/update-service.ts @@ -0,0 +1,105 @@ +import { spawn } from "node:child_process" +import { compareSemver } from "../update-check.ts" + +const NPM_PACKAGE_NAME = "gsd-pi" +const REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest` +const FETCH_TIMEOUT_MS = 5000 + +// --- Version check --- + +interface UpdateCheckResult { + currentVersion: string + latestVersion: string + updateAvailable: boolean +} + +export async function checkForUpdate(): Promise { + const currentVersion = process.env.GSD_VERSION || "0.0.0" + + const controller = new AbortController() + const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS) + + try { + const res = await fetch(REGISTRY_URL, { signal: controller.signal }) + clearTimeout(timeout) + + if (!res.ok) { + return { currentVersion, latestVersion: currentVersion, updateAvailable: false } + } + + const data = (await res.json()) as { version?: string } + const latestVersion = data.version || currentVersion + + return { + currentVersion, + latestVersion, + updateAvailable: compareSemver(latestVersion, currentVersion) > 0, + } + } catch { + // Network error or timeout — report no update available + return { currentVersion, latestVersion: currentVersion, updateAvailable: false } + } finally { + clearTimeout(timeout) + } +} + +// --- Update state singleton --- + +interface UpdateState { + status: "idle" | "running" | "success" | "error" + error?: string + targetVersion?: string +} + +let updateState: UpdateState = { status: "idle" } + +export function getUpdateStatus(): UpdateState { + return { ...updateState } +} + +/** + * Triggers an async global npm install of gsd-pi@latest. + * Returns `true` if the update was started, `false` if one is already running. + * The child process runs in the background; poll `getUpdateStatus()` for progress. + */ +export function triggerUpdate(targetVersion?: string): boolean { + if (updateState.status === "running") { + return false + } + + updateState = { status: "running", targetVersion } + + const child = spawn("npm", ["install", "-g", "gsd-pi@latest"], { + stdio: ["ignore", "ignore", "pipe"], + // Detach so the child process is not killed if the parent exits + detached: false, + }) + + let stderr = "" + + child.stderr?.on("data", (chunk: Buffer) => { + stderr += chunk.toString() + }) + + child.on("close", (code) => { + if (code === 0) { + updateState = { status: "success", targetVersion } + } else { + updateState = { + status: "error", + error: stderr.trim() || `npm install exited with code ${code}`, + targetVersion, + } + } + }) + + child.on("error", (err) => { + updateState = { + status: "error", + error: err.message, + targetVersion, + } + }) + + return true +} diff --git a/src/web/visualizer-service.ts b/src/web/visualizer-service.ts new file mode 100644 index 000000000..ded38626e --- /dev/null +++ b/src/web/visualizer-service.ts @@ -0,0 +1,120 @@ +import { execFile } from "node:child_process" +import { existsSync } from "node:fs" +import { join } from "node:path" +import { pathToFileURL } from "node:url" + +import { resolveBridgeRuntimeConfig } from "./bridge-service.ts" + +const VISUALIZER_MAX_BUFFER = 2 * 1024 * 1024 +const VISUALIZER_MODULE_ENV = "GSD_VISUALIZER_MODULE" + +/** + * Browser-safe version of VisualizerData where Map fields are converted to + * plain Records so JSON.stringify serializes them correctly. + * + * Without this conversion, `JSON.stringify(new Map([["M001", 0]]))` produces + * `"{}"` — silently losing all critical-path slack data. + */ +export interface SerializedVisualizerData { + milestones: unknown[] + phase: string + totals: unknown | null + byPhase: unknown[] + bySlice: unknown[] + byModel: unknown[] + units: unknown[] + criticalPath: { + milestonePath: string[] + slicePath: string[] + milestoneSlack: Record + sliceSlack: Record + } + remainingSliceCount: number + agentActivity: unknown | null + changelog: unknown +} + +function resolveVisualizerModulePath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "visualizer-data.ts") +} + +function resolveTsLoaderPath(packageRoot: string): string { + return join(packageRoot, "src", "resources", "extensions", "gsd", "tests", "resolve-ts.mjs") +} + +/** + * Loads visualizer data from the current project's filesystem via a child + * process (required because upstream .ts files use Node ESM .js import + * extensions that Turbopack cannot resolve). Converts Map fields to Records + * for safe JSON serialization. + */ +export async function collectVisualizerData(projectCwdOverride?: string): Promise { + const config = resolveBridgeRuntimeConfig(undefined, projectCwdOverride) + const { packageRoot, projectCwd } = config + + const resolveTsLoader = resolveTsLoaderPath(packageRoot) + const visualizerModulePath = resolveVisualizerModulePath(packageRoot) + + if (!existsSync(resolveTsLoader) || !existsSync(visualizerModulePath)) { + throw new Error( + `visualizer data provider not found; checked=${resolveTsLoader},${visualizerModulePath}`, + ) + } + + // The child script loads the upstream module, calls loadVisualizerData(), + // converts Map fields to Records, and writes JSON to stdout. + const script = [ + 'const { pathToFileURL } = await import("node:url");', + `const mod = await import(pathToFileURL(process.env.${VISUALIZER_MODULE_ENV}).href);`, + `const data = await mod.loadVisualizerData(process.env.GSD_VISUALIZER_BASE);`, + 'const result = {', + ' ...data,', + ' criticalPath: {', + ' milestonePath: data.criticalPath.milestonePath,', + ' slicePath: data.criticalPath.slicePath,', + ' milestoneSlack: Object.fromEntries(data.criticalPath.milestoneSlack),', + ' sliceSlack: Object.fromEntries(data.criticalPath.sliceSlack),', + ' },', + '};', + 'process.stdout.write(JSON.stringify(result));', + ].join(" ") + + return await new Promise((resolveResult, reject) => { + execFile( + process.execPath, + [ + "--import", + pathToFileURL(resolveTsLoader).href, + "--experimental-strip-types", + "--input-type=module", + "--eval", + script, + ], + { + cwd: packageRoot, + env: { + ...process.env, + [VISUALIZER_MODULE_ENV]: visualizerModulePath, + GSD_VISUALIZER_BASE: projectCwd, + }, + maxBuffer: VISUALIZER_MAX_BUFFER, + }, + (error, stdout, stderr) => { + if (error) { + reject(new Error(`visualizer data subprocess failed: ${stderr || error.message}`)) + return + } + + try { + resolveResult(JSON.parse(stdout) as SerializedVisualizerData) + } catch (parseError) { + reject( + new Error( + `visualizer data subprocess returned invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, + ), + ) + } + }, + ) + }) +} diff --git a/src/web/web-auth-storage.ts b/src/web/web-auth-storage.ts new file mode 100644 index 000000000..732ac8b44 --- /dev/null +++ b/src/web/web-auth-storage.ts @@ -0,0 +1,135 @@ +import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"; +import { dirname } from "node:path"; + +import { getEnvApiKey } from "../../packages/pi-ai/src/web-runtime-env-api-keys.ts"; +import { + getOAuthProvider, + getOAuthProviders, + type OAuthCredentials, + type OAuthLoginCallbacks, + type OAuthProviderInterface, +} from "../../packages/pi-ai/dist/oauth.js"; + +export type ApiKeyCredential = { + type: "api_key"; + key: string; +}; + +export type OAuthCredential = { + type: "oauth"; +} & OAuthCredentials; + +export type StoredCredential = ApiKeyCredential | OAuthCredential; +export type StoredCredentialEntry = StoredCredential | StoredCredential[]; +export type StoredCredentialData = Record; + +export interface OnboardingAuthStorage { + reload(): void; + set(provider: string, credential: StoredCredential): void; + getCredentialsForProvider(provider: string): StoredCredential[]; + hasAuth(provider: string): boolean; + getOAuthProviders(): OAuthProviderInterface[]; + login(providerId: string, callbacks: OAuthLoginCallbacks): Promise; + logout(providerId: string): void; +} + +function ensureAuthFile(authPath: string): void { + const parentDir = dirname(authPath); + if (!existsSync(parentDir)) { + mkdirSync(parentDir, { recursive: true, mode: 0o700 }); + } + if (!existsSync(authPath)) { + writeFileSync(authPath, "{}", "utf-8"); + chmodSync(authPath, 0o600); + } +} + +function parseStoredCredentialData(content: string | undefined): StoredCredentialData { + if (!content || !content.trim()) { + return {}; + } + + try { + const parsed = JSON.parse(content) as StoredCredentialData; + return typeof parsed === "object" && parsed !== null ? parsed : {}; + } catch { + return {}; + } +} + +export class FileOnboardingAuthStorage implements OnboardingAuthStorage { + private data: StoredCredentialData = {}; + private readonly authPath: string; + + constructor(authPath: string) { + this.authPath = authPath; + this.reload(); + } + + reload(): void { + ensureAuthFile(this.authPath); + this.data = parseStoredCredentialData(readFileSync(this.authPath, "utf-8")); + } + + getCredentialsForProvider(provider: string): StoredCredential[] { + const entry = this.data[provider]; + if (!entry) return []; + return Array.isArray(entry) ? entry : [entry]; + } + + set(provider: string, credential: StoredCredential): void { + const existing = this.getCredentialsForProvider(provider); + const next = + credential.type === "api_key" + ? this.mergeApiKeyCredentials(existing, credential) + : this.mergeOAuthCredential(existing, credential); + + this.data[provider] = next.length === 1 ? next[0] : next; + writeFileSync(this.authPath, JSON.stringify(this.data, null, 2), "utf-8"); + chmodSync(this.authPath, 0o600); + } + + hasAuth(provider: string): boolean { + if (this.getCredentialsForProvider(provider).length > 0) { + return true; + } + return Boolean(getEnvApiKey(provider)); + } + + getOAuthProviders(): OAuthProviderInterface[] { + return getOAuthProviders(); + } + + async login(providerId: string, callbacks: OAuthLoginCallbacks): Promise { + const provider = getOAuthProvider(providerId); + if (!provider) { + throw new Error(`Unknown OAuth provider: ${providerId}`); + } + + const credentials = await provider.login(callbacks); + this.set(providerId, { type: "oauth", ...credentials }); + } + + logout(providerId: string): void { + delete this.data[providerId]; + writeFileSync(this.authPath, JSON.stringify(this.data, null, 2), "utf-8"); + chmodSync(this.authPath, 0o600); + } + + private mergeApiKeyCredentials(existing: StoredCredential[], credential: ApiKeyCredential): StoredCredential[] { + const alreadyStored = existing.some((entry) => entry.type === "api_key" && entry.key === credential.key); + if (alreadyStored) { + return existing; + } + return [...existing, credential]; + } + + private mergeOAuthCredential(existing: StoredCredential[], credential: OAuthCredential): StoredCredential[] { + const apiKeys = existing.filter((entry) => entry.type === "api_key"); + return [...apiKeys, credential]; + } +} + +export function createOnboardingAuthStorage(authPath: string): OnboardingAuthStorage { + return new FileOnboardingAuthStorage(authPath); +} diff --git a/tsconfig.json b/tsconfig.json index 2ff21a444..a5b3fa704 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -11,5 +11,5 @@ "skipLibCheck": true }, "include": ["src"], - "exclude": ["src/resources", "src/tests"] + "exclude": ["src/resources", "src/tests", "src/web"] } diff --git a/web/.gitignore b/web/.gitignore new file mode 100644 index 000000000..e90f569ce --- /dev/null +++ b/web/.gitignore @@ -0,0 +1,17 @@ +# v0 sandbox internal files +__v0_runtime_loader.js +__v0_devtools.tsx +__v0_jsx-dev-runtime.ts +.npmrc +.snowflake/ +.v0-trash/ +.vercel/ +next.user-config.* + +# Environment variables +.env*.local + +# Common ignores +node_modules/ +.next/ +.DS_Store diff --git a/web/app/api/boot/route.ts b/web/app/api/boot/route.ts new file mode 100644 index 000000000..eb0c11681 --- /dev/null +++ b/web/app/api/boot/route.ts @@ -0,0 +1,38 @@ +import { collectBootPayload, resolveProjectCwd } from "../../../../src/web/bridge-service.ts"; +import { cancelShutdown } from "../../../lib/shutdown-gate"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function GET(request: Request): Promise { + // A boot request proves the client is alive — cancel any pending shutdown + // that was scheduled by pagehide during a page refresh. + cancelShutdown(); + + const projectCwd = resolveProjectCwd(request); + + // When no project is configured (no GSD_WEB_PROJECT_CWD env and no ?project param), + // return a minimal "no project" payload so the frontend can show the project picker. + if (!projectCwd) { + return Response.json({ + project: null, + workspace: null, + auto: null, + onboarding: { locked: false }, + onboardingNeeded: false, + resumableSessions: [], + bridge: null, + projectDetection: null, + }, { + headers: { "Cache-Control": "no-store" }, + }); + } + + const bootPayload = await collectBootPayload(projectCwd); + + return Response.json(bootPayload, { + headers: { + "Cache-Control": "no-store", + }, + }); +} diff --git a/web/app/api/bridge-terminal/input/route.ts b/web/app/api/bridge-terminal/input/route.ts new file mode 100644 index 000000000..73f1ca772 --- /dev/null +++ b/web/app/api/bridge-terminal/input/route.ts @@ -0,0 +1,29 @@ +import { getProjectBridgeServiceForCwd, requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function POST(request: Request): Promise { + let body: { data?: string }; + try { + body = await request.json(); + } catch { + return Response.json({ error: "Invalid JSON" }, { status: 400 }); + } + + if (typeof body.data !== "string") { + return Response.json({ error: "data must be a string" }, { status: 400 }); + } + + try { + const projectCwd = requireProjectCwd(request); + const bridge = getProjectBridgeServiceForCwd(projectCwd); + await bridge.sendTerminalInput(body.data); + return Response.json({ ok: true }); + } catch (error) { + return Response.json( + { error: error instanceof Error ? error.message : String(error) }, + { status: 503 }, + ); + } +} diff --git a/web/app/api/bridge-terminal/resize/route.ts b/web/app/api/bridge-terminal/resize/route.ts new file mode 100644 index 000000000..6aac5171e --- /dev/null +++ b/web/app/api/bridge-terminal/resize/route.ts @@ -0,0 +1,31 @@ +import { getProjectBridgeServiceForCwd, requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function POST(request: Request): Promise { + let body: { cols?: number; rows?: number }; + try { + body = await request.json(); + } catch { + return Response.json({ error: "Invalid JSON" }, { status: 400 }); + } + + const cols = body.cols; + const rows = body.rows; + if (typeof cols !== "number" || typeof rows !== "number" || cols < 1 || rows < 1) { + return Response.json({ error: "cols and rows must be positive numbers" }, { status: 400 }); + } + + try { + const projectCwd = requireProjectCwd(request); + const bridge = getProjectBridgeServiceForCwd(projectCwd); + await bridge.resizeTerminal(Math.floor(cols), Math.floor(rows)); + return Response.json({ ok: true }); + } catch (error) { + return Response.json( + { error: error instanceof Error ? error.message : String(error) }, + { status: 503 }, + ); + } +} diff --git a/web/app/api/bridge-terminal/stream/route.ts b/web/app/api/bridge-terminal/stream/route.ts new file mode 100644 index 000000000..32961361a --- /dev/null +++ b/web/app/api/bridge-terminal/stream/route.ts @@ -0,0 +1,89 @@ +import { getProjectBridgeServiceForCwd, requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +const encoder = new TextEncoder(); + +function encodeEvent(payload: unknown): Uint8Array { + return encoder.encode(`data: ${JSON.stringify(payload)}\n\n`); +} + +function parseDimension(value: string | null, fallback: number): number { + const parsed = Number.parseInt(value ?? "", 10); + return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; +} + +export async function GET(request: Request): Promise { + const projectCwd = requireProjectCwd(request); + const bridge = getProjectBridgeServiceForCwd(projectCwd); + const url = new URL(request.url); + const cols = parseDimension(url.searchParams.get("cols"), 120); + const rows = parseDimension(url.searchParams.get("rows"), 30); + + let unsubscribe: (() => void) | null = null; + let closed = false; + + const closeWith = (controller: ReadableStreamDefaultController) => { + if (closed) return; + closed = true; + unsubscribe?.(); + unsubscribe = null; + try { + controller.close(); + } catch { + // Already closed. + } + }; + + const stream = new ReadableStream({ + async start(controller) { + try { + await bridge.ensureStarted(); + } catch (error) { + controller.enqueue( + encodeEvent({ + type: "output", + data: `\u001b[31mFailed to start main bridge terminal: ${error instanceof Error ? error.message : String(error)}\u001b[0m\r\n`, + }), + ); + } + + unsubscribe = bridge.subscribeTerminal((data) => { + if (closed) return; + controller.enqueue(encodeEvent({ type: "output", data })); + }); + + controller.enqueue(encodeEvent({ type: "connected" })); + + try { + await bridge.resizeTerminal(cols, rows); + await bridge.redrawTerminal(); + } catch (error) { + controller.enqueue( + encodeEvent({ + type: "output", + data: `\u001b[31mFailed to attach to main bridge terminal: ${error instanceof Error ? error.message : String(error)}\u001b[0m\r\n`, + }), + ); + } + + request.signal.addEventListener("abort", () => closeWith(controller), { once: true }); + }, + cancel() { + if (closed) return; + closed = true; + unsubscribe?.(); + unsubscribe = null; + }, + }); + + return new Response(stream, { + headers: { + "Content-Type": "text/event-stream; charset=utf-8", + "Cache-Control": "no-cache, no-transform", + Connection: "keep-alive", + "X-Accel-Buffering": "no", + }, + }); +} diff --git a/web/app/api/browse-directories/route.ts b/web/app/api/browse-directories/route.ts new file mode 100644 index 000000000..14e33585b --- /dev/null +++ b/web/app/api/browse-directories/route.ts @@ -0,0 +1,107 @@ +import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"; +import { resolve, dirname, join } from "node:path"; +import { homedir } from "node:os"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +/** + * Resolve the configured dev root from web preferences. + * Returns the devRoot path if set, otherwise the user's home directory. + */ +function getDevRoot(): string { + try { + const prefsPath = join(homedir(), ".gsd", "web-preferences.json"); + if (existsSync(prefsPath)) { + const prefs = JSON.parse(readFileSync(prefsPath, "utf-8")) as Record; + if (typeof prefs.devRoot === "string" && prefs.devRoot) { + return resolve(prefs.devRoot); + } + } + } catch { + // Fall through to default + } + return homedir(); +} + +/** + * GET /api/browse-directories?path=/some/path + * + * Returns the directory listing for the given path. + * Defaults to the configured devRoot (or home directory) if no path is given. + * Only returns directories (no files) for the folder picker use case. + * + * Security: Paths are restricted to the devRoot and its children. Requests + * for paths outside devRoot are rejected with 403 to prevent full filesystem + * enumeration. + */ +export async function GET(request: Request): Promise { + try { + const url = new URL(request.url); + const rawPath = url.searchParams.get("path"); + const devRoot = getDevRoot(); + const targetPath = rawPath ? resolve(rawPath) : devRoot; + + // Restrict browsing to devRoot and its subtree, or the home directory + // if no devRoot is configured. Navigating to the parent of devRoot is + // allowed (one level up) so the UI can show the devRoot in context, + // but nothing further. + const devRootParent = dirname(devRoot); + if (!targetPath.startsWith(devRoot) && targetPath !== devRootParent) { + return Response.json( + { error: "Path outside allowed scope" }, + { status: 403 }, + ); + } + + if (!existsSync(targetPath)) { + return Response.json( + { error: `Path does not exist: ${targetPath}` }, + { status: 404 }, + ); + } + + const stat = statSync(targetPath); + if (!stat.isDirectory()) { + return Response.json( + { error: `Not a directory: ${targetPath}` }, + { status: 400 }, + ); + } + + const parentPath = dirname(targetPath); + // Only offer the parent navigation if it's within the allowed scope + const parentAllowed = parentPath.startsWith(devRootParent) && parentPath !== targetPath; + const entries: Array<{ name: string; path: string }> = []; + + try { + const items = readdirSync(targetPath, { withFileTypes: true }); + for (const item of items) { + // Only directories, skip dotfiles and common non-project dirs + if (!item.isDirectory()) continue; + if (item.name.startsWith(".")) continue; + if (item.name === "node_modules") continue; + + entries.push({ + name: item.name, + path: resolve(targetPath, item.name), + }); + } + } catch { + // Permission denied or other read error — return empty entries + } + + entries.sort((a, b) => a.name.localeCompare(b.name)); + + return Response.json({ + current: targetPath, + parent: parentAllowed ? parentPath : null, + entries, + }); + } catch (err) { + return Response.json( + { error: `Browse failed: ${err instanceof Error ? err.message : String(err)}` }, + { status: 500 }, + ); + } +} diff --git a/web/app/api/captures/route.ts b/web/app/api/captures/route.ts new file mode 100644 index 000000000..ae0c895c3 --- /dev/null +++ b/web/app/api/captures/route.ts @@ -0,0 +1,121 @@ +import { collectCapturesData, resolveCaptureAction } from "../../../../src/web/captures-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" +import type { CaptureResolveRequest } from "../../../lib/knowledge-captures-types.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +const VALID_CLASSIFICATIONS = new Set([ + "quick-task", + "inject", + "defer", + "replan", + "note", +]) + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectCapturesData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} + +export async function POST(request: Request): Promise { + try { + let body: unknown + try { + body = await request.json() + } catch { + return Response.json( + { error: "Invalid JSON body" }, + { + status: 400, + headers: { "Cache-Control": "no-store" }, + }, + ) + } + + const validation = validateResolveRequest(body) + if (validation.error) { + return Response.json( + { error: validation.error }, + { + status: 400, + headers: { "Cache-Control": "no-store" }, + }, + ) + } + + const projectCwd = requireProjectCwd(request); + const result = await resolveCaptureAction(validation.value!, projectCwd) + return Response.json(result, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} + +function validateResolveRequest( + body: unknown, +): { value?: CaptureResolveRequest; error?: string } { + if (!body || typeof body !== "object") { + return { error: "Request body must be a JSON object" } + } + + const obj = body as Record + + if (typeof obj.captureId !== "string" || !obj.captureId.trim()) { + return { error: "Missing or invalid field: captureId (string required)" } + } + + if (typeof obj.classification !== "string" || !VALID_CLASSIFICATIONS.has(obj.classification)) { + return { + error: `Missing or invalid field: classification (must be one of: ${[...VALID_CLASSIFICATIONS].join(", ")})`, + } + } + + if (typeof obj.resolution !== "string" || !obj.resolution.trim()) { + return { error: "Missing or invalid field: resolution (non-empty string required)" } + } + + if (typeof obj.rationale !== "string" || !obj.rationale.trim()) { + return { error: "Missing or invalid field: rationale (non-empty string required)" } + } + + return { + value: { + captureId: obj.captureId.trim(), + classification: obj.classification as CaptureResolveRequest["classification"], + resolution: obj.resolution.trim(), + rationale: obj.rationale.trim(), + }, + } +} diff --git a/web/app/api/cleanup/route.ts b/web/app/api/cleanup/route.ts new file mode 100644 index 000000000..d5350071a --- /dev/null +++ b/web/app/api/cleanup/route.ts @@ -0,0 +1,61 @@ +import { collectCleanupData, executeCleanup } from "../../../../src/web/cleanup-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectCleanupData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} + +export async function POST(request: Request): Promise { + try { + let branches: string[] = [] + let snapshots: string[] = [] + try { + const body = await request.json() + branches = Array.isArray(body?.branches) ? body.branches : [] + snapshots = Array.isArray(body?.snapshots) ? body.snapshots : [] + } catch { + // No body or invalid JSON — empty arrays + } + + const projectCwd = requireProjectCwd(request); + const payload = await executeCleanup(branches, snapshots, projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/dev-mode/route.ts b/web/app/api/dev-mode/route.ts new file mode 100644 index 000000000..52a337d01 --- /dev/null +++ b/web/app/api/dev-mode/route.ts @@ -0,0 +1,25 @@ +import { existsSync } from "node:fs"; +import { join } from "node:path"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export function GET(): Response { + const hostKind = process.env.GSD_WEB_HOST_KIND ?? "unknown"; + const packageRoot = process.env.GSD_WEB_PACKAGE_ROOT ?? ""; + const isSourceDev = hostKind === "source-dev"; + + // When running via `npm run gsd:web` from the monorepo, the host resolves + // as packaged-standalone (because the build exists), but the source web/ + // directory is still present at the package root. A truly published package + // won't have web/app/ next to dist/. + const isMonorepoDev = + !isSourceDev && + packageRoot.length > 0 && + existsSync(join(packageRoot, "web", "app")); + + return Response.json( + { isDevMode: isSourceDev || isMonorepoDev }, + { headers: { "Cache-Control": "no-store" } }, + ); +} diff --git a/web/app/api/doctor/route.ts b/web/app/api/doctor/route.ts new file mode 100644 index 000000000..d865c3652 --- /dev/null +++ b/web/app/api/doctor/route.ts @@ -0,0 +1,60 @@ +import { collectDoctorData, applyDoctorFixes } from "../../../../src/web/doctor-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const url = new URL(request.url) + const scope = url.searchParams.get("scope") ?? undefined + const projectCwd = requireProjectCwd(request); + const payload = await collectDoctorData(scope, projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} + +export async function POST(request: Request): Promise { + try { + let scope: string | undefined + try { + const body = await request.json() + scope = body?.scope ?? undefined + } catch { + // No body or invalid JSON — scope stays undefined + } + const projectCwd = requireProjectCwd(request); + const payload = await applyDoctorFixes(scope, projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/export-data/route.ts b/web/app/api/export-data/route.ts new file mode 100644 index 000000000..ef4831e5f --- /dev/null +++ b/web/app/api/export-data/route.ts @@ -0,0 +1,33 @@ +import { collectExportData } from "../../../../src/web/export-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const url = new URL(request.url) + const formatParam = url.searchParams.get("format") + const format: "markdown" | "json" = + formatParam === "json" ? "json" : "markdown" + + const projectCwd = requireProjectCwd(request); + const payload = await collectExportData(format, projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/files/route.ts b/web/app/api/files/route.ts new file mode 100644 index 000000000..e744d942c --- /dev/null +++ b/web/app/api/files/route.ts @@ -0,0 +1,448 @@ +import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs"; +import { join, resolve, relative, dirname, basename } from "node:path"; + +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +const MAX_FILE_SIZE = 256 * 1024; // 256KB +const MAX_PROJECT_DEPTH = 6; + +/** Directories to skip when listing the project root tree */ +const PROJECT_SKIP_DIRS = new Set([ + "node_modules", + ".git", + ".next", + ".turbo", + ".vercel", + ".cache", + ".output", + "dist", + "build", + "coverage", + "__pycache__", + ".svelte-kit", + ".nuxt", + ".parcel-cache", +]); + +type RootMode = "gsd" | "project"; + +interface FileNode { + name: string; + type: "file" | "directory"; + children?: FileNode[]; +} + +function getGsdRoot(projectCwd: string): string { + return join(projectCwd, ".gsd"); +} + +function getRootForMode(mode: RootMode, projectCwd: string): string { + return mode === "project" ? projectCwd : getGsdRoot(projectCwd); +} + +/** + * Validate and resolve a requested path against the given root directory. + * Returns the resolved absolute path or null if the path is invalid. + */ +function resolveSecurePath(requestedPath: string, root: string): string | null { + if (requestedPath.startsWith("/") || requestedPath.startsWith("\\")) { + return null; + } + if (requestedPath.includes("..")) { + return null; + } + + const resolved = resolve(root, requestedPath); + const rel = relative(root, resolved); + if (rel.startsWith("..") || resolve(root, rel) !== resolved) { + return null; + } + + return resolved; +} + +function buildTree(dirPath: string, skipDirs?: Set, depth = 0, maxDepth = Infinity): FileNode[] { + if (!existsSync(dirPath)) return []; + if (depth >= maxDepth) return []; + + const entries = readdirSync(dirPath, { withFileTypes: true }); + const nodes: FileNode[] = []; + + for (const entry of entries) { + if (entry.name.startsWith(".")) continue; + + if (entry.isDirectory()) { + if (skipDirs?.has(entry.name)) continue; + const fullPath = join(dirPath, entry.name); + nodes.push({ + name: entry.name, + type: "directory", + children: buildTree(fullPath, skipDirs, depth + 1, maxDepth), + }); + } else if (entry.isFile()) { + nodes.push({ + name: entry.name, + type: "file", + }); + } + } + + nodes.sort((a, b) => { + if (a.type !== b.type) return a.type === "directory" ? -1 : 1; + return a.name.localeCompare(b.name); + }); + + return nodes; +} + +export async function GET(request: Request): Promise { + const { searchParams } = new URL(request.url); + const pathParam = searchParams.get("path"); + const rootParam = (searchParams.get("root") ?? "gsd") as RootMode; + + if (rootParam !== "gsd" && rootParam !== "project") { + return Response.json( + { error: `Invalid root: must be "gsd" or "project"` }, + { status: 400 }, + ); + } + + const projectCwd = requireProjectCwd(request); + const root = getRootForMode(rootParam, projectCwd); + const headers = { "Cache-Control": "no-store" }; + + // Mode A: return directory tree + if (!pathParam) { + if (!existsSync(root)) { + return Response.json({ tree: [] }, { headers }); + } + const skipDirs = rootParam === "project" ? PROJECT_SKIP_DIRS : undefined; + const maxDepth = rootParam === "project" ? MAX_PROJECT_DEPTH : Infinity; + return Response.json({ tree: buildTree(root, skipDirs, 0, maxDepth) }, { headers }); + } + + // Mode B: return file content + const resolvedPath = resolveSecurePath(pathParam, root); + if (!resolvedPath) { + const label = rootParam === "project" ? "project root" : ".gsd/"; + return Response.json( + { error: `Invalid path: path must be relative within ${label} and cannot contain '..' or start with '/'` }, + { status: 400, headers }, + ); + } + + if (!existsSync(resolvedPath)) { + return Response.json( + { error: `File not found: ${pathParam}` }, + { status: 404, headers }, + ); + } + + const stat = statSync(resolvedPath); + + if (stat.isDirectory()) { + return Response.json( + { error: `Path is a directory, not a file: ${pathParam}` }, + { status: 400, headers }, + ); + } + + if (stat.size > MAX_FILE_SIZE) { + return Response.json( + { error: `File too large: ${pathParam} (${stat.size} bytes, max ${MAX_FILE_SIZE})` }, + { status: 413, headers }, + ); + } + + const content = readFileSync(resolvedPath, "utf-8"); + return Response.json({ content }, { headers }); +} + +export async function POST(request: Request): Promise { + let body: Record; + try { + body = await request.json(); + } catch { + return Response.json( + { error: "Invalid JSON body" }, + { status: 400 }, + ); + } + + const { path: pathParam, content, root: rootParam = "gsd" } = body as { + path?: string; + content?: unknown; + root?: string; + }; + + if (rootParam !== "gsd" && rootParam !== "project") { + return Response.json( + { error: `Invalid root: must be "gsd" or "project"` }, + { status: 400 }, + ); + } + + if (typeof content !== "string") { + return Response.json( + { error: "Missing or invalid content: must be a string" }, + { status: 400 }, + ); + } + + if (Buffer.byteLength(content, "utf-8") > MAX_FILE_SIZE) { + return Response.json( + { error: `Content too large: ${Buffer.byteLength(content, "utf-8")} bytes exceeds max ${MAX_FILE_SIZE}` }, + { status: 413 }, + ); + } + + const projectCwd = requireProjectCwd(request); + const root = getRootForMode(rootParam as RootMode, projectCwd); + + if (typeof pathParam !== "string" || pathParam.length === 0) { + return Response.json( + { error: "Missing or invalid path: must be a non-empty string" }, + { status: 400 }, + ); + } + + const resolvedPath = resolveSecurePath(pathParam, root); + if (!resolvedPath) { + const label = rootParam === "project" ? "project root" : ".gsd/"; + return Response.json( + { error: `Invalid path: path must be relative within ${label} and cannot contain '..' or start with '/'` }, + { status: 400 }, + ); + } + + if (!existsSync(dirname(resolvedPath))) { + return Response.json( + { error: "Parent directory does not exist" }, + { status: 404 }, + ); + } + + writeFileSync(resolvedPath, content, "utf-8"); + return Response.json({ success: true }); +} + +/** PATCH — move/rename a file or directory */ +export async function PATCH(request: Request): Promise { + let body: Record; + try { + body = await request.json(); + } catch { + return Response.json({ error: "Invalid JSON body" }, { status: 400 }); + } + + const { from, to, root: rootParam = "gsd" } = body as { + from?: string; + to?: string; + root?: string; + }; + + if (rootParam !== "gsd" && rootParam !== "project") { + return Response.json( + { error: `Invalid root: must be "gsd" or "project"` }, + { status: 400 }, + ); + } + + if (typeof from !== "string" || from.length === 0) { + return Response.json( + { error: "Missing or invalid 'from': must be a non-empty string" }, + { status: 400 }, + ); + } + + if (typeof to !== "string" || to.length === 0) { + return Response.json( + { error: "Missing or invalid 'to': must be a non-empty string" }, + { status: 400 }, + ); + } + + const projectCwd = requireProjectCwd(request); + const root = getRootForMode(rootParam as RootMode, projectCwd); + const label = rootParam === "project" ? "project root" : ".gsd/"; + + const resolvedFrom = resolveSecurePath(from, root); + if (!resolvedFrom) { + return Response.json( + { error: `Invalid 'from' path: must be relative within ${label}` }, + { status: 400 }, + ); + } + + const resolvedTo = resolveSecurePath(to, root); + if (!resolvedTo) { + return Response.json( + { error: `Invalid 'to' path: must be relative within ${label}` }, + { status: 400 }, + ); + } + + if (!existsSync(resolvedFrom)) { + return Response.json( + { error: `Source not found: ${from}` }, + { status: 404 }, + ); + } + + if (existsSync(resolvedTo)) { + return Response.json( + { error: `Destination already exists: ${to}` }, + { status: 409 }, + ); + } + + if (!existsSync(dirname(resolvedTo))) { + return Response.json( + { error: `Destination directory does not exist: ${dirname(to)}` }, + { status: 404 }, + ); + } + + try { + renameSync(resolvedFrom, resolvedTo); + } catch (err) { + return Response.json( + { error: `Move failed: ${err instanceof Error ? err.message : String(err)}` }, + { status: 500 }, + ); + } + + return Response.json({ success: true, from, to }); +} + +/** DELETE — delete a file or directory */ +export async function DELETE(request: Request): Promise { + const { searchParams } = new URL(request.url); + const pathParam = searchParams.get("path"); + const rootParam = (searchParams.get("root") ?? "gsd") as RootMode; + + if (rootParam !== "gsd" && rootParam !== "project") { + return Response.json( + { error: `Invalid root: must be "gsd" or "project"` }, + { status: 400 }, + ); + } + + if (!pathParam || pathParam.length === 0) { + return Response.json( + { error: "Missing 'path' query parameter" }, + { status: 400 }, + ); + } + + const projectCwd = requireProjectCwd(request); + const root = getRootForMode(rootParam, projectCwd); + const label = rootParam === "project" ? "project root" : ".gsd/"; + + const resolvedPath = resolveSecurePath(pathParam, root); + if (!resolvedPath) { + return Response.json( + { error: `Invalid path: must be relative within ${label}` }, + { status: 400 }, + ); + } + + if (!existsSync(resolvedPath)) { + return Response.json( + { error: `Not found: ${pathParam}` }, + { status: 404 }, + ); + } + + try { + rmSync(resolvedPath, { recursive: true }); + } catch (err) { + return Response.json( + { error: `Delete failed: ${err instanceof Error ? err.message : String(err)}` }, + { status: 500 }, + ); + } + + return Response.json({ success: true }); +} + +/** PUT — create a new file or directory */ +export async function PUT(request: Request): Promise { + let body: Record; + try { + body = await request.json(); + } catch { + return Response.json({ error: "Invalid JSON body" }, { status: 400 }); + } + + const { path: pathParam, type = "file", root: rootParam = "gsd" } = body as { + path?: string; + type?: "file" | "directory"; + root?: string; + }; + + if (rootParam !== "gsd" && rootParam !== "project") { + return Response.json( + { error: `Invalid root: must be "gsd" or "project"` }, + { status: 400 }, + ); + } + + if (typeof pathParam !== "string" || pathParam.length === 0) { + return Response.json( + { error: "Missing or invalid 'path'" }, + { status: 400 }, + ); + } + + if (type !== "file" && type !== "directory") { + return Response.json( + { error: `Invalid type: must be "file" or "directory"` }, + { status: 400 }, + ); + } + + const projectCwd = requireProjectCwd(request); + const root = getRootForMode(rootParam as RootMode, projectCwd); + const label = rootParam === "project" ? "project root" : ".gsd/"; + + const resolvedPath = resolveSecurePath(pathParam, root); + if (!resolvedPath) { + return Response.json( + { error: `Invalid path: must be relative within ${label}` }, + { status: 400 }, + ); + } + + if (existsSync(resolvedPath)) { + return Response.json( + { error: `Already exists: ${pathParam}` }, + { status: 409 }, + ); + } + + if (!existsSync(dirname(resolvedPath))) { + return Response.json( + { error: `Parent directory does not exist: ${dirname(pathParam)}` }, + { status: 404 }, + ); + } + + try { + if (type === "directory") { + mkdirSync(resolvedPath); + } else { + writeFileSync(resolvedPath, "", "utf-8"); + } + } catch (err) { + return Response.json( + { error: `Create failed: ${err instanceof Error ? err.message : String(err)}` }, + { status: 500 }, + ); + } + + return Response.json({ success: true }); +} diff --git a/web/app/api/forensics/route.ts b/web/app/api/forensics/route.ts new file mode 100644 index 000000000..78ec7b494 --- /dev/null +++ b/web/app/api/forensics/route.ts @@ -0,0 +1,28 @@ +import { collectForensicsData } from "../../../../src/web/forensics-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectForensicsData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/git/route.ts b/web/app/api/git/route.ts new file mode 100644 index 000000000..7573e87be --- /dev/null +++ b/web/app/api/git/route.ts @@ -0,0 +1,28 @@ +import { collectCurrentProjectGitSummary } from "../../../../src/web/git-summary-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectCurrentProjectGitSummary(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/history/route.ts b/web/app/api/history/route.ts new file mode 100644 index 000000000..857f32cd3 --- /dev/null +++ b/web/app/api/history/route.ts @@ -0,0 +1,28 @@ +import { collectHistoryData } from "../../../../src/web/history-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectHistoryData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/hooks/route.ts b/web/app/api/hooks/route.ts new file mode 100644 index 000000000..209c56749 --- /dev/null +++ b/web/app/api/hooks/route.ts @@ -0,0 +1,28 @@ +import { collectHooksData } from "../../../../src/web/hooks-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectHooksData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/inspect/route.ts b/web/app/api/inspect/route.ts new file mode 100644 index 000000000..795dd7abb --- /dev/null +++ b/web/app/api/inspect/route.ts @@ -0,0 +1,28 @@ +import { collectInspectData } from "../../../../src/web/inspect-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectInspectData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/knowledge/route.ts b/web/app/api/knowledge/route.ts new file mode 100644 index 000000000..7ff6531fb --- /dev/null +++ b/web/app/api/knowledge/route.ts @@ -0,0 +1,28 @@ +import { collectKnowledgeData } from "../../../../src/web/knowledge-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectKnowledgeData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/live-state/route.ts b/web/app/api/live-state/route.ts new file mode 100644 index 000000000..e61d234d6 --- /dev/null +++ b/web/app/api/live-state/route.ts @@ -0,0 +1,41 @@ +import { + collectSelectiveLiveStatePayload, + requireProjectCwd, + type BridgeSelectiveLiveStateDomain, +} from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +const VALID_DOMAINS = new Set(["auto", "workspace", "resumable_sessions"]) + +function invalidQuery(message: string): Response { + return Response.json( + { error: message }, + { + status: 400, + headers: { + "Cache-Control": "no-store", + }, + }, + ) +} + +export async function GET(request: Request): Promise { + const { searchParams } = new URL(request.url) + const requestedDomains = searchParams.getAll("domain") + + if (requestedDomains.some((domain) => !VALID_DOMAINS.has(domain as BridgeSelectiveLiveStateDomain))) { + return invalidQuery(`Invalid live-state domain: ${requestedDomains.find((domain) => !VALID_DOMAINS.has(domain as BridgeSelectiveLiveStateDomain))}`) + } + + const domains = (requestedDomains.length > 0 ? requestedDomains : ["auto", "workspace", "resumable_sessions"]) as BridgeSelectiveLiveStateDomain[] + const projectCwd = requireProjectCwd(request) + const payload = await collectSelectiveLiveStatePayload(domains, projectCwd) + + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) +} diff --git a/web/app/api/onboarding/route.ts b/web/app/api/onboarding/route.ts new file mode 100644 index 000000000..d8771d334 --- /dev/null +++ b/web/app/api/onboarding/route.ts @@ -0,0 +1,147 @@ +import { + getOnboardingService, + type OnboardingState, +} from "../../../../src/web/onboarding-service.ts"; +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +type OnboardingAction = + | { action: "discover_providers" } + | { action: "recheck" } + | { action: "save_api_key"; providerId: string; apiKey: string } + | { action: "start_provider_flow"; providerId: string } + | { action: "continue_provider_flow"; flowId: string; input: string } + | { action: "cancel_provider_flow"; flowId: string } + | { action: "logout_provider"; providerId: string }; + +function noStoreHeaders(): HeadersInit { + return { + "Cache-Control": "no-store", + }; +} + +function errorResponse(status: number, error: unknown, onboarding?: OnboardingState): Response { + return Response.json( + { + error: error instanceof Error ? error.message : String(error), + ...(onboarding ? { onboarding } : {}), + }, + { + status, + headers: noStoreHeaders(), + }, + ); +} + +function isActionPayload(value: unknown): value is OnboardingAction { + return typeof value === "object" && value !== null && typeof (value as { action?: unknown }).action === "string"; +} + +export async function GET(request: Request): Promise { + requireProjectCwd(request); + return Response.json( + { + onboarding: await getOnboardingService().getState(), + }, + { + headers: noStoreHeaders(), + }, + ); +} + +export async function POST(request: Request): Promise { + requireProjectCwd(request); + let payload: unknown; + try { + payload = await request.json(); + } catch (error) { + return errorResponse(400, error); + } + + if (!isActionPayload(payload)) { + return errorResponse(400, "Request body must be a JSON object with an action field"); + } + + const onboardingService = getOnboardingService(); + + try { + switch (payload.action) { + case "discover_providers": + case "recheck": { + return Response.json( + { onboarding: await onboardingService.getState() }, + { + headers: noStoreHeaders(), + }, + ); + } + case "save_api_key": { + const onboarding = await onboardingService.validateAndSaveApiKey(payload.providerId, payload.apiKey); + return Response.json( + { onboarding }, + { + status: + onboarding.lastValidation?.status === "failed" + ? 422 + : onboarding.lockReason === "bridge_refresh_failed" + ? 503 + : onboarding.lockReason === "bridge_refresh_pending" + ? 202 + : 200, + headers: noStoreHeaders(), + }, + ); + } + case "start_provider_flow": { + const onboarding = await onboardingService.startProviderFlow(payload.providerId); + return Response.json( + { onboarding }, + { + status: 202, + headers: noStoreHeaders(), + }, + ); + } + case "continue_provider_flow": { + const onboarding = await onboardingService.submitProviderFlowInput(payload.flowId, payload.input); + return Response.json( + { onboarding }, + { + status: 202, + headers: noStoreHeaders(), + }, + ); + } + case "cancel_provider_flow": { + const onboarding = await onboardingService.cancelProviderFlow(payload.flowId); + return Response.json( + { onboarding }, + { + headers: noStoreHeaders(), + }, + ); + } + case "logout_provider": { + const onboarding = await onboardingService.logoutProvider(payload.providerId); + return Response.json( + { onboarding }, + { + status: + onboarding.lockReason === "bridge_refresh_failed" + ? 503 + : onboarding.lockReason === "bridge_refresh_pending" + ? 202 + : 200, + headers: noStoreHeaders(), + }, + ); + } + default: + return errorResponse(400, `Unsupported onboarding action: ${(payload as { action: string }).action}`); + } + } catch (error) { + return errorResponse(400, error, await onboardingService.getState()); + } +} diff --git a/web/app/api/preferences/route.ts b/web/app/api/preferences/route.ts new file mode 100644 index 000000000..c60389025 --- /dev/null +++ b/web/app/api/preferences/route.ts @@ -0,0 +1,69 @@ +import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs"; +import { dirname } from "node:path"; +import { webPreferencesPath } from "../../../../src/app-paths.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +/** Shape of persisted web preferences. */ +interface WebPreferences { + devRoot?: string; + lastActiveProject?: string; +} + +// ─── GET: read current preferences ───────────────────────────────────────── + +export async function GET(): Promise { + try { + if (!existsSync(webPreferencesPath)) { + return Response.json({}); + } + const raw = readFileSync(webPreferencesPath, "utf-8"); + const prefs: WebPreferences = JSON.parse(raw); + return Response.json(prefs); + } catch { + // File corrupt or unreadable — return empty + return Response.json({}); + } +} + +// ─── PUT: write preferences ──────────────────────────────────────────────── + +export async function PUT(request: Request): Promise { + try { + const body = await request.json() as Record; + + // Read existing prefs to merge (don't clobber fields not in this request) + let existing: WebPreferences = {}; + try { + if (existsSync(webPreferencesPath)) { + existing = JSON.parse(readFileSync(webPreferencesPath, "utf-8")); + } + } catch { + // Corrupt file — start fresh + } + + // Merge only provided keys + const prefs: WebPreferences = { ...existing }; + if (typeof body.devRoot === "string") { + prefs.devRoot = body.devRoot; + } + if (typeof body.lastActiveProject === "string") { + prefs.lastActiveProject = body.lastActiveProject; + } + + // Ensure parent directory exists + const dir = dirname(webPreferencesPath); + if (!existsSync(dir)) { + mkdirSync(dir, { recursive: true }); + } + + writeFileSync(webPreferencesPath, JSON.stringify(prefs, null, 2), "utf-8"); + return Response.json(prefs); + } catch (err) { + return Response.json( + { error: `Failed to write preferences: ${err instanceof Error ? err.message : String(err)}` }, + { status: 500 }, + ); + } +} diff --git a/web/app/api/projects/route.ts b/web/app/api/projects/route.ts new file mode 100644 index 000000000..023844ad8 --- /dev/null +++ b/web/app/api/projects/route.ts @@ -0,0 +1,103 @@ +import { existsSync, mkdirSync } from "node:fs"; +import { homedir } from "node:os"; +import { join } from "node:path"; +import { execSync } from "node:child_process"; +import { discoverProjects } from "../../../../src/web/project-discovery-service.ts"; +import { detectProjectKind } from "../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +/** Expand leading `~/` to the user's home directory. */ +function expandTilde(p: string): string { + if (p === "~") return homedir(); + if (p.startsWith("~/")) return join(homedir(), p.slice(2)); + return p; +} + +export async function GET(request: Request): Promise { + const url = new URL(request.url); + const root = url.searchParams.get("root"); + + if (!root) { + return Response.json( + { error: "Missing ?root= parameter" }, + { status: 400 }, + ); + } + + const detail = url.searchParams.get("detail") === "true"; + + const projects = discoverProjects(expandTilde(root), detail); + return Response.json(projects, { + headers: { + "Cache-Control": "no-store", + }, + }); +} + +// ─── POST: create a new project directory ────────────────────────────────── + +export async function POST(request: Request): Promise { + try { + const body = (await request.json()) as Record; + const rawDevRoot = typeof body.devRoot === "string" ? body.devRoot.trim() : ""; + const name = typeof body.name === "string" ? body.name.trim() : ""; + + if (!rawDevRoot) { + return Response.json({ error: "Missing devRoot" }, { status: 400 }); + } + + const devRoot = expandTilde(rawDevRoot); + if (!name) { + return Response.json({ error: "Missing project name" }, { status: 400 }); + } + + // Validate name: allow alphanumeric, hyphens, underscores, dots — no slashes or spaces + if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) { + return Response.json( + { error: "Invalid name. Use letters, numbers, hyphens, underscores, and dots. Must start with a letter or number." }, + { status: 400 }, + ); + } + + if (!existsSync(devRoot)) { + return Response.json( + { error: `Dev root does not exist: ${devRoot}` }, + { status: 400 }, + ); + } + + const projectPath = join(devRoot, name); + + if (existsSync(projectPath)) { + return Response.json( + { error: `Directory already exists: ${name}` }, + { status: 409 }, + ); + } + + // Create directory and initialize git repo + mkdirSync(projectPath, { recursive: true }); + execSync("git init", { cwd: projectPath, stdio: "ignore" }); + + // Detect project kind for consistent response + const { kind, signals } = detectProjectKind(projectPath); + + return Response.json( + { + name, + path: projectPath, + kind, + signals, + lastModified: Date.now(), + }, + { status: 201 }, + ); + } catch (err) { + return Response.json( + { error: `Failed to create project: ${err instanceof Error ? err.message : String(err)}` }, + { status: 500 }, + ); + } +} diff --git a/web/app/api/recovery/route.ts b/web/app/api/recovery/route.ts new file mode 100644 index 000000000..ca874d58f --- /dev/null +++ b/web/app/api/recovery/route.ts @@ -0,0 +1,28 @@ +import { collectCurrentProjectRecoveryDiagnostics } from "../../../../src/web/recovery-diagnostics-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectCurrentProjectRecoveryDiagnostics(undefined, projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/remote-questions/route.ts b/web/app/api/remote-questions/route.ts new file mode 100644 index 000000000..ae6e1cf4e --- /dev/null +++ b/web/app/api/remote-questions/route.ts @@ -0,0 +1,404 @@ +import { homedir } from "node:os" +import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "node:fs" +import { join, dirname } from "node:path" +import { parse as parseYaml, stringify as stringifyYaml } from "yaml" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +// ─── Constants (replicated from extensions — cannot import due to Turbopack constraint) ─── + +type RemoteChannel = "slack" | "discord" | "telegram" + +const CHANNEL_ID_PATTERNS: Record = { + slack: /^[A-Z0-9]{9,12}$/, + discord: /^\d{17,20}$/, + telegram: /^-?\d{5,20}$/, +} + +const ENV_KEYS: Record = { + slack: "SLACK_BOT_TOKEN", + discord: "DISCORD_BOT_TOKEN", + telegram: "TELEGRAM_BOT_TOKEN", +} + +const DEFAULT_TIMEOUT_MINUTES = 5 +const DEFAULT_POLL_INTERVAL_SECONDS = 5 +const MIN_TIMEOUT_MINUTES = 1 +const MAX_TIMEOUT_MINUTES = 30 +const MIN_POLL_INTERVAL_SECONDS = 2 +const MAX_POLL_INTERVAL_SECONDS = 30 + +const VALID_CHANNELS: readonly RemoteChannel[] = ["slack", "discord", "telegram"] as const + +// Map channel → auth.json provider ID (matches key-manager.ts PROVIDER_REGISTRY) +const AUTH_PROVIDER_IDS: Record = { + slack: "slack_bot", + discord: "discord_bot", + telegram: "telegram_bot", +} + +// ─── Auth.json Helpers ──────────────────────────────────────────────────────── + +function getAuthPath(): string { + return join(homedir(), ".gsd", "agent", "auth.json") +} + +function readAuthData(): Record { + const authPath = getAuthPath() + if (!existsSync(authPath)) return {} + try { + const content = readFileSync(authPath, "utf-8") + const parsed = JSON.parse(content) + return typeof parsed === "object" && parsed !== null ? parsed as Record : {} + } catch { return {} } +} + +function writeAuthData(data: Record): void { + const authPath = getAuthPath() + const parentDir = dirname(authPath) + if (!existsSync(parentDir)) mkdirSync(parentDir, { recursive: true, mode: 0o700 }) + writeFileSync(authPath, JSON.stringify(data, null, 2), "utf-8") + chmodSync(authPath, 0o600) +} + +function hasStoredBotToken(channel: RemoteChannel): boolean { + const data = readAuthData() + const providerId = AUTH_PROVIDER_IDS[channel] + const entry = data[providerId] + if (!entry) return false + // Could be a single credential or an array + const creds = Array.isArray(entry) ? entry : [entry] + return creds.some((c: unknown) => { + if (typeof c !== "object" || c === null) return false + const cred = c as Record + return cred.type === "api_key" && typeof cred.key === "string" && cred.key.length > 0 + }) +} + +function maskToken(token: string): string { + if (token.length <= 8) return token.slice(0, 2) + "***" + token.slice(-2) + return token.slice(0, 4) + "***" + token.slice(-4) +} + +// ─── Helpers ────────────────────────────────────────────────────────────────── + +function getPreferencesPath(): string { + return join(homedir(), ".gsd", "preferences.md") +} + +function clamp(value: number | undefined, defaultVal: number, min: number, max: number): number { + const v = typeof value === "number" && Number.isFinite(value) ? value : defaultVal + return Math.max(min, Math.min(max, v)) +} + +function isValidChannel(ch: unknown): ch is RemoteChannel { + return typeof ch === "string" && (VALID_CHANNELS as readonly string[]).includes(ch) +} + +/** + * Parse YAML frontmatter from a markdown file. + * Uses the same indexOf-based approach as parsePreferencesMarkdown() in preferences.ts. + */ +function parseFrontmatter(content: string): { data: Record; body: string; hasFrontmatter: boolean } { + const startMarker = content.startsWith("---\r\n") ? "---\r\n" : "---\n" + if (!content.startsWith(startMarker)) { + return { data: {}, body: content, hasFrontmatter: false } + } + const searchStart = startMarker.length + const endIdx = content.indexOf("\n---", searchStart) + if (endIdx === -1) { + return { data: {}, body: content, hasFrontmatter: false } + } + const block = content.slice(searchStart, endIdx) + const afterFrontmatter = content.slice(endIdx + 4) // skip \n--- + + try { + const parsed = parseYaml(block.replace(/\r/g, "")) + const data = typeof parsed === "object" && parsed !== null ? (parsed as Record) : {} + return { data, body: afterFrontmatter, hasFrontmatter: true } + } catch { + return { data: {}, body: content, hasFrontmatter: false } + } +} + +/** + * Write frontmatter data back to a markdown file, preserving the body content. + */ +function writeFrontmatter(data: Record, body: string): string { + const yamlStr = stringifyYaml(data, { lineWidth: 0 }).trimEnd() + return `---\n${yamlStr}\n---${body}` +} + +interface RemoteQuestionsResponse { + config: { + channel: RemoteChannel + channelId: string + timeoutMinutes: number + pollIntervalSeconds: number + } | null + envVarSet: boolean + tokenSet: boolean + envVarName: string | null + status: string +} + +// ─── GET ────────────────────────────────────────────────────────────────────── + +export async function GET(): Promise { + try { + const prefsPath = getPreferencesPath() + + if (!existsSync(prefsPath)) { + const response: RemoteQuestionsResponse = { + config: null, + envVarSet: false, + tokenSet: false, + envVarName: null, + status: "not_configured", + } + return Response.json(response, { + headers: { "Cache-Control": "no-store" }, + }) + } + + const content = readFileSync(prefsPath, "utf-8") + const { data } = parseFrontmatter(content) + const rq = data.remote_questions as Record | undefined + + if (!rq || typeof rq !== "object" || !rq.channel) { + const response: RemoteQuestionsResponse = { + config: null, + envVarSet: false, + tokenSet: false, + envVarName: null, + status: "not_configured", + } + return Response.json(response, { + headers: { "Cache-Control": "no-store" }, + }) + } + + const channel = rq.channel as string + if (!isValidChannel(channel)) { + const response: RemoteQuestionsResponse = { + config: null, + envVarSet: false, + tokenSet: false, + envVarName: null, + status: "invalid_channel", + } + return Response.json(response, { + headers: { "Cache-Control": "no-store" }, + }) + } + + const channelId = rq.channel_id != null ? String(rq.channel_id) : "" + const timeoutMinutes = clamp(rq.timeout_minutes as number | undefined, DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES) + const pollIntervalSeconds = clamp(rq.poll_interval_seconds as number | undefined, DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS) + const envVarName = ENV_KEYS[channel] + const envVarSet = !!process.env[envVarName] + const tokenSet = hasStoredBotToken(channel) || envVarSet + + const response: RemoteQuestionsResponse = { + config: { + channel, + channelId, + timeoutMinutes, + pollIntervalSeconds, + }, + envVarSet, + tokenSet, + envVarName, + status: "configured", + } + return Response.json(response, { + headers: { "Cache-Control": "no-store" }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: `Failed to read remote questions config: ${message}` }, + { status: 500, headers: { "Cache-Control": "no-store" } }, + ) + } +} + +// ─── POST ───────────────────────────────────────────────────────────────────── + +export async function POST(request: Request): Promise { + try { + const body = await request.json() as Record + const { channel, channelId, timeoutMinutes: rawTimeout, pollIntervalSeconds: rawPoll } = body as { + channel: unknown + channelId: unknown + timeoutMinutes: unknown + pollIntervalSeconds: unknown + } + + // Validate channel + if (!isValidChannel(channel)) { + return Response.json( + { error: `Invalid channel type: must be one of ${VALID_CHANNELS.join(", ")}` }, + { status: 400, headers: { "Cache-Control": "no-store" } }, + ) + } + + // Validate channelId + if (typeof channelId !== "string" || !channelId) { + return Response.json( + { error: "channelId is required and must be a non-empty string" }, + { status: 400, headers: { "Cache-Control": "no-store" } }, + ) + } + + if (!CHANNEL_ID_PATTERNS[channel].test(channelId)) { + return Response.json( + { error: `Invalid channel ID format for ${channel}. Expected pattern: ${CHANNEL_ID_PATTERNS[channel].source}` }, + { status: 400, headers: { "Cache-Control": "no-store" } }, + ) + } + + // Clamp timeout and poll interval + const timeoutMinutes = clamp(rawTimeout as number | undefined, DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES) + const pollIntervalSeconds = clamp(rawPoll as number | undefined, DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS) + + // Read current preferences + const prefsPath = getPreferencesPath() + let data: Record = {} + let body2 = "" + + if (existsSync(prefsPath)) { + const content = readFileSync(prefsPath, "utf-8") + const parsed = parseFrontmatter(content) + data = parsed.data + body2 = parsed.body + } + + // Update remote_questions block + data.remote_questions = { + channel, + channel_id: channelId, + timeout_minutes: timeoutMinutes, + poll_interval_seconds: pollIntervalSeconds, + } + + // Write back + const dir = dirname(prefsPath) + if (!existsSync(dir)) { + mkdirSync(dir, { recursive: true }) + } + writeFileSync(prefsPath, writeFrontmatter(data, body2), "utf-8") + + return Response.json( + { + success: true, + config: { channel, channelId, timeoutMinutes, pollIntervalSeconds }, + }, + { headers: { "Cache-Control": "no-store" } }, + ) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: `Failed to save remote questions config: ${message}` }, + { status: 500, headers: { "Cache-Control": "no-store" } }, + ) + } +} + +// ─── DELETE ─────────────────────────────────────────────────────────────────── + +export async function DELETE(): Promise { + try { + const prefsPath = getPreferencesPath() + + if (!existsSync(prefsPath)) { + return Response.json( + { success: true }, + { headers: { "Cache-Control": "no-store" } }, + ) + } + + const content = readFileSync(prefsPath, "utf-8") + const { data, body, hasFrontmatter } = parseFrontmatter(content) + + if (!hasFrontmatter || !data.remote_questions) { + return Response.json( + { success: true }, + { headers: { "Cache-Control": "no-store" } }, + ) + } + + delete data.remote_questions + writeFileSync(prefsPath, writeFrontmatter(data, body), "utf-8") + + return Response.json( + { success: true }, + { headers: { "Cache-Control": "no-store" } }, + ) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: `Failed to remove remote questions config: ${message}` }, + { status: 500, headers: { "Cache-Control": "no-store" } }, + ) + } +} + +// ─── PATCH (save bot token) ─────────────────────────────────────────────────── + +export async function PATCH(request: Request): Promise { + try { + const body = await request.json() as Record + const { channel, token } = body as { channel: unknown; token: unknown } + + if (!isValidChannel(channel)) { + return Response.json( + { error: `Invalid channel type: must be one of ${VALID_CHANNELS.join(", ")}` }, + { status: 400, headers: { "Cache-Control": "no-store" } }, + ) + } + + if (typeof token !== "string" || !token.trim()) { + return Response.json( + { error: "token is required and must be a non-empty string" }, + { status: 400, headers: { "Cache-Control": "no-store" } }, + ) + } + + const trimmedToken = token.trim() + const providerId = AUTH_PROVIDER_IDS[channel] + + // Read existing auth data, merge the new credential + const authData = readAuthData() + const existingEntry = authData[providerId] + const existingCreds: unknown[] = existingEntry + ? (Array.isArray(existingEntry) ? existingEntry : [existingEntry]) + : [] + + // Replace any existing api_key credential, keep OAuth + const oauthCreds = existingCreds.filter((c: unknown) => { + if (typeof c !== "object" || c === null) return false + return (c as Record).type === "oauth" + }) + const newCred = { type: "api_key", key: trimmedToken } + const merged = [...oauthCreds, newCred] + authData[providerId] = merged.length === 1 ? merged[0] : merged + writeAuthData(authData) + + // Also set in process.env so it's available immediately + const envVar = ENV_KEYS[channel] + process.env[envVar] = trimmedToken + + return Response.json( + { success: true, masked: maskToken(trimmedToken) }, + { headers: { "Cache-Control": "no-store" } }, + ) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: `Failed to save bot token: ${message}` }, + { status: 500, headers: { "Cache-Control": "no-store" } }, + ) + } +} diff --git a/web/app/api/session/browser/route.ts b/web/app/api/session/browser/route.ts new file mode 100644 index 000000000..5a9b36b0d --- /dev/null +++ b/web/app/api/session/browser/route.ts @@ -0,0 +1,47 @@ +import { + collectSessionBrowserPayload, + requireProjectCwd, +} from "../../../../../src/web/bridge-service.ts" +import { + isSessionBrowserNameFilter, + isSessionBrowserSortMode, +} from "../../../../lib/session-browser-contract.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +function invalidQuery(message: string): Response { + return Response.json({ error: message }, { + status: 400, + headers: { + "Cache-Control": "no-store", + }, + }) +} + +export async function GET(request: Request): Promise { + const { searchParams } = new URL(request.url) + const sortMode = searchParams.get("sortMode") + const nameFilter = searchParams.get("nameFilter") + + if (sortMode !== null && !isSessionBrowserSortMode(sortMode)) { + return invalidQuery(`Invalid sortMode: ${sortMode}`) + } + + if (nameFilter !== null && !isSessionBrowserNameFilter(nameFilter)) { + return invalidQuery(`Invalid nameFilter: ${nameFilter}`) + } + + const projectCwd = requireProjectCwd(request) + const payload = await collectSessionBrowserPayload({ + query: searchParams.get("query") ?? undefined, + sortMode: sortMode ?? undefined, + nameFilter: nameFilter ?? undefined, + }, projectCwd) + + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) +} diff --git a/web/app/api/session/command/route.ts b/web/app/api/session/command/route.ts new file mode 100644 index 000000000..a0445fb8c --- /dev/null +++ b/web/app/api/session/command/route.ts @@ -0,0 +1,50 @@ +import { + buildBridgeFailureResponse, + requireProjectCwd, + sendBridgeInput, +} from "../../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +function isBridgeInput(value: unknown): value is { type: string } { + return typeof value === "object" && value !== null && typeof (value as { type?: unknown }).type === "string"; +} + +function responseStatus(response: { success: boolean; code?: string }): number { + if (response.success) return 200; + if (response.code === "onboarding_locked") return 423; + return 502; +} + +export async function POST(request: Request): Promise { + let payload: unknown; + try { + payload = await request.json(); + } catch (error) { + return Response.json(buildBridgeFailureResponse("parse", error), { status: 400 }); + } + + if (!isBridgeInput(payload)) { + return Response.json(buildBridgeFailureResponse("parse", "Request body must be a JSON object with a type field"), { + status: 400, + }); + } + + try { + const projectCwd = requireProjectCwd(request); + const response = await sendBridgeInput(payload as Parameters[0], projectCwd); + if (response === null) { + return Response.json({ ok: true }, { status: 202 }); + } + + return Response.json(response, { + status: responseStatus(response), + headers: { + "Cache-Control": "no-store", + }, + }); + } catch (error) { + return Response.json(buildBridgeFailureResponse(payload.type, error), { status: 503 }); + } +} diff --git a/web/app/api/session/events/route.ts b/web/app/api/session/events/route.ts new file mode 100644 index 000000000..e8af59d8e --- /dev/null +++ b/web/app/api/session/events/route.ts @@ -0,0 +1,76 @@ +import { + collectCurrentProjectOnboardingState, + getProjectBridgeServiceForCwd, + requireProjectCwd, +} from "../../../../../src/web/bridge-service.ts"; +import { cancelShutdown } from "../../../../lib/shutdown-gate"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +const encoder = new TextEncoder(); + +function encodeSseData(payload: unknown): Uint8Array { + return encoder.encode(`data: ${JSON.stringify(payload)}\n\n`); +} + +export async function GET(request: Request): Promise { + // SSE reconnection proves the client is alive — cancel any pending shutdown. + cancelShutdown(); + + const projectCwd = requireProjectCwd(request); + const bridge = getProjectBridgeServiceForCwd(projectCwd); + const onboarding = await collectCurrentProjectOnboardingState(projectCwd); + + if (onboarding.locked) { + return new Response(null, { + status: 204, + headers: { + "Cache-Control": "no-store", + }, + }); + } + + try { + await bridge.ensureStarted(); + } catch { + // Keep the stream open and let the initial bridge_status event surface the failure state. + } + + let unsubscribe: (() => void) | null = null; + let closed = false; + + const closeWith = (controller: ReadableStreamDefaultController) => { + if (closed) return; + closed = true; + unsubscribe?.(); + unsubscribe = null; + controller.close(); + }; + + const stream = new ReadableStream({ + start(controller) { + unsubscribe = bridge.subscribe((event) => { + if (closed) return; + controller.enqueue(encodeSseData(event)); + }); + + request.signal.addEventListener("abort", () => closeWith(controller), { once: true }); + }, + cancel() { + if (closed) return; + closed = true; + unsubscribe?.(); + unsubscribe = null; + }, + }); + + return new Response(stream, { + headers: { + "Content-Type": "text/event-stream; charset=utf-8", + "Cache-Control": "no-cache, no-transform", + Connection: "keep-alive", + "X-Accel-Buffering": "no", + }, + }); +} diff --git a/web/app/api/session/manage/route.ts b/web/app/api/session/manage/route.ts new file mode 100644 index 000000000..783fe1519 --- /dev/null +++ b/web/app/api/session/manage/route.ts @@ -0,0 +1,82 @@ +import { + renameSessionInCurrentProject, + requireProjectCwd, +} from "../../../../../src/web/bridge-service.ts" +import { + SESSION_BROWSER_SCOPE, + isSessionManageAction, + type RenameSessionRequest, + type SessionManageResponse, +} from "../../../../lib/session-browser-contract.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +function invalidRequest(error: string): SessionManageResponse { + return { + success: false, + action: "rename", + scope: SESSION_BROWSER_SCOPE, + code: "invalid_request", + error, + } +} + +function responseStatus(response: SessionManageResponse): number { + if (response.success) return 200 + + switch (response.code) { + case "invalid_request": + return 400 + case "not_found": + return 404 + case "onboarding_locked": + return 423 + default: + return 502 + } +} + +function isRenameSessionRequest(value: unknown): value is RenameSessionRequest { + return ( + typeof value === "object" && + value !== null && + isSessionManageAction((value as { action?: string }).action) && + typeof (value as { sessionPath?: unknown }).sessionPath === "string" && + typeof (value as { name?: unknown }).name === "string" + ) +} + +export async function POST(request: Request): Promise { + let payload: unknown + try { + payload = await request.json() + } catch (error) { + const response = invalidRequest(error instanceof Error ? error.message : String(error)) + return Response.json(response, { + status: responseStatus(response), + headers: { + "Cache-Control": "no-store", + }, + }) + } + + if (!isRenameSessionRequest(payload)) { + const response = invalidRequest("Request body must be a rename action with sessionPath and name") + return Response.json(response, { + status: responseStatus(response), + headers: { + "Cache-Control": "no-store", + }, + }) + } + + const projectCwd = requireProjectCwd(request) + const response = await renameSessionInCurrentProject(payload, projectCwd) + return Response.json(response, { + status: responseStatus(response), + headers: { + "Cache-Control": "no-store", + }, + }) +} diff --git a/web/app/api/settings-data/route.ts b/web/app/api/settings-data/route.ts new file mode 100644 index 000000000..19ec22abf --- /dev/null +++ b/web/app/api/settings-data/route.ts @@ -0,0 +1,28 @@ +import { collectSettingsData } from "../../../../src/web/settings-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectSettingsData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/shutdown/route.ts b/web/app/api/shutdown/route.ts new file mode 100644 index 000000000..348044c85 --- /dev/null +++ b/web/app/api/shutdown/route.ts @@ -0,0 +1,13 @@ +import { scheduleShutdown } from "../../../lib/shutdown-gate"; + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function POST(): Promise { + // Schedule a deferred shutdown instead of exiting immediately. + // This gives the client a window to cancel the exit on page refresh — + // the boot route calls cancelShutdown() when it receives the next request. + scheduleShutdown(); + + return Response.json({ ok: true }) +} diff --git a/web/app/api/skill-health/route.ts b/web/app/api/skill-health/route.ts new file mode 100644 index 000000000..62ecb944f --- /dev/null +++ b/web/app/api/skill-health/route.ts @@ -0,0 +1,28 @@ +import { collectSkillHealthData } from "../../../../src/web/skill-health-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectSkillHealthData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/steer/route.ts b/web/app/api/steer/route.ts new file mode 100644 index 000000000..d159f57f4 --- /dev/null +++ b/web/app/api/steer/route.ts @@ -0,0 +1,39 @@ +import { existsSync, readFileSync } from "node:fs" +import { join } from "node:path" + +import { resolveBridgeRuntimeConfig, requireProjectCwd } from "../../../../src/web/bridge-service.ts" +import type { SteerData } from "../../../lib/remaining-command-types.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const config = resolveBridgeRuntimeConfig(undefined, projectCwd) + const overridesPath = join(config.projectCwd, ".gsd", "OVERRIDES.md") + + let overridesContent: string | null = null + if (existsSync(overridesPath)) { + overridesContent = readFileSync(overridesPath, "utf-8") + } + + const payload: SteerData = { overridesContent } + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/terminal/input/route.ts b/web/app/api/terminal/input/route.ts new file mode 100644 index 000000000..c29827b03 --- /dev/null +++ b/web/app/api/terminal/input/route.ts @@ -0,0 +1,40 @@ +/** + * POST endpoint to send input to a PTY session. + * + * POST /api/terminal/input + * Body: { id: string, data: string } + */ + +import { writeToSession } from "../../../../lib/pty-manager"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function POST(request: Request): Promise { + let body: { id?: string; data?: string }; + try { + body = await request.json(); + } catch { + return Response.json({ error: "Invalid JSON" }, { status: 400 }); + } + + const sessionId = body.id || "default"; + const data = body.data; + + if (typeof data !== "string") { + return Response.json( + { error: "data must be a string" }, + { status: 400 }, + ); + } + + const ok = writeToSession(sessionId, data); + if (!ok) { + return Response.json( + { error: "Session not found or dead" }, + { status: 404 }, + ); + } + + return Response.json({ ok: true }); +} diff --git a/web/app/api/terminal/resize/route.ts b/web/app/api/terminal/resize/route.ts new file mode 100644 index 000000000..6e6b53c21 --- /dev/null +++ b/web/app/api/terminal/resize/route.ts @@ -0,0 +1,41 @@ +/** + * POST endpoint to resize a PTY session. + * + * POST /api/terminal/resize + * Body: { id: string, cols: number, rows: number } + */ + +import { resizeSession } from "../../../../lib/pty-manager"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function POST(request: Request): Promise { + let body: { id?: string; cols?: number; rows?: number }; + try { + body = await request.json(); + } catch { + return Response.json({ error: "Invalid JSON" }, { status: 400 }); + } + + const sessionId = body.id || "default"; + const cols = body.cols; + const rows = body.rows; + + if (typeof cols !== "number" || typeof rows !== "number" || cols < 1 || rows < 1) { + return Response.json( + { error: "cols and rows must be positive numbers" }, + { status: 400 }, + ); + } + + const ok = resizeSession(sessionId, Math.floor(cols), Math.floor(rows)); + if (!ok) { + return Response.json( + { error: "Session not found or dead" }, + { status: 404 }, + ); + } + + return Response.json({ ok: true }); +} diff --git a/web/app/api/terminal/sessions/route.ts b/web/app/api/terminal/sessions/route.ts new file mode 100644 index 000000000..3e040cfd5 --- /dev/null +++ b/web/app/api/terminal/sessions/route.ts @@ -0,0 +1,73 @@ +/** + * Terminal session management. + * + * GET /api/terminal/sessions — list all sessions + * POST /api/terminal/sessions — create a new session (returns its id) + * DELETE /api/terminal/sessions?id=x — destroy a session + */ + +import { + listSessions, + getOrCreateSession, + destroySession, +} from "../../../../lib/pty-manager"; +import { requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +// Persist counter across HMR re-evaluations in dev +const g = globalThis as Record; +if (!g.__gsd_pty_next_index__) g.__gsd_pty_next_index__ = 1; +function getNextIndex(): number { + return (g.__gsd_pty_next_index__ as number)++; +} + +export async function GET(): Promise { + return Response.json({ sessions: listSessions() }); +} + +/** + * Whitelist of commands allowed to be spawned via the terminal API. + * Only known-safe executables are permitted to prevent arbitrary code execution + * if the auth layer is ever bypassed. + */ +const ALLOWED_COMMANDS = new Set([ + "gsd", + process.env.SHELL || "/bin/zsh", + "/bin/bash", + "/bin/zsh", + "/bin/sh", +]); + +export async function POST(request: Request): Promise { + const projectCwd = requireProjectCwd(request); + const id = `term-${getNextIndex()}`; + let command: string | undefined; + try { + const body = await request.json() as { command?: string }; + command = body.command; + } catch { + // No body or invalid JSON — use default shell + } + + if (command && !ALLOWED_COMMANDS.has(command)) { + return Response.json( + { error: `Command not allowed: ${command}` }, + { status: 403 }, + ); + } + + getOrCreateSession(id, projectCwd, command); + return Response.json({ id }); +} + +export async function DELETE(request: Request): Promise { + const url = new URL(request.url); + const id = url.searchParams.get("id"); + if (!id) { + return Response.json({ error: "id is required" }, { status: 400 }); + } + const ok = destroySession(id); + return Response.json({ ok, id }); +} diff --git a/web/app/api/terminal/stream/route.ts b/web/app/api/terminal/stream/route.ts new file mode 100644 index 000000000..ec5d2eab4 --- /dev/null +++ b/web/app/api/terminal/stream/route.ts @@ -0,0 +1,95 @@ +/** + * SSE endpoint streaming PTY output to the browser. + * + * GET /api/terminal/stream?id= + * + * Creates the PTY session on first connection if it doesn't exist. + */ + +import { + getOrCreateSession, + addListener, +} from "../../../../lib/pty-manager"; +import { requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +const encoder = new TextEncoder(); + +export async function GET(request: Request): Promise { + const url = new URL(request.url); + const sessionId = url.searchParams.get("id") || "default"; + const command = url.searchParams.get("command") || undefined; + const commandArgs = url.searchParams.getAll("arg"); + const projectCwd = requireProjectCwd(request); + + // Ensure the session exists + try { + getOrCreateSession(sessionId, projectCwd, command, commandArgs); + } catch (error) { + console.error("[pty-stream] Failed to create session:", error); + return Response.json( + { error: "Failed to create PTY session", detail: String(error) }, + { status: 500 }, + ); + } + + let removeListener: (() => void) | null = null; + let closed = false; + + const stream = new ReadableStream({ + start(controller) { + // Send an initial connected event + controller.enqueue( + encoder.encode( + `data: ${JSON.stringify({ type: "connected", sessionId })}\n\n`, + ), + ); + + removeListener = addListener(sessionId, (data: string) => { + if (closed) return; + try { + controller.enqueue( + encoder.encode( + `data: ${JSON.stringify({ type: "output", data })}\n\n`, + ), + ); + } catch { + // Stream closed + } + }); + + request.signal.addEventListener( + "abort", + () => { + if (closed) return; + closed = true; + removeListener?.(); + removeListener = null; + try { + controller.close(); + } catch { + // Already closed + } + }, + { once: true }, + ); + }, + cancel() { + if (closed) return; + closed = true; + removeListener?.(); + removeListener = null; + }, + }); + + return new Response(stream, { + headers: { + "Content-Type": "text/event-stream; charset=utf-8", + "Cache-Control": "no-cache, no-transform", + Connection: "keep-alive", + "X-Accel-Buffering": "no", + }, + }); +} diff --git a/web/app/api/terminal/upload/route.ts b/web/app/api/terminal/upload/route.ts new file mode 100644 index 000000000..b658561ab --- /dev/null +++ b/web/app/api/terminal/upload/route.ts @@ -0,0 +1,98 @@ +/** + * POST endpoint to upload an image file to the OS temp directory. + * + * POST /api/terminal/upload + * Body: multipart/form-data with a single `file` field + * + * Returns: + * 200 { ok: true, path: "/tmp/gsd-upload-..." } + * 400 { error: "No file provided" } + * 413 { error: "File too large (...)" } + * 415 { error: "Unsupported image type: ..." } + * 500 { error: "Failed to write file: ..." } + * + * Observability: + * - Structured error responses with descriptive messages + * - No custom cleanup — OS handles temp dir cleanup on reboot + */ + +import { writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { randomBytes } from "node:crypto"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +const ALLOWED_MIME_TYPES = new Set([ + "image/jpeg", + "image/png", + "image/gif", + "image/webp", +]); + +const MIME_TO_EXT: Record = { + "image/jpeg": "jpg", + "image/png": "png", + "image/gif": "gif", + "image/webp": "webp", +}; + +/** 20 MB raw file size limit */ +const MAX_FILE_SIZE = 20 * 1024 * 1024; + +export async function POST(request: Request): Promise { + let formData: FormData; + try { + formData = await request.formData(); + } catch { + return Response.json( + { error: "Invalid multipart form data" }, + { status: 400 }, + ); + } + + const file = formData.get("file"); + if (!file || !(file instanceof File)) { + return Response.json({ error: "No file provided" }, { status: 400 }); + } + + // Validate MIME type + if (!ALLOWED_MIME_TYPES.has(file.type)) { + return Response.json( + { + error: `Unsupported image type: ${file.type || "unknown"}. Accepted: JPEG, PNG, GIF, WebP.`, + }, + { status: 415 }, + ); + } + + // Validate file size + if (file.size > MAX_FILE_SIZE) { + const sizeMB = (file.size / (1024 * 1024)).toFixed(1); + return Response.json( + { error: `File too large (${sizeMB} MB). Maximum: 20 MB.` }, + { status: 413 }, + ); + } + + // Generate unique filename and write to temp dir + const ext = MIME_TO_EXT[file.type] ?? "bin"; + const hex = randomBytes(4).toString("hex"); + const filename = `gsd-upload-${Date.now()}-${hex}.${ext}`; + const filePath = join(tmpdir(), filename); + + try { + const arrayBuffer = await file.arrayBuffer(); + await writeFile(filePath, Buffer.from(arrayBuffer)); + } catch (err) { + const message = err instanceof Error ? err.message : String(err); + console.error("[terminal-upload] Failed to write file:", message); + return Response.json( + { error: `Failed to write file: ${message}` }, + { status: 500 }, + ); + } + + return Response.json({ ok: true, path: filePath }); +} diff --git a/web/app/api/undo/route.ts b/web/app/api/undo/route.ts new file mode 100644 index 000000000..17c465ef0 --- /dev/null +++ b/web/app/api/undo/route.ts @@ -0,0 +1,51 @@ +import { collectUndoInfo, executeUndo } from "../../../../src/web/undo-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectUndoInfo(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} + +export async function POST(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await executeUndo(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/api/update/route.ts b/web/app/api/update/route.ts new file mode 100644 index 000000000..f0d13c9dd --- /dev/null +++ b/web/app/api/update/route.ts @@ -0,0 +1,72 @@ +import { + checkForUpdate, + getUpdateStatus, + triggerUpdate, +} from "../../../../src/web/update-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(): Promise { + try { + const versionInfo = await checkForUpdate() + const { status, error, targetVersion } = getUpdateStatus() + + return Response.json( + { + currentVersion: versionInfo.currentVersion, + latestVersion: versionInfo.latestVersion, + updateAvailable: versionInfo.updateAvailable, + updateStatus: status, + ...(error ? { error } : {}), + ...(targetVersion ? { targetVersion } : {}), + }, + { + headers: { "Cache-Control": "no-store" }, + }, + ) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { "Cache-Control": "no-store" }, + }, + ) + } +} + +export async function POST(): Promise { + try { + const versionInfo = await checkForUpdate() + const started = triggerUpdate(versionInfo.latestVersion) + + if (!started) { + return Response.json( + { error: "Update already in progress" }, + { + status: 409, + headers: { "Cache-Control": "no-store" }, + }, + ) + } + + return Response.json( + { triggered: true }, + { + status: 202, + headers: { "Cache-Control": "no-store" }, + }, + ) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { "Cache-Control": "no-store" }, + }, + ) + } +} diff --git a/web/app/api/visualizer/route.ts b/web/app/api/visualizer/route.ts new file mode 100644 index 000000000..2f4dac448 --- /dev/null +++ b/web/app/api/visualizer/route.ts @@ -0,0 +1,28 @@ +import { collectVisualizerData } from "../../../../src/web/visualizer-service.ts" +import { requireProjectCwd } from "../../../../src/web/bridge-service.ts" + +export const runtime = "nodejs" +export const dynamic = "force-dynamic" + +export async function GET(request: Request): Promise { + try { + const projectCwd = requireProjectCwd(request); + const payload = await collectVisualizerData(projectCwd) + return Response.json(payload, { + headers: { + "Cache-Control": "no-store", + }, + }) + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + return Response.json( + { error: message }, + { + status: 500, + headers: { + "Cache-Control": "no-store", + }, + }, + ) + } +} diff --git a/web/app/globals.css b/web/app/globals.css new file mode 100644 index 000000000..c87d2c15d --- /dev/null +++ b/web/app/globals.css @@ -0,0 +1,322 @@ +@import 'tailwindcss'; +@import 'tw-animate-css'; + +@custom-variant dark (&:is(.dark *)); + +/* Monochrome IDE Theme - Always Dark */ +:root { + --background: oklch(0.98 0 0); + --foreground: oklch(0.15 0 0); + --card: oklch(0.97 0 0); + --card-foreground: oklch(0.15 0 0); + --popover: oklch(0.98 0 0); + --popover-foreground: oklch(0.15 0 0); + --primary: oklch(0.15 0 0); + --primary-foreground: oklch(0.98 0 0); + --secondary: oklch(0.92 0 0); + --secondary-foreground: oklch(0.2 0 0); + --muted: oklch(0.93 0 0); + --muted-foreground: oklch(0.45 0 0); + --accent: oklch(0.9 0 0); + --accent-foreground: oklch(0.15 0 0); + --destructive: oklch(0.5 0.15 25); + --destructive-foreground: oklch(0.98 0 0); + --border: oklch(0.85 0 0); + --input: oklch(0.9 0 0); + --ring: oklch(0.6 0 0); + --chart-1: oklch(0.35 0 0); + --chart-2: oklch(0.45 0 0); + --chart-3: oklch(0.55 0 0); + --chart-4: oklch(0.65 0 0); + --chart-5: oklch(0.75 0 0); + --radius: 0.375rem; + --sidebar: oklch(0.95 0 0); + --sidebar-foreground: oklch(0.2 0 0); + --sidebar-primary: oklch(0.15 0 0); + --sidebar-primary-foreground: oklch(0.98 0 0); + --sidebar-accent: oklch(0.9 0 0); + --sidebar-accent-foreground: oklch(0.15 0 0); + --sidebar-border: oklch(0.85 0 0); + --sidebar-ring: oklch(0.6 0 0); + + /* Custom tokens */ + --success: oklch(0.45 0.15 145); + --warning: oklch(0.55 0.15 85); + --info: oklch(0.45 0.1 250); + --terminal: oklch(0.96 0 0); + --terminal-foreground: oklch(0.2 0 0); + --code-line-number: oklch(0.55 0 0); +} + +.dark { + --background: oklch(0.09 0 0); + --foreground: oklch(0.9 0 0); + --card: oklch(0.11 0 0); + --card-foreground: oklch(0.9 0 0); + --popover: oklch(0.13 0 0); + --popover-foreground: oklch(0.9 0 0); + --primary: oklch(0.95 0 0); + --primary-foreground: oklch(0.09 0 0); + --secondary: oklch(0.18 0 0); + --secondary-foreground: oklch(0.85 0 0); + --muted: oklch(0.15 0 0); + --muted-foreground: oklch(0.55 0 0); + --accent: oklch(0.2 0 0); + --accent-foreground: oklch(0.9 0 0); + --destructive: oklch(0.5 0.15 25); + --destructive-foreground: oklch(0.95 0 0); + --border: oklch(0.22 0 0); + --input: oklch(0.15 0 0); + --ring: oklch(0.4 0 0); + --chart-1: oklch(0.7 0 0); + --chart-2: oklch(0.6 0 0); + --chart-3: oklch(0.5 0 0); + --chart-4: oklch(0.4 0 0); + --chart-5: oklch(0.3 0 0); + --sidebar: oklch(0.07 0 0); + --sidebar-foreground: oklch(0.85 0 0); + --sidebar-primary: oklch(0.95 0 0); + --sidebar-primary-foreground: oklch(0.09 0 0); + --sidebar-accent: oklch(0.15 0 0); + --sidebar-accent-foreground: oklch(0.9 0 0); + --sidebar-border: oklch(0.18 0 0); + --sidebar-ring: oklch(0.35 0 0); + + /* Custom tokens */ + --success: oklch(0.65 0.15 145); + --warning: oklch(0.7 0.15 85); + --info: oklch(0.6 0.1 250); + --terminal: oklch(0.06 0 0); + --terminal-foreground: oklch(0.75 0 0); + --code-line-number: oklch(0.35 0 0); +} + +@theme inline { + --font-sans: var(--font-geist-sans), 'Geist', 'Geist Fallback'; + --font-mono: var(--font-geist-mono), 'Geist Mono', 'Geist Mono Fallback'; + --color-background: var(--background); + --color-foreground: var(--foreground); + --color-card: var(--card); + --color-card-foreground: var(--card-foreground); + --color-popover: var(--popover); + --color-popover-foreground: var(--popover-foreground); + --color-primary: var(--primary); + --color-primary-foreground: var(--primary-foreground); + --color-secondary: var(--secondary); + --color-secondary-foreground: var(--secondary-foreground); + --color-muted: var(--muted); + --color-muted-foreground: var(--muted-foreground); + --color-accent: var(--accent); + --color-accent-foreground: var(--accent-foreground); + --color-destructive: var(--destructive); + --color-destructive-foreground: var(--destructive-foreground); + --color-border: var(--border); + --color-input: var(--input); + --color-ring: var(--ring); + --color-chart-1: var(--chart-1); + --color-chart-2: var(--chart-2); + --color-chart-3: var(--chart-3); + --color-chart-4: var(--chart-4); + --color-chart-5: var(--chart-5); + --radius-sm: calc(var(--radius) - 4px); + --radius-md: calc(var(--radius) - 2px); + --radius-lg: var(--radius); + --radius-xl: calc(var(--radius) + 4px); + --color-sidebar: var(--sidebar); + --color-sidebar-foreground: var(--sidebar-foreground); + --color-sidebar-primary: var(--sidebar-primary); + --color-sidebar-primary-foreground: var(--sidebar-primary-foreground); + --color-sidebar-accent: var(--sidebar-accent); + --color-sidebar-accent-foreground: var(--sidebar-accent-foreground); + --color-sidebar-border: var(--sidebar-border); + --color-sidebar-ring: var(--sidebar-ring); + --color-success: var(--success); + --color-warning: var(--warning); + --color-info: var(--info); + --color-terminal: var(--terminal); + --color-terminal-foreground: var(--terminal-foreground); +} + +@layer base { + * { + @apply border-border outline-ring/50; + } + body { + @apply bg-background text-foreground; + } +} + +/* ── File viewer: Shiki code blocks ── */ +.file-viewer-code pre { + margin: 0; + padding: 1rem; + background: transparent !important; + overflow-x: auto; + font-family: var(--font-mono); +} + +.file-viewer-code code { + font-family: var(--font-mono); + counter-reset: line; +} + +.file-viewer-code code .line { + display: inline-block; + width: 100%; + padding: 0 0.5rem; +} + +.file-viewer-code code .line:hover { + background: oklch(0.15 0 0); +} + +.file-viewer-code code .line::before { + counter-increment: line; + content: counter(line); + display: inline-block; + width: 3.5ch; + margin-right: 1.5ch; + text-align: right; + color: oklch(0.35 0 0); + user-select: none; +} + +/* ── File viewer: Markdown rendering ── */ +.markdown-body { + color: oklch(0.85 0 0); + font-family: var(--font-sans); + font-size: 0.9rem; + line-height: 1.7; +} + +.markdown-body h1 { + font-size: 1.75rem; + font-weight: 700; + margin-top: 0; + margin-bottom: 1rem; + padding-bottom: 0.5rem; + border-bottom: 1px solid oklch(0.22 0 0); +} + +.markdown-body h2 { + font-size: 1.35rem; + font-weight: 600; + margin-top: 1.75rem; + margin-bottom: 0.75rem; + padding-bottom: 0.35rem; + border-bottom: 1px solid oklch(0.22 0 0); +} + +.markdown-body h3 { + font-size: 1.15rem; + font-weight: 600; + margin-top: 1.5rem; + margin-bottom: 0.5rem; +} + +.markdown-body h4, +.markdown-body h5, +.markdown-body h6 { + font-size: 1rem; + font-weight: 600; + margin-top: 1.25rem; + margin-bottom: 0.5rem; +} + +.markdown-body p { + margin-top: 0; + margin-bottom: 0.75rem; +} + +.markdown-body ul, +.markdown-body ol { + margin-top: 0; + margin-bottom: 0.75rem; + padding-left: 1.75rem; +} + +.markdown-body ul { + list-style: disc; +} + +.markdown-body ol { + list-style: decimal; +} + +.markdown-body li { + margin-bottom: 0.25rem; +} + +.markdown-body li > ul, +.markdown-body li > ol { + margin-top: 0.25rem; + margin-bottom: 0; +} + +.markdown-body blockquote { + margin: 0.75rem 0; + padding: 0.25rem 1rem; + border-left: 3px solid oklch(0.3 0 0); + color: oklch(0.6 0 0); +} + +.markdown-body hr { + margin: 1.5rem 0; + border: none; + border-top: 1px solid oklch(0.22 0 0); +} + +.markdown-body strong { + font-weight: 600; + color: oklch(0.92 0 0); +} + +.markdown-body em { + font-style: italic; +} + +.markdown-body del { + text-decoration: line-through; + color: oklch(0.5 0 0); +} + +/* Task list checkboxes */ +.markdown-body input[type="checkbox"] { + margin-right: 0.4rem; + accent-color: oklch(0.65 0.15 145); +} + +/* ── Chat Mode: streaming cursor animation ── */ +@keyframes chat-cursor { + 0%, 100% { opacity: 0.8; } + 50% { opacity: 0.1; } +} + +/* ── Chat Mode: shiki code blocks inside chat bubbles ── */ +.chat-code-block pre { + margin: 0; + padding: 1rem; + background: transparent !important; + overflow-x: auto; + font-family: var(--font-mono); + font-size: 0.8rem; + line-height: 1.6; +} + +.chat-code-block code { + font-family: var(--font-mono); +} + +/* ── Chat Mode: markdown inside bubbles ── */ +.chat-markdown { + word-break: break-word; + overflow-wrap: anywhere; +} + +.chat-markdown > *:first-child { + margin-top: 0 !important; +} + +.chat-markdown > *:last-child { + margin-bottom: 0 !important; +} diff --git a/web/app/layout.tsx b/web/app/layout.tsx new file mode 100644 index 000000000..8a3202a2b --- /dev/null +++ b/web/app/layout.tsx @@ -0,0 +1,54 @@ +import type { Metadata } from 'next' +import { Geist, Geist_Mono } from 'next/font/google' +import { Toaster } from '@/components/ui/sonner' +import { ThemeProvider } from '@/components/theme-provider' +import './globals.css' + +const geistSans = Geist({ + subsets: ['latin'], + variable: '--font-geist-sans', +}) + +const geistMono = Geist_Mono({ + subsets: ['latin'], + variable: '--font-geist-mono', +}) + +export const metadata: Metadata = { + title: 'GSD', + description: 'The evolution of Get Shit Done — now a real coding agent. One command. Walk away. Come back to a built project.', + applicationName: 'GSD', + icons: { + icon: [ + { + url: '/icon-light-32x32.png', + media: '(prefers-color-scheme: light)', + }, + { + url: '/icon-dark-32x32.png', + media: '(prefers-color-scheme: dark)', + }, + { + url: '/icon.svg', + type: 'image/svg+xml', + }, + ], + }, +} + +export default function RootLayout({ + children, +}: Readonly<{ + children: React.ReactNode +}>) { + return ( + + + + {children} + + + + + ) +} diff --git a/web/app/page.tsx b/web/app/page.tsx new file mode 100644 index 000000000..9923adfd9 --- /dev/null +++ b/web/app/page.tsx @@ -0,0 +1,19 @@ +"use client" + +import dynamic from "next/dynamic" + +const GSDAppShell = dynamic( + () => import("@/components/gsd/app-shell").then((mod) => mod.GSDAppShell), + { + ssr: false, + loading: () => ( +
+ Loading workspace… +
+ ), + }, +) + +export default function Page() { + return +} diff --git a/web/components.json b/web/components.json new file mode 100644 index 000000000..4ee62ee10 --- /dev/null +++ b/web/components.json @@ -0,0 +1,21 @@ +{ + "$schema": "https://ui.shadcn.com/schema.json", + "style": "new-york", + "rsc": true, + "tsx": true, + "tailwind": { + "config": "", + "css": "app/globals.css", + "baseColor": "neutral", + "cssVariables": true, + "prefix": "" + }, + "aliases": { + "components": "@/components", + "utils": "@/lib/utils", + "ui": "@/components/ui", + "lib": "@/lib", + "hooks": "@/hooks" + }, + "iconLibrary": "lucide" +} diff --git a/web/components/gsd/activity-view.tsx b/web/components/gsd/activity-view.tsx new file mode 100644 index 000000000..20ab206bd --- /dev/null +++ b/web/components/gsd/activity-view.tsx @@ -0,0 +1,78 @@ +"use client" + +import { CheckCircle2, Play, Clock, Terminal, AlertCircle } from "lucide-react" +import { cn } from "@/lib/utils" +import { useGSDWorkspaceState, type TerminalLineType } from "@/lib/gsd-workspace-store" + +function EventIcon({ type }: { type: TerminalLineType }) { + const baseClass = "h-4 w-4" + switch (type) { + case "system": + return + case "success": + return + case "error": + return + case "output": + return + case "input": + return + default: + return + } +} + +export function ActivityView() { + const workspace = useGSDWorkspaceState() + const terminalLines = workspace.terminalLines ?? [] + + // Show most recent events first + const reversedLines = [...terminalLines].reverse() + + return ( +
+
+

Activity Log

+

+ Execution history and git operations +

+
+ +
+ {reversedLines.length === 0 ? ( +
+ No activity yet. Events will appear here once the workspace is active. +
+ ) : ( +
+ {/* Timeline line */} +
+ +
+ {reversedLines.map((line) => ( +
+ {/* Timeline dot */} +
+ +
+ + {/* Content */} +
+
+
+

{line.content}

+
+ + {line.timestamp} + +
+
+
+ ))} +
+
+ )} +
+
+ ) +} diff --git a/web/components/gsd/app-shell.tsx b/web/components/gsd/app-shell.tsx new file mode 100644 index 000000000..24c4c12e9 --- /dev/null +++ b/web/components/gsd/app-shell.tsx @@ -0,0 +1,464 @@ +"use client" + +import Image from "next/image" +import { useState, useEffect, useCallback, useRef, useSyncExternalStore } from "react" +import { Sidebar, MilestoneExplorer, CollapsedMilestoneSidebar } from "@/components/gsd/sidebar" +import { ShellTerminal } from "@/components/gsd/shell-terminal" +import { Dashboard } from "@/components/gsd/dashboard" +import { Roadmap } from "@/components/gsd/roadmap" +import { FilesView } from "@/components/gsd/files-view" +import { ActivityView } from "@/components/gsd/activity-view" +import { VisualizerView } from "@/components/gsd/visualizer-view" +import { StatusBar } from "@/components/gsd/status-bar" +import { DualTerminal } from "@/components/gsd/dual-terminal" +import { FocusedPanel } from "@/components/gsd/focused-panel" +import { OnboardingGate } from "@/components/gsd/onboarding-gate" +import { CommandSurface } from "@/components/gsd/command-surface" +import { DevOverridesProvider } from "@/lib/dev-overrides" +import { ProjectStoreManagerProvider, useProjectStoreManager } from "@/lib/project-store-manager" +import { Skeleton } from "@/components/ui/skeleton" +import { cn } from "@/lib/utils" +import { toast } from "sonner" +import { + GSDWorkspaceProvider, + getCurrentScopeLabel, + getProjectDisplayName, + getStatusPresentation, + getVisibleWorkspaceError, + useGSDWorkspaceState, + useGSDWorkspaceActions, +} from "@/lib/gsd-workspace-store" +import { ChatMode } from "@/components/gsd/chat-mode" +import { ScopeBadge } from "@/components/gsd/scope-badge" +import { Badge } from "@/components/ui/badge" +import { ProjectsPanel, ProjectSelectionGate } from "@/components/gsd/projects-view" +import { UpdateBanner } from "@/components/gsd/update-banner" +import { getAuthToken } from "@/lib/auth" + +const KNOWN_VIEWS = new Set(["dashboard", "power", "chat", "roadmap", "files", "activity", "visualize"]) + +function viewStorageKey(projectCwd: string): string { + return `gsd-active-view:${projectCwd}` +} + +function WorkspaceChrome() { + const [activeView, setActiveView] = useState("dashboard") + const [isTerminalExpanded, setIsTerminalExpanded] = useState(false) + const [terminalHeight, setTerminalHeight] = useState(300) + const [terminalDragActive, setTerminalDragActive] = useState(false) + const isDraggingTerminal = useRef(false) + const didDragTerminal = useRef(false) + const dragStartY = useRef(0) + const dragStartHeight = useRef(0) + const [sidebarWidth, setSidebarWidth] = useState(256) + const isDraggingSidebar = useRef(false) + const dragStartX = useRef(0) + const dragStartWidth = useRef(0) + const [sidebarCollapsed, setSidebarCollapsed] = useState(false) + const [viewRestored, setViewRestored] = useState(false) + const [projectsPanelOpen, setProjectsPanelOpen] = useState(false) + const workspace = useGSDWorkspaceState() + const { refreshBoot } = useGSDWorkspaceActions() + + const status = getStatusPresentation(workspace) + const projectPath = workspace.boot?.project.cwd + const projectLabel = getProjectDisplayName(projectPath) + const titleOverride = workspace.titleOverride?.trim() || null + const scopeLabel = getCurrentScopeLabel(workspace.boot?.workspace) + const visibleError = getVisibleWorkspaceError(workspace) + + // Restore persisted view once boot provides projectCwd + useEffect(() => { + if (viewRestored || !projectPath) return + const restoreTimer = window.setTimeout(() => { + try { + const stored = sessionStorage.getItem(viewStorageKey(projectPath)) + if (stored && KNOWN_VIEWS.has(stored)) { + setActiveView(stored) + } + } catch { + // sessionStorage may be unavailable (e.g. SSR, iframe sandbox) + } + setViewRestored(true) + }, 0) + return () => window.clearTimeout(restoreTimer) + }, [projectPath, viewRestored]) + + // Persist view changes to sessionStorage + useEffect(() => { + if (!projectPath) return + try { + sessionStorage.setItem(viewStorageKey(projectPath), activeView) + } catch { + // sessionStorage may be unavailable + } + }, [activeView, projectPath]) + + // Restore sidebar collapsed state from localStorage + useEffect(() => { + const restoreTimer = window.setTimeout(() => { + try { + const stored = localStorage.getItem("gsd-sidebar-collapsed") + if (stored === "true") setSidebarCollapsed(true) + } catch { + // localStorage may be unavailable + } + }, 0) + return () => window.clearTimeout(restoreTimer) + }, []) + + // Persist sidebar collapsed state + useEffect(() => { + try { + localStorage.setItem("gsd-sidebar-collapsed", String(sidebarCollapsed)) + } catch { + // localStorage may be unavailable + } + }, [sidebarCollapsed]) + + useEffect(() => { + if (typeof document === "undefined") return + const base = projectLabel ? `GSD - ${projectLabel}` : "GSD" + document.title = titleOverride ? `${titleOverride} · ${base}` : base + }, [titleOverride, projectLabel]) + + const handleViewChange = useCallback((view: string) => { + setActiveView(view) + }, []) + + // Listen for cross-component file navigation events (e.g. sidebar task clicks) + useEffect(() => { + const handler = () => { + setActiveView("files") + } + window.addEventListener("gsd:open-file", handler) + return () => window.removeEventListener("gsd:open-file", handler) + }, []) + + // Listen for cross-component view navigation events (e.g. /gsd visualize dispatch) + useEffect(() => { + const handler = (e: CustomEvent<{ view: string }>) => { + if (KNOWN_VIEWS.has(e.detail.view)) { + handleViewChange(e.detail.view) + } + } + window.addEventListener("gsd:navigate-view", handler as EventListener) + return () => window.removeEventListener("gsd:navigate-view", handler as EventListener) + }, [handleViewChange]) + + // Listen for projects panel toggle (sidebar icon, or programmatic) + useEffect(() => { + const handler = () => setProjectsPanelOpen(true) + window.addEventListener("gsd:open-projects", handler) + return () => window.removeEventListener("gsd:open-projects", handler) + }, []) + + // Terminal + sidebar panel drag-to-resize + useEffect(() => { + const handleMouseMove = (e: MouseEvent) => { + if (isDraggingTerminal.current) { + didDragTerminal.current = true + const delta = dragStartY.current - e.clientY + const newHeight = Math.max(150, Math.min(600, dragStartHeight.current + delta)) + setTerminalHeight(newHeight) + } + if (isDraggingSidebar.current) { + const delta = dragStartX.current - e.clientX + const newWidth = Math.max(180, Math.min(480, dragStartWidth.current + delta)) + setSidebarWidth(newWidth) + } + } + const handleMouseUp = () => { + isDraggingTerminal.current = false + isDraggingSidebar.current = false + setTerminalDragActive(false) + document.body.style.cursor = "" + document.body.style.userSelect = "" + } + document.addEventListener("mousemove", handleMouseMove) + document.addEventListener("mouseup", handleMouseUp) + return () => { + document.removeEventListener("mousemove", handleMouseMove) + document.removeEventListener("mouseup", handleMouseUp) + } + }, []) + + const handleTerminalDragStart = useCallback( + (e: React.MouseEvent) => { + isDraggingTerminal.current = true + setTerminalDragActive(true) + dragStartY.current = e.clientY + dragStartHeight.current = terminalHeight + document.body.style.cursor = "row-resize" + document.body.style.userSelect = "none" + }, + [terminalHeight], + ) + + const handleSidebarDragStart = useCallback( + (e: React.MouseEvent) => { + isDraggingSidebar.current = true + dragStartX.current = e.clientX + dragStartWidth.current = sidebarWidth + document.body.style.cursor = "col-resize" + document.body.style.userSelect = "none" + }, + [sidebarWidth], + ) + + const retryDisabled = !!workspace.commandInFlight || workspace.onboardingRequestState !== "idle" + const isConnecting = workspace.bootStatus === "idle" || workspace.bootStatus === "loading" + + // Persistent loading toast — dismissed the moment boot completes + useEffect(() => { + if (!isConnecting) return + const id = toast.loading("Connecting to workspace…", { + description: "Establishing the live bridge session", + duration: Infinity, + }) + return () => { + toast.dismiss(id) + } + }, [isConnecting]) + + // Detect project welcome state — hide chrome for v1-legacy, brownfield, blank projects + const detection = workspace.boot?.projectDetection + const isWelcomeState = + !isConnecting && + activeView === "dashboard" && + detection != null && + detection.kind !== "active-gsd" && + detection.kind !== "empty-gsd" + + return ( +
+
+
+
+ GSD + GSD + + beta + +
+ / + + {isConnecting ? ( + + ) : ( + <> + {projectLabel} + {titleOverride && ( + + {titleOverride} + + )} + + )} + +
+ +
+ {/* Hidden status marker for test instrumentation */} + {status.label} + + {isConnecting ? : } + +
+
+ + + + {!isConnecting && visibleError && ( +
+ {visibleError} + +
+ )} + +
+ {} : handleViewChange} isConnecting={isConnecting} /> + +
+
+ {isConnecting ? ( + + ) : ( + <> + {activeView === "dashboard" && ( + setIsTerminalExpanded(true)} + /> + )} + {activeView === "power" && } + {activeView === "roadmap" && } + {activeView === "files" && } + {activeView === "activity" && } + {activeView === "visualize" && } + {activeView === "chat" && } + + )} +
+ + {activeView !== "power" && activeView !== "chat" && ( +
+ {/* Drag handle + toggle header — entire bar is clickable */} +
{ + if (didDragTerminal.current) { + didDragTerminal.current = false + return + } + if (!isConnecting) setIsTerminalExpanded(!isTerminalExpanded) + }} + onKeyDown={(e) => { + if (e.key === "Enter" || e.key === " ") { + e.preventDefault() + if (!isConnecting) setIsTerminalExpanded(!isTerminalExpanded) + } + }} + className={cn( + "flex h-8 w-full items-center justify-between bg-card px-3 text-xs select-none transition-colors", + isTerminalExpanded && "cursor-row-resize", + !isTerminalExpanded && !isConnecting && "cursor-pointer hover:bg-muted/50", + isConnecting && "cursor-default", + )} + onMouseDown={(e) => { + if (isTerminalExpanded) handleTerminalDragStart(e) + }} + > +
+ Terminal + + {isTerminalExpanded ? "▼" : "▲"} + +
+
+ {/* Terminal content */} +
+ +
+
+ )} +
+ + {/* Resizable milestone sidebar — hidden during project welcome */} + {!isWelcomeState && !sidebarCollapsed && ( +
+ {/* Thin visible border */} +
+ {/* Wide invisible grab area overlapping the border */} +
+
+ )} + {!isWelcomeState && (sidebarCollapsed ? ( + setSidebarCollapsed(false)} /> + ) : ( + setSidebarCollapsed(true)} + /> + ))} +
+ + + + + + +
+ ) +} + +export function GSDAppShell() { + // Extract the auth token from the URL fragment on first render. + // Must happen before any API calls fire. + getAuthToken() + + return ( + + + + ) +} + +function ProjectAwareWorkspace() { + const manager = useProjectStoreManager() + const activeProjectCwd = useSyncExternalStore(manager.subscribe, manager.getSnapshot, manager.getSnapshot) + const activeStore = activeProjectCwd ? manager.getActiveStore() : null + + // Shut down all projects when the tab actually closes + useEffect(() => { + const handlePageHide = () => { + navigator.sendBeacon("/api/shutdown", "") + } + + window.addEventListener("pagehide", handlePageHide) + + return () => { + window.removeEventListener("pagehide", handlePageHide) + } + }, []) + + // No project selected yet — show project selection gate + if (!activeProjectCwd || !activeStore) { + return + } + + return ( + + + + + + ) +} diff --git a/web/components/gsd/chat-mode.tsx b/web/components/gsd/chat-mode.tsx new file mode 100644 index 000000000..53c729f6b --- /dev/null +++ b/web/components/gsd/chat-mode.tsx @@ -0,0 +1,2324 @@ +"use client" + +import Image from "next/image" +import { useEffect, useRef, useCallback, useState, useMemo, KeyboardEvent, DragEvent, ClipboardEvent } from "react" +import { MessagesSquare, SendHorizonal, Check, Eye, EyeOff, Play, Loader2, Milestone, X, MessageCircle, FileEdit, FilePlus, Terminal, ChevronDown, ChevronRight, MoreHorizontal, Zap, Square, Pause, BarChart3, LayoutGrid, ListOrdered, History, Compass, PenLine, Inbox, SkipForward, Undo2, BookOpen, Settings, SlidersHorizontal, Stethoscope, FileOutput, Trash2, Globe, type LucideIcon } from "lucide-react" +import { cn } from "@/lib/utils" +import { Input } from "@/components/ui/input" +import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from "@/components/ui/tooltip" +import { Popover, PopoverTrigger, PopoverContent } from "@/components/ui/popover" +import { ChatMessage, TuiPrompt } from "@/lib/pty-chat-parser" +import { PendingImage, processImageFile, generateImageId, MAX_PENDING_IMAGES } from "@/lib/image-utils" +import { + useGSDWorkspaceState, + useGSDWorkspaceActions, + buildPromptCommand, + type CompletedToolExecution, + type ActiveToolExecution, + type PendingUiRequest, + type TurnSegment, +} from "@/lib/gsd-workspace-store" +import { deriveWorkflowAction } from "@/lib/workflow-actions" +import { useTerminalFontSize } from "@/lib/use-terminal-font-size" + +/* ─── ActionPanel types ─── */ + +// ActionPanelConfig removed — all commands now route through the main bridge. + +/* ─── GSD Action Definitions ─── */ + +/** + * Defines every /gsd subcommand available in the chat input bar. + * Top 3 are shown as standalone buttons; the rest live in the overflow menu. + * All commands dispatch through the main bridge session. + */ +interface GSDActionDef { + label: string + command: string + icon: LucideIcon + description: string + category: "workflow" | "visibility" | "correction" | "knowledge" | "config" | "maintenance" + /** When true, this command is disabled while auto-mode is active (injects competing LLM prompt) */ + disabledDuringAuto?: boolean +} + +const GSD_ACTIONS: GSDActionDef[] = [ + // ── Top 3 (standalone buttons) ── + { label: "Discuss", command: "/gsd discuss", icon: MessageCircle, description: "Start guided milestone/slice discussion", category: "workflow", disabledDuringAuto: true }, + { label: "Next", command: "/gsd next", icon: Play, description: "Execute next task, then pause", category: "workflow" }, + { label: "Auto", command: "/gsd auto", icon: Zap, description: "Run all queued units continuously", category: "workflow" }, + // ── Overflow: Workflow ── + { label: "Stop", command: "/gsd stop", icon: Square, description: "Stop auto-mode gracefully", category: "workflow" }, + { label: "Pause", command: "/gsd pause", icon: Pause, description: "Pause auto-mode (preserves state)", category: "workflow" }, + // ── Overflow: Visibility ── + { label: "Status", command: "/gsd status", icon: BarChart3, description: "Show progress dashboard", category: "visibility" }, + { label: "Visualize", command: "/gsd visualize", icon: LayoutGrid, description: "Interactive TUI (progress, deps, metrics, timeline)", category: "visibility" }, + { label: "Queue", command: "/gsd queue", icon: ListOrdered, description: "Show queued/dispatched units and execution order", category: "visibility" }, + { label: "History", command: "/gsd history", icon: History, description: "View execution history with cost/phase/model details", category: "visibility" }, + // ── Overflow: Course correction ── + { label: "Steer", command: "/gsd steer", icon: Compass, description: "Apply user override to active work", category: "correction" }, + { label: "Capture", command: "/gsd capture", icon: PenLine, description: "Quick-capture a thought to CAPTURES.md", category: "correction" }, + { label: "Triage", command: "/gsd triage", icon: Inbox, description: "Classify and route pending captures", category: "correction", disabledDuringAuto: true }, + { label: "Skip", command: "/gsd skip", icon: SkipForward, description: "Prevent a unit from auto-mode dispatch", category: "correction" }, + { label: "Undo", command: "/gsd undo", icon: Undo2, description: "Revert last completed unit", category: "correction" }, + // ── Overflow: Knowledge ── + { label: "Knowledge", command: "/gsd knowledge", icon: BookOpen, description: "Add rule, pattern, or lesson to KNOWLEDGE.md", category: "knowledge" }, + // ── Overflow: Configuration ── + { label: "Mode", command: "/gsd mode", icon: SlidersHorizontal, description: "Set workflow mode (solo/team)", category: "config" }, + { label: "Prefs", command: "/gsd prefs", icon: Settings, description: "Manage preferences (global/project)", category: "config" }, + // ── Overflow: Maintenance ── + { label: "Doctor", command: "/gsd doctor", icon: Stethoscope, description: "Diagnose and repair .gsd/ state", category: "maintenance" }, + { label: "Export", command: "/gsd export", icon: FileOutput, description: "Export milestone/slice results (JSON or Markdown)", category: "maintenance" }, + { label: "Cleanup", command: "/gsd cleanup", icon: Trash2, description: "Remove merged branches or snapshots", category: "maintenance" }, + { label: "Remote", command: "/gsd remote", icon: Globe, description: "Control remote auto-mode (Slack/Discord)", category: "maintenance" }, +] + +/** Top 3 shown as standalone buttons next to chat input */ +const TOP_ACTIONS = GSD_ACTIONS.slice(0, 3) +/** Remaining actions in the overflow menu */ +const OVERFLOW_ACTIONS = GSD_ACTIONS.slice(3) + +const CATEGORY_LABELS: Record = { + workflow: "Workflow", + visibility: "Visibility", + correction: "Course Correction", + knowledge: "Knowledge", + config: "Configuration", + maintenance: "Maintenance", +} + +function groupByCategory(actions: GSDActionDef[]): Array<{ category: GSDActionDef["category"]; label: string; items: GSDActionDef[] }> { + const seen = new Map() + for (const a of actions) { + let group = seen.get(a.category) + if (!group) { + group = [] + seen.set(a.category, group) + } + group.push(a) + } + return Array.from(seen.entries()).map(([cat, items]) => ({ category: cat, label: CATEGORY_LABELS[cat], items })) +} + +/** + * ChatMode — main view for the Chat tab. + * + * All /gsd commands dispatch through the main bridge session. + * Commands that inject competing LLM prompts (discuss, triage) + * are disabled while auto-mode is active. + * + * Observability: + * - This component mounts only when activeView === "chat" (no hidden pre-init). + * - sessionStorage key "gsd-active-view:" equals "chat" when this view is active. + * - Header toolbar: data-testid="chat-mode-action-bar" confirms toolbar rendered. + * - Primary button: data-testid="chat-primary-action" reflects current workflowAction label. + * - Secondary buttons: data-testid="chat-secondary-action-{command}". + */ +export function ChatMode({ className }: { className?: string }) { + const state = useGSDWorkspaceState() + const { sendCommand } = useGSDWorkspaceActions() + + const bridge = state.boot?.bridge ?? null + + const handleAction = useCallback( + (command: string) => { + void sendCommand(buildPromptCommand(command, bridge)) + }, + [sendCommand, bridge], + ) + + return ( +
+ {/* ── Header bar ── */} + + + {/* ── Main chat pane ── */} + handleAction(action.command)} + /> +
+ ) +} + +/* ─── Header ─── */ + +interface ChatModeHeaderProps { + onPrimaryAction: (command: string) => void + onSecondaryAction: (command: string) => void +} + +/** + * ChatModeHeader — action toolbar for Chat Mode. + * + * Single-row layout matching the Power User Mode header: title + badge left-aligned, + * workflow action buttons immediately to the right (no second row). + * + * Observability: + * - data-testid="chat-mode-action-bar" on the workflow button row + * - data-testid="chat-primary-action" on the primary button + * - data-testid="chat-secondary-action-{command}" on each secondary button + */ +function ChatModeHeader({ onPrimaryAction, onSecondaryAction }: ChatModeHeaderProps) { + const state = useGSDWorkspaceState() + + const boot = state.boot + const workspace = boot?.workspace ?? null + const auto = boot?.auto ?? null + + const workflowAction = deriveWorkflowAction({ + phase: workspace?.active.phase ?? "pre-planning", + autoActive: auto?.active ?? false, + autoPaused: auto?.paused ?? false, + onboardingLocked: boot?.onboarding.locked ?? false, + commandInFlight: state.commandInFlight, + bootStatus: state.bootStatus, + hasMilestones: (workspace?.milestones.length ?? 0) > 0, + projectDetectionKind: boot?.projectDetection?.kind ?? null, + }) + + const handlePrimary = () => { + if (!workflowAction.primary) return + onPrimaryAction(workflowAction.primary.command) + } + + // Derive a short GSD state badge label + const stateBadge = (() => { + if (state.bootStatus !== "ready") return state.bootStatus + const phase = workspace?.active.phase + if (!phase) return "idle" + if (auto?.active && !auto?.paused) return "auto" + if (auto?.paused) return "paused" + return phase + })() + + return ( +
+ {/* Left: title + state badge */} +
+ + Chat Mode + + {stateBadge} + +
+ + {/* Right: workflow action buttons */} +
+ {workflowAction.primary && ( + + )} + {workflowAction.secondaries.map((action) => ( + + ))} + {state.commandInFlight && ( + + + + )} +
+
+ ) +} + + +type ShikiHighlighter = { + codeToHtml: (code: string, options: { lang: string; theme: string }) => string +} + +let chatHighlighterPromise: Promise | null = null + +function getChatHighlighter(): Promise { + if (!chatHighlighterPromise) { + chatHighlighterPromise = import("shiki") + .then((mod) => + mod.createHighlighter({ + themes: ["github-dark-default", "github-light-default"], + langs: [ + "typescript", "tsx", "javascript", "jsx", + "json", "jsonc", "markdown", "mdx", + "css", "scss", "less", "html", "xml", + "yaml", "toml", "bash", "python", "ruby", + "rust", "go", "java", "kotlin", "swift", + "c", "cpp", "csharp", "php", "sql", + "graphql", "dockerfile", "makefile", + "lua", "diff", "ini", "dotenv", + ], + }), + ) + .catch((err) => { + chatHighlighterPromise = null + throw err + }) + } + return chatHighlighterPromise +} + +/* ─── Markdown renderer for assistant bubbles ─── */ + +/** + * Renders markdown content using react-markdown + remark-gfm + shiki code blocks. + * Dynamic imports keep the main bundle lean. + * Falls back to plain text if modules fail to load. + * + * Observability: + * - console.debug("[ChatBubble] markdown modules loaded") fires once on first render + */ +function MarkdownContent({ content }: { content: string }) { + const [rendered, setRendered] = useState(null) + const [ready, setReady] = useState(false) + const isDark = useIsDark() + + useEffect(() => { + let cancelled = false + + Promise.all([ + import("react-markdown"), + import("remark-gfm"), + getChatHighlighter(), + ]) + .then(([ReactMarkdownMod, remarkGfmMod, highlighter]) => { + if (cancelled) return + console.debug("[ChatBubble] markdown modules loaded") + + const ReactMarkdown = ReactMarkdownMod.default + const remarkGfm = remarkGfmMod.default + + const shikiTheme = isDark ? "github-dark-default" : "github-light-default" + + const buildComponents = (h: typeof highlighter) => ({ + code({ className, children, ...props }: React.HTMLAttributes & { children?: React.ReactNode }) { + const match = /language-(\w+)/.exec(className || "") + const codeStr = String(children).replace(/\n$/, "") + + if (match) { + try { + const highlighted = h.codeToHtml(codeStr, { + lang: match[1], + theme: shikiTheme, + }) + return ( +
+ ) + } catch { /* unsupported language — fall through */ } + } + + const isInline = !className && !String(children).includes("\n") + if (isInline) { + return ( + + {children} + + ) + } + + return ( + 
+                {children}
+
+ ) + }, + pre({ children }: { children?: React.ReactNode }) { + return <>{children} + }, + table({ children }: { children?: React.ReactNode }) { + return ( +
+ {children}
+
+ ) + }, + th({ children }: { children?: React.ReactNode }) { + return ( + + {children} + + ) + }, + td({ children }: { children?: React.ReactNode }) { + return ( + + {children} + + ) + }, + a({ href, children }: { href?: string; children?: React.ReactNode }) { + return ( + + {children} + + ) + }, + h1({ children }: { children?: React.ReactNode }) { + return

{children}

+ }, + h2({ children }: { children?: React.ReactNode }) { + return

{children}

+ }, + h3({ children }: { children?: React.ReactNode }) { + return

{children}

+ }, + ul({ children }: { children?: React.ReactNode }) { + return
    {children}
+ }, + ol({ children }: { children?: React.ReactNode }) { + return
    {children}
+ }, + blockquote({ children }: { children?: React.ReactNode }) { + return
{children}
+ }, + hr() { + return
+ }, + p({ children }: { children?: React.ReactNode }) { + return

{children}

+ }, + img({ alt, src }: { alt?: string; src?: string }) { + return ( + + 🖼 {alt || src || "image"} + + ) + }, + }) + + setRendered( + + {content} + , + ) + setReady(true) + }) + .catch(() => { + if (!cancelled) setReady(true) + }) + + return () => { cancelled = true } + + }, [content, isDark]) // re-render when content changes (streaming) or theme toggles + + if (!ready) { + // Plain text fallback while modules load + return ( + + {content} + + ) + } + + if (!rendered) { + return ( + + {content} + + ) + } + + return
{rendered}
+} + +/* ─── TuiSelectPrompt ─── */ + +/** + * Renders a GSD arrow-key select prompt as a native clickable list. + * + * Clicking an option calculates the arrow-key delta from the current + * PTY-tracked selection, sends that many \x1b[A/\x1b[B + \r to the PTY, + * and transitions to a static post-submission state. + * + * Observability: + * - Logs "[TuiSelectPrompt] mounted kind=select label=%s" on mount + * - Logs "[TuiSelectPrompt] submit delta=%d keystrokes=%j" on submit + * - data-testid="tui-select-prompt" on container + * - data-testid="tui-select-option-{i}" on each option button + * - data-testid="tui-prompt-submitted" on post-submission element + */ +function TuiSelectPrompt({ + prompt, + onSubmit, +}: { + prompt: TuiPrompt + onSubmit: (data: string) => void +}) { + const [localIndex, setLocalIndex] = useState(prompt.selectedIndex ?? 0) + const [submitted, setSubmitted] = useState(false) + const containerRef = useRef(null) + + useEffect(() => { + console.log("[TuiSelectPrompt] mounted kind=select label=%s", prompt.label) + // Auto-focus the container so keyboard events are captured immediately + containerRef.current?.focus() + }, [prompt.label]) + + const submitIndex = useCallback( + (clickedIndex: number) => { + const delta = clickedIndex - localIndex + let keystrokes = "" + if (delta > 0) { + keystrokes = "\x1b[B".repeat(delta) + } else if (delta < 0) { + keystrokes = "\x1b[A".repeat(Math.abs(delta)) + } + keystrokes += "\r" + + console.log( + "[TuiSelectPrompt] submit delta=%d keystrokes=%j", + delta, + keystrokes, + ) + + setLocalIndex(clickedIndex) + setSubmitted(true) + onSubmit(keystrokes) + }, + [localIndex, onSubmit], + ) + + const handleKeyDown = useCallback( + (e: KeyboardEvent) => { + if (submitted) return + if (e.key === "ArrowUp") { + e.preventDefault() + setLocalIndex((i) => Math.max(0, i - 1)) + } else if (e.key === "ArrowDown") { + e.preventDefault() + setLocalIndex((i) => Math.min(prompt.options.length - 1, i + 1)) + } else if (e.key === "Enter") { + e.preventDefault() + submitIndex(localIndex) + } + }, + [submitted, localIndex, prompt.options.length, submitIndex], + ) + + if (submitted) { + const selectedLabel = prompt.options[localIndex] ?? "" + return ( +
+ + {selectedLabel} +
+ ) + } + + return ( +
+ {prompt.label && ( +

+ {prompt.label} +

+ )} + {prompt.options.map((option, i) => { + const isSelected = i === localIndex + const description = prompt.descriptions?.[i] + return ( + + ) + })} +
+ ) +} + +/* ─── TuiTextPrompt ─── */ + +/** + * Renders a GSD text prompt as a native labeled input field. + * + * Submitting sends the typed value + "\r" to the PTY (carriage return = Enter). + * After submission shows a static "✓ Submitted" confirmation (value not echoed). + * + * Observability: + * - Logs "[TuiTextPrompt] mounted kind=text label=%s" on mount + * - Logs "[TuiTextPrompt] submitted label=%s" on submit + * - data-testid="tui-text-prompt" on container + * - data-testid="tui-prompt-submitted" on post-submission element + */ +function TuiTextPrompt({ + prompt, + onSubmit, +}: { + prompt: TuiPrompt + onSubmit: (data: string) => void +}) { + const [value, setValue] = useState("") + const [submitted, setSubmitted] = useState(false) + const inputRef = useRef(null) + + useEffect(() => { + console.log("[TuiTextPrompt] mounted kind=text label=%s", prompt.label) + inputRef.current?.focus() + }, [prompt.label]) + + const handleSubmit = useCallback(() => { + if (submitted) return + console.log("[TuiTextPrompt] submitted label=%s", prompt.label) + setSubmitted(true) + onSubmit(value + "\r") + }, [submitted, value, prompt.label, onSubmit]) + + const handleKeyDown = useCallback( + (e: React.KeyboardEvent) => { + if (e.key === "Enter") { + e.preventDefault() + handleSubmit() + } + }, + [handleSubmit], + ) + + if (submitted) { + return ( +
+ + ✓ Submitted +
+ ) + } + + return ( +
+ {prompt.label && ( +

+ {prompt.label} +

+ )} +
+ setValue(e.target.value)} + onKeyDown={handleKeyDown} + placeholder="Type your answer…" + className="flex-1 h-8 text-sm" + aria-label={prompt.label || "Text input"} + /> + +
+
+ ) +} + +/* ─── TuiPasswordPrompt ─── */ + +/** + * Renders a GSD password/API-key prompt as a native masked input field. + * + * Submitting sends the typed value + "\r" to the PTY. + * The entered value is NEVER shown in the DOM, logs, or post-submission text. + * After submission shows "{label} — entered ✓" with no value echo. + * + * Observability: + * - Logs "[TuiPasswordPrompt] mounted kind=password label=%s" on mount + * - Logs "[TuiPasswordPrompt] submitted label=%s" on submit (value not logged) + * - data-testid="tui-password-prompt" on container + * - data-testid="tui-prompt-submitted" on post-submission element + */ +function TuiPasswordPrompt({ + prompt, + onSubmit, +}: { + prompt: TuiPrompt + onSubmit: (data: string) => void +}) { + const [value, setValue] = useState("") + const [submitted, setSubmitted] = useState(false) + const [showPassword, setShowPassword] = useState(false) + const inputRef = useRef(null) + + useEffect(() => { + console.log("[TuiPasswordPrompt] mounted kind=password label=%s", prompt.label) + inputRef.current?.focus() + }, [prompt.label]) + + const handleSubmit = useCallback(() => { + if (submitted) return + // Value intentionally not logged — redaction constraint + console.log("[TuiPasswordPrompt] submitted label=%s", prompt.label) + setSubmitted(true) + onSubmit(value + "\r") + }, [submitted, value, prompt.label, onSubmit]) + + const handleKeyDown = useCallback( + (e: React.KeyboardEvent) => { + if (e.key === "Enter") { + e.preventDefault() + handleSubmit() + } + }, + [handleSubmit], + ) + + if (submitted) { + const displayLabel = prompt.label || "Value" + return ( +
+ + {displayLabel} — entered ✓ +
+ ) + } + + return ( +
+ {prompt.label && ( +

+ {prompt.label} +

+ )} +
+
+ setValue(e.target.value)} + onKeyDown={handleKeyDown} + placeholder="Enter value…" + className="h-8 pr-9 text-sm" + aria-label={prompt.label || "Password input"} + autoComplete="off" + /> + +
+ +
+

+ Value is transmitted securely and not stored in chat history. +

+
+ ) +} + +/* ─── StreamingCursor ─── */ + +function StreamingCursor() { + return ( +