note-connector 0.1.0

package/dist/net.d.ts

@@ -0,0 +1,7 @@
+/** Ports commonly used by LocalAnt — note-connector never binds these. */
+export declare const RESERVED_PORTS: number[];
+/**
+ * Pick a free port for note-connector, never using RESERVED_PORTS.
+ * Scans upward from `preferred` (default 8797).
+ */
+export declare function resolveGatewayPort(preferred: number, host?: string, attempts?: number): Promise<number>;

package/dist/net.js

@@ -0,0 +1,34 @@
+import net from "node:net";
+/** Ports commonly used by LocalAnt — note-connector never binds these. */
+export const RESERVED_PORTS = [8787, 8788];
+function isPortFree(port, host) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once("error", () => resolve(false));
+        server.once("listening", () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, host);
+    });
+}
+/**
+ * Pick a free port for note-connector, never using RESERVED_PORTS.
+ * Scans upward from `preferred` (default 8797).
+ */
+export async function resolveGatewayPort(preferred, host = "127.0.0.1", attempts = 50) {
+    const skip = new Set(RESERVED_PORTS);
+    let start = preferred;
+    if (skip.has(start)) {
+        start = Math.max(...RESERVED_PORTS) + 1;
+    }
+    for (let i = 0; i < attempts; i++) {
+        const port = start + i;
+        if (port > 65535)
+            break;
+        if (skip.has(port))
+            continue;
+        if (await isPortFree(port, host))
+            return port;
+    }
+    throw new Error(`No free port found from ${start} on ${host} (avoiding ${[...skip].join(", ")}).`);
+}

package/dist/net.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/net.test.js

@@ -0,0 +1,11 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { RESERVED_PORTS, resolveGatewayPort } from "./net.js";
+test("RESERVED_PORTS includes LocalAnt gateway", () => {
+    assert.ok(RESERVED_PORTS.includes(8787));
+});
+test("resolveGatewayPort returns a free port", async () => {
+    const port = await resolveGatewayPort(8797);
+    assert.ok(port >= 8797);
+    assert.ok(!RESERVED_PORTS.includes(port));
+});

package/dist/note-auth.d.ts

@@ -0,0 +1,3 @@
+export declare function isNoteAuthenticated(): boolean;
+/** Start Playwright note login in background (does not block). */
+export declare function startNoteLoginInBackground(): void;

package/dist/note-auth.js

