adhdev 0.8.25 → 0.8.28

package/vendor/session-host-daemon/index.mjs

@@ -238,6 +238,20 @@ var PtySessionRuntime = class {
     if (!this.ptyProcess) return;
     this.ptyProcess.kill();
   }
+  sendSignal(signal) {
+    if (!this.ptyProcess) throw new Error(`Session not running: ${this.sessionId}`);
+    const normalized = String(signal || "").trim().toUpperCase();
+    if (!normalized) throw new Error("signal is required");
+    try {
+      process.kill(this.ptyProcess.pid, normalized);
+    } catch {
+      if (normalized === "SIGTERM" || normalized === "SIGKILL") {
+        this.ptyProcess.kill();
+        return;
+      }
+      throw new Error(`Unsupported signal for runtime ${this.sessionId}: ${normalized}`);
+    }
+  }
   getSnapshotText() {
     return this.screenMirror?.formatVT() || "";
   }
@@ -306,7 +320,8 @@ var SessionHostStorage = class {
 };
 
 // src/server.ts
-var SessionHostServer = class extends EventEmitter {
+var SessionHostServer = class _SessionHostServer extends EventEmitter {
+  static MAX_RECENT_DIAGNOSTICS = 200;
   endpoint;
   registry = new SessionHostRegistry();
   runtimes = /* @__PURE__ */ new Map();
@@ -314,6 +329,11 @@ var SessionHostServer = class extends EventEmitter {
   ipcServer = null;
   sockets = /* @__PURE__ */ new Set();
   persistTimers = /* @__PURE__ */ new Map();
+  startedAt = Date.now();
+  recentLogs = [];
+  recentRequests = [];
+  recentTransitions = [];
+  exitWaiters = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     super();
     this.endpoint = options.endpoint || getDefaultSessionHostEndpoint(options.appName || "adhdev");
@@ -341,12 +361,12 @@ var SessionHostServer = class extends EventEmitter {
       this.ipcServer?.once("error", reject);
       this.ipcServer?.listen(this.endpoint.path);
     });
-    this.emit("log", `session host endpoint ready: ${this.endpoint.path}`);
+    this.recordHostLog("info", `session host endpoint ready: ${this.endpoint.path}`);
     setTimeout(() => {
       try {
         this.restorePersistedRuntimes();
       } catch (error) {
-        this.emit("log", `session host restore failed: ${error?.message || String(error)}`);
+        this.recordHostLog("error", `session host restore failed: ${error?.message || String(error)}`);
       }
     }, 0);
   }
@@ -387,12 +407,14 @@ var SessionHostServer = class extends EventEmitter {
           const record = this.registry.createSession(request.payload);
           this.schedulePersist(record.sessionId);
           this.emitEvent({ type: "session_created", sessionId: record.sessionId, record });
+          this.recordRuntimeTransition(record.sessionId, "create_session", "starting", `provider=${record.providerType}`, true);
           try {
             const startedRecord = this.startRuntime(record, request.payload, "session_started");
             return { success: true, result: startedRecord };
           } catch (error) {
             this.registry.markStopped(record.sessionId, "failed");
             this.persistNow(record.sessionId);
+            this.recordRuntimeTransition(record.sessionId, "create_session_failed", "failed", void 0, false, error?.message || String(error));
             return { success: false, error: error?.message || String(error) };
           }
         }
@@ -405,32 +427,39 @@ var SessionHostServer = class extends EventEmitter {
           if (client) {
             this.emitEvent({ type: "client_attached", sessionId: record.sessionId, client });
           }
+          this.recordRuntimeTransition(record.sessionId, "attach_client", record.lifecycle, request.payload.clientId, true);
           return { success: true, result: record };
         }
         case "detach_session": {
           const record = this.registry.detachClient(request.payload);
           this.schedulePersist(record.sessionId);
           this.emitEvent({ type: "client_detached", sessionId: record.sessionId, clientId: request.payload.clientId });
+          this.recordRuntimeTransition(record.sessionId, "detach_client", record.lifecycle, request.payload.clientId, true);
           return { success: true, result: record };
         }
         case "acquire_write": {
           const record = this.registry.acquireWrite(request.payload);
           this.persistNow(record.sessionId);
           this.emitEvent({ type: "write_owner_changed", sessionId: record.sessionId, owner: record.writeOwner });
+          this.recordRuntimeTransition(record.sessionId, "acquire_write", record.lifecycle, request.payload.clientId, true);
           return { success: true, result: record };
         }
         case "release_write": {
           const record = this.registry.releaseWrite(request.payload);
           this.persistNow(record.sessionId);
           this.emitEvent({ type: "write_owner_changed", sessionId: record.sessionId, owner: record.writeOwner });
+          this.recordRuntimeTransition(record.sessionId, "release_write", record.lifecycle, request.payload.clientId, true);
           return { success: true, result: record };
         }
         case "get_snapshot":
           return { success: true, result: this.getSnapshot(request.payload.sessionId, request.payload.sinceSeq) };
+        case "get_host_diagnostics":
+          return { success: true, result: this.getHostDiagnostics(request.payload) };
         case "clear_session_buffer": {
           const record = this.registry.clearBuffer(request.payload.sessionId);
           this.persistNow(record.sessionId);
           this.emitEvent({ type: "session_cleared", sessionId: record.sessionId });
+          this.recordRuntimeTransition(record.sessionId, "clear_buffer", record.lifecycle, void 0, true);
           return { success: true, result: record };
         }
         case "update_session_meta": {
@@ -440,6 +469,7 @@ var SessionHostServer = class extends EventEmitter {
             request.payload.replace === true
           );
           this.persistNow(record.sessionId);
+          this.recordRuntimeTransition(record.sessionId, "update_meta", record.lifecycle, void 0, true);
           return { success: true, result: record };
         }
         case "send_input": {
@@ -484,6 +514,7 @@ var SessionHostServer = class extends EventEmitter {
           this.persistNow(request.payload.sessionId);
           this.requireRuntime(request.payload.sessionId).stop();
           this.emitEvent({ type: "session_stopped", sessionId: request.payload.sessionId });
+          this.recordRuntimeTransition(request.payload.sessionId, "stop_session", "stopping", void 0, true);
           return { success: true, result: this.registry.getSession(request.payload.sessionId) };
         }
         case "resume_session": {
@@ -495,8 +526,38 @@ var SessionHostServer = class extends EventEmitter {
             return { success: true, result: existing };
           }
           const resumed = this.startRuntime(existing, this.buildPayloadFromRecord(existing), "session_resumed");
+          this.recordRuntimeTransition(request.payload.sessionId, "resume_session", resumed.lifecycle, void 0, true);
           return { success: true, result: resumed };
         }
+        case "restart_session": {
+          const restarted = await this.restartRuntime(request.payload.sessionId);
+          return { success: true, result: restarted };
+        }
+        case "send_signal": {
+          const runtime = this.requireRuntime(request.payload.sessionId);
+          runtime.sendSignal(request.payload.signal);
+          const record = this.registry.getSession(request.payload.sessionId);
+          this.recordRuntimeTransition(request.payload.sessionId, "send_signal", record?.lifecycle, request.payload.signal, true);
+          return { success: true, result: record };
+        }
+        case "force_detach_client": {
+          const session = this.registry.getSession(request.payload.sessionId);
+          if (session?.writeOwner?.clientId === request.payload.clientId) {
+            const released = this.registry.releaseWrite({
+              sessionId: request.payload.sessionId,
+              clientId: request.payload.clientId
+            });
+            this.emitEvent({ type: "write_owner_changed", sessionId: released.sessionId, owner: released.writeOwner });
+          }
+          const record = this.registry.detachClient({
+            sessionId: request.payload.sessionId,
+            clientId: request.payload.clientId
+          });
+          this.schedulePersist(record.sessionId);
+          this.emitEvent({ type: "client_detached", sessionId: record.sessionId, clientId: request.payload.clientId });
+          this.recordRuntimeTransition(record.sessionId, "force_detach_client", record.lifecycle, request.payload.clientId, true);
+          return { success: true, result: record };
+        }
         default:
           return { success: false, error: `Unsupported session host request: ${request?.type || "unknown"}` };
       }
@@ -523,7 +584,18 @@ var SessionHostServer = class extends EventEmitter {
     this.emit("event", event);
   }
   async handleIncomingRequest(socket, envelope) {
+    const startedAt = Date.now();
     const response = await this.handleRequest(envelope.request);
+    this.recordRequestTrace({
+      timestamp: startedAt,
+      requestId: envelope.requestId,
+      type: envelope.request.type,
+      sessionId: this.getRequestSessionId(envelope.request),
+      clientId: this.getRequestClientId(envelope.request),
+      success: response.success,
+      durationMs: Math.max(0, Date.now() - startedAt),
+      error: response.success ? void 0 : response.error
+    });
     writeEnvelope(socket, createResponseEnvelope(envelope.requestId, response));
   }
   schedulePersist(sessionId) {
@@ -540,6 +612,99 @@ var SessionHostServer = class extends EventEmitter {
     const snapshot = this.getSnapshot(sessionId);
     this.storage.save(record, snapshot);
   }
+  getHostDiagnostics(payload) {
+    const limit = Math.max(1, Math.min(200, Number(payload?.limit) || 50));
+    return {
+      hostStartedAt: this.startedAt,
+      endpoint: this.endpoint.path,
+      runtimeCount: this.runtimes.size,
+      sessions: payload?.includeSessions === false ? void 0 : this.registry.listSessions(),
+      recentLogs: this.recentLogs.slice(-limit),
+      recentRequests: this.recentRequests.slice(-limit),
+      recentTransitions: this.recentTransitions.slice(-limit)
+    };
+  }
+  getRequestSessionId(request) {
+    const payload = request.payload;
+    return typeof payload?.sessionId === "string" ? payload.sessionId : void 0;
+  }
+  getRequestClientId(request) {
+    const payload = request.payload;
+    return typeof payload?.clientId === "string" ? payload.clientId : void 0;
+  }
+  pushRecent(bucket, entry) {
+    bucket.push(entry);
+    if (bucket.length > _SessionHostServer.MAX_RECENT_DIAGNOSTICS) {
+      bucket.splice(0, bucket.length - _SessionHostServer.MAX_RECENT_DIAGNOSTICS);
+    }
+  }
+  recordHostLog(level, message, sessionId, data) {
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      message,
+      sessionId,
+      data
+    };
+    this.pushRecent(this.recentLogs, entry);
+    this.emitEvent({ type: "host_log", entry });
+    this.emit("log", `[${level}] ${message}`);
+  }
+  recordRequestTrace(trace) {
+    this.pushRecent(this.recentRequests, trace);
+    this.emitEvent({ type: "request_trace", trace });
+    if (!trace.success) {
+      this.recordHostLog(
+        "warn",
+        `request ${trace.type} failed after ${trace.durationMs}ms${trace.error ? `: ${trace.error}` : ""}`,
+        trace.sessionId,
+        { requestId: trace.requestId, clientId: trace.clientId }
+      );
+    }
+  }
+  recordRuntimeTransition(sessionId, action, lifecycle, detail, success = true, error) {
+    const transition = {
+      timestamp: Date.now(),
+      sessionId,
+      action,
+      lifecycle,
+      detail,
+      success,
+      error
+    };
+    this.pushRecent(this.recentTransitions, transition);
+    this.emitEvent({ type: "runtime_transition", transition });
+  }
+  waitForRuntimeExit(sessionId, timeoutMs = 5e3) {
+    if (!this.runtimes.has(sessionId)) {
+      return Promise.resolve(this.registry.getSession(sessionId)?.lifecycle === "failed" ? 1 : 0);
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const waiters2 = this.exitWaiters.get(sessionId) || [];
+        this.exitWaiters.set(sessionId, waiters2.filter((waiter) => waiter !== onExit));
+        reject(new Error(`Timed out waiting for runtime ${sessionId} to exit`));
+      }, timeoutMs);
+      const onExit = (exitCode) => {
+        clearTimeout(timeout);
+        resolve(exitCode);
+      };
+      const waiters = this.exitWaiters.get(sessionId) || [];
+      waiters.push(onExit);
+      this.exitWaiters.set(sessionId, waiters);
+    });
+  }
+  resolveExitWaiters(sessionId, exitCode) {
+    const waiters = this.exitWaiters.get(sessionId);
+    if (!waiters?.length) return;
+    this.exitWaiters.delete(sessionId);
+    for (const waiter of waiters) {
+      try {
+        waiter(exitCode);
+      } catch {
+      }
+    }
+  }
   getSnapshot(sessionId, sinceSeq) {
     const snapshot = this.registry.getSnapshot(sessionId, sinceSeq);
     const record = this.registry.getSession(sessionId);
@@ -575,6 +740,23 @@ var SessionHostServer = class extends EventEmitter {
       this.persistNow(record.sessionId);
     }
   }
