@shogo-ai/worker 1.0.10

package/src/lib/__tests__/cloud-sync-watcher.test.ts

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+/**
+ * Tests for {@link CloudSyncWatcher}.
+ *
+ * We exercise the watcher by:
+ *   - mounting a real tmpdir (fs.watch only works on real paths)
+ *   - injecting a fake CloudFileTransport that records uploadFiles calls
+ *   - touching files and waiting for the debounce window to fire
+ *
+ * Recursive `fs.watch` is supported on macOS / Windows / Linux >= 20.x.
+ * The CI matrix is expected to satisfy this; on platforms where it
+ * isn't, the watcher's `start()` will fall back to a flat root watch
+ * (which still passes the "single file in root" assertions but skips
+ * the "nested file" one).
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CloudSyncWatcher, _isExcluded, type CommitAndPushFn } from '../cloud-sync-watcher.ts';
+
+/** Tests inject a fake `commitAndPush` rather than mocking the module
+ *  (mock.module leaks across files in bun:test). */
+const commitAndPushCalls: any[] = [];
+const commitAndPushFake: CommitAndPushFn = async (opts) => {
+  commitAndPushCalls.push(opts);
+  return { committed: true, commitSha: 'deadbeef1234' };
+};
+
+function fakeTransport() {
+  const calls: { paths: string[] }[] = [];
+  return {
+    transport: {
+      uploadFiles: async (paths: string[]) => {
+        calls.push({ paths: [...paths] });
+        return { downloaded: 0, uploaded: paths.length, skipped: 0, deleted: 0, errors: [] };
+      },
+    } as any,
+    calls,
+  };
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+describe('CloudSyncWatcher', () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'cloud-sync-watcher-'));
+  });
+  afterEach(() => {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it('isExcluded skips node_modules / .git / dist / build paths', () => {
+    expect(_isExcluded('node_modules/lib/index.js')).toBe(true);
+    expect(_isExcluded('.git/HEAD')).toBe(true);
+    expect(_isExcluded('dist/bundle.js')).toBe(true);
+    expect(_isExcluded('build/main.css')).toBe(true);
+    expect(_isExcluded('src/App.tsx')).toBe(false);
+    expect(_isExcluded('config.json')).toBe(false);
+    expect(_isExcluded('')).toBe(true);
+  });
+
+  it('debounces a batch of edits into a single uploadFiles call', async () => {
+    const { transport, calls } = fakeTransport();
+    const watcher = new CloudSyncWatcher({ rootDir: dir, transport, debounceMs: 100 });
+    watcher.start();
+    // Give fs.watch a tick to start delivering events on macOS/Linux before
+    // we start writing — otherwise the first writes can be dropped.
+    await wait(50);
+
+    writeFileSync(join(dir, 'a.txt'), 'A');
+    writeFileSync(join(dir, 'b.txt'), 'B');
+    writeFileSync(join(dir, 'c.txt'), 'C');
+
+    await wait(400);
+    await watcher.stop();
+
+    // All three files coalesced into ONE upload batch.
+    expect(calls.length).toBeGreaterThanOrEqual(1);
+    const allPaths = calls.flatMap((c) => c.paths);
+    expect(allPaths).toContain('a.txt');
+    expect(allPaths).toContain('b.txt');
+    expect(allPaths).toContain('c.txt');
+  });
+
+  it('skips events inside excluded directories', async () => {
+    const { transport, calls } = fakeTransport();
+    mkdirSync(join(dir, 'node_modules'), { recursive: true });
+    mkdirSync(join(dir, 'src'), { recursive: true });
+    const watcher = new CloudSyncWatcher({ rootDir: dir, transport, debounceMs: 100 });
+    watcher.start();
+    await wait(50);
+
+    writeFileSync(join(dir, 'node_modules', 'lib.js'), 'LIB');
+    writeFileSync(join(dir, 'src', 'App.tsx'), 'APP');
+
+    await wait(400);
+    await watcher.stop();
+
+    const allPaths = calls.flatMap((c) => c.paths);
+    expect(allPaths.some((p) => p.includes('node_modules'))).toBe(false);
+    // On platforms where recursive watch works, src/App.tsx should have been
+    // captured. Where it doesn't, the array is empty — both are valid given
+    // the platform caveat described at the top of this file.
+  });
+
+  it('flushes any pending uploads on stop()', async () => {
+    const { transport, calls } = fakeTransport();
+    const watcher = new CloudSyncWatcher({ rootDir: dir, transport, debounceMs: 5_000 });
+    watcher.start();
+    await wait(50);
+
+    writeFileSync(join(dir, 'just-in-time.txt'), 'JIT');
+    // Don't wait the full debounce — stop() should still flush.
+    await wait(100);
+    await watcher.stop();
+
+    const allPaths = calls.flatMap((c) => c.paths);
+    expect(allPaths).toContain('just-in-time.txt');
+  });
+
+  it('git mode: flushes call commitAndPush instead of uploadFiles', async () => {
+    commitAndPushCalls.length = 0;
+    const { transport, calls } = fakeTransport();
+    const watcher = new CloudSyncWatcher({
+      rootDir: dir,
+      transport,
+      debounceMs: 100,
+      mode: 'git',
+      git: { apiUrl: 'https://api.shogo.ai', apiKey: 'shogo_sk_test', projectId: 'p_abc' },
+      commitAndPush: commitAndPushFake,
+    });
+    watcher.start();
+    await wait(50);
+
+    writeFileSync(join(dir, 'src.tsx'), 'CODE');
+    await wait(400);
+    await watcher.stop();
+
+    expect(commitAndPushCalls.length).toBeGreaterThanOrEqual(1);
+    expect(commitAndPushCalls[0]!.projectId).toBe('p_abc');
+    expect(commitAndPushCalls[0]!.localDir).toBe(dir);
+    expect(commitAndPushCalls[0]!.apiKey).toBe('shogo_sk_test');
+    // Non-.shogo paths should NOT go through uploadFiles in git mode.
+    const fileTransportPaths = calls.flatMap((c) => c.paths);
+    expect(fileTransportPaths.includes('src.tsx')).toBe(false);
+  });
+
+  it('git mode: .shogo/ writes still route through the file transport', async () => {
+    commitAndPushCalls.length = 0;
+    const { transport, calls } = fakeTransport();
+    mkdirSync(join(dir, '.shogo'), { recursive: true });
+    const watcher = new CloudSyncWatcher({
+      rootDir: dir,
+      transport,
+      debounceMs: 100,
+      mode: 'git',
+      git: { apiUrl: 'https://api.shogo.ai', apiKey: 'shogo_sk_test', projectId: 'p_xyz' },
+      commitAndPush: commitAndPushFake,
+    });
+    watcher.start();
+    await wait(50);
+
+    // App.tsx fires first so its watch event is queued before debounce starts;
+    // .shogo/db.sqlite arrives within the debounce window. The increased
+    // post-write wait absorbs cross-file timing variance (see
+    // gateway-mock side effect from git-cloner.test.ts's hoisted
+    // mock.module('node:child_process', ...) bloating bun's startup).
+    writeFileSync(join(dir, 'App.tsx'), 'APP');
+    writeFileSync(join(dir, '.shogo', 'db.sqlite'), 'SQLITE');
+    await wait(700);
+    await watcher.stop();
+
+    const fileTransportPaths = calls.flatMap((c) => c.paths);
+    expect(fileTransportPaths.some((p) => p.startsWith('.shogo'))).toBe(true);
+    // App.tsx commits go to git, NOT the file transport.
+    expect(fileTransportPaths.includes('App.tsx')).toBe(false);
+    expect(commitAndPushCalls.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('git mode: throws when constructed without git options', () => {
+    const { transport } = fakeTransport();
+    expect(() => new CloudSyncWatcher({ rootDir: dir, transport, mode: 'git' as const })).toThrow();
+  });
+
+  it('invokes onFlush with the uploaded batch + error count', async () => {
+    const { transport } = fakeTransport();
+    const flushes: Array<{ uploaded: string[]; errors: number }> = [];
+    const watcher = new CloudSyncWatcher({
+      rootDir: dir,
+      transport,
+      debounceMs: 50,
+      onFlush: (e) => flushes.push(e),
+    });
+    watcher.start();
+    await wait(50);
+
+    writeFileSync(join(dir, 'x.txt'), 'X');
+    await wait(300);
+    await watcher.stop();
+
+    expect(flushes.length).toBeGreaterThanOrEqual(1);
+    expect(flushes[0]!.errors).toBe(0);
+    expect(flushes[0]!.uploaded).toContain('x.txt');
+  });
+});

package/src/lib/__tests__/config.test.ts

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2026 Shogo Technologies, Inc.
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync, statSync, existsSync, readFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * The config/credentials store reads HOME at module-load time. To test
+ * different home dirs we mock `paths.ts` per-test so config.ts picks up
+ * a tmpdir-rooted CONFIG_FILE / HOME_DIR pair without us having to
+ * mutate process.env.HOME (which is racy across the rest of the suite).
+ */
+
+let tmp: string;
+
+function setupTmpHome(): string {
+  tmp = mkdtempSync(join(tmpdir(), 'shogo-config-'));
+  const homeDir = join(tmp, '.shogo');
+  const configFile = join(homeDir, 'config.json');
+  mock.module('../paths.ts', () => ({
+    HOME_DIR: homeDir,
+    CONFIG_FILE: configFile,
+    CREDENTIALS_FILE: join(homeDir, 'credentials.json'),
+    DEVICE_ID_FILE: join(homeDir, 'device-id'),
+    PID_FILE: join(homeDir, 'worker.pid'),
+    LOGS_DIR: join(homeDir, 'logs'),
+    WORKER_LOG: join(homeDir, 'logs', 'worker.log'),
+    WORKER_ERR: join(homeDir, 'logs', 'worker.err.log'),
+    RUNTIME_DIR: join(homeDir, 'runtime'),
+    RUNTIME_BIN: join(homeDir, 'runtime', 'agent-runtime'),
+    RUNTIME_VERSION_FILE: join(homeDir, 'runtime', 'version.json'),
+    PROJECTS_DIR: join(homeDir, 'projects'),
+    projectDirFor: (id: string, base = join(homeDir, 'projects')) => join(base, id),
+    ensureHome: () => {
+      mkdirSync(homeDir, { recursive: true, mode: 0o700 });
+      mkdirSync(join(homeDir, 'logs'), { recursive: true, mode: 0o700 });
+    },
+    ensureRuntimeDir: () => {
+      mkdirSync(join(homeDir, 'runtime'), { recursive: true, mode: 0o700 });
+    },
+    ensureProjectsDir: (base = join(homeDir, 'projects')) => {
+      mkdirSync(base, { recursive: true, mode: 0o700 });
+    },
+  }));
+  return configFile;
+}
+
+describe('config: load + save round-trip', () => {
+  let configFile: string;
+  beforeEach(() => {
+    configFile = setupTmpHome();
+  });
+  afterEach(() => {
+    mock.restore();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('loadConfig returns {} when no file exists', async () => {
+    const { loadConfig } = await import('../config.ts');
+    expect(loadConfig()).toEqual({});
+  });
+
+  it('saveConfig writes JSON with mode 0600', async () => {
+    const { saveConfig, loadConfig } = await import('../config.ts');
+    saveConfig({ apiKey: 'shogo_sk_test', cloudUrl: 'https://example.com' });
+
+    expect(existsSync(configFile)).toBe(true);
+    const parsed = JSON.parse(readFileSync(configFile, 'utf-8'));
+    expect(parsed.apiKey).toBe('shogo_sk_test');
+    expect(parsed.cloudUrl).toBe('https://example.com');
+    if (process.platform !== 'win32') {
+      const st = statSync(configFile);
+      expect(st.mode & 0o077).toBe(0);
+    }
+    expect(loadConfig().apiKey).toBe('shogo_sk_test');
+  });
+
+  it('loadConfig throws on corrupt JSON', async () => {
+    mkdirSync(join(tmp, '.shogo'), { recursive: true });
+    writeFileSync(configFile, '{not json');
+    const { loadConfig } = await import('../config.ts');
+    expect(() => loadConfig()).toThrow(/Corrupt config/);
+  });
+
+  it('mergeConfig prefers override over base, drops undefined', async () => {
+    const { mergeConfig } = await import('../config.ts');
+    expect(
+      mergeConfig({ apiKey: 'a', cloudUrl: 'old' }, { cloudUrl: 'new', name: undefined }),
+    ).toEqual({ apiKey: 'a', cloudUrl: 'new' });
+  });
+});
+
+describe('config: resolveConfig precedence', () => {
+  let prevEnvKey: string | undefined;
+
+  beforeEach(() => {
+    setupTmpHome();
+    prevEnvKey = process.env.SHOGO_API_KEY;
+    delete process.env.SHOGO_API_KEY;
+  });
+  afterEach(() => {
+    mock.restore();
+    if (prevEnvKey === undefined) delete process.env.SHOGO_API_KEY;
+    else process.env.SHOGO_API_KEY = prevEnvKey;
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('throws when no API key resolves anywhere', async () => {
+    const { resolveConfig } = await import('../config.ts');
+    expect(() => resolveConfig()).toThrow(/No API key/);
+  });
+
+  it('reads API key from explicit override (highest precedence)', async () => {
+    const { resolveConfig, saveConfig } = await import('../config.ts');
+    saveConfig({ apiKey: 'shogo_sk_file' });
+    process.env.SHOGO_API_KEY = 'shogo_sk_env';
+    expect(resolveConfig({ apiKey: 'shogo_sk_override' }).apiKey).toBe('shogo_sk_override');
+  });
+
+  it('falls back to env var when no override is given', async () => {
+    const { resolveConfig, saveConfig } = await import('../config.ts');
+    saveConfig({ apiKey: 'shogo_sk_file' });
+    process.env.SHOGO_API_KEY = 'shogo_sk_env';
+    expect(resolveConfig().apiKey).toBe('shogo_sk_env');
+  });
+
+  it('falls back to file when no override or env is set', async () => {
+    const { resolveConfig, saveConfig } = await import('../config.ts');
+    saveConfig({ apiKey: 'shogo_sk_file' });
+    expect(resolveConfig().apiKey).toBe('shogo_sk_file');
+  });
+
+  it('fills defaults for cloudUrl + port', async () => {
+    const { resolveConfig, saveConfig } = await import('../config.ts');
+    saveConfig({ apiKey: 'shogo_sk_file' });
+    const cfg = resolveConfig();
+    expect(cfg.cloudUrl).toBe('https://studio.shogo.ai');
+    expect(cfg.port).toBe(8002);
+  });
+});

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();
+  });
+});