@sideboard-ai/core 0.1.262 → 0.1.263

package/dist/chunk-NYBFYFK7.js

@@ -0,0 +1,415 @@
+import {
+  appDataDir
+} from "./chunk-EHT2DRT4.js";
+
+// src/agent-rpc/protocol.ts
+var AGENT_RPC_PROTOCOL_VERSION = 1;
+var AGENT_RPC_PATH = "/agent-rpc";
+var AGENT_RPC_JOB_HOLD_MAX_MS = 12e4;
+var AGENT_RPC_JOB_SLICE_MS = 1e4;
+var AGENT_RPC_TOKEN_QUERY = "authToken";
+var AGENT_RPC_NATIVE_ENV = "SIDEBOARD_AGENT_RPC_NATIVE";
+var AGENT_RPC_URL_ENV = "SIDEBOARD_AGENT_RPC_URL";
+var AGENT_RPC_TOKEN_ENV = "SIDEBOARD_AGENT_RPC_TOKEN";
+var AGENT_RPC_CWD_ENV = "SIDEBOARD_AGENT_RPC_CWD";
+var AGENT_RPC_CLAUDE_SDK_SERVER = "sideboard_rpc";
+var RPC_PARSE_ERROR = -32700;
+var RPC_INVALID_REQUEST = -32600;
+var RPC_METHOD_NOT_FOUND = -32601;
+var RPC_UNAUTHORIZED = -32001;
+var RPC_INTERNAL_ERROR = -32603;
+function isJsonRpcRequest(value) {
+  if (!value || typeof value !== "object") return false;
+  const rec = value;
+  if (rec.jsonrpc !== "2.0") return false;
+  if (typeof rec.method !== "string" || !rec.method.trim()) return false;
+  if (rec.id === void 0 || rec.id === null) return false;
+  if (typeof rec.id !== "string" && typeof rec.id !== "number") return false;
+  return true;
+}
+function isJsonRpcNotification(value) {
+  if (!value || typeof value !== "object") return false;
+  const rec = value;
+  if (rec.jsonrpc !== "2.0") return false;
+  if (typeof rec.method !== "string" || !rec.method.trim()) return false;
+  if ("id" in rec && rec.id !== void 0) return false;
+  if ("error" in rec || "result" in rec) return false;
+  return true;
+}
+function rpcError(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: data === void 0 ? { code, message } : { code, message, data }
+  };
+}
+function rpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function rpcNotify(method, params) {
+  return params === void 0 ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params };
+}
+function parseRpcFrame(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/agent-rpc/metadata.ts
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+function agentRuntimeMetadataPath() {
+  return join(appDataDir(), "agent-runtime.json");
+}
+function writeAgentRuntimeMetadata(meta) {
+  writeFileSync(agentRuntimeMetadataPath(), `${JSON.stringify(meta)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function readAgentRuntimeMetadata() {
+  try {
+    const raw = JSON.parse(readFileSync(agentRuntimeMetadataPath(), "utf8"));
+    if (!raw || typeof raw !== "object") return null;
+    const rec = raw;
+    if (typeof rec.runtimeId !== "string" || !rec.runtimeId.trim()) return null;
+    if (typeof rec.authToken !== "string" || !rec.authToken.trim()) return null;
+    const pid = Number(rec.pid);
+    if (!Number.isInteger(pid) || pid <= 0) return null;
+    const transports = Array.isArray(rec.transports) ? rec.transports : [];
+    const ws = transports.filter((t) => {
+      if (!t || typeof t !== "object") return false;
+      const row = t;
+      return row.kind === "websocket" && typeof row.url === "string" && Boolean(row.url.trim());
+    });
+    return {
+      runtimeId: rec.runtimeId.trim(),
+      pid,
+      protocolVersion: Number(rec.protocolVersion) || AGENT_RPC_PROTOCOL_VERSION,
+      authToken: rec.authToken,
+      startedAt: Number(rec.startedAt) || 0,
+      transports: ws
+    };
+  } catch {
+    return null;
+  }
+}
+function websocketUrlFromMetadata(meta) {
+  const url = meta?.transports.find((t) => t.kind === "websocket")?.url?.trim();
+  return url || null;
+}
+function agentRpcConnectFromMetadata(meta = readAgentRuntimeMetadata()) {
+  if (!agentRuntimeLooksLive(meta)) return null;
+  const url = websocketUrlFromMetadata(meta);
+  const authToken = meta?.authToken;
+  if (!url || !authToken) return null;
+  return { url, authToken };
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearAgentRuntimeMetadataIfOwned(pid = process.pid) {
+  const current = readAgentRuntimeMetadata();
+  if (!current || current.pid !== pid) return;
+  try {
+    unlinkSync(agentRuntimeMetadataPath());
+  } catch {
+  }
+}
+function agentRuntimeLooksLive(meta = readAgentRuntimeMetadata()) {
+  if (!meta) return false;
+  return pidAlive(meta.pid);
+}
+
+// src/agent-rpc/client.ts
+import { WebSocket } from "ws";
+var AgentRpcClient = class {
+  ws = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  url;
+  authToken;
+  notifyListeners = /* @__PURE__ */ new Set();
+  constructor(opts = {}) {
+    const connect = opts.url && opts.authToken ? { url: opts.url, authToken: opts.authToken } : agentRpcConnectFromMetadata();
+    if (!connect) throw new Error("Agent RPC runtime is not running (no live agent-runtime.json)");
+    this.url = connect.url;
+    this.authToken = connect.authToken;
+  }
+  onNotify(fn) {
+    this.notifyListeners.add(fn);
+    return () => this.notifyListeners.delete(fn);
+  }
+  async call(method, params) {
+    const ws = await this.ensureSocket();
+    const id = this.nextId;
+    this.nextId += 1;
+    const key = String(id);
+    const payload = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+      authToken: this.authToken
+    };
+    return new Promise((resolve, reject) => {
+      this.pending.set(key, { resolve, reject });
+      try {
+        ws.send(JSON.stringify(payload));
+      } catch (err) {
+        this.pending.delete(key);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  socketUrl() {
+    const url = new URL(this.url);
+    url.searchParams.set(AGENT_RPC_TOKEN_QUERY, this.authToken);
+    return url.toString();
+  }
+  async ensureSocket() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) return this.ws;
+    const ws = new WebSocket(this.socketUrl());
+    this.ws = ws;
+    ws.on("message", (data) => this.onFrame(data.toString()));
+    ws.on("error", (err) => this.drop(ws, err));
+    ws.on("close", () => this.drop(ws, new Error("Agent RPC socket closed")));
+    ws.on("unexpected-response", (_req, res) => {
+      res.resume();
+      this.drop(
+        ws,
+        new Error(
+          res.statusCode === 401 ? "Unauthorized" : `Unexpected server response: ${res.statusCode}`
+        )
+      );
+    });
+    await new Promise((resolve, reject) => {
+      const fail = (err) => {
+        const message = err.message.includes("401") ? "Unauthorized" : err.message;
+        reject(message === err.message ? err : new Error(message));
+      };
+      ws.once("unexpected-response", (_req, res) => {
+        fail(
+          new Error(
+            res.statusCode === 401 ? "Unauthorized" : `Unexpected server response: ${res.statusCode}`
+          )
+        );
+      });
+      ws.once("error", fail);
+      ws.once("open", () => {
+        ws.off("error", fail);
+        resolve();
+      });
+    });
+    return ws;
+  }
+  drop(ws, err) {
+    if (this.ws === ws) this.ws = null;
+    if (this.pending.size === 0) return;
+    this.failAll(err);
+  }
+  onFrame(raw) {
+    const parsed = parseRpcFrame(raw);
+    if (parsed === void 0) return;
+    if (isJsonRpcNotification(parsed)) {
+      for (const fn of this.notifyListeners) fn(parsed);
+      return;
+    }
+    if (!parsed || typeof parsed !== "object") return;
+    const rec = parsed;
+    if (rec.id === void 0 || rec.id === null) return;
+    const key = String(rec.id);
+    const waiter = this.pending.get(key);
+    if (!waiter) return;
+    this.pending.delete(key);
+    if (rec.error && typeof rec.error === "object") {
+      const err = rec.error;
+      waiter.reject(new Error(err.message || "Agent RPC error"));
+      return;
+    }
+    waiter.resolve(rec.result);
+  }
+  failAll(err) {
+    for (const waiter of this.pending.values()) waiter.reject(err);
+    this.pending.clear();
+  }
+  close() {
+    const ws = this.ws;
+    this.ws = null;
+    this.failAll(new Error("Agent RPC client closed"));
+    if (ws) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/agent-rpc/pilot-tools.ts
+var PILOT_TOOL_NAMES = [
+  "present_artifact",
+  "wait_for_job",
+  "stop_job"
+];
+var PILOT_TOOL_DESCRIPTIONS = {
+  present_artifact: "Show a document or live log in Sideboard\u2019s side column. For html/svg/markdown/react, pass the FULL document and do not also fence that same body in chat. For type=log, pass only NEW lines (same artifact_id appends). Prefer type=log for long-running job output \u2014 do not resend HTML. type=react is a single default-export component (JSX/TSX); only react/react-dom imports.",
+  wait_for_job: "Wait until a detached long job (tests, pack, deploy, connector CLI) finishes. This call stays open for up to ~2 minutes. stillRunning true means the runtime hit the max hold; call wait_for_job again immediately. If the job is hanging, producing no useful output, or doing the wrong thing, call stop_job instead. Do not end the turn or tell the user you will let them know later.",
+  stop_job: "Stop a detached job you started with detached-job.cjs when it is hanging, producing no useful output, buffering forever, or doing the wrong thing (wrong project, infinite watch, huge dump). Do not stop a pack/test/deploy that is clearly making progress."
+};
+var WAIT_FOR_TURN_DESCRIPTION = "Wait until the chat finishes its current/queued turn, or return early with a live progress snapshot. This call stays open for up to ~2 minutes. taskState is the A2A-style lifecycle: submitted (queued, not started), working, input-required (ask_user), completed, failed, canceled. stillRunning is true only for submitted/working. If stillRunning, text and usage are empty (they would be the previous turn) \u2014 read progress and call wait_for_turn again. Do not send_to_chat a check-in (that steers / interrupts). On failed, lastError/text is the failure. On canceled, the child did not finish \u2014 resume with send_to_chat or tell the user. On input-required, wait for the user in that chat. When finished, text is this turn\u2019s assistant reply and usage is that turn\u2019s tokens + costUsd (this turn, not the Claude session total; sessionCostUsd is the provider session total when present). lastActivityAt is the latest transcript/live stamp \u2014 present after the turn completes, not only while it is running.";
+var WAIT_FOR_TURN_SCHEMA = {
+  type: "object",
+  properties: {
+    ref: {
+      type: "string",
+      description: "Worktree thread id or ref to wait on (not the orchestrator)"
+    },
+    timeoutMs: {
+      type: "number",
+      description: "Optional cap for this hold (ms). Ignored above the runtime max (~2 minutes)."
+    }
+  },
+  required: ["ref"]
+};
+var PILOT_TOOL_SCHEMAS = {
+  present_artifact: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Short title shown in the artifact pane header"
+      },
+      type: {
+        type: "string",
+        enum: ["html", "svg", "markdown", "react", "log"],
+        description: "html/svg/markdown/react replace the pane. log appends content to the same artifact_id (new lines only)."
+      },
+      content: {
+        type: "string",
+        description: "html/svg/markdown/react: full document. log: only the new lines since the last call (empty is ok for a status-only update)."
+      },
+      artifact_id: {
+        type: "string",
+        description: "Stable id. Required for type=log so later calls append to the same pane."
+      },
+      status: {
+        type: "string",
+        enum: ["running", "ok", "failed", "idle"]
+      },
+      phase: { type: "string" },
+      mode: { type: "string", enum: ["append", "replace"] }
+    },
+    required: ["title", "type", "content"]
+  },
+  wait_for_job: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "Detached job id (same kebab-case id passed to detached-job.cjs start)"
+      }
+    },
+    required: ["id"]
+  },
+  stop_job: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "Detached job id (same kebab-case id passed to detached-job.cjs start)"
+      },
+      reason: { type: "string" }
+    },
+    required: ["id"]
+  }
+};
+function jsonToolResult(value) {
+  return JSON.stringify(value);
+}
+function jsonToolError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return jsonToolResult({ ok: false, error: message });
+}
+function createPilotRpcExecutors(opts) {
+  const client = new AgentRpcClient(opts.rpc);
+  let waitToolCallId;
+  if (opts.onProgress) {
+    const onProgress = opts.onProgress;
+    client.onNotify((msg) => {
+      if (msg.method === "runtime.progress") onProgress(msg.params, waitToolCallId);
+    });
+  }
+  const call = async (method, args) => {
+    try {
+      return jsonToolResult(await client.call(method, args));
+    } catch (err) {
+      return jsonToolError(err);
+    }
+  };
+  const callJob = (method, args) => call(method, { ...args, cwd: opts.cwd });
+  return {
+    present_artifact: (args) => call("ui.presentArtifact", args),
+    wait_for_job: async (args, context) => {
+      const prev = waitToolCallId;
+      waitToolCallId = typeof context?.toolCallId === "string" ? context.toolCallId : void 0;
+      try {
+        return await callJob("job.wait", args);
+      } finally {
+        waitToolCallId = prev;
+      }
+    },
+    stop_job: (args) => callJob("job.stop", args),
+    wait_for_turn: async (args, context) => {
+      const prev = waitToolCallId;
+      waitToolCallId = typeof context?.toolCallId === "string" ? context.toolCallId : void 0;
+      try {
+        return await call("turn.wait", args);
+      } finally {
+        waitToolCallId = prev;
+      }
+    },
+    close: () => client.close()
+  };
+}
+
+export {
+  AGENT_RPC_PROTOCOL_VERSION,
+  AGENT_RPC_PATH,
+  AGENT_RPC_JOB_HOLD_MAX_MS,
+  AGENT_RPC_JOB_SLICE_MS,
+  AGENT_RPC_TOKEN_QUERY,
+  AGENT_RPC_NATIVE_ENV,
+  AGENT_RPC_URL_ENV,
+  AGENT_RPC_TOKEN_ENV,
+  AGENT_RPC_CWD_ENV,
+  AGENT_RPC_CLAUDE_SDK_SERVER,
+  RPC_PARSE_ERROR,
+  RPC_INVALID_REQUEST,
+  RPC_METHOD_NOT_FOUND,
+  RPC_UNAUTHORIZED,
+  RPC_INTERNAL_ERROR,
+  isJsonRpcRequest,
+  rpcError,
+  rpcResult,
+  rpcNotify,
+  parseRpcFrame,
+  writeAgentRuntimeMetadata,
+  readAgentRuntimeMetadata,
+  agentRpcConnectFromMetadata,
+  clearAgentRuntimeMetadataIfOwned,
+  PILOT_TOOL_NAMES,
+  PILOT_TOOL_DESCRIPTIONS,
+  WAIT_FOR_TURN_DESCRIPTION,
+  WAIT_FOR_TURN_SCHEMA,
+  PILOT_TOOL_SCHEMAS,
+  createPilotRpcExecutors
+};