@mycadet/assistant 0.12.10 → 0.13.0

package/src/background-wake/wake-intent-hooks.test.ts

@@ -1,234 +0,0 @@
-import { readFileSync } from "node:fs";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { BackgroundWakeIntentClientResult } from "./cloud-client.js";
-import type { BackgroundWakeIntent } from "./next-wake.js";
-
-const mockPublishBackgroundWakeIntent = mock(
-  async (): Promise<BackgroundWakeIntentClientResult> => ({
-    status: "published",
-  }),
-);
-const mockClearBackgroundWakeIntent = mock(
-  async (): Promise<BackgroundWakeIntentClientResult> => ({
-    status: "cleared",
-  }),
-);
-let computedIntent: BackgroundWakeIntent | null = intentFixture();
-
-mock.module("./next-wake.js", () => ({
-  computeNextBackgroundWakeIntent: () => computedIntent,
-}));
-
-mock.module("./cloud-client.js", () => ({
-  publishBackgroundWakeIntent: mockPublishBackgroundWakeIntent,
-  clearBackgroundWakeIntent: mockClearBackgroundWakeIntent,
-}));
-
-// Replace `publishSchedulesChanged` while keeping the rest of the module REAL
-// — a partial mock that drops the other exports breaks any transitively loaded
-// module that imports them (the conversation write paths reach this module
-// through the hook pipeline).
-const actualSyncEvents =
-  await import("../runtime/sync/resource-sync-events.js");
-mock.module("../runtime/sync/resource-sync-events.js", () => ({
-  ...actualSyncEvents,
-  publishSchedulesChanged: () => {},
-}));
-
-const {
-  flushBackgroundWakeIntentRefreshForTest,
-  refreshBackgroundWakeIntent,
-  resetBackgroundWakeIntentPublisherForTest,
-} = await import("./publisher.js");
-const { initializeDb } = await import("../persistence/db-init.js");
-const { getDb } = await import("../persistence/db-connection.js");
-const { createSchedule, deleteSchedule, updateSchedule } =
-  await import("../schedule/schedule-store.js");
-
-await initializeDb();
-
-describe("background wake intent publisher hooks", () => {
-  beforeEach(() => {
-    computedIntent = intentFixture();
-    mockPublishBackgroundWakeIntent.mockClear();
-    mockClearBackgroundWakeIntent.mockClear();
-    mockPublishBackgroundWakeIntent.mockImplementation(async () => ({
-      status: "published" as const,
-    }));
-    mockClearBackgroundWakeIntent.mockImplementation(async () => ({
-      status: "cleared" as const,
-    }));
-    resetBackgroundWakeIntentPublisherForTest();
-    const db = getDb();
-    db.run("DELETE FROM cron_runs");
-    db.run("DELETE FROM cron_jobs");
-  });
-
-  test("debounces repeated refreshes into one publish", async () => {
-    refreshBackgroundWakeIntent("first");
-    refreshBackgroundWakeIntent("second");
-    refreshBackgroundWakeIntent("third");
-
-    await flushBackgroundWakeIntentRefreshForTest();
-
-    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(1);
-    expect(mockClearBackgroundWakeIntent).not.toHaveBeenCalled();
-  });
-
-  test("clears without throwing when no local intent exists", async () => {
-    computedIntent = null;
-
-    refreshBackgroundWakeIntent("no-intent");
-    await flushBackgroundWakeIntentRefreshForTest();
-
-    expect(mockClearBackgroundWakeIntent).toHaveBeenCalledTimes(1);
-    expect(mockClearBackgroundWakeIntent).toHaveBeenCalledWith(null);
-  });
-
-  test("keeps last intent snapshot when clear is skipped so it can retry", async () => {
-    const publishedIntent = intentFixture({
-      computedAt: 1_800_000_000_000,
-      sourceGeneration: "bw1:stable-source",
-    });
-    computedIntent = publishedIntent;
-
-    refreshBackgroundWakeIntent("publish");
-    await flushBackgroundWakeIntentRefreshForTest();
-
-    computedIntent = null;
-    mockClearBackgroundWakeIntent.mockImplementationOnce(async () => ({
-      status: "skipped" as const,
-      reason: "missing_platform_client" as const,
-    }));
-
-    refreshBackgroundWakeIntent("clear-skipped");
-    await flushBackgroundWakeIntentRefreshForTest();
-    refreshBackgroundWakeIntent("clear-retry");
-    await flushBackgroundWakeIntentRefreshForTest();
-
-    expect(mockClearBackgroundWakeIntent).toHaveBeenCalledTimes(2);
-    expect(mockClearBackgroundWakeIntent).toHaveBeenNthCalledWith(
-      1,
-      publishedIntent,
-    );
-    expect(mockClearBackgroundWakeIntent).toHaveBeenNthCalledWith(
-      2,
-      publishedIntent,
-    );
-  });
-
-  test("does not throw into callers when platform publish fails", async () => {
-    mockPublishBackgroundWakeIntent.mockImplementation(async () => {
-      throw new Error("network down");
-    });
-
-    refreshBackgroundWakeIntent("publish-failure");
-    await expect(
-      flushBackgroundWakeIntentRefreshForTest(),
-    ).resolves.toBeUndefined();
-
-    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(1);
-  });
-
-  test("schedule create, update, and delete mutations refresh the wake intent", async () => {
-    const job = await createSchedule({
-      name: "Wake hook",
-      cronExpression: "* * * * *",
-      message: "wake",
-      syntax: "cron",
-    });
-    await flushQueuedWakeRefresh();
-    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(1);
-
-    await updateSchedule(job.id, { name: "Wake hook updated" });
-    await flushQueuedWakeRefresh();
-    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(2);
-
-    expect(await deleteSchedule(job.id)).toBe(true);
-    await flushQueuedWakeRefresh();
-    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(3);
-  });
-
-  test("heartbeat scheduling and run-completion paths queue wake intent refreshes", () => {
-    const heartbeatSource = readFileSync(
-      new URL("../heartbeat/heartbeat-service.ts", import.meta.url),
-      "utf-8",
-    );
-
-    expect(heartbeatSource).toContain(
-      'refreshBackgroundWakeIntentSoon("heartbeat-disabled")',
-    );
-    expect(heartbeatSource).toContain(
-      'refreshBackgroundWakeIntentSoon("heartbeat-cron-scheduled")',
-    );
-    expect(heartbeatSource).toContain(
-      'refreshBackgroundWakeIntentSoon("heartbeat-interval-scheduled")',
-    );
-    expect(heartbeatSource).toContain(
-      'refreshBackgroundWakeIntentSoon("heartbeat-reconfigured")',
-    );
-    expect(heartbeatSource).toContain(
-      'refreshBackgroundWakeIntentSoon("heartbeat-run-complete")',
-    );
-  });
-
-  test("scheduler startup publishes the daemon-startup wake intent", () => {
-    const schedulerSource = readFileSync(
-      new URL("../schedule/scheduler.ts", import.meta.url),
-      "utf-8",
-    );
-    const lifecycleSource = readFileSync(
-      new URL("../daemon/lifecycle.ts", import.meta.url),
-      "utf-8",
-    );
-
-    // The daemon-startup intent is published from the end of startScheduler(),
-    // so it lands once the scheduler is live and its schedules are visible to
-    // computeNextBackgroundWakeIntent. Heartbeat startup republishes with the
-    // live heartbeat timing via its own "heartbeat-*" refreshes.
-    expect(schedulerSource).toContain(
-      'refreshBackgroundWakeIntent("daemon-startup")',
-    );
-    // Lifecycle no longer publishes the intent directly.
-    expect(lifecycleSource).not.toContain("refreshBackgroundWakeIntent");
-  });
-
-  test("shutdown paths do not clear background wake intents", () => {
-    const lifecycleSource = readFileSync(
-      new URL("../daemon/lifecycle.ts", import.meta.url),
-      "utf-8",
-    );
-    const shutdownSource = readFileSync(
-      new URL("../daemon/shutdown-handlers.ts", import.meta.url),
-      "utf-8",
-    );
-
-    expect(lifecycleSource).not.toContain("clearBackgroundWakeIntent");
-    expect(shutdownSource).not.toContain("clearBackgroundWakeIntent");
-    expect(shutdownSource).not.toContain("background-wake/cloud-client");
-  });
-});
-
-async function flushQueuedWakeRefresh(): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  await flushBackgroundWakeIntentRefreshForTest();
-}
-
-function intentFixture(
-  overrides: Partial<BackgroundWakeIntent> = {},
-): BackgroundWakeIntent {
-  const nextWakeAt = 1_800_000_060_000;
-  return {
-    nextWakeAt,
-    actualNextDueAt: nextWakeAt,
-    reason: "schedule",
-    sourceGeneration: "bw1:source",
-    computedAt: nextWakeAt - 60_000,
-    sourcePayload: {
-      heartbeat: null,
-      schedules: [],
-    },
-    ...overrides,
-  };
-}

