Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

44.7 KB
Raw Blame
import { describe, it, expect, vi } from "vitest";
vi.mock("../../src/db/queries/product-plan", async (original) => ({ ...await original<typeof import("../../src/db/queries/product-plan")>(), assertMachineCapacity: vi.fn() }));
vi.mock("../../src/db/queries/community/funnel-analytics", () => ({
  recordRuntimeConnectedStatement: vi.fn(() => ({ kind: "runtime-connected-statement" })),
}));
import * as q from "../../src/db/queries/community/machine";
import * as sessionEpoch from "../../src/db/queries/community/machine-session-epoch";

async function readyEpoch(db: any, userId: string, machineId: string, metadata: q.MachineMetadataInput, credentialHash: string) {
  db.batch ??= vi.fn(async (statements: unknown[]) => [await statements[0], []]);
  const result = await sessionEpoch.transitionMachineSessionEpoch(db, {
    type: "ready",
    epoch: { userId, machineId, credentialHash },
    metadata,
  });
  return result.type === "stale_epoch" ? null : result;
}

async function renewEpoch(db: any, epoch: sessionEpoch.MachineSessionEpoch) {
  const result = await sessionEpoch.transitionMachineSessionEpoch(db, { type: "renew", epoch });
  return result.type === "stale_epoch" ? null : result.machine;
}

async function closeEpoch(db: any, epoch: sessionEpoch.MachineSessionEpoch) {
  const result = await sessionEpoch.transitionMachineSessionEpoch(db, { type: "close", epoch });
  return result.type === "stale_epoch" ? null : result.machine;
}

function rotateEpoch(
  db: any,
  tokenId: string,
  metadata: q.MachineMetadataInput,
  options: { expectedMachineId?: string } = {},
) {
  return sessionEpoch.transitionMachineSessionEpoch(db, {
    type: "rotate",
    tokenId,
    metadata,
    expectedMachineId: options.expectedMachineId,
  });
}

describe("community/machine exports", () => {
  it("exports the documented helpers", () => {
    expect(typeof q.touchTokenLastUsed).toBe("function");
    expect(typeof q.revokeToken).toBe("function");
    expect(typeof q.getMachineByIdForUser).toBe("function");
    expect(typeof q.listMachinesForUser).toBe("function");
    expect(typeof q.deleteMachineForUser).toBe("function");
    expect(typeof sessionEpoch.transitionMachineSessionEpoch).toBe("function");
    expect(typeof q.revokeCredential).toBe("function");
  });

  it("does not export legacy machineUuid helpers", () => {
    expect((q as any).machineUuidFromTokenId).toBeUndefined();
    expect((q as any).tokenIdFromMachineUuid).toBeUndefined();
    expect((q as any).upsertMachineForUser).toBeUndefined();
    expect((q as any).rotatePairingTokenForMachine).toBeUndefined();
    expect((q as any).findActiveCredential).toBeUndefined();
    expect((q as any).findActiveAgentRunnerKey).toBeUndefined();
    expect((q as any).upsertMachineByMachineId).toBeUndefined();
    expect((q as any).touchMachineHeartbeat).toBeUndefined();
    expect((q as any).markMachineOffline).toBeUndefined();
    expect((q as any).markMachineOnlineIfOffline).toBeUndefined();
    expect((q as any).activateMachineCredential).toBeUndefined();
  });
});

describe("hashCredential", () => {
  it("returns lowercase hex of length 64 (sha256)", async () => {
    const h = await q.hashCredential("cmk_hello");
    expect(h).toMatch(/^[0-9a-f]{64}$/);
  });
  it("is deterministic for the same input", async () => {
    const a = await q.hashCredential("cmk_abc123");
    const b = await q.hashCredential("cmk_abc123");
    expect(a).toBe(b);
  });
  it("differs for different inputs", async () => {
    const a = await q.hashCredential("cmk_a");
    const b = await q.hashCredential("cmk_b");
    expect(a).not.toBe(b);
  });
});

describe("doNameFromHash", () => {
  it("returns the first 32 chars of the hash", async () => {
    const h = await q.hashCredential("cmk_abc");
    expect(q.doNameFromHash(h)).toBe(h.slice(0, 32));
    expect(q.doNameFromHash(h)).toHaveLength(32);
  });
});

