@adhdev/daemon-standalone 0.1.0

package/dist/index.js

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_http = require("http");
+var import_ws = require("ws");
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var import_daemon_core = require("@adhdev/daemon-core");
+var DEFAULT_PORT = 3847;
+var STATUS_INTERVAL = 2e3;
+var StandaloneServer = class {
+  httpServer = null;
+  wss = null;
+  clients = /* @__PURE__ */ new Set();
+  authToken = null;
+  statusTimer = null;
+  running = false;
+  // daemon-core components
+  providerLoader;
+  instanceManager;
+  cliManager;
+  commandHandler = null;
+  agentStreamManager = null;
+  statusReporter = null;
+  cdpManagers = /* @__PURE__ */ new Map();
+  instanceIdMap = /* @__PURE__ */ new Map();
+  detectedIdes = [];
+  devServer = null;
+  constructor() {
+    this.providerLoader = new import_daemon_core.ProviderLoader({
+      builtinDir: path.join(__dirname, "..", "..", "daemon-cloud", "providers", "_builtin")
+    });
+    this.providerLoader.loadAll();
+    this.providerLoader.registerToDetector();
+    this.instanceManager = new import_daemon_core.ProviderInstanceManager();
+    this.cliManager = new import_daemon_core.DaemonCliManager({
+      getServerConn: () => null,
+      getP2p: () => null,
+      onStatusChange: () => this.broadcastStatus(),
+      removeAgentTracking: () => {
+      },
+      getInstanceManager: () => this.instanceManager
+    }, this.providerLoader);
+  }
+  async start(options = {}) {
+    const port = options.port || DEFAULT_PORT;
+    const host = options.host || "127.0.0.1";
+    this.authToken = options.token || process.env.ADHDEV_TOKEN || null;
+    (0, import_daemon_core.installGlobalInterceptor)();
+    console.log("\u{1F50D} Detecting IDEs...");
+    this.detectedIdes = await (0, import_daemon_core.detectIDEs)();
+    const installed = this.detectedIdes.filter((i) => i.installed);
+    console.log(`   Found ${installed.length} IDE(s): ${installed.map((i) => i.id).join(", ") || "none"}`);
+    await this.initCdp();
+    if (options.dev) {
+      this.devServer = new import_daemon_core.DevServer({
+        providerLoader: this.providerLoader,
+        cdpManagers: this.cdpManagers,
+        logFn: (msg) => console.log(msg)
+      });
+      await this.devServer.start();
+    }
+    for (const ide of this.detectedIdes) {
+      if (!ide.installed) continue;
+      const cdp = this.cdpManagers.get(ide.id);
+      if (!cdp) continue;
+      const provider = this.providerLoader.resolve(ide.id);
+      if (!provider) continue;
+      const instance = new import_daemon_core.IdeProviderInstance(provider, ide.id);
+      const context = {
+        cdp: cdp || void 0,
+        serverConn: void 0,
+        settings: {}
+      };
+      await this.instanceManager.addInstance(ide.id, instance, context);
+      this.instanceIdMap.set(instance.getInstanceId(), ide.id);
+    }
+    this.instanceManager.startTicking(3e3);
+    this.commandHandler = new import_daemon_core.DaemonCommandHandler({
+      cdpManagers: this.cdpManagers,
+      ideType: "unknown",
+      adapters: this.cliManager.adapters,
+      providerLoader: this.providerLoader,
+      instanceIdMap: this.instanceIdMap
+    });
+    this.agentStreamManager = new import_daemon_core.DaemonAgentStreamManager(
+      console.log,
+      this.providerLoader
+    );
+    this.commandHandler.setAgentStreamManager(this.agentStreamManager);
+    this.httpServer = (0, import_http.createServer)((req, res) => {
+      this.handleHttp(req, res, options.publicDir);
+    });
+    this.wss = new import_ws.WebSocketServer({ noServer: true });
+    this.httpServer.on("upgrade", (req, socket, head) => {
+      const wsUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+      if (wsUrl.pathname === "/ws") {
+        if (this.authToken) {
+          const urlToken = wsUrl.searchParams.get("token");
+          if (urlToken !== this.authToken) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+          }
+        }
+        this.wss.handleUpgrade(req, socket, head, (ws) => {
+          this.handleWsConnection(ws);
+        });
+      } else {
+        socket.destroy();
+      }
+    });
+    this.statusTimer = setInterval(() => {
+      this.broadcastStatus();
+    }, STATUS_INTERVAL);
+    this.running = true;
+    await new Promise((resolve) => {
+      this.httpServer.listen(port, host, () => {
+        resolve();
+      });
+    });
+    console.log("");
+    console.log("\u{1F680} ADHDev Standalone Server");
+    console.log(`   http://${host === "0.0.0.0" ? "localhost" : host}:${port}`);
+    console.log(`   ws://${host === "0.0.0.0" ? "localhost" : host}:${port}/ws`);
+    if (host === "0.0.0.0") {
+      const lanIps = this.getLanIPs();
+      for (const ip of lanIps) {
+        console.log(`   http://${ip}:${port}  (LAN)`);
+      }
+    }
+    if (this.authToken) {
+      console.log(`   \u{1F511} Token: ${this.authToken}`);
+    }
+    console.log("");
+    const cdpCount = [...this.cdpManagers.values()].filter((m) => m.isConnected).length;
+    console.log(`   CDP: ${cdpCount > 0 ? `\u2705 ${cdpCount} connected` : "\u274C none"}`);
+    console.log(`   Providers: ${this.providerLoader.getAll().length} loaded`);
+    if (options.dev) {
+      console.log(`   \u{1F6E0}\uFE0F  DevConsole: http://127.0.0.1:19280`);
+    }
+    console.log("");
+    console.log("   Press Ctrl+C to stop.");
+    console.log("");
+    if (options.open !== false) {
+      try {
+        const open = (await import("open")).default;
+        await open(`http://localhost:${port}`);
+      } catch {
+      }
+    }
+    process.on("SIGINT", () => this.stop());
+    process.on("SIGTERM", () => this.stop());
+  }
+  // ─── HTTP Handler ───
+  handleHttp(req, res, publicDir) {
+    const url = req.url || "/";
+    const method = req.method || "GET";
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (this.authToken && url.startsWith("/api/")) {
+      const authHeader = req.headers["authorization"];
+      const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+      const queryToken = new URL(url, `http://${req.headers.host || "localhost"}`).searchParams.get("token");
+      if (bearerToken !== this.authToken && queryToken !== this.authToken) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized. Provide token via Authorization header or ?token= query." }));
+        return;
+      }
+    }
+    const apiPath = url.startsWith("/api/v1/") ? url.slice(7) : null;
+    if (apiPath === "/status" && method === "GET") {
+      const status = this.getStatus();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(status));
+      return;
+    }
+    if (apiPath === "/ides" && method === "GET") {
+      const ides = this.getIdes();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ides }));
+      return;
+    }
+    if (apiPath === "/clis" && method === "GET") {
+      const clis = this.getClis();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ clis }));
+      return;
+    }
+    if (apiPath === "/agents" && method === "GET") {
+      const ides = this.getIdes();
+      const agents = [];
+      for (const ide of ides) {
+        const chat = ide.activeChat;
+        if (chat) {
+          agents.push({
+            ideId: ide.id,
+            type: ide.type,
+            name: ide.name || ide.type,
+            status: chat.status || "idle",
+            source: "native"
+          });
+        }
+        for (const stream of ide.agentStreams || []) {
+          agents.push({
+            ideId: ide.id,
+            type: stream.agentType,
+            name: stream.agentName,
+            status: stream.status || "idle",
+            source: "extension"
+          });
+        }
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ agents }));
+      return;
+    }
+    if (apiPath === "/command" && method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", async () => {
+        try {
+          const { type, payload, target } = JSON.parse(body);
+          const args = { ...payload, _targetInstance: target };
+          const result = await this.executeCommand(type, args);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: false, error: e.message }));
+        }
+      });
+      return;
+    }
+    if (publicDir) {
+      const filePath = url === "/" ? "/index.html" : url;
+      const fullPath = path.join(publicDir, filePath);
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+        const ext = path.extname(fullPath);
+        const mimeTypes = {
+          ".html": "text/html",
+          ".js": "application/javascript",
+          ".css": "text/css",
+          ".json": "application/json",
+          ".png": "image/png",
+          ".svg": "image/svg+xml",
+          ".ico": "image/x-icon",
+          ".woff2": "font/woff2"
+        };
+        res.writeHead(200, { "Content-Type": mimeTypes[ext] || "application/octet-stream" });
+        fs.createReadStream(fullPath).pipe(res);
+        return;
+      }
+      const indexPath = path.join(publicDir, "index.html");
+      if (fs.existsSync(indexPath) && !url.startsWith("/api/")) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        fs.createReadStream(indexPath).pipe(res);
+        return;
+      }
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  }
+  // ─── WebSocket Handler ───
+  handleWsConnection(ws) {
+    const MAX_WS_CLIENTS = 10;
+    if (this.clients.size >= MAX_WS_CLIENTS) {
+      const oldest = this.clients.values().next().value;
+      if (oldest) {
+        try {
+          oldest.close(1e3, "Too many connections");
+        } catch {
+        }
+        this.clients.delete(oldest);
+      }
+    }
+    this.clients.add(ws);
+    console.log(`[WS] Client connected (total: ${this.clients.size})`);
+    const status = this.getStatus();
+    ws.send(JSON.stringify({ type: "status", data: status }));
+    ws.on("message", async (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.type === "command" && msg.data) {
+          const { type, payload, target } = msg.data;
+          const requestId = msg.requestId;
+          const args = { ...payload, _targetInstance: target };
+          const result = await this.executeCommand(type, args);
+          ws.send(JSON.stringify({ type: "command_result", requestId, data: result }));
+        }
+      } catch (e) {
+        const requestId = (() => {
+          try {
+            return JSON.parse(raw.toString()).requestId;
+          } catch {
+            return void 0;
+          }
+        })();
+        ws.send(JSON.stringify({ type: "error", requestId, data: { message: e.message } }));
+      }
+    });
+    ws.on("close", () => {
+      this.clients.delete(ws);
+      console.log(`[WS] Client disconnected (total: ${this.clients.size})`);
+    });
+    ws.on("error", () => {
+      this.clients.delete(ws);
+    });
+  }
+  // ─── Core Logic ───
+  getStatus() {
+    const machineId = os.hostname().replace(/[^a-zA-Z0-9]/g, "_");
+    const ides = this.getIdes();
+    const clis = this.getClis();
+    const cpus2 = os.cpus();
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const loadavg2 = os.loadavg();
+    return {
+      id: `standalone_${machineId}`,
+      type: "standalone",
+      platform: os.platform(),
+      hostname: os.hostname(),
+      timestamp: Date.now(),
+      ides,
+      clis,
+      cdpConnected: [...this.cdpManagers.values()].some((m) => m.isConnected),
+      detectedIdes: this.detectedIdes.filter((i) => i.installed).map((i) => ({
+        id: i.id,
+        type: i.id,
+        name: i.displayName || i.name,
+        installed: true,
+        running: this.cdpManagers.has(i.id) && this.cdpManagers.get(i.id).isConnected
+      })),
+      availableProviders: this.providerLoader.getAll().map((p) => ({
+        type: p.type,
+        icon: p.icon || "\u{1F4BB}",
+        displayName: p.displayName || p.type,
+        category: p.category
+      })),
+      system: {
+        cpus: cpus2.length,
+        totalMem,
+        freeMem,
+        loadavg: loadavg2,
+        uptime: os.uptime(),
+        arch: os.arch()
+      }
+    };
+  }
+  getIdes() {
+    const result = [];
+    const allStates = this.instanceManager.collectAllStates();
+    const ideStates = allStates.filter((s) => s.category === "ide");
+    for (const state of ideStates) {
+      const cdp = this.cdpManagers.get(state.type);
+      result.push({
+        id: `standalone:ide:${state.instanceId || state.type}`,
+        instanceId: state.instanceId || state.type,
+        type: state.type,
+        name: state.name || state.type,
+        cdpConnected: cdp?.isConnected || false,
+        cdpPort: cdp?.getPort?.(),
+        chatHistory: state.activeChat?.messages || [],
+        activeChat: state.activeChat || null,
+        agents: [],
+        agentStreams: (state.extensions || []).map((ext) => ({
+          agentType: ext.type,
+          agentName: ext.name,
+          extensionId: ext.type,
+          status: ext.status || "idle",
+          messages: ext.activeChat?.messages || [],
+          inputContent: ext.activeChat?.inputContent || "",
+          activeModal: ext.activeChat?.activeModal || null
+        })),
+        workspaceFolders: state.workspaceFolders || [],
+        activeFile: state.activeFile || null,
+        currentModel: state.currentModel,
+        currentPlan: state.currentPlan
+      });
+    }
+    const coveredTypes = new Set(ideStates.map((s) => s.type));
+    for (const ide of this.detectedIdes) {
+      if (!ide.installed || coveredTypes.has(ide.id)) continue;
+      const cdp = this.cdpManagers.get(ide.id);
+      if (!cdp?.isConnected) continue;
+      result.push({
+        id: `standalone:ide:${ide.id}`,
+        instanceId: ide.id,
+        type: ide.id,
+        name: ide.displayName || ide.id,
+        cdpConnected: true,
+        cdpPort: cdp?.getPort?.(),
+        chatHistory: [],
+        activeChat: null,
+        agents: [],
+        agentStreams: []
+      });
+    }
+    return result;
+  }
+  getClis() {
+    const result = [];
+    for (const [key, adapter] of this.cliManager.adapters.entries()) {
+      result.push({
+        id: `standalone:cli:${key}`,
+        cliId: key,
+        type: adapter.cliType || key,
+        isRunning: true
+      });
+    }
+    return result;
+  }
+  async executeCommand(type, args) {
+    if (!this.commandHandler) {
+      return { success: false, error: "Command handler not initialized" };
+    }
+    switch (type) {
+      case "launch_ide": {
+        const result2 = await (0, import_daemon_core.launchWithCdp)(args);
+        if (result2.success && result2.port && result2.ideId && !this.cdpManagers.has(result2.ideId)) {
+          const manager = new import_daemon_core.DaemonCdpManager(result2.port, (msg) => {
+            console.log(`[CDP:${result2.ideId}] ${msg}`);
+          });
+          const connected = await manager.connect();
+          if (connected) {
+            this.cdpManagers.set(result2.ideId, manager);
+            console.log(`[CDP] Connected: ${result2.ideId} (port ${result2.port})`);
+          }
+        }
+        return { success: result2.success, ...result2 };
+      }
+      case "detect_ides": {
+        this.detectedIdes = await (0, import_daemon_core.detectIDEs)();
+        return { success: true, ides: this.detectedIdes };
+      }
+      case "launch_cli":
+      case "stop_cli": {
+        return this.cliManager.handleCliCommand(type, args);
+      }
+      case "get_logs": {
+        const count = args?.count || 100;
+        const minLevel = args?.minLevel || "info";
+        const sinceTs = args?.since || 0;
+        let logs = (0, import_daemon_core.getRecentLogs)(count, minLevel);
+        if (sinceTs > 0) {
+          logs = logs.filter((l) => l.ts > sinceTs);
+        }
+        return { success: true, logs };
+      }
+    }
+    const result = await this.commandHandler.handle(type, args);
+    (0, import_daemon_core.logCommand)({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd: type, source: "standalone", args, success: result.success, durationMs: 0 });
+    return result;
+  }
+  broadcastStatus() {
+    if (this.clients.size === 0) return;
+    const status = this.getStatus();
+    const msg = JSON.stringify({ type: "status", data: status });
+    const cdpCount = [...this.cdpManagers.values()].filter((m) => m.isConnected).length;
+    import_daemon_core.LOG.debug("Broadcast", `status \u2192 ${this.clients.size} client(s), ${status.ides?.length || 0} IDE(s), ${cdpCount} CDP`);
+    for (const client of this.clients) {
+      if (client.readyState === import_ws.WebSocket.OPEN) {
+        client.send(msg);
+      }
+    }
+  }
+  // ─── CDP Init ───
+  async initCdp() {
+    const cdpPortMap = this.providerLoader.getCdpPortMap?.() || {};
+    for (const ide of this.detectedIdes) {
+      if (!ide.installed) continue;
+      const candidates = [];
+      if (ide.cdpPort) {
+        candidates.push(ide.cdpPort);
+      }
+      const providerPorts = cdpPortMap[ide.id];
+      if (providerPorts) {
+        for (let p = providerPorts[0]; p <= providerPorts[1]; p++) {
+          if (!candidates.includes(p)) candidates.push(p);
+        }
+      }
+      if (candidates.length === 0) continue;
+      for (const port of candidates) {
+        try {
+          const probe = await fetch(`http://localhost:${port}/json/version`, {
+            signal: AbortSignal.timeout(1e3)
+          }).then((r) => r.json()).catch(() => null);
+          if (!probe) continue;
+          const manager = new import_daemon_core.DaemonCdpManager(port, (msg) => {
+            console.log(`[CDP:${ide.id}] ${msg}`);
+          });
+          const connected = await manager.connect();
+          if (connected) {
+            const enabledExtProviders = this.providerLoader.getEnabledExtensionProviders(ide.id).map((p) => ({
+              agentType: p.type,
+              extensionId: p.extensionId || "",
+              extensionIdPattern: p.extensionIdPattern
+            }));
+            manager.setExtensionProviders(enabledExtProviders);
+            this.cdpManagers.set(ide.id, manager);
+            console.log(`   \u2705 CDP connected: ${ide.id} (port ${port})`);
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+    setInterval(async () => {
+      const portMap = this.providerLoader.getCdpPortMap?.() || {};
+      for (const [ide, ports] of Object.entries(portMap)) {
+        const alreadyConnected = [...this.cdpManagers.entries()].some(
+          ([key, m]) => m.isConnected && (key === ide || key.startsWith(ide + "_"))
+        );
+        if (alreadyConnected) continue;
+        const primaryPort = ports[0];
+        try {
+          const probe = await fetch(`http://localhost:${primaryPort}/json/version`, {
+            signal: AbortSignal.timeout(1e3)
+          }).then((r) => r.json()).catch(() => null);
+          if (!probe) continue;
+          const manager = new import_daemon_core.DaemonCdpManager(primaryPort, (msg) => {
+            console.log(`[CDP:${ide}] ${msg}`);
+          });
+          const connected = await manager.connect();
+          if (connected) {
+            const enabledExtProviders = this.providerLoader.getEnabledExtensionProviders(ide).map((p) => ({
+              agentType: p.type,
+              extensionId: p.extensionId || "",
+              extensionIdPattern: p.extensionIdPattern
+            }));
+            manager.setExtensionProviders(enabledExtProviders);
+            this.cdpManagers.set(ide, manager);
+            console.log(`[CDP-Scan] \u2705 Auto-connected: ${ide} (port ${primaryPort})`);
+            const provider = this.providerLoader.resolve(ide);
+            if (provider) {
+              const instance = new import_daemon_core.IdeProviderInstance(provider, ide);
+              await this.instanceManager.addInstance(ide, instance, {
+                cdp: manager,
+                serverConn: void 0,
+                settings: {}
+              });
+              this.instanceIdMap.set(instance.getInstanceId(), ide);
+            }
+            this.broadcastStatus();
+          }
+        } catch {
+        }
+      }
+    }, 15e3);
+  }
+  // ─── Network ───
+  getLanIPs() {
+    const interfaces = os.networkInterfaces();
+    const ips = [];
+    for (const iface of Object.values(interfaces)) {
+      if (!iface) continue;
+      for (const info of iface) {
+        if (info.family === "IPv4" && !info.internal) {
+          ips.push(info.address);
+        }
+      }
+    }
+    return ips;
+  }
+  // ─── Lifecycle ───
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    console.log("\n   Shutting down...");
+    if (this.statusTimer) {
+      clearInterval(this.statusTimer);
+      this.statusTimer = null;
+    }
+    for (const ws of this.clients) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    for (const m of this.cdpManagers.values()) {
+      try {
+        m.disconnect();
+      } catch {
+      }
+    }
+    this.cdpManagers.clear();
+    try {
+      await this.cliManager.shutdownAll();
+    } catch {
+    }
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
+    }
+    console.log("   \u2713 ADHDev Standalone stopped.\n");
+    process.exit(0);
+  }
+};
+async function main() {
+  const args = process.argv.slice(2);
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--port" || args[i] === "-p") && args[i + 1]) {
+      options.port = parseInt(args[i + 1]);
+      i++;
+    }
+    if (args[i] === "--host" || args[i] === "-H") {
+      options.host = "0.0.0.0";
+    }
+    if (args[i] === "--public" && args[i + 1]) {
+      options.publicDir = args[i + 1];
+      i++;
+    }
+    if (args[i] === "--no-open") {
+      options.open = false;
+    }
+    if (args[i] === "--dev") {
+      options.dev = true;
+    }
+    if (args[i] === "--token" && args[i + 1]) {
+      options.token = args[i + 1];
+      i++;
+    }
+  }
+  if (!options.publicDir) {
+    const candidates = [
+      path.join(__dirname, "../../web-standalone/dist"),
+      path.join(__dirname, "../public"),
+      path.join(process.cwd(), "public")
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(path.join(candidate, "index.html"))) {
+        options.publicDir = candidate;
+        break;
+      }
+    }
+  }
+  const server = new StandaloneServer();
+  await server.start(options);
+  await new Promise(() => {
+  });
+}
+main().catch((e) => {
+  console.error("Fatal error:", e);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map