note-connector 0.2.2 → 0.2.4

package/dist/config.test.js

@@ -1,6 +1,29 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import http from "node:http";
 import { buildMcpEndpoint } from "./config.js";
+import { buildRoutedMcpEndpoint, selectAvailableRouterPort } from "./shared-router.js";
 test("buildMcpEndpoint", () => {
     assert.equal(buildMcpEndpoint("https://machine.tail.ts.net/", "abc"), "https://machine.tail.ts.net/mcp?key=abc");
 });
+test("buildRoutedMcpEndpoint", () => {
+    assert.equal(buildRoutedMcpEndpoint("https://machine.tail.ts.net/", "/note-connector", "abc"), "https://machine.tail.ts.net/note-connector/mcp?key=abc");
+});
+test("selectAvailableRouterPort skips ports owned by another service", async () => {
+    const otherService = http.createServer((_req, res) => {
+        res.writeHead(404);
+        res.end("not the shared router");
+    });
+    const occupiedPort = await new Promise((resolve) => {
+        otherService.listen(0, "127.0.0.1", () => {
+            const address = otherService.address();
+            resolve(typeof address === "object" && address ? address.port : 0);
+        });
+    });
+    try {
+        assert.notEqual(await selectAvailableRouterPort(occupiedPort), occupiedPort);
+    }
+    finally {
+        await new Promise((resolve) => otherService.close(() => resolve()));
+    }
+});

package/dist/daemon-worker.js

@@ -10,6 +10,7 @@ import { resolveGatewayPort } from "./net.js";
 import { isNoteAuthenticated, startNoteLoginInBackground } from "./note-auth.js";
 import { TunnelManager } from "./tunnel/manager.js";
 import { saveRuntime, cliPidPath, loadLastMcpAccess } from "./daemon-state.js";
+import { buildRoutedMcpEndpoint, ensureSharedRouterRoute } from "./shared-router.js";
 async function verifyHealth(port) {
     try {
         const res = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(5000) });
@@ -55,11 +56,25 @@ export async function runDaemonWorker(opts, logFile) {
         await new Promise((r) => setTimeout(r, 500));
     }
     if (!opts.noTunnel) {
-        await tunnel.start(port, config.tunnel);
+        if (config.tunnel.provider === "tailscale" && (config.tunnel.domain || config.tunnel.publicUrl)) {
+            await ensureSharedRouterRoute({
+                name: "note-connector",
+                prefix: "/note-connector",
+                target: `http://127.0.0.1:${port}`,
+                publicBaseUrl: config.tunnel.publicUrl || `https://${config.tunnel.domain}`,
+            });
+        }
+        else {
+            await tunnel.start(port, config.tunnel);
+        }
     }
     const t = tunnel.current();
     const localUrl = buildMcpEndpoint(`http://127.0.0.1:${port}`, token);
