@sideboard-ai/core 0.1.9

package/dist/chunk-2M4OHXYX.js

@@ -0,0 +1,198 @@
+import {
+  ensureGlobalCoordinatorCwd
+} from "./chunk-2R5VV4BA.js";
+import {
+  allocateTeamName,
+  takenSlugsFromThread,
+  teamSlugFromName
+} from "./chunk-LL7DTZ5B.js";
+import {
+  createEmptyThread,
+  listThreads,
+  updateThread,
+  writeThread
+} from "./chunk-HYRHI3QU.js";
+import {
+  globalAgentCwd
+} from "./chunk-M37RITA6.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(" ");
+function parseForceStopMessage(message) {
+  const normalized = message.replace(/\r\n/g, "\n");
+  const nl = normalized.indexOf("\n");
+  const firstLine = (nl === -1 ? normalized : normalized.slice(0, nl)).trim();
+  const remainder = (nl === -1 ? "" : normalized.slice(nl + 1)).trim();
+  const forceStop = firstLine.toLowerCase() === SIDEBOARD_FORCE_STOP.toLowerCase();
+  return { forceStop, remainder: forceStop ? remainder : message };
+}
+
+// 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 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: opts.agent,
+    autonomy: opts.autonomy ?? "default",
+    model: opts.model ?? null,
+    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 {
+  CLOUD_ORCHESTRATOR_GOAL,
+  SIDEBOARD_FORCE_STOP,
+  CLOUD_COORDINATOR_BUSY_REPLY,
+  CLOUD_COORDINATOR_STOPPED_REPLY,
+  CLOUD_COORDINATOR_TIMEOUT_REPLY,
+  parseForceStopMessage,
+  GLOBAL_WORKSPACE_ID,
+  isGlobalThread,
+  isGlobalRepoPath,
+  isOrchestratorThread,
+  orchestratorSessionPoisonedByBuiltins,
+  isCloudCoordinatorThread,
+  orchestrationTitleNeedsSoccerNickname,
+  takenTeamSlugsForOrchestration,
+  createGlobalChat,
+  healOrchestrationSoccerTitles,
+  listGlobalThreads,
+  ensureCloudCoordinator
+};

package/dist/chunk-2R5VV4BA.js