describe("toSummary", () => {
  it("returns row.status verbatim (source of truth is the column)", () => {
    const now = new Date().toISOString();
    const s = q.toSummary({
      id: "cm_x",
      userId: "u_1",
      displayName: "host",
      hostname: "host",
      platform: "darwin",
      arch: "arm64",
      osRelease: "23.6.0",
      daemonVersion: "0.1.0",
      metadata: null,
      availableRuntimes: [],
      status: "online",
      lastSeenAt: now,
      createdAt: now,
      updatedAt: now,
    });
    expect(s.id).toBe("cm_x");
    expect(s.hostname).toBe("host");
    expect(s.status).toBe("online");
    expect(s.availableRuntimes).toEqual([]);
  });
  it("returns offline verbatim when the column says so, even with a fresh lastSeenAt", () => {
    const now = new Date().toISOString();
    const s = q.toSummary({
      id: "cm_x",
      userId: "u_1",
      displayName: "host",
      hostname: "host",
      platform: "darwin",
      arch: "arm64",
      osRelease: "23.6.0",
      daemonVersion: "0.1.0",
      metadata: null,
      availableRuntimes: [],
      status: "offline",
      // Deliberately recent lastSeenAt — status is no longer derived from it.
      lastSeenAt: now,
      createdAt: now,
      updatedAt: now,
    });
    expect(s.status).toBe("offline");
  });
  it("passes through availableRuntimes when populated", () => {
    const now = new Date().toISOString();
    const s = q.toSummary({
      id: "cm_x",
      userId: "u_1",
      displayName: "host",
      hostname: "host",
      platform: "darwin",
      arch: "arm64",
      osRelease: "23.6.0",
      daemonVersion: "0.1.0",
      metadata: null,
      availableRuntimes: [{ id: "claude", version: "1.0.0" }],
      status: "online",
      lastSeenAt: now,
      createdAt: now,
      updatedAt: now,
    });
    expect(s.availableRuntimes).toEqual([{ id: "claude", version: "1.0.0" }]);
  });
});

// ---------------------------------------------------------------------------
// session close and renew
// ---------------------------------------------------------------------------

function makeUpdateChain(returningRows: unknown[], priorStatus: "online" | "offline") {
  const chain: any = {};
  const prior = {
    id: "cm_1",
    userId: "u_1",
    displayName: "host",
    hostname: "host",
    platform: "darwin",
    arch: "arm64",
    osRelease: "23",
    daemonVersion: "0.1.0",
    metadata: null,
    availableRuntimes: [],
    status: priorStatus,
    lastSeenAt: "earlier",
    createdAt: "earlier",
    updatedAt: "earlier",
  };
  chain.select = vi.fn(() => chain);
  chain.from = vi.fn(() => chain);
  chain.limit = vi.fn(() => Promise.resolve([prior]));
  chain.update = vi.fn(() => chain);
  chain.set = vi.fn(() => chain);
  chain.where = vi.fn(() => chain);
  chain.returning = vi.fn(() => Promise.resolve(returningRows));
  return chain;
}

describe("session close", () => {
  it("flips status='online' → 'offline' when the row matches + credential is active (returns updated row)", async () => {
    const flipped = { id: "cm_1", userId: "u_1", status: "offline", lastSeenAt: "now" };
    const chain = makeUpdateChain([flipped], "online");
    const out = await closeEpoch(chain, {
      userId: "u_1",
      machineId: "cm_1",
      credentialHash: "abc",
    });
    expect(out).toEqual(flipped);
    expect(chain.set).toHaveBeenCalledWith(
      expect.objectContaining({ status: "offline" })
    );
  });
  it("returns null when the row is already offline / credential revoked / wrong user (guarded UPDATE returned zero rows)", async () => {
    const chain = makeUpdateChain([], "online");
    const out = await closeEpoch(chain, {
      userId: "u_1",
      machineId: "cm_1",
      credentialHash: "revoked",
    });
    expect(out).toBeNull();
  });
});

describe("session renew", () => {
  it("flips offline → online when guarded row + credential are active", async () => {
    const flipped = { id: "cm_1", userId: "u_1", status: "online", lastSeenAt: "now" };
    const chain = makeUpdateChain([flipped], "offline");
    const out = await renewEpoch(chain, {
      userId: "u_1",
      machineId: "cm_1",
      credentialHash: "abc",
    });
    expect(out).toEqual(flipped);
    expect(chain.set).toHaveBeenCalledWith(
      expect.objectContaining({ status: "online" })
    );
  });
  it("returns null when the row is already online or credential revoked", async () => {
    const chain = makeUpdateChain([], "offline");
    const out = await renewEpoch(chain, {
      userId: "u_1",
      machineId: "cm_1",
      credentialHash: "abc",
    });
    expect(out).toBeNull();
  });
});

describe("claimPairingToken", () => {
  it("rejects when no rows are returned (not claimable)", async () => {
    const chain: any = {};
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([]));
    await expect(q.claimPairingToken(chain, "cmt_abc")).rejects.toThrow(/not claimable/);
  });
  it("returns the single winner row", async () => {
    const chain: any = {};
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([{ id: "cmt_abc", userId: "u_1" }]));
    const r = await q.claimPairingToken(chain, "cmt_abc");
    expect(r).toEqual({ tokenId: "cmt_abc", userId: "u_1" });
  });
});

