@shogo-ai/worker 1.0.10

package/src/lib/__tests__/runtime-manager-describe-rejection.test.ts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * Coverage for `WorkerRuntimeManager.describeRejection` — the
+ * structured-rejection hook that the {@link WorkerTunnel} reads when
+ * `resolveLocalUrl` returns null.
+ *
+ * The tunnel echoes the returned `code` + `message` (plus the original
+ * path) into the 502 body so a Studio client reading the response can
+ * tell exactly what the worker refused to do. This file pins the wire
+ * shape so a future refactor doesn't silently change the body Studio
+ * relies on.
+ */
+import { describe, expect, it } from 'bun:test';
+import { WorkerRuntimeManager } from '../runtime-manager.ts';
+
+describe('WorkerRuntimeManager.describeRejection', () => {
+  it('flags non-/agent paths with CLI_WORKER_HAS_NO_DATA_API and the original path', () => {
+    const mgr = new WorkerRuntimeManager({});
+    const r = mgr.describeRejection('/api/projects?workspaceId=abc', 'p-1');
+    expect(r.code).toBe('CLI_WORKER_HAS_NO_DATA_API');
+    // Path in the message must be the pathname only — `?workspaceId=abc`
+    // is verbose and the tunnel echoes the full path separately.
+    expect(r.message).toContain('/api/projects');
+    expect(r.message).toContain('cli-worker only serves /agent/* paths');
+  });
+
+  it('flags /agent paths missing a project context with CLI_WORKER_NO_PROJECT_FOR_PATH', () => {
+    const mgr = new WorkerRuntimeManager({});
+    const r = mgr.describeRejection('/agent/chat', undefined);
+    expect(r.code).toBe('CLI_WORKER_NO_PROJECT_FOR_PATH');
+    expect(r.message).toContain('/agent/chat');
+    expect(r.message).toContain('projectId=none');
+  });
+
+  it('preserves the projectId when one is provided but no runtime exists', () => {
+    const mgr = new WorkerRuntimeManager({});
+    const r = mgr.describeRejection('/agent/chat', 'proj-42');
+    expect(r.code).toBe('CLI_WORKER_NO_PROJECT_FOR_PATH');
+    expect(r.message).toContain('projectId=proj-42');
+  });
+});

package/src/lib/__tests__/runtime-manager-git-pull.test.ts

