@zonease/happy 0.6.38 → 0.6.39

package/dist/session-D--F87zL.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+var chalk = require('chalk');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var sessionSummary = require('./sessionSummary-Bkz52BPh.cjs');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('fs');
+require('axios');
+require('./auth-BIleVCw0.cjs');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-Cc08m7of.cjs');
+require('open');
+require('react');
+require('ink');
+require('./sessionKeyCache-4Tp8pJ3N.cjs');
+
+function printSessionHelp() {
+  console.log(`
+${chalk.bold("happy session")} - Read Happy sessions
+
+${chalk.bold("Usage:")}
+  happy session summary <sessionId> [options]
+  happy session summarize <sessionId> [options]
+
+${chalk.bold("Options:")}
+  --limit <n>              Raw messages to compact (1-500, default 200)
+  --before-seq <n>         Page backwards: messages with seq < n
+  --after-seq <n>          Page forwards: messages with seq > n
+  --max-turns <n>          Compact turns to print (1-200, default 80)
+  --text-limit <n>         Max chars per text block (80-4000, default 800)
+  --max-tools <n>          Max tool names per turn (0-50, default 12)
+  --no-tools               Hide tool-use names
+  --json                   Print full JSON instead of markdown
+  -h, --help               Show this help
+`);
+}
+function readNumberFlag(flag, value) {
+  if (!value || value.startsWith("-")) {
+    throw new Error(`${flag} requires a number value.`);
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new Error(`${flag} must be an integer.`);
+  }
+  return parsed;
+}
+async function handleSessionCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printSessionHelp();
+    return;
+  }
+  if (action !== "summary" && action !== "summarize") {
+    throw new Error(`Unknown session command: ${action}. Use "happy session summary <sessionId>".`);
+  }
+  const sessionId = args[1];
+  if (!sessionId || sessionId.startsWith("-")) {
+    throw new Error('Session ID required. Use "happy session summary <sessionId>".');
+  }
+  const input = { sessionId };
+  let printJson = false;
+  for (let i = 2; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--limit") {
+      input.limit = readNumberFlag(arg, args[++i]);
+    } else if (arg === "--before-seq") {
+      input.beforeSeq = readNumberFlag(arg, args[++i]);
+    } else if (arg === "--after-seq") {
+      input.afterSeq = readNumberFlag(arg, args[++i]);
+    } else if (arg === "--max-turns") {
+      input.maxTurns = readNumberFlag(arg, args[++i]);
+    } else if (arg === "--text-limit") {
+      input.textLimit = readNumberFlag(arg, args[++i]);
+    } else if (arg === "--max-tools") {
+      input.maxToolsPerTurn = readNumberFlag(arg, args[++i]);
+    } else if (arg === "--no-tools") {
+      input.includeTools = false;
+    } else if (arg === "--json") {
+      printJson = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printSessionHelp();
+      return;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  const credentials = await logger.readCredentials();
+  if (!credentials) {
+    throw new Error('No happy credentials found. Run "happy auth login" first.');
+  }
+  const result = await sessionSummary.runSessionSummary(credentials, input);
+  if (printJson) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(result.summaryText);
+    if (result.messageWindow.hasMore) {
+      console.log("");
+      console.log(chalk.gray(`More messages available. Continue with --before-seq ${result.messageWindow.nextBeforeSeq}`));
+    }
+  }
+}
+
+exports.handleSessionCommand = handleSessionCommand;

package/dist/sessionKeyCache-4Tp8pJ3N.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var fs = require('node:fs');
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var logger = require('./persistence-JLUn_Nou.cjs');
+
+function keyPath(sessionId) {
+  return path.join(logger.configuration.sessionKeysDir, `${sessionId}.key`);
+}
+async function cacheSessionKey(sessionId, sessionAESKey, machineKey) {
+  if (!fs.existsSync(logger.configuration.sessionKeysDir)) {
+    fs.mkdirSync(logger.configuration.sessionKeysDir, { recursive: true });
+  }
+  const encrypted = logger.encryptWithDataKey(logger.encodeBase64(sessionAESKey), machineKey);
+  await promises.writeFile(keyPath(sessionId), encrypted);
+}
+function readCachedSessionKey(sessionId, machineKey) {
+  const p = keyPath(sessionId);
+  if (!fs.existsSync(p)) {
+    return null;
+  }
+  try {
+    const blob = new Uint8Array(fs.readFileSync(p));
+    const b64 = logger.decryptWithDataKey(blob, machineKey);
+    if (typeof b64 !== "string") {
+      return null;
+    }
+    return logger.decodeBase64(b64);
+  } catch {
+    return null;
+  }
+}
+
+exports.cacheSessionKey = cacheSessionKey;
+exports.readCachedSessionKey = readCachedSessionKey;

