@actana/sdk 0.2.2

package/dist/core-registration-blob.d.ts

@@ -0,0 +1,52 @@
+import type { CoreLinkTlsMaterial } from "./core-link-socket.ts";
+/**
+ * A decoded registration blob. `endpoint` is the Core's `wss://host:port` core
+ * link; `label` is the machine's own suggestion for an alias and is not used by
+ * anything here.
+ */
+export type CoreRegistrationBlob = {
+    endpoint: string;
+    label?: string;
+    caCert: string;
+    clientCert: string;
+    clientKey: string;
+    bearer: string;
+};
+/**
+ * Everything a blob says about how to reach one Core, unpacked into the parts a
+ * client dials with — and **exposed rather than merely used**.
+ *
+ * `httpsBaseUrl` is the reason this type exists instead of a private helper.
+ * A Core's file surface will mount on the same mTLS server the WebSocket
+ * already listens on (#129 F2), and the same `tls` material authenticates both,
+ * so the connection a client holds is "a Core connection" and not "a socket"
+ * (#129's phase-3 guardrail 1). Naming the base URL now costs nothing and keeps
+ * that from being a breaking change to a published surface later. Nothing in
+ * this phase reads it.
+ */
+export type CoreConnection = {
+    /** The `wss://` (or `ws://`) core-link URL to dial. */
+    url: string;
+    /**
+     * The `https://` origin of the same Core, derived by swapping the scheme —
+     * the server that terminates the WebSocket is the server that will answer
+     * `/v1/…`. No path, no trailing slash.
+     */
+    httpsBaseUrl: string;
+    /** The PEM material for the mTLS handshake, or null for a plain `ws://` dial. */
+    tls: CoreLinkTlsMaterial | null;
+    /** The signed bearer presented in the `auth` frame right after the handshake. */
+    bearer: string;
+};
+/**
+ * Unpack a registration blob into a {@link CoreConnection}.
+ *
+ * `ws://` is accepted here even though a blob's endpoint must be `wss://` for a
+ * real Core (ADR 0002, and the Panel's decoder refuses anything else): this
+ * function converts a shape, it does not police one, and a loopback endpoint is
+ * how the Core's own tests and a local rig dial. A `ws://` endpoint yields
+ * `tls: null` — there is no handshake to pin — and the bearer is still
+ * presented, because the `auth` frame is the app-layer session either way.
+ */
+export declare function coreConnectionFromBlob(blob: CoreRegistrationBlob): CoreConnection;
+//# sourceMappingURL=core-registration-blob.d.ts.map

package/dist/core-registration-blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-registration-blob.d.ts","sourceRoot":"","sources":["../src/core-registration-blob.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,GAAG,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAChC,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,CAWjF"}

package/dist/core-registration-blob.js

@@ -0,0 +1,61 @@
+// The registration blob, as a Core client reads it.
+//
+// `actana setup` emits one base64 artifact per machine — `{endpoint, caCert,
+// clientCert, clientKey, bearer}` (CONTEXT.md "Registration blob"). It is the
+// whole of what a Core client needs to reach a Core: the endpoint to dial, the
+// PEM material for the mTLS handshake, and the bearer for the `auth` frame
+// (#129 D1).
+//
+// Two deliberate boundaries.
+//
+// **The SDK takes a blob object, never a file** (#129 D9). Where the blob is
+// kept — `~/.config/actana/cores/<name>.txt`, an environment variable, a
+// Panel's encrypted store — is the caller's business, and the CLI's config
+// resolution is its own ticket. Nothing here reads a path or base64-decodes a
+// paste.
+//
+// **The shape is declared here, not imported from `@actana/shared`.**
+// `packages/shared` is private and stays private ([ADR 0025][adr] D4), so an
+// SDK that imported `RegistrationBlob` from it would be a published package
+// with a dependency nobody outside this repository can resolve — the exact
+// alternative that ADR rejected. The two declarations are structurally
+// identical, so a Panel holding a `RegistrationBlob` passes it here with no
+// conversion, and the field names are the wire's rather than either side's.
+//
+// [adr]: ../../docs/adr/0025-the-protocol-ships-with-the-client.md
+/**
+ * Unpack a registration blob into a {@link CoreConnection}.
+ *
+ * `ws://` is accepted here even though a blob's endpoint must be `wss://` for a
+ * real Core (ADR 0002, and the Panel's decoder refuses anything else): this
+ * function converts a shape, it does not police one, and a loopback endpoint is
+ * how the Core's own tests and a local rig dial. A `ws://` endpoint yields
+ * `tls: null` — there is no handshake to pin — and the bearer is still
+ * presented, because the `auth` frame is the app-layer session either way.
+ */
+export function coreConnectionFromBlob(blob) {
+    const url = blob.endpoint.trim();
+    const secure = url.startsWith("wss://");
+    return {
+        url,
+        httpsBaseUrl: httpsBaseUrlFor(url),
+        tls: secure
+            ? { ca: blob.caCert, cert: blob.clientCert, key: blob.clientKey }
+            : null,
+        bearer: blob.bearer,
+    };
+}
+/**
+ * `wss://host:port` → `https://host:port`, `ws://…` → `http://…`. Anything
+ * else is returned unchanged rather than guessed at — a caller that handed this
+ * a URL with no WebSocket scheme knows something about its Core that this
+ * function does not.
+ */
+function httpsBaseUrlFor(url) {
+    if (url.startsWith("wss://"))
+        return `https://${url.slice("wss://".length)}`.replace(/\/+$/, "");
+    if (url.startsWith("ws://"))
+        return `http://${url.slice("ws://".length)}`.replace(/\/+$/, "");
+    return url;
+}
+//# sourceMappingURL=core-registration-blob.js.map

