@adhdev/daemon-standalone 0.7.16 → 0.7.18

package/dist/index.js

@@ -33462,6 +33462,59 @@ var SessionHostPtyTransportFactory = class {
     });
   }
 };
+var STARTUP_TIMEOUT_MS = 8e3;
+var STARTUP_POLL_MS = 200;
+async function canConnect(endpoint) {
+  const client = new SessionHostClient({ endpoint });
+  try {
+    await client.connect();
+    await client.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await canConnect(endpoint)) return;
+    await new Promise((resolve92) => setTimeout(resolve92, STARTUP_POLL_MS));
+  }
+  throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
+}
+async function ensureSessionHostReady(options) {
+  const endpoint = getDefaultSessionHostEndpoint(options.appName || "adhdev");
+  if (await canConnect(endpoint)) return endpoint;
+  options.spawnHost();
+  await waitForReady(endpoint, options.timeoutMs);
+  return endpoint;
+}
+async function listHostedCliRuntimes(endpoint) {
+  const client = new SessionHostClient({ endpoint });
+  try {
+    const response = await client.request({
+      type: "list_sessions",
+      payload: {}
+    });
+    if (!response.success || !response.result) {
+      return [];
+    }
+    return response.result.filter((record2) => record2.category === "cli" && ["running", "interrupted"].includes(record2.lifecycle)).sort((a, b) => b.lastActivityAt - a.lastActivityAt).map((record2) => ({
+      runtimeId: record2.sessionId,
+      runtimeKey: record2.runtimeKey,
+      displayName: record2.displayName,
+      workspaceLabel: record2.workspaceLabel,
+      lifecycle: record2.lifecycle,
+      recoveryState: typeof record2.meta?.runtimeRecoveryState === "string" ? String(record2.meta.runtimeRecoveryState) : null,
+      cliType: record2.providerType,
+      workspace: record2.workspace,
+      cliArgs: Array.isArray(record2.meta?.cliArgs) ? record2.meta.cliArgs : []
+    }));
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
 var SessionRegistry = class {
   bySessionId = /* @__PURE__ */ new Map();
   byManagerKey = /* @__PURE__ */ new Map();
@@ -33708,27 +33761,7 @@ async function shutdownDaemonComponents(components) {
 // src/session-host.ts
 var import_child_process8 = require("child_process");
 var path15 = __toESM(require("path"));
-var STARTUP_TIMEOUT_MS = 8e3;
-var STARTUP_POLL_MS = 200;
 var SESSION_HOST_APP_NAME = process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
-async function canConnect(endpoint) {
-  const client = new SessionHostClient({ endpoint });
-  try {
-    await client.connect();
-    await client.close();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await canConnect(endpoint)) return;
-    await new Promise((resolve12) => setTimeout(resolve12, STARTUP_POLL_MS));
-  }
-  throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
-}
 function resolveSessionHostEntry() {
   const localCandidates = [
     path15.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
@@ -33755,51 +33788,33 @@ async function runSessionHostCli(args) {
     child.on("exit", (code) => resolve12(code ?? 0));
   });
 }
-async function ensureSessionHostReady() {
-  const endpoint = getDefaultSessionHostEndpoint(SESSION_HOST_APP_NAME);
-  if (await canConnect(endpoint)) return endpoint;
-  const entry = resolveSessionHostEntry();
-  const child = (0, import_child_process8.spawn)(process.execPath, [entry], {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true
+async function ensureSessionHostReady2() {
+  return ensureSessionHostReady({
+    appName: SESSION_HOST_APP_NAME,
+    spawnHost: () => {
+      const entry = resolveSessionHostEntry();
+      const child = (0, import_child_process8.spawn)(process.execPath, [entry], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: {
+          ...process.env,
+          ADHDEV_SESSION_HOST_NAME: SESSION_HOST_APP_NAME
+        }
+      });
+      child.unref();
+    }
   });
-  child.unref();
-  await waitForReady(endpoint);
-  return endpoint;
 }
-async function listHostedCliRuntimes(endpoint) {
-  const client = new SessionHostClient({ endpoint });
-  try {
-    const response = await client.request({
-      type: "list_sessions",
-      payload: {}
-    });
-    if (!response.success || !response.result) {
-      return [];
-    }
-    return response.result.filter((record2) => record2.category === "cli" && ["running", "interrupted"].includes(record2.lifecycle)).sort((a, b) => b.lastActivityAt - a.lastActivityAt).map((record2) => ({
-      runtimeId: record2.sessionId,
-      runtimeKey: record2.runtimeKey,
-      displayName: record2.displayName,
-      workspaceLabel: record2.workspaceLabel,
-      lifecycle: record2.lifecycle,
-      recoveryState: typeof record2.meta?.runtimeRecoveryState === "string" ? String(record2.meta.runtimeRecoveryState) : null,
-      cliType: record2.providerType,
-      workspace: record2.workspace,
-      cliArgs: Array.isArray(record2.meta?.cliArgs) ? record2.meta.cliArgs : []
-    }));
-  } finally {
-    await client.close().catch(() => {
-    });
-  }
+async function listHostedCliRuntimes2(endpoint) {
+  return listHostedCliRuntimes(endpoint);
 }
 async function proxySessionHostList(showAll = false) {
-  await ensureSessionHostReady();
+  await ensureSessionHostReady2();
   return runSessionHostCli(["list", ...showAll ? ["--all"] : []]);
 }
 async function proxySessionHostAttach(target, options = {}) {
-  await ensureSessionHostReady();
+  await ensureSessionHostReady2();
   const args = ["attach", target];
   if (options.readOnly) args.push("--read-only");
   if (options.takeover) args.push("--takeover");
@@ -33999,7 +34014,7 @@ var StandaloneServer = class {
   async start(options = {}) {
     const port = options.port || DEFAULT_PORT;
     const host = options.host || "127.0.0.1";
-    const sessionHostEndpoint = await ensureSessionHostReady();
+    const sessionHostEndpoint = await ensureSessionHostReady2();
     this.sessionHostEndpoint = sessionHostEndpoint;
     this.authToken = options.token || process.env.ADHDEV_TOKEN || null;
     this.components = await initDaemonComponents({
@@ -34031,7 +34046,7 @@ var StandaloneServer = class {
             managedBy: "adhdev-standalone"
           }
         }),
-        listHostedCliRuntimes: async () => listHostedCliRuntimes(sessionHostEndpoint)
+        listHostedCliRuntimes: async () => listHostedCliRuntimes2(sessionHostEndpoint)
       },
       onStatusChange: () => this.broadcastStatus(),
       onStreamsUpdated: (ideType, streams) => {
@@ -34399,6 +34414,7 @@ var StandaloneServer = class {
     console.log(`[WS] Client connected (total: ${this.clients.size})`);
     const status = this.getStatus();
     ws.send(JSON.stringify({ type: "status", data: status }));
+    void this.pushWsRuntimeSnapshots(ws);
     ws.on("message", async (raw) => {
       try {
         const msg = JSON.parse(raw.toString());
@@ -34442,6 +34458,32 @@ var StandaloneServer = class {
       daemonMode: false
     });
   }
+  async pushWsRuntimeSnapshots(ws) {
+    if (!this.components || !this.sessionHostEndpoint || ws.readyState !== import_ws2.WebSocket.OPEN) return;
+    const client = new SessionHostClient({ endpoint: this.sessionHostEndpoint || void 0 });
+    await client.connect();
+    try {
+      const states = this.components.instanceManager.collectAllStates();
+      for (const state of states) {
+        const sessionId = typeof state?.instanceId === "string" ? state.instanceId : "";
+        if (!sessionId || state?.category !== "cli") continue;
+        const snapshot = await client.request({
+          type: "get_snapshot",
+          payload: { sessionId }
+        });
+        if (!snapshot.success || !snapshot.result || ws.readyState !== import_ws2.WebSocket.OPEN) continue;
+        ws.send(JSON.stringify({
+          type: "runtime_snapshot",
+          sessionId,
+          ...snapshot.result
+        }));
+      }
+    } catch {
+    } finally {
+      await client.close().catch(() => {
+      });
+    }
+  }
   getStatus(snapshot = this.buildSharedSnapshot()) {
     const cfgSnap = loadConfig();
     return {