auvrynt 1.0.1 → 1.0.2

package/README.md

@@ -124,10 +124,15 @@ Keep it private.
 | Command | Description |
 |---|---|
 | `auvrynt init` | Run first-time setup or update your config |
-| `auvrynt start` | Start the server with clean animated output |
-| `auvrynt serve` | Start the server with verbose log output |
-| `auvrynt doctor` | Show your config, Node version, and dependency health |
-| `auvrynt config get` | Print your saved configuration |
+| `auvrynt start` | Start a Cloudflare tunnel scoped to the current directory |
+| `auvrynt serve` | Start the server with verbose log output |
+| `auvrynt doctor` | Show your config, Node version, and dependency health |
+| `auvrynt status` | Show local MCP, Blender, Godot, Cloudflare Tunnel, and Serena status |
+| `auvrynt connected` | Show recently observed ChatGPT, Kimi, Claude, or other MCP providers |
+| `auvrynt uninstall` | Remove Auvrynt configuration after confirmation |
+| `auvrynt uninstall -y` | Remove Auvrynt configuration without confirmation |
+| `auvrynt help` | Print the complete command reference |
+| `auvrynt config get` | Print your saved configuration |
 | `auvrynt config set publicBaseUrl <url>` | Update your public tunnel URL |
 
 **Override the tunnel URL for a one-off run:**

package/dist/cli.js

