toolstile 0.1.1 → 0.2.0

package/dist/parse.js

@@ -1,5 +1,24 @@
-import { parse as parseToml } from "smol-toml";
-/** Parses JSON that may contain comments and trailing commas (VS Code style). */
+import { parse as parseToml, TomlError } from "smol-toml";
+/**
+ * A config file that could not be parsed. The message is fixed text plus a position: parser
+ * messages quote the offending source line, which can hold a secret, so they are never kept.
+ */
+export class ConfigParseError extends Error {
+    format;
+    line;
+    column;
+    constructor(format, line, column) {
+        super(`invalid ${format}${line ? ` at line ${line}${column ? `, column ${column}` : ""}` : ""}`);
+        this.format = format;
+        this.line = line;
+        this.column = column;
+        this.name = "ConfigParseError";
+    }
+}
+/**
+ * Parses JSON that may contain comments and trailing commas (VS Code style). Comments and
+ * trailing commas become spaces so parser positions still match the original text.
+ */
 export function parseJsonc(text) {
     let out = "";
     let inString = false;
@@ -22,15 +41,19 @@ export function parseJsonc(text) {
             out += ch;
         }
         else if (ch === "/" && next === "/") {
-            while (i < text.length && text[i] !== "\n")
+            while (i < text.length && text[i] !== "\n") {
+                out += blank(text[i]);
                 i++;
-            out += "\n";
+            }
+            if (i < text.length)
+                out += "\n";
         }
         else if (ch === "/" && next === "*") {
-            i += 2;
-            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
-                i++;
-            i++;
+            const end = text.indexOf("*/", i + 2);
+            const stop = end === -1 ? text.length : end + 2;
+            for (; i < stop; i++)
+                out += blank(text[i]);
+            i--;
         }
         else {
             out += ch;
@@ -38,6 +61,8 @@ export function parseJsonc(text) {
     }
     return JSON.parse(stripTrailingCommas(out));
 }
+/** Keeps line breaks so line numbers survive; everything else becomes a space. */
+const blank = (ch) => (ch === "\n" || ch === "\r" ? ch : " ");
 function stripTrailingCommas(text) {
     let out = "";
     let inString = false;
@@ -60,17 +85,51 @@ function stripTrailingCommas(text) {
             let j = i + 1;
             while (j < text.length && /\s/.test(text[j]))
                 j++;
-            if (text[j] === "}" || text[j] === "]")
+            if (text[j] === "}" || text[j] === "]") {
+                out += " ";
                 continue;
+            }
         }
         out += ch;
     }
     return out;
 }
+/** 1-based line and column of a character offset. */
+function lineColumn(text, offset) {
+    const before = text.slice(0, Math.min(Math.max(offset, 0), text.length));
+    const lastBreak = before.lastIndexOf("\n");
+    return { line: before.split("\n").length, column: offset - lastBreak };
+}
+/** Reads only the position from a V8 JSON error; the rest of its message may quote the file. */
+function jsonPosition(error, text) {
+    const message = error instanceof Error ? error.message : "";
+    const at = /\bposition (\d+)/.exec(message);
+    if (at)
+        return lineColumn(text, Number(at[1]));
+    if (/Unexpected end of JSON input/.test(message))
+        return lineColumn(text, text.length);
+    return {};
+}
+/** Parses a config file. Throws only {@link ConfigParseError}, whose message never contains file text. */
 export function parseConfig(path, text) {
-    if (path.endsWith(".toml"))
-        return parseToml(text);
-    if (text.trim() === "")
+    const body = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    if (path.endsWith(".toml")) {
+        try {
+            return parseToml(body);
+        }
+        catch (error) {
+            if (error instanceof TomlError)
+                throw new ConfigParseError("TOML", error.line, error.column);
+            throw new ConfigParseError("TOML");
+        }
+    }
+    if (body.trim() === "")
         return {};
-    return parseJsonc(text);
+    try {
+        return parseJsonc(body);
+    }
+    catch (error) {
+        const { line, column } = jsonPosition(error, body);
+        throw new ConfigParseError("JSON", line, column);
+    }
 }

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/report.js

