@kammcs/buildit-mcp 0.2.0 → 0.8.0

package/dist/capabilities.js

@@ -0,0 +1,236 @@
+/**
+ * Capability tags: what this computer can do for work that has Needs
+ * (macos, ios, flutter...), suggested to buildIt.Social at connect and when
+ * a channel session starts. The owner confirms the tags that count, in the
+ * app; a session only ever suggests.
+ *
+ * Detection is cheap and never fails: the operating system from
+ * process.platform, and toolchains by looking for known programs on the
+ * PATH, or for a known folder, without running anything. Every probe has a
+ * time limit, and a probe that fails or runs out of time means "not found".
+ * Only tag names from the fixed list below ever leave the machine: never a
+ * path, a version or any other detail of what was found.
+ */
+import { constants } from 'node:fs';
+import { access, readlink, stat } from 'node:fs/promises';
+import { posix, win32 } from 'node:path';
+/** The suggested tags (the app keeps the same list). Tags stay free-form. */
+export const SUGGESTED_CAPABILITIES = [
+    'windows',
+    'macos',
+    'linux',
+    'ios',
+    'android',
+    'xcode',
+    'flutter',
+    'docker',
+    'rust',
+    'web',
+    'gpu',
+];
+/** A tag once normalised: lower case, a letter or digit, then up to 31 of a-z 0-9 + . _ - */
+export const CAPABILITY_RE = /^[a-z0-9][a-z0-9+._-]{0,31}$/;
+/** The most tags a session suggests (the server's limit). */
+export const MAX_SESSION_CAPABILITIES = 20;
+/** The most Needs an item has (the server's limit). */
+export const MAX_ITEM_NEEDS = 10;
+/** How long one probe may take before it counts as "not found". */
+export const PROBE_TIMEOUT_MS = 1500;
+/**
+ * Tags as the server stores them: trimmed, lower case, unique and sorted.
+ * Throws with the bad ones named, so a person's --capabilities can be fixed.
+ */
+export function normalizeCapabilities(raw, max) {
+    const tags = [...new Set(raw.map((t) => t.trim().toLowerCase()).filter((t) => t !== ''))];
+    const bad = tags.filter((t) => !CAPABILITY_RE.test(t));
+    if (bad.length > 0) {
+        throw new Error(`Not a capability tag: ${bad.map((b) => JSON.stringify(b.slice(0, 40))).join(', ')}. A tag is a lower-case letter or digit, then up to 31 lower-case letters, digits or + . _ - (for example macos, ios, flutter).`);
+    }
+    if (tags.length > max)
+        throw new Error(`At most ${max} capability tags.`);
+    return tags.sort();
+}
+/** The real machine. */
+export const NODE_HOST = {
+    platform: process.platform,
+    env: process.env,
+    async isExecutable(path) {
+        try {
+            const s = await stat(path);
+            if (!s.isFile())
+                return false;
+            if (process.platform === 'win32')
+                return true;
+            await access(path, constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    async isDirectory(path) {
+        try {
+            return (await stat(path)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+    async readLink(path) {
+        try {
+            return await readlink(path);
+        }
+        catch {
+            return undefined;
+        }
+    },
+};
+/** The program names to look for on the PATH, by tag (android: hasAndroid). */
+const PROGRAMS = [
+    { tag: 'flutter', programs: ['flutter'] },
+    { tag: 'docker', programs: ['docker'] },
+    { tag: 'rust', programs: ['cargo', 'rustc'] },
+];
+/** Resolves to false when `probe` fails or takes longer than the time limit. */
+async function within(probe, ms) {
+    let timer;
+    const late = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            resolve(false);
+        }, ms);
+    });
+    try {
+        return await Promise.race([probe().catch(() => false), late]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Whether one of `names` is a program in a folder of the PATH. */
+async function onPath(host, names) {
+    const win = host.platform === 'win32';
+    const path = (win ? (host.env.Path ?? host.env.PATH) : host.env.PATH) ?? '';
+    const paths = win ? win32 : posix;
+    const dirs = path
+        .split(win ? ';' : ':')
+        .map((d) => d.trim().replace(/^"(.*)"$/, '$1'))
+        .filter((d) => d !== '');
+    const extensions = win
+        ? (host.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+            .split(';')
+            .map((e) => e.trim().toLowerCase())
+            .filter((e) => e !== '')
+        : [''];
+    const candidates = dirs.flatMap((dir) => names.flatMap((name) => extensions.map((ext) => paths.join(dir, name + ext))));
+    const found = await Promise.all(candidates.map((c) => host.isExecutable(c)));
+    return found.some(Boolean);
+}
+/** The Android SDK: ANDROID_HOME or ANDROID_SDK_ROOT names a folder, or adb is on the PATH. */
+async function hasAndroid(host) {
+    for (const name of ['ANDROID_HOME', 'ANDROID_SDK_ROOT']) {
+        const dir = host.env[name]?.trim();
+        if (dir !== undefined && dir !== '' && (await host.isDirectory(dir)))
+            return true;
+    }
+    return onPath(host, ['adb']);
+}
+/**
+ * The developer folder of Xcode (macOS), when it is the full app and not
+ * only the command line tools: DEVELOPER_DIR, else the folder xcode-select
+ * chose (the link it keeps), else the app in /Applications. Read from the
+ * file system; nothing is run.
+ */
+async function xcodeDeveloperDir(host) {
+    const isApp = (dir) => /\.app\/Contents\/Developer\/?$/.test(dir);
+    const fromEnv = host.env.DEVELOPER_DIR?.trim();
+    if (fromEnv !== undefined && fromEnv !== '') {
+        return isApp(fromEnv) && (await host.isDirectory(fromEnv)) ? fromEnv : undefined;
+    }
+    const selected = await host.readLink('/var/db/xcode_select_link');
+    if (selected !== undefined) {
+        return isApp(selected) && (await host.isDirectory(selected)) ? selected : undefined;
+    }
+    const standard = '/Applications/Xcode.app/Contents/Developer';
+    return (await host.isDirectory(standard)) ? standard : undefined;
+}
+/** The operating system's tag, or undefined for one outside the list. */
+export function osCapability(platform) {
+    switch (platform) {
+        case 'win32':
+            return 'windows';
+        case 'darwin':
+            return 'macos';
+        case 'linux':
+            return 'linux';
+        default:
+            return undefined;
+    }
+}
+/**
+ * The tags this machine suggests. Never throws: a probe that fails, or runs
+ * out of time, leaves its tag out. `web` and `gpu` are never detected (the
+ * owner adds them in the app).
+ */
+export async function detectCapabilities(host = NODE_HOST) {
+    const ms = host.timeoutMs ?? PROBE_TIMEOUT_MS;
+    const tags = new Set();
+    try {
+        const os = osCapability(host.platform);
+        if (os !== undefined)
+            tags.add(os);
+        const probes = PROGRAMS.map(async ({ tag, programs }) => {
+            if (await within(() => onPath(host, programs), ms))
+                tags.add(tag);
+        });
+        probes.push((async () => {
+            if (await within(() => hasAndroid(host), ms))
+                tags.add('android');
+        })());
+        if (host.platform === 'darwin') {
+            probes.push((async () => {
+                let dir;
+                const found = await within(async () => {
+                    dir = await xcodeDeveloperDir(host);
+                    return dir !== undefined;
+                }, ms);
+                if (!found || dir === undefined)
+                    return;
+                tags.add('xcode');
+                const sdk = posix.join(dir, 'Platforms', 'iPhoneOS.platform');
+                if (await within(() => host.isDirectory(sdk), ms))
+                    tags.add('ios');
+            })());
+        }
+        await Promise.all(probes);
+    }
+    catch {
+        // Detection never fails connect: what was found so far is suggested.
+    }
+    // Only tags of the fixed list leave the machine.
+    return [...tags].filter((t) => SUGGESTED_CAPABILITIES.includes(t)).sort();
+}
+/**
+ * The tags to suggest: `override` (--capabilities, or BUILDIT_CAPABILITIES)
+ * replaces detection; "none" suggests none.
+ */
+export async function suggestedCapabilities(override, host = NODE_HOST) {
+    if (override !== undefined)
+        return [...override];
+    return detectCapabilities(host);
+}
+/**
+ * --capabilities or BUILDIT_CAPABILITIES: tags separated by commas or
+ * spaces, or "none". Throws with what is wrong.
+ */
+export function parseCapabilitiesOption(raw) {
+    const parts = raw
+        .split(/[\s,]+/)
+        .map((t) => t.trim())
+        .filter((t) => t !== '');
+    if (parts.length === 1 && parts[0]?.toLowerCase() === 'none')
+        return [];
+    if (parts.length === 0) {
+        throw new Error('Give capability tags separated by commas (for example macos,ios), or none.');
+    }
+    return normalizeCapabilities(parts, MAX_SESSION_CAPABILITIES);
+}

package/dist/channel/api.js

@@ -0,0 +1,159 @@
+/**
+ * The agent API's session operations, typed from the contract: the
+ * device-code connect flow (`connect_start`, `connect_poll`, which take no
+ * token) and a Claude Code session's own conversation with its owner
+ * (`get_session`, `list_session_events`, `ack_session_events`,
+ * `post_session_message`, `session_heartbeat`, which take a session token),
+ * and its tool approvals (`post_session_approval`, `get_session_approval`,
+ * `close_session_approval`), its capability tags (`set_session_capabilities`) and
+ * its handoffs (`propose_session_handoff`, `get_session_handoff`,
+ * `close_session_handoff`, `decline_session_handoff`).
+ *
+ * Each goes through callOperation, like the tools' calls: request ids,
+ * timeouts, the error envelope, the one 429 retry, and tolerant parsing with
+ * the generated schemas.
+ */
+import { z } from 'zod';
+import { OPERATIONS } from '../api/generated/operations.js';
+import { SessionEventSchema, } from '../api/generated/schemas.js';
+import { callOperation } from '../api/operations.js';
+/** The codes connect_poll answers while the person hasn't approved (RFC 8628, in the API's envelope). */
+export const POLL_CODES = {
+    pending: 'authorization_pending',
+    slowDown: 'slow_down',
+    denied: 'access_denied',
+    expired: 'expired_token',
+};
+/** Codes that end a session for good: the token is no longer accepted. */
+export const SESSION_ENDED_CODES = new Set(['token_revoked', 'token_expired']);
+/** POST /v1/connect/start (no token). */
+export function connectStart(api, body, options = {}) {
+    return callOperation(api, 'connect_start', { body }, options);
+}
+/** POST /v1/connect/poll (no token). The codes of POLL_CODES arrive as ApiErrors. */
+export function connectPoll(api, deviceCode, options = {}) {
+    return callOperation(api, 'connect_poll', { body: { device_code: deviceCode } }, options);
+}
+/** GET /v1/session */
+export function getSession(api, options = {}) {
+    return callOperation(api, 'get_session', {}, options);
+}
+/** A page of events, each checked on its own (see listSessionEvents). */
+const EventsPageSchema = z.looseObject({
+    events: z.array(z.unknown()),
+    cursor: z.number(),
+    more: z.boolean(),
+});
+/**
+ * GET /v1/session/events. The contract may add event types, so the page is
+ * read with each event checked on its own: one this version doesn't know
+ * (or can't read) is left out, and `skipped` counts it. The cursor still
+ * covers it, so it is acknowledged with the page.
+ */
+export async function listSessionEvents(api, query, options = {}) {
+    const op = OPERATIONS.list_session_events;
+    if (api.served?.operations !== undefined && !api.served.operations.has('list_session_events')) {
+        // callOperation's answer for an operation the deployment doesn't serve.
+        return callOperation(api, 'list_session_events', { query }, options).then((page) => ({
+            ...page,
+            skipped: 0,
+        }));
+    }
+    const page = await api.requestParsed(op.method, op.path, EventsPageSchema, {
+        ...options,
+        operation: 'list_session_events',
+        pathTemplate: op.path,
+        query: query,
+    });
+    const events = [];
+    for (const raw of page.events) {
+        const parsed = SessionEventSchema.safeParse(raw);
+        if (parsed.success)
+            events.push(parsed.data);
+    }
+    return { ...page, events, skipped: page.events.length - events.length };
+}
+/** POST /v1/session/events/ack */
+export function ackSessionEvents(api, cursor, options = {}) {
+    return callOperation(api, 'ack_session_events', { body: { cursor } }, options);
+}
+/** POST /v1/session/messages, in the agent's own direct message with its owner. */
+export function postSessionMessage(api, body, options = {}) {
+    return callOperation(api, 'post_session_message', { body }, options);
+}
+/** DELETE /v1/session: the session ends itself (its token stops working at once). 204, no body. */
+export async function revokeSession(api, options = {}) {
+    await callOperation(api, 'revoke_session', {}, options);
+}
+/** POST /v1/session/heartbeat */
+export function sessionHeartbeat(api, state, options = {}) {
+    return callOperation(api, 'session_heartbeat', { body: { state } }, options);
+}
+/** PATCH /v1/session/messages/{id}: changes the session's own message (its text, or its card). */
+export function updateSessionMessage(api, messageId, body, options = {}) {
+    return callOperation(api, 'update_session_message', { path: { id: messageId }, body }, options);
+}
+/** POST /v1/session/messages/{id}/card/close: closes the session's own card to answers. */
+export function closeSessionCard(api, messageId, options = {}) {
+    return callOperation(api, 'close_session_card', { path: { id: messageId }, body: {} }, options);
+}
+/** PATCH /v1/session/responses/{id}: accepts or rejects an answer to the session's own card. */
+export function answerSessionResponse(api, responseId, body, options = {}) {
+    return callOperation(api, 'answer_session_response', { path: { id: responseId }, body }, options);
+}
+/** POST /v1/session/plan-cards: posts a plan's preview as a card the owner applies or cancels. */
+export function postPlanCard(api, body, options = {}) {
+    return callOperation(api, 'post_plan_card', { body }, options);
+}
+/** POST /v1/session/typing: "<agent> is writing…" in a thread (204, no body). */
+export async function sessionTyping(api, body, options = {}) {
+    await callOperation(api, 'session_typing', { body }, options);
+}
+/** GET /v1/session/threads: the session's threads, newest activity first (at most 50). */
+export function listSessionThreads(api, options = {}) {
+    return callOperation(api, 'list_session_threads', {}, options);
+}
+/**
+ * POST /v1/session/approvals: posts a tool approval card (idempotent by its
+ * id: the same id again answers 200 with the card's current state).
+ */
+export function postSessionApproval(api, body, options = {}) {
+    return callOperation(api, 'post_session_approval', { body }, options);
+}
+/** GET /v1/session/approvals/{id}: a tool approval's state (the fallback when an event was missed). */
+export function getSessionApproval(api, id, options = {}) {
+    return callOperation(api, 'get_session_approval', { path: { id } }, options);
+}
+/** POST /v1/session/approvals/{id}/close: closes a tool approval that no longer needs an answer. */
+export function closeSessionApproval(api, id, reason, options = {}) {
+    return callOperation(api, 'close_session_approval', { path: { id }, body: { reason } }, options);
+}
+/**
+ * PUT /v1/session/capabilities: replaces the session's suggested capability
+ * tags with what it detects now (tag names only). It never changes the tags
+ * the owner confirmed. An older server (before 1.9.0) answers 404.
+ */
+export function setSessionCapabilities(api, detected, options = {}) {
+    return callOperation(api, 'set_session_capabilities', { body: { detected: [...detected] } }, options);
+}
+/**
+ * POST /v1/session/handoffs: proposes handing a subtask of the session's own
+ * item to another of the owner's sessions (idempotent by `id`: the same id
+ * again answers the first handoff, created false). Only the owner's tap on
+ * the card hands it over.
+ */
+export function proposeSessionHandoff(api, body, options = {}) {
+    return callOperation(api, 'propose_session_handoff', { body }, options);
+}
+/** GET /v1/session/handoffs/{id}: a handoff the session asked for, or was handed. */
+export function getSessionHandoff(api, id, options = {}) {
+    return callOperation(api, 'get_session_handoff', { path: { id } }, options);
+}
+/** POST /v1/session/handoffs/{id}/close: withdraws the session's own proposal while its card is open. */
+export function closeSessionHandoff(api, id, options = {}) {
+    return callOperation(api, 'close_session_handoff', { path: { id }, body: {} }, options);
+}
+/** POST /v1/session/handoffs/{id}/decline: hands a subtask handed to this session back, with why. */
+export function declineSessionHandoff(api, id, reason, options = {}) {
+    return callOperation(api, 'decline_session_handoff', { path: { id }, body: { reason } }, options);
+}

package/dist/channel/approvals.js

@@ -0,0 +1,259 @@
+/**
+ * The session's open tool approvals: the cards `approve` posted and still
+ * waits on, so the plugin's other hooks can end them.
+ *
+ * Claude Code never says that a permission request no longer needs an
+ * answer (the person answered in the terminal, pressed Esc, or the turn went
+ * on), so the plugin's hooks say it instead, and the waiting `approve` call
+ * ends with `{}` (it changes nothing) and closes its card in buildIt.Social:
+ *
+ * - `tool_done` (PostToolUse, PostToolUseFailure): the call ran, so it was
+ *   answered elsewhere;
+ * - `agent_done` (SubagentStop): that subagent's approvals are no longer
+ *   needed;
+ * - `turn_ended` (Stop) and `prompt_typed` (UserPromptSubmit): the main
+ *   agent's approvals are no longer needed.
+ *
+ * On shutdown every open card is closed (the session ended). A journal file
+ * keeps the open cards' ids, so a server that died with cards open closes
+ * them when the next one starts in the folder: the owner never approves a
+ * call nobody waits for.
+ */
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { ApiError } from '../api/client.js';
+import { closeSessionApproval } from './api.js';
+/** The closer that calls the API (at most 5 seconds each; a failure is only logged). */
+export function apiApprovalCloser(api, logger) {
+    return async (id, reason) => {
+        try {
+            await closeSessionApproval(api, id, reason, {
+                tool: 'approve',
+                signal: AbortSignal.timeout(5000),
+            });
+            return true;
+        }
+        catch (err) {
+            const code = err instanceof ApiError ? err.code : 'error';
+            logger.info('tool approval not closed', { message_id: id, code });
+            // Nothing to close: the post never made it.
+            return code === 'not_found';
+        }
+    };
+}
+/** How many ids of the session's tool approvals are remembered (to know their events). */
+const KNOWN_MAX = 500;
+/** How many ended ids are remembered (so a merged journal doesn't bring them back). */
+const ENDED_MAX = 1000;
+/** The longest shutdown waits for the cards to close. */
+export const SHUTDOWN_CLOSE_MS = 5000;
+export class ToolApprovals {
+    options;
+    open = new Map();
+    /** Every waiting call's settle, by card (the hook may run twice for one call). */
+    settles = new Map();
+    /** Ids of every approval this process posted (bounded), and the journal's from before. */
+    known = new Set();
+    /**
+     * Cards no waiting call holds but that may be open in buildIt.Social: the
+     * ones a process before this one left (the journal at startup), and posts
+     * that failed in a way that may have stored them, until they are closed.
+     */
+    leftOpen = [];
+    /** Ids this process knows have ended (the journal drops them). */
+    ended = new Set();
+    constructor(options) {
+        this.options = options;
+        this.leftOpen = this.readJournal();
+        for (const e of this.leftOpen)
+            this.remember(e.id);
+    }
+    /** The open approvals (tests). */
+    get openIds() {
+        return [...this.open.keys()];
+    }
+    /** Whether a card message is one of this session's tool approvals. */
+    isApproval(messageId) {
+        return this.known.has(messageId) || this.open.has(messageId);
+    }
+    /**
+     * An approval was posted (or is about to be): it is open until removed. A
+     * second call for the same card (the hook ran twice) joins it.
+     */
+    add(entry) {
+        const settles = this.settles.get(entry.id) ?? new Set();
+        settles.add(entry.settle);
+        this.settles.set(entry.id, settles);
+        if (!this.open.has(entry.id))
+            this.open.set(entry.id, entry);
+        this.remember(entry.id);
+        this.writeJournal();
+        return () => {
+            settles.delete(entry.settle);
+            if (settles.size > 0)
+                return;
+            this.settles.delete(entry.id);
+            if (this.open.delete(entry.id)) {
+                if (!this.leftOpen.some((e) => e.id === entry.id))
+                    this.markEnded(entry.id);
+                this.writeJournal();
+            }
+        };
+    }
+    /**
+     * A post that failed in a way that may have stored it (a timeout, the
+     * network, a 5xx): the card stays in the journal until a close succeeds.
+     */
+    orphan(id, postedAt) {
+        if (!this.leftOpen.some((e) => e.id === id))
+            this.leftOpen.push({ id, posted_at: postedAt });
+        this.writeJournal();
+    }
+    /** A card closed for sure (or never stored): it leaves the journal. */
+    forget(id) {
+        this.leftOpen = this.leftOpen.filter((e) => e.id !== id);
+        if (!this.open.has(id))
+            this.markEnded(id);
+        this.writeJournal();
+    }
+    /** The tool call ran (its PostToolUse): an approval waiting for it was answered elsewhere. */
+    toolDone(toolUseId) {
+        let n = 0;
+        for (const entry of [...this.open.values()]) {
+            if (entry.toolUseId !== undefined && entry.toolUseId === toolUseId) {
+                this.settle(entry.id, 'answered_elsewhere');
+                n++;
+            }
+        }
+        return n;
+    }
+    /** An agent's approvals are no longer needed ("" is the main agent). */
+    agentDone(agentRef) {
+        let n = 0;
+        for (const entry of [...this.open.values()]) {
+            if (entry.agentRef === agentRef) {
+                this.settle(entry.id, 'stale');
+                n++;
+            }
+        }
+        return n;
+    }
+    /**
+     * Shutdown: closes every open approval's card (at most SHUTDOWN_CLOSE_MS
+     * in all). The waiting calls end with the session.
+     */
+    async closeAll(closer, reason) {
+        const ids = [...this.open.keys()];
+        if (ids.length === 0)
+            return;
+        let timer;
+        await Promise.race([
+            Promise.all(ids.map((id) => closer(id, reason).catch(() => undefined))),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, SHUTDOWN_CLOSE_MS);
+            }),
+        ]);
+        clearTimeout(timer);
+        this.options.logger.info('tool approvals closed on shutdown', { count: ids.length });
+    }
+    /**
+     * The cards an earlier process left open (it stopped while they waited):
+     * each is closed as interrupted, then the journal holds only this
+     * process's own. Called once the session is known.
+     */
+    async recover(closer) {
+        const left = this.leftOpen.filter((e) => !this.open.has(e.id));
+        if (left.length === 0)
+            return;
+        const closed = await Promise.all(left.map((e) => closer(e.id, 'interrupted').catch(() => false)));
+        // A close that failed keeps its card in the journal, for the next try.
+        left.forEach((e, i) => {
+            if (closed[i] === true)
+                this.forget(e.id);
+        });
+        this.options.logger.info('tool approvals left open by an earlier server closed', {
+            count: closed.filter(Boolean).length,
+            kept: closed.filter((c) => !c).length,
+        });
+    }
+    settle(id, reason) {
+        for (const settle of [...(this.settles.get(id) ?? [])])
+            settle(reason);
+    }
+    markEnded(id) {
+        this.ended.delete(id);
+        this.ended.add(id);
+        if (this.ended.size > ENDED_MAX) {
+            const oldest = this.ended.values().next().value;
+            if (oldest !== undefined)
+                this.ended.delete(oldest);
+        }
+    }
+    remember(id) {
+        this.known.delete(id);
+        this.known.add(id);
+        if (this.known.size > KNOWN_MAX) {
+            const oldest = this.known.values().next().value;
+            if (oldest !== undefined)
+                this.known.delete(oldest);
+        }
+    }
+    readJournal() {
+        const path = this.options.journal;
+        if (path === undefined)
+            return [];
+        try {
+            const parsed = JSON.parse(readFileSync(path, 'utf8'));
+            if (parsed.v !== 1 || !Array.isArray(parsed.open))
+                return [];
+            return parsed.open
+                .filter((e) => typeof e === 'object' && typeof e.id === 'string' && /^[0-9a-f-]{36}$/i.test(e.id))
+                .slice(0, 100)
+                .map((e) => ({ id: e.id, posted_at: typeof e.posted_at === 'string' ? e.posted_at : '' }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Writes the journal: what it already lists (another server's entries
+     * stay), this process's open and left-open cards, less what this process
+     * knows has ended; to a temporary file, then renamed over it.
+     */
+    writeJournal() {
+        const path = this.options.journal;
+        if (path === undefined)
+            return;
+        const entries = new Map();
+        for (const e of [
+            ...this.readJournal(),
+            ...this.leftOpen,
+            ...[...this.open.values()].map((o) => ({ id: o.id, posted_at: o.postedAt })),
+        ]) {
+            if (!this.ended.has(e.id))
+                entries.set(e.id, e.posted_at);
+        }
+        const file = {
+            v: 1,
+            open: [...entries].slice(-100).map(([id, posted_at]) => ({ id, posted_at })),
+        };
+        const temp = `${path}.${process.pid}.tmp`;
+        try {
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+            writeFileSync(temp, JSON.stringify(file), { mode: 0o600 });
+            chmodSync(temp, 0o600);
+            renameSync(temp, path);
+        }
+        catch (err) {
+            this.options.logger.info('tool approval journal not written', {
+                code: err.code ?? 'error',
+            });
+            try {
+                rmSync(temp, { force: true });
+            }
+            catch {
+                // Nothing to clean up.
+            }
+        }
+    }
+}