@north-light/crouter 0.3.170 → 0.3.172

package/dist/clients/inbox/controller.d.ts

@@ -0,0 +1,79 @@
+import type { TUI } from '@earendil-works/pi-tui';
+import type { TicketSummary } from '../../core/human/types.js';
+import type { CanvasSource } from '../../core/canvas/source.js';
+import type { Key } from './tui/keys.js';
+import type { SurfaceHost } from '../surfaces/host.js';
+export interface InboxControllerOptions {
+    host: SurfaceHost;
+    tui: TUI;
+    canvasSource: CanvasSource;
+    /** Called whenever the rendered frame may have changed. */
+    onDirty: () => void;
+    /** Called after the controller has finished closing itself. */
+    onClosed: () => void;
+    cols?: number;
+    rows?: number;
+    scan?: () => TicketSummary[];
+    /** Replaces the default synchronous rescan after inbox activity. */
+    onInboxActivity?: () => void;
+}
+type Screen = 'list' | 'detail';
+/** Host-agnostic model for scanning, stable selection, claims, and rendering. */
+export declare class InboxController {
+    private readonly options;
+    private readonly host;
+    private readonly scan;
+    private items;
+    private selectedDir;
+    private selectedIndex;
+    private screen;
+    private adapter;
+    private reviewAdapter;
+    private focusingSource;
+    private claim;
+    private submittingDir;
+    private cancelConfirmation;
+    private cols;
+    private rows;
+    private status;
+    private watchers;
+    private selectedWatcher;
+    private heartbeat;
+    private started;
+    private closed;
+    constructor(options: InboxControllerOptions);
+    snapshot(): {
+        items: TicketSummary[];
+        selectedDir?: string;
+        screen: Screen;
+        inputBuffer?: string;
+    };
+    rescan(): void;
+    start(): void;
+    invalidate(): void;
+    resize(cols: number, rows: number): void;
+    render(): string[];
+    handleKey(input: string, key: Key): void;
+    private cancelFromInbox;
+    activate(): void;
+    private activateReview;
+    reloadSelectedDeck(): void;
+    private readDeck;
+    close(): void;
+    private complete;
+    /** Edit the active buffer while the host releases the terminal to $EDITOR. */
+    private editActiveDeckInput;
+    private leaveDetail;
+    private select;
+    private detailSize;
+    private detailLines;
+    private focusAvailable;
+    /** Ask the host to bring the selected ticket's node viewer into view. */
+    private focusSelectedSource;
+    private passiveDetailLines;
+    private withStatus;
+    private markDirty;
+    private watchRoots;
+    private watchSelected;
+}
+export {};

package/dist/clients/inbox/controller.js

