toolstile 0.1.2 → 0.2.0

package/dist/commands.js

@@ -0,0 +1,338 @@
+import { spawn } from "node:child_process";
+import { hostname } from "node:os";
+import { ManualEditError, proxyCommand, readEntry, isProxyEntry, targets, writeEntry } from "./agents.js";
+import { ApiError } from "./api.js";
+import { checklist } from "./prompt.js";
+import { runProxy } from "./proxy.js";
+import { tildify } from "./report.js";
+import { CLIENT_NAMES } from "./sources.js";
+import { loadState, saveState } from "./state.js";
+/** A failure explained to the user; exits 1 without a stack trace. */
+export class UserError extends Error {
+}
+const stateEnv = (ctx) => ({ home: ctx.home, env: ctx.env, platform: ctx.platform });
+const print = (ctx, text = "") => ctx.stdout.write(`${text}\n`);
+const interactive = (ctx) => ctx.stdin.isTTY === true && ctx.stdout.isTTY === true;
+/** HTTPS, except a loopback server for local development. */
+export function normalizeServer(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new UserError(`--server must be a URL, for example https://toolstile.com`);
+    }
+    const loopback = /^(localhost|127\.\d+\.\d+\.\d+|\[::1\])$/.test(url.hostname);
+    if (url.protocol !== "https:" && !(loopback && url.protocol === "http:"))
+        throw new UserError("--server must use https://");
+    return url.origin;
+}
+function defaultOpenBrowser(ctx) {
+    return (url) => {
+        // Over SSH or without a display the URL and code are enough; nothing to open.
+        if (ctx.env.SSH_CONNECTION || ctx.env.SSH_TTY)
+            return;
+        if (ctx.platform === "linux" && !ctx.env.DISPLAY && !ctx.env.WAYLAND_DISPLAY)
+            return;
+        const [command, args] = ctx.platform === "darwin" ? ["open", [url]] : ctx.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+        try {
+            spawn(command, args, { stdio: "ignore", detached: true }).on("error", () => { }).unref();
+        }
+        catch { }
+    };
+}
+const formatCode = (code) => (code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code);
+export async function login(ctx, options) {
+    const s = ctx.style;
+    const state = loadState(stateEnv(ctx));
+    const server = normalizeServer(options.server ?? ctx.env.TOOLSTILE_URL ?? state.server);
+    const api = ctx.api(server);
+    const code = await api.deviceCode();
+    print(ctx, `Open this page on any device with a browser, sign in to Toolstile and enter the code:`);
+    print(ctx);
+    print(ctx, `  ${s.bold(code.verification_uri)}`);
+    print(ctx, `  ${s.bold(formatCode(code.user_code))}`);
+    print(ctx);
+    print(ctx, s.dim(`Waiting for approval. The code expires in ${Math.round(code.expires_in / 60)} minutes.`));
+    if (options.browser)
+        (ctx.openBrowser ?? defaultOpenBrowser(ctx))(code.verification_uri);
+    const sleep = ctx.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    let interval = Math.max(code.interval, 1) * 1000;
+    const deadline = Date.now() + code.expires_in * 1000;
+    let token;
+    while (!token) {
+        if (Date.now() > deadline)
+            throw new UserError("The code expired. Run toolstile auth login again.");
+        await sleep(interval);
+        try {
+            token = (await api.deviceToken(code.device_code)).access_token;
+        }
+        catch (error) {
+            if (!(error instanceof ApiError))
+                throw error;
+            if (error.code === "authorization_pending")
+                continue;
+            if (error.code === "slow_down") {
+                interval += 5000;
+                continue;
+            }
+            if (error.code === "access_denied")
+                throw new UserError("Sign-in was denied in the browser.");
+            if (error.code === "expired_token")
+                throw new UserError("The code expired. Run toolstile auth login again.");
+            throw error;
+        }
+    }
+    const account = await api.account(token);
+    const previous = state.session;
+    // The old session is ended where it was issued, never sent to the new server.
+    if (previous)
+        await ctx.api(previous.server ?? state.server).signOut(previous.token).catch(() => undefined);
+    if (server !== state.server || (previous && previous.email !== account.email)) {
+        // Another account's workspace and device do not apply; enabled agents keep their own access.
+        delete state.workspace;
+        delete state.device;
+    }
+    state.server = server;
+    state.session = { token, email: account.email, expiresAt: account.expiresAt, server };
+    saveState(state, stateEnv(ctx));
+    print(ctx);
+    print(ctx, `Signed in as ${s.bold(account.email)}. Next: ${s.bold("toolstile mcp setup")}`);
+    return 0;
+}
+export async function logout(ctx) {
+    const state = loadState(stateEnv(ctx));
+    if (!state.session) {
+        print(ctx, "Not signed in.");
+        return 0;
+    }
+    let reached = true;
+    await ctx
+        .api(state.session.server ?? state.server)
+        .signOut(state.session.token)
+        .catch((error) => {
+        // 401 means the session had already ended; anything else is worth saying.
+        if (!(error instanceof ApiError && error.status === 401))
+            reached = false;
+    });
+    delete state.session;
+    saveState(state, stateEnv(ctx));
+    print(ctx, reached ? "Signed out." : "Signed out on this machine. Toolstile could not be reached, so the session ends when it expires.");
+    const enabled = Object.keys(state.agents).length;
+    if (enabled)
+        print(ctx, ctx.style.dim(`${enabled === 1 ? "The agent" : `The ${enabled} agents`} you enabled keep working. To turn ${enabled === 1 ? "it" : "them"} off, run toolstile mcp setup while signed in, or delete this device in the Toolstile dashboard.`));
+    return 0;
+}
+function parseClients(list, flag) {
+    if (!list)
+        return [];
+    const ids = Object.keys(CLIENT_NAMES);
+    return list.split(",").map((raw) => {
+        const value = raw.trim().toLowerCase();
+        const match = ids.find((id) => id === value || CLIENT_NAMES[id].toLowerCase().replace(/\s+/g, "-") === value);
+        if (!match)
+            throw new UserError(`${flag}: unknown agent "${raw.trim()}". Use ${ids.join(", ")}.`);
+        return match;
+    });
+}
+async function chooseWorkspace(ctx, state, workspaces, wanted) {
+    if (wanted) {
+        const value = wanted.toLowerCase();
+        const match = workspaces.find((w) => w.slug === value || w.id === wanted || w.name.toLowerCase() === value);
+        if (!match)
+            throw new UserError(`No workspace "${wanted}". Yours: ${workspaces.map((w) => w.slug).join(", ")}.`);
+        return match;
+    }
+    const current = workspaces.find((w) => w.id === state.workspace?.id) ?? workspaces.find((w) => w.personal) ?? workspaces[0];
+    if (!current)
+        throw new UserError("Your account has no workspace yet. Open Toolstile in a browser once, then try again.");
+    if (workspaces.length === 1 || !interactive(ctx))
+        return current;
+    const picked = await checklist("Which workspace should this machine's agents use?", workspaces.map((w) => ({ label: w.name, hint: w.personal ? "personal" : w.slug, checked: w.id === current.id })), ctx.stdin, ctx.stdout, { single: true });
+    if (!picked)
+        throw new UserError("Cancelled; nothing changed.");
+    return workspaces[picked.indexOf(true)];
+}
+export async function setup(ctx, options) {
+    const s = ctx.style;
+    const state = loadState(stateEnv(ctx));
+    const session = state.session;
+    if (!session)
+        throw new UserError("Sign in first: toolstile auth login");
+    const api = ctx.api(session.server ?? state.server);
+    const account = await api.account(session.token).catch((error) => {
+        if (error instanceof ApiError && error.status === 401)
+            throw new UserError("Your sign-in has expired. Run toolstile auth login again.");
+        throw error;
+    });
+    const enable = parseClients(options.enable, "--enable");
+    const disable = parseClients(options.disable, "--disable");
+    const both = enable.find((c) => disable.includes(c));
+    if (both)
+        throw new UserError(`${CLIENT_NAMES[both]} is in both --enable and --disable.`);
+    const workspace = await chooseWorkspace(ctx, state, account.workspaces, options.workspace);
+    state.workspace = { id: workspace.id, slug: workspace.slug, name: workspace.name };
+    saveState(state, stateEnv(ctx));
+    /** Created (or renamed) only when something needs it, so listing changes nothing. */
+    let device;
+    const ensureDevice = async () => {
+        device ??= await api.device(session.token, {
+            workspaceId: workspace.id,
+            id: state.device?.id,
+            label: options.deviceName ?? state.device?.label ?? hostname().replace(/\.local$/, ""),
+            rename: options.deviceName !== undefined,
+        });
+        state.device = device;
+        saveState(state, stateEnv(ctx));
+        return device;
+    };
+    if (options.deviceName)
+        await ensureDevice();
+    // Agents deleted from the dashboard, or left in another workspace, are no longer enabled.
+    const remote = new Set(state.device ? (await api.agents(session.token, workspace.id, state.device.id)).agents.map((a) => a.id) : []);
+    const live = (client) => {
+        const link = state.agents[client];
+        return !!link && link.server === state.server && link.workspaceId === workspace.id && remote.has(link.id);
+    };
+    /** Removes an agent where it was created; links from another server are just dropped. */
+    const removeRemote = (link) => link.server === state.server
+        ? api.removeAgent(session.token, link.workspaceId, link.id).catch((error) => {
+            if (!(error instanceof ApiError && (error.status === 404 || error.status === 403)))
+                throw error;
+        })
+        : Promise.resolve();
+    const deviceLabel = state.device?.label ?? hostname().replace(/\.local$/, "");
+    const all = targets(ctx);
+    const shown = all.filter((t) => t.detected || live(t.client) || state.agents[t.client] || enable.includes(t.client));
+    if (!shown.length) {
+        print(ctx, "No supported agents found on this machine. Supported: " + all.map((t) => t.name).join(", ") + ".");
+        return 0;
+    }
+    let wanted;
+    if (enable.length || disable.length) {
+        wanted = new Set(all.filter((t) => live(t.client)).map((t) => t.client));
+        for (const c of enable)
+            wanted.add(c);
+        for (const c of disable)
+            wanted.delete(c);
+    }
+    else if (interactive(ctx)) {
+        print(ctx, `Signed in as ${account.email} · workspace ${s.bold(workspace.name)} · device ${s.bold(deviceLabel)}`);
+        const picked = await checklist("Which agents on this machine should use Toolstile?", shown.map((t) => ({
+            label: t.name,
+            hint: t.detected ? tildify(t.path, ctx.home) : "not found on this machine",
+            checked: live(t.client),
+        })), ctx.stdin, ctx.stdout);
+        if (!picked) {
+            print(ctx, "Cancelled; nothing changed.");
+            return 0;
+        }
+        wanted = new Set(shown.filter((_, i) => picked[i]).map((t) => t.client));
+    }
+    else {
+        print(ctx, `Workspace ${workspace.name} · device ${deviceLabel}`);
+        for (const t of shown)
+            print(ctx, `  ${live(t.client) ? "enabled " : "disabled"}  ${t.client.padEnd(14)} ${t.name}`);
+        print(ctx);
+        print(ctx, "Choose agents with --enable and --disable, for example: toolstile mcp setup --enable claude-code,codex");
+        return 0;
+    }
+    const manual = [];
+    const changes = [];
+    const replaced = [];
+    for (const target of all) {
+        const want = wanted.has(target.client);
+        const link = state.agents[target.client];
+        if (want) {
+            if (!live(target.client)) {
+                if (link)
+                    await removeRemote(link).catch(() => undefined);
+                const { id: deviceId } = await ensureDevice();
+                const created = await api.addAgent(session.token, { workspaceId: workspace.id, deviceId, label: target.name });
+                state.agents[target.client] = {
+                    id: created.id,
+                    workspaceId: workspace.id,
+                    server: state.server,
+                    label: created.label,
+                    token: created.token,
+                };
+                // Saved before touching the agent's config, so a token is never lost.
+                saveState(state, stateEnv(ctx));
+            }
+            try {
+                const result = writeEntry(target, proxyCommand(target.client, ctx.version, ctx.platform));
+                if (!live(target.client) || result !== "unchanged")
+                    changes.push(`${s.bold("+")} ${target.name}  ${s.dim(tildify(target.path, ctx.home))}`);
+                if (result === "replaced")
+                    replaced.push(target.name);
+            }
+            catch (error) {
+                if (!(error instanceof ManualEditError))
+                    throw error;
+                manual.push({ target, error, enable: true });
+            }
+        }
+        else if (link || isProxyEntry(readEntry(target))) {
+            try {
+                writeEntry(target, null);
+            }
+            catch (error) {
+                if (!(error instanceof ManualEditError))
+                    throw error;
+                manual.push({ target, error, enable: false });
+            }
+            if (link) {
+                await removeRemote(link);
+                delete state.agents[target.client];
+                saveState(state, stateEnv(ctx));
+            }
+            changes.push(`${s.bold("-")} ${target.name}`);
+        }
+    }
+    print(ctx);
+    if (changes.length) {
+        for (const line of changes)
+            print(ctx, line);
+        print(ctx);
+        print(ctx, "Restart agents that are running to pick up the change.");
+    }
+    else
+        print(ctx, "Nothing to change.");
+    if (replaced.length) {
+        print(ctx);
+        print(ctx, `Replaced an existing "toolstile" server in ${replaced.join(", ")}. If it signed in directly, remove that older agent under Devices & agents in the dashboard.`);
+    }
+    for (const { target, error, enable } of manual) {
+        print(ctx);
+        print(ctx, `${target.name}: ${tildify(target.path, ctx.home)} was not changed because ${error.message}.`);
+        if (enable) {
+            print(ctx, "Add this entry yourself:");
+            print(ctx, error.snippet.replace(/^/gm, "  "));
+        }
+        else
+            print(ctx, `Remove its "toolstile" server entry yourself.`);
+    }
+    if ([...wanted].length) {
+        print(ctx);
+        print(ctx, `Choose which MCP servers they can use: ${state.server}/app/${workspace.slug}/access`);
+    }
+    return manual.length ? 1 : 0;
+}
+export async function proxy(ctx, agent) {
+    const [client] = parseClients(agent, "--agent");
+    if (!client)
+        throw new UserError("--agent is required");
+    const state = loadState(stateEnv(ctx));
+    const link = state.agents[client];
+    if (!link)
+        throw new UserError(`${CLIENT_NAMES[client]} is not enabled on this machine. Run toolstile mcp setup.`);
+    await runProxy({
+        // The token goes only to the server that issued it, whatever the environment says.
+        endpoint: `${link.server}/mcp`,
+        token: link.token,
+        input: ctx.stdin,
+        output: ctx.stdout,
+        log: (message) => ctx.stderr.write(`toolstile: ${message}\n`),
+    });
+    return 0;
+}

