@zonease/happy 0.6.42 → 0.6.43

package/dist/lib.d.mts

@@ -1073,6 +1073,7 @@ type Metadata = {
     }> | null;
     machineId?: string;
     claudeSessionId?: string;
+    cursorSessionId?: string;
     tools?: string[];
     slashCommands?: string[];
     skills?: Array<{

package/dist/lib.mjs

@@ -1,5 +1,5 @@
-export { A as ApiClient, a as ApiSessionClient } from './api-Ew6xr81i.mjs';
-export { c as configuration, l as logger } from './persistence-D9tMm6bj.mjs';
+export { A as ApiClient, a as ApiSessionClient } from './api-BUCtd3cB.mjs';
+export { c as configuration, l as logger } from './persistence-DbLMvLvk.mjs';
 export { R as RawJSONLinesSchema } from './types-BoJh4Qfv.mjs';
 import 'axios';
 import 'node:events';
@@ -28,6 +28,6 @@ import 'tweetnacl';
 import '@stablelib/base64';
 import 'node:readline';
 import 'expo-server-sdk';
-import './sessionKeyCache-pXTjpETo.mjs';
+import './sessionKeyCache-DtBS_Sb3.mjs';
 import 'chalk';
 import 'fs';

package/dist/{loadableToolOutput-DPGTtKJM.cjs → loadableToolOutput-B3qpMqXT.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var logger = require('./persistence-BcQmjobZ.cjs');
-var api = require('./api-CIE4_cWd.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var api = require('./api-B-PlVQY6.cjs');
 
 class BaseReasoningProcessor {
   accumulator = "";

package/dist/{loadableToolOutput-2dMPAp4N.mjs → loadableToolOutput-DzReWITb.mjs}

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
-import { l as logger } from './persistence-D9tMm6bj.mjs';
-import { s as saveToolOutputRecord } from './api-Ew6xr81i.mjs';
+import { l as logger } from './persistence-DbLMvLvk.mjs';
+import { s as saveToolOutputRecord } from './api-BUCtd3cB.mjs';
 
 class BaseReasoningProcessor {
   accumulator = "";

package/dist/{persistence-BcQmjobZ.cjs → persistence-D7zNFI-d.cjs}

@@ -35,7 +35,7 @@ function isDebug() {
 }
 
 var name = "@zonease/happy";
-var version = "0.6.42";
+var version = "0.6.43";
 var description = "Mobile and Web client for Claude Code, Codex, and Gemini";
 var author = "ZonEaseTech";
 var license = "MIT";

package/dist/{persistence-D9tMm6bj.mjs → persistence-DbLMvLvk.mjs}

@@ -14,7 +14,7 @@ function isDebug() {
 }
 
 var name = "@zonease/happy";
-var version = "0.6.42";
+var version = "0.6.43";
 var description = "Mobile and Web client for Claude Code, Codex, and Gemini";
 var author = "ZonEaseTech";
 var license = "MIT";

package/dist/{push-Cnm6JQMD.cjs → push-RT6Y0Hr3.cjs}

@@ -2,8 +2,8 @@
 
 var promises = require('node:fs/promises');
 var socket_ioClient = require('socket.io-client');
-var logger = require('./persistence-BcQmjobZ.cjs');
-var ssh = require('./ssh-C4YTSHXL.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var ssh = require('./ssh-CsnS89Lr.cjs');
 require('node:fs');
 require('node:os');
 require('node:path');
@@ -12,16 +12,16 @@ require('node:crypto');
 require('tweetnacl');
 require('chalk');
 require('fs');
-require('./deviceKeys-DyUn0bEx.cjs');
+require('./deviceKeys-CdW-HPnz.cjs');
 require('axios');
-require('./auth-G9fZpVJ2.cjs');
+require('./auth-BqGkUXvq.cjs');
 require('qrcode-terminal');
 require('./time-Bj2HRkKH.cjs');
-require('./browser-qDIIAL7S.cjs');
+require('./browser-CY7VNU0C.cjs');
 require('open');
 require('react');
 require('ink');
-require('./controlClient-CEz_p1zc.cjs');
+require('./controlClient-yTkpwcOq.cjs');
 require('./projectPath-ChLhdOyt.cjs');
 require('path');
 require('url');

package/dist/{push-Dxsugkes.mjs → push-z5wQ4Ki_.mjs}

@@ -1,7 +1,7 @@
 import { stat, readFile } from 'node:fs/promises';
 import { io } from 'socket.io-client';
-import { c as configuration, e as encodeBase64, f as encrypt, g as decrypt, h as decodeBase64 } from './persistence-D9tMm6bj.mjs';
-import { resolveDeviceForCommand } from './ssh-8tPIKk-i.mjs';
+import { c as configuration, e as encodeBase64, f as encrypt, g as decrypt, h as decodeBase64 } from './persistence-DbLMvLvk.mjs';
+import { resolveDeviceForCommand } from './ssh-C-nEZiGP.mjs';
 import 'node:fs';
 import 'node:os';
 import 'node:path';
@@ -10,16 +10,16 @@ import 'node:crypto';
 import 'tweetnacl';
 import 'chalk';
 import 'fs';
-import './deviceKeys-B4aqjnE6.mjs';
+import './deviceKeys-CQyFFPtt.mjs';
 import 'axios';
-import './auth-Q2STUNI-.mjs';
+import './auth-qM2eojWx.mjs';
 import 'qrcode-terminal';
 import './time-DgsBLJA_.mjs';
-import './browser-BI7s-V8E.mjs';
+import './browser-D5RN_Axa.mjs';
 import 'open';
 import 'react';
 import 'ink';
-import './controlClient-DoS9JqQC.mjs';
+import './controlClient-BzzTNSfl.mjs';
 import './projectPath-BTBIMB57.mjs';
 import 'path';
 import 'url';

package/dist/registerKillSessionHandler-DmfnJ0zq.mjs

@@ -0,0 +1,407 @@
+import { join, resolve, dirname } from 'node:path';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createServer } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { l as logger, r as readCredentials } from './persistence-DbLMvLvk.mjs';
+import { l as listDevices, d as deviceExec } from './deviceKeys-CQyFFPtt.mjs';
+import { randomUUID } from 'node:crypto';
+import { s as shouldEnableOrchestratorTools } from './prompt-BsAZsPbo.mjs';
+import './mcpToolSchemas-CjeTfrAs.mjs';
+import './index-DTV7drqs.mjs';
+import { execSync } from 'node:child_process';
+import 'axios';
+import 'node:events';
+import 'socket.io-client';
+import './api-BUCtd3cB.mjs';
+import 'tweetnacl';
+import 'ws';
+import 'crypto';
+import '@stablelib/base64';
+import 'node:os';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:readline';
+import 'expo-server-sdk';
+import 'chalk';
+import './types-BoJh4Qfv.mjs';
+
+function createMcpServer(client, options) {
+  const mcp = new McpServer({
+    name: "Happy MCP",
+    version: "1.0.0"
+  });
+  const handler = async (title) => {
+    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: 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 readCredentials();
+    if (!credentials) {
+      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
+    }
+    try {
+      const devices = await 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.string().describe("Shell command to run on the device"),
+      deviceId: z.string().optional().describe("Target device id. Defaults to the session's selected device."),
+      cwd: z.string().optional().describe("Working directory on the device"),
+      timeout: z.number().optional().describe("Timeout in milliseconds (default 60000)")
+    }
+  }, async (args) => {
+    const credentials = await 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 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.string().describe("The new title for the chat session")
+    }
+  }, async (args) => {
+    const response = await handler(args.title);
+    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.string().describe("Complete self-contained HTML document string"),
+      title: z.string().optional().describe("Display title for the preview")
+    }
+  }, async (args) => {
+    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 = shouldEnableOrchestratorTools();
+  const toolNames = ["change_title", "preview_html", "device_list", "device_exec"];
+  const originalConsoleError = console.error;
+  console.error = (...args) => {
+    logger.debug("[happyMCP] console.error:", ...args);
+    originalConsoleError.apply(console, args);
+  };
+  const server = createServer(async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    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.debug("[happyMCP] Reusing transport for session:", sessionId);
+        } else if (!sessionId && isInitializeRequest(parsedBody)) {
+          logger.debug("[happyMCP] New initialize request, creating transport");
+          transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (newSessionId) => {
+              logger.debug("[happyMCP] Session initialized:", newSessionId);
+              transports.set(newSessionId, transport);
+            }
+          });
+          transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid && transports.has(sid)) {
+              logger.debug("[happyMCP] Transport closed, removing session:", sid);
+              transports.delete(sid);
+            }
+          };
+          transport.onerror = (error) => {
+            logger.debug("[happyMCP] Transport error:", error);
+          };
+          const mcp = createMcpServer(client, { enableOrchestratorTools });
+          await mcp.connect(transport);
+          await transport.handleRequest(req, res, parsedBody);
+          logger.debug("[happyMCP] Initialize request handled successfully");
+          return;
+        } else {
+          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.debug("[happyMCP] Request handled successfully");
+      } else if (req.method === "GET" || req.method === "DELETE") {
+        if (!sessionId || !transports.has(sessionId)) {
+          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.debug("[happyMCP] GET/DELETE request handled successfully");
+      } else {
+        res.writeHead(405, { "Content-Type": "text/plain" });
+        res.end("Method not allowed");
+      }
+    } catch (error) {
+      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.debug("[happyMCP] Server started at:", baseUrl.toString());
+  return {
+    url: baseUrl.toString(),
+    toolNames,
+    stop: async () => {
+      logger.debug("[happyMCP] Stopping server");
+      for (const [sessionId, transport] of transports) {
+        logger.debug("[happyMCP] Closing transport for session:", sessionId);
+        try {
+          await transport.close();
+        } catch (error) {
+          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 = () => join(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();
+      }
+    }
+  };
+}
+
+function detectGitWorktree(cwd) {
+  try {
+    const gitDir = execSync("git rev-parse --git-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const absGitDir = resolve(cwd, gitDir);
+    const absCommonDir = resolve(cwd, gitCommonDir);
+    if (absGitDir === absCommonDir) {
+      return { isWorktree: false };
+    }
+    const basePath = dirname(absCommonDir);
+    const branchName = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return {
+      isWorktree: true,
+      worktreeBasePath: basePath,
+      worktreeBranchName: branchName || void 0
+    };
+  } catch {
+    return { isWorktree: false };
+  }
+}
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
+export { createMcpContext as c, detectGitWorktree as d, registerKillSessionHandler as r };