recess-cli 1.9.2 → 2.0.0

package/dist/command-schema.js

@@ -0,0 +1,257 @@
+import { CliError } from "./errors.js";
+export const AGENT_CONTEXT_SCHEMA_VERSION = "3";
+const BOOLEAN_FLAGS = new Set([
+    "all-references",
+    "allow-strand",
+    "archived",
+    "cancel-subscriptions",
+    "confirm",
+    "confirm-destructive-changes",
+    "disable-applet-follow-ups",
+    "dry-run",
+    "enable-applet-follow-ups",
+    "full",
+    "help",
+    "immediate",
+    "include-deleted",
+    "json",
+    "mirrored",
+    "no-collision",
+    "no-invite",
+    "refresh",
+    "restore",
+    "revoke",
+    "send-email",
+    "skill-only",
+    "spec-only",
+    "starter-only",
+    "visual-only",
+    "wait",
+]);
+const REPEATABLE_FLAGS = new Set(["kid", "unassign"]);
+const GLOBAL_FLAGS = new Set([
+    "deliver",
+    "help",
+    "json",
+    "operation-key",
+    "profile",
+    "reason",
+]);
+const GLOBAL_FLAG_TYPES = {
+    deliver: "string",
+    help: "boolean",
+    json: "boolean",
+    "operation-key": "string",
+    profile: "string",
+    reason: "string",
+};
+function usageBlocks(help) {
+    const lines = help.split("\n");
+    const blocks = [];
+    let current = null;
+    for (const line of lines) {
+        if (line.startsWith("  recess ")) {
+            if (current)
+                blocks.push(current.join(" ").replace(/\s+/g, " ").trim());
+            current = [line.trim()];
+            continue;
+        }
+        if (current && /^\s{4,}\S/.test(line)) {
+            current.push(line.trim());
+            continue;
+        }
+        if (current) {
+            blocks.push(current.join(" ").replace(/\s+/g, " ").trim());
+            current = null;
+        }
+    }
+    if (current)
+        blocks.push(current.join(" ").replace(/\s+/g, " ").trim());
+    return blocks;
+}
+function commandPath(usage) {
+    const rest = usage.replace(/^recess\s+(?:\[--json\]\s+)?/, "");
+    const tokens = rest.split(/\s+/);
+    const path = [];
+    for (const token of tokens) {
+        if (token.startsWith("--") ||
+            token.startsWith("[") ||
+            token.startsWith("<") ||
+            token.startsWith("(") ||
+            token.startsWith('"')) {
+            break;
+        }
+        path.push(token);
+    }
+    if (path.length === 0 && rest.startsWith("--version"))
+        return [["--version"]];
+    let variants = [[]];
+    for (const token of path) {
+        const choices = token.split("|");
+        variants = variants.flatMap((prefix) => choices.map((choice) => [...prefix, choice]));
+    }
+    return variants;
+}
+function flagValues(usage, name) {
+    const match = usage.match(new RegExp(`--${name}(?:[ =])([A-Za-z0-9_-]+(?:\\|[A-Za-z0-9_-]+)+)`));
+    return match?.[1]?.split("|");
+}
+function flagIsIndividuallyRequired(usage, name) {
+    const marker = `--${name}`;
+    let squareDepth = 0;
+    let parenDepth = 0;
+    for (let index = 0; index < usage.length; index += 1) {
+        const character = usage[index];
+        if (character === "[")
+            squareDepth += 1;
+        if (character === "]")
+            squareDepth = Math.max(0, squareDepth - 1);
+        if (character === "(")
+            parenDepth += 1;
+        if (character === ")")
+            parenDepth = Math.max(0, parenDepth - 1);
+        if (usage.startsWith(marker, index) &&
+            !/[a-z0-9-]/.test(usage[index + marker.length] ?? "") &&
+            squareDepth === 0 &&
+            parenDepth === 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function positionalBounds(usage) {
+    const rest = usage.replace(/^recess\s+(?:\[--json\]\s+)?/, "");
+    const tokens = rest.split(/\s+/);
+    let count = 0;
+    let variadic = false;
+    for (const token of tokens) {
+        if (token.startsWith("--") ||
+            token.startsWith("[") ||
+            token.startsWith("(")) {
+            break;
+        }
+        count += 1;
+        if (/^<[^,>]+\.\.\.>$/.test(token))
+            variadic = true;
+    }
+    return { min: count, max: variadic ? null : count };
+}
+export function buildCommandSchema(help) {
+    return usageBlocks(help).flatMap((usage) => {
+        const names = Array.from(usage.matchAll(/--([a-z][a-z0-9-]*)/g)).map((match) => match[1]);
+        const flags = Object.fromEntries(Array.from(new Set(names)).map((name) => [
+            name,
+            {
+                type: BOOLEAN_FLAGS.has(name) ? "boolean" : "string",
+                repeatable: REPEATABLE_FLAGS.has(name),
+                required: flagIsIndividuallyRequired(usage, name),
+                ...(flagValues(usage, name)
+                    ? { values: flagValues(usage, name) }
+                    : {}),
+            },
+        ]));
+        const positionals = positionalBounds(usage);
+        return commandPath(usage).map((path) => ({
+            path,
+            usage,
+            flags,
+            positionals,
+        }));
+    });
+}
+function pathStartsWith(path, prefix) {
+    return prefix.every((part, index) => path[index] === part);
+}
+export function findCommandSchema(commands, positionals) {
+    return commands
+        .filter((command) => pathStartsWith(positionals, command.path))
+        .sort((left, right) => right.path.length - left.path.length)[0];
+}
+export function scopedHelp(help, commands, scope) {
+    if (scope.length === 0)
+        return help;
+    const matches = commands.filter((command) => pathStartsWith(command.path, scope));
+    if (matches.length === 0) {
+        throw new CliError("unknown_command", `Unknown command scope: ${scope.join(" ")}. Run \`recess --help\` for available commands.`);
+    }
+    return [
+        `recess ${scope.join(" ")} — command help`,
+        "",
+        "Usage:",
+        ...Array.from(new Set(matches.map((command) => `  ${command.usage}`))),
+    ].join("\n");
+}
+export function validateInvocation(parsed, commands) {
+    const command = findCommandSchema(commands, parsed.positionals);
+    if (!command) {
+        const scope = parsed.positionals.join(" ");
+        const first = parsed.positionals[0];
+        const suggestions = commands
+            .filter((candidate) => !first || candidate.path[0] === first)
+            .slice(0, 12)
+            .map((candidate) => candidate.path.join(" "));
+        throw new CliError("unknown_command", `Unknown command: ${scope || "(none)"}.`, 1, suggestions.length > 0 ? { suggestions } : undefined);
+    }
+    const allowed = new Set([...Object.keys(command.flags), ...GLOBAL_FLAGS]);
+    const unknown = Array.from(parsed.flags.keys()).filter((name) => name !== "version" && !allowed.has(name));
+    if (unknown.length > 0) {
+        const validFlags = Array.from(allowed)
+            .sort()
+            .map((name) => `--${name}`);
+        throw new CliError("unknown_flag", `Unknown flag${unknown.length === 1 ? "" : "s"}: ${unknown
+            .map((name) => `--${name}`)
+            .join(", ")}.`, 1, { usage: command.usage, validFlags });
+    }
+    const duplicate = Array.from(parsed.occurrences).find(([name, count]) => count > 1 && !command.flags[name]?.repeatable);
+    if (duplicate) {
+        throw new CliError("duplicate_flag", `--${duplicate[0]} may only be passed once.`, 1, { usage: command.usage });
+    }
+    const positionalCount = parsed.positionals.length;
+    if (positionalCount < command.positionals.min ||
+        (command.positionals.max !== null &&
+            positionalCount > command.positionals.max)) {
+        throw new CliError("invalid_arguments", `Wrong number of positional arguments for ${command.path.join(" ")}.`, 1, { usage: command.usage });
+    }
+    for (const [name, value] of parsed.flags) {
+        const type = command.flags[name]?.type ?? GLOBAL_FLAG_TYPES[name];
+        if (type === "boolean" && value !== true) {
+            throw new CliError("invalid_arguments", `--${name} is a boolean flag and does not take a value.`, 1, { usage: command.usage });
+        }
+        if (type === "string" && value === true) {
+            throw new CliError("invalid_arguments", `--${name} requires a value.`, 1, { usage: command.usage });
+        }
+    }
+    return command;
+}
+export function agentContext(commands, options) {
+    return {
+        schema_version: AGENT_CONTEXT_SCHEMA_VERSION,
+        cli_version: options.cliVersion,
+        commands: Object.fromEntries(commands
+            .filter((command) => command.path[0] !== "--version")
+            .map((command) => [
+            command.path.join(" "),
+            {
+                usage: command.usage,
+                flags: command.flags,
+                positionals: command.positionals,
+            },
+        ])),
+        global_flags: {
+            "--json": { type: "boolean" },
+            "--profile": { type: "string" },
+            "--operation-key": { type: "string" },
+            "--reason": {
+                type: "string",
+                required_for: "every Recess API request except authentication",
+                max_length: 1024,
+            },
+            "--deliver": { type: "enum", values: ["stdout", "file:<path>"] },
+            "--help": { type: "boolean" },
+        },
+        available_profiles: options.availableProfiles,
+        jobs: { commands: ["jobs list", "jobs get", "jobs prune"] },
+        feedback: { upstream_configured: options.feedbackUpstreamConfigured },
+    };
+}
+//# sourceMappingURL=command-schema.js.map

package/dist/config.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { CliError } from "./errors.js";
 export const DEFAULT_OAUTH_CLIENT_ID = "c7e34138-18f9-45b1-a2fb-26a4e3a6d739";
 export function defaultConfigPath() {
     return (process.env.RECESS_CLI_CONFIG ??
@@ -16,32 +17,111 @@ export async function readStoredConfig(configPath = defaultConfigPath()) {
         throw error;
     }
 }
-export async function resolveConfig() {
+export async function resolveConfig(profileName) {
     const configPath = defaultConfigPath();
     const stored = await readStoredConfig(configPath);
+    const selectedProfileName = profileName ?? process.env.RECESS_CLI_PROFILE ?? stored.activeProfile;
+    const profile = selectedProfileName
+        ? stored.profiles?.[selectedProfileName]
+        : undefined;
+    if (selectedProfileName && !profile) {
+        throw new CliError("unknown_profile", `Unknown Recess CLI profile ${selectedProfileName}. Run \`recess --json profile list\`.`);
+    }
     const envCookie = process.env.RECESS_CLI_COOKIE;
-    const sessionCookie = envCookie ?? stored.sessionCookie;
+    const sessionCookie = envCookie ??
+        (selectedProfileName ? profile?.sessionCookie : stored.sessionCookie);
     return {
         configPath,
         apiOrigin: process.env.RECESS_CLI_API_ORIGIN ??
+            profile?.apiOrigin ??
             stored.apiOrigin ??
             "https://api.recess.gg",
         webOrigin: process.env.RECESS_CLI_WEB_ORIGIN ??
+            profile?.webOrigin ??
             stored.webOrigin ??
             "https://recess.gg",
         oauthClientId: process.env.RECESS_CLI_OAUTH_CLIENT_ID ??
+            profile?.oauthClientId ??
             stored.oauthClientId ??
             DEFAULT_OAUTH_CLIENT_ID,
         sessionCookie,
-        sessionExpiresAt: stored.sessionExpiresAt,
-        user: stored.user,
+        sessionExpiresAt: selectedProfileName
+            ? profile?.sessionExpiresAt
+            : stored.sessionExpiresAt,
+        user: selectedProfileName ? profile?.user : stored.user,
         authSource: envCookie ? "env" : sessionCookie ? "config" : "missing",
-        pendingDeviceCode: stored.pendingDeviceCode,
-        pendingUserCode: stored.pendingUserCode,
-        pendingApprovalUrl: stored.pendingApprovalUrl,
-        pendingExpiresAt: stored.pendingExpiresAt,
+        pendingDeviceCode: selectedProfileName
+            ? profile?.pendingDeviceCode
+            : stored.pendingDeviceCode,
+        pendingUserCode: selectedProfileName
+            ? profile?.pendingUserCode
+            : stored.pendingUserCode,
+        pendingApprovalUrl: selectedProfileName
+            ? profile?.pendingApprovalUrl
+            : stored.pendingApprovalUrl,
+        pendingExpiresAt: selectedProfileName
+            ? profile?.pendingExpiresAt
+            : stored.pendingExpiresAt,
+        profileName: selectedProfileName,
+    };
+}
+export function assertProfileName(name) {
+    const normalized = name.trim();
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(normalized)) {
+        throw new CliError("invalid_arguments", "Profile names must be 1-64 letters, numbers, underscores, or hyphens.");
+    }
+    return normalized;
+}
+export async function listProfiles() {
+    const stored = await readStoredConfig();
+    return {
+        activeProfile: stored.activeProfile ?? null,
+        profiles: Object.entries(stored.profiles ?? {})
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, config]) => ({
+            name,
+            config: {
+                apiOrigin: config.apiOrigin,
+                webOrigin: config.webOrigin,
+                oauthClientId: config.oauthClientId,
+            },
+        })),
     };
 }
+export async function saveProfile(name, profile) {
+    const normalized = assertProfileName(name);
+    const stored = await readStoredConfig();
+    await writeStoredConfig({
+        ...stored,
+        profiles: {
+            ...stored.profiles,
+            [normalized]: {
+                ...stored.profiles?.[normalized],
+                ...profile,
+            },
+        },
+    });
+}
+export async function useProfile(name) {
+    const normalized = assertProfileName(name);
+    const stored = await readStoredConfig();
+    if (!stored.profiles?.[normalized]) {
+        throw new CliError("unknown_profile", `Unknown Recess CLI profile ${normalized}. Run \`recess --json profile list\`.`);
+    }
+    await writeStoredConfig({ ...stored, activeProfile: normalized });
+}
+export async function deleteProfile(name) {
+    const normalized = assertProfileName(name);
+    const stored = await readStoredConfig();
+    if (!stored.profiles?.[normalized]) {
+        throw new CliError("unknown_profile", `Unknown Recess CLI profile ${normalized}.`);
+    }
+    const profiles = { ...stored.profiles };
+    delete profiles[normalized];
+    if (stored.activeProfile === normalized)
+        delete stored.activeProfile;
+    await writeStoredConfig({ ...stored, profiles });
+}
 export async function writeStoredConfig(config, configPath = defaultConfigPath()) {
     const directory = path.dirname(configPath);
     await fs.mkdir(directory, { recursive: true, mode: 0o700 });
@@ -52,28 +132,45 @@ export async function writeStoredConfig(config, configPath = defaultConfigPath()
     await fs.rename(temporary, configPath);
     await fs.chmod(configPath, 0o600);
 }
-export async function updateStoredConfig(update) {
+export async function updateStoredConfig(update, profileName) {
     const configPath = defaultConfigPath();
     const current = await readStoredConfig(configPath);
-    const next = { ...current, ...update };
+    const next = profileName
+        ? {
+            ...current,
+            profiles: {
+                ...current.profiles,
+                [assertProfileName(profileName)]: {
+                    ...current.profiles?.[profileName],
+                    ...update,
+                },
+            },
+        }
+        : { ...current, ...update };
     await writeStoredConfig(next, configPath);
     return next;
 }
-export async function clearStoredSession() {
+export async function clearStoredSession(profileName) {
     const configPath = defaultConfigPath();
     const current = await readStoredConfig(configPath);
-    delete current.sessionCookie;
-    delete current.sessionExpiresAt;
-    delete current.user;
+    const target = profileName ? current.profiles?.[profileName] : current;
+    if (!target)
+        return;
+    delete target.sessionCookie;
+    delete target.sessionExpiresAt;
+    delete target.user;
     await writeStoredConfig(current, configPath);
 }
-export async function clearPendingDeviceAuth() {
+export async function clearPendingDeviceAuth(profileName) {
     const configPath = defaultConfigPath();
     const current = await readStoredConfig(configPath);
-    delete current.pendingDeviceCode;
-    delete current.pendingUserCode;
-    delete current.pendingApprovalUrl;
-    delete current.pendingExpiresAt;
+    const target = profileName ? current.profiles?.[profileName] : current;
+    if (!target)
+        return;
+    delete target.pendingDeviceCode;
+    delete target.pendingUserCode;
+    delete target.pendingApprovalUrl;
+    delete target.pendingExpiresAt;
     await writeStoredConfig(current, configPath);
 }
 //# sourceMappingURL=config.js.map

package/dist/delivery.js

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CliError } from "./errors.js";
+export async function deliverJson(destination, envelope) {
+    if (!destination || destination === "stdout")
+        return { delivered: false };
+    if (!destination.startsWith("file:")) {
+        throw new CliError("invalid_delivery", "--deliver must be one of: stdout, file:<path>. Webhook delivery is deliberately unavailable for authenticated Recess data.");
+    }
+    const requestedPath = destination.slice("file:".length);
+    if (!requestedPath) {
+        throw new CliError("invalid_delivery", "file: delivery requires a path.");
+    }
+    const absolutePath = path.resolve(requestedPath);
+    const bytes = Buffer.from(`${JSON.stringify(envelope)}\n`, "utf8");
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true, mode: 0o700 });
+    const temporary = `${absolutePath}.${process.pid}.tmp`;
+    await fs.writeFile(temporary, bytes, { mode: 0o600 });
+    await fs.rename(temporary, absolutePath);
+    return {
+        delivered: true,
+        deliveredTo: `file:${absolutePath}`,
+        bytes: bytes.byteLength,
+    };
+}
+//# sourceMappingURL=delivery.js.map

package/dist/feedback.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CliError } from "./errors.js";
+function feedbackPath() {
+    return (process.env.RECESS_CLI_FEEDBACK_PATH ??
+        path.join(os.homedir(), ".recess-cli", "feedback.jsonl"));
+}
+async function readFeedback() {
+    try {
+        return (await fs.readFile(feedbackPath(), "utf8"))
+            .split("\n")
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function listFeedback(limit = 20) {
+    const entries = (await readFeedback()).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+    return {
+        entries: entries.slice(0, limit),
+        truncated: entries.length > limit,
+    };
+}
+export async function submitFeedback(entry) {
+    const existing = (await readFeedback()).find((item) => item.id === entry.id);
+    if (existing)
+        return existing;
+    const endpoint = process.env.RECESS_CLI_FEEDBACK_ENDPOINT;
+    let upstreamStatus;
+    if (endpoint) {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "idempotency-key": entry.id,
+            },
+            body: JSON.stringify(entry),
+            signal: AbortSignal.timeout(10_000),
+        });
+        upstreamStatus = response.status;
+        if (!response.ok) {
+            throw new CliError("feedback_delivery_failed", `Feedback endpoint returned HTTP ${response.status}. Retry the unchanged command with the same operation key.`);
+        }
+    }
+    const saved = { ...entry, ...(upstreamStatus ? { upstreamStatus } : {}) };
+    const file = feedbackPath();
+    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await fs.appendFile(file, `${JSON.stringify(saved)}\n`, { mode: 0o600 });
+    await fs.chmod(file, 0o600);
+    return saved;
+}
+//# sourceMappingURL=feedback.js.map

