@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/adapters/llm/child-session.js

@@ -0,0 +1,83 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export async function withChildSession(spec, work) {
+    const directory = await mkdtemp(join(tmpdir(), spec.directoryPrefix));
+    const child = spawn(spec.file, [...spec.args], {
+        cwd: directory,
+        env: spec.env(directory),
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    child.on("error", () => { });
+    child.stdin.on("error", () => { });
+    child.stderr.resume();
+    const closed = new Promise((resolve) => child.once("close", () => resolve()));
+    const terminate = (signal) => {
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                // A child that already exited has no process group to signal.
+            }
+        }
+        child.kill(signal);
+    };
+    let forceTimer;
+    const timer = setTimeout(() => {
+        if (spec.killAfterTermMs === undefined) {
+            terminate("SIGKILL");
+            return;
+        }
+        terminate("SIGTERM");
+        forceTimer = setTimeout(() => terminate("SIGKILL"), spec.killAfterTermMs);
+    }, spec.timeoutMs);
+    try {
+        return await work({
+            child,
+            send: (message) => {
+                child.stdin.write(`${JSON.stringify(message)}\n`);
+            },
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        if (forceTimer !== undefined)
+            clearTimeout(forceTimer);
+        terminate("SIGTERM");
+        if (!(await closesWithin(closed, spec.graceMs))) {
+            terminate("SIGKILL");
+            if (spec.settleMs !== undefined)
+                await closesWithin(closed, spec.settleMs);
+        }
+        await rm(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    }
+}
+async function closesWithin(closed, ms) {
+    let timer;
+    try {
+        return await Promise.race([
+            closed.then(() => true),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), ms);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// The child's output, ended with an error once more than `maxBytes` has arrived.
+export async function* cappedOutput(chunks, maxBytes, oversize) {
+    let bytes = 0;
+    for await (const chunk of chunks) {
+        bytes += chunk.byteLength;
+        if (bytes > maxBytes)
+            throw oversize();
+        yield chunk;
+    }
+}

package/dist/adapters/llm/claude-code-models.js

@@ -1,10 +1,8 @@
-import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { z } from "zod";
 import { cliCommand } from "../../kernel/cli-command.js";
+import { cappedOutput, withChildSession } from "./child-session.js";
+import { lines } from "./sse-lines.js";
 const maxOutputBytes = 1024 * 1024;
 const modelId = z
     .string()
@@ -38,7 +36,7 @@ const responseSchema = z.object({
 });
 const supportedEfforts = ["low", "medium", "high", "xhigh"];
 function unavailable() {
-    return new Error("Slopify could not get the model list from the Claude Code CLI. Check the CLI is installed and signed in (Settings → Providers), then refresh the list, or type an exact model ID.");
+    return new Error("Slopify could not get the model list from the Claude Code CLI. Check the CLI is installed and signed in (Settings → Keys & services), then refresh the list, or type an exact model ID.");
 }
 function discoveryEnv() {
     const names = [
@@ -109,104 +107,59 @@ function claudeModelName(target, description, fallback) {
 // The installed CLI has no model-list command; initialize is a no-prompt
 // stream-JSON control exchange. Treat protocol drift as unavailable metadata.
 export async function nodeClaudeCodeModels(binary, timeoutMs = 15_000) {
-    const directory = await mkdtemp(join(tmpdir(), "slopify-claude-models-"));
     const requestId = randomUUID();
     const command = cliCommand(binary);
-    const child = spawn(command.file, [
-        ...command.args,
-        "-p",
-        "--input-format",
-        "stream-json",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--safe-mode",
-        "--tools",
-        "",
-        "--strict-mcp-config",
-        "--no-session-persistence",
-    ], {
-        cwd: directory,
-        env: discoveryEnv(),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        detached: process.platform !== "win32",
-    });
-    child.on("error", () => { });
-    child.stdin.on("error", () => { });
-    child.stderr.resume();
-    const closed = new Promise((resolve) => child.once("close", () => resolve()));
-    const terminate = (force) => {
-        const signal = force ? "SIGKILL" : "SIGTERM";
-        if (process.platform !== "win32" && child.pid !== undefined) {
-            try {
-                process.kill(-child.pid, signal);
-                return;
-            }
-            catch {
-                // A child that already exited has no process group to signal.
-            }
-        }
-        child.kill(signal);
-    };
-    let forceTimer;
-    const timer = setTimeout(() => {
-        terminate(false);
-        forceTimer = setTimeout(() => terminate(true), 500);
-    }, timeoutMs);
-    try {
-        child.stdin.write(`${JSON.stringify({
-            request_id: requestId,
-            type: "control_request",
-            request: { subtype: "initialize" },
-        })}\n`);
-        let output = "";
-        let bytes = 0;
-        for await (const piece of child.stdout) {
-            bytes += piece.length;
-            if (bytes > maxOutputBytes)
-                throw unavailable();
-            output += piece.toString();
-            let newline = output.indexOf("\n");
-            while (newline >= 0) {
-                const line = output.slice(0, newline).trim();
-                output = output.slice(newline + 1);
-                if (line !== "") {
-                    let event;
-                    try {
-                        event = JSON.parse(line);
-                    }
-                    catch {
-                        throw unavailable();
-                    }
-                    if (typeof event === "object" &&
-                        event !== null &&
-                        "type" in event &&
-                        event.type === "control_response") {
-                        return choices(event, requestId);
-                    }
+    return withChildSession({
+        file: command.file,
+        args: [
+            ...command.args,
+            "-p",
+            "--input-format",
+            "stream-json",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--safe-mode",
+            "--tools",
+            "",
+            "--strict-mcp-config",
+            "--no-session-persistence",
+        ],
+        env: () => discoveryEnv(),
+        directoryPrefix: "slopify-claude-models-",
+        timeoutMs,
+        killAfterTermMs: 500,
+        graceMs: 500,
+        settleMs: 500,
+    }, async ({ child, send }) => {
+        try {
+            send({
+                request_id: requestId,
+                type: "control_request",
+                request: { subtype: "initialize" },
+            });
+            for await (const text of lines(cappedOutput(child.stdout, maxOutputBytes, unavailable))) {
+                const line = text.trim();
+                if (line === "")
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    throw unavailable();
+                }
+                if (typeof event === "object" &&
+                    event !== null &&
+                    "type" in event &&
+                    event.type === "control_response") {
+                    return choices(event, requestId);
                 }
-                newline = output.indexOf("\n");
             }
+            throw unavailable();
         }
-        throw unavailable();
-    }
-    catch {
-        throw unavailable();
-    }
-    finally {
-        clearTimeout(timer);
-        if (forceTimer !== undefined)
-            clearTimeout(forceTimer);
-        terminate(false);
-        const grace = await Promise.race([
-            closed.then(() => true),
-            new Promise((resolve) => setTimeout(() => resolve(false), 500)),
-        ]);
-        if (!grace) {
-            terminate(true);
-            await Promise.race([closed, new Promise((resolve) => setTimeout(resolve, 500))]);
+        catch {
+            throw unavailable();
         }
-        await rm(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
-    }
+    });
 }

package/dist/adapters/llm/claude-code.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { isoOfEpoch } from "../../kernel/ports/plan-limits.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { cliCheck, cliReported, commandOf } from "../explain.js";
 import { nodeClaudeCodeModels } from "./claude-code-models.js";
 import { cliLoginError } from "./cli-login-error.js";
@@ -142,7 +143,11 @@ export function claudeCodeLlm(deps) {
         const read = new Set();
         let run;
         let ended;
+        // A call of several model turns reports its windows once per turn: the first is kept as
+        // the call's "before", the last as its "after".
+        let firstLimits;
         let limits;
+        let limitEvents = 0;
         try {
             images = imageWorkspace(req.images);
             const folder = images?.directory ?? documents?.directory;
@@ -191,8 +196,11 @@ export function claudeCodeLlm(deps) {
                     // A shape this version does not know is not a failure: the plan windows are
                     // reported beside the answer, never needed for it.
                     const parsed = rateLimitEvent.safeParse(event.value);
-                    if (parsed.success)
+                    if (parsed.success) {
+                        firstLimits ??= parsed.data.rate_limit_info;
                         limits = parsed.data.rate_limit_info;
+                        limitEvents += 1;
+                    }
                     continue;
                 }
                 if (event.type === "assistant" && !documents) {
@@ -231,6 +239,7 @@ export function claudeCodeLlm(deps) {
                         });
                     throw providerError({
                         kind: kindOf(result.api_error_status ?? null),
+                        ...(result.api_error_status === 404 ? { access: "not-found" } : {}),
                         message: cliReported(binary, redact(result.result ?? result.subtype), nextStep(binary, result.api_error_status ?? null)),
                     });
                 }
@@ -240,11 +249,14 @@ export function claudeCodeLlm(deps) {
                 if ((documents || images) && result.result)
                     yield { type: "delta", text: result.result };
                 const windows = limits === undefined ? [] : claudeWindows(limits);
+                const start = limitEvents > 1 && firstLimits !== undefined ? claudeWindows(firstLimits) : [];
                 yield {
                     type: "done",
                     usage: usageOf(result.modelUsage),
                     finishReason: result.stop_reason ?? null,
-                    ...(windows.length === 0 ? {} : { limits: { after: windows } }),
+                    ...(windows.length === 0
+                        ? {}
+                        : { limits: { ...(start.length === 0 ? {} : { before: start }), after: windows } }),
                 };
                 return;
             }
@@ -273,7 +285,7 @@ export function claudeCodeLlm(deps) {
         req.signal.throwIfAborted();
         // The stream ended with no result event at all.
         if (!run)
-            throw new Error("The Claude Code CLI could not be started. Check it is installed and set up in Settings → Providers, then use Try again.");
+            throw new Error("The Claude Code CLI could not be started. Check it is installed and set up in Settings → Keys & services, then use Try again.");
         const login = cliLoginError("claude-code", run.stderr());
         if (login)
             throw login;
@@ -311,7 +323,7 @@ function nextStep(binary, status) {
     if (status === 429)
         return "Your Claude usage limit may be used up: wait until it resets, then use Try again.";
     if (status === 404)
-        return "The chosen model may not exist or not be available to your account: choose another in the Providers section of Edit project, then use Try again.";
+        return `The chosen model may not exist or not be available to your account: choose another in ${editSettings.writer}, then use Try again.`;
     return cliCheck(binary);
 }
 // `modelUsage` is keyed by model id and a run may touch more than one - a fallback model,

package/dist/adapters/llm/codex-limits.js

@@ -1,10 +1,8 @@
-import { spawn } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { z } from "zod";
 import { cliCommand } from "../../kernel/cli-command.js";
 import { isoOfEpoch, windowKindOf, } from "../../kernel/ports/plan-limits.js";
+import { withChildSession } from "./child-session.js";
+import { lines } from "./sse-lines.js";
 // The Codex plan windows. `codex exec --json` reports none, so they are asked of the CLI's
 // app server with `account/rateLimits/read` - a metadata-only exchange that starts no thread
 // and spends nothing. Measured on 0.155.1: the reply carries `rateLimits.primary` and
@@ -40,49 +38,26 @@ export function codexWindows(result) {
 // method, a slow start: the windows are reported beside a run, never needed for it.
 export async function nodeCodexLimits(binary, env, timeoutMs = 10_000) {
     const command = cliCommand(binary);
-    const directory = await mkdtemp(join(tmpdir(), "slopify-codex-limits-"));
-    const child = spawn(command.file, [...command.args, "app-server", "--listen", "stdio://"], {
-        cwd: directory,
-        env: { ...env, PWD: directory },
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        detached: process.platform !== "win32",
-    });
-    child.on("error", () => { });
-    child.stdin.on("error", () => { });
-    child.stderr.resume();
-    const closed = new Promise((resolve) => child.once("close", () => resolve()));
-    const terminate = (signal) => {
-        if (process.platform !== "win32" && child.pid !== undefined) {
-            try {
-                process.kill(-child.pid, signal);
-                return;
-            }
-            catch {
-                /* The process may already have exited. */
-            }
-        }
-        child.kill(signal);
-    };
-    const timer = setTimeout(() => terminate("SIGKILL"), timeoutMs);
-    const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
-    let buffer = "";
-    try {
-        send({
-            id: 1,
-            method: "initialize",
-            params: { clientInfo: { name: "slopify_limits", version: "1.0" } },
-        });
-        child.stdout.setEncoding("utf8");
-        for await (const piece of child.stdout) {
-            buffer += piece;
-            if (buffer.length > 1024 * 1024)
-                return null;
-            let newline = buffer.indexOf("\n");
-            while (newline >= 0) {
-                const line = buffer.slice(0, newline).trim();
-                buffer = buffer.slice(newline + 1);
-                newline = buffer.indexOf("\n");
+    const oversize = () => new Error("Oversized reply");
+    return withChildSession({
+        file: command.file,
+        args: [...command.args, "app-server", "--listen", "stdio://"],
+        env: (directory) => ({ ...env, PWD: directory }),
+        directoryPrefix: "slopify-codex-limits-",
+        timeoutMs,
+        graceMs: 1000,
+    }, async ({ child, send }) => {
+        try {
+            send({
+                id: 1,
+                method: "initialize",
+                params: { clientInfo: { name: "slopify_limits", version: "1.0" } },
+            });
+            for await (const raw of lines(child.stdout, undefined, {
+                chars: 1024 * 1024,
+                error: oversize,
+            })) {
+                const line = raw.trim();
                 if (line === "")
                     continue;
                 const reply = z
@@ -99,28 +74,12 @@ export async function nodeCodexLimits(binary, env, timeoutMs = 10_000) {
                     return windows.length === 0 ? null : windows;
                 }
             }
+            return null;
         }
-        return null;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        clearTimeout(timer);
-        terminate("SIGTERM");
-        let grace;
-        await Promise.race([
-            closed,
-            new Promise((resolve) => {
-                grace = setTimeout(() => {
-                    terminate("SIGKILL");
-                    resolve();
-                }, 1000);
-            }),
-        ]);
-        clearTimeout(grace);
-        await rm(directory, { recursive: true, force: true });
-    }
+        catch {
+            return null;
+        }
+    });
 }
 const months = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
 // Codex refuses a turn over the plan's allowance with "You've hit your usage limit. … Try

package/dist/adapters/llm/codex-models.js

@@ -59,7 +59,7 @@ export async function nodeCodexModels(env = process.env, binary = "codex", timeo
         }
         catch {
             // Do not expose cache contents, home paths or raw JSON errors to the browser.
-            throw new Error("Slopify could not get the model list from the Codex CLI. Check the CLI is installed and signed in (Settings → Providers), then refresh the list, or type an exact model ID.");
+            throw new Error("Slopify could not get the model list from the Codex CLI. Check the CLI is installed and signed in (Settings → Keys & services), then refresh the list, or type an exact model ID.");
         }
     }
 }

package/dist/adapters/llm/codex-server-models.js

@@ -1,10 +1,8 @@
-import { spawn } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { z } from "zod";
 import { cliCommand } from "../../kernel/cli-command.js";
 import { thinkingModes as knownEfforts } from "../../kernel/ports/llm.js";
+import { cappedOutput, withChildSession } from "./child-session.js";
+import { lines } from "./sse-lines.js";
 const text = z
     .string()
     .trim()
@@ -28,39 +26,18 @@ const pageSchema = z.object({
 // model/list is a metadata-only app-server exchange: no thread, turn or tool is started.
 export async function nodeCodexServerModels(binary, env, timeoutMs = 15_000) {
     const command = cliCommand(binary);
-    const directory = await mkdtemp(join(tmpdir(), "slopify-codex-models-"));
-    const child = spawn(command.file, [...command.args, "app-server", "--listen", "stdio://"], {
-        cwd: directory,
-        env: { ...env, PWD: directory },
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        detached: process.platform !== "win32",
-    });
-    child.on("error", () => { });
-    child.stdin.on("error", () => { });
-    child.stderr.resume();
-    const closed = new Promise((resolve) => child.once("close", () => resolve()));
-    function terminate(signal) {
-        if (process.platform !== "win32" && child.pid !== undefined) {
-            try {
-                process.kill(-child.pid, signal);
-                return;
-            }
-            catch {
-                /* The process may already have exited. */
-            }
-        }
-        child.kill(signal);
-    }
-    const timer = setTimeout(() => terminate("SIGKILL"), timeoutMs);
-    const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
-    let expectedId = 1;
-    let pages = 0;
-    let bytes = 0;
-    let buffer = "";
-    const models = new Map();
-    const cursors = new Set();
-    try {
+    return withChildSession({
+        file: command.file,
+        args: [...command.args, "app-server", "--listen", "stdio://"],
+        env: (directory) => ({ ...env, PWD: directory }),
+        directoryPrefix: "slopify-codex-models-",
+        timeoutMs,
+        graceMs: 500,
+    }, async ({ child, send }) => {
+        let expectedId = 1;
+        let pages = 0;
+        const models = new Map();
+        const cursors = new Set();
         send({
             id: expectedId,
             method: "initialize",
@@ -68,83 +45,58 @@ export async function nodeCodexServerModels(binary, env, timeoutMs = 15_000) {
                 clientInfo: { name: "slopify_model_discovery", version: "1.0" },
             },
         });
-        child.stdout.setEncoding("utf8");
-        for await (const piece of child.stdout) {
-            bytes += Buffer.byteLength(piece);
-            if (bytes > 4 * 1024 * 1024)
-                throw new Error("Oversized metadata");
-            buffer += piece;
-            let newline = buffer.indexOf("\n");
-            while (newline >= 0) {
-                const line = buffer.slice(0, newline).trim();
-                buffer = buffer.slice(newline + 1);
-                newline = buffer.indexOf("\n");
-                if (line === "")
-                    continue;
-                const event = z
-                    .object({
-                    id: z.unknown().optional(),
-                    result: z.unknown().optional(),
-                    error: z.unknown().optional(),
-                })
-                    .parse(JSON.parse(line));
-                if (event.id !== expectedId)
-                    continue;
-                if (event.error !== undefined)
-                    throw new Error("Discovery refused");
-                let cursor;
-                if (expectedId === 1) {
-                    send({ method: "initialized" });
+        const oversize = () => new Error("Oversized metadata");
+        for await (const raw of lines(cappedOutput(child.stdout, 4 * 1024 * 1024, oversize))) {
+            const line = raw.trim();
+            if (line === "")
+                continue;
+            const event = z
+                .object({
+                id: z.unknown().optional(),
+                result: z.unknown().optional(),
+                error: z.unknown().optional(),
+            })
+                .parse(JSON.parse(line));
+            if (event.id !== expectedId)
+                continue;
+            if (event.error !== undefined)
+                throw new Error("Discovery refused");
+            let cursor;
+            if (expectedId === 1) {
+                send({ method: "initialized" });
+            }
+            else {
+                const page = pageSchema.parse(event.result);
+                for (const row of page.data) {
+                    if (row.hidden === true || models.has(row.model))
+                        continue;
+                    const thinkingModes = row.supportedReasoningEfforts
+                        ?.map((item) => item.reasoningEffort)
+                        .filter((effort) => knownEfforts.includes(effort));
+                    models.set(row.model, {
+                        id: row.model,
+                        name: codexModelName(row.displayName),
+                        ...(thinkingModes?.length ? { thinkingModes } : {}),
+                    });
                 }
-                else {
-                    const page = pageSchema.parse(event.result);
-                    for (const row of page.data) {
-                        if (row.hidden === true || models.has(row.model))
-                            continue;
-                        const thinkingModes = row.supportedReasoningEfforts
-                            ?.map((item) => item.reasoningEffort)
-                            .filter((effort) => knownEfforts.includes(effort));
-                        models.set(row.model, {
-                            id: row.model,
-                            name: codexModelName(row.displayName),
-                            ...(thinkingModes?.length ? { thinkingModes } : {}),
-                        });
-                    }
-                    cursor = page.nextCursor;
-                    if (!cursor) {
-                        if (models.size === 0)
-                            throw new Error("No visible models");
-                        return [...models.values()];
-                    }
-                    if (cursors.has(cursor) || ++pages >= 20)
-                        throw new Error("Invalid pagination");
-                    cursors.add(cursor);
+                cursor = page.nextCursor;
+                if (!cursor) {
+                    if (models.size === 0)
+                        throw new Error("No visible models");
+                    return [...models.values()];
                 }
-                send({
-                    id: ++expectedId,
-                    method: "model/list",
-                    params: { limit: 100, includeHidden: false, ...(cursor ? { cursor } : {}) },
-                });
+                if (cursors.has(cursor) || ++pages >= 20)
+                    throw new Error("Invalid pagination");
+                cursors.add(cursor);
             }
+            send({
+                id: ++expectedId,
+                method: "model/list",
+                params: { limit: 100, includeHidden: false, ...(cursor ? { cursor } : {}) },
+            });
         }
         throw new Error("Discovery ended before its reply");
-    }
-    finally {
-        clearTimeout(timer);
-        terminate("SIGTERM");
-        let grace;
-        await Promise.race([
-            closed,
-            new Promise((resolve) => {
-                grace = setTimeout(() => {
-                    terminate("SIGKILL");
-                    resolve();
-                }, 500);
-            }),
-        ]);
-        clearTimeout(grace);
-        await rm(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
-    }
+    });
 }
 export function codexModelName(name) {
     return name.replace(/^(GPT-\d+(?:\.\d+)?)-/i, "$1 ");