toolstile 0.1.2 → 0.2.0

package/README.md

@@ -38,15 +38,16 @@ HIGH   Plaintext secret in github (Cursor)
        Fix: Reference an environment variable instead (for example ${API_TOKEN}) …
 ```
 
-## It only reads
+## The audit only reads
 
 - Reads config files on your machine. Writes nothing unless you ask for a card.
-- Makes no network requests and collects no telemetry.
+- Makes no network requests and collects no telemetry. (Only the separate
+  `auth` and `mcp` commands below talk to Toolstile, and only when you run them.)
 - Never prints, stores or sends secret values. Findings name the file and key,
   for example `mcpServers.github.env.GITHUB_TOKEN`, and the kind of secret.
 - Never quotes a config file: one that cannot be read or parsed is listed with a
   reason and position only, for example `invalid TOML at line 3, column 12`.
-- About 1,400 lines of TypeScript with one runtime dependency
+- About 2,500 lines of TypeScript with one runtime dependency
   ([smol-toml](https://github.com/squirrelchat/smol-toml), for Codex's TOML
   config) and an optional one ([resvg-js](https://github.com/thx/resvg-js), only
   to render `--card` as PNG). Read it before you run it.
@@ -106,6 +107,59 @@ values) and prints a ready-to-post link. To post the text report instead, add
 | Gemini CLI | `~/.gemini/settings.json` | `.gemini/settings.json` |
 | Cline | `cline_mcp_settings.json` in VS Code or Cursor storage | |
 
+## Connect your agents to Toolstile
+
+If you use [Toolstile](https://toolstile.com), the CLI can also sign in and set
+up the agents on a machine for you:
+
+```sh
+npx toolstile auth login
+npx toolstile mcp setup
+```
+
+`auth login` prints a link and a code. Open the link on any device with a
+browser (your laptop or phone), sign in and approve the code. Nothing has to
+reach the machine you are signing in, so it works over SSH, in containers and on
+servers without a browser.
+
+`mcp setup` lists the agents it finds (Claude Code, Claude Desktop, Cursor,
+Codex, VS Code, Windsurf, Gemini CLI, Cline) and lets you turn each one on or
+off. Run it again any time to change the selection. Each enabled agent appears
+under this machine in the Toolstile dashboard with its own access, so you can
+grant, limit or revoke it there; then choose which MCP servers it can use.
+
+```text
+Which agents on this machine should use Toolstile?
+› ◉ Claude Code  ~/.claude.json
+  ○ Cursor  ~/.cursor/mcp.json
+  ◉ Codex  ~/.codex/config.toml
+↑/↓ move · space toggle · a all · enter save · esc cancel
+```
+
+Without a terminal, pass the choice as flags:
+`npx toolstile mcp setup --enable claude-code,codex --disable cursor`.
+
+How it stays out of your configs: an enabled agent's config gets a `toolstile`
+server that runs `npx -y toolstile@<version> mcp proxy --agent <agent>`. The proxy
+relays the agent's MCP messages to Toolstile using that agent's own token, which
+lives only in the CLI's credentials file (`~/.config/toolstile/credentials.json`,
+readable by you alone; `%APPDATA%\toolstile` on Windows). No token is written
+into the agent's config, so `toolstile audit` has nothing to flag. JSON configs
+with comments are not rewritten; setup prints the entry to add yourself.
+
+`npx toolstile auth logout` ends the CLI's sign-in. Agents you enabled keep
+working until you turn them off with `mcp setup` or delete the device in the
+dashboard.
+
+| Option | Command | Meaning |
+| --- | --- | --- |
+| `--server <url>` | `auth login` | Toolstile address (default `https://toolstile.com`, or `TOOLSTILE_URL`) |
+| `--no-browser` | `auth login` | Do not try to open a browser on this machine |
+| `--enable <agents>` | `mcp setup` | Turn these on without prompting (comma-separated) |
+| `--disable <agents>` | `mcp setup` | Turn these off without prompting |
+| `--workspace <slug>` | `mcp setup` | Workspace the agents use (default: the last one, or personal) |
+| `--device-name <name>` | `mcp setup` | Name for this machine in the dashboard (default: its hostname) |
+
 ## Use it from code
 
 ```ts

package/dist/agents.d.ts

@@ -0,0 +1,43 @@
+import type { ClientId } from "./types.js";
+/** The server name `toolstile mcp setup` adds to each agent's config. */
+export declare const ENTRY = "toolstile";
+type Format = "mcpServers" | "vscode" | "codex";
+export interface Target {
+    client: ClientId;
+    name: string;
+    /** User-level config file that gets the entry. */
+    path: string;
+    format: Format;
+    /** Whether the app looks installed: its config file or folder exists. */
+    detected: boolean;
+}
+export interface TargetEnv {
+    home: string;
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+}
+export declare function targets(opts: TargetEnv): Target[];
+/** How the agent starts the proxy. Pinned, so the config runs the version that wrote it. */
+export declare function proxyCommand(client: ClientId, version: string, platform: NodeJS.Platform): {
+    command: string;
+    args: string[];
+};
+/** A config entry for a different, hand-written `toolstile` server is left alone. */
+export declare function isProxyEntry(value: unknown): boolean;
+export declare class ManualEditError extends Error {
+    readonly target: Target;
+    readonly snippet: string;
+    constructor(target: Target, reason: string, snippet: string);
+}
+/** The current entry, if the agent's config has one. */
+export declare function readEntry(target: Target): unknown;
+/**
+ * Adds (or, with `command` null, removes) the `toolstile` entry. JSON files with comments are
+ * not rewritten, since that would drop the comments; the caller shows the snippet instead.
+ */
+export type WriteResult = "added" | "updated" | "replaced" | "removed" | "unchanged";
+export declare function writeEntry(target: Target, command: {
+    command: string;
+    args: string[];
+} | null): WriteResult;
+export {};

package/dist/agents.js

@@ -0,0 +1,192 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { parseJsonc } from "./parse.js";
+import { appData, CLIENT_NAMES } from "./sources.js";
+/** The server name `toolstile mcp setup` adds to each agent's config. */
+export const ENTRY = "toolstile";
+export function targets(opts) {
+    const { home, env } = opts;
+    const data = appData(opts);
+    const codexHome = env.CODEX_HOME ?? join(home, ".codex");
+    const code = ["Code", "Code - Insiders"].map((edition) => join(data, edition, "User")).find((dir) => existsSync(dir)) ??
+        join(data, "Code", "User");
+    const cline = join(code, "globalStorage", "saoudrizwan.claude-dev");
+    const list = [
+        ["claude-code", join(home, ".claude.json"), "mcpServers", join(home, ".claude")],
+        ["claude-desktop", join(data, "Claude", "claude_desktop_config.json"), "mcpServers", join(data, "Claude")],
+        ["cursor", join(home, ".cursor", "mcp.json"), "mcpServers", join(home, ".cursor")],
+        ["codex", join(codexHome, "config.toml"), "codex", codexHome],
+        ["vscode", join(code, "mcp.json"), "vscode", code],
+        ["windsurf", join(home, ".codeium", "windsurf", "mcp_config.json"), "mcpServers", join(home, ".codeium", "windsurf")],
+        ["gemini", join(home, ".gemini", "settings.json"), "mcpServers", join(home, ".gemini")],
+        ["cline", join(cline, "settings", "cline_mcp_settings.json"), "mcpServers", cline],
+    ];
+    return list.map(([client, path, format, folder]) => ({
+        client,
+        name: CLIENT_NAMES[client],
+        path,
+        format,
+        detected: existsSync(path) || existsSync(folder),
+    }));
+}
+/** How the agent starts the proxy. Pinned, so the config runs the version that wrote it. */
+export function proxyCommand(client, version, platform) {
+    const args = ["-y", `toolstile@${version}`, "mcp", "proxy", "--agent", client];
+    // Windows apps start commands without a shell, and npx is a .cmd script there.
+    return platform === "win32" ? { command: "cmd", args: ["/c", "npx", ...args] } : { command: "npx", args };
+}
+/** A config entry for a different, hand-written `toolstile` server is left alone. */
+export function isProxyEntry(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const args = value.args;
+    return Array.isArray(args) && args.some((a) => typeof a === "string" && /^toolstile(@|$)/.test(a)) &&
+        args.includes("proxy");
+}
+export class ManualEditError extends Error {
+    target;
+    snippet;
+    constructor(target, reason, snippet) {
+        super(reason);
+        this.target = target;
+        this.snippet = snippet;
+        this.name = "ManualEditError";
+    }
+}
+function readText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+/** Replaces the file in one step and keeps its permission bits; a symlink keeps pointing at it. */
+function writeText(link, text) {
+    let path = link;
+    let mode = 0o600;
+    try {
+        path = realpathSync(link);
+        mode = statSync(path).mode & 0o777;
+    }
+    catch {
+        mkdirSync(dirname(path), { recursive: true });
+    }
+    const temp = `${path}.toolstile-${process.pid}.tmp`;
+    try {
+        writeFileSync(temp, text, { mode });
+        chmodSync(temp, mode);
+        renameSync(temp, path);
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+}
+const serversKey = (format) => (format === "vscode" ? "servers" : "mcpServers");
+function jsonEntry(target, command) {
+    return target.format === "vscode" || target.client === "claude-code" ? { type: "stdio", ...command } : command;
+}
+function tomlEntry(command) {
+    return `[mcp_servers.${ENTRY}]\ncommand = ${JSON.stringify(command.command)}\nargs = [${command.args.map((a) => JSON.stringify(a)).join(", ")}]\n`;
+}
+/** Drops `[mcp_servers.toolstile]` and its sub-tables, keeping every other line and comment. */
+function withoutTomlEntry(text) {
+    const lines = text.split("\n");
+    const out = [];
+    let skipping = false;
+    for (const line of lines) {
+        const header = line.match(/^\s*\[\s*([^\]]+?)\s*\]\s*(#.*)?$/)?.[1];
+        if (header !== undefined) {
+            const name = header.replace(/\s+/g, "").replace(/"/g, "");
+            skipping = name === `mcp_servers.${ENTRY}` || name.startsWith(`mcp_servers.${ENTRY}.`);
+        }
+        if (!skipping)
+            out.push(line);
+    }
+    return out.join("\n").replace(/\n{3,}$/, "\n\n");
+}
+/** The current entry, if the agent's config has one. */
+export function readEntry(target) {
+    const text = readText(target.path);
+    if (!text?.trim())
+        return undefined;
+    try {
+        if (target.format === "codex") {
+            const servers = parseToml(text).mcp_servers;
+            return servers?.[ENTRY];
+        }
+        const data = parseJsonc(text);
+        return data?.[serversKey(target.format)]?.[ENTRY];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `replaced` means a hand-written `toolstile` server (not the proxy) was swapped out. */
+const outcome = (command, existing) => !command ? "removed" : existing === undefined ? "added" : isProxyEntry(existing) ? "updated" : "replaced";
+export function writeEntry(target, command) {
+    const text = readText(target.path) ?? "";
+    if (target.format === "codex") {
+        let current;
+        try {
+            current = parseToml(text).mcp_servers;
+        }
+        catch {
+            throw new ManualEditError(target, "its TOML could not be parsed", command ? tomlEntry(command) : "");
+        }
+        const existing = current?.[ENTRY];
+        if (!command && (existing === undefined || !isProxyEntry(existing)))
+            return "unchanged";
+        let next = withoutTomlEntry(text);
+        if (command)
+            next = `${next.replace(/\s*$/, "")}${next.trim() ? "\n\n" : ""}${tomlEntry(command)}`;
+        let parsed;
+        try {
+            parsed = parseToml(next).mcp_servers?.[ENTRY];
+        }
+        catch {
+            parsed = null;
+        }
+        if (command ? !isProxyEntry(parsed) : parsed !== undefined)
+            throw new ManualEditError(target, "its toolstile server is written in a form setup cannot edit", command ? tomlEntry(command) : "");
+        if (next === text)
+            return "unchanged";
+        writeText(target.path, next);
+        return outcome(command, existing);
+    }
+    const key = serversKey(target.format);
+    const entry = command ? jsonEntry(target, command) : undefined;
+    const snippet = entry ? JSON.stringify({ [key]: { [ENTRY]: entry } }, null, 2) : "";
+    let data;
+    try {
+        data = text.trim() ? parseJsonc(text) : {};
+    }
+    catch {
+        throw new ManualEditError(target, "its JSON could not be parsed", snippet);
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        throw new ManualEditError(target, "it is not a JSON object", snippet);
+    const object = data;
+    const servers = (typeof object[key] === "object" && object[key] !== null ? object[key] : {});
+    const existing = servers[ENTRY];
+    if (entry ? JSON.stringify(existing) === JSON.stringify(entry) : existing === undefined || !isProxyEntry(existing))
+        return "unchanged";
+    // Rewriting would drop comments and trailing commas, so such files are left to the user.
+    try {
+        JSON.parse(text || "{}");
+    }
+    catch {
+        throw new ManualEditError(target, "it contains comments", snippet);
+    }
+    if (entry)
+        servers[ENTRY] = entry;
+    else
+        delete servers[ENTRY];
+    object[key] = servers;
+    const indent = text.match(/\n([ \t]+)"/)?.[1] ?? "  ";
+    writeText(target.path, `${JSON.stringify(object, null, indent)}\n`);
+    return outcome(entry, existing);
+}

package/dist/api.d.ts

@@ -0,0 +1,64 @@
+export declare const CLIENT_ID = "toolstile-cli";
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, message: string, code?: string | undefined);
+}
+export interface Workspace {
+    id: string;
+    slug: string;
+    name: string;
+    personal: boolean;
+}
+export interface Account {
+    email: string;
+    name: string;
+    expiresAt: string;
+    workspaces: Workspace[];
+}
+export interface DeviceCode {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    expires_in: number;
+    interval: number;
+}
+type Fetch = typeof fetch;
+/** The Toolstile endpoints the CLI uses. Session calls carry the device-flow session token. */
+export declare function createApi(server: string, fetcher?: Fetch): {
+    deviceCode: () => Promise<DeviceCode>;
+    deviceToken: (deviceCode: string) => Promise<{
+        access_token: string;
+        expires_in: number;
+    }>;
+    account: (token: string) => Promise<Account>;
+    signOut: (token: string) => Promise<void>;
+    device: (token: string, input: {
+        workspaceId: string;
+        id?: string;
+        label: string;
+        rename?: boolean;
+    }) => Promise<{
+        id: string;
+        label: string;
+    }>;
+    agents: (token: string, workspaceId: string, deviceId: string) => Promise<{
+        agents: {
+            id: string;
+            label: string;
+        }[];
+    }>;
+    addAgent: (token: string, input: {
+        workspaceId: string;
+        deviceId: string;
+        label: string;
+    }) => Promise<{
+        id: string;
+        label: string;
+        token: string;
+    }>;
+    removeAgent: (token: string, workspaceId: string, id: string) => Promise<void>;
+};
+export type Api = ReturnType<typeof createApi>;
+export {};

package/dist/api.js

@@ -0,0 +1,61 @@
+export const CLIENT_ID = "toolstile-cli";
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ApiError";
+    }
+}
+async function request(fetcher, url, init = {}) {
+    let response;
+    try {
+        response = await fetcher(url, {
+            ...init,
+            // Never follow a redirect with a session token to another address.
+            redirect: "error",
+            headers: { "Content-Type": "application/json", Accept: "application/json", ...init.headers },
+        });
+    }
+    catch {
+        throw new ApiError(0, `Could not reach ${new URL(url).origin}. Check your connection.`);
+    }
+    if (response.status === 204)
+        return undefined;
+    const body = (await response.json().catch(() => null));
+    if (!response.ok) {
+        const message = body?.error_description ?? body?.message;
+        throw new ApiError(response.status, typeof message === "string" ? message : `Request failed (${response.status})`, typeof body?.error === "string" ? body.error : undefined);
+    }
+    return body;
+}
+/** The Toolstile endpoints the CLI uses. Session calls carry the device-flow session token. */
+export function createApi(server, fetcher = fetch) {
+    const base = server.replace(/\/+$/, "");
+    const session = (token, init = {}) => ({
+        ...init,
+        headers: { ...init.headers, Authorization: `Bearer ${token}` },
+    });
+    return {
+        deviceCode: () => request(fetcher, `${base}/api/auth/device/code`, {
+            method: "POST",
+            body: JSON.stringify({ client_id: CLIENT_ID }),
+        }),
+        deviceToken: (deviceCode) => request(fetcher, `${base}/api/auth/device/token`, {
+            method: "POST",
+            body: JSON.stringify({
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                device_code: deviceCode,
+                client_id: CLIENT_ID,
+            }),
+        }),
+        account: (token) => request(fetcher, `${base}/api/cli/account`, session(token)),
+        signOut: (token) => request(fetcher, `${base}/api/cli/sign-out`, session(token, { method: "POST" })),
+        device: (token, input) => request(fetcher, `${base}/api/cli/device`, session(token, { method: "POST", body: JSON.stringify(input) })),
+        agents: (token, workspaceId, deviceId) => request(fetcher, `${base}/api/cli/agents?${new URLSearchParams({ workspaceId, deviceId })}`, session(token)),
+        addAgent: (token, input) => request(fetcher, `${base}/api/cli/agents`, session(token, { method: "POST", body: JSON.stringify(input) })),
+        removeAgent: (token, workspaceId, id) => request(fetcher, `${base}/api/cli/agents/${encodeURIComponent(id)}?${new URLSearchParams({ workspaceId })}`, session(token, { method: "DELETE" })),
+    };
+}

package/dist/checks.js

@@ -202,8 +202,8 @@ function broadRoots(s, home) {
         .filter((a) => a === "/" || /^[A-Za-z]:\\?$/.test(a) || homes.has(a) || homes.has(a.replace(/\/+$/, "")));
 }
 const SEVERITY_ORDER = { high: 0, medium: 1, low: 2, info: 3 };
-/** Toolstile's own gateway is meant to be added to every client. */
-const TOOLSTILE = /^url:([a-z0-9-]+\.)*toolstile\.com\//i;
+/** Toolstile's own gateway, directly or through `toolstile mcp proxy`, is meant to be added to every client. */
+const TOOLSTILE = /^(url:([a-z0-9-]+\.)*toolstile\.com\/|npm:toolstile$)/i;
 /** A path for a shell command: `~/...` under the home folder, single-quoted when needed. */
 export function shellPath(path, home) {
     const quote = (p) => (/^[\w@%+=:,./-]+$/.test(p) ? p : `'${p.replace(/'/g, "'\\''")}'`);

