agent-dealer 1.2.2 → 1.2.4

package/dist/doctor.test.js

@@ -0,0 +1,276 @@
+// packages/cli/src/doctor.test.ts
+//
+// NOT-267: doctor reports which local login the experimental Cursor
+// Individual adapter would use — desktop, Agent fallback, or none — using
+// static lines only. Tests never touch the real local login: every case
+// points the resolution at temporary fixtures.
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+// Local mirror of the server module's env/key contract
+// (packages/server/src/capacity/cursor-individual-credentials.ts). A static
+// import is impossible — CLI `rootDir` cannot include server sources — so
+// the mirror is pinned against the live server module by the contract test
+// below: a rename there fails that test loudly instead of letting these
+// fixtures silently stop applying (and probe the real local login).
+const CURSOR_DESKTOP_ACCESS_TOKEN_KEY = "cursorAuth/accessToken";
+const CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV = "CURSOR_INDIVIDUAL_CREDENTIAL_FILE";
+const CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV = "CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE";
+const CURSOR_INDIVIDUAL_HOME_ENV = "CURSOR_INDIVIDUAL_HOME";
+test("fixture env/key names match the server module's live contract", async () => {
+    const { pathToFileURL, fileURLToPath } = await import("node:url");
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(here, "..", "..", "server", "src", "capacity", "cursor-individual-credentials.ts"),
+        path.resolve(here, "..", "..", "server", "dist", "capacity", "cursor-individual-credentials.js"),
+    ];
+    let mod = null;
+    for (const file of candidates) {
+        try {
+            if (!fs.existsSync(file))
+                continue;
+            mod = (await import(pathToFileURL(file).href));
+            break;
+        }
+        catch {
+            continue;
+        }
+    }
+    assert.ok(mod, "the server credentials module must be loadable for the contract pin");
+    assert.equal(mod.CURSOR_DESKTOP_ACCESS_TOKEN_KEY, CURSOR_DESKTOP_ACCESS_TOKEN_KEY);
+    assert.equal(mod.CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV, CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV);
+    assert.equal(mod.CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV, CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV);
+    assert.equal(mod.CURSOR_INDIVIDUAL_HOME_ENV, CURSOR_INDIVIDUAL_HOME_ENV);
+});
+import { CLAUDE_CAPACITY_CACHE_FILE_ENV, CLAUDE_CAPACITY_REFRESH_ENV, CLAUDE_CAPACITY_REFRESH_PAID_VALUE, CURSOR_INDIVIDUAL_LOGIN_LINES, MUSE_CAPACITY_REFRESH_ENV, MUSE_CAPACITY_REFRESH_MS_ENV, MUSE_CAPACITY_REFRESH_PAID_VALUE, checkClaudeCapacitySource, checkCursorIndividualLogin, describeClaudeCapacitySource, describeClaudeProbeOptIn, describeCursorIndividualLogin, describeMuseProbeOptIn, } from "./doctor.js";
+const SECRET = "doctor-fixture-secret-must-never-print";
+const USER_ID = "user_doctor_fixture";
+function fixtureJwt(sub) {
+    const b64url = (obj) => Buffer.from(JSON.stringify(obj)).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    return `${b64url({ alg: "none" })}.${b64url({ sub })}.sig`;
+}
+let dir;
+const saved = {};
+beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-doctor-indiv-"));
+    for (const key of [
+        CURSOR_INDIVIDUAL_CREDENTIAL_FILE_ENV,
+        CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV,
+        CURSOR_INDIVIDUAL_HOME_ENV,
+        CLAUDE_CAPACITY_CACHE_FILE_ENV,
+    ]) {
+        saved[key] = process.env[key];
+        delete process.env[key];
+    }
+});
+afterEach(() => {
+    for (const [key, value] of Object.entries(saved)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+});
+test("describe maps each credential state to its static line", () => {
+    assert.deepEqual(describeCursorIndividualLogin({ present: true, source: "desktop" }), {
+        kind: "desktop",
+        line: CURSOR_INDIVIDUAL_LOGIN_LINES.desktop,
+    });
+    assert.deepEqual(describeCursorIndividualLogin({ present: true, source: "agent" }), {
+        kind: "agent",
+        line: CURSOR_INDIVIDUAL_LOGIN_LINES.agent,
+    });
+    const degraded = [
+        { present: false, source: null },
+        { present: false, source: "desktop" },
+        { present: true, source: null },
+        null,
+        undefined,
+    ];
+    for (const state of degraded) {
+        assert.deepEqual(describeCursorIndividualLogin(state), {
+            kind: "none",
+            line: CURSOR_INDIVIDUAL_LOGIN_LINES.none,
+        });
+    }
+});
+test("the three lines name the three states and carry no paths or secrets", () => {
+    assert.match(CURSOR_INDIVIDUAL_LOGIN_LINES.desktop, /desktop login found/);
+    assert.match(CURSOR_INDIVIDUAL_LOGIN_LINES.agent, /Agent login found/);
+    assert.match(CURSOR_INDIVIDUAL_LOGIN_LINES.none, /no usable local login/);
+    for (const line of Object.values(CURSOR_INDIVIDUAL_LOGIN_LINES)) {
+        assert.ok(!line.includes("/"), "no filesystem paths in doctor output");
+        assert.ok(!line.includes(SECRET));
+    }
+});
+function fixtureDesktopDb(token) {
+    const file = path.join(dir, "state.vscdb");
+    const db = new Database(file);
+    try {
+        db.exec("CREATE TABLE ItemTable (key TEXT PRIMARY KEY, value TEXT)");
+        db.prepare("INSERT INTO ItemTable (key, value) VALUES (?, ?)").run(CURSOR_DESKTOP_ACCESS_TOKEN_KEY, token);
+    }
+    finally {
+        db.close();
+    }
+    process.env[CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV] = file;
+    return file;
+}
+test("check reports desktop login found for a fixture state.vscdb", async () => {
+    process.env[CURSOR_INDIVIDUAL_HOME_ENV] = dir;
+    const jwt = fixtureJwt(USER_ID);
+    const dbFile = fixtureDesktopDb(jwt);
+    const report = await checkCursorIndividualLogin();
+    assert.equal(report.kind, "desktop");
+    assert.equal(report.line, CURSOR_INDIVIDUAL_LOGIN_LINES.desktop);
+    assert.ok(!report.line.includes(jwt), "token material must not print");
+    assert.ok(!report.line.includes(dbFile), "database paths must not print");
+});
+test("check reports Agent login found when only the Agent auth file answers", async () => {
+    process.env[CURSOR_INDIVIDUAL_HOME_ENV] = dir;
+    process.env[CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV] = path.join(dir, "missing.vscdb");
+    const agentFile = path.join(dir, ".cursor", "auth.json");
+    fs.mkdirSync(path.dirname(agentFile), { recursive: true });
+    fs.writeFileSync(agentFile, JSON.stringify({ token: SECRET, userId: USER_ID }));
+    const report = await checkCursorIndividualLogin();
+    assert.equal(report.kind, "agent");
+    assert.equal(report.line, CURSOR_INDIVIDUAL_LOGIN_LINES.agent);
+    assert.ok(!report.line.includes(SECRET), "token material must not print");
+    assert.ok(!report.line.includes(agentFile), "credential paths must not print");
+});
+test("check reports no usable local login when neither source answers", async () => {
+    process.env[CURSOR_INDIVIDUAL_HOME_ENV] = dir;
+    process.env[CURSOR_INDIVIDUAL_DESKTOP_STATE_FILE_ENV] = path.join(dir, "missing.vscdb");
+    const report = await checkCursorIndividualLogin();
+    assert.equal(report.kind, "none");
+    assert.equal(report.line, CURSOR_INDIVIDUAL_LOGIN_LINES.none);
+});
+// ---------------------------------------------------------------------------
+// NOT-268: Claude capacity source reporting. Tests never touch the real
+// ~/.claude.json: every case points the override at a temporary fixture.
+// ---------------------------------------------------------------------------
+test("fixture cache-file env name matches the server module's live contract", async () => {
+    const { fileURLToPath } = await import("node:url");
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(here, "..", "..", "server", "src", "capacity", "claude-local-cache.ts"),
+        path.resolve(here, "..", "..", "server", "dist", "capacity", "claude-local-cache.js"),
+    ];
+    const src = candidates.find((file) => fs.existsSync(file));
+    assert.ok(src, "the server cache module must exist for the contract pin");
+    const text = fs.readFileSync(src, "utf8");
+    assert.ok(text.includes(`"${CLAUDE_CAPACITY_CACHE_FILE_ENV}"`));
+    assert.ok(text.includes(`"${CLAUDE_CAPACITY_REFRESH_ENV}"`));
+    assert.ok(text.includes(`"${CLAUDE_CAPACITY_REFRESH_PAID_VALUE}"`));
+});
+test("describe maps each cache state to its static line", () => {
+    const fresh = describeClaudeCapacitySource({ present: true, ageMs: 5 * 60_000 });
+    assert.equal(fresh.kind, "fresh");
+    assert.match(fresh.line, /fresh/);
+    const stale = describeClaudeCapacitySource({ present: true, ageMs: 61 * 60_000 });
+    assert.equal(stale.kind, "stale");
+    assert.match(stale.line, /stale/);
+    const degraded = [
+        { present: false, ageMs: null },
+        { present: false, ageMs: 0 },
+        { present: true, ageMs: null },
+        { present: true, ageMs: -1 },
+        null,
+        undefined,
+    ];
+    for (const state of degraded) {
+        const report = describeClaudeCapacitySource(state);
+        assert.equal(report.kind, "missing");
+        assert.match(report.line, /no local 5H\/1W cache/);
+    }
+});
+test("probe warning appears for the default and explicit paid value", () => {
+    for (const setting of [undefined, "", CLAUDE_CAPACITY_REFRESH_PAID_VALUE]) {
+        const armed = describeClaudeProbeOptIn(setting);
+        assert.ok(armed);
+        assert.match(armed, /enabled/);
+        assert.match(armed, /≤\$0\.01/);
+        assert.match(armed, /=off/);
+    }
+    assert.equal(describeClaudeProbeOptIn("off"), null);
+    assert.equal(describeClaudeProbeOptIn("auto"), null);
+});
+test("Muse paid-fallback warning matches server defaults and legacy no-spend precedence", () => {
+    for (const setting of [undefined, "", MUSE_CAPACITY_REFRESH_PAID_VALUE]) {
+        const armed = describeMuseProbeOptIn(setting, undefined);
+        assert.ok(armed);
+        assert.match(armed, /Muse capacity paid fallback: enabled/);
+        assert.match(armed, /restricted contributor-model turn/);
+        assert.match(armed, new RegExp(`${MUSE_CAPACITY_REFRESH_ENV}=off`));
+    }
+    assert.equal(describeMuseProbeOptIn("off", undefined), null);
+    assert.equal(describeMuseProbeOptIn("auto", undefined), null);
+    assert.equal(describeMuseProbeOptIn(undefined, "off"), null);
+    assert.equal(describeMuseProbeOptIn("", "off"), null);
+    assert.ok(describeMuseProbeOptIn(MUSE_CAPACITY_REFRESH_PAID_VALUE, "off"), "the explicit new paid value overrides the legacy free-refresh switch");
+});
+test("Muse doctor env names and paid value match the server contract", () => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(here, "..", "..", "server", "src", "capacity", "muse-probe.ts"),
+        path.resolve(here, "..", "..", "server", "dist", "capacity", "muse-probe.js"),
+    ];
+    const src = candidates.find((file) => fs.existsSync(file));
+    assert.ok(src, "the server Muse probe module must exist for the contract pin");
+    const text = fs.readFileSync(src, "utf8");
+    assert.ok(text.includes(`"${MUSE_CAPACITY_REFRESH_ENV}"`));
+    assert.ok(text.includes(`"${MUSE_CAPACITY_REFRESH_PAID_VALUE}"`));
+    assert.ok(text.includes("AGENT_DEALER_MUSE_CAPACITY_REFRESH_MS"));
+    assert.equal(MUSE_CAPACITY_REFRESH_MS_ENV, "AGENT_DEALER_MUSE_CAPACITY_REFRESH_MS");
+});
+test("check reads fetchedAtMs from the config key, never mtime or the real home", async () => {
+    const now = Date.now();
+    // Full config envelope with sensitive siblings: freshness comes from the
+    // subtree timestamp even though mtime is two days old (mtime must be
+    // ignored — unrelated config writes touch it). The line must not leak
+    // the sibling values.
+    const freshFile = path.join(dir, "cached-fresh.json");
+    fs.writeFileSync(freshFile, JSON.stringify({
+        userID: "user-secret-must-never-print",
+        email: "someone@example.com",
+        cachedUsageUtilization: { fetchedAtMs: now - 5 * 60_000, accountUuid: "acct-secret" },
+    }));
+    const ancient = new Date(now - 2 * 24 * 3600_000);
+    fs.utimesSync(freshFile, ancient, ancient);
+    process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV] = freshFile;
+    const fresh = await checkClaudeCapacitySource(now);
+    assert.equal(fresh.kind, "fresh");
+    assert.ok(!fresh.line.includes("user-secret-must-never-print"));
+    assert.ok(!fresh.line.includes("acct-secret"));
+    // Bare cache object (no envelope) still works; a brand-new mtime cannot
+    // rescue a stale timestamp.
+    const staleFile = path.join(dir, "cached-stale.json");
+    fs.writeFileSync(staleFile, JSON.stringify({ fetchedAtMs: 1 }));
+    const justNow = new Date(now);
+    fs.utimesSync(staleFile, justNow, justNow);
+    process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV] = staleFile;
+    const stale = await checkClaudeCapacitySource(now);
+    assert.equal(stale.kind, "stale");
+    // Missing file, garbage JSON, future timestamp, and a config without the
+    // key all report missing.
+    process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV] = path.join(dir, "missing.json");
+    assert.equal((await checkClaudeCapacitySource(now)).kind, "missing");
+    const garbageFile = path.join(dir, "cached-garbage.json");
+    fs.writeFileSync(garbageFile, "{not json");
+    process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV] = garbageFile;
+    assert.equal((await checkClaudeCapacitySource(now)).kind, "missing");
+    const futureFile = path.join(dir, "cached-future.json");
+    fs.writeFileSync(futureFile, JSON.stringify({ cachedUsageUtilization: { fetchedAtMs: now + 60_000 } }));
+    process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV] = futureFile;
+    assert.equal((await checkClaudeCapacitySource(now)).kind, "missing");
+    const keylessFile = path.join(dir, "cached-keyless.json");
+    fs.writeFileSync(keylessFile, JSON.stringify({ userID: "x", projects: {} }));
+    process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV] = keylessFile;
+    assert.equal((await checkClaudeCapacitySource(now)).kind, "missing");
+    delete process.env[CLAUDE_CAPACITY_CACHE_FILE_ENV];
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dealer",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Human control plane for agent execution — queue, plan approval, audit",
   "license": "MIT",
   "type": "module",