@mycadet/cli 0.12.10 → 0.13.0-dev.202610171617.9ea363e

package/src/__tests__/upgrade-root-recovery.test.ts

@@ -0,0 +1,185 @@
+import { afterAll, beforeEach, expect, spyOn, test } from "bun:test";
+import * as backups from "../lib/backup-ops.js";
+import * as docker from "../lib/docker.js";
+import * as lifecycle from "../lib/upgrade-lifecycle.js";
+import * as config from "../lib/assistant-config.js";
+import { mockCommands } from "./commands-mock.js";
+import * as loopback from "../lib/loopback-fetch.js";
+
+const capture = spyOn(backups, "createBackup");
+const images = spyOn(docker, "captureImageRefs");
+const pull = spyOn(docker, "pullImage");
+const wake = spyOn(docker, "wakeContainers");
+const save = spyOn(config, "saveAssistantEntry");
+const restore = spyOn(backups, "restoreBackup");
+const sleep = spyOn(docker, "sleepContainers");
+const stop = spyOn(docker, "stopContainers");
+const start = spyOn(docker, "startContainers");
+const fetch = spyOn(loopback, "loopbackSafeFetch");
+const res = docker.dockerResourceNames("recovery");
+const containerOptions = {
+  gatewayPort: 7830,
+  assistantPort: 3001,
+  imageTags: {
+    assistant: "assistant:old",
+    gateway: "gateway:old",
+    "credential-executor": "ces:old",
+  },
+  instanceName: "recovery",
+  res,
+};
+const events: string[] = [];
+beforeEach(() => {
+  events.length = 0;
+  capture.mockReset();
+  images.mockReset();
+  pull.mockReset();
+  wake.mockReset();
+  save.mockReset();
+  save.mockImplementation(() => {});
+  restore.mockReset();
+  sleep.mockReset();
+  stop.mockReset();
+  start.mockReset();
+  fetch.mockReset();
+  restore.mockImplementation(async () => {
+    events.push("restore-roots");
+    return true;
+  });
+  sleep.mockImplementation(async () => {
+    events.push("sleep");
+  });
+  stop.mockImplementation(async () => {
+    events.push("remove");
+  });
+  start.mockImplementation(async () => {
+    events.push("start-old-version");
+  });
+  fetch.mockImplementation(async () => {
+    events.push("check-ready");
+    return Response.json({ ready: true });
+  });
+});
+afterAll(() => {
+  for (const spy of [
+    restore,
+    sleep,
+    stop,
+    start,
+    fetch,
+    capture,
+    images,
+    pull,
+    wake,
+    save,
+  ])
+    spy.mockRestore();
+});
+
+test("failed-state recovery restores tar roots while stopped before restarting old services", async () => {
+  expect(
+    await lifecycle.attemptFailedStateRestore({
+      runtimeUrl: "http://127.0.0.1:1",
+      assistantId: "recovery",
+      backupPath: "pre-upgrade.tar.gz",
+      backupLabel: "pre-upgrade",
+      res,
+      containerOptions,
+    }),
+  ).toEqual({ restored: true, ready: true });
+  expect(restore).toHaveBeenCalledWith(
+    "http://127.0.0.1:1",
+    "recovery",
+    "pre-upgrade.tar.gz",
+    { resume: false },
+  );
+  expect(events).toEqual([
+    "restore-roots",
+    "sleep",
+    "remove",
+    "start-old-version",
+    "check-ready",
+  ]);
+});
+
+test("failed root restore does not restart a partial installation", async () => {
+  restore.mockResolvedValue(false);
+  expect(
+    await lifecycle.attemptFailedStateRestore({
+      runtimeUrl: "http://127.0.0.1:1",
+      assistantId: "recovery",
+      backupPath: "pre-upgrade.tar.gz",
+      backupLabel: "pre-upgrade",
+      res,
+      containerOptions,
+    }),
+  ).toEqual({ restored: false, ready: false });
+  expect(start).not.toHaveBeenCalled();
+  expect(stop).not.toHaveBeenCalled();
+  expect(fetch).not.toHaveBeenCalled();
+});
+
+test("versioned restore installs roots into stopped target containers before first startup", async () => {
+  const commands = mockCommands();
+  commands.on(
+    "docker",
+    (args) => args[0] === "inspect",
+    () => ({
+      stdout: JSON.stringify(["ACTOR_TOKEN_SIGNING_KEY=" + "01".repeat(32)]),
+    }),
+  );
+  const entry: config.AssistantEntry = {
+    assistantId: "recovery",
+    cloud: "docker",
+    runtimeUrl: "http://127.0.0.1:1",
+  };
+  capture.mockImplementation(async () => {
+    events.push("capture-safety");
+    return "/tmp/pre-rollback.tar.gz";
+  });
+  images.mockResolvedValue({
+    assistant: "assistant:current",
+    gateway: "gateway:current",
+    "credential-executor": "ces:current",
+  });
+  pull.mockResolvedValue(undefined);
+  start.mockImplementation(async (options) => {
+    expect(options.createOnly).toBe(true);
+    events.push("create-stopped-target");
+  });
+  wake.mockImplementation(async () => {
+    events.push("wake-restored-target");
+  });
+  fetch.mockImplementation(async (url) => {
+    if (String(url).includes("/healthz"))
+      return Response.json({ version: "0.12.11" });
+    if (String(url).includes("/readyz")) {
+      events.push("check-ready");
+      return Response.json({ ready: true });
+    }
+    return Response.json({});
+  });
+  try {
+    await lifecycle.performDockerRollback(entry, {
+      targetVersion: "0.12.10",
+      backupPath: "/tmp/source.tar.gz",
+    });
+    expect(restore).toHaveBeenCalledWith(
+      entry.runtimeUrl,
+      entry.assistantId,
+      "/tmp/source.tar.gz",
+      { resume: false },
+    );
+    expect(events).toEqual([
+      "capture-safety",
+      "sleep",
+      "remove",
+      "create-stopped-target",
+      "restore-roots",
+      "wake-restored-target",
+      "check-ready",
+    ]);
+  } finally {
+    commands.restore();
+  }
+});