@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * Tests for the GIT-mode branch of `WorkerRuntimeManager.maybeAutoPull`.
+ *
+ * Strategy:
+ *   - Mock `../git-cloner` so `cloneProject()` doesn't actually spawn git.
+ *   - Mock `globalThis.fetch` for the `.shogo/` SQLite top-up pass and
+ *     the manifest endpoint.
+ *   - Assert that:
+ *       * a fresh project triggers `cloneProject()`
+ *       * the `.shogo/` top-up issues a manifest+download for only those entries
+ *       * a populated `.git/` dir skips re-clone
+ *       * cloneProject failure flips the mode to 'files' and runs the
+ *         file-transport fallback
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// ─── git-cloner fakes injected via `autoPull.gitOps` ────────────────
+type CloneCall = { apiUrl: string; apiKey: string; projectId: string; localDir: string; shallow?: boolean };
+const cloneCalls: CloneCall[] = [];
+let cloneShouldThrow = false;
+const gitOps = {
+  cloneProject: async (opts: CloneCall) => {
+    cloneCalls.push(opts);
+    if (cloneShouldThrow) throw new Error('simulated clone failure');
+    mkdirSync(join(opts.localDir, '.git'), { recursive: true });
+    writeFileSync(join(opts.localDir, 'AGENTS.md'), 'AGENT');
+    return { commitSha: 'deadbeef' };
+  },
+  gitIsAvailable: async () => true,
+  isGitRepo: (dir: string) => existsSync(join(dir, '.git')),
+};
+
+// ─── fetch shim ────────────────────────────────────────────────────
+let scriptedFetch: typeof fetch | null = null;
+const originalFetch = globalThis.fetch;
+beforeEach(() => {
+  cloneCalls.length = 0;
+  cloneShouldThrow = false;
+  globalThis.fetch = ((input: any, init?: RequestInit) => {
+    if (!scriptedFetch) throw new Error('no scripted fetch set');
+    return scriptedFetch(input, init);
+  }) as any;
+});
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  scriptedFetch = null;
+});
+
+function scriptShogoTopup(files: Array<{ path: string; content: string }>) {
+  return (async (input: any, init?: RequestInit) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/workspace/manifest')) {
+      return new Response(
+        JSON.stringify({
+          ok: true,
+          projectId: 'p',
+          source: 's3',
+          generatedAt: '',
+          files: files.map((f) => ({ path: f.path, size: f.content.length, lastModified: null, etag: null })),
+        }),
+        { status: 200 },
+      );
+    }
+    if (url.includes('/s3/presign')) {
+      const body = JSON.parse((init?.body as string) || '{}') as { files: Array<{ path: string; action: string }> };
+      return new Response(
+        JSON.stringify({
+          ok: true,
+          urls: body.files.map((f) => ({ path: f.path, action: f.action, url: `https://dl.test/${encodeURIComponent(f.path)}` })),
+        }),
+        { status: 200 },
+      );
+    }
+    if (url.startsWith('https://dl.test/')) {
+      const path = decodeURIComponent(url.slice('https://dl.test/'.length));
+      const file = files.find((f) => f.path === path);
+      return file
+        ? new Response(file.content, { status: 200 })
+        : new Response('not found', { status: 404 });
+    }
+    return new Response('unhandled', { status: 500 });
+  }) as unknown as typeof fetch;
+}
+
+describe('WorkerRuntimeManager auto-pull (git mode)', () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'wrm-git-pull-'));
+  });
+  afterEach(() => {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('clones via git when git is available and the dir is empty', async () => {
+    const { WorkerRuntimeManager } = await import('../runtime-manager.ts');
+    scriptedFetch = scriptShogoTopup([]); // no .shogo entries
+    const mgr = new WorkerRuntimeManager({
+      autoPull: { enabled: true, projectsDir: dir, watch: false, useGit: true, gitOps },
+    });
+    const result = await mgr.ensurePulled('proj-g1', {
+      cloudUrl: 'https://api.test',
+      apiKey: 'shogo_sk_x',
+    });
+
+    expect(result.projectDir).toBe(join(dir, 'proj-g1'));
+    expect(cloneCalls.length).toBe(1);
+    expect(cloneCalls[0]!.projectId).toBe('proj-g1');
+    expect(cloneCalls[0]!.localDir).toBe(join(dir, 'proj-g1'));
+    expect(cloneCalls[0]!.shallow).toBe(true);
+    // The stub created AGENTS.md.
+    expect(existsSync(join(dir, 'proj-g1', 'AGENTS.md'))).toBe(true);
+  });
+
+  it('downloads .shogo/* via the file transport after a successful git clone', async () => {
+    const { WorkerRuntimeManager } = await import('../runtime-manager.ts');
+    scriptedFetch = scriptShogoTopup([
+      { path: '.shogo/db.sqlite', content: 'SQLITE-DB' },
+      { path: '.shogo/snapshots/2024.sqlite', content: 'SNAP' },
+      // non-.shogo entries in the manifest must be ignored by the top-up.
+      { path: 'src/App.tsx', content: 'APP' },
+    ]);
+    const mgr = new WorkerRuntimeManager({
+      autoPull: { enabled: true, projectsDir: dir, watch: false, useGit: true, gitOps },
+    });
+    await mgr.ensurePulled('proj-g2', {
+      cloudUrl: 'https://api.test',
+      apiKey: 'shogo_sk_x',
+    });
+
+    expect(cloneCalls.length).toBe(1);
+    const target = join(dir, 'proj-g2');
+    // .shogo/* was downloaded via the file transport.
+    expect(existsSync(join(target, '.shogo', 'db.sqlite'))).toBe(true);
+    expect(existsSync(join(target, '.shogo', 'snapshots', '2024.sqlite'))).toBe(true);
+    // src/App.tsx was NOT downloaded — git handles that.
+    expect(existsSync(join(target, 'src', 'App.tsx'))).toBe(false);
+  });
+
+  it('skips re-cloning when the local dir already has a .git/', async () => {
+    const { WorkerRuntimeManager } = await import('../runtime-manager.ts');
+    const target = join(dir, 'proj-g3');
+    mkdirSync(join(target, '.git'), { recursive: true });
+    writeFileSync(join(target, 'AGENTS.md'), 'existing');
+
+    scriptedFetch = scriptShogoTopup([]); // top-up still fires but is a no-op
+    const mgr = new WorkerRuntimeManager({
+      autoPull: { enabled: true, projectsDir: dir, watch: false, useGit: true, gitOps },
+    });
+    await mgr.ensurePulled('proj-g3', {
+      cloudUrl: 'https://api.test',
+      apiKey: 'shogo_sk_x',
+    });
+
+    expect(cloneCalls.length).toBe(0);
+    // Existing content is preserved.
+    expect(existsSync(join(target, 'AGENTS.md'))).toBe(true);
+  });
+
+  it('falls back to file transport when cloneProject throws', async () => {
+    const { WorkerRuntimeManager } = await import('../runtime-manager.ts');
+    cloneShouldThrow = true;
+    // Manifest serves a real file so the fallback downloadAll can produce something.
+    scriptedFetch = scriptShogoTopup([
+      { path: 'fallback.txt', content: 'FROM-FILES' },
+    ]);
+    const warnings: string[] = [];
+    const logger = {
+      log: () => {},
+      warn: (...args: any[]) => warnings.push(args.join(' ')),
+      error: () => {},
+    };
+
+    const mgr = new WorkerRuntimeManager({
+      autoPull: { enabled: true, projectsDir: dir, watch: false, useGit: true, logger, gitOps },
+    });
+    await mgr.ensurePulled('proj-g4', {
+      cloudUrl: 'https://api.test',
+      apiKey: 'shogo_sk_x',
+    });
+
+    expect(cloneCalls.length).toBe(1);
+    expect(warnings.some((w) => w.includes('git clone failed'))).toBe(true);
+    expect(existsSync(join(dir, 'proj-g4', 'fallback.txt'))).toBe(true);
+  });
+
+  it('uses file transport (not git) when useGit=false', async () => {
+    const { WorkerRuntimeManager } = await import('../runtime-manager.ts');
+    scriptedFetch = scriptShogoTopup([
+      { path: 'plain.txt', content: 'P' },
+    ]);
+    const mgr = new WorkerRuntimeManager({
+      autoPull: { enabled: true, projectsDir: dir, watch: false, useGit: false, gitOps },
+    });
+    await mgr.ensurePulled('proj-g5', {
+      cloudUrl: 'https://api.test',
+      apiKey: 'shogo_sk_x',
+    });
+    expect(cloneCalls.length).toBe(0);
+    expect(existsSync(join(dir, 'proj-g5', 'plain.txt'))).toBe(true);
+  });
+});