package/dist/core-registration-blob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-registration-blob.js","sourceRoot":"","sources":["../src/core-registration-blob.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,EAAE;AACF,6EAA6E;AAC7E,8EAA8E;AAC9E,+EAA+E;AAC/E,2EAA2E;AAC3E,aAAa;AACb,EAAE;AACF,6BAA6B;AAC7B,EAAE;AACF,6EAA6E;AAC7E,yEAAyE;AACzE,2EAA2E;AAC3E,8EAA8E;AAC9E,SAAS;AACT,EAAE;AACF,sEAAsE;AACtE,6EAA6E;AAC7E,4EAA4E;AAC5E,2EAA2E;AAC3E,uEAAuE;AACvE,4EAA4E;AAC5E,4EAA4E;AAC5E,EAAE;AACF,mEAAmE;AA6CnE;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAA0B;IAC/D,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IACxC,OAAO;QACL,GAAG;QACH,YAAY,EAAE,eAAe,CAAC,GAAG,CAAC;QAClC,GAAG,EAAE,MAAM;YACT,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE;YACjE,CAAC,CAAC,IAAI;QACR,MAAM,EAAE,IAAI,CAAC,MAAM;KACpB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,eAAe,CAAC,GAAW;IAClC,IAAI,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,WAAW,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACjG,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC;QAAE,OAAO,UAAU,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC9F,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/core-session.d.ts

