excalidrop 0.1.3 → 0.2.1

package/dist/cli.js

@@ -1,209 +1,205 @@
 #!/usr/bin/env node
-/**
- * excalidrop — per-project Excalidraw canvas + MCP server setup.
- *
- * Modelled on the `chrome-devtools-mcp` install pattern (`npx -y <pkg>` +
- * `mcpServers` JSON), with one addition: per-project dynamic port selection
- * so multiple checkouts can run their own canvas concurrently.
- *
- * How the dynamic port works:
- *  - `excalidrop init` picks a free port (default scan from 3030) and writes
- *    it to `.excalidrop.json` in the project root.
- *  - `excalidrop mcp` (what the AI agent runs via stdio) resolves that same
- *    file by walking up from cwd, so each project transparently gets its own
- *    canvas URL with nothing hardcoded in the agent config.
- *
- * Commands:
- *  init   pick a port, write .excalidrop.json + .mcp.json, offer agent install
- *  up     start the canvas server on this project's port
- *  mcp    run the MCP stdio server pointed at this project's canvas (for agents)
- *  status show resolved port + canvas health
- *  add    print / run AI-agent install commands
- */
-import { spawn, spawnSync } from 'node:child_process';
-import { createConnection } from 'node:net';
+import { spawn, spawnSync, execSync } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
-import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const CONFIG_NAME = '.excalidrop.json';
 const MCP_JSON = '.mcp.json';