+  async restartRuntime(sessionId) {
+    const existing = this.registry.getSession(sessionId);
+    if (!existing) {
+      throw new Error(`Unknown session: ${sessionId}`);
+    }
+    if (this.runtimes.has(sessionId)) {
+      this.registry.setLifecycle(sessionId, "stopping");
+      this.persistNow(sessionId);
+      this.recordRuntimeTransition(sessionId, "restart_requested", "stopping", void 0, true);
+      this.requireRuntime(sessionId).stop();
+      await this.waitForRuntimeExit(sessionId);
+    }
+    const latest = this.registry.getSession(sessionId) || existing;
+    const restarted = this.startRuntime(latest, this.buildPayloadFromRecord(latest), "session_resumed");
+    this.recordRuntimeTransition(sessionId, "restart_completed", restarted.lifecycle, void 0, true);
+    return restarted;
+  }
   restorePersistedRuntimes() {
     const states = this.storage.loadAll();
     const runtimesToResume = [];
@@ -607,7 +789,7 @@ var SessionHostServer = class extends EventEmitter {
       }
     }
     if (skippedOrphanLiveSessions > 0) {
-      this.emit("log", `session host skipped ${skippedOrphanLiveSessions} orphan live runtime(s) during restore`);
+      this.recordHostLog("warn", `session host skipped ${skippedOrphanLiveSessions} orphan live runtime(s) during restore`);
     }
     for (const { persisted, recoveredRecord } of runtimesToResume) {
       try {
@@ -626,6 +808,7 @@ var SessionHostServer = class extends EventEmitter {
           this.registry.getSnapshot(resumed.sessionId)
         );
         this.persistNow(resumed.sessionId);
+        this.recordRuntimeTransition(resumed.sessionId, "restore_auto_resumed", resumed.lifecycle, void 0, true);
       } catch (error) {
         const interrupted = this.registry.setLifecycle(recoveredRecord.sessionId, "interrupted");
         this.registry.restoreSession({
@@ -638,6 +821,8 @@ var SessionHostServer = class extends EventEmitter {
           }
         }, persisted.snapshot);
         this.persistNow(recoveredRecord.sessionId);
+        this.recordRuntimeTransition(recoveredRecord.sessionId, "restore_resume_failed", "interrupted", void 0, false, error?.message || String(error));
+        this.recordHostLog("error", `restore resume failed for ${recoveredRecord.sessionId}: ${error?.message || String(error)}`, recoveredRecord.sessionId);
       }
     }
   }
