@zonease/happy 0.6.38 → 0.6.40

package/dist/sessionSummary-DCWQoaDP.mjs

@@ -0,0 +1,387 @@
+import axios from 'axios';
+import { z } from 'zod';
+import { q as decryptLegacy, f as decodeBase64, m as decryptWithDataKey, c as configuration } from './persistence-DKfF81pd.mjs';
+import { decryptWithEphemeralKey } from './auth-DxJ3VvrX.mjs';
+import { r as readCachedSessionKey } from './sessionKeyCache-B6cGadYL.mjs';
+
+function resolveSessionKey(credentials, dataEncryptionKey, sessionId) {
+  if (credentials.encryption.type === "legacy") {
+    return { key: credentials.encryption.secret, variant: "legacy" };
+  }
+  if (sessionId) {
+    const cached = readCachedSessionKey(sessionId, credentials.encryption.machineKey);
+    if (cached) {
+      return { key: cached, variant: "dataKey" };
+    }
+  }
+  if (!dataEncryptionKey) {
+    return null;
+  }
+  const blob = decodeBase64(dataEncryptionKey);
+  if (blob.length < 1 || blob[0] !== 0) {
+    return null;
+  }
+  const opened = decryptWithEphemeralKey(blob.slice(1), credentials.encryption.machineKey);
+  if (!opened) {
+    return null;
+  }
+  return { key: opened, variant: "dataKey" };
+}
+function decryptSessionRow(credentials, row) {
+  const resolved = resolveSessionKey(credentials, row.dataEncryptionKey, row.id);
+  if (!resolved) {
+    return null;
+  }
+  let metadata = null;
+  if (row.metadata) {
+    try {
+      metadata = resolved.variant === "legacy" ? decryptLegacy(decodeBase64(row.metadata), resolved.key) : decryptWithDataKey(decodeBase64(row.metadata), resolved.key);
+    } catch {
+      metadata = null;
+    }
+  }
+  let agentState = null;
+  if (row.agentState) {
+    try {
+      agentState = resolved.variant === "legacy" ? decryptLegacy(decodeBase64(row.agentState), resolved.key) : decryptWithDataKey(decodeBase64(row.agentState), resolved.key);
+    } catch {
+      agentState = null;
+    }
+  }
+  return {
+    id: row.id,
+    seq: row.seq,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    activeAt: row.activeAt,
+    active: row.active,
+    metadata,
+    agentState,
+    isShared: row.isShared,
+    encryptionKey: resolved.key,
+    encryptionVariant: resolved.variant
+  };
+}
+
+async function fetchSessionById(credentials, sessionId) {
+  const response = await axios.get(
+    `${configuration.serverUrl}/v1/sessions`,
+    {
+      headers: { Authorization: `Bearer ${credentials.token}` },
+      timeout: 1e4
+    }
+  );
+  const row = response.data.sessions.find((s) => s.id === sessionId);
+  if (!row) return null;
+  return decryptSessionRow(credentials, row);
+}
+
+function extractEncryptedBase64(content) {
+  if (typeof content === "string") return content;
+  if (content && typeof content === "object" && content.t === "encrypted" && typeof content.c === "string") {
+    return content.c;
+  }
+  return null;
+}
+function buildPreview(content) {
+  if (!content) return "";
+  if (content.type === "text" && typeof content.text === "string") {
+    return content.text;
+  }
+  if (content.type === "mixed" && typeof content.text === "string") {
+    return content.text;
+  }
+  if (content.type === "output") {
+    const data = content.data;
+    if (typeof data === "string") return data;
+    if (data && typeof data === "object") {
+      if (data.type === "message" && typeof data.message === "string") return data.message;
+      if (data.type === "reasoning" && typeof data.message === "string") return data.message;
+      if (typeof data.text === "string") return data.text;
+    }
+  }
+  return "";
+}
+function decryptMessage(raw, encryptionKey, encryptionVariant) {
+  const base64 = extractEncryptedBase64(raw.content);
+  let decrypted = null;
+  if (base64) {
+    try {
+      const bytes = decodeBase64(base64);
+      decrypted = encryptionVariant === "legacy" ? decryptLegacy(bytes, encryptionKey) : decryptWithDataKey(bytes, encryptionKey);
+    } catch {
+      decrypted = null;
+    }
+  }
+  const role = decrypted?.role === "user" || decrypted?.role === "agent" ? decrypted.role : "unknown";
+  const content = decrypted?.content ?? null;
+  return {
+    id: raw.id,
+    seq: raw.seq,
+    role,
+    content,
+    meta: decrypted?.meta ?? null,
+    textPreview: buildPreview(content),
+    sentBy: raw.sentBy,
+    sentByName: raw.sentByName,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt,
+    deliveryIssue: raw.deliveryIssue ?? void 0
+  };
+}
+
+const DEFAULT_LIMIT = 200;
+const DEFAULT_TEXT_LIMIT = 800;
+const DEFAULT_MAX_TURNS = 80;
+const DEFAULT_MAX_TOOLS_PER_TURN = 12;
+const sessionSummaryInputSchema = {
+  sessionId: z.string().describe("Target session ID (from happy_session_list)."),
+  limit: z.number().int().min(1).max(500).optional().describe(`Max raw messages to compact in this call. Default: ${DEFAULT_LIMIT}.`),
+  beforeSeq: z.number().int().min(1).optional().describe("Return messages with seq < this value (paginate backwards). Mutually exclusive with afterSeq."),
+  afterSeq: z.number().int().min(0).optional().describe("Return messages with seq > this value (paginate forwards). Mutually exclusive with beforeSeq."),
+  maxTurns: z.number().int().min(1).max(200).optional().describe(`Max compact turns to return. Default: ${DEFAULT_MAX_TURNS}.`),
+  textLimit: z.number().int().min(80).max(4e3).optional().describe(`Max chars per user/assistant text block. Default: ${DEFAULT_TEXT_LIMIT}.`),
+  includeTools: z.boolean().optional().describe("Include compact tool-use names. Default: true."),
+  maxToolsPerTurn: z.number().int().min(0).max(50).optional().describe(`Max tool names per turn when includeTools=true. Default: ${DEFAULT_MAX_TOOLS_PER_TURN}.`)
+};
+function trimText(text, limit) {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+  if (normalized.length <= limit) return normalized;
+  return `${normalized.slice(0, limit)}\u2026`;
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function imageCount(content) {
+  return Array.isArray(content?.images) ? content.images.length : 0;
+}
+function isHumanOnlyMessage(message) {
+  const meta = message.meta;
+  if (!meta || typeof meta !== "object") return false;
+  const collaboration = meta.collaboration;
+  return meta.humanOnly === true || meta.skipAiContext === true || collaboration?.kind === "mention";
+}
+function assistantContentItems(messageData) {
+  if (Array.isArray(messageData?.message?.content)) {
+    return messageData.message.content;
+  }
+  if (Array.isArray(messageData?.content)) {
+    return messageData.content;
+  }
+  return [];
+}
+function extractAssistantTexts(message, textLimit) {
+  const content = message.content;
+  if (content?.type !== "output") return [];
+  const data = content.data;
+  if (typeof data === "string") {
+    return [trimText(data, textLimit)].filter(Boolean);
+  }
+  if (!data || typeof data !== "object") return [];
+  const directMessage = typeof data.message === "string" ? data.message : null;
+  if (directMessage) {
+    return [trimText(directMessage, textLimit)].filter(Boolean);
+  }
+  const directText = typeof data.text === "string" ? data.text : null;
+  if (directText) {
+    return [trimText(directText, textLimit)].filter(Boolean);
+  }
+  return assistantContentItems(data).filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => trimText(item.text, textLimit)).filter(Boolean);
+}
+function extractToolNames(message) {
+  const content = message.content;
+  if (content?.type !== "output") return [];
+  const data = content.data;
+  if (!data || typeof data !== "object") return [];
+  const names = [];
+  for (const item of assistantContentItems(data)) {
+    if (item?.type === "tool_use" && typeof item.name === "string") {
+      names.push(item.name);
+    }
+    if (item?.type === "tool_call" && typeof item.name === "string") {
+      names.push(item.name);
+    }
+  }
+  const directToolName = typeof data.toolName === "string" ? data.toolName : typeof data.name === "string" && (data.type === "tool_call" || data.type === "tool_use") ? data.name : null;
+  if (directToolName) {
+    names.push(directToolName);
+  }
+  return names;
+}
+function pushTurn(turns, turn) {
+  if (!turn) return;
+  if (!turn.user && turn.assistantTexts.length === 0 && turn.tools.length === 0) return;
+  turns.push(turn);
+}
+function compactSessionMessages(messages, options) {
+  const chronological = [...messages].sort((a, b) => a.seq - b.seq);
+  const turns = [];
+  let current = null;
+  let compactedCount = 0;
+  for (const message of chronological) {
+    if (isHumanOnlyMessage(message)) {
+      continue;
+    }
+    if (message.role === "user") {
+      const content = message.content;
+      const text = typeof content?.text === "string" ? trimText(content.text, options.textLimit) : "";
+      if (!text && imageCount(content) === 0) continue;
+      pushTurn(turns, current);
+      current = {
+        startSeq: message.seq,
+        endSeq: message.seq,
+        startedAt: message.createdAt,
+        user: {
+          seq: message.seq,
+          createdAt: message.createdAt,
+          text,
+          imageCount: imageCount(content)
+        },
+        assistantTexts: [],
+        tools: [],
+        omittedToolCount: 0
+      };
+      compactedCount += 1;
+      continue;
+    }
+    const texts = extractAssistantTexts(message, options.textLimit);
+    const toolNames = options.includeTools ? extractToolNames(message) : [];
+    if (texts.length === 0 && toolNames.length === 0) continue;
+    if (!current) {
+      current = {
+        startSeq: message.seq,
+        endSeq: message.seq,
+        startedAt: message.createdAt,
+        user: null,
+        assistantTexts: [],
+        tools: [],
+        omittedToolCount: 0
+      };
+    }
+    current.endSeq = message.seq;
+    for (const text of texts) {
+      current.assistantTexts.push({ seq: message.seq, createdAt: message.createdAt, text });
+      compactedCount += 1;
+    }
+    for (const name of toolNames) {
+      if (current.tools.length < options.maxToolsPerTurn) {
+        current.tools.push({ seq: message.seq, createdAt: message.createdAt, name });
+      } else {
+        current.omittedToolCount += 1;
+      }
+      compactedCount += 1;
+    }
+  }
+  pushTurn(turns, current);
+  return {
+    turns: turns.slice(-options.maxTurns),
+    compactedCount
+  };
+}
+function formatTimestamp(ms) {
+  return new Date(ms).toISOString();
+}
+function buildSummaryText(result) {
+  const lines = [];
+  lines.push(`# Happy session ${result.sessionId}`);
+  lines.push("");
+  lines.push(`- Active: ${result.active ? "yes" : "no"}`);
+  lines.push(`- Agent: ${[result.agent.name, result.agent.model].filter(Boolean).join(" / ") || "unknown"}`);
+  lines.push(`- Path: ${result.path ?? "unknown"}`);
+  lines.push(`- Updated: ${formatTimestamp(result.updatedAt)}`);
+  if (result.storedSummary) {
+    lines.push(`- Stored summary: ${oneLine(result.storedSummary)}`);
+  }
+  lines.push(`- Window: ${result.messageWindow.rawCount} raw messages, ${result.messageWindow.compactedCount} compact items, hasMore=${result.messageWindow.hasMore}`);
+  lines.push("");
+  if (result.turns.length === 0) {
+    lines.push("No user/assistant text found in this window.");
+    return lines.join("\n");
+  }
+  result.turns.forEach((turn, index) => {
+    lines.push(`## Turn ${index + 1} (seq ${turn.startSeq}-${turn.endSeq})`);
+    if (turn.user) {
+      const imageSuffix = turn.user.imageCount > 0 ? ` [${turn.user.imageCount} image${turn.user.imageCount === 1 ? "" : "s"}]` : "";
+      lines.push(`User: ${oneLine(turn.user.text) || "(no text)"}${imageSuffix}`);
+    } else {
+      lines.push("User: (continuation before the first user message in this window)");
+    }
+    for (const text of turn.assistantTexts) {
+      lines.push(`Assistant: ${oneLine(text.text)}`);
+    }
+    if (turn.tools.length > 0) {
+      const omitted = turn.omittedToolCount > 0 ? `, +${turn.omittedToolCount} more` : "";
+      lines.push(`Tools: ${turn.tools.map((tool) => tool.name).join(", ")}${omitted}`);
+    }
+    lines.push("");
+  });
+  return lines.join("\n").trimEnd();
+}
+async function runSessionSummary(credentials, input) {
+  if (input.beforeSeq !== void 0 && input.afterSeq !== void 0) {
+    throw new Error("Specify only one of beforeSeq / afterSeq, not both.");
+  }
+  const session = await fetchSessionById(credentials, input.sessionId);
+  if (!session) {
+    throw new Error(`Session ${input.sessionId} not found or not decryptable.`);
+  }
+  const params = {
+    limit: String(input.limit ?? DEFAULT_LIMIT)
+  };
+  if (input.beforeSeq !== void 0) params.before_seq = String(input.beforeSeq);
+  if (input.afterSeq !== void 0) params.after_seq = String(input.afterSeq);
+  const response = await axios.get(
+    `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(input.sessionId)}/messages`,
+    {
+      params,
+      headers: { Authorization: `Bearer ${credentials.token}` },
+      timeout: 1e4
+    }
+  );
+  const decrypted = response.data.messages.map(
+    (raw) => decryptMessage(raw, session.encryptionKey, session.encryptionVariant)
+  );
+  const compacted = compactSessionMessages(decrypted, {
+    textLimit: input.textLimit ?? DEFAULT_TEXT_LIMIT,
+    maxTurns: input.maxTurns ?? DEFAULT_MAX_TURNS,
+    includeTools: input.includeTools ?? true,
+    maxToolsPerTurn: input.maxToolsPerTurn ?? DEFAULT_MAX_TOOLS_PER_TURN
+  });
+  const seqs = decrypted.map((message) => message.seq);
+  const minSeq = seqs.length > 0 ? Math.min(...seqs) : null;
+  const maxSeq = seqs.length > 0 ? Math.max(...seqs) : null;
+  const meta = session.metadata ?? {};
+  const resultWithoutText = {
+    sessionId: session.id,
+    active: session.active,
+    activeAt: session.activeAt,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    agent: {
+      name: typeof meta.agentName === "string" ? meta.agentName : null,
+      model: typeof meta.model === "string" ? meta.model : null,
+      mode: typeof meta.permissionMode === "string" ? meta.permissionMode : null,
+      flavor: typeof meta.flavor === "string" ? meta.flavor : null
+    },
+    machine: {
+      id: typeof meta.machineId === "string" ? meta.machineId : null,
+      name: typeof meta.machineName === "string" ? meta.machineName : null
+    },
+    path: typeof meta.path === "string" ? meta.path : null,
+    storedSummary: typeof meta.summary?.text === "string" ? meta.summary.text : null,
+    messageWindow: {
+      rawCount: decrypted.length,
+      compactedCount: compacted.compactedCount,
+      hasMore: response.data.hasMore,
+      nextBeforeSeq: minSeq,
+      nextAfterSeq: maxSeq
+    },
+    turns: compacted.turns
+  };
+  return {
+    ...resultWithoutText,
+    summaryText: buildSummaryText(resultWithoutText)
+  };
+}
+
+export { decryptMessage as a, decryptSessionRow as d, fetchSessionById as f, runSessionSummary as r, sessionSummaryInputSchema as s };

