@sideboard-ai/core 0.1.9

package/dist/chunk-WMCPLDW3.js

@@ -0,0 +1,1413 @@
+import {
+  applyConnectedTeamToCli,
+  brightsyMcpServerName,
+  ensureCliTeamTracked,
+  ensureConnectedBrightsyTeamTokens,
+  loadBrightsyConfig
+} from "./chunk-ILQK4P5R.js";
+import {
+  parseCursorRunnerLine
+} from "./chunk-3DKGI32Q.js";
+import {
+  claudeChromeEnabled,
+  loadAppSettings,
+  resolveClaudeExecutable
+} from "./chunk-3WF3X46L.js";
+import {
+  run
+} from "./chunk-AJ6ROGD7.js";
+
+// src/agents/brightsy-targets.ts
+function encodeBrightsyTarget(type, id, accountId) {
+  if (accountId) return `team:${accountId}:${type}:${id}`;
+  return `${type}:${id}`;
+}
+function decodeBrightsyTarget(model) {
+  const raw = model?.trim();
+  if (!raw || raw === "default" || raw === "agent:default") {
+    return { type: "agent", id: "default" };
+  }
+  const teamMatch = raw.match(/^team:([^:]+):(agent|model):(.+)$/);
+  if (teamMatch) {
+    return {
+      type: teamMatch[2],
+      id: teamMatch[3] || "default",
+      accountId: teamMatch[1]
+    };
+  }
+  if (raw.startsWith("agent:")) {
+    return { type: "agent", id: raw.slice("agent:".length) || "default" };
+  }
+  if (raw.startsWith("model:")) {
+    return { type: "model", id: raw.slice("model:".length) };
+  }
+  if (/^[0-9a-f]{8}-[0-9a-f-]{27,}$/i.test(raw) || raw === "default") {
+    return { type: "agent", id: raw };
+  }
+  return { type: "model", id: raw };
+}
+
+// src/agents/turn-input.ts
+function normalizeTurnInput(input) {
+  if (typeof input === "string") return { prompt: input };
+  return { prompt: input.prompt, cachedPrefix: input.cachedPrefix?.trim() || void 0 };
+}
+function flattenTurnInput(input) {
+  const { cachedPrefix, prompt } = normalizeTurnInput(input);
+  if (!cachedPrefix) return prompt;
+  return `${cachedPrefix}
+
+---
+
+Current request:
+${prompt}`;
+}
+function buildCachedUserContent(input) {
+  return [{ type: "text", text: flattenTurnInput(input) }];
+}
+function buildClaudeStreamJsonUserMessage(input) {
+  return `${JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: buildCachedUserContent(input)
+    }
+  })}
+`;
+}
+function walkCacheControls(blocks, saw5m) {
+  if (!blocks?.length) return { saw5m, invalid: null };
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const ttl = block.cache_control?.ttl ?? (block.cache_control ? "5m" : null);
+    if (ttl === "5m") saw5m = true;
+    if (ttl === "1h" && saw5m) return { saw5m, invalid: { index: i, ttl: "1h" } };
+    if (Array.isArray(block.content)) {
+      const nested = walkCacheControls(block.content, saw5m);
+      if (nested.invalid) return { saw5m: nested.saw5m, invalid: { index: i, ttl: "1h" } };
+      saw5m = nested.saw5m;
+    }
+  }
+  return { saw5m, invalid: null };
+}
+function findInvalidCacheControlTtlOrder(blocks) {
+  return walkCacheControls(blocks, false).invalid;
+}
+function countCacheControlBlocks(blocks) {
+  if (!blocks?.length) return 0;
+  let count = 0;
+  for (const block of blocks) {
+    if (block.cache_control) count++;
+    if (Array.isArray(block.content)) {
+      count += countCacheControlBlocks(block.content);
+    }
+  }
+  return count;
+}
+var MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS = 4;
+
+// src/agents/brightsy.ts
+function usageFromBrightsy(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.prompt_tokens ?? 0);
+  const outputTokens = Number(usage.completion_tokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  const cached = Number(usage.prompt_tokens_details?.cached_tokens ?? 0);
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: cached || void 0
+  };
+}
+function parseBrightsyCliLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (obj.type === "text" && typeof obj.text === "string") {
+      return { type: "stdout", data: obj.text };
+    }
+    if (obj.type === "thinking" && typeof obj.text === "string") {
+      return { type: "thinking", data: obj.text };
+    }
+    if (obj.type === "error") {
+      const msg = String(obj.error ?? trimmed);
+      return [
+        { type: "stderr", data: msg },
+        { type: "stdout", data: `Error: ${msg}` }
+      ];
+    }
+    if (obj.type === "usage") {
+      const usage = usageFromBrightsy(obj.usage);
+      return usage ? { type: "usage", data: usage } : null;
+    }
+    if (obj.type === "tool_use") {
+      const id = typeof obj.id === "string" && obj.id || `brightsy-tool-${Date.now()}`;
+      const name = typeof obj.name === "string" && obj.name || "brightsy_tool";
+      const input = obj.input && typeof obj.input === "object" && !Array.isArray(obj.input) ? obj.input : void 0;
+      return { type: "tool_use", id, name, input };
+    }
+    if (obj.type === "tool_result" || obj.type === "tool") {
+      const id = typeof obj.id === "string" && obj.id || typeof obj.tool_call_id === "string" && obj.tool_call_id || `brightsy-tool-${Date.now()}`;
+      const content = typeof obj.content === "string" ? obj.content : obj.content != null ? JSON.stringify(obj.content) : void 0;
+      return {
+        type: "tool_result",
+        id,
+        content,
+        isError: obj.isError === true
+      };
+    }
+    if (obj.type === "done") return null;
+    if (typeof obj.type === "string" && ["tool_use", "tool_result", "tool", "thinking", "usage", "error", "done", "text"].includes(
+      obj.type
+    )) {
+      return null;
+    }
+    return { type: "stdout", data: trimmed };
+  } catch {
+    if (trimmed.startsWith("{") && /"type"\s*:\s*"(tool_use|tool_result|tool|text|thinking|usage|done|error)"/.test(trimmed)) {
+      return null;
+    }
+    return { type: "stdout", data: line };
+  }
+}
+async function fetchTeamChatTargets(team) {
+  const endpoint = (team.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  let agents = [
+    {
+      type: "agent",
+      id: "default",
+      name: "Default Agent",
+      description: "Account default agent (tools + memory)",
+      accountId: team.id,
+      accountSlug: team.slug,
+      accountName: team.name
+    }
+  ];
+  let models = [];
+  try {
+    const res = await fetch(`${endpoint}/api/v1beta/${team.id}/agents`, {
+      headers: { Authorization: `Bearer ${team.access_token}` }
+    });
+    if (res.ok) {
+      const json = await res.json();
+      const listed = (json.data || []).filter(
+        (a) => Boolean(a?.id && a?.name)
+      ).filter((a) => a.id !== "default").map((a) => ({
+        type: "agent",
+        id: a.id,
+        name: a.name,
+        description: a.description,
+        accountId: team.id,
+        accountSlug: team.slug,
+        accountName: team.name
+      }));
+      agents = [...agents, ...listed];
+      if (Array.isArray(json.models)) {
+        models = json.models.filter(
+          (m) => Boolean(m?.id && m?.name)
+        ).slice(0, 12).map((m) => ({
+          type: "model",
+          id: m.id,
+          name: m.name,
+          description: m.description,
+          accountId: team.id,
+          accountSlug: team.slug,
+          accountName: team.name
+        }));
+      }
+    }
+  } catch {
+  }
+  return {
+    accountId: team.id,
+    accountSlug: team.slug,
+    accountName: team.name,
+    agents,
+    models
+  };
+}
+async function listBrightsyChatTargetsViaCli() {
+  const listed = await run("brightsy", ["chat", "--list-targets", "--json"], {
+    reject: false
+  });
+  if (listed.exitCode !== 0 || !listed.stdout.trim()) {
+    throw new Error(
+      listed.stderr.trim() || "Failed to list Brightsy chat targets \u2014 is `brightsy` installed and logged in?"
+    );
+  }
+  try {
+    const parsed = JSON.parse(listed.stdout);
+    let accountId = null;
+    let accountSlug = "team";
+    let accountName = "Brightsy";
+    try {
+      const cfg = loadBrightsyConfig();
+      accountId = cfg.account_id;
+      accountSlug = cfg.account_slug || accountSlug;
+      accountName = cfg.account_slug || accountName;
+    } catch {
+    }
+    const agents = (Array.isArray(parsed.agents) ? parsed.agents : []).map((a) => ({
+      ...a,
+      accountId: accountId ?? void 0,
+      accountSlug,
+      accountName
+    }));
+    const models = (Array.isArray(parsed.models) ? parsed.models : []).map((m) => ({
+      ...m,
+      accountId: accountId ?? void 0,
+      accountSlug,
+      accountName
+    }));
+    const teams = accountId ? [
+      {
+        accountId,
+        accountSlug,
+        accountName,
+        agents,
+        models
+      }
+    ] : [];
+    return { teams, agents, models, activeAccountId: accountId };
+  } catch {
+    throw new Error("Brightsy --list-targets returned invalid JSON");
+  }
+}
+async function listBrightsyChatTargets() {
+  ensureCliTeamTracked();
+  const teamsRaw = await ensureConnectedBrightsyTeamTokens();
+  if (teamsRaw.length === 0) {
+    return listBrightsyChatTargetsViaCli();
+  }
+  let activeAccountId = null;
+  try {
+    activeAccountId = loadBrightsyConfig().account_id;
+  } catch {
+    activeAccountId = teamsRaw[0]?.id ?? null;
+  }
+  const teams = await Promise.all(teamsRaw.map((t) => fetchTeamChatTargets(t)));
+  teams.sort((a, b) => {
+    if (a.accountId === activeAccountId) return -1;
+    if (b.accountId === activeAccountId) return 1;
+    return a.accountSlug.localeCompare(b.accountSlug);
+  });
+  const active = teams.find((t) => t.accountId === activeAccountId) ?? teams[0] ?? null;
+  return {
+    teams,
+    agents: active?.agents ?? [],
+    models: active?.models ?? [],
+    activeAccountId
+  };
+}
+async function syncCliForTarget(accountId) {
+  if (!accountId) return;
+  const teams = await ensureConnectedBrightsyTeamTokens();
+  const team = teams.find((t) => t.id === accountId);
+  if (!team) return;
+  try {
+    const cfg = loadBrightsyConfig();
+    if (cfg.account_id === team.id && cfg.access_token === team.access_token) {
+      return;
+    }
+  } catch {
+  }
+  applyConnectedTeamToCli(team);
+}
+var brightsyAdapter = {
+  kind: "brightsy",
+  async detect() {
+    const which = await run("which", ["brightsy"], { reject: false });
+    if (which.exitCode !== 0) {
+      return {
+        agent: "brightsy",
+        installed: false,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "brightsy CLI not found on PATH \u2014 npm i -g @brightsy/cli"
+      };
+    }
+    const who = await run("brightsy", ["whoami"], { reject: false });
+    const authenticated = who.exitCode === 0 && /logged in as/i.test(who.stdout);
+    return {
+      agent: "brightsy",
+      installed: true,
+      authenticated,
+      linearMcp: false,
+      warnings: [],
+      reason: authenticated ? void 0 : "not logged in \u2014 run `brightsy login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const target = decodeBrightsyTarget(thread.model);
+    await syncCliForTarget(target.accountId);
+    const mode = thread.planMode ? "plan" : target.type === "model" ? "ask" : "agent";
+    const args = [
+      "chat",
+      "--json",
+      "--mode",
+      mode,
+      target.type === "model" ? "--model" : "--agent",
+      target.id
+    ];
+    return {
+      file: "brightsy",
+      args,
+      cwd: thread.worktreePath,
+      // Piped stdin becomes the message body (avoids ARG_MAX for long seeds).
+      stdin: prompt
+    };
+  },
+  parseEvent(line) {
+    return parseBrightsyCliLine(line);
+  },
+  async resolveSessionId() {
+    return null;
+  },
+  async buildAttach(thread) {
+    const target = decodeBrightsyTarget(thread.model);
+    await syncCliForTarget(target.accountId);
+    const args = target.type === "model" ? ["chat", "--model", target.id] : ["chat", "--agent", target.id];
+    return { file: "brightsy", args, cwd: thread.worktreePath };
+  }
+};
+
+// src/agents/claude.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/agents/claude-mcp.ts
+function parseMcpList(text) {
+  const servers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (!line || /^Checking MCP/i.test(line)) continue;
+    const m = line.match(/^(.+?):\s+\S+/);
+    if (!m) continue;
+    const name = m[1].trim();
+    if (!name || seen.has(name)) continue;
+    const needsAuth = /Needs authentication/i.test(line);
+    const connected = !needsAuth && /Connected/i.test(line);
+    if (!needsAuth && !connected) continue;
+    seen.add(name);
+    servers.push({ name, connected, needsAuth });
+  }
+  return servers;
+}
+function sanitizeMcpServerName(name) {
+  return name.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+function mcpAllowTools(servers) {
+  const out = [];
+  for (const s of servers) {
+    if (!s.connected) continue;
+    const id = sanitizeMcpServerName(s.name);
+    if (!id) continue;
+    out.push(`mcp__${id}`);
+    out.push(`mcp__${id}__*`);
+  }
+  return out;
+}
+function mcpAuthWarnings(servers) {
+  const needing = servers.filter((s) => s.needsAuth).map((s) => s.name);
+  if (needing.length === 0) return [];
+  return [
+    `MCP needs login: ${needing.join(", ")}. Run: claude mcp login "<name>"`
+  ];
+}
+
+// src/agents/injected-mcp.ts
+import { existsSync, mkdtempSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var SIDEBOARD_MCP_ALLOWED_TOOLS = [
+  "mcp__sideboard",
+  "mcp__sideboard__*"
+];
+var BRIGHTSY_MCP_ALLOWED_TOOLS = [
+  "mcp__brightsy",
+  "mcp__brightsy__*"
+];
+var brightsyMcpCommandCache = null;
+async function resolveBrightsyMcpCommand() {
+  const now = Date.now();
+  if (brightsyMcpCommandCache && now - brightsyMcpCommandCache.at < 6e4 && brightsyMcpCommandCache.command) {
+    return brightsyMcpCommandCache.command;
+  }
+  const which = await run("which", ["brightsy-mcp"], { reject: false });
+  const command = which.exitCode === 0 && which.stdout.trim() ? "brightsy-mcp" : "npx";
+  brightsyMcpCommandCache = { at: now, command };
+  return command;
+}
+function isBrightsyConnected() {
+  try {
+    loadBrightsyConfig();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mcpLaunch(cmd, name, env) {
+  if (cmd === "brightsy-mcp") {
+    return { name, command: "brightsy-mcp", ...env ? { env } : {} };
+  }
+  return {
+    name,
+    command: "npx",
+    args: ["-y", "@brightsy/mcp-server"],
+    ...env ? { env } : {}
+  };
+}
+function teamEnv(team) {
+  const endpoint = (team.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  return {
+    BRIGHTSY_API_TOKEN: team.access_token,
+    BRIGHTSY_ACCOUNT_ID: team.id,
+    BRIGHTSY_API_URL: endpoint
+  };
+}
+function brightsyMcpAllowedTools(serverNames) {
+  const out = [];
+  for (const name of serverNames) {
+    out.push(`mcp__${name}`, `mcp__${name}__*`);
+  }
+  return out;
+}
+function corePackageDir() {
+  const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
+  if (cjsDir) return cjsDir;
+  try {
+    const url = import.meta.url;
+    if (typeof url === "string" && url.length > 0) {
+      return dirname(fileURLToPath(url));
+    }
+  } catch {
+  }
+  try {
+    const req = createRequire(join(process.cwd(), "package.json"));
+    return dirname(req.resolve("@sideboard-ai/core"));
+  } catch {
+    return process.cwd();
+  }
+}
+function findSideboardMcpJsEntry() {
+  const override = process.env.SIDEBOARD_MCP_ENTRY?.trim() || process.env.SIDEBOARD_CLI?.trim();
+  if (override && existsSync(override)) return override;
+  let dir = corePackageDir();
+  for (let i = 0; i < 10; i++) {
+    const candidates = [
+      join(dir, "mcp/run-stdio.js"),
+      join(dir, "mcp/run-stdio.cjs"),
+      join(dir, "dist/mcp/run-stdio.js"),
+      join(dir, "dist/mcp/run-stdio.cjs"),
+      join(dir, "packages/core/dist/mcp/run-stdio.js"),
+      join(dir, "packages/cli/dist/index.js"),
+      join(dir, "cli/dist/index.js")
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) return p;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function resolveSideboardMcpServer() {
+  const which = await run("which", ["sideboard"], { reject: false });
+  if (which.exitCode === 0 && which.stdout.trim()) {
+    return { name: "sideboard", command: which.stdout.trim(), args: ["mcp"] };
+  }
+  const entry = findSideboardMcpJsEntry();
+  if (entry) {
+    const isCli = /[/\\]cli[/\\]dist[/\\]index\.js$/.test(entry);
+    return {
+      name: "sideboard",
+      // Use `node` (not process.execPath) — under Electron execPath is Electron itself.
+      command: "node",
+      args: isCli ? [entry, "mcp"] : [entry]
+    };
+  }
+  return { name: "sideboard", command: "sideboard", args: ["mcp"] };
+}
+async function buildInjectedMcpServers(opts) {
+  const servers = [];
+  if (opts.includeSideboard) {
+    servers.push(await resolveSideboardMcpServer());
+  }
+  if (opts.includeBrightsy && isBrightsyConnected()) {
+    const cmd = await resolveBrightsyMcpCommand();
+    const teams = await ensureConnectedBrightsyTeamTokens();
+    if (teams.length > 0) {
+      const used = /* @__PURE__ */ new Set();
+      for (const team of teams) {
+        let name = brightsyMcpServerName(team.slug);
+        if (used.has(name)) name = `${name}_${team.id.slice(0, 8)}`;
+        used.add(name);
+        servers.push(mcpLaunch(cmd, name, teamEnv(team)));
+      }
+    } else {
+      servers.push(mcpLaunch(cmd, "brightsy"));
+    }
+  }
+  return servers;
+}
+function writeMcpServersConfig(servers) {
+  if (servers.length === 0) return null;
+  const mcpServers = {};
+  for (const s of servers) {
+    mcpServers[s.name] = {
+      command: s.command,
+      ...s.args ? { args: s.args } : {},
+      ...s.env ? { env: s.env } : {}
+    };
+  }
+  const dir = mkdtempSync(join(tmpdir(), "sideboard-mcp-"));
+  const cfgPath = join(dir, "mcp.json");
+  writeFileSync(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  return cfgPath;
+}
+async function writeInjectedMcpConfig(opts) {
+  return writeMcpServersConfig(await buildInjectedMcpServers(opts));
+}
+
+// src/agents/types.ts
+var PLAN_MODE_INSTRUCTION = "Plan mode is active and must remain active until the user turns Plan mode off in the UI (or explicitly asks you to implement). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any files. Do not exit plan mode on your own.";
+function permissionMode(thread) {
+  if (thread.planMode) {
+    return {
+      claude: "plan",
+      opencodePermission: JSON.stringify({
+        edit: "deny",
+        write: "deny",
+        bash: { "*": "deny" }
+      }),
+      codexSandbox: "read-only"
+    };
+  }
+  if (thread.autonomy === "full") {
+    return {
+      claude: "bypassPermissions",
+      opencodePermission: JSON.stringify({ "*": "allow" }),
+      codexSandbox: "workspace-write"
+    };
+  }
+  return {
+    claude: "acceptEdits",
+    opencodePermission: JSON.stringify({
+      edit: "allow",
+      bash: { "*": "allow", "rm -rf *": "deny" }
+    }),
+    codexSandbox: "workspace-write"
+  };
+}
+
+// src/agents/claude.ts
+var BASE_ALLOWED_TOOLS = ["Edit", "Write", "Bash", "Read", "Glob", "Grep"];
+var CLAUDE_PROMPT_ARG_MAX = 2e5;
+async function loadMcpServers() {
+  const claude = resolveClaudeExecutable();
+  const mcpText = await run(claude, ["mcp", "list"], { reject: false });
+  return parseMcpList(`${mcpText.stdout}
+${mcpText.stderr}`);
+}
+function usageFromClaude(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.input_tokens ?? 0);
+  const outputTokens = Number(usage.output_tokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usage.cache_read_input_tokens ? Number(usage.cache_read_input_tokens) : void 0,
+    cacheWriteTokens: usage.cache_creation_input_tokens ? Number(usage.cache_creation_input_tokens) : void 0
+  };
+}
+function eventsFromContentBlocks(blocks) {
+  if (!blocks?.length) return [];
+  const out = [];
+  for (const block of blocks) {
+    if (!block?.type) continue;
+    if (block.type === "text" && block.text) {
+      out.push({ type: "stdout", data: block.text });
+      continue;
+    }
+    if ((block.type === "thinking" || block.type === "redacted_thinking") && block.thinking) {
+      out.push({ type: "thinking", data: block.thinking });
+      continue;
+    }
+    if (block.type === "tool_use" && block.id && block.name) {
+      out.push({
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.input
+      });
+      continue;
+    }
+    if (block.type === "tool_result" && block.tool_use_id) {
+      const content = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map(
+        (c) => typeof c === "string" ? c : c && typeof c === "object" && "text" in c ? String(c.text ?? "") : ""
+      ).join("") : block.content != null ? JSON.stringify(block.content) : void 0;
+      out.push({
+        type: "tool_result",
+        id: block.tool_use_id,
+        content,
+        isError: Boolean(block.is_error)
+      });
+    }
+  }
+  return out;
+}
+var claudeAdapter = {
+  kind: "claude",
+  async detect() {
+    const claude = resolveClaudeExecutable();
+    if (claude !== "claude") {
+      if (!existsSync2(claude)) {
+        return {
+          agent: "claude",
+          installed: false,
+          authenticated: false,
+          linearMcp: false,
+          warnings: [],
+          reason: `Claude Code executable not found: ${claude}`
+        };
+      }
+    } else {
+      const which = await run("which", ["claude"], { reject: false });
+      if (which.exitCode !== 0) {
+        return {
+          agent: "claude",
+          installed: false,
+          authenticated: false,
+          linearMcp: false,
+          warnings: [],
+          reason: "claude CLI not found on PATH"
+        };
+      }
+    }
+    const auth = await run(claude, ["auth", "status"], { reject: false });
+    const authenticated = auth.exitCode === 0;
+    const servers = await loadMcpServers();
+    const linearMcp = servers.some(
+      (s) => s.connected && /linear/i.test(s.name)
+    );
+    return {
+      agent: "claude",
+      installed: true,
+      authenticated,
+      linearMcp,
+      warnings: mcpAuthWarnings(servers),
+      reason: authenticated ? void 0 : "claude auth status failed \u2014 run `claude auth login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const claude = resolveClaudeExecutable();
+    const turn = normalizeTurnInput(input);
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const effective = sessionId ? { prompt: turn.prompt } : turn;
+    const promptText = flattenTurnInput(effective);
+    const useStdin = promptText.length > CLAUDE_PROMPT_ARG_MAX;
+    if (process.env.SIDEBOARD_DEBUG_CLAUDE_TURN === "1") {
+      console.error(
+        `[sideboard/claude] promptChars=${promptText.length} resumed=${Boolean(sessionId)} stdin=${useStdin}`
+      );
+    }
+    const mode = permissionMode(thread);
+    const { isOrchestratorThread } = await import("./global-workspace-R44HGBU6.js");
+    const isOrchestrator = isOrchestratorThread(thread);
+    const injectedServers = await buildInjectedMcpServers({
+      includeSideboard: isOrchestrator,
+      includeBrightsy: isBrightsyConnected()
+    });
+    const injectedBrightsyNames = injectedServers.filter((s) => s.name === "brightsy" || s.name.startsWith("brightsy_")).map((s) => s.name);
+    let allowedTools;
+    if (isOrchestrator) {
+      allowedTools = [
+        ...BASE_ALLOWED_TOOLS,
+        ...SIDEBOARD_MCP_ALLOWED_TOOLS,
+        ...brightsyMcpAllowedTools(injectedBrightsyNames)
+      ];
+    } else {
+      const servers = await loadMcpServers();
+      allowedTools = [
+        ...BASE_ALLOWED_TOOLS,
+        ...mcpAllowTools(servers),
+        ...brightsyMcpAllowedTools(injectedBrightsyNames)
+      ];
+    }
+    const args = [
+      "-p",
+      ...useStdin ? [] : [promptText],
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--permission-mode",
+      mode.claude
+    ];
+    const mcpConfigPath = writeMcpServersConfig(injectedServers);
+    if (mcpConfigPath) {
+      args.push("--mcp-config", mcpConfigPath);
+    }
+    if (claudeChromeEnabled()) {
+      args.push("--chrome");
+    }
+    if (useStdin) {
+      args.push("--input-format", "text");
+    }
+    for (const tool of allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+    if (thread.model) {
+      args.push("--model", thread.model);
+    }
+    if (thread.fast) {
+      args.push("--effort", "low");
+    }
+    if (sessionId) {
+      args.push("--resume", sessionId);
+    }
+    return {
+      file: claude,
+      args,
+      cwd: thread.worktreePath,
+      stdin: useStdin ? `${promptText}
+` : void 0
+    };
+  },
+  parseEvent(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj.type === "system" && obj.subtype === "init") {
+        const sid = obj.session_id;
+        if (typeof sid === "string") return { type: "session_id", data: sid };
+        return null;
+      }
+      if (obj.type === "system" && typeof obj.session_id === "string") {
+        return { type: "session_id", data: obj.session_id };
+      }
+      if (obj.type === "assistant" || obj.type === "user") {
+        const content = obj.message?.content;
+        const events = eventsFromContentBlocks(content);
+        if (events.length === 0) return null;
+        return events.length === 1 ? events[0] : events;
+      }
+      if (obj.type === "stream_event") {
+        const event = obj.event;
+        if (!event) return null;
+        if (event.type === "content_block_start" && event.content_block) {
+          const block = event.content_block;
+          if (block.type === "tool_use" && block.id && block.name) {
+            return {
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input
+            };
+          }
+          if (block.type === "thinking" && block.thinking) {
+            return { type: "thinking", data: block.thinking };
+          }
+          return null;
+        }
+        if (event.type === "content_block_delta" && event.delta) {
+          if (event.delta.text) return { type: "stdout", data: event.delta.text };
+          if (event.delta.thinking) return { type: "thinking", data: event.delta.thinking };
+          return null;
+        }
+        return null;
+      }
+      if (obj.type === "content_block_delta") {
+        const delta = obj.delta;
+        if (delta?.text) return { type: "stdout", data: delta.text };
+        if (delta?.thinking) return { type: "thinking", data: delta.thinking };
+        return null;
+      }
+      if (obj.type === "result") {
+        const events = [];
+        const text = obj.result;
+        if (typeof text === "string" && text) events.push({ type: "stdout", data: text });
+        const usage = usageFromClaude(obj.usage);
+        if (usage) events.push({ type: "usage", data: usage });
+        if (events.length === 0) return null;
+        return events.length === 1 ? events[0] : events;
+      }
+      return null;
+    } catch {
+      return { type: "stdout", data: line };
+    }
+  },
+  async resolveSessionId(_worktreePath, cached) {
+    return cached;
+  },
+  async buildAttach(thread) {
+    const claude = resolveClaudeExecutable();
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const args = sessionId ? ["--resume", sessionId] : [];
+    if (claudeChromeEnabled()) {
+      args.push("--chrome");
+    }
+    return { file: claude, args, cwd: thread.worktreePath };
+  },
+  async listLinearIssues(_repoPath) {
+    const claude = resolveClaudeExecutable();
+    const prompt = "List my assigned Linear issues as JSON array only, no markdown. Each item: id, identifier, title, url, labels (string[]).";
+    const { stdout, exitCode } = await run(
+      claude,
+      [
+        "-p",
+        prompt,
+        "--output-format",
+        "json",
+        "--permission-mode",
+        "bypassPermissions",
+        "--allowedTools",
+        "mcp__linear__*"
+      ],
+      { reject: false }
+    );
+    if (exitCode !== 0) return [];
+    return parseIssuesJson(stdout);
+  }
+};
+function parseIssuesJson(raw) {
+  const text = raw.trim();
+  const candidates = [text];
+  const match = text.match(/\[[\s\S]*\]/);
+  if (match) candidates.push(match[0]);
+  for (const c of candidates) {
+    try {
+      const parsed = JSON.parse(c);
+      if (Array.isArray(parsed)) {
+        return parsed.map((item) => ({
+          id: String(item.id ?? item.identifier ?? ""),
+          identifier: String(item.identifier ?? item.id ?? ""),
+          title: String(item.title ?? ""),
+          url: String(item.url ?? ""),
+          labels: Array.isArray(item.labels) ? item.labels.map(String) : []
+        }));
+      }
+      if (parsed && typeof parsed === "object" && typeof parsed.result === "string") {
+        return parseIssuesJson(parsed.result);
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+
+// src/agents/codex.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var CODEX_PROMPT_ARG_MAX = 2e5;
+function usageFromCodex(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.input_tokens ?? 0);
+  const outputTokens = Number(usage.output_tokens ?? 0) + Number(usage.reasoning_output_tokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usage.cached_input_tokens ? Number(usage.cached_input_tokens) : void 0
+  };
+}
+function codexConfigHasNetworkAccess() {
+  const candidates = [
+    join2(homedir(), ".codex", "config.toml"),
+    join2(homedir(), ".config", "codex", "config.toml")
+  ];
+  for (const path of candidates) {
+    if (!existsSync3(path)) continue;
+    const text = readFileSync(path, "utf8");
+    if (/network_access\s*=\s*true/.test(text)) return true;
+  }
+  return false;
+}
+var codexAdapter = {
+  kind: "codex",
+  async detect() {
+    const which = await run("which", ["codex"], { reject: false });
+    if (which.exitCode !== 0) {
+      return {
+        agent: "codex",
+        installed: false,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "codex CLI not found on PATH"
+      };
+    }
+    const auth = await run("codex", ["login", "status"], { reject: false });
+    const authenticated = auth.exitCode === 0;
+    const mcp = await run("codex", ["mcp", "list", "--json"], { reject: false });
+    const linearMcp = /linear/i.test(mcp.stdout + mcp.stderr);
+    const warnings = [];
+    if (!codexConfigHasNetworkAccess()) {
+      warnings.push(
+        "Codex workspace-write blocks network by default \u2014 set [sandbox_workspace_write] network_access = true in ~/.codex/config.toml if agents need npm install etc."
+      );
+    }
+    return {
+      agent: "codex",
+      installed: true,
+      authenticated,
+      linearMcp,
+      warnings,
+      reason: authenticated ? void 0 : "codex login status failed \u2014 run `codex login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const useStdin = prompt.length > CODEX_PROMPT_ARG_MAX;
+    const promptArg = useStdin ? "-" : prompt;
+    if (process.env.SIDEBOARD_DEBUG_CODEX_TURN === "1") {
+      const { cachedPrefix } = normalizeTurnInput(input);
+      console.error(
+        `[sideboard/codex] promptChars=${prompt.length} resumed=${Boolean(sessionId)} stdin=${useStdin} hasPrefix=${Boolean(cachedPrefix)}`
+      );
+    }
+    const mode = permissionMode(thread);
+    const args = [
+      "exec",
+      ...sessionId ? ["resume", sessionId] : [],
+      promptArg,
+      "--cd",
+      thread.worktreePath,
+      "--json",
+      "--sandbox",
+      mode.codexSandbox,
+      "--ask-for-approval",
+      "never"
+    ];
+    return {
+      file: "codex",
+      args,
+      cwd: thread.worktreePath,
+      stdin: useStdin ? `${prompt}
+` : void 0
+    };
+  },
+  parseEvent(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    try {
+      const obj = JSON.parse(trimmed);
+      const sid = typeof obj.session_id === "string" && obj.session_id || typeof obj.thread_id === "string" && obj.thread_id || typeof obj.session?.id === "string" && obj.session.id;
+      if (sid) return { type: "session_id", data: sid };
+      if (obj.type === "turn.completed" || obj.type === "turn_completed") {
+        const usage = usageFromCodex(obj.usage);
+        return usage ? { type: "usage", data: usage } : null;
+      }
+      if (typeof obj.item === "object" && obj.item !== null) {
+        const item = obj.item;
+        if (item.type === "agent_message" && item.text) {
+          return { type: "stdout", data: item.text };
+        }
+      }
+      if (typeof obj.content === "string") {
+        return { type: "stdout", data: obj.content };
+      }
+      return { type: "stdout", data: trimmed };
+    } catch {
+      return { type: "stdout", data: line };
+    }
+  },
+  async resolveSessionId(_worktreePath, cached) {
+    return cached;
+  },
+  async buildAttach(thread) {
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    if (sessionId) {
+      return {
+        file: "codex",
+        args: ["exec", "resume", sessionId, "--cd", thread.worktreePath],
+        cwd: thread.worktreePath
+      };
+    }
+    return {
+      file: "codex",
+      args: ["--cd", thread.worktreePath],
+      cwd: thread.worktreePath
+    };
+  },
+  async listLinearIssues(_repoPath) {
+    const prompt = "List my assigned Linear issues as JSON array only: id, identifier, title, url, labels.";
+    const { stdout, exitCode } = await run(
+      "codex",
+      [
+        "exec",
+        prompt,
+        "--json",
+        "--sandbox",
+        "read-only",
+        "--ask-for-approval",
+        "never"
+      ],
+      { reject: false }
+    );
+    if (exitCode !== 0) return [];
+    const match = stdout.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    try {
+      const parsed = JSON.parse(match[0]);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/agents/cursor.ts
+import { existsSync as existsSync4 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Cursor } from "@cursor/sdk";
+function resolveCursorApiKey() {
+  const fromEnv = (process.env.CURSOR_API_KEY || "").trim();
+  if (fromEnv) return fromEnv;
+  return (loadAppSettings().environment.CURSOR_API_KEY || "").trim();
+}
+function entryDir() {
+  const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
+  if (cjsDir) return cjsDir;
+  try {
+    return dirname2(fileURLToPath2(import.meta.url));
+  } catch {
+    try {
+      const req = createRequire2(process.cwd() + "/");
+      return dirname2(req.resolve("@sideboard-ai/core"));
+    } catch {
+      return process.cwd();
+    }
+  }
+}
+function cursorRunnerPath() {
+  const root = entryDir();
+  const candidates = [
+    join3(root, "agents", "cursor-runner.js"),
+    join3(root, "agents", "cursor-runner.cjs"),
+    // If somehow resolved from package root instead of dist/
+    join3(root, "dist", "agents", "cursor-runner.js"),
+    join3(root, "dist", "agents", "cursor-runner.cjs"),
+    // Source tree (dev): packages/core/src/agents/cursor-runner.ts
+    join3(root, "cursor-runner.ts"),
+    join3(root, "src", "agents", "cursor-runner.ts")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync4(candidate)) return candidate;
+  }
+  return candidates[0];
+}
+var cursorAdapter = {
+  kind: "cursor",
+  async detect() {
+    const apiKey = resolveCursorApiKey();
+    if (!apiKey) {
+      return {
+        agent: "cursor",
+        installed: true,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "CURSOR_API_KEY not set \u2014 add it in Settings \u2192 Agents \u2192 Cursor, or Settings \u2192 Environment"
+      };
+    }
+    try {
+      await Cursor.models.list({ apiKey });
+      return {
+        agent: "cursor",
+        installed: true,
+        authenticated: true,
+        linearMcp: false,
+        warnings: []
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        agent: "cursor",
+        installed: true,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: `Cursor API auth failed: ${message}`
+      };
+    }
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const agentId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const apiKey = resolveCursorApiKey() || void 0;
+    const req = {
+      prompt,
+      cwd: thread.worktreePath,
+      agentId,
+      model: thread.model,
+      fast: thread.fast,
+      planMode: thread.planMode,
+      apiKey
+    };
+    const runner = cursorRunnerPath();
+    const isTs = runner.endsWith(".ts");
+    return {
+      file: process.execPath,
+      args: isTs ? ["--import", "tsx", runner] : [runner],
+      cwd: thread.worktreePath,
+      stdin: JSON.stringify(req),
+      env: {
+        ...apiKey ? { CURSOR_API_KEY: apiKey } : {}
+      }
+    };
+  },
+  parseEvent(line) {
+    return parseCursorRunnerLine(line);
+  },
+  async resolveSessionId(_worktreePath, cached) {
+    return cached;
+  },
+  async buildAttach(thread) {
+    const which = await run("which", ["cursor"], { reject: false });
+    if (which.exitCode === 0) {
+      return { file: "cursor", args: [thread.worktreePath], cwd: thread.worktreePath };
+    }
+    throw new Error(
+      "Cursor agents have no interactive CLI attach. Install the Cursor shell command (`cursor`) to open the worktree, or continue the thread in Sideboard."
+    );
+  }
+};
+
+// src/agents/opencode.ts
+function usageFromOpencode(tokens) {
+  if (!tokens) return null;
+  const inputTokens = Number(tokens.input ?? 0);
+  const outputTokens = Number(tokens.output ?? 0) + Number(tokens.reasoning ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: tokens.cache?.read ? Number(tokens.cache.read) : void 0,
+    cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
+  };
+}
+var opencodeAdapter = {
+  kind: "opencode",
+  async detect() {
+    const which = await run("which", ["opencode"], { reject: false });
+    if (which.exitCode !== 0) {
+      return {
+        agent: "opencode",
+        installed: false,
+        authenticated: false,
+        linearMcp: false,
+        warnings: [],
+        reason: "opencode CLI not found on PATH"
+      };
+    }
+    const auth = await run("opencode", ["auth", "list"], { reject: false });
+    const authenticated = auth.exitCode === 0 && auth.stdout.trim().length > 0;
+    const mcp = await run("opencode", ["mcp", "list"], { reject: false });
+    const linearMcp = /linear/i.test(mcp.stdout + mcp.stderr);
+    return {
+      agent: "opencode",
+      installed: true,
+      authenticated,
+      linearMcp,
+      warnings: [],
+      reason: authenticated ? void 0 : "opencode auth list empty \u2014 run `opencode auth login`"
+    };
+  },
+  async buildTurn(thread, input) {
+    const prompt = flattenTurnInput(input);
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const mode = permissionMode(thread);
+    const args = [
+      "run",
+      "--dir",
+      thread.worktreePath,
+      "--format",
+      "json"
+    ];
+    if (sessionId) {
+      args.push("--session", sessionId);
+    }
+    return {
+      file: "opencode",
+      args,
+      cwd: thread.worktreePath,
+      // `opencode run` treats non-TTY stdin as the message body when no positional
+      // message is given (see resolveRunInput in opencode's run.ts).
+      stdin: prompt,
+      env: {
+        OPENCODE_PERMISSION: mode.opencodePermission
+      }
+    };
+  },
+  parseEvent(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    try {
+      const obj = JSON.parse(trimmed);
+      const sid = typeof obj.sessionID === "string" && obj.sessionID || typeof obj.sessionId === "string" && obj.sessionId || typeof obj.session_id === "string" && obj.session_id;
+      if (sid) return { type: "session_id", data: sid };
+      if (obj.type === "text") {
+        const text = obj.part?.text ?? obj.text;
+        if (text) return { type: "stdout", data: text };
+      }
+      if (obj.type === "tool_use") {
+        const part = obj.part;
+        const id = part?.id ?? obj.id ?? `tool-${Date.now()}`;
+        const name = part?.name ?? part?.tool ?? obj.name ?? obj.tool ?? "tool";
+        const input = part?.input ?? obj.input;
+        return { type: "tool_use", id, name, input };
+      }
+      if (obj.type === "tool_result") {
+        const part = obj.part;
+        const id = part?.tool_use_id ?? part?.id ?? obj.tool_use_id ?? obj.id;
+        if (!id) return null;
+        return {
+          type: "tool_result",
+          id,
+          content: part?.output ?? part?.content ?? obj.output ?? obj.content
+        };
+      }
+      if (obj.type === "error") {
+        return {
+          type: "stderr",
+          data: String(obj.error ?? trimmed)
+        };
+      }
+      if (obj.type === "step_finish" || obj.type === "step-finish") {
+        const part = obj.part;
+        const usage = usageFromOpencode(
+          part?.tokens ?? obj.tokens
+        );
+        return usage ? { type: "usage", data: usage } : null;
+      }
+      return { type: "stdout", data: trimmed };
+    } catch {
+      return { type: "stdout", data: line };
+    }
+  },
+  async resolveSessionId(worktreePath, cached) {
+    const listed = await run(
+      "opencode",
+      ["session", "list", "--format", "json"],
+      { cwd: worktreePath, reject: false }
+    );
+    if (listed.exitCode === 0 && listed.stdout.trim()) {
+      try {
+        const sessions = JSON.parse(listed.stdout);
+        if (Array.isArray(sessions) && sessions.length > 0) {
+          const norm = (p) => p.replace(/\/+$/, "");
+          const wt = norm(worktreePath);
+          const match = sessions.find(
+            (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
+          );
+          if (match?.id) return match.id;
+        }
+      } catch {
+      }
+    }
+    return cached;
+  },
+  async buildAttach(thread) {
+    const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
+    const args = ["--dir", thread.worktreePath];
+    if (sessionId) args.push("--session", sessionId);
+    return {
+      file: "opencode",
+      args,
+      cwd: thread.worktreePath,
+      env: {
+        OPENCODE_PERMISSION: permissionMode(thread).opencodePermission
+      }
+    };
+  },
+  async listLinearIssues(_repoPath) {
+    const prompt = "List my assigned Linear issues as JSON array only: id, identifier, title, url, labels.";
+    const { stdout, exitCode } = await run(
+      "opencode",
+      ["run", prompt, "--format", "json"],
+      {
+        reject: false,
+        env: { OPENCODE_PERMISSION: JSON.stringify({ "*": "allow" }) }
+      }
+    );
+    if (exitCode !== 0) return [];
+    const texts = [];
+    for (const line of stdout.split("\n")) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "text") {
+          texts.push(obj.part?.text ?? obj.text ?? "");
+        }
+      } catch {
+      }
+    }
+    const joined = texts.join("");
+    const match = joined.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    try {
+      return JSON.parse(match[0]);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/agents/index.ts
+var adapters = {
+  claude: claudeAdapter,
+  codex: codexAdapter,
+  opencode: opencodeAdapter,
+  brightsy: brightsyAdapter,
+  cursor: cursorAdapter
+};
+function getAdapter(kind) {
+  return adapters[kind];
+}
+function allAdapters() {
+  return Object.values(adapters);
+}
+
+export {
+  encodeBrightsyTarget,
+  decodeBrightsyTarget,
+  normalizeTurnInput,
+  flattenTurnInput,
+  buildCachedUserContent,
+  buildClaudeStreamJsonUserMessage,
+  findInvalidCacheControlTtlOrder,
+  countCacheControlBlocks,
+  MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
+  parseBrightsyCliLine,
+  listBrightsyChatTargets,
+  brightsyAdapter,
+  parseMcpList,
+  sanitizeMcpServerName,
+  mcpAllowTools,
+  mcpAuthWarnings,
+  SIDEBOARD_MCP_ALLOWED_TOOLS,
+  BRIGHTSY_MCP_ALLOWED_TOOLS,
+  isBrightsyConnected,
+  brightsyMcpAllowedTools,
+  writeInjectedMcpConfig,
+  PLAN_MODE_INSTRUCTION,
+  permissionMode,
+  claudeAdapter,
+  codexAdapter,
+  cursorAdapter,
+  opencodeAdapter,
+  getAdapter,
+  allAdapters
+};