@sideboard-ai/core 0.1.286 → 0.1.288

package/dist/chunk-OH4EN323.js

@@ -0,0 +1,89 @@
+import {
+  OPTIONAL_SERVICES,
+  isOptionalServiceId,
+  optionalServiceSpec
+} from "./chunk-AF2DMY3K.js";
+import {
+  installNpmGlobalPackage,
+  whichOnPath
+} from "./chunk-NXXQFLNQ.js";
+import {
+  enrichPathWithNpmGlobalBin
+} from "./chunk-QVN2WOKJ.js";
+
+// src/integrations/optional-cli.ts
+async function detectOptionalServiceClis() {
+  enrichPathWithNpmGlobalBin();
+  return Promise.all(
+    OPTIONAL_SERVICES.map(async (spec) => {
+      if (!spec.cli) {
+        return { id: spec.id, cli: null, installed: false, path: null };
+      }
+      const path = await whichOnPath(spec.cli);
+      return {
+        id: spec.id,
+        cli: spec.cli,
+        installed: Boolean(path),
+        path
+      };
+    })
+  );
+}
+var CLI_PRESENCE_TTL_MS = 6e4;
+var cliPresenceCache = /* @__PURE__ */ new Map();
+function clearOptionalCliPresenceCache() {
+  cliPresenceCache.clear();
+}
+async function optionalCliPresence(ids) {
+  const presence = {};
+  const now = Date.now();
+  await Promise.all(
+    ids.map(async (id) => {
+      const spec = optionalServiceSpec(id);
+      if (!spec.cli) return;
+      const hit = cliPresenceCache.get(id);
+      if (hit && now - hit.at < CLI_PRESENCE_TTL_MS) {
+        presence[id] = hit.installed;
+        return;
+      }
+      const path = await whichOnPath(spec.cli);
+      const installed = Boolean(path);
+      cliPresenceCache.set(id, { at: now, installed });
+      presence[id] = installed;
+    })
+  );
+  return presence;
+}
+async function installOptionalServiceCli(id) {
+  if (!isOptionalServiceId(id)) {
+    return { ok: false, message: "Unknown optional service" };
+  }
+  const spec = optionalServiceSpec(id);
+  if (!spec.cli || !spec.npmPackage) {
+    return {
+      ok: false,
+      message: `${spec.label} has no CLI to install. Agents call posthog_api.`
+    };
+  }
+  enrichPathWithNpmGlobalBin();
+  const existing = await whichOnPath(spec.cli);
+  if (existing) {
+    return {
+      ok: true,
+      command: existing,
+      message: `Already on PATH: ${existing}`
+    };
+  }
+  return installNpmGlobalPackage({
+    npmPackage: spec.npmPackage,
+    installCommand: `npm install -g ${spec.npmPackage}`,
+    cliBin: spec.cli
+  });
+}
+
+export {
+  detectOptionalServiceClis,
+  clearOptionalCliPresenceCache,
+  optionalCliPresence,
+  installOptionalServiceCli
+};