package/dist/spawnHappyCLI-KiazE3kL.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var child_process = require('child_process');
+var path = require('node:path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var fs = require('node:fs');
+
+let cachedRuntime = null;
+function getRuntime() {
+  if (cachedRuntime) return cachedRuntime;
+  if (typeof globalThis.Bun !== "undefined") {
+    cachedRuntime = "bun";
+    return cachedRuntime;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    cachedRuntime = "deno";
+    return cachedRuntime;
+  }
+  if (process?.versions?.bun) {
+    cachedRuntime = "bun";
+    return cachedRuntime;
+  }
+  if (process?.versions?.deno) {
+    cachedRuntime = "deno";
+    return cachedRuntime;
+  }
+  if (process?.versions?.node) {
+    cachedRuntime = "node";
+    return cachedRuntime;
+  }
+  cachedRuntime = "unknown";
+  return cachedRuntime;
+}
+const isBun = () => getRuntime() === "bun";
+
+function spawnHappyCLI(args, options = {}) {
+  const projectRoot = projectPath.projectPath();
+  const entrypoint = path.join(projectRoot, "dist", "index.mjs");
+  let directory;
+  if ("cwd" in options) {
+    directory = options.cwd;
+  } else {
+    directory = process.cwd();
+  }
+  const fullCommand = `happy ${args.join(" ")}`;
+  logger.logger.debug(`[SPAWN HAPPY CLI] Spawning: ${fullCommand} in ${directory}`);
+  const nodeArgs = [
+    "--no-warnings",
+    "--no-deprecation",
+    entrypoint,
+    ...args
+  ];
+  if (!fs.existsSync(entrypoint)) {
+    const errorMessage = `Entrypoint ${entrypoint} does not exist`;
+    logger.logger.debug(`[SPAWN HAPPY CLI] ${errorMessage}`);
+    throw new Error(errorMessage);
+  }
+  const runtime = isBun() ? "bun" : "node";
+  return child_process.spawn(runtime, nodeArgs, options);
+}
+
+var spawnHappyCLI$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    spawnHappyCLI: spawnHappyCLI
+});
+
+exports.isBun = isBun;
+exports.spawnHappyCLI = spawnHappyCLI;
+exports.spawnHappyCLI$1 = spawnHappyCLI$1;

