parallel-codex-tui 0.2.9 → 0.3.0

package/dist/core/session-manager.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { cp, mkdir, mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { cp, mkdir, mkdtemp, open, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { createInterface } from "node:readline";
 import { z } from "zod";
 import { appendJsonLine, appendText, ensureDir, pathExists, readJson, readRecentJsonLines, readTextIfExists, removeIfExists, writeJson, writeText } from "./file-store.js";
 import { runWithLeaseFinalization } from "./lease-finalization.js";
@@ -183,7 +185,7 @@ export class SessionManager {
         }
         return readJson(path, MainConversationStateSchema);
     }
-    async listMainConversations(limit = 100) {
+    async listMainConversations(limit = 100, options = {}) {
         const boundedLimit = Number.isFinite(limit)
             ? Math.min(500, Math.max(0, Math.trunc(limit)))
             : 100;
@@ -223,7 +225,13 @@ export class SessionManager {
             return summary;
         };
         for (const archive of archives) {
-            ensureConversation(archive.id, archive.created_at, archive.last_activated_at);
+            const conversation = ensureConversation(archive.id, archive.created_at, archive.last_activated_at);
+            if (archive.title) {
+                conversation.title = archive.title;
+            }
+            if (archive.archived_at) {
+                conversation.archivedAt = archive.archived_at;
+            }
         }
         for (const record of records) {
             const id = record.conversation_id ?? null;
@@ -254,7 +262,9 @@ export class SessionManager {
             conversation.nativeSessionCount = archived.size;
         }));
         return [...conversations.values()]
+            .filter((conversation) => options.includeArchived || !conversation.archivedAt || conversation.current)
             .sort((left, right) => (Number(right.current) - Number(left.current)
+            || Number(Boolean(left.archivedAt)) - Number(Boolean(right.archivedAt))
             || right.lastActivityAt.localeCompare(left.lastActivityAt)
             || mainConversationScopeKey(right.id).localeCompare(mainConversationScopeKey(left.id))))
             .slice(0, boundedLimit);
@@ -292,11 +302,14 @@ export class SessionManager {
         await ensureDir(main.dir);
         const lease = await this.claimTaskRunLease(main.dir);
         return runWithLeaseFinalization("Main conversation restore", lease, async () => {
-            const conversations = await this.listMainConversations(500);
+            const conversations = await this.listMainConversations(500, { includeArchived: true });
             const target = conversations.find((conversation) => conversation.id === id);
             if (!target) {
                 throw new Error(`Main conversation not found: ${id ?? "legacy"}`);
             }
+            if (target.archivedAt) {
+                throw new Error(`Cannot restore archived Main conversation ${id ?? "legacy"}. Unarchive it first.`);
+            }
             const current = await this.readMainConversationState();
             const currentId = current?.id ?? null;
             if (currentId === id) {
@@ -331,6 +344,140 @@ export class SessionManager {
             return { conversation: restored, restoredNativeSessions, changed: true };
         });
     }
+    async renameMainConversation(conversationId, title) {
+        const normalizedTitle = normalizeMainConversationTitle(title);
+        return this.withMainConversationManagementLease(conversationId, "rename", async (main, conversation) => {
+            const metadata = await this.mainConversationArchiveMetadata(conversation);
+            await this.writeMainConversationArchive({ ...metadata, title: normalizedTitle });
+            await this.appendEvent(main, "main.conversation_renamed", `Renamed ${conversation.id ?? "legacy conversation"} to ${normalizedTitle}`);
+            return this.requireMainConversationSummary(conversation.id);
+        });
+    }
+    async setMainConversationArchived(conversationId, archived) {
+        return this.withMainConversationManagementLease(conversationId, archived ? "archive" : "unarchive", async (main, conversation) => {
+            if (archived && conversation.current) {
+                throw new Error("Cannot archive the current Main conversation. Restore another conversation first.");
+            }
+            if (Boolean(conversation.archivedAt) === archived) {
+                return conversation;
+            }
+            const metadata = await this.mainConversationArchiveMetadata(conversation);
+            const next = archived
+                ? MainConversationArchiveSchema.parse({
+                    ...metadata,
+                    archived_at: this.now().toISOString()
+                })
+                : withoutMainConversationArchiveTime(metadata);
+            await writeJson(join(this.mainConversationArchiveDir(conversation.id), "meta.json"), next);
+            await this.appendEvent(main, archived ? "main.conversation_archived" : "main.conversation_unarchived", archived
+                ? `Archived ${conversation.id ?? "legacy conversation"}`
+                : `Unarchived ${conversation.id ?? "legacy conversation"}`);
+            return this.requireMainConversationSummary(conversation.id);
+        });
+    }
+    async deleteMainConversation(conversationId) {
+        await this.withMainConversationManagementLease(conversationId, "delete", async (main, conversation) => {
+            if (conversation.current) {
+                throw new Error("Cannot delete the current Main conversation. Restore another conversation first.");
+            }
+            const staging = await mkdtemp(join(main.dir, ".conversation-delete-"));
+            const chatPath = join(main.dir, "chat.jsonl");
+            const replacementPath = join(staging, "chat.next.jsonl");
+            const originalPath = join(staging, "chat.original.jsonl");
+            const archivePath = this.mainConversationArchiveDir(conversation.id);
+            const stagedArchivePath = join(staging, "archive");
+            let archiveMoved = false;
+            let originalMoved = false;
+            let replacementInstalled = false;
+            try {
+                await writeConversationChatFile(chatPath, replacementPath, conversation.id, "exclude");
+                if (await pathExists(archivePath)) {
+                    await rename(archivePath, stagedArchivePath);
+                    archiveMoved = true;
+                }
+                if (await pathExists(chatPath)) {
+                    await rename(chatPath, originalPath);
+                    originalMoved = true;
+                }
+                await rename(replacementPath, chatPath);
+                replacementInstalled = true;
+                await this.appendEvent(main, "main.conversation_deleted", `Deleted ${conversation.id ?? "legacy conversation"}`);
+            }
+            catch (error) {
+                const rollbackErrors = [];
+                if (replacementInstalled) {
+                    try {
+                        await removeIfExists(chatPath);
+                    }
+                    catch (rollbackError) {
+                        rollbackErrors.push(rollbackError);
+                    }
+                }
+                if (originalMoved) {
+                    try {
+                        await rename(originalPath, chatPath);
+                    }
+                    catch (rollbackError) {
+                        rollbackErrors.push(rollbackError);
+                    }
+                }
+                if (archiveMoved) {
+                    try {
+                        await rename(stagedArchivePath, archivePath);
+                    }
+                    catch (rollbackError) {
+                        rollbackErrors.push(rollbackError);
+                    }
+                }
+                await rm(staging, { force: true, recursive: true }).catch(() => undefined);
+                if (rollbackErrors.length > 0) {
+                    throw new Error(`Main conversation deletion failed and rollback also failed: ${errorMessage(error)}`, { cause: new AggregateError([error, ...rollbackErrors]) });
+                }
+                throw error;
+            }
+            await rm(staging, { force: true, recursive: true }).catch(() => undefined);
+        });
+    }
+    async exportMainConversation(conversationId) {
+        return this.withMainConversationManagementLease(conversationId, "export", async (main, conversation) => {
+            const createdAt = this.now().toISOString();
+            const exportsRoot = join(this.projectRoot, this.dataDir, "exports");
+            await ensureDir(exportsRoot);
+            const scope = conversation.id ?? "main-legacy";
+            const staging = await mkdtemp(join(exportsRoot, `.${scope}-`));
+            const suffix = basename(staging).slice(-6);
+            const stamp = createdAt.replace(/[^0-9]/g, "").slice(0, 14);
+            const destination = join(exportsRoot, `${scope}-${stamp}-${suffix}`);
+            try {
+                const messageCount = await writeConversationChatFile(join(main.dir, "chat.jsonl"), join(staging, "chat.jsonl"), conversation.id, "include");
+                const nativeSessions = await this.mainConversationNativeSessions(conversation.id, conversation.current);
+                for (const session of nativeSessions) {
+                    await writeJson(join(staging, "native-sessions", `${session.worker_id}.json`), session);
+                }
+                await writeJson(join(staging, "manifest.json"), {
+                    format: "parallel-codex-main-conversation-export-v1",
+                    exported_at: createdAt,
+                    source_workspace: this.projectRoot,
+                    conversation: {
+                        id: conversation.id,
+                        title: conversation.title,
+                        created_at: conversation.createdAt,
+                        last_activity_at: conversation.lastActivityAt,
+                        ...(conversation.archivedAt ? { archived_at: conversation.archivedAt } : {})
+                    },
+                    message_count: messageCount,
+                    native_session_count: nativeSessions.length
+                });
+                await this.appendEvent(main, "main.conversation_exported", `Exported ${conversation.id ?? "legacy conversation"}`);
+                await rename(staging, destination);
+            }
+            catch (error) {
+                await rm(staging, { force: true, recursive: true });
+                throw error;
+            }
+            return { conversationId: conversation.id, path: destination, createdAt };
+        });
+    }
     async reconcileInterruptedMainSession() {
         const main = this.taskFromId("main");
         if (!(await pathExists(main.dir))) {
@@ -924,6 +1071,24 @@ export class SessionManager {
         await this.clearWorkerStatusNativeSession(worker);
         await this.index?.deleteNativeSession(this.taskIdFromWorkerDir(worker.dir), record.worker_id);
     }
+    async mainConversationArchiveMetadata(conversation) {
+        const existing = await readMainConversationArchiveIfValid(join(this.mainConversationArchiveDir(conversation.id), "meta.json"));
+        return MainConversationArchiveSchema.parse({
+            ...existing,
+            version: 1,
+            id: conversation.id,
+            created_at: existing?.created_at ?? conversation.createdAt,
+            last_activated_at: existing?.last_activated_at ?? conversation.lastActivityAt
+        });
+    }
+    async requireMainConversationSummary(conversationId) {
+        const conversation = (await this.listMainConversations(500, { includeArchived: true }))
+            .find((entry) => entry.id === conversationId);
+        if (!conversation) {
+            throw new Error(`Main conversation disappeared from its catalog: ${conversationId ?? "legacy"}`);
+        }
+        return conversation;
+    }
     mainConversationArchiveDir(conversationId) {
         return join(this.mainSessionDir(), MAIN_CONVERSATION_ARCHIVE_DIRECTORY, mainConversationScopeKey(conversationId));
     }
@@ -949,6 +1114,7 @@ export class SessionManager {
         const path = join(this.mainConversationArchiveDir(parsed.id), "meta.json");
         const existing = await readMainConversationArchiveIfValid(path);
         await writeJson(path, MainConversationArchiveSchema.parse({
+            ...existing,
             ...parsed,
             created_at: existing && existing.created_at < parsed.created_at
                 ? existing.created_at
@@ -1045,6 +1211,39 @@ export class SessionManager {
         }
         return ids;
     }
+    async mainConversationNativeSessions(conversationId, includeActive) {
+        const sessions = new Map();
+        const archiveDir = join(this.mainConversationArchiveDir(conversationId), "native-sessions");
+        if (await pathExists(archiveDir)) {
+            for (const entry of await readdir(archiveDir, { withFileTypes: true })) {
+                if (!entry.isFile() || !entry.name.endsWith(".json")) {
+                    continue;
+                }
+                const record = await readNativeSessionIfValid(join(archiveDir, entry.name));
+                if (record?.scope === "main"
+                    && record.role === "main"
+                    && safeMainWorkerId(record.worker_id)
+                    && entry.name === `${record.worker_id}.json`) {
+                    sessions.set(record.worker_id, record);
+                }
+            }
+        }
+        if (includeActive) {
+            const mainDir = this.mainSessionDir();
+            for (const entry of await readdir(mainDir, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name === MAIN_CONVERSATION_ARCHIVE_DIRECTORY) {
+                    continue;
+                }
+                const record = await this.readNativeSession({ dir: join(mainDir, entry.name) });
+                if (record?.scope === "main"
+                    && record.role === "main"
+                    && safeMainWorkerId(record.worker_id)) {
+                    sessions.set(record.worker_id, record);
+                }
+            }
+        }
+        return [...sessions.values()].sort((left, right) => left.worker_id.localeCompare(right.worker_id));
+    }
     async appendEvent(task, type, message) {
         const event = {
             time: this.now().toISOString(),
@@ -1069,6 +1268,20 @@ export class SessionManager {
             return run(task, meta);
         });
     }
+    async withMainConversationManagementLease(conversationId, operation, run) {
+        const id = conversationId === null ? null : ConversationIdSchema.parse(conversationId);
+        const main = this.taskFromId("main");
+        await ensureDir(main.dir);
+        const lease = await this.claimTaskRunLease(main.dir);
+        return runWithLeaseFinalization(`Main conversation ${operation}`, lease, async () => {
+            const conversation = (await this.listMainConversations(500, { includeArchived: true }))
+                .find((entry) => entry.id === id);
+            if (!conversation) {
+                throw new Error(`Main conversation not found: ${id ?? "legacy"}`);
+            }
+            return run(main, conversation);
+        });
+    }
     assertTerminalTask(meta, operation) {
         if (!TERMINAL_TASK_STATES.has(meta.status)) {
             throw new Error(`Cannot ${operation} task ${meta.id} while it is ${meta.status}.`);
@@ -1620,6 +1833,10 @@ function nextConversationId(baseId, previousId) {
 function mainConversationScopeKey(conversationId) {
     return conversationId ?? LEGACY_MAIN_CONVERSATION_DIRECTORY;
 }
+function withoutMainConversationArchiveTime(metadata) {
+    const { archived_at: _archivedAt, ...active } = metadata;
+    return MainConversationArchiveSchema.parse(active);
+}
 function mainConversationTitle(text, conversationId) {
     const sanitized = sanitizePersistedMainMessage("user", text)
         .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
@@ -1634,9 +1851,75 @@ function mainConversationTitle(text, conversationId) {
         ? `${characters.slice(0, 77).join("")}...`
         : sanitized;
 }
+function normalizeMainConversationTitle(title) {
+    const normalized = title
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized) {
+        throw new Error("Main conversation title cannot be empty.");
+    }
+    if (Array.from(normalized).length > 160) {
+        throw new Error("Main conversation title cannot exceed 160 characters.");
+    }
+    return normalized;
+}
 function safeMainWorkerId(workerId) {
     return SAFE_MAIN_WORKER_ID.test(workerId) && workerId !== "." && workerId !== "..";
 }
+async function writeConversationChatFile(sourcePath, destinationPath, conversationId, mode) {
+    await ensureDir(dirname(destinationPath));
+    const output = await open(destinationPath, "wx");
+    let matched = 0;
+    let buffer = "";
+    try {
+        if (!(await pathExists(sourcePath))) {
+            await output.close();
+            return 0;
+        }
+        const input = createReadStream(sourcePath, { encoding: "utf8" });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        for await (const line of lines) {
+            const belongs = chatLineBelongsToMainConversation(line, conversationId);
+            if (belongs) {
+                matched += 1;
+            }
+            if ((mode === "include") !== belongs) {
+                continue;
+            }
+            buffer += `${line}\n`;
+            if (Buffer.byteLength(buffer, "utf8") >= 64 * 1024) {
+                await output.write(buffer);
+                buffer = "";
+            }
+        }
+        if (buffer) {
+            await output.write(buffer);
+        }
+        await output.close();
+        return matched;
+    }
+    catch (error) {
+        await output.close().catch(() => undefined);
+        await removeIfExists(destinationPath).catch(() => undefined);
+        throw error;
+    }
+}
+function chatLineBelongsToMainConversation(line, conversationId) {
+    try {
+        const parsed = ChatRecordSchema.safeParse(JSON.parse(line));
+        if (!parsed.success || parsed.data.task_id) {
+            return false;
+        }
+        return conversationId
+            ? parsed.data.conversation_id === conversationId
+            : !parsed.data.conversation_id;
+    }
+    catch {
+        return false;
+    }
+}
 function normalizeTaskTitle(title) {
     const normalized = title
         .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")

package/dist/domain/schemas.js

@@ -209,7 +209,9 @@ export const MainConversationArchiveSchema = z.object({
     version: z.literal(1),
     id: ConversationIdSchema.nullable(),
     created_at: z.string().datetime(),
-    last_activated_at: z.string().datetime()
+    last_activated_at: z.string().datetime(),
+    title: z.string().min(1).max(160).optional(),
+    archived_at: z.string().datetime().optional()
 });
 export const ChatRecordSchema = z.object({
     time: z.string().datetime(),