@sideboard-ai/core 0.1.45 → 0.1.49

package/dist/chunk-DF5VQQKA.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+import {
+  assertOrchestratorCapableAgent
+} from "./chunk-S2LL5HA4.js";
+import {
+  ensureGlobalCoordinatorCwd
+} from "./chunk-GZXBYHJC.js";
+import {
+  allocateTeamName,
+  takenSlugsFromThread,
+  teamSlugFromName
+} from "./chunk-ZVV5EEQN.js";
+import {
+  createEmptyThread,
+  listThreads,
+  updateThread,
+  writeThread
+} from "./chunk-EOYDCKQC.js";
+import {
+  globalAgentCwd
+} from "./chunk-7MV3RXSC.js";
+
+// src/brightsy/cloud-connect-constants.ts
+var CLOUD_ORCHESTRATOR_GOAL = "Cloud-connected Sideboard orchestrator";
+var SIDEBOARD_FORCE_STOP = "SIDEBOARD_FORCE_STOP";
+var CLOUD_COORDINATOR_BUSY_REPLY = [
+  "Sideboard is busy with an in-progress client/desktop tool turn on the global coordinator.",
+  "I did not start a new orchestration turn.",
+  `To force-stop the in-progress turn, send another desktop request whose first line is exactly ${SIDEBOARD_FORCE_STOP}`,
+  "(optional follow-up request on later lines).",
+  "What do you want me to do? (retry later, wait until idle, force-stop, rephrase, or cancel)"
+].join(" ");
+var CLOUD_COORDINATOR_STOPPED_REPLY = [
+  "Sideboard force-stopped the in-progress global coordinator turn.",
+  "No new orchestration request was started."
+].join(" ");
+var CLOUD_COORDINATOR_TIMEOUT_REPLY = [
+  "Sideboard global coordinator timed out waiting for the local agent turn to finish.",
+  "I did not produce a full orchestration result.",
+  `To force-stop the in-progress turn, send another desktop request whose first line is exactly ${SIDEBOARD_FORCE_STOP}`,
+  "(optional follow-up request on later lines).",
+  "What do you want me to do? (retry later, wait, force-stop, rephrase, or cancel)"
+].join(" ");
+
+// src/store/global-workspace.ts
+var GLOBAL_WORKSPACE_ID = "__global__";
+function isGlobalThread(thread) {
+  return Boolean(thread && thread.repoPath === GLOBAL_WORKSPACE_ID);
+}
+function isGlobalRepoPath(repoPath) {
+  return repoPath === GLOBAL_WORKSPACE_ID;
+}
+function isOrchestratorThread(thread) {
+  return Boolean(
+    thread && (thread.sourceType === "orchestration" || isGlobalThread(thread))
+  );
+}
+function orchestratorSessionPoisonedByBuiltins(thread) {
+  if (!thread?.messages?.length) return false;
+  let usedBuiltin = false;
+  let usedSideboardMcp = false;
+  for (const msg of thread.messages) {
+    for (const part of msg.parts ?? []) {
+      if (part.type !== "tool") continue;
+      if (part.name.startsWith("mcp__sideboard")) {
+        usedSideboardMcp = true;
+      } else if (part.name === "Bash" || part.name === "Edit" || part.name === "Write" || part.name === "Read" || part.name === "Glob" || part.name === "Grep") {
+        usedBuiltin = true;
+      }
+    }
+  }
+  return usedBuiltin && !usedSideboardMcp;
+}
+function isCloudCoordinatorThread(thread) {
+  if (thread.sourceRef === CLOUD_ORCHESTRATOR_GOAL) {
+    return isGlobalThread(thread) || thread.sourceType === "orchestration";
+  }
+  if (thread.title === CLOUD_ORCHESTRATOR_GOAL) {
+    return isGlobalThread(thread) || thread.sourceType === "orchestration";
+  }
+  return false;
+}
+function orchestrationTitleNeedsSoccerNickname(thread) {
+  if (!isOrchestratorThread(thread)) return false;
+  const title = thread.title?.trim() ?? "";
+  if (teamSlugFromName(title)) return false;
+  if (title === CLOUD_ORCHESTRATOR_GOAL) return true;
+  if (!title || title === "Untitled") return true;
+  if (thread.userSetTitle) return false;
+  if (thread.sourceRef?.trim() && title === thread.sourceRef.trim()) return true;
+  return false;
+}
+function takenTeamSlugsForOrchestration() {
+  const taken = /* @__PURE__ */ new Set(["global"]);
+  for (const thread of listThreads({ includeArchived: true })) {
+    if (thread.status === "archived") continue;
+    for (const slug of takenSlugsFromThread(thread)) {
+      taken.add(slug);
+    }
+  }
+  return [...taken];
+}
+function createGlobalChat(opts) {
+  ensureGlobalCoordinatorCwd();
+  const isCloud = opts.sourceRef === CLOUD_ORCHESTRATOR_GOAL || opts.title?.trim() === CLOUD_ORCHESTRATOR_GOAL;
+  const explicit = opts.title?.trim();
+  const title = explicit && explicit !== CLOUD_ORCHESTRATOR_GOAL ? explicit : allocateTeamName(takenTeamSlugsForOrchestration()).name;
+  const sourceRef = opts.sourceRef?.trim() || (isCloud ? CLOUD_ORCHESTRATOR_GOAL : title);
+  const agent = assertOrchestratorCapableAgent(opts.agent);
+  const thread = createEmptyThread({
+    title,
+    // Stick nicknames the same way chat tabs do (avoid later sync overwrites).
+    userSetTitle: true,
+    sourceType: "orchestration",
+    sourceRef,
+    branchName: "global",
+    worktreePath: globalAgentCwd(),
+    repoPath: GLOBAL_WORKSPACE_ID,
+    agent,
+    autonomy: opts.autonomy ?? "default",
+    model: opts.model ?? null,
+    effort: opts.effort ?? "high",
+    fast: Boolean(opts.fast),
+    planMode: Boolean(opts.planMode),
+    attachments: opts.attachments ?? [],
+    parentThreadId: opts.parentThreadId ?? null,
+    status: "idle"
+  });
+  writeThread(thread);
+  return thread;
+}
+function healOrchestrationSoccerTitles() {
+  let healed = 0;
+  const taken = new Set(takenTeamSlugsForOrchestration());
+  for (const thread of listThreads({ includeArchived: true })) {
+    if (thread.status === "archived") continue;
+    if (!orchestrationTitleNeedsSoccerNickname(thread)) continue;
+    const team = allocateTeamName(taken);
+    taken.add(team.slug);
+    updateThread(thread.id, { title: team.name, userSetTitle: true });
+    healed += 1;
+  }
+  return healed;
+}
+function listGlobalThreads(includeArchived = false) {
+  return listThreads({ includeArchived }).filter(
+    (t) => t.repoPath === GLOBAL_WORKSPACE_ID
+  );
+}
+function findCloudCoordinator() {
+  return listThreads({ includeArchived: true }).find(
+    (t) => t.status !== "archived" && isCloudCoordinatorThread(t)
+  );
+}
+function ensureCloudCoordinator(agent) {
+  const existing = findCloudCoordinator();
+  if (existing) {
+    if (existing.repoPath !== GLOBAL_WORKSPACE_ID) {
+      return updateThread(existing.id, {
+        repoPath: GLOBAL_WORKSPACE_ID,
+        worktreePath: globalAgentCwd(),
+        branchName: "global"
+      });
+    }
+    return existing;
+  }
+  const created = createGlobalChat({
+    sourceRef: CLOUD_ORCHESTRATOR_GOAL,
+    agent
+  });
+  const all = listThreads({ includeArchived: true }).filter(
+    (t) => t.status !== "archived" && isCloudCoordinatorThread(t)
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return all[0] ?? created;
+}
+
+export {
+  GLOBAL_WORKSPACE_ID,
+  isGlobalThread,
+  isGlobalRepoPath,
+  isOrchestratorThread,
+  orchestratorSessionPoisonedByBuiltins,
+  isCloudCoordinatorThread,
+  orchestrationTitleNeedsSoccerNickname,
+  takenTeamSlugsForOrchestration,
+  createGlobalChat,
+  healOrchestrationSoccerTitles,
+  listGlobalThreads,
+  ensureCloudCoordinator
+};

package/dist/chunk-E35APBHV.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+import {
+  run
+} from "./chunk-ISY4EGF6.js";
+import {
+  appDataDir
+} from "./chunk-7MV3RXSC.js";
+
+// src/brightsy/connected-teams.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/brightsy/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function brightsyConfigPath() {
+  return join(homedir(), ".brightsy", "config.json");
+}
+function loadBrightsyConfig() {
+  const path = brightsyConfigPath();
+  if (!existsSync(path)) {
+    throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
+  }
+  const raw = JSON.parse(readFileSync(path, "utf8"));
+  if (!raw.access_token || !raw.account_id) {
+    throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
+  }
+  return raw;
+}
+function saveBrightsyConfig(cfg) {
+  writeFileSync(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+`, {
+    mode: 384
+  });
+}
+
+// src/brightsy/accounts.ts
+async function runBrightsyTeamsJson(args) {
+  const listed = await run("brightsy", ["teams", ...args, "--json"], {
+    reject: false
+  });
+  if (listed.exitCode !== 0) {
+    throw new Error(
+      listed.stderr.trim() || listed.stdout.trim() || "brightsy teams failed \u2014 is `@brightsy/cli` installed and logged in?"
+    );
+  }
+  const raw = listed.stdout.trim();
+  if (!raw) {
+    throw new Error("brightsy teams returned empty output");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("brightsy teams returned invalid JSON");
+  }
+}
+async function listBrightsyAccounts() {
+  const data = await runBrightsyTeamsJson([]);
+  return Array.isArray(data.teams) ? data.teams : [];
+}
+async function performBrightsyAccountSwitch(accountIdOrSlug) {
+  const data = await runBrightsyTeamsJson([
+    "switch",
+    accountIdOrSlug
+  ]);
+  if (!data.active?.id) {
+    throw new Error(`Team switch failed for: ${accountIdOrSlug}`);
+  }
+  const cfg = loadBrightsyConfig();
+  if (data.active.slug && data.active.slug !== cfg.account_slug) {
+    cfg.account_slug = data.active.slug;
+    saveBrightsyConfig(cfg);
+  }
+  return { cfg, target: data.active };
+}
+
+// src/brightsy/connected-teams.ts
+function storePath() {
+  return join2(appDataDir(), "brightsy-teams.json");
+}
+function readStore() {
+  const path = storePath();
+  if (!existsSync2(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return Array.isArray(parsed.teams) ? parsed.teams : [];
+  } catch {
+    return [];
+  }
+}
+function writeStore(teams) {
+  mkdirSync(appDataDir(), { recursive: true });
+  const path = storePath();
+  writeFileSync2(path, `${JSON.stringify({ teams }, null, 2)}
+`, {
+    mode: 384
+  });
+  return teams;
+}
+function listConnectedBrightsyTeams() {
+  return readStore().map(({ id, slug, name, expires_at }) => ({
+    id,
+    slug,
+    name,
+    expires_at
+  }));
+}
+function getConnectedBrightsyTeamsRaw() {
+  return readStore();
+}
+function applyConnectedTeamToCli(team) {
+  let base = {};
+  try {
+    base = loadBrightsyConfig();
+  } catch {
+  }
+  saveBrightsyConfig({
+    ...base,
+    access_token: team.access_token,
+    refresh_token: team.refresh_token ?? base.refresh_token,
+    expires_at: team.expires_at ?? base.expires_at,
+    account_id: team.id,
+    account_slug: team.slug,
+    endpoint: team.endpoint ?? base.endpoint ?? "https://brightsy.ai",
+    oauth_client_id: base.oauth_client_id
+  });
+}
+async function refreshTeamToken(team) {
+  if (!team.refresh_token) return team;
+  const endpoint = (team.endpoint || "https://brightsy.ai").replace(/\/$/, "");
+  const cfg = (() => {
+    try {
+      return loadBrightsyConfig();
+    } catch {
+      return null;
+    }
+  })();
+  const clientId = cfg?.oauth_client_id || "brightsy-cli";
+  const res = await fetch(`${endpoint}/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: team.refresh_token,
+      client_id: clientId
+    })
+  });
+  if (!res.ok) return team;
+  const data = await res.json();
+  if (!data.access_token) return team;
+  return {
+    ...team,
+    access_token: data.access_token,
+    refresh_token: data.refresh_token || team.refresh_token,
+    expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : team.expires_at
+  };
+}
+async function ensureConnectedBrightsyTeamTokens() {
+  const teams = readStore();
+  if (teams.length === 0) return [];
+  const next = [];
+  let changed = false;
+  for (const team of teams) {
+    const expired = typeof team.expires_at === "number" && Date.now() >= team.expires_at - 6e4;
+    if (!expired) {
+      next.push(team);
+      continue;
+    }
+    const refreshed = await refreshTeamToken(team);
+    if (refreshed.access_token !== team.access_token) changed = true;
+    next.push(refreshed);
+  }
+  if (changed) writeStore(next);
+  try {
+    const cfg = loadBrightsyConfig();
+    const active = next.find((t) => t.id === cfg.account_id);
+    if (active && active.access_token !== cfg.access_token) {
+      applyConnectedTeamToCli(active);
+    }
+  } catch {
+  }
+  return next;
+}
+function ensureCliTeamTracked(meta) {
+  try {
+    const cfg = loadBrightsyConfig();
+    const existing = readStore();
+    if (existing.some((t) => t.id === cfg.account_id)) {
+      return listConnectedBrightsyTeams();
+    }
+    const team = {
+      id: cfg.account_id,
+      slug: meta?.slug || cfg.account_slug || cfg.account_id,
+      name: meta?.name || cfg.account_slug || cfg.account_id,
+      access_token: cfg.access_token,
+      refresh_token: cfg.refresh_token,
+      expires_at: cfg.expires_at,
+      endpoint: cfg.endpoint
+    };
+    writeStore([...existing, team]);
+  } catch {
+  }
+  return listConnectedBrightsyTeams();
+}
+async function connectBrightsyTeam(accountIdOrSlug) {
+  const accounts = await listBrightsyAccounts();
+  const target = accounts.find((a) => a.id === accountIdOrSlug) ?? accounts.find((a) => a.slug === accountIdOrSlug);
+  if (!target) {
+    throw new Error(`Brightsy team not found: ${accountIdOrSlug}`);
+  }
+  const existing = readStore();
+  const already = existing.find((t) => t.id === target.id);
+  if (already) {
+    applyConnectedTeamToCli(already);
+    return listConnectedBrightsyTeams();
+  }
+  const { cfg: minted } = await performBrightsyAccountSwitch(target.id);
+  const team = {
+    id: target.id,
+    slug: target.slug,
+    name: target.name,
+    access_token: minted.access_token,
+    refresh_token: minted.refresh_token,
+    expires_at: minted.expires_at,
+    endpoint: minted.endpoint
+  };
+  writeStore([...existing, team]);
+  return listConnectedBrightsyTeams();
+}
+async function disconnectBrightsyTeam(accountIdOrSlug) {
+  const before = readStore();
+  const removed = before.find(
+    (t) => t.id === accountIdOrSlug || t.slug === accountIdOrSlug
+  );
+  const teams = before.filter(
+    (t) => t.id !== accountIdOrSlug && t.slug !== accountIdOrSlug
+  );
+  writeStore(teams);
+  if (removed) {
+    try {
+      const cfg = loadBrightsyConfig();
+      if (cfg.account_id === removed.id) {
+        if (teams[0]) {
+          applyConnectedTeamToCli(teams[0]);
+        }
+      }
+    } catch {
+    }
+  }
+  return listConnectedBrightsyTeams();
+}
+function brightsyMcpServerName(slug) {
+  const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
+  return `brightsy_${cleaned || "team"}`;
+}
+
+export {
+  loadBrightsyConfig,
+  listConnectedBrightsyTeams,
+  getConnectedBrightsyTeamsRaw,
+  applyConnectedTeamToCli,
+  ensureConnectedBrightsyTeamTokens,
+  ensureCliTeamTracked,
+  connectBrightsyTeam,
+  disconnectBrightsyTeam,
+  brightsyMcpServerName
+};