@@ -0,0 +1,143 @@
+import {
+  resolveGithubRepoSlug
+} from "./chunk-LL7DTZ5B.js";
+import {
+  globalAgentCwd,
+  sideboardReposDir
+} from "./chunk-M37RITA6.js";
+
+// src/orchestrator/coordinator-prompt.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+function formatWorkspaceInventory(workspaces) {
+  if (workspaces.length === 0) return "(no registered workspaces)";
+  return workspaces.map((w) => {
+    const slug = w.githubSlug?.trim() ? `  github:${w.githubSlug.trim()}` : "";
+    return `- ${w.name}: ${w.path}${slug}`;
+  }).join("\n");
+}
+async function enrichWorkspacesWithGithub(workspaces) {
+  return Promise.all(
+    workspaces.map(async (w) => {
+      const githubSlug = await resolveGithubRepoSlug(w.path).catch(() => null);
+      return { ...w, githubSlug };
+    })
+  );
+}
+function coordinatorGreenfieldPlaybook(reposDir) {
+  return [
+    "Greenfield (new app / new GitHub repo) \u2014 use Bash + MCP:",
+    `- Create or clone under \`${reposDir}/<name>\` (never inside this synthetic home cwd).`,
+    "- Examples:",
+    `  - Clone: \`git clone <url> ${reposDir}/<name>\``,
+    `  - New GitHub repo: \`gh repo create <owner>/<name> --private --clone -- ${reposDir}/<name>\` (or mkdir + git init + gh repo create + remote add + push)`,
+    "- Then: add_workspace with that absolute path \u2192 create_thread (repoPath + parentThreadId) \u2192 send_to_thread (build) \u2192 wait_for_turn \u2192 send_to_thread (`gh pr create --draft`) or create_draft_pr.",
+    "- Do coding work in the child worktree thread, not by editing files in this home cwd."
+  ].join("\n");
+}
+var COORDINATOR_TOOL_PLAYBOOK = [
+  "Role: you oversee Sideboard worktree agents across registered repos. You do not live inside one of those worktrees.",
+  "Sideboard MCP (fleet control \u2014 prefer these for status and orchestration):",
+  "Discover:",
+  "- list_workspaces \u2014 registered repos (path + github slug when known)",
+  "- list_branches / list_prs / list_issues \u2014 pass repoPath from list_workspaces (issues: Linear API or GitHub Issues)",
+  "- list_threads / get_thread \u2014 fleet status (what is going on)",
+  "Workspaces:",
+  "- add_workspace / remove_workspace \u2014 register or unregister a git repo",
+  "Worktree threads (chats):",
+  "- create_thread \u2014 create a worktree + chat from branch | pr | ticket; pass repoPath + parentThreadId",
+  "- send_to_thread \u2014 queue a prompt (start/continue a chat turn); pass force_stop: true to interrupt mid-turn / clear stale queued prompts before replacing with a new request",
+  "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply",
+  "- stop_thread \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
+  "- archive_thread / restore_thread \u2014 archive (tears down worktree when last tab) or restore",
+  "Setup / run:",
+  "- run_setup \u2014 re-run worktree setup",
+  "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
+  "Inspect / PRs:",
+  "- get_diff \u2014 compact diff summary",
+  "- preview_land \u2014 preview push+PR (does not push)",
+  "- Prefer asking the worktree agent via send_to_thread to open a draft PR (`gh pr create --draft`) so it owns title/body from the diff.",
+  "- create_draft_pr \u2014 fallback: commit (if dirty), push, open/update a DRAFT PR from the orchestrator",
+  "Human-only (do not attempt): ready-for-review confirm_land, purge_thread.",
+  "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
+  "Bash / Read / etc: allowed for (1) inspecting target worktrees / registered repo paths from MCP, and (2) greenfield setup under ~/sideboard/repos (git clone, gh repo create, git init+remote). Never git init/clone *inside* this synthetic home cwd \u2014 emptiness here is expected, not a bug."
+].join("\n");
+function coordinatorTurnReminder(opts) {
+  const goal = opts.goal?.trim();
+  return [
+    "Sideboard Orchestration (mandatory):",
+    "- You oversee Sideboard worktree agents. You are not yourself checked out in a project worktree.",
+    "- This cwd is a synthetic empty home (not a git repo). Emptiness here is expected \u2014 it is not a problem to fix.",
+    "- Registered workspaces / child threads are the fleet you manage via Sideboard MCP.",
+    `- Parent thread id (pass as parentThreadId when creating children): ${opts.parentId}`,
+    goal ? `- Goal / title: ${goal}` : null,
+    `- For "what's going on": call list_threads (and list_workspaces if needed). Summarize fleet status \u2014 do not ls/git-status this synthetic home.`,
+    "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn.",
+    "- New repo: Bash (clone or gh repo create under ~/sideboard/repos/<name>) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR.",
+    "- When naming threads for the user, link them as `[Title](sideboard://thread/<id>)`."
+  ].filter(Boolean).join("\n");
+}
+function ensureGlobalCoordinatorCwd() {
+  const dir = globalAgentCwd();
+  mkdirSync(dir, { recursive: true });
+  const reposDir = sideboardReposDir();
+  const body = [
+    "# Sideboard Orchestration",
+    "",
+    "You are the Sideboard **Orchestration** agent \u2014 you oversee worktree agents in the Sideboard app.",
+    "You are **not** connected to a single project workspace. This directory is a synthetic empty cwd (not a git worktree).",
+    "It being empty / not a git repo is **normal**. Do not initialize git here or ask the user to point you at a repo for *your* checkout.",
+    "Repos from `list_workspaces` and threads from `list_threads` are the fleet you orchestrate.",
+    'For status questions ("what\'s going on?"), use `list_threads` / `list_workspaces` \u2014 never diagnose this synthetic home as a broken worktree.',
+    "Bash is fine for inspecting **child worktree** / registered-repo paths, and for greenfield repo setup under the Sideboard repos directory \u2014 not for treating this home as the project.",
+    "",
+    COORDINATOR_TOOL_PLAYBOOK,
+    "",
+    coordinatorGreenfieldPlaybook(reposDir),
+    "",
+    "When creating threads, pass `repoPath` from `list_workspaces` (or the path you just registered) and `parentThreadId` for children.",
+    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn.",
+    "Typical flow (new app): Bash create/clone under repos dir \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 draft PR.",
+    "Prefer asking worktree agents to open draft PRs; use create_draft_pr as fallback."
+  ].join("\n");
+  writeFileSync(join(dir, "CLAUDE.md"), `${body}
+`, "utf8");
+  writeFileSync(join(dir, "AGENTS.md"), `${body}
+`, "utf8");
+  return dir;
+}
+function coordinatorSystemPrompt(opts) {
+  const audience = opts.audience ?? "cloud";
+  const reposDir = sideboardReposDir();
+  const intro = audience === "cloud" ? [
+    "You are a Sideboard coordinator responding to a request from a Brightsy cloud agent (Slack, Discord, Teams, or other chat).",
+    "Your reply will be sent back to that cloud agent \u2014 be concise and actionable."
+  ] : [
+    "You are a Sideboard orchestration agent: you oversee worktree agents across registered workspaces in the Sideboard app.",
+    "Stay concise and actionable; prefer Sideboard MCP for fleet status; use Bash for greenfield repo setup and inspecting target worktree paths."
+  ];
+  return [
+    ...intro,
+    "You operate across ALL registered workspaces below.",
+    "You have no project git home \u2014 this process cwd is synthetic and empty on purpose.",
+    COORDINATOR_TOOL_PLAYBOOK,
+    coordinatorGreenfieldPlaybook(reposDir),
+    "When creating threads, pass the correct repoPath for the target workspace and parentThreadId for children.",
+    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 send_to_thread (ask for `gh pr create --draft`) \u2192 wait_for_turn. Use create_draft_pr only if the child cannot open the PR.",
+    "Typical flow (new app): Bash under repos dir (clone or gh repo create) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR.",
+    `Goal: ${opts.goal}`,
+    `Parent thread id (pass as parentThreadId when creating children): ${opts.parentId}`,
+    "Registered workspaces:",
+    formatWorkspaceInventory(opts.workspaces)
+  ].join("\n");
+}
+
+export {
+  formatWorkspaceInventory,
+  enrichWorkspacesWithGithub,
+  coordinatorGreenfieldPlaybook,
+  COORDINATOR_TOOL_PLAYBOOK,
+  coordinatorTurnReminder,
+  ensureGlobalCoordinatorCwd,
+  coordinatorSystemPrompt
+};