package/dist/prompt.d.ts

@@ -0,0 +1,10 @@
+import type { ReadStream, WriteStream } from "node:tty";
+export interface Choice {
+    label: string;
+    hint?: string;
+    checked: boolean;
+}
+/** Terminal checklist: arrows (or j/k) move, space toggles, a toggles all, enter saves. */
+export declare function checklist(title: string, choices: Choice[], input: ReadStream, output: WriteStream, options?: {
+    single?: boolean;
+}): Promise<boolean[] | null>;

package/dist/prompt.js

@@ -0,0 +1,54 @@
+import { emitKeypressEvents } from "node:readline";
+/** Terminal checklist: arrows (or j/k) move, space toggles, a toggles all, enter saves. */
+export function checklist(title, choices, input, output, options = {}) {
+    const state = choices.map((c) => c.checked);
+    let cursor = Math.max(0, options.single ? state.indexOf(true) : 0);
+    let drawn = 0;
+    const help = options.single ? "↑/↓ move · enter select · esc cancel" : "↑/↓ move · space toggle · a all · enter save · esc cancel";
+    const render = () => {
+        if (drawn)
+            output.write(`\x1b[${drawn}A\x1b[0J`);
+        const lines = [
+            title,
+            ...choices.map((c, i) => {
+                const mark = options.single ? (i === cursor ? "●" : "○") : state[i] ? "◉" : "○";
+                const pointer = i === cursor ? "›" : " ";
+                return `${pointer} ${mark} ${c.label}${c.hint ? `  \x1b[2m${c.hint}\x1b[22m` : ""}`;
+            }),
+            `\x1b[2m${help}\x1b[22m`,
+        ];
+        output.write(`${lines.join("\n")}\n`);
+        drawn = lines.length;
+    };
+    return new Promise((resolve) => {
+        emitKeypressEvents(input);
+        const raw = input.isRaw;
+        input.setRawMode(true);
+        input.resume();
+        output.write("\x1b[?25l");
+        const finish = (value) => {
+            input.off("keypress", onKey);
+            input.setRawMode(raw);
+            input.pause();
+            output.write("\x1b[?25h");
+            resolve(value);
+        };
+        const onKey = (text, key = {}) => {
+            if ((key.ctrl && key.name === "c") || key.name === "escape")
+                return finish(null);
+            if (key.name === "up" || text === "k")
+                cursor = (cursor - 1 + choices.length) % choices.length;
+            else if (key.name === "down" || text === "j")
+                cursor = (cursor + 1) % choices.length;
+            else if (!options.single && (key.name === "space" || text === " "))
+                state[cursor] = !state[cursor];
+            else if (!options.single && text === "a")
+                state.fill(!state.every(Boolean));
+            else if (key.name === "return" || key.name === "enter")
+                return finish(options.single ? choices.map((_, i) => i === cursor) : state);
+            render();
+        };
+        input.on("keypress", onKey);
+        render();
+    });
+}

package/dist/proxy.d.ts

@@ -0,0 +1,15 @@
+import type { Readable, Writable } from "node:stream";
+/**
+ * Bridges an agent's stdio MCP connection to the Toolstile gateway's Streamable HTTP endpoint,
+ * so the agent's config holds a command instead of a credential. Messages pass through
+ * unchanged; only the transport differs.
+ */
+export interface ProxyOptions {
+    endpoint: string;
+    token: string;
+    input: Readable;
+    output: Writable;
+    log: (message: string) => void;
+    fetch?: typeof fetch;
+}
+export declare function runProxy(options: ProxyOptions): Promise<void>;

package/dist/proxy.js

@@ -0,0 +1,235 @@
+import { createInterface } from "node:readline";
+/** Yields each SSE event's data and id. */
+async function* events(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let data = [];
+    let id;
+    for await (const chunk of body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        let newline;
+        while ((newline = buffer.search(/\r?\n/)) !== -1) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(buffer[newline] === "\r" ? newline + 2 : newline + 1);
+            if (line === "") {
+                if (data.length)
+                    yield { data: data.join("\n"), id };
+                data = [];
+                continue;
+            }
+            if (line.startsWith(":"))
+                continue;
+            const colon = line.indexOf(":");
+            const field = colon === -1 ? line : line.slice(0, colon);
+            const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+            if (field === "data")
+                data.push(value);
+            else if (field === "id")
+                id = value;
+        }
+    }
+    if (data.length)
+        yield { data: data.join("\n"), id };
+}
+/** How long in-flight requests may finish after the agent closes stdin. */
+const CLOSE_GRACE_MS = 3000;
+export function runProxy(options) {
+    const fetcher = options.fetch ?? fetch;
+    let sessionId;
+    let protocolVersion;
+    /** The agent's own `initialize`, replayed if the gateway forgets the session. */
+    let opening;
+    let listening = false;
+    let closed = false;
+    /** Aborts every request and the listener's waits once the agent has gone. */
+    const shutdown = new AbortController();
+    const pending = new Set();
+    /** Later messages wait for `initialize`, so they carry the session it opens. */
+    let initialized = Promise.resolve();
+    const write = (message) => {
+        if (!options.output.writableEnded)
+            options.output.write(`${JSON.stringify(message)}\n`);
+    };
+    const headers = (extra = {}) => ({
+        Authorization: `Bearer ${options.token}`,
+        ...(sessionId ? { "Mcp-Session-Id": sessionId } : {}),
+        ...(protocolVersion ? { "Mcp-Protocol-Version": protocolVersion } : {}),
+        ...extra,
+    });
+    /** Never follow a redirect: the token is only for the gateway endpoint. */
+    const request = (init) => fetcher(options.endpoint, { ...init, redirect: "error", signal: shutdown.signal });
+    const post = (body) => request({
+        method: "POST",
+        headers: headers({ "Content-Type": "application/json", Accept: "application/json, text/event-stream" }),
+        body,
+    });
+    const explain = (status, text) => status === 401
+        ? "Toolstile no longer accepts this agent's access (removed from the dashboard?). Run `toolstile mcp setup` to enable it again."
+        : status === 403
+            ? `Toolstile refused this agent: ${text || "access denied"}`
+            : status === 429
+                ? "Toolstile is rate limiting this agent; try again shortly."
+                : `Toolstile returned ${status}${text ? `: ${text}` : ""}`;
+    const deliver = (message, answered) => {
+        if (message.id !== undefined && message.result && typeof message.result === "object") {
+            const version = message.result.protocolVersion;
+            if (typeof version === "string")
+                protocolVersion = version;
+        }
+        if (message.method === undefined && message.id !== undefined)
+            answered?.add(message.id);
+        write(message);
+    };
+    async function readBody(response, answered, quiet = false) {
+        const type = response.headers.get("content-type") ?? "";
+        const take = (message) => (quiet ? answered.add(message.id) : deliver(message, answered));
+        if (!response.body)
+            return;
+        if (type.includes("text/event-stream")) {
+            for await (const event of events(response.body)) {
+                try {
+                    take(JSON.parse(event.data));
+                }
+                catch {
+                    options.log("Ignored a malformed message from Toolstile.");
+                }
+            }
+            return;
+        }
+        if (type.includes("application/json")) {
+            const body = (await response.json());
+            for (const message of Array.isArray(body) ? body : [body])
+                take(message);
+        }
+    }
+    const wait = (ms) => new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        shutdown.signal.addEventListener("abort", () => (clearTimeout(timer), resolve()), { once: true });
+    });
+    /** Server-initiated messages (list changes, approvals) arrive on a long-lived GET stream. */
+    async function listen() {
+        if (listening || !sessionId)
+            return;
+        listening = true;
+        let lastEventId;
+        for (let attempt = 0; !closed && attempt < 8; attempt++) {
+            try {
+                const response = await request({
+                    method: "GET",
+                    headers: headers({ Accept: "text/event-stream", ...(lastEventId ? { "Last-Event-ID": lastEventId } : {}) }),
+                });
+                // 405: this server offers no stream; that is allowed.
+                if (response.status === 405 || !response.ok || !response.body)
+                    break;
+                attempt = 0;
+                for await (const event of events(response.body)) {
+                    if (event.id)
+                        lastEventId = event.id;
+                    try {
+                        deliver(JSON.parse(event.data));
+                    }
+                    catch { }
+                }
+            }
+            catch {
+                if (closed)
+                    break;
+            }
+            await wait(Math.min(30_000, 1000 * 2 ** attempt));
+        }
+        listening = false;
+    }
+    /**
+     * The gateway answers 404 for a session it no longer has (for example after a restart).
+     * Open a new one with the agent's original `initialize`, without showing its reply again.
+     */
+    async function reopen() {
+        if (!opening)
+            return false;
+        sessionId = undefined;
+        const response = await post(opening);
+        sessionId = response.headers.get("mcp-session-id") ?? undefined;
+        if (!response.ok)
+            return false;
+        await readBody(response, new Set(), true);
+        await post(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })).then((r) => r.body?.cancel());
+        void listen();
+        return true;
+    }
+    async function send(line) {
+        let messages;
+        try {
+            const parsed = JSON.parse(line);
+            messages = Array.isArray(parsed) ? parsed : [parsed];
+        }
+        catch {
+            write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+            return;
+        }
+        const requests = messages.filter((m) => m.method !== undefined && m.id !== undefined);
+        const answered = new Set();
+        const fail = (message) => {
+            for (const request of requests)
+                if (!answered.has(request.id))
+                    write({ jsonrpc: "2.0", id: request.id, error: { code: -32000, message } });
+        };
+        if (messages.some((m) => m.method === "initialize"))
+            opening = line;
+        try {
+            let response = await post(line);
+            if (response.status === 404 && sessionId && !messages.some((m) => m.method === "initialize")) {
+                await response.body?.cancel();
+                if (await reopen())
+                    response = await post(line);
+            }
+            const session = response.headers.get("mcp-session-id");
+            if (session)
+                sessionId = session;
+            if (!response.ok) {
+                const text = (await response.text().catch(() => "")).trim().slice(0, 300);
+                const message = explain(response.status, text);
+                options.log(message);
+                fail(message);
+                return;
+            }
+            await readBody(response, answered);
+            if (messages.some((m) => m.method === "notifications/initialized"))
+                void listen();
+            // A stream that ended early must still answer every request, or the agent waits forever.
+            fail("Toolstile closed the connection before answering. Try again.");
+        }
+        catch (error) {
+            if (closed)
+                return fail("The agent closed the connection.");
+            const message = `Could not reach Toolstile: ${error.message}`;
+            options.log(message);
+            fail(message);
+        }
+    }
+    return new Promise((resolve) => {
+        const lines = createInterface({ input: options.input, crlfDelay: Number.POSITIVE_INFINITY });
+        lines.on("line", (line) => {
+            if (!line.trim())
+                return;
+            const opens = /"method"\s*:\s*"initialize"/.test(line);
+            const task = (opens ? send(line) : initialized.then(() => send(line))).finally(() => pending.delete(task));
+            if (opens)
+                initialized = task;
+            pending.add(task);
+        });
+        lines.on("close", async () => {
+            // Let replies already on their way finish, but never hang on a long call or stream.
+            const grace = setTimeout(() => {
+                closed = true;
+                shutdown.abort();
+            }, CLOSE_GRACE_MS);
+            await Promise.allSettled([...pending]);
+            clearTimeout(grace);
+            closed = true;
+            shutdown.abort();
+            if (sessionId)
+                await fetcher(options.endpoint, { method: "DELETE", headers: headers(), redirect: "error" }).catch(() => undefined);
+            resolve();
+        });
+    });
+}

package/dist/sources.d.ts

@@ -7,6 +7,7 @@ export interface ScanOptions {
     env: Record<string, string | undefined>;
 }
 export declare const CLIENT_NAMES: Record<ClientId, string>;
+export declare function appData({ home, platform, env }: Omit<ScanOptions, "cwd">): string;
 /** Appends a key to a pointer, quoting keys that are not plain identifiers. */
 export declare function pointerJoin(base: string, key: string): string;
 /**

package/dist/sources.js

@@ -11,7 +11,7 @@ export const CLIENT_NAMES = {
     gemini: "Gemini CLI",
     cline: "Cline",
 };
-function appData({ home, platform, env }) {
+export function appData({ home, platform, env }) {
     if (platform === "darwin")
         return join(home, "Library", "Application Support");
     if (platform === "win32")