@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/adapters/llm/assistant-cli.js

@@ -0,0 +1,388 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { cliName } from "../explain.js";
+import { cliLoginError } from "./cli-login-error.js";
+import { codexBinary, hardenedCodexBase } from "./codex.js";
+import { cliInput, endedWithout, stopCliRun, stuckCli } from "./run-cli.js";
+import { lines } from "./sse-lines.js";
+// The in-app assistant's CLI turn: Claude Code or Codex with no tool of its own (no shell, no
+// files, no web), none of the person's settings, hooks, plugins, skills, memory or MCP
+// servers, and one MCP server: Slopify's `/mcp/assistant`, opened with the turn's token.
+//
+// The token is never an argument: argv is readable by every process on the computer. It is in
+// the CLI's environment only, and the CLIs put it in the header themselves:
+// - Claude Code 2.1.302 expands ${VAR} in an --mcp-config file's headers (checked on this
+//   machine: a stand-in server saw "Bearer <the token>" from `"Bearer
+//   ${SLOPIFY_ASSISTANT_TOKEN}"`). The file names the variable, not the token.
+// - Codex 0.155.1 reads `mcp_servers.<name>.bearer_token_env_var` (codex-rs config
+//   `McpServerTransportConfig::StreamableHttp`; also checked: the server saw the bearer).
+export const assistantServerName = "slopify";
+export const assistantTokenVariable = "SLOPIFY_ASSISTANT_TOKEN";
+const slopifyTool = `mcp__${assistantServerName}__`;
+export function claudeAssistantArgs(options) {
+    return [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--include-partial-messages",
+        // `claude --help` 2.1.302: --restricted drops the code-running tools and WebFetch and
+        // ignores the user, project and local settings files; --setting-sources "" loads none of
+        // them either. --bare would discard the OAuth sign-in the assistant runs on.
+        "--restricted",
+        "--setting-sources",
+        "",
+        "--disable-slash-commands",
+        "--no-chrome",
+        "--no-session-persistence",
+        "--settings",
+        JSON.stringify({
+            disableAllHooks: true,
+            autoMemoryEnabled: false,
+            claudeMdExcludes: ["**"],
+            enabledPlugins: {},
+        }),
+        "--system-prompt",
+        options.system,
+        "--strict-mcp-config",
+        "--mcp-config",
+        options.mcpConfig,
+        // No built-in tool at all; only Slopify's server is allowed, and the web tools are named
+        // as refused in case a later version brings them back by default.
+        "--tools",
+        "",
+        "--allowedTools",
+        `mcp__${assistantServerName}`,
+        "--disallowedTools",
+        "WebSearch,WebFetch,Bash",
+        "--permission-mode",
+        "dontAsk",
+        ...(options.model === undefined || options.model === "" ? [] : ["--model", options.model]),
+    ];
+}
+export function claudeAssistantConfig(url) {
+    return JSON.stringify({
+        mcpServers: {
+            [assistantServerName]: {
+                type: "http",
+                url,
+                headers: { Authorization: `Bearer \${${assistantTokenVariable}}` },
+            },
+        },
+    });
+}
+export function codexAssistantArgs(options) {
+    const server = `mcp_servers.${assistantServerName}`;
+    return [
+        ...hardenedCodexBase(options.directory),
+        "-c",
+        `instructions=${JSON.stringify(options.system)}`,
+        "-c",
+        'web_search="disabled"',
+        "-c",
+        "tool_output_token_limit=32768",
+        "-c",
+        `${server}.url=${JSON.stringify(options.url)}`,
+        "-c",
+        `${server}.bearer_token_env_var=${JSON.stringify(assistantTokenVariable)}`,
+        "-c",
+        `${server}.required=true`,
+        "-c",
+        `${server}.default_tools_approval_mode="auto"`,
+        ...(options.model === undefined || options.model === "" ? [] : ["-m", options.model]),
+        "--",
+        "-",
+    ];
+}
+// What the CLI is started with: enough to find itself, its sign-in and the network, and
+// nothing else of Slopify's environment. A provider key there would make the CLI bill that key
+// instead of the person's plan, and hand it a secret it never needs.
+const passedNames = new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LANGUAGE",
+    "TZ",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "TERM",
+    // Where each CLI keeps its sign-in and settings, when moved from the default.
+    "CLAUDE_CONFIG_DIR",
+    "CODEX_HOME",
+    // A network that needs a proxy or its own certificates.
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+    "NODE_EXTRA_CA_CERTS",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    // Windows: the CLI can't start, or find its folders, without these.
+    "SYSTEMROOT",
+    "SystemRoot",
+    "WINDIR",
+    "COMSPEC",
+    "PATHEXT",
+    "USERPROFILE",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "PROGRAMDATA",
+    "ProgramData",
+    "PROGRAMFILES",
+    "ProgramFiles",
+    "Path",
+]);
+export function assistantEnv(sourceEnv) {
+    const env = {};
+    for (const [name, value] of Object.entries(sourceEnv))
+        if (value !== undefined && (passedNames.has(name) || /^(LC|XDG)_[A-Z_]+$/.test(name)))
+            env[name] = value;
+    return env;
+}
+// A private folder (0700) that is the CLI's working directory, so nothing of the person's
+// projects is its cwd, holding the 0600 config file; removed when the turn ends.
+export function assistantWorkspace(url, token, sourceEnv) {
+    const directory = mkdtempSync(join(tmpdir(), "slopify-assistant-"));
+    const remove = () => rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    try {
+        const config = join(directory, "mcp.json");
+        writeFileSync(config, claudeAssistantConfig(url), { mode: 0o600, flag: "wx" });
+        const env = assistantEnv(sourceEnv);
+        env.PWD = directory;
+        env[assistantTokenVariable] = token;
+        return { directory, config, env, remove };
+    }
+    catch (error) {
+        remove();
+        throw error;
+    }
+}
+const typed = z.object({ type: z.string() }).loose();
+const claudeInit = z
+    .object({
+    subtype: z.literal("init"),
+    tools: z.array(z.string()).optional(),
+    mcp_servers: z.array(z.object({ name: z.string(), status: z.string() }).loose()).optional(),
+})
+    .loose();
+const claudeAssistant = z
+    .object({
+    message: z.object({
+        content: z.array(z
+            .object({ type: z.string(), text: z.string().optional(), name: z.string().optional() })
+            .loose()),
+    }),
+})
+    .loose();
+const claudePartial = z
+    .object({
+    event: z.object({
+        type: z.literal("content_block_delta"),
+        delta: z.object({ type: z.literal("text_delta"), text: z.string() }),
+    }),
+})
+    .loose();
+const claudeResult = z
+    .object({ subtype: z.string(), is_error: z.boolean().optional(), result: z.string().optional() })
+    .loose();
+const codexItem = z
+    .object({
+    item: z
+        .object({
+        id: z.string().optional(),
+        type: z.string(),
+        text: z.string().optional(),
+        server: z.string().optional(),
+        tool: z.string().optional(),
+    })
+        .loose(),
+})
+    .loose();
+const codexFailed = z.object({ error: z.object({ message: z.string() }) }).loose();
+const codexError = z.object({ message: z.string() }).loose();
+// Codex items that are no part of a Slopify chat: a shell command, a file edit, a web
+// search, another agent.
+const codexForeign = new Set([
+    "command_execution",
+    "file_change",
+    "web_search",
+    "collab_tool_call",
+]);
+function failed(cli, said) {
+    const login = cliLoginError(cli, said);
+    if (login !== undefined)
+        return { type: "failed", message: login.message };
+    return {
+        type: "failed",
+        message: `The ${cliName(cli === "claude-code" ? "claude" : "codex")} stopped with an error: ${redact(said).slice(0, 500)}. Send your message again; if it keeps happening, check the CLI in Settings → Providers.`,
+    };
+}
+// One JSONL line of the CLI's stream as what the chat shows. A stateful reader: Codex reports
+// a message's text so far, and only what is new is passed on.
+export function assistantStream(cli) {
+    const typedSoFar = new Map();
+    return (line) => {
+        if (line.trim() === "")
+            return [];
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return [];
+        }
+        const event = typed.safeParse(value);
+        if (!event.success)
+            return [];
+        return cli === "claude-code"
+            ? claudeEvents(event.data.type, value)
+            : codexEvents(event.data.type, value);
+    };
+    function claudeEvents(type, value) {
+        if (type === "system") {
+            const init = claudeInit.safeParse(value);
+            if (!init.success)
+                return [];
+            const foreign = (init.data.tools ?? []).filter((name) => !name.startsWith(slopifyTool));
+            if (foreign.length > 0)
+                return [{ type: "foreign", name: foreign.join(", ") }];
+            const server = init.data.mcp_servers?.find((one) => one.name === assistantServerName);
+            if (server !== undefined && (server.status === "failed" || server.status === "needs-auth"))
+                return [
+                    {
+                        type: "failed",
+                        message: "Claude Code couldn't reach Slopify's assistant tools, so it answered nothing. Send your message again; if it keeps happening, restart Slopify.",
+                    },
+                ];
+            return [];
+        }
+        if (type === "stream_event") {
+            const partial = claudePartial.safeParse(value);
+            return partial.success && partial.data.event.delta.text !== ""
+                ? [{ type: "partial", text: partial.data.event.delta.text }]
+                : [];
+        }
+        if (type === "assistant") {
+            const message = claudeAssistant.safeParse(value);
+            if (!message.success)
+                return [];
+            return message.data.message.content.flatMap((block) => {
+                if (block.type === "text" && block.text !== undefined && block.text !== "")
+                    return [{ type: "text", text: block.text }];
+                if (block.type !== "tool_use" || block.name === undefined)
+                    return [];
+                return block.name.startsWith(slopifyTool)
+                    ? [{ type: "tool", name: block.name.slice(slopifyTool.length) }]
+                    : [{ type: "foreign", name: block.name }];
+            });
+        }
+        if (type === "result") {
+            const result = claudeResult.safeParse(value);
+            if (!result.success)
+                return [];
+            return result.data.is_error === true || result.data.subtype !== "success"
+                ? [failed("claude-code", result.data.result ?? result.data.subtype)]
+                : [{ type: "done" }];
+        }
+        return [];
+    }
+    function codexEvents(type, value) {
+        if (type === "item.started" || type === "item.updated" || type === "item.completed") {
+            const parsed = codexItem.safeParse(value);
+            if (!parsed.success)
+                return [];
+            const { item } = parsed.data;
+            if (codexForeign.has(item.type))
+                return [{ type: "foreign", name: item.type }];
+            if (item.type === "mcp_tool_call") {
+                if (item.server !== assistantServerName)
+                    return [{ type: "foreign", name: `${item.server ?? "?"}.${item.tool ?? "?"}` }];
+                return type === "item.started" && item.tool !== undefined
+                    ? [{ type: "tool", name: item.tool }]
+                    : [];
+            }
+            if (item.type !== "agent_message")
+                return [];
+            const id = item.id ?? "";
+            const seen = typedSoFar.get(id) ?? "";
+            const text = item.text ?? "";
+            if (type === "item.completed") {
+                typedSoFar.delete(id);
+                return text === "" ? [] : [{ type: "text", text }];
+            }
+            if (text.length > seen.length && text.startsWith(seen)) {
+                typedSoFar.set(id, text);
+                return [{ type: "partial", text: text.slice(seen.length) }];
+            }
+            return [];
+        }
+        if (type === "turn.completed")
+            return [{ type: "done" }];
+        if (type === "turn.failed") {
+            const parsed = codexFailed.safeParse(value);
+            return [failed("codex", parsed.success ? parsed.data.error.message : "the turn failed")];
+        }
+        if (type === "error") {
+            const parsed = codexError.safeParse(value);
+            return [failed("codex", parsed.success ? parsed.data.message : "unknown error")];
+        }
+        return [];
+    }
+}
+// The turn itself: a private workspace, the CLI started in it with the prompt on stdin, its
+// stream read into the chat's events, and everything stopped and removed at the end.
+export function assistantCliRunner(run, sourceEnv = process.env) {
+    return async function* turn(request) {
+        const space = assistantWorkspace(request.url, request.token, sourceEnv);
+        let child;
+        let ended;
+        try {
+            child = run(request.binary, request.cli === "claude-code"
+                ? claudeAssistantArgs({ mcpConfig: space.config, system: request.system })
+                : codexAssistantArgs({
+                    directory: space.directory,
+                    url: request.url,
+                    system: request.system,
+                }), request.signal, { cwd: space.directory, env: space.env, stdin: cliInput(request.prompt) });
+            const read = assistantStream(request.cli);
+            for await (const line of lines(child.stdout, request.signal))
+                for (const event of read(line)) {
+                    yield event;
+                    if (event.type === "done" || event.type === "failed" || event.type === "foreign")
+                        return;
+                }
+        }
+        finally {
+            // Also when the reader stops early (Stop, the time limit): a CLI left running would
+            // keep spending the person's plan.
+            try {
+                if (child !== undefined)
+                    ended = await stopCliRun(child);
+            }
+            finally {
+                space.remove();
+            }
+        }
+        if (request.signal.aborted || child === undefined)
+            return;
+        // The stream ended with neither an answer nor a failure.
+        const binary = request.cli === "claude-code" ? "claude" : codexBinary;
+        const said = child.stderr();
+        yield {
+            type: "failed",
+            message: cliLoginError(request.cli, said)?.message ??
+                (ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, said)),
+        };
+    };
+}

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()
@@ -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

@@ -142,7 +142,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 +195,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 +238,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 +248,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;
             }