@shogo-ai/worker 1.0.10

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__/cloud-login-coverage.test.ts

@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * Coverage gaps for cloud-login.ts.
+ *
+ * Targets:
+ *   L201-205  sigHandler body (SIGINT/SIGTERM aborts the poll loop)
+ *   L239-244  poll fetch network error → .catch swallows and retries
+ *   L287-289  sleep() onAbort handler (signal fires DURING sleep)
+ *   L323-337  openInBrowser (default openBrowser path)
+ */
+import { describe, it, expect } from 'bun:test';
+import { runCloudLogin, CloudLoginError } from '../cloud-login.ts';
+
+function jsonResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+const startBody = {
+  ok: true,
+  state: 'state-abc',
+  userCode: 'XXXXXX',
+  authUrl: 'https://cloud.example.com/auth/cli-link?state=state-abc',
+  expiresInMs: 60_000,
+  pollIntervalMs: 1,
+};
+
+describe('runCloudLogin — sigHandler (L201-205)', () => {
+  it('SIGINT during the poll loop unwinds via cancelled CloudLoginError', async () => {
+    // Issue SIGINT after start; the sigHandler should abort the local controller.
+    let pollCount = 0;
+    const fetchImpl = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+      if (url.endsWith('/api/cli/login/start')) {
+        return jsonResponse(startBody);
+      }
+      pollCount += 1;
+      if (pollCount === 1) {
+        // Fire SIGINT in the next microtask while the loop is about to sleep
+        setImmediate(() => process.emit('SIGINT' as any));
+        return jsonResponse({ ok: true, status: 'pending' });
+      }
+      return jsonResponse({ ok: true, status: 'pending' });
+    }) as unknown as typeof fetch;
+
+    try {
+      await runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'dev-abc',
+        openBrowser: false,
+        pollIntervalMs: 100,
+        installSignalHandlers: true,
+        log: () => {},
+        fetchImpl,
+      });
+      throw new Error('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(CloudLoginError);
+      expect((err as CloudLoginError).kind).toBe('cancelled');
+    }
+  });
+});
+
+describe('runCloudLogin — poll network error .catch (L239-244)', () => {
+  it('soft network error during poll is logged and the loop retries until approved', async () => {
+    let pollCount = 0;
+    const logs: string[] = [];
+    const fetchImpl = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+      if (url.endsWith('/api/cli/login/start')) {
+        return jsonResponse(startBody);
+      }
+      pollCount += 1;
+      if (pollCount === 1) {
+        throw new Error('ECONNRESET on first poll');
+      }
+      return jsonResponse({
+        ok: true, status: 'approved', key: 'shogo_sk_recovered',
+        email: 'u@e.com', workspace: 'w', deviceId: 'd',
+      });
+    }) as unknown as typeof fetch;
+
+    const result = await runCloudLogin({
+      cloudUrl: 'https://cloud.example.com',
+      deviceId: 'd',
+      openBrowser: false,
+      pollIntervalMs: 1,
+      installSignalHandlers: false,
+      log: (s) => logs.push(s),
+      fetchImpl,
+    });
+    expect(result.key).toBe('shogo_sk_recovered');
+    expect(logs.some((l) => l.includes('poll error'))).toBe(true);
+  });
+});
+
+describe('runCloudLogin — sleep onAbort (L287-289)', () => {
+  it('abort signal fires DURING the inter-poll sleep → cancelled CloudLoginError', async () => {
+    // Use a long pollIntervalMs so sleep is in flight when we abort.
+    const ac = new AbortController();
+    let pollCount = 0;
+    const fetchImpl = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+      if (url.endsWith('/api/cli/login/start')) {
+        return jsonResponse({ ...startBody, pollIntervalMs: 5000 });
+      }
+      pollCount += 1;
+      if (pollCount === 1) {
+        // After this poll, sleep(5000) begins. Schedule abort 20ms later.
+        setTimeout(() => ac.abort(), 20);
+        return jsonResponse({ ok: true, status: 'pending' });
+      }
+      return jsonResponse({ ok: true, status: 'pending' });
+    }) as unknown as typeof fetch;
+
+    try {
+      await runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'd',
+        openBrowser: false,
+        pollIntervalMs: 5000, // long sleep
+        installSignalHandlers: false,
+        log: () => {},
+        fetchImpl,
+        abortSignal: ac.signal,
+      });
+      throw new Error('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(CloudLoginError);
+      expect((err as CloudLoginError).kind).toBe('cancelled');
+    }
+  });
+});
+
+describe('runCloudLogin — openInBrowser default path (L323-337)', () => {
+  it('with openBrowser undefined: invokes openInBrowser (default path) without breaking the flow', async () => {
+    // Default openBrowser triggers spawn('xdg-open' | 'open' | 'cmd'). On a
+    // sandbox the spawn may fail or succeed; in BOTH cases the .catch on the
+    // call site swallows it. We're after coverage of L323-334 / L335-337.
+    let pollCount = 0;
+    const fetchImpl = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+      if (url.endsWith('/api/cli/login/start')) {
+        return jsonResponse(startBody);
+      }
+      pollCount += 1;
+      return jsonResponse({
+        ok: true, status: 'approved', key: 'shogo_sk_via_browser',
+        email: 'u@e.com', workspace: 'w', deviceId: 'd',
+      });
+    }) as unknown as typeof fetch;
+
+    const result = await runCloudLogin({
+      cloudUrl: 'https://cloud.example.com',
+      deviceId: 'd',
+      // openBrowser omitted → defaults to true → openInBrowser runs
+      pollIntervalMs: 1,
+      installSignalHandlers: false,
+      log: () => {},
+      fetchImpl,
+    });
+    expect(result.key).toBe('shogo_sk_via_browser');
+  });
+
+  it('openInBrowser swallows synchronous spawn errors via the outer try/catch (L335-337)', async () => {
+    // Force spawn to throw synchronously by temporarily replacing it via
+    // process.binding-style override. The cleanest cross-runtime way: monkey-
+    // patch the resolved module's spawn. cloud-login imports `spawn` at the
+    // top, so we can't change it post-import. Instead, indirectly: pass a
+    // platform that resolves to a binary that almost certainly does NOT exist
+    // — and rely on the catch branch firing if spawn throws.
+    //
+    // In practice on the sandbox `spawn('xdg-open', ...)` resolves to ENOENT
+    // asynchronously via child.on('error'), not synchronously, so this test
+    // mainly documents the contract: a synchronous spawn failure is silently
+    // swallowed and the flow still completes.
+    let pollCount = 0;
+    const fetchImpl = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+      if (url.endsWith('/api/cli/login/start')) {
+        return jsonResponse(startBody);
+      }
+      pollCount += 1;
+      return jsonResponse({
+        ok: true, status: 'approved', key: 'shogo_sk_browser_failed',
+        email: 'u@e.com', workspace: 'w', deviceId: 'd',
+      });
+    }) as unknown as typeof fetch;
+
+    // Custom openBrowser function that throws — runCloudLogin .catch()es it.
+    // This exercises L189-192 (custom openBrowser branch). For the actual
+    // spawn-throws branch in openInBrowser we'd need module mocking, which
+    // would conflict with the git-cloner.test.ts spawn mock running in the
+    // same Bun process. The default-openBrowser test above already exercises
+    // openInBrowser's spawn path with whatever the sandbox provides.
+    const result = await runCloudLogin({
+      cloudUrl: 'https://cloud.example.com',
+      deviceId: 'd',
+      openBrowser: () => { throw new Error('user opener boom'); },
+      pollIntervalMs: 1,
+      installSignalHandlers: false,
+      log: () => {},
+      fetchImpl,
+    });
+    expect(result.key).toBe('shogo_sk_browser_failed');
+  });
+});

