@shogo-ai/worker 1.9.9 → 1.10.1

package/src/commands/doctor.ts

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * `shogo doctor` — diagnose and repair a wedged local Shogo database.
+ *
+ *   shogo doctor                 — detect + (with confirmation) repair
+ *   shogo doctor --check         — detect only, never mutate
+ *   shogo doctor --yes           — repair without the confirmation prompt
+ *   shogo doctor --db <path>     — target a specific shogo.db
+ *   shogo doctor --bun <path>    — use a specific bun binary
+ *   shogo doctor --no-backup     — skip the pre-repair backup (discouraged)
+ *
+ * Clears `_prisma_migrations` rows left in a failed (P3009) state so the
+ * desktop app can re-apply migrations on its next launch. Always backs up
+ * the database first unless `--no-backup` is passed.
+ */
+import { createInterface } from 'node:readline';
+import pc from 'picocolors';
+import {
+  detectFailedMigrations,
+  runDatabaseDoctor,
+  resolveDesktopDbPath,
+  resolveBunBinary,
+  type FailedMigration,
+} from '../lib/db-doctor.ts';
+
+export interface DoctorFlags {
+  check?: boolean;
+  yes?: boolean;
+  db?: string;
+  bun?: string;
+  backup?: boolean; // commander sets `backup: false` for --no-backup
+}
+
+function printFailures(failures: FailedMigration[]): void {
+  for (const f of failures) {
+    const when = Number.isFinite(f.startedAt) ? new Date(f.startedAt).toISOString() : 'unknown time';
+    const firstLine = (f.errorExcerpt ?? '').split('\n')[0]?.trim();
+    console.log(`  ${pc.yellow('•')} ${pc.bold(f.name)} ${pc.dim(`(attempted ${when})`)}`);
+    if (firstLine) console.log(`    ${pc.dim(firstLine)}`);
+  }
+}
+
+async function confirm(question: string): Promise<boolean> {
+  // Non-interactive (CI, piped) stdin: refuse rather than hang.
+  if (!process.stdin.isTTY) {
+    console.log(pc.dim('(stdin is not a TTY — re-run with --yes to repair non-interactively)'));
+    return false;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise<string>((resolve) => rl.question(question, resolve));
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+export async function runDoctor(flags: DoctorFlags = {}): Promise<void> {
+  const dbPath = flags.db ?? resolveDesktopDbPath();
+  const bunPath = resolveBunBinary(flags.bun);
+
+  if (!bunPath) {
+    throw new Error(
+      'Could not find a usable `bun` binary (needed to inspect the SQLite database).\n' +
+        '  • Install Bun (https://bun.sh) so `bun` is on your PATH, or\n' +
+        '  • pass --bun <path> pointing at the bun shipped inside the Shogo app\n' +
+        "    (e.g. /Applications/Shogo.app/Contents/Resources/bun/bun on macOS).",
+    );
+  }
+
+  console.log(pc.dim(`Database: ${dbPath}`));
+  console.log(pc.dim(`Bun:      ${bunPath}`));
+  console.log();
+
+  const failures = detectFailedMigrations(bunPath, dbPath);
+
+  if (failures.length === 0) {
+    console.log(pc.green('✓ No failed migrations detected — your local database looks healthy.'));
+    return;
+  }
+
+  console.log(pc.red(`✗ Found ${failures.length} failed migration(s):`));
+  printFailures(failures);
+  console.log();
+
+  if (flags.check) {
+    console.log(
+      pc.dim('Run `shogo doctor` (without --check) to back up the database and clear these records.'),
+    );
+    // Signal "needs repair" to scripts/CI without throwing a stack trace.
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!flags.yes) {
+    const backupNote =
+      flags.backup === false
+        ? pc.red('This will NOT create a backup (--no-backup).')
+        : 'Your database will be backed up to a .bak-<timestamp> file first.';
+    console.log(backupNote);
+    const ok = await confirm(pc.bold('Clear these failed migration records and repair? [y/N] '));
+    if (!ok) {
+      console.log(pc.dim('Aborted — no changes made.'));
+      process.exitCode = 1;
+      return;
+    }
+    console.log();
+  }
+
+  const result = runDatabaseDoctor({
+    bunPath,
+    dbPath,
+    skipBackup: flags.backup === false,
+    log: (line) => console.log(pc.dim(`  ${line}`)),
+  });
+
+  console.log();
+  if (result.status === 'repaired') {
+    console.log(pc.green(`✓ ${result.message}`));
+    if (result.backupPath) console.log(pc.dim(`  Backup: ${result.backupPath}`));
+    console.log(pc.bold('\n  → Relaunch the Shogo app to finish applying migrations.'));
+  } else {
+    console.log(pc.red(`✗ ${result.message}`));
+    if (result.backupPath) console.log(pc.dim(`  Backup: ${result.backupPath}`));
+    process.exitCode = 1;
+  }
+}

package/src/commands/start.ts

@@ -124,9 +124,17 @@ export async function runStart(flags: StartFlags): Promise<void> {
   }
   console.log('');
 
+  // Derive the AI proxy URL from the cloud URL so the agent-runtime
+  // routes LLM calls through Shogo Cloud's proxy instead of requiring
+  // direct API keys on the machine.  The proxy endpoint lives at
+  // <cloudUrl>/api/ai/v1 — the same base the desktop app uses.
+  const aiProxyUrl = `${cfg.cloudUrl.replace(/\/+$/, '')}/api/ai/v1`;
+
   const defaultSpawnConfig: ProjectSpawnConfig = {
     cloudUrl: cfg.cloudUrl,
     apiKey: cfg.apiKey,
+    aiProxyUrl,
+    aiProxyToken: cfg.apiKey,
     // No projectDir up front — the runtime manager's `maybeAutoPull`
     // sets PROJECT_DIR per-project to <projectsDir>/<projectId>/ once
     // the clone completes. CWD defaults to that same directory.
@@ -261,13 +269,18 @@ function buildChildArgv(flags: StartFlags): string[] {
  *   2. The compiled binary at /usr/local/bin/shogo on PATH (best-effort).
  *   3. The bin shim shipped with this package.
  */
-function resolveSelfEntry(): { entry: string; runner: 'bun' | 'node' } {
+function resolveSelfEntry(): { entry: string; runner: 'bun' | 'node' | 'tsx' } {
   // process.execPath is the bun/node binary; argv[1] is the script.
   const execPath = process.execPath;
   const isBun = /\bbun(?:-[^/\\]*)?$/.test(execPath) || typeof (globalThis as any).Bun !== 'undefined';
   const argvScript = process.argv[1];
   if (argvScript && existsSync(argvScript)) {
-    return { entry: argvScript, runner: isBun ? 'bun' : 'node' };
+    // When spawned via tsx (from the bin shim), process.execPath is still
+    // `node` because tsx runs on top of Node. Detect a .ts entry and route
+    // through tsx so the detached child can handle TypeScript natively.
+    const isTs = /\.ts$/.test(argvScript);
+    const runner = isBun ? 'bun' : (isTs ? 'tsx' : 'node');
+    return { entry: argvScript, runner };
   }
   // Fallback: the compiled bin shim shipped with the package.
   // Resolved relative to this file via import.meta.url so it works

package/src/lib/__tests__/agent-launch.test.ts

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * Smoke tests for the MIT `shogo` agent launcher (argv + env shape).
+ * buildAgentSpawn is pure, so no spawn / network / runtime binary is needed.
+ */
+import { describe, test, expect } from 'bun:test'
+import { resolve as resolvePath } from 'node:path'
+import { buildAgentSpawn } from '../../commands/agent.ts'
+import type { ResolvedRuntime } from '../runtime-resolver.ts'
+
+const runtime: ResolvedRuntime = { path: '/home/u/.shogo/runtime/agent-runtime', source: 'home' }
+const config = { apiKey: 'shogo_sk_test123', cloudUrl: 'https://studio.shogo.ai' }
+
+describe('buildAgentSpawn', () => {
+  test('interactive launch: argv + billing env point at the proxy', () => {
+    const plan = buildAgentSpawn({
+      flags: { cwd: '/work/repo' },
+      config,
+      runtime,
+      baseEnv: {},
+    })
+
+    expect(plan.bin).toBe('/home/u/.shogo/runtime/agent-runtime')
+    expect(plan.args).toEqual(['interactive'])
+    expect(plan.cwd).toBe(resolvePath('/work/repo'))
+
+    expect(plan.env.SHOGO_INTERACTIVE).toBe('1')
+    expect(plan.env.SHOGO_INTERACTIVE_CWD).toBe(resolvePath('/work/repo'))
+    expect(plan.env.PROJECT_DIR).toBe(resolvePath('/work/repo'))
+    expect(plan.env.WORKSPACE_DIR).toBe(resolvePath('/work/repo'))
+    expect(plan.env.SHOGO_API_URL).toBe('https://studio.shogo.ai')
+    expect(plan.env.SHOGO_API_KEY).toBe('shogo_sk_test123')
+    expect(plan.env.AI_PROXY_URL).toBe('https://studio.shogo.ai/api/ai/v1')
+    expect(plan.env.AI_PROXY_TOKEN).toBe('shogo_sk_test123')
+  })
+
+  test('headless -p adds the print argv + SHOGO_PRINT_PROMPT', () => {
+    const plan = buildAgentSpawn({
+      flags: { print: 'review this', cwd: '/work/repo' },
+      config,
+      runtime,
+      baseEnv: {},
+    })
+    expect(plan.args).toEqual(['interactive', '-p', 'review this'])
+    expect(plan.env.SHOGO_PRINT_PROMPT).toBe('review this')
+  })
+
+  test('--no-tui and --model are threaded through', () => {
+    const plan = buildAgentSpawn({
+      flags: { noTui: true, model: 'claude-sonnet', cwd: '/work/repo' },
+      config,
+      runtime,
+      baseEnv: {},
+    })
+    expect(plan.args).toEqual(['interactive', '--no-tui'])
+    expect(plan.env.SHOGO_MODEL).toBe('claude-sonnet')
+  })
+
+  test('trailing slash on cloudUrl is stripped before building proxy URL', () => {
+    const plan = buildAgentSpawn({
+      flags: { cwd: '/work/repo' },
+      config: { apiKey: 'shogo_sk_x', cloudUrl: 'https://example.dev/' },
+      runtime,
+      baseEnv: {},
+    })
+    expect(plan.env.SHOGO_API_URL).toBe('https://example.dev')
+    expect(plan.env.AI_PROXY_URL).toBe('https://example.dev/api/ai/v1')
+  })
+
+  test('base env is preserved (e.g. PATH) and not clobbered', () => {
+    const plan = buildAgentSpawn({
+      flags: { cwd: '/work/repo' },
+      config,
+      runtime,
+      baseEnv: { PATH: '/usr/bin', HOME: '/home/u' },
+    })
+    expect(plan.env.PATH).toBe('/usr/bin')
+    expect(plan.env.HOME).toBe('/home/u')
+  })
+
+  test('empty -p (no value) still routes to headless argv', () => {
+    const plan = buildAgentSpawn({
+      flags: { print: '', cwd: '/work/repo' },
+      config,
+      runtime,
+      baseEnv: {},
+    })
+    expect(plan.args).toEqual(['interactive', '-p', ''])
+    expect(plan.env.SHOGO_PRINT_PROMPT).toBe('')
+  })
+})

package/src/lib/__tests__/db-doctor.test.ts

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+//
+// Tests for the local SQLite migration doctor.
+//
+// The doctor shells out to a `bun` binary to run `bun:sqlite` scripts.
+// Under `bun test` the test process IS bun, so `process.execPath` is a
+// valid bun binary to drive the real shell-out path against synthesized
+// databases (mirrors apps/desktop/test-db-recovery.ts).
+
+import { describe, it, expect, afterAll } from 'bun:test';
+import { Database } from 'bun:sqlite';
+import { mkdtempSync, rmSync, existsSync, statSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+import {
+  detectFailedMigrations,
+  backupDatabase,
+  repairFailedMigrations,
+  runDatabaseDoctor,
+  resolveDesktopDataDir,
+  resolveDesktopDbPath,
+  resolveBunBinary,
+} from '../db-doctor.ts';
+
+const BUN_PATH = process.execPath;
+
+const tempDirs: string[] = [];
+afterAll(() => {
+  for (const dir of tempDirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best-effort
+    }
+  }
+});
+
+interface SeedRow {
+  name: string;
+  startedAt: number;
+  finishedAt: number | null;
+  rolledBackAt?: number | null;
+  logs?: string;
+}
+
+function makeDbPath(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'shogo-doctor-test-'));
+  tempDirs.push(dir);
+  return join(dir, 'shogo.db');
+}
+
+function seed(dbPath: string, rows: SeedRow[]): void {
+  const db = new Database(dbPath, { create: true });
+  db.exec(`
+    CREATE TABLE _prisma_migrations (
+      id TEXT PRIMARY KEY,
+      migration_name TEXT NOT NULL,
+      checksum TEXT NOT NULL,
+      finished_at INTEGER,
+      started_at INTEGER NOT NULL,
+      rolled_back_at INTEGER,
+      logs TEXT,
+      applied_steps_count INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+  const stmt = db.prepare(
+    'INSERT INTO _prisma_migrations (id, migration_name, checksum, started_at, finished_at, rolled_back_at, logs) VALUES (?, ?, ?, ?, ?, ?, ?)',
+  );
+  for (const r of rows) {
+    stmt.run(randomUUID(), r.name, 'fake-checksum', r.startedAt, r.finishedAt, r.rolledBackAt ?? null, r.logs ?? null);
+  }
+  db.close();
+}
+
+describe('detectFailedMigrations', () => {
+  it('finds the stuck row on a broken DB', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [
+      { name: '0000_baseline', startedAt: 1000, finishedAt: 1100 },
+      { name: '0001_bad', startedAt: 2000, finishedAt: null, logs: 'no such table: widgets' },
+    ]);
+    const failures = detectFailedMigrations(BUN_PATH, dbPath);
+    expect(failures).toHaveLength(1);
+    expect(failures[0]?.name).toBe('0001_bad');
+    expect(failures[0]?.startedAt).toBe(2000);
+    expect(failures[0]?.errorExcerpt).toContain('no such table: widgets');
+  });
+
+  it('returns [] for a healthy DB', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [{ name: '0000_baseline', startedAt: 1000, finishedAt: 1100 }]);
+    expect(detectFailedMigrations(BUN_PATH, dbPath)).toHaveLength(0);
+  });
+
+  it('returns [] when the DB file does not exist', () => {
+    expect(detectFailedMigrations(BUN_PATH, join(tmpdir(), `nope-${Date.now()}.db`))).toHaveLength(0);
+  });
+});
+
+describe('runDatabaseDoctor', () => {
+  it('reports no-database for a missing file', () => {
+    const result = runDatabaseDoctor({
+      bunPath: BUN_PATH,
+      dbPath: join(tmpdir(), `missing-${Date.now()}.db`),
+    });
+    expect(result.status).toBe('no-database');
+    expect(result.detected).toHaveLength(0);
+  });
+
+  it('is a no-op on a healthy DB', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [{ name: '0000_baseline', startedAt: 1000, finishedAt: 1100 }]);
+    const result = runDatabaseDoctor({ bunPath: BUN_PATH, dbPath });
+    expect(result.status).toBe('healthy');
+    expect(result.backupPath).toBeUndefined();
+    expect(result.cleared).toHaveLength(0);
+  });
+
+  it('backs up, clears the stuck row, and reports repaired', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [
+      { name: 'good', startedAt: 1000, finishedAt: 1100 },
+      { name: 'bad', startedAt: 2000, finishedAt: null, logs: 'oops' },
+    ]);
+
+    const result = runDatabaseDoctor({ bunPath: BUN_PATH, dbPath });
+
+    expect(result.status).toBe('repaired');
+    expect(result.detected.map((m) => m.name)).toEqual(['bad']);
+    expect(result.cleared).toEqual(['bad']);
+    expect(result.remaining).toHaveLength(0);
+    expect(result.backupPath).toBeDefined();
+    expect(existsSync(result.backupPath!)).toBe(true);
+    expect(statSync(result.backupPath!).size).toBeGreaterThan(0);
+
+    // The good row survives; the bad row is gone.
+    const db = new Database(dbPath, { readonly: true });
+    const names = (db.query('SELECT migration_name FROM _prisma_migrations').all() as Array<{ migration_name: string }>)
+      .map((r) => r.migration_name);
+    db.close();
+    expect(names).toEqual(['good']);
+
+    // Re-running is idempotent: now healthy.
+    expect(runDatabaseDoctor({ bunPath: BUN_PATH, dbPath }).status).toBe('healthy');
+  });
+
+  it('honors skipBackup', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [{ name: 'bad', startedAt: 2000, finishedAt: null, logs: 'oops' }]);
+    const result = runDatabaseDoctor({ bunPath: BUN_PATH, dbPath, skipBackup: true });
+    expect(result.status).toBe('repaired');
+    expect(result.backupPath).toBeUndefined();
+  });
+});
+
+describe('backupDatabase / repairFailedMigrations', () => {
+  it('produces a byte-faithful sibling backup', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [{ name: 'm1', startedAt: 1, finishedAt: 2 }]);
+    const backupPath = backupDatabase(dbPath);
+    expect(existsSync(backupPath)).toBe(true);
+    expect(dirname(backupPath)).toBe(dirname(dbPath));
+    expect(backupPath).toMatch(/\.bak-/);
+    expect(statSync(backupPath).size).toBe(statSync(dbPath).size);
+  });
+
+  it('leaves already rolled-back rows alone', () => {
+    const dbPath = makeDbPath();
+    seed(dbPath, [{ name: 'rb', startedAt: 1000, finishedAt: null, rolledBackAt: 1200 }]);
+    const deleted = repairFailedMigrations(BUN_PATH, dbPath, ['rb']);
+    expect(deleted).toBe(0);
+  });
+});
+
+describe('path / bun resolution', () => {
+  it('resolveDesktopDbPath is shogo.db under the Shogo data dir', () => {
+    expect(resolveDesktopDbPath()).toBe(join(resolveDesktopDataDir(), 'shogo.db'));
+    expect(resolveDesktopDataDir()).toContain('Shogo');
+  });
+
+  it('resolveDesktopDataDir uses the platform app-data root', () => {
+    const dir = resolveDesktopDataDir();
+    if (process.platform === 'darwin') {
+      expect(dir).toContain(join('Library', 'Application Support'));
+    } else if (process.platform === 'win32') {
+      // %APPDATA% (Roaming) — just assert it ends with the expected tail.
+      expect(dir.endsWith(join('Shogo', 'data'))).toBe(true);
+    } else {
+      expect(dir).toContain(join('.config'));
+    }
+    expect(dir.startsWith(homedir()) || process.platform === 'win32').toBe(true);
+  });
+
+  it('resolveBunBinary returns the running bun and honors an explicit override', () => {
+    // Under `bun test`, process.execPath is a usable bun.
+    expect(resolveBunBinary()).toBe(process.execPath);
+    expect(resolveBunBinary(process.execPath)).toBe(process.execPath);
+    // A bogus override is rejected (null) rather than returned blindly.
+    expect(resolveBunBinary(join(tmpdir(), 'definitely-not-bun'))).toBeNull();
+  });
+});

package/src/lib/__tests__/runtime-manager-tree-sitter-env.test.ts

@@ -122,3 +122,68 @@ describe('WorkerRuntimeManager.buildEnv — TREE_SITTER_WASM_DIR injection', ()
     expect(env.TREE_SITTER_WASM_DIR).toBe('/runtime/tree-sitter-wasm');
   });
 });
+
+describe('WorkerRuntimeManager.buildEnv — WORKSPACE_API_PORT_BASE (per-runtime preview sidecar base)', () => {
+  // Regression: every workspace runtime previously fell back to the fixed
+  // default base (3101) for its preview sidecars, so the first project of each
+  // concurrently-warm runtime bound the SAME port — crash-looping the
+  // preview-manager and SIGKILL-restart-storming the agent-runtime. The base
+  // must be derived from the runtime's unique agent port instead.
+  function mgr() {
+    return new WorkerRuntimeManager({ env: {} as NodeJS.ProcessEnv }) as unknown as {
+      buildEnv(slot: unknown, runtimeBinPath: string): NodeJS.ProcessEnv;
+    };
+  }
+
+  it('anchors WORKSPACE_API_PORT_BASE at agentPort + 2 (above agent + its API server)', () => {
+    const env = mgr().buildEnv(
+      fakeSlot({ agentPort: 37646, apiServerPort: 37647 }),
+      '/runtime/shogo-agent-runtime',
+    );
+    expect(env.WORKSPACE_API_PORT_BASE).toBe('37648');
+  });
+
+  it('gives two distinct runtimes distinct sidecar bases (no cross-runtime 3101 collision)', () => {
+    const m = mgr();
+    const a = m.buildEnv(fakeSlot({ agentPort: 37646 }), '/runtime/shogo-agent-runtime');
+    const b = m.buildEnv(fakeSlot({ agentPort: 37404 }), '/runtime/shogo-agent-runtime');
+    expect(a.WORKSPACE_API_PORT_BASE).not.toBe(b.WORKSPACE_API_PORT_BASE);
+    expect(a.WORKSPACE_API_PORT_BASE).toBe('37648');
+    expect(b.WORKSPACE_API_PORT_BASE).toBe('37406');
+  });
+});
+
+describe('WorkerRuntimeManager.allocatePort — per-runtime port block reservation', () => {
+  function rawMgr() {
+    return new WorkerRuntimeManager({ env: {} as NodeJS.ProcessEnv }) as unknown as {
+      allocatePort(): Promise<number>;
+      releasePort(port: number): void;
+      usedPorts: Set<number>;
+    };
+  }
+
+  it('reserves a contiguous block so a second allocation never overlaps the first runtime sidecar range', async () => {
+    const m = rawMgr();
+    const p1 = await m.allocatePort();
+    const p2 = await m.allocatePort();
+    // The two blocks [p, p+15] must be disjoint — otherwise runtime 2's agent
+    // port (or a sidecar) could land inside runtime 1's sidecar range.
+    const block1 = new Set<number>();
+    for (let off = 0; off < 16; off++) block1.add(p1 + off);
+    for (let off = 0; off < 16; off++) {
+      expect(block1.has(p2 + off)).toBe(false);
+    }
+  });
+
+  it('releasePort frees the whole block so the ports can be reused', async () => {
+    const m = rawMgr();
+    const p = await m.allocatePort();
+    // Sidecar ports (p+2 … p+15) are reserved, not just p and p+1.
+    expect(m.usedPorts.has(p + 2)).toBe(true);
+    expect(m.usedPorts.has(p + 15)).toBe(true);
+    m.releasePort(p);
+    for (let off = 0; off < 16; off++) {
+      expect(m.usedPorts.has(p + off)).toBe(false);
+    }
+  });
+});