background-agents 0.1.1 → 1.0.0

package/app/dist/preload.cjs

@@ -0,0 +1,70 @@
+"use strict";
+
+// src/preload.ts
+var import_electron = require("electron");
+import_electron.contextBridge.exposeInMainWorld("electron", {
+  // Platform info
+  platform: process.platform,
+  // Notifications
+  showNotification: (options) => {
+    import_electron.ipcRenderer.send("show-notification", options);
+  },
+  // Badge count
+  updateBadge: (count) => {
+    import_electron.ipcRenderer.send("update-badge", count);
+  },
+  // Window control
+  toggleWindow: () => {
+    import_electron.ipcRenderer.send("toggle-window");
+  },
+  // Auth token (secure storage)
+  getAuthToken: () => import_electron.ipcRenderer.invoke("get-auth-token"),
+  setAuthToken: (token) => import_electron.ipcRenderer.invoke("set-auth-token", token),
+  // External links
+  openExternal: (url) => {
+    import_electron.ipcRenderer.send("open-external", url);
+  },
+  // Local repo sync (Backgrounder folder)
+  getGitSyncSettings: () => import_electron.ipcRenderer.invoke("git-sync:get-settings"),
+  setGitSyncSettings: (settings) => import_electron.ipcRenderer.invoke("git-sync:set-settings", settings),
+  pickSyncDirectory: () => import_electron.ipcRenderer.invoke("git-sync:pick-directory"),
+  getRepoSyncState: (repo) => import_electron.ipcRenderer.invoke("git-sync:get-repo-state", repo),
+  openRepoFolder: (data) => import_electron.ipcRenderer.invoke("git-sync:open-repo-folder", data),
+  setActiveChat: (data) => import_electron.ipcRenderer.invoke("git-sync:set-active-chat", data),
+  syncBranch: (data) => import_electron.ipcRenderer.invoke("git-sync:sync-branch", data),
+  // License auto-detection
+  getClaudeLicenseAutoDetect: () => import_electron.ipcRenderer.invoke("get-claude-license-auto-detect"),
+  getLicenseDetectSettings: () => import_electron.ipcRenderer.invoke("get-license-detect-settings"),
+  setLicenseDetectSettings: (settings) => import_electron.ipcRenderer.invoke("set-license-detect-settings", settings),
+  // Event listeners
+  onDeepLink: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("deep-link", handler);
+    return () => import_electron.ipcRenderer.removeListener("deep-link", handler);
+  },
+  onNavigateToChat: (callback) => {
+    const handler = (_event, chatId) => callback(chatId);
+    import_electron.ipcRenderer.on("navigate-to-chat", handler);
+    return () => import_electron.ipcRenderer.removeListener("navigate-to-chat", handler);
+  },
+  onGitPushed: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("git-pushed", handler);
+    return () => import_electron.ipcRenderer.removeListener("git-pushed", handler);
+  },
+  onShortcut: (callback) => {
+    const handler = (_event, action) => callback(action);
+    import_electron.ipcRenderer.on("shortcut", handler);
+    return () => import_electron.ipcRenderer.removeListener("shortcut", handler);
+  },
+  onSyncStatus: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("sync-status", handler);
+    return () => import_electron.ipcRenderer.removeListener("sync-status", handler);
+  },
+  onSyncError: (callback) => {
+    const handler = (_event, data) => callback(data);
+    import_electron.ipcRenderer.on("sync-error", handler);
+    return () => import_electron.ipcRenderer.removeListener("sync-error", handler);
+  }
+});