package/src/lib/__tests__/cloud-login.test.ts

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+import { describe, it, expect } from 'bun:test';
+import { runCloudLogin, CloudLoginError } from '../cloud-login.ts';
+
+/**
+ * Drive `runCloudLogin` against a scripted fetch implementation so we
+ * can exercise the start → poll → approved happy path plus all four
+ * documented terminal states (denied / expired / state-mismatch via
+ * malformed responses / network error).
+ *
+ * The CLI client should:
+ *   - never auto-open a browser when openBrowser:false
+ *   - poll until status='approved' or terminal state
+ *   - return the key + email + workspace from the approved poll exactly
+ *     once and not call any further endpoints
+ *   - throw CloudLoginError with the right `kind` for each failure mode
+ */
+
+function scripted(handlers: Array<(url: string) => Response | Promise<Response>>) {
+  let i = 0;
+  const fetchImpl = async (input: RequestInfo | URL, _init?: RequestInit) => {
+    const url = typeof input === 'string' ? input : input.toString();
+    if (i >= handlers.length) {
+      throw new Error(`scripted fetch ran out of handlers at request #${i + 1} (${url})`);
+    }
+    return handlers[i++](url);
+  };
+  return { fetchImpl: fetchImpl as unknown as typeof fetch, calls: () => i };
+}
+
+function jsonResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+describe('runCloudLogin', () => {
+  it('returns the minted key on the second poll (start → pending → approved)', async () => {
+    const { fetchImpl } = scripted([
+      (url) => {
+        expect(url).toEndWith('/api/cli/login/start');
+        return jsonResponse({
+          ok: true,
+          state: 'abcdef0123456789',
+          userCode: '456789',
+          authUrl: 'https://cloud.example.com/auth/cli-link?state=abcdef0123456789',
+          expiresInMs: 60_000,
+          pollIntervalMs: 1_000,
+        });
+      },
+      (url) => {
+        expect(url).toContain('/api/cli/login/poll?state=abcdef0123456789');
+        return jsonResponse({ ok: true, status: 'pending' });
+      },
+      (url) => {
+        expect(url).toContain('/api/cli/login/poll?state=abcdef0123456789');
+        return jsonResponse({
+          ok: true,
+          status: 'approved',
+          key: 'shogo_sk_test_key_123',
+          email: 'user@example.com',
+          workspace: 'My Workspace',
+          deviceId: 'dev-abc',
+        });
+      },
+    ]);
+
+    const result = await runCloudLogin({
+      cloudUrl: 'https://cloud.example.com',
+      deviceId: 'dev-abc',
+      openBrowser: false,
+      pollIntervalMs: 1, // tighten so the test runs fast
+      log: () => { /* silence */ },
+      fetchImpl,
+    });
+
+    expect(result.key).toBe('shogo_sk_test_key_123');
+    expect(result.email).toBe('user@example.com');
+    expect(result.workspace).toBe('My Workspace');
+    expect(result.deviceId).toBe('dev-abc');
+  });
+
+  it('throws CloudLoginError(kind="denied") when the user clicks Cancel', async () => {
+    const { fetchImpl } = scripted([
+      () =>
+        jsonResponse({
+          ok: true,
+          state: 's',
+          userCode: 'XXXXXX',
+          authUrl: 'https://cloud.example.com/auth/cli-link?state=s',
+          expiresInMs: 60_000,
+          pollIntervalMs: 1,
+        }),
+      () => jsonResponse({ ok: true, status: 'denied' }),
+    ]);
+
+    await expect(
+      runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'dev-abc',
+        openBrowser: false,
+        pollIntervalMs: 1,
+        log: () => { /* silence */ },
+        fetchImpl,
+      }),
+    ).rejects.toBeInstanceOf(CloudLoginError);
+  });
+
+  it('throws CloudLoginError(kind="expired") when the cloud says expired', async () => {
+    const { fetchImpl } = scripted([
+      () =>
+        jsonResponse({
+          ok: true,
+          state: 's',
+          userCode: 'XXXXXX',
+          authUrl: 'https://cloud.example.com/auth/cli-link?state=s',
+          expiresInMs: 60_000,
+          pollIntervalMs: 1,
+        }),
+      () => jsonResponse({ ok: true, status: 'expired' }),
+    ]);
+
+    try {
+      await runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'dev-abc',
+        openBrowser: false,
+        pollIntervalMs: 1,
+        log: () => { /* silence */ },
+        fetchImpl,
+      });
+      throw new Error('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(CloudLoginError);
+      expect((err as CloudLoginError).kind).toBe('expired');
+    }
+  });
+
+  it('respects abortSignal and throws cancelled', async () => {
+    const ac = new AbortController();
+    const { fetchImpl } = scripted([
+      () =>
+        jsonResponse({
+          ok: true,
+          state: 's',
+          userCode: 'XXXXXX',
+          authUrl: 'https://cloud.example.com/auth/cli-link?state=s',
+          expiresInMs: 60_000,
+          pollIntervalMs: 50,
+        }),
+      () => {
+        // Abort right before the next sleep so the wait raises cancelled.
+        ac.abort();
+        return jsonResponse({ ok: true, status: 'pending' });
+      },
+    ]);
+
+    try {
+      await runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'dev-abc',
+        openBrowser: false,
+        pollIntervalMs: 50,
+        log: () => { /* silence */ },
+        fetchImpl,
+        abortSignal: ac.signal,
+      });
+      throw new Error('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(CloudLoginError);
+      expect((err as CloudLoginError).kind).toBe('cancelled');
+    }
+  });
+
+  it('throws transport when start endpoint is unreachable', async () => {
+    const fetchImpl = (async () => {
+      throw new Error('ECONNREFUSED');
+    }) as unknown as typeof fetch;
+
+    try {
+      await runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'dev-abc',
+        openBrowser: false,
+        pollIntervalMs: 1,
+        log: () => { /* silence */ },
+        fetchImpl,
+      });
+      throw new Error('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(CloudLoginError);
+      expect((err as CloudLoginError).kind).toBe('transport');
+    }
+  });
+
+  it('throws transport when start returns malformed body', async () => {
+    const { fetchImpl } = scripted([
+      () => jsonResponse({ ok: false, error: 'bad request' }, 400),
+    ]);
+
+    try {
+      await runCloudLogin({
+        cloudUrl: 'https://cloud.example.com',
+        deviceId: 'dev-abc',
+        openBrowser: false,
+        pollIntervalMs: 1,
+        log: () => { /* silence */ },
+        fetchImpl,
+      });
+      throw new Error('should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(CloudLoginError);
+      expect((err as CloudLoginError).kind).toBe('transport');
+    }
+  });
+});