package/dist/cli.js

@@ -2,10 +2,24 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { createApi } from "./api.js";
 import { renderCard, shareText, shareUrl } from "./card.js";
+import { login, logout, proxy, setup, UserError } from "./commands.js";
 import { audit } from "./index.js";
 import { redact, renderJson, renderReport, style } from "./report.js";
-const HELP = `toolstile: audit the MCP server configs your AI agents use
+const HELP = `toolstile: audit your MCP configs and connect your agents to Toolstile
+
+Usage
+  npx toolstile audit [options]     Check local MCP configs (offline, read-only)
+  npx toolstile auth login          Sign in, from any machine, with a code
+  npx toolstile auth logout         Sign out on this machine
+  npx toolstile mcp setup           Choose which agents here use Toolstile
+
+Run toolstile <command> --help for a command's options.
+  -h, --help          Show this help
+  -v, --version       Show the version
+`;
+const AUDIT_HELP = `toolstile audit: check the MCP server configs your AI agents use
 
 Usage
   npx toolstile audit [options]
@@ -26,8 +40,40 @@ Options
   --project <dir>     Also scan project configs in <dir> (default: current directory)
   --no-project        Scan only user-level configs
   --fail-on <level>   Exit with code 1 if any finding is at or above high, medium or low
-  -h, --help          Show this help
-  -v, --version       Show the version
+`;
+const AUTH_HELP = `toolstile auth: sign the CLI in to Toolstile
+
+Usage
+  npx toolstile auth login [--server <url>] [--no-browser]
+  npx toolstile auth logout
+
+login prints a link and a code. Open the link on any device with a browser
+(your laptop, your phone), sign in and approve the code. Nothing has to
+reach this machine, so it works over SSH and on servers without a browser.
+
+Options
+  --server <url>      Toolstile address (default https://toolstile.com, or TOOLSTILE_URL)
+  --no-browser        Do not try to open a browser on this machine
+`;
+const MCP_HELP = `toolstile mcp: connect the agents on this machine to Toolstile
+
+Usage
+  npx toolstile mcp setup [options]
+  npx toolstile mcp proxy --agent <agent>
+
+setup lists the agents found here and lets you turn each one on or off.
+Each enabled agent gets its own access, shown under this device in the
+Toolstile dashboard. Its config runs \`toolstile mcp proxy\`, which holds the
+agent's token in the CLI's own owner-only credentials file, so no secret
+is written into the agent's config.
+
+Options for setup
+  --enable <agents>     Turn these on without prompting (comma-separated)
+  --disable <agents>    Turn these off without prompting
+  --workspace <slug>    Workspace the agents use (default: the last one, or personal)
+  --device-name <name>  Name for this machine (default: its hostname)
+
+Agents: claude-code, claude-desktop, cursor, codex, vscode, windsurf, gemini, cline
 `;
 function version() {
     const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -111,17 +157,102 @@ async function writeCard(path, svg) {
     }
 }
 const RANK = { high: 3, medium: 2, low: 1, info: 0 };
+/** `--name value`, `--name=value` and boolean `--name` flags for the auth and mcp commands. */
+function parseFlags(argv, valued, booleans) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-h" || a === "--help")
+            return "help";
+        const eq = a.indexOf("=");
+        const name = a.startsWith("--") ? (eq === -1 ? a.slice(2) : a.slice(2, eq)) : "";
+        if (valued.includes(name)) {
+            const v = eq === -1 ? argv[++i] : a.slice(eq + 1);
+            if (v === undefined || v.startsWith("-"))
+                throw new UserError(`--${name} needs a value`);
+            flags[name] = v;
+        }
+        else if (booleans.includes(name) && eq === -1)
+            flags[name] = true;
+        else
+            throw new UserError(`Unknown option: ${a}`);
+    }
+    return flags;
+}
+async function command(argv) {
+    const [group, action, ...rest] = argv;
+    const help = group === "auth" ? AUTH_HELP : MCP_HELP;
+    const actions = group === "auth" ? ["login", "logout"] : ["setup", "proxy"];
+    if (!action || action === "-h" || action === "--help" || action === "help") {
+        process.stdout.write(help);
+        return action ? 0 : 2;
+    }
+    if (!actions.includes(action)) {
+        process.stderr.write(`Unknown command: toolstile ${group} ${action}\n\n${help}`);
+        return 2;
+    }
+    const color = process.stdout.isTTY === true && !process.env.NO_COLOR;
+    const ctx = {
+        home: homedir(),
+        platform: process.platform,
+        env: process.env,
+        version: version(),
+        api: (server) => createApi(server),
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        // The proxy's stdout carries MCP messages, so nothing else may be printed there.
+        style: style(action !== "proxy" && color),
+    };
+    try {
+        const flags = action === "login"
+            ? parseFlags(rest, ["server"], ["no-browser"])
+            : action === "logout"
+                ? parseFlags(rest, [], [])
+                : action === "setup"
+                    ? parseFlags(rest, ["enable", "disable", "workspace", "device-name"], [])
+                    : parseFlags(rest, ["agent"], []);
+        if (flags === "help") {
+            process.stdout.write(help);
+            return 0;
+        }
+        const value = (name) => (typeof flags[name] === "string" ? flags[name] : undefined);
+        if (action === "login")
+            return await login(ctx, { server: value("server"), browser: !flags["no-browser"] });
+        if (action === "logout")
+            return await logout(ctx);
+        if (action === "setup")
+            return await setup(ctx, {
+                enable: value("enable"),
+                disable: value("disable"),
+                workspace: value("workspace"),
+                deviceName: value("device-name"),
+            });
+        return await proxy(ctx, value("agent"));
+    }
+    catch (error) {
+        if (error instanceof UserError || error.name === "ApiError") {
+            process.stderr.write(`toolstile: ${error.message}\n`);
+            return 1;
+        }
+        throw error;
+    }
+}
 async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === "auth" || argv[0] === "mcp")