package/dist/chunk-EOYDCKQC.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+import {
+  normalizeThinkingEffort
+} from "./chunk-KGZBYWZ3.js";
+import {
+  threadFilePath,
+  threadLockPath,
+  threadsDir
+} from "./chunk-7MV3RXSC.js";
+
+// src/store/thread-store.ts
+import { randomUUID } from "crypto";
+import {
+  existsSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+  readdirSync
+} from "fs";
+import lockfile from "proper-lockfile";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function resolveThreadEffort(raw) {
+  const fromField = normalizeThinkingEffort(raw.effort);
+  if (fromField) return fromField;
+  if (raw.fast) return "low";
+  return "high";
+}
+function normalizeThread(raw) {
+  return {
+    ...raw,
+    model: raw.model ?? null,
+    effort: resolveThreadEffort(raw),
+    fast: Boolean(raw.fast),
+    planMode: Boolean(raw.planMode),
+    autonomy: raw.autonomy ?? "default",
+    lastError: raw.lastError ?? null,
+    agentPid: raw.agentPid ?? null,
+    attachments: Array.isArray(raw.attachments) ? raw.attachments : [],
+    prTitle: raw.prTitle ?? null,
+    userSetTitle: Boolean(raw.userSetTitle),
+    activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : [],
+    quotaResumeAt: raw.quotaResumeAt ?? null,
+    quotaContinuedFromId: raw.quotaContinuedFromId ?? null
+  };
+}
+function createEmptyThread(partial) {
+  const ts = nowIso();
+  return {
+    id: randomUUID(),
+    sessionId: partial.sessionId ?? null,
+    autonomy: partial.autonomy ?? "default",
+    model: partial.model ?? null,
+    effort: partial.effort ?? "high",
+    fast: partial.fast ?? false,
+    planMode: partial.planMode ?? false,
+    sourceIsFork: partial.sourceIsFork ?? false,
+    status: partial.status ?? "idle",
+    queue: partial.queue ?? [],
+    parentThreadId: partial.parentThreadId ?? null,
+    devPort: partial.devPort ?? null,
+    activeRuns: partial.activeRuns ?? [],
+    prUrl: partial.prUrl ?? null,
+    prTitle: partial.prTitle ?? null,
+    userSetTitle: partial.userSetTitle ?? false,
+    messages: partial.messages ?? [],
+    attachments: partial.attachments ?? [],
+    createdAt: ts,
+    updatedAt: ts,
+    title: partial.title,
+    sourceType: partial.sourceType,
+    sourceRef: partial.sourceRef,
+    branchName: partial.branchName,
+    worktreePath: partial.worktreePath,
+    repoPath: partial.repoPath,
+    agent: partial.agent,
+    lastError: null,
+    agentPid: null
+  };
+}
+async function withThreadLock(id, fn) {
+  const lockPath = threadLockPath(id);
+  writeFileSync(lockPath, "", { flag: "a" });
+  let release;
+  try {
+    release = await lockfile.lock(lockPath, {
+      retries: { retries: 10, minTimeout: 50, maxTimeout: 200 },
+      stale: 6e4
+    });
+    return await fn();
+  } finally {
+    if (release) await release();
+  }
+}
+function readThread(id) {
+  const path = threadFilePath(id);
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  return normalizeThread(JSON.parse(raw));
+}
+function writeThread(thread) {
+  const path = threadFilePath(idPath(thread.id));
+  const tmp = `${path}.${process.pid}.tmp`;
+  const next = { ...thread, updatedAt: nowIso() };
+  writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
+  renameSync(tmp, path);
+}
+function idPath(id) {
+  return id;
+}
+function listThreads(opts) {
+  const files = readdirSync(threadsDir()).filter((f) => f.endsWith(".json"));
+  const threads = files.map((f) => {
+    try {
+      return normalizeThread(
+        JSON.parse(readFileSync(threadFilePath(f.replace(/\.json$/, "")), "utf8"))
+      );
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  if (opts?.includeArchived) return threads;
+  return threads.filter((t) => t.status !== "archived");
+}
+function deleteThreadRecord(id) {
+  const path = threadFilePath(id);
+  if (existsSync(path)) unlinkSync(path);
+  const lock = threadLockPath(id);
+  if (existsSync(lock)) {
+    try {
+      unlinkSync(lock);
+    } catch {
+    }
+  }
+}
+function updateThread(id, patch) {
+  const current = readThread(id);
+  if (!current) throw new Error(`Thread not found: ${id}`);
+  const next = { ...current, ...patch, id: current.id, updatedAt: nowIso() };
+  writeThread(next);
+  return next;
+}
+function appendMessage(id, message) {
+  const current = readThread(id);
+  if (!current) throw new Error(`Thread not found: ${id}`);
+  return updateThread(id, { messages: [...current.messages, message] });
+}
+function setStatus(id, status, lastError) {
+  return updateThread(id, { status, lastError: lastError ?? null });
+}
+function findThreadByRef(ref) {
+  const all = listThreads({ includeArchived: true });
+  return all.find((t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref) ?? null;
+}
+
+export {
+  resolveThreadEffort,
+  normalizeThread,
+  createEmptyThread,
+  withThreadLock,
+  readThread,
+  writeThread,
+  listThreads,
+  deleteThreadRecord,
+  updateThread,
+  appendMessage,
+  setStatus,
+  findThreadByRef
+};

package/dist/chunk-GI7E5733.js

@@ -0,0 +1,30 @@
+// src/agents/orchestrator-capable.ts
+var ORCHESTRATOR_AGENT_KINDS = [
+  "claude",
+  "codex",
+  "opencode",
+  "cursor"
+];
+function isOrchestratorCapableAgent(agent) {
+  return Boolean(
+    agent && ORCHESTRATOR_AGENT_KINDS.includes(agent)
+  );
+}
+function assertOrchestratorCapableAgent(agent, context = "orchestration") {
+  if (!isOrchestratorCapableAgent(agent)) {
+    throw new Error(
+      `${agent} cannot run ${context} \u2014 it does not support Sideboard MCP. Use Claude, Cursor, Codex, or OpenCode.`
+    );
+  }
+  return agent;
+}
+function coerceOrchestratorAgent(agent, fallback = "claude") {
+  return isOrchestratorCapableAgent(agent) ? agent : fallback;
+}
+
+export {
+  ORCHESTRATOR_AGENT_KINDS,
+  isOrchestratorCapableAgent,
+  assertOrchestratorCapableAgent,
+  coerceOrchestratorAgent
+};