@adhdev/daemon-standalone 0.9.76-rc.50 → 0.9.76-rc.52

package/dist/index.js

@@ -9165,6 +9165,7 @@ var require_dist = __commonJS({
       DEFAULT_SESSION_HOST_COLS: () => DEFAULT_SESSION_HOST_COLS,
       DEFAULT_SESSION_HOST_ROWS: () => DEFAULT_SESSION_HOST_ROWS,
       DEFAULT_SESSION_RING_BUFFER_MAX_BYTES: () => DEFAULT_SESSION_RING_BUFFER_MAX_BYTES2,
+      SESSION_HOST_SUPPORTED_REQUEST_TYPES: () => SESSION_HOST_SUPPORTED_REQUEST_TYPES,
       SessionHostClient: () => SessionHostClient2,
       SessionHostRegistry: () => SessionHostRegistry,
       SessionRingBuffer: () => SessionRingBuffer,
@@ -9189,6 +9190,27 @@ var require_dist = __commonJS({
       writeEnvelope: () => writeEnvelope
     });
     module2.exports = __toCommonJS2(index_exports);
+    var SESSION_HOST_SUPPORTED_REQUEST_TYPES = [
+      "create_session",
+      "attach_session",
+      "detach_session",
+      "send_input",
+      "resize_session",
+      "stop_session",
+      "delete_session",
+      "resume_session",
+      "acquire_write",
+      "release_write",
+      "get_snapshot",
+      "clear_session_buffer",
+      "update_session_meta",
+      "get_host_diagnostics",
+      "force_detach_client",
+      "send_signal",
+      "restart_session",
+      "prune_duplicate_sessions",
+      "list_sessions"
+    ];
     var DEFAULT_SESSION_RING_BUFFER_MAX_BYTES2 = 4 * 1024 * 1024;
     var SessionRingBuffer = class {
       maxBytes;
@@ -42986,6 +43008,7 @@ ${effect.notification.body || ""}`.trim();
     }
     var RECENT_SEND_WINDOW_MS = 1200;
     var READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25e3;
+    var HERMES_CLI_STARTING_SEND_SETTLE_MS = 2e3;
     var recentSendByTarget = /* @__PURE__ */ new Map();
     function getCurrentProviderType(h, fallback = "") {
       return h.currentSession?.providerType || h.currentProviderType || fallback;
@@ -43038,6 +43061,16 @@ ${effect.notification.body || ""}`.trim();
     function getSendChatInputEnvelope(args) {
       return normalizeInputEnvelope(args?.input ? { input: args.input } : args);
     }
+    function sleep(ms2) {
+      return new Promise((resolve16) => setTimeout(resolve16, ms2));
+    }
+    async function waitOnceForFreshHermesCliStart(adapter, log) {
+      if (adapter.cliType !== "hermes-cli") return;
+      const status = typeof adapter.getStatus === "function" ? adapter.getStatus()?.status : void 0;
+      if (status !== "starting") return;
+      log(`Hermes CLI is still starting; waiting ${HERMES_CLI_STARTING_SEND_SETTLE_MS}ms before first send`);
+      await sleep(HERMES_CLI_STARTING_SEND_SETTLE_MS);
+    }
     function getHistorySessionId(h, args) {
       const explicit = typeof args?.historySessionId === "string" ? args.historySessionId.trim() : "";
       if (explicit) return explicit;
@@ -43897,6 +43930,7 @@ ${effect.notification.body || ""}`.trim();
           try {
             assertTextOnlyInput(provider, input);
             if (!text) return { success: false, error: "text required for PTY send" };
+            await waitOnceForFreshHermesCliStart(adapter, _log);
             await adapter.sendMessage(text);
             return _logSendSuccess(`${transport}-adapter`, adapter.cliType);
           } catch (e) {
@@ -46802,8 +46836,6 @@ ${effect.notification.body || ""}`.trim();
           const aTime = getTime(a.message);
           const bTime = getTime(b2.message);
           if (aTime && bTime && aTime !== bTime) return aTime - bTime;
-          if (aTime && !bTime && a.source === "runtime" && b2.source === "parsed") return -1;
-          if (!aTime && bTime && a.source === "parsed" && b2.source === "runtime") return 1;
           return a.index - b2.index;
         }).map((entry) => entry.message));
       }
@@ -57088,7 +57120,7 @@ async (params) => {
       if (!adapter) return null;
       return { target, instance, adapter };
     }
-    function sleep(ms2) {
+    function sleep2(ms2) {
       return new Promise((resolve16) => setTimeout(resolve16, ms2));
     }
     async function waitForCliReady(ctx, type, instanceId, timeoutMs) {
@@ -57105,7 +57137,7 @@ async (params) => {
             return bundle;
           }
         }
-        await sleep(100);
+        await sleep2(100);
       }
       return getCliTargetBundle(ctx, type, instanceId);
     }