package/dist/chunk-W2KZTDET.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+import {
+  enrichPathWithNpmGlobalBin,
+  isConductorBundledCli,
+  resolveCommandBinarySync,
+  run,
+  withExportedPath
+} from "./chunk-2UG25RMK.js";
+import {
+  resolveAgentExecutable
+} from "./chunk-MVZO7QZ2.js";
+
+// src/agents/install.ts
+import { existsSync } from "fs";
+var SETUP = {
+  claude: {
+    agent: "claude",
+    kind: "cli",
+    summary: "Install the Claude Code CLI, then complete login in a terminal.",
+    docsUrl: "https://code.claude.com/docs/en/install",
+    installCommand: "npm install -g @anthropic-ai/claude-code",
+    loginCommand: "claude auth login",
+    npmPackage: "@anthropic-ai/claude-code",
+    updateArgs: ["update"]
+  },
+  codex: {
+    agent: "codex",
+    kind: "cli",
+    summary: "Install the Codex CLI, then run login in a terminal.",
+    docsUrl: "https://github.com/openai/codex",
+    installCommand: "npm install -g @openai/codex",
+    loginCommand: "codex login",
+    npmPackage: "@openai/codex",
+    updateArgs: ["update"]
+  },
+  opencode: {
+    agent: "opencode",
+    kind: "cli",
+    summary: "Install OpenCode (curl installer or npm), then authenticate providers.",
+    docsUrl: "https://opencode.ai/docs",
+    // Prefer the official installer; npm package name is opencode-ai.
+    installCommand: "curl -fsSL https://opencode.ai/install | bash",
+    loginCommand: "opencode auth login",
+    npmPackage: "opencode-ai@latest",
+    updateArgs: ["upgrade"]
+  },
+  cursor: {
+    agent: "cursor",
+    kind: "cli",
+    summary: "Install (or update) @cursor/sdk with npm \u2014 Sideboard does not pin it in the app. Then add a CURSOR_API_KEY.",
+    docsUrl: "https://www.npmjs.com/package/@cursor/sdk",
+    installCommand: "npm install -g @cursor/sdk",
+    loginCommand: null,
+    npmPackage: "@cursor/sdk"
+  },
+  brightsy: {
+    agent: "brightsy",
+    kind: "cli",
+    summary: "Install (or update) the Brightsy CLI with npm, then run `brightsy login`.",
+    docsUrl: "https://www.npmjs.com/package/@brightsy/cli",
+    installCommand: "npm install -g @brightsy/cli",
+    loginCommand: "brightsy login",
+    npmPackage: "@brightsy/cli"
+  }
+};
+var CLI_BIN = {
+  claude: "claude",
+  codex: "codex",
+  opencode: "opencode",
+  brightsy: "brightsy"
+};
+function getAgentSetupInfo(agent) {
+  return SETUP[agent];
+}
+function listAgentSetupInfo() {
+  return Object.values(SETUP);
+}
+var CLI_LOGIN_AGENTS = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "opencode",
+  "brightsy"
+]);
+function resolveLoginCommand(agent) {
+  const info = getAgentSetupInfo(agent);
+  if (!info.loginCommand) return null;
+  if (!CLI_LOGIN_AGENTS.has(agent)) return info.loginCommand;
+  const exe = resolveAgentExecutable(agent);
+  return info.loginCommand.replace(/^\S+/, exe);
+}
+async function prepareTerminalCommand(command) {
+  enrichPathWithNpmGlobalBin();
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
+  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
+  const bin = match?.[1];
+  let whichPath = null;
+  if (bin && !bin.includes("/") && !bin.includes("\\")) {
+    const which = await run("which", [bin], { reject: false, timeoutMs: 3e3 });
+    whichPath = which.exitCode === 0 ? which.stdout.trim() : null;
+  }
+  const resolved = resolveCommandBinarySync(trimmed, whichPath);
+  return withExportedPath(resolved, process.env.PATH ?? "");
+}
+async function openInSystemTerminal(command) {
+  const trimmed = (await prepareTerminalCommand(command)).trim();
+  if (!trimmed) throw new Error("Command is empty");
+  if (process.platform === "darwin") {
+    const escaped = trimmed.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const script = `tell application "Terminal" to do script "${escaped}"`;
+    const result = await run("osascript", ["-e", script], { reject: false });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to open Terminal");
+    }
+    await run("osascript", ["-e", 'tell application "Terminal" to activate'], {
+      reject: false
+    });
+    return;
+  }
+  if (process.platform === "win32") {
+    const result = await run(
+      "cmd.exe",
+      ["/c", "start", "cmd.exe", "/k", trimmed],
+      { reject: false }
+    );
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to open cmd");
+    }
+    return;
+  }
+  const candidates = [
+    { file: "gnome-terminal", args: ["--", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "x-terminal-emulator", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "konsole", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] },
+    { file: "xterm", args: ["-e", "bash", "-lc", `${trimmed}; exec bash`] }
+  ];
+  for (const c of candidates) {
+    const which = await run("which", [c.file], { reject: false });
+    if (which.exitCode !== 0 || !which.stdout.trim()) continue;
+    const result = await run(c.file, c.args, { reject: false });
+    if (result.exitCode === 0) return;
+  }
+  throw new Error(
+    `No terminal found to run: ${trimmed}. Install gnome-terminal (or similar), or run the command manually.`
+  );
+}
+async function whichOnPath(bin) {
+  const which = await run("which", [bin], { reject: false, timeoutMs: 3e3 });
+  if (which.exitCode !== 0) return null;
+  return which.stdout.trim().split(/\r?\n/).find(Boolean) ?? null;
+}
+async function installNpmGlobalPackage(opts) {
+  enrichPathWithNpmGlobalBin();
+  const result = await run("npm", ["install", "-g", opts.npmPackage], { reject: false });
+  const ok = result.exitCode === 0;
+  if (!ok) {
+    try {
+      await openInSystemTerminal(opts.installCommand);
+      return {
+        ok: false,
+        openedTerminal: true,
+        command: opts.installCommand,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        message: `npm install failed (exit ${result.exitCode}). Opened Terminal with: ${opts.installCommand}`
+      };
+    } catch {
+      return {
+        ok: false,
+        command: opts.installCommand,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        message: result.stderr.trim() || result.stdout.trim() || `npm install failed (exit ${result.exitCode})`
+      };
+    }
+  }
+  enrichPathWithNpmGlobalBin();
+  const binPath = opts.cliBin ? await whichOnPath(opts.cliBin) : null;
+  return {
+    ok: true,
+    command: opts.installCommand,
+    exitCode: 0,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    // Library-only packages (`@cursor/sdk`) have no CLI to look for.
+    message: !opts.cliBin ? `Installed ${opts.npmPackage}` : binPath ? `Installed ${opts.npmPackage} \u2192 ${binPath}` : `Installed ${opts.npmPackage} (CLI not yet on PATH)`
+  };
+}
+async function resolveExistingCli(agent) {
+  if (agent === "cursor") return null;
+  const exe = resolveAgentExecutable(agent);
+  if ((exe.includes("/") || exe.includes("\\")) && existsSync(exe)) return exe;
+  enrichPathWithNpmGlobalBin();
+  return whichOnPath(CLI_BIN[agent]);
+}
+async function runVendorUpdate(existing, updateArgs) {
+  const result = await run(existing, updateArgs, {
+    reject: false,
+    timeoutMs: 12e4
+  });
+  const command = `${existing} ${updateArgs.join(" ")}`;
+  const ok = result.exitCode === 0;
+  const detail = result.stdout.trim() || result.stderr.trim() || `exit ${result.exitCode}`;
+  return {
+    ok,
+    command,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    message: ok ? isConductorBundledCli(existing) ? `Updated Conductor\u2019s CLI at ${existing}. ${detail}` : `Updated ${command}. ${detail}` : `Update failed (${command}): ${detail}`
+  };
+}
+function isCurlInstaller(command) {
+  return /curl\s| \|\s*bash/.test(command);
+}
+async function installAgent(agent) {
+  const info = getAgentSetupInfo(agent);
+  if (info.kind === "bundled-sdk" || info.kind === "api-key") {
+    return {
+      ok: true,
+      message: info.summary
+    };
+  }
+  if (!info.installCommand) {
+    return { ok: false, message: `No install command for ${agent}` };
+  }
+  const existing = await resolveExistingCli(agent);
+  if (existing && info.updateArgs?.length) {
+    return runVendorUpdate(existing, info.updateArgs);
+  }
+  if (info.npmPackage && !isCurlInstaller(info.installCommand)) {
+    const cliBin = agent === "cursor" ? null : CLI_BIN[agent];
+    return installNpmGlobalPackage({
+      npmPackage: info.npmPackage,
+      installCommand: info.installCommand,
+      cliBin
+    });
+  }
+  await openInSystemTerminal(info.installCommand);
+  return {
+    ok: true,
+    openedTerminal: true,
+    command: info.installCommand,
+    message: `Opened Terminal to run: ${info.installCommand}`
+  };
+}
+async function loginAgent(agent) {
+  const info = getAgentSetupInfo(agent);
+  const loginCommand = resolveLoginCommand(agent);
+  if (!loginCommand) {
+    return {
+      ok: true,
+      message: info.kind === "bundled-sdk" || info.kind === "api-key" ? info.summary : `No login command for ${agent}`
+    };
+  }
+  const prepared = await prepareTerminalCommand(loginCommand);
+  await openInSystemTerminal(prepared);
+  return {
+    ok: true,
+    openedTerminal: true,
+    command: prepared,
+    message: `Opened Terminal to run: ${prepared}`
+  };
+}
+async function loginManagedAccount(accountId) {
+  const { loadAppSettings } = await import("./app-settings-EHMXHNG5.js");
+  const { loginEnvPrefix } = await import("./managed-accounts-46A4KRUE.js");
+  const account = loadAppSettings().accounts.accounts.find((a) => a.id === accountId);
+  if (!account) {
+    return { ok: false, message: `Account not found: ${accountId}` };
+  }
+  const loginCommand = resolveLoginCommand(account.kind);
+  if (!loginCommand) {
+    return { ok: false, message: `No login command for ${account.kind}` };
+  }
+  const prepared = await prepareTerminalCommand(loginCommand);
+  const prefixed = `${loginEnvPrefix(account)} && ${prepared}`;
+  await openInSystemTerminal(prefixed);
+  return {
+    ok: true,
+    openedTerminal: true,
+    command: prefixed,
+    message: `Opened Terminal to run: ${prefixed}`
+  };
+}
+
+export {
+  getAgentSetupInfo,
+  listAgentSetupInfo,
+  resolveLoginCommand,
+  prepareTerminalCommand,
+  openInSystemTerminal,
+  whichOnPath,
+  installNpmGlobalPackage,
+  installAgent,
+  loginAgent,
+  loginManagedAccount
+};