-    const publicUrl = t.url ? buildMcpEndpoint(t.url, token) : localUrl;
+    const publicUrl = config.tunnel.provider === "tailscale" && (config.tunnel.domain || config.tunnel.publicUrl) && !opts.noTunnel
+        ? buildRoutedMcpEndpoint(config.tunnel.publicUrl || `https://${config.tunnel.domain}`, "/note-connector", token)
+        : t.url
+            ? buildMcpEndpoint(t.url, token)
+            : localUrl;
     saveRuntime({
         cliPid: process.pid,
         port,
@@ -67,7 +82,9 @@ export async function runDaemonWorker(opts, logFile) {
         localMcpUrl: localUrl,
         startedAt,
         logFile,
-        tunnelProvider: t.provider,
+        tunnelProvider: config.tunnel.provider === "tailscale" && (config.tunnel.domain || config.tunnel.publicUrl) && !opts.noTunnel
+            ? "tailscale-shared-router"
+            : t.provider,
     });
     if (!isNoteAuthenticated() && !opts.skipNoteLogin) {
         startNoteLoginInBackground();

package/dist/runtime.js

@@ -10,6 +10,7 @@ import { isNoteAuthenticated, startNoteLoginInBackground } from "./note-auth.js"
 import { spawnDaemon } from "./daemon.js";
 import { setupDependencies } from "./setup-dependencies.js";
 import { TunnelManager } from "./tunnel/manager.js";
+import { buildRoutedMcpEndpoint, ensureSharedRouterRoute } from "./shared-router.js";
 async function verifyHealth(port) {
     try {
         const res = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(5000) });
@@ -94,7 +95,18 @@ export async function runStartForeground(opts) {
         await new Promise((r) => setTimeout(r, 500));
     }
     if (!opts.noTunnel) {
-        const info = await tunnel.start(port, config.tunnel);
+        const info = config.tunnel.provider === "tailscale" && (config.tunnel.domain || config.tunnel.publicUrl)
+            ? await (async () => {
+                const publicBaseUrl = config.tunnel.publicUrl || `https://${config.tunnel.domain}`;
+                const route = await ensureSharedRouterRoute({
+                    name: "note-connector",
+                    prefix: "/note-connector",
+                    target: `http://127.0.0.1:${port}`,
+                    publicBaseUrl,
+                });
+                return { provider: "tailscale-shared-router", url: route.publicBaseUrl, status: "running" };
+            })()
+            : await tunnel.start(port, config.tunnel);
         if (info.url) {
             try {
                 tunnelHost = new URL(info.url).host;
@@ -110,11 +122,15 @@ export async function runStartForeground(opts) {
     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;
+    const publicUrl = config.tunnel.provider === "tailscale" && (config.tunnel.domain || config.tunnel.publicUrl) && !opts.noTunnel
+        ? buildRoutedMcpEndpoint(config.tunnel.publicUrl || `https://${config.tunnel.domain}`, "/note-connector", token)
+        : t.url
+            ? buildMcpEndpoint(t.url, token)
+            : localUrl;
     console.log("");
     console.log("note-connector is running");
     console.log(`Local MCP: ${localUrl}`);
-    if (t.url) {
+    if (publicUrl !== localUrl) {
         console.log(`Public MCP: ${publicUrl}`);
     }
     else if (t.error) {

package/dist/setup-dependencies.js

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { loadConfig, saveConfig } from "./config.js";
@@ -44,6 +44,21 @@ function cloneRepo(target) {
     fs.mkdirSync(path.dirname(target), { recursive: true });
     execFileSync("git", ["clone", "--depth", "1", DEFAULT_REPO, target], { stdio: "inherit" });
 }
+function updateRepo(repo) {
+    try {
+        const result = spawnSync("git", ["pull", "--ff-only", "origin", "main"], {
+            cwd: repo,
+            encoding: "utf8",
+            timeout: 15000,
+        });
+        if (result.status === 0 && !String(result.stdout).trim().includes("Already up to date")) {
+            console.log("note-connector を最新に更新しました");
+        }
+    }
+    catch {
+        // Network issues or git not available — skip silently
+    }
+}
 function ensureRepoPath(config) {
     if (config.repoPath && repoHasPython(config.repoPath)) {
         return path.resolve(config.repoPath);
@@ -90,6 +105,7 @@ export async function setupDependencies() {
     const config = loadConfig();
     ensureUv();
     const repo = ensureRepoPath(config);
+    updateRepo(repo);
     runUvSync(repo);
     ensurePlaywright(repo);
     if (!commandExists("tailscale") && config.tunnel.provider === "tailscale" && !config.tunnel.publicUrl) {

package/dist/shared-router-daemon.d.ts

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

package/dist/shared-router-daemon.js

@@ -0,0 +1,6 @@
+import fs from "node:fs";
+import { createSharedRouterServer, routerConfigPath } from "./shared-router.js";
+const configFile = process.env.MCP_TAILSCALE_ROUTER_CONFIG || routerConfigPath();
+const server = createSharedRouterServer(configFile);
+const parsed = fs.existsSync(configFile) ? JSON.parse(fs.readFileSync(configFile, "utf8")) : {};
+server.listen(parsed.port ?? 8790, "127.0.0.1");

package/dist/shared-router.d.ts

@@ -0,0 +1,25 @@
+import http from "node:http";
+export interface SharedRouterRoute {
+    name: string;
+    prefix: string;
+    target: string;
+}
+export interface SharedRouterConfig {
+    port: number;
+    routes: Record<string, SharedRouterRoute>;
+}
+export interface EnsureSharedRouterOptions {
+    name: string;
+    prefix: string;
+    target: string;
+    publicBaseUrl: string;
+}
+export declare function normalizeRoutePrefix(prefix: string): string;
+export declare function buildRoutedMcpEndpoint(publicBaseUrl: string, prefix: string, token: string): string;
+export declare function selectAvailableRouterPort(preferredPort: number): Promise<number>;
+export declare function ensureSharedRouterRoute(options: EnsureSharedRouterOptions): Promise<{
+    publicBaseUrl: string;
+    routeBaseUrl: string;
+}>;
+export declare function createSharedRouterServer(configFile?: string): http.Server;
+export declare function routerConfigPath(): string;

package/dist/shared-router.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import http from "node:http";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { resolveTailscaleBin, tailscaleEnv } from "./tunnel/tailscale.js";
+const ROUTER_DIR = path.join(os.homedir(), ".mcp-tailscale-router");
+const CONFIG_FILE = path.join(ROUTER_DIR, "config.json");
+const PID_FILE = path.join(ROUTER_DIR, "router.pid");
+const DEFAULT_PORT = 8790;
+export function normalizeRoutePrefix(prefix) {
+    const trimmed = prefix.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!trimmed || trimmed.includes("..") || /[^a-zA-Z0-9._-]/.test(trimmed)) {
+        throw new Error(`Invalid shared router prefix "${prefix}". Use letters, numbers, dot, underscore or dash.`);
+    }
+    return `/${trimmed}`;
+}
+export function buildRoutedMcpEndpoint(publicBaseUrl, prefix, token) {
+    return `${publicBaseUrl.replace(/\/$/, "")}${normalizeRoutePrefix(prefix)}/mcp?key=${encodeURIComponent(token)}`;
+}
+function loadRouterConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return { port: DEFAULT_PORT, routes: {} };
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    return { port: parsed.port ?? DEFAULT_PORT, routes: parsed.routes ?? {} };
+}
+function saveRouterConfig(config) {
+    fs.mkdirSync(ROUTER_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+async function routerHealthy(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/__mcp_router/healthz`, { signal: AbortSignal.timeout(1000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function portAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once("error", () => resolve(false));
+        server.listen(port, "127.0.0.1", () => {
+            server.close(() => resolve(true));
+        });
+    });
+}
+export async function selectAvailableRouterPort(preferredPort) {
+    if (await routerHealthy(preferredPort))
+        return preferredPort;
+    if (await portAvailable(preferredPort))
+        return preferredPort;
+    for (let port = DEFAULT_PORT + 1; port < DEFAULT_PORT + 100; port++) {
+        if (await routerHealthy(port))
+            return port;
+        if (await portAvailable(port))
+            return port;
+    }
+    throw new Error(`No available shared MCP router port found near ${DEFAULT_PORT}.`);
+}
+async function ensureRouterProcess(port) {
+    if (await routerHealthy(port))
+        return;
+    const child = spawn(process.execPath, [new URL("./shared-router-daemon.js", import.meta.url).pathname], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, MCP_TAILSCALE_ROUTER_CONFIG: CONFIG_FILE },
+    });
+    child.unref();
+    fs.mkdirSync(ROUTER_DIR, { recursive: true });
+    fs.writeFileSync(PID_FILE, String(child.pid ?? ""));
+    for (let i = 0; i < 30; i++) {
+        if (await routerHealthy(port))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    throw new Error(`Shared MCP router did not start on port ${port}.`);
+}
+async function ensureTailscaleFunnel(port) {
+    const bin = resolveTailscaleBin();
+    if (!bin)
+        throw new Error("Tailscale CLI was not found. Install Tailscale or set a non-Tailscale tunnel provider.");
+    const env = tailscaleEnv();
+    await new Promise((resolve) => {
+        const reset = spawn(bin, ["funnel", "reset"], { env, stdio: "ignore" });
+        reset.on("close", () => resolve());
+        reset.on("error", () => resolve());
+    });
+    await new Promise((resolve, reject) => {
+        const child = spawn(bin, ["funnel", "--bg", String(port)], { env, stdio: "ignore" });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Tailscale Funnel failed to publish shared router on port ${port} (exit ${code}).`));
+        });
+    });
+}
+export async function ensureSharedRouterRoute(options) {
+    const prefix = normalizeRoutePrefix(options.prefix);
+    const config = loadRouterConfig();
+    config.routes[options.name] = {
+        name: options.name,
+        prefix,
+        target: options.target.replace(/\/$/, ""),
+    };
+    config.port = await selectAvailableRouterPort(config.port);
+    saveRouterConfig(config);
+    await ensureRouterProcess(config.port);
+    await ensureTailscaleFunnel(config.port);
+    const publicBaseUrl = options.publicBaseUrl.replace(/\/$/, "");
+    return { publicBaseUrl, routeBaseUrl: `${publicBaseUrl}${prefix}` };
+}
+export function createSharedRouterServer(configFile = CONFIG_FILE) {
+    const readConfig = () => {
+        if (!fs.existsSync(configFile))
+            return { port: DEFAULT_PORT, routes: {} };
+        const parsed = JSON.parse(fs.readFileSync(configFile, "utf8"));
+        return { port: parsed.port ?? DEFAULT_PORT, routes: parsed.routes ?? {} };
+    };
+    return http.createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        if (url.pathname === "/__mcp_router/healthz") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, service: "mcp-tailscale-router" }));
+            return;
+        }
+        const config = readConfig();
+        const route = Object.values(config.routes).find((candidate) => {
+            return url.pathname === candidate.prefix || url.pathname.startsWith(`${candidate.prefix}/`);
+        });
+        if (!route) {
+            res.writeHead(404, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "route_not_found" }));
+            return;
+        }
+        const target = new URL(route.target);
+        const stripped = url.pathname.slice(route.prefix.length) || "/";
+        target.pathname = `${target.pathname.replace(/\/$/, "")}${stripped}`;
+        target.search = url.search;
+        const headers = { ...req.headers };
+        headers.host = target.host;
+        const proxy = http.request(target, { method: req.method, headers }, (upstream) => {
+            res.writeHead(upstream.statusCode ?? 502, upstream.headers);
+            upstream.pipe(res);
+        });
+        proxy.on("error", (err) => {
+            if (!res.headersSent)
+                res.writeHead(502, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "upstream_error", message: err.message }));
+        });
+        req.pipe(proxy);
+    });
+}
+export function routerConfigPath() {
+    return CONFIG_FILE;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "note-connector",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "publishConfig": {
     "access": "public"
   },