@@ -57161,7 +57193,7 @@ async (params) => {
             const message = String(lastLaunchError.message || "");
             const retryable = /ECONNREFUSED|session-host|Session host/i.test(message);
             if (!retryable || attempt === 2) break;
-            await sleep(1e3);
+            await sleep2(1e3);
           }
         }
         if (!launched) {
@@ -57224,16 +57256,16 @@ async (params) => {
         const modal = debug?.activeModal || trace?.activeModal || null;
         noteStatus(status);
         if (resolveActiveModalIfNeeded(status, modal)) {
-          await sleep(150);
+          await sleep2(150);
           continue;
         }
         const startupParseGate = !!debug?.startupParseGate;
         if (status === "idle" && !startupParseGate) break;
-        await sleep(150);
+        await sleep2(150);
       }
       ctx.instanceManager.sendEvent(bundle.target.instanceId, "send_message", { text });
       while (Date.now() - startAt < Math.max(1e3, timeoutMs)) {
-        await sleep(150);
+        await sleep2(150);
         bundle = getCliTargetBundle(ctx, type, bundle.target.instanceId);
         if (!bundle) {
           throw new Error("CLI instance disappeared during exercise");
@@ -61109,29 +61141,58 @@ data: ${JSON.stringify(msg.data)}
     var import_session_host_core4 = require_dist();
     var STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS2;
     var STARTUP_POLL_MS = 200;
-    async function canConnect(endpoint) {
+    var SessionHostCompatibilityError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SessionHostCompatibilityError";
+      }
+    };
+    function getMissingRequestTypes(diagnostics, requiredRequestTypes) {
+      const supported = new Set(diagnostics?.supportedRequestTypes || []);
+      return requiredRequestTypes.filter((requestType) => !supported.has(requestType));
+    }
+    async function assertRequiredRequestTypes(client, requiredRequestTypes) {
+      if (requiredRequestTypes.length === 0) return;
+      const response = await client.request({
+        type: "get_host_diagnostics",
+        payload: { includeSessions: false }
+      });
+      const missing = getMissingRequestTypes(response.success ? response.result : void 0, requiredRequestTypes);
+      if (missing.length > 0) {
+        const detail = response.success ? "" : ` (${response.error || "capability probe failed"})`;
+        throw new SessionHostCompatibilityError(
+          `Session host does not support required request types: ${missing.join(", ")}${detail}`
+        );
+      }
+    }
+    async function canConnect(endpoint, requiredRequestTypes = []) {
       const client = new import_session_host_core4.SessionHostClient({ endpoint });
       try {
         await client.connect();
-        await client.close();
+        await assertRequiredRequestTypes(client, requiredRequestTypes);
         return true;
-      } catch {
+      } catch (error48) {
+        if (error48 instanceof SessionHostCompatibilityError) throw error48;
         return false;
+      } finally {
+        await client.close().catch(() => {
+        });
       }
     }
-    async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
+    async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS, requiredRequestTypes = []) {
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
-        if (await canConnect(endpoint)) return;
+        if (await canConnect(endpoint, requiredRequestTypes)) return;
         await new Promise((resolve16) => setTimeout(resolve16, STARTUP_POLL_MS));
       }
       throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
     }
     async function ensureSessionHostReady2(options) {
       const endpoint = (0, import_session_host_core4.getDefaultSessionHostEndpoint)(options.appName || "adhdev");
-      if (await canConnect(endpoint)) return endpoint;
+      const requiredRequestTypes = options.requiredRequestTypes || [];
+      if (await canConnect(endpoint, requiredRequestTypes)) return endpoint;
       options.spawnHost();
-      await waitForReady(endpoint, options.timeoutMs);
+      await waitForReady(endpoint, options.timeoutMs, requiredRequestTypes);
       return endpoint;
     }
     async function listHostedCliRuntimes2(endpoint) {
@@ -61851,14 +61912,16 @@ async function ensureSessionHostReady() {
     return await (0, import_daemon_core.ensureSessionHostReady)({
       appName: SESSION_HOST_APP_NAME,
       spawnHost,
-      timeoutMs: SESSION_HOST_START_TIMEOUT_MS
+      timeoutMs: SESSION_HOST_START_TIMEOUT_MS,
+      requiredRequestTypes: ["delete_session"]
     });
   } catch (error48) {
     stopSessionHost();
     return (0, import_daemon_core.ensureSessionHostReady)({
       appName: SESSION_HOST_APP_NAME,
       spawnHost,
-      timeoutMs: SESSION_HOST_START_TIMEOUT_MS
+      timeoutMs: SESSION_HOST_START_TIMEOUT_MS,
+      requiredRequestTypes: ["delete_session"]
     }).catch((retryError) => {
       const initialMessage = error48 instanceof Error ? error48.message : String(error48);
       const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);