package/dist/sessionKeyCache-D2BwO91C.mjs

@@ -0,0 +1,33 @@
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { c as configuration, k as encryptWithDataKey, f as encodeBase64, m as decryptWithDataKey, e as decodeBase64 } from './persistence-BFjvtUad.mjs';
+
+function keyPath(sessionId) {
+  return join(configuration.sessionKeysDir, `${sessionId}.key`);
+}
+async function cacheSessionKey(sessionId, sessionAESKey, machineKey) {
+  if (!existsSync(configuration.sessionKeysDir)) {
+    mkdirSync(configuration.sessionKeysDir, { recursive: true });
+  }
+  const encrypted = encryptWithDataKey(encodeBase64(sessionAESKey), machineKey);
+  await writeFile(keyPath(sessionId), encrypted);
+}
+function readCachedSessionKey(sessionId, machineKey) {
+  const p = keyPath(sessionId);
+  if (!existsSync(p)) {
+    return null;
+  }
+  try {
+    const blob = new Uint8Array(readFileSync(p));
+    const b64 = decryptWithDataKey(blob, machineKey);
+    if (typeof b64 !== "string") {
+      return null;
+    }
+    return decodeBase64(b64);
+  } catch {
+    return null;
+  }
+}
+
+export { cacheSessionKey as c, readCachedSessionKey as r };

package/dist/sessionList-BCSw3qYt.mjs

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import { z } from 'zod';
+import { c as configuration } from './persistence-BFjvtUad.mjs';
+import { d as decryptSessionRow } from './sessionSummary-lHGBWQSb.mjs';
+
+const sessionListInputSchema = {
+  status: z.enum(["active", "archived", "all"]).optional().describe("Filter by session state. Default: all."),
+  since: z.number().int().nonnegative().optional().describe("Only return sessions updated after this epoch-millis timestamp."),
+  limit: z.number().int().min(1).max(150).optional().describe("Max sessions to return. Default: 50.")
+};
+async function runSessionList(credentials, input) {
+  const limit = input.limit ?? 50;
+  const params = {};
+  if (input.since) params.since = String(input.since);
+  const response = await axios.get(
+    `${configuration.serverUrl}/v1/sessions`,
+    {
+      params,
+      headers: { Authorization: `Bearer ${credentials.token}` },
+      timeout: 1e4
+    }
+  );
+  const filtered = response.data.sessions.map((row) => decryptSessionRow(credentials, row)).filter((row) => row !== null).filter((row) => {
+    if (input.status === "active") return row.active;
+    if (input.status === "archived") return !row.active;
+    return true;
+  }).slice(0, limit).map((row) => {
+    const meta = row.metadata ?? {};
+    const summary = typeof meta.summary?.text === "string" ? meta.summary.text : null;
+    return {
+      sessionId: row.id,
+      active: row.active,
+      activeAt: row.activeAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      tag: typeof meta.tag === "string" ? meta.tag : null,
+      summary,
+      agentName: typeof meta.agentName === "string" ? meta.agentName : null,
+      machineId: typeof meta.machineId === "string" ? meta.machineId : null,
+      machineName: typeof meta.machineName === "string" ? meta.machineName : null,
+      path: typeof meta.path === "string" ? meta.path : null,
+      flavor: typeof meta.flavor === "string" ? meta.flavor : null
+    };
+  });
+  return {
+    sessions: filtered,
+    truncated: response.data.sessions.length >= 150
+  };
+}
+
+export { runSessionList as r, sessionListInputSchema as s };

