@sideboard-ai/core 0.1.261 → 0.1.263

package/dist/{abletime-OQ4PC52L.js → abletime-6AOJI2YZ.js}

@@ -17,11 +17,11 @@ import {
   toAbleTimeIssueInfo,
   updateAbleTimeTask,
   verifyAbleTimeConnection
-} from "./chunk-S7VDDJ34.js";
-import "./chunk-B6XFBNYM.js";
-import "./chunk-5OKJDCBK.js";
+} from "./chunk-CEOTK5GZ.js";
+import "./chunk-BOMSJUXW.js";
+import "./chunk-5PK53SAP.js";
 import "./chunk-VKQGAWHY.js";
-import "./chunk-VIC6TDYT.js";
+import "./chunk-36FOBJBF.js";
 import "./chunk-NSTQ6QKD.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";

package/dist/{abletime-CDGINDXG.js → abletime-U75ZGDIX.js}

@@ -15,16 +15,16 @@ import {
   toAbleTimeIssueInfo,
   updateAbleTimeTask,
   verifyAbleTimeConnection
-} from "./chunk-KVQX62XI.js";
-import "./chunk-D554YCHG.js";
-import "./chunk-J6ONZP74.js";
+} from "./chunk-K7B25HO4.js";
+import "./chunk-YKYEHDMX.js";
+import "./chunk-6YY7XPPL.js";
 import "./chunk-N7WZ6NIN.js";
-import "./chunk-6PFZ6XO7.js";
+import "./chunk-2QUQH2SZ.js";
+import "./chunk-77WWLBCI.js";
 import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
 import "./chunk-3HO2OY5T.js";
 import "./chunk-JT7R45JB.js";
-import "./chunk-77WWLBCI.js";
 import "./chunk-EHT2DRT4.js";
 export {
   ableTimeDependencyTarget,

package/dist/{abletime-oauth-KX2TDFTE.js → abletime-oauth-LOAHGG4X.js}

@@ -3,7 +3,7 @@
 import {
   DEFAULT_ABLETIME_HOST,
   normalizeAbleTimeHost
-} from "./chunk-5OKJDCBK.js";
+} from "./chunk-5PK53SAP.js";
 import {
   httpFetch
 } from "./chunk-VKQGAWHY.js";
@@ -12,7 +12,7 @@ import {
   getAbleTimeHost,
   loadAppSettings,
   saveAbleTimeConnection
-} from "./chunk-VIC6TDYT.js";
+} from "./chunk-36FOBJBF.js";
 import "./chunk-NSTQ6QKD.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";