+        return command(argv);
+    const help = argv[0] === "audit" ? AUDIT_HELP : HELP;
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (error) {
-        process.stderr.write(`${error.message}\n\n${HELP}`);
+        process.stderr.write(`${error.message}\n\n${help}`);
         return 2;
     }
     if (args === "help") {
-        process.stdout.write(HELP);
+        process.stdout.write(help);
         return 0;
     }
     if (args === "version") {

package/dist/commands.d.ts

@@ -0,0 +1,37 @@
+import { type Api } from "./api.js";
+import { type Style } from "./report.js";
+export interface Context {
+    home: string;
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+    version: string;
+    api: (server: string) => Api;
+    stdin: NodeJS.ReadableStream & {
+        isTTY?: boolean;
+    };
+    stdout: NodeJS.WritableStream & {
+        isTTY?: boolean;
+    };
+    stderr: NodeJS.WritableStream;
+    style: Style;
+    sleep?: (ms: number) => Promise<void>;
+    openBrowser?: (url: string) => void;
+}
+/** A failure explained to the user; exits 1 without a stack trace. */
+export declare class UserError extends Error {
+}
+/** HTTPS, except a loopback server for local development. */
+export declare function normalizeServer(value: string): string;
+export declare function login(ctx: Context, options: {
+    server?: string;
+    browser: boolean;
+}): Promise<number>;
+export declare function logout(ctx: Context): Promise<number>;
+export interface SetupOptions {
+    enable?: string;
+    disable?: string;
+    workspace?: string;
+    deviceName?: string;
+}
+export declare function setup(ctx: Context, options: SetupOptions): Promise<number>;
+export declare function proxy(ctx: Context, agent: string | undefined): Promise<number>;