package/src/cli/commands/__tests__/backup.test.ts

@@ -1,363 +0,0 @@
-/**
- * Tests for the `assistant backup` CLI command tree.
- *
- * Uses the IPC mock pattern: cliIpcCall is stubbed out so tests assert the
- * correct method + params are sent without touching the daemon or filesystem.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { Command } from "commander";
-
-// ---------------------------------------------------------------------------
-// Mock state
-// ---------------------------------------------------------------------------
-
-/** The last `cliIpcCall` invocation captured for assertions. */
-let lastIpcCall: { method: string; params?: any } | null = null;
-
-/** The result that cliIpcCall will return. */
-let mockIpcResult: { ok: boolean; result?: unknown; error?: string } = {
-  ok: true,
-  result: {},
-};
-
-/** Captured log output for assertion. */
-let logOutput: string[] = [];
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-mock.module("../../../ipc/cli-client.js", () => ({
-  cliIpcCall: async (method: string, params?: any) => {
-    lastIpcCall = { method, params };
-    return mockIpcResult;
-  },
-  exitFromIpcResult: (r: any) => {
-    process.exitCode = 1;
-    throw new Error(r.error ?? "ipc error");
-  },
-}));
-
-const capture = (...args: unknown[]) => {
-  logOutput.push(args.map(String).join(" "));
-};
-const fakeLogger = {
-  info: capture,
-  warn: capture,
-  error: capture,
-  debug: () => {},
-};
-
-mock.module("../../logger.js", () => ({
-  log: fakeLogger,
-  getCliLogger: () => fakeLogger,
-}));
-
-// ---------------------------------------------------------------------------
-// Import module under test (after mocks)
-// ---------------------------------------------------------------------------
-
-const { registerBackupCommand } = await import("../backup.js");
-
-// ---------------------------------------------------------------------------
-// Test helpers
-// ---------------------------------------------------------------------------
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {},
-  });
-  registerBackupCommand(program);
-  return program;
-}
-
-async function runCommand(args: string[]): Promise<{ exitCode: number }> {
-  process.exitCode = 0;
-  try {
-    const program = buildProgram();
-    await program.parseAsync(["node", "assistant", ...args]);
-  } catch {
-    if (process.exitCode === 0) {
-      process.exitCode = 1;
-    }
-  }
-  const exitCode = process.exitCode ?? 0;
-  process.exitCode = 0;
-  return { exitCode };
-}
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  lastIpcCall = null;
-  mockIpcResult = { ok: true, result: {} };
-  logOutput = [];
-  process.exitCode = 0;
-});
-
-// ---------------------------------------------------------------------------
-// enable
-// ---------------------------------------------------------------------------
-
-describe("backup enable", () => {
-  test("basic enable sends backup_enable with no extra params", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: {
-        enabled: true,
-        intervalHours: 6,
-        retention: 3,
-        offsite: { enabled: true },
-      },
-    };
-    const { exitCode } = await runCommand(["backup", "enable"]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_enable");
-    // Should not have intervalHours or retention if not specified
-    expect(
-      (lastIpcCall!.params?.body as Record<string, unknown>)?.intervalHours,
-    ).toBeUndefined();
-    expect(
-      (lastIpcCall!.params?.body as Record<string, unknown>)?.retention,
-    ).toBeUndefined();
-    expect(
-      (lastIpcCall!.params?.body as Record<string, unknown>)?.offsiteEnabled,
-    ).toBeUndefined();
-  });
-
-  test("--interval 12 --retention 7 sends correct params", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: {
-        enabled: true,
-        intervalHours: 12,
-        retention: 7,
-        offsite: { enabled: true },
-      },
-    };
-    const { exitCode } = await runCommand([
-      "backup",
-      "enable",
-      "--interval",
-      "12",
-      "--retention",
-      "7",
-    ]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_enable");
-    expect(lastIpcCall!.params).toEqual({
-      body: { intervalHours: 12, retention: 7 },
-    });
-  });
-
-  test("--no-offsite sends offsiteEnabled: false", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: {
-        enabled: true,
-        intervalHours: 6,
-        retention: 3,
-        offsite: { enabled: false },
-      },
-    };
-    const { exitCode } = await runCommand(["backup", "enable", "--no-offsite"]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_enable");
-    expect(
-      (lastIpcCall!.params?.body as Record<string, unknown>)?.offsiteEnabled,
-    ).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// disable
-// ---------------------------------------------------------------------------
-
-describe("backup disable", () => {
-  test("sends backup_disable", async () => {
-    const { exitCode } = await runCommand(["backup", "disable"]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_disable");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// destinations list
-// ---------------------------------------------------------------------------
-
-describe("backup destinations list", () => {
-  test("sends backup_destinations_list", async () => {
-    mockIpcResult = { ok: true, result: { destinations: [] } };
-    const { exitCode } = await runCommand(["backup", "destinations", "list"]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_destinations_list");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// destinations add
-// ---------------------------------------------------------------------------
-
-describe("backup destinations add", () => {
-  test("sends backup_destinations_add with encrypt: true by default", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: { destinations: [{ path: "/tmp/foo", encrypt: true }] },
-    };
-    const { exitCode } = await runCommand([
-      "backup",
-      "destinations",
-      "add",
-      "/tmp/foo",
-    ]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_destinations_add");
-    expect(lastIpcCall!.params).toEqual({
-      body: { path: "/tmp/foo", encrypt: true },
-    });
-  });
-
-  test("--plaintext sends encrypt: false", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: { destinations: [{ path: "/tmp/foo", encrypt: false }] },
-    };
-    const { exitCode } = await runCommand([
-      "backup",
-      "destinations",
-      "add",
-      "/tmp/foo",
-      "--plaintext",
-    ]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_destinations_add");
-    expect(lastIpcCall!.params).toEqual({
-      body: { path: "/tmp/foo", encrypt: false },
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// destinations remove
-// ---------------------------------------------------------------------------
-
-describe("backup destinations remove", () => {
-  test("sends backup_destinations_remove with correct path", async () => {
-    mockIpcResult = { ok: true, result: { destinations: [] } };
-    const { exitCode } = await runCommand([
-      "backup",
-      "destinations",
-      "remove",
-      "/tmp/foo",
-    ]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_destinations_remove");
-    expect((lastIpcCall!.params?.body as Record<string, unknown>)?.path).toBe(
-      "/tmp/foo",
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// destinations set-encrypt
-// ---------------------------------------------------------------------------
-
-describe("backup destinations set-encrypt", () => {
-  test("sends backup_destinations_set_encrypt with encrypt: true", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: { destination: { path: "/tmp/foo", encrypt: true } },
-    };
-    const { exitCode } = await runCommand([
-      "backup",
-      "destinations",
-      "set-encrypt",
-      "/tmp/foo",
-      "true",
-    ]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_destinations_set_encrypt");
-    expect(lastIpcCall!.params).toEqual({
-      body: { path: "/tmp/foo", encrypt: true },
-    });
-  });
-
-  test("invalid value exits with code 1 without calling IPC", async () => {
-    const { exitCode } = await runCommand([
-      "backup",
-      "destinations",
-      "set-encrypt",
-      "/tmp/foo",
-      "yes",
-    ]);
-    expect(exitCode).toBe(1);
-    // IPC should not have been called since we validated locally
-    expect(lastIpcCall).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// status
-// ---------------------------------------------------------------------------
-
-describe("backup status", () => {
-  test("successful status call exits with 0", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: {
-        enabled: true,
-        intervalHours: 6,
-        retention: 3,
-        lastRunAt: null,
-        nextRunAt: null,
-        localDir: "/tmp/local",
-        localSnapshotCount: 0,
-        offsiteEnabled: false,
-        offsite: [],
-      },
-    };
-    const { exitCode } = await runCommand(["backup", "status"]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backup_status");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// list
-// ---------------------------------------------------------------------------
-
-describe("backup list", () => {
-  test("sends backups_list", async () => {
-    mockIpcResult = {
-      ok: true,
-      result: {
-        local: [],
-        offsite: [],
-        offsiteEnabled: false,
-        nextRunAt: null,
-      },
-    };
-    const { exitCode } = await runCommand(["backup", "list"]);
-    expect(exitCode).toBe(0);
-    expect(lastIpcCall!.method).toBe("backups_list");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// IPC error path
-// ---------------------------------------------------------------------------
-
-describe("IPC error handling", () => {
-  test("IPC error causes process.exitCode = 1", async () => {
-    mockIpcResult = { ok: false, error: "daemon not running" };
-    const { exitCode } = await runCommand(["backup", "disable"]);
-    expect(exitCode).toBe(1);
-  });
-});