package/src/lib/__tests__/runtime-manager-idle-eviction.test.ts

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * Coverage for `WorkerRuntimeManager` idle eviction.
+ *
+ * The "chat cut mid-stream" symptom in production was: the agent-proxy
+ * never refreshed `lastUsedAt` on a long stream, so a 16-minute Opus
+ * turn looked identical to a 16-minute idle slot to the manager and
+ * `stop()` fired mid-stream. The reaper itself is correct — it's
+ * `lastUsedAt` that wasn't being kept fresh by the surrounding HTTP
+ * code.
+ *
+ * The reproduction here pins both halves of the contract:
+ *
+ *   1. With NO `touch()` calls inside the idle window, the reaper
+ *      DOES fire — the slot is killed, the process is SIGTERM'd, and
+ *      the runtimes map is cleared. This is the bug surface.
+ *
+ *   2. With periodic `touch()` calls (modelling the agent-proxy
+ *      forwarding chunks / the AI proxy receiving tool-call requests),
+ *      the reaper NEVER fires across multiple idle windows — each
+ *      touch resets the timer.
+ *
+ * The remaining tests pin the desktop / `SHOGO_LOCAL_MODE=true` opt-out:
+ * `idleMs: 0` (or any non-finite value) disables the reaper without
+ * ever arming a timer, so a long chat in local mode is not bounded by
+ * the cloud's 15-minute window even if a touch hook breaks somewhere.
+ */
+import { describe, expect, it } from 'bun:test';
+import { WorkerRuntimeManager } from '../runtime-manager.ts';
+
+interface FakeProc {
+  exitCode: number | null;
+  signalCode: NodeJS.Signals | null;
+  killed: boolean;
+  pid: number;
+  kill: (signal?: NodeJS.Signals | number) => boolean;
+  once: (event: string, cb: (...args: unknown[]) => void) => FakeProc;
+  on: (event: string, cb: (...args: unknown[]) => void) => FakeProc;
+}
+
+function makeFakeProc(): FakeProc {
+  const proc: FakeProc = {
+    // `waitForExit` short-circuits when `exitCode !== null`, so a
+    // synchronous "already exited" fake keeps stop() from blocking on
+    // an exit listener that never fires.
+    exitCode: 0,
+    signalCode: null,
+    killed: false,
+    pid: 99999,
+    kill(_signal?: NodeJS.Signals | number) {
+      proc.killed = true;
+      return true;
+    },
+    once(_event, _cb) {
+      return proc;
+    },
+    on(_event, _cb) {
+      return proc;
+    },
+  };
+  return proc;
+}
+
+function insertRunningSlot(mgr: WorkerRuntimeManager, projectId: string) {
+  const proc = makeFakeProc();
+  const slot = {
+    projectId,
+    // 0 short-circuits releasePort and avoids polluting usedPorts.
+    agentPort: 0,
+    apiServerPort: 0,
+    status: 'running' as const,
+    proc,
+    startedAt: Date.now(),
+    lastUsedAt: Date.now(),
+    restarts: 0,
+    restartTimer: null,
+    idleTimer: null,
+    spawnConfig: {} as never,
+    startPromise: null,
+  };
+  // The runtimes map and armIdleTimer are private; tests reach in
+  // deliberately because the public surface (ensureRunning) requires a
+  // real binary on disk.
+  (mgr as unknown as { runtimes: Map<string, typeof slot> }).runtimes.set(
+    projectId,
+    slot,
+  );
+  return slot;
+}
+
+function armIdle(mgr: WorkerRuntimeManager, slot: ReturnType<typeof insertRunningSlot>): void {
+  (mgr as unknown as { armIdleTimer: (s: typeof slot) => void }).armIdleTimer(slot);
+}
+
+const SILENT = { log: () => {}, warn: () => {}, error: () => {} } as const;
+
+describe('WorkerRuntimeManager idle eviction', () => {
+  it('reproduction: with no touches inside the idle window, the reaper kills the runtime (mid-stream cut)', async () => {
+    // 50ms idle window stands in for the production 15min — what we
+    // want to pin is "no `touch()` for >= idleMs ⇒ stop() fires", not
+    // the magnitude.
+    const mgr = new WorkerRuntimeManager({ idleMs: 50, logger: SILENT });
+    const slot = insertRunningSlot(mgr, 'proj-stream');
+
+    armIdle(mgr, slot);
+    expect(slot.idleTimer).not.toBeNull();
+
+    // Simulate an agent-proxy that forwards bytes for >idleMs but
+    // never calls `touch()` — exactly the production bug. The
+    // manager has no notion of in-flight HTTP, so it evicts.
+    await new Promise((r) => setTimeout(r, 120));
+
+    const runtimes = (mgr as unknown as { runtimes: Map<string, unknown> }).runtimes;
+    expect(runtimes.has('proj-stream')).toBe(false);
+    expect(slot.proc.killed).toBe(true);
+  });
+
+  it('fix: periodic touch() inside the idle window keeps the runtime alive across multiple windows', async () => {
+    const idleMs = 50;
+    const mgr = new WorkerRuntimeManager({ idleMs, logger: SILENT });
+    const slot = insertRunningSlot(mgr, 'proj-active');
+
+    armIdle(mgr, slot);
+
+    // Models the activity hooks the API server will install:
+    //   - agent-proxy `touch(projectId)` on each forwarded SSE chunk,
+    //   - AI proxy `touch(projectId)` after token decode.
+    // We tick every (idleMs / 5) for ~3x the idle window so the
+    // assertion lands well past where an unfixed reaper would fire.
+    const touchInterval = setInterval(() => mgr.touch('proj-active'), Math.max(5, idleMs / 5));
+    await new Promise((r) => setTimeout(r, idleMs * 3));
+    clearInterval(touchInterval);
+
+    const runtimes = (mgr as unknown as { runtimes: Map<string, unknown> }).runtimes;
+    expect(runtimes.has('proj-active')).toBe(true);
+    expect(slot.proc.killed).toBe(false);
+
+    // Sanity: once activity stops, the reaper does fire — the slot is
+    // not somehow "stuck alive". This pins the resume-eviction-on-idle
+    // half of the contract so a future regression that disables the
+    // reaper outright still gets caught.
+    await new Promise((r) => setTimeout(r, idleMs * 3));
+    expect(runtimes.has('proj-active')).toBe(false);
+    expect(slot.proc.killed).toBe(true);
+  });
+
+  it('touch() on an unknown projectId is a safe no-op', () => {
+    const mgr = new WorkerRuntimeManager({ idleMs: 50, logger: SILENT });
+    expect(() => mgr.touch('does-not-exist')).not.toThrow();
+  });
+
+  it('idleMs=0 disables the reaper (no timer is armed) — desktop opt-out', async () => {
+    const mgr = new WorkerRuntimeManager({ idleMs: 0, logger: SILENT });
+    const slot = insertRunningSlot(mgr, 'proj-local');
+
+    armIdle(mgr, slot);
+    expect(slot.idleTimer).toBeNull();
+
+    await new Promise((r) => setTimeout(r, 50));
+    const runtimes = (mgr as unknown as { runtimes: Map<string, unknown> }).runtimes;
+    expect(runtimes.has('proj-local')).toBe(true);
+    expect(slot.proc.killed).toBe(false);
+  });
+
+  it('idleMs=Infinity also disables the reaper', () => {
+    const mgr = new WorkerRuntimeManager({
+      idleMs: Number.POSITIVE_INFINITY,
+      logger: SILENT,
+    });
+    const slot = insertRunningSlot(mgr, 'proj-inf');
+
+    armIdle(mgr, slot);
+    expect(slot.idleTimer).toBeNull();
+  });
+
+  it('negative idleMs disables the reaper (defensive)', () => {
+    const mgr = new WorkerRuntimeManager({ idleMs: -1, logger: SILENT });
+    const slot = insertRunningSlot(mgr, 'proj-neg');
+
+    armIdle(mgr, slot);
+    expect(slot.idleTimer).toBeNull();
+  });
+
+  it('idleMs > 0 still arms a timer (cloud regression)', () => {
+    const mgr = new WorkerRuntimeManager({ idleMs: 1_000, logger: SILENT });
+    const slot = insertRunningSlot(mgr, 'proj-cloud');
+
+    armIdle(mgr, slot);
+    expect(slot.idleTimer).not.toBeNull();
+    if (slot.idleTimer) {
+      clearTimeout(slot.idleTimer);
+      slot.idleTimer = null;
+    }
+  });
+});