parallel-codex-tui 0.1.3 → 0.1.5

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 });
 }
@@ -38,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))) {
@@ -65,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");
 }
@@ -16,5 +17,11 @@ 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;
+}

package/dist/core/process-mutation-turn.js

@@ -0,0 +1,128 @@
+import { randomUUID } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { ensureDir, readJson, removeIfExists, writeJson } from "./file-store.js";
+import { processIsAlive, readProcessStartToken } from "./process-identity.js";
+const ProcessMutationIntentSchema = z.object({
+    version: z.literal(1),
+    intent_id: z.string().min(1),
+    pid: z.number().int().positive(),
+    created_at: z.string().datetime(),
+    choosing: z.boolean(),
+    ticket: z.number().int().nonnegative(),
+    process_start_token: z.string().min(1).optional()
+});
+let currentProcessStartToken = null;
+export async function acquireProcessMutationTurn(directory, options) {
+    validateIntentPrefix(options.intentPrefix);
+    await ensureDir(directory);
+    const identity = await currentMutationIdentity();
+    const intentId = randomUUID();
+    const path = join(directory, `${options.intentPrefix}${intentId}.json`);
+    let intent = ProcessMutationIntentSchema.parse({
+        version: 1,
+        intent_id: intentId,
+        pid: identity.pid,
+        created_at: new Date().toISOString(),
+        choosing: true,
+        ticket: 0,
+        ...(identity.process_start_token ? { process_start_token: identity.process_start_token } : {})
+    });
+    await writeJson(path, intent);
+    try {
+        const existing = await readActiveIntents(directory, options.intentPrefix);
+        intent = {
+            ...intent,
+            choosing: false,
+            ticket: Math.max(0, ...existing.map((candidate) => candidate.ticket)) + 1
+        };
+        await writeJson(path, intent);
+        const deadline = Date.now() + (options.timeoutMs ?? 5000);
+        while (true) {
+            const candidates = await readActiveIntents(directory, options.intentPrefix);
+            const blocked = candidates.some((candidate) => (candidate.intent_id !== intent.intent_id
+                && (candidate.choosing || intentPrecedes(candidate, intent))));
+            if (!blocked) {
+                let released = false;
+                return {
+                    release: async () => {
+                        if (released) {
+                            return;
+                        }
+                        released = true;
+                        await removeIfExists(path);
+                    }
+                };
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(options.timeoutMessage);
+            }
+            await delay(options.pollMs ?? 5);
+        }
+    }
+    catch (error) {
+        await removeIfExists(path);
+        throw error;
+    }
+}
+async function currentMutationIdentity() {
+    currentProcessStartToken ??= readProcessStartToken(process.pid);
+    const processStartToken = await currentProcessStartToken;
+    return {
+        pid: process.pid,
+        ...(processStartToken ? { process_start_token: processStartToken } : {})
+    };
+}
+async function readActiveIntents(directory, prefix) {
+    const names = await readdir(directory);
+    const tokenReads = new Map();
+    const active = [];
+    for (const name of names) {
+        if (!name.startsWith(prefix) || !name.endsWith(".json")) {
+            continue;
+        }
+        const path = join(directory, name);
+        const intent = await readValidIntent(path);
+        if (!intent || !processIsAlive(intent.pid)) {
+            await removeIfExists(path);
+            continue;
+        }
+        if (intent.process_start_token) {
+            let tokenRead = tokenReads.get(intent.pid);
+            if (!tokenRead) {
+                tokenRead = readProcessStartToken(intent.pid);
+                tokenReads.set(intent.pid, tokenRead);
+            }
+            const currentToken = await tokenRead;
+            if (!currentToken || currentToken !== intent.process_start_token) {
+                await removeIfExists(path);
+                continue;
+            }
+        }
+        active.push(intent);
+    }
+    return active;
+}
+async function readValidIntent(path) {
+    try {
+        return await readJson(path, ProcessMutationIntentSchema);
+    }
+    catch {
+        return null;
+    }
+}
+function intentPrecedes(candidate, current) {
+    if (candidate.ticket !== current.ticket) {
+        return candidate.ticket < current.ticket;
+    }
+    return candidate.intent_id < current.intent_id;
+}
+function validateIntentPrefix(prefix) {
+    if (!prefix.startsWith(".") || prefix.includes("/") || prefix.includes("\\")) {
+        throw new Error(`Invalid process mutation intent prefix: ${prefix}`);
+    }
+}
+async function delay(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/core/process-ownership.js

@@ -0,0 +1,276 @@
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { ensureDir, pathExists, readJson, removeIfExists, writeJson } from "./file-store.js";
+import { processIsAlive, readProcessStartToken } from "./process-identity.js";
+import { acquireProcessMutationTurn } from "./process-mutation-turn.js";
+export { processIsAlive, readProcessStartToken } from "./process-identity.js";
+const TaskRunOwnerSchema = z.object({
+    version: z.literal(1),
+    owner_id: z.string().min(1),
+    pid: z.number().int().positive(),
+    acquired_at: z.string().datetime(),
+    process_start_token: z.string().min(1).optional()
+});
+const CLAIM_INTENT_PREFIX = ".run-owner-claim-";
+const CLAIM_INTENT_TIMEOUT_MS = 5000;
+const CLAIM_INTENT_POLL_MS = 5;
+const WorkerProcessRecordSchema = z.object({
+    version: z.literal(1),
+    worker_id: z.string().min(1),
+    pid: z.number().int().positive(),
+    process_group_id: z.number().int().positive().optional(),
+    process_start_token: z.string().min(1).optional(),
+    owner_pid: z.number().int().positive(),
+    command: z.string().min(1),
+    started_at: z.string().datetime()
+});
+export class TaskRunLeaseConflictError extends Error {
+    owner;
+    constructor(owner) {
+        super(`Task is already running in another parallel-codex-tui process (pid ${owner?.pid ?? "unknown"}).`);
+        this.owner = owner;
+        this.name = "TaskRunLeaseConflictError";
+    }
+}
+export function taskRunOwnerPath(taskDir) {
+    return join(taskDir, "run-owner.json");
+}
+export function workerProcessRecordPath(workerDir) {
+    return join(workerDir, "process.json");
+}
+export async function claimTaskRunLease(taskDir, options = {}) {
+    const pid = options.pid ?? process.pid;
+    const owner = TaskRunOwnerSchema.parse({
+        version: 1,
+        owner_id: options.ownerId ?? randomUUID(),
+        pid,
+        acquired_at: (options.now ?? (() => new Date()))().toISOString(),
+        ...await optionalProcessStartToken(pid)
+    });
+    const path = taskRunOwnerPath(taskDir);
+    await ensureDir(taskDir);
+    const mutationTurn = await acquireTaskRunMutationTurn(taskDir);
+    try {
+        if (await writeJsonExclusive(path, owner)) {
+            return {
+                owner,
+                release: () => releaseTaskRunLease(taskDir, path, owner.owner_id)
+            };
+        }
+        const inspection = await inspectTaskRunLease(taskDir);
+        if (inspection.state === "active") {
+            throw new TaskRunLeaseConflictError(inspection.owner);
+        }
+        await removeOwnedLease(path, inspection.owner?.owner_id);
+        if (await writeJsonExclusive(path, owner)) {
+            return {
+                owner,
+                release: () => releaseTaskRunLease(taskDir, path, owner.owner_id)
+            };
+        }
+        const current = await inspectTaskRunLease(taskDir);
+        throw new TaskRunLeaseConflictError(current.owner);
+    }
+    finally {
+        await mutationTurn.release();
+    }
+}
+export async function inspectTaskRunLease(taskDir) {
+    const path = taskRunOwnerPath(taskDir);
+    if (!(await pathExists(path))) {
+        return { state: "missing", owner: null };
+    }
+    const owner = await readValidJson(path, TaskRunOwnerSchema);
+    if (!owner) {
+        return { state: "stale", owner: null };
+    }
+    if (!processIsAlive(owner.pid)) {
+        return { state: "stale", owner };
+    }
+    if (owner.process_start_token) {
+        const currentToken = await readProcessStartToken(owner.pid);
+        if (!currentToken || currentToken !== owner.process_start_token) {
+            return { state: "stale", owner };
+        }
+    }
+    return { state: "active", owner };
+}
+export async function clearStaleTaskRunLease(taskDir, owner) {
+    const mutationTurn = await acquireTaskRunMutationTurn(taskDir);
+    try {
+        const inspection = await inspectTaskRunLease(taskDir);
+        if (inspection.state !== "stale") {
+            return;
+        }
+        await removeOwnedLease(taskRunOwnerPath(taskDir), owner?.owner_id ?? inspection.owner?.owner_id);
+    }
+    finally {
+        await mutationTurn.release();
+    }
+}
+export async function writeWorkerProcessRecord(workerDir, input) {
+    const record = WorkerProcessRecordSchema.parse({
+        version: 1,
+        worker_id: input.workerId,
+        pid: input.pid,
+        ...(input.processGroupId ? { process_group_id: input.processGroupId } : {}),
+        owner_pid: process.pid,
+        command: input.command,
+        started_at: (input.now ?? (() => new Date()))().toISOString(),
+        ...await optionalProcessStartToken(input.pid)
+    });
+    await writeJson(workerProcessRecordPath(workerDir), record);
+    return record;
+}
+export async function clearWorkerProcessRecord(workerDir) {
+    await removeIfExists(workerProcessRecordPath(workerDir));
+}
+export async function terminateOwnedWorkerProcess(workerDir) {
+    const path = workerProcessRecordPath(workerDir);
+    if (!(await pathExists(path))) {
+        return "missing";
+    }
+    const record = await readValidJson(path, WorkerProcessRecordSchema);
+    if (!record) {
+        return "unverifiable";
+    }
+    const leaderIsAlive = processIsAlive(record.pid);
+    if (!ownedProcessIsAlive(record)) {
+        await removeIfExists(path);
+        return "not-running";
+    }
+    if (!record.process_start_token) {
+        return "unverifiable";
+    }
+    if (leaderIsAlive) {
+        const currentToken = await readProcessStartToken(record.pid);
+        if (!currentToken) {
+            return "unverifiable";
+        }
+        if (currentToken !== record.process_start_token) {
+            return "identity-mismatch";
+        }
+    }
+    signalOwnedProcess(record, "SIGTERM");
+    if (!(await waitForOwnedProcessExit(record, 1500))) {
+        if (!targetsProcessGroup(record)) {
+            const tokenBeforeKill = await readProcessStartToken(record.pid);
+            if (tokenBeforeKill !== record.process_start_token) {
+                return "identity-mismatch";
+            }
+        }
+        signalOwnedProcess(record, "SIGKILL");
+        await waitForOwnedProcessExit(record, 500);
+    }
+    if (!ownedProcessIsAlive(record)) {
+        await removeIfExists(path);
+        return "terminated";
+    }
+    return "still-running";
+}
+async function optionalProcessStartToken(pid) {
+    const processStartToken = await readProcessStartToken(pid);
+    return processStartToken ? { process_start_token: processStartToken } : {};
+}
+async function writeJsonExclusive(path, value) {
+    try {
+        await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function acquireTaskRunMutationTurn(taskDir) {
+    return acquireProcessMutationTurn(taskDir, {
+        intentPrefix: CLAIM_INTENT_PREFIX,
+        timeoutMs: CLAIM_INTENT_TIMEOUT_MS,
+        pollMs: CLAIM_INTENT_POLL_MS,
+        timeoutMessage: "Timed out waiting to update task run ownership."
+    });
+}
+async function releaseTaskRunLease(taskDir, path, ownerId) {
+    if (!(await pathExists(taskDir))) {
+        return;
+    }
+    const mutationTurn = await acquireTaskRunMutationTurn(taskDir);
+    try {
+        await removeOwnedLease(path, ownerId);
+    }
+    finally {
+        await mutationTurn.release();
+    }
+}
+async function removeOwnedLease(path, ownerId) {
+    if (ownerId) {
+        const current = await readValidJson(path, TaskRunOwnerSchema);
+        if (!current || current.owner_id !== ownerId) {
+            return;
+        }
+    }
+    await removeIfExists(path);
+}
+async function readValidJson(path, schema) {
+    try {
+        return await readJson(path, schema);
+    }
+    catch {
+        return null;
+    }
+}
+function signalProcess(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH") {
+            throw error;
+        }
+    }
+}
+function signalOwnedProcess(record, signal) {
+    if (targetsProcessGroup(record)) {
+        try {
+            process.kill(-record.process_group_id, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code !== "ESRCH") {
+                throw error;
+            }
+        }
+    }
+    signalProcess(record.pid, signal);
+}
+function targetsProcessGroup(record) {
+    return Boolean(record.process_group_id && process.platform !== "win32");
+}
+function ownedProcessIsAlive(record) {
+    return targetsProcessGroup(record)
+        ? processGroupIsAlive(record.process_group_id)
+        : processIsAlive(record.pid);
+}
+function processGroupIsAlive(processGroupId) {
+    try {
+        process.kill(-processGroupId, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function waitForOwnedProcessExit(record, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!ownedProcessIsAlive(record)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 40));
+    }
+    return !ownedProcessIsAlive(record);
+}