@@ -667,8 +852,17 @@ var SessionHostServer = class extends EventEmitter {
       onExit: (exitCode) => {
         this.registry.markStopped(record.sessionId, exitCode === 0 ? "stopped" : "failed");
         this.runtimes.delete(record.sessionId);
+        this.resolveExitWaiters(record.sessionId, exitCode);
         this.persistNow(record.sessionId);
         this.emitEvent({ type: "session_exit", sessionId: record.sessionId, exitCode });
+        this.recordRuntimeTransition(
+          record.sessionId,
+          "session_exit",
+          exitCode === 0 ? "stopped" : "failed",
+          void 0,
+          exitCode === 0,
+          exitCode === 0 ? void 0 : `exitCode=${exitCode}`
+        );
         setTimeout(() => this.storage.remove(record.sessionId), 5e3);
       }
     });
@@ -678,6 +872,7 @@ var SessionHostServer = class extends EventEmitter {
     const startedRecord = this.registry.markStarted(record.sessionId, pid);
     this.persistNow(record.sessionId);
     this.emitEvent({ type: startEventType, sessionId: record.sessionId, pid });
+    this.recordRuntimeTransition(record.sessionId, startEventType, startedRecord.lifecycle, `pid=${pid}`, true);
     return startedRecord;
   }
 };
@@ -939,6 +1134,7 @@ async function attachRuntime(target, readOnly = false, takeover = false) {
       return { signal, handler };
     });
     const unsubscribe = client.onEvent((event) => {
+      if (!("sessionId" in event)) return;
       if (event.sessionId !== runtimeId) return;
       if (event.type === "session_output") {
         if (event.seq <= lastSeq) return;