parallel-codex-tui 0.1.3 → 0.1.5

package/dist/cli-workspace.js

@@ -1,7 +1,6 @@
-import { createInterface } from "node:readline/promises";
-import { basename } from "node:path";
 import { pathExists, pathIsDirectory } from "./core/file-store.js";
 import { listWorkspaceChoices, resolveWorkspacePath, resolveWorkspaceSelection } from "./core/workspace.js";
+import { promptForWorkspaceTui } from "./cli-workspace-picker.js";
 export async function selectWorkspaceForCli(input) {
     if (input.explicitWorkspace?.trim()) {
         const explicit = resolveWorkspacePath(input.cwd, input.explicitWorkspace);
@@ -10,15 +9,15 @@ export async function selectWorkspaceForCli(input) {
         const explicitExists = await pathExists(explicit);
         const explicitIsDirectory = explicitExists && (await pathIsDirectory(explicit));
         if (!explicitIsDirectory && input.interactive !== false && shouldPromptForWorkspace(stdin, stdout)) {
-            return promptForWorkspace({
+            return promptForWorkspaceTui({
                 cwd: input.cwd,
                 choices: await listWorkspaceChoices(input.appRoot),
                 invalidExplicitWorkspace: {
                     path: explicit,
                     reason: explicitExists ? "file" : "missing"
                 },
-                stdin: stdin,
-                stdout: stdout
+                stdin,
+                stdout
             });
         }
         return resolveWorkspaceSelection(input);
@@ -29,76 +28,13 @@ export async function selectWorkspaceForCli(input) {
     if (input.interactive === false || !shouldPromptForWorkspace(stdin, stdout)) {
         return resolveWorkspaceSelection(input);
     }
-    return promptForWorkspace({
+    return promptForWorkspaceTui({
         cwd: input.cwd,
         choices,
-        stdin: stdin,
-        stdout: stdout
+        stdin,
+        stdout
     });
 }
 function shouldPromptForWorkspace(stdin, stdout) {
     return Boolean(stdin.isTTY && stdout.isTTY);
 }
-async function promptForWorkspace(input) {
-    if (input.invalidExplicitWorkspace?.reason === "missing") {
-        input.stdout.write(`Workspace does not exist: ${input.invalidExplicitWorkspace.path}\n`);
-    }
-    else if (input.invalidExplicitWorkspace?.reason === "file") {
-        input.stdout.write(`Workspace is not a directory: ${input.invalidExplicitWorkspace.path}\n`);
-    }
-    if (input.choices.length === 0) {
-        input.stdout.write("No workspace selected yet.\n");
-    }
-    else {
-        input.stdout.write("Select workspace:\n");
-        for (const [index, choice] of input.choices.entries()) {
-            input.stdout.write(`  ${index + 1}. ${workspaceLabel(choice)}\n`);
-        }
-        input.stdout.write("  n. Create/open another folder\n");
-    }
-    const rl = createInterface({ input: input.stdin, output: input.stdout });
-    try {
-        const defaultWorkspace = createableDefaultWorkspace(input.invalidExplicitWorkspace);
-        if (input.choices.length === 0) {
-            return await promptForNewWorkspace(rl, input.cwd, defaultWorkspace);
-        }
-        const defaultLabel = defaultWorkspace ? `${defaultWorkspace}, ` : "";
-        const answer = (await rl.question(`Workspace [${defaultLabel}1/${input.choices.length}, n]: `)).trim();
-        if (!answer && defaultWorkspace) {
-            return defaultWorkspace;
-        }
-        if (!answer || answer === "1") {
-            return input.choices[0]?.path ?? input.cwd;
-        }
-        const newWorkspaceMatch = answer.match(/^n(?:ew)?\s+(.+)$/i);
-        if (newWorkspaceMatch?.[1]?.trim()) {
-            return resolveWorkspacePath(input.cwd, newWorkspaceMatch[1].trim());
-        }
-        if (/^n(?:ew)?$/i.test(answer)) {
-            return await promptForNewWorkspace(rl, input.cwd, defaultWorkspace);
-        }
-        const index = Number.parseInt(answer, 10);
-        if (Number.isInteger(index) && index >= 1 && index <= input.choices.length) {
-            return input.choices[index - 1]?.path ?? input.cwd;
-        }
-        return resolveWorkspacePath(input.cwd, answer);
-    }
-    finally {
-        rl.close();
-    }
-}
-async function promptForNewWorkspace(rl, cwd, defaultWorkspace) {
-    const prompt = defaultWorkspace ? `Workspace path [${defaultWorkspace}]: ` : "Workspace path: ";
-    const answer = (await rl.question(prompt)).trim();
-    if (answer) {
-        return resolveWorkspacePath(cwd, answer);
-    }
-    return defaultWorkspace ?? cwd;
-}
-function createableDefaultWorkspace(invalidExplicitWorkspace) {
-    return invalidExplicitWorkspace?.reason === "missing" ? invalidExplicitWorkspace.path : undefined;
-}
-function workspaceLabel(choice) {
-    const marker = choice.exists ? "" : " (will create)";
-    return `${basename(choice.path) || choice.path}  ${choice.path}${marker}`;
-}

package/dist/cli.js

@@ -1,29 +1,33 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
+import { join } from "node:path";
 import { render } from "ink";
 import { ZodError } from "zod";
 import { parseCliArgs, validateCliArgs } from "./cli-args.js";
 import { selectWorkspaceForCli } from "./cli-workspace.js";
+import { commitWorkspaceTransition } from "./cli-workspace-transition.js";
+import { WorkspaceSelectionCancelledError } from "./cli-workspace-picker.js";
+import { startupRecoveryMessages } from "./cli-startup-recovery.js";
+import { startupPreflightMessages } from "./cli-startup-preflight.js";
 import { createRuntime } from "./bootstrap.js";
 import { prepareAppRoot } from "./core/app-root.js";
-import { configPath, writeDefaultConfig } from "./core/config.js";
+import { formatConfigErrorMessage } from "./core/config-errors.js";
+import { configPath, loadConfig, withUiThemeOverride, writeDefaultConfig } from "./core/config.js";
 import { pathExists } from "./core/file-store.js";
-import { runDoctor } from "./doctor.js";
+import { readRouterAudit } from "./core/router-audit.js";
+import { loadTaskSessionDetails as loadPersistedTaskSessionDetails } from "./core/task-session-details.js";
+import { listWorkspaceChoices } from "./core/workspace.js";
+import { runDoctor, runRuntimePreflight } from "./doctor.js";
+import { helpText } from "./cli-help.js";
 import { App } from "./tui/App.js";
+import { formatTuiThemeCatalog } from "./tui/theme-preview.js";
+import { configureTuiTheme } from "./tui/theme.js";
+import { routerDiagnosticsPolicy } from "./tui/RouterDiagnosticsView.js";
 import { version } from "./version.js";
-const helpText = `Usage: parallel-codex-tui [options]
-
-Options:
-  -w, --workspace <path>  Project workspace for worker sessions and edits
-      --app-root <path>   App root for configuration lookup
-  -t, --task <id>         Open an existing task session
-      --init              Write .parallel-codex/config.toml if missing
-      --doctor            Check local configuration and agent commands
-  -v, --version           Print the current version
-  -h, --help              Print this help message
-
-Options with values also accept --name=value and -x=value forms.`;
 main().catch((error) => {
+    if (error instanceof WorkspaceSelectionCancelledError) {
+        return;
+    }
     process.stderr.write(`${formatStartupError(error)}\n`);
     process.exit(1);
 });
@@ -35,7 +39,7 @@ async function main() {
         process.exit(1);
     }
     const cliArgs = parseCliArgs(rawArgs, process.cwd());
-    if (!cliArgs.help && !cliArgs.version) {
+    if (!cliArgs.help && !cliArgs.themes && !cliArgs.version) {
         await prepareAppRoot(cliArgs.appRoot);
     }
     const localConfigPath = configPath(cliArgs.appRoot);
@@ -45,6 +49,9 @@ async function main() {
     else if (cliArgs.version) {
         console.log(`parallel-codex-tui ${version}`);
     }
+    else if (cliArgs.themes) {
+        console.log(formatTuiThemeCatalog(cliArgs.theme ? [cliArgs.theme] : undefined).join("\n"));
+    }
     else if (cliArgs.doctor) {
         const workspaceRoot = await selectWorkspaceForCli({
             appRoot: cliArgs.appRoot,
@@ -52,7 +59,11 @@ async function main() {
             explicitWorkspace: cliArgs.explicitWorkspace,
             interactive: false
         });
-        const result = await runDoctor(cliArgs.appRoot, workspaceRoot);
+        const result = await runDoctor(cliArgs.appRoot, workspaceRoot, process.env, {
+            probeAgents: cliArgs.probeAgents,
+            probeRouter: cliArgs.probeRouter,
+            theme: cliArgs.theme
+        });
         process.stdout.write(result.text);
         process.exitCode = result.ok ? 0 : 1;
     }
@@ -66,28 +77,227 @@ async function main() {
         }
     }
     else {
+        const startupConfig = await loadConfig(cliArgs.appRoot);
+        configureTuiTheme({
+            theme: cliArgs.theme ?? startupConfig.ui.theme,
+            colors: startupConfig.ui.colors
+        });
         const workspaceRoot = await selectWorkspaceForCli({
             appRoot: cliArgs.appRoot,
             cwd: process.cwd(),
             explicitWorkspace: cliArgs.explicitWorkspace
         });
-        const runtime = await createRuntime(cliArgs.appRoot, workspaceRoot);
-        if (cliArgs.taskId && !(await runtime.sessions.hasTask(cliArgs.taskId))) {
-            throw new Error(`Task session not found in workspace ${runtime.workspaceRoot}: ${cliArgs.taskId}`);
-        }
+        let current = await loadInteractiveWorkspace(cliArgs.appRoot, workspaceRoot, cliArgs.taskId);
         if (!canRenderInteractiveTui()) {
+            current.runtime.index.close();
             throw new Error("parallel-codex-tui requires an interactive terminal. Use --help, --version, --init, or --doctor for non-interactive command modes.");
         }
-        const latestTask = await runtime.sessions.latestTask();
-        const initialTaskId = cliArgs.taskId ?? latestTask?.id ?? null;
-        render(_jsx(App, { config: runtime.config, orchestrator: runtime.orchestrator, cwd: runtime.workspaceRoot, initialTaskId: initialTaskId }), { exitOnCtrlC: false });
+        let instance = null;
+        const shutdownController = new AbortController();
+        const deferredWorkspaceClosures = new Set();
+        const appElement = (state) => (_jsx(App, { config: withUiThemeOverride(state.runtime.config, cliArgs.theme), orchestrator: state.runtime.orchestrator, cwd: state.runtime.workspaceRoot, initialTaskId: state.initialTaskId, initialRoute: state.initialRoute, initialWorkers: state.initialWorkers, initialCanRetryTask: state.initialCanRetryTask, initialMessages: state.initialMessages, workspaceChoices: state.workspaceChoices, shutdownSignal: shutdownController.signal, loadRouterDiagnostics: async () => {
+                const [records, latestConfig] = await Promise.all([
+                    readRouterAudit(join(state.runtime.routerCwd, "routes.jsonl"), 100),
+                    loadConfig(cliArgs.appRoot)
+                ]);
+                return {
+                    records,
+                    policy: routerDiagnosticsPolicy(latestConfig.router)
+                };
+            }, loadTaskSessions: (options) => state.runtime.index.listTasks(100, options), loadTaskSessionDetails: (task) => loadPersistedTaskSessionDetails({
+                task,
+                taskDir: state.runtime.sessions.taskFromId(task.id).dir,
+                modelNames: Object.fromEntries(Object.entries(state.runtime.config.workers).map(([id, worker]) => [id, worker.model.name]))
+            }), renameTaskSession: async (taskId, title) => {
+                await state.runtime.sessions.renameTask(taskId, title);
+            }, setTaskSessionArchived: async (taskId, archived) => {
+                await state.runtime.sessions.setTaskArchived(taskId, archived);
+            }, deleteTaskSession: async (taskId) => {
+                await state.runtime.sessions.deleteTask(taskId);
+            }, exportTaskSession: async (taskId) => (await state.runtime.sessions.exportTask(taskId)).path, loadCollaborationTimeline: (taskId) => state.runtime.sessions.readCollaborationTimeline(taskId), activateTaskSession: async (taskId) => {
+                if (!taskId) {
+                    await state.runtime.index.setActiveTaskId(null);
+                    return null;
+                }
+                if (!(await state.runtime.sessions.hasTask(taskId))) {
+                    throw new Error(`Task session not found in workspace ${state.runtime.workspaceRoot}: ${taskId}`);
+                }
+                const task = state.runtime.sessions.taskFromId(taskId);
+                const meta = await state.runtime.sessions.readMeta(task);
+                if (meta.archived_at) {
+                    throw new Error(`Task session is archived: ${taskId}`);
+                }
+                const [route, workers, canRetry] = await Promise.all([
+                    state.runtime.sessions.readLatestRoute(task),
+                    state.runtime.orchestrator.listTaskWorkers(taskId),
+                    state.runtime.orchestrator.canRetryTask(taskId)
+                ]);
+                await state.runtime.index.setActiveTaskId(taskId);
+                return { taskId, route, workers, canRetry };
+            }, switchWorkspace: async (workspace) => {
+                if (workspace === current.runtime.workspaceRoot) {
+                    return;
+                }
+                retryDeferredWorkspaceClosures(deferredWorkspaceClosures);
+                const next = await loadInteractiveWorkspace(cliArgs.appRoot, workspace, null);
+                const previous = current;
+                current = commitWorkspaceTransition({
+                    previous,
+                    next,
+                    render: (state) => {
+                        if (!instance) {
+                            throw new Error("Interactive TUI is not ready to switch workspaces.");
+                        }
+                        instance.rerender(appElement(state));
+                    },
+                    close: closeInteractiveWorkspace,
+                    deferClose: (state) => deferredWorkspaceClosures.add(state)
+                });
+            }, persistChatMessage: (message, taskId) => state.runtime.sessions.appendChatMessage({
+                ...message,
+                taskId
+            }) }, state.runtime.workspaceRoot));
+        const removeSigintHandler = installInteractiveSigintExitHandler(() => shutdownController.abort());
+        try {
+            instance = render(appElement(current), { exitOnCtrlC: false });
+            await instance.waitUntilExit();
+        }
+        finally {
+            removeSigintHandler();
+            retryDeferredWorkspaceClosures(deferredWorkspaceClosures);
+        }
+    }
+}
+async function loadInteractiveWorkspace(appRoot, workspaceRoot, requestedTaskId) {
+    const runtime = await createRuntime(appRoot, workspaceRoot);
+    try {
+        const preflightPromise = runRuntimePreflight(runtime.config, runtime.workspaceRoot, process.env).catch((error) => ({
+            ok: false,
+            lines: [`preflight: failed (${error instanceof Error ? error.message : String(error)})`]
+        }));
+        if (requestedTaskId) {
+            if (!(await runtime.sessions.hasTask(requestedTaskId))) {
+                throw new Error(`Task session not found in workspace ${runtime.workspaceRoot}: ${requestedTaskId}`);
+            }
+            const requestedMeta = await runtime.sessions.readMeta(runtime.sessions.taskFromId(requestedTaskId));
+            if (requestedMeta.archived_at) {
+                throw new Error(`Task session is archived in workspace ${runtime.workspaceRoot}: ${requestedTaskId}`);
+            }
+        }
+        const [latestTask, rememberedTaskId] = await Promise.all([
+            runtime.sessions.latestTask(),
+            runtime.index.activeTaskId()
+        ]);
+        const rememberedTaskIsRestorable = typeof rememberedTaskId === "string"
+            && await runtime.sessions.hasTask(rememberedTaskId)
+            && !(await runtime.sessions.readMeta(runtime.sessions.taskFromId(rememberedTaskId))).archived_at;
+        let initialTaskId;
+        if (requestedTaskId) {
+            initialTaskId = requestedTaskId;
+        }
+        else if (rememberedTaskId === null) {
+            initialTaskId = null;
+        }
+        else if (rememberedTaskId && rememberedTaskIsRestorable) {
+            initialTaskId = rememberedTaskId;
+        }
+        else {
+            initialTaskId = latestTask?.id ?? null;
+        }
+        if (initialTaskId && initialTaskId !== rememberedTaskId) {
+            await runtime.index.setActiveTaskId(initialTaskId);
+        }
+        else if (!initialTaskId && typeof rememberedTaskId === "string") {
+            await runtime.index.setActiveTaskId(null);
+        }
+        const [initialRoute, initialWorkers, initialCanRetryTask, initialHistory, workspaceChoices, preflight] = await Promise.all([
+            initialTaskId
+                ? runtime.sessions.readLatestRoute(runtime.sessions.taskFromId(initialTaskId))
+                : null,
+            initialTaskId ? runtime.orchestrator.listTaskWorkers(initialTaskId) : [],
+            initialTaskId ? runtime.orchestrator.canRetryTask(initialTaskId) : false,
+            runtime.sessions.readChatHistory(),
+            listWorkspaceChoices(appRoot),
+            preflightPromise
+        ]);
+        const recoveryMessages = startupRecoveryMessages(runtime.recoveredTasks, initialTaskId, runtime.pendingTaskCreations, runtime.index.recovery);
+        return {
+            runtime,
+            initialTaskId,
+            initialRoute,
+            initialWorkers,
+            initialCanRetryTask,
+            initialMessages: [
+                ...initialHistory.map(({ from, text, task_id }) => ({
+                    from,
+                    text,
+                    ...(task_id ? { taskId: task_id } : {})
+                })),
+                ...recoveryMessages,
+                ...startupPreflightMessages(preflight)
+            ],
+            workspaceChoices
+        };
+    }
+    catch (error) {
+        runtime.index.close();
+        throw error;
+    }
+}
+function closeInteractiveWorkspace(state) {
+    state.runtime.index.close();
+}
+function retryDeferredWorkspaceClosures(states) {
+    for (const state of states) {
+        try {
+            closeInteractiveWorkspace(state);
+            states.delete(state);
+        }
+        catch {
+            // Process exit remains the final cleanup boundary if an index cannot be closed yet.
+        }
     }
 }
 function canRenderInteractiveTui() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
+function installInteractiveSigintExitHandler(requestGracefulExit) {
+    let interrupted = false;
+    const onSigint = () => {
+        if (!interrupted) {
+            interrupted = true;
+            try {
+                requestGracefulExit();
+                return;
+            }
+            catch {
+                // Fall through to the force-exit path when graceful shutdown cannot start.
+            }
+        }
+        restoreInteractiveTerminal();
+        process.exit(0);
+    };
+    process.on("SIGINT", onSigint);
+    return () => process.off("SIGINT", onSigint);
+}
+function restoreInteractiveTerminal() {
+    if (process.stdin.isTTY && process.stdin.isRaw && typeof process.stdin.setRawMode === "function") {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch {
+            // The active view may already be releasing raw mode.
+        }
+    }
+    process.stdin.pause();
+    if (process.stdout.isTTY) {
+        process.stdout.write("\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h");
+    }
+}
 function formatStartupError(error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = isConfigStartupError(error)
+        ? formatConfigErrorMessage(error)
+        : error instanceof Error ? error.message : String(error);
     if (isConfigStartupError(error)) {
         return `Config error: ${message}\nRun parallel-codex-tui --doctor for details.`;
     }