package/dist/sessionList-ICJsjNtJ.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var axios = require('axios');
+var z = require('zod');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var sessionSummary = require('./sessionSummary-Bkz52BPh.cjs');
+
+const sessionListInputSchema = {
+  status: z.z.enum(["active", "archived", "all"]).optional().describe("Filter by session state. Default: all."),
+  since: z.z.number().int().nonnegative().optional().describe("Only return sessions updated after this epoch-millis timestamp."),
+  limit: z.z.number().int().min(1).max(150).optional().describe("Max sessions to return. Default: 50.")
+};
+async function runSessionList(credentials, input) {
+  const limit = input.limit ?? 50;
+  const params = {};
+  if (input.since) params.since = String(input.since);
+  const response = await axios.get(
+    `${logger.configuration.serverUrl}/v1/sessions`,
+    {
+      params,
+      headers: { Authorization: `Bearer ${credentials.token}` },
+      timeout: 1e4
+    }
+  );
+  const filtered = response.data.sessions.map((row) => sessionSummary.decryptSessionRow(credentials, row)).filter((row) => row !== null).filter((row) => {
+    if (input.status === "active") return row.active;
+    if (input.status === "archived") return !row.active;
+    return true;
+  }).slice(0, limit).map((row) => {
+    const meta = row.metadata ?? {};
+    const summary = typeof meta.summary?.text === "string" ? meta.summary.text : null;
+    return {
+      sessionId: row.id,
+      active: row.active,
+      activeAt: row.activeAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      tag: typeof meta.tag === "string" ? meta.tag : null,
+      summary,
+      agentName: typeof meta.agentName === "string" ? meta.agentName : null,
+      machineId: typeof meta.machineId === "string" ? meta.machineId : null,
+      machineName: typeof meta.machineName === "string" ? meta.machineName : null,
+      path: typeof meta.path === "string" ? meta.path : null,
+      flavor: typeof meta.flavor === "string" ? meta.flavor : null
+    };
+  });
+  return {
+    sessions: filtered,
+    truncated: response.data.sessions.length >= 150
+  };
+}
+
+exports.runSessionList = runSessionList;
+exports.sessionListInputSchema = sessionListInputSchema;

package/dist/sessionSummary-Bkz52BPh.cjs

@@ -0,0 +1,393 @@
+'use strict';
+
+var axios = require('axios');
+var z = require('zod');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var auth = require('./auth-BIleVCw0.cjs');
+var sessionKeyCache = require('./sessionKeyCache-4Tp8pJ3N.cjs');
+
+function resolveSessionKey(credentials, dataEncryptionKey, sessionId) {
+  if (credentials.encryption.type === "legacy") {
+    return { key: credentials.encryption.secret, variant: "legacy" };
+  }
+  if (sessionId) {
+    const cached = sessionKeyCache.readCachedSessionKey(sessionId, credentials.encryption.machineKey);
+    if (cached) {
+      return { key: cached, variant: "dataKey" };
+    }
+  }
+  if (!dataEncryptionKey) {
+    return null;
+  }
+  const blob = logger.decodeBase64(dataEncryptionKey);
+  if (blob.length < 1 || blob[0] !== 0) {
+    return null;
+  }
+  const opened = auth.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" ? logger.decryptLegacy(logger.decodeBase64(row.metadata), resolved.key) : logger.decryptWithDataKey(logger.decodeBase64(row.metadata), resolved.key);
+    } catch {
+      metadata = null;
+    }
+  }
+  let agentState = null;
+  if (row.agentState) {
+    try {
+      agentState = resolved.variant === "legacy" ? logger.decryptLegacy(logger.decodeBase64(row.agentState), resolved.key) : logger.decryptWithDataKey(logger.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(
+    `${logger.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 = logger.decodeBase64(base64);
+      decrypted = encryptionVariant === "legacy" ? logger.decryptLegacy(bytes, encryptionKey) : logger.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.z.string().describe("Target session ID (from happy_session_list)."),
+  limit: z.z.number().int().min(1).max(500).optional().describe(`Max raw messages to compact in this call. Default: ${DEFAULT_LIMIT}.`),
+  beforeSeq: z.z.number().int().min(1).optional().describe("Return messages with seq < this value (paginate backwards). Mutually exclusive with afterSeq."),
+  afterSeq: z.z.number().int().min(0).optional().describe("Return messages with seq > this value (paginate forwards). Mutually exclusive with beforeSeq."),
+  maxTurns: z.z.number().int().min(1).max(200).optional().describe(`Max compact turns to return. Default: ${DEFAULT_MAX_TURNS}.`),
+  textLimit: z.z.number().int().min(80).max(4e3).optional().describe(`Max chars per user/assistant text block. Default: ${DEFAULT_TEXT_LIMIT}.`),
+  includeTools: z.z.boolean().optional().describe("Include compact tool-use names. Default: true."),
+  maxToolsPerTurn: z.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(
+    `${logger.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)
+  };
+}
+
+exports.decryptMessage = decryptMessage;
+exports.decryptSessionRow = decryptSessionRow;
+exports.fetchSessionById = fetchSessionById;
+exports.runSessionSummary = runSessionSummary;
+exports.sessionSummaryInputSchema = sessionSummaryInputSchema;