very-happy-cli 0.2.158 → 0.2.160

package/dist/lib.cjs

@@ -1,40 +1,49 @@
 'use strict';
 
-var index = require('./types-DnrPeN80.cjs');
-var persistence = require('./limits-kqFqhfsh.cjs');
+var api = require('./api-CgundNNX.cjs');
+var logger = require('./logger-CS0mw3fa.cjs');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var types = require('./types-CRS-srZK.cjs');
 require('axios');
 require('node:events');
 require('socket.io-client');
+require('./attachmentLimits-CzVrqgLR.cjs');
 require('zod');
+require('./index-DA7yINuk.cjs');
+require('@paralleldrive/cuid2');
+require('./authRelay-BdYkC1Po.cjs');
 require('node:crypto');
+require('tweetnacl');
+require('./limits-C-a7gr04.cjs');
+require('./time-DCuTyook.cjs');
+require('./lidState-BeDfxxEX.cjs');
+require('os');
 require('child_process');
+require('./registerCommonHandlers-DskirN-_.cjs');
 require('util');
 require('fs/promises');
 require('crypto');
 require('path');
 require('cross-spawn');
-require('./terminalTitleSuggest-Dji8I0Jy.cjs');
+require('./projectPath-ChLhdOyt.cjs');
 require('url');
-require('os');
-require('@paralleldrive/cuid2');
+require('./sync-DccIKZ5_.cjs');
+require('./backgroundTaskActivity-CBvUdj39.cjs');
+require('./controlClient-Bcwv3D21.cjs');
+require('./persistence-yKTH3-5X.cjs');
 require('node:fs/promises');
-require('node:path');
-require('node:os');
-require('node:child_process');
-require('node-pty');
 require('node:fs');
-require('fs');
-require('tweetnacl');
-require('node:readline');
-require('@anthropic-ai/sandbox-runtime');
-require('expo-server-sdk');
+require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 require('node:util');
+require('node:path');
+require('node:os');
+require('./package-BwMrPwqH.cjs');
 
 
 
-exports.ApiClient = index.ApiClient;
-exports.ApiSessionClient = index.ApiSessionClient;
-exports.RawJSONLinesSchema = index.RawJSONLinesSchema;
-exports.configuration = persistence.configuration;
-exports.logger = persistence.logger;
+exports.ApiClient = api.ApiClient;
+exports.ApiSessionClient = api.ApiSessionClient;
+exports.logger = logger.logger;
+exports.configuration = configuration.configuration;
+exports.RawJSONLinesSchema = types.RawJSONLinesSchema;

package/dist/lib.d.cts

@@ -888,6 +888,104 @@ declare class RpcHandlerManager {
     private getPrefixedMethod;
 }
 