@@ -1,13 +1,19 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { stdin as input, stdout as output } from "node:process";
-import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, rmSync } from "node:fs";
+import { mkdir, open, readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { execFileSync, spawn } from "node:child_process";
 import * as prompts from "@clack/prompts";
 import { getShellConfig } from "@earendil-works/pi-coding-agent";
 import { satisfies } from "semver";
 import { loadConfig } from "./config.js";
 import { generateOwnerToken, loadAuvryntFiles, writeAuvryntAuth, writeAuvryntConfig, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
+import { discoverLocalIntegrations, processDetected } from "./integration-discovery.js";
+import { readConnectedClients } from "./connection-registry.js";
 const require = createRequire(import.meta.url);
 const SUPPORTED_NODE_RANGE = ">=20.12 <27";
 async function main(argv) {
@@ -16,11 +22,42 @@ async function main(argv) {
     const command = normalizeCommand(rawCommand);
     switch (command) {
         case "serve":
-            await ensureConfigured();
             if (rawCommand === "start") {
-                process.env.AUVRYNT_START_MODE = "true";
+                // `start` is intentionally directory-scoped: the launch directory is
+                // the only project root available to the web agent for this session.
+                const launchRoot = resolve(process.cwd());
+                process.env.AUVRYNT_ALLOWED_ROOTS = launchRoot;
+                process.env.AUVRYNT_WORKTREE_ROOT = launchRoot;
+            }
+            await ensureConfigured({ directoryScoped: rawCommand === "start" });
+            const localConfig = loadConfig();
+            const instanceLock = await acquireInstanceLock(localConfig.stateDir);
+            let tunnel;
+            let stopTunnel;
+            try {
+                if (rawCommand === "start") {
+                    process.env.AUVRYNT_START_MODE = "true";
+                    process.env.AUVRYNT_SERENA_ENABLED = "true";
+                    process.env.AUVRYNT_SERENA_EXECUTABLE = await ensureSerenaExecutable();
+                    tunnel = await startCloudflareTunnel(localConfig.port);
+                    process.env.AUVRYNT_PUBLIC_BASE_URL = tunnel.url;
+                    stopTunnel = () => {
+                        if (tunnel && !tunnel.process.killed)
+                            tunnel.process.kill();
+                    };
+                    process.once("SIGINT", stopTunnel);
+                    process.once("SIGTERM", stopTunnel);
+                }
+                await serve();
+            }
+            finally {
+                if (stopTunnel) {
+                    process.removeListener("SIGINT", stopTunnel);
+                    process.removeListener("SIGTERM", stopTunnel);
+                    stopTunnel();
+                }
+                await instanceLock.release();
             }
-            await serve();
             return;
         case "init":
             await runInit({ force: args.includes("--force") });
@@ -28,9 +65,21 @@ async function main(argv) {
         case "doctor":
             await runDoctor();
             return;
+        case "status":
+            await runStatus();
+            return;
+        case "connected":
+            runConnected();
+            return;
+        case "uninstall":
+            await runUninstall(args.includes("--yes") || args.includes("-y"));
+            return;
         case "config":
             runConfigCommand(args);
             return;
+        case "setup":
+            await runSetup();
+            return;
         case "help":
             printHelp();
             return;
@@ -41,16 +90,35 @@ function normalizeCommand(command) {
         return "serve";
     if (command === "init" || command === "doctor" || command === "config")
         return command;
+    if (command === "status" || command === "connected" || command === "uninstall")
+        return command;
+    if (command === "setup")
+        return "setup";
     if (command === "help" || command === "--help" || command === "-h")
         return "help";
     throw new Error(`Unknown command: ${command}`);
 }
-async function ensureConfigured() {
+async function ensureConfigured(options = {}) {
     const files = loadAuvryntFiles();
     if (files.configExists && files.authExists)
         return;
     if (process.env.AUVRYNT_OAUTH_OWNER_TOKEN)
         return;
+    if (options.directoryScoped) {
+        const launchRoot = resolve(process.cwd());
+        if (!files.configExists) {
+            writeAuvryntConfig({
+                host: files.config.host ?? "127.0.0.1",
+                port: files.config.port ?? 49321,
+                allowedRoots: [launchRoot],
+                publicBaseUrl: files.config.publicBaseUrl ?? `http://127.0.0.1:${files.config.port ?? 49321}`,
+            });
+        }
+        if (!files.authExists) {
+            writeAuvryntAuth({ ownerToken: generateOwnerToken() });
+        }
+        return;
+    }
     if (!input.isTTY || !output.isTTY) {
         throw new Error([
             "Auvrynt is not configured and this terminal is non-interactive.",
@@ -129,7 +197,7 @@ async function runInit({ force }) {
             "Use this when ChatGPT or Claude asks you to approve Auvrynt access.",
             `Stored at: ${authPath}`,
         ].join("\n"), "Owner password");
-        prompts.outro("Run `auvrynt serve` to start the MCP server.");
+        prompts.outro("Run `auvrynt start` to start the MCP server.");
     }
     catch (error) {
         if (error instanceof SetupCancelledError) {
@@ -159,51 +227,75 @@ async function serve() {
     const publicMcpUrl = config.publicBaseUrl
         ? `${config.publicBaseUrl.replace(/\/$/, "")}/mcp`
         : `http://${config.host}:${config.port}/mcp`;
-    const httpServer = app.listen(config.port, config.host, () => {
-        if (startMode) {
-            console.clear();
-            console.log("Auvrynt is running!");
-            console.log("");
-            console.log(`  Public URL:     \x1b[36m${publicMcpUrl}\x1b[0m`);
-            console.log(`  Owner Password: \x1b[33m${ownerToken}\x1b[0m`);
-            console.log("");
-            console.log("  # CTRL + C to stop");
-            console.log("");
-            const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-            let frameIndex = 0;
-            let mcpEventsCount = 0;
-            let lastEvent = "Started successfully";
-            global.auvryntLogEmitter = (level, event) => {
-                mcpEventsCount++;
-                lastEvent = `${event} (${level})`;
-            };
-            const interval = setInterval(() => {
-                const frame = frames[frameIndex];
-                frameIndex = (frameIndex + 1) % frames.length;
-                process.stdout.write(`\r\x1b[K  \x1b[32m${frame}\x1b[0m Logs active... (${mcpEventsCount} requests handled | Last: ${lastEvent})`);
-            }, 100);
-            global.auvryntStartInterval = interval;
-        }
-        else {
-            console.log(`auvrynt listening on http://${config.host}:${config.port}/mcp`);
-            console.log(`public base url: ${config.publicBaseUrl}`);
-            console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
-            console.log(`allowed hosts: ${config.allowedHosts.join(", ")}`);
-            if (config.allowedHosts.includes("*")) {
-                console.warn("warning: Host header allowlist is disabled because AUVRYNT_ALLOWED_HOSTS=*");
+    await new Promise((resolveServer, rejectServer) => {
+        const httpServer = app.listen(config.port, config.host, () => {
+            if (startMode) {
+                console.clear();
+                console.log("");
+                console.log("  \x1b[36m\x1b[1mAuvrynt: Webkit Arsenal is ready\x1b[0m");
+                console.log("");
+                console.log("  \x1b[90mClaude Web connector URL:\x1b[0m");
+                console.log("    \x1b[36m" + publicMcpUrl + "\x1b[0m");
+                console.log("");
+                console.log("  \x1b[90mAuthorization page:\x1b[0m");
+                console.log("    \x1b[36m" + config.publicBaseUrl.replace(/\/$/, "") + "/authorize\x1b[0m");
+                console.log("");
+                console.log("  \x1b[90mOwner token:\x1b[0m");
+                console.log("    \x1b[33m" + ownerToken + "\x1b[0m");
+                console.log("");
+                console.log("  \x1b[90mNote:\x1b[0m");
+                console.log("    Web-agent workspace: " + config.allowedRoots.join(", "));
+                console.log("    The Cloudflare URL is temporary.");
+                console.log("    Recreate or edit the web agent connector after restart.");
+                console.log("");
+                const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+                let frameIndex = 0;
+                let mcpEventsCount = 0;
+                let lastEvent = "Started successfully";
+                global.auvryntLogEmitter = (level, event) => {
+                    mcpEventsCount++;
+                    lastEvent = `${event} (${level})`;
+                };
+                const interval = setInterval(() => {
+                    const frame = frames[frameIndex];
+                    frameIndex = (frameIndex + 1) % frames.length;
+                    process.stdout.write(`\r\x1b[K  \x1b[32m${frame}\x1b[0m Logs active... (${mcpEventsCount} requests handled | Last: ${lastEvent})`);
+                }, 100);
+                global.auvryntStartInterval = interval;
             }
-            console.log("auth: Owner password approval required");
-            console.log(`logging: ${config.logging.level} ${config.logging.format}`);
-        }
+            else {
+                console.log(`auvrynt listening on http://${config.host}:${config.port}/mcp`);
+                console.log(`public base url: ${config.publicBaseUrl}`);
+                console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
+                console.log(`allowed hosts: ${config.allowedHosts.join(", ")}`);
+                if (config.allowedHosts.includes("*")) {
+                    console.warn("warning: Host header allowlist is disabled because AUVRYNT_ALLOWED_HOSTS=*");
+                }
+                console.log("auth: Owner password approval required");
+                console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+            }
+        });
+        const removeSignalHandlers = () => {
+            process.removeListener("SIGINT", shutdown);
+            process.removeListener("SIGTERM", shutdown);
+        };
+        const shutdown = () => {
+            if (global.auvryntStartInterval) {
+                clearInterval(global.auvryntStartInterval);
+                delete global.auvryntStartInterval;
+            }
+            httpServer.close(() => {
+                removeSignalHandlers();
+                resolveServer();
+            });
+        };
+        httpServer.once("error", (error) => {
+            removeSignalHandlers();
+            rejectServer(error);
+        });
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
     });
-    const shutdown = () => {
-        if (global.auvryntStartInterval) {
-            clearInterval(global.auvryntStartInterval);
-        }
-        httpServer.close(() => process.exit(0));
-    };
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
 }
 async function runDoctor() {
     const files = loadAuvryntFiles();
@@ -227,6 +319,236 @@ async function runDoctor() {
         console.log(`Config status: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+async function acquireInstanceLock(stateDir) {
+    const lockPath = join(stateDir, "server.lock");
+    await mkdir(stateDir, { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const handle = await open(lockPath, "wx");
+            await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
+            return { release: () => releaseInstanceLock(handle, lockPath) };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            let ownerPid;
+            try {
+                const lock = JSON.parse(await readFile(lockPath, "utf8"));
+                ownerPid = lock.pid;
+            }
+            catch {
+                // A partially written lock is treated as stale and retried once.
+            }
+            if (ownerPid && isProcessRunning(ownerPid)) {
+                throw new Error(`Auvrynt is already running (PID ${ownerPid}). Stop that instance before starting another.`);
+            }
+            await unlink(lockPath).catch((unlinkError) => {
+                if (unlinkError.code !== "ENOENT")
+                    throw unlinkError;
+            });
+        }
+    }
+    throw new Error("Could not acquire the Auvrynt server lock.");
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function releaseInstanceLock(handle, lockPath) {
+    await handle.close().catch(() => undefined);
+    await unlink(lockPath).catch(() => undefined);
+}
+async function startCloudflareTunnel(port) {
+    const executable = await resolveCloudflaredExecutable();
+    const child = spawn(executable, ["tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${port}`], {
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    const tunnelUrl = await new Promise((resolveUrl, reject) => {
+        let output = "";
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error("Cloudflare tunnel did not provide a public URL within 30 seconds."));
+        }, 30_000);
+        const onOutput = (chunk) => {
+            output += chunk.toString();
+            const match = output.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+            if (match) {
+                clearTimeout(timeout);
+                resolveUrl(match[0]);
+            }
+        };
+        child.stdout?.on("data", onOutput);
+        child.stderr?.on("data", onOutput);
+        child.once("error", (error) => {
+            clearTimeout(timeout);
+            reject(new Error(`Cloudflare tunnel failed to start: ${error.message}`));
+        });
+        child.once("exit", (code) => {
+            if (code !== null) {
+                clearTimeout(timeout);
+                reject(new Error(`Cloudflare tunnel exited before connecting (code ${code}).`));
+            }
+        });
+    });
+    return { process: child, url: tunnelUrl };
+}
+async function resolveCloudflaredExecutable() {
+    try {
+        return execFileSync(process.platform === "win32" ? "where.exe" : "which", ["cloudflared"], { encoding: "utf8" }).split(/\r?\n/)[0]?.trim() || "cloudflared";
+    }
+    catch {
+        if (process.platform === "win32") {
+            return installWindowsCloudflared();
+        }
+        throw new Error("cloudflared is required for `auvrynt start`. Install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/.");
+    }
+}
+function findCommand(command) {
+    try {
+        return execFileSync(process.platform === "win32" ? "where.exe" : "which", [command], { encoding: "utf8" }).split(/\r?\n/)[0]?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function ensureSerenaExecutable() {
+    const existing = findCommand("serena");
+    if (existing)
+        return existing;
+    const projectRoot = resolve(process.cwd());
+    const localCandidates = [
+        join(projectRoot, "serena"),
+        join(dirname(projectRoot), "serena"),
+        join(homedir(), "Desktop", "Projectsss", "serena"),
+    ];
+    const localSource = localCandidates.find((candidate) => existsSync(join(candidate, "pyproject.toml")));
+    const uv = await ensureUvExecutable();
+    console.log(localSource
+        ? `Serena is not installed; installing the local checkout from ${localSource}...`
+        : "Serena is not installed; installing the official Serena package...");
+    const installArgs = localSource
+        ? ["tool", "install", "--force", "--editable", localSource]
+        : ["tool", "install", "--force", "serena-agent"];
+    execFileSync(uv, installArgs, { stdio: "inherit" });
+    const installed = findCommand("serena") ?? findInstalledExecutable("serena");
+    if (!installed) {
+        throw new Error("Serena installed but its executable is not available. Restart PowerShell and run `where.exe serena`.");
+    }
+    return installed;
+}
+async function ensureUvExecutable() {
+    const existing = findCommand("uv");
+    if (existing)
+        return existing;
+    const python = findCommand("py") ?? findCommand("python");
+    if (!python) {
+        throw new Error("Serena requires uv, and Python was not found to install it automatically.");
+    }
+    console.log("uv is not installed; installing it for Serena...");
+    execFileSync(python, ["-m", "pip", "install", "--user", "uv"], { stdio: "inherit" });
+    const installed = findCommand("uv") ?? findInstalledExecutable("uv");
+    if (!installed) {
+        throw new Error("uv was installed but its executable is not available. Restart PowerShell and run `uv --version`.");
+    }
+    return installed;
+}
+function findInstalledExecutable(name) {
+    const executable = process.platform === "win32" ? `${name}.exe` : name;
+    const candidates = [
+        join(homedir(), ".local", "bin", executable),
+        join(process.env.LOCALAPPDATA ?? "", "uv", "bin", executable),
+        join(process.env.APPDATA ?? "", "uv", "bin", executable),
+        join(process.env.APPDATA ?? "", "Python", "Python313", "Scripts", executable),
+        join(process.env.APPDATA ?? "", "Python", "Python312", "Scripts", executable),
+    ];
+    return candidates.find((candidate) => candidate && existsSync(candidate));
+}
+async function installWindowsCloudflared() {
+    const targetDir = join(homedir(), ".auvrynt", "bin");
+    const executable = join(targetDir, "cloudflared.exe");
+    const artifact = process.arch === "arm64"
+        ? "cloudflared-windows-arm64.exe"
+        : process.arch === "ia32"
+            ? "cloudflared-windows-386.exe"
+            : "cloudflared-windows-amd64.exe";
+    const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/${artifact}`;
+    console.log("cloudflared is not installed; downloading the official Windows binary...");
+    const response = await fetch(downloadUrl, { signal: AbortSignal.timeout(120_000) });
+    if (!response.ok) {
+        throw new Error(`Could not download cloudflared (HTTP ${response.status}). Install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/.`);
+    }
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(executable, Buffer.from(await response.arrayBuffer()), { mode: 0o755 });
+    return executable;
+}
+async function runStatus() {
+    const files = loadAuvryntFiles();
+    const host = files.config.host ?? "127.0.0.1";
+    const port = files.config.port ?? 49321;
+    const healthUrl = `http://${host}:${port}/healthz`;
+    try {
+        const response = await fetch(healthUrl, { signal: AbortSignal.timeout(1500) });
+        const body = await response.json().catch(() => ({}));
+        console.log(`Local MCP: ${response.ok && body.ok ? "connected" : "error"}`);
+        console.log(`Health URL: ${healthUrl}`);
+    }
+    catch (error) {
+        console.log("Local MCP: disconnected");
+        console.log(`Health URL: ${healthUrl}`);
+        console.log(`Detail: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const local = await discoverLocalIntegrations();
+    console.log(`Blender MCP (9876): ${local.ports.blender_lab_mcp ? "connected" : processDetected(local, "blender") ? "running, MCP unavailable" : "not detected"}${local.executables.blender ? ` (${local.executables.blender})` : ""}`);
+    console.log(`Godot: ${local.ports.auvrynt_godot_bridge ? "Auvrynt bridge connected" : processDetected(local, "godot") ? "running, bridge unavailable" : "not detected"}${local.executables.godot ? ` (${local.executables.godot})` : ""}`);
+    if (local.executables.godotCsharp)
+        console.log(`Godot C#: configured (${local.executables.godotCsharp})`);
+    console.log(`Cloudflare Tunnel: ${processDetected(local, "cloudflare_tunnel") ? "running" : local.executables.cloudflared ? "installed, not running" : "not installed"}`);
+    console.log(`Serena: ${processDetected(local, "serena") ? "running" : local.executables.serena ? `installed (${local.executables.serena})` : "not installed"}`);
+}
+function stateDirForFiles(files) {
+    return resolve(expandHomePath(files.config.stateDir ?? join(homedir(), ".local", "share", "auvrynt")));
+}
+function runConnected() {
+    const clients = readConnectedClients(stateDirForFiles(loadAuvryntFiles()));
+    console.log("Connected web agents:");
+    if (clients.length === 0) {
+        console.log("  none recorded yet");
+        return;
+    }
+    for (const client of clients) {
+        console.log(`  ${client.provider} — ${client.requestCount} request(s), last seen ${client.lastSeen}`);
+        if (client.userAgent)
+            console.log(`    user-agent: ${client.userAgent}`);
+    }
+}
+async function runUninstall(skipConfirmation) {
+    const files = loadAuvryntFiles();
+    if (!skipConfirmation) {
+        if (!input.isTTY || !output.isTTY) {
+            throw new Error("Uninstall is destructive in a non-interactive terminal. Re-run with `auvrynt uninstall --yes`.");
+        }
+        const answer = await prompts.confirm({ message: `Remove Auvrynt configuration from ${files.dir}?`, initialValue: false });
+        if (prompts.isCancel(answer) || !answer) {
+            console.log("Uninstall cancelled.");
+            return;
+        }
+    }
+    if (files.configExists || files.authExists) {
+        rmSync(files.dir, { recursive: true, force: true });
+        console.log(`Removed Auvrynt configuration: ${files.dir}`);
+    }
+    else {
+        console.log("Auvrynt configuration was already absent.");
+    }
+    console.log("The npm CLI package remains installed. Remove it with: npm uninstall -g auvrynt");
+    console.log("Custom state/worktree directories were preserved.");
+}
 function runConfigCommand(args) {
     const [subcommand, key, ...rest] = args;
     const files = loadAuvryntFiles();
@@ -256,17 +578,106 @@ function printHelp() {
         "",
         "Usage:",
         "  auvrynt                 Run first-time setup if needed, then start the server",
-        "  auvrynt start           Start the server with an animated logs indicator (clean UI)",
+        "  auvrynt start           Start a Cloudflare tunnel scoped to the current directory",
         "  auvrynt serve           Start the server with verbose console logs",
         "  auvrynt init            Create or update ~/.auvrynt/config.json and auth.json",
+        "  auvrynt setup           Configure tool integrations (Serena, Godot, Blender...)",
         "  auvrynt doctor          Show config, runtime, and native dependency status",
+        "  auvrynt status          Show local MCP and integration connection status",
+        "  auvrynt connected       Show recently connected MCP/web-agent providers",
+        "  auvrynt uninstall       Remove Auvrynt configuration after confirmation",
+        "  auvrynt uninstall -y    Remove Auvrynt configuration without confirmation",
         "  auvrynt config get      Print persisted config",
         "  auvrynt config set publicBaseUrl <url|null>",
         "",
         "For temporary tunnels:",
-        "  AUVRYNT_PUBLIC_BASE_URL=https://example.trycloudflare.com auvrynt serve",
+        "  AUVRYNT_PUBLIC_BASE_URL=https://example.trycloudflare.com auvrynt start",
     ].join("\n"));
 }
+// ─── auvrynt setup ────────────────────────────────────────────────────────────
+const SETUP_TOOL_LABELS = {
+    serena: "Serena       - semantic code search / code intelligence",
+    godot: "Godot        - GDScript game engine",
+    godotCsharp: "Godot C#     - .NET / Mono Godot build",
+    blender: "Blender      - 3D modelling and rendering",
+};
+const SETUP_TOOL_KEYS = ["serena", "godot", "godotCsharp", "blender"];
+async function runSetup() {
+    prompts.intro("  Auvrynt Setup - configure local tool integrations  ");
+    const files = loadAuvryntFiles();
+    const existingExecs = files.config.executables ?? {};
+    // 1. Pick which tools to configure
+    const picked = await prompts.multiselect({
+        message: "Select tools to configure  (arrows navigate, space select, enter confirm)",
+        options: SETUP_TOOL_KEYS.map((key) => ({
+            value: key,
+            label: SETUP_TOOL_LABELS[key],
+            hint: existingExecs[key] ? `currently: ${existingExecs[key]}` : undefined,
+        })),
+        required: false,
+    });
+    if (prompts.isCancel(picked)) {
+        prompts.cancel("Setup cancelled.");
+        return;
+    }
+    const selection = picked;
+    if (selection.length === 0) {
+        prompts.outro("Nothing selected - no changes made.");
+        return;
+    }
+    // 2. Prompt for executable path for each selected tool
+    const updated = { ...existingExecs };
+    for (const key of selection) {
+        const label = SETUP_TOOL_LABELS[key].split(" - ")[0].trim();
+        let placeholder;
+        switch (key) {
+            case "serena":
+                placeholder = "e.g. C:\\tools\\serena.exe  or just  serena  if on PATH";
+                break;
+            case "godot":
+                placeholder = "e.g. C:\\Program Files\\Godot\\Godot.exe";
+                break;
+            case "godotCsharp":
+                placeholder = "e.g. C:\\Program Files\\Godot_v4-mono\\Godot.exe  (.NET build)";
+                break;
+            case "blender":
+                placeholder = "e.g. C:\\Program Files\\Blender Foundation\\Blender 4.3\\blender.exe";
+                break;
+            default:
+                placeholder = "";
+        }
+        const answer = await prompts.text({
+            message: ` executable path`,
+            placeholder,
+            initialValue: existingExecs[key] ?? "",
+            validate: (val) => {
+                if (!(val ?? "").trim())
+                    return "Path cannot be empty.";
+                return undefined;
+            },
+        });
+        if (prompts.isCancel(answer)) {
+            prompts.cancel("Setup cancelled.");
+            return;
+        }
+        updated[key] = answer.trim();
+    }
+    // 3. Persist to ~/.auvrynt/config.json
+    writeAuvryntConfig({
+        ...files.config,
+        executables: {
+            serena: updated.serena,
+            godot: updated.godot,
+            godotCsharp: updated.godotCsharp,
+            blender: updated.blender,
+        },
+    });
+    // 4. Show summary
+    prompts.note(selection
+        .map((key) => ` -> `)
+        .join("\n"), "Saved to ~/.auvrynt/config.json");
+    prompts.outro("Setup complete. Run `auvrynt status` to verify.");
+}
 function normalizeOptionalPublicBaseUrl(value) {
     const trimmed = value.trim();
     if (!trimmed || trimmed === "null" || trimmed === "none")