@actana/sdk 0.3.2 → 0.4.1

package/dist/core-session.d.ts

@@ -16,6 +16,33 @@ type Unsubscribe = () => void;
  * `command` and takes the Core's answer on it.
  */
 export declare const HARNESS_LAUNCH_COMMANDS: Readonly<Record<CoreLinkPtySpawnHarness, string>>;
+/**
+ * Each harness's spelling of "do not stop to ask me", appended to the default
+ * command when {@link CoreSessionStartOptions.dangerouslySkipPermissions} is
+ * set.
+ *
+ * The option and the flag are two halves of one gesture and the Core checks
+ * both **directions** of it (issue 177 finding 2): a flag with no option is a
+ * rejected spawn, and since that issue an option with no flag is one too. It
+ * used to be neither — the Core accepted the mismatch, launched an interactive
+ * harness, and let a caller that believed itself unattended sit on a permission
+ * prompt nobody was watching. So this table is not a convenience: it is the
+ * only thing standing between `dangerouslySkipPermissions: true` and a refused
+ * spawn, for every caller that does not pass its own `command`.
+ *
+ * OpenCode has no such flag, and `null` says so. That is a fact about the
+ * vendor's CLI rather than a gap here, and the Core reads it the same way — it
+ * is the one harness where the option is allowed to arrive with no flag behind
+ * it, because there is no flag to send.
+ *
+ * Exported because it is the answer to "what does auto mode look like for this
+ * harness", and a caller building its own command needs the same cell of the
+ * same table. Two transcriptions of a vendor fact is one more than can be kept
+ * in step; finding 1 of the same issue was that mistake in the binary column.
+ */
+export declare const HARNESS_SKIP_PERMISSION_FLAGS: Readonly<Record<CoreLinkPtySpawnHarness, string | null>>;
+/** The flag that puts `harness` in auto mode, or null where it ships none. */
+export declare function harnessAutoModeFlag(harness: CoreLinkPtySpawnHarness): string | null;
 /**
  * The statuses that mean the harness has stopped and is waiting on a human.
  *
@@ -106,6 +133,32 @@ export type CoreSessionStartOptions = {
      */
     subscribeToEvents?: boolean;
 };
+export type CoreSessionAttachOptions = {
+    /** The Session to join. It must have a live PTY; see {@link CoreSessionAttachError}. */
+    taskId: string;
+    /** Screen width for the transcript this attachment renders. */
+    cols?: number;
+    /** Screen height. Same. */
+    rows?: number;
+    /** How many scrolled-off lines {@link CoreSession.screen} keeps. */
+    scrollback?: number;
+    /** As {@link CoreSessionStartOptions.subscribeToEvents}. Default true. */
+    subscribeToEvents?: boolean;
+    /**
+     * Paint the Core's replay ring into the screen before returning. Default true.
+     *
+     * On by default because a caller that attaches to read a turn wants the
+     * conversation it lands in the middle of, not the tail of one turn — and the
+     * ring belongs to the PTY, so it is readable now and gone when the harness
+     * exits. Off is for a caller that wants only what this attachment saw.
+     *
+     * **It does not turn the PTY subscription off**, which is a separate thing and
+     * is unconditional: without one, `onData` and `onExit` never fire against a
+     * multi-connection Core, and an attachment that could not hear an exit is one
+     * whose wait outlives the process it is about.
+     */
+    replay?: boolean;
+};
 /** What a Session settled on. */
 export type CoreSessionIdle = {
     /** The Core's status for this Session — one of {@link SETTLED_SESSION_STATUSES}. */
@@ -125,12 +178,37 @@ export type CoreSessionWaitOptions = {
      */
     timeoutMs?: number;
 };
+export type CoreSessionTurnWaitOptions = CoreSessionWaitOptions & {
+    /**
+     * Only a settling status learned at an event id **strictly greater** than this
+     * one ends the wait — the id the Core stamped a delivery with
+     * ({@link CoreSession.deliver}).
+     *
+     * 0, the default, is no cursor: any settled status the Session is known to be
+     * in ends the wait, which is what {@link CoreSession.waitForIdle} has always
+     * done.
+     */
+    afterEventId?: 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;
     });
 }