package/dist/{chunk-ABOH7GBG.js → chunk-WQSIUZEB.js}

@@ -2,17 +2,17 @@ import {
   compactSummaryPart,
   isInternalAgentStatusText,
   lastAssistantMessageText
-} from "./chunk-XSDCLM3F.js";
+} from "./chunk-YSLCWCMJ.js";
 import {
   isCloudCoordinatorThread,
   isGlobalThread,
   isOrchestratorThread,
   isSlackCoordinatorThread
-} from "./chunk-MGJ7R7UX.js";
+} from "./chunk-DBOFDEQ7.js";
 import {
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv
-} from "./chunk-K5XSTHHP.js";
+} from "./chunk-HNB2HTCV.js";
 import {
   allocateTeamName,
   createEmptyThread,
@@ -29,7 +29,7 @@ import {
 } from "./chunk-2P4XKWV2.js";
 import {
   clipToolResultForStore
-} from "./chunk-U6QDXT4K.js";
+} from "./chunk-MIVX7QKI.js";
 import {
   ATTACHMENTS_DIR,
   DETACHED_JOBS_DIR,
@@ -43,7 +43,7 @@ import {
 import {
   assertOrchestratorCapableAgent,
   contextTokens
-} from "./chunk-YNTXWFXT.js";
+} from "./chunk-36J3IZBS.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-4TR3HZFT.js";
@@ -1776,7 +1776,7 @@ var PORT_RANGE_SIZE = 10;
 var RECLAIM_RETRY_DELAY_MS = 40;
 var RECLAIM_TRIES = 8;
 async function killReclaimable(ports, worktreePath, signal) {
-  const { killListenersOnPorts: killListenersOnPorts2, killStaleWorktreeListeners: killStaleWorktreeListeners2 } = await import("./conductor-WYOWFB7I.js");
+  const { killListenersOnPorts: killListenersOnPorts2, killStaleWorktreeListeners: killStaleWorktreeListeners2 } = await import("./conductor-ZLYZVIAV.js");
   if (worktreePath) killStaleWorktreeListeners2(ports, worktreePath, signal);
   else killListenersOnPorts2(ports);
 }