package/dist/chunk-3DKGI32Q.js

@@ -0,0 +1,92 @@
+// src/agents/cursor-events.ts
+function usageFromCursor(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.inputTokens ?? 0);
+  const outputTokens = Number(usage.outputTokens ?? 0);
+  if (!inputTokens && !outputTokens) return null;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usage.cacheReadTokens ? Number(usage.cacheReadTokens) : void 0,
+    cacheWriteTokens: usage.cacheWriteTokens ? Number(usage.cacheWriteTokens) : void 0
+  };
+}
+function cursorSdkMessageToEvents(msg) {
+  if (!msg?.type) return [];
+  if (msg.type === "system" && msg.agent_id) {
+    return [{ type: "session_id", data: msg.agent_id }];
+  }
+  if (msg.type === "thinking" && msg.text) {
+    return [{ type: "thinking", data: msg.text }];
+  }
+  if (msg.type === "assistant" && msg.message?.content?.length) {
+    const out = [];
+    for (const block of msg.message.content) {
+      if (block?.type === "text" && block.text) {
+        out.push({ type: "stdout", data: block.text });
+      } else if (block?.type === "tool_use" && block.id && block.name) {
+        out.push({
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input && typeof block.input === "object" ? block.input : void 0
+        });
+      }
+    }
+    return out;
+  }
+  if (msg.type === "tool_call" && msg.call_id && msg.name) {
+    if (msg.status === "running") {
+      return [
+        {
+          type: "tool_use",
+          id: msg.call_id,
+          name: msg.name,
+          input: msg.args && typeof msg.args === "object" ? msg.args : void 0
+        }
+      ];
+    }
+    if (msg.status === "completed" || msg.status === "error") {
+      const content = typeof msg.result === "string" ? msg.result : msg.result != null ? JSON.stringify(msg.result) : void 0;
+      return [
+        {
+          type: "tool_result",
+          id: msg.call_id,
+          content,
+          isError: msg.status === "error"
+        }
+      ];
+    }
+  }
+  if (msg.type === "usage") {
+    const usage = usageFromCursor(msg.usage);
+    if (usage) return [{ type: "usage", data: usage }];
+  }
+  if (msg.type === "status" && msg.status === "ERROR") {
+    const detail = msg.message || msg.text || "Cursor run entered ERROR status";
+    return [{ type: "stderr", data: detail }];
+  }
+  return [];
+}
+function parseCursorRunnerLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (Array.isArray(obj)) return obj;
+    if (obj && typeof obj === "object" && "events" in obj && Array.isArray(obj.events)) {
+      return obj.events;
+    }
+    if (obj && typeof obj === "object" && "type" in obj) {
+      return obj;
+    }
+    return null;
+  } catch {
+    return { type: "stdout", data: line };
+  }
+}
+
+export {
+  cursorSdkMessageToEvents,
+  parseCursorRunnerLine
+};