@webpresso/agent-kit 3.1.28 → 3.1.30

package/dist/esm/cli/commands/init/scaffolders/codex-mcp/index.js

@@ -23,6 +23,7 @@ import { accessSync, constants, existsSync, mkdirSync, readFileSync, statSync }
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import lockfile from "proper-lockfile";
 import { isJsonRecord, isUnsafeRuntimeLauncher, parseJson, parseProjectMcpServers, parseTomlString, } from "#hooks/host-config-contract.js";
 import { appendGlobalCapableVpArgs, resolveGlobalCapableVpCommand, } from "#cli/global-vp.js";
 import { pathCandidates } from "#runtime/command-exists.js";
@@ -41,6 +42,57 @@ const PLAYWRIGHT_STDIO_MCP_DEFINITION = {
     command: "vp",
     args: ["dlx", PLAYWRIGHT_MCP_PACKAGE, ...PLAYWRIGHT_MCP_ARGS],
 };
+const CODEX_CONFIG_LOCK_TIMEOUT_MS = 5_000;
+const CODEX_CONFIG_LOCK_POLL_MS = 25;
+const CODEX_CONFIG_LOCK_STALE_MS = 30_000;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireCodexConfigLock(configPath) {
+    mkdirSync(dirname(configPath), { recursive: true });
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            return lockfile.lockSync(configPath, {
+                realpath: false,
+                stale: CODEX_CONFIG_LOCK_STALE_MS,
+                update: CODEX_CONFIG_LOCK_STALE_MS / 2,
+            });
+        }
+        catch (error) {
+            if (error.code !== "ELOCKED")
+                throw error;
+            if (Date.now() - startedAt >= CODEX_CONFIG_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out waiting for Codex config lock: ${configPath}`, {
+                    cause: error,
+                });
+            }
+            sleepSync(CODEX_CONFIG_LOCK_POLL_MS);
+        }
+    }
+}
+function withCodexConfigLock(configPath, action) {
+    const release = acquireCodexConfigLock(configPath);
+    try {
+        return action();
+    }
+    finally {
+        release();
+    }
+}
+function readCodexConfig(configPath) {
+    return existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+}
+function updateCodexConfig(configPath, transform) {
+    return withCodexConfigLock(configPath, () => {
+        const existing = readCodexConfig(configPath);
+        const next = transform(existing);
+        if (next === existing)
+            return "unchanged";
+        writeFileAtomic(configPath, next, "utf8");
+        return "written";
+    });
+}
 function tomlString(value) {
     return JSON.stringify(value);
 }
@@ -271,13 +323,8 @@ export function ensurePinnedCodexMcp(input, definition) {
             reason: provisioned.reason,
         };
     }
-    const existing = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
-    const next = upsertCommandMcpServer(existing, provisioned.definition);
-    if (next === existing)
-        return { kind: "unchanged", path: configPath };
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileAtomic(configPath, next, "utf8");
-    return { kind: "written", path: configPath };
+    const result = updateCodexConfig(configPath, (existing) => upsertCommandMcpServer(existing, provisioned.definition));
+    return { kind: result === "written" ? "written" : "unchanged", path: configPath };
 }
 function removeUnsafePackageManagerMcpBlocks(raw) {
     const lines = raw.split(/\r?\n/u);
@@ -329,15 +376,11 @@ function removeUnsafePackageManagerMcpBlocks(raw) {
 export function ensureCodexProjectMcpServers(input) {
     const configPath = input.configPath ?? defaultConfigPath();
     const sourcePath = input.sourcePath ?? join(input.repoRoot, ".mcp.json");
-    const existing = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
-    const withoutUnsafeLaunchers = removeUnsafePackageManagerMcpBlocks(existing);
-    const cleanedUnsafeLaunchers = withoutUnsafeLaunchers !== existing;
     const persistSafetyCleanup = () => {
-        if (!cleanedUnsafeLaunchers || input.options.dryRun)
+        if (input.options.dryRun)
             return undefined;
-        mkdirSync(dirname(configPath), { recursive: true });
-        writeFileAtomic(configPath, withoutUnsafeLaunchers, "utf8");
-        return true;
+        const result = updateCodexConfig(configPath, removeUnsafePackageManagerMcpBlocks);
+        return result === "written" ? true : undefined;
     };
     const parsed = existsSync(sourcePath)
         ? parseProjectMcpServers(readFileSync(sourcePath, "utf8"))
@@ -368,12 +411,10 @@ export function ensureCodexProjectMcpServers(input) {
         }
         provisioned.push(result.definition);
     }
-    const next = provisioned.reduce(upsertCommandMcpServer, withoutUnsafeLaunchers);
-    if (next === existing) {
+    const result = updateCodexConfig(configPath, (existing) => provisioned.reduce(upsertCommandMcpServer, removeUnsafePackageManagerMcpBlocks(existing)));
+    if (result === "unchanged") {
         return { kind: "codex-project-mcp-unchanged", path: configPath, servers };
     }
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileAtomic(configPath, next, "utf8");
     return { kind: "codex-project-mcp-written", path: configPath, servers };
 }
 function claudePlaywrightServer() {
@@ -561,12 +602,9 @@ export function ensureCodexWebpressoMcp(input) {
         const checked = resolution?.checked ?? [];
         return { kind: "codex-webpresso-mcp-not-installed", path: configPath, checked };
     }
-    const existing = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
-    const next = upsertWebpressoMcpServer(existing, entryPath);
-    if (next === existing) {
+    const result = updateCodexConfig(configPath, (existing) => upsertWebpressoMcpServer(existing, entryPath));
+    if (result === "unchanged") {
         return { kind: "codex-webpresso-mcp-unchanged", path: configPath, entryPath };
     }
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileAtomic(configPath, next, "utf8");
     return { kind: "codex-webpresso-mcp-written", path: configPath, entryPath };
 }

package/dist/esm/cli/commands/logs.d.ts

@@ -1,3 +1,18 @@
 import type { CAC } from "cac";
+interface LogsCommandOptions {
+    readonly follow?: boolean;
+    readonly tail?: string | number | boolean;
+    readonly watch?: boolean;
+}
+interface FollowLogFileOptions {
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+    readonly write?: (chunk: string) => void;
+}
 export declare const LOGS_COMMAND_HELP: string;
 export declare function registerLogsCommand(cli: CAC): void;
+export declare function parseTailLineCount(value: LogsCommandOptions["tail"]): number | null;
+export declare function tailLogContent(content: string, lineCount: number): string;
+export declare function readTailLogContent(logPath: string, lineCount: number, chunkSize?: number): string;
+export declare function followLogFile(logPath: string, startOffset: number, options?: FollowLogFileOptions): Promise<number>;
+export {};

package/dist/esm/cli/commands/logs.js

@@ -1,16 +1,22 @@
-import { readFileSync } from "node:fs";
+import { closeSync, createReadStream, openSync, readFileSync, readSync, statSync, unwatchFile, watchFile, } from "node:fs";
 import { CLI_LOG_COMMANDS, isCliLogCommandName, readCliLogEntry } from "./quality-log-store.js";
+const TAIL_READ_CHUNK_BYTES = 64 * 1024;
 export const LOGS_COMMAND_HELP = [
     "Print persisted raw output for a recent summary-first quality command run.",
     "",
     "Examples:",
     "  wp logs test",
     "  wp logs qa 2",
+    "  wp logs test --tail 200",
+    "  wp logs test --tail 200 --follow",
 ].join("\n");
 export function registerLogsCommand(cli) {
     cli
         .command("logs <command> [n]", LOGS_COMMAND_HELP)
-        .action((command, n) => {
+        .option("--follow", "Keep printing appended output from the selected log")
+        .option("--tail <lines>", "Print only the last N lines from the selected log")
+        .option("--watch", "Alias for --follow")
+        .action((command, n, options = {}) => {
         if (!isCliLogCommandName(command)) {
             console.error(`Unknown logs command: ${command}. Expected one of: ${CLI_LOG_COMMANDS.join(", ")}`);
             return 1;
@@ -20,12 +26,195 @@ export function registerLogsCommand(cli) {
             console.error("Usage: wp logs <command> [n]\n`n` must be an integer in the range 1..10.");
             return 1;
         }
+        const tailLines = parseTailLineCount(options.tail);
+        if (tailLines !== null && tailLines < 1) {
+            console.error("Usage: wp logs <command> [n] [--tail <lines>]\n`tail` must be a positive integer.");
+            return 1;
+        }
         const entry = readCliLogEntry(command, ordinal);
         if (!entry) {
             console.log(`No logs yet for ${command}.`);
             return 0;
         }
-        process.stdout.write(readFileSync(entry.logPath, "utf8"));
+        const snapshot = tailLines === null
+            ? readFullLogSnapshot(entry.logPath)
+            : readTailLogSnapshot(entry.logPath, tailLines);
+        const printed = snapshot.content;
+        process.stdout.write(printed);
+        if (options.follow === true || options.watch === true) {
+            return followLogFile(entry.logPath, snapshot.offset);
+        }
         return 0;
     });
 }
+export function parseTailLineCount(value) {
+    if (value === undefined || value === null || value === false)
+        return null;
+    if (value === true)
+        return 0;
+    const count = typeof value === "number" ? value : Number(value);
+    if (!Number.isInteger(count) || count < 1)
+        return 0;
+    return count;
+}
+export function tailLogContent(content, lineCount) {
+    const lines = content.split("\n");
+    const trailingNewline = lines.at(-1) === "";
+    const body = trailingNewline ? lines.slice(0, -1) : lines;
+    const selected = body.slice(-lineCount);
+    if (selected.length === 0)
+        return "";
+    return `${selected.join("\n")}${trailingNewline ? "\n" : ""}`;
+}
+export function readTailLogContent(logPath, lineCount, chunkSize = TAIL_READ_CHUNK_BYTES) {
+    return readTailLogSnapshot(logPath, lineCount, chunkSize).content;
+}
+function readFullLogSnapshot(logPath) {
+    const content = readFileSync(logPath, "utf8");
+    return { content, offset: Buffer.byteLength(content) };
+}
+function readTailLogSnapshot(logPath, lineCount, chunkSize = TAIL_READ_CHUNK_BYTES) {
+    const fileSize = statSync(logPath).size;
+    if (fileSize === 0 || lineCount < 1)
+        return { content: "", offset: fileSize };
+    const fd = openSync(logPath, "r");
+    try {
+        const hasTrailingNewline = readLastByte(fd, fileSize) === 0x0a;
+        const targetNewlines = hasTrailingNewline ? lineCount + 1 : lineCount;
+        const chunks = [];
+        let position = fileSize;
+        let newlineCount = 0;
+        while (position > 0 && newlineCount < targetNewlines) {
+            const bytesToRead = Math.min(chunkSize, position);
+            position -= bytesToRead;
+            const buffer = Buffer.allocUnsafe(bytesToRead);
+            const bytesRead = readSync(fd, buffer, 0, bytesToRead, position);
+            const chunk = buffer.subarray(0, bytesRead);
+            chunks.unshift(chunk);
+            newlineCount += countNewlines(chunk);
+        }
+        return {
+            content: tailLogContent(Buffer.concat(chunks).toString("utf8"), lineCount),
+            offset: fileSize,
+        };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readLastByte(fd, fileSize) {
+    if (fileSize < 1)
+        return null;
+    const buffer = Buffer.allocUnsafe(1);
+    const bytesRead = readSync(fd, buffer, 0, 1, fileSize - 1);
+    return bytesRead === 1 ? buffer.readUInt8(0) : null;
+}
+function countNewlines(buffer) {
+    let count = 0;
+    for (const byte of buffer) {
+        if (byte === 0x0a)
+            count++;
+    }
+    return count;
+}
+export function followLogFile(logPath, startOffset, options = {}) {
+    if (options.signal?.aborted === true)
+        return Promise.resolve(0);
+    let offset = startOffset;
+    let pendingSize = startOffset;
+    let reading = false;
+    let readGeneration = 0;
+    let settled = false;
+    let activeStream = null;
+    let poll = null;
+    const write = options.write ??
+        ((chunk) => {
+            process.stdout.write(chunk);
+        });
+    let resolvePromise = null;
+    const settle = () => {
+        if (settled)
+            return;
+        settled = true;
+        unwatchFile(logPath, onChange);
+        activeStream?.destroy();
+        if (poll !== null)
+            clearInterval(poll);
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        options.signal?.removeEventListener("abort", onSignal);
+        resolvePromise?.(0);
+    };
+    const onSignal = () => {
+        settle();
+    };
+    const drain = () => {
+        if (settled || reading || pendingSize <= offset)
+            return;
+        reading = true;
+        const nextOffset = pendingSize;
+        const generation = readGeneration;
+        const stream = createReadStream(logPath, {
+            encoding: "utf8",
+            start: offset,
+            end: nextOffset - 1,
+        });
+        activeStream = stream;
+        stream.on("data", (chunk) => {
+            if (settled)
+                return;
+            write(String(chunk));
+        });
+        stream.on("close", () => {
+            if (activeStream === stream)
+                activeStream = null;
+            if (settled || generation !== readGeneration)
+                return;
+            offset = nextOffset;
+            reading = false;
+            drain();
+        });
+        stream.on("error", onSignal);
+    };
+    const onChange = (current) => {
+        if (settled)
+            return;
+        if (current.size < pendingSize) {
+            readGeneration++;
+            activeStream?.destroy();
+            activeStream = null;
+            reading = false;
+            offset = 0;
+            pendingSize = current.size;
+            drain();
+            return;
+        }
+        if (current.size <= pendingSize)
+            return;
+        pendingSize = current.size;
+        drain();
+    };
+    return new Promise((resolve) => {
+        resolvePromise = resolve;
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        options.signal?.addEventListener("abort", onSignal, { once: true });
+        watchFile(logPath, { interval: options.pollIntervalMs ?? 250 }, onChange);
+        poll = setInterval(() => {
+            if (settled)
+                return;
+            try {
+                onChange(statSync(logPath));
+            }
+            catch (error) {
+                if (isMissingFileError(error))
+                    return;
+                onSignal();
+            }
+        }, options.pollIntervalMs ?? 250);
+        onChange(statSync(logPath));
+    });
+}
+function isMissingFileError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/esm/cli/commands/quality-log-store.d.ts

@@ -6,6 +6,7 @@ export interface CliLogEntry {
     readonly timestamp: string;
     readonly exitCode: number;
     readonly logPath: string;
+    readonly active?: boolean;
     readonly options?: Record<string, unknown>;
     readonly summary?: string;
 }