@@ -288,7 +288,7 @@ async function startAbleTimeOAuth(opts) {
   persistAbleTimeTokens(data, { host });
   const token = data.access_token.trim();
   try {
-    const { getAbleTimeOrientation } = await import("./abletime-OQ4PC52L.js");
+    const { getAbleTimeOrientation } = await import("./abletime-6AOJI2YZ.js");
     const orientation = await getAbleTimeOrientation({ token, host });
     return saveAbleTimeConnection({
       accessToken: token,

package/dist/{abletime-oauth-5A5EOH2A.js → abletime-oauth-TA2YDCYX.js}

@@ -20,15 +20,15 @@ import {
   parseAbleTimeOAuthCallbackUrl,
   resolveAbleTimeOAuthHost,
   startAbleTimeOAuth
-} from "./chunk-YFTO7U2A.js";
-import "./chunk-J6ONZP74.js";
+} from "./chunk-6YOXQVJ7.js";
+import "./chunk-6YY7XPPL.js";
 import "./chunk-N7WZ6NIN.js";
-import "./chunk-6PFZ6XO7.js";
+import "./chunk-2QUQH2SZ.js";
+import "./chunk-77WWLBCI.js";
 import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
 import "./chunk-3HO2OY5T.js";
 import "./chunk-JT7R45JB.js";
-import "./chunk-77WWLBCI.js";
 import "./chunk-EHT2DRT4.js";
 export {
   ABLETIME_OAUTH_CALLBACK_PATH,

package/dist/{abletime-rest-UEHOBLXD.js → abletime-rest-CTA5WV26.js}

@@ -5,15 +5,15 @@ import {
   callAbleTimeRestTool,
   looksLikeAbleTimeUlid,
   textFromAbleTimeDoc
-} from "./chunk-D554YCHG.js";
-import "./chunk-J6ONZP74.js";
+} from "./chunk-YKYEHDMX.js";
+import "./chunk-6YY7XPPL.js";
 import "./chunk-N7WZ6NIN.js";
-import "./chunk-6PFZ6XO7.js";
+import "./chunk-2QUQH2SZ.js";
+import "./chunk-77WWLBCI.js";
 import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
 import "./chunk-3HO2OY5T.js";
 import "./chunk-JT7R45JB.js";
-import "./chunk-77WWLBCI.js";
 import "./chunk-EHT2DRT4.js";
 export {
   ABLETIME_REST_PREFIX,

package/dist/{abletime-rest-PUGKYTRR.js → abletime-rest-YZPFM6IY.js}

@@ -7,10 +7,10 @@ import {
   callAbleTimeRestTool,
   looksLikeAbleTimeUlid,
   textFromAbleTimeDoc
-} from "./chunk-B6XFBNYM.js";
-import "./chunk-5OKJDCBK.js";
+} from "./chunk-BOMSJUXW.js";
+import "./chunk-5PK53SAP.js";
 import "./chunk-VKQGAWHY.js";
-import "./chunk-VIC6TDYT.js";
+import "./chunk-36FOBJBF.js";
 import "./chunk-NSTQ6QKD.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";

package/dist/agents/claude-runner.cjs

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/agents/claude-runner.ts
+var import_node_readline2 = require("readline");
+
+// src/agent-rpc/protocol.ts
+var AGENT_RPC_PROTOCOL_VERSION = 1;
+var AGENT_RPC_TOKEN_QUERY = "authToken";
+var AGENT_RPC_CLAUDE_SDK_SERVER = "sideboard_rpc";
+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 parseRpcFrame(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/hook/nested-electron-env.ts
+var NESTED_ELECTRON_ENV_PREFIXES = ["ELECTRON_", "CHROME_"];
+function isNestedElectronEnvKey(key) {
+  return NESTED_ELECTRON_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+function dropNestedElectronEnvFromProcess(env = process.env) {
+  for (const key of Object.keys(env)) {
+    if (isNestedElectronEnvKey(key)) delete env[key];
+  }
+}
+var STRIP_NESTED_ELECTRON_THEN_EXEC = [
+  "vars=`printenv | awk -F= '/^(ELECTRON_|CHROME_)/{print $1}'`",
+  '[ -n "$vars" ] && unset $vars',
+  "export ELECTRON_RUN_AS_NODE=1",
+  'exec "$@"'
+].join("; ");
+
+// src/agents/claude-sdk-tools.ts
+var import_zod = require("zod");
+
+// src/agent-rpc/client.ts
+var import_ws = require("ws");
+
+// src/agent-rpc/metadata.ts
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
+
+// src/store/paths.ts
+var import_node_path5 = require("path");
+var import_node_os2 = require("os");
+var import_node_path6 = require("path");
+var import_node_fs5 = require("fs");
+
+// src/hook/settings.ts
+var import_node_fs4 = require("fs");
+var import_node_os = require("os");
+var import_node_path4 = require("path");
+var import_smol_toml = require("smol-toml");
+
+// src/hook/convention-setup.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/hook/cursor-worktrees.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_execa = require("execa");
+var import_node_readline = require("readline");
+
+// src/hook/dev-preview.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+
+// src/store/paths.ts
+function appDataDir() {
+  const override = process.env.SIDEBOARD_APP_DATA?.trim();
+  const base = override ? override : process.platform === "darwin" ? (0, import_node_path6.join)((0, import_node_os2.homedir)(), "Library", "Application Support", "sideboard") : process.platform === "win32" ? (0, import_node_path6.join)(process.env.APPDATA ?? (0, import_node_path6.join)((0, import_node_os2.homedir)(), "AppData", "Roaming"), "sideboard") : (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".local", "share", "sideboard");
+  (0, import_node_fs5.mkdirSync)(base, { recursive: true });
+  return base;
+}
+
+// src/agent-rpc/metadata.ts
+function agentRuntimeMetadataPath() {
+  return (0, import_node_path7.join)(appDataDir(), "agent-runtime.json");
+}
+function readAgentRuntimeMetadata() {
+  try {
+    const raw = JSON.parse((0, import_node_fs6.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 agentRuntimeLooksLive(meta = readAgentRuntimeMetadata()) {
+  if (!meta) return false;
+  return pidAlive(meta.pid);
+}
+
+// src/agent-rpc/client.ts
+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 === import_ws.WebSocket.OPEN) return this.ws;
+    const ws = new import_ws.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_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."
+};
+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()
+  };
+}
+
+// src/agents/claude-sdk-tools.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function createClaudePilotSdkServer(createSdkMcpServer, tool, opts) {
+  const exec = createPilotRpcExecutors(opts);
+  const server = createSdkMcpServer({
+    name: AGENT_RPC_CLAUDE_SDK_SERVER,
+    version: "1.0.0",
+    timeout: 18e4,
+    tools: [
+      tool(
+        "present_artifact",
+        PILOT_TOOL_DESCRIPTIONS.present_artifact,
+        {
+          title: import_zod.z.string(),
+          type: import_zod.z.enum(["html", "svg", "markdown", "react", "log"]),
+          content: import_zod.z.string(),
+          artifact_id: import_zod.z.string().optional(),
+          status: import_zod.z.enum(["running", "ok", "failed", "idle"]).optional(),
+          phase: import_zod.z.string().optional(),
+          mode: import_zod.z.enum(["append", "replace"]).optional()
+        },
+        async (args) => textResult(await exec.present_artifact(args))
+      ),
+      tool(
+        "wait_for_job",
+        PILOT_TOOL_DESCRIPTIONS.wait_for_job,
+        { id: import_zod.z.string() },
+        async (args) => textResult(await exec.wait_for_job(args))
+      ),
+      tool(
+        "stop_job",
+        PILOT_TOOL_DESCRIPTIONS.stop_job,
+        { id: import_zod.z.string(), reason: import_zod.z.string().optional() },
+        async (args) => textResult(await exec.stop_job(args))
+      )
+    ]
+  });
+  return { server, exec };
+}
+
+// src/agents/claude-runner.ts
+dropNestedElectronEnvFromProcess();
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+async function readStdin() {
+  const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, crlfDelay: Infinity });
+  const chunks = [];
+  for await (const line of rl) chunks.push(line);
+  return chunks.join("\n").trim();
+}
+async function main() {
+  const raw = await readStdin();
+  if (!raw) {
+    emit({ type: "stderr", data: "claude-runner: empty stdin" });
+    process.exitCode = 1;
+    return;
+  }
+  const req = JSON.parse(raw);
+  if (!req.prompt || !req.cwd || !req.agentRpc || !req.claudePath) {
+    emit({ type: "stderr", data: "claude-runner: prompt, cwd, claudePath, and agentRpc are required" });
+    process.exitCode = 1;
+    return;
+  }
+  let sdk;
+  try {
+    sdk = await import("@anthropic-ai/claude-agent-sdk");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    emit({
+      type: "stderr",
+      data: `claude-runner: @anthropic-ai/claude-agent-sdk is required (${message})`
+    });
+    process.exitCode = 1;
+    return;
+  }
+  const { server, exec } = createClaudePilotSdkServer(
+    sdk.createSdkMcpServer,
+    sdk.tool,
+    { cwd: req.cwd, rpc: req.agentRpc }
+  );
+  const mcpServers = {
+    [AGENT_RPC_CLAUDE_SDK_SERVER]: server
+  };
+  for (const [name, spec] of Object.entries(req.mcpServers ?? {})) {
+    mcpServers[name] = spec;
+  }
+  try {
+    const options = {
+      cwd: req.cwd,
+      pathToClaudeCodeExecutable: req.claudePath,
+      permissionMode: req.permissionMode,
+      allowedTools: req.allowedTools,
+      mcpServers,
+      includePartialMessages: true
+    };
+    if (req.sessionId) options.resume = req.sessionId;
+    if (req.model) options.model = req.model;
+    if (req.systemPrompt) options.appendSystemPrompt = req.systemPrompt;
+    if (req.effort) options.effort = req.effort;
+    if (req.chrome) options.chrome = true;
+    options.settingSources = [];
+    for await (const message of sdk.query({ prompt: req.prompt, options })) {
+      emit(message);
+    }
+  } finally {
+    exec.close();
+  }
+}
+main().catch((err) => {
+  emit({
+    type: "stderr",
+    data: err instanceof Error ? err.message : String(err)
+  });
+  process.exitCode = 1;
+});

package/dist/agents/claude-runner.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/agents/claude-runner.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node