+/**
+ * There is nothing running to attach to.
+ *
+ * Its own kind because it is the one failure an attach has that a start does
+ * not, and because the alternative is worse than an error: a wait against a
+ * Session whose harness has already exited has nothing that will ever report a
+ * turn, so it would hang until the caller's deadline and then blame the Core.
+ */
+export declare class CoreSessionAttachError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
 /**
  * One Session on one Core, driven programmatically.
  *
@@ -144,17 +222,70 @@ export declare class CoreSession {
     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;
+    /**
+     * The harness running in it, or `null` on a Session this process did not
+     * start — {@link attach} joins a PTY that is already running, and the Core
+     * publishes no harness for one. A caller that needs the name reads it off the
+     * Task row, which is where it lives.
+     */
+    readonly harness: CoreLinkPtySpawnHarness | null;
+    /**
+     * The command the Core was asked to start, after defaulting, or `null` on an
+     * {@link attach} — the command was decided by whoever spawned the PTY and the
+     * Core does not publish it afterwards. Null is "this side does not know",
+     * never "there was none".
+     */
+    readonly command: string | null;
+    /**
+     * Will anything move this Session to `running` when a turn begins (issue 84,
+     * issue 177 finding 4)?
+     *
+     * The Core's answer for this Session and not a property of the harness
+     * family: it depends on which hooks actually landed on that machine and on
+     * whether the vendor fires them. `false` today for `cursor-cli` — the Core
+     * writes `.cursor/hooks.json` and cursor-agent never fires
+     * `beforeSubmitPrompt` — and for `codex` until an operator reviews the newly
+     * installed hooks with `/hooks`. Both still report a turn's *end*.
+     *
+     * What that means for a caller: {@link waitForIdle} is unaffected, because it
+     * waits for a settled status and turn *end* is reported. What is missing is
+     * everything in between. A Session with `reportsTurnStart === false` will sit
+     * at its pre-turn status for the whole of a turn that is genuinely running,
+     * which is indistinguishable from a Session that never started — so a caller
+     * that shows progress, or that treats "not running" as "stuck", has to read
+     * this and say so rather than infer activity from a status that will not
+     * move. The Panel's answer is a terminal-input fallback; the `actana` CLI's
+     * is to print the asymmetry.
+     *
+     * `false` on a Core too old to answer, which is the safe direction: a
+     * redundant caveat, never a silently statusless Session.
+     *
+     * `null` on an {@link attach}, which is a different thing again: the Core
+     * answers this question on a **spawn**, so a Session joined after the fact has
+     * no answer rather than a negative one. **No wait consults this field** (#289
+     * A) — turn *end* is reported by every harness family, and that is what every
+     * wait here is waiting for.
+     */
+    readonly reportsTurnStart: boolean | null;
     private readonly client;
     private readonly terminal;
     private readonly unsubscribes;
     private readonly dataListeners;
     private readonly exitListeners;
     private readonly statusListeners;
+    /**
+     * Everyone waiting for a turn to end, each with the event id it counts from.
+     * A waiter with `afterEventId: 0` takes any settled status; one carrying a
+     * delivery stamp takes only a status learned after it.
+     */
     private readonly idleWaiters;
+    /**
+     * This Session asked the Core for its PTY's stream, so {@link dispose} owes it
+     * a matching `ptyUnsubscribe`. False for a spawned Session: the Core
+     * subscribes the connection that spawned a PTY, inside the spawn, and nothing
+     * here asked for that.
+     */
+    private subscribedToPty;
     /**
      * The Core's last reported status, or null before one has been *observed*.
      *
@@ -165,6 +296,18 @@ export declare class CoreSession {
      * event after {@link start} lands here.
      */
     private lastStatus;
+    /**
+     * The event id {@link lastStatus} was learned at, or 0 when it was not learned
+     * from an event — the status {@link attach} seeded from the Task row.
+     *
+     * This is what makes a cursored wait possible (#289 A). "Has this Session
+     * settled?" answers with whatever it is sitting at, including last turn's
+     * answer; "has this Session settled **since event N**?" is the question a
+     * caller that just delivered a prompt is actually asking, and it needs a
+     * *where* as well as a *what*. A seeded status carries 0 on purpose: 0 is
+     * greater than nothing, so it can never satisfy a real cursor.
+     */
+    private lastStatusEventId;
     private exit;
     private disposed;
     /** A status read is in flight; another event arrived while it was. */