describe("isBotOnline", () => {
  function makeJoinChain(rows: unknown[]) {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve(rows));
    return chain;
  }

  it("returns true when the bound machine is online", async () => {
    const chain = makeJoinChain([{ status: "online" }]);
    expect(await q.isBotOnline(chain, "bot_1")).toBe(true);
  });

  it("returns false when the bound machine is offline", async () => {
    const chain = makeJoinChain([{ status: "offline" }]);
    expect(await q.isBotOnline(chain, "bot_1")).toBe(false);
  });

  it("returns false when the bot has no machine binding", async () => {
    const chain = makeJoinChain([]);
    expect(await q.isBotOnline(chain, "bot_1")).toBe(false);
  });

  it("joins the user table so a soft-deleted bot's row is excluded (mirrors listBotsForMachine's guard)", async () => {
    // A real DB would filter the join itself; this mock always returns the
    // row, so the assertion is structural — the query must join `user` at
    // all, not just `communityBotBinding`/`communityMachine`, so a
    // `deletedAt` filter has somewhere to apply.
    const chain = makeJoinChain([{ status: "online" }]);
    await q.isBotOnline(chain, "bot_1");
    expect(chain.innerJoin).toHaveBeenCalledTimes(2);
  });

  it("filters on `user.isBot` in the WHERE — defense-in-depth against a human user id sneaking into `communityBotBinding`", async () => {
    // Walk the where-condition graph looking for a drizzle column whose
    // name is `isBot`. Uses the same seen-set traversal
    // `user.test.ts::conditionReferencesColumn` uses.
    function referencesColumn(node: unknown, columnName: string, seen = new Set<unknown>()): boolean {
      if (node === null || typeof node !== "object") return false;
      if (seen.has(node)) return false;
      seen.add(node);
      if ((node as { name?: unknown }).name === columnName) return true;
      for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
        if (key === "table") continue;
        if (Array.isArray(value)) {
          if (value.some((v) => referencesColumn(v, columnName, seen))) return true;
        } else if (referencesColumn(value, columnName, seen)) {
          return true;
        }
      }
      return false;
    }
    const chain = makeJoinChain([{ status: "online" }]);
    await q.isBotOnline(chain, "bot_1");
    expect(referencesColumn(chain.where.mock.calls[0][0], "isBot")).toBe(true);
    expect(referencesColumn(chain.where.mock.calls[0][0], "deletedAt")).toBe(true);
  });
});

describe("reconcileBotActivityFromRunningAgents", () => {
  // The reconciler only clears "stuck" system-driven bot-activity pills to
  // Idle when the bot isn't in the daemon's runningAgents list. Owner-set
  // custom statuses (not matching the known bot presets) are left alone.
  it("returns [] when no bots are bound to the machine", async () => {
    const db: any = {
      select: vi.fn(() => ({
        from: vi.fn(() => ({
          innerJoin: vi.fn(() => ({ where: vi.fn(() => Promise.resolve([])) })),
        })),
      })),
    };
    const changed = await q.reconcileBotActivityFromRunningAgents(db, "cm_1", ["bot_a"]);
    expect(changed).toEqual([]);
  });
});

describe("findActiveToken", () => {
  it("returns null when no row matches", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    expect(await q.findActiveToken(chain, "cmt_x")).toBeNull();
  });
  it("returns the row when present", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([{ id: "cmt_x", userId: "u_1" }]));
    expect(await q.findActiveToken(chain, "cmt_x")).toEqual({
      tokenId: "cmt_x",
      userId: "u_1",
    });
  });
});

describe("findTokenById returns machineId (nullable)", () => {
  it("passes through null machineId for first-pair tokens", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmt_a",
          userId: "u_1",
          machineId: null,
          status: "pending",
          expiresAt: "9999",
        },
      ])
    );
    const r = await q.findTokenById(chain, "cmt_a");
    expect(r?.machineId).toBeNull();
  });
  it("returns bound machineId for reconnect tokens", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmt_a",
          userId: "u_1",
          machineId: "cm_existing",
          status: "pending",
          expiresAt: "9999",
        },
      ])
    );
    const r = await q.findTokenById(chain, "cmt_a");
    expect(r?.machineId).toBe("cm_existing");
  });
});

