Initial import of streamline
This commit is contained in:
@@ -0,0 +1,499 @@
|
||||
import { afterEach, describe, expect, test } from "bun:test";
|
||||
import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import path from "node:path";
|
||||
import {
|
||||
clearAgentAccountDrain,
|
||||
isAgentAccountClaimDrained,
|
||||
readAgentAccountDrain,
|
||||
updateAgentAccountDrain,
|
||||
writeAgentAccountDrain,
|
||||
type AgentAccountDrainState,
|
||||
} from "../src/security_telemetry/agent_account_gate";
|
||||
import {
|
||||
cursorIdentityFromConfig,
|
||||
cursorSessionCookieValue,
|
||||
cursorSnapshotFromUsage,
|
||||
createCursorAccountAdapter,
|
||||
} from "../src/security_telemetry/cursor_account_adapter";
|
||||
import { primaryQuotaBelow, type AgentAccountIdentity } from "../src/security_telemetry/agent_account_adapter";
|
||||
import {
|
||||
buildTokenAlertPayload,
|
||||
postTokenAlert,
|
||||
TOKEN_ALERT_URL,
|
||||
} from "../src/security_telemetry/token_alert";
|
||||
import {
|
||||
captureHeadlessLoginUrl,
|
||||
handleSecurityAccountExhausted,
|
||||
monitorSecurityAccountAfterSuccess,
|
||||
startAgentAccountRecoveryMonitor,
|
||||
} from "../src/security_telemetry/security_account_manager";
|
||||
|
||||
const dirs: string[] = [];
|
||||
|
||||
function tempState(): string {
|
||||
const dir = mkdtempSync(path.join(tmpdir(), "streamline-agent-account-"));
|
||||
dirs.push(dir);
|
||||
return dir;
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
createCursorAccountAdapter().finishReauth();
|
||||
for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
describe("persistent agent account claim gate", () => {
|
||||
test("drains every claim loop until the persisted state is cleared", () => {
|
||||
const stateDir = tempState();
|
||||
expect(isAgentAccountClaimDrained(stateDir)).toBe(false);
|
||||
const state: AgentAccountDrainState = {
|
||||
schema_version: 1,
|
||||
provider: "cursor",
|
||||
reason: "TOKEN_EXHAUSTED",
|
||||
task_id: "sec-1",
|
||||
execution_id: "sec-1:run:1",
|
||||
phase: "run",
|
||||
cluster_name: "security-android-a",
|
||||
node_id: "sat-1",
|
||||
account: "owner@example.com",
|
||||
card_id: "sec-1:run:1",
|
||||
recovery_id: "recovery-1",
|
||||
login_url: null,
|
||||
drained_at: "2026-08-31T00:00:00.000Z",
|
||||
updated_at: "2026-08-31T00:00:00.000Z",
|
||||
};
|
||||
writeAgentAccountDrain(state, stateDir);
|
||||
expect(isAgentAccountClaimDrained(stateDir)).toBe(true);
|
||||
expect(readAgentAccountDrain(stateDir)).toMatchObject({ task_id: "sec-1", provider: "cursor" });
|
||||
updateAgentAccountDrain({ login_url: "https://cursor.example/login", updated_at: "later" }, stateDir);
|
||||
expect(readAgentAccountDrain(stateDir)?.login_url).toBe("https://cursor.example/login");
|
||||
expect(clearAgentAccountDrain(stateDir)).toBe(true);
|
||||
expect(isAgentAccountClaimDrained(stateDir)).toBe(false);
|
||||
});
|
||||
|
||||
test("fails closed when the durable gate is corrupt", () => {
|
||||
const stateDir = tempState();
|
||||
const file = path.join(stateDir, "agent-account-drain.json");
|
||||
writeFileSync(file, "{", "utf8");
|
||||
expect(isAgentAccountClaimDrained(stateDir)).toBe(true);
|
||||
expect(readAgentAccountDrain(stateDir)?.recovery_id).toBe("corrupt-state");
|
||||
});
|
||||
});
|
||||
|
||||
const identity: AgentAccountIdentity = {
|
||||
account_id: "auth0|user_abc",
|
||||
email: "owner@example.com",
|
||||
display_name: "Owner",
|
||||
organization_id: "team-1",
|
||||
organization_name: "Security",
|
||||
auth_method: "browser_login",
|
||||
plan: null,
|
||||
};
|
||||
|
||||
describe("Cursor account adapter pure contract", () => {
|
||||
test("reads identity and builds the WorkOS session cookie without logging the JWT", () => {
|
||||
expect(cursorIdentityFromConfig({
|
||||
authInfo: {
|
||||
authId: "auth0|user_abc", email: "owner@example.com", displayName: "Owner",
|
||||
teamId: 7, teamName: "Security", userId: 42,
|
||||
},
|
||||
})).toMatchObject({
|
||||
account_id: "auth0|user_abc",
|
||||
email: "owner@example.com",
|
||||
organization_id: "7",
|
||||
});
|
||||
expect(cursorSessionCookieValue("header.payload.signature", "auth0|user_abc"))
|
||||
.toBe("user_abc::header.payload.signature");
|
||||
expect(cursorSessionCookieValue("user_abc::jwt", "auth0|user_abc"))
|
||||
.toBe("user_abc::jwt");
|
||||
});
|
||||
|
||||
test("normalises legacy enterprise individual and team windows", () => {
|
||||
const snapshot = cursorSnapshotFromUsage({
|
||||
membershipType: "enterprise",
|
||||
billingCycleEnd: "2026-09-01T00:00:00.000Z",
|
||||
individualUsage: { overall: { enabled: true, used: 100_005, limit: 100_000, remaining: 0 } },
|
||||
teamUsage: { onDemand: { enabled: true, used: 915_880_392, limit: 1_031_680_000, remaining: 115_799_608 } },
|
||||
}, identity, new Date("2026-08-31T00:00:00.000Z"));
|
||||
expect(snapshot.account.plan).toBe("enterprise");
|
||||
expect(snapshot.runnable).toBe(true); // team pool is still available
|
||||
expect(primaryQuotaBelow(snapshot, 5)).toMatchObject({ scope: "individual", remaining_percent: 0 });
|
||||
});
|
||||
|
||||
test("normalises Cursor's newer Auto/API percent shape", () => {
|
||||
const snapshot = cursorSnapshotFromUsage({
|
||||
membershipType: "pro",
|
||||
billingCycleEnd: "2026-09-01T00:00:00.000Z",
|
||||
individualUsage: {
|
||||
plan: { enabled: true, autoPercentUsed: 96.5, apiPercentUsed: 20 },
|
||||
},
|
||||
}, identity);
|
||||
expect(snapshot.quotas).toEqual(expect.arrayContaining([
|
||||
expect.objectContaining({ scope: "cursor_auto_composer", remaining_percent: 3.5, primary: true }),
|
||||
expect.objectContaining({ scope: "cursor_api_usage", remaining_percent: 80, primary: true }),
|
||||
]));
|
||||
});
|
||||
|
||||
test("captures a headless login URL without waiting for authorization", async () => {
|
||||
const dir = tempState();
|
||||
const fake = path.join(dir, "cursor-agent");
|
||||
writeFileSync(fake, `#!/bin/sh
|
||||
case "$1" in
|
||||
logout) exit 0 ;;
|
||||
login) test "$NO_OPEN_BROWSER" = "1" || exit 9; printf '%s\\n' "$$" > "$CURSOR_TEST_PID_FILE"; printf 'Open https://cursor.example/authorize?id=test\\n'; sleep 30 ;;
|
||||
status|whoami) printf 'Not logged in\\n'; exit 1 ;;
|
||||
esac
|
||||
`, "utf8");
|
||||
chmodSync(fake, 0o755);
|
||||
const previous = process.env.CURSOR_BIN;
|
||||
const previousPidFile = process.env.CURSOR_TEST_PID_FILE;
|
||||
const pidFile = path.join(dir, "login.pid");
|
||||
process.env.CURSOR_BIN = fake;
|
||||
process.env.CURSOR_TEST_PID_FILE = pidFile;
|
||||
const adapter = createCursorAccountAdapter();
|
||||
try {
|
||||
expect(await adapter.beginReauth({ resetCredentials: true })).toMatchObject({
|
||||
kind: "browser_url",
|
||||
verification_uri: "https://cursor.example/authorize?id=test",
|
||||
});
|
||||
const pid = Number(readFileSync(pidFile, "utf8").trim());
|
||||
expect(() => process.kill(pid, 0)).not.toThrow();
|
||||
} finally {
|
||||
adapter.finishReauth();
|
||||
if (previous === undefined) delete process.env.CURSOR_BIN;
|
||||
else process.env.CURSOR_BIN = previous;
|
||||
if (previousPidFile === undefined) delete process.env.CURSOR_TEST_PID_FILE;
|
||||
else process.env.CURSOR_TEST_PID_FILE = previousPidFile;
|
||||
}
|
||||
});
|
||||
|
||||
test("keeps the active account while capturing an early-rotation login URL", async () => {
|
||||
const logs: string[] = [];
|
||||
const adapter = {
|
||||
id: "cursor-login",
|
||||
provider: "cursor" as const,
|
||||
readIdentity: () => identity,
|
||||
probeAccount: async () => { throw new Error("not used"); },
|
||||
beginReauth: async ({ resetCredentials }: { resetCredentials: boolean }) => {
|
||||
expect(resetCredentials).toBe(false);
|
||||
return {
|
||||
kind: "browser_url" as const,
|
||||
verification_uri: "https://cursor.example/authorize?id=warning",
|
||||
user_code: null,
|
||||
issued_at: "2026-09-10T00:00:00.000Z",
|
||||
};
|
||||
},
|
||||
checkAuth: async () => ({ state: "AUTHENTICATED" as const, account: "owner@example.com" }),
|
||||
finishReauth: () => {},
|
||||
};
|
||||
expect(await captureHeadlessLoginUrl(adapter, (_level, message) => logs.push(message)))
|
||||
.toBe("https://cursor.example/authorize?id=warning");
|
||||
expect(logs).toEqual([]);
|
||||
});
|
||||
|
||||
test("concurrent reset requests share one logout and preserve the first live login", async () => {
|
||||
const dir = tempState();
|
||||
const fake = path.join(dir, "cursor-agent");
|
||||
writeFileSync(fake, `#!/bin/sh
|
||||
printf '%s\\n' "$1" >> "$CURSOR_TEST_LOGIN_DIR/calls"
|
||||
case "$1" in
|
||||
logout) sleep 0.05; exit 0 ;;
|
||||
login) printf '%s' "$$" > "$CURSOR_TEST_LOGIN_DIR/pid"; printf 'Open https://cursor.example/authorize?id=first\\n'; exec sleep 30 ;;
|
||||
esac
|
||||
`, "utf8");
|
||||
chmodSync(fake, 0o755);
|
||||
const previousBin = process.env.CURSOR_BIN;
|
||||
const previousDir = process.env.CURSOR_TEST_LOGIN_DIR;
|
||||
process.env.CURSOR_BIN = fake;
|
||||
process.env.CURSOR_TEST_LOGIN_DIR = dir;
|
||||
const a = createCursorAccountAdapter(), b = createCursorAccountAdapter();
|
||||
try {
|
||||
const challenges = await Promise.all([
|
||||
a.beginReauth({ resetCredentials: true }),
|
||||
b.beginReauth({ resetCredentials: true }),
|
||||
]);
|
||||
challenges.push(await a.beginReauth({ resetCredentials: false }));
|
||||
challenges.push(await b.beginReauth({ resetCredentials: true }));
|
||||
expect(new Set(challenges.map((challenge) => challenge.verification_uri)).size).toBe(1);
|
||||
expect(new Set(challenges.map((challenge) => challenge.issued_at)).size).toBe(1);
|
||||
expect(readFileSync(path.join(dir, "calls"), "utf8").trim().split("\n")).toEqual(["logout", "login"]);
|
||||
expect(() => process.kill(Number(readFileSync(path.join(dir, "pid"), "utf8")), 0)).not.toThrow();
|
||||
expect(a.reauthProcessState?.()).toMatchObject({ state: "waiting" });
|
||||
} finally {
|
||||
a.finishReauth();
|
||||
if (previousBin === undefined) delete process.env.CURSOR_BIN; else process.env.CURSOR_BIN = previousBin;
|
||||
if (previousDir === undefined) delete process.env.CURSOR_TEST_LOGIN_DIR; else process.env.CURSOR_TEST_LOGIN_DIR = previousDir;
|
||||
}
|
||||
});
|
||||
|
||||
test("reads structured auth status without confusing missing account details with missing credentials", async () => {
|
||||
const dir = tempState();
|
||||
const fake = path.join(dir, "cursor-agent");
|
||||
const output = path.join(dir, "status.json");
|
||||
const configPath = path.join(dir, "cli-config.json");
|
||||
writeFileSync(configPath, JSON.stringify({ authInfo: { authId: "old", email: "stale@example.com" } }));
|
||||
writeFileSync(fake, `#!/bin/sh
|
||||
test "$1" = whoami && test "$2" = --format && test "$3" = json || exit 9
|
||||
cat "$CURSOR_TEST_STATUS_JSON"
|
||||
`, "utf8");
|
||||
chmodSync(fake, 0o755);
|
||||
const previousBin = process.env.CURSOR_BIN;
|
||||
const previousOutput = process.env.CURSOR_TEST_STATUS_JSON;
|
||||
process.env.CURSOR_BIN = fake;
|
||||
process.env.CURSOR_TEST_STATUS_JSON = output;
|
||||
const adapter = createCursorAccountAdapter({ configPath });
|
||||
try {
|
||||
writeFileSync(output, JSON.stringify({ status: "authenticated", isAuthenticated: true, userInfo: { email: "fresh@example.com" } }));
|
||||
expect(await adapter.checkAuth()).toEqual({ state: "AUTHENTICATED", account: "fresh@example.com" });
|
||||
writeFileSync(output, JSON.stringify({ status: "authenticated", isAuthenticated: true, message: "Logged in (unable to fetch user details)" }));
|
||||
expect(await adapter.checkAuth()).toEqual({ state: "AUTHENTICATED", account: null });
|
||||
writeFileSync(output, JSON.stringify({ status: "authenticated", isAuthenticated: true, userInfo: { userId: 123 } }));
|
||||
expect(await adapter.checkAuth()).toEqual({ state: "AUTHENTICATED", account: null });
|
||||
writeFileSync(output, JSON.stringify({ status: "unauthenticated", isAuthenticated: false }));
|
||||
expect(await adapter.checkAuth()).toEqual({ state: "UNAUTHENTICATED", account: null });
|
||||
writeFileSync(output, "network request failed");
|
||||
expect(await adapter.checkAuth()).toMatchObject({ state: "UNKNOWN" });
|
||||
} finally {
|
||||
if (previousBin === undefined) delete process.env.CURSOR_BIN; else process.env.CURSOR_BIN = previousBin;
|
||||
if (previousOutput === undefined) delete process.env.CURSOR_TEST_STATUS_JSON; else process.env.CURSOR_TEST_STATUS_JSON = previousOutput;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("account recovery polling", () => {
|
||||
test("API-key mode skips login and quota probes, drains on exhaustion, and resumes after key replacement", async () => {
|
||||
const dir = tempState();
|
||||
const keyFile = path.join(dir, "cursor-key");
|
||||
const old = {
|
||||
mode: process.env.STREAMLINE_CURSOR_AUTH_MODE,
|
||||
keyFile: process.env.STREAMLINE_CURSOR_API_KEY_FILE,
|
||||
stateDir: process.env.SECURITY_TELEMETRY_DIR,
|
||||
fetch: globalThis.fetch,
|
||||
};
|
||||
process.env.STREAMLINE_CURSOR_AUTH_MODE = "api-key";
|
||||
process.env.STREAMLINE_CURSOR_API_KEY_FILE = keyFile;
|
||||
process.env.SECURITY_TELEMETRY_DIR = dir;
|
||||
writeFileSync(keyFile, "first-key\n", { mode: 0o600 });
|
||||
const calls: string[] = [];
|
||||
globalThis.fetch = (async () => { calls.push("fetch"); throw new Error("unexpected HTTP request"); }) as typeof fetch;
|
||||
const adapter = {
|
||||
...createCursorAccountAdapter(),
|
||||
readIdentity: () => { calls.push("identity"); return null; },
|
||||
probeAccount: async () => { calls.push("quota"); throw new Error("unexpected quota probe"); },
|
||||
beginReauth: async () => { calls.push("login"); throw new Error("unexpected login"); },
|
||||
checkAuth: async () => { calls.push("whoami"); return { state: "UNAUTHENTICATED" as const, account: null }; },
|
||||
onReauthProcessExit: () => { calls.push("subscribe"); return () => {}; },
|
||||
};
|
||||
const now = new Date().toISOString();
|
||||
writeAgentAccountDrain({
|
||||
schema_version: 1, provider: "cursor", reason: "TOKEN_READ_FAILED", task_id: "old",
|
||||
execution_id: "old:run:1", phase: "run", cluster_name: "pns", node_id: "sat-1",
|
||||
account: "old", card_id: "old", recovery_id: "old", login_url: null, drained_at: now, updated_at: now,
|
||||
});
|
||||
const oldState = readAgentAccountDrain()!;
|
||||
const stop = startAgentAccountRecoveryMonitor(() => {}, 10, { adapter });
|
||||
const context = { security: { id: "sec-api", attempts: 0, clusters: ["pns"] }, phase: "run" as const, provider: "cursor" as const, nodeId: "sat-1" };
|
||||
try {
|
||||
for (let i = 0; i < 50 && readAgentAccountDrain(); i++) await Bun.sleep(10);
|
||||
expect(readAgentAccountDrain()).toBeNull();
|
||||
writeAgentAccountDrain({ ...oldState, reason: "TOKEN_DWINDLING" });
|
||||
expect(isAgentAccountClaimDrained()).toBe(false);
|
||||
for (let i = 0; i < 50 && readAgentAccountDrain(); i++) await Bun.sleep(10);
|
||||
expect(readAgentAccountDrain()).toBeNull();
|
||||
await monitorSecurityAccountAfterSuccess(context, () => {}, adapter);
|
||||
await handleSecurityAccountExhausted(context, "usage_limit_exceeded", () => {});
|
||||
const drained = readAgentAccountDrain();
|
||||
expect(drained).toMatchObject({ reason: "TOKEN_EXHAUSTED", task_id: "sec-api", login_url: null });
|
||||
expect(drained?.api_key_fingerprint).toMatch(/^[0-9a-f]{64}$/);
|
||||
expect(JSON.stringify(drained)).not.toContain("first-key");
|
||||
expect(isAgentAccountClaimDrained()).toBe(true);
|
||||
await Bun.sleep(30);
|
||||
expect(isAgentAccountClaimDrained()).toBe(true);
|
||||
writeFileSync(keyFile, "replacement-key\n");
|
||||
for (let i = 0; i < 50 && isAgentAccountClaimDrained(); i++) await Bun.sleep(10);
|
||||
expect(isAgentAccountClaimDrained()).toBe(false);
|
||||
expect(calls).toEqual([]);
|
||||
} finally {
|
||||
stop();
|
||||
globalThis.fetch = old.fetch;
|
||||
if (old.mode === undefined) delete process.env.STREAMLINE_CURSOR_AUTH_MODE; else process.env.STREAMLINE_CURSOR_AUTH_MODE = old.mode;
|
||||
if (old.keyFile === undefined) delete process.env.STREAMLINE_CURSOR_API_KEY_FILE; else process.env.STREAMLINE_CURSOR_API_KEY_FILE = old.keyFile;
|
||||
if (old.stateDir === undefined) delete process.env.SECURITY_TELEMETRY_DIR; else process.env.SECURITY_TELEMETRY_DIR = old.stateDir;
|
||||
}
|
||||
});
|
||||
|
||||
test("a restored login clears the global gate so all task types may claim again", async () => {
|
||||
const dir = tempState();
|
||||
const fake = path.join(dir, "cursor-agent");
|
||||
writeFileSync(fake, `#!/bin/sh
|
||||
if [ "$1" = whoami ]; then printf '✓ Logged in as restored@example.com\\n'; exit 0; fi
|
||||
exit 0
|
||||
`, "utf8");
|
||||
chmodSync(fake, 0o755);
|
||||
const previousBin = process.env.CURSOR_BIN;
|
||||
const previousState = process.env.SECURITY_TELEMETRY_DIR;
|
||||
process.env.CURSOR_BIN = fake;
|
||||
process.env.SECURITY_TELEMETRY_DIR = dir;
|
||||
writeAgentAccountDrain({
|
||||
schema_version: 1,
|
||||
provider: "cursor",
|
||||
reason: "TOKEN_EXHAUSTED",
|
||||
task_id: "sec-restore",
|
||||
execution_id: "sec-restore:run:1",
|
||||
phase: "run",
|
||||
cluster_name: "security",
|
||||
node_id: "sat-1",
|
||||
account: "old@example.com",
|
||||
card_id: "sec-restore:run:1",
|
||||
recovery_id: "recovery-restore",
|
||||
login_url: null,
|
||||
drained_at: new Date().toISOString(),
|
||||
updated_at: new Date().toISOString(),
|
||||
});
|
||||
const logs: string[] = [];
|
||||
const stop = startAgentAccountRecoveryMonitor((_level, message) => logs.push(message), 10, {
|
||||
adapter: {
|
||||
...createCursorAccountAdapter(),
|
||||
async probeAccount() {
|
||||
return cursorSnapshotFromUsage({
|
||||
individualUsage: { overall: { enabled: true, used: 20, limit: 100, remaining: 80 } },
|
||||
}, { ...identity, email: "restored@example.com" });
|
||||
},
|
||||
},
|
||||
});
|
||||
try {
|
||||
for (let i = 0; i < 40 && isAgentAccountClaimDrained(); i++) await Bun.sleep(50);
|
||||
expect(isAgentAccountClaimDrained()).toBe(false);
|
||||
expect(logs.some((message) => message.includes("global task claiming resumed"))).toBe(true);
|
||||
} finally {
|
||||
stop();
|
||||
if (previousBin === undefined) delete process.env.CURSOR_BIN;
|
||||
else process.env.CURSOR_BIN = previousBin;
|
||||
if (previousState === undefined) delete process.env.SECURITY_TELEMETRY_DIR;
|
||||
else process.env.SECURITY_TELEMETRY_DIR = previousState;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("token alert contract", () => {
|
||||
test("uses the temporary security alert service", () => {
|
||||
expect(TOKEN_ALERT_URL).toBe("http://10.37.81.28:3100/api/v1/lark-card");
|
||||
});
|
||||
|
||||
test("puts every server-required field in card_info.message and redacts credentials", () => {
|
||||
const payload = buildTokenAlertPayload({
|
||||
eventType: "TOKEN_EXHAUSTED",
|
||||
alertLevel: "critical",
|
||||
taskId: "sec-1",
|
||||
executionId: "sec-1:run:1",
|
||||
phase: "run",
|
||||
clusterName: "security-android-a",
|
||||
nodeId: "sat-1",
|
||||
provider: "cursor",
|
||||
account: identity,
|
||||
loginUrl: "https://cursor.example/login",
|
||||
reason: "Bearer secret-token eyJabc.def.ghi",
|
||||
}, new Date("2026-08-31T00:00:00.000Z"));
|
||||
expect(payload).toMatchObject({
|
||||
schema_version: 1,
|
||||
occurred_at: "2026-08-31T00:00:00.000Z",
|
||||
alert_level: "critical",
|
||||
card_info: { source: "streamline" },
|
||||
});
|
||||
expect(payload.card_info.card_id).toMatch(/^sec-1:run:1:[0-9a-f-]{36}$/);
|
||||
const message = payload.card_info.message;
|
||||
for (const value of [
|
||||
"event_type=TOKEN_EXHAUSTED", "cluster_name=security-android-a", "node_id=sat-1",
|
||||
"agent_type=cursor", "current_account=owner@example.com", "login_url=https://cursor.example/login",
|
||||
]) expect(message).toContain(value);
|
||||
expect(message).not.toContain("secret-token");
|
||||
expect(message).not.toContain("eyJabc.def.ghi");
|
||||
});
|
||||
|
||||
test("generates a fresh card id for every lark-card request body", () => {
|
||||
const context = {
|
||||
eventType: "TOKEN_EXHAUSTED" as const,
|
||||
alertLevel: "critical" as const,
|
||||
taskId: "sec-1",
|
||||
executionId: "sec-1:run:1",
|
||||
phase: "run" as const,
|
||||
clusterName: "security-android-a",
|
||||
nodeId: "sat-1",
|
||||
provider: "cursor" as const,
|
||||
account: identity,
|
||||
loginUrl: "https://cursor.example/login",
|
||||
};
|
||||
const first = buildTokenAlertPayload(context, new Date("2026-08-31T00:00:00.000Z"));
|
||||
const second = buildTokenAlertPayload(context, new Date("2026-08-31T00:00:00.000Z"));
|
||||
expect(first.card_info.card_id).not.toBe(second.card_info.card_id);
|
||||
expect(first.card_info.card_id.startsWith("sec-1:run:1:")).toBe(true);
|
||||
expect(second.card_info.card_id.startsWith("sec-1:run:1:")).toBe(true);
|
||||
});
|
||||
|
||||
test("uses a valid Cursor login page when a warning has no generated URL", () => {
|
||||
const payload = buildTokenAlertPayload({
|
||||
eventType: "TOKEN_DWINDLING",
|
||||
alertLevel: "warning",
|
||||
taskId: "sec-low",
|
||||
executionId: "sec-low:run:1",
|
||||
phase: "run",
|
||||
clusterName: "default",
|
||||
nodeId: "sat-low",
|
||||
provider: "cursor",
|
||||
account: identity,
|
||||
quota: null,
|
||||
loginUrl: null,
|
||||
});
|
||||
expect(payload.card_info.message).toContain("login_url=https://cursor.com/login");
|
||||
expect(payload.card_info.message).not.toContain("login_url=not_generated");
|
||||
});
|
||||
|
||||
test("posts the exact lark-card request body", async () => {
|
||||
const payload = buildTokenAlertPayload({
|
||||
eventType: "TOKEN_READ_FAILED",
|
||||
alertLevel: "warning",
|
||||
taskId: "sec-2",
|
||||
executionId: "sec-2:evaluate:1",
|
||||
phase: "evaluate",
|
||||
clusterName: "default",
|
||||
nodeId: "sat-2",
|
||||
provider: "cursor",
|
||||
account: identity,
|
||||
reason: "keychain unavailable",
|
||||
});
|
||||
let seen: { url: string; body: string } | null = null;
|
||||
const fakeFetch = (async (input: string | URL | Request, init?: RequestInit) => {
|
||||
seen = {
|
||||
url: String(input),
|
||||
body: String(init?.body || ""),
|
||||
};
|
||||
return new Response("", { status: 204 });
|
||||
}) as typeof fetch;
|
||||
expect(await postTokenAlert(payload, { fetchImpl: fakeFetch })).toEqual({ ok: true, error: null });
|
||||
expect(seen).toEqual({
|
||||
url: TOKEN_ALERT_URL,
|
||||
body: JSON.stringify(payload),
|
||||
});
|
||||
});
|
||||
|
||||
test("turns lark-card connection failures into a non-throwing result", async () => {
|
||||
const payload = buildTokenAlertPayload({
|
||||
eventType: "TOKEN_DWINDLING",
|
||||
alertLevel: "warning",
|
||||
taskId: "sec-3",
|
||||
executionId: "sec-3:run:1",
|
||||
phase: "run",
|
||||
clusterName: "default",
|
||||
nodeId: "sat-3",
|
||||
provider: "cursor",
|
||||
account: identity,
|
||||
});
|
||||
const failingFetch = (async () => {
|
||||
throw new Error("connection refused");
|
||||
}) as typeof fetch;
|
||||
expect(await postTokenAlert(payload, { fetchImpl: failingFetch })).toEqual({
|
||||
ok: false,
|
||||
error: "connection refused",
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user