@openacp/cli 0.6.10 → 2026.326.3

package/dist/main-T5WVCCFN.js

@@ -0,0 +1,715 @@
+#!/usr/bin/env node
+import {
+  corePlugins
+} from "./chunk-Q6ZXJTZB.js";
+import "./chunk-UB2QB6DE.js";
+import {
+  SettingsManager
+} from "./chunk-MLF4W5R6.js";
+import "./chunk-WVLDNYOJ.js";
+import "./chunk-Y64XWMJ4.js";
+import "./chunk-P4SNGQNI.js";
+import "./chunk-V5JT5TPD.js";
+import "./chunk-5OCGO27U.js";
+import "./chunk-YEULD3SG.js";
+import "./chunk-ZHGPZBS4.js";
+import "./chunk-2CX4IEEC.js";
+import "./chunk-AD3X6DGK.js";
+import "./chunk-SNPYTMPR.js";
+import {
+  OpenACPCore
+} from "./chunk-FQEBWOZR.js";
+import "./chunk-SHTGQGAU.js";
+import "./chunk-A6Y4GZM3.js";
+import "./chunk-FNRSWA2K.js";
+import "./chunk-ZSLHHQPQ.js";
+import "./chunk-LGFWH3AE.js";
+import "./chunk-OYSAN7UX.js";
+import "./chunk-BLQUXO7S.js";
+import "./chunk-QWP76EBW.js";
+import "./chunk-APS6UEFU.js";
+import "./chunk-WAAD23KY.js";
+import "./chunk-WIIZNPCR.js";
+import "./chunk-WXVT3AOY.js";
+import {
+  ConfigManager
+} from "./chunk-QVMEF6FB.js";
+import {
+  cleanupOldSessionLogs,
+  initLogger,
+  log,
+  muteLogger,
+  shutdownLogger,
+  unmuteLogger
+} from "./chunk-XMMAGAT4.js";
+import {
+  PluginRegistry
+} from "./chunk-W26AUH5B.js";
+import "./chunk-VUNV25KB.js";
+
+// src/core/command-registry.ts
+var CommandRegistry = class _CommandRegistry {
+  /** Main registry: short names + qualified names → RegisteredCommand */
+  commands = /* @__PURE__ */ new Map();
+  /** Adapter-specific overrides: `channelId:commandName` → RegisteredCommand */
+  overrides = /* @__PURE__ */ new Map();
+  static ADAPTER_SCOPES = /* @__PURE__ */ new Set(["telegram", "discord", "slack"]);
+  /**
+   * Register a command definition.
+   * @param def - Command definition
+   * @param pluginName - Plugin that owns the command (set automatically by PluginContext)
+   */
+  register(def, pluginName) {
+    const cmd = {
+      ...def,
+      pluginName: pluginName ?? def.pluginName
+    };
+    if (pluginName) {
+      cmd.scope = _CommandRegistry.extractScope(pluginName);
+    }
+    const qualifiedName = cmd.scope ? `${cmd.scope}:${cmd.name}` : void 0;
+    if (cmd.scope && _CommandRegistry.ADAPTER_SCOPES.has(cmd.scope) && this.commands.has(cmd.name)) {
+      this.overrides.set(`${cmd.scope}:${cmd.name}`, cmd);
+      return;
+    }
+    if (qualifiedName) {
+      this.commands.set(qualifiedName, cmd);
+    }
+    if (this.commands.has(cmd.name)) {
+      const existing = this.commands.get(cmd.name);
+      if (existing.category === "system") {
+        return;
+      }
+      return;
+    }
+    this.commands.set(cmd.name, cmd);
+  }
+  /** Retrieve a command by name (short or qualified). */
+  get(name) {
+    return this.commands.get(name);
+  }
+  /** Remove a command by short name. Also removes its qualified name entry. */
+  unregister(name) {
+    const cmd = this.commands.get(name);
+    if (cmd) {
+      this.commands.delete(name);
+      if (cmd.scope) {
+        this.commands.delete(`${cmd.scope}:${name}`);
+      }
+    }
+    if (!cmd) {
+      this.commands.delete(name);
+    }
+  }
+  /** Remove all commands registered by a given plugin. */
+  unregisterByPlugin(pluginName) {
+    const scope = _CommandRegistry.extractScope(pluginName);
+    const toDelete = [];
+    for (const [key, cmd] of this.commands) {
+      if (cmd.pluginName === pluginName) {
+        toDelete.push(key);
+      }
+    }
+    for (const key of toDelete) {
+      this.commands.delete(key);
+    }
+    for (const [key, cmd] of this.overrides) {
+      if (cmd.pluginName === pluginName) {
+        this.overrides.delete(key);
+      }
+    }
+  }
+  /** Return all unique commands (deduplicated — each command appears once). */
+  getAll() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const cmd of this.commands.values()) {
+      seen.add(cmd);
+    }
+    return [...seen];
+  }
+  /** Filter commands by category. */
+  getByCategory(category) {
+    return this.getAll().filter((cmd) => cmd.category === category);
+  }
+  /**
+   * Parse and execute a command string.
+   * @param commandString - Full command string, e.g. "/greet hello world"
+   * @param baseArgs - Base arguments (channelId, userId, etc.)
+   * @returns CommandResponse
+   */
+  async execute(commandString, baseArgs) {
+    const trimmed = commandString.trim();
+    const spaceIdx = trimmed.indexOf(" ");
+    const cmdName = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+    const rawArgs = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
+    const overrideKey = `${baseArgs.channelId}:${cmdName}`;
+    const override = this.overrides.get(overrideKey);
+    const cmd = override ?? this.commands.get(cmdName);
+    if (!cmd) {
+      return { type: "error", message: `Unknown command: /${cmdName}` };
+    }
+    const args = {
+      ...baseArgs,
+      raw: rawArgs
+    };
+    try {
+      const result = await cmd.handler(args);
+      if (result === void 0 || result === null) {
+        return { type: "silent" };
+      }
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { type: "error", message: `Command /${cmdName} failed: ${message}` };
+    }
+  }
+  /** Extract scope from plugin name: '@openacp/speech' → 'speech', 'my-plugin' → 'my-plugin' */
+  static extractScope(pluginName) {
+    const slashIdx = pluginName.lastIndexOf("/");
+    if (slashIdx !== -1) {
+      return pluginName.slice(slashIdx + 1);
+    }
+    return pluginName;
+  }
+};
+
+// src/core/commands/session.ts
+function registerSessionCommands(registry, _core) {
+  registry.register({
+    name: "new",
+    description: "Start a new session",
+    usage: "[agent-name]",
+    category: "system",
+    handler: async (args) => {
+      const agent = args.raw.trim();
+      if (agent) {
+        return { type: "text", text: `Starting new session with agent: ${agent}` };
+      }
+      return { type: "text", text: "Starting new session..." };
+    }
+  });
+  registry.register({
+    name: "cancel",
+    description: "Cancel the current agent turn",
+    category: "system",
+    handler: async () => {
+      return { type: "silent" };
+    }
+  });
+  registry.register({
+    name: "status",
+    description: "Show current session status",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "No active session." };
+    }
+  });
+  registry.register({
+    name: "sessions",
+    description: "List all active sessions",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "No active sessions." };
+    }
+  });
+  registry.register({
+    name: "clear",
+    description: "Clear session history",
+    category: "system",
+    handler: async () => {
+      return { type: "silent" };
+    }
+  });
+  registry.register({
+    name: "newchat",
+    description: "End current session and start a new one",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "Ending session and starting a new one..." };
+    }
+  });
+  registry.register({
+    name: "resume",
+    description: "Resume a previous session",
+    usage: "<session-number>",
+    category: "system",
+    handler: async (args) => {
+      const id = args.raw.trim();
+      if (!id) {
+        return { type: "error", message: "Usage: /resume <session-number>" };
+      }
+      return { type: "text", text: `Resuming session ${id}...` };
+    }
+  });
+  registry.register({
+    name: "summary",
+    description: "Show session summary",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "No session summary available." };
+    }
+  });
+  registry.register({
+    name: "handoff",
+    description: "Hand off session to another agent",
+    usage: "<agent-name>",
+    category: "system",
+    handler: async (args) => {
+      const agent = args.raw.trim();
+      if (!agent) {
+        return { type: "error", message: "Usage: /handoff <agent-name>" };
+      }
+      return { type: "text", text: `Handing off to ${agent}...` };
+    }
+  });
+}
+
+// src/core/commands/agents.ts
+function registerAgentCommands(registry, _core) {
+  registry.register({
+    name: "agents",
+    description: "List available agents",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "No agents configured." };
+    }
+  });
+  registry.register({
+    name: "install",
+    description: "Install a plugin",
+    usage: "<plugin-name>",
+    category: "system",
+    handler: async (args) => {
+      const plugin = args.raw.trim();
+      if (!plugin) {
+        return { type: "error", message: "Usage: /install <plugin-name>" };
+      }
+      return { type: "text", text: `Installing plugin: ${plugin}...` };
+    }
+  });
+}
+
+// src/core/commands/admin.ts
+function registerAdminCommands(registry, _core) {
+  registry.register({
+    name: "restart",
+    description: "Restart the server",
+    category: "system",
+    handler: async () => {
+      return { type: "silent" };
+    }
+  });
+  registry.register({
+    name: "update",
+    description: "Check for and apply updates",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "Checking for updates..." };
+    }
+  });
+  registry.register({
+    name: "doctor",
+    description: "Run system diagnostics",
+    category: "system",
+    handler: async () => {
+      return { type: "text", text: "Running diagnostics..." };
+    }
+  });
+  registry.register({
+    name: "integrate",
+    description: "Set up a new channel integration",
+    usage: "<channel>",
+    category: "system",
+    handler: async (args) => {
+      const channel = args.raw.trim();
+      if (!channel) {
+        return {
+          type: "menu",
+          title: "Available Integrations",
+          options: [
+            { label: "Telegram", command: "/integrate telegram" },
+            { label: "Discord", command: "/integrate discord" },
+            { label: "Slack", command: "/integrate slack" }
+          ]
+        };
+      }
+      return { type: "text", text: `Setting up ${channel} integration...` };
+    }
+  });
+}
+
+// src/core/commands/help.ts
+function registerHelpCommand(registry, _core) {
+  registry.register({
+    name: "help",
+    description: "Show available commands",
+    usage: "[command]",
+    category: "system",
+    handler: async (args) => {
+      const query = args.raw.trim();
+      if (query) {
+        const cmd = registry.get(query);
+        if (!cmd) {
+          return { type: "error", message: `Unknown command: /${query}` };
+        }
+        let text = `/${cmd.name}`;
+        if (cmd.usage) text += ` ${cmd.usage}`;
+        text += `
+${cmd.description}`;
+        return { type: "text", text };
+      }
+      const systemCmds = registry.getByCategory("system");
+      const pluginCmds = registry.getByCategory("plugin");
+      const lines = [];
+      if (systemCmds.length > 0) {
+        lines.push("System Commands:");
+        for (const cmd of systemCmds) {
+          const usage = cmd.usage ? ` ${cmd.usage}` : "";
+          lines.push(`  /${cmd.name}${usage} \u2014 ${cmd.description}`);
+        }
+      }
+      if (pluginCmds.length > 0) {
+        if (lines.length > 0) lines.push("");
+        lines.push("Plugin Commands:");
+        for (const cmd of pluginCmds) {
+          const usage = cmd.usage ? ` ${cmd.usage}` : "";
+          lines.push(`  /${cmd.name}${usage} \u2014 ${cmd.description}`);
+        }
+      }
+      if (lines.length === 0) {
+        return { type: "text", text: "No commands registered." };
+      }
+      return { type: "text", text: lines.join("\n") };
+    }
+  });
+}
+
+// src/core/commands/menu.ts
+function registerMenuCommand(registry, _core) {
+  registry.register({
+    name: "menu",
+    description: "Show the main menu",
+    category: "system",
+    handler: async () => {
+      return {
+        type: "menu",
+        title: "Main Menu",
+        options: [
+          { label: "New Session", command: "/new" },
+          { label: "Active Sessions", command: "/sessions" },
+          { label: "Available Agents", command: "/agents" },
+          { label: "Usage", command: "/usage" },
+          { label: "Help", command: "/help" }
+        ]
+      };
+    }
+  });
+}
+
+// src/core/commands/index.ts
+function registerSystemCommands(registry, core) {
+  registerSessionCommands(registry, core);
+  registerAgentCommands(registry, core);
+  registerAdminCommands(registry, core);
+  registerHelpCommand(registry, core);
+  registerMenuCommand(registry, core);
+}
+
+// src/main.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var RESTART_EXIT_CODE = 75;
+var shuttingDown = false;
+var OPENACP_DIR = path.join(os.homedir(), ".openacp");
+var PLUGINS_DATA_DIR = path.join(OPENACP_DIR, "plugins", "data");
+var REGISTRY_PATH = path.join(OPENACP_DIR, "plugins.json");
+async function startServer(opts) {
+  if (process.argv.includes("--daemon-child")) {
+    const { writePidFile, readPidFile, getPidPath, shouldAutoStart } = await import("./daemon-PXO5QPCR.js");
+    if (!shouldAutoStart()) {
+      process.exit(0);
+    }
+    const pidPath = getPidPath();
+    const existingPid = readPidFile(pidPath);
+    if (existingPid !== null && existingPid !== process.pid) {
+      try {
+        process.kill(existingPid, 0);
+        console.error(`Another OpenACP instance is already running (PID ${existingPid}). Exiting.`);
+        process.exit(1);
+      } catch {
+      }
+    }
+    writePidFile(pidPath, process.pid);
+  }
+  const settingsManager = new SettingsManager(PLUGINS_DATA_DIR);
+  const pluginRegistry = new PluginRegistry(REGISTRY_PATH);
+  await pluginRegistry.load();
+  const configManager = new ConfigManager();
+  const configExists = await configManager.exists();
+  if (!configExists) {
+    const { runSetup } = await import("./setup-BAI2F24H.js");
+    const shouldStart = await runSetup(configManager, { settingsManager, pluginRegistry });
+    if (!shouldStart) process.exit(0);
+  }
+  await configManager.load();
+  const config = configManager.get();
+  initLogger(config.logging);
+  log.debug({ configPath: configManager.getConfigPath() }, "Config loaded");
+  if (pluginRegistry.list().size === 0) {
+    await autoRegisterBuiltinPlugins(settingsManager, pluginRegistry, configManager);
+  }
+  const isForegroundTTY = !!(process.stdout.isTTY && !process.env.NO_COLOR && config.runMode !== "daemon");
+  if (isForegroundTTY) {
+    const { printStartBanner } = await import("./setup-BAI2F24H.js");
+    await printStartBanner();
+  }
+  let spinner;
+  if (isForegroundTTY) {
+    muteLogger();
+    const ora = (await import("ora")).default;
+    spinner = ora({ text: "Starting OpenACP...", spinner: "dots" }).start();
+  }
+  try {
+    const { runPostUpgradeChecks } = await import("./post-upgrade-XLHZ6ZB7.js");
+    await runPostUpgradeChecks(config);
+  } catch (err) {
+    log.warn({ err }, "Post-upgrade check failed");
+  }
+  cleanupOldSessionLogs(config.logging.sessionLogRetentionDays).catch(
+    (err) => log.warn({ err }, "Session log cleanup failed")
+  );
+  const core = new OpenACPCore(configManager);
+  const commandRegistry = new CommandRegistry();
+  const serviceRegistry = core.lifecycleManager.serviceRegistry;
+  serviceRegistry.register("command-registry", commandRegistry, "core");
+  registerSystemCommands(commandRegistry, core);
+  try {
+    core.eventBus.emit("kernel:booted");
+    core.lifecycleManager.settingsManager = settingsManager;
+    core.lifecycleManager.pluginRegistry = pluginRegistry;
+    await core.lifecycleManager.boot(corePlugins);
+    if (opts?.devPluginPath) {
+      const { DevPluginLoader } = await import("./dev-loader-RDC5E2CW.js");
+      const devLoader = new DevPluginLoader(opts.devPluginPath);
+      try {
+        const devPlugin = await devLoader.load();
+        await core.lifecycleManager.boot([devPlugin]);
+        log.info({ plugin: devPlugin.name, version: devPlugin.version }, "Dev plugin loaded");
+        if (!opts.noWatch) {
+          const distPath = devLoader.getDistPath();
+          let reloadTimer = null;
+          fs.watch(distPath, { recursive: true }, (_eventType, filename) => {
+            if (!filename?.endsWith(".js")) return;
+            if (reloadTimer) clearTimeout(reloadTimer);
+            reloadTimer = setTimeout(async () => {
+              try {
+                log.info({ filename }, "Dev plugin changed, reloading...");
+                await core.lifecycleManager.unloadPlugin(devPlugin.name);
+                const reloaded = await devLoader.load();
+                await core.lifecycleManager.boot([reloaded]);
+                log.info({ plugin: reloaded.name, version: reloaded.version }, "Dev plugin reloaded");
+              } catch (err) {
+                log.error({ err }, "Dev plugin reload failed");
+              }
+            }, 500);
+          });
+          log.info({ distPath }, "Watching dev plugin for changes");
+        }
+      } catch (err) {
+        log.error({ err, pluginPath: opts.devPluginPath }, "Failed to load dev plugin");
+      }
+    }
+    for (const adapterName of ["telegram", "discord", "slack"]) {
+      const adapter = serviceRegistry.get(`adapter:${adapterName}`);
+      if (adapter) {
+        core.registerAdapter(adapterName, adapter);
+        log.info({ adapter: adapterName }, "Adapter registered");
+      }
+    }
+    const tunnelSvc = serviceRegistry.get("tunnel");
+    if (tunnelSvc) {
+      core.tunnelService = tunnelSvc;
+    }
+    core.eventBus.emit("system:commands-ready", { commands: commandRegistry.getAll() });
+    core.eventBus.emit("system:ready");
+  } catch (err) {
+    log.error({ err }, "Plugin boot failed");
+  }
+  if (core.adapters.size === 0) {
+    log.error("No channels enabled. Enable at least one channel in config.");
+    process.exit(1);
+  }
+  const shutdown = async (signal, exitCode = 0) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log.info({ signal, exitCode }, "Signal received, shutting down");
+    try {
+      await core.lifecycleManager.shutdown();
+      await core.stop();
+    } catch (err) {
+      log.error({ err }, "Error during shutdown");
+    }
+    const isDaemon = process.argv.includes("--daemon-child");
+    if (isDaemon) {
+      const { removePidFile, getPidPath } = await import("./daemon-PXO5QPCR.js");
+      removePidFile(getPidPath());
+    }
+    if (exitCode === RESTART_EXIT_CODE) {
+      if (isDaemon) {
+        const { spawn: spawnChild } = await import("child_process");
+        const { expandHome } = await import("./config-I4FMCJGZ.js");
+        const fs2 = await import("fs");
+        const pathMod = await import("path");
+        const cliPath = pathMod.resolve(process.argv[1]);
+        const resolvedLogDir = expandHome(config.logging.logDir);
+        fs2.mkdirSync(resolvedLogDir, { recursive: true });
+        const logFile = pathMod.join(resolvedLogDir, "openacp.log");
+        const out = fs2.openSync(logFile, "a");
+        const err = fs2.openSync(logFile, "a");
+        const child = spawnChild(process.execPath, [cliPath, "--daemon-child"], {
+          detached: true,
+          stdio: ["ignore", out, err],
+          env: { ...process.env, OPENACP_SKIP_UPDATE_CHECK: "1" }
+        });
+        fs2.closeSync(out);
+        fs2.closeSync(err);
+        child.unref();
+        log.info({ newPid: child.pid }, "Respawned daemon for restart");
+      } else if (!process.env.OPENACP_DEV_LOOP) {
+        const { spawn: spawnChild } = await import("child_process");
+        const child = spawnChild(process.execPath, process.argv.slice(1), {
+          stdio: "inherit",
+          env: { ...process.env, OPENACP_SKIP_UPDATE_CHECK: "1" }
+        });
+        await shutdownLogger();
+        child.on("exit", (code) => process.exit(code ?? 0));
+        return;
+      }
+    }
+    await shutdownLogger();
+    process.exit(exitCode);
+  };
+  core.requestRestart = () => shutdown("restart", RESTART_EXIT_CODE);
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("uncaughtException", (err) => {
+    log.error({ err }, "Uncaught exception");
+  });
+  process.on("unhandledRejection", (err) => {
+    log.error({ err }, "Unhandled rejection");
+  });
+  await core.start();
+  if (isForegroundTTY) {
+    if (spinner) spinner.stop();
+    const ok = (msg) => console.log(`\x1B[32m\u2713\x1B[0m ${msg}`);
+    ok("Config loaded");
+    ok("Dependencies checked");
+    const tunnelSvc = core.lifecycleManager.serviceRegistry.get("tunnel");
+    if (tunnelSvc) ok(`Tunnel ready \u2192 ${tunnelSvc.getPublicUrl()}`);
+    for (const [name] of core.adapters) ok(`${name.charAt(0).toUpperCase() + name.slice(1)} connected`);
+    const apiPort = config.api?.port ?? 21420;
+    if (core.lifecycleManager.serviceRegistry.get("api-server")) ok(`API server on port ${apiPort}`);
+    console.log(`
+OpenACP is running. Press Ctrl+C to stop.
+`);
+    unmuteLogger();
+  }
+  log.debug({ agents: Object.keys(config.agents) }, "OpenACP started");
+}
+async function autoRegisterBuiltinPlugins(settingsManager, pluginRegistry, configManager) {
+  const allPlugins = [
+    { name: "@openacp/security", version: "1.0.0", description: "User access control and session limits" },
+    { name: "@openacp/file-service", version: "1.0.0", description: "File storage and management" },
+    { name: "@openacp/context", version: "1.0.0", description: "Conversation context management" },
+    { name: "@openacp/usage", version: "1.0.0", description: "Token usage tracking and budget enforcement" },
+    { name: "@openacp/speech", version: "1.0.0", description: "Text-to-speech and speech-to-text" },
+    { name: "@openacp/notifications", version: "1.0.0", description: "Cross-session notification routing" },
+    { name: "@openacp/tunnel", version: "1.0.0", description: "Expose local services via tunnel" },
+    { name: "@openacp/api-server", version: "1.0.0", description: "REST API + SSE streaming server" },
+    { name: "@openacp/telegram", version: "1.0.0", description: "Telegram adapter with forum topics" },
+    { name: "@openacp/discord", version: "1.0.0", description: "Discord adapter with forum threads" },
+    { name: "@openacp/slack", version: "1.0.0", description: "Slack adapter with channels and threads" }
+  ];
+  let legacyConfig;
+  try {
+    const cfg = configManager.get();
+    if (cfg && typeof cfg === "object") {
+      legacyConfig = cfg;
+    }
+  } catch {
+  }
+  if (legacyConfig) {
+    const pluginModules = await Promise.allSettled([
+      import("./security-YNRBW6S7.js"),
+      import("./file-service-EUODJAIT.js"),
+      import("./context-XM6E22LM.js"),
+      import("./usage-WYNK6ZC5.js"),
+      import("./speech-2GHQNRIO.js"),
+      import("./notifications-D5BRDNSU.js"),
+      import("./tunnel-M47I7H4B.js"),
+      import("./api-server-3PYLRBCN.js"),
+      import("./telegram-ZDC3JQF2.js"),
+      import("./discord-NOJQ5PZO.js"),
+      import("./slack-KH7E3VBS.js")
+    ]);
+    for (const result of pluginModules) {
+      if (result.status !== "fulfilled") continue;
+      const plugin = result.value.default;
+      if (plugin?.install) {
+        try {
+          const existing = await settingsManager.loadSettings(plugin.name);
+          if (Object.keys(existing).length > 0) continue;
+          const { createInstallContext } = await import("./install-context-XPWTFT3J.js");
+          const ctx = createInstallContext({
+            pluginName: plugin.name,
+            settingsManager,
+            basePath: PLUGINS_DATA_DIR,
+            legacyConfig
+          });
+          ctx.terminal = createSilentTerminal();
+          await plugin.install(ctx);
+        } catch {
+        }
+      }
+    }
+  }
+  for (const p of allPlugins) {
+    pluginRegistry.register(p.name, {
+      version: p.version,
+      source: "builtin",
+      enabled: true,
+      settingsPath: settingsManager.getSettingsPath(p.name),
+      description: p.description
+    });
+  }
+  await pluginRegistry.save();
+  log.info("Built-in plugins registered in plugin registry");
+}
+function createSilentTerminal() {
+  const noop = () => {
+  };
+  return {
+    text: async () => "",
+    select: async () => "",
+    confirm: async () => false,
+    password: async () => "",
+    multiselect: async () => [],
+    log: { info: noop, success: noop, warning: noop, error: noop, step: noop },
+    spinner: () => ({ start: noop, stop: noop, fail: noop }),
+    note: noop,
+    cancel: noop
+  };
+}
+var isDirectExecution = process.argv[1]?.endsWith("main.js");
+if (isDirectExecution) {
+  startServer().catch((err) => {
+    log.error({ err }, "Fatal error");
+    process.exit(1);
+  });
+}
+export {
+  RESTART_EXIT_CODE,
+  startServer
+};
+//# sourceMappingURL=main-T5WVCCFN.js.map