describe("createPairingToken", () => {
  function makeChain(insertRows: Array<{ id: string; expiresAt: string }>) {
    const chain: any = {};
    // update().set().where() — awaited directly, returns nothing meaningful
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.where = vi.fn(() => Promise.resolve());
    // insert().values().returning()
    chain.insert = vi.fn(() => chain);
    chain.values = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve(insertRows));
    return chain;
  }

  it("revokes any existing pending token for the user before insert", async () => {
    const chain = makeChain([{ id: "cmt_new", expiresAt: "future" }]);
    await q.createPairingToken(chain, "u_1");
    expect(chain.update).toHaveBeenCalled();
    expect(chain.set).toHaveBeenCalledWith(
      expect.objectContaining({ status: "revoked" })
    );
    // update() ran before insert() — both were called
    expect(chain.insert).toHaveBeenCalled();
    const updateOrder = chain.update.mock.invocationCallOrder[0];
    const insertOrder = chain.insert.mock.invocationCallOrder[0];
    expect(updateOrder).toBeLessThan(insertOrder);
  });

  it("inserts a pending token and returns id + expiry", async () => {
    const chain = makeChain([{ id: "cmt_new", expiresAt: "future" }]);
    const r = await q.createPairingToken(chain, "u_1");
    expect(r).toEqual({ tokenId: "cmt_new", expiresAt: "future" });
    expect(chain.values).toHaveBeenCalledWith(
      expect.objectContaining({ userId: "u_1", machineId: null, status: "pending" })
    );
  });

  it("passes through machineId when supplied (reconnect path)", async () => {
    const chain = makeChain([{ id: "cmt_new", expiresAt: "future" }]);
    await q.createPairingToken(chain, "u_1", { machineId: "cm_x" });
    expect(chain.values).toHaveBeenCalledWith(
      expect.objectContaining({ machineId: "cm_x" })
    );
  });
});

describe("createReconnectPairingToken", () => {
  it("rejects when machine is not owned by the user", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    await expect(
      q.createReconnectPairingToken(chain, "u_1", "cm_other")
    ).rejects.toThrow(/not owned by user/);
  });

  it("mints a machine-bound token on success", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    // select().from().where().limit() → owned row; update().set().where() → pre-revoke
    let whereCallCount = 0;
    chain.where = vi.fn(() => {
      whereCallCount += 1;
      // 2nd where() is the pre-revoke tail; resolves to nothing
      return whereCallCount >= 2 ? Promise.resolve() : chain;
    });
    chain.limit = vi.fn(() => Promise.resolve([{ id: "cm_x" }]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.insert = vi.fn(() => chain);
    chain.values = vi.fn(() => chain);
    chain.returning = vi.fn(() =>
      Promise.resolve([{ id: "cmt_new", expiresAt: "future" }])
    );
    const r = await q.createReconnectPairingToken(chain, "u_1", "cm_x");
    expect(r).toEqual({ tokenId: "cmt_new", expiresAt: "future" });
    expect(chain.values).toHaveBeenCalledWith(
      expect.objectContaining({ machineId: "cm_x" })
    );
  });
});

// ---------------------------------------------------------------------------
// session ready transition
// ---------------------------------------------------------------------------

describe("session ready transition", () => {
  const priorRow = {
    id: "cm_1",
    userId: "u_1",
    displayName: "host",
    hostname: "host",
    platform: "darwin",
    arch: "arm64",
    osRelease: "23",
    daemonVersion: "0.1.0",
    metadata: null,
    availableRuntimes: [{ id: "claude" }],
    status: "offline" as const,
    lastSeenAt: "earlier",
    createdAt: "earlier",
    updatedAt: "earlier",
  };

  it("returns null when the machine row is missing", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    expect(
      await readyEpoch(chain, "u_1", "cm_missing", {}, "hash")
    ).toBeNull();
  });

  it("passes availableRuntimes through the update when supplied", async () => {
    const updated = { ...priorRow, availableRuntimes: [{ id: "claude" }, { id: "codex" }] };
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([priorRow]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([updated]));
    const res = await readyEpoch(chain, "u_1", "cm_1", {
      availableRuntimes: [{ id: "claude" }, { id: "codex" }],
    }, "hash");
    expect(res?.priorAvailableRuntimes).toEqual([{ id: "claude" }]);
    expect(res?.priorDaemonVersion).toBe("0.1.0");
    expect(res?.machine.availableRuntimes).toEqual([{ id: "claude" }, { id: "codex" }]);
    expect(chain.set).toHaveBeenCalledWith(
      expect.objectContaining({
        availableRuntimes: [{ id: "claude" }, { id: "codex" }],
      })
    );
  });

  it("preserves prior availableRuntimes when caller passes undefined", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([priorRow]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([priorRow]));
    await readyEpoch(chain, "u_1", "cm_1", { hostname: "host2" }, "hash");
    expect(chain.set).toHaveBeenCalledWith(
      expect.objectContaining({ availableRuntimes: [{ id: "claude" }] })
    );
  });

  it("writes status='online' on every ready-frame upsert (the DO gates broadcast on priorStatus)", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([priorRow]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() =>
      Promise.resolve([{ ...priorRow, status: "online", lastSeenAt: "now" }])
    );
    await readyEpoch(chain, "u_1", "cm_1", { hostname: "host2" }, "hash");
    expect(chain.set).toHaveBeenCalledWith(expect.objectContaining({ status: "online" }));
  });

  it("returns priorStatus='offline' when the row was offline before the upsert", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([priorRow]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() =>
      Promise.resolve([{ ...priorRow, status: "online", lastSeenAt: "now" }])
    );
    const res = await readyEpoch(chain, "u_1", "cm_1", {}, "hash");
    expect(res?.priorStatus).toBe("offline");
  });

  it("returns priorStatus='online' when the row was already online (repeat ready-frame)", async () => {
    const onlinePrior = { ...priorRow, status: "online" as const };
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([onlinePrior]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([onlinePrior]));
    const res = await readyEpoch(chain, "u_1", "cm_1", {}, "hash");
    expect(res?.priorStatus).toBe("online");
  });

  it("returns null when the ready frame credential is no longer current", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([priorRow]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([]));
    const res = await readyEpoch(
      chain,
      "u_1",
      "cm_1",
      { hostname: "host2" },
      "revoked-hash"
    );
    expect(res).toBeNull();
  });
});

