@zhigang1992/happy-cli 0.12.1

package/dist/lib.mjs

@@ -0,0 +1,21 @@
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-CGco5Y-r.mjs';
+import 'axios';
+import 'chalk';
+import 'fs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:fs/promises';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'node:events';
+import 'socket.io-client';
+import 'child_process';
+import 'util';
+import 'fs/promises';
+import 'crypto';
+import 'path';
+import 'url';
+import 'os';
+import 'expo-server-sdk';

package/dist/list-BW6QBLa1.cjs

@@ -0,0 +1,328 @@
+'use strict';
+
+var types = require('./types-BsjUgWOx.cjs');
+var axios = require('axios');
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var crypto = require('crypto');
+var tweetnacl = require('tweetnacl');
+require('chalk');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('node:fs/promises');
+require('zod');
+require('node:crypto');
+require('node:events');
+require('socket.io-client');
+require('child_process');
+require('util');
+require('fs/promises');
+require('url');
+require('expo-server-sdk');
+
+function decryptDataEncryptionKey(encryptedKey, credentials) {
+  try {
+    types.logger.debug(`Attempting to decrypt dataEncryptionKey...`);
+    types.logger.debug(`Credentials type: ${credentials.encryption.type}`);
+    if (credentials.encryption.type !== "dataKey") {
+      types.logger.debug(`Credentials type is not 'dataKey', returning null`);
+      return null;
+    }
+    const encryptedBundle = types.decodeBase64(encryptedKey);
+    types.logger.debug(`Encrypted bundle length: ${encryptedBundle.length}`);
+    types.logger.debug(`Version byte: ${encryptedBundle[0]}`);
+    if (encryptedBundle.length === 0 || encryptedBundle[0] !== 0) {
+      types.logger.debug(`Invalid version or empty bundle`);
+      return null;
+    }
+    const bundleWithoutVersion = encryptedBundle.slice(1);
+    types.logger.debug(`Bundle without version length: ${bundleWithoutVersion.length}`);
+    const seedBytes = credentials.encryption.dataKeySeed;
+    types.logger.debug(`Seed bytes from dataKeySeed: ${seedBytes.length} bytes`);
+    const hash = crypto.createHash("sha512").update(Buffer.from(seedBytes)).digest();
+    const secretKey = new Uint8Array(hash.slice(0, 32));
+    const keypair = tweetnacl.box.keyPair.fromSecretKey(secretKey);
+    types.logger.debug(`Derived keypair from dataKeySeed`);
+    const decrypted = types.libsodiumDecryptFromPublicKey(bundleWithoutVersion, keypair.secretKey);
+    types.logger.debug(`Decryption result: ${decrypted ? `success (${decrypted.length} bytes)` : "null"}`);
+    return decrypted;
+  } catch (error) {
+    types.logger.debug(`Failed to decrypt dataEncryptionKey:`, error);
+    return null;
+  }
+}
+function getCurrentWorkingDirectory(claudeSessionId, spawnDirectory) {
+  try {
+    const homeDir = os.homedir();
+    const claudeProjectsDir = path.join(homeDir, ".claude", "projects");
+    if (!fs.existsSync(claudeProjectsDir)) {
+      return spawnDirectory;
+    }
+    const projectDirs = fs.readdirSync(claudeProjectsDir).map((name) => path.join(claudeProjectsDir, name)).filter((path) => fs.statSync(path).isDirectory());
+    for (const projectDir of projectDirs) {
+      const sessionFile = path.join(projectDir, `${claudeSessionId}.jsonl`);
+      if (fs.existsSync(sessionFile)) {
+        const content = fs.readFileSync(sessionFile, "utf8");
+        const lines = content.trim().split("\n");
+        const lastLine = lines[lines.length - 1];
+        try {
+          const lastMessage = JSON.parse(lastLine);
+          if (lastMessage.cwd) {
+            return lastMessage.cwd;
+          }
+        } catch (e) {
+          types.logger.debug(`Failed to parse last line of session file ${sessionFile}:`, e);
+        }
+      }
+    }
+  } catch (error) {
+    types.logger.debug(`Failed to get current working directory for session ${claudeSessionId}:`, error);
+  }
+  return spawnDirectory;
+}
+async function fetchSessionMessages(sessionId, credentials, encryptionKey, encryptionVariant, limit) {
+  const serverUrl = types.configuration.serverUrl;
+  try {
+    const response = await axios.get(
+      `${serverUrl}/v1/sessions/${sessionId}/messages`,
+      {
+        headers: {
+          "Authorization": `Bearer ${credentials.token}`
+        }
+      }
+    );
+    const messages = response.data.messages;
+    const decryptedMessages = [];
+    const messagesToProcess = messages.slice(0, limit);
+    for (const msg of messagesToProcess) {
+      try {
+        const encryptedContent = msg.content.c;
+        const decrypted = types.decrypt(
+          encryptionKey,
+          encryptionVariant,
+          types.decodeBase64(encryptedContent)
+        );
+        if (decrypted) {
+          decryptedMessages.push(decrypted);
+        }
+      } catch (error) {
+        types.logger.debug(`Failed to decrypt message ${msg.id}:`, error);
+      }
+    }
+    return decryptedMessages.reverse();
+  } catch (error) {
+    types.logger.debug(`Failed to fetch messages for session ${sessionId}:`, error);
+    return [];
+  }
+}
+function extractMessageText(msg) {
+  const msgContent = msg.content;
+  if (typeof msgContent === "string") {
+    return msgContent.trim() || null;
+  }
+  if (msgContent?.type === "text" && msgContent?.text) {
+    return String(msgContent.text).trim() || null;
+  }
+  if (msgContent?.type === "output" && msgContent?.data?.message?.content) {
+    const messageContent = msgContent.data.message.content;
+    if (Array.isArray(messageContent)) {
+      const text = messageContent.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+      return text || null;
+    } else if (typeof messageContent === "string") {
+      return messageContent.trim() || null;
+    }
+  }
+  if (Array.isArray(msgContent)) {
+    const text = msgContent.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+    return text || null;
+  }
+  if (msgContent?.type === "event") {
+    return null;
+  }
+  return null;
+}
+function shouldDisplayMessage(msg) {
+  return extractMessageText(msg) !== null;
+}
+function formatMessage(msg, indent = "", maxLen = 200) {
+  const role = msg.role;
+  let prefix;
+  if (role === "user") {
+    prefix = "\u{1F464} User";
+  } else if (role === "agent" || role === "assistant") {
+    prefix = "\u{1F916} Assistant";
+  } else {
+    prefix = `[${role || "unknown"}]`;
+  }
+  let content = extractMessageText(msg) || "";
+  if (maxLen >= 0 && content.length > maxLen) {
+    content = content.substring(0, maxLen) + "...";
+  }
+  content = content.replace(/\n/g, `
+${indent}         `);
+  return `${indent}${prefix}: ${content}`;
+}
+async function listSessions(credentials, options = {}) {
+  try {
+    const serverUrl = types.configuration.serverUrl;
+    const response = await axios.get(`${serverUrl}/v2/sessions/active`, {
+      headers: {
+        "Authorization": `Bearer ${credentials.token}`
+      }
+    });
+    const sessions = response.data.sessions;
+    if (sessions.length === 0) {
+      console.log("No active sessions found.");
+      return;
+    }
+    const processedSessions = [];
+    for (const session of sessions) {
+      types.logger.debug(`
+=== Processing session ${session.id} ===`);
+      types.logger.debug(`Has dataEncryptionKey: ${!!session.dataEncryptionKey}`);
+      types.logger.debug(`Has metadata: ${!!session.metadata}`);
+      let metadata = {};
+      let agentState = {};
+      let encryptionKey = null;
+      let encryptionVariant = "dataKey";
+      if (session.dataEncryptionKey) {
+        types.logger.debug(`Session has dataEncryptionKey, attempting to decrypt...`);
+        encryptionKey = decryptDataEncryptionKey(session.dataEncryptionKey, credentials);
+        if (!encryptionKey) {
+          types.logger.debug(`Failed to decrypt dataEncryptionKey for session ${session.id}`);
+        } else {
+          types.logger.debug(`Successfully decrypted dataEncryptionKey`);
+        }
+      } else if (credentials.encryption.type === "dataKey") {
+        types.logger.debug(`Using machineKey directly for CLI session`);
+        encryptionKey = credentials.encryption.machineKey;
+      } else {
+        types.logger.debug(`Using legacy secret key`);
+        encryptionKey = credentials.encryption.secret;
+        encryptionVariant = "legacy";
+      }
+      if (session.metadata && encryptionKey) {
+        types.logger.debug(`Attempting to decrypt metadata...`);
+        try {
+          const metadataBytes = types.decodeBase64(session.metadata);
+          const decrypted = types.decrypt(encryptionKey, encryptionVariant, metadataBytes);
+          if (decrypted) {
+            types.logger.debug(`Successfully decrypted metadata:`, JSON.stringify(decrypted));
+            metadata = decrypted;
+          }
+        } catch (error) {
+          types.logger.debug(`Failed to decrypt metadata for session ${session.id}:`, error);
+        }
+      }
+      if (session.agentState && encryptionKey) {
+        try {
+          const decrypted = types.decrypt(encryptionKey, encryptionVariant, types.decodeBase64(session.agentState));
+          if (decrypted) {
+            agentState = decrypted;
+          }
+        } catch (error) {
+          types.logger.debug(`Failed to decrypt agent state for session ${session.id}:`, error);
+        }
+      }
+      let title = "(Untitled)";
+      if (metadata.summary?.text) {
+        title = metadata.summary.text;
+      } else if (metadata.path) {
+        const segments = metadata.path.split("/").filter(Boolean);
+        if (segments.length > 0) {
+          title = segments[segments.length - 1];
+        }
+      }
+      let workingDir = metadata.path || "(Unknown)";
+      if (metadata.claudeSessionId && metadata.path) {
+        workingDir = getCurrentWorkingDirectory(metadata.claudeSessionId, metadata.path);
+      }
+      processedSessions.push({
+        session,
+        metadata,
+        agentState,
+        encryptionKey,
+        encryptionVariant,
+        title,
+        host: metadata.host || "(Unknown)",
+        workingDir,
+        thinking: !!agentState.thinking
+      });
+    }
+    let filteredSessions = processedSessions;
+    if (options.sessionId) {
+      const idFilter = options.sessionId.toLowerCase();
+      filteredSessions = filteredSessions.filter(
+        (s) => s.session.id.toLowerCase().startsWith(idFilter)
+      );
+    }
+    if (options.titleFilter) {
+      const titleFilter = options.titleFilter.toLowerCase();
+      filteredSessions = filteredSessions.filter(
+        (s) => s.title.toLowerCase().includes(titleFilter)
+      );
+    }
+    if (filteredSessions.length === 0) {
+      if (options.sessionId || options.titleFilter) {
+        console.log("No sessions match the specified filters.");
+      } else {
+        console.log("No active sessions found.");
+      }
+      return;
+    }
+    const showMessages = options.recentMsgs && options.recentMsgs > 0;
+    const needsSeparators = showMessages && filteredSessions.length > 1;
+    const indent = needsSeparators ? "    " : "";
+    console.log(`
+Active Sessions (${filteredSessions.length}):
+`);
+    for (let i = 0; i < filteredSessions.length; i++) {
+      const { session, encryptionKey, encryptionVariant, title, host, workingDir, thinking } = filteredSessions[i];
+      if (needsSeparators && i > 0) {
+        console.log("\n" + "\u2550".repeat(70) + "\n");
+      }
+      const thinkingStatus = thinking ? "\u{1F914} Thinking" : "\u{1F4A4} Idle";
+      console.log(`${indent}ID: ${session.id}`);
+      console.log(`${indent}Title: ${title}`);
+      console.log(`${indent}Working Directory: ${workingDir}`);
+      console.log(`${indent}Host: ${host}`);
+      console.log(`${indent}Status: ${thinkingStatus}`);
+      console.log(`${indent}Last Active: ${types.formatTimeAgo(session.activeAt)}`);
+      if (showMessages && encryptionKey) {
+        console.log(`${indent}Recent Messages:`);
+        const messages = await fetchSessionMessages(
+          session.id,
+          credentials,
+          encryptionKey,
+          encryptionVariant,
+          options.recentMsgs
+        );
+        const displayableMessages = messages.filter(shouldDisplayMessage);
+        const msgLen = options.msgLen ?? 200;
+        if (displayableMessages.length === 0) {
+          console.log(`${indent}    (no messages)`);
+        } else {
+          for (const msg of displayableMessages) {
+            console.log(formatMessage(msg, indent + "    ", msgLen));
+          }
+        }
+      }
+      console.log("");
+    }
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.response?.status === 401) {
+        console.error("Authentication failed. Please run `happy auth` to authenticate.");
+      } else {
+        console.error(`Failed to fetch sessions: ${error.response?.data?.message || error.message}`);
+      }
+    } else {
+      console.error(`Failed to fetch sessions: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+exports.listSessions = listSessions;

package/dist/list-hET5tyMc.mjs

@@ -0,0 +1,326 @@
+import { c as configuration, l as logger, d as decodeBase64, b as decrypt, f as formatTimeAgo, e as libsodiumDecryptFromPublicKey } from './types-CGco5Y-r.mjs';
+import axios from 'axios';
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+import tweetnacl from 'tweetnacl';
+import 'chalk';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:fs/promises';
+import 'zod';
+import 'node:crypto';
+import 'node:events';
+import 'socket.io-client';
+import 'child_process';
+import 'util';
+import 'fs/promises';
+import 'url';
+import 'expo-server-sdk';
+
+function decryptDataEncryptionKey(encryptedKey, credentials) {
+  try {
+    logger.debug(`Attempting to decrypt dataEncryptionKey...`);
+    logger.debug(`Credentials type: ${credentials.encryption.type}`);
+    if (credentials.encryption.type !== "dataKey") {
+      logger.debug(`Credentials type is not 'dataKey', returning null`);
+      return null;
+    }
+    const encryptedBundle = decodeBase64(encryptedKey);
+    logger.debug(`Encrypted bundle length: ${encryptedBundle.length}`);
+    logger.debug(`Version byte: ${encryptedBundle[0]}`);
+    if (encryptedBundle.length === 0 || encryptedBundle[0] !== 0) {
+      logger.debug(`Invalid version or empty bundle`);
+      return null;
+    }
+    const bundleWithoutVersion = encryptedBundle.slice(1);
+    logger.debug(`Bundle without version length: ${bundleWithoutVersion.length}`);
+    const seedBytes = credentials.encryption.dataKeySeed;
+    logger.debug(`Seed bytes from dataKeySeed: ${seedBytes.length} bytes`);
+    const hash = createHash("sha512").update(Buffer.from(seedBytes)).digest();
+    const secretKey = new Uint8Array(hash.slice(0, 32));
+    const keypair = tweetnacl.box.keyPair.fromSecretKey(secretKey);
+    logger.debug(`Derived keypair from dataKeySeed`);
+    const decrypted = libsodiumDecryptFromPublicKey(bundleWithoutVersion, keypair.secretKey);
+    logger.debug(`Decryption result: ${decrypted ? `success (${decrypted.length} bytes)` : "null"}`);
+    return decrypted;
+  } catch (error) {
+    logger.debug(`Failed to decrypt dataEncryptionKey:`, error);
+    return null;
+  }
+}
+function getCurrentWorkingDirectory(claudeSessionId, spawnDirectory) {
+  try {
+    const homeDir = homedir();
+    const claudeProjectsDir = join(homeDir, ".claude", "projects");
+    if (!existsSync(claudeProjectsDir)) {
+      return spawnDirectory;
+    }
+    const projectDirs = readdirSync(claudeProjectsDir).map((name) => join(claudeProjectsDir, name)).filter((path) => statSync(path).isDirectory());
+    for (const projectDir of projectDirs) {
+      const sessionFile = join(projectDir, `${claudeSessionId}.jsonl`);
+      if (existsSync(sessionFile)) {
+        const content = readFileSync(sessionFile, "utf8");
+        const lines = content.trim().split("\n");
+        const lastLine = lines[lines.length - 1];
+        try {
+          const lastMessage = JSON.parse(lastLine);
+          if (lastMessage.cwd) {
+            return lastMessage.cwd;
+          }
+        } catch (e) {
+          logger.debug(`Failed to parse last line of session file ${sessionFile}:`, e);
+        }
+      }
+    }
+  } catch (error) {
+    logger.debug(`Failed to get current working directory for session ${claudeSessionId}:`, error);
+  }
+  return spawnDirectory;
+}
+async function fetchSessionMessages(sessionId, credentials, encryptionKey, encryptionVariant, limit) {
+  const serverUrl = configuration.serverUrl;
+  try {
+    const response = await axios.get(
+      `${serverUrl}/v1/sessions/${sessionId}/messages`,
+      {
+        headers: {
+          "Authorization": `Bearer ${credentials.token}`
+        }
+      }
+    );
+    const messages = response.data.messages;
+    const decryptedMessages = [];
+    const messagesToProcess = messages.slice(0, limit);
+    for (const msg of messagesToProcess) {
+      try {
+        const encryptedContent = msg.content.c;
+        const decrypted = decrypt(
+          encryptionKey,
+          encryptionVariant,
+          decodeBase64(encryptedContent)
+        );
+        if (decrypted) {
+          decryptedMessages.push(decrypted);
+        }
+      } catch (error) {
+        logger.debug(`Failed to decrypt message ${msg.id}:`, error);
+      }
+    }
+    return decryptedMessages.reverse();
+  } catch (error) {
+    logger.debug(`Failed to fetch messages for session ${sessionId}:`, error);
+    return [];
+  }
+}
+function extractMessageText(msg) {
+  const msgContent = msg.content;
+  if (typeof msgContent === "string") {
+    return msgContent.trim() || null;
+  }
+  if (msgContent?.type === "text" && msgContent?.text) {
+    return String(msgContent.text).trim() || null;
+  }
+  if (msgContent?.type === "output" && msgContent?.data?.message?.content) {
+    const messageContent = msgContent.data.message.content;
+    if (Array.isArray(messageContent)) {
+      const text = messageContent.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+      return text || null;
+    } else if (typeof messageContent === "string") {
+      return messageContent.trim() || null;
+    }
+  }
+  if (Array.isArray(msgContent)) {
+    const text = msgContent.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+    return text || null;
+  }
+  if (msgContent?.type === "event") {
+    return null;
+  }
+  return null;
+}
+function shouldDisplayMessage(msg) {
+  return extractMessageText(msg) !== null;
+}
+function formatMessage(msg, indent = "", maxLen = 200) {
+  const role = msg.role;
+  let prefix;
+  if (role === "user") {
+    prefix = "\u{1F464} User";
+  } else if (role === "agent" || role === "assistant") {
+    prefix = "\u{1F916} Assistant";
+  } else {
+    prefix = `[${role || "unknown"}]`;
+  }
+  let content = extractMessageText(msg) || "";
+  if (maxLen >= 0 && content.length > maxLen) {
+    content = content.substring(0, maxLen) + "...";
+  }
+  content = content.replace(/\n/g, `
+${indent}         `);
+  return `${indent}${prefix}: ${content}`;
+}
+async function listSessions(credentials, options = {}) {
+  try {
+    const serverUrl = configuration.serverUrl;
+    const response = await axios.get(`${serverUrl}/v2/sessions/active`, {
+      headers: {
+        "Authorization": `Bearer ${credentials.token}`
+      }
+    });
+    const sessions = response.data.sessions;
+    if (sessions.length === 0) {
+      console.log("No active sessions found.");
+      return;
+    }
+    const processedSessions = [];
+    for (const session of sessions) {
+      logger.debug(`
+=== Processing session ${session.id} ===`);
+      logger.debug(`Has dataEncryptionKey: ${!!session.dataEncryptionKey}`);
+      logger.debug(`Has metadata: ${!!session.metadata}`);
+      let metadata = {};
+      let agentState = {};
+      let encryptionKey = null;
+      let encryptionVariant = "dataKey";
+      if (session.dataEncryptionKey) {
+        logger.debug(`Session has dataEncryptionKey, attempting to decrypt...`);
+        encryptionKey = decryptDataEncryptionKey(session.dataEncryptionKey, credentials);
+        if (!encryptionKey) {
+          logger.debug(`Failed to decrypt dataEncryptionKey for session ${session.id}`);
+        } else {
+          logger.debug(`Successfully decrypted dataEncryptionKey`);
+        }
+      } else if (credentials.encryption.type === "dataKey") {
+        logger.debug(`Using machineKey directly for CLI session`);
+        encryptionKey = credentials.encryption.machineKey;
+      } else {
+        logger.debug(`Using legacy secret key`);
+        encryptionKey = credentials.encryption.secret;
+        encryptionVariant = "legacy";
+      }
+      if (session.metadata && encryptionKey) {
+        logger.debug(`Attempting to decrypt metadata...`);
+        try {
+          const metadataBytes = decodeBase64(session.metadata);
+          const decrypted = decrypt(encryptionKey, encryptionVariant, metadataBytes);
+          if (decrypted) {
+            logger.debug(`Successfully decrypted metadata:`, JSON.stringify(decrypted));
+            metadata = decrypted;
+          }
+        } catch (error) {
+          logger.debug(`Failed to decrypt metadata for session ${session.id}:`, error);
+        }
+      }
+      if (session.agentState && encryptionKey) {
+        try {
+          const decrypted = decrypt(encryptionKey, encryptionVariant, decodeBase64(session.agentState));
+          if (decrypted) {
+            agentState = decrypted;
+          }
+        } catch (error) {
+          logger.debug(`Failed to decrypt agent state for session ${session.id}:`, error);
+        }
+      }
+      let title = "(Untitled)";
+      if (metadata.summary?.text) {
+        title = metadata.summary.text;
+      } else if (metadata.path) {
+        const segments = metadata.path.split("/").filter(Boolean);
+        if (segments.length > 0) {
+          title = segments[segments.length - 1];
+        }
+      }
+      let workingDir = metadata.path || "(Unknown)";
+      if (metadata.claudeSessionId && metadata.path) {
+        workingDir = getCurrentWorkingDirectory(metadata.claudeSessionId, metadata.path);
+      }
+      processedSessions.push({
+        session,
+        metadata,
+        agentState,
+        encryptionKey,
+        encryptionVariant,
+        title,
+        host: metadata.host || "(Unknown)",
+        workingDir,
+        thinking: !!agentState.thinking
+      });
+    }
+    let filteredSessions = processedSessions;
+    if (options.sessionId) {
+      const idFilter = options.sessionId.toLowerCase();
+      filteredSessions = filteredSessions.filter(
+        (s) => s.session.id.toLowerCase().startsWith(idFilter)
+      );
+    }
+    if (options.titleFilter) {
+      const titleFilter = options.titleFilter.toLowerCase();
+      filteredSessions = filteredSessions.filter(
+        (s) => s.title.toLowerCase().includes(titleFilter)
+      );
+    }
+    if (filteredSessions.length === 0) {
+      if (options.sessionId || options.titleFilter) {
+        console.log("No sessions match the specified filters.");
+      } else {
+        console.log("No active sessions found.");
+      }
+      return;
+    }
+    const showMessages = options.recentMsgs && options.recentMsgs > 0;
+    const needsSeparators = showMessages && filteredSessions.length > 1;
+    const indent = needsSeparators ? "    " : "";
+    console.log(`
+Active Sessions (${filteredSessions.length}):
+`);
+    for (let i = 0; i < filteredSessions.length; i++) {
+      const { session, encryptionKey, encryptionVariant, title, host, workingDir, thinking } = filteredSessions[i];
+      if (needsSeparators && i > 0) {
+        console.log("\n" + "\u2550".repeat(70) + "\n");
+      }
+      const thinkingStatus = thinking ? "\u{1F914} Thinking" : "\u{1F4A4} Idle";
+      console.log(`${indent}ID: ${session.id}`);
+      console.log(`${indent}Title: ${title}`);
+      console.log(`${indent}Working Directory: ${workingDir}`);
+      console.log(`${indent}Host: ${host}`);
+      console.log(`${indent}Status: ${thinkingStatus}`);
+      console.log(`${indent}Last Active: ${formatTimeAgo(session.activeAt)}`);
+      if (showMessages && encryptionKey) {
+        console.log(`${indent}Recent Messages:`);
+        const messages = await fetchSessionMessages(
+          session.id,
+          credentials,
+          encryptionKey,
+          encryptionVariant,
+          options.recentMsgs
+        );
+        const displayableMessages = messages.filter(shouldDisplayMessage);
+        const msgLen = options.msgLen ?? 200;
+        if (displayableMessages.length === 0) {
+          console.log(`${indent}    (no messages)`);
+        } else {
+          for (const msg of displayableMessages) {
+            console.log(formatMessage(msg, indent + "    ", msgLen));
+          }
+        }
+      }
+      console.log("");
+    }
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.response?.status === 401) {
+        console.error("Authentication failed. Please run `happy auth` to authenticate.");
+      } else {
+        console.error(`Failed to fetch sessions: ${error.response?.data?.message || error.message}`);
+      }
+    } else {
+      console.error(`Failed to fetch sessions: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+export { listSessions };