From 815be0a698bf317060988b0913437301c6c11bcb Mon Sep 17 00:00:00 2001 From: Andrew <43323844+snowdamiz@users.noreply.github.com> Date: Thu, 26 Mar 2026 08:33:07 -0700 Subject: [PATCH] feat: managed RTK integration with opt-in preference and web UI toggle (#2620) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: integrate managed RTK across shell workflows * fix(rtk): unify managed fallback and live savings wiring * fix(rtk): improve TUI status visibility * fix(tests): make portability tests independent of pi-coding-agent dist build The CI portability test runs don't guarantee that packages/pi-coding-agent has been compiled. Any test that imported files pulling in @gsd/pi-coding-agent (resource-loader, preferences-skills, async-bash-tool, etc.) crashed with ERR_MODULE_NOT_FOUND pointing at dist/index.js. Two changes to dist-redirect.mjs (the Node ESM loader hook used by all unit tests): - Redirect the bare @gsd/pi-coding-agent specifier to the workspace source entrypoint (src/index.ts) so no dist/ artifact is needed. - Extend the load() hook to transpile *.ts files under packages/pi-coding-agent/src/ through TypeScript's transpileModule. Node's --experimental-strip-types can't handle parameter properties and similar syntax present in that package's source; full transpilation avoids the ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX crash. Also fix the dashboard.tsx responsive grid: - xl:grid-cols-5 → xl:grid-cols-4 2xl:grid-cols-5 (5 metric cards no longer fit at xl without overflow; test contract expected xl:grid-cols-4) - Keep loading-skeletons.tsx in sync with the same breakpoints. Add src/tests/resolve-ts-loader.test.ts to guard the loader behaviour: - bare @gsd/pi-coding-agent redirect points to workspace source - direct source-entry rewrite (.js → .ts) - transpilation removes TS parameter property syntax that strip-only mode cannot parse * fix(tests): redirect all workspace package imports to source in portability tests The previous fix only redirected @gsd/pi-coding-agent to its source entrypoint. In CI, pi-coding-agent/src itself imports @gsd/pi-ai (and other workspace packages) which were still pointing at dist/. Since no workspace dist is built during the portability test run, any transitive resolution hit the same ERR_MODULE_NOT_FOUND. Changes to dist-redirect.mjs: - Redirect @gsd/pi-ai, @gsd/pi-ai/oauth, @gsd/pi-agent-core, and @gsd/pi-tui bare imports to their workspace src/ entrypoints. - Broaden the load() transpilation condition from '/packages/pi-coding-agent/src/' to '/packages/*/src/' so that all workspace source files are run through TypeScript's transpileModule, handling parameter properties and other syntax that Node's strip-only mode rejects. Verified by hiding all four workspace dist/ directories locally and running the failing test set — 96/96 pass. * fix(tests): redirect @gsd/native sub-paths; fix Windows .cmd spawnSync Two more portability failures after the previous fix: 1. @gsd/native sub-path imports (@gsd/native/fd, @gsd/native/text, etc.) were not redirected — the loader only handled the bare specifier. Added a prefix-match redirect for @gsd/native/* → packages/native/src//index.ts. 2. Windows RTK tests failed because createFakeRtk produces a .cmd wrapper on Windows, and spawnSync(binaryPath, [...]) without shell:true silently returns non-zero when the binary is a .cmd file. Added shell: /\.(cmd|bat)$/i.test(binaryPath) to the spawnSync calls in: - src/resources/extensions/shared/rtk.ts (rewriteCommandWithRtk) - src/resources/extensions/shared/rtk-session-stats.ts (readCurrentRtkGainSummary) - packages/pi-coding-agent/src/utils/rtk.ts (rewriteCommandForGsd) Production use of rtk.exe is unaffected; the shell flag is only true for .cmd/.bat paths. Verified: all 93 portability tests pass with all workspace dist/ directories removed (simulating CI portability environment). * fix(tests): Windows portability fixes — HOME env, managed RTK path, perf threshold Four Windows-specific failures fixed: 1. app-smoke.test.ts: process.env.HOME is undefined on Windows (uses USERPROFILE instead). Changed to homedir() from node:os which works cross-platform. 2. Managed RTK path tests on Windows: tests placed a fake RTK as rtk.exe (by copying a .cmd script into a .exe filename), which Windows cannot execute. Two-part fix: - resolveRtkBinaryPath() in both rtk.ts files now falls back to rtk.cmd in the managed dir on Windows when rtk.exe is absent. - withManagedFakeRtk and equivalent patterns in rtk.test.ts, rtk-session-stats.test.ts, rtk-execution-seams.test.ts changed to place the fake at rtk.cmd instead of rtk.exe on Windows. 3. bg_shell RTK test on Windows: requires bash (for shell sessions), which is not available on the blacksmith-4vcpu-windows-2025 runner without Git Bash installed. Test now skips on win32. 4. derive-state-db perf assertion: 10ms threshold was too tight for Windows CI runners (measured 12ms under load). Raised to 25ms — still catches real regressions (baseline is 3ms locally and ~12ms on stressed runners). * fix(tests): fix managed RTK path fallback on Windows in src/rtk.ts + fix copyable fake Two remaining Windows failures: 1. src/rtk.ts was never patched with the rtk.cmd managed-dir fallback (only the shared/rtk.ts and pi-coding-agent/src/utils/rtk.ts were updated). Added the same rtk.cmd fallback and shell:.cmd detection to src/rtk.ts, which is what rtk.test.ts imports from. 2. createFakeRtk on Windows wrote '%~dp0\fake-rtk.js' in the .cmd content — this resolves relative to the .cmd file's own directory. When the test copies rtk.cmd to a different managed dir, %~dp0 resolves to the copy destination where fake-rtk.js does not exist. Fixed by embedding the absolute path to fake-rtk.js directly in the .cmd content so the fake works correctly regardless of where the .cmd is copied. * feat(experimental): add RTK opt-in preference with web UI toggle - Add `experimental` category to GSDPreferences with `rtk: boolean` (default: false) - RTK is now opt-in: disabled by default for all projects unless explicitly enabled - Validate experimental.* keys; unknown experimental keys produce warnings Web UI: - Add ExperimentalPanel component with animated toggle switch per flag - Add /api/experimental route (GET/PATCH) to read/write flags in preferences.md - Add 'Experimental' tab to settings dialog sidebar nav (FlaskConical icon) - Include ExperimentalPanel at bottom of gsd-prefs mega-scroll - Fix toggle disabled state: trigger loadSettingsData for 'experimental' section and self-fetch on mount when data is absent Dashboard: - Gate RTK Saved metric card on rtkEnabled from live auto state (web) - Gate TUI dashboard RTK savings row on rtkEnabled - Gate TUI footer RTK status updates on experimental.rtk preference - Propagate rtkEnabled through AutoDashboardData → bridge-service → store Build: - Add scripts/build-if-stale.cjs: incremental build driver that skips each step (packages, root tsc, copy-resources, web) when output is newer than source; replaces full rebuild chain in gsd:web - Add scripts/web-stop.cjs: robust stop with registry + legacy PID + orphan sweep via pgrep; handles crash/restart orphaned next-server processes - gsd:web now uses build-if-stale.cjs (fast cold starts, instant when unchanged) - gsd:web:stop / gsd:web:stop:all use web-stop.cjs directly Fix: correct import path in rtk-status.ts (./preferences.js not ../preferences.js) * fix: restore em-dash encoding in package.json to match upstream * refactor(rtk): move command rewrite out of pi-coding-agent into GSD extension Per review feedback from igouss: pi-coding-agent should not be modified to add GSD-specific logic. Instead, add a proper extension point and wire RTK through it. Changes to packages/pi-coding-agent (extension API only — no RTK logic): - Add BashTransformEvent + BashTransformEventResult types to extension API - Add on('bash_transform') overload to ExtensionAPI interface - Add emitBashTransform() to ExtensionRunner (chains all handlers in order) - Call emitBashTransform() in wrapToolWithExtensions before bash tool execution - Export new types from extensions/index.ts and package index.ts - Revert all RTK-specific changes from bash-executor.ts, tools/bash.ts - Remove packages/pi-coding-agent/src/utils/rtk.ts entirely Changes to GSD extension: - Register bash_transform handler in register-hooks.ts that calls rewriteCommandWithRtk() from the existing shared/rtk.ts module - Handler is a no-op when RTK is disabled or not installed * fix: correct import path for shared/rtk.js in register-hooks * fix(tests): remove deleted pi-coding-agent/utils/rtk imports from execution seams test The RTK rewrite logic was moved out of pi-coding-agent into the GSD extension (bash_transform hook). Tests that directly imported the deleted utils/rtk.ts are removed; remaining tests verify the shared RTK module and GSD-layer surfaces that still call rewriteCommandWithRtk. --- .github/workflows/ci.yml | 64 +++ README.md | 2 + .../src/core/extensions/index.ts | 2 + .../src/core/extensions/runner.ts | 18 + .../src/core/extensions/types.ts | 21 + .../src/core/extensions/wrapper.ts | 9 + packages/pi-coding-agent/src/index.ts | 2 + .../modes/interactive/components/footer.ts | 5 +- scripts/postinstall.js | 169 ++++++- scripts/rtk-benchmark.mjs | 169 +++++++ src/cli.ts | 30 ++ src/loader.ts | 5 + .../extensions/async-jobs/async-bash-tool.ts | 4 +- .../extensions/bg-shell/interaction.ts | 4 +- .../extensions/bg-shell/process-manager.ts | 5 +- .../extensions/gsd/auto-dashboard.ts | 34 +- src/resources/extensions/gsd/auto.ts | 8 + .../gsd/bootstrap/register-hooks.ts | 17 + .../extensions/gsd/custom-verification.ts | 4 +- .../extensions/gsd/dashboard-overlay.ts | 7 + .../gsd/docs/preferences-reference.md | 15 + .../extensions/gsd/preferences-types.ts | 20 + .../extensions/gsd/preferences-validation.ts | 26 ++ src/resources/extensions/gsd/preferences.ts | 3 + src/resources/extensions/gsd/rtk-status.ts | 53 +++ .../extensions/gsd/templates/preferences.md | 2 + .../gsd/tests/auto-dashboard.test.ts | 16 + .../gsd/tests/custom-verification.test.ts | 33 ++ .../gsd/tests/derive-state-db.test.ts | 7 +- .../extensions/gsd/tests/dist-redirect.mjs | 37 +- .../extensions/gsd/tests/preferences.test.ts | 50 +++ .../extensions/gsd/verification-gate.ts | 4 +- .../extensions/shared/rtk-session-stats.ts | 249 +++++++++++ src/resources/extensions/shared/rtk.ts | 120 +++++ src/rtk.ts | 415 ++++++++++++++++++ src/tests/app-smoke.test.ts | 7 +- src/tests/footer-component.test.ts | 17 + src/tests/postinstall.test.ts | 6 +- src/tests/resolve-ts-loader.test.ts | 50 +++ src/tests/rtk-execution-seams.test.ts | 180 ++++++++ src/tests/rtk-session-stats.test.ts | 189 ++++++++ src/tests/rtk-test-utils.ts | 45 ++ src/tests/rtk.test.ts | 126 ++++++ src/tests/web-dashboard-rtk-contract.test.ts | 21 + src/tests/web-terminal-allowlist.test.ts | 28 ++ src/web/auto-dashboard-service.ts | 5 +- src/web/bridge-service.ts | 14 + src/web/settings-service.ts | 1 + web/app/api/experimental/route.ts | 110 +++++ web/app/api/terminal/sessions/route.ts | 16 +- web/app/api/terminal/stream/route.ts | 8 + web/components/gsd/command-surface.tsx | 12 +- web/components/gsd/dashboard.tsx | 23 +- web/components/gsd/loading-skeletons.tsx | 2 +- web/components/gsd/settings-panels.tsx | 160 +++++++ web/lib/command-surface-contract.ts | 1 + web/lib/gsd-workspace-store.tsx | 14 + web/lib/pty-manager.ts | 16 + web/lib/settings-types.ts | 3 + 59 files changed, 2629 insertions(+), 54 deletions(-) create mode 100644 scripts/rtk-benchmark.mjs create mode 100644 src/resources/extensions/gsd/rtk-status.ts create mode 100644 src/resources/extensions/shared/rtk-session-stats.ts create mode 100644 src/resources/extensions/shared/rtk.ts create mode 100644 src/rtk.ts create mode 100644 src/tests/footer-component.test.ts create mode 100644 src/tests/resolve-ts-loader.test.ts create mode 100644 src/tests/rtk-execution-seams.test.ts create mode 100644 src/tests/rtk-session-stats.test.ts create mode 100644 src/tests/rtk-test-utils.ts create mode 100644 src/tests/rtk.test.ts create mode 100644 src/tests/web-dashboard-rtk-contract.test.ts create mode 100644 src/tests/web-terminal-allowlist.test.ts create mode 100644 web/app/api/experimental/route.ts diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1dc5af360..4e0e5f64a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -176,3 +176,67 @@ jobs: - name: Run package tests run: npm run test:packages + + rtk-portability: + timeout-minutes: 20 + needs: detect-changes + if: needs.detect-changes.outputs.docs-only != 'true' + strategy: + fail-fast: false + matrix: + include: + - label: linux + os: blacksmith-4vcpu-ubuntu-2404 + - label: windows + os: blacksmith-4vcpu-windows-2025 + - label: macos + os: macos-15 + runs-on: ${{ matrix.os }} + + steps: + - name: Checkout repository + uses: actions/checkout@v6 + + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: '24' + cache: 'npm' + + - name: Install dependencies + env: + PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: '1' + run: npm ci + + - name: Validate managed RTK install + run: >- + node --experimental-strip-types --input-type=module -e + "const mod = await import('./src/rtk.ts'); + const path = mod.getManagedRtkPath(process.platform); + if (!mod.validateRtkBinary(path)) { + console.error('Managed RTK validation failed:', path); + process.exit(1); + } + console.log('Managed RTK validated at', path);" + + - name: Run RTK-focused portability tests + run: >- + node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs + --experimental-strip-types --experimental-test-isolation=process --test + src/tests/rtk.test.ts + src/tests/rtk-execution-seams.test.ts + src/tests/postinstall.test.ts + src/tests/app-smoke.test.ts + src/resources/extensions/gsd/tests/custom-verification.test.ts + src/resources/extensions/gsd/tests/verification-gate.test.ts + + - name: Generate RTK benchmark evidence + if: matrix.label == 'linux' + run: node scripts/rtk-benchmark.mjs --output .artifacts/rtk-benchmark.md + + - name: Upload RTK benchmark artifact + if: matrix.label == 'linux' + uses: actions/upload-artifact@v4 + with: + name: rtk-benchmark-linux + path: .artifacts/rtk-benchmark.md diff --git a/README.md b/README.md index b37c9b4f3..d7c624552 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,8 @@ One command. Walk away. Come back to a built project with clean git history. 
npm install -g gsd-pi@latest
+> GSD now provisions a managed [RTK](https://github.com/rtk-ai/rtk) binary on supported macOS, Linux, and Windows installs to compress shell-command output in `bash`, `async_bash`, `bg_shell`, and verification flows. GSD forces `RTK_TELEMETRY_DISABLED=1` for all managed invocations. Set `GSD_RTK_DISABLED=1` to disable the integration. + > **📋 NOTICE: New to Node on Mac?** If you installed Node.js via Homebrew, you may be running a development release instead of LTS. **[Read this guide](./docs/node-lts-macos.md)** to pin Node 24 LTS and avoid compatibility issues. diff --git a/packages/pi-coding-agent/src/core/extensions/index.ts b/packages/pi-coding-agent/src/core/extensions/index.ts index 5726741a4..1ef9b82a7 100644 --- a/packages/pi-coding-agent/src/core/extensions/index.ts +++ b/packages/pi-coding-agent/src/core/extensions/index.ts @@ -146,6 +146,8 @@ export type { // Events - User Bash UserBashEvent, UserBashEventResult, + BashTransformEvent, + BashTransformEventResult, WidgetPlacement, WriteToolCallEvent, WriteToolResultEvent, diff --git a/packages/pi-coding-agent/src/core/extensions/runner.ts b/packages/pi-coding-agent/src/core/extensions/runner.ts index cde7cfa57..da06f0f13 100644 --- a/packages/pi-coding-agent/src/core/extensions/runner.ts +++ b/packages/pi-coding-agent/src/core/extensions/runner.ts @@ -634,6 +634,24 @@ export class ExtensionRunner { return result; } + async emitBashTransform(command: string, cwd: string): Promise { + if (!this.hasHandlers("bash_transform")) return command; + + let current = command; + await this.invokeHandlers( + "bash_transform", + () => ({ type: "bash_transform" as const, command: current, cwd }), + (handlerResult) => { + const result = handlerResult as import("./types.js").BashTransformEventResult | undefined; + if (result?.command && result.command.trim()) { + current = result.command; + } + return { done: false }; // chain all handlers + }, + ); + return current; + } + async emitUserBash(event: UserBashEvent): Promise { let result: UserBashEventResult | undefined; diff --git a/packages/pi-coding-agent/src/core/extensions/types.ts b/packages/pi-coding-agent/src/core/extensions/types.ts index 0876568e4..8b6ff6ff1 100644 --- a/packages/pi-coding-agent/src/core/extensions/types.ts +++ b/packages/pi-coding-agent/src/core/extensions/types.ts @@ -607,6 +607,25 @@ export interface ModelSelectEvent { // User Bash Events // ============================================================================ +/** + * Fired before the bash tool executes a shell command. + * Extensions can return a transformed command string. + * All registered handlers are called in order; each receives the output of the previous. + */ +export interface BashTransformEvent { + type: "bash_transform"; + /** The command string about to be executed */ + command: string; + /** Current working directory */ + cwd: string; +} + +/** Result from bash_transform event handler */ +export interface BashTransformEventResult { + /** Replacement command string. If omitted or empty, the original command is used. */ + command?: string; +} + /** Fired when user executes a bash command via ! or !! prefix */ export interface UserBashEvent { type: "user_bash"; @@ -846,6 +865,7 @@ export type ExtensionEvent = | ToolExecutionUpdateEvent | ToolExecutionEndEvent | ModelSelectEvent + | BashTransformEvent | UserBashEvent | InputEvent | ToolCallEvent @@ -1027,6 +1047,7 @@ export interface ExtensionAPI { on(event: "tool_execution_update", handler: ExtensionHandler): void; on(event: "tool_execution_end", handler: ExtensionHandler): void; on(event: "model_select", handler: ExtensionHandler): void; + on(event: "bash_transform", handler: ExtensionHandler): void; on(event: "tool_call", handler: ExtensionHandler): void; on(event: "tool_result", handler: ExtensionHandler): void; on(event: "user_bash", handler: ExtensionHandler): void; diff --git a/packages/pi-coding-agent/src/core/extensions/wrapper.ts b/packages/pi-coding-agent/src/core/extensions/wrapper.ts index b8d050dfc..d328f7610 100644 --- a/packages/pi-coding-agent/src/core/extensions/wrapper.ts +++ b/packages/pi-coding-agent/src/core/extensions/wrapper.ts @@ -44,6 +44,15 @@ export function wrapToolWithExtensions(tool: AgentTool, runner: Exten signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback, ) => { + // For bash tool calls, let extensions transform the command before execution + if (tool.name === "bash" && runner.hasHandlers("bash_transform")) { + const input = params as { command?: string; cwd?: string }; + if (typeof input.command === "string") { + const transformed = await runner.emitBashTransform(input.command, input.cwd ?? ""); + params = { ...params, command: transformed }; + } + } + // Emit tool_call event - extensions can block execution if (runner.hasHandlers("tool_call")) { try { diff --git a/packages/pi-coding-agent/src/index.ts b/packages/pi-coding-agent/src/index.ts index e194e0324..b8bdcb430 100644 --- a/packages/pi-coding-agent/src/index.ts +++ b/packages/pi-coding-agent/src/index.ts @@ -125,6 +125,8 @@ export type { TurnStartEvent, UserBashEvent, UserBashEventResult, + BashTransformEvent, + BashTransformEventResult, WidgetPlacement, WriteToolCallEvent, } from "./core/extensions/index.js"; diff --git a/packages/pi-coding-agent/src/modes/interactive/components/footer.ts b/packages/pi-coding-agent/src/modes/interactive/components/footer.ts index 6a1c49d43..7a2b763bf 100644 --- a/packages/pi-coding-agent/src/modes/interactive/components/footer.ts +++ b/packages/pi-coding-agent/src/modes/interactive/components/footer.ts @@ -221,8 +221,9 @@ export class FooterComponent implements Component { .sort(([a], [b]) => a.localeCompare(b)) .map(([, text]) => sanitizeStatusText(text)); const statusLine = sortedStatuses.join(" "); - // Truncate to terminal width with dim ellipsis for consistency with footer style - lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "..."))); + // Match the rest of the footer styling: extension statuses should render + // in the same dim color as pwd/stats, with a dim ellipsis on truncation. + lines.push(truncateToWidth(theme.fg("dim", statusLine), width, theme.fg("dim", "..."))); } return lines; diff --git a/scripts/postinstall.js b/scripts/postinstall.js index a75953878..2e4b39776 100644 --- a/scripts/postinstall.js +++ b/scripts/postinstall.js @@ -1,23 +1,180 @@ #!/usr/bin/env node -import { exec as execCb } from 'child_process' -import { dirname, resolve } from 'path' +import { exec as execCb, spawnSync } from 'child_process' +import { createHash, randomUUID } from 'crypto' +import { chmodSync, copyFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'fs' +import { arch, homedir, platform } from 'os' +import { dirname, resolve, join } from 'path' +import { Readable } from 'stream' +import { finished } from 'stream/promises' +import extractZip from 'extract-zip' import { fileURLToPath } from 'url' const __dirname = dirname(fileURLToPath(import.meta.url)) const cwd = resolve(__dirname, '..') -const shouldSkip = +const PLAYWRIGHT_SKIP = process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === '1' || process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === 'true' +const RTK_SKIP = + process.env.GSD_SKIP_RTK_INSTALL === '1' || + process.env.GSD_SKIP_RTK_INSTALL === 'true' || + process.env.GSD_RTK_DISABLED === '1' || + process.env.GSD_RTK_DISABLED === 'true' + +const RTK_VERSION = '0.33.1' +const RTK_REPO = 'rtk-ai/rtk' +const RTK_ENV = { ...process.env, RTK_TELEMETRY_DISABLED: '1' } +const managedBinDir = join(process.env.GSD_HOME || join(homedir(), '.gsd'), 'agent', 'bin') +const managedBinaryPath = join(managedBinDir, platform() === 'win32' ? 'rtk.exe' : 'rtk') function run(cmd) { - return new Promise((resolve) => { + return new Promise((resolvePromise) => { execCb(cmd, { cwd }, (error, stdout, stderr) => { - resolve({ ok: !error, stdout, stderr }) + resolvePromise({ ok: !error, stdout, stderr }) }) }) } -if (!shouldSkip) { +function logWarn(message) { + process.stderr.write(`[gsd] postinstall: ${message}\n`) +} + +function resolveAssetName() { + const currentPlatform = platform() + const currentArch = arch() + if (currentPlatform === 'darwin' && currentArch === 'arm64') return 'rtk-aarch64-apple-darwin.tar.gz' + if (currentPlatform === 'darwin' && currentArch === 'x64') return 'rtk-x86_64-apple-darwin.tar.gz' + if (currentPlatform === 'linux' && currentArch === 'arm64') return 'rtk-aarch64-unknown-linux-gnu.tar.gz' + if (currentPlatform === 'linux' && currentArch === 'x64') return 'rtk-x86_64-unknown-linux-musl.tar.gz' + if (currentPlatform === 'win32' && currentArch === 'x64') return 'rtk-x86_64-pc-windows-msvc.zip' + return null +} + +function parseChecksums(text) { + const checksums = new Map() + for (const rawLine of text.split(/\r?\n/)) { + const line = rawLine.trim() + if (!line) continue + const match = line.match(/^([a-f0-9]{64})\s+(.+)$/i) + if (!match) continue + checksums.set(match[2], match[1].toLowerCase()) + } + return checksums +} + +function sha256File(path) { + const hash = createHash('sha256') + hash.update(readFileSync(path)) + return hash.digest('hex') +} + +async function downloadToFile(url, destination) { + const response = await fetch(url, { headers: { 'User-Agent': 'gsd-pi-postinstall' } }) + if (!response.ok) { + throw new Error(`download failed (${response.status}) for ${url}`) + } + if (!response.body) { + throw new Error(`download returned no body for ${url}`) + } + const output = createWriteStream(destination) + await finished(Readable.fromWeb(response.body).pipe(output)) +} + +function findBinaryRecursively(rootDir, binaryName) { + const stack = [rootDir] + while (stack.length > 0) { + const current = stack.pop() + if (!current) continue + const entries = readdirSync(current, { withFileTypes: true }) + for (const entry of entries) { + const fullPath = join(current, entry.name) + if (entry.isFile() && entry.name === binaryName) return fullPath + if (entry.isDirectory()) stack.push(fullPath) + } + } + return null +} + +function validateRtkBinary(binaryPath) { + const result = spawnSync(binaryPath, ['rewrite', 'git status'], { + encoding: 'utf-8', + env: RTK_ENV, + stdio: ['ignore', 'pipe', 'ignore'], + timeout: 5000, + }) + return !result.error && result.status === 0 && (result.stdout || '').trim() === 'rtk git status' +} + +async function ensureRtkInstalled() { + if (RTK_SKIP) return + const assetName = resolveAssetName() + if (!assetName) return + if (existsSync(managedBinaryPath) && validateRtkBinary(managedBinaryPath)) return + + const tempRoot = join(managedBinDir, `.rtk-postinstall-${randomUUID().slice(0, 8)}`) + const archivePath = join(tempRoot, assetName) + const extractDir = join(tempRoot, 'extract') + const releaseBase = `https://github.com/${RTK_REPO}/releases/download/v${RTK_VERSION}` + + mkdirSync(tempRoot, { recursive: true }) + mkdirSync(managedBinDir, { recursive: true }) + + try { + const checksumsResponse = await fetch(`${releaseBase}/checksums.txt`, { + headers: { 'User-Agent': 'gsd-pi-postinstall' }, + }) + if (!checksumsResponse.ok) { + throw new Error(`failed to fetch RTK checksums (${checksumsResponse.status})`) + } + + const checksums = parseChecksums(await checksumsResponse.text()) + const expectedSha = checksums.get(assetName) + if (!expectedSha) { + throw new Error(`missing checksum for ${assetName}`) + } + + await downloadToFile(`${releaseBase}/${assetName}`, archivePath) + const actualSha = sha256File(archivePath) + if (actualSha !== expectedSha) { + throw new Error(`checksum mismatch for ${assetName}`) + } + + mkdirSync(extractDir, { recursive: true }) + if (assetName.endsWith('.zip')) { + await extractZip(archivePath, { dir: extractDir }) + } else { + const extractResult = spawnSync('tar', ['xzf', archivePath, '-C', extractDir], { + encoding: 'utf-8', + timeout: 30000, + }) + if (extractResult.error || extractResult.status !== 0) { + throw new Error(extractResult.error?.message || extractResult.stderr?.trim() || `failed to extract ${assetName}`) + } + } + + const extractedBinary = findBinaryRecursively(extractDir, platform() === 'win32' ? 'rtk.exe' : 'rtk') + if (!extractedBinary) { + throw new Error(`RTK binary not found in ${assetName}`) + } + + copyFileSync(extractedBinary, managedBinaryPath) + if (platform() !== 'win32') { + chmodSync(managedBinaryPath, 0o755) + } + + if (!validateRtkBinary(managedBinaryPath)) { + rmSync(managedBinaryPath, { force: true }) + throw new Error('downloaded RTK binary failed validation') + } + } catch (error) { + logWarn(`RTK install skipped: ${error instanceof Error ? error.message : String(error)}`) + } finally { + rmSync(tempRoot, { recursive: true, force: true }) + } +} + +if (!PLAYWRIGHT_SKIP) { await run('npx playwright install chromium') } + +await ensureRtkInstalled() diff --git a/scripts/rtk-benchmark.mjs b/scripts/rtk-benchmark.mjs new file mode 100644 index 000000000..ef6480b85 --- /dev/null +++ b/scripts/rtk-benchmark.mjs @@ -0,0 +1,169 @@ +#!/usr/bin/env node + +import { spawnSync } from 'node:child_process' +import { homedir, tmpdir } from 'node:os' +import { join, dirname } from 'node:path' +import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs' + +function getManagedRtkPath() { + return join(homedir(), '.gsd', 'agent', 'bin', process.platform === 'win32' ? 'rtk.exe' : 'rtk') +} + +function run(command, args, options = {}) { + const result = spawnSync(command, args, { + encoding: 'utf-8', + stdio: ['ignore', 'pipe', 'pipe'], + ...options, + }) + if (result.error) throw result.error + return result +} + +function ensureOk(result, label) { + if (result.status !== 0) { + throw new Error(`${label} failed: ${result.stderr || result.stdout || `exit ${result.status}`}`) + } +} + +function createFixture(projectDir) { + mkdirSync(join(projectDir, 'src', 'components'), { recursive: true }) + + writeFileSync(join(projectDir, 'package.json'), JSON.stringify({ + name: 'gsd-rtk-benchmark', + version: '1.0.0', + scripts: { + test: 'node test.js', + }, + }, null, 2)) + + const testLines = [] + for (let i = 0; i < 120; i += 1) { + const group = i % 6 + testLines.push(`console.log('FAIL src/components/file${group}.test.ts:${i + 1}: expected value ${i}')`) + } + testLines.push('process.exit(1)') + writeFileSync(join(projectDir, 'test.js'), `${testLines.join('\n')}\n`) + + for (let i = 1; i <= 80; i += 1) { + writeFileSync( + join(projectDir, 'src', 'components', `file${i}.ts`), + `export function component_${i}() {\n return "value_${i}";\n}\n`, + ) + } + + ensureOk(run('git', ['init', '-q'], { cwd: projectDir }), 'git init') + ensureOk(run('git', ['config', 'user.email', 'benchmark@example.com'], { cwd: projectDir }), 'git config email') + ensureOk(run('git', ['config', 'user.name', 'Benchmark'], { cwd: projectDir }), 'git config name') + ensureOk(run('git', ['add', '.'], { cwd: projectDir }), 'git add') + ensureOk(run('git', ['commit', '-qm', 'init'], { cwd: projectDir }), 'git commit') + + for (let i = 1; i <= 25; i += 1) { + writeFileSync( + join(projectDir, 'src', 'components', `file${i}.ts`), + `export function component_${i}() {\n return "value_${i}";\n}\n// change ${i}\n`, + ) + } + + for (let i = 81; i <= 100; i += 1) { + writeFileSync( + join(projectDir, 'src', 'components', `file${i}.ts`), + `export const new_${i} = ${i}\n`, + ) + } +} + +function renderMarkdown({ summary, history, binaryPath }) { + const timestamp = new Date().toISOString() + return [ + '# RTK benchmark evidence', + '', + `- Generated: ${timestamp}`, + `- RTK binary: \`${binaryPath}\``, + `- Telemetry: disabled via \`RTK_TELEMETRY_DISABLED=1\``, + `- Fixture: synthetic git + find + ls + npm test workload`, + '', + '## Aggregate savings', + '', + '| Commands | Input tokens | Output tokens | Saved tokens | Savings | Avg command time |', + '| --- | ---: | ---: | ---: | ---: | ---: |', + `| ${summary.total_commands} | ${summary.total_input} | ${summary.total_output} | ${summary.total_saved} | ${summary.avg_savings_pct.toFixed(1)}% | ${summary.avg_time_ms} ms |`, + '', + '## Command breakdown', + '', + '```text', + history.trim(), + '```', + '', + '## Commands exercised', + '', + '- `git status`', + '- `git diff`', + '- `find src -type f`', + '- `ls -R src`', + '- `npm run test`', + '', + ].join('\n') +} + +function main() { + const outputIndex = process.argv.indexOf('--output') + const outputPath = outputIndex !== -1 ? process.argv[outputIndex + 1] : null + const binaryPath = process.env.GSD_RTK_PATH || getManagedRtkPath() + + if (!binaryPath) { + throw new Error('RTK binary path not resolved') + } + + const workspace = mkdtempSync(join(tmpdir(), 'gsd-rtk-benchmark-')) + const homeDir = join(workspace, 'home') + const projectDir = join(workspace, 'project') + mkdirSync(homeDir, { recursive: true }) + mkdirSync(projectDir, { recursive: true }) + + try { + createFixture(projectDir) + + const env = { + ...process.env, + HOME: homeDir, + RTK_TELEMETRY_DISABLED: '1', + } + + const commands = [ + ['git', 'status'], + ['git', 'diff'], + ['find', 'src', '-type', 'f'], + ['ls', '-R', 'src'], + ['npm', 'run', 'test'], + ] + + for (const command of commands) { + run(binaryPath, command, { cwd: projectDir, env }) + } + + const summaryJson = run(binaryPath, ['gain', '--all', '--format', 'json'], { cwd: projectDir, env }) + ensureOk(summaryJson, 'rtk gain --all --format json') + const historyText = run(binaryPath, ['gain', '--history'], { cwd: projectDir, env }) + ensureOk(historyText, 'rtk gain --history') + + const parsed = JSON.parse(summaryJson.stdout) + const markdown = renderMarkdown({ + summary: parsed.summary, + history: historyText.stdout, + binaryPath, + }) + + if (outputPath) { + mkdirSync(dirname(outputPath), { recursive: true }) + writeFileSync(outputPath, markdown, 'utf-8') + console.log(outputPath) + return + } + + console.log(markdown) + } finally { + rmSync(workspace, { recursive: true, force: true }) + } +} + +main() diff --git a/src/cli.ts b/src/cli.ts index f14cbe0c4..467760153 100644 --- a/src/cli.ts +++ b/src/cli.ts @@ -29,6 +29,8 @@ import { import { stopWebMode } from './web-mode.js' import { getProjectSessionsDir } from './project-sessions.js' import { markStartup, printStartupTimings } from './startup-timings.js' +import { bootstrapRtk, GSD_RTK_DISABLED_ENV } from './rtk.js' +import { loadEffectiveGSDPreferences } from './resources/extensions/gsd/preferences.js' // --------------------------------------------------------------------------- // V8 compile cache — Node 22+ can cache compiled bytecode across runs, @@ -146,6 +148,28 @@ if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listMode process.exit(1) } +async function ensureRtkBootstrap(): Promise { + if ((ensureRtkBootstrap as { _done?: boolean })._done) return + + // RTK is opt-in via experimental.rtk preference. Default: disabled. + // Honor GSD_RTK_DISABLED if already explicitly set in the environment + // (env var takes precedence over preferences for manual override). + if (!process.env[GSD_RTK_DISABLED_ENV]) { + const prefs = loadEffectiveGSDPreferences(); + const rtkEnabled = prefs?.preferences.experimental?.rtk === true; + if (!rtkEnabled) { + process.env[GSD_RTK_DISABLED_ENV] = "1"; + } + } + + const rtkStatus = await bootstrapRtk() + ;(ensureRtkBootstrap as { _done?: boolean })._done = true + markStartup('bootstrapRtk') + if (!rtkStatus.available && rtkStatus.supported && rtkStatus.enabled && rtkStatus.reason) { + process.stderr.write(`[gsd] Warning: RTK unavailable — continuing without shell-command compression (${rtkStatus.reason}).\n`) + } +} + // `gsd --help` — show subcommand-specific help const subcommand = cliFlags.messages[0] if (subcommand && process.argv.includes('--help')) { @@ -198,6 +222,7 @@ if (cliFlags.messages[0] === 'web' && cliFlags.messages[1] === 'stop') { // `gsd --web [path]` or `gsd web [start] [path]` — launch browser-only web mode if (cliFlags.web || (cliFlags.messages[0] === 'web' && cliFlags.messages[1] !== 'stop')) { + await ensureRtkBootstrap() const webFlags = parseWebCliArgs(process.argv) const webBranch = await runWebCliBranch(webFlags, { stderr: process.stderr, @@ -269,6 +294,7 @@ if (cliFlags.messages[0] === 'sessions') { // `gsd headless` — run auto-mode without TUI if (cliFlags.messages[0] === 'headless') { + await ensureRtkBootstrap() const { runHeadless, parseHeadlessArgs } = await import('./headless.js') await runHeadless(parseHeadlessArgs(process.argv)) process.exit(0) @@ -415,6 +441,7 @@ if (!settingsManager.getCollapseChangelog()) { // Print / subagent mode — single-shot execution, no TTY required // --------------------------------------------------------------------------- if (isPrintMode) { + await ensureRtkBootstrap() const sessionManager = cliFlags.noSession ? SessionManager.inMemory() : SessionManager.create(process.cwd()) @@ -542,6 +569,8 @@ if (!cliFlags.worktree && !isPrintMode) { // Interactive mode — normal TTY session // --------------------------------------------------------------------------- +await ensureRtkBootstrap() + // 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() @@ -659,3 +688,4 @@ const interactiveMode = new InteractiveMode(session) markStartup('InteractiveMode') printStartupTimings() await interactiveMode.run() + diff --git a/src/loader.ts b/src/loader.ts index 875956295..1d3ce46a2 100644 --- a/src/loader.ts +++ b/src/loader.ts @@ -71,6 +71,7 @@ if (firstArg === '--help' || firstArg === '-h') { } import { agentDir, appRoot } from './app-paths.js' +import { applyRtkProcessEnv } from './rtk.js' import { serializeBundledExtensionPaths } from './bundled-extension-paths.js' import { discoverExtensionEntryPaths } from './extension-discovery.js' import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-registry.js' @@ -109,6 +110,10 @@ if (!existsSync(appRoot)) { // GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.gsd/agent/ process.env.GSD_CODING_AGENT_DIR = agentDir +// RTK environment — make ~/.gsd/agent/bin visible to all child-process paths, +// not just the bash tool, and force-disable RTK telemetry for GSD-managed use. +applyRtkProcessEnv(process.env) + // NODE_PATH — make gsd's own node_modules available to extensions loaded via jiti. // Without this, extensions (e.g. browser-tools) can't resolve dependencies like // `playwright` because jiti resolves modules from pi-coding-agent's location, not gsd's. diff --git a/src/resources/extensions/async-jobs/async-bash-tool.ts b/src/resources/extensions/async-jobs/async-bash-tool.ts index a2b29b97b..4314b5c89 100644 --- a/src/resources/extensions/async-jobs/async-bash-tool.ts +++ b/src/resources/extensions/async-jobs/async-bash-tool.ts @@ -20,6 +20,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { randomBytes } from "node:crypto"; import type { AsyncJobManager } from "./job-manager.js"; +import { rewriteCommandWithRtk } from "../shared/rtk.js"; const schema = Type.Object({ command: Type.String({ description: "Bash command to execute in the background" }), @@ -114,7 +115,8 @@ function executeBashInBackground( const safeReject = (err: unknown) => { if (!settled) { settled = true; reject(err); } }; const { shell, args } = getShellConfig(); - const resolvedCommand = sanitizeCommand(command); + const rewrittenCommand = rewriteCommandWithRtk(command); + const resolvedCommand = sanitizeCommand(rewrittenCommand); const child = spawn(shell, [...args, resolvedCommand], { cwd, diff --git a/src/resources/extensions/bg-shell/interaction.ts b/src/resources/extensions/bg-shell/interaction.ts index 9fcac657d..274288c66 100644 --- a/src/resources/extensions/bg-shell/interaction.ts +++ b/src/resources/extensions/bg-shell/interaction.ts @@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto"; import type { BgProcess } from "./types.js"; +import { rewriteCommandWithRtk } from "../shared/rtk.js"; // ── Query Shell Environment ──────────────────────────────────────────────── @@ -128,9 +129,10 @@ export async function runOnSession( const startIndex = bg.output.length; // Write the sentinel-wrapped command to stdin + const rewrittenCommand = rewriteCommandWithRtk(command); const wrappedCommand = [ `echo ${startMarker}`, - command, + rewrittenCommand, `${exitVar}=$?`, `echo ${endMarker} $${exitVar}`, ].join("\n"); diff --git a/src/resources/extensions/bg-shell/process-manager.ts b/src/resources/extensions/bg-shell/process-manager.ts index fcff5f374..db707fb40 100644 --- a/src/resources/extensions/bg-shell/process-manager.ts +++ b/src/resources/extensions/bg-shell/process-manager.ts @@ -8,6 +8,7 @@ import { randomUUID } from "node:crypto"; import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs"; import { join } from "node:path"; import { getShellConfig, sanitizeCommand } from "@gsd/pi-coding-agent"; +import { rewriteCommandWithRtk } from "../shared/rtk.js"; import type { BgProcess, BgProcessInfo, @@ -127,7 +128,9 @@ export function startProcess(opts: StartOptions): BgProcess { const { shell, args: shellArgs } = getShellConfig(); // Shell sessions default to the user's shell if no command specified - const command = processType === "shell" && !opts.command ? shell : opts.command; + const command = processType === "shell" && !opts.command + ? shell + : rewriteCommandWithRtk(opts.command); const proc = spawn(shell, [...shellArgs, sanitizeCommand(command)], { cwd: opts.cwd, stdio: ["pipe", "pipe", "pipe"], diff --git a/src/resources/extensions/gsd/auto-dashboard.ts b/src/resources/extensions/gsd/auto-dashboard.ts index 5f0b5d21d..19d2433f4 100644 --- a/src/resources/extensions/gsd/auto-dashboard.ts +++ b/src/resources/extensions/gsd/auto-dashboard.ts @@ -26,6 +26,11 @@ import { getActiveWorktreeName } from "./worktree-command.js"; import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js"; import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js"; import { parseUnitId } from "./unit-id.js"; +import { + formatRtkSavingsLabel, + getRtkSessionSavings, + type RtkSessionSavings, +} from "../shared/rtk-session-stats.js"; // ─── UAT Slice Extraction ───────────────────────────────────────────────────── @@ -59,6 +64,10 @@ export interface AutoDashboardData { profileDowngraded?: boolean; /** Number of pending captures awaiting triage (0 if none or file missing) */ pendingCaptureCount: number; + /** RTK token savings for the current session, or null when unavailable. */ + rtkSavings?: RtkSessionSavings | null; + /** Whether RTK is enabled via experimental.rtk preference. False when not opted in. */ + rtkEnabled?: boolean; /** Cross-process: another auto-mode session detected via auto.lock (PID, startedAt) */ remoteSession?: { pid: number; startedAt: string; unitType: string; unitId: string }; } @@ -476,6 +485,19 @@ export function updateProgressWidget( let pulseBright = true; let cachedLines: string[] | undefined; let cachedWidth: number | undefined; + let cachedRtkLabel: string | null | undefined; + + const refreshRtkLabel = (): void => { + try { + const sessionId = ctx.sessionManager.getSessionId(); + const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null; + cachedRtkLabel = formatRtkSavingsLabel(savings); + } catch { + cachedRtkLabel = null; + } + }; + + refreshRtkLabel(); const pulseTimer = setInterval(() => { pulseBright = !pulseBright; @@ -487,12 +509,15 @@ export function updateProgressWidget( // task/slice completion mid-unit. Without this, the progress bar only // updates at dispatch time, appearing frozen during long-running units. // 15s (vs 5s) reduces synchronous file I/O on the hot path. - const progressRefreshTimer = mid ? setInterval(() => { + const progressRefreshTimer = setInterval(() => { try { - updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id); + if (mid) { + updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id); + } + refreshRtkLabel(); cachedLines = undefined; } catch { /* non-fatal */ } - }, 15_000) : null; + }, 15_000); return { render(width: number): string[] { @@ -776,6 +801,9 @@ export function updateProgressWidget( if (statsLine) { lines.push(rightAlign("", statsLine, width)); } + if (cachedRtkLabel) { + lines.push(rightAlign("", theme.fg("dim", cachedRtkLabel), width)); + } } // PWD line with last commit info right-aligned const lastCommit = getLastCommit(accessors.getBasePath()); diff --git a/src/resources/extensions/gsd/auto.ts b/src/resources/extensions/gsd/auto.ts index c807a878d..e09c62bd7 100644 --- a/src/resources/extensions/gsd/auto.ts +++ b/src/resources/extensions/gsd/auto.ts @@ -104,6 +104,7 @@ import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js"; +import { getRtkSessionSavings } from "../shared/rtk-session-stats.js"; import { initMetrics, resetMetrics, @@ -301,6 +302,11 @@ export { type AutoDashboardData } from "./auto-dashboard.js"; export function getAutoDashboardData(): AutoDashboardData { const ledger = getLedger(); const totals = ledger ? getProjectTotals(ledger.units) : null; + const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null; + const rtkSavings = sessionId && s.basePath + ? getRtkSessionSavings(s.basePath, sessionId) + : null; + const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true; // Pending capture count — lazy check, non-fatal let pendingCaptureCount = 0; try { @@ -323,6 +329,8 @@ export function getAutoDashboardData(): AutoDashboardData { totalCost: totals?.cost ?? 0, totalTokens: totals?.tokens.total ?? 0, pendingCaptureCount, + rtkSavings, + rtkEnabled, }; } diff --git a/src/resources/extensions/gsd/bootstrap/register-hooks.ts b/src/resources/extensions/gsd/bootstrap/register-hooks.ts index 9de7759e8..07d385584 100644 --- a/src/resources/extensions/gsd/bootstrap/register-hooks.ts +++ b/src/resources/extensions/gsd/bootstrap/register-hooks.ts @@ -16,6 +16,8 @@ import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markTool import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js"; import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js"; import { saveActivityLog } from "../activity-log.js"; +import { startRtkStatusUpdates, stopRtkStatusUpdates } from "../rtk-status.js"; +import { rewriteCommandWithRtk } from "../../shared/rtk.js"; // Skip the welcome screen on the very first session_start — cli.ts already // printed it before the TUI launched. Only re-print on /clear (subsequent sessions). @@ -27,10 +29,19 @@ async function syncServiceTierStatus(ctx: ExtensionContext): Promise { } export function registerHooks(pi: ExtensionAPI): void { + // Route all agent bash tool commands through RTK rewrite when opted in. + // This is a no-op when RTK is disabled or not installed. + pi.on("bash_transform", async (event) => { + const rewritten = rewriteCommandWithRtk(event.command); + if (rewritten === event.command) return undefined; + return { command: rewritten }; + }); + pi.on("session_start", async (_event, ctx) => { resetWriteGateState(); resetToolCallLoopGuard(); await syncServiceTierStatus(ctx); + startRtkStatusUpdates(ctx); // Apply show_token_cost preference (#1515) try { @@ -75,6 +86,11 @@ export function registerHooks(pi: ExtensionAPI): void { clearDiscussionFlowState(); await syncServiceTierStatus(ctx); loadToolApiKeys(); + startRtkStatusUpdates(ctx); + }); + + pi.on("session_fork", async (_event, ctx) => { + startRtkStatusUpdates(ctx); }); pi.on("before_agent_start", async (event, ctx: ExtensionContext) => { @@ -123,6 +139,7 @@ export function registerHooks(pi: ExtensionAPI): void { }); pi.on("session_shutdown", async (_event, ctx: ExtensionContext) => { + stopRtkStatusUpdates(ctx); if (isParallelActive()) { try { await shutdownParallel(process.cwd()); diff --git a/src/resources/extensions/gsd/custom-verification.ts b/src/resources/extensions/gsd/custom-verification.ts index 6c9a28b72..4d60c507b 100644 --- a/src/resources/extensions/gsd/custom-verification.ts +++ b/src/resources/extensions/gsd/custom-verification.ts @@ -22,6 +22,7 @@ import { join, resolve, sep } from "node:path"; import { spawnSync } from "node:child_process"; import type { StepDefinition, VerifyPolicy } from "./definition-loader.js"; import { readFrozenDefinition } from "./custom-workflow-engine.js"; +import { rewriteCommandWithRtk } from "../shared/rtk.js"; /** Verification outcome type — matches ExecutionPolicy.verify() return type. */ export type VerificationOutcome = "continue" | "retry" | "pause"; @@ -164,7 +165,8 @@ function handleShellCommand( return "pause"; } - const result = spawnSync("sh", ["-c", verify.command], { + const rewrittenCommand = rewriteCommandWithRtk(verify.command); + const result = spawnSync("sh", ["-c", rewrittenCommand], { cwd: runDir, timeout: 30_000, encoding: "utf-8", diff --git a/src/resources/extensions/gsd/dashboard-overlay.ts b/src/resources/extensions/gsd/dashboard-overlay.ts index cf5d59db9..26926cf97 100644 --- a/src/resources/extensions/gsd/dashboard-overlay.ts +++ b/src/resources/extensions/gsd/dashboard-overlay.ts @@ -557,6 +557,13 @@ export class GSDDashboardOverlay { if (cacheRate > 0) { lines.push(row(`${th.fg("dim", "cache hit rate:")} ${th.fg("text", `${cacheRate}%`)}`)); } + + if (this.dashData.rtkEnabled && this.dashData.rtkSavings && this.dashData.rtkSavings.commands > 0) { + const rtk = this.dashData.rtkSavings; + lines.push(row( + `${th.fg("dim", "rtk saved:")} ${th.fg("text", formatTokenCount(rtk.savedTokens))} ${th.fg("dim", `(${Math.round(rtk.savingsPct)}% · ${rtk.commands} cmd${rtk.commands === 1 ? "" : "s"})`)}`, + )); + } } // Environment health section (#1221) — only show issues diff --git a/src/resources/extensions/gsd/docs/preferences-reference.md b/src/resources/extensions/gsd/docs/preferences-reference.md index f3b2ccd0f..5afeff2bd 100644 --- a/src/resources/extensions/gsd/docs/preferences-reference.md +++ b/src/resources/extensions/gsd/docs/preferences-reference.md @@ -241,6 +241,9 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea **Known unit types for `before`/`after`:** `research-milestone`, `plan-milestone`, `research-slice`, `plan-slice`, `execute-task`, `complete-slice`, `replan-slice`, `reassess-roadmap`, `run-uat`. +- `experimental`: opt-in experimental features. All features here are **off by default** — you must explicitly set each one to `true` to enable it. Features in this block may change or be removed without a deprecation cycle while in experimental status. Keys: + - `rtk`: boolean — enable RTK (Real-Time Kompression) shell-command compression. When enabled, GSD wraps shell commands through the RTK binary to reduce token usage during command execution. RTK is downloaded automatically on first use if not already installed. **Default: `false`** (opt-in required). Set `GSD_RTK_DISABLED=1` in the environment to force-disable regardless of this preference. + --- ## Best Practices @@ -652,3 +655,15 @@ verification_max_retries: 2 ``` Runs test, lint, and typecheck after each task. On failure, auto-fix is attempted up to 2 times before reporting the issue. + +## Experimental Features Example + +```yaml +--- +version: 1 +experimental: + rtk: true +--- +``` + +Opts in to RTK shell-command compression. RTK is downloaded automatically on first use. Set `GSD_RTK_DISABLED=1` to force-disable at the environment level regardless of this setting. diff --git a/src/resources/extensions/gsd/preferences-types.ts b/src/resources/extensions/gsd/preferences-types.ts index bfad606e4..e385b6914 100644 --- a/src/resources/extensions/gsd/preferences-types.ts +++ b/src/resources/extensions/gsd/preferences-types.ts @@ -93,6 +93,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([ "service_tier", "forensics_dedup", "show_token_cost", + "experimental", ]); /** Canonical list of all dispatch unit types. */ @@ -182,6 +183,20 @@ export interface CmuxPreferences { browser?: boolean; } +/** + * Opt-in experimental features. All features in this block are disabled by + * default and must be explicitly enabled. They may change or be removed without + * a deprecation cycle while in experimental status. + */ +export interface ExperimentalPreferences { + /** + * Enable RTK (Real-Time Kompression) shell-command compression. + * RTK wraps shell commands to reduce token usage during command execution. + * Default: false (opt-in required). + */ + rtk?: boolean; +} + export interface GSDPreferences { version?: number; mode?: WorkflowMode; @@ -233,6 +248,11 @@ export interface GSDPreferences { forensics_dedup?: boolean; /** Opt-in: show per-prompt and cumulative session token cost in the footer. Default: false. */ show_token_cost?: boolean; + /** + * Opt-in experimental features. All features here are disabled by default. + * See the preferences reference for details on each feature. + */ + experimental?: ExperimentalPreferences; } export interface LoadedGSDPreferences { diff --git a/src/resources/extensions/gsd/preferences-validation.ts b/src/resources/extensions/gsd/preferences-validation.ts index 733035e84..6b4e0e217 100644 --- a/src/resources/extensions/gsd/preferences-validation.ts +++ b/src/resources/extensions/gsd/preferences-validation.ts @@ -793,5 +793,31 @@ export function validatePreferences(preferences: GSDPreferences): { } } + // ─── Experimental Features ──────────────────────────────────────── + if (preferences.experimental !== undefined) { + if (typeof preferences.experimental === "object" && preferences.experimental !== null) { + const exp = preferences.experimental as unknown as Record; + const validExp: import("./preferences-types.js").ExperimentalPreferences = {}; + + if (exp.rtk !== undefined) { + if (typeof exp.rtk === "boolean") validExp.rtk = exp.rtk; + else errors.push("experimental.rtk must be a boolean"); + } + + const knownExpKeys = new Set(["rtk"]); + for (const key of Object.keys(exp)) { + if (!knownExpKeys.has(key)) { + warnings.push(`unknown experimental key "${key}" — ignored`); + } + } + + if (Object.keys(validExp).length > 0) { + validated.experimental = validExp; + } + } else { + errors.push("experimental must be an object"); + } + } + return { preferences: validated, errors, warnings }; } diff --git a/src/resources/extensions/gsd/preferences.ts b/src/resources/extensions/gsd/preferences.ts index df207d1f8..0b0b82927 100644 --- a/src/resources/extensions/gsd/preferences.ts +++ b/src/resources/extensions/gsd/preferences.ts @@ -353,6 +353,9 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr service_tier: override.service_tier ?? base.service_tier, forensics_dedup: override.forensics_dedup ?? base.forensics_dedup, show_token_cost: override.show_token_cost ?? base.show_token_cost, + experimental: (base.experimental || override.experimental) + ? { ...(base.experimental ?? {}), ...(override.experimental ?? {}) } + : undefined, }; } diff --git a/src/resources/extensions/gsd/rtk-status.ts b/src/resources/extensions/gsd/rtk-status.ts new file mode 100644 index 000000000..f3f519cdf --- /dev/null +++ b/src/resources/extensions/gsd/rtk-status.ts @@ -0,0 +1,53 @@ +import type { ExtensionContext } from "@gsd/pi-coding-agent"; +import { + ensureRtkSessionBaseline, + formatRtkSavingsLabel, + getRtkSessionSavings, +} from "../shared/rtk-session-stats.js"; +import { loadEffectiveGSDPreferences } from "./preferences.js"; + +const STATUS_KEY = "gsd-rtk"; +const REFRESH_INTERVAL_MS = 30_000; + +let refreshTimer: ReturnType | null = null; + +function clearTimer(): void { + if (refreshTimer) { + clearInterval(refreshTimer); + refreshTimer = null; + } +} + +function isRtkEnabledInPrefs(): boolean { + return loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true; +} + +function updateStatus(ctx: ExtensionContext): void { + if (!ctx.hasUI) return; + if (!isRtkEnabledInPrefs()) return; + + const basePath = ctx.cwd; + const sessionId = ctx.sessionManager.getSessionId(); + ensureRtkSessionBaseline(basePath, sessionId); + const savings = getRtkSessionSavings(basePath, sessionId); + ctx.ui.setStatus(STATUS_KEY, formatRtkSavingsLabel(savings) ?? undefined); +} + +export function startRtkStatusUpdates(ctx: ExtensionContext): void { + clearTimer(); + if (!isRtkEnabledInPrefs()) { + // Ensure any previously set status is cleared (e.g. preference was toggled off) + ctx.ui.setStatus(STATUS_KEY, undefined); + return; + } + updateStatus(ctx); + if (!ctx.hasUI) return; + refreshTimer = setInterval(() => { + updateStatus(ctx); + }, REFRESH_INTERVAL_MS); +} + +export function stopRtkStatusUpdates(ctx?: ExtensionContext): void { + clearTimer(); + ctx?.ui.setStatus(STATUS_KEY, undefined); +} diff --git a/src/resources/extensions/gsd/templates/preferences.md b/src/resources/extensions/gsd/templates/preferences.md index 83fcde1a2..878e2ccdf 100644 --- a/src/resources/extensions/gsd/templates/preferences.md +++ b/src/resources/extensions/gsd/templates/preferences.md @@ -71,6 +71,8 @@ remote_questions: uat_dispatch: post_unit_hooks: [] pre_dispatch_hooks: [] +# experimental: +# rtk: false --- # GSD Skill Preferences diff --git a/src/resources/extensions/gsd/tests/auto-dashboard.test.ts b/src/resources/extensions/gsd/tests/auto-dashboard.test.ts index 4ca0836f9..b772b1e48 100644 --- a/src/resources/extensions/gsd/tests/auto-dashboard.test.ts +++ b/src/resources/extensions/gsd/tests/auto-dashboard.test.ts @@ -1,5 +1,7 @@ import test from "node:test"; import assert from "node:assert/strict"; +import { readFileSync } from "node:fs"; +import { join } from "node:path"; import { unitVerb, @@ -11,6 +13,9 @@ import { extractUatSliceId, } from "../auto-dashboard.ts"; +const autoSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto.ts"), "utf-8"); +const dashboardSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto-dashboard.ts"), "utf-8"); + // ─── unitVerb ───────────────────────────────────────────────────────────── test("unitVerb maps known unit types to verbs", () => { @@ -180,6 +185,17 @@ test("formatAutoElapsed returns empty string for negative autoStartTime", () => assert.equal(formatAutoElapsed(NaN), ""); }); +test("getAutoDashboardData returns RTK savings in the dashboard payload", () => { + assert.match(autoSource, /const rtkSavings = sessionId && s\.basePath/); + assert.match(autoSource, /rtkSavings,/); +}); + +test("auto progress widget renders RTK savings under the footer stats line", () => { + assert.match(dashboardSource, /formatRtkSavingsLabel/); + assert.match(dashboardSource, /getRtkSessionSavings\(accessors\.getBasePath\(\), sessionId\)/); + assert.match(dashboardSource, /lines\.push\(rightAlign\("", theme\.fg\("dim", cachedRtkLabel\), width\)\);/); +}); + // ─── extractUatSliceId ─────────────────────────────────────────────────── test("extractUatSliceId extracts slice ID from M001/S01 format", () => { diff --git a/src/resources/extensions/gsd/tests/custom-verification.test.ts b/src/resources/extensions/gsd/tests/custom-verification.test.ts index 700a9bd15..62e49aa6f 100644 --- a/src/resources/extensions/gsd/tests/custom-verification.test.ts +++ b/src/resources/extensions/gsd/tests/custom-verification.test.ts @@ -15,6 +15,7 @@ import { tmpdir } from "node:os"; import { stringify } from "yaml"; import { runCustomVerification } from "../custom-verification.ts"; import type { WorkflowDefinition } from "../definition-loader.ts"; +import { createFakeRtk } from "../../../../tests/rtk-test-utils.ts"; /** Create a temp run directory with the given definition and optional files. */ function makeTempRun( @@ -225,6 +226,38 @@ describe("shell-command policy", () => { const result = runCustomVerification(runDir, "step-1"); assert.equal(result, "retry"); }); + + it("rewrites shell-command verification through RTK when available", () => { + const fake = createFakeRtk({ + "echo raw": "echo rewritten", + }); + const previous = process.env.GSD_RTK_PATH; + process.env.GSD_RTK_PATH = fake.path; + + try { + const def = makeDef([ + { + id: "step-1", + name: "Build artifact", + prompt: "Build the artifact", + requires: [], + produces: ["artifact.txt"], + verify: { + policy: "shell-command", + command: "echo raw", + }, + }, + ]); + + const runDir = makeTempRun(def); + const result = runCustomVerification(runDir, "step-1"); + assert.equal(result, "continue"); + } finally { + if (previous === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previous; + fake.cleanup(); + } + }); }); // ─── prompt-verify tests ──────────────────────────────────────────────── diff --git a/src/resources/extensions/gsd/tests/derive-state-db.test.ts b/src/resources/extensions/gsd/tests/derive-state-db.test.ts index 307a51c29..a0d98b6fd 100644 --- a/src/resources/extensions/gsd/tests/derive-state-db.test.ts +++ b/src/resources/extensions/gsd/tests/derive-state-db.test.ts @@ -769,9 +769,10 @@ describe('derive-state-db', async () => { const elapsed = performance.now() - start; console.log(` deriveStateFromDb() took ${elapsed.toFixed(3)}ms`); - // Use 10ms threshold — catches real regressions without flaking on - // CI runners under load (1ms threshold failed at 1.050ms on GitHub Actions) - assert.ok(elapsed < 10, `perf-db: deriveStateFromDb() <10ms (got ${elapsed.toFixed(3)}ms)`); + // Use 25ms threshold — catches real regressions without flaking on + // slower CI runners (Windows agents measured at ~12ms under load; + // the 10ms threshold was too tight for those environments). + assert.ok(elapsed < 25, `perf-db: deriveStateFromDb() <25ms (got ${elapsed.toFixed(3)}ms)`); closeDatabase(); } finally { diff --git a/src/resources/extensions/gsd/tests/dist-redirect.mjs b/src/resources/extensions/gsd/tests/dist-redirect.mjs index 6188d54a4..8fdf93c5b 100644 --- a/src/resources/extensions/gsd/tests/dist-redirect.mjs +++ b/src/resources/extensions/gsd/tests/dist-redirect.mjs @@ -7,17 +7,28 @@ const require = createRequire(import.meta.url); const ROOT = new URL("../../../../../", import.meta.url); export function resolve(specifier, context, nextResolve) { - // 1. Direct redirects to dist/ for specific packages + // 1. Redirect all workspace package bare imports to source. + // CI portability runs don't build any packages/ dist artifacts, so every + // @gsd/* specifier (including transitive ones pulled in by pi-coding-agent + // source itself) must resolve to the TypeScript source entrypoint. if (specifier === "../../packages/pi-coding-agent/src/index.js") { - specifier = new URL("packages/pi-coding-agent/dist/index.js", ROOT).href; + specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href; + } else if (specifier === "@gsd/pi-coding-agent") { + specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href; } else if (specifier === "@gsd/pi-ai/oauth") { - specifier = new URL("packages/pi-ai/dist/utils/oauth/index.js", ROOT).href; + specifier = new URL("packages/pi-ai/src/utils/oauth/index.ts", ROOT).href; } else if (specifier === "@gsd/pi-ai") { - specifier = new URL("packages/pi-ai/dist/index.js", ROOT).href; + specifier = new URL("packages/pi-ai/src/index.ts", ROOT).href; } else if (specifier === "@gsd/pi-agent-core") { - specifier = new URL("packages/pi-agent-core/dist/index.js", ROOT).href; + specifier = new URL("packages/pi-agent-core/src/index.ts", ROOT).href; } else if (specifier === "@gsd/pi-tui") { - specifier = new URL("packages/pi-tui/dist/index.js", ROOT).href; + specifier = new URL("packages/pi-tui/src/index.ts", ROOT).href; + } else if (specifier === "@gsd/native") { + specifier = new URL("packages/native/src/index.ts", ROOT).href; + } else if (specifier.startsWith("@gsd/native/")) { + // Sub-path imports like @gsd/native/fd, @gsd/native/text, etc. + const subpath = specifier.slice("@gsd/native/".length); + specifier = new URL(`packages/native/src/${subpath}/index.ts`, 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. @@ -54,9 +65,15 @@ export function resolve(specifier, context, nextResolve) { } 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')) { + // Node's --experimental-strip-types handles plain .ts but not .tsx and not + // all TypeScript syntax used by workspace packages (parameter properties, + // decorators, etc.). Transpile all workspace package source files and .tsx + // files through TypeScript's transpileModule to avoid those crashes. + const shouldTranspileWithTypeScript = + url.endsWith('.tsx') || + (url.endsWith('.ts') && url.includes('/packages/') && url.includes('/src/')); + + if (shouldTranspileWithTypeScript) { const ts = require('typescript'); const source = readFileSync(fileURLToPath(url), 'utf-8'); const { outputText } = ts.transpileModule(source, { @@ -66,6 +83,8 @@ export function load(url, context, nextLoad) { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ESNext, esModuleInterop: true, + experimentalDecorators: true, + emitDecoratorMetadata: true, }, }); return { format: 'module', source: outputText, shortCircuit: true }; diff --git a/src/resources/extensions/gsd/tests/preferences.test.ts b/src/resources/extensions/gsd/tests/preferences.test.ts index 8c8e3d198..f2c033784 100644 --- a/src/resources/extensions/gsd/tests/preferences.test.ts +++ b/src/resources/extensions/gsd/tests/preferences.test.ts @@ -377,3 +377,53 @@ test("unrecognized format warning is emitted at most once (#2373)", () => { _resetParseWarningFlag(); } }); + +// ── Experimental preferences ───────────────────────────────────────────────── + +test("experimental.rtk: true is accepted and stored", () => { + const result = validatePreferences({ experimental: { rtk: true } }); + assert.deepEqual(result.errors, []); + assert.equal(result.preferences.experimental?.rtk, true); +}); + +test("experimental.rtk: false is accepted and stored", () => { + const result = validatePreferences({ experimental: { rtk: false } }); + assert.deepEqual(result.errors, []); + assert.equal(result.preferences.experimental?.rtk, false); +}); + +test("experimental.rtk: non-boolean produces error", () => { + const result = validatePreferences({ experimental: { rtk: "yes" } } as unknown as GSDPreferences); + assert.ok(result.errors.some(e => e.includes("experimental.rtk")), `expected rtk error in: ${JSON.stringify(result.errors)}`); +}); + +test("experimental: non-object produces error", () => { + const result = validatePreferences({ experimental: true } as unknown as GSDPreferences); + assert.ok(result.errors.some(e => e.includes("experimental must be an object"))); +}); + +test("experimental: unknown key produces warning", () => { + const result = validatePreferences({ experimental: { rtk: true, future_flag: true } } as unknown as GSDPreferences); + assert.ok(result.warnings.some(w => w.includes("future_flag")), `expected unknown-key warning in: ${JSON.stringify(result.warnings)}`); + assert.equal(result.preferences.experimental?.rtk, true); +}); + +test("experimental: omitting rtk defaults to undefined (opt-in)", () => { + const result = validatePreferences({ version: 1 }); + assert.equal(result.preferences.experimental, undefined); +}); + +test("experimental.rtk parses correctly from preferences markdown", () => { + const content = "---\nversion: 1\nexperimental:\n rtk: true\n---\n"; + const prefs = parsePreferencesMarkdown(content); + assert.notEqual(prefs, null); + assert.equal(prefs!.experimental?.rtk, true); +}); + +test("experimental.rtk defaults to off in new project preferences", () => { + // No experimental key → feature is disabled + const content = "---\nversion: 1\n---\n"; + const prefs = parsePreferencesMarkdown(content); + assert.notEqual(prefs, null); + assert.equal(prefs!.experimental?.rtk, undefined); +}); diff --git a/src/resources/extensions/gsd/verification-gate.ts b/src/resources/extensions/gsd/verification-gate.ts index 91f504df4..220597772 100644 --- a/src/resources/extensions/gsd/verification-gate.ts +++ b/src/resources/extensions/gsd/verification-gate.ts @@ -8,6 +8,7 @@ import { existsSync, readFileSync } from "node:fs"; import { join, basename } from "node:path"; import type { AuditWarning, RuntimeError, VerificationCheck, VerificationResult } from "./types.js"; import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js"; +import { rewriteCommandWithRtk } from "../shared/rtk.js"; /** Maximum bytes of stdout/stderr to retain per command (10 KB). */ const MAX_OUTPUT_BYTES = 10 * 1024; @@ -257,10 +258,11 @@ export function runVerificationGate(options: RunVerificationGateOptions): Verifi for (const command of commands) { const start = Date.now(); + const rewrittenCommand = rewriteCommandWithRtk(command); // Pass the command string as an argument to the shell explicitly // to avoid Node.js DEP0190 (spawnSync with shell: true and no args). const shellBin = process.platform === "win32" ? "cmd" : "sh"; - const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command]; + const shellArgs = process.platform === "win32" ? ["/c", rewrittenCommand] : ["-c", rewrittenCommand]; const result: SpawnSyncReturns = spawnSync(shellBin, shellArgs, { cwd: options.cwd, stdio: "pipe", diff --git a/src/resources/extensions/shared/rtk-session-stats.ts b/src/resources/extensions/shared/rtk-session-stats.ts new file mode 100644 index 000000000..4de3ae0dd --- /dev/null +++ b/src/resources/extensions/shared/rtk-session-stats.ts @@ -0,0 +1,249 @@ +import { spawnSync } from "node:child_process"; +import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"; +import { join } from "node:path"; + +import { gsdRoot } from "../gsd/paths.js"; +import { formatTokenCount } from "./format-utils.js"; +import { buildRtkEnv, isRtkEnabled, resolveRtkBinaryPath } from "./rtk.js"; + +const SESSION_BASELINES_FILE = "rtk-session-baselines.json"; +const CURRENT_SUMMARY_TTL_MS = 15_000; +const CURRENT_SUMMARY_TIMEOUT_MS = 5_000; +const MAX_BASELINE_SESSIONS = 200; + +export interface RtkGainSummary { + totalCommands: number; + totalInput: number; + totalOutput: number; + totalSaved: number; + avgSavingsPct: number; + totalTimeMs: number; + avgTimeMs: number; +} + +export interface RtkSessionSavings { + commands: number; + inputTokens: number; + outputTokens: number; + savedTokens: number; + savingsPct: number; + totalTimeMs: number; + avgTimeMs: number; + updatedAt: string; +} + +interface BaselineEntry { + summary: RtkGainSummary; + createdAt: string; + updatedAt: string; +} + +interface BaselineStore { + version: 1; + sessions: Record; +} + +let cachedSummary: { at: number; binaryPath: string; summary: RtkGainSummary | null } | null = null; + +function getRuntimeDir(basePath: string): string { + return join(gsdRoot(basePath), "runtime"); +} + +function getBaselinesPath(basePath: string): string { + return join(getRuntimeDir(basePath), SESSION_BASELINES_FILE); +} + +function defaultStore(): BaselineStore { + return { version: 1, sessions: {} }; +} + +function loadBaselineStore(basePath: string): BaselineStore { + const path = getBaselinesPath(basePath); + if (!existsSync(path)) return defaultStore(); + try { + const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial; + if (parsed.version !== 1 || typeof parsed.sessions !== "object" || parsed.sessions === null) { + return defaultStore(); + } + return { + version: 1, + sessions: parsed.sessions as Record, + }; + } catch { + return defaultStore(); + } +} + +function saveBaselineStore(basePath: string, store: BaselineStore): void { + const runtimeDir = getRuntimeDir(basePath); + mkdirSync(runtimeDir, { recursive: true }); + + const entries = Object.entries(store.sessions) + .sort((left, right) => right[1].updatedAt.localeCompare(left[1].updatedAt)) + .slice(0, MAX_BASELINE_SESSIONS); + + const normalized: BaselineStore = { + version: 1, + sessions: Object.fromEntries(entries), + }; + + writeFileSync(getBaselinesPath(basePath), JSON.stringify(normalized, null, 2), "utf-8"); +} + +function normalizeSummary(raw: unknown): RtkGainSummary | null { + if (!raw || typeof raw !== "object") return null; + const summary = raw as Record; + return { + totalCommands: Number(summary.total_commands ?? 0), + totalInput: Number(summary.total_input ?? 0), + totalOutput: Number(summary.total_output ?? 0), + totalSaved: Number(summary.total_saved ?? 0), + avgSavingsPct: Number(summary.avg_savings_pct ?? 0), + totalTimeMs: Number(summary.total_time_ms ?? 0), + avgTimeMs: Number(summary.avg_time_ms ?? 0), + }; +} + +export function readCurrentRtkGainSummary(env: NodeJS.ProcessEnv = process.env): RtkGainSummary | null { + if (!isRtkEnabled(env)) return null; + + const binaryPath = resolveRtkBinaryPath({ env }); + if (!binaryPath) return null; + + if ( + cachedSummary && + cachedSummary.binaryPath === binaryPath && + Date.now() - cachedSummary.at < CURRENT_SUMMARY_TTL_MS + ) { + return cachedSummary.summary; + } + + const result = spawnSync(binaryPath, ["gain", "--all", "--format", "json"], { + encoding: "utf-8", + env: buildRtkEnv(env), + stdio: ["ignore", "pipe", "ignore"], + timeout: CURRENT_SUMMARY_TIMEOUT_MS, + // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows + shell: /\.(cmd|bat)$/i.test(binaryPath), + }); + + if (result.error || result.status !== 0) { + cachedSummary = { at: Date.now(), binaryPath, summary: null }; + return null; + } + + try { + const parsed = JSON.parse(result.stdout ?? "{}") as { summary?: unknown }; + const summary = normalizeSummary(parsed.summary ?? null); + cachedSummary = { at: Date.now(), binaryPath, summary }; + return summary; + } catch { + cachedSummary = { at: Date.now(), binaryPath, summary: null }; + return null; + } +} + +function computeSavingsDelta(current: RtkGainSummary, baseline: RtkGainSummary): RtkSessionSavings { + const commands = Math.max(0, current.totalCommands - baseline.totalCommands); + const inputTokens = Math.max(0, current.totalInput - baseline.totalInput); + const outputTokens = Math.max(0, current.totalOutput - baseline.totalOutput); + const savedTokens = Math.max(0, current.totalSaved - baseline.totalSaved); + const totalTimeMs = Math.max(0, current.totalTimeMs - baseline.totalTimeMs); + const avgTimeMs = commands > 0 ? Math.round(totalTimeMs / commands) : 0; + const savingsPct = inputTokens > 0 ? (savedTokens / inputTokens) * 100 : 0; + + return { + commands, + inputTokens, + outputTokens, + savedTokens, + savingsPct, + totalTimeMs, + avgTimeMs, + updatedAt: new Date().toISOString(), + }; +} + +export function ensureRtkSessionBaseline( + basePath: string, + sessionId: string, + env: NodeJS.ProcessEnv = process.env, +): RtkGainSummary | null { + if (!sessionId) return null; + + const current = readCurrentRtkGainSummary(env); + if (!current) return null; + + const store = loadBaselineStore(basePath); + const existing = store.sessions[sessionId]; + if (existing) return existing.summary; + + const now = new Date().toISOString(); + store.sessions[sessionId] = { + summary: current, + createdAt: now, + updatedAt: now, + }; + saveBaselineStore(basePath, store); + return current; +} + +export function getRtkSessionSavings( + basePath: string, + sessionId: string | null | undefined, + env: NodeJS.ProcessEnv = process.env, +): RtkSessionSavings | null { + if (!sessionId) return null; + + const current = readCurrentRtkGainSummary(env); + if (!current) return null; + + const store = loadBaselineStore(basePath); + const existing = store.sessions[sessionId]; + if (!existing) { + const now = new Date().toISOString(); + store.sessions[sessionId] = { + summary: current, + createdAt: now, + updatedAt: now, + }; + saveBaselineStore(basePath, store); + return computeSavingsDelta(current, current); + } + + if ( + current.totalCommands < existing.summary.totalCommands || + current.totalInput < existing.summary.totalInput || + current.totalSaved < existing.summary.totalSaved + ) { + const now = new Date().toISOString(); + store.sessions[sessionId] = { + summary: current, + createdAt: existing.createdAt, + updatedAt: now, + }; + saveBaselineStore(basePath, store); + return computeSavingsDelta(current, current); + } + + existing.updatedAt = new Date().toISOString(); + saveBaselineStore(basePath, store); + return computeSavingsDelta(current, existing.summary); +} + +export function clearRtkSessionBaseline(basePath: string, sessionId: string): void { + if (!sessionId) return; + const store = loadBaselineStore(basePath); + if (!(sessionId in store.sessions)) return; + delete store.sessions[sessionId]; + saveBaselineStore(basePath, store); +} + +export function formatRtkSavingsLabel(savings: RtkSessionSavings | null | undefined): string | null { + if (!savings) return null; + if (savings.commands <= 0) return "rtk: waiting for shell usage"; + if (savings.inputTokens <= 0 && savings.outputTokens <= 0) { + return `rtk: active (${savings.commands} cmd${savings.commands === 1 ? "" : "s"})`; + } + return `rtk: ${formatTokenCount(savings.savedTokens)} saved (${Math.round(savings.savingsPct)}%)`; +} diff --git a/src/resources/extensions/shared/rtk.ts b/src/resources/extensions/shared/rtk.ts new file mode 100644 index 000000000..4ff6a320f --- /dev/null +++ b/src/resources/extensions/shared/rtk.ts @@ -0,0 +1,120 @@ +import { spawnSync } from "node:child_process"; +import { existsSync } from "node:fs"; +import { homedir } from "node:os"; +import { delimiter, join } from "node:path"; + +const GSD_RTK_PATH_ENV = "GSD_RTK_PATH"; +const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED"; +const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED"; +const RTK_REWRITE_TIMEOUT_MS = 5_000; + +function isTruthy(value: string | undefined): boolean { + if (!value) return false; + const normalized = value.trim().toLowerCase(); + return normalized === "1" || normalized === "true" || normalized === "yes"; +} + +export function isRtkEnabled(env: NodeJS.ProcessEnv = process.env): boolean { + return !isTruthy(env[GSD_RTK_DISABLED_ENV]); +} + +export function buildRtkEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv { + return { + ...env, + [RTK_TELEMETRY_DISABLED_ENV]: "1", + }; +} + +function getManagedRtkDir(env: NodeJS.ProcessEnv = process.env): string { + return join(env.GSD_HOME || join(homedir(), ".gsd"), "agent", "bin"); +} + +function getRtkBinaryName(platform: NodeJS.Platform = process.platform): string { + return platform === "win32" ? "rtk.exe" : "rtk"; +} + +function getPathValue(env: NodeJS.ProcessEnv): string | undefined { + const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path"); + return pathKey ? env[pathKey] : env.PATH; +} + +function resolvePathCandidates(pathValue: string | undefined): string[] { + if (!pathValue) return []; + return pathValue + .split(delimiter) + .map((part) => part.trim()) + .filter(Boolean); +} + +function resolveSystemRtkPath(pathValue: string | undefined, platform: NodeJS.Platform = process.platform): string | null { + const candidates = platform === "win32" + ? ["rtk.exe", "rtk.cmd", "rtk.bat", "rtk"] + : ["rtk"]; + + for (const dir of resolvePathCandidates(pathValue)) { + for (const candidate of candidates) { + const fullPath = join(dir, candidate); + if (existsSync(fullPath)) { + return fullPath; + } + } + } + + return null; +} + +export interface ResolveRtkBinaryPathOptions { + binaryPath?: string; + env?: NodeJS.ProcessEnv; + pathValue?: string; + platform?: NodeJS.Platform; +} + +export function resolveRtkBinaryPath(options: ResolveRtkBinaryPathOptions = {}): string | null { + const env = options.env ?? process.env; + const platform = options.platform ?? process.platform; + + const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV]; + if (explicitPath && existsSync(explicitPath)) { + return explicitPath; + } + + const managedDir = getManagedRtkDir(env); + const managedPath = join(managedDir, getRtkBinaryName(platform)); + if (existsSync(managedPath)) { + return managedPath; + } + // On Windows, also check for rtk.cmd in the managed dir (used by test fake RTK + // and any wrapper-style installs where a .cmd launcher accompanies the binary). + if (platform === "win32") { + const managedCmd = join(managedDir, "rtk.cmd"); + if (existsSync(managedCmd)) { + return managedCmd; + } + } + + return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform); +} + +export function rewriteCommandWithRtk(command: string, env: NodeJS.ProcessEnv = process.env): string { + if (!command.trim()) return command; + if (!isRtkEnabled(env)) return command; + + const binaryPath = resolveRtkBinaryPath({ env }); + if (!binaryPath) return command; + + const result = spawnSync(binaryPath, ["rewrite", command], { + encoding: "utf-8", + env: buildRtkEnv(env), + stdio: ["ignore", "pipe", "ignore"], + timeout: RTK_REWRITE_TIMEOUT_MS, + // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows + shell: /\.(cmd|bat)$/i.test(binaryPath), + }); + + if (result.error) return command; + if (result.status !== 0 && result.status !== 3) return command; + + const rewritten = (result.stdout ?? "").trimEnd(); + return rewritten || command; +} diff --git a/src/rtk.ts b/src/rtk.ts new file mode 100644 index 000000000..82ad0af52 --- /dev/null +++ b/src/rtk.ts @@ -0,0 +1,415 @@ +import { createHash, randomUUID } from "node:crypto"; +import { spawnSync } from "node:child_process"; +import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, chmodSync, readdirSync } from "node:fs"; +import { createWriteStream } from "node:fs"; +import { arch as osArch, homedir as osHomedir } from "node:os"; +import { delimiter, join } from "node:path"; +import { Readable } from "node:stream"; +import { finished } from "node:stream/promises"; +import extractZip from "extract-zip"; + +export const RTK_VERSION = "0.33.1"; +export const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED"; +export const GSD_SKIP_RTK_INSTALL_ENV = "GSD_SKIP_RTK_INSTALL"; +export const GSD_RTK_PATH_ENV = "GSD_RTK_PATH"; +export const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED"; + +const RTK_REPO = "rtk-ai/rtk"; +const RTK_REWRITE_TIMEOUT_MS = 5_000; + +export interface EnsureRtkOptions { + targetDir?: string; + allowDownload?: boolean; + env?: NodeJS.ProcessEnv; + pathValue?: string; + releaseVersion?: string; + log?: (message: string) => void; +} + +export interface EnsureRtkResult { + enabled: boolean; + supported: boolean; + available: boolean; + source: "disabled" | "unsupported" | "managed" | "system" | "downloaded" | "missing"; + binaryPath?: string; + reason?: string; +} + +function isTruthy(value: string | undefined): boolean { + if (!value) return false; + const normalized = value.trim().toLowerCase(); + return normalized === "1" || normalized === "true" || normalized === "yes"; +} + +export function isRtkEnabled(env: NodeJS.ProcessEnv = process.env): boolean { + return !isTruthy(env[GSD_RTK_DISABLED_ENV]); +} + +function resolveAppRoot(env: NodeJS.ProcessEnv = process.env): string { + return env.GSD_HOME || join(osHomedir(), ".gsd"); +} + +export function getManagedRtkDir(env: NodeJS.ProcessEnv = process.env): string { + return join(resolveAppRoot(env), "agent", "bin"); +} + +export function getRtkBinaryName(platform: NodeJS.Platform = process.platform): string { + return platform === "win32" ? "rtk.exe" : "rtk"; +} + +export function getManagedRtkPath( + platform: NodeJS.Platform = process.platform, + targetDir: string = getManagedRtkDir(), +): string { + return join(targetDir, getRtkBinaryName(platform)); +} + +export function prependPathEntry(env: NodeJS.ProcessEnv, entry: string): NodeJS.ProcessEnv { + const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") ?? (process.platform === "win32" ? "Path" : "PATH"); + const currentPath = env[pathKey] ?? ""; + const parts = currentPath.split(delimiter).filter(Boolean); + if (!parts.includes(entry)) { + env[pathKey] = [entry, currentPath].filter(Boolean).join(delimiter); + } + return env; +} + +export function applyRtkProcessEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv { + prependPathEntry(env, getManagedRtkDir(env)); + env[RTK_TELEMETRY_DISABLED_ENV] = "1"; + return env; +} + +function getPathValue(env: NodeJS.ProcessEnv): string | undefined { + const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path"); + return pathKey ? env[pathKey] : env.PATH; +} + +export function buildRtkEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv { + return applyRtkProcessEnv({ ...env }); +} + +export function resolveRtkAssetName( + platform: NodeJS.Platform, + arch: string, + version: string = RTK_VERSION, +): string | null { + void version; + if (platform === "darwin" && arch === "arm64") return "rtk-aarch64-apple-darwin.tar.gz"; + if (platform === "darwin" && arch === "x64") return "rtk-x86_64-apple-darwin.tar.gz"; + if (platform === "linux" && arch === "arm64") return "rtk-aarch64-unknown-linux-gnu.tar.gz"; + if (platform === "linux" && arch === "x64") return "rtk-x86_64-unknown-linux-musl.tar.gz"; + if (platform === "win32" && arch === "x64") return "rtk-x86_64-pc-windows-msvc.zip"; + return null; +} + +function getReleaseBaseUrl(version: string): string { + return `https://github.com/${RTK_REPO}/releases/download/v${version}`; +} + +function getChecksumsUrl(version: string): string { + return `${getReleaseBaseUrl(version)}/checksums.txt`; +} + +function buildAssetUrl(version: string, assetName: string): string { + return `${getReleaseBaseUrl(version)}/${assetName}`; +} + +function parseChecksums(content: string): Map { + const checksums = new Map(); + for (const rawLine of content.split(/\r?\n/)) { + const line = rawLine.trim(); + if (!line) continue; + const match = line.match(/^([a-f0-9]{64})\s+(.+)$/i); + if (!match) continue; + checksums.set(match[2], match[1].toLowerCase()); + } + return checksums; +} + +function sha256File(path: string): string { + const hash = createHash("sha256"); + hash.update(readFileSync(path)); + return hash.digest("hex"); +} + +async function downloadToFile(url: string, destination: string): Promise { + const response = await fetch(url, { + headers: { "User-Agent": "gsd-pi-rtk" }, + }); + + if (!response.ok) { + throw new Error(`download failed (${response.status}) for ${url}`); + } + if (!response.body) { + throw new Error(`download returned no body for ${url}`); + } + + const output = createWriteStream(destination); + await finished(Readable.fromWeb(response.body as never).pipe(output)); +} + +function findBinaryRecursively(rootDir: string, binaryName: string): string | null { + const stack: string[] = [rootDir]; + while (stack.length > 0) { + const current = stack.pop(); + if (!current) continue; + const entries = readdirSync(current, { withFileTypes: true }); + for (const entry of entries) { + const fullPath = join(current, entry.name); + if (entry.isFile() && entry.name === binaryName) { + return fullPath; + } + if (entry.isDirectory()) { + stack.push(fullPath); + } + } + } + return null; +} + +function extractArchive(assetName: string, archivePath: string, extractDir: string): void { + if (!assetName.endsWith(".tar.gz")) { + throw new Error(`unsupported RTK archive format: ${assetName}`); + } + + mkdirSync(extractDir, { recursive: true }); + const result = spawnSync("tar", ["xzf", archivePath, "-C", extractDir], { + encoding: "utf-8", + timeout: 30_000, + }); + if (result.error || result.status !== 0) { + throw new Error(result.error?.message ?? result.stderr?.trim() ?? `tar extraction failed for ${assetName}`); + } +} + +async function extractArchiveAsync(assetName: string, archivePath: string, extractDir: string): Promise { + if (assetName.endsWith(".zip")) { + mkdirSync(extractDir, { recursive: true }); + await extractZip(archivePath, { dir: extractDir }); + return; + } + extractArchive(assetName, archivePath, extractDir); +} + +function resolvePathCandidates(pathValue: string | undefined): string[] { + if (!pathValue) return []; + return pathValue + .split(delimiter) + .map((part) => part.trim()) + .filter(Boolean); +} + +function resolveSystemRtkPath(pathValue: string | undefined, platform: NodeJS.Platform = process.platform): string | null { + const candidates = platform === "win32" + ? ["rtk.exe", "rtk.cmd", "rtk.bat", "rtk"] + : ["rtk"]; + + for (const dir of resolvePathCandidates(pathValue)) { + for (const candidate of candidates) { + const fullPath = join(dir, candidate); + if (existsSync(fullPath)) { + return fullPath; + } + } + } + + return null; +} + +export interface ResolveRtkBinaryPathOptions { + binaryPath?: string; + env?: NodeJS.ProcessEnv; + pathValue?: string; + platform?: NodeJS.Platform; + targetDir?: string; +} + +export function resolveRtkBinaryPath(options: ResolveRtkBinaryPathOptions = {}): string | null { + const env = options.env ?? process.env; + const platform = options.platform ?? process.platform; + + const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV]; + if (explicitPath && existsSync(explicitPath)) { + return explicitPath; + } + + const managedPath = getManagedRtkPath(platform, options.targetDir ?? getManagedRtkDir(env)); + if (existsSync(managedPath)) { + return managedPath; + } + // On Windows, also check for rtk.cmd in the managed dir (used by test fake RTK + // and any wrapper-style installs where a .cmd launcher accompanies the binary). + if (platform === "win32") { + const managedDir = options.targetDir ?? getManagedRtkDir(env); + const managedCmd = join(managedDir, "rtk.cmd"); + if (existsSync(managedCmd)) { + return managedCmd; + } + } + + return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform); +} + +export interface RewriteCommandOptions { + binaryPath?: string; + env?: NodeJS.ProcessEnv; + timeoutMs?: number; + spawnSyncImpl?: typeof spawnSync; +} + +export function rewriteCommandWithRtk(command: string, options: RewriteCommandOptions = {}): string { + if (!command.trim()) return command; + if (!isRtkEnabled(options.env ?? process.env)) return command; + + const env = options.env ?? process.env; + const binaryPath = resolveRtkBinaryPath({ + env, + binaryPath: options.binaryPath, + }); + + if (!binaryPath) return command; + + const run = options.spawnSyncImpl ?? spawnSync; + const result = run(binaryPath, ["rewrite", command], { + encoding: "utf-8", + env: buildRtkEnv(options.env ?? process.env), + stdio: ["ignore", "pipe", "ignore"], + timeout: options.timeoutMs ?? RTK_REWRITE_TIMEOUT_MS, + // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows + shell: /\.(cmd|bat)$/i.test(binaryPath), + }); + + if (result.error) return command; + if (result.status !== 0 && result.status !== 3) return command; + + const rewritten = (result.stdout ?? "").trimEnd(); + return rewritten || command; +} + +export interface ValidateRtkBinaryOptions { + spawnSyncImpl?: typeof spawnSync; + env?: NodeJS.ProcessEnv; +} + +export function validateRtkBinary(binaryPath: string, options: ValidateRtkBinaryOptions = {}): boolean { + const run = options.spawnSyncImpl ?? spawnSync; + const result = run(binaryPath, ["rewrite", "git status"], { + encoding: "utf-8", + env: buildRtkEnv(options.env ?? process.env), + stdio: ["ignore", "pipe", "ignore"], + timeout: RTK_REWRITE_TIMEOUT_MS, + }); + + if (result.error) return false; + if (result.status !== 0) return false; + return (result.stdout ?? "").trim() === "rtk git status"; +} + +export async function ensureRtkAvailable(options: EnsureRtkOptions = {}): Promise { + const env = options.env ?? process.env; + if (!isRtkEnabled(env)) { + return { enabled: false, supported: true, available: false, source: "disabled", reason: `${GSD_RTK_DISABLED_ENV} is set` }; + } + if (isTruthy(env[GSD_SKIP_RTK_INSTALL_ENV])) { + const configuredPath = env[GSD_RTK_PATH_ENV]; + if (configuredPath && existsSync(configuredPath)) { + return { enabled: true, supported: true, available: true, source: "managed", binaryPath: configuredPath }; + } + return { enabled: true, supported: true, available: false, source: "missing", reason: `${GSD_SKIP_RTK_INSTALL_ENV} is set` }; + } + + const targetDir = options.targetDir ?? getManagedRtkDir(env); + const managedPath = getManagedRtkPath(process.platform, targetDir); + + if (existsSync(managedPath) && validateRtkBinary(managedPath, { env })) { + return { enabled: true, supported: true, available: true, source: "managed", binaryPath: managedPath }; + } + + const systemPath = resolveSystemRtkPath(options.pathValue ?? getPathValue(env)); + if (systemPath && validateRtkBinary(systemPath, { env })) { + return { enabled: true, supported: true, available: true, source: "system", binaryPath: systemPath }; + } + + const version = options.releaseVersion ?? RTK_VERSION; + const assetName = resolveRtkAssetName(process.platform, osArch(), version); + if (!assetName) { + return { + enabled: true, + supported: false, + available: false, + source: "unsupported", + reason: `RTK release asset unavailable for ${process.platform}/${osArch()}`, + }; + } + + if (options.allowDownload === false) { + return { enabled: true, supported: true, available: false, source: "missing", reason: "download disabled" }; + } + + mkdirSync(targetDir, { recursive: true }); + + const tempRoot = join(targetDir, `.rtk-install-${randomUUID().slice(0, 8)}`); + const archivePath = join(tempRoot, assetName); + const extractDir = join(tempRoot, "extract"); + + mkdirSync(tempRoot, { recursive: true }); + + try { + const checksumsUrl = getChecksumsUrl(version); + const checksumsResponse = await fetch(checksumsUrl, { headers: { "User-Agent": "gsd-pi-rtk" } }); + if (!checksumsResponse.ok) { + throw new Error(`failed to fetch RTK checksums (${checksumsResponse.status})`); + } + const checksums = parseChecksums(await checksumsResponse.text()); + const expectedSha = checksums.get(assetName); + if (!expectedSha) { + throw new Error(`missing checksum for ${assetName}`); + } + + await downloadToFile(buildAssetUrl(version, assetName), archivePath); + const actualSha = sha256File(archivePath); + if (actualSha !== expectedSha) { + throw new Error(`checksum mismatch for ${assetName}`); + } + + await extractArchiveAsync(assetName, archivePath, extractDir); + const extractedBinary = findBinaryRecursively(extractDir, getRtkBinaryName(process.platform)); + if (!extractedBinary) { + throw new Error(`RTK binary not found in ${assetName}`); + } + + copyFileSync(extractedBinary, managedPath); + if (process.platform !== "win32") { + chmodSync(managedPath, 0o755); + } + + if (!validateRtkBinary(managedPath, { env })) { + rmSync(managedPath, { force: true }); + throw new Error("downloaded RTK binary failed validation"); + } + + options.log?.(`installed RTK ${version} to ${managedPath}`); + return { enabled: true, supported: true, available: true, source: "downloaded", binaryPath: managedPath }; + } catch (error) { + options.log?.(`RTK install skipped: ${error instanceof Error ? error.message : String(error)}`); + return { + enabled: true, + supported: true, + available: false, + source: "missing", + reason: error instanceof Error ? error.message : String(error), + }; + } finally { + rmSync(tempRoot, { recursive: true, force: true }); + } +} + +export async function bootstrapRtk(options: EnsureRtkOptions = {}): Promise { + const result = await ensureRtkAvailable(options); + applyRtkProcessEnv(process.env); + if (result.binaryPath) { + process.env[GSD_RTK_PATH_ENV] = result.binaryPath; + } + return result; +} diff --git a/src/tests/app-smoke.test.ts b/src/tests/app-smoke.test.ts index c6a55f291..d68512937 100644 --- a/src/tests/app-smoke.test.ts +++ b/src/tests/app-smoke.test.ts @@ -34,7 +34,9 @@ function assertExtensionIndexExists(agentDir: string, extensionName: string): vo test("app-paths resolve to ~/.gsd/", async () => { const { appRoot, agentDir, sessionsDir, authFilePath } = await import("../app-paths.ts"); - const home = process.env.HOME!; + // Use homedir() — process.env.HOME is undefined on Windows (uses USERPROFILE instead) + const { homedir } = await import("node:os"); + const home = homedir(); assert.equal(appRoot, join(home, ".gsd"), "appRoot is ~/.gsd/"); assert.equal(agentDir, join(home, ".gsd", "agent"), "agentDir is ~/.gsd/agent/"); @@ -100,6 +102,9 @@ test("loader sets all 4 GSD_ env vars and PI_PACKAGE_DIR", async (t) => { assert.ok(loaderSrc.includes("GSD_BIN_PATH"), "loader sets GSD_BIN_PATH"); assert.ok(loaderSrc.includes("GSD_WORKFLOW_PATH"), "loader sets GSD_WORKFLOW_PATH"); assert.ok(loaderSrc.includes("GSD_BUNDLED_EXTENSION_PATHS"), "loader sets GSD_BUNDLED_EXTENSION_PATHS"); + assert.ok(loaderSrc.includes("applyRtkProcessEnv"), "loader applies RTK environment bootstrap"); + const rtkSrc = readFileSync(join(projectRoot, "src", "rtk.ts"), "utf-8"); + assert.ok(rtkSrc.includes("RTK_TELEMETRY_DISABLED"), "RTK helper disables telemetry for managed sessions"); assert.ok(loaderSrc.includes("serializeBundledExtensionPaths"), "loader uses shared bundled path serializer"); assert.ok(loaderSrc.includes("join(delimiter)"), "loader uses platform delimiter for NODE_PATH"); diff --git a/src/tests/footer-component.test.ts b/src/tests/footer-component.test.ts new file mode 100644 index 000000000..6873ef3ad --- /dev/null +++ b/src/tests/footer-component.test.ts @@ -0,0 +1,17 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { readFileSync } from "node:fs"; +import { join } from "node:path"; + +const footerSource = readFileSync( + join(process.cwd(), "packages", "pi-coding-agent", "src", "modes", "interactive", "components", "footer.ts"), + "utf-8", +); + +test("FooterComponent dims extension status lines to match the rest of the footer", () => { + assert.match( + footerSource, + /theme\.fg\("dim", statusLine\)/, + "extension status line should be wrapped in the dim footer color", + ); +}); diff --git a/src/tests/postinstall.test.ts b/src/tests/postinstall.test.ts index 88b8e0a47..ff655529e 100644 --- a/src/tests/postinstall.test.ts +++ b/src/tests/postinstall.test.ts @@ -9,7 +9,11 @@ const projectRoot = join(dirname(fileURLToPath(import.meta.url)), "..", ".."); test("postinstall respects PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", () => { const result = spawnSync("node", ["scripts/postinstall.js"], { cwd: projectRoot, - env: { ...process.env, PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1" }, + env: { + ...process.env, + PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1", + GSD_SKIP_RTK_INSTALL: "1", + }, encoding: "utf-8", }); diff --git a/src/tests/resolve-ts-loader.test.ts b/src/tests/resolve-ts-loader.test.ts new file mode 100644 index 000000000..6c81a6a32 --- /dev/null +++ b/src/tests/resolve-ts-loader.test.ts @@ -0,0 +1,50 @@ +import test from "node:test" +import assert from "node:assert/strict" + +import { load as loadWithTestLoader, resolve as resolveWithTestLoader } from "../resources/extensions/gsd/tests/dist-redirect.mjs" + +const nextResolve = async (specifier: string) => ({ url: specifier }) + +const cases = [ + ["@gsd/pi-coding-agent", "../../packages/pi-coding-agent/src/index.ts"], +] as const + +test("resolve-ts loader redirects pi-coding-agent bare imports to the workspace source entrypoint", async () => { + for (const [specifier, relativeTarget] of cases) { + const resolved = await resolveWithTestLoader(specifier, {}, nextResolve) + assert.equal( + resolved.url, + new URL(relativeTarget, import.meta.url).href, + `${specifier} should resolve to ${relativeTarget}`, + ) + } +}) + +test("resolve-ts loader rewrites direct pi-coding-agent source entry import to .ts", async () => { + const resolved = await resolveWithTestLoader( + "../../packages/pi-coding-agent/src/index.js", + {}, + nextResolve, + ) + + assert.equal( + resolved.url, + new URL("../../packages/pi-coding-agent/src/index.ts", import.meta.url).href, + ) +}) + +test("resolve-ts loader transpiles pi-coding-agent source files that strip-only mode cannot parse", async () => { + const orchestratorUrl = new URL( + "../../packages/pi-coding-agent/src/core/compaction-orchestrator.ts", + import.meta.url, + ).href + + const loaded = await loadWithTestLoader(orchestratorUrl, {}, async () => { + throw new Error("expected pi-coding-agent source to be transpiled before nextLoad") + }) + + assert.equal(loaded.format, "module") + assert.equal(loaded.shortCircuit, true) + assert.match(loaded.source, /constructor\(_deps\)/, "transpiled constructor should be valid JavaScript") + assert.doesNotMatch(loaded.source, /private readonly _deps/, "TypeScript parameter property syntax should be removed") +}) diff --git a/src/tests/rtk-execution-seams.test.ts b/src/tests/rtk-execution-seams.test.ts new file mode 100644 index 000000000..ab1dda678 --- /dev/null +++ b/src/tests/rtk-execution-seams.test.ts @@ -0,0 +1,180 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { chmodSync, copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; + +import { rewriteCommandWithRtk as rewriteSharedCommandWithRtk } from "../resources/extensions/shared/rtk.ts"; +import { runVerificationGate } from "../resources/extensions/gsd/verification-gate.ts"; +import { AsyncJobManager } from "../resources/extensions/async-jobs/job-manager.ts"; +import { createAsyncBashTool } from "../resources/extensions/async-jobs/async-bash-tool.ts"; +import { cleanupAll, startProcess } from "../resources/extensions/bg-shell/process-manager.ts"; +import { runOnSession } from "../resources/extensions/bg-shell/interaction.ts"; +import { createFakeRtk } from "./rtk-test-utils.ts"; + +const noopSignal = new AbortController().signal; + +function withFakeRtk(mapping: Record, run: () => Promise | T): Promise | T { + const fake = createFakeRtk(mapping); + const previousPath = process.env.GSD_RTK_PATH; + const previousDisabled = process.env.GSD_RTK_DISABLED; + process.env.GSD_RTK_PATH = fake.path; + delete process.env.GSD_RTK_DISABLED; + + const finalize = () => { + if (previousPath === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previousPath; + if (previousDisabled === undefined) delete process.env.GSD_RTK_DISABLED; + else process.env.GSD_RTK_DISABLED = previousDisabled; + fake.cleanup(); + }; + + try { + const result = run(); + if (result && typeof (result as Promise).then === "function") { + return (result as Promise).finally(finalize); + } + finalize(); + return result; + } catch (error) { + finalize(); + throw error; + } +} + +function withManagedFakeRtk(mapping: Record, run: (env: NodeJS.ProcessEnv, managedPath: string) => Promise | T): Promise | T { + const fake = createFakeRtk(mapping); + const managedHome = mkdtempSync(join(tmpdir(), "gsd-rtk-managed-home-")); + const managedDir = join(managedHome, "agent", "bin"); + const managedPath = join(managedDir, process.platform === "win32" ? "rtk.cmd" : "rtk"); + mkdirSync(managedDir, { recursive: true }); + copyFileSync(fake.path, managedPath); + if (process.platform !== "win32") { + chmodSync(managedPath, 0o755); + } + + const previousHome = process.env.GSD_HOME; + const previousPath = process.env.GSD_RTK_PATH; + const previousDisabled = process.env.GSD_RTK_DISABLED; + process.env.GSD_HOME = managedHome; + delete process.env.GSD_RTK_PATH; + delete process.env.GSD_RTK_DISABLED; + + const env: NodeJS.ProcessEnv = { + ...process.env, + GSD_HOME: managedHome, + }; + delete env.GSD_RTK_PATH; + + const finalize = () => { + if (previousHome === undefined) delete process.env.GSD_HOME; + else process.env.GSD_HOME = previousHome; + if (previousPath === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previousPath; + if (previousDisabled === undefined) delete process.env.GSD_RTK_DISABLED; + else process.env.GSD_RTK_DISABLED = previousDisabled; + fake.cleanup(); + rmSync(managedHome, { recursive: true, force: true }); + }; + + try { + const result = run(env, managedPath); + if (result && typeof (result as Promise).then === "function") { + return (result as Promise).finally(finalize); + } + finalize(); + return result; + } catch (error) { + finalize(); + throw error; + } +} + +// NOTE: The bash tool itself no longer does RTK rewriting directly. That's now +// handled by the bash_transform extension hook in register-hooks.ts. The seam +// tests below verify the GSD-layer surfaces that still call rewriteCommandWithRtk +// directly: shared/rtk.ts, verification-gate, async-bash, and bg-shell. + +test("shared RTK helper rewrites commands via fake RTK binary", async () => { + await withFakeRtk({ "echo raw": "echo rewritten" }, async () => { + const rewritten = rewriteSharedCommandWithRtk("echo raw"); + assert.equal(rewritten, "echo rewritten"); + }); +}); + +test("shared RTK helper falls back to the managed RTK path when GSD_RTK_PATH is unset", async () => { + await withManagedFakeRtk({ "echo raw": "echo rewritten" }, async (env) => { + assert.equal(rewriteSharedCommandWithRtk("echo raw", env), "echo rewritten"); + }); +}); + +test("verification gate executes the RTK-rewritten command", async () => { + await withFakeRtk({ "echo raw": "echo rewritten" }, async () => { + const result = runVerificationGate({ + basePath: process.cwd(), + unitId: "T-RTK", + cwd: process.cwd(), + preferenceCommands: ["echo raw"], + }); + + assert.equal(result.passed, true); + assert.equal(result.checks.length, 1); + assert.match(result.checks[0]?.stdout ?? "", /rewritten/); + }); +}); + +test("async_bash executes the RTK-rewritten command", async () => { + await withFakeRtk({ "echo raw": "echo rewritten" }, async () => { + const manager = new AsyncJobManager(); + const tool = createAsyncBashTool(() => manager, () => process.cwd()); + + const result = await tool.execute( + "rtk-async", + { command: "echo raw", label: "rtk-async" }, + noopSignal, + () => {}, + undefined as never, + ); + + const text = result.content.map((entry) => entry.text ?? "").join("\n"); + const jobId = text.match(/\*\*(bg_[a-f0-9]+)\*\*/)?.[1]; + assert.ok(jobId, "expected async_bash to return a job id"); + + const job = manager.getJob(jobId!); + assert.ok(job, "job should be registered"); + await job!.promise; + assert.match(job!.resultText ?? "", /rewritten/); + manager.shutdown(); + }); +}); + +test("bg_shell start and runOnSession both execute RTK-rewritten commands", async (t) => { + if (process.platform === "win32") { + t.skip("bg_shell requires bash; Windows CI runners don't have Git Bash"); + return; + } + t.after(cleanupAll); + + await withFakeRtk({ "echo raw": "echo rewritten" }, async () => { + const oneshot = startProcess({ + command: "echo raw", + cwd: process.cwd(), + ownerSessionFile: "session-rtk", + }); + + await new Promise((resolve) => setTimeout(resolve, 300)); + assert.match(oneshot.output.map((line) => line.line).join("\n"), /rewritten/); + + const shellSession = startProcess({ + command: "", + cwd: process.cwd(), + ownerSessionFile: "session-rtk-shell", + type: "shell", + }); + + await new Promise((resolve) => setTimeout(resolve, 300)); + const result = await runOnSession(shellSession, "echo raw", 2_000); + assert.equal(result.exitCode, 0); + assert.match(result.output, /rewritten/); + }); +}); diff --git a/src/tests/rtk-session-stats.test.ts b/src/tests/rtk-session-stats.test.ts new file mode 100644 index 000000000..88a14e944 --- /dev/null +++ b/src/tests/rtk-session-stats.test.ts @@ -0,0 +1,189 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { chmodSync, copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs"; +import { join } from "node:path"; +import { tmpdir } from "node:os"; + +import { + clearRtkSessionBaseline, + ensureRtkSessionBaseline, + formatRtkSavingsLabel, + getRtkSessionSavings, +} from "../resources/extensions/shared/rtk-session-stats.ts"; +import { createFakeRtk } from "./rtk-test-utils.ts"; + +function summary(totalCommands: number, totalInput: number, totalOutput: number, totalSaved: number, totalTimeMs = 1000) { + return JSON.stringify({ + summary: { + total_commands: totalCommands, + total_input: totalInput, + total_output: totalOutput, + total_saved: totalSaved, + avg_savings_pct: totalInput > 0 ? (totalSaved / totalInput) * 100 : 0, + total_time_ms: totalTimeMs, + avg_time_ms: totalCommands > 0 ? totalTimeMs / totalCommands : 0, + }, + }); +} + +test("RTK session savings diff from a persisted baseline", () => { + const basePath = mkdtempSync(join(tmpdir(), "gsd-rtk-session-stats-")); + mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true }); + + const first = createFakeRtk({ + "gain --all --format json": { stdout: summary(10, 1000, 600, 400) }, + }); + const second = createFakeRtk({ + "gain --all --format json": { stdout: summary(14, 1600, 900, 700, 1800) }, + }); + + const previous = process.env.GSD_RTK_PATH; + try { + process.env.GSD_RTK_PATH = first.path; + ensureRtkSessionBaseline(basePath, "sess-1"); + + process.env.GSD_RTK_PATH = second.path; + const savings = getRtkSessionSavings(basePath, "sess-1"); + assert.ok(savings, "expected RTK savings snapshot"); + assert.equal(savings?.commands, 4); + assert.equal(savings?.inputTokens, 600); + assert.equal(savings?.outputTokens, 300); + assert.equal(savings?.savedTokens, 300); + assert.equal(Math.round(savings?.savingsPct ?? 0), 50); + } finally { + if (previous === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previous; + first.cleanup(); + second.cleanup(); + rmSync(basePath, { recursive: true, force: true }); + } +}); + +test("RTK session savings baseline resets cleanly when tracking totals go backwards", () => { + const basePath = mkdtempSync(join(tmpdir(), "gsd-rtk-session-reset-")); + mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true }); + + const first = createFakeRtk({ + "gain --all --format json": { stdout: summary(8, 800, 500, 300) }, + }); + const second = createFakeRtk({ + "gain --all --format json": { stdout: summary(1, 100, 80, 20) }, + }); + + const previous = process.env.GSD_RTK_PATH; + try { + process.env.GSD_RTK_PATH = first.path; + ensureRtkSessionBaseline(basePath, "sess-2"); + + process.env.GSD_RTK_PATH = second.path; + const savings = getRtkSessionSavings(basePath, "sess-2"); + assert.ok(savings, "expected RTK savings snapshot"); + assert.equal(savings?.commands, 0); + assert.equal(savings?.savedTokens, 0); + } finally { + if (previous === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previous; + first.cleanup(); + second.cleanup(); + rmSync(basePath, { recursive: true, force: true }); + } +}); + +test("RTK session stats fall back to the managed RTK path when GSD_RTK_PATH is unset", () => { + const basePath = mkdtempSync(join(tmpdir(), "gsd-rtk-session-managed-")); + mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true }); + + const fake = createFakeRtk({ + "gain --all --format json": { stdout: summary(6, 900, 500, 400) }, + }); + const managedHome = mkdtempSync(join(tmpdir(), "gsd-rtk-home-")); + const managedDir = join(managedHome, "agent", "bin"); + const managedPath = join(managedDir, process.platform === "win32" ? "rtk.cmd" : "rtk"); + mkdirSync(managedDir, { recursive: true }); + copyFileSync(fake.path, managedPath); + if (process.platform !== "win32") { + chmodSync(managedPath, 0o755); + } + + const previousHome = process.env.GSD_HOME; + const previousPath = process.env.GSD_RTK_PATH; + + try { + process.env.GSD_HOME = managedHome; + delete process.env.GSD_RTK_PATH; + + const env: NodeJS.ProcessEnv = { + ...process.env, + GSD_HOME: managedHome, + }; + delete env.GSD_RTK_PATH; + + const baseline = ensureRtkSessionBaseline(basePath, "sess-managed", env); + assert.ok(baseline, "expected baseline from managed RTK path"); + + const savings = getRtkSessionSavings(basePath, "sess-managed", env); + assert.ok(savings, "expected savings snapshot from managed RTK path"); + assert.equal(savings?.commands, 0); + } finally { + if (previousHome === undefined) delete process.env.GSD_HOME; + else process.env.GSD_HOME = previousHome; + if (previousPath === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previousPath; + fake.cleanup(); + rmSync(managedHome, { recursive: true, force: true }); + rmSync(basePath, { recursive: true, force: true }); + } +}); + +test("formatRtkSavingsLabel produces a compact footer string", () => { + assert.equal( + formatRtkSavingsLabel({ + commands: 5, + inputTokens: 5949, + outputTokens: 2905, + savedTokens: 3044, + savingsPct: 51.2, + totalTimeMs: 3200, + avgTimeMs: 640, + updatedAt: new Date().toISOString(), + }), + "rtk: 3.0k saved (51%)", + ); + assert.equal( + formatRtkSavingsLabel({ + commands: 2, + inputTokens: 0, + outputTokens: 0, + savedTokens: 0, + savingsPct: 0, + totalTimeMs: 120, + avgTimeMs: 60, + updatedAt: new Date().toISOString(), + }), + "rtk: active (2 cmds)", + ); + assert.equal(formatRtkSavingsLabel(null), null); +}); + +test("clearRtkSessionBaseline removes a stored session entry", () => { + const basePath = mkdtempSync(join(tmpdir(), "gsd-rtk-session-clear-")); + mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true }); + const fake = createFakeRtk({ + "gain --all --format json": { stdout: summary(3, 300, 200, 100) }, + }); + const previous = process.env.GSD_RTK_PATH; + + try { + process.env.GSD_RTK_PATH = fake.path; + ensureRtkSessionBaseline(basePath, "sess-clear"); + clearRtkSessionBaseline(basePath, "sess-clear"); + const savings = getRtkSessionSavings(basePath, "sess-clear"); + assert.ok(savings, "expected savings snapshot after baseline recreation"); + assert.equal(savings?.commands, 0); + } finally { + if (previous === undefined) delete process.env.GSD_RTK_PATH; + else process.env.GSD_RTK_PATH = previous; + fake.cleanup(); + rmSync(basePath, { recursive: true, force: true }); + } +}); diff --git a/src/tests/rtk-test-utils.ts b/src/tests/rtk-test-utils.ts new file mode 100644 index 000000000..76cf81072 --- /dev/null +++ b/src/tests/rtk-test-utils.ts @@ -0,0 +1,45 @@ +import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; + +export type FakeRtkResponse = string | { status?: number; stdout?: string }; + +export function createFakeRtk(mapping: Record): { path: string; cleanup: () => void } { + const dir = mkdtempSync(join(tmpdir(), "gsd-fake-rtk-")); + const payload = JSON.stringify(mapping); + + const jsSource = `#!/usr/bin/env node +const mapping = ${payload}; +const args = process.argv.slice(2); +const fullInput = args.join(' '); +const rewriteInput = args[0] === 'rewrite' ? args.slice(1).join(' ') : null; +const match = mapping[fullInput] ?? (rewriteInput !== null ? mapping[rewriteInput] : undefined); +if (match === undefined) process.exit(1); +if (typeof match === 'string') { + process.stdout.write(match); + process.exit(0); +} +if (match.stdout) process.stdout.write(match.stdout); +process.exit(match.status ?? 0); +`; + + if (process.platform === "win32") { + const jsPath = join(dir, "fake-rtk.js"); + const cmdPath = join(dir, "rtk.cmd"); + writeFileSync(jsPath, jsSource, "utf-8"); + // Use the absolute jsPath so the .cmd works even when copied to another directory. + writeFileSync(cmdPath, `@echo off\r\n"${process.execPath}" "${jsPath}" %*\r\n`, "utf-8"); + return { + path: cmdPath, + cleanup: () => rmSync(dir, { recursive: true, force: true }), + }; + } + + const binaryPath = join(dir, "rtk"); + writeFileSync(binaryPath, jsSource, "utf-8"); + chmodSync(binaryPath, 0o755); + return { + path: binaryPath, + cleanup: () => rmSync(dir, { recursive: true, force: true }), + }; +} diff --git a/src/tests/rtk.test.ts b/src/tests/rtk.test.ts new file mode 100644 index 000000000..c51e2d7cf --- /dev/null +++ b/src/tests/rtk.test.ts @@ -0,0 +1,126 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { chmodSync, copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { delimiter, join } from "node:path"; + +import { + buildRtkEnv, + ensureRtkAvailable, + GSD_RTK_DISABLED_ENV, + GSD_RTK_PATH_ENV, + GSD_SKIP_RTK_INSTALL_ENV, + getManagedRtkDir, + prependPathEntry, + resolveRtkAssetName, + resolveRtkBinaryPath, + rewriteCommandWithRtk, + validateRtkBinary, +} from "../rtk.ts"; +import { createFakeRtk } from "./rtk-test-utils.ts"; + +test("resolveRtkAssetName maps supported release assets correctly", () => { + assert.equal(resolveRtkAssetName("darwin", "arm64"), "rtk-aarch64-apple-darwin.tar.gz"); + assert.equal(resolveRtkAssetName("darwin", "x64"), "rtk-x86_64-apple-darwin.tar.gz"); + assert.equal(resolveRtkAssetName("linux", "arm64"), "rtk-aarch64-unknown-linux-gnu.tar.gz"); + assert.equal(resolveRtkAssetName("linux", "x64"), "rtk-x86_64-unknown-linux-musl.tar.gz"); + assert.equal(resolveRtkAssetName("win32", "x64"), "rtk-x86_64-pc-windows-msvc.zip"); + assert.equal(resolveRtkAssetName("win32", "arm64"), null); +}); + +test("prependPathEntry preserves the original PATH key casing and avoids duplicates", () => { + const env: NodeJS.ProcessEnv = { Path: "/usr/bin" }; + prependPathEntry(env, "/tmp/gsd-bin"); + assert.equal(env.Path, `/tmp/gsd-bin${delimiter}${"/usr/bin"}`); + prependPathEntry(env, "/tmp/gsd-bin"); + assert.equal(env.Path, `/tmp/gsd-bin${delimiter}${"/usr/bin"}`); +}); + +test("buildRtkEnv prepends the managed bin dir and disables telemetry", () => { + const env = buildRtkEnv({ PATH: "/usr/bin" }); + assert.ok(env.PATH?.startsWith(`${getManagedRtkDir()}${delimiter}`)); + assert.equal(env.RTK_TELEMETRY_DISABLED, "1"); +}); + +test("rewriteCommandWithRtk rewrites when RTK returns exit 0 or 3", () => { + const spawnSyncImpl = ((_binary: string, _args: string[]) => ({ status: 0, stdout: "rtk git status", error: undefined })) as typeof import("node:child_process").spawnSync; + assert.equal(rewriteCommandWithRtk("git status", { binaryPath: "/tmp/rtk", spawnSyncImpl }), "rtk git status"); + + const askSpawn = ((_binary: string, _args: string[]) => ({ status: 3, stdout: "rtk npm run test", error: undefined })) as typeof import("node:child_process").spawnSync; + assert.equal(rewriteCommandWithRtk("npm run test", { binaryPath: "/tmp/rtk", spawnSyncImpl: askSpawn }), "rtk npm run test"); +}); + +test("rewriteCommandWithRtk passes commands through on no-match or process error", () => { + const passthroughSpawn = ((_binary: string, _args: string[]) => ({ status: 1, stdout: "", error: undefined })) as typeof import("node:child_process").spawnSync; + assert.equal(rewriteCommandWithRtk("echo hello", { binaryPath: "/tmp/rtk", spawnSyncImpl: passthroughSpawn }), "echo hello"); + + const failingSpawn = ((_binary: string, _args: string[]) => ({ status: null, stdout: "", error: new Error("boom") })) as typeof import("node:child_process").spawnSync; + assert.equal(rewriteCommandWithRtk("git status", { binaryPath: "/tmp/rtk", spawnSyncImpl: failingSpawn }), "git status"); +}); + +test("rewriteCommandWithRtk respects the disable flag", () => { + const spawnSyncImpl = (() => { + throw new Error("should not be called"); + }) as unknown as typeof import("node:child_process").spawnSync; + + assert.equal( + rewriteCommandWithRtk("git status", { + binaryPath: "/tmp/rtk", + spawnSyncImpl, + env: { [GSD_RTK_DISABLED_ENV]: "1" }, + }), + "git status", + ); +}); + +test("rewriteCommandWithRtk falls back to the managed RTK path when GSD_RTK_PATH is unset", () => { + const fake = createFakeRtk({ "git status": "rtk git status" }); + const managedHome = mkdtempSync(join(tmpdir(), "gsd-rtk-managed-home-")); + const managedDir = join(managedHome, "agent", "bin"); + const managedPath = join(managedDir, process.platform === "win32" ? "rtk.cmd" : "rtk"); + + mkdirSync(managedDir, { recursive: true }); + copyFileSync(fake.path, managedPath); + if (process.platform !== "win32") { + chmodSync(managedPath, 0o755); + } + + try { + const env = { + ...process.env, + GSD_HOME: managedHome, + }; + delete env.GSD_RTK_PATH; + + assert.equal(resolveRtkBinaryPath({ env }), managedPath); + assert.equal(rewriteCommandWithRtk("git status", { env }), "rtk git status"); + } finally { + fake.cleanup(); + rmSync(managedHome, { recursive: true, force: true }); + } +}); + +test("validateRtkBinary checks the rewrite contract", () => { + const validSpawn = ((_binary: string, _args: string[]) => ({ status: 0, stdout: "rtk git status", error: undefined })) as typeof import("node:child_process").spawnSync; + assert.equal(validateRtkBinary("/tmp/rtk", { spawnSyncImpl: validSpawn }), true); + + const invalidSpawn = ((_binary: string, _args: string[]) => ({ status: 0, stdout: "wrong output", error: undefined })) as typeof import("node:child_process").spawnSync; + assert.equal(validateRtkBinary("/tmp/rtk", { spawnSyncImpl: invalidSpawn }), false); +}); + +test("ensureRtkAvailable respects explicit disable and skip flags without downloading", async () => { + const disabled = await ensureRtkAvailable({ + env: { [GSD_RTK_DISABLED_ENV]: "1" }, + }); + assert.equal(disabled.enabled, false); + assert.equal(disabled.source, "disabled"); + + const skipped = await ensureRtkAvailable({ + env: { + [GSD_SKIP_RTK_INSTALL_ENV]: "1", + [GSD_RTK_PATH_ENV]: "/tmp/nonexistent-rtk", + }, + }); + assert.equal(skipped.available, false); + assert.equal(skipped.source, "missing"); +}); diff --git a/src/tests/web-dashboard-rtk-contract.test.ts b/src/tests/web-dashboard-rtk-contract.test.ts new file mode 100644 index 000000000..08c1e18fd --- /dev/null +++ b/src/tests/web-dashboard-rtk-contract.test.ts @@ -0,0 +1,21 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { readFileSync } from "node:fs"; +import { join } from "node:path"; + +const dashboardPath = join(process.cwd(), "web", "components", "gsd", "dashboard.tsx"); +const source = readFileSync(dashboardPath, "utf-8"); + +test("dashboard gates RTK Saved metric card on rtkEnabled", () => { + assert.match(source, /rtkEnabled && \(/, "dashboard should gate the RTK card on rtkEnabled"); + assert.match(source, /label="RTK Saved"/, "dashboard should contain an RTK Saved card (gated)"); +}); + +test("dashboard reads rtkEnabled from live auto state", () => { + assert.match(source, /const rtkEnabled = auto\?\.rtkEnabled === true/, "dashboard should derive rtkEnabled from the live auto payload"); +}); + +test("dashboard reads RTK savings from live auto state", () => { + assert.match(source, /const rtkSavings = auto\?\.rtkSavings \?\? null/, "dashboard should source RTK savings from the live auto payload"); + assert.doesNotMatch(source, /\/api\/rtk-savings/, "dashboard should not fetch RTK savings through a dedicated API route"); +}); diff --git a/src/tests/web-terminal-allowlist.test.ts b/src/tests/web-terminal-allowlist.test.ts new file mode 100644 index 000000000..c1d36341c --- /dev/null +++ b/src/tests/web-terminal-allowlist.test.ts @@ -0,0 +1,28 @@ +import test from "node:test"; +import assert from "node:assert/strict"; + +const sessionsRoute = await import("../../web/app/api/terminal/sessions/route.ts"); +const streamRoute = await import("../../web/app/api/terminal/stream/route.ts"); + +test("terminal session creation rejects disallowed commands", async () => { + const response = await sessionsRoute.POST( + new Request("http://localhost/api/terminal/sessions?project=/tmp/demo", { + method: "POST", + body: JSON.stringify({ command: "rm" }), + }), + ); + + assert.equal(response.status, 403); + const payload = await response.json() as { error?: string }; + assert.match(payload.error ?? "", /Command not allowed/); +}); + +test("terminal stream rejects disallowed commands before creating a PTY session", async () => { + const response = await streamRoute.GET( + new Request("http://localhost/api/terminal/stream?id=term-1&project=/tmp/demo&command=rm"), + ); + + assert.equal(response.status, 403); + const payload = await response.json() as { error?: string }; + assert.match(payload.error ?? "", /Command not allowed/); +}); diff --git a/src/web/auto-dashboard-service.ts b/src/web/auto-dashboard-service.ts index 58c62a4ad..31afe3ef8 100644 --- a/src/web/auto-dashboard-service.ts +++ b/src/web/auto-dashboard-service.ts @@ -4,7 +4,7 @@ import { join } from "node:path"; import { pathToFileURL } from "node:url"; import type { AutoDashboardData } from "./bridge-service.ts"; -import { resolveTypeStrippingFlag, resolveSubprocessModule, buildSubprocessPrefixArgs } from "./ts-subprocess-flags.ts" +import { resolveSubprocessModule, buildSubprocessPrefixArgs } from "./ts-subprocess-flags.ts"; const AUTO_DASHBOARD_MAX_BUFFER = 1024 * 1024; const TEST_AUTO_DASHBOARD_MODULE_ENV = "GSD_WEB_TEST_AUTO_DASHBOARD_MODULE"; @@ -29,6 +29,8 @@ function fallbackAutoDashboardData(): AutoDashboardData { basePath: "", totalCost: 0, totalTokens: 0, + rtkSavings: null, + rtkEnabled: false, }; } @@ -52,7 +54,6 @@ export async function collectAuthoritativeAutoDashboardData( const checkExists = options.existsSync ?? existsSync; const resolveTsLoader = resolveTsLoaderPath(packageRoot); - // Use test override if provided; otherwise resolve via resolveSubprocessModule const testModulePath = env[TEST_AUTO_DASHBOARD_MODULE_ENV]; const moduleResolution = testModulePath ? { modulePath: testModulePath, useCompiledJs: false } diff --git a/src/web/bridge-service.ts b/src/web/bridge-service.ts index 796873fc7..c355086e8 100644 --- a/src/web/bridge-service.ts +++ b/src/web/bridge-service.ts @@ -397,6 +397,17 @@ function filterAndSortSessions( return scored.map((entry) => entry.session); } +export interface RtkSessionSavings { + commands: number; + inputTokens: number; + outputTokens: number; + savedTokens: number; + savingsPct: number; + totalTimeMs: number; + avgTimeMs: number; + updatedAt: string; +} + export interface AutoDashboardData { active: boolean; paused: boolean; @@ -408,6 +419,9 @@ export interface AutoDashboardData { basePath: string; totalCost: number; totalTokens: number; + rtkSavings?: RtkSessionSavings | null; + /** Whether RTK is enabled via experimental.rtk preference. False when not opted in. */ + rtkEnabled?: boolean; } export interface BridgeLastError { diff --git a/src/web/settings-service.ts b/src/web/settings-service.ts index bbca6132d..8e1b5c6ea 100644 --- a/src/web/settings-service.ts +++ b/src/web/settings-service.ts @@ -98,6 +98,7 @@ export async function collectSettingsData(projectCwdOverride?: string): Promise< ' scope: loaded.scope,', ' path: loaded.path,', ' warnings: loaded.warnings,', + ' experimental: p.experimental ? { rtk: p.experimental.rtk } : undefined,', ' };', '}', diff --git a/web/app/api/experimental/route.ts b/web/app/api/experimental/route.ts new file mode 100644 index 000000000..81b3ec6f7 --- /dev/null +++ b/web/app/api/experimental/route.ts @@ -0,0 +1,110 @@ +import { homedir } from "node:os" +import { readFileSync, writeFileSync, existsSync, mkdirSync } 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" + +const NO_STORE = { "Cache-Control": "no-store" } as const + +// ─── Helpers (same pattern as remote-questions/route.ts) ───────────────────── + +function getPreferencesPath(): string { + return join(homedir(), ".gsd", "preferences.md") +} + +function parseFrontmatter(content: string): { data: Record; body: string } { + const startMarker = content.startsWith("---\r\n") ? "---\r\n" : "---\n" + if (!content.startsWith(startMarker)) return { data: {}, body: content } + const searchStart = startMarker.length + const endIdx = content.indexOf("\n---", searchStart) + if (endIdx === -1) return { data: {}, body: content } + const block = content.slice(searchStart, endIdx) + const afterFrontmatter = content.slice(endIdx + 4) + try { + const parsed = parseYaml(block.replace(/\r/g, "")) + const data = typeof parsed === "object" && parsed !== null ? (parsed as Record) : {} + return { data, body: afterFrontmatter } + } catch { + return { data: {}, body: content } + } +} + +function writeFrontmatter(data: Record, body: string): string { + const yamlStr = stringifyYaml(data, { lineWidth: 0 }).trimEnd() + return `---\n${yamlStr}\n---${body}` +} + +function readPrefs(): { data: Record; body: string } { + const path = getPreferencesPath() + if (!existsSync(path)) return { data: {}, body: "\n" } + const content = readFileSync(path, "utf-8") + return parseFrontmatter(content) +} + +function writePrefs(data: Record, body: string): void { + const path = getPreferencesPath() + const dir = dirname(path) + if (!existsSync(dir)) mkdirSync(dir, { recursive: true }) + writeFileSync(path, writeFrontmatter(data, body), "utf-8") +} + +// ─── GET — read current experimental flags ─────────────────────────────────── + +export async function GET(): Promise { + try { + const { data } = readPrefs() + const exp = typeof data.experimental === "object" && data.experimental !== null + ? (data.experimental as Record) + : {} + return Response.json({ rtk: exp.rtk === true }, { headers: NO_STORE }) + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + return Response.json({ error: message }, { status: 500, headers: NO_STORE }) + } +} + +// ─── PATCH — toggle an experimental flag ──────────────────────────────────── +// +// Body: { flag: "rtk", enabled: boolean } + +export async function PATCH(request: Request): Promise { + try { + const body = await request.json() as Record + const { flag, enabled } = body + + const KNOWN_FLAGS = new Set(["rtk"]) + if (typeof flag !== "string" || !KNOWN_FLAGS.has(flag)) { + return Response.json( + { error: `Unknown experimental flag "${flag}". Known flags: ${[...KNOWN_FLAGS].join(", ")}` }, + { status: 400, headers: NO_STORE }, + ) + } + if (typeof enabled !== "boolean") { + return Response.json( + { error: "enabled must be a boolean" }, + { status: 400, headers: NO_STORE }, + ) + } + + const { data, body: mdBody } = readPrefs() + + // Merge into experimental block + const existing = typeof data.experimental === "object" && data.experimental !== null + ? { ...(data.experimental as Record) } + : {} + existing[flag] = enabled + data.experimental = existing + + writePrefs(data, mdBody) + + return Response.json({ [flag]: enabled }, { headers: NO_STORE }) + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + return Response.json( + { error: `Failed to update experimental flag: ${message}` }, + { status: 500, headers: NO_STORE }, + ) + } +} diff --git a/web/app/api/terminal/sessions/route.ts b/web/app/api/terminal/sessions/route.ts index 3e040cfd5..d6d9a8f0f 100644 --- a/web/app/api/terminal/sessions/route.ts +++ b/web/app/api/terminal/sessions/route.ts @@ -10,6 +10,7 @@ import { listSessions, getOrCreateSession, destroySession, + isAllowedTerminalCommand, } from "../../../../lib/pty-manager"; import { requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; @@ -27,19 +28,6 @@ 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()}`; @@ -51,7 +39,7 @@ export async function POST(request: Request): Promise { // No body or invalid JSON — use default shell } - if (command && !ALLOWED_COMMANDS.has(command)) { + if (command && !isAllowedTerminalCommand(command)) { return Response.json( { error: `Command not allowed: ${command}` }, { status: 403 }, diff --git a/web/app/api/terminal/stream/route.ts b/web/app/api/terminal/stream/route.ts index ec5d2eab4..92b8f389a 100644 --- a/web/app/api/terminal/stream/route.ts +++ b/web/app/api/terminal/stream/route.ts @@ -9,6 +9,7 @@ import { getOrCreateSession, addListener, + isAllowedTerminalCommand, } from "../../../../lib/pty-manager"; import { requireProjectCwd } from "../../../../../src/web/bridge-service.ts"; @@ -24,6 +25,13 @@ export async function GET(request: Request): Promise { const commandArgs = url.searchParams.getAll("arg"); const projectCwd = requireProjectCwd(request); + if (!isAllowedTerminalCommand(command)) { + return Response.json( + { error: `Command not allowed: ${command}` }, + { status: 403 }, + ); + } + // Ensure the session exists try { getOrCreateSession(sessionId, projectCwd, command, commandArgs); diff --git a/web/components/gsd/command-surface.tsx b/web/components/gsd/command-surface.tsx index 179f9fbc0..90a8baa0d 100644 --- a/web/components/gsd/command-surface.tsx +++ b/web/components/gsd/command-surface.tsx @@ -11,6 +11,7 @@ import { Download, ExternalLink, FileText, + FlaskConical, FolderRoot, GitBranch, KeyRound, @@ -56,7 +57,7 @@ import { } from "@/lib/dev-overrides" import { DoctorPanel, ForensicsPanel, SkillHealthPanel } from "./diagnostics-panels" import { KnowledgeCapturesPanel } from "./knowledge-captures-panel" -import { PrefsPanel, ModelRoutingPanel, BudgetPanel, RemoteQuestionsPanel, GeneralPanel } from "./settings-panels" +import { PrefsPanel, ModelRoutingPanel, BudgetPanel, RemoteQuestionsPanel, GeneralPanel, ExperimentalPanel } from "./settings-panels" import { DevRootSettingsSection } from "./projects-view" import { QuickPanel, @@ -82,7 +83,7 @@ import { // ─── Section metadata ──────────────────────────────────────────────── -const SETTINGS_SURFACE_SECTIONS = ["general", "model", "session-behavior", "recovery", "auth", "integrations", "workspace"] as const +const SETTINGS_SURFACE_SECTIONS = ["general", "model", "session-behavior", "recovery", "auth", "integrations", "workspace", "experimental"] as const const ADMIN_SECTION: CommandSurfaceSection = "admin" const GIT_SURFACE_SECTIONS = ["git"] as const const SESSION_SURFACE_SECTIONS = ["resume", "name", "fork", "session", "compact"] as const @@ -125,6 +126,7 @@ function sectionLabel(section: CommandSurfaceSection): string { compact: "Compact", workspace: "Workspace", integrations: "Integrations", + experimental: "Experimental", } return labels[section] ?? section } @@ -149,6 +151,7 @@ function sectionIcon(section: CommandSurfaceSection) { compact: , workspace: , integrations: , + experimental: , } return icons[section] ?? null } @@ -435,7 +438,8 @@ export function CommandSurface() { } else if ( (commandSurface.section === "gsd-prefs" || commandSurface.section === "gsd-mode" || - commandSurface.section === "gsd-config") && + commandSurface.section === "gsd-config" || + commandSurface.section === "experimental") && settingsData.phase === "idle" ) { void loadSettingsData() @@ -2053,6 +2057,7 @@ export function CommandSurface() { const renderSection = () => { switch (commandSurface.section) { case "general": return + case "experimental": return case "model": return (
{renderModelSection()} @@ -2139,6 +2144,7 @@ export function CommandSurface() { +
) case "gsd-mode": return diff --git a/web/components/gsd/dashboard.tsx b/web/components/gsd/dashboard.tsx index b1480fda2..165a55b5c 100644 --- a/web/components/gsd/dashboard.tsx +++ b/web/components/gsd/dashboard.tsx @@ -9,8 +9,7 @@ import { Circle, Play, GitBranch, - Loader2, - Milestone, + TrendingDown, } from "lucide-react" import { cn } from "@/lib/utils" import { @@ -114,12 +113,13 @@ export function Dashboard({ onSwitchView, onExpandTerminal }: DashboardProps = { const workspace = getLiveWorkspaceIndex(state) const auto = getLiveAutoDashboard(state) const bridge = boot?.bridge ?? null - const projectCwd = boot?.project.cwd ?? null const freshness = state.live.freshness const elapsed = auto?.elapsed ?? 0 const totalCost = auto?.totalCost ?? 0 const totalTokens = auto?.totalTokens ?? 0 + const rtkSavings = auto?.rtkSavings ?? null + const rtkEnabled = auto?.rtkEnabled === true const currentSlice = getCurrentSlice(workspace) const doneTasks = currentSlice?.tasks.filter((t) => t.done).length ?? 0 @@ -157,6 +157,13 @@ export function Dashboard({ onSwitchView, onExpandTerminal }: DashboardProps = { const recentLines: WorkspaceTerminalLine[] = (state.terminalLines ?? []).slice(-6) const isConnecting = state.bootStatus === "idle" || state.bootStatus === "loading" + const rtkValue = isConnecting ? null : formatTokens(rtkSavings?.savedTokens ?? 0) + const rtkSubtext = isConnecting + ? null + : rtkSavings && rtkSavings.commands > 0 + ? `${Math.round(rtkSavings.savingsPct)}% saved • ${rtkSavings.commands} cmd${rtkSavings.commands === 1 ? "" : "s"}` + : "Waiting for shell usage" + // ─── Project Welcome Gate ─────────────────────────────────────────── // Show welcome screen for projects that aren't initialized with GSD yet const detection = boot?.projectDetection @@ -221,7 +228,7 @@ export function Dashboard({ onSwitchView, onExpandTerminal }: DashboardProps = {
-
+
@@ -262,6 +269,14 @@ export function Dashboard({ onSwitchView, onExpandTerminal }: DashboardProps = { value={isConnecting ? null : formatTokens(totalTokens)} icon={} /> + {rtkEnabled && ( + } + /> + )}
diff --git a/web/components/gsd/loading-skeletons.tsx b/web/components/gsd/loading-skeletons.tsx index c6a445fc3..a99462e62 100644 --- a/web/components/gsd/loading-skeletons.tsx +++ b/web/components/gsd/loading-skeletons.tsx @@ -129,7 +129,7 @@ interface DashboardSkeletonProps { export function DashboardMetricsSkeleton({ icons }: DashboardSkeletonProps) { return ( -
+
diff --git a/web/components/gsd/settings-panels.tsx b/web/components/gsd/settings-panels.tsx index 877f11703..c80bf7d8a 100644 --- a/web/components/gsd/settings-panels.tsx +++ b/web/components/gsd/settings-panels.tsx @@ -9,6 +9,7 @@ import { DollarSign, Eye, EyeOff, + FlaskConical, KeyRound, LoaderCircle, Radio, @@ -1052,6 +1053,165 @@ export function GeneralPanel() { ) } +// ═══════════════════════════════════════════════════════════════════════ +// EXPERIMENTAL PANEL +// ═══════════════════════════════════════════════════════════════════════ + +interface ExperimentalFlag { + key: string + label: string + description: string + warning?: string +} + +const EXPERIMENTAL_FLAGS: ExperimentalFlag[] = [ + { + key: "rtk", + label: "RTK Shell Compression", + description: + "Wraps shell commands through the RTK binary to reduce token usage during command execution. RTK is downloaded automatically on first use.", + warning: "Experimental — may change or be removed without notice.", + }, +] + +export function ExperimentalPanel() { + const { state, data, busy, refresh } = useSettingsData() + const prefs = data?.preferences ?? null + + const [flags, setFlags] = useState>({}) + const [saving, setSaving] = useState>({}) + const [saveError, setSaveError] = useState(null) + + // Trigger a settings load if data hasn't been fetched yet (e.g. navigating + // directly to the Experimental tab without going through gsd-prefs first). + useEffect(() => { + if (!data && !busy && state.phase === "idle") { + refresh() + } + }, []) // eslint-disable-line react-hooks/exhaustive-deps + + // Sync local state from loaded prefs + useEffect(() => { + if (!prefs) return + setFlags({ rtk: prefs.experimental?.rtk === true }) + }, [prefs]) + + async function toggle(flagKey: string, next: boolean) { + setSaving((s) => ({ ...s, [flagKey]: true })) + setSaveError(null) + try { + const res = await authFetch("/api/experimental", { + method: "PATCH", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ flag: flagKey, enabled: next }), + }) + if (!res.ok) { + const body = await res.json().catch(() => ({})) as { error?: string } + throw new Error(body.error ?? `HTTP ${res.status}`) + } + setFlags((f) => ({ ...f, [flagKey]: next })) + // Refresh settings data so PrefsPanel reflects the change + refresh() + } catch (err) { + setSaveError(err instanceof Error ? err.message : String(err)) + } finally { + setSaving((s) => ({ ...s, [flagKey]: false })) + } + } + + return ( +
+ } + subtitle="Opt-in features — may change without notice" + onRefresh={refresh} + refreshing={busy} + /> + + {state.error && } + {saveError && } + {busy && !data && } + +
+ {EXPERIMENTAL_FLAGS.map((flag) => { + const enabled = flags[flag.key] ?? false + const isSaving = saving[flag.key] ?? false + + return ( +
+
+
+
+ {flag.label} + + {enabled ? "on" : "off"} + +
+

+ {flag.description} +

+ {flag.warning && ( +
+ + {flag.warning} +
+ )} +
+ +
+
+ ) + })} +
+ + {data && ( +

+ Changes are written to{" "} + {prefs?.path ?? "~/.gsd/preferences.md"} + {" "}and take effect on the next session. +

+ )} +
+ ) +} + +// ═══════════════════════════════════════════════════════════════════════ +// LEGACY EXPORTS +// ═══════════════════════════════════════════════════════════════════════ + // Legacy exports for backward compatibility with gsd-prefs mega-scroll export const TerminalSizePanel = GeneralPanel export const EditorSizePanel = () => null diff --git a/web/lib/command-surface-contract.ts b/web/lib/command-surface-contract.ts index bb0760914..00029418f 100644 --- a/web/lib/command-surface-contract.ts +++ b/web/lib/command-surface-contract.ts @@ -40,6 +40,7 @@ export type CommandSurfaceSection = | "compact" | "workspace" | "integrations" + | "experimental" // GSD subcommand surfaces (S02) | "gsd-status" | "gsd-visualize" diff --git a/web/lib/gsd-workspace-store.tsx b/web/lib/gsd-workspace-store.tsx index a912c4217..335085c47 100644 --- a/web/lib/gsd-workspace-store.tsx +++ b/web/lib/gsd-workspace-store.tsx @@ -180,6 +180,17 @@ export interface WorkspaceIndex { validationIssues: WorkspaceValidationIssue[] } +export interface RtkSessionSavings { + commands: number + inputTokens: number + outputTokens: number + savedTokens: number + savingsPct: number + totalTimeMs: number + avgTimeMs: number + updatedAt: string +} + export interface AutoDashboardData { active: boolean paused: boolean @@ -191,6 +202,9 @@ export interface AutoDashboardData { basePath: string totalCost: number totalTokens: number + rtkSavings?: RtkSessionSavings | null + /** Whether RTK is enabled via experimental.rtk preference. False when not opted in. */ + rtkEnabled?: boolean } export interface BootResumableSession { diff --git a/web/lib/pty-manager.ts b/web/lib/pty-manager.ts index ddadb3958..dcb21fb03 100644 --- a/web/lib/pty-manager.ts +++ b/web/lib/pty-manager.ts @@ -119,6 +119,19 @@ interface TerminalSpawnSpec { label: string; } +const ALLOWED_TERMINAL_COMMANDS = new Set([ + "gsd", + process.env.SHELL || "/bin/zsh", + "/bin/bash", + "/bin/zsh", + "/bin/sh", +]); + +export function isAllowedTerminalCommand(command?: string): boolean { + if (!command) return true; + return ALLOWED_TERMINAL_COMMANDS.has(command); +} + function resolveTerminalSpawnSpec(cwd: string, command?: string, commandArgs: string[] = []): TerminalSpawnSpec { if (!command) { const shell = getDefaultShell(); @@ -235,6 +248,9 @@ function loadNodePty(): LoadedNodePty { export function getOrCreateSession(sessionId: string, projectCwd?: string, command?: string, commandArgs: string[] = []): PtySession { ensureProcessCleanupHandlers(); + if (!isAllowedTerminalCommand(command)) { + throw new Error(`Command not allowed: ${command}`); + } const map = getSessions(); const existing = map.get(sessionId); if (existing?.alive) return existing; diff --git a/web/lib/settings-types.ts b/web/lib/settings-types.ts index db962e00d..5a28175c2 100644 --- a/web/lib/settings-types.ts +++ b/web/lib/settings-types.ts @@ -107,6 +107,9 @@ export interface SettingsPreferencesData { timeoutMinutes?: number pollIntervalSeconds?: number } + experimental?: { + rtk?: boolean + } scope: "global" | "project" path: string warnings?: string[]