package/dist/http.js

@@ -0,0 +1,25 @@
+import { CliError } from "./errors.js";
+export const RECESS_CLIENT_HEADER = "x-recess-client";
+export const RECESS_CLIENT_CLI = "cli";
+export const RECESS_CLIENT_CLI_UI = "cli-ui";
+export const RECESS_REASON_HEADER = "x-recess-reason";
+export function requireCliRequestReason(value) {
+    const reason = value?.trim();
+    if (!reason) {
+        throw new CliError("invalid_arguments", "Missing required --reason.");
+    }
+    if (reason.length > 1024) {
+        throw new CliError("invalid_arguments", "--reason must be 1024 characters or fewer.");
+    }
+    return reason;
+}
+export function markCliRequest(headers, reason, client = RECESS_CLIENT_CLI) {
+    headers.set(RECESS_CLIENT_HEADER, client);
+    if (reason)
+        headers.set(RECESS_REASON_HEADER, reason);
+    return headers;
+}
+export function cliRequestHeaders(init, reason, client = RECESS_CLIENT_CLI) {
+    return markCliRequest(new Headers(init), reason, client);
+}
+//# sourceMappingURL=http.js.map

package/dist/index.js

@@ -2,6 +2,7 @@
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "./args.js";
 import { runCommand } from "./cli.js";