package/bin/background-agents.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+"use strict";
+
+// Background Agents desktop launcher.
+//
+// `npx background-agents` resolves the latest published version of this package,
+// then this script spawns the bundled Electron app (packages/launcher/app),
+// pointed at the production backend by default. The heavy Electron runtime is a
+// normal npm dependency, so npm/npx downloads it (with its own progress bar) on
+// first run and caches it for subsequent launches.
+
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const { spawn } = require("child_process");
+
+const { colors, symbols, Spinner, line, showCursor } = require("../lib/ui");
+const pkg = require("../package.json");
+
+const PROD_URL = "https://backgrounder.dev";
+const DEV_URL = "http://localhost:4000";
+const APP_ENTRY = path.join(__dirname, "..", "app", "dist", "main.js");
+const READY_MARKER = "background-agents:ready";
+
+function parseArgs(argv) {
+  const opts = {
+    url: null,
+    dev: false,
+    verbose: false,
+    help: false,
+    version: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") opts.help = true;
+    else if (arg === "-v" || arg === "--version") opts.version = true;
+    else if (arg === "--dev") opts.dev = true;
+    else if (arg === "--verbose") opts.verbose = true;
+    else if (arg === "--url") opts.url = argv[++i];
+    else if (arg.startsWith("--url=")) opts.url = arg.slice("--url=".length);
+  }
+  return opts;
+}
+
+function printBanner() {
+  line();
+  line(
+    `  ${colors.bold(colors.magenta("Background Agents"))} ${colors.dim(
+      "desktop launcher v" + pkg.version
+    )}`
+  );
+  line(`  ${colors.dim("https://backgrounder.dev")}`);
+  line();
+}
+
+function printHelp() {
+  printBanner();
+  line(`  ${colors.bold("Usage")}`);
+  line(`    npx ${pkg.name} [options]`);
+  line();
+  line(`  ${colors.bold("Options")}`);
+  line(`    --url <url>     Backend URL to load (default: ${PROD_URL})`);
+  line(`    --dev          Use the local dev server (${DEV_URL})`);
+  line(`    --verbose      Stream the desktop app's logs to this terminal`);
+  line(`    -v, --version  Print the launcher version`);
+  line(`    -h, --help     Show this help`);
+  line();
+  line(`  ${colors.bold("Environment")}`);
+  line(`    BACKGROUND_AGENTS_URL   Same as --url (the --url flag wins)`);
+  line();
+  line(
+    `  ${colors.dim(
+      "Tip: run `npx " + pkg.name + "@latest` to always get the newest version."
+    )}`
+  );
+  line();
+}
+
+// The `electron` package returns the absolute path to its binary when required
+// from a normal Node process (i.e. not from inside Electron itself).
+function resolveElectron() {
+  let electronPath;
+  try {
+    electronPath = require("electron");
+  } catch (_err) {
+    return {
+      error:
+        "Electron runtime is not installed. Reinstall with: npx " +
+        pkg.name +
+        "@latest",
+    };
+  }
+  if (typeof electronPath !== "string" || !fs.existsSync(electronPath)) {
+    return {
+      error:
+        "The Electron binary is missing or its download was skipped.\n" +
+        "  Reinstall without ELECTRON_SKIP_BINARY_DOWNLOAD set, e.g.: npx background-agents@latest",
+    };
+  }
+  return { electronPath };
+}
+
+// Non-blocking check of the npm registry for a newer launcher version.
+function checkLatestVersion(timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${encodeURIComponent(pkg.name)}/latest`,
+      { headers: { accept: "application/json" }, timeout: timeoutMs },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data).version || null);
+          } catch (_err) {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+function semverGt(a, b) {
+  const pa = String(a).split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return true;
+    if (pa[i] < pb[i]) return false;
+  }
+  return false;
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    printHelp();
+    return;
+  }
+  if (opts.version) {
+    line(pkg.version);
+    return;
+  }
+
+  printBanner();
+
+  if (!fs.existsSync(APP_ENTRY)) {
+    line(
+      `  ${symbols.error} ${colors.red(
+        "App bundle is missing — this package was built incorrectly."
+      )}`
+    );
+    line(`  ${colors.dim("Expected: " + APP_ENTRY)}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const { electronPath, error } = resolveElectron();
+  if (error) {
+    line(`  ${symbols.error} ${colors.red(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const backendUrl =
+    opts.url ||
+    (opts.dev ? DEV_URL : process.env.BACKGROUND_AGENTS_URL || PROD_URL);
+
+  const latestPromise = checkLatestVersion();
+
+  const spinner = new Spinner();
+  spinner.start(`Launching Background Agents ${colors.dim("→ " + backendUrl)}`);
+
+  const env = Object.assign({}, process.env, {
+    BACKGROUND_AGENTS_URL: backendUrl,
+    // Avoid Electron attaching to / spawning a console window on Windows.
+    ELECTRON_NO_ATTACH_CONSOLE: "1",
+  });
+
+  const child = spawn(electronPath, [APP_ENTRY], {
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: false,
+  });
+
+  let ready = false;
+  let exited = false;
+
+  function announceRunning() {
+    if (ready) return;
+    ready = true;
+    clearTimeout(readyFallback);
+    spinner.succeed(
+      `Background Agents is running ${colors.dim("→ " + backendUrl)}`
+    );
+    line(
+      `  ${colors.dim("Close the app window (or press Ctrl+C here) to quit.")}`
+    );
+    latestPromise.then((latest) => {
+      if (!exited && latest && semverGt(latest, pkg.version)) {
+        line();
+        line(
+          `  ${symbols.info} ${colors.yellow(
+            "A newer version is available"
+          )} ${colors.dim("(" + pkg.version + " → " + latest + ")")}`
+        );
+        line(
+          `  ${colors.dim("Update with: ")}${colors.cyan(
+            "npx " + pkg.name + "@latest"
+          )}`
+        );
+      }
+    });
+  }
+
+  function handleOutput(buffer, stream) {
+    const text = buffer.toString();
+    if (text.includes(READY_MARKER)) announceRunning();
+    if (opts.verbose) {
+      const cleaned = text.split(READY_MARKER).join("").replace(/\n{2,}/g, "\n");
+      if (cleaned.trim()) stream.write(colors.dim(cleaned));
+    }
+  }
+
+  child.stdout.on("data", (b) => handleOutput(b, process.stdout));
+  child.stderr.on("data", (b) => handleOutput(b, process.stderr));
+
+  // Fallback: if the app never prints the ready marker (older build, or output
+  // buffered), assume it's up after a short grace period so the UI doesn't hang.
+  const readyFallback = setTimeout(announceRunning, 8000);
+  if (readyFallback.unref) readyFallback.unref();
+
+  let shuttingDown = false;
+  function shutdown(signal) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearTimeout(readyFallback);
+    try {
+      child.kill(signal || "SIGTERM");
+    } catch (_err) {
+      /* ignore */
+    }
+  }
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+  child.on("error", (err) => {
+    exited = true;
+    clearTimeout(readyFallback);
+    if (!ready) spinner.fail("Failed to launch Background Agents");
+    showCursor();
+    line(`  ${symbols.error} ${colors.red(err.message)}`);
+    process.exitCode = 1;
+  });
+
+  child.on("exit", (code, signal) => {
+    exited = true;
+    clearTimeout(readyFallback);
+    showCursor();
+    if (!ready) {
+      spinner.fail("Background Agents exited before it finished starting");
+      if (code) {
+        line(
+          `  ${colors.dim(
+            "The app exited with code " +
+              code +
+              ". Re-run with --verbose to see its logs."
+          )}`
+        );
+      }
+    } else {
+      line(`  ${symbols.arrow} ${colors.dim("Background Agents closed.")}`);
+    }
+    process.exitCode = signal ? 0 : code == null ? 0 : code;
+  });
+}
+
+try {
+  main();
+} catch (err) {
+  showCursor();
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exitCode = 1;
+}

package/lib/ui.js

@@ -0,0 +1,110 @@
+"use strict";
+
+// Tiny dependency-free terminal UI: colors + a spinner. Keeping this free of
+// npm deps means `npx background-agents` installs fast (only Electron is heavy).
+
+const useColor =
+  process.env.NO_COLOR == null &&
+  process.env.TERM !== "dumb" &&
+  (Boolean(process.stdout.isTTY) || process.env.FORCE_COLOR != null);
+
+function wrap(open, close) {
+  return (s) => (useColor ? `[${open}m${s}[${close}m` : String(s));
+}
+
+const colors = {
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan: wrap(36, 39),
+  gray: wrap(90, 39),
+};
+
+const symbols = {
+  success: colors.green("✔"),
+  error: colors.red("✖"),
+  warn: colors.yellow("⚠"),
+  info: colors.cyan("ℹ"),
+  arrow: colors.gray("›"),
+  bullet: colors.gray("•"),
+};
+
+const isTTY = Boolean(process.stdout.isTTY);
+
+const HIDE_CURSOR = "[?25l";
+const SHOW_CURSOR = "[?25h";
+const CLEAR_LINE = "\r";
+
+function showCursor() {
+  if (isTTY) process.stdout.write(SHOW_CURSOR);
+}
+
+class Spinner {
+  constructor() {
+    this.frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    this.index = 0;
+    this.timer = null;
+    this.text = "";
+  }
+
+  start(text) {
+    this.text = text;
+    if (!isTTY) {
+      process.stdout.write(`  ${text}\n`);
+      return this;
+    }
+    if (this.timer) return this;
+    process.stdout.write(HIDE_CURSOR);
+    this.render();
+    this.timer = setInterval(() => this.render(), 80);
+    if (this.timer.unref) this.timer.unref();
+    return this;
+  }
+
+  render() {
+    const frame = colors.cyan(this.frames[this.index]);
+    this.index = (this.index + 1) % this.frames.length;
+    process.stdout.write(`${CLEAR_LINE}  ${frame} ${this.text}`);
+  }
+
+  update(text) {
+    this.text = text;
+    if (!isTTY) process.stdout.write(`  ${text}\n`);
+    return this;
+  }
+
+  stop(symbol, text) {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    const message = text != null ? text : this.text;
+    const line = `  ${symbol} ${message}`;
+    if (isTTY) process.stdout.write(`${CLEAR_LINE}${line}\n${SHOW_CURSOR}`);
+    else process.stdout.write(`${line}\n`);
+    return this;
+  }
+
+  succeed(text) {
+    return this.stop(symbols.success, text);
+  }
+  fail(text) {
+    return this.stop(symbols.error, text);
+  }
+  warn(text) {
+    return this.stop(symbols.warn, text);
+  }
+  info(text) {
+    return this.stop(symbols.info, text);
+  }
+}
+
+function line(text = "") {
+  process.stdout.write(`${text}\n`);
+}
+
+module.exports = { colors, symbols, Spinner, line, isTTY, showCursor };

package/package.json

@@ -1,57 +1,42 @@
 {
   "name": "background-agents",
-  "version": "0.1.1",
-  "description": "A TypeScript SDK for interacting with various AI coding agents (Claude, Codex, OpenCode, Gemini)",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "lint": "eslint src --ext .ts",
-    "clean": "rm -rf dist",
-    "prepublishOnly": "npm run build"
+  "version": "1.0.0",
+  "description": "Launch the Background Agents desktop app with one command — npx background-agents. Always runs the latest published version.",
+  "type": "commonjs",
+  "bin": {
+    "background-agents": "bin/background-agents.js"
   },
-  "keywords": [
-    "ai",
-    "coding-agent",
-    "claude",
-    "codex",
-    "opencode",
-    "gemini",
-    "sdk"
+  "files": [
+    "bin",
+    "lib",
+    "app",
+    "README.md"
   ],
-  "author": "",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "@types/ssh2": "^1.15.5",
-    "typescript": "^5.3.0",
-    "vitest": "^1.0.0"
-  },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=18"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "next.config.codeagentsdk.cjs"
-  ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./next.config": "./next.config.codeagentsdk.cjs"
+  "scripts": {
+    "bundle": "node scripts/bundle-app.mjs",
+    "prepack": "node scripts/bundle-app.mjs",
+    "start": "node bin/background-agents.js",
+    "typecheck": "node --check bin/background-agents.js && node --check lib/ui.js"
   },
   "dependencies": {
-    "@daytonaio/sdk": "^0.150.0",
-    "dotenv": "^17.3.1",
-    "ssh2": "^1.17.0"
+    "electron": "^33.2.1"
+  },
+  "keywords": [
+    "background-agents",
+    "electron",
+    "launcher",
+    "npx",
+    "desktop"
+  ],
+  "license": "MIT",
+  "author": "James Murdza",
+  "homepage": "https://backgrounder.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jamesmurdza/background-agents.git",
+    "directory": "packages/launcher"
   }
 }

package/dist/debug.d.ts

@@ -1,7 +0,0 @@
-/**
- * Debug logging for the SDK. Enable with env CODING_AGENTS_DEBUG=1 (or non-empty).
- * Logs agent lifecycle (start/stop), background runs, and any lines that fail to parse.
- */
-export declare function isDebugEnabled(): boolean;
-export declare function debugLog(message: string, sessionId?: string | null, ...args: unknown[]): void;
-//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAID,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAK7F"}

package/dist/debug.js

@@ -1,19 +0,0 @@
-/**
- * Debug logging for the SDK. Enable with env CODING_AGENTS_DEBUG=1 (or non-empty).
- * Logs agent lifecycle (start/stop), background runs, and any lines that fail to parse.
- */
-const DEBUG_ENABLED = typeof process !== "undefined" &&
-    process.env &&
-    String(process.env.CODING_AGENTS_DEBUG ?? "").trim() !== "";
-export function isDebugEnabled() {
-    return DEBUG_ENABLED;
-}
-const PREFIX = "[background-agents]";
-export function debugLog(message, sessionId, ...args) {
-    if (!DEBUG_ENABLED)
-        return;
-    const sessionTag = sessionId != null && sessionId !== "" ? ` sessionId=${sessionId}` : "";
-    const line = args.length ? `${message} ${args.map(a => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ")}` : message;
-    process.stderr.write(`${PREFIX}${sessionTag} ${line}\n`);
-}
-//# sourceMappingURL=debug.js.map

package/dist/debug.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.js","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,aAAa,GACjB,OAAO,OAAO,KAAK,WAAW;IAC9B,OAAO,CAAC,GAAG;IACX,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAA;AAE7D,MAAM,UAAU,cAAc;IAC5B,OAAO,aAAa,CAAA;AACtB,CAAC;AAED,MAAM,MAAM,GAAG,qBAAqB,CAAA;AAEpC,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,SAAyB,EAAE,GAAG,IAAe;IACrF,IAAI,CAAC,aAAa;QAAE,OAAM;IAC1B,MAAM,UAAU,GAAG,SAAS,IAAI,IAAI,IAAI,SAAS,KAAK,EAAE,CAAC,CAAC,CAAC,cAAc,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IACzF,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAA;IACrI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,GAAG,UAAU,IAAI,IAAI,IAAI,CAAC,CAAA;AAC1D,CAAC"}

package/dist/factory.d.ts

@@ -1,31 +0,0 @@
-import type { ProviderName, ProviderOptions } from "./types/index.js";
-import { Provider } from "./providers/index.js";
-/**
- * Create a provider instance by name
- *
- * @param name - The provider name ("claude", "codex", "opencode", "gemini")
- * @param options - Provider options (sandbox or dangerouslyAllowLocalExecution)
- * @returns A provider instance
- * @throws Error if the provider name is unknown
- *
- * @example
- * ```typescript
- * import { Daytona } from "@daytonaio/sdk"
- * const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
- * const sandbox = await daytona.create({ envVars: { ... } })
- * const provider = createProvider("claude", { sandbox })
- *
- * // Or with dangerous local execution:
- * const provider = createProvider("claude", { dangerouslyAllowLocalExecution: true })
- * ```
- */
-export declare function createProvider(name: ProviderName | string, options: ProviderOptions): Provider;
-/**
- * Get all available provider names
- */
-export declare function getProviderNames(): ProviderName[];
-/**
- * Check if a provider name is valid
- */
-export declare function isValidProvider(name: string): name is ProviderName;
-//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EAAE,QAAQ,EAAmE,MAAM,sBAAsB,CAAA;AAEhH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,QAAQ,CAa9F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,YAAY,EAAE,CAEjD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,YAAY,CAElE"}

package/dist/factory.js

@@ -1,47 +0,0 @@
-import { ClaudeProvider, CodexProvider, OpenCodeProvider, GeminiProvider } from "./providers/index.js";
-/**
- * Create a provider instance by name
- *
- * @param name - The provider name ("claude", "codex", "opencode", "gemini")
- * @param options - Provider options (sandbox or dangerouslyAllowLocalExecution)
- * @returns A provider instance
- * @throws Error if the provider name is unknown
- *
- * @example
- * ```typescript
- * import { Daytona } from "@daytonaio/sdk"
- * const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
- * const sandbox = await daytona.create({ envVars: { ... } })
- * const provider = createProvider("claude", { sandbox })
- *
- * // Or with dangerous local execution:
- * const provider = createProvider("claude", { dangerouslyAllowLocalExecution: true })
- * ```
- */
-export function createProvider(name, options) {
-    switch (name) {
-        case "claude":
-            return new ClaudeProvider(options);
-        case "codex":
-            return new CodexProvider(options);
-        case "opencode":
-            return new OpenCodeProvider(options);
-        case "gemini":
-            return new GeminiProvider(options);
-        default:
-            throw new Error(`Unknown provider: ${name}. Valid providers are: claude, codex, opencode, gemini`);
-    }
-}
-/**
- * Get all available provider names
- */
-export function getProviderNames() {
-    return ["claude", "codex", "opencode", "gemini"];
-}
-/**
- * Check if a provider name is valid
- */
-export function isValidProvider(name) {
-    return getProviderNames().includes(name);
-}
-//# sourceMappingURL=factory.js.map