very-happy-cli 0.2.159 → 0.2.160

package/dist/deterministicJson-C5CYTVpm.cjs

@@ -0,0 +1,507 @@
+'use strict';
+
+var index = require('./index-DA7yINuk.cjs');
+var promises = require('node:fs/promises');
+var node_crypto = require('node:crypto');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var z = require('zod');
+var client = require('./client-3Ac-O4pw.cjs');
+var context = require('./context-DsDr6E2t.cjs');
+var sessionOps = require('./sessionOps-Dn8z85h_.cjs');
+var resources = require('./resources-JDPugcDq.cjs');
+var tools = require('./tools-Be3AoAwu.cjs');
+var tools$1 = require('./tools-DQj0AeLk.cjs');
+var peerTools = require('./peerTools-BvKtHXj8.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 logger = require('./logger-CS0mw3fa.cjs');
+var limits = require('./limits-C-a7gr04.cjs');
+var assistantTools = require('./assistantTools-BTqPnlFl.cjs');
+var agentGuidance = require('./agentGuidance-B5NATuFa.cjs');
+var previewPath = require('./previewPath-B0rBdhy1.cjs');
+var crypto = require('crypto');
+
+const TEAMS_ADOPT_CAPABILITY = "teams-adopt-v1";
+const TeamAdoptSchema = z.z.object({
+  requestId: z.z.string().min(1).max(128),
+  name: z.z.string().trim().min(1).max(128),
+  teamId: z.z.string().min(1).max(128).optional()
+}).strict();
+async function retainIntent(path$1, input) {
+  await promises.mkdir(path.dirname(path$1), { recursive: true, mode: 448 });
+  let file;
+  try {
+    file = await promises.open(path$1, node_fs.constants.O_WRONLY | node_fs.constants.O_CREAT | node_fs.constants.O_EXCL, 384);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw new Error("Cannot retain team connection request");
+  }
+  if (file) {
+    try {
+      await file.writeFile(JSON.stringify(input));
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    return { fresh: true };
+  }
+  const existing = await promises.open(path$1, node_fs.constants.O_RDONLY | (node_fs.constants.O_NOFOLLOW ?? 0));
+  try {
+    const stat = await existing.stat();
+    if (!stat.isFile() || process.platform !== "win32" && (stat.mode & 63) !== 0 || typeof process.getuid === "function" && stat.uid !== process.getuid()) throw new Error("Unsafe team connection receipt");
+    const stored = JSON.parse(await existing.readFile("utf8"));
+    const { resolvedTeamId, guidanceDelivered, ...request } = stored;
+    const previous = TeamAdoptSchema.parse(request);
+    if (JSON.stringify(previous) !== JSON.stringify(input)) throw new Error("Another team connection request already exists; retry the original request");
+    if (resolvedTeamId !== void 0 && (typeof resolvedTeamId !== "string" || !resolvedTeamId)) throw new Error("Invalid connection receipt");
+    if (guidanceDelivered !== void 0 && typeof guidanceDelivered !== "boolean") throw new Error("Invalid guidance receipt");
+    return { resolvedTeamId, guidanceDelivered };
+  } finally {
+    await existing.close();
+  }
+}
+async function retainTeam(path, input, resolvedTeamId, guidanceDelivered = false) {
+  const temporary = `${path}.${node_crypto.randomUUID()}.new`;
+  const file = await promises.open(temporary, "wx", 384);
+  try {
+    await file.writeFile(JSON.stringify({ ...input, resolvedTeamId, guidanceDelivered }));
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  try {
+    await promises.rename(temporary, path);
+  } finally {
+    await promises.unlink(temporary).catch(() => {
+    });
+  }
+}
+function createTeamAdoption(sessionId) {
+  const client$1 = client.createTeamsClient(sessionId);
+  let current;
+  return (raw) => {
+    const parsed = TeamAdoptSchema.safeParse(raw);
+    if (!parsed.success) return { error: "Invalid team connection request" };
+    if (process.env.VH_TEAM_SCOPE_FILE) return { error: "Assigned team members cannot create or join another team" };
+    let path;
+    try {
+      path = `${context.teamScopePath(sessionId)}.adopt.json`;
+    } catch {
+      return { error: "A managed session identity is required" };
+    }
+    const input = parsed.data;
+    const signature = JSON.stringify(input);
+    if (current) {
+      if (current.signature !== signature && current.safeToChange) current = void 0;
+      else if (current.signature !== signature) return { error: "Another team connection request already exists; retry the original request" };
+    }
+    if (current) {
+      const result = current.result;
+      if (result && "error" in result) current = void 0;
+      return result ?? { status: "pending", requestId: input.requestId };
+    }
+    const operation = { signature };
+    current = operation;
+    void (async () => {
+      let intent;
+      try {
+        intent = await retainIntent(path, input);
+        const connected = await client$1.initialize(input, { resumeAdoption: true, expectedTeamId: intent.resolvedTeamId, onTeamResolved: (teamId) => retainTeam(path, input, teamId, intent?.guidanceDelivered) });
+        const instructions = `${resources.TEAM_SKILL}
+
+This session is now connected as the team lead. Call team_inspect to read the authoritative state before continuing the user's goal. Do not call team_create or team_join again.`;
+        if (!intent.guidanceDelivered) {
+          const key = await sessionOps.waitForSessionKey(sessionId, 1e4);
+          await sessionOps.sendUserMessage(sessionId, key, instructions, "teams", { localId: `teams-adopt-${input.requestId}`, sentFrom: "team" });
+          await retainTeam(path, input, connected.team.id, true);
+        }
+        operation.result = { status: "connected", teamId: connected.team.id, botId: connected.botId, instructions };
+      } catch (error) {
+        if (error instanceof client.TeamConnectionPreflightError && intent?.fresh && !intent.resolvedTeamId) {
+          await promises.unlink(path).catch(() => {
+          });
+          operation.safeToChange = true;
+        }
+        operation.result = { error: error instanceof Error ? error.message : "Team connection failed; retry the same request", ...operation.safeToChange ? { safeToChange: true } : {} };
+      }
+    })();
+    return { status: "pending", requestId: input.requestId };
+  };
+}
+
+const SELF_REPORT_MIN_INTERVAL_MS = 30 * 1e3;
+const SELF_REPORT_FRESH_MS = 15 * 60 * 1e3;
+const PROGRESS_MAX_CHARS = 200;
+function createSelfReportState() {
+  return { lastAcceptedAt: 0 };
+}
+function shouldAcceptSelfReport(state, now, attention) {
+  if (state.lastAcceptedAt === 0) return true;
+  if (attention !== void 0 && attention !== state.lastAttention) return true;
+  return now - state.lastAcceptedAt >= SELF_REPORT_MIN_INTERVAL_MS;
+}
+function isSelfReportFresh(state, now) {
+  if (state.lastAcceptedAt === 0) return false;
+  const age = now - state.lastAcceptedAt;
+  return age >= 0 && age < SELF_REPORT_FRESH_MS;
+}
+function normalizeProgress(value) {
+  if (typeof value !== "string") return null;
+  const flat = value.replace(/\s+/g, " ").trim();
+  if (!flat) return null;
+  return flat.length > PROGRESS_MAX_CHARS ? flat.slice(0, PROGRESS_MAX_CHARS) : flat;
+}
+
+function createMcpServer(handlers, options, sessionId, client) {
+  const mcp = new mcp_js.McpServer({
+    name: "Very Happy Tools",
+    version: "1.0.0"
+  });
+  tools.registerTeamsTools(mcp, sessionId);
+  tools$1.registerAutomationTools(mcp);
+  if (client) peerTools.registerSessionPeerTools(mcp, peerTools.createSessionPeerToolExecutor(client));
+  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 handlers.changeTitle(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(limits.CLIPBOARD_TOOL_NAME, {
+    description: limits.CLIPBOARD_TOOL_DESCRIPTION,
+    title: limits.CLIPBOARD_TOOL_TITLE,
+    inputSchema: {
+      text: z.z.string().describe("The text to copy to the user's clipboard")
+    }
+  }, async (args) => {
+    const response = await handlers.copyToClipboard(args.text);
+    logger.logger.debug("[happyMCP] copy_to_clipboard response:", response);
+    if (response.delivered) {
+      const note = response.truncated ? ` (truncated to ${limits.CLIPBOARD_MAX_BYTES / 1024}KB \u2014 original was ${response.totalBytes} bytes)` : "";
+      return {
+        content: [{
+          type: "text",
+          text: `Queued a clipboard request for the user's open Very Happy device(s)${note}. This does not confirm that a browser wrote the clipboard; the user may need to tap a confirmation button.`
+        }],
+        isError: false
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `Failed to push to clipboard: ${response.error || "not connected to the server"}`
+      }],
+      isError: true
+    };
+  });
+  mcp.registerTool(agentGuidance.PREVIEW_TOOL_NAME, {
+    description: agentGuidance.PREVIEW_TOOL_DESCRIPTION,
+    title: agentGuidance.PREVIEW_TOOL_TITLE,
+    inputSchema: {
+      path: z.z.string().describe("Absolute path (or ~/\u2026) of the file to show the user"),
+      mode: z.z.enum(["file", "diff"]).optional().describe("'file' (default) renders the file; 'diff' is reserved and currently falls back to 'file'")
+    }
+  }, async (args) => {
+    const response = await handlers.openPreview(args.path, args.mode ?? "file");
+    logger.logger.debug("[happyMCP] open_preview response:", response);
+    if (response.delivered) {
+      return {
+        content: [{
+          type: "text",
+          // 明说不保证用户看到了——否则 claude 会基于「已预览」做后续推断（spec 风险 8）
+          text: `Asked the user's open web client(s) to preview ${response.resolved ?? args.path}. This does not confirm they looked at it.`
+        }],
+        isError: false
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Could not open preview: ${response.error || "unknown error"}` }],
+      isError: true
+    };
+  });
+  mcp.registerTool(agentGuidance.REPORT_PROGRESS_TOOL_NAME, {
+    description: agentGuidance.REPORT_PROGRESS_TOOL_DESCRIPTION,
+    title: agentGuidance.REPORT_PROGRESS_TOOL_TITLE,
+    inputSchema: {
+      progress: z.z.string().describe("One short line describing the current state of this task"),
+      attention: z.z.enum(["none", "review", "blocked"]).optional().describe("'blocked' = cannot proceed without the user; 'review' = wants their eyes; 'none' = ordinary progress")
+    }
+  }, async (args) => {
+    const response = await handlers.reportProgress(args.progress, args.attention ?? "none");
+    logger.logger.debug("[happyMCP] report_progress response:", response);
+    if (response.accepted) {
+      return { content: [{ type: "text", text: "Board updated." }], isError: false };
+    }
+    return {
+      content: [{ type: "text", text: response.error || "Report skipped (reported too recently); no need to retry." }],
+      isError: false
+    };
+  });
+  if (options?.assistant && !process.env.VH_TEAM_SCOPE_FILE) {
+    assistantTools.registerAssistantTools(mcp);
+  }
+  return mcp;
+}
+async function startHappyServer(client, options) {
+  logger.logger.debug(`[happyMCP] server:start sessionId=${client.sessionId} assistant=${!!options?.assistant}`);
+  const selfReportState = options?.selfReportState ?? createSelfReportState();
+  const handlers = {
+    openPreview: async (path, mode) => {
+      const verdict = previewPath.checkPreviewPath(path);
+      if (verdict.deniedReason) {
+        logger.logger.debug(`[happyMCP] open_preview denied: ${verdict.deniedReason}`);
+        return { delivered: false, error: verdict.deniedReason };
+      }
+      try {
+        const result = client.pushFilePreview(verdict.resolved, mode);
+        return { delivered: result.delivered, resolved: verdict.resolved, error: result.error };
+      } catch (error) {
+        return { delivered: false, error: String(error) };
+      }
+    },
+    reportProgress: async (progress, attention) => {
+      const text = normalizeProgress(progress);
+      if (!text) {
+        return { accepted: false, error: "progress must be a non-empty one-line string" };
+      }
+      const now = Date.now();
+      if (!shouldAcceptSelfReport(selfReportState, now, attention)) {
+        return { accepted: false };
+      }
+      selfReportState.lastAcceptedAt = now;
+      selfReportState.lastAttention = attention;
+      try {
+        client.updateMetadata((metadata) => ({
+          ...metadata,
+          board: {
+            ...metadata?.board,
+            attention,
+            progress: text,
+            analyzedAt: now,
+            // ⚠️ 这个字段**到不了 web**：web 的 MetadataSchema.board 是普通
+            // zod object（非 passthrough），safeParse 会把它剥掉；而 web 下
+            // 一次写 metadata 又会用剥净的对象回写，把它从服务端也删掉。
+            // 留着是为了 daemon 侧日志/未来把字段加进 web schema 时能对上，
+            // **别拿它做 UI**（review finding 5：原注释声称能区分自报与
+            // haiku 猜的，不成立）。
+            source: "self-report"
+          }
+        }));
+        return { accepted: true };
+      } catch (error) {
+        return { accepted: false, error: String(error) };
+      }
+    },
+    changeTitle: async (title) => {
+      logger.logger.debug("[happyMCP] Changing title to:", title);
+      try {
+        client.sendClaudeSessionMessage({
+          type: "summary",
+          summary: title,
+          leafUuid: node_crypto.randomUUID()
+        });
+        return { success: true };
+      } catch (error) {
+        return { success: false, error: String(error) };
+      }
+    },
+    copyToClipboard: async (text) => {
+      logger.logger.debug(`[happyMCP] Pushing ${text.length} chars to clipboard`);
+      try {
+        return client.pushClipboard(text);
+      } catch (error) {
+        return { delivered: false, truncated: false, totalBytes: 0, error: String(error) };
+      }
+    }
+  };
+  const contextPath = "/runtime-context/" + node_crypto.randomUUID();
+  const server = node_http.createServer(async (req, res) => {
+    if (req.url?.startsWith("/runtime-context/")) {
+      if (!options?.onContextUsage || req.url !== contextPath || req.method !== "POST" || req.headers.origin) {
+        res.writeHead(403).end();
+        return;
+      }
+      try {
+        let body = "";
+        for await (const chunk of req) {
+          body += chunk.toString();
+          if (Buffer.byteLength(body) > 2048) {
+            res.writeHead(413).end();
+            return;
+          }
+        }
+        const usage = index.ContextUsageSchema.parse({ ...JSON.parse(body), updatedAt: Date.now() });
+        options.onContextUsage(usage);
+        res.writeHead(204).end();
+      } catch {
+        if (!res.headersSent) res.writeHead(400).end();
+      }
+      return;
+    }
+    const mcp = createMcpServer(handlers, options, client.sessionId, client);
+    try {
+      const transport = new streamableHttp_js.StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0
+      });
+      await mcp.connect(transport);
+      await transport.handleRequest(req, res);
+      res.on("close", () => {
+        transport.close();
+        mcp.close();
+      });
+    } catch (error) {
+      logger.logger.debug("Error handling request:", error);
+      if (!res.headersSent) {
+        res.writeHead(500).end();
+      }
+      mcp.close();
+    }
+  });
+  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}`));
+    });
+  });
+  const adoptionEnabled = !process.env.VH_TEAM_SCOPE_FILE;
+  if (adoptionEnabled) {
+    client.rpcHandlerManager.registerHandler("teams-adopt", createTeamAdoption(client.sessionId));
+    client.updateMetadata((metadata) => ({ ...metadata, capabilities: [.../* @__PURE__ */ new Set([...metadata.capabilities ?? [], TEAMS_ADOPT_CAPABILITY])] }));
+  }
+  logger.logger.debug(`[happyMCP] server:ready sessionId=${client.sessionId} url=${baseUrl.toString()}`);
+  return {
+    url: baseUrl.toString(),
+    contextUsageUrl: options?.onContextUsage ? new URL(contextPath, baseUrl).toString() : void 0,
+    toolNames: [
+      "change_title",
+      limits.CLIPBOARD_TOOL_NAME,
+      agentGuidance.PREVIEW_TOOL_NAME,
+      agentGuidance.REPORT_PROGRESS_TOOL_NAME,
+      ...tools.TEAM_TOOL_NAMES,
+      ...tools$1.AUTOMATION_TOOL_NAMES,
+      ...peerTools.SESSION_PEER_TOOL_NAMES,
+      ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? assistantTools.ASSISTANT_TOOL_NAMES : []
+    ],
+    stop: () => {
+      logger.logger.debug(`[happyMCP] server:stop sessionId=${client.sessionId}`);
+      if (adoptionEnabled) client.rpcHandlerManager.unregisterHandler("teams-adopt");
+      server.close();
+    }
+  };
+}
+
+function deterministicStringify(obj, options = {}) {
+  const {
+    undefinedBehavior = "omit",
+    sortArrays = false,
+    replacer,
+    includeSymbols = false
+  } = options;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function processValue(value, key) {
+    if (replacer && key !== void 0) {
+      value = replacer(key, value);
+    }
+    if (value === null) return null;
+    if (value === void 0) {
+      switch (undefinedBehavior) {
+        case "omit":
+          return void 0;
+        case "null":
+          return null;
+        case "throw":
+          throw new Error(`Undefined value at key: ${key}`);
+      }
+    }
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (typeof value === "function") {
+      return void 0;
+    }
+    if (typeof value === "symbol") {
+      return includeSymbols ? value.toString() : void 0;
+    }
+    if (typeof value === "bigint") {
+      return value.toString() + "n";
+    }
+    if (seen.has(value)) {
+      throw new Error("Circular reference detected");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const processed2 = value.map((item, index) => processValue(item, String(index))).filter((item) => item !== void 0);
+      if (sortArrays) {
+        processed2.sort((a, b) => {
+          const aStr = JSON.stringify(processValue(a));
+          const bStr = JSON.stringify(processValue(b));
+          return aStr.localeCompare(bStr);
+        });
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    if (value.constructor === Object || value.constructor === void 0) {
+      const processed2 = {};
+      const keys = Object.keys(value).sort();
+      for (const k of keys) {
+        const processedValue = processValue(value[k], k);
+        if (processedValue !== void 0) {
+          processed2[k] = processedValue;
+        }
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    try {
+      const plain = { ...value };
+      seen.delete(value);
+      return processValue(plain, key);
+    } catch {
+      seen.delete(value);
+      return String(value);
+    }
+  }
+  const processed = processValue(obj);
+  return JSON.stringify(processed);
+}
+function hashObject(obj, options, encoding = "hex") {
+  const jsonString = deterministicStringify(obj, options);
+  return crypto.createHash("sha256").update(jsonString).digest(encoding);
+}
+
+exports.createSelfReportState = createSelfReportState;
+exports.hashObject = hashObject;
+exports.isSelfReportFresh = isSelfReportFresh;
+exports.startHappyServer = startHappyServer;