@tokenfactory/acc-runner 0.41.7 → 0.43.0

package/dist/user-auth/liveness.js

@@ -0,0 +1,128 @@
+/**
+ * Does this terminal's session still exist server-side? (AX-G3, gap G-16.)
+ *
+ * THE PROBLEM. Revoking a CLI login on Settings → Sessions deletes the
+ * `auth.sessions` row and cascades its refresh-token family, so this machine can
+ * never mint another access token. But the access token already in the keychain
+ * stays cryptographically valid until it expires — and PostgREST, which every
+ * `acc task` read goes through, verifies a JWT's signature without ever looking at
+ * the session table. So a revoked terminal would keep reading the board for the
+ * rest of the token's life, which is up to an hour of a revoke not being a revoke.
+ *
+ * The refresh path already handles the other half: once the token IS stale,
+ * refreshUserSession gets a 4xx and raises SignedOutError. This module covers the
+ * window before that — one cheap read of /api/auth/session-status per command.
+ *
+ * FAIL OPEN, ON PURPOSE. Only a positive `live: false` signs the operator out.
+ * An unreachable control plane, a 5xx, a deployment that predates the endpoint
+ * (404), an unwired session directory, a token with no session claim — all of
+ * those leave the session alone. The alternative is a pooler hiccup logging out
+ * every terminal in the fleet at once, which is a worse failure than the one this
+ * module exists to fix. The only thing we treat as definitive besides `live:false`
+ * is a 401 whose reason is `invalid_token`: that is the auth authority itself
+ * saying this credential is not a credential.
+ */
+import { loadConfig } from "../config.js";
+import { signInCommand } from "../cli-name.js";
+import { accessTokenIsFresh, clearUserSession, cliUserAgent, loadUserSession, SignedOutError, } from "./session.js";
+export const SESSION_STATUS_PATH = "/api/auth/session-status";
+/**
+ * Map one HTTP answer onto a verdict. Pure, so every branch is asserted directly
+ * rather than through a fetch double.
+ */
+export function decideLiveness(status, body) {
+    const b = (body ?? {});
+    if (status === 401) {
+        // requireUser answers 401 with a discriminated reason. `invalid_token` is the
+        // authority rejecting the credential — definitive. `auth_unreachable` and the
+        // header-shape classes are not about this session at all.
+        const reason = typeof b.reason === "string" ? b.reason : "unauthenticated";
+        if (reason === "invalid_token")
+            return { live: false, verified: true, reason };
+        return { live: true, verified: false, reason };
+    }
+    if (status !== 200) {
+        // 404 = an older deployment without this endpoint. 5xx = the control plane.
+        // Neither is evidence about the session.
+        return { live: true, verified: false, reason: `http_${status}` };
+    }
+    if (b.live === false && b.verified === true) {
+        return { live: false, verified: true, reason: typeof b.reason === "string" ? b.reason : "revoked" };
+    }
+    return {
+        live: true,
+        verified: b.verified === true,
+        reason: typeof b.reason === "string" ? b.reason : "live",
+    };
+}
+/** Ask the control plane about this session. Never throws — a transport failure
+ *  is an unverified verdict, not a sign-out. */
+export async function probeUserSession(session, deps = {}) {
+    const doFetch = deps.fetch ?? fetch;
+    const base = loadConfig().publicUrl.replace(/\/+$/, "");
+    try {
+        const res = await doFetch(`${base}${SESSION_STATUS_PATH}`, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${session.access_token}`,
+                "User-Agent": deps.userAgent ?? cliUserAgent(),
+            },
+        });
+        const body = await res.json().catch(() => ({}));
+        return decideLiveness(res.status, body);
+    }
+    catch (err) {
+        return {
+            live: true,
+            verified: false,
+            reason: `unreachable: ${err.message?.slice(0, 120) ?? "error"}`,
+        };
+    }
+}
+/** The message an operator sees when their terminal was revoked from the web. */
+export function revokedMessage() {
+    return ("This terminal's ACC session is no longer valid — it was revoked from " +
+        `Settings → Sessions, or it expired. Run \`${signInCommand()}\` to sign in again.`);
+}
+/**
+ * One probe per process, so two calls inside a single command do not both go to
+ * the network. A new command is a new process, which is what "takes effect on its
+ * next call" means for a CLI.
+ */
+let inFlight = null;
+/** Test seam: forget the memoized verdict. */
+export function resetSessionLivenessProbe() {
+    inFlight = null;
+}
+async function runCheck(deps) {
+    const session = await loadUserSession();
+    // No session at all: the command's own "not signed in" error is the right
+    // message, and it does not need a network call to say it.
+    if (!session)
+        return;
+    // A stale token is about to be refreshed, and a refresh against a revoked
+    // session already fails with the same error. Probing would be a second network
+    // call to learn what the first one is about to tell us.
+    if (!accessTokenIsFresh(session, deps.now?.() ?? Date.now()))
+        return;
+    const verdict = await probeUserSession(session, deps);
+    if (verdict.live)
+        return;
+    // Drop the dead credential: leaving it would make every later command fail the
+    // same way, and would make `whoami` claim a session that no longer exists.
+    await clearUserSession();
+    throw new SignedOutError(revokedMessage());
+}
+/**
+ * Called at the top of every person-lane command. Throws SignedOutError when the
+ * session has been revoked; returns silently in every other case, including every
+ * case where we could not tell.
+ */
+export function ensureUserSessionLive(deps = {}) {
+    // A rejected memo is deliberately kept: a second caller in the same process
+    // should see the same sign-out, not probe a session we already know is gone.
+    inFlight ??= runCheck(deps);
+    return inFlight;
+}
+//# sourceMappingURL=liveness.js.map

package/dist/user-auth/liveness.js.map

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

package/dist/user-auth/session.d.ts

@@ -0,0 +1,82 @@
+/** Keychain account for the person session. The runner's is "default". */
+export declare const USER_SESSION_SLOT: "user";
+/** Refresh this far ahead of expiry, so a long RPC never straddles it. */
+export declare const REFRESH_SKEW_SECONDS = 120;
+export interface StoredUserSession {
+    access_token: string;
+    refresh_token: string;
+    /** ISO-8601 instant at which access_token expires. */
+    access_expires_at: string;
+    user_id: string;
+    email: string | null;
+    /** Resolved by the exchange, so a fresh machine needs no connection env. */
+    supabase_url: string;
+    anon_key: string;
+}
+/**
+ * `acc-cli/1.2.3 (darwin; my-laptop)`. The hostname is filtered to header-safe
+ * characters — a hostname with a stray byte must not make an auth call throw
+ * where it would otherwise have succeeded.
+ */
+export declare function cliUserAgent(hostname?: string): string;
+/** Raised when the session is gone for good — revoked, expired, or never there. */
+export declare class SignedOutError extends Error {
+    constructor(message: string);
+}
+export declare function saveUserSession(session: StoredUserSession): Promise<void>;
+export declare function loadUserSession(): Promise<StoredUserSession | null>;
+export declare function clearUserSession(): Promise<boolean>;
+/** The token payload GoTrue answers `/verify` and `/token` with. */
+export interface GoTrueTokenResponse {
+    access_token?: string;
+    refresh_token?: string;
+    expires_in?: number;
+    expires_at?: number;
+    user?: {
+        id?: string;
+        email?: string | null;
+    } | null;
+}
+export interface GoTrueTarget {
+    supabaseUrl: string;
+    anonKey: string;
+}
+/** Injectable so the tests drive the rules without a network. */
+export interface GoTrueDeps {
+    fetch?: typeof fetch;
+    now?: () => number;
+    userAgent?: string;
+}
+/**
+ * Fold a token response into a session, or fail loudly. A response missing
+ * either token, or the user id, is not a session however cheerful its status
+ * code was — better to refuse than to persist a credential we cannot refresh.
+ */
+export declare function toStoredSession(json: GoTrueTokenResponse, target: GoTrueTarget, now: number): StoredUserSession;
+/** Spend the one-time grant from /api/auth/device-code for a real session. */
+export declare function verifyEmailOtp(target: GoTrueTarget, params: {
+    email: string;
+    token: string;
+}, deps?: GoTrueDeps): Promise<StoredUserSession>;
+/**
+ * Trade the refresh token for a fresh pair. A 4xx here is the revocation path,
+ * not an outage: GoTrue answers 400/401 for a token that was revoked (the
+ * sessions surface deleted the row) or already rotated, and both mean the same
+ * thing to the operator — sign in again.
+ */
+export declare function refreshUserSession(session: StoredUserSession, deps?: GoTrueDeps): Promise<StoredUserSession>;
+export declare function accessTokenIsFresh(session: StoredUserSession, now?: number): boolean;
+/**
+ * The accessor everything downstream should use: a live access token for the
+ * signed-in human, refreshed and re-persisted when it is close to expiry.
+ *
+ * The rotated successor is written back BEFORE the token is returned, because a
+ * caller that used a token whose refresh partner never landed would be one crash
+ * away from replaying a spent token — which GoTrue treats as reuse.
+ *
+ * A revoked session clears the keychain slot on the way out. Leaving a dead
+ * credential in the keychain would make every later command fail the same way
+ * with nothing to show for it; removing it makes `auth status` honest.
+ */
+export declare function getUserAccessToken(deps?: GoTrueDeps): Promise<string>;
+//# sourceMappingURL=session.d.ts.map

package/dist/user-auth/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/user-auth/session.ts"],"names":[],"mappings":"AAmCA,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,EAAG,MAAe,CAAC;AAEjD,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,GAAE,MAAsB,GAAG,MAAM,CAGrE;AAED,mFAAmF;AACnF,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAI5B;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE;AAED,wBAAgB,eAAe,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAEnE;AAED,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAEnD;AAID,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iEAAiE;AACjE,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA4BD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,MAAM,GACV,iBAAiB,CAoBnB;AAED,8EAA8E;AAC9E,wBAAsB,cAAc,CAClC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EACxC,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAW5B;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,GAAE,UAAe,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAiB5B;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,iBAAiB,EAC1B,GAAG,GAAE,MAAmB,GACvB,OAAO,CAIT;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,GAAE,UAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAc/E"}

package/dist/user-auth/session.js

@@ -0,0 +1,172 @@
+/**
+ * The PERSON's CLI session (AX-G1 DEVICE-FLOW-GENERALIZE, gap G-16).
+ *
+ * `acc-runner login` enrols a MACHINE: it ends holding an ACC-signed JWT that
+ * impersonates its owner, plus a runner row in the fleet. This module is the
+ * other thing a terminal might want to be — a human, signed in as themselves,
+ * with no runner attached. It is the credential AX-G2 acts under.
+ *
+ * WHAT THE CREDENTIAL IS
+ * ----------------------------------------------------------------------------
+ * An ordinary Supabase session: the same access/refresh pair the user's browser
+ * holds, obtained by spending the one-time grant /api/auth/device-code hands
+ * back (see that file for why the CLI, not the server, spends it). Everything
+ * follows from that choice:
+ *
+ *   * REFRESH is GoTrue's, not ACC's. `/auth/v1/token?grant_type=refresh_token`,
+ *     with rotation — so the successor MUST be written back to the keychain on
+ *     every refresh, or the next start replays a spent token.
+ *   * REVOCATION is real and it is not ours. The session is a row in
+ *     `auth.sessions`; Settings → Sessions deletes it and the delete cascades
+ *     the refresh-token family. The next refresh here fails, and `signedOut`
+ *     below is how that becomes "you were signed out" rather than a stack trace.
+ *   * STORAGE is the OS keychain and nothing else. Its own account slot, so it
+ *     cannot disturb the runner session's frozen entry.
+ *
+ * The USER AGENT is stamped deliberately. GoTrue records it on the session row,
+ * and api/auth/sessions-core.ts turns it into the device label on the sessions
+ * surface — so this string is the difference between "Unknown device" and
+ * "acc CLI · my-laptop" when the user decides what to revoke.
+ */
+import os from "node:os";
+import { clearSlot, loadSlot, saveSlot } from "../keychain.js";
+import { signInCommand } from "../cli-name.js";
+import { PACKAGE_VERSION } from "../pkg-version.js";
+/** Keychain account for the person session. The runner's is "default". */
+export const USER_SESSION_SLOT = "user";
+/** Refresh this far ahead of expiry, so a long RPC never straddles it. */
+export const REFRESH_SKEW_SECONDS = 120;
+/**
+ * `acc-cli/1.2.3 (darwin; my-laptop)`. The hostname is filtered to header-safe
+ * characters — a hostname with a stray byte must not make an auth call throw
+ * where it would otherwise have succeeded.
+ */
+export function cliUserAgent(hostname = os.hostname()) {
+    const host = hostname.replace(/[^\w.-]+/g, "-").slice(0, 63) || "unknown-host";
+    return `acc-cli/${PACKAGE_VERSION} (${process.platform}; ${host})`;
+}
+/** Raised when the session is gone for good — revoked, expired, or never there. */
+export class SignedOutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SignedOutError";
+    }
+}
+// ── Keychain ───────────────────────────────────────────────────────────────
+export function saveUserSession(session) {
+    return saveSlot(USER_SESSION_SLOT, session);
+}
+export function loadUserSession() {
+    return loadSlot(USER_SESSION_SLOT);
+}
+export function clearUserSession() {
+    return clearSlot(USER_SESSION_SLOT);
+}
+async function postGoTrue(target, path, body, deps) {
+    const doFetch = deps.fetch ?? fetch;
+    const res = await doFetch(`${target.supabaseUrl.replace(/\/+$/, "")}${path}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            apikey: target.anonKey,
+            // Recorded on auth.sessions.user_agent — this is the device label.
+            "User-Agent": deps.userAgent ?? cliUserAgent(),
+        },
+        body: JSON.stringify(body),
+    });
+    let json = {};
+    try {
+        json = (await res.json());
+    }
+    catch {
+        /* a non-JSON body is handled by the shape check below */
+    }
+    return { status: res.status, json };
+}
+/**
+ * Fold a token response into a session, or fail loudly. A response missing
+ * either token, or the user id, is not a session however cheerful its status
+ * code was — better to refuse than to persist a credential we cannot refresh.
+ */
+export function toStoredSession(json, target, now) {
+    const access = json.access_token;
+    const refresh = json.refresh_token;
+    const userId = json.user?.id;
+    if (!access || !refresh || !userId) {
+        throw new Error("auth response did not contain a usable session");
+    }
+    const expiresAt = typeof json.expires_at === "number"
+        ? json.expires_at * 1000
+        : now + (typeof json.expires_in === "number" ? json.expires_in : 3600) * 1000;
+    return {
+        access_token: access,
+        refresh_token: refresh,
+        access_expires_at: new Date(expiresAt).toISOString(),
+        user_id: userId,
+        email: json.user?.email ?? null,
+        supabase_url: target.supabaseUrl,
+        anon_key: target.anonKey,
+    };
+}
+/** Spend the one-time grant from /api/auth/device-code for a real session. */
+export async function verifyEmailOtp(target, params, deps = {}) {
+    const { status, json } = await postGoTrue(target, "/auth/v1/verify", { type: "email", email: params.email, token: params.token }, deps);
+    if (status !== 200) {
+        throw new Error(`sign-in grant was rejected (HTTP ${status})`);
+    }
+    return toStoredSession(json, target, deps.now?.() ?? Date.now());
+}
+/**
+ * Trade the refresh token for a fresh pair. A 4xx here is the revocation path,
+ * not an outage: GoTrue answers 400/401 for a token that was revoked (the
+ * sessions surface deleted the row) or already rotated, and both mean the same
+ * thing to the operator — sign in again.
+ */
+export async function refreshUserSession(session, deps = {}) {
+    const target = { supabaseUrl: session.supabase_url, anonKey: session.anon_key };
+    const { status, json } = await postGoTrue(target, "/auth/v1/token?grant_type=refresh_token", { refresh_token: session.refresh_token }, deps);
+    if (status >= 400 && status < 500) {
+        throw new SignedOutError(`This CLI session was revoked or expired. Run \`${signInCommand()}\`.`);
+    }
+    if (status !== 200) {
+        throw new Error(`token refresh failed (HTTP ${status})`);
+    }
+    return toStoredSession(json, target, deps.now?.() ?? Date.now());
+}
+export function accessTokenIsFresh(session, now = Date.now()) {
+    const expiry = new Date(session.access_expires_at).getTime();
+    if (!Number.isFinite(expiry))
+        return false;
+    return expiry - now > REFRESH_SKEW_SECONDS * 1000;
+}
+/**
+ * The accessor everything downstream should use: a live access token for the
+ * signed-in human, refreshed and re-persisted when it is close to expiry.
+ *
+ * The rotated successor is written back BEFORE the token is returned, because a
+ * caller that used a token whose refresh partner never landed would be one crash
+ * away from replaying a spent token — which GoTrue treats as reuse.
+ *
+ * A revoked session clears the keychain slot on the way out. Leaving a dead
+ * credential in the keychain would make every later command fail the same way
+ * with nothing to show for it; removing it makes `auth status` honest.
+ */
+export async function getUserAccessToken(deps = {}) {
+    const session = await loadUserSession();
+    if (!session) {
+        throw new SignedOutError(`Not signed in. Run \`${signInCommand()}\`.`);
+    }
+    if (accessTokenIsFresh(session, deps.now?.() ?? Date.now()))
+        return session.access_token;
+    try {
+        const rotated = await refreshUserSession(session, deps);
+        await saveUserSession(rotated);
+        return rotated.access_token;
+    }
+    catch (err) {
+        if (err instanceof SignedOutError)
+            await clearUserSession();
+        throw err;
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/user-auth/session.js.map

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

package/dist/user-cli/chat.d.ts

@@ -0,0 +1,44 @@
+import { type UserApiDeps } from "./client.js";
+export interface ChatOptions {
+    conversation?: string;
+    json?: boolean;
+}
+export interface SseEvent {
+    event: string;
+    data: unknown;
+}
+/**
+ * Split a raw SSE buffer into whole events, returning the unconsumed tail.
+ *
+ * The tail matters: a chunk boundary lands mid-frame constantly on a token
+ * stream, and an implementation that parsed each chunk independently would drop
+ * every event unlucky enough to straddle one.
+ */
+export declare function drainSseBuffer(buffer: string): {
+    events: SseEvent[];
+    rest: string;
+};
+/** What one completed turn tells the caller, so a REPL can continue the thread. */
+export interface TurnResult {
+    conversationId: string | null;
+    text: string;
+    queued: boolean;
+}
+/**
+ * Send one message and render the reply. Exported separately from the command so
+ * the REPL below can loop over it while holding the conversation id, and so the
+ * tests can drive a whole turn through a fetch double.
+ */
+export declare function streamTurn(message: string, opts: ChatOptions, deps?: UserApiDeps & {
+    write?: (chunk: string) => void;
+}): Promise<TurnResult>;
+/**
+ * `acc chat "question"` for one shot, `echo q | acc chat` for a pipe, and a bare
+ * `acc chat` on a terminal for a REPL that holds the conversation open. The REPL
+ * is not a nicety: without it every follow-up question would need the operator
+ * to copy a conversation id back out of the previous line.
+ */
+export declare function chatCommand(words: string[], opts?: ChatOptions, deps?: UserApiDeps & {
+    write?: (chunk: string) => void;
+}): Promise<void>;
+//# sourceMappingURL=chat.d.ts.map

package/dist/user-cli/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/user-cli/chat.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,WAAW;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAwBnF;AAED,mFAAmF;AACnF,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;CACjB;AAMD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,WAAW,EACjB,IAAI,GAAE,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC3D,OAAO,CAAC,UAAU,CAAC,CAkFrB;AASD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,GAAE,WAAgB,EACtB,IAAI,GAAE,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC3D,OAAO,CAAC,IAAI,CAAC,CAoCf"}

package/dist/user-cli/chat.js

@@ -0,0 +1,199 @@
+/**
+ * `acc chat` — Ask-ACC from the terminal.
+ *
+ * Posts to the same `/api/chat/stream` endpoint the browser uses, authenticated
+ * with the operator's own session, and renders the SSE stream as it arrives.
+ * Using the shared endpoint rather than calling a model directly is the whole
+ * point: the tool catalog, the delegation ceiling, the capability manifest, the
+ * per-turn tool cap and the chat audit trail are all server-side, so a terminal
+ * turn is governed exactly like a browser turn and cannot become a side door.
+ *
+ * TWO SHAPES OF ANSWER. With a BYOK key the endpoint streams `token` events and
+ * the reply appears here word by word. Without one, an eligible turn is ENQUEUED
+ * for a companion runner to drain and the stream ends after `queued` — there is
+ * no inline answer to print, so this says so and hands back the conversation id
+ * rather than pretending the turn failed.
+ */
+import chalk from "chalk";
+import { createInterface } from "node:readline/promises";
+import { userFetch } from "./client.js";
+import { cliName } from "../cli-name.js";
+/**
+ * Split a raw SSE buffer into whole events, returning the unconsumed tail.
+ *
+ * The tail matters: a chunk boundary lands mid-frame constantly on a token
+ * stream, and an implementation that parsed each chunk independently would drop
+ * every event unlucky enough to straddle one.
+ */
+export function drainSseBuffer(buffer) {
+    const events = [];
+    let rest = buffer;
+    for (;;) {
+        const boundary = rest.indexOf("\n\n");
+        if (boundary === -1)
+            break;
+        const frame = rest.slice(0, boundary);
+        rest = rest.slice(boundary + 2);
+        let event = "message";
+        const dataLines = [];
+        for (const line of frame.split("\n")) {
+            if (line.startsWith("event:"))
+                event = line.slice(6).trim();
+            else if (line.startsWith("data:"))
+                dataLines.push(line.slice(5).trim());
+        }
+        if (dataLines.length === 0)
+            continue;
+        let data = dataLines.join("\n");
+        try {
+            data = JSON.parse(dataLines.join("\n"));
+        }
+        catch {
+            /* a non-JSON payload is passed through as the raw string */
+        }
+        events.push({ event, data });
+    }
+    return { events, rest };
+}
+function asRecord(data) {
+    return data && typeof data === "object" ? data : {};
+}
+/**
+ * Send one message and render the reply. Exported separately from the command so
+ * the REPL below can loop over it while holding the conversation id, and so the
+ * tests can drive a whole turn through a fetch double.
+ */
+export async function streamTurn(message, opts, deps = {}) {
+    const say = deps.log ?? ((line) => console.log(line));
+    const write = deps.write ?? ((chunk) => process.stdout.write(chunk));
+    const res = await userFetch("/api/chat/stream", { body: { message, conversation_id: opts.conversation } }, deps);
+    if (!res.ok) {
+        // The endpoint's own body carries the actionable reason (no provider, no
+        // membership, rate limit); a bare status code would send the operator to
+        // the logs for something they can read here.
+        let detail = `HTTP ${res.status}`;
+        try {
+            const body = asRecord(await res.json());
+            if (typeof body.error === "string")
+                detail = `${body.error} (HTTP ${res.status})`;
+        }
+        catch {
+            /* keep the status-only detail */
+        }
+        throw new Error(`Chat request failed: ${detail}`);
+    }
+    if (!res.body)
+        throw new Error("Chat response carried no stream.");
+    let conversationId = opts.conversation ?? null;
+    let text = "";
+    let queued = false;
+    let buffer = "";
+    let wroteAnything = false;
+    const decoder = new TextDecoder();
+    const reader = res.body.getReader();
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const drained = drainSseBuffer(buffer);
+        buffer = drained.rest;
+        for (const { event, data } of drained.events) {
+            const payload = asRecord(data);
+            switch (event) {
+                case "conversation":
+                    if (typeof payload.id === "string")
+                        conversationId = payload.id;
+                    break;
+                case "token": {
+                    const chunk = typeof payload.text === "string" ? payload.text : "";
+                    text += chunk;
+                    if (!opts.json) {
+                        write(chunk);
+                        wroteAnything = wroteAnything || chunk.length > 0;
+                    }
+                    break;
+                }
+                case "tool_call":
+                    if (!opts.json)
+                        say(chalk.gray(`\n  · ${String(payload.name ?? "tool")}…`));
+                    break;
+                case "queued":
+                case "turn":
+                    queued = true;
+                    break;
+                case "error":
+                    throw new Error(String(payload.message ?? "chat stream failed"));
+                case "done":
+                    if (typeof payload.conversation_id === "string")
+                        conversationId = payload.conversation_id;
+                    if (payload.queued === true)
+                        queued = true;
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    if (wroteAnything)
+        write("\n");
+    if (opts.json) {
+        say(JSON.stringify({ conversation_id: conversationId, text, queued }, null, 2));
+    }
+    else if (queued && !text) {
+        say(chalk.yellow("· Queued to a companion runner — no inline answer. Open the conversation in ACC to read the reply."));
+    }
+    return { conversationId, text, queued };
+}
+/** Read a piped message when one was not passed as an argument. */
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8").trim();
+}
+/**
+ * `acc chat "question"` for one shot, `echo q | acc chat` for a pipe, and a bare
+ * `acc chat` on a terminal for a REPL that holds the conversation open. The REPL
+ * is not a nicety: without it every follow-up question would need the operator
+ * to copy a conversation id back out of the previous line.
+ */
+export async function chatCommand(words, opts = {}, deps = {}) {
+    const say = deps.log ?? ((line) => console.log(line));
+    const inline = words.join(" ").trim();
+    if (inline) {
+        const result = await streamTurn(inline, opts, deps);
+        if (!opts.json && result.conversationId) {
+            say(chalk.gray(`\nContinue: ${cliName()} chat --conversation ${result.conversationId}`));
+        }
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        const piped = await readStdin();
+        if (!piped)
+            throw new Error("No message given (pass one as an argument or pipe it in).");
+        await streamTurn(piped, opts, deps);
+        return;
+    }
+    say(chalk.bold("Ask ACC. Blank line or Ctrl-D to exit."));
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    // Ctrl-D closes the input without settling the pending question(), which would
+    // hang the process on an invisible prompt. Racing the close event turns EOF
+    // into the same clean exit a blank line gives.
+    const closed = new Promise((resolve) => rl.once("close", () => resolve(null)));
+    let conversation = opts.conversation;
+    try {
+        for (;;) {
+            const answer = await Promise.race([rl.question(chalk.cyan("\n› ")), closed]);
+            const line = (answer ?? "").trim();
+            if (!line)
+                break;
+            const result = await streamTurn(line, { ...opts, conversation }, deps);
+            conversation = result.conversationId ?? conversation;
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=chat.js.map