// ---------------------------------------------------------------------------
// session epoch rotation
// ---------------------------------------------------------------------------

describe("session epoch rotation — validation", () => {
  it("throws 'unknown' when the token is not in the DB", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    await expect(
      rotateEpoch(chain, "cmt_unknown", { hostname: "" })
    ).rejects.toBeInstanceOf(sessionEpoch.MachineSessionRotationError);
    try {
      await rotateEpoch(chain, "cmt_unknown", { hostname: "" });
    } catch (err) {
      expect((err as sessionEpoch.MachineSessionRotationError).kind).toBe("unknown");
      expect((err as sessionEpoch.MachineSessionRotationError).sessionOutcome).toBe("not_committed");
    }
  });

  it("throws 'revoked' when token status is revoked", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmt_x",
          userId: "u_1",
          machineId: null,
          status: "revoked",
          expiresAt: "9999",
        },
      ])
    );
    try {
      await rotateEpoch(chain, "cmt_x", { hostname: "" });
      throw new Error("should have thrown");
    } catch (err) {
      expect((err as sessionEpoch.MachineSessionRotationError).kind).toBe("revoked");
      expect((err as sessionEpoch.MachineSessionRotationError).sessionOutcome).toBe("unknown");
    }
  });

  it("throws 'already_active' when token status is active", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmt_x",
          userId: "u_1",
          machineId: null,
          status: "active",
          expiresAt: "9999",
        },
      ])
    );
    try {
      await rotateEpoch(chain, "cmt_x", { hostname: "" });
      throw new Error("should have thrown");
    } catch (err) {
      expect((err as sessionEpoch.MachineSessionRotationError).kind).toBe("already_active");
      expect((err as sessionEpoch.MachineSessionRotationError).sessionOutcome).toBe("unknown");
    }
  });

  it("throws 'expired' when expiresAt is past", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmt_x",
          userId: "u_1",
          machineId: null,
          status: "pending",
          expiresAt: "1970-01-01T00:00:00Z",
        },
      ])
    );
    try {
      await rotateEpoch(chain, "cmt_x", { hostname: "" });
      throw new Error("should have thrown");
    } catch (err) {
      expect((err as sessionEpoch.MachineSessionRotationError).kind).toBe("expired");
      expect((err as sessionEpoch.MachineSessionRotationError).sessionOutcome).toBe("not_committed");
    }
  });

  it("classifies a concurrent claim loser as ambiguous", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([{
      id: "cmt_x",
      userId: "u_1",
      machineId: "cm_existing",
      status: "pending",
      expiresAt: "9999",
    }]));
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([]));

    await expect(rotateEpoch(
      chain,
      "cmt_x",
      { hostname: "" },
      { expectedMachineId: "cm_existing" },
    )).rejects.toMatchObject({
      kind: "already_active",
      sessionOutcome: "unknown",
    });
  });

  it("fails reconnect without expectedMachineId before claiming the token", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([{
      id: "cmt_x",
      userId: "u_1",
      machineId: "cm_existing",
      status: "pending",
      expiresAt: "9999",
    }]));
    chain.update = vi.fn(() => chain);
    await expect(
      rotateEpoch(chain, "cmt_x", { hostname: "" })
    ).rejects.toMatchObject({
      kind: "expected_machine_required",
      sessionOutcome: "not_committed",
    });
    expect(chain.update).not.toHaveBeenCalled();
  });

  it("fails expectedMachineId mismatch before claiming the token", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([{
      id: "cmt_x",
      userId: "u_1",
      machineId: "cm_existing",
      status: "pending",
      expiresAt: "9999",
    }]));
    chain.update = vi.fn(() => chain);
    await expect(
      rotateEpoch(
        chain,
        "cmt_x",
        { hostname: "" },
        { expectedMachineId: "cm_other" },
      )
    ).rejects.toMatchObject({
      kind: "machine_mismatch",
      sessionOutcome: "not_committed",
    });
    expect(chain.update).not.toHaveBeenCalled();
  });
});

/**
 * session epoch rotation success paths use a scripted mock that returns
 * different results per call. Kept minimal — the interesting behavior is:
 * (1) new-pair path creates a machine row via insert;
 * (2) reconnect path (token.machineId set) reuses via update;
 * (3) either path stores credential_hash + do_name and returns the plaintext.
 */
