@mycadet/cli 0.0.1 → 0.12.6-dev.202610080043.b727a33

package/src/__tests__/local-hatch-lock.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import {
+  resolveLocalHatchLockPath,
+  withLocalHatchLock,
+} from "../lib/local-hatch-lock.js";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const tempDir of tempDirs.splice(0)) {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+function makeLockPath(): string {
+  const tempDir = mkdtempSync(join(tmpdir(), "cadet-hatch-lock-test-"));
+  tempDirs.push(tempDir);
+  return join(tempDir, "local-hatch.lock");
+}
+
+describe("withLocalHatchLock", () => {
+  test("uses the same machine lock when callers have different temp directories", () => {
+    const originalTmpDir = process.env.TMPDIR;
+    const firstTmpDir = mkdtempSync(join(tmpdir(), "cadet-tmp-a-"));
+    const secondTmpDir = mkdtempSync(join(tmpdir(), "cadet-tmp-b-"));
+    tempDirs.push(firstTmpDir, secondTmpDir);
+
+    try {
+      process.env.TMPDIR = firstTmpDir;
+      const firstPath = resolveLocalHatchLockPath();
+      process.env.TMPDIR = secondTmpDir;
+      const secondPath = resolveLocalHatchLockPath();
+
+      expect(secondPath).toBe(firstPath);
+      expect(firstPath.startsWith(firstTmpDir)).toBe(false);
+      expect(firstPath.startsWith(secondTmpDir)).toBe(false);
+    } finally {
+      if (originalTmpDir === undefined) {
+        delete process.env.TMPDIR;
+      } else {
+        process.env.TMPDIR = originalTmpDir;
+      }
+    }
+  });
+
+  test("serializes startup work that shares the machine-wide lock", async () => {
+    const lockPath = makeLockPath();
+    let releaseFirst!: () => void;
+    let firstStarted!: () => void;
+    const firstStartedPromise = new Promise<void>((resolve) => {
+      firstStarted = resolve;
+    });
+    const firstReleasePromise = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+    let secondEntered = false;
+
+    const first = withLocalHatchLock(
+      async () => {
+        firstStarted();
+        await firstReleasePromise;
+      },
+      { lockPath, timeoutMs: 1_000, retryMs: 5 },
+    );
+    await firstStartedPromise;
+
+    const second = withLocalHatchLock(
+      async () => {
+        secondEntered = true;
+      },
+      { lockPath, timeoutMs: 1_000, retryMs: 5 },
+    );
+    await Bun.sleep(20);
+    expect(secondEntered).toBe(false);
+
+    releaseFirst();
+    await Promise.all([first, second]);
+
+    expect(secondEntered).toBe(true);
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  test("recovers a lock owned by a dead process", async () => {
+    const lockPath = makeLockPath();
+    writeFileSync(
+      lockPath,
+      JSON.stringify({ pid: 2_147_483_647, token: "stale-owner" }) + "\n",
+    );
+
+    const result = await withLocalHatchLock(async () => "started", {
+      lockPath,
+      timeoutMs: 1_000,
+      retryMs: 5,
+    });
+
+    expect(result).toBe("started");
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  test("recovers an expired lock even when its PID has been reused", async () => {
+    const lockPath = makeLockPath();
+    writeFileSync(
+      lockPath,
+      JSON.stringify({
+        pid: process.pid,
+        processStartedAt: "not-the-current-process",
+        token: "reused-pid-owner",
+      }) + "\n",
+    );
+    const expired = new Date(Date.now() - 300_000);
+    utimesSync(lockPath, expired, expired);
+
+    const result = await withLocalHatchLock(async () => "started", {
+      lockPath,
+      liveOwnerRecoveryGraceMs: 0,
+      timeoutMs: 1_000,
+      retryMs: 5,
+    });
+
+    expect(result).toBe("started");
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  test("recovers a fresh lock when its PID has been reused", async () => {
+    const lockPath = makeLockPath();
+    writeFileSync(
+      lockPath,
+      JSON.stringify({
+        pid: process.pid,
+        processStartedAt: "not-the-current-process",
+        token: "fresh-reused-pid-owner",
+      }) + "\n",
+    );
+
+    const result = await withLocalHatchLock(async () => "started", {
+      lockPath,
+      timeoutMs: 1_000,
+      retryMs: 5,
+    });
+
+    expect(result).toBe("started");
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  test("releases the lock when startup fails", async () => {
+    const lockPath = makeLockPath();
+
+    await expect(
+      withLocalHatchLock(
+        async () => {
+          throw new Error("startup failed");
+        },
+        { lockPath },
+      ),
+    ).rejects.toThrow("startup failed");
+
+    expect(existsSync(lockPath)).toBe(false);
+  });
+});

package/src/__tests__/local-runtime-version.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+
+import { isValidReleaseVersion } from "@mycadet/local-mode";
+
+import type { LocalInstanceResources } from "../lib/assistant-config.js";
+import { ensureLocalRuntime } from "../lib/local.js";
+
+// Only `instanceDir` is read, and only after the validation guard passes —
+// invalid versions throw before any filesystem access, so a minimal stub is
+// sufficient for the rejection cases.
+const resources = {
+  instanceDir: "/tmp/cadet-nonexistent-instance",
+} as unknown as LocalInstanceResources;
+
+const VALID_VERSIONS = ["latest", "v1.2.3", "1.2.3", "0.6.0-staging.5"];
+const MALICIOUS_VERSIONS = [
+  "npm:@attacker/evil@1.0.0",
+  "https://evil.example/x.tgz",
+  "git+https://evil.example/x.git",
+  "../../../../tmp/evil",
+  "1.2.3-..",
+  "1.2.3-a..b",
+];
+
+describe("ensureLocalRuntime version guard", () => {
+  test("shares the trusted-release validator with the host boundary", () => {
+    for (const version of VALID_VERSIONS) {
+      expect(isValidReleaseVersion(version)).toBe(true);
+    }
+    for (const version of MALICIOUS_VERSIONS) {
+      expect(isValidReleaseVersion(version)).toBe(false);
+    }
+  });
+
+  test("throws before any install for untrusted versions", () => {
+    for (const version of MALICIOUS_VERSIONS) {
+      expect(() => ensureLocalRuntime(resources, version)).toThrow(
+        `Invalid runtime version '${version}'`,
+      );
+    }
+  });
+});

package/src/__tests__/login-loopback.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+
+import { startLoopbackListener } from "../commands/login.js";
+
+/** Resolve "settled"/"pending" — proves whether `waitForCode` resolved. */
+async function settleState(
+  p: Promise<unknown>,
+): Promise<"settled" | "pending"> {
+  return Promise.race([
+    p.then(
+      () => "settled" as const,
+      () => "settled" as const,
+    ),
+    new Promise<"pending">((r) => setTimeout(() => r("pending"), 50)),
+  ]);
+}
+
+describe("startLoopbackListener", () => {
+  test("rejects a state-mismatched callback (CSRF) without settling", async () => {
+    const listener = await startLoopbackListener("expected-state");
+    try {
+      // Wrong state — the load-bearing CSRF check. Any local process can
+      // hit the loopback port, so a mismatched state must NOT deliver a code.
+      const res = await fetch(`${listener.redirectUri}?code=evil&state=wrong`);
+      expect(res.status).toBe(404);
+      expect(await settleState(listener.waitForCode)).toBe("pending");
+
+      // Wrong path on the right port is also ignored.
+      const noise = await fetch(
+        `${listener.redirectUri.replace("/auth/callback", "/evil")}?state=expected-state&code=c`,
+      );
+      expect(noise.status).toBe(404);
+      expect(await settleState(listener.waitForCode)).toBe("pending");
+
+      // A state-matched callback then settles it — the listener kept
+      // listening through the noise above.
+      const ok = await fetch(
+        `${listener.redirectUri}?code=good-code&state=expected-state`,
+      );
+      expect(ok.status).toBe(200);
+      expect(await listener.waitForCode).toBe("good-code");
+    } finally {
+      listener.close();
+    }
+  });
+
+  test("rejects on an error callback with the matching state", async () => {
+    const listener = await startLoopbackListener("st");
+    try {
+      const settled = listener.waitForCode.then(
+        () => null,
+        (e: Error) => e,
+      );
+      const res = await fetch(
+        `${listener.redirectUri}?error=access_denied&state=st`,
+      );
+      expect(res.status).toBe(400);
+      const err = await settled;
+      expect(err?.message).toMatch(/access_denied/);
+    } finally {
+      listener.close();
+    }
+  });
+
+  test("close rejects a pending waiter with the given reason", async () => {
+    const listener = await startLoopbackListener("st");
+    const settled = listener.waitForCode.then(
+      () => null,
+      (e: Error) => e,
+    );
+    listener.close("Login timed out. Please try again.");
+    const err = await settled;
+    expect(err?.message).toMatch(/timed out/);
+  });
+});

package/src/__tests__/message.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect } from "bun:test";
+
+import { parseMessageArgs } from "../commands/message.js";
+
+describe("parseMessageArgs", () => {
+  test("parses an inline message with the active assistant", () => {
+    const r = parseMessageArgs(["hello"]);
+    expect(r).toEqual({
+      ok: true,
+      value: {
+        conversationKey: undefined,
+        jsonOutput: false,
+        inlineMessage: "hello",
+      },
+    });
+  });
+
+  test("parses an explicit assistant plus inline message", () => {
+    const r = parseMessageArgs(["my-assistant", "ping"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.assistantId).toBe("my-assistant");
+    expect(r.value.inlineMessage).toBe("ping");
+    expect(r.value.filePath).toBeUndefined();
+  });
+
+  test("requires message content when nothing is provided", () => {
+    const r = parseMessageArgs([]);
+    expect(r).toEqual({ ok: false, error: "message content is required." });
+  });
+
+  test("reads content from --file with the active assistant", () => {
+    const r = parseMessageArgs(["--file", "prompt.txt"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.filePath).toBe("prompt.txt");
+    expect(r.value.assistantId).toBeUndefined();
+    expect(r.value.inlineMessage).toBeUndefined();
+  });
+
+  test("reads content from --file with an explicit assistant", () => {
+    const r = parseMessageArgs(["my-assistant", "--file", "prompt.txt"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.assistantId).toBe("my-assistant");
+    expect(r.value.filePath).toBe("prompt.txt");
+  });
+
+  test("supports stdin via --file -", () => {
+    const r = parseMessageArgs(["--file", "-"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.filePath).toBe("-");
+  });
+
+  test("rejects combining --file with an inline message", () => {
+    const r = parseMessageArgs(["my-assistant", "extra", "--file", "p.txt"]);
+    expect(r).toEqual({
+      ok: false,
+      error: "--file cannot be combined with an inline message argument.",
+    });
+  });
+
+  test("rejects --file without a path argument", () => {
+    const r = parseMessageArgs(["my-assistant", "--file"]);
+    expect(r).toEqual({
+      ok: false,
+      error: "--file requires a path argument.",
+    });
+  });
+
+  test("preserves --conversation-key and --json alongside --file", () => {
+    const r = parseMessageArgs([
+      "--json",
+      "--conversation-key",
+      "thread-1",
+      "--file",
+      "prompt.txt",
+    ]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.jsonOutput).toBe(true);
+    expect(r.value.conversationKey).toBe("thread-1");
+    expect(r.value.filePath).toBe("prompt.txt");
+  });
+});