+/**
+ * B-509 —— server-side prompt queue drain (pure state machine, no I/O).
+ *
+ * The web no longer releases queued prompts itself; it stores them on the
+ * server (`/v1/sessions/:id/prompt-queue`). This process asks the server to
+ * pop the head item into an ordinary user message (`POST …/dispatch`) exactly
+ * when the runner is idle: its `MessageQueue2` is empty AND a consumer is
+ * blocked waiting for the next message (the turn is over). The dispatched
+ * message then arrives through the normal socket / catch-up path and is
+ * routed like anything the user typed — so it starts a turn of its own,
+ * never merged with a sibling (one item per turn).
+ *
+ * Guards, in order:
+ *   - `closed` / `disabled` (404 from an old server → never retried);
+ *   - a dispatch already in progress;
+ *   - an `inflight` item whose message has not been routed yet (cleared by
+ *     `onInbound(localId)`; released by timeout so a lost socket cannot wedge
+ *     the queue — the catch-up fetch still delivers it in seq order);
+ *   - an error backoff window;
+ *   - `isIdle()` false.
+ */
+type PromptQueueDispatchOutcome = 
+/** `remaining` = items still queued after this pop; `created:false` = the message row pre-existed (replayed localId) — nothing new will be routed. */
+{
+    kind: 'dispatched';
+    localId: string;
+    remaining?: number;
+    created?: boolean;
+} | {
+    kind: 'empty';
+} | {
+    kind: 'unsupported';
+} | {
+    kind: 'error';
+    message: string;
+};
+type PromptQueueDrainDeps = {
+    isIdle: () => boolean;
+    dispatch: () => Promise<PromptQueueDispatchOutcome>;
+    now?: () => number;
+    log?: (message: string) => void;
+    /** Schedules a retry after an error; default `setTimeout` (unref'd). */
+    schedule?: (fn: () => void, delayMs: number) => void;
+    inflightTimeoutMs?: number;
+};
+declare class PromptQueueDrain {
+    private readonly deps;
+    private inflight;
+    /**
+     * localIds routed while a dispatch call was still in flight. The server's
+     * `new-message` echo regularly beats the HTTP response (both come off the
+     * same transaction), so `onInbound` can precede the `dispatched` outcome;
+     * without this the guard armed AFTER the message had arrived and sat
+     * until the timeout — observed in the first isolated e2e run.
+     */
+    private arrivedDuringDispatch;
+    /** Items the server still holds, from the last snapshot / dispatch response. */
+    private pending;
+    private disabled;
+    private closed;
+    private busy;
+    private failures;
+    private retryAt;
+    private retryScheduled;
+    private readonly now;
+    private readonly log;
+    private readonly schedule;
+    private readonly inflightTimeoutMs;
+    constructor(deps: PromptQueueDrainDeps);
+    /** The runner is blocked on an empty input queue. */
+    onIdle(): void;
+    /** A `prompt-queue` snapshot arrived; only a non-empty queue is worth a call. */
+    onQueueChanged(count: number): void;
+    /**
+     * True while the server still holds queued prompts for this session. The
+     * runners fold it into their "idle, waiting for the user" judgement so a
+     * turn that ends with more queue behind it raises no reply_done /
+     * input_needed notification and no daemon `completed` report per item.
+     */
+    hasPending(): boolean;
+    /** A user message with this localId was routed into the runner's queue. */
+    onInbound(localId: string): void;
+    close(): void;
+    state(): {
+        inflight: {
+            localId: string;
+            since: number;
+        } | null;
+        disabled: boolean;
+        busy: boolean;
+        failures: number;
+        retryAt: number;
+        pending: number;
+    };
+    maybeDispatch(reason: string): Promise<boolean>;
+    private scheduleRetry;
+}
+
 /**
  * ACP (Agent Communication Protocol) message data types.
  * This is the unified format for all agent messages - CLI adapts each provider's format to ACP.
@@ -945,6 +1043,15 @@ type ACPMessageData = {
     [key: string]: unknown;
 };
 declare class ApiSessionClient extends EventEmitter {
+    /**
+     * B-512: the session socket now connects before the runner has attached its
+     * `archived` listener (registerKillSessionHandler). An archive signal that
+     * fires in that window must not be lost: remember it and replay it to any
+     * listener attached later.
+     */
+    private archiveSignalled;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
     private readonly token;
     readonly sessionId: string;
     private metadata;
