@sideboard-ai/core 0.1.9

package/dist/chunk-HYRHI3QU.js

@@ -0,0 +1,154 @@
+import {
+  threadFilePath,
+  threadLockPath,
+  threadsDir
+} from "./chunk-M37RITA6.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 normalizeThread(raw) {
+  return {
+    ...raw,
+    model: raw.model ?? null,
+    fast: Boolean(raw.fast),
+    planMode: Boolean(raw.planMode),
+    autonomy: raw.autonomy ?? "default",
+    lastError: raw.lastError ?? null,
+    attachments: Array.isArray(raw.attachments) ? raw.attachments : [],
+    prTitle: raw.prTitle ?? null,
+    userSetTitle: Boolean(raw.userSetTitle),
+    activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : []
+  };
+}
+function createEmptyThread(partial) {
+  const ts = nowIso();
+  return {
+    id: randomUUID(),
+    sessionId: partial.sessionId ?? null,
+    autonomy: partial.autonomy ?? "default",
+    model: partial.model ?? null,
+    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
+  };
+}
+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 {
+  normalizeThread,
+  createEmptyThread,
+  withThreadLock,
+  readThread,
+  writeThread,
+  listThreads,
+  deleteThreadRecord,
+  updateThread,
+  appendMessage,
+  setStatus,
+  findThreadByRef
+};

package/dist/chunk-ILQK4P5R.js

@@ -0,0 +1,311 @@
+import {
+  appDataDir
+} from "./chunk-M37RITA6.js";
+import {
+  run
+} from "./chunk-AJ6ROGD7.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 loadConnectedTeams() {
+  const { listConnectedBrightsyTeams: listConnectedBrightsyTeams2 } = await import("./connected-teams-GF52Q7LB.js");
+  return listConnectedBrightsyTeams2();
+}
+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 getBrightsySession() {
+  try {
+    loadBrightsyConfig();
+    const data = await runBrightsyTeamsJson([]);
+    const accounts = Array.isArray(data.teams) ? data.teams : [];
+    const active = data.active ?? accounts.find((a) => a.active) ?? null;
+    const { ensureCliTeamTracked: ensureCliTeamTracked2 } = await import("./connected-teams-GF52Q7LB.js");
+    const connectedTeams = ensureCliTeamTracked2(
+      active ? { id: active.id, slug: active.slug, name: active.name } : void 0
+    );
+    return {
+      connected: true,
+      endpoint: (data.endpoint || "https://brightsy.ai").replace(/\/$/, ""),
+      accountId: active?.id ?? null,
+      accountSlug: active?.slug ?? null,
+      accounts,
+      connectedTeams
+    };
+  } catch (err) {
+    return {
+      connected: false,
+      endpoint: "https://brightsy.ai",
+      accountId: null,
+      accountSlug: null,
+      accounts: [],
+      connectedTeams: await loadConnectedTeams(),
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+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 };
+}
+async function switchBrightsyAccount(accountIdOrSlug) {
+  const { connectBrightsyTeam: connectBrightsyTeam2 } = await import("./connected-teams-GF52Q7LB.js");
+  await connectBrightsyTeam2(accountIdOrSlug);
+  return getBrightsySession();
+}
+
+// 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 {
+  brightsyConfigPath,
+  loadBrightsyConfig,
+  saveBrightsyConfig,
+  listBrightsyAccounts,
+  getBrightsySession,
+  switchBrightsyAccount,
+  listConnectedBrightsyTeams,
+  getConnectedBrightsyTeamsRaw,
+  applyConnectedTeamToCli,
+  ensureConnectedBrightsyTeamTokens,
+  ensureCliTeamTracked,
+  connectBrightsyTeam,
+  disconnectBrightsyTeam,
+  brightsyMcpServerName
+};