Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

9.5 KB
Raw Blame
import { readFileSync } from "node:fs";
import Sqlite from "better-sqlite3";
import { drizzle } from "drizzle-orm/better-sqlite3";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { hashCredential } from "../../src/db/queries/community/machine";
import { transitionMachineSessionEpoch } from "../../src/db/queries/community/machine-session-epoch";

const OLD_HASH = "a".repeat(64);
const OLD_DO = "a".repeat(32);

describe("machine session epoch SQL transaction", () => {
  let sqlite: Sqlite.Database;
  let db: ReturnType<typeof drizzle>;

  beforeEach(() => {
    sqlite = new Sqlite(":memory:");
    sqlite.exec(`
      CREATE TABLE community_machine_token (
        id TEXT PRIMARY KEY,
        user_id TEXT NOT NULL,
        machine_id TEXT,
        status TEXT NOT NULL DEFAULT 'pending',
        expires_at TEXT NOT NULL,
        created_at TEXT NOT NULL,
        last_used_at TEXT
      );
      CREATE TABLE community_machine (
        id TEXT PRIMARY KEY,
        user_id TEXT NOT NULL,
        display_name TEXT NOT NULL DEFAULT '',
        hostname TEXT NOT NULL DEFAULT '',
        platform TEXT NOT NULL DEFAULT '',
        arch TEXT NOT NULL DEFAULT '',
        os_release TEXT NOT NULL DEFAULT '',
        daemon_version TEXT NOT NULL DEFAULT '',
        time_zone TEXT,
        metadata TEXT,
        available_runtimes TEXT NOT NULL DEFAULT '[]',
        status TEXT NOT NULL DEFAULT 'offline',
        last_seen_at TEXT,
        created_at TEXT NOT NULL,
        updated_at TEXT NOT NULL
      );
      CREATE TABLE community_machine_credential (
        id TEXT PRIMARY KEY,
        user_id TEXT NOT NULL,
        machine_id TEXT NOT NULL,
        credential_hash TEXT NOT NULL UNIQUE,
        do_name TEXT NOT NULL UNIQUE,
        created_at TEXT NOT NULL,
        last_used_at TEXT,
        revoked_at TEXT
      );
      CREATE TABLE community_agent_runner_key (
        id TEXT PRIMARY KEY,
        user_id TEXT NOT NULL,
        machine_id TEXT NOT NULL,
        agent_id TEXT NOT NULL,
        runner_key_hash TEXT NOT NULL UNIQUE,
        do_name TEXT NOT NULL UNIQUE,
        created_at TEXT NOT NULL,
        revoked_at TEXT
      );
    `);
    sqlite.exec("CREATE TABLE user(id TEXT PRIMARY KEY, isBot INTEGER NOT NULL DEFAULT 0, ownerUserId TEXT, createdAt TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, deletedAt TEXT); CREATE TABLE community_bot_binding(user_id TEXT PRIMARY KEY, machine_id TEXT);");
    sqlite.exec(readFileSync(new URL("../../../web/migrations/0098_product_plan_bot_active.sql", import.meta.url), "utf8"));
    sqlite.exec(readFileSync(new URL("../../../web/migrations/0099_billing_founder.sql", import.meta.url), "utf8"));
    sqlite.exec(readFileSync(new URL("../../../web/migrations/0101_machine_plan_limits.sql", import.meta.url), "utf8"));
    sqlite.exec(readFileSync(new URL("../../../web/migrations/0103_community_funnel_analytics_event.sql", import.meta.url), "utf8"));
    db = drizzle(sqlite);
    // Match D1's all-or-nothing batch contract using real generated SQL.
    (db as any).batch = (statements: Array<{ toSQL: () => { sql: string; params: unknown[] } }>) =>
      sqlite.transaction(() => statements.map((statement) => {
        const query = statement.toSQL();
        const prepared = sqlite.prepare(query.sql);
        return prepared.reader ? prepared.all(...query.params) : prepared.run(...query.params);
      }))();
    seedCurrentEpoch();
  });

  afterEach(() => sqlite.close());

  function seedCurrentEpoch() {
    sqlite.prepare(`
      INSERT INTO community_machine
        (id, user_id, display_name, hostname, platform, arch, os_release,
         daemon_version, metadata, available_runtimes, status, last_seen_at,
         created_at, updated_at)
      VALUES
        ('cm_machine', 'u_1', 'old-host', 'old-host', 'darwin', 'arm64', '23',
         '0.1.0', NULL, '[]', 'online', '2026-08-18T00:00:00.000Z',
         '2026-08-18T00:00:00.000Z', '2026-08-18T00:00:00.000Z')
    `).run();
    sqlite.prepare(`
      INSERT INTO community_machine_token
        (id, user_id, machine_id, status, expires_at, created_at)
      VALUES ('cmt_rotate', 'u_1', 'cm_machine', 'pending', '9999-01-01', '2026-08-18')
    `).run();
    sqlite.prepare(`
      INSERT INTO community_machine_credential
        (id, user_id, machine_id, credential_hash, do_name, created_at)
      VALUES ('cred_old', 'u_1', 'cm_machine', ?, ?, '2026-08-18')
    `).run(OLD_HASH, OLD_DO);
    sqlite.prepare(`
      INSERT INTO community_agent_runner_key
        (id, user_id, machine_id, agent_id, runner_key_hash, do_name, created_at)
      VALUES ('runner_old', 'u_1', 'cm_machine', 'bot_1', ?, ?, '2026-08-18')
    `).run("b".repeat(64), "b".repeat(32));
  }

  async function rotate() {
    return transitionMachineSessionEpoch(db as never, {
      type: "rotate",
      tokenId: "cmt_rotate",
      expectedMachineId: "cm_machine",
      metadata: {
        hostname: "new-host",
        platform: "darwin",
        arch: "arm64",
        daemonVersion: "0.1.12",
        availableRuntimes: [],
      },
    });
  }

  it("preserves machine identity metadata on a catalog-only ready update", async () => {
    sqlite.prepare("UPDATE community_machine SET display_name = ? WHERE id = ?").run("My laptop", "cm_machine");
    const availableRuntimes = [{ id: "codex", reasoning: { updateMode: "unsupported" as const, models: [{ id: "native-model", supportedReasoningEfforts: [] }] } }];
    const result = await transitionMachineSessionEpoch(db as any, {
      type: "ready", epoch: { userId: "u_1", machineId: "cm_machine", credentialHash: OLD_HASH }, metadata: { availableRuntimes },
    });
    expect(result.type).toBe("transitioned");
    if (result.type !== "transitioned") throw new Error("epoch not accepted");
    const stored = sqlite.prepare("SELECT display_name AS displayName, hostname, platform, arch, os_release AS osRelease, daemon_version AS daemonVersion, available_runtimes AS availableRuntimes FROM community_machine WHERE id = ?").get("cm_machine") as Record<string, string>;
    expect(stored).toMatchObject({ displayName: "My laptop", hostname: "old-host", platform: "darwin", arch: "arm64", osRelease: "23", daemonVersion: "0.1.0" });
    expect(JSON.parse(stored.availableRuntimes!)).toEqual(availableRuntimes);
  });

  it("commits credential, runner, and offline projection together and fences the old epoch", async () => {
    const result = await rotate();
    const newHash = await hashCredential(result.credential);

    expect(sqlite.prepare(`
      SELECT status, last_seen_at AS lastSeenAt, hostname
      FROM community_machine WHERE id = 'cm_machine'
    `).get()).toEqual({ status: "offline", lastSeenAt: null, hostname: "new-host" });
    expect(sqlite.prepare(`
      SELECT credential_hash AS credentialHash, revoked_at AS revokedAt
      FROM community_machine_credential ORDER BY id
    `).all()).toEqual(expect.arrayContaining([
      { credentialHash: OLD_HASH, revokedAt: expect.any(String) },
      { credentialHash: newHash, revokedAt: null },
    ]));
    expect(sqlite.prepare(`
      SELECT revoked_at AS revokedAt FROM community_agent_runner_key WHERE id = 'runner_old'
    `).get()).toEqual({ revokedAt: expect.any(String) });
    expect(sqlite.prepare(`
      SELECT status FROM community_machine_token WHERE id = 'cmt_rotate'
    `).get()).toEqual({ status: "revoked" });

    const oldEpoch = { userId: "u_1", machineId: "cm_machine", credentialHash: OLD_HASH };
    await expect(transitionMachineSessionEpoch(db as never, {
      type: "ready",
      epoch: oldEpoch,
      metadata: { hostname: "stale-host" },
    })).resolves.toEqual({ type: "stale_epoch" });

    const currentEpoch = { userId: "u_1", machineId: "cm_machine", credentialHash: newHash };
    await expect(transitionMachineSessionEpoch(db as never, {
      type: "ready",
      epoch: currentEpoch,
      metadata: { hostname: "current-host" },
    })).resolves.toMatchObject({ type: "transitioned", machine: { status: "online" } });
    for (const type of ["renew", "close", "expire"] as const) {
      await expect(transitionMachineSessionEpoch(db as never, {
        type,
        epoch: oldEpoch,
      })).resolves.toEqual({ type: "stale_epoch" });
    }
    expect(sqlite.prepare(`
      SELECT status, hostname FROM community_machine WHERE id = 'cm_machine'
    `).get()).toEqual({ status: "online", hostname: "current-host" });
  });

  it("rolls back DB state but keeps the token consumed when a dispatched batch rejects", async () => {
    sqlite.exec(`
      CREATE TRIGGER reject_new_machine_credential
      BEFORE INSERT ON community_machine_credential
      BEGIN
        SELECT RAISE(ABORT, 'injected credential insert failure');
      END;
    `);

    await expect(rotate()).rejects.toThrow("injected credential insert failure");

    expect(sqlite.prepare(`
      SELECT status, last_seen_at AS lastSeenAt, hostname
      FROM community_machine WHERE id = 'cm_machine'
    `).get()).toEqual({
      status: "online",
      lastSeenAt: "2026-08-18T00:00:00.000Z",
      hostname: "old-host",
    });
    expect(sqlite.prepare(`
      SELECT credential_hash AS credentialHash, revoked_at AS revokedAt
      FROM community_machine_credential
    `).all()).toEqual([{ credentialHash: OLD_HASH, revokedAt: null }]);
    expect(sqlite.prepare(`
      SELECT revoked_at AS revokedAt FROM community_agent_runner_key WHERE id = 'runner_old'
    `).get()).toEqual({ revokedAt: null });
    expect(sqlite.prepare(`
      SELECT status, last_used_at AS lastUsedAt FROM community_machine_token WHERE id = 'cmt_rotate'
    `).get()).toEqual({ status: "revoked", lastUsedAt: expect.any(String) });
  });
});