@zonease/happy 0.6.42 → 0.6.44

package/dist/{downloadImage-Cijmufpr.cjs → downloadImage-B7MKUI0u.cjs}

@@ -1,34 +1,8 @@
 'use strict';
 
-var logger = require('./persistence-BcQmjobZ.cjs');
+var logger = require('./persistence-DOgft4tZ.cjs');
 var crypto = require('crypto');
-var path = require('node:path');
-var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
-var node_http = require('node:http');
-var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-var types_js = require('@modelcontextprotocol/sdk/types.js');
-var z = require('zod');
-var deviceKeys = require('./deviceKeys-DyUn0bEx.cjs');
-var node_crypto = require('node:crypto');
-var prompt = require('./prompt-BTWDZZO0.cjs');
-require('./mcpToolSchemas-DK42yoZ_.cjs');
-require('./index-BeKrqPYR.cjs');
 var axios = require('axios');
-require('node:events');
-require('socket.io-client');
-require('./api-CIE4_cWd.cjs');
-require('tweetnacl');
-require('ws');
-require('@stablelib/base64');
-require('node:os');
-require('node:fs/promises');
-require('node:fs');
-require('node:readline');
-require('node:child_process');
-require('expo-server-sdk');
-require('chalk');
-require('./types-DWeB7aqh.cjs');
 
 function parseCompact(message) {
   const trimmed = message.trim();
@@ -427,338 +401,6 @@ function hashObject(obj, options, encoding = "hex") {
   return crypto.createHash("sha256").update(jsonString).digest(encoding);
 }
 
-function createMcpServer(client, options) {
-  const mcp = new mcp_js.McpServer({
-    name: "Happy MCP",
-    version: "1.0.0"
-  });
-  const handler = async (title) => {
-    logger.logger.debug("[happyMCP] Changing title to:", title);
-    if (client.isTitlePinned) {
-      return { success: false, error: "Title is pinned by user and cannot be changed automatically" };
-    }
-    try {
-      client.sendClaudeSessionMessage({
-        type: "summary",
-        summary: title,
-        leafUuid: node_crypto.randomUUID()
-      });
-      return { success: true };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  };
-  mcp.registerTool("device_list", {
-    description: "List enrolled Happy devices (servers and computers) with their online state. Use before device_exec when you need a device id.",
-    title: "List Devices",
-    inputSchema: {}
-  }, async () => {
-    const credentials = await logger.readCredentials();
-    if (!credentials) {
-      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
-    }
-    try {
-      const devices = await deviceKeys.listDevices(credentials);
-      const target = client.targetDevices.map((device) => device.id);
-      const lines = devices.map((device) => {
-        const marks = [device.active ? "online" : "offline"];
-        if (target.includes(device.id)) marks.push("session default");
-        return `${device.id}  ${device.name}${device.platform ? ` (${device.platform})` : ""}  [${marks.join(", ")}]${device.description ? `  \u2014 ${device.description}` : ""}`;
-      });
-      return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "No devices enrolled yet." }] };
-    } catch (error) {
-      return { content: [{ type: "text", text: `Failed to list devices: ${error instanceof Error ? error.message : String(error)}` }] };
-    }
-  });
-  mcp.registerTool("device_exec", {
-    description: "Run a shell command on an enrolled device (a server or computer registered in Happy). Omit deviceId to use the device the user selected for this session. Returns stdout, stderr and exit code.",
-    title: "Run Command on Device",
-    inputSchema: {
-      command: z.z.string().describe("Shell command to run on the device"),
-      deviceId: z.z.string().optional().describe("Target device id. Defaults to the session's selected device."),
-      cwd: z.z.string().optional().describe("Working directory on the device"),
-      timeout: z.z.number().optional().describe("Timeout in milliseconds (default 60000)")
-    }
-  }, async (args) => {
-    const credentials = await logger.readCredentials();
-    if (!credentials) {
-      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
-    }
-    const targets = client.targetDevices;
-    const deviceId = args.deviceId || (targets.length === 1 ? targets[0].id : null);
-    if (!deviceId && targets.length > 1) {
-      return { content: [{ type: "text", text: `This session targets several devices \u2014 pass deviceId: ${targets.map((device) => `${device.name} (${device.id})`).join(", ")}` }] };
-    }
-    if (!deviceId) {
-      return { content: [{ type: "text", text: "No device selected for this session. Pick one in the app or pass deviceId (see device_list)." }] };
-    }
-    try {
-      const result = await deviceKeys.deviceExec(client.rpcSocket, credentials, deviceId, args.command, {
-        cwd: args.cwd,
-        timeout: args.timeout,
-        deviceKeyBase64: targets.find((device) => device.id === deviceId)?.key ?? null
-      });
-      const parts = [`exit code: ${result.exitCode}`];
-      if (result.stdout) parts.push(`stdout:
-${result.stdout}`);
-      if (result.stderr) parts.push(`stderr:
-${result.stderr}`);
-      return { content: [{ type: "text", text: parts.join("\n\n") }] };
-    } catch (error) {
-      return { content: [{ type: "text", text: `Device command failed: ${error instanceof Error ? error.message : String(error)}` }] };
-    }
-  });
-  mcp.registerTool("change_title", {
-    description: "Change the title of the current chat session",
-    title: "Change Chat Title",
-    inputSchema: {
-      title: z.z.string().describe("The new title for the chat session")
-    }
-  }, async (args) => {
-    const response = await handler(args.title);
-    logger.logger.debug("[happyMCP] Response:", response);
-    if (response.success) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Successfully changed chat title to: "${args.title}"`
-          }
-        ],
-        isError: false
-      };
-    } else {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to change chat title: ${response.error || "Unknown error"}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-  mcp.registerTool("preview_html", {
-    description: "Preview an HTML page in the client app. The HTML must be a complete, self-contained document with all CSS and JS inlined.",
-    title: "Preview HTML",
-    inputSchema: {
-      html: z.z.string().describe("Complete self-contained HTML document string"),
-      title: z.z.string().optional().describe("Display title for the preview")
-    }
-  }, async (args) => {
-    logger.logger.debug("[happyMCP] Preview HTML:", args.title || "Untitled");
-    return {
-      content: [{
-        type: "text",
-        text: `HTML preview ready: ${args.title || "Untitled"}`
-      }],
-      isError: false
-    };
-  });
-  return mcp;
-}
-async function startHappyServer(client) {
-  const transports = /* @__PURE__ */ new Map();
-  const enableOrchestratorTools = prompt.shouldEnableOrchestratorTools();
-  const toolNames = ["change_title", "preview_html", "device_list", "device_exec"];
-  const originalConsoleError = console.error;
-  console.error = (...args) => {
-    logger.logger.debug("[happyMCP] console.error:", ...args);
-    originalConsoleError.apply(console, args);
-  };
-  const server = node_http.createServer(async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    logger.logger.debug("[happyMCP] Received request:", req.method, req.url, "sessionId:", sessionId);
-    try {
-      if (req.method === "POST") {
-        const body = await readRequestBody(req);
-        const parsedBody = JSON.parse(body);
-        let transport;
-        if (sessionId && transports.has(sessionId)) {
-          transport = transports.get(sessionId);
-          logger.logger.debug("[happyMCP] Reusing transport for session:", sessionId);
-        } else if (!sessionId && types_js.isInitializeRequest(parsedBody)) {
-          logger.logger.debug("[happyMCP] New initialize request, creating transport");
-          transport = new streamableHttp_js.StreamableHTTPServerTransport({
-            sessionIdGenerator: () => node_crypto.randomUUID(),
-            onsessioninitialized: (newSessionId) => {
-              logger.logger.debug("[happyMCP] Session initialized:", newSessionId);
-              transports.set(newSessionId, transport);
-            }
-          });
-          transport.onclose = () => {
-            const sid = transport.sessionId;
-            if (sid && transports.has(sid)) {
-              logger.logger.debug("[happyMCP] Transport closed, removing session:", sid);
-              transports.delete(sid);
-            }
-          };
-          transport.onerror = (error) => {
-            logger.logger.debug("[happyMCP] Transport error:", error);
-          };
-          const mcp = createMcpServer(client, { enableOrchestratorTools });
-          await mcp.connect(transport);
-          await transport.handleRequest(req, res, parsedBody);
-          logger.logger.debug("[happyMCP] Initialize request handled successfully");
-          return;
-        } else {
-          logger.logger.debug("[happyMCP] Bad request: no session ID and not initialize");
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({
-            jsonrpc: "2.0",
-            error: {
-              code: -32e3,
-              message: "Bad Request: No valid session ID provided"
-            },
-            id: null
-          }));
-          return;
-        }
-        await transport.handleRequest(req, res, parsedBody);
-        logger.logger.debug("[happyMCP] Request handled successfully");
-      } else if (req.method === "GET" || req.method === "DELETE") {
-        if (!sessionId || !transports.has(sessionId)) {
-          logger.logger.debug("[happyMCP] Bad request: invalid session for GET/DELETE");
-          res.writeHead(400, { "Content-Type": "text/plain" });
-          res.end("Invalid or missing session ID");
-          return;
-        }
-        const transport = transports.get(sessionId);
-        await transport.handleRequest(req, res);
-        logger.logger.debug("[happyMCP] GET/DELETE request handled successfully");
-      } else {
-        res.writeHead(405, { "Content-Type": "text/plain" });
-        res.end("Method not allowed");
-      }
-    } catch (error) {
-      logger.logger.debug("[happyMCP] Error handling request:", error);
-      if (!res.headersSent) {
-        res.writeHead(500).end();
-      }
-    }
-  });
-  const baseUrl = await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolve(new URL(`http://127.0.0.1:${addr.port}`));
-    });
-  });
-  logger.logger.debug("[happyMCP] Server started at:", baseUrl.toString());
-  return {
-    url: baseUrl.toString(),
-    toolNames,
-    stop: async () => {
-      logger.logger.debug("[happyMCP] Stopping server");
-      for (const [sessionId, transport] of transports) {
-        logger.logger.debug("[happyMCP] Closing transport for session:", sessionId);
-        try {
-          await transport.close();
-        } catch (error) {
-          logger.logger.debug("[happyMCP] Error closing transport:", error);
-        }
-      }
-      transports.clear();
-      server.close();
-    }
-  };
-}
-function readRequestBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = "";
-    req.on("data", (chunk) => body += chunk);
-    req.on("end", () => resolve(body));
-    req.on("error", reject);
-  });
-}
-
-const getBridgeCommand = () => path.join(projectPath.projectPath(), "bin", "happy-mcp.mjs");
-function adaptForClaude(def) {
-  return { type: "http", url: def.url, ...def.headers && { headers: def.headers } };
-}
-function adaptForStdio(def) {
-  const args = ["--url", def.url];
-  if (def.headers) {
-    for (const [k, v] of Object.entries(def.headers)) {
-      args.push("--header", `${k}: ${v}`);
-    }
-  }
-  return { command: getBridgeCommand(), args };
-}
-function adaptForHttp(def) {
-  return { type: "http", url: def.url, headers: def.headers || {} };
-}
-async function createMcpContext(session) {
-  const happyServer = await startHappyServer(session);
-  const servers = {
-    happy: {
-      url: happyServer.url,
-      toolNames: happyServer.toolNames,
-      stop: () => happyServer.stop()
-    }
-  };
-  const extraServersJson = process.env.HAPPY_EXTRA_MCP_SERVERS;
-  if (extraServersJson) {
-    try {
-      const extraServers = JSON.parse(extraServersJson);
-      for (const srv of extraServers) {
-        servers[srv.name] = {
-          url: srv.url,
-          toolNames: [],
-          // External MCP — tools discovered by agent, not whitelisted
-          headers: srv.headers,
-          stop: () => {
-          }
-          // No lifecycle management for external servers
-        };
-      }
-    } catch (e) {
-      console.warn("Failed to parse HAPPY_EXTRA_MCP_SERVERS:", e);
-    }
-  }
-  return {
-    configForClaude() {
-      const result = {};
-      for (const [name, def] of Object.entries(servers)) {
-        result[name] = adaptForClaude(def);
-      }
-      return result;
-    },
-    configForStdio() {
-      const result = {};
-      for (const [name, def] of Object.entries(servers)) {
-        result[name] = adaptForStdio(def);
-      }
-      return result;
-    },
-    configForHttp() {
-      const result = {};
-      for (const [name, def] of Object.entries(servers)) {
-        result[name] = adaptForHttp(def);
-      }
-      return result;
-    },
-    allowedToolNames() {
-      return Object.entries(servers).flatMap(
-        ([name, def]) => def.toolNames.map((tool) => `mcp__${name}__${tool}`)
-      );
-    },
-    normalizeToolName(rawName) {
-      for (const [name, def] of Object.entries(servers)) {
-        if (def.toolNames.includes(rawName)) {
-          return `mcp:${name}:${rawName}`;
-        }
-      }
-      return rawName;
-    },
-    stop() {
-      for (const def of Object.values(servers)) {
-        def.stop();
-      }
-    }
-  };
-}
-
 class MessageBuffer {
   messages = [];
   listeners = [];
@@ -829,17 +471,6 @@ class MessageBuffer {
   }
 }
 
-function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
-  rpcHandlerManager.registerHandler("killSession", async () => {
-    logger.logger.debug("Kill session request received");
-    void killThisHappy();
-    return {
-      success: true,
-      message: "Killing happy-cli process"
-    };
-  });
-}
-
 async function downloadImage(url) {
   const response = await axios.get(url, {
     responseType: "arraybuffer"
@@ -855,9 +486,7 @@ async function downloadImage(url) {
 
 exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
-exports.createMcpContext = createMcpContext;
 exports.downloadImage = downloadImage;
 exports.hashObject = hashObject;
 exports.parseClear = parseClear;
 exports.parseSpecialCommand = parseSpecialCommand;
-exports.registerKillSessionHandler = registerKillSessionHandler;