describe("session epoch rotation — success paths", () => {
  function scriptChain(script: Array<() => Promise<any>>) {
    let step = 0;
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => script[step++]!());
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => script[step++]!());
    chain.insert = vi.fn(() => chain);
    // Values captured for assertion
    chain._insertValues = [] as any[];
    chain.values = vi.fn((v: any) => {
      chain._insertValues.push(v);
      return chain;
    });
    return chain;
  }

  it("new-pair path — inserts a new machine row and stores credential_hash + do_name", async () => {
    const nowStub = "2026-07-02T00:00:00.000Z";
    const insertedMachine = {
      id: "cm_new",
      userId: "u_1",
      displayName: "host",
      hostname: "host",
      platform: "darwin",
      arch: "arm64",
      osRelease: "23",
      daemonVersion: "0.1.0",
      metadata: null,
      availableRuntimes: [],
      lastSeenAt: nowStub,
      createdAt: nowStub,
      updatedAt: nowStub,
    };

    // Scripted results in call order:
    // 1. select token row (limit) → pending, no machineId
    // 2. update token pending→revoked (returning) → row
    // 3. insert machine (returning) → machine row
    // 4. insert credential — no returning
    const chain = scriptChain([
      // (1) findToken
      () =>
        Promise.resolve([
          {
            id: "cmt_x",
            userId: "u_1",
            machineId: null,
            status: "pending",
            expiresAt: "9999",
          },
        ]),
      // (2) flip returning
      () => Promise.resolve([{ id: "cmt_x" }]),
      // (3) insert machine returning
      () => Promise.resolve([insertedMachine]),
    ]);

    const r = await rotateEpoch(chain, "cmt_x", {
      hostname: "host",
    });
    expect(r.userId).toBe("u_1");
    expect(r.machineId).toBe("cm_new");
    expect(r.credential.startsWith("cmk_")).toBe(true);

    // Credential row insert must have set credential_hash + do_name.
    const credInsert = chain._insertValues.find(
      (v: any) => v.credentialHash && v.doName
    );
    expect(credInsert).toBeTruthy();
    expect(credInsert.credentialHash).toMatch(/^[0-9a-f]{64}$/);
    expect(credInsert.doName).toBe(credInsert.credentialHash.slice(0, 32));
    // The hash stored must match sha256(returned plaintext bearer).
    const expectedHash = await q.hashCredential(r.credential);
    expect(credInsert.credentialHash).toBe(expectedHash);
  });

  it("reconnect path atomically rotates credential + runner keys and projects offline", async () => {
    const existingMachine = {
      id: "cm_existing",
      userId: "u_1",
      displayName: "host",
      hostname: "host",
      platform: "darwin",
      arch: "arm64",
      osRelease: "23",
      daemonVersion: "0.1.0",
      metadata: null,
      availableRuntimes: [],
      lastSeenAt: "earlier",
      createdAt: "earlier",
      updatedAt: "earlier",
    };

    let selectCount = 0;
    let updateCount = 0;
    let mode = "";
    const chain: any = {};
    chain.select = vi.fn(() => {
      mode = "select";
      selectCount++;
      return chain;
    });
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => {
      if (mode === "select" && selectCount === 4) {
        return Promise.resolve([{ doName: "old-do" }]);
      }
      return chain;
    });
    chain.limit = vi.fn(() => Promise.resolve(
      selectCount === 1
        ? [{
            id: "cmt_x",
            userId: "u_1",
            machineId: "cm_existing",
            status: "pending",
            expiresAt: "9999",
          }]
        : [existingMachine],
    ));
    chain.update = vi.fn(() => {
      mode = "update";
      updateCount++;
      return chain;
    });
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => updateCount === 1
      ? Promise.resolve([{ id: "cmt_x" }])
      : { statement: "update-machine" });
    chain.insert = vi.fn(() => {
      mode = "insert";
      return chain;
    });
    chain._insertValues = [] as any[];
    chain.values = vi.fn((value: any) => {
      chain._insertValues.push(value);
      return chain;
    });
    chain.batch = vi.fn(async () => [[{
      ...existingMachine,
      status: "offline",
      lastSeenAt: null,
    }], [], [], []]);

    const r = await rotateEpoch(
      chain,
      "cmt_x",
      { hostname: "host" },
      { expectedMachineId: "cm_existing" },
    );
    expect(r.machineId).toBe("cm_existing");
    expect(r.revokedDoNames).toEqual(["old-do"]);
    expect(chain.batch).toHaveBeenCalledTimes(1);
    expect(chain.batch.mock.calls[0]![0]).toHaveLength(4);
    const machineSetCall = chain.set.mock.calls.find(
      (args: any[]) => args[0] && "hostname" in args[0]
    );
    expect(machineSetCall?.[0]).toEqual(expect.objectContaining({
      status: "offline",
      lastSeenAt: null,
    }));
  });

  it("keeps the token consumed when the reconnect batch rejects ambiguously", async () => {
    const machine = {
      id: "cm_existing",
      userId: "u_1",
      displayName: "host",
      hostname: "host",
      platform: "darwin",
      arch: "arm64",
      osRelease: "23",
      daemonVersion: "0.1.0",
      metadata: null,
      availableRuntimes: [],
      status: "online",
      lastSeenAt: "earlier",
      createdAt: "earlier",
      updatedAt: "earlier",
    };
    let selectCount = 0;
    let updateCount = 0;
    let mode = "";
    const chain: any = {};
    chain.select = vi.fn(() => {
      mode = "select";
      selectCount++;
      return chain;
    });
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => {
      if (mode === "select" && selectCount === 4) return Promise.resolve([]);
      return chain;
    });
    chain.limit = vi.fn(() => Promise.resolve(
      selectCount === 1
        ? [{
            id: "cmt_x",
            userId: "u_1",
            machineId: machine.id,
            status: "pending",
            expiresAt: "9999",
          }]
        : [machine],
    ));
    chain.update = vi.fn(() => {
      mode = "update";
      updateCount++;
      return chain;
    });
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => updateCount === 1
      ? Promise.resolve([{ id: "cmt_x" }])
      : { statement: "update-machine" });
    chain.insert = vi.fn(() => {
      mode = "insert";
      return chain;
    });
    chain.values = vi.fn(() => chain);
    chain.batch = vi.fn(async () => { throw new Error("D1 batch failed"); });

    await expect(rotateEpoch(
      chain,
      "cmt_x",
      { hostname: "host" },
      { expectedMachineId: machine.id },
    )).rejects.toThrow("D1 batch failed");

    expect(chain.batch).toHaveBeenCalledOnce();
    expect(chain.set.mock.calls.some(([value]: any[]) => value?.status === "pending")).toBe(false);
  });

  it("leaves the token revoked (not rolled back) when the reconnect target machine is missing", async () => {
    // If the machine row was deleted between mint and activate, we CANNOT
    // roll the token back to `pending` — a `pending` token that references
    // a missing machine will loop the daemon forever and the pending-token
    // unique index blocks the user from minting a fresh pair token for
    // 15 min. So the token stays `revoked` and the user re-pairs.
    let step = 0;
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => {
      const idx = step++;
      if (idx === 0) {
        return Promise.resolve([
          {
            id: "cmt_x",
            userId: "u_1",
            machineId: "cm_bad",
            status: "pending",
            expiresAt: "9999",
          },
        ]);
      }
      if (idx === 1) return Promise.resolve([]); // reconnect target missing
      return Promise.resolve([]);
    });
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    chain.returning = vi.fn(() => Promise.resolve([{ id: "cmt_x" }]));
    chain.insert = vi.fn(() => chain);
    chain.values = vi.fn(() => chain);

    await expect(
      rotateEpoch(
        chain,
        "cmt_x",
        { hostname: "" },
        { expectedMachineId: "cm_bad" },
      )
    ).rejects.toMatchObject({
      name: "MachineSessionRotationError",
      kind: "unknown",
      sessionOutcome: "unknown",
    });

    const setPayloads = chain.set.mock.calls.map((c: any[]) => c[0]);
    const rolledBack = setPayloads.some((p: any) => p.status === "pending");
    expect(rolledBack).toBe(false);
  });
});