+import { deliverJson } from "./delivery.js";
 import { CliError } from "./errors.js";
 async function withInteractiveAdmissionStage(args) {
     const parsed = parseArgs(args);
@@ -38,7 +39,8 @@ async function withInteractiveAdmissionStage(args) {
     }
 }
 const argv = await withInteractiveAdmissionStage(process.argv.slice(2));
-const json = argv.includes("--json");
+const parsedArgv = parseArgs(argv);
+const json = parsedArgv.flags.has("json");
 // The interactive console owns the terminal, so it runs before the JSON
 // envelope machinery rather than through it.
 if (argv[0] === "ui") {
@@ -57,11 +59,21 @@ if (argv[0] === "ui") {
 }
 try {
     const data = await runCommand(argv);
-    if (typeof data === "object" && data && "help" in data && !json) {
+    const destination = parsedArgv.flags.get("deliver");
+    if (destination === true) {
+        throw new CliError("invalid_delivery", "--deliver requires a value.");
+    }
+    const envelope = { ok: true, data };
+    const delivery = await deliverJson(destination, envelope);
+    if (delivery.delivered) {
+        const acknowledgement = { ok: true, data: delivery };
+        process.stdout.write(`${json ? JSON.stringify(acknowledgement) : JSON.stringify(acknowledgement.data, null, 2)}\n`);
+    }
+    else if (typeof data === "object" && data && "help" in data && !json) {
         process.stdout.write(`${String(data.help)}\n`);
     }
     else if (json) {
-        process.stdout.write(`${JSON.stringify({ ok: true, data })}\n`);
+        process.stdout.write(`${JSON.stringify(envelope)}\n`);
     }
     else {
         process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);

package/dist/jobs.js

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function jobsPath() {
+    return (process.env.RECESS_CLI_JOBS_PATH ??
+        path.join(os.homedir(), ".recess-cli", "jobs.jsonl"));
+}
+async function readEvents() {
+    try {
+        return (await fs.readFile(jobsPath(), "utf8"))
+            .split("\n")
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function appendJobEvent(event) {
+    const file = jobsPath();
+    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    let stored = event;
+    const serialized = JSON.stringify(stored);
+    if (serialized.length > 64 * 1024 && event.result !== undefined) {
+        stored = {
+            ...event,
+            result: {
+                omitted: true,
+                reason: "Result exceeded the 64 KiB local job-ledger limit.",
+                bytes: Buffer.byteLength(serialized),
+            },
+        };
+    }
+    await fs.appendFile(file, `${JSON.stringify(stored)}\n`, { mode: 0o600 });
+    await fs.chmod(file, 0o600);
+}
+function foldJobs(events) {
+    const jobs = new Map();
+    for (const event of events) {
+        const prior = jobs.get(event.jobId);
+        jobs.set(event.jobId, { ...event, events: (prior?.events ?? 0) + 1 });
+    }
+    return Array.from(jobs.values()).sort((left, right) => right.timestamp.localeCompare(left.timestamp));
+}
+export async function listJobs(limit = 20) {
+    const jobs = foldJobs(await readEvents());
+    return {
+        jobs: jobs.slice(0, limit),
+        truncated: jobs.length > limit,
+        total: jobs.length,
+    };
+}
+export async function getJob(jobId) {
+    const history = (await readEvents()).filter((event) => event.jobId === jobId);
+    return { job: foldJobs(history)[0] ?? null, history };
+}
+export async function pruneJobs(olderThanDays) {
+    const events = await readEvents();
+    const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+    const kept = events.filter((event) => Date.parse(event.timestamp) >= cutoff);
+    const file = jobsPath();
+    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.tmp`;
+    await fs.writeFile(temporary, kept.length > 0
+        ? `${kept.map((event) => JSON.stringify(event)).join("\n")}\n`
+        : "", { mode: 0o600 });
+    await fs.rename(temporary, file);
+    await fs.chmod(file, 0o600);
+    return { removed: events.length - kept.length, remaining: kept.length };
+}
+//# sourceMappingURL=jobs.js.map