auvrynt 1.0.2 → 1.0.5

package/dist/cli/commands/tunnel-command.js

@@ -0,0 +1,127 @@
+import * as prompts from "@clack/prompts";
+import { resolve } from "node:path";
+import { normalizeNgrokUrl, tunnelProviderLabel } from "../../tunnels/tunnel-utils.js";
+import { loadAuvryntFiles, writeAuvryntAuth, writeAuvryntConfig } from "../../user-config.js";
+export async function runTunnelCommand(dependencies) {
+    const files = loadAuvryntFiles();
+    const current = files.config.tunnelProvider ?? "cloudflare";
+    prompts.intro("  Auvrynt tunnel provider  ");
+    const picked = await prompts.select({
+        message: `Select a tunnel provider  (current: ${tunnelProviderLabel(current)})`,
+        options: [
+            { value: "0", label: "0. Exit", hint: "make no changes" },
+            { value: "1", label: "1. Cloudflare (CDN tunnel)", hint: current === "cloudflare" ? "current" : undefined },
+            { value: "2", label: "2. ngrok", hint: current === "ngrok" ? "current" : undefined },
+            { value: "3", label: "3. Custom external URL", hint: current === "custom" ? "current" : "for Cloudflare Named Tunnel or another external proxy" },
+        ],
+    });
+    if (prompts.isCancel(picked) || picked === "0") {
+        prompts.cancel("No changes made.");
+        return;
+    }
+    const provider = picked === "2" ? "ngrok" : picked === "3" ? "custom" : "cloudflare";
+    let publicBaseUrl = files.config.publicBaseUrl;
+    let ngrokAuthtoken = files.config.ngrokAuthtoken;
+    let ngrokUrl = files.config.ngrokUrl;
+    let cloudflareTunnelToken = files.auth.cloudflareTunnelToken;
+    if (provider === "custom") {
+        const answer = await prompts.text({
+            message: "Cloudflare Named Tunnel token (leave blank to manage the tunnel externally)",
+            placeholder: "paste the tunnel token from Cloudflare, or press Enter to skip",
+            initialValue: "",
+        });
+        if (prompts.isCancel(answer)) {
+            prompts.cancel("Tunnel setup cancelled.");
+            return;
+        }
+        const trimmed = String(answer).trim();
+        if (trimmed)
+            cloudflareTunnelToken = trimmed;
+    }
+    if (provider === "ngrok" && !ngrokAuthtoken && !process.env.AUVRYNT_NGROK_AUTHTOKEN) {
+        const answer = await prompts.text({
+            message: "ngrok authtoken (leave blank if already set via `ngrok config add-authtoken`)",
+            placeholder: "paste your ngrok authtoken, or press Enter to skip",
+        });
+        if (prompts.isCancel(answer)) {
+            prompts.cancel("Tunnel setup cancelled.");
+            return;
+        }
+        const trimmed = String(answer).trim();
+        if (trimmed)
+            ngrokAuthtoken = trimmed;
+    }
+    if (provider === "ngrok") {
+        const answer = await prompts.text({
+            message: "Stable ngrok HTTPS URL (optional; leave blank for an assigned URL)",
+            placeholder: "https://your-name.ngrok.app",
+            initialValue: ngrokUrl ?? "",
+            validate: (value) => {
+                try {
+                    normalizeNgrokUrl(String(value));
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : String(error);
+                }
+            },
+        });
+        if (prompts.isCancel(answer)) {
+            prompts.cancel("Tunnel setup cancelled.");
+            return;
+        }
+        ngrokUrl = normalizeNgrokUrl(String(answer));
+    }
+    if (provider === "custom") {
+        const answer = await prompts.text({
+            message: "External HTTPS base URL (without /mcp)",
+            placeholder: "https://mcp.example.com",
+            initialValue: publicBaseUrl ?? "",
+            validate: (value) => {
+                try {
+                    const parsed = new URL(String(value).trim());
+                    if (parsed.protocol !== "https:")
+                        return "Custom public URL must use HTTPS.";
+                    if (parsed.pathname !== "/" || parsed.search || parsed.hash)
+                        return "Enter the origin only, without /mcp or another path.";
+                    return undefined;
+                }
+                catch {
+                    return "Enter a valid HTTPS URL.";
+                }
+            },
+        });
+        if (prompts.isCancel(answer)) {
+            prompts.cancel("Tunnel setup cancelled.");
+            return;
+        }
+        publicBaseUrl = new URL(String(answer).trim()).origin;
+    }
+    const nextConfig = { ...files.config, tunnelProvider: provider, publicBaseUrl };
+    if (ngrokAuthtoken)
+        nextConfig.ngrokAuthtoken = ngrokAuthtoken;
+    else
+        delete nextConfig.ngrokAuthtoken;
+    if (ngrokUrl)
+        nextConfig.ngrokUrl = ngrokUrl;
+    else
+        delete nextConfig.ngrokUrl;
+    writeAuvryntConfig(nextConfig);
+    writeAuvryntAuth({ ...files.auth, ...(cloudflareTunnelToken ? { cloudflareTunnelToken } : {}) });
+    prompts.note(`Tunnel provider set to ${tunnelProviderLabel(provider)}.`, "Saved to ~/.auvrynt/config.json");
+    const active = await dependencies.readActiveInstance();
+    if (active) {
+        const restart = await prompts.confirm({
+            message: "Auvrynt is currently running. Restart it now to switch the live tunnel?",
+            initialValue: true,
+        });
+        if (!prompts.isCancel(restart) && restart) {
+            await dependencies.restart({ replace: true, backgroundChild: false }, active.record.launchRoot ?? resolve(process.cwd()), true);
+            prompts.outro(`Restarted with the ${tunnelProviderLabel(provider)} tunnel.`);
+            return;
+        }
+        prompts.outro("Run `auvrynt restart hard` when you're ready to apply this.");
+        return;
+    }
+    prompts.outro("Run `auvrynt start` to launch with the new tunnel provider.");
+}

