note-connector 0.1.0

package/README.md

@@ -0,0 +1,31 @@
+# note-connector
+
+ChatGPT **Connector** for [note.com](https://note.com) — MCP + Apps SDK UI.
+
+## Install
+
+```bash
+npm install -g note-connector
+```
+
+## Requirements
+
+- Node.js 20+
+- [uv](https://docs.astral.sh/uv/) + Python 3.13+
+- Git clone of this repository (MCP server):
+
+```bash
+git clone https://github.com/drillan/note-mcp.git
+cd note-mcp && uv sync && uv run playwright install chromium
+note-connector config set repoPath "$(pwd)"
+```
+
+## Run
+
+```bash
+note-connector
+note-connector status
+note-connector stop
+```
+
+See [full docs](https://github.com/drillan/note-mcp/blob/main/README.md).

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { loadConfig, saveConfig } from "./config.js";
+import { runSetup, runStart, runStartForeground } from "./runtime.js";
+import { isDaemonRunning, loadRuntime, loadLastMcpAccess, clearRuntime } from "./daemon-state.js";
+import { configDir } from "./paths.js";
+import { APP_VERSION, isNewerVersion } from "./version.js";
+const program = new Command();
+program.name("note-connector").description("ChatGPT connector for note.com").version(APP_VERSION);
+program
+    .command("start", { isDefault: true })
+    .description("Start note-connector in background (MCP + tunnel); terminal can close after setup")
+    .option("--no-tunnel", "Do not start a public tunnel")
+    .option("-p, --port <number>", "Local port", (v) => parseInt(v, 10))
+    .option("--no-open", "Do not open ChatGPT / note.com in the browser")
+    .option("--no-clipboard", "Do not copy Public MCP URL to clipboard")
+    .option("--skip-note-login", "Do not open Playwright note login")
+    .option("--foreground", "Keep terminal open (debug)")
+    .action(async (opts) => {
+    const base = {
+        noTunnel: Boolean(opts.noTunnel),
+        port: opts.port,
+        noOpen: Boolean(opts.noOpen),
+        noClipboard: Boolean(opts.noClipboard),
+        skipNoteLogin: Boolean(opts.skipNoteLogin),
+    };
+    if (opts.foreground)
+        await runStartForeground(base);
+    else
+        await runStart(base);
+});
+program
+    .command("setup", { hidden: true })
+    .description("Deprecated: use note-connector without arguments")
+    .action(async () => {
+    await runSetup();
+});
+program
+    .command("config")
+    .description("Get or set configuration")
+    .argument("[key]", "dotted key e.g. tunnel.domain")
+    .argument("[value]", "value to set")
+    .action((key, value) => {
+    const config = loadConfig();
+    if (!key) {
+        console.log(JSON.stringify(config, null, 2));
+        return;
+    }
+    if (value === undefined) {
+        const parts = key.split(".");
+        let cur = config;
+        for (const p of parts) {
+            cur = cur[p];
+        }
+        console.log(cur);
+        return;
+    }
+    const updated = { ...config, tunnel: { ...config.tunnel } };
+    if (key === "tunnel.provider")
+        updated.tunnel.provider = value;
+    else if (key === "tunnel.domain")
+        updated.tunnel.domain = value;
+    else if (key === "tunnel.subdomain")
+        updated.tunnel.subdomain = value;
+    else if (key === "tunnel.token")
+        updated.tunnel.token = value;
+    else if (key === "tunnel.publicUrl")
+        updated.tunnel.publicUrl = value;
+    else if (key === "gatewayPort")
+        updated.gatewayPort = parseInt(value, 10);
+    else if (key === "repoPath")
+        updated.repoPath = value;
+    else {
+        console.error(`Unknown key: ${key}`);
+        process.exit(1);
+    }
+    saveConfig(updated);
+    console.log(`Set ${key}=${value}`);
+});
+program
+    .command("update")
+    .description("Update note-connector to the latest npm release")
+    .option("--check", "only check for a newer version")
+    .option("--pm <manager>", "package manager (npm|pnpm|yarn|bun)", "npm")
+    .action((o) => {
+    const current = APP_VERSION;
+    let latest;
+    try {
+        latest = execFileSync("npm", ["view", "note-connector", "version"], { encoding: "utf8" }).trim();
+    }
+    catch {
+        console.error("Could not check npm for updates (package may not be published yet).\n"
+            + "After first release: npm install -g note-connector@latest");
+        process.exit(1);
+    }
+    if (!isNewerVersion(latest, current)) {
+        console.log(`Already up to date (v${current}).`);
+        return;
+    }
+    console.log(`Update available: v${current} → v${latest}`);
+    if (o.check) {
+        console.log("Run `note-connector update` to install.");
+        return;
+    }
+    const pm = String(o.pm ?? "npm");
+    const installArgs = {
+        npm: ["install", "-g", "note-connector@latest"],
+        pnpm: ["add", "-g", "note-connector@latest"],
+        yarn: ["global", "add", "note-connector@latest"],
+        bun: ["add", "-g", "note-connector@latest"],
+    };
+    const args = installArgs[pm];
+    if (!args) {
+        console.error(`Unknown package manager: ${pm}`);
+        process.exit(1);
+    }
+    console.log(`Installing note-connector@latest via ${pm}…`);
+    execFileSync(pm, args, { stdio: "inherit" });
+    console.log(`Updated to v${latest}.`);
+});
+program
+    .command("status")
+    .description("Show background server status and last ChatGPT MCP access")
+    .action(() => {
+    if (!isDaemonRunning()) {
+        console.log("note-connector は停止中です。起動: note-connector");
+        return;
+    }
+    const rt = loadRuntime();
+    const access = loadLastMcpAccess();
+    console.log("note-connector: running (background)");
+    if (rt) {
+        console.log(`PID: ${rt.cliPid}`);
+        console.log(`Public MCP: ${rt.publicMcpUrl}`);
+        console.log(`ログ: ${rt.logFile}`);
+        console.log(`起動: ${rt.startedAt}`);
+    }
+    if (access) {
+        console.log(`最終 ChatGPT 接続: ${access.at}${access.remote ? ` (${access.remote})` : ""}`);
+    }
+});
+program
+    .command("stop")
+    .description("Stop background note-connector")
+    .action(() => {
+    const rt = loadRuntime();
+    const pidFile = path.join(configDir(), "note-connector.pid");
+    const pid = rt?.cliPid ?? (fs.existsSync(pidFile) ? parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10) : NaN);
+    if (!pid || Number.isNaN(pid)) {
+        console.log("note-connector は動いていません。");
+        clearRuntime();
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(`停止しました (PID ${pid})`);
+    }
+    catch {
+        console.log(`PID ${pid} は既に終了しています。`);
+    }
+    clearRuntime();
+});
+program.parseAsync(process.argv);

package/dist/chatgpt-setup.d.ts

@@ -0,0 +1,6 @@
+/** ChatGPT Connector setup URLs and copy (aligned with OpenAI Developer mode docs). */
+export declare const CHATGPT_APPS_CONNECTORS = "https://chatgpt.com/#settings/Connectors";
+export declare const CHATGPT_ADVANCED_SETTINGS = "https://chatgpt.com/#settings/Connectors/Advanced";
+export declare const CONNECTOR_NAME = "note-connector";
+export declare const SETUP_STEPS_JA: readonly string[];
+export declare function formatSetupGuide(publicMcpUrl: string): string;

package/dist/chatgpt-setup.js

@@ -0,0 +1,58 @@
+/** ChatGPT Connector setup URLs and copy (aligned with OpenAI Developer mode docs). */
+export const CHATGPT_APPS_CONNECTORS = "https://chatgpt.com/#settings/Connectors";
+export const CHATGPT_ADVANCED_SETTINGS = "https://chatgpt.com/#settings/Connectors/Advanced";
+export const CONNECTOR_NAME = "note-connector";
+export const SETUP_STEPS_JA = [
+    "【準備】ChatGPT の Plus / Pro / Business 等のアカウントで Web 版を開く",
+    "【1】設定 → アプリとコネクタ（Apps & Connectors）を開く",
+    "【2】高度な設定（Advanced settings）を開く",
+    "【3】開発者モード（Developer mode）を ON にする",
+    "【4】アプリとコネクタ画面に戻る",
+    "【5】「アプリを作成」（Create app）をクリック ※開発者モード ON のときだけ表示",
+    "【6】作成フォームに入力して保存:",
+    "     ・名前: note-connector",
+    "     ・接続 / Connector URL: （下の Public MCP URL を貼り付け）",
+    "     ・認証: なし / No authentication（URL に key= が含まれるため）",
+    "【7】新しいチャット → ＋メニュー → 開発者モードで note-connector を有効化",
+    "【8】例:「note の認証状態を確認して」「下書き一覧を見せて」",
+];
+export function formatSetupGuide(publicMcpUrl) {
+    return `# note-connector — ChatGPT 接続手順
+
+参照: OpenAI [Developer mode](https://platform.openai.com/docs/guides/developer-mode) / LocalAnt 同様の MCP Connector 手順
+
+## Public MCP URL（コピーして貼り付け）
+
+\`\`\`
+${publicMcpUrl}
+\`\`\`
+
+## 手順（この順番で）
+
+1. **ChatGPT** → [アプリとコネクタ](${CHATGPT_APPS_CONNECTORS})
+2. **[高度な設定](${CHATGPT_ADVANCED_SETTINGS})** を開く
+3. **開発者モード（Developer mode）** を **ON**
+4. 再度 [アプリとコネクタ](${CHATGPT_APPS_CONNECTORS}) へ
+5. **「アプリを作成」**（Create app）をクリック  
+   （開発者モードが ON のときだけ表示されます）
+6. フォーム:
+   | 項目 | 入力 |
+   |------|------|
+   | 名前 | \`${CONNECTOR_NAME}\` |
+   | 接続 URL / Connector URL | 上記 Public MCP URL 全体 |
+   | 認証 | **なし** / **No authentication** |
+7. 保存後、下書き（Drafts）に \`${CONNECTOR_NAME}\` が表示されます
+8. **新しいチャット** → ツール／＋メニュー → **開発者モード** → \`${CONNECTOR_NAME}\` を選択
+9. 会話で note 操作（初回は \`note_login\` が必要な場合あり）
+
+## 注意
+
+- プロトコル: **Streaming HTTP**（\`/mcp\`）
+- 認証は URL の \`?key=\` で行うため、ChatGPT 側は **認証なし** で正しいです
+- 書き込みツールは ChatGPT が確認を求めることがあります（Developer mode の仕様）
+
+## note.com
+
+未ログインの場合、別タブで note.com にログインし、Playwright のログインが完了するまで待ってください。
+`;
+}

package/dist/config.d.ts

@@ -0,0 +1,22 @@
+export type TunnelProvider = "tailscale" | "ngrok" | "cloudflared" | "localtunnel" | "none";
+export interface TunnelConfig {
+    provider: TunnelProvider;
+    domain?: string;
+    subdomain?: string;
+    token?: string;
+    publicUrl?: string;
+}
+export interface NoteConnectorConfig {
+    gatewayPort: number;
+    tunnel: TunnelConfig;
+    /** Path to git clone with src/note_mcp (required when CLI is npm global-only). */
+    repoPath?: string;
+}
+/** Old default collided with LocalAnt — migrate on load. */
+export declare const LEGACY_GATEWAY_PORT = 8787;
+export declare function configPath(): string;
+export declare function tokenPath(): string;
+export declare function loadConfig(): NoteConnectorConfig;
+export declare function saveConfig(config: NoteConnectorConfig): void;
+export declare function loadOrCreateToken(): string;
+export declare function buildMcpEndpoint(publicBase: string, token: string): string;

package/dist/config.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { configDir, ensureConfigDir } from "./paths.js";
+/** Old default collided with LocalAnt — migrate on load. */
+export const LEGACY_GATEWAY_PORT = 8787;
+const DEFAULT_CONFIG = {
+    gatewayPort: 8797,
+    tunnel: {
+        provider: "tailscale",
+    },
+};
+export function configPath() {
+    return path.join(configDir(), "config.json");
+}
+export function tokenPath() {
+    return path.join(configDir(), "token");
+}
+export function loadConfig() {
+    const file = configPath();
+    if (!fs.existsSync(file)) {
+        return { ...DEFAULT_CONFIG, tunnel: { ...DEFAULT_CONFIG.tunnel } };
+    }
+    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    let gatewayPort = raw.gatewayPort ?? DEFAULT_CONFIG.gatewayPort;
+    if (gatewayPort === LEGACY_GATEWAY_PORT) {
+        gatewayPort = DEFAULT_CONFIG.gatewayPort;
+        saveConfig({
+            gatewayPort,
+            tunnel: { ...DEFAULT_CONFIG.tunnel, ...raw.tunnel },
+        });
+    }
+    return {
+        gatewayPort,
+        tunnel: { ...DEFAULT_CONFIG.tunnel, ...raw.tunnel },
+    };
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(configPath(), JSON.stringify(config, null, 2));
+}
+export function loadOrCreateToken() {
+    ensureConfigDir();
+    const file = tokenPath();
+    if (fs.existsSync(file)) {
+        const t = fs.readFileSync(file, "utf8").trim();
+        if (t)
+            return t;
+    }
+    const token = crypto.randomBytes(32).toString("base64url");
+    fs.writeFileSync(file, token, "utf8");
+    return token;
+}
+export function buildMcpEndpoint(publicBase, token) {
+    return `${publicBase.replace(/\/$/, "")}/mcp?key=${token}`;
+}

package/dist/config.test.d.ts

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

package/dist/config.test.js

@@ -0,0 +1,6 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildMcpEndpoint } from "./config.js";
+test("buildMcpEndpoint", () => {
+    assert.equal(buildMcpEndpoint("https://machine.tail.ts.net/", "abc"), "https://machine.tail.ts.net/mcp?key=abc");
+});

package/dist/daemon-state.d.ts

@@ -0,0 +1,22 @@
+export interface DaemonRuntime {
+    cliPid: number;
+    port: number;
+    publicMcpUrl: string;
+    localMcpUrl: string;
+    startedAt: string;
+    logFile: string;
+    tunnelProvider?: string;
+}
+export declare function runtimePath(): string;
+export declare function cliPidPath(): string;
+export declare function accessPath(): string;
+export declare function loadRuntime(): DaemonRuntime | null;
+export declare function saveRuntime(runtime: DaemonRuntime): void;
+export declare function clearRuntime(): void;
+export declare function isProcessAlive(pid: number): boolean;
+export declare function isDaemonRunning(): boolean;
+export interface McpAccessRecord {
+    at: string;
+    remote?: string | null;
+}
+export declare function loadLastMcpAccess(): McpAccessRecord | null;

package/dist/daemon-state.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { configDir } from "./paths.js";
+export function runtimePath() {
+    return path.join(configDir(), "runtime.json");
+}
+export function cliPidPath() {
+    return path.join(configDir(), "note-connector.pid");
+}
+export function accessPath() {
+    return path.join(configDir(), "last-mcp-access.json");
+}
+export function loadRuntime() {
+    const file = runtimePath();
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveRuntime(runtime) {
+    fs.mkdirSync(configDir(), { recursive: true });
+    fs.writeFileSync(runtimePath(), JSON.stringify(runtime, null, 2));
+}
+export function clearRuntime() {
+    for (const f of [runtimePath(), cliPidPath(), accessPath()]) {
+        try {
+            fs.rmSync(f, { force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isDaemonRunning() {
+    const rt = loadRuntime();
+    if (!rt)
+        return false;
+    return isProcessAlive(rt.cliPid);
+}
+export function loadLastMcpAccess() {
+    const file = accessPath();
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/daemon-worker.d.ts

@@ -0,0 +1,2 @@
+import { type StartOptions } from "./runtime.js";
+export declare function runDaemonWorker(opts: StartOptions, logFile: string): Promise<void>;

package/dist/daemon-worker.js

@@ -0,0 +1,110 @@
+/**
+ * Background worker: MCP + tunnel. Started detached by `note-connector`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { buildMcpEndpoint, loadConfig, loadOrCreateToken } from "./config.js";
+import { configDir } from "./paths.js";
+import { startPythonServer } from "./spawn-python.js";
+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 { ensureInitialized } from "./runtime.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;
+    }
+}
+function watchFirstChatGptAccess(sinceIso, logFile) {
+    let announced = false;
+    const tick = () => {
+        if (announced)
+            return;
+        const rec = loadLastMcpAccess();
+        if (rec && rec.at > sinceIso) {
+            announced = true;
+            const line = `\n✓ ChatGPT から MCP 接続を確認しました (${rec.at})\n`;
+            fs.appendFileSync(logFile, line);
+            process.stdout.write(line);
+        }
+    };
+    setInterval(tick, 2000);
+}
+export async function runDaemonWorker(opts, logFile) {
+    await ensureInitialized();
+    const startedAt = new Date().toISOString();
+    fs.writeFileSync(cliPidPath(), String(process.pid));
+    const config = loadConfig();
+    const port = await resolveGatewayPort(opts.port ?? config.gatewayPort, "127.0.0.1");
+    const tokenFile = path.join(configDir(), "token");
+    const token = loadOrCreateToken();
+    const tunnel = new TunnelManager();
+    const tunnelHostHint = config.tunnel.domain ?? (config.tunnel.publicUrl ? new URL(config.tunnel.publicUrl).host : undefined);
+    const child = startPythonServer({
+        host: "127.0.0.1",
+        port,
+        tokenFile,
+        tunnelHost: tunnelHostHint,
+    });
+    for (let i = 0; i < 60; i++) {
+        if (await verifyHealth(port))
+            break;
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    if (!opts.noTunnel) {
+        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;
+    saveRuntime({
+        cliPid: process.pid,
+        port,
+        publicMcpUrl: publicUrl,
+        localMcpUrl: localUrl,
+        startedAt,
+        logFile,
+        tunnelProvider: t.provider,
+    });
+    if (!isNoteAuthenticated() && !opts.skipNoteLogin) {
+        startNoteLoginInBackground();
+    }
+    watchFirstChatGptAccess(startedAt, logFile);
+    child.on("exit", (code) => {
+        if (code !== 0 && code !== null) {
+            fs.appendFileSync(logFile, `\nPython MCP exited: ${code}\n`);
+            process.exit(code ?? 1);
+        }
+    });
+    const shutdown = () => {
+        tunnel.stop();
+        child.kill("SIGTERM");
+        try {
+            fs.rmSync(cliPidPath(), { force: true });
+        }
+        catch {
+            /* ignore */
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => { });
+}
+const logFile = process.env.NOTE_CONNECTOR_LOG_FILE;
+if (logFile && process.env.NOTE_CONNECTOR_DAEMON_WORKER === "1") {
+    const opts = {
+        noTunnel: process.env.NOTE_CONNECTOR_NO_TUNNEL === "1",
+        skipNoteLogin: process.env.NOTE_CONNECTOR_SKIP_NOTE_LOGIN === "1",
+        port: process.env.NOTE_CONNECTOR_PORT ? parseInt(process.env.NOTE_CONNECTOR_PORT, 10) : undefined,
+    };
+    runDaemonWorker(opts, logFile).catch((e) => {
+        fs.appendFileSync(logFile, `\n${e.stack ?? e}\n`);
+        process.exit(1);
+    });
+}

package/dist/daemon.d.ts

@@ -0,0 +1,2 @@
+import type { StartOptions } from "./runtime.js";
+export declare function spawnDaemon(opts: StartOptions): Promise<void>;

package/dist/daemon.js

@@ -0,0 +1,117 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureConfigDir, configDir } from "./paths.js";
+import { isDaemonRunning, loadRuntime, loadLastMcpAccess, } from "./daemon-state.js";
+import { runOnboarding } from "./onboarding.js";
+import { isNoteAuthenticated } from "./note-auth.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function logsDir() {
+    const dir = path.join(configDir(), "logs");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function waitForRuntime(timeoutMs) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const tick = () => {
+            const rt = loadRuntime();
+            if (rt) {
+                resolve(rt);
+                return;
+            }
+            if (Date.now() - start > timeoutMs) {
+                resolve(null);
+                return;
+            }
+            setTimeout(tick, 400);
+        };
+        tick();
+    });
+}
+function waitForChatGptAccess(sinceIso, timeoutMs) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const tick = () => {
+            const rec = loadLastMcpAccess();
+            if (rec && rec.at > sinceIso) {
+                resolve(true);
+                return;
+            }
+            if (Date.now() - start > timeoutMs) {
+                resolve(false);
+                return;
+            }
+            setTimeout(tick, 1500);
+        };
+        tick();
+    });
+}
+export async function spawnDaemon(opts) {
+    if (isDaemonRunning()) {
+        const rt = loadRuntime();
+        console.log("note-connector はすでにバックグラウンドで動作中です。");
+        if (rt) {
+            console.log(`Public MCP: ${rt.publicMcpUrl}`);
+            console.log(`ログ: ${rt.logFile}`);
+            console.log("停止: note-connector stop / 状態: note-connector status");
+        }
+        return;
+    }
+    ensureConfigDir();
+    const logFile = path.join(logsDir(), "note-connector.log");
+    const worker = path.join(__dirname, "daemon-worker.js");
+    const env = {
+        ...process.env,
+        NOTE_CONNECTOR_DAEMON_WORKER: "1",
+        NOTE_CONNECTOR_LOG_FILE: logFile,
+        NOTE_CONNECTOR_NO_TUNNEL: opts.noTunnel ? "1" : "0",
+        NOTE_CONNECTOR_SKIP_NOTE_LOGIN: opts.skipNoteLogin ? "1" : "0",
+    };
+    if (opts.port)
+        env.NOTE_CONNECTOR_PORT = String(opts.port);
+    const out = fs.openSync(logFile, "a");
+    const child = spawn(process.execPath, [worker], {
+        detached: true,
+        stdio: ["ignore", out, out],
+        env,
+    });
+    child.unref();
+    console.log("バックグラウンドで起動中…");
+    const rt = await waitForRuntime(600_000);
+    if (!rt) {
+        console.error(`起動タイムアウト。ログ: ${logFile}`);
+        process.exit(1);
+    }
+    console.log("");
+    console.log("note-connector をバックグラウンドで起動しました");
+    console.log(`PID: ${rt.cliPid}`);
+    console.log(`ログ: ${rt.logFile}`);
+    console.log(`Local MCP: ${rt.localMcpUrl}`);
+    console.log(`Public MCP: ${rt.publicMcpUrl}`);
+    const noteOk = isNoteAuthenticated();
+    await runOnboarding({
+        publicMcpUrl: rt.publicMcpUrl,
+        localMcpUrl: rt.localMcpUrl,
+        noteAuthenticated: noteOk,
+        tunnelOk: rt.publicMcpUrl.startsWith("https://"),
+        noOpen: opts.noOpen,
+        noClipboard: opts.noClipboard,
+    });
+    console.log("");
+    console.log("ChatGPT からの初回接続を待っています（最大 600 秒）…");
+    const connected = await waitForChatGptAccess(rt.startedAt, 600_000);
+    if (connected) {
+        const rec = loadLastMcpAccess();
+        console.log(`✓ ChatGPT 接続成功${rec?.remote ? ` (${rec.remote})` : ""}`);
+        console.log("このターミナルは閉じて大丈夫です。サーバーはバックグラウンドで動き続けます。");
+    }
+    else {
+        console.log("まだ ChatGPT からの接続はありません。");
+        console.log("Connector 登録後に ChatGPT で使うと、ログに接続が記録されます。");
+        console.log("確認: note-connector status");
+    }
+    console.log("");
+    console.log("停止: note-connector stop");
+}