// ---------------------------------------------------------------------------
// findCredentialByHash / findActiveCredentialByBearer
// ---------------------------------------------------------------------------

function whereRefsColumn(node: unknown, columnName: string, seen = new Set<unknown>()): boolean {
  if (node === null || typeof node !== "object") return false;
  if (seen.has(node)) return false;
  seen.add(node);
  if ((node as { name?: unknown }).name === columnName) return true;
  for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
    if (key === "table") continue;
    if (Array.isArray(value)) {
      if (value.some((v) => whereRefsColumn(v, columnName, seen))) return true;
    } else if (whereRefsColumn(value, columnName, seen)) {
      return true;
    }
  }
  return false;
}

describe("findCredentialByHash", () => {
  it("returns null when no active row matches", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    expect(await q.findCredentialByHash(chain, "deadbeef")).toBeNull();
  });

  it("joins `user` and filters `user.deletedAt` so a soft-deleted owner's daemon credential stops authenticating", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    await q.findCredentialByHash(chain, "h");
    expect(chain.innerJoin).toHaveBeenCalled();
    expect(whereRefsColumn(chain.where.mock.calls[0][0], "deletedAt")).toBe(true);
  });

  it("returns the row on hit and bumps last_used_at", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmkid_a",
          userId: "u_1",
          machineId: "cm_1",
          credentialHash: "h",
          doName: "d",
        },
      ])
    );
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    const r = await q.findCredentialByHash(chain, "h");
    expect(r).toEqual({
      credentialId: "cmkid_a",
      userId: "u_1",
      machineId: "cm_1",
      credentialHash: "h",
      doName: "d",
    });
    expect(chain.set).toHaveBeenCalledWith(
      expect.objectContaining({ lastUsedAt: expect.any(String) })
    );
  });
});