package/dist/cli/commands/user-config-commands.js

@@ -0,0 +1,105 @@
+import * as prompts from "@clack/prompts";
+import { rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { stdin, stdout } from "node:process";
+import { readConnectedClients } from "../../connection-registry.js";
+import { expandHomePath } from "../../roots.js";
+import { generateOwnerToken, loadAuvryntFiles, writeAuvryntAuth, writeAuvryntConfig, } from "../../user-config.js";
+import { printConsolePanel } from "../runtime-support.js";
+function stateDirForFiles(files) {
+    return resolve(expandHomePath(files.config.stateDir ?? join(homedir(), ".local", "share", "auvrynt")));
+}
+function normalizePublicBaseUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("Public base URL must use http:// or https://.");
+    if (url.username || url.password)
+        throw new Error("Public base URL must not contain credentials.");
+    if (url.search || url.hash)
+        throw new Error("Public base URL must not contain a query string or fragment.");
+    if (url.pathname !== "/")
+        throw new Error("Public base URL must be an origin only, without a path such as /mcp.");
+    if (url.protocol === "http:" && !["localhost", "127.0.0.1", "::1"].includes(url.hostname)) {
+        throw new Error("Public base URL must use HTTPS unless it targets localhost/loopback.");
+    }
+    return url.origin;
+}
+function normalizeOptionalPublicBaseUrl(value) {
+    if (["null", "none", "clear"].includes(value.toLowerCase()))
+        return null;
+    return normalizePublicBaseUrl(value);
+}
+export function runTokenCommand(args) {
+    const files = loadAuvryntFiles();
+    const [subcommand] = args;
+    if (subcommand === "reset") {
+        if (process.env.AUVRYNT_OAUTH_OWNER_TOKEN?.trim()) {
+            throw new Error("Cannot reset the persisted token while AUVRYNT_OAUTH_OWNER_TOKEN is set. Remove that environment variable first.");
+        }
+        const token = generateOwnerToken();
+        writeAuvryntAuth({ ownerToken: token });
+        rmSync(join(stateDirForFiles(files), "oauth-state.json"), { force: true });
+        printConsolePanel("Owner token reset", [{ label: "Token", value: token }], "Apply it: auvrynt restart");
+        return;
+    }
+    if (subcommand)
+        throw new Error("Usage: auvrynt token [reset]");
+    const token = process.env.AUVRYNT_OAUTH_OWNER_TOKEN?.trim() || files.auth.ownerToken?.trim();
+    if (!token)
+        throw new Error("Owner token is not configured. Run `auvrynt init` first.");
+    console.log(token);
+}
+export function runConnectedCommand() {
+    const clients = readConnectedClients(stateDirForFiles(loadAuvryntFiles()));
+    if (clients.length === 0) {
+        printConsolePanel("Connected web agents", [{ label: "Status", value: "None recorded yet" }]);
+        return;
+    }
+    const rows = clients.flatMap((client) => [
+        { label: client.provider, value: `${client.requestCount} request(s), last seen ${client.lastSeen}` },
+        ...(client.userAgent ? [{ label: "User agent", value: client.userAgent }] : []),
+    ]);
+    printConsolePanel("Connected web agents", rows);
+}
+export async function runUninstallCommand(skipConfirmation) {
+    const files = loadAuvryntFiles();
+    if (!skipConfirmation) {
+        if (!stdin.isTTY || !stdout.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) {
+            printConsolePanel("Auvrynt uninstall cancelled");
+            return;
+        }
+    }
+    if (files.configExists || files.authExists) {
+        rmSync(files.dir, { recursive: true, force: true });
+        printConsolePanel("Auvrynt configuration removed", [
+            { label: "Removed", value: files.dir },
+            { label: "Preserved", value: "npm package and custom state/worktree directories" },
+        ], "Remove CLI: npm uninstall -g auvrynt");
+    }
+    else {
+        printConsolePanel("Auvrynt configuration", [{ label: "Status", value: "Already absent" }]);
+    }
+}
+export function runConfigCommand(args) {
+    const [subcommand, key, ...rest] = args;
+    const files = loadAuvryntFiles();
+    if (!subcommand || subcommand === "get") {
+        console.log(JSON.stringify(files.config, null, 2));
+        return;
+    }
+    if (subcommand !== "set")
+        throw new Error(`Unknown config command: ${subcommand}`);
+    if (key !== "publicBaseUrl") {
+        throw new Error("Only `auvrynt config set publicBaseUrl <url|null>` is supported right now.");
+    }
+    const value = rest.join(" ").trim();
+    if (!value)
+        throw new Error("Missing publicBaseUrl value.");
+    writeAuvryntConfig({ ...files.config, publicBaseUrl: normalizeOptionalPublicBaseUrl(value) });
+    console.log(`Updated ${files.configPath}`);
+}