@skrr-ai/cli 0.1.8

package/dist/lib/worklogs.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.worklogApi = exports.WORKLOG_STATUSES = exports.WORKLOG_CATEGORIES = void 0;
+exports.worklogWasCreated = worklogWasCreated;
+exports.renderWorklogList = renderWorklogList;
+exports.renderWorklogEntry = renderWorklogEntry;
+/**
+ * worklogs.ts — request-based client for `/api/worklogs`.
+ *
+ * A **worklog** entry is a durable note an agent keeps about work it did:
+ * keyed, categorised, and searchable. It is not memory (which is about the
+ * user) and not a task (which is work to do) — it is the record of work done.
+ *
+ * ── Why this file exists ──────────────────────────────────────────────────
+ *
+ * Worklog writing was an MCP capability, and MCP tools execute in the CLOUD.
+ * An agent pinned to a LOCAL daemon runtime — Claude Code, Codex, skrr Code
+ * alike — could read a worklog and could not write one, because the route
+ * exposed three endpoints and all three were reads (OSK-3495).
+ *
+ * That is the same gap the CLI already closes for every sibling domain: tasks,
+ * spaces, skills, memory, files, approvals, artifacts. This is worklogs taking
+ * its place in that list.
+ *
+ * ── Addressing ────────────────────────────────────────────────────────────
+ *
+ * Every entry is addressed by (agent, key). `main` is the user-scoped agent —
+ * it is stored with a null agentId, so `main` and an agent with the same key
+ * are two different entries, and neither shadows the other.
+ */
+const data_provider_1 = require("@skrr-ai/data-provider");
+const format_1 = require("./format");
+const triggers_1 = require("./triggers");
+exports.WORKLOG_CATEGORIES = [
+    'task_completed',
+    'milestone',
+    'discovery',
+    'optimization',
+    'fix',
+    'other',
+];
+exports.WORKLOG_STATUSES = ['completed', 'in_progress', 'superseded'];
+/**
+ * Whether a saved worklog entry was freshly inserted vs. an existing one
+ * overwritten. `save` is an upsert with exactly two outcomes and the caller
+ * cares which one they got — "did I add a second entry, or overwrite this
+ * morning's?". The server does not label the outcome, but a row it just
+ * inserted carries the same createdAt and updatedAt. Kept as a pure helper so
+ * both the plain and --json renderers state the same fact (OSK-4863).
+ */
+function worklogWasCreated(entry) {
+    return Boolean(entry.createdAt) && entry.createdAt === entry.updatedAt;
+}
+const base = (agentId) => `/api/worklogs/${encodeURIComponent(agentId)}`;
+const entry = (agentId, key) => `${base(agentId)}/${encodeURIComponent(key)}`;
+exports.worklogApi = {
+    list: (agentId, query) => data_provider_1.request.get((0, triggers_1.withQuery)(base(agentId), query)),
+    get: (agentId, key) => data_provider_1.request.get(entry(agentId, key)),
+    stats: (agentId) => data_provider_1.request.get(`${base(agentId)}/stats`),
+    search: (agentId, query) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(agentId)}/search`, query)),
+    save: (agentId, body) => data_provider_1.request.post(base(agentId), body),
+    update: (agentId, key, body) => data_provider_1.request.patch(entry(agentId, key), body),
+    remove: (agentId, key) => data_provider_1.request.delete(entry(agentId, key)),
+};
+function shortDate(value) {
+    if (!value)
+        return '—';
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? '—' : parsed.toISOString().slice(0, 10);
+}
+function renderWorklogList(entries, log) {
+    if (entries.length === 0) {
+        log('No worklog entries.');
+        return;
+    }
+    (0, format_1.renderTable)(entries.map((item) => ({
+        key: item.key,
+        title: item.title ?? '—',
+        category: item.category ?? '—',
+        status: item.status ?? '—',
+        updated: shortDate(item.updatedAt ?? item.createdAt),
+    })), [
+        { key: 'key', header: 'KEY', maxWidth: 30 },
+        { key: 'title', header: 'TITLE', maxWidth: 44 },
+        { key: 'category', header: 'CATEGORY' },
+        { key: 'status', header: 'STATUS' },
+        { key: 'updated', header: 'UPDATED' },
+    ], log);
+}
+function renderWorklogEntry(item, log) {
+    log(item.title ?? item.key);
+    log(`key       ${item.key}`);
+    log(`category  ${item.category ?? '—'}`);
+    log(`status    ${item.status ?? '—'}`);
+    log(`updated   ${shortDate(item.updatedAt ?? item.createdAt)}`);
+    if (item.description) {
+        log('');
+        log(item.description);
+    }
+}

package/dist/lib/workspace-header.d.ts

@@ -0,0 +1,22 @@
+type WorkspaceEnv = Record<string, string | undefined>;
+/**
+ * Apply the effective CLI workspace to a request without weakening the
+ * daemon-owned session boundary.
+ *
+ * Ordinary CLI calls preserve an explicit caller header (for example an outbox
+ * replay) and otherwise use `OVERSKY_WORKSPACE_ID`. Autonomous Agent calls
+ * discard both of those ambient inputs and use only the canonical session
+ * workspace. A workspace-less Agent session therefore stays personal.
+ *
+ * The durable selection from `skrr workspaces use` reaches this function as that
+ * same env var — `seedWorkspaceEnv()` copies it in at process start, and only
+ * when nothing already set it. Deliberately NOT read here: this runs on every
+ * outbound request, and a function that reaches into `~/.skrr` would make the
+ * CLI's most load-bearing header depend on the machine running the test suite —
+ * green on a fresh checkout, differently green on a laptop that happens to have
+ * a workspace selected. Seeding also means the selection is honoured by every
+ * other `OVERSKY_WORKSPACE_ID` reader (the outbox queue, `runtime-context`)
+ * without each of them learning about a config file.
+ */
+export declare function withWorkspaceHeader(headers: Record<string, string>, env?: WorkspaceEnv): Record<string, string>;
+export {};

package/dist/lib/workspace-header.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withWorkspaceHeader = withWorkspaceHeader;
+const WORKSPACE_HEADER = 'x-workspace-id';
+/**
+ * Apply the effective CLI workspace to a request without weakening the
+ * daemon-owned session boundary.
+ *
+ * Ordinary CLI calls preserve an explicit caller header (for example an outbox
+ * replay) and otherwise use `OVERSKY_WORKSPACE_ID`. Autonomous Agent calls
+ * discard both of those ambient inputs and use only the canonical session
+ * workspace. A workspace-less Agent session therefore stays personal.
+ *
+ * The durable selection from `skrr workspaces use` reaches this function as that
+ * same env var — `seedWorkspaceEnv()` copies it in at process start, and only
+ * when nothing already set it. Deliberately NOT read here: this runs on every
+ * outbound request, and a function that reaches into `~/.skrr` would make the
+ * CLI's most load-bearing header depend on the machine running the test suite —
+ * green on a fresh checkout, differently green on a laptop that happens to have
+ * a workspace selected. Seeding also means the selection is honoured by every
+ * other `OVERSKY_WORKSPACE_ID` reader (the outbox queue, `runtime-context`)
+ * without each of them learning about a config file.
+ */
+function withWorkspaceHeader(headers, env = process.env) {
+    const scoped = { ...headers };
+    const workspaceHeaderKeys = Object.keys(scoped).filter((key) => key.toLowerCase() === WORKSPACE_HEADER);
+    if (env.OVERSKY_AUTONOMOUS_SESSION === '1') {
+        for (const key of workspaceHeaderKeys)
+            delete scoped[key];
+        const sessionWorkspaceId = env.OVERSKY_SESSION_WORKSPACE_ID?.trim();
+        if (sessionWorkspaceId)
+            scoped['X-Workspace-Id'] = sessionWorkspaceId;
+        return scoped;
+    }
+    if (workspaceHeaderKeys.length === 0) {
+        const workspaceId = env.OVERSKY_WORKSPACE_ID?.trim();
+        if (workspaceId)
+            scoped['X-Workspace-Id'] = workspaceId;
+    }
+    return scoped;
+}

package/dist/lib/workspace-transfer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Move an agent or a space tree to another workspace.
+ *
+ * Design: docs/architecture/ownership-axes-implementation-plan-2026-08-15.zh-CN.md §7.1.
+ *
+ * Authorization is double-ended and enforced server-side: SHARE on the thing
+ * being moved, plus MEMBERSHIP of the destination workspace. The CLI does not
+ * pre-check either — a client-side gate would only ever be a second opinion
+ * about a decision the server has to make anyway.
+ */
+export interface WorkspaceTransferResult {
+    moved: boolean;
+    reason?: string;
+    previousWorkspaceId?: string | null;
+    workspaceId: string | null;
+    /** Space transfers only: every space id that moved, root first. */
+    spaceIds?: string[];
+}
+export declare function transferAgentWorkspace(agentId: string, workspaceId: string): Promise<WorkspaceTransferResult>;
+export declare function transferSpaceWorkspace(spaceId: string, workspaceId: string): Promise<WorkspaceTransferResult>;

package/dist/lib/workspace-transfer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferAgentWorkspace = transferAgentWorkspace;
+exports.transferSpaceWorkspace = transferSpaceWorkspace;
+const api_fetch_1 = require("./api-fetch");
+async function transferAgentWorkspace(agentId, workspaceId) {
+    return (0, api_fetch_1.apiFetch)(`/api/agents/${encodeURIComponent(agentId)}/transfer-workspace`, { method: 'POST', body: { workspaceId } });
+}
+async function transferSpaceWorkspace(spaceId, workspaceId) {
+    return (0, api_fetch_1.apiFetch)(`/api/spaces/${encodeURIComponent(spaceId)}/transfer-workspace`, { method: 'POST', body: { workspaceId } });
+}

package/dist/lib/workspaces.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The workspaces this account belongs to.
+ *
+ * Inline path literals rather than a composed builder: `domain-api-parity`
+ * resolves a CLI command to an endpoint by reading these strings, and a helper
+ * that assembles the URL is opaque to it — the endpoint then reads as
+ * unreachable and gets allow-listed, which is a check going green on an
+ * assertion it never made.
+ */
+export interface WorkspaceRow {
+    id: string;
+    name?: string;
+    slug?: string;
+    role?: string;
+}
+/**
+ * The list, plus WHICH row an unscoped write lands in.
+ *
+ * `defaultWorkspaceId` is a property of the CALLER, not of any workspace, which
+ * is why it rides the envelope rather than a row. Null when the server could
+ * not resolve one — that is different from "there isn't one", and the caller
+ * must not print a guess either way.
+ *
+ * `WorkspaceRow` previously declared `isPersonal?: boolean`. The API has never
+ * sent that field and nothing here ever read it: the declaration was its only
+ * occurrence in the package. It is removed rather than left as a plausible
+ * hook, because a field that looks like the answer and is always `undefined` is
+ * how the "which one is Personal?" question went unanswered in the first place.
+ */
+export interface WorkspaceListing {
+    rows: WorkspaceRow[];
+    defaultWorkspaceId: string | null;
+}
+/**
+ * `GET /api/workspaces` answers `{ data, has_more, next_cursor }` on EVERY
+ * path, including its just-in-time provisioning branch. Reading `.workspaces`
+ * — which nothing returns — made this resolve to `[]` for every account, so
+ * `workspaces list` reported "you do not belong to any workspace yet" to a user
+ * who owned one and `workspaces use` could never match the name they typed.
+ *
+ * The array form is still accepted so a future unwrapped response does not
+ * break the CLI, but `data` is the shape that exists today.
+ *
+ * PAGINATED, and followed to the end rather than taking page one: this list is
+ * what `matchWorkspace` resolves against, so a truncated page does not read as
+ * "fewer choices", it reads as "that workspace does not exist".
+ */
+/**
+ * One sentence for "nothing is selected, so where do my writes go?"
+ *
+ * Names the workspace when the server told us which one it is, and says
+ * plainly that it could not tell when it did not. The old copy asserted "your
+ * Personal Workspace" unconditionally — a name that appears in no listing, so a
+ * user in a team workspace and a personal one could not resolve it, and could
+ * be wrong about where their writes and billing land.
+ */
+export declare function describeUnselectedWorkspace(listing: WorkspaceListing): string;
+export declare function listWorkspaces(): Promise<WorkspaceRow[]>;
+/** `listWorkspaces`, keeping the envelope's caller-level fields. */
+export declare function listWorkspaceListing(): Promise<WorkspaceListing>;
+export declare function getWorkspace(workspaceId: string): Promise<WorkspaceRow>;
+/**
+ * Resolve what a human typed to a workspace they are actually in.
+ *
+ * Accepts an id, a slug, or a name, and resolves against the caller's OWN
+ * membership list rather than by fetching the id directly. Selecting a
+ * workspace you do not belong to is not a thing to store and discover later:
+ * every request would carry a header the server refuses, and the failure would
+ * surface far from the command that caused it.
+ *
+ * An ambiguous name is a REFUSAL, not a first match. Two workspaces can share a
+ * display name, and picking one silently would send this machine's whole
+ * session history to the wrong team.
+ */
+export declare function matchWorkspace(rows: WorkspaceRow[], ref: string): WorkspaceRow[];

package/dist/lib/workspaces.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeUnselectedWorkspace = describeUnselectedWorkspace;
+exports.listWorkspaces = listWorkspaces;
+exports.listWorkspaceListing = listWorkspaceListing;
+exports.getWorkspace = getWorkspace;
+exports.matchWorkspace = matchWorkspace;
+const api_fetch_1 = require("./api-fetch");
+/**
+ * The server's workspace document can include presentation metadata such as an
+ * avatar source. This CLI surface is a selector, not a workspace export: keep
+ * its JSON response to the documented row contract so nested metadata (and any
+ * URL query values it carries) never lands in routine automation logs.
+ */
+function toWorkspaceRow(row) {
+    return {
+        id: row.id,
+        ...(typeof row.name === 'string' ? { name: row.name } : {}),
+        ...(typeof row.slug === 'string' ? { slug: row.slug } : {}),
+        ...(typeof row.role === 'string' ? { role: row.role } : {}),
+    };
+}
+/**
+ * `GET /api/workspaces` answers `{ data, has_more, next_cursor }` on EVERY
+ * path, including its just-in-time provisioning branch. Reading `.workspaces`
+ * — which nothing returns — made this resolve to `[]` for every account, so
+ * `workspaces list` reported "you do not belong to any workspace yet" to a user
+ * who owned one and `workspaces use` could never match the name they typed.
+ *
+ * The array form is still accepted so a future unwrapped response does not
+ * break the CLI, but `data` is the shape that exists today.
+ *
+ * PAGINATED, and followed to the end rather than taking page one: this list is
+ * what `matchWorkspace` resolves against, so a truncated page does not read as
+ * "fewer choices", it reads as "that workspace does not exist".
+ */
+/**
+ * One sentence for "nothing is selected, so where do my writes go?"
+ *
+ * Names the workspace when the server told us which one it is, and says
+ * plainly that it could not tell when it did not. The old copy asserted "your
+ * Personal Workspace" unconditionally — a name that appears in no listing, so a
+ * user in a team workspace and a personal one could not resolve it, and could
+ * be wrong about where their writes and billing land.
+ */
+function describeUnselectedWorkspace(listing) {
+    const fallback = listing.rows.find((row) => row.id === listing.defaultWorkspaceId);
+    if (fallback) {
+        const label = fallback.name ? `"${fallback.name}"` : fallback.id;
+        return `No workspace selected — sessions resolve to ${label} (${fallback.id}), your default workspace.`;
+    }
+    if (listing.defaultWorkspaceId) {
+        // A default pointing somewhere this listing does not contain is worth
+        // saying out loud rather than smoothing over: it usually means membership
+        // was removed without the default being cleared.
+        return `No workspace selected — sessions resolve to your default workspace (${listing.defaultWorkspaceId}), which is not in the list above.`;
+    }
+    return 'No workspace selected, and the server did not report a default — sessions resolve server-side.';
+}
+async function listWorkspaces() {
+    return (await listWorkspaceListing()).rows;
+}
+/** `listWorkspaces`, keeping the envelope's caller-level fields. */
+async function listWorkspaceListing() {
+    const rows = [];
+    let defaultWorkspaceId = null;
+    let cursor;
+    // Bounded: a cursor the server keeps echoing must not spin forever.
+    for (let page = 0; page < 50; page += 1) {
+        const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : '';
+        const response = await (0, api_fetch_1.apiFetch)(`/api/workspaces${query}`);
+        if (!Array.isArray(response) && response?.defaultWorkspaceId) {
+            defaultWorkspaceId = response.defaultWorkspaceId;
+        }
+        const page_rows = Array.isArray(response)
+            ? response
+            : (response?.data ?? response?.workspaces ?? []);
+        rows.push(...page_rows.filter((row) => Boolean(row?.id)).map(toWorkspaceRow));
+        const next = Array.isArray(response) ? null : (response?.next_cursor ?? null);
+        if (!next || next === cursor)
+            break;
+        cursor = next;
+    }
+    return { rows, defaultWorkspaceId };
+}
+async function getWorkspace(workspaceId) {
+    return (0, api_fetch_1.apiFetch)(`/api/workspaces/${encodeURIComponent(workspaceId)}`);
+}
+/**
+ * Resolve what a human typed to a workspace they are actually in.
+ *
+ * Accepts an id, a slug, or a name, and resolves against the caller's OWN
+ * membership list rather than by fetching the id directly. Selecting a
+ * workspace you do not belong to is not a thing to store and discover later:
+ * every request would carry a header the server refuses, and the failure would
+ * surface far from the command that caused it.
+ *
+ * An ambiguous name is a REFUSAL, not a first match. Two workspaces can share a
+ * display name, and picking one silently would send this machine's whole
+ * session history to the wrong team.
+ */
+function matchWorkspace(rows, ref) {
+    const needle = ref.trim().toLowerCase();
+    const byId = rows.filter((row) => row.id.toLowerCase() === needle);
+    if (byId.length)
+        return byId;
+    const bySlug = rows.filter((row) => (row.slug ?? '').toLowerCase() === needle);
+    if (bySlug.length)
+        return bySlug;
+    return rows.filter((row) => (row.name ?? '').toLowerCase() === needle);
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/aead.d.ts

@@ -0,0 +1,24 @@
+/** Key length in bytes (256 bits). */
+export declare const AEAD_KEY_LEN = 32;
+/** Nonce length in bytes (96-bit GCM standard). */
+export declare const AEAD_NONCE_LEN = 12;
+/** GCM authentication tag length in bytes (128 bits). */
+export declare const AEAD_TAG_LEN = 16;
+/** Result of an AEAD seal operation. */
+export interface AeadSealed {
+    readonly nonce: Buffer;
+    readonly ct: Buffer;
+    readonly tag: Buffer;
+}
+/**
+ * Seal `plaintext` under `key` with optional `aad`. A fresh 96-bit nonce is
+ * generated per call — callers must never reuse nonces for the same key.
+ *
+ * Throws if `key` is not exactly 32 bytes.
+ */
+export declare function aeadSeal(plaintext: Buffer, key: Buffer, aad?: Buffer): AeadSealed;
+/**
+ * Open a sealed AEAD blob. Throws on any authentication failure (wrong key,
+ * wrong AAD, truncated ciphertext). Never silently returns garbage.
+ */
+export declare function aeadOpen(sealed: AeadSealed, key: Buffer, aad?: Buffer): Buffer;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/aead.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AEAD_TAG_LEN = exports.AEAD_NONCE_LEN = exports.AEAD_KEY_LEN = void 0;
+exports.aeadSeal = aeadSeal;
+exports.aeadOpen = aeadOpen;
+/**
+ * aead.ts — shared AES-256-GCM primitive for auth-core envelope formats.
+ *
+ * CredentialEnvelope (L12 at-rest) uses AES-256-GCM. This module owns the
+ * bare cipher operation; framing, versioning, and serialization live in its
+ * envelope module.
+ */
+const node_crypto_1 = __importDefault(require("node:crypto"));
+/** AEAD algorithm. */
+const ALG = 'aes-256-gcm';
+/** Key length in bytes (256 bits). */
+exports.AEAD_KEY_LEN = 32;
+/** Nonce length in bytes (96-bit GCM standard). */
+exports.AEAD_NONCE_LEN = 12;
+/** GCM authentication tag length in bytes (128 bits). */
+exports.AEAD_TAG_LEN = 16;
+/**
+ * Seal `plaintext` under `key` with optional `aad`. A fresh 96-bit nonce is
+ * generated per call — callers must never reuse nonces for the same key.
+ *
+ * Throws if `key` is not exactly 32 bytes.
+ */
+function aeadSeal(plaintext, key, aad) {
+    if (!Buffer.isBuffer(key) || key.length !== exports.AEAD_KEY_LEN) {
+        throw new TypeError(`aeadSeal: key must be a ${exports.AEAD_KEY_LEN}-byte Buffer`);
+    }
+    const nonce = node_crypto_1.default.randomBytes(exports.AEAD_NONCE_LEN);
+    const cipher = node_crypto_1.default.createCipheriv(ALG, key, nonce);
+    if (aad && aad.length > 0)
+        cipher.setAAD(aad);
+    const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return { nonce, ct, tag };
+}
+/**
+ * Open a sealed AEAD blob. Throws on any authentication failure (wrong key,
+ * wrong AAD, truncated ciphertext). Never silently returns garbage.
+ */
+function aeadOpen(sealed, key, aad) {
+    if (!Buffer.isBuffer(key) || key.length !== exports.AEAD_KEY_LEN) {
+        throw new TypeError(`aeadOpen: key must be a ${exports.AEAD_KEY_LEN}-byte Buffer`);
+    }
+    if (!Buffer.isBuffer(sealed.nonce) || sealed.nonce.length !== exports.AEAD_NONCE_LEN) {
+        throw new Error('aeadOpen: invalid nonce length');
+    }
+    if (!Buffer.isBuffer(sealed.tag) || sealed.tag.length !== exports.AEAD_TAG_LEN) {
+        throw new Error('aeadOpen: invalid auth tag length');
+    }
+    if (!Buffer.isBuffer(sealed.ct)) {
+        throw new Error('aeadOpen: ciphertext must be a Buffer');
+    }
+    const decipher = node_crypto_1.default.createDecipheriv(ALG, key, sealed.nonce);
+    if (aad && aad.length > 0)
+        decipher.setAAD(aad);
+    decipher.setAuthTag(sealed.tag);
+    return Buffer.concat([decipher.update(sealed.ct), decipher.final()]);
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/authExpiredDetector.d.ts

@@ -0,0 +1,65 @@
+/**
+ * authExpiredDetector.ts — mid-stream auth-expired SSE detector.
+ *
+ * HTTP auth is checked BEFORE the body stream starts — a 401 mid-stream
+ * is technically impossible. But long-running SSE / Socket.IO sessions
+ * (chat with tool calls, agent steps, voice) can see the access token
+ * expire mid-body, because the server-side auth check fires per-event
+ * on every internal step. The server's contract: emit a terminal event
+ * with `type: 'error'` + `error.code === 'auth_expired'` (or the legacy
+ * forms `event: 'auth:expired'`, `event: 'auth_expired'`, `code:
+ * 'auth_expired'`) signalling the client to refresh and restart.
+ *
+ * This module recognises every documented shape and exposes a small
+ * orchestration helper that runs the caller-supplied refresher, then
+ * fires a user-visible message via the callbacks bag.
+ *
+ * Pure — no React, no fetch, no platform code. Suitable for daemon,
+ * desktop, web, and mobile clients. The mobile React Native client
+ * keeps a byte-equal mirror at
+ * `mobile/react-native/src/chat/streaming/authExpiredDetector.ts`
+ * (separate repo, can't import this package today). Treat that file
+ * as auth-tier canonical: any change here MUST be ported there.
+ */
+/** Minimal shape of a parsed SSE event this module recognises. */
+export interface ParsedSseLike {
+    type?: unknown;
+    event?: unknown;
+    error?: unknown;
+    code?: unknown;
+}
+/**
+ * Return true when `parsed` looks like the server's mid-stream auth
+ * expiry signal. The check is broad on purpose — multiple server
+ * generations use slightly different shapes and we want to catch them
+ * all rather than drop into the generic-error branch and confuse the
+ * user.
+ *
+ * Accepted shapes (any one is enough):
+ *   - `{ type: 'error', error: { code: 'auth_expired' } }`
+ *   - `{ event: 'auth:expired' }`
+ *   - `{ event: 'auth_expired' }`
+ *   - `{ code: 'auth_expired' }`
+ *   - `{ type: 'error', error: 'auth_expired' }`
+ */
+export declare function isAuthExpiredSseEvent(parsed: unknown): boolean;
+/**
+ * Integration helper — call from the SSE parser when `isAuthExpiredSseEvent`
+ * returns true. Calls the supplied refresher, fires callbacks.onError
+ * with a user-visible message, and returns the new token (or null on
+ * failure) so the caller can decide whether to auto-retry.
+ *
+ * Pure in the sense that it does NOT drive a fetch / socket itself —
+ * that is the caller's responsibility, because retry semantics differ
+ * between SSE (re-POST) and Socket.IO (disconnect+reconnect).
+ */
+export interface AuthExpiredCallbacks {
+    onError?: (message: string) => void;
+}
+export interface HandleMidStreamAuthExpiryResult {
+    /** True when the refresher returned a fresh token. */
+    refreshed: boolean;
+    /** The fresh token when refreshed===true, else null. */
+    token: string | null;
+}
+export declare function handleMidStreamAuthExpiry(callbacks: AuthExpiredCallbacks, refresher: () => Promise<string | null>): Promise<HandleMidStreamAuthExpiryResult>;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/authExpiredDetector.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * authExpiredDetector.ts — mid-stream auth-expired SSE detector.
+ *
+ * HTTP auth is checked BEFORE the body stream starts — a 401 mid-stream
+ * is technically impossible. But long-running SSE / Socket.IO sessions
+ * (chat with tool calls, agent steps, voice) can see the access token
+ * expire mid-body, because the server-side auth check fires per-event
+ * on every internal step. The server's contract: emit a terminal event
+ * with `type: 'error'` + `error.code === 'auth_expired'` (or the legacy
+ * forms `event: 'auth:expired'`, `event: 'auth_expired'`, `code:
+ * 'auth_expired'`) signalling the client to refresh and restart.
+ *
+ * This module recognises every documented shape and exposes a small
+ * orchestration helper that runs the caller-supplied refresher, then
+ * fires a user-visible message via the callbacks bag.
+ *
+ * Pure — no React, no fetch, no platform code. Suitable for daemon,
+ * desktop, web, and mobile clients. The mobile React Native client
+ * keeps a byte-equal mirror at
+ * `mobile/react-native/src/chat/streaming/authExpiredDetector.ts`
+ * (separate repo, can't import this package today). Treat that file
+ * as auth-tier canonical: any change here MUST be ported there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthExpiredSseEvent = isAuthExpiredSseEvent;
+exports.handleMidStreamAuthExpiry = handleMidStreamAuthExpiry;
+/**
+ * Return true when `parsed` looks like the server's mid-stream auth
+ * expiry signal. The check is broad on purpose — multiple server
+ * generations use slightly different shapes and we want to catch them
+ * all rather than drop into the generic-error branch and confuse the
+ * user.
+ *
+ * Accepted shapes (any one is enough):
+ *   - `{ type: 'error', error: { code: 'auth_expired' } }`
+ *   - `{ event: 'auth:expired' }`
+ *   - `{ event: 'auth_expired' }`
+ *   - `{ code: 'auth_expired' }`
+ *   - `{ type: 'error', error: 'auth_expired' }`
+ */
+function isAuthExpiredSseEvent(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return false;
+    const p = parsed;
+    const eventStr = typeof p.event === 'string' ? p.event.toLowerCase() : '';
+    if (eventStr === 'auth:expired' || eventStr === 'auth_expired')
+        return true;
+    const codeStr = typeof p.code === 'string' ? p.code.toLowerCase() : '';
+    if (codeStr === 'auth_expired')
+        return true;
+    const typeStr = typeof p.type === 'string' ? p.type.toLowerCase() : '';
+    if (typeStr === 'error' && isAuthExpiredError(p.error)) {
+        return true;
+    }
+    return false;
+}
+function isAuthExpiredError(err) {
+    if (!err)
+        return false;
+    if (typeof err === 'string')
+        return err.toLowerCase() === 'auth_expired';
+    if (typeof err !== 'object')
+        return false;
+    const maybe = err.code;
+    if (typeof maybe === 'string' && maybe.toLowerCase() === 'auth_expired') {
+        return true;
+    }
+    const message = err.message;
+    if (typeof message === 'string' && message.toLowerCase().includes('auth_expired')) {
+        return true;
+    }
+    return false;
+}
+async function handleMidStreamAuthExpiry(callbacks, refresher) {
+    let token = null;
+    try {
+        token = await refresher();
+    }
+    catch {
+        token = null;
+    }
+    if (token) {
+        callbacks.onError?.('Your session was refreshed. Tap retry to resume the response.');
+        return { refreshed: true, token };
+    }
+    callbacks.onError?.('Session expired. Please sign in again.');
+    return { refreshed: false, token: null };
+}