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

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

@@ -0,0 +1,41 @@
+// @bun
+// packages/runtime/src/control-plane/pi-sessiond/client.ts
+class RigPiSessionDaemonClient {
+  baseUrl;
+  token;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+  }
+  static fromConnection(connection, token) {
+    if (connection.mode === "http")
+      return new RigPiSessionDaemonClient({ baseUrl: connection.baseUrl, token });
+    throw new Error("Unix-socket Rig Pi daemon connections are not implemented in this build; use loopback HTTP.");
+  }
+  async request(method, path, body) {
+    const response = await fetch(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        ...body === undefined ? {} : { "content-type": "application/json" }
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    const text = await response.text();
+    const payload = text.trim() ? JSON.parse(text) : undefined;
+    if (!response.ok) {
+      const message = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.error === "string" ? payload.error : text || response.statusText;
+      throw new Error(`Rig Pi session daemon request failed (${response.status}): ${message}`);
+    }
+    return payload;
+  }
+  webSocketUrl(path) {
+    const url = new URL(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("token", this.token);
+    return url.toString();
+  }
+}
+export {
+  RigPiSessionDaemonClient
+};

package/dist/src/control-plane/pi-sessiond/event-hub.js

@@ -0,0 +1,59 @@
+// @bun
+// 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);
+  };
+}
+export {
+  RigPiSessionEventHub
+};

package/dist/src/control-plane/pi-sessiond/extension-ui-context.js

@@ -0,0 +1,198 @@
+// @bun
+// 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
+  };
+}
+export {
+  RigPiExtensionUiBridge
+};

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

@@ -0,0 +1,163 @@
+// @bun
+// packages/runtime/src/control-plane/pi-sessiond/launcher.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// packages/runtime/src/control-plane/pi-sessiond/client.ts
+class RigPiSessionDaemonClient {
+  baseUrl;
+  token;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+  }
+  static fromConnection(connection, token) {
+    if (connection.mode === "http")
+      return new RigPiSessionDaemonClient({ baseUrl: connection.baseUrl, token });
+    throw new Error("Unix-socket Rig Pi daemon connections are not implemented in this build; use loopback HTTP.");
+  }
+  async request(method, path, body) {
+    const response = await fetch(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        ...body === undefined ? {} : { "content-type": "application/json" }
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    const text = await response.text();
+    const payload = text.trim() ? JSON.parse(text) : undefined;
+    if (!response.ok) {
+      const message = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.error === "string" ? payload.error : text || response.statusText;
+      throw new Error(`Rig Pi session daemon request failed (${response.status}): ${message}`);
+    }
+    return payload;
+  }
+  webSocketUrl(path) {
+    const url = new URL(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("token", this.token);
+    return url.toString();
+  }
+}
+
+// packages/runtime/src/control-plane/pi-sessiond/launcher.ts
+var BUILD_CONFIG = {};
+var BAKED_RIG_SOURCE_ROOT = BUILD_CONFIG.RIG_SOURCE_ROOT ?? "";
+async function ensureRigPiSessionDaemon(input) {
+  const rootDir = resolve(input.rootDir);
+  mkdirSync(rootDir, { recursive: true });
+  const readyFile = resolve(rootDir, "ready.json");
+  const existing = readDaemonReadyFile(readyFile);
+  const existingHandle = existing ? await tryReady(existing) : null;
+  if (existingHandle)
+    return existingHandle;
+  try {
+    rmSync(readyFile, { force: true });
+  } catch {}
+  const token = randomBytes(32).toString("hex");
+  const binPath = resolveRigPiSessionDaemonBinPath(input.env);
+  const bunPath = input.env.RIG_BUN_PATH || process.execPath;
+  const proc = Bun.spawn([bunPath, binPath], {
+    cwd: rootDir,
+    env: {
+      ...input.env,
+      RIG_PI_SESSIOND_ROOT: rootDir,
+      RIG_PI_SESSIOND_TOKEN: token,
+      RIG_PI_SESSIOND_READY_FILE: readyFile,
+      RIG_PI_SESSIOND_HOST: "127.0.0.1",
+      RIG_PI_SESSIOND_PORT: "0",
+      ...input.version ? { RIG_VERSION: input.version } : {},
+      ...input.commit ? { RIG_GIT_COMMIT: input.commit } : {}
+    },
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "inherit"
+  });
+  proc.unref();
+  const deadline = Date.now() + (input.timeoutMs ?? 15000);
+  while (Date.now() < deadline) {
+    const ready = readDaemonReadyFile(readyFile);
+    const handle = ready ? await tryReady(ready) : null;
+    if (handle)
+      return handle;
+    await sleep(100);
+  }
+  throw new Error(`Rig Pi session daemon did not become ready at ${readyFile}`);
+}
+function privateMetadataForDaemon(input) {
+  return { public: input.publicMetadata, daemonConnection: input.connection };
+}
+async function tryReady(ready) {
+  const host = typeof ready.host === "string" ? ready.host : "127.0.0.1";
+  const port = typeof ready.port === "number" ? ready.port : Number(ready.port);
+  const token = typeof ready.token === "string" ? ready.token : "";
+  if (!Number.isFinite(port) || port <= 0 || !token)
+    return null;
+  const baseUrl = `http://${host}:${port}`;
+  const client = new RigPiSessionDaemonClient({ baseUrl, token });
+  try {
+    await client.request("GET", "/health");
+  } catch {
+    return null;
+  }
+  return {
+    client,
+    connection: { mode: "http", baseUrl, tokenRef: tokenRefFromReady(ready) },
+    token,
+    ready
+  };
+}
+function tokenRefFromReady(ready) {
+  const token = typeof ready.token === "string" ? ready.token : "";
+  return token ? `inline:${token}` : "missing";
+}
+function resolveRigPiSessionDaemonBinPath(env) {
+  const explicit = env.RIG_PI_SESSIOND_BIN?.trim();
+  if (explicit)
+    return explicit;
+  const roots = [
+    env.RIG_CONTROL_PLANE_SOURCE_ROOT?.trim(),
+    BAKED_RIG_SOURCE_ROOT.trim(),
+    process.env.RIG_CONTROL_PLANE_SOURCE_ROOT?.trim(),
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    process.env.PROJECT_RIG_ROOT?.trim()
+  ].filter((value) => Boolean(value));
+  for (const root of roots) {
+    const candidate = resolve(root, "packages/runtime/src/control-plane/pi-sessiond/bin.ts");
+    if (existsSync(candidate))
+      return candidate;
+  }
+  const moduleCandidate = fileURLToPath(new URL("./bin.ts", import.meta.url));
+  if (existsSync(moduleCandidate))
+    return moduleCandidate;
+  throw new Error("Unable to locate rig-pi-sessiond entrypoint. Set RIG_PI_SESSIOND_BIN or RIG_CONTROL_PLANE_SOURCE_ROOT to the Rig source checkout.");
+}
+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;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function resolveRigPiSessionDaemonRoot(stateDir) {
+  const root = resolve(stateDir, "pi-sessiond");
+  mkdirSync(dirname(root), { recursive: true });
+  if (!existsSync(root))
+    mkdirSync(root, { recursive: true });
+  return root;
+}
+export {
+  resolveRigPiSessionDaemonRoot,
+  readDaemonReadyFile,
+  privateMetadataForDaemon,
+  ensureRigPiSessionDaemon
+};