@delt/claude-alarm 0.1.0 → 0.1.2

package/dist/cli.js

@@ -12,7 +12,7 @@ var __export = (target, all) => {
 // src/shared/constants.ts
 import path from "path";
 import os from "os";
-var DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, CONFIG_DIR, CONFIG_FILE, PID_FILE, LOG_FILE, WS_PATH_CHANNEL, WS_PATH_DASHBOARD;
+var DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, CONFIG_DIR, CONFIG_FILE, PID_FILE, LOG_FILE, WS_PATH_CHANNEL, WS_PATH_DASHBOARD, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION;
 var init_constants = __esm({
   "src/shared/constants.ts"() {
     "use strict";
@@ -24,6 +24,88 @@ var init_constants = __esm({
     LOG_FILE = path.join(CONFIG_DIR, "hub.log");
     WS_PATH_CHANNEL = "/ws/channel";
     WS_PATH_DASHBOARD = "/ws/dashboard";
+    CHANNEL_SERVER_NAME = "claude-alarm";
+    CHANNEL_SERVER_VERSION = "0.1.0";
+  }
+});
+
+// src/shared/config.ts
+import fs from "fs";
+import path2 from "path";
+import { randomUUID } from "crypto";
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let config2;
+  if (!fs.existsSync(CONFIG_FILE)) {
+    config2 = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+  } else {
+    try {
+      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      config2 = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub } };
+    } catch {
+      config2 = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+    }
+  }
+  if (!config2.hub.token) {
+    config2.hub.token = randomUUID();
+    saveConfig(config2);
+  }
+  return config2;
+}
+function getOrCreateToken() {
+  const config2 = loadConfig();
+  return config2.hub.token;
+}
+function saveConfig(config2) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function setupMcpConfig(targetDir) {
+  const dir = targetDir ?? process.cwd();
+  const mcpPath = path2.join(dir, ".mcp.json");
+  let mcpConfig = {};
+  if (fs.existsSync(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+    } catch {
+      mcpConfig = {};
+    }
+  }
+  if (!mcpConfig.mcpServers) {
+    mcpConfig.mcpServers = {};
+  }
+  mcpConfig.mcpServers["claude-alarm"] = {
+    command: "npx",
+    args: ["-y", "@delt/claude-alarm", "serve"],
+    env: {
+      CLAUDE_ALARM_SESSION_NAME: path2.basename(dir)
+    }
+  };
+  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  return mcpPath;
+}
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/shared/config.ts"() {
+    "use strict";
+    init_constants();
+    DEFAULT_CONFIG = {
+      hub: {
+        host: DEFAULT_HUB_HOST,
+        port: DEFAULT_HUB_PORT
+      },
+      notifications: {
+        desktop: true,
+        sound: true
+      },
+      webhooks: []
+    };
   }
 });
 
