parallel-codex-tui 0.1.0 → 0.1.4

package/dist/core/config.js

@@ -1,7 +1,9 @@
-import { parse, stringify } from "@iarna/toml";
+import { parse } from "@iarna/toml";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { pathExists, readTextIfExists, writeText } from "./file-store.js";
+import { normalizeTuiThemeColorValue, normalizeTuiThemeName, TUI_THEME_FIELDS, TUI_THEME_NAMES } from "../tui/theme.js";
 const NativeSessionConfigSchema = z.object({
     enabled: z.boolean().default(true),
     resumeArgs: z.array(z.string()).default([]),
@@ -14,6 +16,26 @@ const WorkerModelConfigSchema = z.object({
     args: z.array(z.string()).default([]),
     env: z.record(z.string()).default({})
 });
+const WorkerCapabilitiesConfigSchema = z.object({
+    profile: z.enum(["codex", "claude", "generic"]),
+    writableDirArgs: z.array(z.string()).default([]),
+    freshSessionArgs: z.array(z.string()).default([])
+}).strict().superRefine((value, context) => {
+    if (value.writableDirArgs.length > 0 && !value.writableDirArgs.some((arg) => arg.includes("{dir}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["writableDirArgs"],
+            message: "writableDirArgs must include a {dir} template"
+        });
+    }
+    if (value.freshSessionArgs.length > 0 && !value.freshSessionArgs.some((arg) => arg.includes("{sessionId}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["freshSessionArgs"],
+            message: "freshSessionArgs must include a {sessionId} template"
+        });
+    }
+});
 const InteractiveCommandSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()).default([])
@@ -22,12 +44,45 @@ const RolePromptConfigSchema = z.object({
     title: z.string().min(1),
     instructions: z.array(z.string()).default([])
 });
+const TuiColorValueSchema = z.string().min(1).refine((value) => normalizeTuiThemeColorValue(value) !== null, {
+    message: "Invalid TUI color value. Use a Chalk color name, #rgb/#rrggbb, rgb(r,g,b), or ansi256(0..255)."
+}).transform((value) => normalizeTuiThemeColorValue(value) ?? value.trim());
+const TuiThemeNameSchema = z.preprocess((value) => typeof value === "string" ? normalizeTuiThemeName(value) ?? value.trim() : value, z.enum(TUI_THEME_NAMES)).default("codex");
+const UiColorOverridesSchema = z.object(Object.fromEntries(TUI_THEME_FIELDS.map((field) => [field, TuiColorValueSchema.optional()]))).strict().default({});
 const CodexRouterConfigSchema = z.object({
     command: z.string().min(1).default("codex"),
-    args: z.array(z.string()).default(["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"]),
-    timeoutMs: z.number().int().positive().default(120000),
-    fallback: z.enum(["simple", "complex"]).default("complex")
+    args: z.array(z.string()).default([
+        "exec",
+        "--ephemeral",
+        "--ignore-rules",
+        "-c",
+        "model_reasoning_effort=low",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "read-only",
+        "--color",
+        "never",
+        "-"
+    ]),
+    timeoutMs: z.number().int().positive().default(30000),
+    firstOutputTimeoutMs: z.number().int().positive().default(15000),
+    idleTimeoutMs: z.number().int().positive().default(15000),
+    maxOutputBytes: z.number().int().min(1024).max(16 * 1024 * 1024).default(1024 * 1024),
+    maxAttempts: z.number().int().min(1).max(3).default(2),
+    retryDelayMs: z.number().int().min(0).max(10000).default(500),
+    followUpTimeoutMs: z.number().int().positive().max(120000).default(20000),
+    fallback: z.enum(["simple", "complex"]).default("simple"),
+    env: z.record(z.string()).default({})
 });
+const OrchestrationConfigSchema = z.object({
+    maxParallelFeatures: z.number().int().min(1).max(8)
+}).strict();
+const UiConfigSchema = z.object({
+    showStatusBar: z.boolean(),
+    autoOpenFailedWorker: z.boolean(),
+    theme: TuiThemeNameSchema,
+    colors: UiColorOverridesSchema
+}).strict();
 const WorkerCommandSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()).default([]),
