@sideboard-ai/core 0.1.9

package/dist/chunk-3WF3X46L.js

@@ -0,0 +1,373 @@
+import {
+  appDataDir
+} from "./chunk-M37RITA6.js";
+
+// src/store/app-settings.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HARNESS_ENV_KEYS = {
+  claude: "ANTHROPIC_API_KEY",
+  codex: "CODEX_API_KEY",
+  cursor: "CURSOR_API_KEY",
+  opencode: null,
+  brightsy: null
+};
+function appSettingsPath() {
+  return join(appDataDir(), "settings.json");
+}
+function claudeUserSettingsPath() {
+  return join(homedir(), ".claude", "settings.json");
+}
+function normalizeClaude(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.executablePath === "string") {
+    const path = source.executablePath.trim();
+    if (path) out.executablePath = path;
+  }
+  if (typeof source.chromeEnabled === "boolean") {
+    out.chromeEnabled = source.chromeEnabled;
+  }
+  return out;
+}
+var CLOUD_CONNECT_AGENTS = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "opencode",
+  "cursor"
+]);
+function normalizeBrightsy(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.cloudConnectEnabled === "boolean") {
+    out.cloudConnectEnabled = source.cloudConnectEnabled;
+  }
+  if (typeof source.cloudConnectAgent === "string" && CLOUD_CONNECT_AGENTS.has(source.cloudConnectAgent)) {
+    out.cloudConnectAgent = source.cloudConnectAgent;
+  }
+  return out;
+}
+var ISSUE_SOURCES = /* @__PURE__ */ new Set(["linear", "github"]);
+function normalizeIntegrations(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.linearApiKey === "string") {
+    const key = source.linearApiKey.trim();
+    if (key) out.linearApiKey = key;
+  }
+  if (typeof source.issueSource === "string" && ISSUE_SOURCES.has(source.issueSource)) {
+    out.issueSource = source.issueSource;
+  }
+  return out;
+}
+function normalizeAdvanced(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw;
+  const out = {};
+  if (typeof source.autoRenameBranch === "boolean") {
+    out.autoRenameBranch = source.autoRenameBranch;
+  }
+  if (typeof source.autoRunAfterSetup === "boolean") {
+    out.autoRunAfterSetup = source.autoRunAfterSetup;
+  }
+  if (typeof source.caffeinateWhileRunning === "boolean") {
+    out.caffeinateWhileRunning = source.caffeinateWhileRunning;
+  }
+  if (typeof source.caffeinateWhileCloudConnect === "boolean") {
+    out.caffeinateWhileCloudConnect = source.caffeinateWhileCloudConnect;
+  }
+  if (typeof source.deleteBranchOnPurge === "boolean") {
+    out.deleteBranchOnPurge = source.deleteBranchOnPurge;
+  }
+  if (typeof source.maxConcurrent === "number" && Number.isFinite(source.maxConcurrent)) {
+    out.maxConcurrent = Math.max(1, Math.min(32, Math.floor(source.maxConcurrent)));
+  }
+  if (typeof source.worktreeMaxCount === "number" && Number.isFinite(source.worktreeMaxCount)) {
+    out.worktreeMaxCount = Math.max(1, Math.min(500, Math.floor(source.worktreeMaxCount)));
+  }
+  if (typeof source.worktreeCleanupIntervalHours === "number" && Number.isFinite(source.worktreeCleanupIntervalHours)) {
+    out.worktreeCleanupIntervalHours = Math.max(
+      1,
+      Math.min(168, Math.floor(source.worktreeCleanupIntervalHours))
+    );
+  }
+  if (typeof source.worktreeLastCleanupAt === "string" && source.worktreeLastCleanupAt.trim()) {
+    out.worktreeLastCleanupAt = source.worktreeLastCleanupAt.trim();
+  }
+  if (typeof source.autoCleanupOrphans === "boolean") {
+    out.autoCleanupOrphans = source.autoCleanupOrphans;
+  }
+  return out;
+}
+function normalizeSettings(raw) {
+  const env = {};
+  let claude = {};
+  let brightsy = {};
+  let integrations = {};
+  let advanced = {};
+  if (raw && typeof raw === "object") {
+    if ("environment" in raw) {
+      const source = raw.environment;
+      if (source && typeof source === "object") {
+        for (const [k, v] of Object.entries(source)) {
+          const key = k.trim();
+          if (!key) continue;
+          if (typeof v === "string" && v.length > 0) env[key] = v;
+        }
+      }
+    }
+    if ("claude" in raw) {
+      claude = normalizeClaude(raw.claude);
+    }
+    if ("brightsy" in raw) {
+      brightsy = normalizeBrightsy(raw.brightsy);
+    }
+    if ("integrations" in raw) {
+      integrations = normalizeIntegrations(
+        raw.integrations
+      );
+    }
+    if ("advanced" in raw) {
+      advanced = normalizeAdvanced(raw.advanced);
+    }
+  }
+  return { environment: env, claude, brightsy, integrations, advanced };
+}
+var EMPTY_SETTINGS = {
+  environment: {},
+  claude: {},
+  brightsy: {},
+  integrations: {},
+  advanced: {}
+};
+function loadAppSettings() {
+  const path = appSettingsPath();
+  if (!existsSync(path)) {
+    return { ...EMPTY_SETTINGS };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return normalizeSettings(parsed);
+  } catch {
+    return { ...EMPTY_SETTINGS };
+  }
+}
+function saveAppSettings(settings) {
+  const normalized = normalizeSettings(settings);
+  mkdirSync(appDataDir(), { recursive: true });
+  writeFileSync(appSettingsPath(), `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+  return normalized;
+}
+function updateAppEnvironment(patch) {
+  const current = loadAppSettings();
+  const environment = { ...current.environment };
+  for (const [key, value] of Object.entries(patch)) {
+    const k = key.trim();
+    if (!k) continue;
+    if (value == null || value === "") {
+      delete environment[k];
+    } else {
+      environment[k] = value;
+    }
+  }
+  return saveAppSettings({ ...current, environment });
+}
+function updateClaudeSettings(patch) {
+  const current = loadAppSettings();
+  const claude = { ...current.claude };
+  if ("executablePath" in patch) {
+    if (patch.executablePath == null || patch.executablePath.trim() === "") {
+      delete claude.executablePath;
+    } else {
+      claude.executablePath = patch.executablePath.trim();
+    }
+  }
+  if (typeof patch.chromeEnabled === "boolean") {
+    claude.chromeEnabled = patch.chromeEnabled;
+  }
+  return saveAppSettings({ ...current, claude });
+}
+function updateBrightsySettings(patch) {
+  const current = loadAppSettings();
+  const brightsy = { ...current.brightsy };
+  if (typeof patch.cloudConnectEnabled === "boolean") {
+    brightsy.cloudConnectEnabled = patch.cloudConnectEnabled;
+  }
+  if ("cloudConnectAgent" in patch) {
+    if (patch.cloudConnectAgent == null) {
+      delete brightsy.cloudConnectAgent;
+    } else if (CLOUD_CONNECT_AGENTS.has(patch.cloudConnectAgent)) {
+      brightsy.cloudConnectAgent = patch.cloudConnectAgent;
+    }
+  }
+  return saveAppSettings({ ...current, brightsy });
+}
+function updateIntegrationsSettings(patch) {
+  const current = loadAppSettings();
+  const integrations = { ...current.integrations };
+  if ("linearApiKey" in patch) {
+    if (patch.linearApiKey == null || patch.linearApiKey.trim() === "") {
+      delete integrations.linearApiKey;
+    } else {
+      integrations.linearApiKey = patch.linearApiKey.trim();
+    }
+  }
+  if ("issueSource" in patch) {
+    if (patch.issueSource == null) {
+      delete integrations.issueSource;
+    } else if (ISSUE_SOURCES.has(patch.issueSource)) {
+      integrations.issueSource = patch.issueSource;
+    }
+  }
+  return saveAppSettings({ ...current, integrations });
+}
+function isLinearConnected(settings = loadAppSettings()) {
+  return Boolean(settings.integrations.linearApiKey?.trim());
+}
+function getIssueSource(settings = loadAppSettings()) {
+  return settings.integrations.issueSource ?? "github";
+}
+function resolveEffectiveIssueSource(settings = loadAppSettings()) {
+  const preferred = getIssueSource(settings);
+  if (preferred === "linear" && !isLinearConnected(settings)) return "github";
+  return preferred;
+}
+function getLinearApiKey(settings = loadAppSettings()) {
+  const key = settings.integrations.linearApiKey?.trim();
+  return key || null;
+}
+function brightsyCloudConnectEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.brightsy.cloudConnectEnabled);
+}
+function brightsyCloudConnectAgent(settings = loadAppSettings()) {
+  return settings.brightsy.cloudConnectAgent ?? "claude";
+}
+function updateAdvancedSettings(patch) {
+  const current = loadAppSettings();
+  const advanced = { ...current.advanced };
+  if (typeof patch.autoRenameBranch === "boolean") {
+    advanced.autoRenameBranch = patch.autoRenameBranch;
+  }
+  if (typeof patch.autoRunAfterSetup === "boolean") {
+    advanced.autoRunAfterSetup = patch.autoRunAfterSetup;
+  }
+  if (typeof patch.caffeinateWhileRunning === "boolean") {
+    advanced.caffeinateWhileRunning = patch.caffeinateWhileRunning;
+  }
+  if (typeof patch.caffeinateWhileCloudConnect === "boolean") {
+    advanced.caffeinateWhileCloudConnect = patch.caffeinateWhileCloudConnect;
+  }
+  if (typeof patch.deleteBranchOnPurge === "boolean") {
+    advanced.deleteBranchOnPurge = patch.deleteBranchOnPurge;
+  }
+  if (typeof patch.maxConcurrent === "number" && Number.isFinite(patch.maxConcurrent)) {
+    advanced.maxConcurrent = Math.max(1, Math.min(32, Math.floor(patch.maxConcurrent)));
+  }
+  if (typeof patch.worktreeMaxCount === "number" && Number.isFinite(patch.worktreeMaxCount)) {
+    advanced.worktreeMaxCount = Math.max(1, Math.min(500, Math.floor(patch.worktreeMaxCount)));
+  }
+  if (typeof patch.worktreeCleanupIntervalHours === "number" && Number.isFinite(patch.worktreeCleanupIntervalHours)) {
+    advanced.worktreeCleanupIntervalHours = Math.max(
+      1,
+      Math.min(168, Math.floor(patch.worktreeCleanupIntervalHours))
+    );
+  }
+  if (typeof patch.worktreeLastCleanupAt === "string") {
+    advanced.worktreeLastCleanupAt = patch.worktreeLastCleanupAt;
+  }
+  if (typeof patch.autoCleanupOrphans === "boolean") {
+    advanced.autoCleanupOrphans = patch.autoCleanupOrphans;
+  }
+  return saveAppSettings({ ...current, advanced });
+}
+function autoRenameBranchEnabled(settings = loadAppSettings()) {
+  return settings.advanced.autoRenameBranch !== false;
+}
+function autoRunAfterSetupEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.autoRunAfterSetup);
+}
+function caffeinateWhileRunningEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.caffeinateWhileRunning);
+}
+function caffeinateWhileCloudConnectEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.caffeinateWhileCloudConnect);
+}
+function deleteBranchOnPurgeEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.deleteBranchOnPurge);
+}
+function autoCleanupOrphansEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.autoCleanupOrphans);
+}
+function maxConcurrentAgents(settings = loadAppSettings()) {
+  const n = settings.advanced.maxConcurrent;
+  if (typeof n === "number" && Number.isFinite(n)) {
+    return Math.max(1, Math.min(32, Math.floor(n)));
+  }
+  return 3;
+}
+function resolveClaudeExecutable(settings = loadAppSettings()) {
+  const override = settings.claude.executablePath?.trim();
+  return override || "claude";
+}
+function claudeChromeEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.claude.chromeEnabled);
+}
+function applyAppEnvironment(target = process.env, settings = loadAppSettings()) {
+  for (const [key, value] of Object.entries(settings.environment)) {
+    if (!key || value == null || value === "") continue;
+    if (target[key] == null || target[key] === "") {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+function childEnvWithAppSettings(extra) {
+  const settings = loadAppSettings();
+  const env = { ...process.env };
+  applyAppEnvironment(env, settings);
+  if (extra) {
+    for (const [k, v] of Object.entries(extra)) {
+      if (v != null) env[k] = v;
+    }
+  }
+  return env;
+}
+function harnessEnvKey(harness) {
+  return HARNESS_ENV_KEYS[harness];
+}
+
+export {
+  HARNESS_ENV_KEYS,
+  appSettingsPath,
+  claudeUserSettingsPath,
+  loadAppSettings,
+  saveAppSettings,
+  updateAppEnvironment,
+  updateClaudeSettings,
+  updateBrightsySettings,
+  updateIntegrationsSettings,
+  isLinearConnected,
+  getIssueSource,
+  resolveEffectiveIssueSource,
+  getLinearApiKey,
+  brightsyCloudConnectEnabled,
+  brightsyCloudConnectAgent,
+  updateAdvancedSettings,
+  autoRenameBranchEnabled,
+  autoRunAfterSetupEnabled,
+  caffeinateWhileRunningEnabled,
+  caffeinateWhileCloudConnectEnabled,
+  deleteBranchOnPurgeEnabled,
+  autoCleanupOrphansEnabled,
+  maxConcurrentAgents,
+  resolveClaudeExecutable,
+  claudeChromeEnabled,
+  applyAppEnvironment,
+  childEnvWithAppSettings,
+  harnessEnvKey
+};

package/dist/chunk-AJ6ROGD7.js

@@ -0,0 +1,74 @@
+// src/git/run.ts
+import { execa } from "execa";
+
+// src/agents/path.ts
+import { homedir } from "os";
+import { delimiter } from "path";
+var EXTRA_BIN_DIRS = [
+  ".local/bin",
+  ".cargo/bin",
+  ".nvm/current/bin",
+  ".asdf/shims",
+  // pnpm / npm global bins (where `@brightsy/cli` typically lands)
+  "Library/pnpm",
+  ".pnpm"
+];
+function ensureAgentPath(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || homedir();
+  const current = env.PATH ?? "";
+  const parts = current.split(delimiter).filter(Boolean);
+  const seen = new Set(parts);
+  const extras = [
+    ...EXTRA_BIN_DIRS.map((rel) => `${home}/${rel}`),
+    "/opt/homebrew/bin",
+    "/usr/local/bin"
+  ];
+  for (const dir of extras.reverse()) {
+    if (!dir || seen.has(dir)) continue;
+    parts.unshift(dir);
+    seen.add(dir);
+  }
+  const next = parts.join(delimiter);
+  env.PATH = next;
+  return next;
+}
+
+// src/git/run.ts
+async function run(file, args, opts) {
+  ensureAgentPath();
+  try {
+    const result = await execa(file, args, {
+      cwd: opts?.cwd,
+      env: { ...process.env, ...opts?.env },
+      reject: opts?.reject ?? true
+    });
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.exitCode ?? 0
+    };
+  } catch (err) {
+    const e = err;
+    if (opts?.reject === false) {
+      return {
+        stdout: String(e.stdout ?? ""),
+        stderr: String(e.stderr ?? ""),
+        exitCode: e.exitCode ?? 1
+      };
+    }
+    throw err;
+  }
+}
+async function git(args, cwd, opts) {
+  return run("git", args, { cwd, reject: opts?.reject });
+}
+async function gh(args, cwd, opts) {
+  return run("gh", args, { cwd, reject: opts?.reject });
+}
+
+export {
+  ensureAgentPath,
+  run,
+  git,
+  gh
+};