kennel 0.1.9 → 0.2.1

package/node_modules/@raggle-ai/local/dist/sessions/index.js

@@ -0,0 +1,686 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_SESSION_CLIENTS = exports.sessionResumeTarget = exports.sessionResumeCommand = exports.SESSION_RESUME_DEEPLINKS = exports.sessionCreateCommand = void 0;
+exports.listLocalSessionProjectActivity = listLocalSessionProjectActivity;
+exports.listLocalSessions = listLocalSessions;
+exports.readLocalSession = readLocalSession;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+var create_1 = require("./create");
+Object.defineProperty(exports, "sessionCreateCommand", { enumerable: true, get: function () { return create_1.sessionCreateCommand; } });
+var resume_1 = require("./resume");
+Object.defineProperty(exports, "SESSION_RESUME_DEEPLINKS", { enumerable: true, get: function () { return resume_1.SESSION_RESUME_DEEPLINKS; } });
+Object.defineProperty(exports, "sessionResumeCommand", { enumerable: true, get: function () { return resume_1.sessionResumeCommand; } });
+Object.defineProperty(exports, "sessionResumeTarget", { enumerable: true, get: function () { return resume_1.sessionResumeTarget; } });
+exports.LOCAL_SESSION_CLIENTS = ["codex", "claude", "pi", "opencode"];
+const maxHeadBytes = 256 * 1_024;
+function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function string(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function timestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return new Date(value).toISOString();
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+        return undefined;
+    return new Date(value).toISOString();
+}
+function safeRealpath(item) {
+    try {
+        return (0, node_fs_1.realpathSync)(item);
+    }
+    catch {
+        return node_path_1.default.resolve(item);
+    }
+}
+function isWithinFolder(candidate, folder) {
+    const resolvedCandidate = safeRealpath(candidate);
+    const resolvedFolder = safeRealpath(folder);
+    return resolvedCandidate === resolvedFolder || resolvedCandidate.startsWith(`${resolvedFolder}${node_path_1.default.sep}`);
+}
+function readJsonLines(filePath) {
+    try {
+        return (0, node_fs_1.readFileSync)(filePath, "utf8")
+            .split("\n")
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function readHeadJsonLines(filePath) {
+    let fd;
+    try {
+        const fileSize = (0, node_fs_1.statSync)(filePath).size;
+        const size = Math.min(fileSize, maxHeadBytes);
+        const buffer = Buffer.alloc(size);
+        fd = (0, node_fs_1.openSync)(filePath, "r");
+        (0, node_fs_1.readSync)(fd, buffer, 0, size, 0);
+        const lines = buffer.toString("utf8").split("\n");
+        if (size < fileSize)
+            lines.pop();
+        return lines.flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (fd !== undefined)
+            (0, node_fs_1.closeSync)(fd);
+    }
+}
+function jsonlFiles(root, recursive = true) {
+    const files = [];
+    function visit(current) {
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory() && recursive)
+                visit(entryPath);
+            else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+                files.push(entryPath);
+        }
+    }
+    visit(root);
+    return files;
+}
+function fileActivityAt(filePath) {
+    try {
+        return new Date((0, node_fs_1.statSync)(filePath).mtimeMs).toISOString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function firstTimestamp(records) {
+    return records.flatMap((record) => timestamp(record.timestamp) ?? []).at(0);
+}
+function latestTimestamp(messages) {
+    return messages
+        .flatMap((message) => (message.timestamp ? [message.timestamp] : []))
+        .sort((a, b) => Date.parse(b) - Date.parse(a))[0];
+}
+function textContent(value) {
+    if (typeof value === "string")
+        return value.trim() ? [{ type: "text", text: value }] : [];
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        const block = object(item);
+        if (!block)
+            return [];
+        const type = string(block.type);
+        const text = string(block.text) ?? string(block.content);
+        if (["text", "input_text", "output_text"].includes(type ?? "") && text)
+            return [{ type: "text", text }];
+        if (type === "tool_use" || type === "toolCall") {
+            return [{ type: "tool-call", name: string(block.name) ?? "tool", input: block.input ?? block.arguments }];
+        }
+        if (type === "tool_result" && text)
+            return [{ type: "tool-result", output: text }];
+        return [];
+    });
+}
+function titleFromMessages(messages) {
+    const text = messages
+        .filter((message) => message.role === "user")
+        .flatMap((message) => message.content)
+        .find((content) => content.type === "text")?.text;
+    return (text
+        ?.replace(/<[^>]+>/g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 200) ?? "");
+}
+function normalizeTitle(value) {
+    const title = value?.trim();
+    if (!title || /^New (session|thread)(\b| -)/i.test(title))
+        return "";
+    return title.slice(0, 200);
+}
+function summary(client, nativeId, values) {
+    return { id: `${client}:${nativeId}`, client, ...values, title: values.title || "Untitled" };
+}
+function codexHome() {
+    return process.env.CODEX_HOME || node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+}
+function codexTitles() {
+    const titles = new Map();
+    for (const row of readJsonLines(node_path_1.default.join(codexHome(), "session_index.jsonl"))) {
+        const id = string(row.id);
+        const title = normalizeTitle(string(row.thread_name));
+        if (id && title)
+            titles.set(id, title);
+    }
+    return titles;
+}
+function codexMessages(records) {
+    return records.flatMap((record) => {
+        const payload = object(record.payload);
+        const ts = timestamp(record.timestamp);
+        if (record.type === "event_msg" && payload?.type === "user_message") {
+            const text = string(payload.message);
+            return text ? [{ role: "user", timestamp: ts, content: [{ type: "text", text }] }] : [];
+        }
+        if (record.type === "event_msg" && payload?.type === "agent_message") {
+            const text = string(payload.message);
+            return text ? [{ role: "assistant", timestamp: ts, content: [{ type: "text", text }] }] : [];
+        }
+        if (record.type === "response_item" && payload?.type === "function_call") {
+            let input = payload.arguments;
+            if (typeof input === "string") {
+                try {
+                    input = JSON.parse(input);
+                }
+                catch {
+                    // Keep the original argument text.
+                }
+            }
+            return [
+                { role: "tool", timestamp: ts, content: [{ type: "tool-call", name: string(payload.name) ?? "tool", input }] },
+            ];
+        }
+        if (record.type === "response_item" && payload?.type === "function_call_output") {
+            const output = string(payload.output);
+            return output ? [{ role: "tool", timestamp: ts, content: [{ type: "tool-result", output }] }] : [];
+        }
+        return [];
+    });
+}
+function parseCodexFile(filePath, archived, titles) {
+    const records = readJsonLines(filePath);
+    const meta = records.find((record) => record.type === "session_meta");
+    const payload = object(meta?.payload);
+    const id = string(payload?.id);
+    const folder = string(payload?.cwd);
+    if (!id ||
+        !folder ||
+        payload?.thread_source === "subagent" ||
+        object(payload?.source)?.subagent ||
+        object(payload?.thread_source)?.parent_thread_id)
+        return undefined;
+    const messages = codexMessages(records);
+    return summary("codex", id, {
+        title: titles.get(id) ?? titleFromMessages(messages),
+        folder: safeRealpath(folder),
+        createdAt: timestamp(payload?.timestamp) ?? firstTimestamp(records),
+        lastMessageAt: latestTimestamp(messages),
+        messageCount: messages.filter((message) => message.role !== "tool").length,
+        archived,
+        messages,
+    });
+}
+function codexSessions(folder, wantedId) {
+    const home = codexHome();
+    const titles = codexTitles();
+    const roots = [
+        { root: node_path_1.default.join(home, "sessions"), archived: false },
+        { root: node_path_1.default.join(home, "archived_sessions"), archived: true },
+    ];
+    const sessions = [];
+    for (const { root, archived } of roots) {
+        for (const filePath of jsonlFiles(root)) {
+            const headMeta = readHeadJsonLines(filePath).find((record) => record.type === "session_meta");
+            const headPayload = object(headMeta?.payload);
+            const id = string(headPayload?.id);
+            const cwd = string(headPayload?.cwd);
+            if (!id || !cwd || (wantedId ? id !== wantedId : folder && !isWithinFolder(cwd, folder)))
+                continue;
+            const session = parseCodexFile(filePath, archived, titles);
+            if (session)
+                sessions.push(session);
+        }
+    }
+    return sessions;
+}
+function claudeRoot() {
+    return node_path_1.default.join(process.env.CLAUDE_CONFIG_DIR || node_path_1.default.join(node_os_1.default.homedir(), ".claude"), "projects");
+}
+function claudeMessages(records) {
+    return records.flatMap((record) => {
+        if (record.isSidechain === true || record.isCompactSummary === true)
+            return [];
+        if (record.type !== "user" && record.type !== "assistant")
+            return [];
+        const message = object(record.message);
+        const role = record.type === "assistant" ? "assistant" : "user";
+        const content = textContent(message?.content);
+        return content.length ? [{ role, timestamp: timestamp(record.timestamp), content }] : [];
+    });
+}
+function parseClaudeFile(filePath) {
+    const records = readJsonLines(filePath);
+    const metadata = records.find((record) => string(record.cwd) && string(record.sessionId));
+    const id = string(metadata?.sessionId) ?? node_path_1.default.basename(filePath, ".jsonl");
+    const folder = string(metadata?.cwd);
+    if (!folder)
+        return undefined;
+    const messages = claudeMessages(records);
+    let explicitTitle = "";
+    let generatedTitle = "";
+    for (const record of records) {
+        if (record.type === "custom-title")
+            explicitTitle = normalizeTitle(string(record.customTitle));
+        else if (record.type === "ai-title" && !generatedTitle)
+            generatedTitle = normalizeTitle(string(record.aiTitle));
+        else if (record.type === "agent-name" && !generatedTitle)
+            generatedTitle = normalizeTitle(string(record.agentName));
+    }
+    return summary("claude", id, {
+        title: explicitTitle || generatedTitle || titleFromMessages(messages),
+        folder: safeRealpath(folder),
+        createdAt: firstTimestamp(records),
+        lastMessageAt: latestTimestamp(messages),
+        messageCount: messages.length,
+        archived: false,
+        messages,
+    });
+}
+function claudeSessions(folder, wantedId) {
+    const sessions = [];
+    let projects;
+    try {
+        projects = (0, node_fs_1.readdirSync)(claudeRoot(), { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    }
+    catch {
+        return sessions;
+    }
+    for (const project of projects) {
+        for (const filePath of jsonlFiles(node_path_1.default.join(claudeRoot(), project.name), false)) {
+            if (wantedId && node_path_1.default.basename(filePath, ".jsonl") !== wantedId)
+                continue;
+            const head = readHeadJsonLines(filePath);
+            const cwd = head.flatMap((record) => string(record.cwd) ?? []).at(0);
+            const id = head.flatMap((record) => string(record.sessionId) ?? []).at(0) ?? node_path_1.default.basename(filePath, ".jsonl");
+            if ((wantedId && id !== wantedId) || (!wantedId && folder && (!cwd || !isWithinFolder(cwd, folder))))
+                continue;
+            const session = parseClaudeFile(filePath);
+            if (session)
+                sessions.push(session);
+        }
+    }
+    return sessions;
+}
+function piRoot() {
+    if (process.env.PI_CODING_AGENT_SESSION_DIR)
+        return process.env.PI_CODING_AGENT_SESSION_DIR;
+    return node_path_1.default.join(process.env.PI_CODING_AGENT_DIR || node_path_1.default.join(node_os_1.default.homedir(), ".pi", "agent"), "sessions");
+}
+function activePiRecords(records) {
+    const byId = new Map(records.flatMap((record) => (string(record.id) ? [[string(record.id), record]] : [])));
+    let nextId = records.flatMap((record) => string(record.id) ?? []).at(-1);
+    if (!nextId || !records.some((record) => string(record.parentId)))
+        return records;
+    const active = new Set();
+    while (nextId && !active.has(nextId)) {
+        const record = byId.get(nextId);
+        if (!record)
+            break;
+        active.add(nextId);
+        nextId = string(record.parentId);
+    }
+    return records.filter((record) => !string(record.id) || active.has(string(record.id)));
+}
+function piMessages(records) {
+    return records.flatMap((record) => {
+        if (record.type !== "message")
+            return [];
+        const message = object(record.message);
+        const sourceRole = string(message?.role);
+        const role = sourceRole === "assistant"
+            ? "assistant"
+            : sourceRole === "user"
+                ? "user"
+                : sourceRole === "toolResult"
+                    ? "tool"
+                    : undefined;
+        if (!role)
+            return [];
+        const content = textContent(message?.content);
+        return content.length
+            ? [{ role, timestamp: timestamp(record.timestamp) ?? timestamp(message?.timestamp), content }]
+            : [];
+    });
+}
+function parsePiFile(filePath) {
+    const records = readJsonLines(filePath);
+    const header = records.find((record) => record.type === "session");
+    const id = string(header?.id);
+    const folder = string(header?.cwd);
+    if (!id || !folder)
+        return undefined;
+    const active = activePiRecords(records);
+    const messages = piMessages(active);
+    const named = active
+        .filter((record) => record.type === "session_info")
+        .flatMap((record) => normalizeTitle(string(record.name)) || [])
+        .at(-1);
+    return summary("pi", id, {
+        title: named ?? titleFromMessages(messages),
+        folder: safeRealpath(folder),
+        createdAt: timestamp(header?.timestamp) ?? firstTimestamp(records),
+        lastMessageAt: latestTimestamp(messages),
+        messageCount: messages.filter((message) => message.role !== "tool").length,
+        archived: false,
+        messages,
+    });
+}
+function piSessions(folder, wantedId) {
+    const sessions = [];
+    for (const filePath of jsonlFiles(piRoot())) {
+        const header = readHeadJsonLines(filePath).find((record) => record.type === "session");
+        const id = string(header?.id);
+        const cwd = string(header?.cwd);
+        if (!id || !cwd || (wantedId ? id !== wantedId : folder && !isWithinFolder(cwd, folder)))
+            continue;
+        const session = parsePiFile(filePath);
+        if (session)
+            sessions.push(session);
+    }
+    return sessions;
+}
+function opencodeDatabasePath() {
+    const dataPath = node_path_1.default.join(process.env.XDG_DATA_HOME || node_path_1.default.join(node_os_1.default.homedir(), ".local", "share"), "opencode");
+    if (process.env.OPENCODE_DB) {
+        return node_path_1.default.isAbsolute(process.env.OPENCODE_DB)
+            ? process.env.OPENCODE_DB
+            : node_path_1.default.join(dataPath, process.env.OPENCODE_DB);
+    }
+    const channel = process.env.OPENCODE_CHANNEL || "latest";
+    const filename = ["latest", "beta"].includes(channel) || process.env.OPENCODE_DISABLE_CHANNEL_DB === "true"
+        ? "opencode.db"
+        : `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "-")}.db`;
+    return node_path_1.default.join(dataPath, filename);
+}
+async function opencodeClient() {
+    const databasePath = opencodeDatabasePath();
+    if (!(0, node_fs_1.existsSync)(databasePath))
+        return undefined;
+    const libsqlModuleName = "@libsql/client";
+    const { createClient } = (await Promise.resolve(`${libsqlModuleName}`).then(s => __importStar(require(s))));
+    return createClient({ url: `file:${databasePath}` });
+}
+async function opencodeMessages(client, sessionId) {
+    const messageResult = await client.execute({
+        sql: "select id, time_created, time_updated, data from message where session_id = ? order by time_created asc, id asc",
+        args: [sessionId],
+    });
+    const partResult = await client.execute({
+        sql: "select message_id, data from part where session_id = ? order by time_created asc, id asc",
+        args: [sessionId],
+    });
+    const parts = new Map();
+    for (const row of partResult.rows) {
+        const messageId = string(row.message_id);
+        if (!messageId || typeof row.data !== "string")
+            continue;
+        try {
+            const list = parts.get(messageId) ?? [];
+            list.push(JSON.parse(row.data));
+            parts.set(messageId, list);
+        }
+        catch {
+            // Ignore an invalid part.
+        }
+    }
+    return messageResult.rows.flatMap((row) => {
+        const id = string(row.id);
+        if (!id || typeof row.data !== "string")
+            return [];
+        let data;
+        try {
+            data = JSON.parse(row.data);
+        }
+        catch {
+            return [];
+        }
+        const sourceRole = string(data.role);
+        const role = sourceRole === "assistant" ? "assistant" : sourceRole === "user" ? "user" : undefined;
+        if (!role)
+            return [];
+        const content = (parts.get(id) ?? []).flatMap((part) => {
+            if (part.type === "text" && string(part.text))
+                return [{ type: "text", text: string(part.text) }];
+            if (part.type === "tool") {
+                const state = object(part.state);
+                const values = [
+                    { type: "tool-call", name: string(part.tool) ?? "tool", input: state?.input },
+                ];
+                const output = string(state?.output) ?? string(state?.error);
+                if (output)
+                    values.push({ type: "tool-result", name: string(part.tool), output });
+                return values;
+            }
+            return [];
+        });
+        if (!content.length)
+            return [];
+        const times = object(data.time);
+        return [
+            {
+                role,
+                timestamp: timestamp(times?.completed) ??
+                    timestamp(times?.created) ??
+                    timestamp(row.time_updated) ??
+                    timestamp(row.time_created),
+                content,
+            },
+        ];
+    });
+}
+async function opencodeSessions(folder, wantedId) {
+    const client = await opencodeClient();
+    if (!client)
+        return [];
+    try {
+        const result = await client.execute("select id, directory, title, time_created, time_archived from session where parent_id is null");
+        const sessions = [];
+        for (const row of result.rows) {
+            const id = string(row.id);
+            const directory = string(row.directory);
+            if (!id || !directory || (wantedId ? id !== wantedId : folder && !isWithinFolder(directory, folder)))
+                continue;
+            const messages = await opencodeMessages(client, id);
+            sessions.push(summary("opencode", id, {
+                title: normalizeTitle(string(row.title)) || titleFromMessages(messages),
+                folder: safeRealpath(directory),
+                createdAt: timestamp(row.time_created),
+                lastMessageAt: latestTimestamp(messages),
+                messageCount: messages.length,
+                archived: row.time_archived !== null,
+                messages,
+            }));
+        }
+        return sessions;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        client.close();
+    }
+}
+function codexProjectActivity() {
+    const activities = [];
+    for (const root of [node_path_1.default.join(codexHome(), "sessions"), node_path_1.default.join(codexHome(), "archived_sessions")]) {
+        for (const filePath of jsonlFiles(root)) {
+            const meta = readHeadJsonLines(filePath).find((record) => record.type === "session_meta");
+            const payload = object(meta?.payload);
+            const folder = string(payload?.cwd);
+            if (!folder ||
+                payload?.thread_source === "subagent" ||
+                object(payload?.source)?.subagent ||
+                object(payload?.thread_source)?.parent_thread_id)
+                continue;
+            const lastActivityAt = fileActivityAt(filePath) ?? timestamp(payload?.timestamp) ?? timestamp(meta?.timestamp);
+            if (lastActivityAt)
+                activities.push({ client: "codex", folder: safeRealpath(folder), lastActivityAt });
+        }
+    }
+    return activities;
+}
+function claudeProjectActivity() {
+    const activities = [];
+    let projects;
+    try {
+        projects = (0, node_fs_1.readdirSync)(claudeRoot(), { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    }
+    catch {
+        return activities;
+    }
+    for (const project of projects) {
+        for (const filePath of jsonlFiles(node_path_1.default.join(claudeRoot(), project.name), false)) {
+            const folder = readHeadJsonLines(filePath)
+                .flatMap((record) => string(record.cwd) ?? [])
+                .at(0);
+            const lastActivityAt = fileActivityAt(filePath);
+            if (folder && lastActivityAt)
+                activities.push({ client: "claude", folder: safeRealpath(folder), lastActivityAt });
+        }
+    }
+    return activities;
+}
+function piProjectActivity() {
+    const activities = [];
+    for (const filePath of jsonlFiles(piRoot())) {
+        const header = readHeadJsonLines(filePath).find((record) => record.type === "session");
+        const folder = string(header?.cwd);
+        const lastActivityAt = fileActivityAt(filePath) ?? timestamp(header?.timestamp);
+        if (folder && lastActivityAt)
+            activities.push({ client: "pi", folder: safeRealpath(folder), lastActivityAt });
+    }
+    return activities;
+}
+async function opencodeProjectActivity() {
+    const client = await opencodeClient();
+    if (!client)
+        return [];
+    try {
+        const result = await client.execute("select directory, max(coalesce(time_updated, time_created)) as last_activity_at from session where parent_id is null and directory != '/' group by directory");
+        return result.rows.flatMap((row) => {
+            const folder = string(row.directory);
+            const lastActivityAt = timestamp(row.last_activity_at);
+            return folder && lastActivityAt ? [{ client: "opencode", folder: safeRealpath(folder), lastActivityAt }] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+    finally {
+        client.close();
+    }
+}
+async function listLocalSessionProjectActivity(options = {}) {
+    const clients = options.client ? [options.client] : [...exports.LOCAL_SESSION_CLIENTS];
+    const activities = await Promise.all(clients.map((client) => {
+        if (client === "codex")
+            return Promise.resolve(codexProjectActivity());
+        if (client === "claude")
+            return Promise.resolve(claudeProjectActivity());
+        if (client === "pi")
+            return Promise.resolve(piProjectActivity());
+        return opencodeProjectActivity();
+    }));
+    return activities.flat().sort((a, b) => Date.parse(b.lastActivityAt) - Date.parse(a.lastActivityAt));
+}
+function withoutMessages(session) {
+    const { messages: _messages, ...value } = session;
+    return value;
+}
+async function listLocalSessions(options) {
+    const folder = safeRealpath(options.folder);
+    const clients = options.client ? [options.client] : [...exports.LOCAL_SESSION_CLIENTS];
+    const results = await Promise.all(clients.map((client) => {
+        if (client === "codex")
+            return Promise.resolve(codexSessions(folder));
+        if (client === "claude")
+            return Promise.resolve(claudeSessions(folder));
+        if (client === "pi")
+            return Promise.resolve(piSessions(folder));
+        return opencodeSessions(folder);
+    }));
+    const sessions = results
+        .flat()
+        .sort((a, b) => Date.parse(b.lastMessageAt ?? b.createdAt ?? "1970-01-01") -
+        Date.parse(a.lastMessageAt ?? a.createdAt ?? "1970-01-01") || a.id.localeCompare(b.id))
+        .map(withoutMessages);
+    return options.limit === undefined ? sessions : sessions.slice(0, options.limit);
+}
+async function readLocalSession(id) {
+    const separator = id.indexOf(":");
+    const client = id.slice(0, separator);
+    const nativeId = id.slice(separator + 1);
+    if (separator <= 0 || !exports.LOCAL_SESSION_CLIENTS.includes(client) || !nativeId)
+        throw new Error(`Invalid session ID: ${id}`);
+    const sessions = client === "codex"
+        ? codexSessions(undefined, nativeId)
+        : client === "claude"
+            ? claudeSessions(undefined, nativeId)
+            : client === "pi"
+                ? piSessions(undefined, nativeId)
+                : await opencodeSessions(undefined, nativeId);
+    const session = sessions[0];
+    if (!session)
+        throw new Error(`Session not found: ${id}`);
+    return session;
+}