@@ -35,6 +90,7 @@ const WorkerCommandSchema = z.object({
     idleTimeoutMs: z.number().int().positive().optional(),
     firstOutputTimeoutMs: z.number().int().positive().optional(),
     model: WorkerModelConfigSchema.default({}),
+    capabilities: WorkerCapabilitiesConfigSchema,
     nativeSession: NativeSessionConfigSchema,
     interactive: InteractiveCommandSchema
 });
@@ -45,6 +101,7 @@ const AppConfigSchema = z.object({
         defaultMode: z.enum(["auto", "simple", "complex"]),
         codex: CodexRouterConfigSchema.default({})
     }),
+    orchestration: OrchestrationConfigSchema,
     workers: z.object({
         codex: WorkerCommandSchema,
         claude: WorkerCommandSchema,
@@ -62,10 +119,7 @@ const AppConfigSchema = z.object({
         actor: RolePromptConfigSchema,
         critic: RolePromptConfigSchema
     }),
-    ui: z.object({
-        showStatusBar: z.boolean(),
-        autoOpenFailedWorker: z.boolean()
-    })
+    ui: UiConfigSchema
 });
 export function defaultConfig(projectRoot) {
     return {
@@ -75,11 +129,33 @@ export function defaultConfig(projectRoot) {
             defaultMode: "auto",
             codex: {
                 command: "codex",
-                args: ["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"],
-                timeoutMs: 120000,
-                fallback: "complex"
+                args: [
+                    "exec",
+                    "--ephemeral",
+                    "--ignore-rules",
+                    "-c",
+                    "model_reasoning_effort=low",
+                    "--skip-git-repo-check",
+                    "--sandbox",
+                    "read-only",
+                    "--color",
+                    "never",
+                    "-"
+                ],
+                timeoutMs: 30000,
+                firstOutputTimeoutMs: 15000,
+                idleTimeoutMs: 15000,
+                maxOutputBytes: 1024 * 1024,
+                maxAttempts: 2,
+                retryDelayMs: 500,
+                followUpTimeoutMs: 20000,
+                fallback: "simple",
+                env: {}
             }
         },
+        orchestration: {
+            maxParallelFeatures: 3
+        },
         workers: {
             codex: {
                 command: "codex",
@@ -93,6 +169,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "codex",
+                    writableDirArgs: ["--add-dir", "{dir}"],
+                    freshSessionArgs: []
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["exec", "resume", "{sessionId}", "--skip-git-repo-check", "-"],
@@ -116,6 +197,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "claude",
+                    writableDirArgs: ["--add-dir", "{dir}"],
+                    freshSessionArgs: ["--session-id", "{sessionId}"]
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["--print", "--resume", "{sessionId}", "--permission-mode", "acceptEdits", "--output-format", "text"],
@@ -136,6 +222,11 @@ export function defaultConfig(projectRoot) {
                     args: [],
                     env: {}
                 },
+                capabilities: {
+                    profile: "generic",
+                    writableDirArgs: [],
+                    freshSessionArgs: []
+                },
                 nativeSession: {
                     enabled: true,
                     resumeArgs: ["resume", "{sessionId}", "-"],
@@ -174,7 +265,9 @@ export function defaultConfig(projectRoot) {
         },
         ui: {
             showStatusBar: true,
-            autoOpenFailedWorker: true
+            autoOpenFailedWorker: true,
+            theme: "codex",
+            colors: {}
         }
     };
 }
@@ -188,6 +281,7 @@ export async function loadConfig(projectRoot) {
         return base;
     }
     const parsed = parse(await readTextIfExists(file));
+    assertObjectSections(parsed);
     const merged = {
         ...base,
         ...parsed,
@@ -197,9 +291,17 @@ export async function loadConfig(projectRoot) {
             ...(parsed.router ?? {}),
             codex: {
                 ...base.router.codex,
-                ...(parsed.router?.codex ?? {})
+                ...(parsed.router?.codex ?? {}),
+                env: {
+                    ...base.router.codex.env,
+                    ...(parsed.router?.codex?.env ?? {})
+                }
             }
         },
+        orchestration: {
+            ...base.orchestration,
+            ...(parsed.orchestration ?? {})
+        },
         workers: {
             codex: {
                 ...base.workers.codex,
@@ -212,6 +314,10 @@ export async function loadConfig(projectRoot) {
                         ...(parsed.workers?.codex?.model?.env ?? {})
                     }
                 },
+                capabilities: {
+                    ...base.workers.codex.capabilities,
+                    ...(parsed.workers?.codex?.capabilities ?? {})
+                },
                 nativeSession: {
                     ...base.workers.codex.nativeSession,
                     ...(parsed.workers?.codex?.nativeSession ?? {})
@@ -232,6 +338,10 @@ export async function loadConfig(projectRoot) {
                         ...(parsed.workers?.claude?.model?.env ?? {})
                     }
                 },
+                capabilities: {
+                    ...base.workers.claude.capabilities,
+                    ...(parsed.workers?.claude?.capabilities ?? {})
+                },
                 nativeSession: {
                     ...base.workers.claude.nativeSession,
                     ...(parsed.workers?.claude?.nativeSession ?? {})
@@ -252,6 +362,10 @@ export async function loadConfig(projectRoot) {
                         ...(parsed.workers?.mock?.model?.env ?? {})
                     }
                 },
+                capabilities: {
+                    ...base.workers.mock.capabilities,
+                    ...(parsed.workers?.mock?.capabilities ?? {})
+                },
                 nativeSession: {
                     ...base.workers.mock.nativeSession,
                     ...(parsed.workers?.mock?.nativeSession ?? {})
@@ -286,19 +400,73 @@ export async function loadConfig(projectRoot) {
         },
         ui: {
             ...base.ui,
-            ...(parsed.ui ?? {})
+            ...(parsed.ui ?? {}),
+            colors: {
+                ...base.ui.colors,
+                ...(parsed.ui?.colors ?? {})
+            }
         }
     };
     return AppConfigSchema.parse(merged);
 }
+export function withUiThemeOverride(config, theme) {
+    if (!theme) {
+        return config;
+    }
+    return {
+        ...config,
+        ui: {
+            ...config.ui,
+            theme
+        }
+    };
+}
+function assertObjectSections(parsed) {
+    const sections = [
+        ["router", parsed.router],
+        ["router.codex", parsed.router?.codex],
+        ["router.codex.env", parsed.router?.codex?.env],
+        ["orchestration", parsed.orchestration],
+        ["workers", parsed.workers],
+        ["workers.codex", parsed.workers?.codex],
+        ["workers.codex.model", parsed.workers?.codex?.model],
+        ["workers.codex.model.env", parsed.workers?.codex?.model?.env],
+        ["workers.codex.capabilities", parsed.workers?.codex?.capabilities],
+        ["workers.codex.nativeSession", parsed.workers?.codex?.nativeSession],
+        ["workers.codex.interactive", parsed.workers?.codex?.interactive],
+        ["workers.claude", parsed.workers?.claude],
+        ["workers.claude.model", parsed.workers?.claude?.model],
+        ["workers.claude.model.env", parsed.workers?.claude?.model?.env],
+        ["workers.claude.capabilities", parsed.workers?.claude?.capabilities],
+        ["workers.claude.nativeSession", parsed.workers?.claude?.nativeSession],
+        ["workers.claude.interactive", parsed.workers?.claude?.interactive],
+        ["workers.mock", parsed.workers?.mock],
+        ["workers.mock.model", parsed.workers?.mock?.model],
+        ["workers.mock.model.env", parsed.workers?.mock?.model?.env],
+        ["workers.mock.capabilities", parsed.workers?.mock?.capabilities],
+        ["workers.mock.nativeSession", parsed.workers?.mock?.nativeSession],
+        ["workers.mock.interactive", parsed.workers?.mock?.interactive],
+        ["pairing", parsed.pairing],
+        ["roles", parsed.roles],
+        ["roles.main", parsed.roles?.main],
+        ["roles.judge", parsed.roles?.judge],
+        ["roles.actor", parsed.roles?.actor],
+        ["roles.critic", parsed.roles?.critic],
+        ["ui", parsed.ui],
+        ["ui.colors", parsed.ui?.colors]
+    ];
+    for (const [path, value] of sections) {
+        if (value !== undefined && !isPlainObject(value)) {
+            throw new Error(`Invalid config section [${path}]: expected a table`);
+        }
+    }
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 export async function writeDefaultConfig(projectRoot) {
-    const config = defaultConfig(projectRoot);
-    const tomlText = stringify({
-        router: config.router,
-        workers: config.workers,
-        pairing: config.pairing,
-        roles: config.roles,
-        ui: config.ui
-    });
-    await writeText(configPath(projectRoot), tomlText);
+    await writeText(configPath(projectRoot), await readExampleConfig());
+}
+async function readExampleConfig() {
+    return readFile(new URL("../../.parallel-codex/config.example.toml", import.meta.url), "utf8");
 }

package/dist/core/file-store.js

@@ -1,5 +1,8 @@
-import { mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+const appendQueues = new Map();
+const defaultRecentJsonLineChunkBytes = 64 * 1024;
+const defaultRecentJsonLineMaxBytes = 2 * 1024 * 1024;
 export async function ensureDir(path) {
     await mkdir(path, { recursive: true });
 }
@@ -15,6 +18,17 @@ export async function pathExists(path) {
         throw error;
     }
 }
+export async function pathIsDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
 export async function writeJson(path, value) {
     const dir = dirname(path);
     const tempPath = join(dir, `.${basename(path)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
@@ -27,16 +41,120 @@ export async function readJson(path, schema) {
     return schema.parse(JSON.parse(text));
 }
 export async function appendJsonLine(path, value) {
-    await ensureDir(dirname(path));
-    await writeFile(path, `${JSON.stringify(value)}\n`, { encoding: "utf8", flag: "a" });
+    await appendFile(path, `${JSON.stringify(value)}\n`);
 }
 export async function writeText(path, value) {
     await ensureDir(dirname(path));
     await writeFile(path, value, "utf8");
 }
 export async function appendText(path, value) {
-    await ensureDir(dirname(path));
-    await writeFile(path, value, { encoding: "utf8", flag: "a" });
+    await appendFile(path, value);
+}
+export async function readRecentJsonLines(path, schema, limit, options = {}) {
+    const targetLimit = Number.isFinite(limit)
+        ? Math.min(10000, Math.max(0, Math.trunc(limit)))
+        : 10000;
+    if (targetLimit === 0) {
+        return [];
+    }
+    const chunkBytes = boundedPositiveInteger(options.chunkBytes, defaultRecentJsonLineChunkBytes, 4 * 1024 * 1024);
+    const maxLineBytes = boundedPositiveInteger(options.maxLineBytes, defaultRecentJsonLineMaxBytes, 16 * 1024 * 1024);
+    let handle;
+    try {
+        handle = await open(path, "r");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    try {
+        let position = (await handle.stat()).size;
+        let lineSegments = [];
+        let lineBytes = 0;
+        let lineTooLong = false;
+        const newestFirst = [];
+        const addLineSegment = (segment) => {
+            if (segment.length === 0 || lineTooLong) {
+                return;
+            }
+            lineBytes += segment.length;
+            if (lineBytes > maxLineBytes) {
+                lineSegments = [];
+                lineTooLong = true;
+                return;
+            }
+            lineSegments.push(Buffer.from(segment));
+        };
+        const finishLine = () => {
+            if (!lineTooLong && lineBytes > 0) {
+                const line = Buffer.concat([...lineSegments].reverse(), lineBytes).toString("utf8").trim();
+                if (line) {
+                    try {
+                        const parsed = schema.safeParse(JSON.parse(line));
+                        if (parsed.success) {
+                            newestFirst.push(parsed.data);
+                        }
+                    }
+                    catch {
+                        // Invalid or partial rows do not hide earlier valid records.
+                    }
+                }
+            }
+            lineSegments = [];
+            lineBytes = 0;
+            lineTooLong = false;
+        };
+        while (position > 0 && newestFirst.length < targetLimit) {
+            const requested = Math.min(chunkBytes, position);
+            position -= requested;
+            const buffer = Buffer.allocUnsafe(requested);
+            const { bytesRead } = await handle.read(buffer, 0, requested, position);
+            if (bytesRead === 0) {
+                continue;
+            }
+            let segmentEnd = bytesRead;
+            for (let index = bytesRead - 1; index >= 0; index -= 1) {
+                if (buffer[index] !== 0x0a) {
+                    continue;
+                }
+                addLineSegment(buffer.subarray(index + 1, segmentEnd));
+                finishLine();
+                segmentEnd = index;
+                if (newestFirst.length >= targetLimit) {
+                    break;
+                }
+            }
+            if (newestFirst.length < targetLimit) {
+                addLineSegment(buffer.subarray(0, segmentEnd));
+            }
+        }
+        if (position === 0 && newestFirst.length < targetLimit && (lineBytes > 0 || lineTooLong)) {
+            finishLine();
+        }
+        return newestFirst.reverse();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function appendFile(path, value) {
+    const key = resolve(path);
+    const previous = appendQueues.get(key) ?? Promise.resolve();
+    const operation = previous.catch(() => undefined).then(async () => {
+        await ensureDir(dirname(path));
+        await writeFile(path, value, { encoding: "utf8", flag: "a" });
+    });
+    appendQueues.set(key, operation);
+    try {
+        await operation;
+    }
+    finally {
+        if (appendQueues.get(key) === operation) {
+            appendQueues.delete(key);
+        }
+    }
 }
 export async function readTextIfExists(path) {
     if (!(await pathExists(path))) {
@@ -54,3 +172,9 @@ export async function removeIfExists(path) {
         }
     }
 }
+function boundedPositiveInteger(value, fallback, maximum) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(maximum, Math.max(1, Math.trunc(value)));
+}

package/dist/core/lease-finalization.js

@@ -0,0 +1,22 @@
+export async function runWithLeaseFinalization(subject, lease, run) {
+    const outcome = await run().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+    try {
+        await lease.release();
+    }
+    catch (releaseError) {
+        const releaseSummary = `${subject} lease release failed: ${errorMessage(releaseError)}`;
+        if (!outcome.ok) {
+            throw new Error(`${errorMessage(outcome.error)}; ${releaseSummary}`, {
+                cause: new AggregateError([outcome.error, releaseError])
+            });
+        }
+        throw new Error(releaseSummary, { cause: releaseError });
+    }
+    if (!outcome.ok) {
+        throw outcome.error;
+    }
+    return outcome.value;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/paths.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { TaskSessionIdSchema } from "../domain/schemas.js";
 function pad(value) {
     return String(value).padStart(2, "0");
 }
@@ -12,6 +13,15 @@ export function formatTaskTimestamp(date) {
 export function sessionsRoot(projectRoot, dataDir) {
     return join(projectRoot, dataDir, "sessions");
 }
+export function routerRuntimeDir(appRoot, dataDir) {
+    return join(appRoot, dataDir, "router");
+}
 export function taskDir(projectRoot, dataDir, taskId) {
+    if (!taskSessionIdIsValid(taskId)) {
+        throw new Error(`Invalid task session id: ${JSON.stringify(taskId)}`);
+    }
     return join(sessionsRoot(projectRoot, dataDir), taskId);
 }
+export function taskSessionIdIsValid(taskId) {
+    return TaskSessionIdSchema.safeParse(taskId).success;
+}

package/dist/core/process-identity.js

@@ -0,0 +1,48 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export function processIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export async function readProcessStartToken(pid) {
+    if (!processIsAlive(pid)) {
+        return null;
+    }
+    if (process.platform === "linux") {
+        try {
+            const stat = await readFile(`/proc/${pid}/stat`, "utf8");
+            const fields = stat.slice(stat.lastIndexOf(") ") + 2).trim().split(/\s+/);
+            const startTick = fields[19];
+            if (startTick) {
+                return `linux:${startTick}`;
+            }
+        }
+        catch {
+            // Fall through to ps when procfs is unavailable.
+        }
+    }
+    if (process.platform !== "win32") {
+        try {
+            const result = await execFileAsync("ps", ["-o", "lstart=", "-p", String(pid)], {
+                encoding: "utf8",
+                timeout: 1000
+            });
+            const value = String(result.stdout).trim().replace(/\s+/g, " ");
+            return value ? `ps:${value}` : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}