@@ -197,6 +340,43 @@ export declare class CoreSession {
      * installed on that machine.
      */
     static start(client: CoreClient, opts: CoreSessionStartOptions): Promise<CoreSession>;
+    /**
+     * Join a Session that is **already running**, for the length of a turn (#289).
+     *
+     * The gap this closes: {@link start} is the only way into a `CoreSession`, and
+     * it spawns. Everything this class offers a caller after the first turn — the
+     * screen, the status, the wait — was unreachable for a Session somebody else
+     * started, or that this process started and hung up on. Awaiting a follow-up
+     * turn is therefore SDK work rather than a flag on a command, and this is it.
+     *
+     * What it does, in order, and the order is the point:
+     *
+     *   1. subscribe to the event log, if nothing has, so a status change that
+     *      lands during the rest of this is heard rather than missed;
+     *   2. resolve the Task's live PTY — **once**, and every write and wait made
+     *      through the returned Session uses that resolution, so there is no
+     *      window between delivering text and starting to wait for it;
+     *   3. wire the byte stream, the exit and the events **before** subscribing;
+     *   4. subscribe to that PTY, which is what makes the Core send this
+     *      connection its bytes and its exit at all;
+     *   5. seed the screen from the Core's replay ring, and the last known status
+     *      from the Session snapshot.
+     *
+     * **The seeded status carries event id 0**, which is what keeps it honest.
+     * `waitForIdle` will answer from it — that is `actana session wait` on a
+     * Session already sitting at `needs-input`, and answering immediately is
+     * right, because no turn was asked for. {@link waitForTurnEnd} with a delivery
+     * stamp will not: 0 can never be greater than a real cursor, so a wait for the
+     * turn a write starts cannot be answered by the turn before it.
+     *
+     * Rejects with {@link CoreSessionAttachError} when the Task has no live PTY —
+     * a harness that exited, or a Session id that is not one. **Only that.** A
+     * link that blinked during the subscribe, the replay or the status read
+     * rejects with an ordinary `Error`: the two are different next steps, and
+     * reporting a busy Core as a dead harness sends a caller to `resume` for a
+     * Session that is running perfectly well.
+     */
+    static attach(client: CoreClient, opts: CoreSessionAttachOptions): Promise<CoreSession>;
     /**
      * Write to the Session, exactly these bytes and nothing else.
      *
@@ -215,6 +395,25 @@ export declare class CoreSession {
      * exited. Rejects when another Core client holds this Session's lock.
      */
     send(text: string): Promise<boolean>;
+    /**
+     * {@link send}, with the Core stamping the delivery in its event log and
+     * answering with the id — the cursor {@link waitForTurnEnd} counts from
+     * (#289 A).
+     *
+     * Exactly the same bytes and exactly as little timing as `send`: the stamp is
+     * a fact recorded about a write that already happened, not a schedule imposed
+     * on one. A caller wanting to await the turn its text starts writes with this
+     * and waits from what it returns, and the two are one round trip apart with no
+     * window between them in which the Session could settle unobserved.
+     *
+     * `deliveryEventId` is 0 when the Core did not stamp — a write the PTY
+     * refused, a Core that predates the stamp, a PTY with no Task behind it. 0 is
+     * not a cursor: a caller that waits from it is waiting with none.
+     */
+    deliver(text: string): Promise<{
+        ok: boolean;
+        deliveryEventId: number;
+    }>;
     /**
      * Every chunk of this Session's output, as it arrives.
      *
@@ -283,6 +482,32 @@ export declare class CoreSession {
      * passes a deadline it chose itself.
      */
     waitForIdle(opts?: CoreSessionWaitOptions): Promise<CoreSessionIdle>;
+    /**
+     * Wait for the end of the turn that follows event `afterEventId` — the wait
+     * `session send --wait` is built on (#289 A, B).
+     *
+     * **Why a cursor.** {@link waitForIdle} answers from the status the Session is
+     * already sitting at, and for a Session that was started here that is right:
+     * it has observed no status yet, so anything it hears is this turn's. For a
+     * Session that was **already running** it is a lie waiting to be told — a
+     * harness parked on `needs-input` is settled, so a wait attached to it and
+     * started after a write would return before the harness had read a character,
+     * reporting the previous turn's answer as this one's. Passing the id the Core
+     * stamped the delivery with turns "is it settled?" into "has it settled since
+     * the thing I sent?", and only the second question has a truthful answer.
+     *
+     * `afterEventId: 0` (the default) is no cursor and is {@link waitForIdle}.
+     *
+     * Resolves on **any** of {@link SETTLED_SESSION_STATUSES}, not on `finished`
+     * alone: a turn that ended on a permission prompt, an escape or a dead harness
+     * ended, and a caller waiting for `finished` there waits forever on exactly the
+     * cases it most needs to hear about. A process exit resolves it too.
+     *
+     * Nothing here reads the byte stream, and nothing here consults
+     * {@link reportsTurnStart}. Turn end is reported by every harness family; turn
+     * *start* is not, which is why no wait is keyed on it.
+     */
+    waitForTurnEnd(opts?: CoreSessionTurnWaitOptions): 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. */
@@ -308,14 +533,67 @@ export declare class CoreSession {
      * 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.
+     *
+     * **What it reads never advances the wait cursor** (#289 A). This path is
+     * reached for an event that did not say what it changed — a rename, an
+     * archive, a Core too old to name the patched status — and the row it reads
+     * back may be carrying the status of a turn that ended long before. Answering
+     * a cursored wait from that is the early resolution the cursor exists to
+     * prevent, so a read updates `lastStatus` and leaves the cursor where it was.
      */
     private readStatus;
+    /**
+     * Read the Core's current status for this Session once, at attach, at event
+     * id 0 — "what it is sitting at", never "what it did".
+     *
+     * A missing row is not an error here: the Session has a live PTY (the attach
+     * proved it), and a Core that does not list it yet will report its status like
+     * any other, through the event log this attachment is already listening to.
+     */
+    private seedStatus;
     /** The next re-ask of a read that failed. Cleared by {@link dispose}. */
     private scheduleStatusRetry;
+    /**
+     * Record a status the Core reported, and where in the log it was reported.
+     *
+     * **A repeated status is still news**, which is why the cursor moves even when
+     * the string does not (#289 A). A harness that never moved its Session to
+     * `running` ends its second turn by patching `finished` onto a row that
+     * already said `finished`; the value did not change, but a turn ended, and a
+     * waiter counting from a delivery stamp is waiting for exactly that. What
+     * stays gated on a change is {@link onStatus}, which is about the value.
+     */
     private noteStatus;
     /** What {@link waitForIdle} would answer right now, or null if it must wait. */
     private settledNow;
+    /**
+     * What a wait counting from `afterEventId` would answer right now, or null.
+     *
+     * An **exit** answers every wait, cursor or none: a harness whose process is
+     * gone will not report anything else, and a caller left waiting for a status
+     * after that waits forever. A status answers a cursored wait only when it was
+     * learned after the cursor — a seeded status (event id 0) never does.
+     */
+    private settledSince;
     private releaseWaiters;
 }
+/**
+ * The launch command a Session gets when its caller named none — the whole of
+ * it, auto-mode flag included.
+ *
+ * Exported because it is the one answer to "what will `start` actually run",
+ * and issue 177 is what happens when that question has two answers. Both
+ * halves of the command come out of the same tables the Core validates against
+ * ({@link HARNESS_LAUNCH_COMMANDS} for the binary, which is `cursor-agent` and
+ * not `cursor-cli`; {@link HARNESS_SKIP_PERMISSION_FLAGS} for the flag), so a
+ * test can put this straight through the Core's `resolveSpawnPlan` and find
+ * out rather than reason about it.
+ *
+ * `skipPermissions` is the caller's request, not a promise about the result:
+ * OpenCode has no such flag and so gets none, which the Core accepts, and
+ * every other harness gets the one it spells auto mode with, which the Core
+ * now *requires* whenever the option is set.
+ */
+export declare function harnessLaunchCommand(harness: CoreLinkPtySpawnHarness, skipPermissions: boolean): string;
 export {};
 //# sourceMappingURL=core-session.d.ts.map

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

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