@@ -0,0 +1,448 @@
+import { watch } from 'node:fs';
+import { renderMarkdown } from '../../core/termrender/termrender.js';
+import { BOLD, CYAN, DIM, GRAY, RESET, YELLOW, clipLine } from './tui/ansi.js';
+import { buildInboxLines } from './tui.js';
+import { inboxLayout } from './layout.js';
+import { scanInbox } from '../../core/human/scan.js';
+import { watchInboxActivity } from '../../core/human/root.js';
+import { claimTicket, heartbeatClaim, releaseClaim } from '../../core/human/claim.js';
+import { readTicketResult } from '../../core/human/tickets.js';
+import { clearProgress, deckPath, readJson } from '../../core/human/convention.js';
+import { DeckAdapter } from './deck-adapter.js';
+import { validateDeck } from '../../core/human/deck-schema.js';
+import { ReviewAdapter } from './review-adapter.js';
+import { editBufferInEditor } from './review/roundtrip.js';
+import { cancelTicketViaDaemon, daemonErrorMessage, nodeIdFor, resolveFailureKind, resolveTicketDeck, } from './resolve.js';
+/** Host-agnostic model for scanning, stable selection, claims, and rendering. */
+export class InboxController {
+    options;
+    host;
+    scan;
+    items = [];
+    selectedDir;
+    selectedIndex = 0;
+    screen = 'list';
+    adapter;
+    reviewAdapter;
+    focusingSource = false;
+    claim;
+    submittingDir;
+    cancelConfirmation;
+    cols;
+    rows;
+    status;
+    watchers = [];
+    selectedWatcher;
+    heartbeat;
+    started = false;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.host = options.host;
+        this.scan = options.scan ?? scanInbox;
+        this.cols = options.cols ?? 80;
+        this.rows = options.rows ?? 24;
+        this.rescan();
+    }
+    snapshot() {
+        return { items: [...this.items], selectedDir: this.selectedDir, screen: this.screen, inputBuffer: this.adapter?.inputBuffer() };
+    }
+    rescan() {
+        const priorDir = this.selectedDir;
+        const priorIndex = this.selectedIndex;
+        this.items = this.scan();
+        const found = priorDir === undefined ? -1 : this.items.findIndex((item) => item.dir === priorDir);
+        if (found >= 0) {
+            this.selectedIndex = found;
+            this.selectedDir = priorDir;
+            return;
+        }
+        if (this.adapter !== undefined && priorDir !== undefined) {
+            const canceled = readTicketResult(priorDir)?.kind === 'canceled';
+            if (canceled)
+                clearProgress(priorDir);
+            // Suppress the "resolved elsewhere" banner when WE are the ones resolving
+            // this ticket: the response.json we just published trips the root watch
+            // mid-submit, and that is our own completion, not an external event.
+            if (priorDir !== this.submittingDir)
+                this.status = canceled ? 'canceled by requester' : 'ticket resolved elsewhere';
+            this.leaveDetail(priorDir !== this.submittingDir);
+        }
+        if (this.items.length === 0) {
+            this.selectedIndex = 0;
+            this.selectedDir = undefined;
+            return;
+        }
+        this.selectedIndex = Math.min(priorIndex, this.items.length - 1);
+        this.selectedDir = this.items[this.selectedIndex].dir;
+    }
+    start() {
+        if (this.started || this.closed)
+            return;
+        this.started = true;
+        this.watchRoots();
+        this.heartbeat = setInterval(() => {
+            if (this.claim !== undefined)
+                heartbeatClaim(this.claim.dir, this.claim.token);
+        }, 10_000);
+    }
+    invalidate() { this.rescan(); this.markDirty(); }
+    resize(cols, rows) {
+        this.cols = cols;
+        this.rows = rows;
+        this.adapter?.resize(this.detailSize().cols, this.detailSize().rows);
+        this.markDirty();
+    }
+    render() {
+        const geometry = inboxLayout(this.cols, this.rows, this.screen);
+        if (geometry.mode === 'minimum')
+            return [`${YELLOW}Resize terminal to at least 60×18 to use inbox.${RESET}`];
+        const list = buildInboxLines(this.items, geometry.listWidth, this.selectedIndex, geometry.height);
+        const detail = this.detailLines(geometry.detailWidth, geometry.height);
+        if (geometry.mode === 'list')
+            return this.withStatus(list);
+        if (geometry.mode === 'detail')
+            return this.withStatus(detail);
+        const lines = [];
+        // Dim box-drawing rule in the single-column gutter the layout reserves
+        // (detailWidth = cols - listWidth - 1) so the list and detail read as two
+        // distinct panels rather than one run-together block.
+        const divider = `${GRAY}│${RESET}`;
+        for (let i = 0; i < geometry.height; i++) {
+            // Hard-clip the list line to its column: an overflowing row would eat
+            // the pad and push the divider out of alignment for that row alone.
+            const left = clipLine(list[i] ?? '', geometry.listWidth);
+            // Clip the detail column too: a deck/preview row is only ever entitled to
+            // its own panel, so an over-wide row cannot run past the pane's edge.
+            const right = clipLine(detail[i] ?? '', geometry.detailWidth);
+            const pad = ' '.repeat(Math.max(0, geometry.listWidth - visibleWidth(left)));
+            lines.push(`${left}${pad}${divider}${right}`);
+        }
+        return this.withStatus(lines);
+    }
+    handleKey(input, key) {
+        // Ctrl-C closes from every controller mode before adapter forwarding.
+        // The inbox toggle is a host action, never a surface key chord.
+        if (key.ctrl && input === 'c') {
+            this.close();
+            return;
+        }
+        if (this.screen === 'detail' && this.adapter !== undefined) {
+            if ((input === 'g' || input === 'G') && this.adapter.canAcceptHostKeys()) {
+                void this.focusSelectedSource();
+                return;
+            }
+            this.adapter.handleKey(input, key);
+            this.markDirty();
+            return;
+        }
+        if (this.cancelConfirmation !== undefined) {
+            if (input === 'y' || input === 'Y') {
+                const dir = this.cancelConfirmation.dir;
+                this.cancelConfirmation = undefined;
+                this.status = 'canceling…';
+                void this.cancelFromInbox(dir);
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                this.cancelConfirmation = undefined;
+                this.status = undefined;
+            }
+            this.markDirty();
+            return;
+        }
+        if (input === 'x' || input === 'X') {
+            const selected = this.items[this.selectedIndex];
+            if (selected !== undefined) {
+                this.cancelConfirmation = { dir: selected.dir, title: selected.title };
+                this.status = undefined;
+            }
+            this.markDirty();
+            return;
+        }
+        if (key.escape || input === 'q') {
+            this.close();
+            return;
+        }
+        if (input === 'j' || key.downArrow)
+            this.select(this.selectedIndex + 1);
+        else if (input === 'k' || key.upArrow)
+            this.select(this.selectedIndex - 1);
+        else if (input === 'g' || input === 'G')
+            void this.focusSelectedSource();
+        else if (key.return || input === 'a')
+            this.activate();
+        this.markDirty();
+    }
+    async cancelFromInbox(dir) {
+        this.submittingDir = dir;
+        try {
+            await cancelTicketViaDaemon(dir, { reason: 'Canceled from the inbox.', actor: 'human' });
+            this.status = 'canceled';
+        }
+        catch (error) {
+            this.status = daemonErrorMessage(error);
+        }
+        finally {
+            this.submittingDir = undefined;
+            this.rescan();
+            this.markDirty();
+        }
+    }
+    activate() {
+        const item = this.items[this.selectedIndex];
+        if (item === undefined)
+            return;
+        if (item.kind === 'review') {
+            void this.activateReview(item);
+            return;
+        }
+        if (item.kind !== 'deck')
+            return;
+        const claim = claimTicket(item.dir);
+        if (claim === null) {
+            this.status = 'ticket is being edited by another inbox';
+            return;
+        }
+        this.claim = { dir: item.dir, token: claim.token };
+        const deck = this.readDeck(item.dir);
+        if (deck === undefined) {
+            releaseClaim(item.dir, claim.token);
+            this.claim = undefined;
+            this.invalidate();
+            return;
+        }
+        // Notifications use the same canonical deck panel as every other deck:
+        // opening is not acknowledgement; panel completion is.
+        this.screen = 'detail';
+        this.adapter = new DeckAdapter({
+            dir: item.dir,
+            deck,
+            cols: this.detailSize().cols,
+            rows: this.detailSize().rows,
+            onDirty: () => this.markDirty(),
+            onEditorRequest: () => this.editActiveDeckInput(),
+            onBack: () => { this.leaveDetail(); this.markDirty(); },
+            onComplete: (responses) => { void this.complete(responses); },
+        });
+        this.watchSelected(item.dir);
+    }
+    async activateReview(item) {
+        this.reviewAdapter = new ReviewAdapter({
+            dir: item.dir,
+            host: this.host,
+            tui: this.options.tui,
+            canvasSource: this.options.canvasSource,
+        });
+        try {
+            await this.reviewAdapter.start();
+        }
+        catch (error) {
+            this.status = daemonErrorMessage(error);
+        }
+        finally {
+            this.reviewAdapter = undefined;
+            this.rescan();
+            this.markDirty();
+        }
+    }
+    reloadSelectedDeck() {
+        if (this.adapter === undefined || this.claim === undefined) {
+            this.markDirty();
+            return;
+        }
+        const deck = this.readDeck(this.claim.dir);
+        if (deck === undefined) {
+            this.markDirty();
+            return;
+        }
+        // Reload applies the latest deck shape before the panel preserves surviving answers.
+        this.adapter.reload(deck);
+        this.markDirty();
+    }
+    readDeck(dir) {
+        const deck = readJson(deckPath(dir));
+        if (deck === null)
+            return undefined;
+        try {
+            return validateDeck(deck);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.started = false;
+        if (this.heartbeat !== undefined)
+            clearInterval(this.heartbeat);
+        this.heartbeat = undefined;
+        void this.reviewAdapter?.stop();
+        this.leaveDetail(this.claim?.dir !== this.submittingDir);
+        for (const watcher of this.watchers)
+            watcher.close();
+        this.watchers = [];
+        this.selectedWatcher?.close();
+        this.selectedWatcher = undefined;
+        this.options.onClosed();
+    }
+    async complete(responses) {
+        const claim = this.claim;
+        if (claim === undefined)
+            return;
+        this.submittingDir = claim.dir;
+        try {
+            await resolveTicketDeck(claim.dir, responses);
+        }
+        catch (error) {
+            this.submittingDir = undefined;
+            this.status = daemonErrorMessage(error);
+            const failure = resolveFailureKind(error);
+            if (failure === 'unreachable' || failure === 'other') {
+                this.markDirty();
+                return;
+            }
+            if (failure === 'already_resolved')
+                this.status = canonicalResultStatus(readTicketResult(claim.dir));
+            this.leaveDetail(false);
+            this.rescan();
+            this.markDirty();
+            return;
+        }
+        this.submittingDir = undefined;
+        this.leaveDetail(false);
+        this.rescan();
+        this.markDirty();
+    }
+    /** Edit the active buffer while the host releases the terminal to $EDITOR. */
+    editActiveDeckInput() {
+        const buffer = this.adapter?.inputBuffer();
+        if (buffer === undefined)
+            return;
+        const resume = this.host.suspendForChild();
+        let result = { text: buffer };
+        try {
+            result = editBufferInEditor(buffer);
+        }
+        finally {
+            resume();
+            this.adapter?.setInputBuffer(result.text);
+            if (result.error !== undefined)
+                this.status = result.error;
+            this.markDirty();
+        }
+    }
+    leaveDetail(release = true) {
+        this.adapter?.close();
+        this.adapter = undefined;
+        this.selectedWatcher?.close();
+        this.selectedWatcher = undefined;
+        if (release && this.claim !== undefined)
+            releaseClaim(this.claim.dir, this.claim.token);
+        this.claim = undefined;
+        this.screen = 'list';
+    }
+    select(index) {
+        if (this.items.length === 0)
+            return;
+        this.selectedIndex = Math.max(0, Math.min(index, this.items.length - 1));
+        this.selectedDir = this.items[this.selectedIndex].dir;
+    }
+    detailSize() {
+        const layout = inboxLayout(this.cols, this.rows, this.screen);
+        return { cols: Math.max(1, layout.detailWidth - 2), rows: layout.height };
+    }
+    detailLines(width, rows) {
+        if (this.adapter !== undefined)
+            return this.adapter.render();
+        const selected = this.items[this.selectedIndex];
+        if (selected === undefined)
+            return this.passiveDetailLines(width).slice(0, rows);
+        const focusHint = this.focusAvailable(selected.dir) ? `  ${DIM}g${RESET} chat` : '';
+        const footer = selected.kind === 'deck'
+            ? [`  ${DIM}Enter${RESET} opens the full ticket  ${DIM}j/k${RESET} select  ${DIM}x${RESET} cancel`, `  ${DIM}Active ask:${RESET} c comment  u/d scroll${focusHint}  ${DIM}q${RESET} close`]
+            : [`  ${DIM}Enter${RESET} opens the full review  ${DIM}j/k${RESET} select  ${DIM}x${RESET} cancel`, ` ${focusHint}  ${DIM}q${RESET} close`];
+        const preview = this.passiveDetailLines(width).slice(0, Math.max(0, rows - footer.length));
+        return [...preview, ...footer.map((line) => clipLine(line, width))];
+    }
+    focusAvailable(_dir) {
+        return this.host.capabilities.canFocusNode;
+    }
+    /** Ask the host to bring the selected ticket's node viewer into view. */
+    async focusSelectedSource() {
+        const item = this.items[this.selectedIndex];
+        if (item === undefined || this.focusingSource)
+            return;
+        this.focusingSource = true;
+        try {
+            const focused = await this.host.focusNode(nodeIdFor(item.dir));
+            if (focused)
+                this.close();
+            else {
+                this.status = 'Could not open that node’s viewer';
+                this.markDirty();
+            }
+        }
+        finally {
+            this.focusingSource = false;
+        }
+    }
+    passiveDetailLines(width) {
+        const selected = this.items[this.selectedIndex];
+        if (selected === undefined)
+            return [`  ${DIM}Select a pending interaction.${RESET}`];
+        const lines = [`  ${BOLD}${CYAN}${selected.title}${RESET}`, ''];
+        for (const rendered of renderMarkdown(selected.subtitle, Math.max(1, width - 2)))
+            lines.push(`  ${rendered}`);
+        const count = selected.kind === 'deck'
+            ? `${selected.interactionCount} question${selected.interactionCount === 1 ? '' : 's'}`
+            : '1 file to review';
+        lines.push('', `  ${DIM}${count}${RESET}`);
+        return lines.map((line) => clipLine(line, width));
+    }
+    withStatus(lines) {
+        const status = this.cancelConfirmation === undefined
+            ? this.status
+            : `cancel “${this.cancelConfirmation.title}”?  y yes · n/Esc no`;
+        if (status === undefined || this.rows < 1)
+            return lines;
+        const next = [...lines];
+        while (next.length < this.rows)
+            next.push('');
+        next[this.rows - 1] = `${YELLOW}${status}${RESET}`;
+        return next;
+    }
+    markDirty() {
+        this.options.onDirty();
+    }
+    watchRoots() {
+        const unsubscribe = watchInboxActivity(this.options.onInboxActivity ?? (() => this.invalidate()));
+        this.watchers.push({ close: unsubscribe });
+    }
+    watchSelected(dir) {
+        this.selectedWatcher?.close();
+        try {
+            this.selectedWatcher = watch(dir, (_event, file) => {
+                if (file === 'deck.json') {
+                    this.reloadSelectedDeck();
+                    return;
+                }
+                this.invalidate();
+            });
+        }
+        catch {
+            this.selectedWatcher = undefined;
+        }
+    }
+}
+function visibleWidth(line) { return line.replace(/\x1b\[[0-9;]*m/g, '').length; }
+function canonicalResultStatus(result) {
+    if (result === null)
+        return 'ticket was already resolved';
+    if (result.kind === 'deck')
+        return `ticket was already resolved: ${result.summary}`;
+    if (result.kind === 'review')
+        return `ticket was already resolved: ${result.result.approved ? 'approved' : 'review submitted'}`;
+    return 'ticket was already canceled';
+}

package/dist/clients/inbox/deck-adapter.d.ts

@@ -0,0 +1,29 @@
+import type { Deck, InteractionResponse } from '../../core/human/types.js';
+import type { Key } from './tui/keys.js';
+export interface DeckAdapterOptions {
+    dir: string;
+    deck: Deck;
+    cols: number;
+    rows: number;
+    onProgress?: (responses: InteractionResponse[]) => void;
+    onComplete: (responses: InteractionResponse[]) => void;
+    onBack: () => void;
+    onDirty: () => void;
+    onEditorRequest?: () => void;
+}
+/** Embeds the single deck renderer in a controller-owned rectangle. */
+export declare class DeckAdapter {
+    private readonly opts;
+    private panel;
+    private responses;
+    constructor(opts: DeckAdapterOptions);
+    render(): string[];
+    resize(cols: number, rows: number): string[];
+    inputBuffer(): string | undefined;
+    setInputBuffer(text: string): void;
+    canAcceptHostKeys(): boolean;
+    handleKey(input: string, key: Key): void;
+    /** Fresh descriptor reads preserve mounted answers for interaction ids still present. */
+    reload(deck: Deck): void;
+    close(): void;
+}

package/dist/clients/inbox/deck-adapter.js

@@ -0,0 +1,62 @@
+import { progressPath, readJson } from '../../core/human/convention.js';
+import { mountPanel } from './tui/panel.js';
+/** Embeds the single deck renderer in a controller-owned rectangle. */
+export class DeckAdapter {
+    opts;
+    panel;
+    responses = [];
+    constructor(opts) {
+        this.opts = opts;
+        this.responses = initialResponses(opts.deck, opts.dir);
+        this.panel = mountPanel({
+            deck: opts.deck,
+            progressPath: progressPath(opts.dir),
+            cols: opts.cols,
+            rows: opts.rows,
+            onProgress: (responses) => { this.responses = responses; opts.onProgress?.(responses); },
+            onComplete: opts.onComplete,
+            // A partial-deck exit is a valid completion for ordinary asks, but a
+            // notification is resolved only by its explicit acknowledgement.
+            onExit: () => { if (notificationsAcknowledged(opts.deck, this.responses))
+                opts.onComplete(this.responses); },
+            onDirty: opts.onDirty,
+            onEditorRequest: opts.onEditorRequest,
+        });
+    }
+    render() { return this.panel.render(); }
+    resize(cols, rows) { return this.panel.handleResize(cols, rows); }
+    inputBuffer() { return this.panel.getInputBuffer(); }
+    setInputBuffer(text) { this.panel.setInputBuffer(text); }
+    canAcceptHostKeys() { return this.panel.canAcceptHostKeys(); }
+    handleKey(input, key) {
+        if (key.escape && this.panel.atDeckTop()) {
+            this.opts.onBack();
+            return;
+        }
+        this.panel.handleKey(input, key);
+    }
+    /** Fresh descriptor reads preserve mounted answers for interaction ids still present. */
+    reload(deck) {
+        this.panel.loadDeck(deck, { progressPath: progressPath(this.opts.dir) });
+        this.opts.onDirty();
+    }
+    close() { this.panel.unmount(); }
+}
+function notificationsAcknowledged(deck, responses) {
+    const byId = new Map(responses.map((response) => [response.id, response]));
+    return deck.interactions.filter((interaction) => interaction.kind === 'notify').every((interaction) => {
+        const response = byId.get(interaction.id);
+        return response !== undefined && (response.selectedOptionId !== undefined || (response.selectedOptionIds?.length ?? 0) > 0 || (response.freetext?.trim() ?? '') !== '');
+    });
+}
+function initialResponses(deck, dir) {
+    const saved = readJson(progressPath(dir))?.responses;
+    if (Array.isArray(saved))
+        return saved;
+    return deck.interactions.flatMap((interaction) => {
+        const answer = interaction.preAnswered;
+        if (answer === undefined)
+            return [];
+        return [{ id: interaction.id, ...(answer.selectedOptionId === undefined ? {} : { selectedOptionId: answer.selectedOptionId }), ...(answer.selectedOptionIds === undefined ? {} : { selectedOptionIds: [...answer.selectedOptionIds] }), ...(answer.freetext === undefined ? {} : { freetext: answer.freetext }) }];
+    });
+}

package/dist/clients/inbox/layout.d.ts

@@ -0,0 +1,8 @@
+export interface InboxLayout {
+    mode: 'two-column' | 'list' | 'detail' | 'minimum';
+    listWidth: number;
+    detailWidth: number;
+    height: number;
+}
+/** Pure geometry for the centralized inbox surface. */
+export declare function inboxLayout(cols: number, rows: number, screen?: 'list' | 'detail'): InboxLayout;

package/dist/clients/inbox/layout.js

@@ -0,0 +1,9 @@
+/** Pure geometry for the centralized inbox surface. */
+export function inboxLayout(cols, rows, screen = 'list') {
+    if (cols < 60 || rows < 18)
+        return { mode: 'minimum', listWidth: cols, detailWidth: 0, height: rows };
+    if (cols < 96)
+        return { mode: screen, listWidth: cols, detailWidth: cols, height: rows };
+    const listWidth = Math.max(30, Math.min(44, Math.floor(cols / 3)));
+    return { mode: 'two-column', listWidth, detailWidth: cols - listWidth - 1, height: rows };
+}

package/dist/clients/inbox/resolve.d.ts

@@ -0,0 +1,10 @@
+import type { InteractionResponse } from '../../core/human/types.js';
+export declare function nodeIdFor(dir: string): string;
+export declare function resolveTicketDeck(dir: string, responses: InteractionResponse[]): Promise<void>;
+export declare function cancelTicketViaDaemon(dir: string, opts: {
+    reason: string;
+    actor: string;
+}): Promise<void>;
+export declare function daemonErrorMessage(err: unknown): string;
+export type ResolveFailure = 'unreachable' | 'already_resolved' | 'delivery_failed' | 'other';
+export declare function resolveFailureKind(err: unknown): ResolveFailure;

package/dist/clients/inbox/resolve.js

@@ -0,0 +1,34 @@
+import { basename } from 'node:path';
+import { ApiError } from '../../api/errors.js';
+import { cliClient } from '../../commands/api-client.js';
+export function nodeIdFor(dir) {
+    return basename(dir);
+}
+export async function resolveTicketDeck(dir, responses) {
+    await cliClient().resolveHumanTicket(nodeIdFor(dir), { responses });
+}
+export async function cancelTicketViaDaemon(dir, opts) {
+    await cliClient().cancelHumanTicket(nodeIdFor(dir), opts);
+}
+function isUnreachable(err) {
+    if (err instanceof ApiError)
+        return err.status === 503 || err.code === 'daemon_unavailable';
+    const code = err?.code;
+    return code === 'ECONNREFUSED' || code === 'ENOENT';
+}
+export function daemonErrorMessage(err) {
+    if (isUnreachable(err))
+        return 'could not reach crtrd — nothing was submitted';
+    if (err instanceof ApiError)
+        return err.message;
+    return err instanceof Error ? err.message : String(err);
+}
+export function resolveFailureKind(err) {
+    if (isUnreachable(err))
+        return 'unreachable';
+    if (err instanceof ApiError && err.status === 409 && err.code === 'ticket_already_resolved')
+        return 'already_resolved';
+    if (err instanceof ApiError && err.status === 500 && err.code === 'delivery_failed')
+        return 'delivery_failed';
+    return 'other';
+}