@shogo-ai/worker 1.8.10 → 1.8.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shogo-ai/worker",
-  "version": "1.8.10",
+  "version": "1.8.12",
   "description": "Shogo Cloud Agent Worker — run Shogo agents on your own machine (laptop, devbox, CI).",
   "license": "MIT",
   "author": "Shogo Technologies, Inc.",

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__/git-cloner.test.ts

@@ -22,12 +22,14 @@ interface SpawnInvocation {
 }
 
 const spawnInvocations: SpawnInvocation[] = [];
-type SpawnHandler = (
-  inv: SpawnInvocation,
-) => { stdout?: string; stderr?: string; exitCode?: number; runError?: Error };
+type SpawnResult = { stdout?: string; stderr?: string; exitCode?: number; runError?: Error; hang?: boolean };
+type SpawnHandler = (inv: SpawnInvocation) => SpawnResult;
 let spawnHandler: SpawnHandler = () => ({ exitCode: 0 });
 
-function makeFakeChild(result: { stdout?: string; stderr?: string; exitCode?: number; runError?: Error }) {
+let execFileHandler: (cmd: string, args: string[]) => { error?: Error; stdout?: string } =
+  () => ({ stdout: 'git version 2.40.0' });
+
+function makeFakeChild(result: SpawnResult) {
   const child = new EventEmitter() as any;
   child.stdout = new EventEmitter();
   child.stdout.setEncoding = () => {};
@@ -38,6 +40,7 @@ function makeFakeChild(result: { stdout?: string; stderr?: string; exitCode?: nu
   child.signalCode = null;
   // Emit chunks + close asynchronously so callers' on() handlers register first.
   setTimeout(() => {
+    if (result.hang) return; // never emit close — used for timeout tests
     if (result.runError) {
       child.emit('error', result.runError);
       return;
@@ -60,9 +63,12 @@ mock.module('node:child_process', () => ({
   execFile: (cmd: string, args: string[], opts: any, cb: any) => {
     const inv: SpawnInvocation = { cmd, args };
     spawnInvocations.push(inv);
-    // probe for `git --version`
     const callback = typeof opts === 'function' ? opts : cb;
-    setTimeout(() => callback?.(null, 'git version 2.40.0', ''), 1);
+    const r = execFileHandler(cmd, args);
+    setTimeout(() => {
+      if (r.error) callback?.(r.error, '', '');
+      else callback?.(null, r.stdout ?? '', '');
+    }, 1);
   },
 }));
 
@@ -72,6 +78,7 @@ const { buildGitUrl, cloneProject, commitAndPush, gitIsAvailable, isGitRepo, git
 beforeEach(() => {
   spawnInvocations.length = 0;
   spawnHandler = () => ({ exitCode: 0 });
+  execFileHandler = () => ({ stdout: 'git version 2.40.0' });
 });
 
 describe('buildGitUrl', () => {
@@ -256,3 +263,120 @@ describe('isGitRepo', () => {
     }
   });
 });
+
+// ─── Additional coverage tests ──────────────────────────────────────────────
+
+describe('gitIsAvailable (failure path)', () => {
+  it('returns false when git --version fails (L46)', async () => {
+    execFileHandler = () => ({ error: new Error('git not found in PATH') });
+    const ok = await gitIsAvailable(true); // force=true bypasses cache
+    expect(ok).toBe(false);
+    // Restore the cache to true for subsequent tests (idempotent re-probe)
+    execFileHandler = () => ({ stdout: 'git version 2.40.0' });
+    await gitIsAvailable(true);
+  });
+});
+
+describe('runGit (timeout + error paths)', () => {
+  it('rejects when the timer fires before the child closes (L127-128)', async () => {
+    const { runGit } = await import('../git-cloner.ts');
+    spawnHandler = () => ({ hang: true });
+    await expect(
+      runGit(['fetch'], { timeoutMs: 30 }),
+    ).rejects.toThrow(/timed out after 30ms/);
+  });
+
+  it('rejects when the child emits an error event (L132-133)', async () => {
+    const { runGit } = await import('../git-cloner.ts');
+    spawnHandler = () => ({ runError: new Error('spawn ENOENT') });
+    await expect(
+      runGit(['status'], { timeoutMs: 5000 }),
+    ).rejects.toThrow(/spawn ENOENT/);
+  });
+});
+
+describe('gitFetchUnshallow', () => {
+  it('runs git fetch --unshallow when .git/shallow exists (L270-276)', async () => {
+    const { gitFetchUnshallow } = await import('../git-cloner.ts');
+    const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+    const { tmpdir } = await import('node:os');
+    const { join } = await import('node:path');
+    const dir = mkdtempSync(join(tmpdir(), 'unshallow-'));
+    try {
+      mkdirSync(join(dir, '.git'));
+      writeFileSync(join(dir, '.git', 'shallow'), 'deadbeef\n');
+      await gitFetchUnshallow({
+        apiUrl: 'https://api.shogo.ai',
+        apiKey: 'shogo_sk_test',
+        projectId: 'p_demo',
+        localDir: dir,
+      });
+      const fetchInv = spawnInvocations.find((i) => i.args.includes('--unshallow'));
+      expect(fetchInv).toBeDefined();
+      expect(fetchInv!.args.some((a) => a.startsWith('http.extraHeader='))).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('no-ops when .git/shallow is missing (repo already complete)', async () => {
+    const { gitFetchUnshallow } = await import('../git-cloner.ts');
+    const { mkdtempSync, mkdirSync, rmSync } = await import('node:fs');
+    const { tmpdir } = await import('node:os');
+    const { join } = await import('node:path');
+    const dir = mkdtempSync(join(tmpdir(), 'unshallow-'));
+    try {
+      mkdirSync(join(dir, '.git'));
+      await gitFetchUnshallow({
+        apiUrl: 'https://api.shogo.ai',
+        apiKey: 'shogo_sk_test',
+        projectId: 'p_demo',
+        localDir: dir,
+      });
+      expect(spawnInvocations.length).toBe(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('commitAndPush (author env vars)', () => {
+  it('sets GIT_AUTHOR_EMAIL + GIT_COMMITTER_EMAIL when authorEmail is provided (L315-316)', async () => {
+    spawnHandler = (inv) => {
+      if (inv.args[0] === 'diff') return { exitCode: 1 };
+      if (inv.args[0] === 'rev-parse') return { stdout: 'shaaaaaa\n' };
+      return { exitCode: 0 };
+    };
+    await commitAndPush({
+      apiUrl: 'https://api.shogo.ai',
+      apiKey: 'k',
+      projectId: 'p',
+      localDir: '/tmp/never',
+      message: 'feat: x',
+      authorEmail: 'dev@shogo.ai',
+    });
+    const addInv = spawnInvocations.find((i) => i.args[0] === 'add')!;
+    expect(addInv.env?.GIT_AUTHOR_EMAIL).toBe('dev@shogo.ai');
+    expect(addInv.env?.GIT_COMMITTER_EMAIL).toBe('dev@shogo.ai');
+  });
+
+  it('sets GIT_AUTHOR_NAME + GIT_COMMITTER_NAME when authorName is provided (L319-320)', async () => {
+    spawnHandler = (inv) => {
+      if (inv.args[0] === 'diff') return { exitCode: 1 };
+      if (inv.args[0] === 'rev-parse') return { stdout: 'shaaaaaa\n' };
+      return { exitCode: 0 };
+    };
+    await commitAndPush({
+      apiUrl: 'https://api.shogo.ai',
+      apiKey: 'k',
+      projectId: 'p',
+      localDir: '/tmp/never',
+      message: 'feat: x',
+      authorName: 'Shogo Bot',
+    });
+    const addInv = spawnInvocations.find((i) => i.args[0] === 'add')!;
+    expect(addInv.env?.GIT_AUTHOR_NAME).toBe('Shogo Bot');
+    expect(addInv.env?.GIT_COMMITTER_NAME).toBe('Shogo Bot');
+  });
+});
+