@@ -988,6 +1095,8 @@ declare class ApiSessionClient extends EventEmitter {
      *  must wait for the first fetch, otherwise a message that lands between
      *  the seed and the first fetch is routed twice (socket + fetch). */
     private awaitingInitialFetch;
+    /** B-509: server-side prompt queue drain, attached by the runner. */
+    private promptQueueDrain;
     constructor(token: string, session: Session, opts?: {
         initialSeq?: number;
     });
@@ -1037,6 +1146,20 @@ declare class ApiSessionClient extends EventEmitter {
         name: string;
     }>>;
     private authHeaders;
+    /**
+     * B-509: attach the server-side prompt queue drain. `isIdle` is the
+     * runner's own notion (input queue empty + blocked waiting); dispatching is
+     * `POST /v1/sessions/:id/prompt-queue/dispatch`, whose message then comes
+     * back through the ordinary socket / catch-up path and is routed below.
+     */
+    attachPromptQueueDrain(opts: {
+        isIdle: () => boolean;
+    }): PromptQueueDrain;
+    /** B-509: the server still holds queued prompts for this session (see PromptQueueDrain.hasPending). */
+    promptQueueHasPending(): boolean;
+    /** B-509: stop draining before the process winds down (cleanup's first line). */
+    closePromptQueueDrain(): void;
+    private dispatchPromptQueueHead;
     private routeIncomingMessage;
     private fetchMessages;
     private static readonly MAX_OUTBOX_BATCH_SIZE;
@@ -1566,8 +1689,9 @@ type SessionNotificationKind = 'done' | 'permission' | 'question';
 declare class PushNotificationClient {
     private readonly token;
     private readonly baseUrl;
-    private readonly expo;
+    private expoLoad;
     constructor(token: string, baseUrl?: string);
+    private loadExpo;
     /**
      * Fetch all push tokens for the authenticated user.
      * Retries up to 3 times with exponential backoff on transient errors.
@@ -1693,7 +1817,7 @@ declare class ApiClient {
     sessionSyncClient(session: Session, opts?: {
         initialSeq?: number;
     }): ApiSessionClient;
-    machineSyncClient(machine: Machine): ApiMachineClient;
+    machineSyncClient(machine: Machine): Promise<ApiMachineClient>;
     push(): PushNotificationClient;
     /**
      * Create an account-encrypted notification producer bound to a session.

package/dist/lib.d.mts

@@ -888,6 +888,104 @@ declare class RpcHandlerManager {
     private getPrefixedMethod;
 }
 
+/**
+ * B-509 —— server-side prompt queue drain (pure state machine, no I/O).
+ *
+ * The web no longer releases queued prompts itself; it stores them on the
+ * server (`/v1/sessions/:id/prompt-queue`). This process asks the server to
+ * pop the head item into an ordinary user message (`POST …/dispatch`) exactly
+ * when the runner is idle: its `MessageQueue2` is empty AND a consumer is
+ * blocked waiting for the next message (the turn is over). The dispatched
+ * message then arrives through the normal socket / catch-up path and is
+ * routed like anything the user typed — so it starts a turn of its own,
+ * never merged with a sibling (one item per turn).
+ *
+ * Guards, in order:
+ *   - `closed` / `disabled` (404 from an old server → never retried);
+ *   - a dispatch already in progress;
+ *   - an `inflight` item whose message has not been routed yet (cleared by
+ *     `onInbound(localId)`; released by timeout so a lost socket cannot wedge
+ *     the queue — the catch-up fetch still delivers it in seq order);
+ *   - an error backoff window;
+ *   - `isIdle()` false.
+ */
+type PromptQueueDispatchOutcome = 
+/** `remaining` = items still queued after this pop; `created:false` = the message row pre-existed (replayed localId) — nothing new will be routed. */
+{
+    kind: 'dispatched';
+    localId: string;
+    remaining?: number;
+    created?: boolean;
+} | {
+    kind: 'empty';
+} | {
+    kind: 'unsupported';
+} | {
+    kind: 'error';
+    message: string;
+};
+type PromptQueueDrainDeps = {
+    isIdle: () => boolean;
+    dispatch: () => Promise<PromptQueueDispatchOutcome>;
+    now?: () => number;
+    log?: (message: string) => void;
+    /** Schedules a retry after an error; default `setTimeout` (unref'd). */
+    schedule?: (fn: () => void, delayMs: number) => void;
+    inflightTimeoutMs?: number;
+};
+declare class PromptQueueDrain {
+    private readonly deps;
+    private inflight;
+    /**
+     * localIds routed while a dispatch call was still in flight. The server's
+     * `new-message` echo regularly beats the HTTP response (both come off the
+     * same transaction), so `onInbound` can precede the `dispatched` outcome;
+     * without this the guard armed AFTER the message had arrived and sat
+     * until the timeout — observed in the first isolated e2e run.
+     */
+    private arrivedDuringDispatch;
+    /** Items the server still holds, from the last snapshot / dispatch response. */
+    private pending;
+    private disabled;
+    private closed;
+    private busy;
+    private failures;
+    private retryAt;
+    private retryScheduled;
+    private readonly now;
+    private readonly log;
+    private readonly schedule;
+    private readonly inflightTimeoutMs;
+    constructor(deps: PromptQueueDrainDeps);
+    /** The runner is blocked on an empty input queue. */
+    onIdle(): void;
+    /** A `prompt-queue` snapshot arrived; only a non-empty queue is worth a call. */
+    onQueueChanged(count: number): void;
+    /**
+     * True while the server still holds queued prompts for this session. The
+     * runners fold it into their "idle, waiting for the user" judgement so a
+     * turn that ends with more queue behind it raises no reply_done /
+     * input_needed notification and no daemon `completed` report per item.
+     */
+    hasPending(): boolean;
+    /** A user message with this localId was routed into the runner's queue. */
+    onInbound(localId: string): void;
+    close(): void;
+    state(): {
+        inflight: {
+            localId: string;
+            since: number;
+        } | null;
+        disabled: boolean;
+        busy: boolean;
+        failures: number;
+        retryAt: number;
+        pending: number;
+    };
+    maybeDispatch(reason: string): Promise<boolean>;
+    private scheduleRetry;
+}
+
 /**
  * ACP (Agent Communication Protocol) message data types.
  * This is the unified format for all agent messages - CLI adapts each provider's format to ACP.
@@ -945,6 +1043,15 @@ type ACPMessageData = {
     [key: string]: unknown;
 };
 declare class ApiSessionClient extends EventEmitter {
+    /**
+     * B-512: the session socket now connects before the runner has attached its
+     * `archived` listener (registerKillSessionHandler). An archive signal that
+     * fires in that window must not be lost: remember it and replay it to any
+     * listener attached later.
+     */
+    private archiveSignalled;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
     private readonly token;
     readonly sessionId: string;
     private metadata;
@@ -988,6 +1095,8 @@ declare class ApiSessionClient extends EventEmitter {
      *  must wait for the first fetch, otherwise a message that lands between
      *  the seed and the first fetch is routed twice (socket + fetch). */
     private awaitingInitialFetch;
+    /** B-509: server-side prompt queue drain, attached by the runner. */
+    private promptQueueDrain;
     constructor(token: string, session: Session, opts?: {
         initialSeq?: number;
     });
@@ -1037,6 +1146,20 @@ declare class ApiSessionClient extends EventEmitter {
         name: string;
     }>>;
     private authHeaders;
+    /**
+     * B-509: attach the server-side prompt queue drain. `isIdle` is the
+     * runner's own notion (input queue empty + blocked waiting); dispatching is
+     * `POST /v1/sessions/:id/prompt-queue/dispatch`, whose message then comes
+     * back through the ordinary socket / catch-up path and is routed below.
+     */
+    attachPromptQueueDrain(opts: {
+        isIdle: () => boolean;
+    }): PromptQueueDrain;
+    /** B-509: the server still holds queued prompts for this session (see PromptQueueDrain.hasPending). */
+    promptQueueHasPending(): boolean;
+    /** B-509: stop draining before the process winds down (cleanup's first line). */
+    closePromptQueueDrain(): void;
+    private dispatchPromptQueueHead;
     private routeIncomingMessage;
     private fetchMessages;
     private static readonly MAX_OUTBOX_BATCH_SIZE;
@@ -1566,8 +1689,9 @@ type SessionNotificationKind = 'done' | 'permission' | 'question';
 declare class PushNotificationClient {
     private readonly token;
     private readonly baseUrl;
-    private readonly expo;
+    private expoLoad;
     constructor(token: string, baseUrl?: string);
+    private loadExpo;
     /**
      * Fetch all push tokens for the authenticated user.
      * Retries up to 3 times with exponential backoff on transient errors.
@@ -1693,7 +1817,7 @@ declare class ApiClient {
     sessionSyncClient(session: Session, opts?: {
         initialSeq?: number;
     }): ApiSessionClient;
-    machineSyncClient(machine: Machine): ApiMachineClient;
+    machineSyncClient(machine: Machine): Promise<ApiMachineClient>;
     push(): PushNotificationClient;
     /**
      * Create an account-encrypted notification producer bound to a session.

package/dist/lib.mjs

@@ -1,30 +1,39 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema } from './types-DIBF4U0Y.mjs';
-export { c as configuration, l as logger } from './limits-D2uN090G.mjs';
+export { A as ApiClient, a as ApiSessionClient } from './api-CLMUr-SX.mjs';
+export { l as logger } from './logger-6HYUEXNk.mjs';
+export { c as configuration } from './configuration-RfeNjFmd.mjs';
+export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
+import './attachmentLimits-yba1uHFO.mjs';
 import 'zod';
+import './index-qdS1friN.mjs';
+import '@paralleldrive/cuid2';
+import './authRelay-DSAvg1uv.mjs';
 import 'node:crypto';
+import 'tweetnacl';
+import './limits-DIo7rEBR.mjs';
+import './time-D0XyHOid.mjs';
+import './lidState-CeEt442o.mjs';
+import 'os';
 import 'child_process';
+import './registerCommonHandlers-Ccvsz7Ou.mjs';
 import 'util';
 import 'fs/promises';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
-import './terminalTitleSuggest-DKgX3osW.mjs';
+import './projectPath-BTBIMB57.mjs';
 import 'url';
-import 'os';
-import '@paralleldrive/cuid2';
+import './sync-C8gyQFMc.mjs';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import './controlClient-BGbDcgWS.mjs';
+import './persistence-HGW_ZVs9.mjs';
 import 'node:fs/promises';
-import 'node:path';
-import 'node:os';
-import 'node:child_process';
-import 'node-pty';
 import 'node:fs';
-import 'fs';
-import 'tweetnacl';
-import 'node:readline';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
+import './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 import 'node:util';
+import 'node:path';
+import 'node:os';
+import './package-BhaKlnxz.mjs';