very-happy-cli 0.2.159 → 0.2.160

package/dist/sessionOps-Dn8z85h_.cjs

@@ -0,0 +1,783 @@
+'use strict';
+
+var axios = require('axios');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var controlClient = require('./controlClient-Bcwv3D21.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+var node_crypto = require('node:crypto');
+var time = require('./time-DCuTyook.cjs');
+var socket_ioClient = require('socket.io-client');
+var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
+
+function sessionWebUrl(sessionId) {
+  return `${configuration.configuration.webappUrl.replace(/\/+$/, "")}/session/${sessionId}`;
+}
+async function waitForSessionKey(sessionId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const entry = persistence.readPersistedSessions()[sessionId];
+    if (entry) return entry;
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Session ${sessionId} has no encryption key in ${configuration.configuration.sessionsFile}. Either it was not spawned by this machine's daemon, or the daemon is too old to persist session keys.`
+      );
+    }
+    await time.delay(200);
+  }
+}
+async function sendUserMessage(sessionId, persisted, text, client, options = {}) {
+  const credentials = await persistence.readCredentialsForConfiguredRelay();
+  if (!credentials) {
+    throw new Error("Not authenticated. Run `very-happy auth login` first.");
+  }
+  const envelope = {
+    role: "user",
+    content: {
+      type: "text",
+      text
+    },
+    meta: {
+      sentFrom: options.sentFrom ?? "cli",
+      ...options.model !== void 0 ? { model: options.model } : {},
+      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {},
+      ...options.effort !== void 0 ? { effort: options.effort } : {},
+      ...options.delivery !== void 0 ? { delivery: options.delivery } : {}
+    }
+  };
+  const encrypted = authRelay.encodeBase64(authRelay.encrypt(
+    authRelay.decodeBase64(persisted.encryptionKey),
+    persisted.encryptionVariant,
+    envelope
+  ));
+  await axios.post(
+    `${configuration.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
+    { messages: [{ content: encrypted, localId: options.localId ?? node_crypto.randomUUID() }] },
+    {
+      headers: {
+        "Authorization": `Bearer ${credentials.token}`,
+        "Content-Type": "application/json",
+        "X-Happy-Client": `${client}/${configuration.configuration.currentCliVersion}`
+      },
+      timeout: 3e4
+    }
+  );
+}
+
+const MAX_LINE_CHARS = 500;
+const MAX_ARGS_CHARS = 160;
+const DEFAULT_LIMITS = { line: MAX_LINE_CHARS, args: MAX_ARGS_CHARS };
+const NO_LIMITS = { line: Number.POSITIVE_INFINITY, args: Number.POSITIVE_INFINITY };
+function truncateText(text, max = MAX_LINE_CHARS) {
+  const chars = Array.from(text);
+  if (chars.length <= max) return text;
+  return chars.slice(0, max).join("") + ` \u2026[+${chars.length - max} chars]`;
+}
+function squash(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function safeJson(value, max) {
+  try {
+    return truncateText(JSON.stringify(value) ?? "", max);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function formatMessageBody(body, limits = DEFAULT_LIMITS) {
+  if (!body || typeof body !== "object") return null;
+  const b = body;
+  if (b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string") {
+    const text = squash(b.content.text);
+    return text.length > 0 ? `user: ${truncateText(text, limits.line)}` : null;
+  }
+  if (b.role === "session" && b.content && typeof b.content === "object") {
+    const env = b.content;
+    const ev = env.ev;
+    if (!ev || typeof ev.t !== "string") return null;
+    switch (ev.t) {
+      case "text": {
+        if (ev.thinking) return null;
+        const text = squash(String(ev.text ?? ""));
+        if (text.length === 0) return null;
+        const role = env.role === "user" ? "user" : "assistant";
+        return `${role}: ${truncateText(text, limits.line)}`;
+      }
+      case "tool-call-start": {
+        const name = String(ev.name ?? "tool");
+        const title = squash(String(ev.title ?? ""));
+        const args = ev.args ? safeJson(ev.args, limits.args) : "";
+        const detail = title || args;
+        return `[tool] ${name}${detail ? `: ${truncateText(detail, limits.args)}` : ""}`;
+      }
+      case "service": {
+        const text = squash(String(ev.text ?? ""));
+        return text.length > 0 ? `[service] ${truncateText(text, limits.args)}` : null;
+      }
+      case "turn-end": {
+        if (ev.status && ev.status !== "completed") return `[turn ${ev.status}]`;
+        return null;
+      }
+      default:
+        return null;
+    }
+  }
+  if (b.role === "agent" && b.content?.type === "acp" && b.content.data && typeof b.content.data === "object") {
+    const d = b.content.data;
+    switch (d.type) {
+      case "message": {
+        const text = squash(String(d.message ?? ""));
+        return text.length > 0 ? `assistant: ${truncateText(text, limits.line)}` : null;
+      }
+      case "tool-call":
+        return `[tool] ${String(d.name ?? "tool")}: ${safeJson(d.input, limits.args)}`;
+      case "permission-request":
+        return `[permission] ${String(d.toolName ?? "")}: ${truncateText(squash(String(d.description ?? "")), limits.args)}`;
+      default:
+        return null;
+    }
+  }
+  if (b.role === "agent" && b.content?.type === "output") {
+    const msg = b.content.data?.message;
+    if (msg && Array.isArray(msg.content)) {
+      const texts = msg.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => squash(c.text)).filter((t) => t.length > 0);
+      if (texts.length > 0) {
+        const role = msg.role === "user" ? "user" : "assistant";
+        return `${role}: ${truncateText(texts.join(" "), limits.line)}`;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function formatTranscript(bodies, options = {}) {
+  const limits = options.full ? NO_LIMITS : DEFAULT_LIMITS;
+  const lines = [];
+  for (const body of bodies) {
+    const line = formatMessageBody(body, limits);
+    if (line !== null) lines.push(line);
+  }
+  return lines.join("\n");
+}
+
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function sessionEnvelope(body) {
+  const b = asRecord(body);
+  if (!b || b.role !== "session") return null;
+  const env = asRecord(b.content);
+  if (!env) return null;
+  const ev = asRecord(env.ev);
+  return ev && typeof ev.t === "string" ? { role: env.role, ev } : null;
+}
+function isUserPrompt(body) {
+  const b = asRecord(body);
+  return !!b && b.role === "user" && b.content?.type === "text" && typeof b.content.text === "string";
+}
+function agentPiece(body) {
+  const env = sessionEnvelope(body);
+  if (env && env.role !== "user") {
+    if (env.ev.t === "text" && !env.ev.thinking) {
+      const text = String(env.ev.text ?? "");
+      return text.trim().length > 0 ? { kind: "text", text } : null;
+    }
+    if (env.ev.t === "tool-call-start") return { kind: "tool" };
+    return null;
+  }
+  const b = asRecord(body);
+  if (b?.role === "agent" && b.content?.type === "acp") {
+    const d = asRecord(b.content.data);
+    if (d?.type === "message") {
+      const text = String(d.message ?? "");
+      return text.trim().length > 0 ? { kind: "text", text } : null;
+    }
+    if (d?.type === "tool-call") return { kind: "tool" };
+  }
+  return null;
+}
+function userPromptText(body) {
+  return isUserPrompt(body) ? body.content.text : null;
+}
+function analyzeLatestTurn(entries, options = {}) {
+  const lastSeq = entries.length > 0 ? entries[entries.length - 1].seq : 0;
+  let userIndex = -1;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (isUserPrompt(entries[i].body) && (!options.anchor || options.anchor(entries[i].body))) {
+      userIndex = i;
+      break;
+    }
+  }
+  let ended = false;
+  let status = null;
+  let error = null;
+  let texts = [];
+  let lastMarker = null;
+  let startedAfterPrompt = false;
+  const emitsStarts = entries.some((entry) => sessionEnvelope(entry.body)?.ev?.t === "turn-start");
+  for (let i = userIndex + 1; i < entries.length; i++) {
+    const body = entries[i].body;
+    if (options.anchor && isUserPrompt(body)) {
+      if (ended) break;
+      continue;
+    }
+    const env = sessionEnvelope(body);
+    if (env?.ev?.t === "turn-start") {
+      lastMarker = "start";
+      startedAfterPrompt = true;
+      ended = false;
+      status = null;
+      error = null;
+      texts = [];
+      continue;
+    }
+    if (env?.ev?.t === "turn-end") {
+      lastMarker = "end";
+      if (userIndex >= 0 && emitsStarts && !startedAfterPrompt) continue;
+      ended = true;
+      status = typeof env.ev.status === "string" ? env.ev.status : null;
+      error = typeof env.ev.error === "string" ? env.ev.error : null;
+      continue;
+    }
+    const piece = agentPiece(body);
+    if (!piece) continue;
+    if (piece.kind === "tool") texts = [];
+    else texts.push(piece.text);
+  }
+  if (userIndex < 0) ended = lastMarker === "end";
+  return {
+    userSeq: userIndex >= 0 ? entries[userIndex].seq : null,
+    ended,
+    status: ended ? status : null,
+    error: ended ? error : null,
+    answer: texts.join("\n\n").trim(),
+    lastSeq
+  };
+}
+
+const USER_SOCKET_CONNECT_TIMEOUT_MS = 15e3;
+async function openUserScopedSocket(token, options = {}) {
+  const socket = socket_ioClient.io(configuration.configuration.serverUrl, {
+    auth: {
+      token,
+      clientType: "user-scoped",
+      happyClient: `cli-session-ops/${configuration.configuration.currentCliVersion}`
+    },
+    path: "/v1/updates",
+    transports: ["websocket"],
+    reconnection: false,
+    autoConnect: false
+  });
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      socket.close();
+      reject(new Error(`Timed out connecting to ${configuration.configuration.serverUrl}`));
+    }, options.connectTimeoutMs ?? USER_SOCKET_CONNECT_TIMEOUT_MS);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    socket.once("connect_error", (error) => {
+      clearTimeout(timer);
+      socket.close();
+      reject(new Error(`Could not connect to ${configuration.configuration.serverUrl}: ${error.message}`));
+    });
+    socket.connect();
+  });
+  return {
+    async rpcCall(payload, timeoutMs) {
+      const ack = await socket.timeout(timeoutMs).emitWithAck("rpc-call", payload);
+      return ack;
+    },
+    close() {
+      socket.close();
+    }
+  };
+}
+
+const RPC_RATE_LIMIT_ERROR = "RPC rate limit reached";
+const RPC_ACCOUNT_RATE_LIMIT_ERROR = "RPC account rate limit reached";
+const RPC_RATE_RETRY_MIN_DELAY_MS = 2e3;
+const RPC_RATE_RETRY_MAX_DELAY_MS = 6e4;
+const RPC_RATE_MAX_RETRIES = 2;
+function isRpcRateLimitAck(ack) {
+  if (!ack || typeof ack !== "object") return false;
+  const a = ack;
+  if (a.ok !== false) return false;
+  if (a.code === "rpc_rate_limited" || a.code === "rpc_account_rate_limited") return true;
+  return a.error === RPC_RATE_LIMIT_ERROR || a.error === RPC_ACCOUNT_RATE_LIMIT_ERROR;
+}
+function rpcRateRetryDelayMs(attempt, retryAfterMs, random = Math.random()) {
+  if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+    return Math.min(RPC_RATE_RETRY_MAX_DELAY_MS, Math.round(retryAfterMs * (1 + random * 0.5)));
+  }
+  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
+  const ceiling = Math.min(RPC_RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RPC_RATE_RETRY_MAX_DELAY_MS);
+  return Math.round(RPC_RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RPC_RATE_RETRY_MIN_DELAY_MS));
+}
+
+const PERMISSION_OPS_CLIENT = "session-ops";
+const PERMISSION_RPC_TIMEOUT_MS = 3e4;
+const SETTLE_TIMEOUT_MS = 5e3;
+const SETTLE_POLL_MS = 500;
+function buildPermissionRpcPayload(requestId, verdict) {
+  if (verdict.kind === "approve") {
+    return {
+      id: requestId,
+      approved: true,
+      decision: verdict.forSession ? "approved_for_session" : "approved"
+    };
+  }
+  return {
+    id: requestId,
+    approved: false,
+    decision: "denied",
+    ...verdict.reason ? { reason: verdict.reason } : {}
+  };
+}
+function interpretPermissionAck(ack, decryptResult) {
+  if (!ack.ok) {
+    const message = ack.error ?? "RPC call failed";
+    if (message === "RPC method not available") {
+      return { status: "offline", message: "no running wrapper has registered the permission RPC for this session" };
+    }
+    if (message === "RPC target disconnected") {
+      return { status: "offline", message: "the wrapper disconnected while the permission RPC was in flight" };
+    }
+    if (/timed? ?out/i.test(message)) {
+      return { status: "timeout", message };
+    }
+    if (isRpcRateLimitAck(ack)) {
+      return { status: "rate-limited", message, retryAfterMs: rpcRateRetryDelayMs(1, ack.retryAfterMs, 0) };
+    }
+    return { status: "rejected", message };
+  }
+  let body = null;
+  if (typeof ack.result === "string" && ack.result.length > 0) {
+    try {
+      body = decryptResult(ack.result);
+    } catch {
+      body = null;
+    }
+  }
+  if (body && typeof body === "object" && typeof body.error === "string") {
+    return { status: "handler-error", message: body.error };
+  }
+  return { status: "acknowledged" };
+}
+function pendingRequestsOf(agentState, now) {
+  const requests = agentState?.requests;
+  if (!requests || typeof requests !== "object") return [];
+  return Object.entries(requests).map(([id, request]) => ({
+    id,
+    tool: typeof request?.tool === "string" ? request.tool : "unknown",
+    ...request?.kind ? { kind: request.kind } : {},
+    ...typeof request?.createdAt === "number" ? { createdAt: request.createdAt, waitingMs: Math.max(0, now - request.createdAt) } : {}
+  })).sort((a, b) => (a.createdAt ?? Number.MAX_SAFE_INTEGER) - (b.createdAt ?? Number.MAX_SAFE_INTEGER));
+}
+const RPC_DEADLINE_GRACE_MS = 2e3;
+function withDeadline(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${message} (timed out)`)), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+async function resolvePermissionRequest(sessionId, requestId, verdict, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const persisted = (deps.readPersisted ?? persistence.readPersistedSessions)()[sessionId];
+  if (!persisted) {
+    throw new Error(
+      `No local key for session ${sessionId} \u2014 approve/deny needs the session key from ~/.happy/sessions.json (the RPC payload is encrypted with it), so only sessions this machine's daemon spawned within 14 days can be answered from here.`
+    );
+  }
+  const token = await (deps.bearerToken ?? bearerToken$1)();
+  const fetchState = deps.fetchAgentState ?? fetchDecryptedAgentState;
+  const before = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
+  if (!before.some((request) => request.id === requestId)) {
+    const hint = before.length > 0 ? `Pending request ids: ${before.map((request) => `${request.id} (${request.tool})`).join(", ")}` : "The session has no pending requests.";
+    throw new Error(`Request ${requestId} is not pending on session ${sessionId}. ${hint}`);
+  }
+  const payload = buildPermissionRpcPayload(requestId, verdict);
+  const key = authRelay.decodeBase64(persisted.encryptionKey);
+  const params = authRelay.encodeBase64(authRelay.encrypt(key, persisted.encryptionVariant, payload));
+  const transport = await (deps.openTransport ?? openUserScopedSocket)(token);
+  const rpcTimeoutMs = deps.rpcTimeoutMs ?? PERMISSION_RPC_TIMEOUT_MS;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let ack;
+  try {
+    for (let attempt = 1; ; attempt++) {
+      try {
+        ack = await withDeadline(
+          transport.rpcCall({ method: `${sessionId}:permission`, params }, rpcTimeoutMs),
+          rpcTimeoutMs + RPC_DEADLINE_GRACE_MS,
+          `permission RPC did not settle within ${rpcTimeoutMs}ms`
+        );
+      } catch (error) {
+        ack = { ok: false, error: error instanceof Error ? error.message : "RPC call failed" };
+      }
+      if (!isRpcRateLimitAck(ack) || attempt > RPC_RATE_MAX_RETRIES) break;
+      const waitMs = rpcRateRetryDelayMs(attempt, ack.retryAfterMs, (deps.random ?? Math.random)());
+      deps.onRateLimited?.({ attempt, waitMs, serverError: ack.error ?? "RPC rate limit reached" });
+      await sleep(waitMs);
+    }
+  } finally {
+    transport.close();
+  }
+  const outcome = interpretPermissionAck(ack, (encrypted) => authRelay.decrypt(key, persisted.encryptionVariant, authRelay.decodeBase64(encrypted)));
+  if (outcome.status !== "acknowledged") {
+    return { sessionId, requestId, payload, outcome };
+  }
+  const deadline = now() + (deps.settleTimeoutMs ?? SETTLE_TIMEOUT_MS);
+  let settled = false;
+  for (; ; ) {
+    const pending = pendingRequestsOf(await fetchState(sessionId, persisted, token), now());
+    if (!pending.some((request) => request.id === requestId)) {
+      settled = true;
+      break;
+    }
+    if (now() >= deadline) break;
+    await sleep(SETTLE_POLL_MS);
+  }
+  return { sessionId, requestId, payload, outcome, settled };
+}
+async function bearerToken$1() {
+  const credentials = await persistence.readCredentialsForConfiguredRelay();
+  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
+  return credentials.token;
+}
+async function fetchDecryptedAgentState(sessionId, persisted, token) {
+  const response = await axios.get(
+    `${configuration.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
+    {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${PERMISSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+      },
+      timeout: 15e3,
+      // 404 is a real answer ("not yours / gone"), not a transport fault.
+      validateStatus: (status) => status >= 200 && status < 300 || status === 404
+    }
+  );
+  if (response.status === 404) {
+    throw new Error(`Session ${sessionId} was not found on this account (it may have been deleted, or the local key belongs to a session on another relay).`);
+  }
+  const raw = response.data?.session?.agentState;
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  return authRelay.decrypt(authRelay.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, authRelay.decodeBase64(raw));
+}
+
+const SESSION_OPS_CLIENT = "session-ops";
+const DEFAULT_RECENT_LIMIT = 15;
+const MAX_READ_LIMIT = 100;
+function backgroundTasksOf(child) {
+  const raw = child.backgroundTasks;
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  if (typeof r.count !== "number" || !Array.isArray(r.tasks)) return void 0;
+  return {
+    count: r.count,
+    tasks: r.tasks.filter((task) => !!task && typeof task === "object" && typeof task.id === "string"),
+    ...typeof r.reportedAt === "number" ? { reportedAt: r.reportedAt } : {},
+    ...r.stale === true ? { stale: true } : {}
+  };
+}
+function mergeSessionSummaries(live, persisted, options = {}) {
+  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
+  const seen = /* @__PURE__ */ new Set();
+  const summaries = [];
+  for (const child of live) {
+    const id = typeof child.happySessionId === "string" ? child.happySessionId : void 0;
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    summaries.push(toSummary(id, persisted[id], livenessOf(child)));
+  }
+  const rest = Object.entries(persisted).filter(([id]) => !seen.has(id)).filter(([, entry]) => entry.metadata?.flavor !== "terminal-mirror").sort((a, b) => b[1].savedAt - a[1].savedAt).slice(0, recentLimit);
+  for (const [id, entry] of rest) {
+    summaries.push(toSummary(id, entry, { live: false }));
+  }
+  if (!options.tag) return summaries;
+  const wanted = options.tag;
+  return summaries.filter((summary) => summary.tags?.includes(wanted) === true);
+}
+function livenessOf(child) {
+  const backgroundTasks = backgroundTasksOf(child);
+  return { live: true, pid: typeof child.pid === "number" ? child.pid : void 0, ...backgroundTasks ? { backgroundTasks } : {} };
+}
+function sessionLiveness(live, sessionId) {
+  const child = live.find((entry) => entry.happySessionId === sessionId);
+  return child ? livenessOf(child) : { live: false };
+}
+function toSummary(id, persisted, extra) {
+  const meta = persisted?.metadata;
+  return {
+    id,
+    live: extra.live,
+    ...extra.pid !== void 0 ? { pid: extra.pid } : {},
+    ...extra.backgroundTasks ? { backgroundTasks: extra.backgroundTasks } : {},
+    ...meta?.summary?.text ? { title: meta.summary.text } : {},
+    ...meta?.path ? { cwd: meta.path } : {},
+    ...meta?.flavor ? { flavor: meta.flavor } : {},
+    ...meta?.tags?.length ? { tags: [...meta.tags] } : {},
+    ...meta?.variant ? { variant: meta.variant } : {},
+    url: sessionWebUrl(id),
+    ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {}
+  };
+}
+async function listSessions(options = {}) {
+  const live = await controlClient.listDaemonSessions();
+  return mergeSessionSummaries(live, persistence.readPersistedSessions(), options);
+}
+function summarizeAccountSession(row, persisted, liveIds, now) {
+  const base = {
+    id: row.id,
+    live: liveIds.has(row.id),
+    url: sessionWebUrl(row.id),
+    decryptable: false,
+    readable: false,
+    active: row.active === true,
+    archived: typeof row.archivedAt === "number",
+    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
+    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {},
+    attention: false
+  };
+  if (!persisted) return base;
+  const key = authRelay.decodeBase64(persisted.encryptionKey);
+  let metadata = null;
+  let agentState = null;
+  try {
+    metadata = row.metadata ? authRelay.decrypt(key, persisted.encryptionVariant, authRelay.decodeBase64(row.metadata)) : null;
+    agentState = row.agentState ? authRelay.decrypt(key, persisted.encryptionVariant, authRelay.decodeBase64(row.agentState)) : null;
+  } catch {
+    return base;
+  }
+  if (!metadata) return base;
+  const meta = metadata;
+  const pending = pendingRequestsOf(agentState, now);
+  const backgroundTasks = backgroundTaskActivity.backgroundTasksReport(agentState?.backgroundTasks, now, { active: row.active === true });
+  return {
+    ...base,
+    decryptable: true,
+    readable: true,
+    backgroundTasks,
+    ...meta.summary?.text ? { title: meta.summary.text } : {},
+    ...meta.path ? { cwd: meta.path } : {},
+    ...meta.flavor ? { flavor: meta.flavor } : {},
+    ...meta.tags?.length ? { tags: [...meta.tags] } : {},
+    ...meta.variant ? { variant: meta.variant } : {},
+    ...meta.machineId ? { machineId: meta.machineId } : {},
+    ...persisted.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
+    pending,
+    attention: pending.length > 0
+  };
+}
+function orderAccountSessions(summaries, options = {}) {
+  const oldestWait = (summary) => Math.max(0, ...(summary.pending ?? []).map((request) => request.waitingMs ?? 0));
+  const rank = (summary) => summary.attention ? 0 : summary.live ? 1 : 2;
+  let rows = summaries.filter((summary) => summary.flavor !== "terminal-mirror").slice().sort((a, b) => {
+    const byRank = rank(a) - rank(b);
+    if (byRank !== 0) return byRank;
+    if (a.attention && b.attention) return oldestWait(b) - oldestWait(a);
+    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
+  });
+  if (options.tag) {
+    const wanted = options.tag;
+    rows = rows.filter((summary) => summary.tags?.includes(wanted) === true);
+  }
+  const recentLimit = Math.max(0, options.recentLimit ?? DEFAULT_RECENT_LIMIT);
+  let idleKept = 0;
+  return rows.filter((summary) => rank(summary) < 2 || idleKept++ < recentLimit);
+}
+async function listAccountSessions(options = {}) {
+  const token = await bearerToken();
+  const response = await axios.get(`${configuration.configuration.serverUrl}/v1/sessions`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+    },
+    timeout: 15e3
+  });
+  const rows = Array.isArray(response.data?.sessions) ? response.data.sessions : [];
+  const persisted = persistence.readPersistedSessions();
+  const live = await controlClient.listDaemonSessions();
+  const liveIds = new Set(live.map((child) => child.happySessionId).filter((id) => typeof id === "string"));
+  const now = Date.now();
+  const summaries = rows.filter((row) => typeof row?.id === "string").map((row) => summarizeAccountSession(row, persisted[row.id], liveIds, now)).filter((summary) => options.includeArchived || !summary.archived);
+  return orderAccountSessions(summaries, options);
+}
+async function bearerToken() {
+  const credentials = await persistence.readCredentialsForConfiguredRelay();
+  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
+  return credentials.token;
+}
+function requirePersisted(sessionId) {
+  const persisted = persistence.readPersistedSessions()[sessionId];
+  if (!persisted) {
+    throw new Error(
+      `No local key for session ${sessionId} \u2014 it was not spawned by this machine's daemon (or is older than 14 days).`
+    );
+  }
+  return persisted;
+}
+async function readSessionLog(sessionId, persisted, limit) {
+  const token = await bearerToken();
+  const response = await axios.get(
+    `${configuration.configuration.serverUrl}/v3/sessions/${encodeURIComponent(sessionId)}/messages`,
+    {
+      params: { before_seq: 2147483647, limit },
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+      },
+      timeout: 15e3
+    }
+  );
+  const messages = Array.isArray(response.data?.messages) ? response.data.messages : [];
+  messages.reverse();
+  const key = authRelay.decodeBase64(persisted.encryptionKey);
+  return messages.map((message) => {
+    if (message.content?.t !== "encrypted") return { seq: message.seq, body: null };
+    try {
+      return { seq: message.seq, body: authRelay.decrypt(key, persisted.encryptionVariant, authRelay.decodeBase64(message.content.c)) };
+    } catch {
+      return { seq: message.seq, body: null };
+    }
+  });
+}
+const TURN_WINDOW = 500;
+async function readSessionTranscript(sessionId, limit, options = {}) {
+  const persisted = requirePersisted(sessionId);
+  const bounded = Math.max(1, Math.min(MAX_READ_LIMIT, Math.floor(limit)));
+  const entries = await readSessionLog(sessionId, persisted, Math.max(bounded, TURN_WINDOW));
+  const shown = entries.slice(-bounded);
+  const live = await controlClient.listDaemonSessions();
+  return {
+    summary: toSummary(sessionId, persisted, sessionLiveness(live, sessionId)),
+    messageCount: shown.length,
+    transcript: formatTranscript(shown.map((entry) => entry.body), { full: options.full }),
+    turn: analyzeLatestTurn(entries)
+  };
+}
+async function readSessionMetadata(sessionId, persisted) {
+  const token = await bearerToken();
+  const response = await axios.get(`${configuration.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+    },
+    timeout: 15e3
+  });
+  const ciphertext = response.data?.session?.metadata;
+  if (typeof ciphertext !== "string" || ciphertext.length === 0) return null;
+  return authRelay.decrypt(authRelay.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, authRelay.decodeBase64(ciphertext));
+}
+async function readSessionState(sessionId, persisted) {
+  const token = await bearerToken();
+  const response = await axios.get(`${configuration.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+    },
+    timeout: 15e3,
+    validateStatus: (status) => status >= 200 && status < 300 || status === 404
+  });
+  if (response.status === 404) return { found: false, active: false };
+  const row = response.data?.session;
+  if (!row || typeof row.id !== "string") throw new Error(`Server returned no session row for ${sessionId}`);
+  const state = {
+    found: true,
+    active: row.active === true,
+    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
+    archivedAt: typeof row.archivedAt === "number" ? row.archivedAt : null,
+    ...typeof row.updatedAt === "number" ? { updatedAt: row.updatedAt } : {}
+  };
+  if (persisted && typeof row.metadata === "string" && row.metadata.length > 0) {
+    try {
+      const metadata = authRelay.decrypt(authRelay.decodeBase64(persisted.encryptionKey), persisted.encryptionVariant, authRelay.decodeBase64(row.metadata));
+      if (metadata?.machineId) state.machineId = metadata.machineId;
+    } catch {
+    }
+  }
+  return state;
+}
+class TurnWaitTimeoutError extends Error {
+  constructor(sessionId, timeoutMs, turn) {
+    super(`Session ${sessionId}: the latest turn did not end within ${Math.round(timeoutMs / 1e3)}s`);
+    this.sessionId = sessionId;
+    this.timeoutMs = timeoutMs;
+    this.turn = turn;
+  }
+}
+async function waitForTurnEnd(sessionId, options) {
+  const persisted = requirePersisted(sessionId);
+  const pollMs = options.pollMs ?? 3e3;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = Date.now() + options.timeoutMs;
+  while (true) {
+    const turn = analyzeLatestTurn(await readSessionLog(sessionId, persisted, TURN_WINDOW));
+    if (turn.ended) return turn;
+    if (Date.now() + pollMs > deadline) throw new TurnWaitTimeoutError(sessionId, options.timeoutMs, turn);
+    await sleep(pollMs);
+  }
+}
+async function stopSession(sessionId) {
+  return await controlClient.stopDaemonSession(sessionId);
+}
+async function archiveSession(sessionId) {
+  const token = await bearerToken();
+  await axios.post(
+    `${configuration.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/archive`,
+    {},
+    {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+      },
+      timeout: 1e4
+    }
+  );
+}
+async function unarchiveSession(sessionId) {
+  const token = await bearerToken();
+  await axios.post(
+    `${configuration.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}/unarchive`,
+    {},
+    {
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "X-Happy-Client": `${SESSION_OPS_CLIENT}/${configuration.configuration.currentCliVersion}`
+      },
+      timeout: 1e4
+    }
+  );
+}
+
+exports.DEFAULT_RECENT_LIMIT = DEFAULT_RECENT_LIMIT;
+exports.MAX_READ_LIMIT = MAX_READ_LIMIT;
+exports.TURN_WINDOW = TURN_WINDOW;
+exports.TurnWaitTimeoutError = TurnWaitTimeoutError;
+exports.analyzeLatestTurn = analyzeLatestTurn;
+exports.archiveSession = archiveSession;
+exports.listAccountSessions = listAccountSessions;
+exports.listSessions = listSessions;
+exports.openUserScopedSocket = openUserScopedSocket;
+exports.readSessionLog = readSessionLog;
+exports.readSessionMetadata = readSessionMetadata;
+exports.readSessionState = readSessionState;
+exports.readSessionTranscript = readSessionTranscript;
+exports.resolvePermissionRequest = resolvePermissionRequest;
+exports.sendUserMessage = sendUserMessage;
+exports.sessionLiveness = sessionLiveness;
+exports.sessionWebUrl = sessionWebUrl;
+exports.stopSession = stopSession;
+exports.unarchiveSession = unarchiveSession;
+exports.userPromptText = userPromptText;
+exports.waitForSessionKey = waitForSessionKey;
+exports.waitForTurnEnd = waitForTurnEnd;