@h-rig/runtime 0.0.6-alpha.21 → 0.0.6-alpha.23

package/dist/src/control-plane/pi-sessiond/server.js

@@ -0,0 +1,802 @@
+// @bun
+// packages/runtime/src/control-plane/pi-sessiond/server.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+
+// packages/runtime/src/control-plane/pi-sessiond/event-hub.ts
+function isOpen(socket) {
+  return socket.readyState === (socket.OPEN ?? 1);
+}
+
+class RigPiSessionEventHub {
+  socketsBySession = new Map;
+  socketsByRun = new Map;
+  addSession(sessionId, socket) {
+    return addToMapSet(this.socketsBySession, sessionId, socket);
+  }
+  addRun(runId, socket) {
+    return addToMapSet(this.socketsByRun, runId, socket);
+  }
+  publishSession(sessionId, event) {
+    this.publishSet(this.socketsBySession.get(sessionId), event);
+  }
+  publishRun(runId, event) {
+    this.publishSet(this.socketsByRun.get(runId), event);
+  }
+  publish(sessionId, runId, event) {
+    this.publishSession(sessionId, event);
+    if (runId)
+      this.publishRun(runId, event);
+  }
+  publishSet(sockets, event) {
+    if (!sockets || sockets.size === 0)
+      return;
+    const payload = JSON.stringify(event);
+    for (const socket of [...sockets]) {
+      if (isOpen(socket)) {
+        socket.send(payload);
+      } else {
+        sockets.delete(socket);
+      }
+    }
+  }
+}
+function addToMapSet(map, key, socket) {
+  let sockets = map.get(key);
+  if (!sockets) {
+    sockets = new Set;
+    map.set(key, sockets);
+  }
+  sockets.add(socket);
+  let removed = false;
+  return () => {
+    if (removed)
+      return;
+    removed = true;
+    sockets?.delete(socket);
+    if (sockets?.size === 0)
+      map.delete(key);
+  };
+}
+
+// packages/runtime/src/control-plane/pi-sessiond/session-service.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import {
+  AuthStorage,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  ModelRegistry,
+  SessionManager
+} from "@earendil-works/pi-coding-agent";
+
+// packages/runtime/src/control-plane/pi-sessiond/extension-ui-context.ts
+import { randomUUID } from "crypto";
+import {
+  initTheme
+} from "@earendil-works/pi-coding-agent";
+var headlessTheme = {
+  fg: (_color, text) => text,
+  bg: (_color, text) => text,
+  dim: (text) => text,
+  bold: (text) => text,
+  italic: (text) => text,
+  underline: (text) => text,
+  strikethrough: (text) => text,
+  reset: (text) => text,
+  getFgAnsi: () => "",
+  getBgAnsi: () => "",
+  name: "rig-headless"
+};
+function ensureThemeInitialized() {
+  try {
+    initTheme(undefined, false);
+  } catch {}
+}
+
+class RigPiExtensionUiBridge {
+  sessionId;
+  runId;
+  publish;
+  pending = new Map;
+  constructor(sessionId, runId, publish) {
+    this.sessionId = sessionId;
+    this.runId = runId;
+    this.publish = publish;
+    ensureThemeInitialized();
+  }
+  createContext() {
+    const dialog = (opts, defaultValue, request, parse) => {
+      if (opts?.signal?.aborted)
+        return Promise.resolve(defaultValue);
+      const id = randomUUID();
+      return new Promise((resolve) => {
+        let timeout;
+        const cleanup = () => {
+          if (timeout)
+            clearTimeout(timeout);
+          opts?.signal?.removeEventListener("abort", onAbort);
+          this.pending.delete(id);
+        };
+        const finish = (value) => {
+          cleanup();
+          resolve(value);
+        };
+        const onAbort = () => finish(defaultValue);
+        opts?.signal?.addEventListener("abort", onAbort, { once: true });
+        if (opts?.timeout)
+          timeout = setTimeout(() => finish(defaultValue), opts.timeout);
+        this.pending.set(id, {
+          timeout,
+          abort: onAbort,
+          resolve: (raw) => finish(parse(normalizeResponse(raw)))
+        });
+        this.publish({
+          type: "extension_ui_request",
+          sessionId: this.sessionId,
+          runId: this.runId,
+          request: { id, timeout: opts?.timeout, ...request }
+        });
+      });
+    };
+    return {
+      select: (title, options, opts) => dialog(opts, undefined, { method: "select", title, options }, (response) => {
+        if (response.cancelled)
+          return;
+        return typeof response.value === "string" ? response.value : undefined;
+      }),
+      confirm: (title, message, opts) => dialog(opts, false, { method: "confirm", title, message }, (response) => {
+        if (response.cancelled)
+          return false;
+        return response.confirmed === true || response.value === true;
+      }),
+      input: (title, placeholder, opts) => dialog(opts, undefined, { method: "input", title, placeholder }, (response) => {
+        if (response.cancelled)
+          return;
+        return typeof response.value === "string" ? response.value : undefined;
+      }),
+      notify: (message, type) => {
+        this.fire({ method: "notify", message, notifyType: type });
+      },
+      onTerminalInput: () => () => {},
+      setStatus: (key, text) => {
+        this.fire({ method: "setStatus", statusKey: key, statusText: text });
+      },
+      setWorkingMessage: (message) => {
+        this.fire({ method: "setWorkingMessage", message });
+      },
+      setWorkingVisible: (visible) => {
+        this.fire({ method: "setWorkingVisible", visible });
+      },
+      setWorkingIndicator: (options) => {
+        this.fire({ method: "setWorkingIndicator", options });
+      },
+      setHiddenThinkingLabel: (label) => {
+        this.fire({ method: "setHiddenThinkingLabel", label });
+      },
+      setWidget: (key, content, options) => {
+        if (content === undefined || Array.isArray(content)) {
+          this.fire({ method: "setWidget", widgetKey: key, widgetLines: content, widgetPlacement: options?.placement });
+          return;
+        }
+        this.fire({ method: "notify", message: `Extension widget '${key}' uses a component factory that Rig daemon mode cannot render.`, notifyType: "warning" });
+      },
+      setFooter: (factory) => {
+        if (factory !== undefined)
+          this.fire({ method: "notify", message: "Custom extension footers are not rendered in Rig daemon mode.", notifyType: "warning" });
+      },
+      setHeader: (factory) => {
+        if (factory !== undefined)
+          this.fire({ method: "notify", message: "Custom extension headers are not rendered in Rig daemon mode.", notifyType: "warning" });
+      },
+      setTitle: (title) => {
+        this.fire({ method: "setTitle", title });
+      },
+      custom: async () => {
+        this.fire({ method: "notify", message: "Custom extension UI components are not supported in Rig daemon mode.", notifyType: "warning" });
+        return;
+      },
+      pasteToEditor: (text) => {
+        this.fire({ method: "set_editor_text", text });
+      },
+      setEditorText: (text) => {
+        this.fire({ method: "set_editor_text", text });
+      },
+      getEditorText: () => "",
+      editor: (title, prefill) => dialog(undefined, undefined, { method: "editor", title, prefill }, (response) => {
+        if (response.cancelled)
+          return;
+        return typeof response.value === "string" ? response.value : undefined;
+      }),
+      addAutocompleteProvider: () => {},
+      setEditorComponent: (factory) => {
+        if (factory !== undefined)
+          this.fire({ method: "notify", message: "Custom editor components are not supported in Rig daemon mode.", notifyType: "warning" });
+      },
+      getEditorComponent: () => {
+        return;
+      },
+      get theme() {
+        return headlessTheme;
+      },
+      getAllThemes: () => [],
+      getTheme: () => {
+        return;
+      },
+      setTheme: () => ({ success: false, error: "Theme switching is not supported in Rig daemon mode" }),
+      getToolsExpanded: () => false,
+      setToolsExpanded: () => {}
+    };
+  }
+  respond(input) {
+    const pending = this.pending.get(input.requestId);
+    if (!pending)
+      return false;
+    pending.resolve(input);
+    return true;
+  }
+  cancelAll() {
+    for (const [id, pending] of this.pending.entries()) {
+      if (pending.timeout)
+        clearTimeout(pending.timeout);
+      pending.abort?.();
+      this.pending.delete(id);
+      pending.resolve({ requestId: id, cancelled: true });
+    }
+  }
+  fire(request) {
+    this.publish({
+      type: "extension_ui_request",
+      sessionId: this.sessionId,
+      runId: this.runId,
+      request: { id: randomUUID(), ...request }
+    });
+  }
+}
+function normalizeResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { requestId: "", cancelled: true };
+  const record = value;
+  return {
+    requestId: typeof record.requestId === "string" ? record.requestId : "",
+    value: record.value,
+    confirmed: typeof record.confirmed === "boolean" ? record.confirmed : undefined,
+    cancelled: record.cancelled === true
+  };
+}
+
+// packages/runtime/src/control-plane/pi-sessiond/session-service.ts
+var BUILTIN_COMMANDS = [
+  { name: "session", description: "Show session info and stats", source: "builtin" },
+  { name: "name", description: "Set session display name", source: "builtin" },
+  { name: "compact", description: "Manually compact session context", source: "builtin" },
+  { name: "reload", description: "Reload keybindings, extensions, skills, prompts, and themes", source: "builtin" },
+  { name: "quit", description: "Detach from the current local Pi frontend", source: "builtin" }
+];
+
+class RigPiSessionService {
+  hub;
+  config;
+  activeBySession = new Map;
+  sessionIdByRun = new Map;
+  heartbeat;
+  constructor(hub, config) {
+    this.hub = hub;
+    this.config = config;
+    this.heartbeat = setInterval(() => this.publishHeartbeats(), 2000);
+  }
+  activeCount() {
+    return this.activeBySession.size;
+  }
+  async dispose() {
+    clearInterval(this.heartbeat);
+    const sessions = [...this.activeBySession.values()];
+    this.activeBySession.clear();
+    this.sessionIdByRun.clear();
+    await Promise.all(sessions.map(async (active) => {
+      active.unsubscribe();
+      active.ui.cancelAll();
+      try {
+        await active.runtime.session.abort();
+      } catch {}
+      await active.runtime.dispose();
+    }));
+  }
+  async startSession(input) {
+    const existing = this.getByRun(input.runId);
+    if (existing)
+      return existing.metadata;
+    mkdirSync(input.agentDir, { recursive: true });
+    mkdirSync(input.sessionDir, { recursive: true });
+    const authStorage = AuthStorage.create(join(input.agentDir, "auth.json"));
+    const modelRegistry = ModelRegistry.create(authStorage, join(input.agentDir, "models.json"));
+    const createRuntime = async ({ cwd, agentDir, sessionManager: sessionManager2, sessionStartEvent }) => {
+      const services = await createAgentSessionServices({ cwd, agentDir, authStorage, modelRegistry });
+      const result = await createAgentSessionFromServices({ services, sessionManager: sessionManager2, sessionStartEvent });
+      return { ...result, services, diagnostics: services.diagnostics };
+    };
+    const sessionManager = SessionManager.create(input.cwd, input.sessionDir);
+    const runtime = await createAgentSessionRuntime(createRuntime, {
+      cwd: input.cwd,
+      agentDir: input.agentDir,
+      sessionManager,
+      sessionStartEvent: { type: "session_start", reason: "new" }
+    });
+    const now = new Date().toISOString();
+    const metadata = {
+      runId: input.runId,
+      sessionId: runtime.session.sessionId,
+      daemonId: this.config.daemonId,
+      cwd: input.cwd,
+      agentDir: input.agentDir,
+      sessionDir: input.sessionDir,
+      transport: "http-control-ws-events",
+      serverBasePath: `/api/runs/${encodeURIComponent(input.runId)}/pi`,
+      eventsPath: `/api/runs/${encodeURIComponent(input.runId)}/pi/events`,
+      createdAt: now,
+      updatedAt: now,
+      backend: {
+        kind: "worker-pi-sessiond",
+        version: this.config.version,
+        commit: this.config.commit,
+        pid: process.pid
+      }
+    };
+    const active = {
+      runId: input.runId,
+      runtime,
+      metadata,
+      unsubscribe: () => {},
+      ui: new RigPiExtensionUiBridge(runtime.session.sessionId, input.runId, (event) => this.publish(runtime.session.sessionId, input.runId, event))
+    };
+    await this.bindRuntime(active);
+    if (input.sessionName?.trim())
+      runtime.session.setSessionName(input.sessionName.trim());
+    this.activeBySession.set(runtime.session.sessionId, active);
+    this.sessionIdByRun.set(input.runId, runtime.session.sessionId);
+    this.publish(runtime.session.sessionId, input.runId, { type: "ready", metadata });
+    this.publishStatus(active);
+    this.publishActivity(active, "ready", "idle");
+    return metadata;
+  }
+  getByRun(runId) {
+    const sessionId = this.sessionIdByRun.get(runId);
+    return sessionId ? this.activeBySession.get(sessionId) : undefined;
+  }
+  getBySession(sessionId) {
+    return this.activeBySession.get(sessionId);
+  }
+  messages(sessionId) {
+    const active = this.requireActive(sessionId);
+    return [...active.runtime.session.messages];
+  }
+  status(sessionId) {
+    return this.statusFromActive(this.requireActive(sessionId));
+  }
+  commands(sessionId) {
+    const session = this.requireActive(sessionId).runtime.session;
+    const commands = [...BUILTIN_COMMANDS];
+    for (const command of session.extensionRunner.getRegisteredCommands()) {
+      commands.push({ name: command.invocationName, description: command.description, source: "extension" });
+    }
+    for (const template of session.promptTemplates) {
+      commands.push({ name: template.name, description: template.description, source: "prompt" });
+    }
+    for (const skill of session.resourceLoader.getSkills().skills) {
+      commands.push({ name: `skill:${skill.name}`, description: skill.description, source: "skill" });
+    }
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async prompt(sessionId, text, streamingBehavior) {
+    const active = this.requireActive(sessionId);
+    const session = active.runtime.session;
+    const behavior = session.isStreaming || session.isCompacting ? streamingBehavior ?? "steer" : undefined;
+    this.publishActivity(active, behavior === "followUp" ? "follow-up queued" : behavior === "steer" ? "steering queued" : "prompt accepted", "active");
+    session.prompt(text, behavior ? { streamingBehavior: behavior, source: "rpc" } : { source: "rpc" }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "error", message });
+      this.publishActivity(active, "prompt failed", "error", message);
+    });
+    this.publishStatus(active);
+    return { accepted: true };
+  }
+  async shell(sessionId, text) {
+    const active = this.requireActive(sessionId);
+    const session = active.runtime.session;
+    const excluded = text.startsWith("!!");
+    const command = (excluded ? text.slice(2) : text.startsWith("!") ? text.slice(1) : text).trim();
+    if (!command)
+      throw new Error("Usage: !<shell command>");
+    if (session.isBashRunning)
+      throw new Error("A bash command is already running");
+    this.publishActivity(active, "running bash", "active", command);
+    this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.start", command, excludeFromContext: excluded } });
+    session.executeBash(command, (chunk) => {
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.chunk", chunk } });
+      this.publishActivity(active, "running bash", "active", command);
+      this.publishStatus(active);
+    }, { excludeFromContext: excluded }).then((result) => {
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.end", ...result } });
+      this.publishActivity(active, "bash complete", result.exitCode === 0 ? "idle" : "error", command);
+      this.publishStatus(active);
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.end", output: message, isError: true } });
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "error", message });
+      this.publishActivity(active, "bash failed", "error", message);
+      this.publishStatus(active);
+    });
+    return { accepted: true };
+  }
+  async runCommand(sessionId, text) {
+    const active = this.requireActive(sessionId);
+    const trimmed = text.trim();
+    const [rawName = "", ...args] = trimmed.replace(/^\//, "").split(/\s+/);
+    const rest = args.join(" ").trim();
+    if (rawName === "session")
+      return { type: "done", message: formatSessionStats(active.runtime.session) };
+    if (rawName === "name") {
+      if (!rest)
+        return { type: "unsupported", message: "Usage: /name <session name>" };
+      active.runtime.session.setSessionName(rest);
+      this.publishStatus(active);
+      return { type: "done", message: `Session named: ${rest}` };
+    }
+    if (rawName === "compact") {
+      active.runtime.session.compact(rest || undefined).catch((error) => {
+        this.publish(active.runtime.session.sessionId, active.runId, { type: "error", message: error instanceof Error ? error.message : String(error) });
+      });
+      return { type: "done", message: "Compaction started\u2026" };
+    }
+    if (rawName === "reload") {
+      await active.runtime.session.reload();
+      await this.bindRuntime(active);
+      return { type: "done", message: "Pi resources reloaded" };
+    }
+    if (rawName === "quit")
+      return { type: "done", message: "Detach locally with /detach or /quit." };
+    await this.prompt(sessionId, trimmed, active.runtime.session.isStreaming ? "steer" : undefined);
+    return { type: "done", message: `Accepted ${trimmed}` };
+  }
+  respondToCommand(_sessionId, _requestId, _value) {
+    return { type: "unsupported", message: "No pending command selection is active." };
+  }
+  respondToExtensionUi(sessionId, input) {
+    const active = this.requireActive(sessionId);
+    return { accepted: active.ui.respond(input) };
+  }
+  async abort(sessionId) {
+    const active = this.requireActive(sessionId);
+    active.runtime.session.clearQueue();
+    await active.runtime.session.abort();
+    this.publishActivity(active, "stopped", "idle");
+    this.publishStatus(active);
+    return { aborted: true };
+  }
+  async bindRuntime(active) {
+    active.unsubscribe();
+    const session = active.runtime.session;
+    active.ui.cancelAll();
+    active.ui = new RigPiExtensionUiBridge(session.sessionId, active.runId, (event) => this.publish(session.sessionId, active.runId, event));
+    active.metadata = { ...active.metadata, sessionId: session.sessionId, updatedAt: new Date().toISOString() };
+    this.sessionIdByRun.set(active.runId, session.sessionId);
+    this.activeBySession.set(session.sessionId, active);
+    active.runtime.setRebindSession(async () => this.bindRuntime(active));
+    await session.bindExtensions({
+      uiContext: active.ui.createContext(),
+      commandContextActions: {
+        waitForIdle: () => session.agent.waitForIdle(),
+        newSession: async (options) => active.runtime.newSession(options),
+        fork: async (entryId, options) => {
+          const result = await active.runtime.fork(entryId, options);
+          return { cancelled: result.cancelled };
+        },
+        navigateTree: async (targetId, options) => session.navigateTree(targetId, options),
+        switchSession: async (sessionPath, options) => active.runtime.switchSession(sessionPath, options),
+        reload: async () => {
+          await session.reload();
+        }
+      },
+      shutdownHandler: () => {
+        this.abort(session.sessionId);
+      },
+      onError: (error) => {
+        this.publish(session.sessionId, active.runId, { type: "error", message: error.error, detail: error });
+      }
+    });
+    active.unsubscribe = session.subscribe((event) => {
+      this.publish(session.sessionId, active.runId, { type: "pi.event", sessionId: session.sessionId, runId: active.runId, event });
+      this.publishActivityForEvent(active, event);
+      this.publishStatus(active);
+    });
+  }
+  publish(sessionId, runId, event) {
+    this.hub.publish(sessionId, runId, event);
+  }
+  publishStatus(active) {
+    const status = this.statusFromActive(active);
+    this.publish(active.runtime.session.sessionId, active.runId, { type: "status.update", sessionId: active.runtime.session.sessionId, runId: active.runId, status });
+  }
+  publishActivity(active, label, phase, detail) {
+    const activity = {
+      sessionId: active.runtime.session.sessionId,
+      runId: active.runId,
+      phase,
+      label,
+      detail,
+      at: new Date().toISOString()
+    };
+    active.activity = activity;
+    this.publish(active.runtime.session.sessionId, active.runId, { type: "activity.update", sessionId: active.runtime.session.sessionId, runId: active.runId, activity });
+  }
+  publishActivityForEvent(active, event) {
+    const type = event && typeof event === "object" && !Array.isArray(event) ? event.type : undefined;
+    if (type === "agent_start")
+      this.publishActivity(active, "agent running", "active");
+    else if (type === "agent_end")
+      this.publishActivity(active, "idle", "idle");
+    else if (type === "tool_execution_start")
+      this.publishActivity(active, `tool: ${String(event.toolName ?? "tool")}`, "active");
+    else if (type === "compaction_start")
+      this.publishActivity(active, "compacting", "active");
+    else if (type === "compaction_end")
+      this.publishActivity(active, "compaction complete", "idle");
+  }
+  publishHeartbeats() {
+    for (const active of this.activeBySession.values()) {
+      if (active.runtime.session.isStreaming || active.runtime.session.isCompacting || active.runtime.session.isBashRunning || active.runtime.session.pendingMessageCount > 0) {
+        this.publishStatus(active);
+        this.publishActivity(active, active.activity?.label ?? "active", "active", active.activity?.detail);
+      }
+    }
+  }
+  statusFromActive(active) {
+    const session = active.runtime.session;
+    return {
+      sessionId: session.sessionId,
+      runId: active.runId,
+      cwd: active.runtime.cwd,
+      sessionFile: session.sessionFile,
+      sessionName: session.sessionName,
+      model: session.model,
+      thinkingLevel: session.thinkingLevel,
+      isStreaming: session.isStreaming,
+      isCompacting: session.isCompacting,
+      isBashRunning: session.isBashRunning,
+      pendingMessageCount: session.pendingMessageCount,
+      messageCount: session.messages.length,
+      steeringMessages: session.getSteeringMessages(),
+      followUpMessages: session.getFollowUpMessages(),
+      contextUsage: session.getContextUsage(),
+      stats: session.getSessionStats()
+    };
+  }
+  requireActive(sessionId) {
+    const active = this.activeBySession.get(sessionId);
+    if (!active)
+      throw new Error("Pi session not found");
+    return active;
+  }
+}
+function formatSessionStats(session) {
+  const stats = session.getSessionStats();
+  return [
+    `Session: ${stats.sessionId}`,
+    `Messages: ${stats.totalMessages} (${stats.userMessages} user, ${stats.assistantMessages} assistant)`,
+    `Tool calls: ${stats.toolCalls}`,
+    `Tokens: \u2191${stats.tokens.input} \u2193${stats.tokens.output} total ${stats.tokens.total}`,
+    `Cost: $${stats.cost.toFixed(4)}`
+  ].join(`
+`);
+}
+function createDaemonId() {
+  return `rig-pi-sessiond-${randomUUID2()}`;
+}
+
+// packages/runtime/src/control-plane/pi-sessiond/server.ts
+async function runRigPiSessionDaemon(options = {}) {
+  const rootDir = resolve(options.rootDir || process.env.RIG_PI_SESSIOND_ROOT || process.cwd());
+  mkdirSync2(rootDir, { recursive: true });
+  const token = options.token || process.env.RIG_PI_SESSIOND_TOKEN || randomToken();
+  const host = options.host || process.env.RIG_PI_SESSIOND_HOST || "127.0.0.1";
+  const requestedPort = options.port ?? numberFromEnv(process.env.RIG_PI_SESSIOND_PORT) ?? 0;
+  const startedAt = new Date().toISOString();
+  const config = {
+    daemonId: options.daemonId || process.env.RIG_PI_SESSIOND_ID || createDaemonId(),
+    token,
+    host,
+    port: requestedPort,
+    rootDir,
+    startedAt,
+    version: options.version || process.env.RIG_VERSION || "dev",
+    commit: options.commit || process.env.RIG_GIT_COMMIT
+  };
+  const hub = new RigPiSessionEventHub;
+  const sessions = new RigPiSessionService(hub, config);
+  const server = Bun.serve({
+    hostname: host,
+    port: requestedPort,
+    idleTimeout: 255,
+    fetch: async (req, server2) => {
+      const url = new URL(req.url);
+      if (url.pathname === "/health" && req.method === "GET") {
+        return json(health(server2.port ?? config.port, config, sessions.activeCount()));
+      }
+      if (!isAuthorized(req, token))
+        return json({ ok: false, error: "Unauthorized" }, 401);
+      if (url.pathname === "/sessions" && req.method === "POST") {
+        const body = await readJson(req);
+        const runId = asString(body.runId);
+        const cwd = asString(body.cwd);
+        const agentDir = asString(body.agentDir);
+        const sessionDir = asString(body.sessionDir);
+        if (!runId || !cwd || !agentDir || !sessionDir)
+          return json({ ok: false, error: "runId, cwd, agentDir, and sessionDir are required" }, 400);
+        const metadata = await sessions.startSession({ runId, cwd, agentDir, sessionDir, sessionName: asString(body.sessionName) ?? undefined });
+        return json({ metadata });
+      }
+      const runEventsMatch = url.pathname.match(/^\/runs\/([^/]+)\/events$/);
+      if (runEventsMatch && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        const upgraded = server2.upgrade(req, { data: { kind: "run-events", runId: decodeURIComponent(runEventsMatch[1]) } });
+        return upgraded ? new Response(null) : json({ ok: false, error: "WebSocket upgrade failed" }, 400);
+      }
+      const sessionEventsMatch = url.pathname.match(/^\/sessions\/([^/]+)\/events$/);
+      if (sessionEventsMatch && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        const upgraded = server2.upgrade(req, { data: { kind: "session-events", sessionId: decodeURIComponent(sessionEventsMatch[1]) } });
+        return upgraded ? new Response(null) : json({ ok: false, error: "WebSocket upgrade failed" }, 400);
+      }
+      const sessionMatch = url.pathname.match(/^\/sessions\/([^/]+)(?:\/(.*))?$/);
+      if (!sessionMatch)
+        return json({ ok: false, error: "Not found" }, 404);
+      const sessionId = decodeURIComponent(sessionMatch[1]);
+      const action = sessionMatch[2] || "";
+      try {
+        if (action === "messages" && req.method === "GET")
+          return json({ messages: sessions.messages(sessionId) });
+        if (action === "status" && req.method === "GET")
+          return json({ status: sessions.status(sessionId) });
+        if (action === "commands" && req.method === "GET")
+          return json({ commands: sessions.commands(sessionId) });
+        if (action === "prompt" && req.method === "POST") {
+          const body = await readJson(req);
+          return json(await sessions.prompt(sessionId, requireText(body, "text"), optionalStreamingBehavior(body)));
+        }
+        if (action === "shell" && req.method === "POST") {
+          const body = await readJson(req);
+          return json(await sessions.shell(sessionId, requireText(body, "text")));
+        }
+        if (action === "commands/run" && req.method === "POST") {
+          const body = await readJson(req);
+          return json(await sessions.runCommand(sessionId, requireText(body, "text")));
+        }
+        if (action === "commands/respond" && req.method === "POST") {
+          const body = await readJson(req);
+          return json(sessions.respondToCommand(sessionId, requireText(body, "requestId"), body.value));
+        }
+        if (action === "extension-ui/respond" && req.method === "POST") {
+          const body = await readJson(req);
+          return json(sessions.respondToExtensionUi(sessionId, {
+            requestId: requireText(body, "requestId"),
+            value: body.value,
+            confirmed: typeof body.confirmed === "boolean" ? body.confirmed : undefined,
+            cancelled: body.cancelled === true
+          }));
+        }
+        if (action === "abort" && req.method === "POST")
+          return json(await sessions.abort(sessionId));
+        return json({ ok: false, error: "Not found" }, 404);
+      } catch (error) {
+        return json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 400);
+      }
+    },
+    websocket: {
+      open(ws) {
+        const data = ws.data;
+        const cleanup = data.kind === "session-events" ? hub.addSession(data.sessionId, ws) : hub.addRun(data.runId, ws);
+        ws.__rigCleanup = cleanup;
+      },
+      message() {},
+      close(ws) {
+        ws.__rigCleanup?.();
+      }
+    }
+  });
+  config.port = server.port ?? requestedPort;
+  writeReadyFile(options.readyFile || process.env.RIG_PI_SESSIOND_READY_FILE, {
+    pid: process.pid,
+    host,
+    port: server.port ?? requestedPort,
+    token,
+    daemonId: config.daemonId,
+    rootDir,
+    startedAt,
+    version: config.version,
+    commit: config.commit
+  });
+  console.error(`[rig-pi-sessiond] listening on http://${host}:${server.port ?? requestedPort}`);
+  const shutdown = async () => {
+    await sessions.dispose();
+    server.stop(true);
+    process.exit(0);
+  };
+  process.once("SIGTERM", () => {
+    shutdown();
+  });
+  process.once("SIGINT", () => {
+    shutdown();
+  });
+  return await new Promise(() => {});
+}
+function health(port, config, activeSessions) {
+  return {
+    ok: true,
+    daemonId: config.daemonId,
+    version: config.version,
+    commit: config.commit,
+    pid: process.pid,
+    startedAt: config.startedAt,
+    activeSessions,
+    checkedAt: new Date().toISOString()
+  };
+}
+async function readJson(req) {
+  const value = await req.json().catch(() => ({}));
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function json(payload, status = 200) {
+  return Response.json(payload, { status });
+}
+function isAuthorized(req, token) {
+  const url = new URL(req.url);
+  const queryToken = url.searchParams.get("token");
+  const header = req.headers.get("authorization") || "";
+  const match = header.match(/^Bearer\s+(.+)$/i);
+  return queryToken === token || match?.[1] === token;
+}
+function requireText(body, field) {
+  const value = body && typeof body === "object" && !Array.isArray(body) ? body[field] : undefined;
+  if (typeof value !== "string" || value.trim() === "")
+    throw new Error(`${field} is required`);
+  return value;
+}
+function optionalStreamingBehavior(body) {
+  const value = body && typeof body === "object" && !Array.isArray(body) ? body.streamingBehavior : undefined;
+  return value === "steer" || value === "followUp" ? value : undefined;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function numberFromEnv(value) {
+  if (!value?.trim())
+    return;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function randomToken() {
+  return randomBytes(32).toString("hex");
+}
+function writeReadyFile(path, payload) {
+  if (!path)
+    return;
+  const resolved = resolve(path);
+  mkdirSync2(dirname(resolved), { recursive: true });
+  writeFileSync(resolved, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+function readDaemonReadyFile(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  runRigPiSessionDaemon,
+  readDaemonReadyFile
+};