@@ -61,27 +143,27 @@ var init_session_manager = __esm({
       register(session) {
         this.sessions.set(session.id, { ...session });
       }
-      unregister(sessionId) {
-        const session = this.sessions.get(sessionId);
-        this.sessions.delete(sessionId);
+      unregister(sessionId2) {
+        const session = this.sessions.get(sessionId2);
+        this.sessions.delete(sessionId2);
         return session;
       }
-      updateStatus(sessionId, status) {
-        const session = this.sessions.get(sessionId);
+      updateStatus(sessionId2, status) {
+        const session = this.sessions.get(sessionId2);
         if (session) {
           session.status = status;
           session.lastActivity = Date.now();
         }
         return session;
       }
-      updateActivity(sessionId) {
-        const session = this.sessions.get(sessionId);
+      updateActivity(sessionId2) {
+        const session = this.sessions.get(sessionId2);
         if (session) {
           session.lastActivity = Date.now();
         }
       }
-      get(sessionId) {
-        return this.sessions.get(sessionId);
+      get(sessionId2) {
+        return this.sessions.get(sessionId2);
       }
       getAll() {
         return Array.from(this.sessions.values());
@@ -240,17 +322,17 @@ var init_server = __esm({
       host;
       port;
       token;
-      constructor(config) {
-        this.host = config?.hub?.host ?? DEFAULT_HUB_HOST;
-        this.port = config?.hub?.port ?? DEFAULT_HUB_PORT;
-        this.token = config?.hub?.token;
-        if (config?.notifications) {
+      constructor(config2) {
+        this.host = config2?.hub?.host ?? DEFAULT_HUB_HOST;
+        this.port = config2?.hub?.port ?? DEFAULT_HUB_PORT;
+        this.token = config2?.hub?.token;
+        if (config2?.notifications) {
           this.notifier.configure({
-            desktop: config.notifications.desktop
+            desktop: config2.notifications.desktop
           });
         }
-        if (config?.webhooks) {
-          this.notifier.configure({ webhooks: config.webhooks });
+        if (config2?.webhooks) {
+          this.notifier.configure({ webhooks: config2.webhooks });
         }
         this.notifier.configure({ dashboardUrl: `http://${this.host}:${this.port}` });
         this.httpServer = http.createServer((req, res) => this.handleHttp(req, res));
@@ -375,17 +457,17 @@ var init_server = __esm({
           this.jsonResponse(res, 400, { error: "Invalid JSON" });
           return;
         }
-        const { sessionId, content } = body;
-        if (!sessionId || !content) {
+        const { sessionId: sessionId2, content } = body;
+        if (!sessionId2 || !content) {
           this.jsonResponse(res, 400, { error: "sessionId and content are required" });
           return;
         }
-        const ws = this.channelSockets.get(sessionId);
+        const ws = this.channelSockets.get(sessionId2);
         if (!ws || ws.readyState !== WebSocket.OPEN) {
           this.jsonResponse(res, 404, { error: "Session not connected" });
           return;
         }
-        const msg = { type: "message_to_session", sessionId, content };
+        const msg = { type: "message_to_session", sessionId: sessionId2, content };
         ws.send(JSON.stringify(msg));
         this.jsonResponse(res, 200, { ok: true });
       }
@@ -415,14 +497,14 @@ var init_server = __esm({
           }
         });
         ws.on("close", () => {
-          for (const [sessionId, sock] of this.channelSockets) {
+          for (const [sessionId2, sock] of this.channelSockets) {
             if (sock === ws) {
-              const session = this.sessions.unregister(sessionId);
-              this.channelSockets.delete(sessionId);
-              logger.info(`Channel disconnected: ${sessionId}`);
+              const session = this.sessions.unregister(sessionId2);
+              this.channelSockets.delete(sessionId2);
+              logger.info(`Channel disconnected: ${sessionId2}`);
               this.broadcastToDashboards({
                 type: "session_disconnected",
-                sessionId
+                sessionId: sessionId2
               });
               break;
             }
@@ -553,90 +635,287 @@ var init_server = __esm({
   }
 });
 
-// src/cli.ts
-import { spawn } from "child_process";
-import fs3 from "fs";
-import path4 from "path";
-import readline from "readline";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/shared/config.ts
-init_constants();
-import fs from "fs";
-import path2 from "path";
-import { randomUUID } from "crypto";
-var DEFAULT_CONFIG = {
-  hub: {
-    host: DEFAULT_HUB_HOST,
-    port: DEFAULT_HUB_PORT
-  },
-  notifications: {
-    desktop: true,
-    sound: true
-  },
-  webhooks: []
-};
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+// src/channel/hub-client.ts
+import WebSocket2 from "ws";
+var HubClient;
+var init_hub_client = __esm({
+  "src/channel/hub-client.ts"() {
+    "use strict";
+    init_logger();
+    init_constants();
+    HubClient = class {
+      constructor(sessionId2, sessionName2, hubHost2 = DEFAULT_HUB_HOST, hubPort2 = DEFAULT_HUB_PORT, token) {
+        this.sessionId = sessionId2;
+        this.sessionName = sessionName2;
+        this.hubHost = hubHost2;
+        this.hubPort = hubPort2;
+        this.token = token;
+      }
+      ws = null;
+      reconnectTimer = null;
+      messageHandlers = [];
+      queue = [];
+      connected = false;
+      connect() {
+        const tokenQuery = this.token ? `?token=${encodeURIComponent(this.token)}` : "";
+        const url = `ws://${this.hubHost}:${this.hubPort}${WS_PATH_CHANNEL}${tokenQuery}`;
+        logger.debug(`Connecting to hub at ${url}`);
+        try {
+          this.ws = new WebSocket2(url);
+          this.ws.on("open", () => {
+            logger.info("Connected to hub");
+            this.connected = true;
+            const registration = {
+              type: "register",
+              session: {
+                id: this.sessionId,
+                name: this.sessionName,
+                status: "idle",
+                connectedAt: Date.now(),
+                lastActivity: Date.now(),
+                cwd: process.cwd()
+              }
+            };
+            this.ws.send(JSON.stringify(registration));
+            for (const msg of this.queue) {
+              this.ws.send(JSON.stringify(msg));
+            }
+            this.queue = [];
+          });
+          this.ws.on("message", (data) => {
+            try {
+              const msg = JSON.parse(data.toString());
+              for (const handler of this.messageHandlers) {
+                handler(msg);
+              }
+            } catch (err) {
+              logger.warn("Failed to parse hub message:", err);
+            }
+          });
+          this.ws.on("close", () => {
+            logger.info("Disconnected from hub");
+            this.connected = false;
+            this.scheduleReconnect();
+          });
+          this.ws.on("error", (err) => {
+            logger.debug(`Hub connection error: ${err.message}`);
+            this.connected = false;
+          });
+        } catch {
+          logger.debug("Failed to connect to hub, will retry");
+          this.scheduleReconnect();
+        }
+      }
+      send(msg) {
+        if (this.connected && this.ws?.readyState === WebSocket2.OPEN) {
+          this.ws.send(JSON.stringify(msg));
+        } else {
+          if (this.queue.length < 100) {
+            this.queue.push(msg);
+          }
+          logger.debug("Hub not connected, message queued");
+        }
+      }
+      onMessage(handler) {
+        this.messageHandlers.push(handler);
+      }
+      disconnect() {
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        if (this.ws) {
+          this.ws.close();
+          this.ws = null;
+        }
+        this.connected = false;
+      }
+      scheduleReconnect() {
+        if (this.reconnectTimer) return;
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectTimer = null;
+          this.connect();
+        }, 5e3);
+      }
+    };
   }
-}
-function loadConfig() {
-  ensureConfigDir();
-  let config;
-  if (!fs.existsSync(CONFIG_FILE)) {
-    config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
-  } else {
-    try {
-      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-      const parsed = JSON.parse(raw);
-      config = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub } };
-    } catch {
-      config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+});
+
+// src/channel/server.ts
+var server_exports2 = {};
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID as randomUUID2 } from "crypto";
+async function main() {
+  logger.info(`Starting MCP channel server (session: ${sessionId})`);
+  hubClient.connect();
+  hubClient.onMessage(async (msg) => {
+    if (msg.type === "message_to_session" && msg.sessionId === sessionId) {
+      logger.info(`Message from dashboard: ${msg.content}`);
+      await server.notification({
+        method: "notifications/claude/channel",
+        params: {
+          content: msg.content,
+          meta: { sender: "dashboard", timestamp: String(Date.now()) }
+        }
+      });
     }
-  }
-  if (!config.hub.token) {
-    config.hub.token = randomUUID();
-    saveConfig(config);
-  }
-  return config;
-}
-function getOrCreateToken() {
-  const config = loadConfig();
-  return config.hub.token;
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("MCP channel server running on stdio");
 }
-function setupMcpConfig(targetDir) {
-  const dir = targetDir ?? process.cwd();
-  const mcpPath = path2.join(dir, ".mcp.json");
-  let mcpConfig = {};
-  if (fs.existsSync(mcpPath)) {
-    try {
-      mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
-    } catch {
-      mcpConfig = {};
-    }
-  }
-  if (!mcpConfig.mcpServers) {
-    mcpConfig.mcpServers = {};
+var sessionId, sessionName, server, config, hubHost, hubPort, hubToken, hubClient;
+var init_server2 = __esm({
+  "src/channel/server.ts"() {
+    "use strict";
+    init_logger();
+    init_constants();
+    init_config();
+    init_hub_client();
+    sessionId = randomUUID2();
+    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? `session-${sessionId.slice(0, 8)}`;
+    server = new Server(
+      {
+        name: CHANNEL_SERVER_NAME,
+        version: CHANNEL_SERVER_VERSION
+      },
+      {
+        capabilities: {
+          experimental: { "claude/channel": {} },
+          tools: {}
+        },
+        instructions: 'Messages from the claude-alarm dashboard arrive as <channel source="claude-alarm" sender="...">. Read the message and act on it. To reply, call the reply tool with the message content. Use the notify tool to send desktop notifications. Use the status tool to update your session status.'
+      }
+    );
+    config = loadConfig();
+    hubHost = process.env.CLAUDE_ALARM_HUB_HOST ?? config.hub.host;
+    hubPort = process.env.CLAUDE_ALARM_HUB_PORT ? parseInt(process.env.CLAUDE_ALARM_HUB_PORT, 10) : config.hub.port;
+    hubToken = process.env.CLAUDE_ALARM_HUB_TOKEN ?? config.hub.token;
+    hubClient = new HubClient(
+      sessionId,
+      sessionName,
+      hubHost,
+      hubPort,
+      hubToken
+    );
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "notify",
+          description: "Send a desktop notification to the user. Use this when you complete a task, encounter an error, or need user attention. The notification will appear as a system toast/popup.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              title: { type: "string", description: "Notification title (short)" },
+              message: { type: "string", description: "Notification body text" },
+              level: {
+                type: "string",
+                enum: ["info", "warning", "error", "success"],
+                description: "Notification level (default: info)"
+              }
+            },
+            required: ["title", "message"]
+          }
+        },
+        {
+          name: "reply",
+          description: "Send a message to the web dashboard. Use this to communicate status updates, results, or any information the user should see in the monitoring dashboard.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              content: { type: "string", description: "Message content to display on the dashboard" }
+            },
+            required: ["content"]
+          }
+        },
+        {
+          name: "status",
+          description: 'Update your session status displayed on the dashboard. Set to "working" when actively processing, "waiting_input" when you need user input, or "idle" when done.',
+          inputSchema: {
+            type: "object",
+            properties: {
+              status: {
+                type: "string",
+                enum: ["idle", "working", "waiting_input"],
+                description: "Current session status"
+              }
+            },
+            required: ["status"]
+          }
+        }
+      ]
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      switch (name) {
+        case "notify": {
+          const title = args?.title;
+          const message = args?.message;
+          const level = args?.level ?? "info";
+          logger.info(`Notify [${level}]: ${title} - ${message}`);
+          hubClient.send({
+            type: "notify",
+            sessionId,
+            title,
+            message,
+            level
+          });
+          return {
+            content: [{ type: "text", text: `Notification sent: "${title}"` }]
+          };
+        }
+        case "reply": {
+          const content = args?.content;
+          logger.info(`Reply: ${content.slice(0, 100)}...`);
+          hubClient.send({
+            type: "reply",
+            sessionId,
+            content
+          });
+          return {
+            content: [{ type: "text", text: "Message sent to dashboard." }]
+          };
+        }
+        case "status": {
+          const status = args?.status;
+          logger.info(`Status update: ${status}`);
+          hubClient.send({
+            type: "status",
+            sessionId,
+            status
+          });
+          return {
+            content: [{ type: "text", text: `Status updated to "${status}".` }]
+          };
+        }
+        default:
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            isError: true
+          };
+      }
+    });
+    main().catch((err) => {
+      logger.error("Fatal error:", err);
+      process.exit(1);
+    });
   }
-  mcpConfig.mcpServers["claude-alarm"] = {
-    command: "npx",
-    args: ["-y", "@delt/claude-alarm"],
-    env: {
-      CLAUDE_ALARM_SESSION_NAME: path2.basename(dir)
-    }
-  };
-  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-  return mcpPath;
-}
+});
 
 // src/cli.ts
+init_config();
 init_constants();
 init_logger();
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path4 from "path";
+import readline from "readline";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
 function printUsage() {
   console.log(`
@@ -657,9 +936,9 @@ Quick start:
 `);
 }
 async function hubStart(daemon) {
-  const config = loadConfig();
-  const host = config.hub.host ?? DEFAULT_HUB_HOST;
-  const port = config.hub.port ?? DEFAULT_HUB_PORT;
+  const config2 = loadConfig();
+  const host = config2.hub.host ?? DEFAULT_HUB_HOST;
+  const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   if (fs3.existsSync(PID_FILE)) {
     const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
@@ -682,7 +961,7 @@ async function hubStart(daemon) {
       child.unref();
       console.log(`Hub started as daemon (PID: ${child.pid})`);
       console.log(`Dashboard: http://${host}:${port}`);
-      console.log(`Token: ${config.hub.token}`);
+      console.log(`Token: ${config2.hub.token}`);
       console.log(`Logs: ${LOG_FILE}`);
     } else {
       console.error("Failed to start hub daemon");
@@ -690,9 +969,9 @@ async function hubStart(daemon) {
     }
   } else {
     console.log(`Starting hub on http://${host}:${port} (press Ctrl+C to stop)`);
-    console.log(`Token: ${config.hub.token}`);
+    console.log(`Token: ${config2.hub.token}`);
     const { HubServer: HubServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-    const hub = new HubServer2(config);
+    const hub = new HubServer2(config2);
     await hub.start();
     ensureConfigDir();
     fs3.writeFileSync(PID_FILE, String(process.pid), "utf-8");
@@ -721,9 +1000,9 @@ function hubStop() {
   fs3.unlinkSync(PID_FILE);
 }
 async function hubStatus() {
-  const config = loadConfig();
-  const host = config.hub.host ?? DEFAULT_HUB_HOST;
-  const port = config.hub.port ?? DEFAULT_HUB_PORT;
+  const config2 = loadConfig();
+  const host = config2.hub.host ?? DEFAULT_HUB_HOST;
+  const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   let pidInfo = "not running";
   if (fs3.existsSync(PID_FILE)) {
     const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
@@ -742,7 +1021,7 @@ async function hubStatus() {
       console.log(`Sessions: ${data.sessions}`);
       console.log(`Uptime: ${Math.round(data.uptime / 1e3)}s`);
       console.log(`Dashboard: http://${host}:${port}`);
-      const token = config.hub.token;
+      const token = config2.hub.token;
       if (token) {
         console.log(`Token: ${token.slice(0, 8)}...(masked)`);
       }
@@ -761,13 +1040,13 @@ function setup(targetDir) {
   console.log("  2. Run Claude Code: claude --dangerously-load-development-channels server:claude-alarm");
 }
 async function test() {
-  const config = loadConfig();
-  const host = config.hub.host ?? DEFAULT_HUB_HOST;
-  const port = config.hub.port ?? DEFAULT_HUB_PORT;
+  const config2 = loadConfig();
+  const host = config2.hub.host ?? DEFAULT_HUB_HOST;
+  const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   try {
     const headers = { "Content-Type": "application/json" };
-    if (config.hub.token) {
-      headers["Authorization"] = `Bearer ${config.hub.token}`;
+    if (config2.hub.token) {
+      headers["Authorization"] = `Bearer ${config2.hub.token}`;
     }
     const res = await fetch(`http://${host}:${port}/api/notify`, {
       method: "POST",
@@ -830,16 +1109,16 @@ claude-alarm init for "${projectName}"
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   mcpConfig.mcpServers["claude-alarm"] = {
     command: "npx",
-    args: ["-y", "@delt/claude-alarm"],
+    args: ["-y", "@delt/claude-alarm", "serve"],
     env
   };
   fs3.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   console.log(`
 \u2713 Created ${mcpPath}`);
   if (remote.toLowerCase() !== "y") {
-    const config = loadConfig();
-    const host = config.hub.host ?? DEFAULT_HUB_HOST;
-    const port = config.hub.port ?? DEFAULT_HUB_PORT;
+    const config2 = loadConfig();
+    const host = config2.hub.host ?? DEFAULT_HUB_HOST;
+    const port = config2.hub.port ?? DEFAULT_HUB_PORT;
     let hubRunning = false;
     try {
       const res = await fetch(`http://${host}:${port}/api/status`);
@@ -856,7 +1135,13 @@ claude-alarm init for "${projectName}"
   }
   console.log(`
 Next step:`);
-  console.log(`  claude --dangerously-load-development-channels server:claude-alarm
+  console.log(`  claude --dangerously-load-development-channels server:claude-alarm`);
+  console.log(`
+To skip permission prompts (allows remote control without approval):`);
+  console.log(`  claude --dangerously-load-development-channels server:claude-alarm --dangerously-skip-permissions`);
+  console.log(`
+  WARNING: --dangerously-skip-permissions allows Claude to execute any action`);
+  console.log(`  without your approval. Only use in trusted, isolated environments.
 `);
 }
 function showToken() {
@@ -871,7 +1156,7 @@ function isProcessRunning(pid) {
     return false;
   }
 }
-async function main() {
+async function main2() {
   const args = process.argv.slice(2);
   const cmd = args[0];
   const sub = args[1];
@@ -879,6 +1164,10 @@ async function main() {
     printUsage();
     return;
   }
+  if (cmd === "serve") {
+    await Promise.resolve().then(() => (init_server2(), server_exports2));
+    return;
+  }
   if (cmd === "init") {
     await init();
     return;
@@ -914,7 +1203,7 @@ async function main() {
   printUsage();
   process.exit(1);
 }
-main().catch((err) => {
+main2().catch((err) => {
   logger.error("CLI error:", err);
   process.exit(1);
 });