@@ -0,0 +1,321 @@
+import type { CoreLinkPtySpawnHarness } from "./core-link-frames.ts";
+import type { CoreClient } from "./core-client.ts";
+type Unsubscribe = () => void;
+/**
+ * The command a fresh Session starts with, per harness, when the caller names
+ * none.
+ *
+ * The first token has to be that harness's canonical binary or the Core refuses
+ * the spawn — that is the allow-list, and it is enforced there, not here. What
+ * this table adds beyond the binary is the one flag a harness needs for the
+ * Core to hear about it at all: `codex` reports its lifecycle through hooks only
+ * when started with `--enable hooks`, and a Session that never reports is a
+ * Session {@link CoreSession.waitForIdle} waits on forever.
+ *
+ * A caller wanting anything else — a model, a resumed session id — passes
+ * `command` and takes the Core's answer on it.
+ */
+export declare const HARNESS_LAUNCH_COMMANDS: Readonly<Record<CoreLinkPtySpawnHarness, string>>;
+/**
+ * The statuses that mean the harness has stopped and is waiting on a human.
+ *
+ * `finished` is a completed turn, `needs-input` a permission prompt or a
+ * question, `interrupted` an escape, `terminated` a dead process, and
+ * `disconnected` a Core that restarted underneath the Session. Every one of them
+ * is a state that does not leave on its own, which is the property
+ * {@link CoreSession.waitForIdle} is waiting for — not "finished", which would
+ * hang on the question a caller could have answered.
+ */
+export declare const SETTLED_SESSION_STATUSES: ReadonlySet<string>;
+/**
+ * How a failed status read is re-asked: this many further attempts, this long
+ * apart.
+ *
+ * A retry of a *read*, and only of a read. It re-asks the Core a question whose
+ * answer the Core already settled on — it does not retry a prompt, a keystroke
+ * or a spawn, and it cannot make a Session look idle sooner than the Core says
+ * it is. The reason it has to exist: `needs-input`, `interrupted` and
+ * `terminated` reach this layer only as `task:updated`, and that event is
+ * appended once. Swallowing the read that failed on it leaves
+ * {@link CoreSession.waitForIdle} waiting for a report that will not be made
+ * again, and by design there is no deadline to end that wait.
+ *
+ * Bounded rather than indefinite: a link that is still down after three tries a
+ * quarter-second apart is not going to be talked round by a fourth, and a
+ * Session that polls forever is the busy-loop version of the timer #191 deleted.
+ */
+export declare const STATUS_READ_RETRIES = 3;
+export declare const STATUS_READ_RETRY_MS = 250;
+export type CoreSessionStartOptions = {
+    /**
+     * The Project to start this Session in. Either this or {@link taskId}: with a
+     * `projectId` a Task row is created on the Core first, because a Session's
+     * status lives on that row and a spawn naming a row that does not exist
+     * reports nothing back.
+     */
+    projectId?: string;
+    /** An existing Task to start a Session for. Either this or {@link projectId}. */
+    taskId?: string;
+    /** Title for the Task created from {@link projectId}. Ignored with a `taskId`. */
+    title?: string;
+    /**
+     * The working directory on the **Core's** machine.
+     *
+     * A machine path, validatable only there: the Core resolves it through
+     * `realpath` and refuses it unless it lands inside a registered Project root.
+     * Nothing here checks it — this process may not even be on that machine — so a
+     * bad path comes back as a rejected {@link start}, which is the design.
+     */
+    cwd: string;
+    /** Which harness to run. */
+    harness: CoreLinkPtySpawnHarness;
+    /**
+     * The starting prompt, handed to the Core as `initialInput`.
+     *
+     * Text, and no timing with it. The Core waits for the harness's TUI to settle,
+     * answers whatever dialog it opened, writes this, and sends the carriage
+     * return separately (ADR 0026). Omit it to start a Session with no prompt and
+     * drive it with {@link CoreSession.send}.
+     */
+    prompt?: string;
+    /**
+     * Override the launch command. Defaults to {@link HARNESS_LAUNCH_COMMANDS}.
+     * The Core allow-lists the binary and every flag; a command it does not accept
+     * rejects the spawn rather than being trimmed here.
+     */
+    command?: string;
+    /** PTY width. The screen is built at the same size, or the two disagree about wrapping. */
+    cols?: number;
+    /** PTY height. Same. */
+    rows?: number;
+    /** How many scrolled-off lines {@link CoreSession.screen} keeps. */
+    scrollback?: number;
+    /** Start the harness with permission prompts disabled. See {@link HARNESS_SKIP_PERMISSION_FLAGS}. */
+    dangerouslySkipPermissions?: boolean;
+    /** The Core's theme hint for the harness, so its output matches a Panel's. */
+    theme?: "dark" | "light";
+    /**
+     * Subscribe this client to the Core's event log if nothing has yet, so
+     * {@link CoreSession.waitForIdle} and {@link CoreSession.onStatus} have
+     * something to work from. Default true.
+     *
+     * Set it false when the events are already arriving by another route and the
+     * replay tail is not wanted — a {@link DurableCoreClient} subscribes itself,
+     * and this checks before sending anything, so the flag is for the case where a
+     * caller is doing something the check cannot see.
+     */
+    subscribeToEvents?: boolean;
+};
+/** What a Session settled on. */
+export type CoreSessionIdle = {
+    /** The Core's status for this Session — one of {@link SETTLED_SESSION_STATUSES}. */
+    status: string;
+    /** True when the harness's process exited rather than settling on a status. */
+    exited: boolean;
+    /** The process's exit code, when it exited. */
+    exitCode?: number;
+};
+export type CoreSessionWaitOptions = {
+    /**
+     * Give up after this long, in ms. **No deadline by default**, and that is not
+     * an oversight: a turn takes as long as the work takes, and a default that
+     * fires would report a healthy Session as broken — the same lie the flat
+     * timer #191 deleted used to tell. A caller that needs a deadline knows what
+     * its own is.
+     */
+    timeoutMs?: number;
+};
+/** The Core refused to start this Session. Carries the Core's own reason. */
+export declare class CoreSessionStartError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * One Session on one Core, driven programmatically.
+ *
+ * Built by {@link start}. Holds a screen fed from the Session's PTY, the Core's
+ * last reported status for it, and the listeners that keep both current — so
+ * it must be released with {@link dispose} (or {@link kill}, which disposes)
+ * when the caller is done, or those listeners outlive it on the client.
+ */
+export declare class CoreSession {
+    /** The Task this Session belongs to. Its status is the Session's status. */
+    readonly taskId: string;
+    /** The Core's id for this Session's PTY. */
+    readonly ptyId: string;
+    /** The harness running in it. */
+    readonly harness: CoreLinkPtySpawnHarness;
+    /** The command the Core was asked to start, after defaulting. */
+    readonly command: string;
+    private readonly client;
+    private readonly terminal;
+    private readonly unsubscribes;
+    private readonly dataListeners;
+    private readonly exitListeners;
+    private readonly statusListeners;
+    private readonly idleWaiters;
+    /**
+     * The Core's last reported status, or null before one has been *observed*.
+     *
+     * Null rather than the status the Task carried when this Session started, and
+     * the distinction is what makes {@link waitForIdle} correct: a caller starting
+     * a Session on a Task that was already `finished` is waiting for the next turn
+     * to end, not being told about the last one. Only a status learned from an
+     * event after {@link start} lands here.
+     */
+    private lastStatus;
+    private exit;
+    private disposed;
+    /** A status read is in flight; another event arrived while it was. */
+    private statusReadInFlight;
+    private statusReadAgain;
+    /** Re-asks left for the read that failed, and the timer carrying the next. */
+    private statusReadRetriesLeft;
+    private statusRetryTimer;
+    private constructor();
+    /**
+     * Start a Session and return once the Core has one running.
+     *
+     * What happens, in order: a Task row is created when the caller named a
+     * Project rather than a Task; the client is subscribed to the Core's event log
+     * if nothing has done that yet; the PTY's byte stream is wired up *before* the
+     * spawn goes out; and the spawn carries the prompt as `initialInput` for the
+     * Core to deliver.
+     *
+     * The stream is wired first on purpose. A harness starts printing its banner
+     * immediately, and on a Core that fans output out by subscription the
+     * connection that spawned a PTY is subscribed to it before the answer is even
+     * written — so the first bytes can be on the wire before this side knows the
+     * PTY's id. They are held and replayed into the screen once it is known, which
+     * is the difference between a transcript that starts at the beginning and one
+     * that starts wherever the round trip happened to end.
+     *
+     * Rejects with the Core's own message when the Core refuses: a working
+     * directory outside every registered Project root, a command whose binary is
+     * not that harness's, a flag that is not allow-listed, a harness that is not
+     * installed on that machine.
+     */
+    static start(client: CoreClient, opts: CoreSessionStartOptions): Promise<CoreSession>;
+    /**
+     * Write to the Session, exactly these bytes and nothing else.
+     *
+     * The equivalent of typing, not of prompting. Nothing is appended: no carriage
+     * return, no delay, no waiting for the harness to look ready. That restraint
+     * is the rule rather than a gap — a client that decided when to press Enter
+     * would be doing prompt delivery, which is the Core's (ADR 0026), and would do
+     * it differently from every other client. A *starting* prompt goes through
+     * {@link CoreSessionStartOptions.prompt}, where the Core owns the schedule.
+     *
+     * What this is for is everything after: answering the numbered option of a
+     * question the harness asked (`send("2")` then `send("\r")`), an escape
+     * (`send("\u001B")`), a follow-up typed into a harness already at its prompt.
+     *
+     * Resolves false when the Core did not accept the write — a PTY that has
+     * exited. Rejects when another Core client holds this Session's lock.
+     */
+    send(text: string): Promise<boolean>;
+    /**
+     * Every chunk of this Session's output, as it arrives.
+     *
+     * Raw PTY bytes, escape sequences included — the same stream the screen is
+     * built from. A caller wanting the rendered text wants {@link screen}; this is
+     * for one that is streaming somewhere else.
+     */
+    onData(cb: (chunk: string) => void): Unsubscribe;
+    /** The harness's process exited. Fires once. */
+    onExit(cb: (exit: {
+        exitCode: number;
+        signal?: number;
+    }) => void): Unsubscribe;
+    /** The Core reported a new status for this Session. */
+    onStatus(cb: (status: string) => void): Unsubscribe;
+    /**
+     * What a terminal would be showing for this Session, **including the lines
+     * that have scrolled off the top of it**.
+     *
+     * The scrolled-off part is not a bonus: a harness's conversation left the
+     * screen long ago, so the transcript is the scrollback and a caller reading
+     * only the visible rows reads a status bar. See `terminal-screen.ts` for what
+     * is emulated and what an erase costs.
+     *
+     * **Read it while the Session is alive.** A harness that runs full-screen
+     * leaves the alternate screen when it quits, and what a terminal shows after
+     * that is the main buffer — which is where nothing was ever printed. Reading
+     * before {@link kill}, not after, is the difference between the transcript and
+     * an empty string. (Claude Code 2.1.228 runs full-screen, so this is the
+     * ordinary case rather than an exotic one.)
+     */
+    screen(): string;
+    /** Only the rows on screen right now — for reading a dialog rather than a transcript. */
+    viewport(): string;
+    /** The screen as an array of lines, scrollback first. */
+    lines(): string[];
+    /** The Core's last reported status, or null before one has been observed. */
+    status(): string | null;
+    /** How the harness's process ended, or null while it is running. */
+    exitStatus(): {
+        exitCode: number;
+        signal?: number;
+    } | null;
+    /**
+     * Wait until the Core reports this Session settled — the harness finished its
+     * turn, asked a question, was interrupted, or died.
+     *
+     * **The Core's report, not a guess from the byte stream.** The harness's own
+     * lifecycle hooks move the Session's status on the Core, the change lands in
+     * the event log, and this is watching for it. Nothing here inspects output for
+     * quietness: that is a timing decision, it belongs to the Core, and the flat
+     * timer that used to make it here is what #191 deleted.
+     *
+     * Only statuses observed *after* this Session started count, so starting one
+     * on a Task that was already `finished` waits for this turn rather than
+     * returning last turn's answer. An exit resolves it too — a harness that died
+     * is not going to report anything else.
+     *
+     * Resolves as soon as it can: if the Session has already settled by the time
+     * this is called, it answers from what it saw.
+     *
+     * With no {@link CoreSessionWaitOptions.timeoutMs} this waits indefinitely, on
+     * purpose. A status read that fails is re-asked, so a link that blinks does
+     * not cost the report; a link that stays down does, and nothing here invents a
+     * status the Core never sent. A caller that must not hang on a broken Core
+     * passes a deadline it chose itself.
+     */
+    waitForIdle(opts?: CoreSessionWaitOptions): Promise<CoreSessionIdle>;
+    /** Resize the PTY and the screen together, so both agree about wrapping. */
+    resize(cols: number, rows: number): Promise<boolean>;
+    /** Kill the harness's process, then release this Session's listeners. */
+    kill(): Promise<boolean>;
+    /**
+     * Release the listeners this Session holds on the client, leaving the harness
+     * running. The screen stops advancing; the Core carries on.
+     */
+    dispose(): void;
+    private ingest;
+    private ingestExit;
+    /** @internal — called by {@link start} for events held during the spawn. */
+    private onCoreEvent;
+    /**
+     * Read this Session's status back off the Core.
+     *
+     * The `task:updated` event says a row moved, not what it moved to, and the
+     * Core owns the answer — so it is asked. Coalesced, because a turn's worth of
+     * hook events arrives in a burst and each one would otherwise be its own round
+     * trip: a read already in flight is re-run once at the end rather than queued
+     * behind itself.
+     *
+     * A read that fails is re-asked ({@link STATUS_READ_RETRIES}), because on
+     * `needs-input`, `interrupted` and `terminated` there is no second event to
+     * carry the news.
+     */
+    private readStatus;
+    /** The next re-ask of a read that failed. Cleared by {@link dispose}. */
+    private scheduleStatusRetry;
+    private noteStatus;
+    /** What {@link waitForIdle} would answer right now, or null if it must wait. */
+    private settledNow;
+    private releaseWaiters;
+}
+export {};
+//# sourceMappingURL=core-session.d.ts.map

package/dist/core-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-session.d.ts","sourceRoot":"","sources":["../src/core-session.ts"],"names":[],"mappings":"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"}