@@ -60,7 +60,7 @@ export function renderReport(r, home, s, redacted = false) {
     const clientList = r.clients.map((c) => CLIENT_NAMES[c]).join(", ");
     lines.push(`Scanned ${plural(r.files.length, "file")} from ${clientList}: ${plural(r.servers, "MCP server")}.`);
     for (const u of r.unreadable) {
-        lines.push(s.dim(`Skipped ${tildify(u.path, home)} (${CLIENT_NAMES[u.client]}): could not parse it.`));
+        lines.push(s.dim(`Skipped ${tildify(u.path, home)} (${CLIENT_NAMES[u.client]}): ${u.error}.`));
     }
     lines.push("");
     if (r.grade !== null) {

package/dist/secrets.js

@@ -28,9 +28,9 @@ const PATTERNS = [
     [/\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/, "JWT"],
     [/\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s@/]{3,}@/i, "password in connection string"],
 ];
-const SECRET_KEY = /(token|secret|passw(or)?d|passwd|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|credential|auth|bearer|session|cookie|\bpat\b|_pat$|^pat_)/i;
-/** Key suffixes that name configuration about a secret rather than the secret itself. */
-const NOT_SECRET_KEY = /(url|uri|endpoint|host|port|path|file|dir|type|mode|enabled|header|name|user(name)?|id|region|scope|scopes|method|env_var|_var)$/i;
+const SECRET_KEY = /(token|secret|passw(or)?d|passwd|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|credential|auth|bearer|session|cookie|\bpat\b|_pat$|^pat_|(^|[_-])key$)/i;
+/** Key suffixes that name configuration about a secret, or a public half, rather than the secret itself. */
+const NOT_SECRET_KEY = /(url|uri|endpoint|host|port|path|file|dir|type|mode|enabled|header|name|user(name)?|id|region|scope|scopes|method|env_var|_var|public[_-]?key)$/i;
 const PLACEHOLDER = /^(<.*>|\{.*\}|\[.*\]|x{4,}|\*{3,}|\.{3,}|your[-_ ].*|change[-_ ]?me|todo|placeholder|example|redacted|none|null|undefined|true|false|test|secret|token)$/i;
 /** True for `${VAR}`, `${env:VAR}`, `$VAR`, `%VAR%` and `{env:VAR}` references. */
 export function isReference(value) {

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

@@ -1,6 +1,6 @@
 import { readFileSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { parseConfig } from "./parse.js";
+import { ConfigParseError, parseConfig } from "./parse.js";
 export const CLIENT_NAMES = {
     "claude-code": "Claude Code",
     "claude-desktop": "Claude Desktop",
@@ -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")
@@ -149,6 +149,14 @@ function ancestorModes(path) {
         dir = parent;
     }
 }
+/** A fixed description of a read failure; system messages are not passed through. */
+function readError(code) {
+    if (code === "EACCES" || code === "EPERM")
+        return "permission denied";
+    if (code === "EISDIR")
+        return "is a directory";
+    return code && /^E[A-Z]+$/.test(code) ? `could not read it (${code})` : "could not read it";
+}
 export function discover(opts) {
     const result = { files: [], unreadable: [], servers: [], approvals: [] };
     for (const c of candidates(opts)) {
@@ -161,7 +169,12 @@ export function discover(opts) {
             mode = opts.platform === "win32" ? undefined : stat.mode & 0o777;
             text = readFileSync(c.path, "utf8");
         }
-        catch {
+        catch (error) {
+            const code = error.code;
+            // Absent files are normal; anything else means a config exists that we could not check.
+            if (code !== "ENOENT" && code !== "ENOTDIR") {
+                result.unreadable.push({ client: c.client, path: c.path, error: readError(code) });
+            }
             continue;
         }
         let data;
@@ -169,7 +182,9 @@ export function discover(opts) {
             data = parseConfig(c.path, text);
         }
         catch (error) {
-            result.unreadable.push({ client: c.client, path: c.path, error: error.message });
+            // parseConfig's messages are fixed text plus a position, never file contents.
+            const message = error instanceof ConfigParseError ? error.message : "could not parse it";
+            result.unreadable.push({ client: c.client, path: c.path, error: message });
             continue;
         }
         const exposure = mode === undefined ? undefined : exposureOf(mode, ancestorModes(c.path));

package/dist/state.d.ts

@@ -0,0 +1,48 @@
+import type { ClientId } from "./types.js";
+export declare const DEFAULT_SERVER = "https://toolstile.com";
+export interface AgentLink {
+    /** The agent's authorization ID in Toolstile, valid in one workspace. */
+    id: string;
+    workspaceId: string;
+    /** The Toolstile origin that issued the token; the proxy sends it nowhere else. */
+    server: string;
+    label: string;
+    /** The agent's own gateway token; only `toolstile mcp proxy` reads it. */
+    token: string;
+}
+/** Everything `auth` and `mcp` keep on this machine, in one owner-only file. */
+export interface State {
+    /** The origin `auth login` last signed in to. */
+    server: string;
+    session?: {
+        token: string;
+        email: string;
+        expiresAt: string;
+        server: string;
+    };
+    workspace?: {
+        id: string;
+        slug: string;
+        name: string;
+    };
+    device?: {
+        id: string;
+        label: string;
+    };
+    agents: Partial<Record<ClientId, AgentLink>>;
+}
+export interface StateEnv {
+    home?: string;
+    env?: Record<string, string | undefined>;
+    platform?: NodeJS.Platform;
+}
+/** `TOOLSTILE_CONFIG_DIR`, else the platform's per-user config folder. */
+export declare function stateDir({ home, env, platform }?: StateEnv): string;
+export declare const statePath: (opts?: StateEnv) => string;
+/**
+ * The saved server always wins over `TOOLSTILE_URL`, which only picks the server for a new
+ * `auth login`: an environment variable set by a project must not redirect saved tokens.
+ */
+export declare function loadState(opts?: StateEnv): State;
+/** Written to a temporary file and renamed, so a crash never leaves half a file. */
+export declare function saveState(state: State, opts?: StateEnv): void;

package/dist/state.js

@@ -0,0 +1,51 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const DEFAULT_SERVER = "https://toolstile.com";
+/** `TOOLSTILE_CONFIG_DIR`, else the platform's per-user config folder. */
+export function stateDir({ home = homedir(), env = process.env, platform = process.platform } = {}) {
+    if (env.TOOLSTILE_CONFIG_DIR)
+        return env.TOOLSTILE_CONFIG_DIR;
+    if (platform === "win32")
+        return join(env.APPDATA ?? join(home, "AppData", "Roaming"), "toolstile");
+    return join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "toolstile");
+}
+export const statePath = (opts) => join(stateDir(opts), "credentials.json");
+/**
+ * The saved server always wins over `TOOLSTILE_URL`, which only picks the server for a new
+ * `auth login`: an environment variable set by a project must not redirect saved tokens.
+ */
+export function loadState(opts) {
+    const fallback = { server: DEFAULT_SERVER, agents: {} };
+    let text;
+    try {
+        text = readFileSync(statePath(opts), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return fallback;
+        throw error;
+    }
+    try {
+        const data = JSON.parse(text);
+        return { ...fallback, ...data, agents: data.agents ?? {} };
+    }
+    catch {
+        throw new Error(`${statePath(opts)} is not valid JSON. Delete it and run toolstile auth login again.`);
+    }
+}
+/** Written to a temporary file and renamed, so a crash never leaves half a file. */
+export function saveState(state, opts) {
+    const dir = stateDir(opts);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const path = statePath(opts);
+    const temp = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+        chmodSync(temp, 0o600);
+        renameSync(temp, path);
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+}

package/dist/types.d.ts

@@ -55,7 +55,10 @@ export interface AuditResult {
         client: ClientId;
         path: string;
     }[];
-    /** Files that exist but could not be parsed. */
+    /**
+     * Files that exist but could not be read or parsed. `error` is a fixed description with at most
+     * a line and column, for example `invalid TOML at line 3, column 12`; it never quotes the file.
+     */
     unreadable: {
         client: ClientId;
         path: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "toolstile",
-  "version": "0.1.1",
-  "description": "Audit the MCP server configs your AI agents use for plaintext secrets, unpinned packages, auto-approved tools and duplicated setups. Local and read-only.",
+  "version": "0.2.0",
+  "description": "Audit the MCP server configs your AI agents use for plaintext secrets, unpinned packages, auto-approved tools and duplicated setups, and connect those agents to Toolstile without putting tokens in their configs.",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -10,7 +10,9 @@
     "claude",
     "cursor",
     "codex",
-    "secrets"
+    "secrets",
+    "mcp-proxy",
+    "device-login"
   ],
   "homepage": "https://github.com/toolstile/cli#readme",
   "repository": {
@@ -37,8 +39,8 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "prepublishOnly": "pnpm typecheck && pnpm build && pnpm test"
+    "test": "pnpm build && vitest run",
+    "prepublishOnly": "pnpm typecheck && pnpm test"
   },
   "dependencies": {
     "smol-toml": "^1.9.1"