picocode 0.9.196 → 0.9.198

package/dist/daemon.js

@@ -0,0 +1,141 @@
+// src/daemon.js
+import { dirname } from "node:path";
+import { serveDaemon, daemonPaths } from "picocode-core/daemon-transport.js";
+
+// src/daemon-session.js
+import { buildProjectBoot } from "picocode-core/boot.js";
+import { createController } from "picocode-core/controller.js";
+import { createShellManager } from "picocode-core/shells.js";
+import { createWakeupManager } from "picocode-core/wakeups.js";
+import { createGitService } from "picocode-core/git.js";
+import { readConfig } from "picocode-core/config.js";
+import { defaultModel as defaultModel2 } from "picocode-core/models.js";
+
+// src/model-runtime.js
+import { discoverKeys, applyKeys, keyHint } from "picocode-core/keys.js";
+import { loadCatalog, extractModels, adhocModel } from "picocode-core/catalog.js";
+import { loadCodexModels } from "picocode-core/codex-models.js";
+import { loadOpenRouterModels } from "picocode-core/openrouter-models.js";
+import { openaiConnected, openaiCredentials } from "picocode-core/openai-auth.js";
+import { defaultModel } from "picocode-core/models.js";
+import { fuzzyScore } from "picocode-core/fuzzy.js";
+var CATALOG_PROVIDERS = ["google", "anthropic", "openai", "xai"];
+function codexContext(catalogData, model) {
+  const entry = catalogData.openai?.models?.[model.name.split("/")[1]];
+  return model.context ?? entry?.limit?.input ?? entry?.limit?.context ?? null;
+}
+async function buildModels({ providers, force }) {
+  const has = (provider) => providers.includes(provider);
+  const codexCredentials = has("codex") ? await openaiCredentials().catch(() => null) : null;
+  const [catalogData, codex, openrouter] = await Promise.all([
+    loadCatalog({ force }),
+    loadCodexModels(codexCredentials, { force }),
+    has("openrouter") ? loadOpenRouterModels({ force }) : []
+  ]);
+  return [
+    ...extractModels(catalogData, CATALOG_PROVIDERS).map((model) => ({
+      ...model,
+      available: has(model.provider),
+      keyHint: keyHint(model.provider)
+    })),
+    ...codex.map((model) => ({
+      ...model,
+      context: codexContext(catalogData, model),
+      available: has("codex"),
+      keyHint: "/connect"
+    })),
+    ...openrouter.map((model) => ({ ...model, available: true, keyHint: keyHint("openrouter") }))
+  ];
+}
+async function loadModelRuntime() {
+  const chatgpt = await openaiConnected();
+  const providers = [...applyKeys(discoverKeys()), ...chatgpt ? ["codex"] : []];
+  const codexCredentials = chatgpt ? await openaiCredentials().catch(() => null) : null;
+  const loadModels = ({ force = false } = {}) => buildModels({ providers, force });
+  return { providers, models: await loadModels(), codexCredentials, loadModels };
+}
+
+// src/daemon-session.js
+async function createDaemonSession({ cwd = process.cwd(), version, theme, detectedTheme, themePref } = {}) {
+  const { models, providers, loadModels } = await loadModelRuntime();
+  if (!providers.length) throw new Error("no model credentials found");
+  const config = await readConfig();
+  const notify = {};
+  const shells = createShellManager({ onChange: () => notify.shells?.(), onExit: (shell) => notify.shellExit?.(shell) });
+  const wakeups = createWakeupManager({ onChange: () => notify.wakeups?.(), onFire: (wakeup) => notify.wakeupFire?.(wakeup) });
+  const git = createGitService({ onChange: () => notify.git?.() });
+  const rebuild = (cwd2) => buildProjectBoot(cwd2, { onMcpChange: () => notify.mcp?.() });
+  let boot;
+  try {
+    boot = {
+      ...await rebuild(cwd),
+      version,
+      theme,
+      detectedTheme,
+      themePref,
+      models,
+      providers,
+      initialModel: models.find((m) => m.name === config.defaultModel && m.available !== false) || defaultModel2(models),
+      researchModel: config.models?.researchWorker || null,
+      shellModel: config.models?.shell || null,
+      participantAModel: config.models?.participantA || null,
+      participantBModel: config.models?.participantB || null,
+      deliberationModel: config.models?.deliberation || config.models?.researchWorker || null,
+      researchAgentLimit: Number.isInteger(config.research?.agentLimit) && config.research.agentLimit >= 1 && config.research.agentLimit <= 100 ? config.research.agentLimit : 10,
+      initialEffort: ["low", "medium", "high", "max"].includes(config.defaultEffort) ? config.defaultEffort : null,
+      speedDefaults: config.speedDefaults,
+      autoCompact: config.autoCompact !== false,
+      clouds: config.animation?.clouds === true,
+      compactToolHistory: config.display?.compactToolHistory === true,
+      gitFooter: config.display?.gitStatus !== false,
+      wideSidebar: config.display?.wideSidebar !== false,
+      refs: {},
+      shells,
+      wakeups,
+      git,
+      rebuild,
+      refreshModels: () => loadModels({ force: true }),
+      setMcpNotify: (fn) => {
+        notify.mcp = fn;
+      },
+      setGitNotify: (fn) => {
+        notify.git = fn;
+      },
+      setShellsNotify: (fn) => {
+        notify.shells = fn;
+      },
+      setShellsExit: (fn) => {
+        notify.shellExit = fn;
+      },
+      setWakeupsNotify: (fn) => {
+        notify.wakeups = fn;
+      },
+      setWakeupsFire: (fn) => {
+        notify.wakeupFire = fn;
+      }
+    };
+    git.retarget(boot.root);
+    git.setEnabled(boot.gitFooter);
+    const controller = createController({ boot });
+    boot.mcp.connectAll();
+    return { controller, dispose: () => {
+      git.dispose();
+      wakeups.cancelAll();
+      shells.killAll();
+    } };
+  } catch (error) {
+    git.dispose();
+    shells.killAll();
+    boot?.mcp.terminateAll();
+    throw error;
+  }
+}
+
+// src/daemon.js
+var socket = process.argv[process.argv.indexOf("--socket") + 1];
+var paths = process.argv.includes("--socket") ? { socket, directory: dirname(socket) } : daemonPaths();
+var daemon = await serveDaemon({ paths, createSession: createDaemonSession, onClose: () => process.exit(0) });
+for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) process.on(signal, () => daemon.close().catch(() => process.exit(1)));
+process.on("uncaughtException", () => daemon.close().finally(() => process.exit(1)));
+process.on("unhandledRejection", () => daemon.close().finally(() => process.exit(1)));
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/daemon.js", "../src/daemon-session.js", "../src/model-runtime.js"],
  "sourcesContent": ["import { dirname } from 'node:path'\nimport { serveDaemon, daemonPaths } from 'picocode-core/daemon-transport.js'\nimport { createDaemonSession } from './daemon-session.js'\n\nconst socket = process.argv[process.argv.indexOf('--socket') + 1]\nconst paths = process.argv.includes('--socket') ? { socket, directory: dirname(socket) } : daemonPaths()\nconst daemon = await serveDaemon({ paths, createSession: createDaemonSession, onClose: () => process.exit(0) })\nfor (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) process.on(signal, () => daemon.close().catch(() => process.exit(1)))\nprocess.on('uncaughtException', () => daemon.close().finally(() => process.exit(1)))\nprocess.on('unhandledRejection', () => daemon.close().finally(() => process.exit(1)))\n", "import { buildProjectBoot } from 'picocode-core/boot.js'\nimport { createController } from 'picocode-core/controller.js'\nimport { createShellManager } from 'picocode-core/shells.js'\nimport { createWakeupManager } from 'picocode-core/wakeups.js'\nimport { createGitService } from 'picocode-core/git.js'\nimport { readConfig } from 'picocode-core/config.js'\nimport { defaultModel } from 'picocode-core/models.js'\nimport { loadModelRuntime } from './model-runtime.js'\n\nexport async function createDaemonSession({ cwd = process.cwd(), version, theme, detectedTheme, themePref } = {}) {\n  const { models, providers, loadModels } = await loadModelRuntime()\n  if (!providers.length) throw new Error('no model credentials found')\n  const config = await readConfig()\n  const notify = {}\n  const shells = createShellManager({ onChange: () => notify.shells?.(), onExit: shell => notify.shellExit?.(shell) })\n  const wakeups = createWakeupManager({ onChange: () => notify.wakeups?.(), onFire: wakeup => notify.wakeupFire?.(wakeup) })\n  const git = createGitService({ onChange: () => notify.git?.() })\n  const rebuild = cwd => buildProjectBoot(cwd, { onMcpChange: () => notify.mcp?.() })\n  let boot\n  try {\n    boot = {\n      ...await rebuild(cwd), version, theme, detectedTheme, themePref,\n      models, providers, initialModel: models.find(m => m.name === config.defaultModel && m.available !== false) || defaultModel(models),\n      researchModel: config.models?.researchWorker || null, shellModel: config.models?.shell || null,\n      participantAModel: config.models?.participantA || null, participantBModel: config.models?.participantB || null,\n      deliberationModel: config.models?.deliberation || config.models?.researchWorker || null,\n      researchAgentLimit: Number.isInteger(config.research?.agentLimit) && config.research.agentLimit >= 1 && config.research.agentLimit <= 100 ? config.research.agentLimit : 10,\n      initialEffort: ['low', 'medium', 'high', 'max'].includes(config.defaultEffort) ? config.defaultEffort : null, speedDefaults: config.speedDefaults,\n      autoCompact: config.autoCompact !== false, clouds: config.animation?.clouds === true,\n      compactToolHistory: config.display?.compactToolHistory === true, gitFooter: config.display?.gitStatus !== false,\n      wideSidebar: config.display?.wideSidebar !== false, refs: {}, shells, wakeups, git, rebuild,\n      refreshModels: () => loadModels({ force: true }),\n      setMcpNotify: fn => { notify.mcp = fn }, setGitNotify: fn => { notify.git = fn },\n      setShellsNotify: fn => { notify.shells = fn }, setShellsExit: fn => { notify.shellExit = fn },\n      setWakeupsNotify: fn => { notify.wakeups = fn }, setWakeupsFire: fn => { notify.wakeupFire = fn },\n    }\n    git.retarget(boot.root)\n    git.setEnabled(boot.gitFooter)\n    const controller = createController({ boot })\n    boot.mcp.connectAll()\n    return { controller, dispose: () => { git.dispose(); wakeups.cancelAll(); shells.killAll() } }\n  } catch (error) { git.dispose(); shells.killAll(); boot?.mcp.terminateAll(); throw error }\n}\n", "import { discoverKeys, applyKeys, keyHint } from 'picocode-core/keys.js'\nimport { loadCatalog, extractModels, adhocModel } from 'picocode-core/catalog.js'\nimport { loadCodexModels } from 'picocode-core/codex-models.js'\nimport { loadOpenRouterModels } from 'picocode-core/openrouter-models.js'\nimport { openaiConnected, openaiCredentials } from 'picocode-core/openai-auth.js'\nimport { defaultModel } from 'picocode-core/models.js'\nimport { fuzzyScore } from 'picocode-core/fuzzy.js'\n\nconst CATALOG_PROVIDERS = ['google', 'anthropic', 'openai', 'xai']\n\nfunction codexContext(catalogData, model) {\n  const entry = catalogData.openai?.models?.[model.name.split('/')[1]]\n  return model.context ?? entry?.limit?.input ?? entry?.limit?.context ?? null\n}\n\nasync function buildModels({ providers, force }) {\n  const has = (provider) => providers.includes(provider)\n  const codexCredentials = has('codex') ? await openaiCredentials().catch(() => null) : null\n  const [catalogData, codex, openrouter] = await Promise.all([\n    loadCatalog({ force }),\n    loadCodexModels(codexCredentials, { force }),\n    has('openrouter') ? loadOpenRouterModels({ force }) : [],\n  ])\n  return [\n    ...extractModels(catalogData, CATALOG_PROVIDERS).map((model) => ({\n      ...model,\n      available: has(model.provider),\n      keyHint: keyHint(model.provider),\n    })),\n    ...codex.map((model) => ({\n      ...model,\n      context: codexContext(catalogData, model),\n      available: has('codex'),\n      keyHint: '/connect',\n    })),\n    ...openrouter.map((model) => ({ ...model, available: true, keyHint: keyHint('openrouter') })),\n  ]\n}\n\nexport async function loadModelRuntime() {\n  const chatgpt = await openaiConnected()\n  const providers = [...applyKeys(discoverKeys()), ...(chatgpt ? ['codex'] : [])]\n  const codexCredentials = chatgpt ? await openaiCredentials().catch(() => null) : null\n  const loadModels = ({ force = false } = {}) => buildModels({ providers, force })\n  return { providers, models: await loadModels(), codexCredentials, loadModels }\n}\n\nexport function resolveModel(models, providers, name) {\n  if (!name) return null\n  const exact = models.find((model) => model.name === name)\n  if (exact) return exact\n  if (name.includes('/')) return adhocModel(name, providers)\n  const available = models.filter((model) => model.available !== false)\n  return available\n      .map((model) => [fuzzyScore(name, model.name), model])\n      .filter(([score]) => score >= 0)\n      .sort((a, b) => b[0] - a[0])[0]?.[1]\n    || null\n}\n\nexport function selectModel({ models, providers, requested, configured }) {\n  return resolveModel(models, providers, requested)\n    || (configured && models.find((model) => model.name === configured && model.available))\n    || defaultModel(models)\n}\n"],
  "mappings": "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",
  "names": ["defaultModel", "cwd", "defaultModel"]
}