package/src/__tests__/wake.test.ts

@@ -173,7 +173,7 @@ mock.module("../lib/ingress-config.js", () => ({
 }));
 
 const ensureTunnelEdgeMock = mock<typeof nginxIngress.ensureTunnelEdge>(
-  async () => ({ port: 7840, started: true, includesWebApp: true }),
+  async () => ({ port: 7840, started: true, includesWebApp: true, shellMode: "web" }),
 );
 const isIngressRunningMock = mock<typeof nginxIngress.isIngressRunning>(
   () => false,
@@ -305,6 +305,7 @@ beforeEach(() => {
     port: 7840,
     started: true,
     includesWebApp: true,
+    shellMode: "web",
   });
   isIngressRunningMock.mockReset();
   isIngressRunningMock.mockReturnValue(false);
@@ -1073,6 +1074,7 @@ describe("cadet wake — tunnel edge restore", () => {
       port: 7840,
       started: false,
       includesWebApp: true,
+      shellMode: "web",
     });
     process.argv = ["bun", "cadet", "wake", "docker-1"];
 
@@ -1579,6 +1581,7 @@ describe("cadet wake — tunnel edge restore", () => {
       port: 7841,
       started: false,
       includesWebApp: true,
+      shellMode: "web",
     });
 
     await wake();

package/src/__tests__/windows-lifecycle.test.ts

@@ -227,3 +227,28 @@ test("preserves PID tracking when process termination fails", async () => {
   expect(isProcessAlive(pidFile)).toEqual({ alive: true, pid: process.pid });
   rmSync(dir, { recursive: true, force: true });
 });
+
+test("graceful-only stop times out without SIGKILL or losing PID identity", async () => {
+  const originalKill = process.kill;
+  const calls: Array<NodeJS.Signals | number | undefined> = [];
+  process.kill = ((_pid: number, signal?: NodeJS.Signals | number) => {
+    calls.push(signal);
+    return true;
+  }) as typeof process.kill;
+  try {
+    expect(
+      await stopProcess(
+        4812,
+        "backup service",
+        0,
+        "linux",
+        undefined,
+        () => "cadet-daemon",
+        true,
+      ),
+    ).toBe(false);
+    expect(calls).toEqual([0, "SIGTERM", 0]);
+  } finally {
+    process.kill = originalKill;
+  }
+});