-const SERVER_ENTRY = path.join(__dirname, 'server.js');
-const MCP_ENTRY = path.join(__dirname, 'index.js');
-const DEFAULT_START_PORT = 3030;
-const PORT_SCAN_SIZE = 200;
-// ─── port utils ──────────────────────────────────────────────────────────────
-function isPortFree(port, host = '127.0.0.1', timeoutMs = 300) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const socket = createConnection({ host, port });
-        const done = (free) => {
-            if (settled)
-                return;
-            settled = true;
-            socket.destroy();
-            resolve(free);
-        };
-        socket.setTimeout(timeoutMs);
-        socket.once('connect', () => done(false)); // something listens → taken
-        socket.once('timeout', () => done(true));
-        socket.once('error', () => done(true)); // ECONNREFUSED → free
+const RELAY_DEFAULT = 'https://excalidrop.wtf403.workers.dev';
+const GH_API = 'https://api.github.com';
+const SCENE_PATH = process.env.SCENE_PATH || 'canvas.excalidraw';
+const CANVAS_BRANCH = process.env.CANVAS_BRANCH || 'excalidrop';
+const PAGES_BRANCH = process.env.PAGES_BRANCH || 'excalidrop';
+function ghToken() {
+    if (process.env.GITHUB_TOKEN)
+        return process.env.GITHUB_TOKEN;
+    try {
+        return execSync('gh auth token', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function ghHeaders() {
+    return { Authorization: `Bearer ${ghToken()}`, Accept: 'application/vnd.github+json', 'User-Agent': 'excalidrop-setup', 'Content-Type': 'application/json' };
+}
+async function ghGet(pathname) {
+    const r = await fetch(`${GH_API}${pathname}`, { headers: ghHeaders() });
+    if (!r.ok)
+        throw new Error(`GitHub GET ${pathname} → ${r.status}: ${(await r.text()).slice(0, 150)}`);
+    return r.json();
+}
+async function ghPut(pathname, body) {
+    const r = await fetch(`${GH_API}${pathname}`, { method: 'PUT', headers: ghHeaders(), body: JSON.stringify(body) });
+    if (!r.ok)
+        throw new Error(`GitHub PUT ${pathname} → ${r.status}: ${(await r.text()).slice(0, 150)}`);
+    return r.json();
+}
+async function ensureMainBranch(repo) {
+    const main = await fetch(`${GH_API}/repos/${repo}/git/ref/heads/main`, { headers: ghHeaders() });
+    if (main.ok)
+        return;
+    const branches = await (await fetch(`${GH_API}/repos/${repo}/branches`, { headers: ghHeaders() })).json();
+    if (branches.length !== 0)
+        return;
+    await ghPut(`/repos/${repo}/contents/README.md`, {
+        message: 'Initial commit',
+        content: Buffer.from(`# ${repo.split('/')[1]}\n\nExcalidraw canvas powered by [excalidrop](https://github.com/wtf403/excalidrop).\n`).toString('base64'),
+        branch: 'main',
     });
 }
-async function findFreePort(preferred, start = DEFAULT_START_PORT) {
-    if (preferred && preferred > 0 && preferred < 65536 && (await isPortFree(preferred))) {
-        return preferred;
+async function getScene(repo) {
+    const r = await fetch(`${GH_API}/repos/${repo}/contents/${SCENE_PATH}?ref=${CANVAS_BRANCH}`, { headers: ghHeaders() });
+    if (r.status === 404)
+        return { elements: [], sha: null };
+    if (!r.ok)
+        throw new Error(`scene read ${r.status}`);
+    const j = await r.json();
+    let b64 = typeof j.content === 'string' && j.content.length ? j.content : null;
+    if (!b64) {
+        const blob = await fetch(`${GH_API}/repos/${repo}/git/blobs/${j.sha}`, { headers: ghHeaders() });
+        if (blob.ok)
+            b64 = (await blob.json()).content || null;
     }
-    for (let port = start; port < start + PORT_SCAN_SIZE; port++) {
-        if (await isPortFree(port))
-            return port;
+    if (!b64)
+        return { elements: [], sha: j.sha || null };
+    return { elements: (JSON.parse(Buffer.from(b64, 'base64').toString('utf8')).elements || []), sha: j.sha };
+}
+async function putScene(repo, elements, sha, message) {
+    const body = {
+        message,
+        content: Buffer.from(JSON.stringify({ type: 'excalidraw', version: 2, source: 'excalidrop', elements, appState: { viewBackgroundColor: '#ffffff', gridSize: null }, files: {} }, null, 2)).toString('base64'),
+        branch: CANVAS_BRANCH,
+    };
+    if (sha)
+        body.sha = sha;
+    const r = await fetch(`${GH_API}/repos/${repo}/contents/${SCENE_PATH}`, { method: 'PUT', headers: ghHeaders(), body: JSON.stringify(body) });
+    if (r.status === 404) {
+        // create the branch from default, then retry once
+        const info = await ghGet(`/repos/${repo}`);
+        const from = info.default_branch || 'main';
+        const ref = await ghGet(`/repos/${repo}/git/ref/heads/${from}`);
+        await fetch(`${GH_API}/repos/${repo}/git/refs`, { method: 'POST', headers: ghHeaders(), body: JSON.stringify({ ref: `refs/heads/${CANVAS_BRANCH}`, sha: ref.object.sha }) });
+        const retry = await fetch(`${GH_API}/repos/${repo}/contents/${SCENE_PATH}`, { method: 'PUT', headers: ghHeaders(), body: JSON.stringify(body) });
+        if (!retry.ok)
+            throw new Error(`scene write ${retry.status}`);
+        return;
     }
-    // Fallback: random high port
-    for (let i = 0; i < 50; i++) {
-        const port = 32000 + Math.floor(Math.random() * 2000);
-        if (await isPortFree(port))
-            return port;
+    if (!r.ok)
+        throw new Error(`scene write ${r.status}: ${(await r.text()).slice(0, 150)}`);
+}
+function viewerDir() {
+    // dist/cli.js → dist/frontend; fallback to checkout layout.
+    const cands = [path.join(__dirname, 'frontend'), path.join(process.cwd(), 'dist', 'frontend')];
+    for (const d of cands) {
+        if (fs.existsSync(path.join(d, 'index.html')) && fs.existsSync(path.join(d, 'assets')))
+            return d;
     }
-    throw new Error('Could not find a free port for the excalidrop canvas server.');
+    throw new Error('Viewer build not found (dist/frontend). Reinstall excalidrop or run `npm run build:frontend` in the excalidrop checkout.');
 }
-// ─── config discovery ────────────────────────────────────────────────────────
-function findProjectRoot(cwd) {
-    let dir = path.resolve(cwd);
-    const home = process.env.HOME || process.env.USERPROFILE || '/';
-    while (true) {
-        if (fs.existsSync(path.join(dir, 'package.json')) || fs.existsSync(path.join(dir, '.git'))) {
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir || dir === home)
-            return path.resolve(cwd);
-        dir = parent;
+function listFilesRecursive(dir, base = dir) {
+    const out = [];
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            out.push(...listFilesRecursive(full, base));
+        else if (e.isFile())
+            out.push(path.relative(base, full));
     }
+    return out;
 }
-function findDropConfig(cwd) {
-    let dir = path.resolve(cwd);
-    const root = path.parse(dir).root;
-    while (true) {
-        const file = path.join(dir, CONFIG_NAME);
-        if (fs.existsSync(file)) {
-            try {
-                const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
-                if (typeof raw.port === 'number') {
-                    return {
-                        dir,
-                        config: {
-                            port: raw.port,
-                            canvasUrl: raw.canvasUrl || `http://127.0.0.1:${raw.port}`,
-                        },
-                    };
-                }
-            }
-            catch {
-                // corrupt config → ignore, treat as missing
-            }
+async function deployViewerPages(repo) {
+    const dir = viewerDir();
+    const files = listFilesRecursive(dir);
+    const blob = async (content) => (await (await fetch(`${GH_API}/repos/${repo}/git/blobs`, { method: 'POST', headers: ghHeaders(), body: JSON.stringify({ content, encoding: 'base64' }) })).json()).sha;
+    const tree = [];
+    const pool = 8;
+    let i = 0;
+    await Promise.all(Array.from({ length: Math.min(pool, files.length) }, async () => {
+        while (i < files.length) {
+            const rel = files[i++];
+            tree.push({ path: rel.split(path.sep).join('/'), mode: '100644', type: 'blob', sha: await blob(fs.readFileSync(path.join(dir, rel)).toString('base64')) });
         }
-        if (dir === root)
-            return null;
-        dir = path.dirname(dir);
+    }));
+    tree.push({ path: '.nojekyll', mode: '100644', type: 'blob', sha: await blob('') });
+    let baseSha = null;
+    let baseTree = null;
+    try {
+        const ref = await ghGet(`/repos/${repo}/git/ref/heads/${PAGES_BRANCH}`);
+        baseSha = ref.object.sha;
+        baseTree = (await ghGet(`/repos/${repo}/git/commits/${baseSha}`)).tree.sha;
+    }
+    catch { /* first deploy — root commit */ }
+    const newTree = await (await fetch(`${GH_API}/repos/${repo}/git/trees`, { method: 'POST', headers: ghHeaders(), body: JSON.stringify({ ...(baseTree ? { base_tree: baseTree } : {}), tree }) })).json();
+    const commit = await (await fetch(`${GH_API}/repos/${repo}/git/commits`, { method: 'POST', headers: ghHeaders(), body: JSON.stringify({ message: 'excalidrop: publish viewer', tree: newTree.sha, ...(baseSha ? { parents: [baseSha] } : { parents: [] }) }) })).json();
+    if (baseSha)
+        await fetch(`${GH_API}/repos/${repo}/git/refs/heads/${PAGES_BRANCH}`, { method: 'PATCH', headers: ghHeaders(), body: JSON.stringify({ sha: commit.sha, force: true }) });
+    else
+        await fetch(`${GH_API}/repos/${repo}/git/refs`, { method: 'POST', headers: ghHeaders(), body: JSON.stringify({ ref: `refs/heads/${PAGES_BRANCH}`, sha: commit.sha }) });
+    // API commits don't reliably queue builds — request one explicitly.
+    try {
+        const cur = await fetch(`${GH_API}/repos/${repo}/pages`, { headers: ghHeaders() });
+        if (!cur.ok || (await cur.json())?.source?.branch !== PAGES_BRANCH) {
+            const up = await fetch(`${GH_API}/repos/${repo}/pages`, { method: 'PUT', headers: ghHeaders(), body: JSON.stringify({ source: { branch: PAGES_BRANCH, path: '/' } }) });
+            if (!up.ok)
+                await fetch(`${GH_API}/repos/${repo}/pages`, { method: 'POST', headers: ghHeaders(), body: JSON.stringify({ source: { branch: PAGES_BRANCH, path: '/' } }) });
+        }
+        await fetch(`${GH_API}/repos/${repo}/pages/builds`, { method: 'POST', headers: ghHeaders() });
+    }
+    catch { /* Pages setup is best-effort */ }
+}
+function projectNameForRepo(repo) {
+    return `excalidrop-${repo.replace('/', '-').toLowerCase().replace(/[^a-z0-9-]/g, '-')}`.slice(0, 60);
+}
+function viewerUrlFor(repo, target) {
+    if (target === 'cloudflare') {
+        // Generic viewer build can't infer the repo from a pages.dev host —
+        // detectRepo() reads it from ?repo= instead.
+        return `https://${projectNameForRepo(repo)}.pages.dev/?repo=${repo}`;
     }
+    const [owner, name] = repo.split('/');
+    return `https://${owner}.github.io/${name}/`;
 }
-function portFromExpressUrl(url) {
-    if (!url)
-        return undefined;
+async function isPrivateRepo(repo) {
     try {
-        const port = Number(new URL(url).port);
-        return Number.isFinite(port) && port > 0 ? port : undefined;
+        const r = spawnSync('gh', ['api', `repos/${repo}`, '--jq', '.private'], { encoding: 'utf8' });
+        if (r.status !== 0)
+            return null;
+        if (r.stdout.trim() === 'true')
+            return true;
+        if (r.stdout.trim() === 'false')
+            return false;
+        return null;
     }
     catch {
-        return undefined;
-    }
-}
-/** Resolve this project's canvas port without side effects (used by `mcp`). */
-function resolveSavedPort(cwd) {
-    const envPort = Number(process.env.EXCALIDROP_PORT);
-    if (Number.isFinite(envPort) && envPort > 0)
-        return envPort;
-    const envUrlPort = portFromExpressUrl(process.env.EXPRESS_SERVER_URL);
-    if (envUrlPort)
-        return envUrlPort;
-    const found = findDropConfig(cwd);
-    if (found)
-        return found.config.port;
-    return DEFAULT_START_PORT;
-}
-// ─── agent config snippets (chrome-devtools-mcp style) ───────────────────────
-function mcpServerJson() {
-    // No hardcoded port: `excalidrop mcp` resolves `.excalidrop.json` at runtime,
-    // so the same snippet works for every project, concurrently.
-    return {
-        mcpServers: {
-            excalidrop: {
-                command: 'npx',
-                args: ['excalidrop', 'mcp'],
-            },
-        },
-    };
+        return null;
+    }
 }
-function agentCommands() {
-    return [
-        {
-            name: 'Claude Code (project scope)',
-            command: 'claude mcp add excalidrop --scope project -- npx excalidrop mcp',
-        },
-        {
-            name: 'Claude Code (user scope)',
-            command: 'claude mcp add excalidraw --scope user -- npx excalidrop mcp',
-        },
-        {
-            name: 'Codex CLI',
-            command: 'codex mcp add excalidrop -- npx excalidrop mcp',
-        },
-        {
-            name: 'Gemini CLI',
-            command: 'gemini mcp add excalidrop npx excalidrop mcp',
-        },
-        {
-            name: 'Cursor (.cursor/mcp.json) / Claude Desktop / Antigravity',
-            command: JSON.stringify(mcpServerJson(), null, 2),
-        },
-        {
-            name: 'OpenCode (opencode.json)',
-            command: JSON.stringify({
-                $schema: 'https://opencode.ai/config.json',
-                mcp: {
-                    excalidrop: {
-                        type: 'local',
-                        command: ['npx', 'excalidrop', 'mcp'],
-                        enabled: true,
-                    },
-                },
-            }, null, 2),
-        },
-    ];
-}
-function prompt(question) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise((resolve) => {
-        rl.question(question, (answer) => {
-            rl.close();
-            resolve(answer.trim());
-        });
-    });
+async function resolveTarget(repo, explicit) {
+    if (explicit === 'pages' || explicit === 'cloudflare')
+        return explicit;
+    return (await isPrivateRepo(repo)) === true ? 'cloudflare' : 'pages';
 }
-function commandExists(cmd) {
-    const probe = spawnSync(process.platform === 'win32' ? 'where' : 'command', ['-v', cmd], {
-        stdio: 'ignore',
-        shell: process.platform === 'win32',
-    });
-    return probe.status === 0;
+function deployToCloudflarePages(project) {
+    // wrangler 4 doesn't auto-create Pages projects and its Workers delegation
+    // misfires on explicit asset dirs — create once, then deploy classic with --force.
+    const WRANGLER = ['-y', 'wrangler@4'];
+    const create = spawnSync('npx', [...WRANGLER, 'pages', 'project', 'create', project, '--force', '--production-branch=main'], { stdio: 'pipe', encoding: 'utf8', env: process.env });
+    const createOut = (create.stdout || '') + (create.stderr || '');
+    if (create.status !== 0 && !/already exists/i.test(createOut)) {
+        throw new Error(`wrangler pages project create failed:\n${createOut.slice(-800)}\nRun \`wrangler login\` first (or set CLOUDFLARE_API_TOKEN).`);
+    }
+    const r = spawnSync('npx', [...WRANGLER, 'pages', 'deploy', viewerDir(), '--project-name', project, '--force'], { stdio: 'inherit', env: process.env });
+    if (r.status !== 0)
+        throw new Error('wrangler pages deploy failed. Run `wrangler login` first (or set CLOUDFLARE_API_TOKEN).');
 }
-// ─── commands ────────────────────────────────────────────────────────────────
 function detectSlug() {
     try {
         const url = spawnSync('git', ['config', '--get', 'remote.origin.url'], { encoding: 'utf8' }).stdout.trim().replace(/\.git$/, '');
-        return url.match(/github\.com[:/](.+)/)?.[1] || '';
+        return url.match(/github\.com[:/](.+)/)?.[1]?.toLowerCase() || '';
     }
     catch {
         return '';
@@ -212,30 +208,127 @@ function detectSlug() {
 function ghAuthed() {
     return spawnSync('gh', ['auth', 'status'], { stdio: 'ignore' }).status === 0;
 }
-async function cmdInit(args) {
-    const portFlag = args.find((a) => a.startsWith('--port='));
-    const preferred = portFlag ? Number(portFlag.split('=')[1]) : undefined;
-    const noPrompt = args.includes('--no-prompt') || args.includes('-y');
+function commandExists(cmd) {
+    const probe = spawnSync(process.platform === 'win32' ? 'where' : 'command', ['-v', cmd], { stdio: 'ignore', shell: process.platform === 'win32' });
+    return probe.status === 0;
+}
+function findProjectRoot(cwd) {
+    let dir = path.resolve(cwd);
+    const home = process.env.HOME || process.env.USERPROFILE || '/';
+    while (true) {
+        if (fs.existsSync(path.join(dir, 'package.json')) || fs.existsSync(path.join(dir, '.git')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir || dir === home)
+            return path.resolve(cwd);
+        dir = parent;
+    }
+}
+function mcpArgs(repo) {
+    return ['-y', 'excalidrop@latest', 'mcp', '--repo', repo];
+}
+const EDITOR_IDS = ['claude-project', 'claude-user', 'codex', 'cursor', 'desktop', 'opencode'];
+function editorCommand(id, repo) {
+    const a = mcpArgs(repo).join(' ');
+    switch (id) {
+        case 'claude-project': return `claude mcp add excalidrop --scope project -- npx ${a}`;
+        case 'claude-user': return `claude mcp add excalidrop --scope user -- npx ${a}`;
+        case 'codex': return `codex mcp add excalidrop -- npx ${a}`;
+        case 'cursor': return JSON.stringify({ mcpServers: { excalidrop: { command: 'npx', args: mcpArgs(repo) } } }, null, 2);
+        case 'desktop': return JSON.stringify({ mcpServers: { excalidrop: { command: 'npx', args: mcpArgs(repo) } } }, null, 2);
+        case 'opencode': return JSON.stringify({ $schema: 'https://opencode.ai/config.json', mcp: { excalidrop: { type: 'local', command: ['npx', ...mcpArgs(repo)], enabled: true } } }, null, 2);
+    }
+}
+function installEditor(id, repo) {
+    try {
+        if (id === 'claude-project' && commandExists('claude')) {
+            return spawnSync('claude', ['mcp', 'add', 'excalidrop', '--scope', 'project', '--', 'npx', ...mcpArgs(repo)], { stdio: 'ignore' }).status === 0;
+        }
+        if (id === 'claude-user' && commandExists('claude')) {
+            return spawnSync('claude', ['mcp', 'add', 'excalidrop', '--scope', 'user', '--', 'npx', ...mcpArgs(repo)], { stdio: 'ignore' }).status === 0;
+        }
+        if (id === 'codex' && commandExists('codex')) {
+            return spawnSync('codex', ['mcp', 'add', 'excalidrop', '--', 'npx', ...mcpArgs(repo)], { stdio: 'ignore' }).status === 0;
+        }
+    }
+    catch { /* fall through to manual */ }
+    return false;
+}
+const EDITOR_LABELS = {
+    'claude-project': 'Claude Code (project scope)',
+    'claude-user': 'Claude Code (user scope)',
+    codex: 'Codex CLI',
+    cursor: 'Cursor (.cursor/mcp.json)',
+    desktop: 'Claude Desktop',
+    opencode: 'OpenCode (opencode.json)',
+};
+function printEditorCommands(ids, repo) {
+    console.log('Add excalidrop to your AI agent (no install, always latest):\n');
+    for (const id of ids)
+        console.log(`## ${EDITOR_LABELS[id]}\n${editorCommand(id, repo)}\n`);
+}
+function parseFlag(args, name) {
+    const eq = args.find((a) => a.startsWith(`--${name}=`));
+    if (eq)
+        return eq.split('=').slice(1).join('=');
+    const i = args.indexOf(`--${name}`);
+    if (i !== -1 && args[i + 1] && !args[i + 1].startsWith('-'))
+        return args[i + 1];
+    return undefined;
+}
+function parseEditorsFlag(args) {
+    const raw = parseFlag(args, 'editor');
+    if (!raw)
+        return null;
+    const ids = raw.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const valid = ids.filter((s) => EDITOR_IDS.includes(s));
+    if (!valid.length) {
+        console.error(`Unknown --editor value. Use comma-separated: ${EDITOR_IDS.join(',')}`);
+        process.exit(1);
+    }
+    return valid;
+}
+async function cmdSetup(args, editorOverride) {
+    const positional = args.find((a) => !a.startsWith('-') && a.includes('/'));
+    const slug = parseFlag(args, 'repo') || positional || detectSlug();
+    if (!slug || !/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(slug)) {
+        console.error('Usage: npx excalidrop setup owner/repo [--target pages|cloudflare] [--editor claude-project,codex] [--no-prompt]');
+        process.exit(1);
+    }
+    if (!ghAuthed() && !process.env.GITHUB_TOKEN) {
+        console.error('Not logged in to GitHub. Run `gh auth login` or `npx excalidrop login` first.');
+        process.exit(1);
+    }
+    try {
+        await ghGet(`/repos/${slug}`);
+    }
+    catch (e) {
+        if (String(e.message).includes('→ 404')) {
+            console.error(`Repo "${slug}" not found (404). Check the slug for typos, or create it:\n\n  gh repo create ${slug} --private   # or --public\n`);
+            process.exit(1);
+        }
+        throw e;
+    }
+    const explicitTarget = parseFlag(args, 'target');
+    const target = await resolveTarget(slug, explicitTarget);
+    console.log(`Repo: ${slug}\nHost: ${target}${explicitTarget ? ' (explicit)' : ' (auto: private→cloudflare, public→pages)'}\n`);
+    await ensureMainBranch(slug);
+    const scene = await getScene(slug).catch(() => ({ elements: [], sha: null }));
+    if (!scene.sha) {
+        await putScene(slug, [], null, 'excalidrop: init canvas');
+        console.log('Empty canvas created on branch excalidrop.');
+    }
+    let viewerUrl;
+    if (target === 'pages') {
+        await deployViewerPages(slug);
+        viewerUrl = viewerUrlFor(slug, 'pages');
+    }
+    else {
+        deployToCloudflarePages(projectNameForRepo(slug));
+        viewerUrl = viewerUrlFor(slug, 'cloudflare');
+    }
     const root = findProjectRoot(process.cwd());
-    const slug = detectSlug();
-    const port = await findFreePort(preferred);
-    // Preselect this repo as the remote canvas: the MCP auto-loads it, so the
-    // agent never needs switch_remote for its home project (chrome-devtools-mcp
-    // wrapper pattern: in-memory default + persisted startup target — ours
-    // persists in .excalidrop.json so it survives restarts too).
-    const config = { port, canvasUrl: `http://127.0.0.1:${port}`, ...(slug ? { remote: slug } : {}) };
-    fs.writeFileSync(path.join(root, CONFIG_NAME), JSON.stringify(config, null, 2) + '\n');
-    console.log(`\nexcalidrop: canvas port ${port} saved to ${path.join(root, CONFIG_NAME)}`);
-    if (slug)
-        console.log(`excalidrop: remote canvas preselected: ${slug} (agent uses it automatically)`);
-    // Seed canvas.excalidraw so `npm i -D excalidrop` leaves a visible file
-    // that export_scene/import_scene round-trip through.
-    const scenePath = path.join(root, 'canvas.excalidraw');
-    if (!fs.existsSync(scenePath)) {
-        fs.writeFileSync(scenePath, JSON.stringify({ type: 'excalidraw', version: 2, source: 'excalidrop', elements: [], appState: { viewBackgroundColor: '#ffffff', gridSize: null }, files: {} }, null, 2) + '\n');
-        console.log(`excalidrop: empty scene written to ${scenePath}`);
-    }
-    // Merge into .mcp.json (generic MCP clients + Claude Code project scope)
+    fs.writeFileSync(path.join(root, CONFIG_NAME), JSON.stringify({ remote: slug, target, viewerUrl }, null, 2) + '\n');
     const mcpPath = path.join(root, MCP_JSON);
     let mcp = {};
     if (fs.existsSync(mcpPath)) {
@@ -243,291 +336,247 @@ async function cmdInit(args) {
             mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
         }
         catch {
-            console.warn(`excalidrop: existing ${MCP_JSON} is not valid JSON, leaving it untouched.`);
+            console.warn(`Existing ${MCP_JSON} is not valid JSON, leaving it untouched.`);
         }
     }
     if (!mcp.mcpServers || typeof mcp.mcpServers !== 'object')
         mcp.mcpServers = {};
-    mcp.mcpServers.excalidrop = { command: 'npx', args: ['excalidrop', 'mcp'] };
-    if (Object.keys(mcp).length > 0) {
-        fs.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + '\n');
-        console.log(`excalidrop: MCP server entry written to ${mcpPath}`);
-    }
-    console.log('\nStart the canvas for this project with:');
-    console.log(`  npx excalidrop up   # ${config.canvasUrl}\n`);
+    mcp.mcpServers.excalidrop = { command: 'npx', args: mcpArgs(slug), env: { EXCALIDROP_RELAY_URL: process.env.EXCALIDROP_RELAY_URL || RELAY_DEFAULT } };
+    fs.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + '\n');
+    console.log(`MCP entry written to ${mcpPath}`);
+    const editors = editorOverride || parseEditorsFlag(args) || [...EDITOR_IDS];
+    const noPrompt = args.includes('--no-prompt') || args.includes('-y');
     if (noPrompt) {
-        printAgentCommands();
-        return;
+        const installed = [];
+        const manual = [];
+        for (const id of editors)
+            (installEditor(id, slug) ? installed : manual).push(id);
+        if (installed.length)
+            console.log(`Installed into: ${installed.map((i) => EDITOR_LABELS[i]).join(', ')}`);
+        if (manual.length)
+            printEditorCommands(manual, slug);
+        return { repo: slug, viewerUrl };
     }
-    // Guided remote setup: gh auth → publish empty canvas → agent install → login
-    if (slug) {
-        if (!ghAuthed()) {
-            console.log('GitHub: not logged in. Run `gh auth login` first (2FA via GitHub), then re-run init.\n');
-        }
-        else {
-            const pub = await prompt(`Publish an empty canvas to ${slug} (creates gh-pages + enables Pages)? [Y/n] `);
-            if (!pub || /^(y|yes)$/i.test(pub)) {
-                const r = spawnSync('bash', [path.join(__dirname, '../scripts/publish-pages.sh')], {
-                    stdio: 'inherit', env: { ...process.env, REPO_SLUG: slug },
-                });
-                if (r.status === 0) {
-                    const [owner, repo] = slug.split('/');
-                    console.log(`\nCanvas live at https://${owner}.github.io/${repo}/`);
-                    const appSlug = process.env.EXCALIDROP_APP_SLUG || 'excalidrop';
-                    console.log(`Install the app once per repo: https://github.com/apps/${appSlug}/installations/new`);
-                }
-            }
+    return { repo: slug, viewerUrl };
+}
+function cmdMcp() {
+    const child = spawn(process.execPath, [path.join(__dirname, 'mcp.js'), ...process.argv.slice(3)], { stdio: 'inherit', env: process.env });
+    child.on('exit', (code) => process.exit(code ?? 0));
+}
+async function cmdLogin() {
+    const clientId = process.env.GITHUB_OAUTH_CLIENT_ID || 'Iv23liuS2fx3QOEIoDmx';
+    console.log('Starting GitHub device login…');
+    const dev = await (await fetch('https://github.com/login/device/code', {
+        method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+        body: JSON.stringify({ client_id: clientId }),
+    })).json();
+    console.log(`\nOpen ${dev.verification_uri} and enter code: ${dev.user_code}\n`);
+    const deadline = Date.now() + 300_000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, (dev.interval || 5) * 1000));
+        const j = await (await fetch('https://github.com/login/oauth/access_token', {
+            method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+            body: JSON.stringify({ client_id: clientId, device_code: dev.device_code, grant_type: 'urn:ietf:params:oauth:grant-type:device_code' }),
+        })).json();
+        if (j.access_token) {
+            const dir = path.join(os.homedir(), '.config', 'excalidrop');
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, 'gh_token'), j.access_token + '\n', { mode: 0o600 });
+            console.log('Logged in — token stored in ~/.config/excalidrop/gh_token');
+            return;
         }
+        if (j.error && j.error !== 'authorization_pending' && j.error !== 'slow_down')
+            throw new Error(j.error_description || j.error);
     }
-    const answer = await prompt('Install the excalidrop MCP server into your AI agent now? [Y/n] ');
-    if (answer && !/^(y|yes)$/i.test(answer)) {
-        printAgentCommands();
+    throw new Error('device login timed out');
+}
+async function cmdStatus() {
+    const flag = process.argv.find((a) => a.startsWith('--repo='));
+    const repo = flag ? flag.split('=').slice(1).join('=') : detectSlug();
+    console.log(`repo: ${repo || '(none — run setup or pass --repo=owner/repo)'}`);
+    console.log(`auth: ${ghToken() ? 'ok (env/gh CLI/stored)' : 'missing — run `gh auth login` or `npx excalidrop login`'}`);
+    console.log(`relay: ${process.env.EXCALIDROP_RELAY_URL || RELAY_DEFAULT}`);
+    if (!repo || !ghToken())
         return;
+    try {
+        const scene = await getScene(repo);
+        console.log(`scene: ${scene.elements.length} elements @${CANVAS_BRANCH}`);
     }
-    // Try the CLIs that exist; fall back to printing snippets.
-    let installed = false;
-    if (commandExists('claude')) {
-        const scopeAnswer = await prompt('Claude Code scope? [project/user] (default: project) ');
-        const scope = /user/i.test(scopeAnswer) ? 'user' : 'project';
-        const r = spawnSync('claude', ['mcp', 'add', 'excalidrop', '--scope', scope, '--', 'npx', 'excalidrop', 'mcp'], {
-            stdio: 'inherit',
-        });
-        installed = r.status === 0;
-    }
-    if (!installed && commandExists('codex')) {
-        const useIt = await prompt('Run `codex mcp add excalidrop`? [Y/n] ');
-        if (!useIt || /^(y|yes)$/i.test(useIt)) {
-            const r = spawnSync('codex', ['mcp', 'add', 'excalidrop', '--', 'npx', 'excalidrop', 'mcp'], {
-                stdio: 'inherit',
-            });
-            installed = r.status === 0;
-        }
+    catch (e) {
+        console.log(`scene: unreachable (${e.message})`);
     }
-    if (!installed)
-        printAgentCommands();
 }
-function printAgentCommands() {
-    console.log('Add excalidrop to your AI agent (same pattern as chrome-devtools-mcp):\n');
-    for (const c of agentCommands()) {
-        console.log(`## ${c.name}\n${c.command}\n`);
+async function runTui() {
+    let clack;
+    try {
+        clack = await import('@clack/prompts');
     }
-}
-async function cmdUp(args) {
-    const portFlag = args.find((a) => a.startsWith('--port='));
-    const preferred = portFlag ? Number(portFlag.split('=')[1]) : undefined;
-    const root = findProjectRoot(process.cwd());
-    const existing = findDropConfig(process.cwd());
-    // Reuse the saved port if it's still free (stable URL per project),
-    // otherwise claim a new one so concurrent projects never collide.
-    let port;
-    if (preferred) {
-        port = await findFreePort(preferred);
+    catch {
+        console.error('TUI needs @clack/prompts. Run instead: npx excalidrop setup owner/repo');
+        process.exit(1);
     }
-    else if (existing && (await isPortFree(existing.config.port))) {
-        port = existing.config.port;
+    clack.intro('excalidrop — remote canvas setup');
+    const detected = detectSlug();
+    const repoAnswer = await clack.text({
+        message: 'Which repo holds the canvas?',
+        placeholder: detected || 'owner/repo',
+        initialValue: detected || '',
+        validate: (v) => (/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(v.trim()) ? undefined : 'Use owner/repo'),
+    });
+    if (clack.isCancel(repoAnswer)) {
+        clack.cancel('Aborted.');
+        process.exit(0);
     }
-    else {
-        port = await findFreePort(existing?.config.port ?? DEFAULT_START_PORT);
-    }
-    fs.writeFileSync(path.join(existing?.dir ?? root, CONFIG_NAME), JSON.stringify({ port, canvasUrl: `http://127.0.0.1:${port}` }, null, 2) + '\n');
-    const host = process.env.HOST || '127.0.0.1';
-    console.log(`excalidrop: starting canvas on http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${port}`);
-    const child = spawn(process.execPath, [SERVER_ENTRY], {
-        stdio: 'inherit',
-        env: { ...process.env, PORT: String(port), HOST: host },
+    const slug = repoAnswer.trim().toLowerCase();
+    const priv = await isPrivateRepo(slug);
+    if (priv !== null)
+        clack.log.info(`Repo is ${priv ? 'private' : 'public'} — recommended host: ${priv ? 'Cloudflare Pages' : 'GitHub Pages'}.`);
+    if (!ghAuthed() && !process.env.GITHUB_TOKEN) {
+        const how = await clack.select({
+            message: 'GitHub auth missing. How to log in?',
+            options: [
+                { value: 'retry', label: 'I ran `gh auth login` (re-check)' },
+                { value: 'device', label: 'Device flow (code + browser, 2FA ok)' },
+                { value: 'skip', label: 'Skip (I set GITHUB_TOKEN later)' },
+            ],
+        });
+        if (clack.isCancel(how)) {
+            clack.cancel('Aborted.');
+            process.exit(0);
+        }
+        if (how === 'device') {
+            const s = clack.spinner();
+            s.start('Waiting for browser approval…');
+            try {
+                await cmdLogin();
+                s.stop('Logged in.');
+            }
+            catch (e) {
+                s.stop('Login failed: ' + e.message);
+                process.exit(1);
+            }
+        }
+        else if (how === 'retry' && !ghAuthed() && !process.env.GITHUB_TOKEN) {
+            clack.log.error('Still not logged in. Run `gh auth login` first.');
+            process.exit(1);
+        }
+    }
+    const auto = await resolveTarget(slug);
+    const hostAnswer = await clack.select({
+        message: `Where to host the viewer? (auto: ${auto})`,
+        options: [
+            { value: 'auto', label: `Auto — ${auto === 'pages' ? 'GitHub Pages (public repo)' : 'Cloudflare Pages (private repo)'}`, hint: 'recommended' },
+            { value: 'pages', label: 'GitHub Pages', hint: 'public repos, zero config' },
+            { value: 'cloudflare', label: 'Cloudflare Pages', hint: 'private repos' },
+        ],
     });
-    child.on('exit', (code) => process.exit(code ?? 0));
-}
-function cmdMcp() {
-    // What the agent runs over stdio. Port resolves per-project at runtime.
-    const port = resolveSavedPort(process.cwd());
-    const canvasUrl = process.env.EXPRESS_SERVER_URL || `http://127.0.0.1:${port}`;
-    const child = spawn(process.execPath, [MCP_ENTRY], {
-        stdio: 'inherit',
-        env: { ...process.env, EXPRESS_SERVER_URL: canvasUrl },
+    if (clack.isCancel(hostAnswer)) {
+        clack.cancel('Aborted.');
+        process.exit(0);
+    }
+    const target = (hostAnswer === 'auto' ? auto : hostAnswer);
+    const editorAnswer = await clack.multiselect({
+        message: 'Install the MCP server into which editors?',
+        options: Object.keys(EDITOR_LABELS).map((id) => ({ value: id, label: EDITOR_LABELS[id] })),
+        initialValues: ['claude-project', 'codex'],
+        required: false,
     });
-    child.on('exit', (code) => process.exit(code ?? 0));
-}
-async function cmdStatus() {
-    const found = findDropConfig(process.cwd());
-    const port = found?.config.port ?? resolveSavedPort(process.cwd());
-    const url = process.env.EXPRESS_SERVER_URL || `http://127.0.0.1:${port}`;
-    console.log(`config: ${found ? path.join(found.dir, CONFIG_NAME) : '(none — using defaults)'}`);
-    console.log(`canvas: ${url}`);
+    if (clack.isCancel(editorAnswer)) {
+        clack.cancel('Aborted.');
+        process.exit(0);
+    }
+    const editors = editorAnswer;
+    const s = clack.spinner();
+    s.start('Publishing viewer + wiring MCP…');
+    let viewerUrl;
     try {
-        const res = await fetch(`${url}/health`);
-        console.log(`health: ${res.ok ? 'ok' : `HTTP ${res.status}`} ${res.ok ? '' : await res.text()}`);
-        if (res.ok)
-            console.log(await res.text());
-    }
-    catch (err) {
-        console.log(`health: unreachable (${err.message}) — start it with \`npx excalidrop up\``);
-    }
-}
-async function cmdPages(_args) {
-    console.log(`excalidrop pages (GitHub as source of truth, no Actions, no setup)\n`);
-    console.log('1. Publish viewer: npx excalidrop publish');
-    console.log('   (uses `gh auth` — repo auto-detected, Pages auto-enabled.)\n');
-    console.log('2. In your agent: switch_remote { target: "<owner>.github.io/<repo>" }');
-    console.log('   Draw as usual — commits land on GitHub, viewer updates on gh-pages.\n');
-    console.log('3. Login: ask the agent to run github_login (device flow, 2FA via GitHub),');
-    console.log('   or paste a token (`gh auth token`) on the viewer login pill.\n');
-    console.log('Rule: never edit the canvas locally — the Pages site + GitHub repo are the canvas.');
-}
-function cmdRemote() {
-    const child = spawn(process.execPath, [path.join(__dirname, 'remote.js')], { stdio: 'inherit', env: process.env });
-    child.on('exit', (code) => process.exit(code ?? 0));
-}
-/** One-command per-user setup on ANY repo: gh auth → publish viewer → app install link. */
-async function cmdSetup(args = []) {
-    if (args.includes('--help') || args.includes('-h')) {
-        console.log('Usage: npx excalidrop setup\n\nChecks `gh auth`, publishes the viewer to this repo\'s gh-pages\n(enabling Pages if needed), then prints the app-install link and next steps.');
-        return;
+        ({ viewerUrl } = await cmdSetup(['--no-prompt', slug, `--target=${target}`], editors));
+        s.stop('Setup complete.');
     }
-    console.log('excalidrop setup — works on any repo you own or can access\n');
-    // 1. gh auth (the only prerequisite; 2FA enforced by GitHub itself)
-    const auth = spawnSync('gh', ['auth', 'status'], { stdio: 'pipe', encoding: 'utf8' });
-    if (auth.status !== 0) {
-        console.error('Not logged in to GitHub. Run this first:\n\n  gh auth login\n');
+    catch (e) {
+        s.stop('Setup failed: ' + e.message);
         process.exit(1);
     }
-    const slug = (() => {
-        try {
-            const url = spawnSync('git', ['config', '--get', 'remote.origin.url'], { encoding: 'utf8' }).stdout.trim().replace(/\.git$/, '');
-            const m = url.match(/github\.com[:/](.+)/);
-            return m?.[1] || '';
+    for (const id of editors) {
+        if (id === 'claude-project' || id === 'claude-user' || id === 'codex') {
+            clack.log.success(`${EDITOR_LABELS[id]}: installed (or already present).`);
         }
-        catch {
-            return '';
+        else {
+            clack.log.info(`${EDITOR_LABELS[id]} config:\n${editorCommand(id, slug)}`);
         }
-    })();
-    if (!slug) {
-        console.error('No GitHub remote detected. Run setup inside a cloned repo.\n');
-        process.exit(1);
     }
-    console.log(`Repo: ${slug} (detected from git remote)\n`);
-    // 2. publish viewer (auto-enables Pages, auto-syncs scene)
-    await new Promise((resolve, reject) => {
-        const child = spawn('bash', [path.join(__dirname, '../scripts/publish-pages.sh')], { stdio: 'inherit', env: { ...process.env, REPO_SLUG: slug } });
-        child.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`publish failed (exit ${code})`))));
-    });
-    // 3. remember the target: agent auto-loads it, no switch_remote needed
     try {
-        const cfgFile = path.join(process.cwd(), CONFIG_NAME);
-        const cfg = fs.existsSync(cfgFile) ? JSON.parse(fs.readFileSync(cfgFile, 'utf8')) : {};
-        fs.writeFileSync(cfgFile, JSON.stringify({ port: cfg.port || 3030, canvasUrl: cfg.canvasUrl || 'http://127.0.0.1:3030', ...cfg, remote: slug }, null, 2) + '\n');
-        console.log(`Remote target remembered in ${CONFIG_NAME} (agent uses it automatically).`);
-    }
-    catch { /* non-fatal */ }
-    // 4. verify: Pages serves the viewer AND the scene file
-    const [sOwner, sRepo] = slug.split('/');
-    let verified = false;
-    for (let i = 0; i < 12; i++) {
-        await new Promise((r) => setTimeout(r, 10000));
-        try {
-            const res = await fetch(`https://${sOwner}.github.io/${sRepo}/canvas.excalidraw`, { signal: AbortSignal.timeout(15000) });
-            if (res.ok) {
-                verified = true;
-                break;
-            }
-        }
-        catch { /* Pages build still running */ }
-    }
-    console.log(verified ? 'Verified: viewer + scene live.' : 'Note: Pages still building — check back in a minute.');
-    // 4. next steps: install the shared app + draw
-    const appSlug = process.env.EXCALIDROP_APP_SLUG || 'excalidrop';
-    console.log(`\nDone. Your canvas: https://${sOwner}.github.io/${sRepo}/\n`);
-    console.log('Two remaining clicks (one time per repo):');
-    console.log(`  1. Install the Excalidrop app on this repo:\n     https://github.com/apps/${appSlug}/installations/new\n`);
-    console.log('  2. In your agent: switch_remote { target: "<that canvas URL>" }');
-    console.log('     then draw — commits land on GitHub, the viewer updates itself.');
-    console.log('\nLogin on the page: pill → device code → github.com/login/device (2FA via GitHub).');
-}
-/** Terminal GitHub login via device flow (same flow the agent's github_login uses). */
-async function cmdLogin() {
-    const { APP_CLIENT_ID } = await import('./target.js');
-    const clientId = process.env.GITHUB_OAUTH_CLIENT_ID || APP_CLIENT_ID;
-    if (!clientId) {
-        console.error('No GitHub App Client ID configured yet.');
-        console.error('Set GITHUB_OAUTH_CLIENT_ID (or wait for the shared excalidrop app),');
-        console.error('or just run `gh auth login` — the MCP picks that token up automatically.');
-        process.exit(1);
+        const scene = await getScene(slug);
+        clack.log.success(`Scene readable: ${scene.elements.length} elements @${CANVAS_BRANCH}.`);
     }
-    // Dynamic import to avoid loading MCP deps in CLI path
-    const mod = await import('./target.js');
-    console.log('Starting GitHub device login…');
-    const dev = await mod.deviceStart(clientId);
-    console.log(`\nOpen ${dev.verification_uri} and enter code: ${dev.user_code}\n`);
-    const repoId = undefined; // unrestricted; pass --repo owner/repo? (future: parse argv)
-    const token = await mod.devicePoll(clientId, dev.device_code, dev.interval || 5, 300, repoId);
-    console.log('Logged in — token stored in ~/.config/excalidrop/gh_token');
-    void token;
+    catch (e) {
+        clack.log.warn(`Scene not readable yet: ${e.message} — draw once to create it.`);
+    }
+    try {
+        const r = await fetch(viewerUrl, { signal: AbortSignal.timeout(15000) });
+        if (r.ok)
+            clack.log.success('Viewer is serving.');
+        else
+            clack.log.warn(`Viewer returned HTTP ${r.status} — Pages/Cloudflare may still be building; retry in a minute.`);
+    }
+    catch {
+        clack.log.warn('Viewer not reachable yet — hosting may still be building; retry in a minute.');
+    }
+    clack.outro(`Canvas live: ${viewerUrl}`);
 }
 function printHelp() {
-    console.log(`excalidrop — drop an Excalidraw canvas + MCP server into any project
+    console.log(`excalidrop — remote GitHub-backed canvas (no local server)
 
 Usage:
-  npx excalidrop init [--port=N] [--no-prompt]  pick a free port, write .excalidrop.json + .mcp.json
-  npx excalidrop up [--port=N]                  start this project's canvas server
-  npx excalidrop setup                        one-command setup on any repo (gh auth + publish + guide)
-  npx excalidrop login                        GitHub device-flow login from the terminal
-  npx excalidrop pages                        GitHub-truth + gh-pages publish guide
-  npx excalidrop remote                       run remote MCP-v2 (GitHub-backed, multi-project)
-  npx excalidrop publish                      publish viewer straight to gh-pages (no Actions)
-  npx excalidrop mcp                            run MCP stdio server (used by AI agents)
-  npx excalidrop status                         show port + canvas health
-  npx excalidrop add                            print AI-agent install commands
+  npx excalidrop                          interactive setup TUI
+  npx excalidrop setup owner/repo [--target pages|cloudflare] [--editor claude-project,codex,cursor,desktop,opencode] [--no-prompt]
+  npx -y excalidrop@latest mcp --repo owner/repo   run MCP stdio server (editors use this)
+  npx excalidrop login [--repo owner/repo]         GitHub device-flow login
+  npx excalidrop publish owner/repo [--target ..]  redeploy viewer only
+  npx excalidrop status                   show repo + auth + scene
+  npx excalidrop add [owner/repo]         print editor install commands
 
-Install:
-  npm i -D excalidrop && npx excalidrop init
-
-Each project gets its own port (scanned free from ${DEFAULT_START_PORT}), so several
-checkouts can run concurrently. Agent config needs no hardcoded port.`);
+No devDependency needed. Token: GITHUB_TOKEN → gh auth → ~/.config/excalidrop/gh_token.`);
 }
-// ─── entry ───────────────────────────────────────────────────────────────────
 async function main() {
     const [cmd, ...rest] = process.argv.slice(2);
+    if (!cmd) {
+        if (!process.stdout.isTTY) {
+            printHelp();
+            return;
+        }
+        await runTui();
+        return;
+    }
     switch (cmd) {
-        case 'init':
-            await cmdInit(rest);
-            break;
-        case 'up':
-            await cmdUp(rest);
+        case 'setup':
+            await cmdSetup(rest);
             break;
         case 'mcp':
             cmdMcp();
             break;
-        case 'status':
-            await cmdStatus();
-            break;
-        case 'pages':
-            await cmdPages(rest);
-            break;
-        case 'remote':
-            cmdRemote();
-            break;
-        case 'setup':
-            await cmdSetup(rest);
-            break;
         case 'login':
             await cmdLogin();
             break;
-        case 'publish': {
-            const child = spawn('bash', [path.join(__dirname, '../scripts/publish-pages.sh')], { stdio: 'inherit', env: process.env });
-            child.on('exit', (code) => process.exit(code ?? 0));
+        case 'status':
+            await cmdStatus();
+            break;
+        case 'publish':
+            await cmdSetup(['--no-prompt', ...rest]);
             break;
-        }
         case 'add':
-            printAgentCommands();
+            printEditorCommands(parseEditorsFlag(rest) || [...EDITOR_IDS], rest.find((a) => a.includes('/')) || detectSlug() || 'owner/repo');
+            break;
+        case 'init':
+        case 'up':
+        case 'remote':
+            console.error(`\`excalidrop ${cmd}\` was removed (no local canvas). Run: npx excalidrop setup owner/repo`);
+            process.exit(1);
             break;
         default:
             printHelp();
-            if (cmd && cmd !== '--help' && cmd !== '-h')
-                process.exitCode = 1;
+            process.exitCode = 1;
     }
 }
-main().catch((err) => {
-    console.error(`excalidrop: ${err.message}`);
-    process.exit(1);
-});
+main().catch((err) => { console.error(`excalidrop: ${err.message}`); process.exit(1); });
 //# sourceMappingURL=cli.js.map