@@ -0,0 +1,28 @@
+import { execFileSync, spawn } from "node:child_process";
+import { repoRootFromPackage } from "./paths.js";
+export function isNoteAuthenticated() {
+    const root = repoRootFromPackage();
+    try {
+        execFileSync("uv", [
+            "run",
+            "python",
+            "-c",
+            "from note_mcp.auth.session import SessionManager; import sys; sys.exit(0 if SessionManager().has_session() else 1)",
+        ], { cwd: root, stdio: "ignore", timeout: 60_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Start Playwright note login in background (does not block). */
+export function startNoteLoginInBackground() {
+    const root = repoRootFromPackage();
+    const child = spawn("uv", ["run", "python", "-m", "note_mcp.chatgpt.login_once"], {
+        cwd: root,
+        stdio: "inherit",
+        detached: true,
+        shell: false,
+    });
+    child.unref();
+}

package/dist/onboarding.d.ts

@@ -0,0 +1,9 @@
+export interface OnboardingInput {
+    publicMcpUrl: string;
+    localMcpUrl: string;
+    noteAuthenticated: boolean;
+    tunnelOk: boolean;
+    noOpen?: boolean;
+    noClipboard?: boolean;
+}
+export declare function runOnboarding(input: OnboardingInput): Promise<void>;

package/dist/onboarding.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+import { configDir } from "./paths.js";
+import { CHATGPT_ADVANCED_SETTINGS, CHATGPT_APPS_CONNECTORS, CONNECTOR_NAME, SETUP_STEPS_JA, formatSetupGuide, } from "./chatgpt-setup.js";
+import { copyToClipboard, openBrowser } from "./util.js";
+const NOTE_LOGIN = "https://note.com/login";
+export async function runOnboarding(input) {
+    const { publicMcpUrl, localMcpUrl, noteAuthenticated, tunnelOk, noOpen, noClipboard } = input;
+    if (tunnelOk && !noClipboard) {
+        const copied = await copyToClipboard(publicMcpUrl);
+        if (copied) {
+            console.log("✓ Public MCP URL をクリップボードにコピーしました（「接続 URL」に貼り付け）");
+        }
+    }
+    const guidePath = path.join(configDir(), "CONNECTOR-SETUP.md");
+    fs.writeFileSync(guidePath, formatSetupGuide(publicMcpUrl), "utf8");
+    console.log(`✓ 詳細手順: ${guidePath}`);
+    console.log("");
+    console.log("══════════════════════════════════════════════════════════");
+    console.log("  ChatGPT に note-connector を登録する手順");
+    console.log("══════════════════════════════════════════════════════════");
+    console.log("");
+    if (!tunnelOk) {
+        console.log("⚠ トンネル未接続のため Public URL がありません。ChatGPT には使えません。");
+        console.log(`  ローカル検証用: ${localMcpUrl}`);
+        console.log("");
+        return;
+    }
+    for (const line of SETUP_STEPS_JA) {
+        console.log(line);
+    }
+    console.log("");
+    console.log("  接続 URL（貼り付け用）:");
+    console.log(`  ${publicMcpUrl}`);
+    console.log("");
+    if (!noteAuthenticated) {
+        console.log("【note.com】ログイン用ブラウザを開きます（MCP セッション保存まで待機）");
+    }
+    else {
+        console.log("【note.com】ログイン済み ✓");
+    }
+    console.log("══════════════════════════════════════════════════════════");
+    console.log("");
+    if (!noOpen) {
+        openBrowser(CHATGPT_ADVANCED_SETTINGS);
+        console.log("ブラウザ: 高度な設定 → 開発者モードを ON にしてください");
+        console.log(`次に: ${CHATGPT_APPS_CONNECTORS} で「アプリを作成」`);
+        console.log(`  名前: ${CONNECTOR_NAME} / 認証: なし / URL: クリップボードの内容`);
+        if (!noteAuthenticated) {
+            setTimeout(() => openBrowser(NOTE_LOGIN), 1500);
+        }
+    }
+}

package/dist/paths.d.ts

@@ -0,0 +1,6 @@
+export declare function configDir(): string;
+/** Directory containing `src/note_mcp` (clone) or set via config / env. */
+export declare function resolveNoteConnectorRepo(): string;
+/** @deprecated use resolveNoteConnectorRepo */
+export declare function repoRootFromPackage(): string;
+export declare function ensureConfigDir(): string;

package/dist/paths.js

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function configDir() {
+    return process.env.NOTE_CONNECTOR_CONFIG_DIR ?? path.join(os.homedir(), ".note-connector");
+}
+/** Directory containing `src/note_mcp` (clone) or set via config / env. */
+export function resolveNoteConnectorRepo() {
+    const fromEnv = process.env.NOTE_CONNECTOR_REPO;
+    if (fromEnv) {
+        const root = path.resolve(fromEnv);
+        if (fs.existsSync(path.join(root, "src", "note_mcp")))
+            return root;
+    }
+    const cfgFile = path.join(configDir(), "config.json");
+    if (fs.existsSync(cfgFile)) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(cfgFile, "utf8"));
+            if (cfg.repoPath) {
+                const root = path.resolve(cfg.repoPath);
+                if (fs.existsSync(path.join(root, "src", "note_mcp")))
+                    return root;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const fromDevLayout = path.resolve(here, "..", "..");
+    if (fs.existsSync(path.join(fromDevLayout, "src", "note_mcp"))) {
+        return fromDevLayout;
+    }
+    const fromGlobal = path.resolve(here, "..");
+    if (fs.existsSync(path.join(fromGlobal, "src", "note_mcp"))) {
+        return fromGlobal;
+    }
+    throw new Error("note-connector Python 本体が見つかりません。\n"
+        + "  git clone https://github.com/drillan/note-mcp.git\n"
+        + "  note-connector config set repoPath /path/to/note-connector\n"
+        + "または NOTE_CONNECTOR_REPO=/path/to/note-connector を設定してください。");
+}
+/** @deprecated use resolveNoteConnectorRepo */
+export function repoRootFromPackage() {
+    return resolveNoteConnectorRepo();
+}
+export function ensureConfigDir() {
+    const dir = configDir();
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,14 @@
+export interface StartOptions {
+    noTunnel?: boolean;
+    port?: number;
+    noOpen?: boolean;
+    noClipboard?: boolean;
+    skipNoteLogin?: boolean;
+}
+/** Create config + token + optional Tailscale domain (runs on every start, idempotent). */
+export declare function ensureInitialized(): Promise<void>;
+/** @deprecated Use `note-connector` or `note-connector start` */
+export declare function runSetup(): Promise<void>;
+export declare function runStart(opts: StartOptions): Promise<void>;
+/** Foreground mode (debug): keep terminal attached. */
+export declare function runStartForeground(opts: StartOptions): Promise<void>;

package/dist/runtime.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import path from "node:path";
+import { buildMcpEndpoint, loadConfig, loadOrCreateToken, saveConfig } from "./config.js";
+import { ensureConfigDir, configDir } from "./paths.js";
+import { startPythonServer } from "./spawn-python.js";
+import { resolveGatewayPort } from "./net.js";
+import { discoverTailscaleFqdn } from "./tunnel/tailscale.js";
+import { runOnboarding } from "./onboarding.js";
+import { isNoteAuthenticated, startNoteLoginInBackground } from "./note-auth.js";
+import { spawnDaemon } from "./daemon.js";
+import { TunnelManager } from "./tunnel/manager.js";
+async function verifyHealth(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(5000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Create config + token + optional Tailscale domain (runs on every start, idempotent). */
+export async function ensureInitialized() {
+    const firstRun = !fs.existsSync(path.join(configDir(), "config.json"));
+    ensureConfigDir();
+    let config = loadConfig();
+    const fqdn = discoverTailscaleFqdn();
+    if (fqdn && !config.tunnel.domain) {
+        config = { ...config, tunnel: { ...config.tunnel, domain: fqdn } };
+        saveConfig(config);
+        if (firstRun) {
+            console.log(`Tailscale FQDN saved: ${fqdn}`);
+        }
+    }
+    else {
+        saveConfig(config);
+    }
+    loadOrCreateToken();
+    if (firstRun) {
+        console.log(`Ready (~/.note-connector). Starting…`);
+    }
+}
+/** @deprecated Use `note-connector` or `note-connector start` */
+export async function runSetup() {
+    await ensureInitialized();
+    console.log("Setup is included in start. Just run: note-connector");
+}
+export async function runStart(opts) {
+    await ensureInitialized();
+    await spawnDaemon(opts);
+    return;
+}
+/** Foreground mode (debug): keep terminal attached. */
+export async function runStartForeground(opts) {
+    await ensureInitialized();
+    const config = loadConfig();
+    const preferred = opts.port ?? config.gatewayPort;
+    let port;
+    try {
+        port = await resolveGatewayPort(preferred, "127.0.0.1");
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+    if (port !== config.gatewayPort && opts.port === undefined) {
+        saveConfig({ ...config, gatewayPort: port });
+        console.log(`Using free port ${port} (saved to config; avoids LocalAnt 8787/8788).`);
+    }
+    else if (port !== preferred) {
+        console.log(`Using free port ${port} (preferred ${preferred} was busy).`);
+    }
+    const tokenFile = path.join(configDir(), "token");
+    loadOrCreateToken();
+    const tunnel = new TunnelManager();
+    let tunnelHost;
+    const tunnelHostHint = config.tunnel.domain ?? (config.tunnel.publicUrl ? new URL(config.tunnel.publicUrl).host : undefined);
+    const pidFile = path.join(configDir(), "note-connector.pid");
+    fs.writeFileSync(pidFile, String(process.pid));
+    const child = startPythonServer({
+        host: "127.0.0.1",
+        port,
+        tokenFile,
+        tunnelHost: tunnelHostHint,
+    });
+    for (let i = 0; i < 30; i++) {
+        if (await verifyHealth(port))
+            break;
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    if (!opts.noTunnel) {
+        const info = await tunnel.start(port, config.tunnel);
+        if (info.url) {
+            try {
+                tunnelHost = new URL(info.url).host;
+            }
+            catch {
+                tunnelHost = undefined;
+            }
+            if (tunnelHost) {
+                process.env.NOTE_CONNECTOR_TUNNEL_HOST = tunnelHost;
+            }
+        }
+    }
+    const token = fs.readFileSync(tokenFile, "utf8").trim();
+    const localUrl = buildMcpEndpoint(`http://127.0.0.1:${port}`, token);
+    const t = tunnel.current();
+    const publicUrl = t.url ? buildMcpEndpoint(t.url, token) : localUrl;
+    console.log("");
+    console.log("note-connector is running");
+    console.log(`Local MCP: ${localUrl}`);
+    if (t.url) {
+        console.log(`Public MCP: ${publicUrl}`);
+    }
+    else if (t.error) {
+        console.log(`Tunnel: ${t.error}`);
+        console.log("Public URL なし → 下記はローカル用です。ChatGPT にはトンネル成功後の URL が必要です。");
+        const fqdn = discoverTailscaleFqdn();
+        if (fqdn) {
+            console.log(`Fix: note-connector config set tunnel.domain ${fqdn}`);
+            console.log(`     tailscale funnel ${port}`);
+        }
+    }
+    const noteOk = isNoteAuthenticated();
+    if (!noteOk && !opts.skipNoteLogin) {
+        startNoteLoginInBackground();
+    }
+    await runOnboarding({
+        publicMcpUrl: publicUrl,
+        localMcpUrl: localUrl,
+        noteAuthenticated: noteOk,
+        tunnelOk: Boolean(t.url),
+        noOpen: opts.noOpen,
+        noClipboard: opts.noClipboard,
+    });
+    child.on("exit", (code, signal) => {
+        if (code !== 0 && code !== null) {
+            console.error(`Python MCP server exited (code=${code}${signal ? `, signal=${signal}` : ""}).\n` +
+                `If you saw 'address already in use', another app owns the port — stop LocalAnt or change gatewayPort.`);
+            process.exit(code ?? 1);
+        }
+    });
+    const shutdown = () => {
+        tunnel.stop();
+        child.kill("SIGTERM");
+        try {
+            fs.rmSync(pidFile, { force: true });
+        }
+        catch {
+            /* ignore */
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => { });
+}

package/dist/spawn-python.d.ts

@@ -0,0 +1,7 @@
+import { type ChildProcess } from "node:child_process";
+export declare function startPythonServer(options: {
+    host: string;
+    port: number;
+    tokenFile: string;
+    tunnelHost?: string;
+}): ChildProcess;

package/dist/spawn-python.js

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { repoRootFromPackage } from "./paths.js";
+export function startPythonServer(options) {
+    const root = repoRootFromPackage();
+    const env = {
+        ...process.env,
+        HOME: process.env.HOME ?? process.env.USERPROFILE ?? "",
+        NOTE_CONNECTOR_CONFIG_DIR: path.dirname(options.tokenFile),
+    };
+    if (options.tunnelHost) {
+        env.NOTE_CONNECTOR_TUNNEL_HOST = options.tunnelHost;
+    }
+    return spawn("uv", [
+        "run",
+        "python",
+        "-m",
+        "note_mcp.chatgpt",
+        "--host",
+        options.host,
+        "--port",
+        String(options.port),
+        "--token-file",
+        options.tokenFile,
+    ], {
+        cwd: root,
+        env,
+        stdio: "inherit",
+        shell: false,
+    });
+}

package/dist/tunnel/manager.d.ts

@@ -0,0 +1,18 @@
+import type { TunnelConfig } from "../config.js";
+export interface TunnelInfo {
+    provider: string;
+    url?: string;
+    status: "starting" | "running" | "stopped" | "error";
+    error?: string;
+}
+export declare class TunnelManager {
+    private child?;
+    private info;
+    private timeoutId?;
+    current(): TunnelInfo;
+    stop(): void;
+    start(port: number, tunnel: TunnelConfig): Promise<TunnelInfo>;
+    private stableTailscaleUrl;
+    private startTailscale;
+    private startNgrok;
+}

package/dist/tunnel/manager.js

@@ -0,0 +1,163 @@
+import { spawn } from "node:child_process";
+import { discoverTailscaleFqdn, funnelReset, parseTailscaleFunnelUrl, resolveTailscaleBin, tailscaleEnv, } from "./tailscale.js";
+export class TunnelManager {
+    child;
+    info = { provider: "none", status: "stopped" };
+    timeoutId;
+    current() {
+        return this.info;
+    }
+    stop() {
+        if (this.timeoutId)
+            clearTimeout(this.timeoutId);
+        if (this.child) {
+            this.child.kill();
+            this.child = undefined;
+        }
+        this.info = { provider: "none", status: "stopped" };
+    }
+    async start(port, tunnel) {
+        if (tunnel.publicUrl) {
+            this.info = { provider: "custom", url: tunnel.publicUrl.replace(/\/$/, ""), status: "running" };
+            return this.info;
+        }
+        if (tunnel.provider === "none") {
+            this.info = { provider: "none", status: "stopped" };
+            return this.info;
+        }
+        if (tunnel.provider === "tailscale") {
+            return this.startTailscale(port, tunnel);
+        }
+        if (tunnel.provider === "ngrok") {
+            return this.startNgrok(port, tunnel);
+        }
+        this.info = {
+            provider: tunnel.provider,
+            status: "error",
+            error: `Unknown tunnel provider '${tunnel.provider}'.`,
+        };
+        return this.info;
+    }
+    stableTailscaleUrl(tunnel) {
+        if (tunnel.domain)
+            return `https://${tunnel.domain.replace(/^https?:\/\//, "").replace(/\/$/, "")}`;
+        const discovered = discoverTailscaleFqdn();
+        if (discovered)
+            return `https://${discovered}`;
+        return undefined;
+    }
+    startTailscale(port, tunnel) {
+        return new Promise((resolve) => {
+            this.info = { provider: "tailscale", status: "starting" };
+            const bin = resolveTailscaleBin();
+            if (!bin) {
+                this.info = {
+                    provider: "tailscale",
+                    status: "error",
+                    error: "Tailscale not found. Install from https://tailscale.com/download or set tunnel.publicUrl.",
+                };
+                resolve(this.info);
+                return;
+            }
+            const stableUrl = this.stableTailscaleUrl(tunnel);
+            funnelReset(bin);
+            const env = tailscaleEnv();
+            this.child = spawn(bin, ["funnel", String(port)], { env, shell: false });
+            let acc = "";
+            const finishRunning = (url) => {
+                if (this.info.status === "running")
+                    return;
+                this.info = { provider: "tailscale", url: url.replace(/\/$/, ""), status: "running" };
+                if (this.timeoutId)
+                    clearTimeout(this.timeoutId);
+                resolve(this.info);
+            };
+            const onData = (chunk) => {
+                acc += chunk.toString("utf8");
+                const parsed = parseTailscaleFunnelUrl(acc);
+                if (parsed)
+                    finishRunning(parsed);
+            };
+            this.child.stdout?.on("data", onData);
+            this.child.stderr?.on("data", onData);
+            this.child.on("error", (e) => {
+                this.info = { provider: "tailscale", status: "error", error: e.message };
+                resolve(this.info);
+            });
+            this.child.on("close", (code) => {
+                if (this.info.status === "running")
+                    return;
+                if (stableUrl) {
+                    finishRunning(stableUrl);
+                    return;
+                }
+                this.info = {
+                    provider: "tailscale",
+                    status: "error",
+                    error: `Tailscale Funnel exited (code ${code ?? "?"}). ` +
+                        "Enable Funnel in the admin console, or run: tailscale funnel " +
+                        port,
+                };
+                resolve(this.info);
+            });
+            this.timeoutId = setTimeout(() => {
+                if (this.info.status === "running")
+                    return;
+                if (stableUrl) {
+                    finishRunning(stableUrl);
+                    return;
+                }
+                this.info = {
+                    provider: "tailscale",
+                    status: "error",
+                    error: "Timed out waiting for Tailscale Funnel URL. Run once: tailscale funnel " +
+                        port +
+                        " (approve in admin), then: note-connector config set tunnel.domain <your-machine.ts.net>",
+                };
+                resolve(this.info);
+            }, 45_000);
+        });
+    }
+    startNgrok(port, tunnel) {
+        return new Promise((resolve) => {
+            this.info = { provider: "ngrok", status: "starting" };
+            const args = ["http", String(port), "--log", "stdout"];
+            if (tunnel.domain)
+                args.push("--domain", tunnel.domain);
+            if (tunnel.token)
+                args.push("--authtoken", tunnel.token);
+            this.child = spawn("ngrok", args, { shell: false });
+            let buf = "";
+            const onData = (chunk) => {
+                buf += chunk.toString("utf8");
+                const m = buf.match(/https:\/\/[a-z0-9-]+\.ngrok[a-z0-9.-]*\.(app|io)/i);
+                if (m && this.info.status !== "running") {
+                    this.info = { provider: "ngrok", url: m[0], status: "running" };
+                    resolve(this.info);
+                }
+            };
+            this.child.stdout?.on("data", onData);
+            this.child.stderr?.on("data", onData);
+            this.child.on("error", (e) => {
+                this.info = { provider: "ngrok", status: "error", error: e.message };
+                resolve(this.info);
+            });
+            setTimeout(() => {
+                if (this.info.status === "running")
+                    return;
+                if (tunnel.domain) {
+                    this.info = {
+                        provider: "ngrok",
+                        url: `https://${tunnel.domain}`,
+                        status: "running",
+                    };
+                    resolve(this.info);
+                }
+                else {
+                    this.info = { provider: "ngrok", status: "error", error: "Timed out waiting for ngrok URL" };
+                    resolve(this.info);
+                }
+            }, 20_000);
+        });
+    }
+}

package/dist/tunnel/tailscale.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveTailscaleBin(): string | null;
+export declare function tailscaleEnv(): NodeJS.ProcessEnv;
+/** Public Funnel FQDN from `tailscale status --json` (Self.DNSName). */
+export declare function discoverTailscaleFqdn(): string | undefined;
+export declare function funnelReset(bin: string): void;
+export declare function parseTailscaleFunnelUrl(text: string): string | undefined;

package/dist/tunnel/tailscale.js

@@ -0,0 +1,50 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+export function resolveTailscaleBin() {
+    if (fs.existsSync("/Applications/Tailscale.app/Contents/MacOS/Tailscale")) {
+        return "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
+    }
+    return "tailscale";
+}
+export function tailscaleEnv() {
+    if (process.env.SHLVL && process.env.SHLVL.length > 0)
+        return process.env;
+    return { ...process.env, SHLVL: "1" };
+}
+/** Public Funnel FQDN from `tailscale status --json` (Self.DNSName). */
+export function discoverTailscaleFqdn() {
+    const bin = resolveTailscaleBin();
+    if (!bin)
+        return undefined;
+    try {
+        const out = execFileSync(bin, ["status", "--json"], {
+            encoding: "utf8",
+            timeout: 8000,
+            env: tailscaleEnv(),
+        });
+        const dns = JSON.parse(out).Self?.DNSName;
+        if (!dns)
+            return undefined;
+        return dns.replace(/\.$/, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function funnelReset(bin) {
+    try {
+        execFileSync(bin, ["funnel", "reset"], {
+            timeout: 10_000,
+            stdio: "ignore",
+            env: tailscaleEnv(),
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+const TS_NET_URL = /https:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)*\.ts\.net/i;
+export function parseTailscaleFunnelUrl(text) {
+    const m = text.match(TS_NET_URL);
+    return m?.[0];
+}

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare function copyToClipboard(text: string): Promise<boolean>;
+export declare function openBrowser(url: string): void;