describe("findActiveCredentialByBearer", () => {
  it("returns null for a non-`cmk_` prefix without hitting the DB", async () => {
    const chain: any = {
      select: vi.fn(),
      from: vi.fn(),
      where: vi.fn(),
      limit: vi.fn(),
      update: vi.fn(),
      set: vi.fn(),
    };
    expect(await q.findActiveCredentialByBearer(chain, "cmt_wrong")).toBeNull();
    expect(chain.select).not.toHaveBeenCalled();
  });

  it("hashes the bearer and delegates to findCredentialByHash", async () => {
    const bearer = "cmk_test123";
    const hash = await q.hashCredential(bearer);
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    // The .where call receives the drizzle condition; we can't easily peek at
    // the compiled value, so we just assert the limit returns a shaped row.
    chain.limit = vi.fn(() =>
      Promise.resolve([
        {
          id: "cmkid_a",
          userId: "u_1",
          machineId: "cm_1",
          credentialHash: hash,
          doName: hash.slice(0, 32),
        },
      ])
    );
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    const r = await q.findActiveCredentialByBearer(chain, bearer);
    expect(r?.credentialHash).toBe(hash);
    expect(r?.doName).toBe(hash.slice(0, 32));
  });
});

// ---------------------------------------------------------------------------
// mintAgentRunnerKey / findActiveAgentRunnerKeyByBearer
// ---------------------------------------------------------------------------

describe("mintAgentRunnerKey", () => {
  it("hard-deletes an existing row before inserting a fresh bearer", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([{ id: "crkid_old" }]));
    chain.delete = vi.fn(() => chain);
    chain.insert = vi.fn(() => chain);
    chain.values = vi.fn(() => chain);
    const r = await q.mintAgentRunnerKey(chain, {
      userId: "u_1",
      machineId: "cm_1",
      agentId: "agent_a",
    });
    expect(r.existed).toBe(true);
    expect(r.runnerKey.startsWith("crk_")).toBe(true);
    expect(chain.delete).toHaveBeenCalled();
    expect(chain.values).toHaveBeenCalledWith(
      expect.objectContaining({
        userId: "u_1",
        machineId: "cm_1",
        agentId: "agent_a",
      })
    );
  });

  it("inserts a fresh row when nothing exists for (machine, agent)", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    chain.insert = vi.fn(() => chain);
    chain.values = vi.fn(() => chain);
    const r = await q.mintAgentRunnerKey(chain, {
      userId: "u_1",
      machineId: "cm_1",
      agentId: "agent_a",
    });
    expect(r.existed).toBe(false);
    expect(r.runnerKey.startsWith("crk_")).toBe(true);
    // Insert values include runnerKeyHash and doName.
    const inserted = chain.values.mock.calls[0][0];
    expect(inserted.runnerKeyHash).toMatch(/^[0-9a-f]{64}$/);
    expect(inserted.doName).toBe(inserted.runnerKeyHash.slice(0, 32));
  });
});

describe("findActiveAgentRunnerKeyByBearer", () => {
  it("returns null for a non-`crk_` prefix", async () => {
    const chain: any = {
      select: vi.fn(),
      from: vi.fn(),
      where: vi.fn(),
      limit: vi.fn(),
    };
    expect(await q.findActiveAgentRunnerKeyByBearer(chain, "cmk_wrong")).toBeNull();
    expect(chain.select).not.toHaveBeenCalled();
  });

  it("joins `user` and filters the owner's `user.deletedAt` so a banned owner's runner keys stop authenticating", async () => {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve([]));
    await q.findActiveAgentRunnerKeyByBearer(chain, "crk_x");
    expect(chain.innerJoin).toHaveBeenCalled();
    expect(whereRefsColumn(chain.where.mock.calls[0][0], "deletedAt")).toBe(true);
  });
});

// ---------------------------------------------------------------------------
// revokeCredentialsForMachine
// ---------------------------------------------------------------------------

describe("revokeCredentialsForMachine", () => {
  it("soft-revokes every active credential and returns the DO-name suffixes", async () => {
    const chain: any = {};
    chain.update = vi.fn(() => chain);
    chain.set = vi.fn(() => chain);
    let captured: unknown;
    chain.where = vi.fn((w: unknown) => {
      captured = w;
      return chain;
    });
    chain.returning = vi.fn(() =>
      Promise.resolve([{ doName: "aa".repeat(16) }, { doName: "bb".repeat(16) }])
    );
    const result = await q.revokeCredentialsForMachine(chain, "u_1", "cm_1");
    expect(chain.update).toHaveBeenCalledOnce();
    expect(chain.set).toHaveBeenCalledOnce();
    expect(captured).toBeDefined();
    expect(result.doNames).toEqual(["aa".repeat(16), "bb".repeat(16)]);
  });
});