package/dist/spawnHappyCLI-yBIP_Oqi.mjs

@@ -0,0 +1,66 @@
+import { spawn } from 'child_process';
+import { join } from 'node:path';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { l as logger } from './persistence-DKfF81pd.mjs';
+import { existsSync } from 'node:fs';
+
+let cachedRuntime = null;
+function getRuntime() {
+  if (cachedRuntime) return cachedRuntime;
+  if (typeof globalThis.Bun !== "undefined") {
+    cachedRuntime = "bun";
+    return cachedRuntime;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    cachedRuntime = "deno";
+    return cachedRuntime;
+  }
+  if (process?.versions?.bun) {
+    cachedRuntime = "bun";
+    return cachedRuntime;
+  }
+  if (process?.versions?.deno) {
+    cachedRuntime = "deno";
+    return cachedRuntime;
+  }
+  if (process?.versions?.node) {
+    cachedRuntime = "node";
+    return cachedRuntime;
+  }
+  cachedRuntime = "unknown";
+  return cachedRuntime;
+}
+const isBun = () => getRuntime() === "bun";
+
+function spawnHappyCLI(args, options = {}) {
+  const projectRoot = projectPath();
+  const entrypoint = join(projectRoot, "dist", "index.mjs");
+  let directory;
+  if ("cwd" in options) {
+    directory = options.cwd;
+  } else {
+    directory = process.cwd();
+  }
+  const fullCommand = `happy ${args.join(" ")}`;
+  logger.debug(`[SPAWN HAPPY CLI] Spawning: ${fullCommand} in ${directory}`);
+  const nodeArgs = [
+    "--no-warnings",
+    "--no-deprecation",
+    entrypoint,
+    ...args
+  ];
+  if (!existsSync(entrypoint)) {
+    const errorMessage = `Entrypoint ${entrypoint} does not exist`;
+    logger.debug(`[SPAWN HAPPY CLI] ${errorMessage}`);
+    throw new Error(errorMessage);
+  }
+  const runtime = isBun() ? "bun" : "node";
+  return spawn(runtime, nodeArgs, options);
+}
+
+var spawnHappyCLI$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    spawnHappyCLI: spawnHappyCLI
+});
+
+export { spawnHappyCLI$1 as a, isBun as i, spawnHappyCLI as s };