excalidrop 0.2.1 → 0.2.3

package/dist/cli.js

@@ -38,6 +38,25 @@ async function ghPut(pathname, body) {
         throw new Error(`GitHub PUT ${pathname} → ${r.status}: ${(await r.text()).slice(0, 150)}`);
     return r.json();
 }
+async function ghPatch(pathname, body) {
+    const r = await fetch(`${GH_API}${pathname}`, { method: 'PATCH', headers: ghHeaders(), body: JSON.stringify(body) });
+    if (!r.ok)
+        throw new Error(`GitHub PATCH ${pathname} → ${r.status}: ${(await r.text()).slice(0, 150)}`);
+    return r.json();
+}
+/** Set repo website (homepage) to the canvas viewer URL — only if empty. Best-effort. */
+async function ensureRepoHomepage(repo, viewerUrl) {
+    try {
+        const info = await ghGet(`/repos/${repo}`);
+        if (info.homepage && String(info.homepage).trim())
+            return;
+        await ghPatch(`/repos/${repo}`, { homepage: viewerUrl });
+        console.log(`Repo website set to canvas: ${viewerUrl}`);
+    }
+    catch (e) {
+        console.warn(`Could not set repo website (non-fatal): ${e.message}`);
+    }
+}
 async function ensureMainBranch(repo) {
     const main = await fetch(`${GH_API}/repos/${repo}/git/ref/heads/main`, { headers: ghHeaders() });
     if (main.ok)
@@ -47,7 +66,7 @@ async function ensureMainBranch(repo) {
         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'),
+        content: Buffer.from('').toString('base64'),
         branch: 'main',
     });
 }
@@ -154,15 +173,25 @@ async function deployViewerPages(repo) {
 function projectNameForRepo(repo) {
     return `excalidrop-${repo.replace('/', '-').toLowerCase().replace(/[^a-z0-9-]/g, '-')}`.slice(0, 60);
 }
-function viewerUrlFor(repo, target) {
+function viewerUrlFor(repo, target, project) {
     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}`;
+        return `https://${project || projectNameForRepo(repo)}.pages.dev/?repo=${repo}`;
     }
     const [owner, name] = repo.split('/');
     return `https://${owner}.github.io/${name}/`;
 }
+/** Cloudflare project names: lowercase alphanumerics + hyphens, ≤63 chars. */
+export function normalizeProjectName(input, fallback) {
+    const cleaned = (input || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 63);
+    return cleaned || fallback;
+}
 async function isPrivateRepo(repo) {
     try {
         const r = spawnSync('gh', ['api', `repos/${repo}`, '--jq', '.private'], { encoding: 'utf8' });
@@ -183,10 +212,22 @@ async function resolveTarget(repo, explicit) {
         return explicit;
     return (await isPrivateRepo(repo)) === true ? 'cloudflare' : 'pages';
 }
+const WRANGLER = ['-y', 'wrangler@4'];
+// Which Cloudflare identity would a Pages deploy use? whoami fails when
+// logged out; a CLOUDFLARE_API_TOKEN works without a login. Deploys always
+// run under the USER's own account/quota — never the author's.
+function wranglerAccount() {
+    if (process.env.CLOUDFLARE_API_TOKEN)
+        return { ok: true, display: 'API token (CLOUDFLARE_API_TOKEN)' };
+    const r = runCapture('npx', [...WRANGLER, 'whoami']);
+    if (r.status !== 0)
+        return { ok: false, display: '' };
+    const m = r.out.match(/[\w.+-]+@[\w-]+\.[\w.]+/);
+    return { ok: true, display: m?.[0] ?? 'logged in' };
+}
 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)) {
@@ -205,6 +246,19 @@ function detectSlug() {
         return '';
     }
 }
+/** Accept owner/repo, a GitHub URL, or git@ SSH — always returns owner/repo or ''. */
+export function normalizeRepoSlug(input) {
+    const s = (input || '').trim();
+    if (!s)
+        return '';
+    // Full URL / SSH / bare host path → extract the owner/repo tail.
+    const m = s.match(/github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?(?:\/.*)?$/i);
+    const candidate = m ? m[1] : s;
+    const cleaned = candidate.replace(/\.git$/i, '').replace(/^\/+|\/+$/g, '');
+    const ok = cleaned.match(/^([a-z0-9_.-]+)\/([a-z0-9_.-]+)$/i);
+    return ok ? `${ok[1].toLowerCase()}/${ok[2]}` : '';
+}
+const SLUG_HINT = 'owner/repo or a GitHub link';
 function ghAuthed() {
     return spawnSync('gh', ['auth', 'status'], { stdio: 'ignore' }).status === 0;
 }
@@ -213,59 +267,314 @@ function commandExists(cmd) {
     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;
+    // Inside a git checkout the repo top is the root. Never walk up past cwd
+    // looking for package.json: from a fresh non-checkout dir (e.g. a folder
+    // holding a brand-new canvas repo) the old walk-up climbed into an
+    // unrelated parent project and wrote .mcp.json / .excalidrop.json there.
+    try {
+        const top = execSync('git rev-parse --show-toplevel', { cwd: path.resolve(cwd), encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (top)
+            return top;
     }
+    catch { /* not inside a git work tree — fall through to cwd */ }
+    return path.resolve(cwd);
 }
 function mcpArgs(repo) {
     return ['-y', 'excalidrop@latest', 'mcp', '--repo', repo];
 }
-const EDITOR_IDS = ['claude-project', 'claude-user', 'codex', 'cursor', 'desktop', 'opencode'];
+const EDITOR_IDS = ['claude-project', 'claude-user', 'codex', 'cursor', 'cursor-user', 'desktop', 'opencode', 'opencode-user'];
 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 'cursor':
+        case 'cursor-user':
         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);
+        case 'opencode':
+        case 'opencode-user': 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) {
+function editorScope(id) {
+    return id === 'claude-project' || id === 'cursor' || id === 'opencode' ? 'project' : 'user';
+}
+// Where each editor id reads its config from. File-based harnesses support
+// both a project file and a user-global file; CLI-driven ones (claude, codex)
+// are detected through the same files their CLIs write.
+function editorFile(id, root) {
+    const home = os.homedir();
+    switch (id) {
+        case 'claude-user': return { path: path.join(home, '.claude.json'), key: 'mcpServers' };
+        case 'claude-project': return { path: path.join(root, MCP_JSON), key: 'mcpServers' };
+        case 'cursor': return { path: path.join(root, '.cursor', 'mcp.json'), key: 'mcpServers' };
+        case 'cursor-user': return { path: path.join(home, '.cursor', 'mcp.json'), key: 'mcpServers' };
+        case 'desktop': return { path: desktopConfigPath(), key: 'mcpServers' };
+        case 'opencode': return { path: path.join(root, 'opencode.json'), key: 'mcp' };
+        case 'opencode-user': return { path: path.join(home, '.config', 'opencode', 'opencode.json'), key: 'mcp' };
+        case 'codex': return null; // TOML (~/.codex/config.toml) — parsed separately
+    }
+}
+function desktopConfigPath() {
+    const home = os.homedir();
+    if (process.platform === 'darwin')
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    if (process.platform === 'win32')
+        return path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+}
+function editorTarget(id, root) {
+    const f = editorFile(id, root);
+    if (id === 'codex')
+        return 'user config (~/.codex/config.toml)';
+    const scope = editorScope(id);
+    const short = f ? shortenHome(f.path) : id;
+    return `${scope} scope (${short})`;
+}
+function shortenHome(p) {
+    const home = os.homedir();
+    return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+function repoFromArgs(args) {
+    if (!Array.isArray(args))
+        return null;
+    const i = args.findIndex((a) => a === '--repo');
+    const v = i !== -1 ? args[i + 1] : null;
+    return typeof v === 'string' && v.includes('/') ? v.toLowerCase() : null;
+}
+// {present, repo} for a JSON MCP config (claude/cursor/desktop/opencode shapes).
+function jsonMcpRepo(file, key) {
+    let j;
     try {
-        if (id === 'claude-project' && commandExists('claude')) {
-            return spawnSync('claude', ['mcp', 'add', 'excalidrop', '--scope', 'project', '--', 'npx', ...mcpArgs(repo)], { stdio: 'ignore' }).status === 0;
+        j = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return { present: false, repo: null };
+    }
+    const e = key === 'mcpServers' ? j?.mcpServers?.excalidrop : j?.mcp?.excalidrop;
+    if (!e)
+        return { present: false, repo: null };
+    if (Array.isArray(e.command))
+        return { present: true, repo: repoFromArgs(e.command) };
+    if (e.command === 'npx' && Array.isArray(e.args))
+        return { present: true, repo: repoFromArgs(e.args) };
+    return { present: true, repo: null };
+}
+// {present, repo} for Codex's TOML config — crude section parse, no new deps.
+function codexMcpRepo() {
+    let txt;
+    try {
+        txt = fs.readFileSync(path.join(os.homedir(), '.codex', 'config.toml'), 'utf8');
+    }
+    catch {
+        return { present: false, repo: null };
+    }
+    const sec = txt.match(/\[mcp_servers\.excalidrop\]([\s\S]*?)(?=^\[|\z)/m);
+    if (!sec)
+        return { present: false, repo: null };
+    const m = (sec[1] ?? '').match(/--repo["'\s=,]+([A-Za-z0-9_.\-]+\/[A-Za-z0-9_.\-]+)/);
+    return { present: true, repo: m?.[1]?.toLowerCase() ?? null };
+}
+function detectEditorState(id, repo, root) {
+    const want = repo.toLowerCase();
+    if (id === 'codex') {
+        const s = codexMcpRepo();
+        if (!s.present)
+            return { status: 'missing', repo: null, where: '~/.codex/config.toml' };
+        return s.repo === want
+            ? { status: 'current', repo: s.repo, where: '~/.codex/config.toml' }
+            : { status: 'stale', repo: s.repo, where: '~/.codex/config.toml' };
+    }
+    const f = editorFile(id, root);
+    const where = shortenHome(f.path);
+    const s = jsonMcpRepo(f.path, f.key);
+    if (!s.present)
+        return { status: 'missing', repo: null, where };
+    return s.repo === want
+        ? { status: 'current', repo: s.repo, where }
+        : { status: 'stale', repo: s.repo, where };
+}
+function updateCommand(id, repo) {
+    if (id === 'claude-project' || id === 'claude-user') {
+        const scope = id === 'claude-project' ? 'project' : 'user';
+        return `claude mcp remove excalidrop -s ${scope} && ${editorCommand(id, repo)}`;
+    }
+    return editorCommand(id, repo);
+}
+function runCapture(cmd, args) {
+    try {
+        const r = spawnSync(cmd, args, { encoding: 'utf8' });
+        return { status: r.status, out: `${r.stdout || ''}\n${r.stderr || ''}` };
+    }
+    catch (e) {
+        return { status: 1, out: e.message };
+    }
+}
+// Merge an MCP entry into a JSON config file (creates parent dirs). Returns
+// false when the existing file isn't valid JSON — caller falls back to manual.
+function upsertJsonMcp(file, key, entry) {
+    let j = {};
+    if (fs.existsSync(file)) {
+        try {
+            j = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch {
+            return false;
+        }
+        if (!j || typeof j !== 'object')
+            return false;
+    }
+    else {
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
         }
-        if (id === 'claude-user' && commandExists('claude')) {
-            return spawnSync('claude', ['mcp', 'add', 'excalidrop', '--scope', 'user', '--', 'npx', ...mcpArgs(repo)], { stdio: 'ignore' }).status === 0;
+        catch {
+            return false;
         }
-        if (id === 'codex' && commandExists('codex')) {
-            return spawnSync('codex', ['mcp', 'add', 'excalidrop', '--', 'npx', ...mcpArgs(repo)], { stdio: 'ignore' }).status === 0;
+    }
+    if (key === 'mcpServers') {
+        if (!j.mcpServers || typeof j.mcpServers !== 'object')
+            j.mcpServers = {};
+        j.mcpServers.excalidrop = entry;
+    }
+    else {
+        if (!j.mcp || typeof j.mcp !== 'object')
+            j.mcp = {};
+        j.mcp.excalidrop = entry;
+        if (!j.$schema)
+            j.$schema = 'https://opencode.ai/config.json';
+    }
+    try {
+        fs.writeFileSync(file, JSON.stringify(j, null, 2) + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cursorEntry(repo) {
+    return { command: 'npx', args: mcpArgs(repo), env: { EXCALIDROP_RELAY_URL: process.env.EXCALIDROP_RELAY_URL || RELAY_DEFAULT } };
+}
+function opencodeEntry(repo) {
+    return { type: 'local', command: ['npx', ...mcpArgs(repo)], enabled: true, env: { EXCALIDROP_RELAY_URL: process.env.EXCALIDROP_RELAY_URL || RELAY_DEFAULT } };
+}
+function installEditor(id, repo, root) {
+    const fail = (detail) => ({ id, outcome: 'failed', detail });
+    // Idempotent first: never reinstall over an identical entry, never silently
+    // leave a stale one — report it with the exact update command.
+    const st = detectEditorState(id, repo, root);
+    if (st.status === 'current')
+        return { id, outcome: 'already-current', detail: `${st.where} already points at ${repo}` };
+    const staleNote = st.status === 'stale' ? ` (currently → ${st.repo ?? 'unknown'})` : '';
+    if (id === 'claude-project' || id === 'claude-user' || id === 'codex') {
+        const bin = id === 'codex' ? 'codex' : 'claude';
+        if (!commandExists(bin))
+            return fail(`${bin} CLI not found — run manually:\n${editorCommand(id, repo)}`);
+        const cargs = id === 'claude-project'
+            ? ['mcp', 'add', 'excalidrop', '--scope', 'project', '--', 'npx', ...mcpArgs(repo)]
+            : id === 'claude-user'
+                ? ['mcp', 'add', 'excalidrop', '--scope', 'user', '--', 'npx', ...mcpArgs(repo)]
+                : ['mcp', 'add', 'excalidrop', '--', 'npx', ...mcpArgs(repo)];
+        const r = runCapture(bin, cargs);
+        if (r.status === 0 && !/already exists/i.test(r.out)) {
+            return { id, outcome: 'added', detail: editorCommand(id, repo) };
         }
+        if (/already exists/i.test(r.out)) {
+            // Exit code is 0 even when nothing changed — re-read the file to say
+            // honestly whether the existing entry is current or stale.
+            const now = detectEditorState(id, repo, root);
+            if (now.status === 'current')
+                return { id, outcome: 'already-current', detail: `${now.where} already points at ${repo}` };
+            return { id, outcome: 'stale', detail: `already exists${now.repo ? ` → ${now.repo}` : ''} — not updated. Run:\n${updateCommand(id, repo)}` };
+        }
+        return fail((r.out.trim() || `${bin} exited ${r.status}`).slice(0, 300));
     }
-    catch { /* fall through to manual */ }
-    return false;
+    // File-based harnesses: JSON merge is safe to write for both add and update.
+    const f = editorFile(id, root);
+    const entry = id === 'cursor' || id === 'cursor-user' || id === 'desktop' ? cursorEntry(repo) : opencodeEntry(repo);
+    if (upsertJsonMcp(f.path, f.key, entry)) {
+        return { id, outcome: 'added', detail: `wrote ${shortenHome(f.path)}${staleNote} → ${repo}` };
+    }
+    return fail(`${shortenHome(f.path)} is not valid JSON — leaving it untouched. Add manually:\n${editorCommand(id, repo)}`);
 }
 const EDITOR_LABELS = {
     'claude-project': 'Claude Code (project scope)',
     'claude-user': 'Claude Code (user scope)',
+    codex: 'Codex CLI (user config)',
+    cursor: 'Cursor (project file)',
+    'cursor-user': 'Cursor (user file)',
+    desktop: 'Claude Desktop (user config)',
+    opencode: 'OpenCode (project file)',
+    'opencode-user': 'OpenCode (user config)',
+};
+// Harnesses group the flat scope-specific ids for the two-step TUI picker:
+// step 1 picks harnesses, step 2 picks the scope per multi-scope harness.
+// Single-scope harnesses (codex, desktop) are user-global — no step 2.
+const HARNESSES = ['claude', 'codex', 'cursor', 'desktop', 'opencode'];
+const HARNESS_EDITORS = {
+    claude: ['claude-user', 'claude-project'],
+    codex: ['codex'],
+    cursor: ['cursor-user', 'cursor'],
+    desktop: ['desktop'],
+    opencode: ['opencode-user', 'opencode'],
+};
+const HARNESS_LABELS = {
+    claude: 'Claude Code',
     codex: 'Codex CLI',
-    cursor: 'Cursor (.cursor/mcp.json)',
+    cursor: 'Cursor',
     desktop: 'Claude Desktop',
-    opencode: 'OpenCode (opencode.json)',
+    opencode: 'OpenCode',
 };
-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`);
+// One-line install-state summary for the harness picker, e.g.
+// "user: installed, project: —" or "installed → other/repo".
+function harnessSummary(h, slug, root) {
+    const ids = HARNESS_EDITORS[h];
+    const parts = ids.map((id) => {
+        const st = detectEditorState(id, slug, root);
+        const cur = st.status === 'current' ? 'installed' : st.status === 'stale' ? `installed → ${st.repo ?? 'unknown'}` : '—';
+        return ids.length > 1 ? `${editorScope(id)}: ${cur}` : cur;
+    });
+    return parts.join(', ');
+}
+// Scope option for step 2 of the picker: short scope label + live state hint.
+function scopeOption(id, slug, root) {
+    const st = detectEditorState(id, slug, root);
+    return {
+        value: id,
+        label: editorTarget(id, root),
+        hint: st.status === 'current' ? 'installed' : st.status === 'stale' ? `installed → ${st.repo ?? 'unknown'}` : undefined,
+    };
+}
+// One honest report for every editor install attempt — always shows the
+// command/config that was (or should be) applied, so "installed" can never
+// mean "already existed but points elsewhere".
+function reportInstalls(results, repo, root) {
+    for (const r of results) {
+        const target = editorTarget(r.id, root);
+        if (r.outcome === 'added')
+            console.log(`ok   ${EDITOR_LABELS[r.id]} → ${target}:\n  ${editorCommand(r.id, repo).split('\n').join('\n  ')}\n  installed (${r.detail})`);
+        else if (r.outcome === 'already-current')
+            console.log(`skip ${EDITOR_LABELS[r.id]} → ${target}: ${r.detail}`);
+        else if (r.outcome === 'stale')
+            console.log(`warn ${EDITOR_LABELS[r.id]} → ${target}: ${r.detail}`);
+        else
+            console.log(`fail ${EDITOR_LABELS[r.id]} → ${target}: ${r.detail}`);
+    }
+}
+/** Poll a viewer URL until it serves 200 (slow first builds take minutes). */
+async function waitForLive(url, timeoutMs = 7 * 60_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const r = await fetch(url, { signal: AbortSignal.timeout(15000) });
+            if (r.ok)
+                return true;
+            // 404 during initial propagation — keep waiting; anything else too.
+        }
+        catch { /* offline / DNS — keep waiting */ }
+        await new Promise((r) => setTimeout(r, 10000));
+    }
+    return false;
 }
 function parseFlag(args, name) {
     const eq = args.find((a) => a.startsWith(`--${name}=`));
@@ -288,11 +597,12 @@ function parseEditorsFlag(args) {
     }
     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]');
+async function cmdSetup(args, editorOverride, opts = {}) {
+    const positional = args.find((a) => !a.startsWith('-') && (a.includes('/') || a.includes('github.com')));
+    const rawSlug = parseFlag(args, 'repo') || positional || detectSlug();
+    const slug = normalizeRepoSlug(rawSlug);
+    if (!slug) {
+        console.error(`Usage: npx excalidrop setup ${SLUG_HINT} [--target pages|cloudflare] [--editor claude-project,codex] [--no-prompt]`);
         process.exit(1);
     }
     if (!ghAuthed() && !process.env.GITHUB_TOKEN) {
@@ -311,7 +621,7 @@ async function cmdSetup(args, editorOverride) {
     }
     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`);
+    console.log(`Repo: ${slug}\nHost: ${target}${explicitTarget ? (opts.fromTui ? ' (selected)' : ' (explicit)') : ' (auto: private→cloudflare, public→pages)'}\n`);
     await ensureMainBranch(slug);
     const scene = await getScene(slug).catch(() => ({ elements: [], sha: null }));
     if (!scene.sha) {
@@ -324,9 +634,39 @@ async function cmdSetup(args, editorOverride) {
         viewerUrl = viewerUrlFor(slug, 'pages');
     }
     else {
-        deployToCloudflarePages(projectNameForRepo(slug));
-        viewerUrl = viewerUrlFor(slug, 'cloudflare');
+        // Fail fast on missing auth instead of dying mid-deploy. The TUI checks
+        // interactively before the spinner; non-interactive runs land here.
+        const acct = wranglerAccount();
+        if (!acct.ok && !opts.fromTui) {
+            throw new Error('Not logged into Cloudflare (wrangler whoami failed). Run `npx -y wrangler@4 login` first, or set CLOUDFLARE_API_TOKEN.');
+        }
+        console.log(`Cloudflare account: ${acct.display || 'unknown'} — the viewer deploys to YOUR account and quota.`);
+        // TUI asks for this (prompt below); --project-name sets it headless.
+        // NOTE: renaming the project changes the viewer URL, so a previously
+        // registered OAuth callback URL stops matching — re-register login (see
+        // README "Browser login") after a rename.
+        const project = normalizeProjectName(parseFlag(args, 'project-name') || opts.project || '', projectNameForRepo(slug));
+        console.log(`Cloudflare project: ${project} (viewer host ${project}.pages.dev)`);
+        deployToCloudflarePages(project);
+        viewerUrl = viewerUrlFor(slug, 'cloudflare', project);
     }
+    // Don't declare victory until the viewer actually serves — first Pages /
+    // Cloudflare builds take minutes, and "Canvas live" on a 404 wastes a debug
+    // session. Poll the URL (up to 7 min for slow first builds), then report
+    // honestly with the Pages build state attached.
+    const live = await waitForLive(viewerUrl);
+    if (live) {
+        console.log('Viewer is serving.');
+    }
+    else {
+        console.log('Viewer not live yet (HTTP 404) — hosting may still be building; retry the URL in a minute.');
+        const info = await pagesBuildInfo(slug, target).catch(() => null);
+        if (info)
+            console.log(info);
+    }
+    await ensureRepoHomepage(slug, viewerUrl);
+    const appSlug = process.env.EXCALIDROP_APP_SLUG || 'excalidrop';
+    console.log(`Note: browser login stays read-only until the Excalidrop app is installed on ${slug}:\n  https://github.com/apps/${appSlug}/installations/new`);
     const root = findProjectRoot(process.cwd());
     fs.writeFileSync(path.join(root, CONFIG_NAME), JSON.stringify({ remote: slug, target, viewerUrl }, null, 2) + '\n');
     const mcpPath = path.join(root, MCP_JSON);
@@ -346,18 +686,28 @@ async function cmdSetup(args, editorOverride) {
     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) {
-        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 };
-    }
-    return { repo: slug, viewerUrl };
+    const installs = editors.map((id) => installEditor(id, slug, root));
+    // The TUI prints its own per-editor report (it owns the spinner); the plain
+    // CLI prints here so `setup --no-prompt` shows exactly what ran.
+    if (!opts.fromTui)
+        reportInstalls(installs, slug, root);
+    void noPrompt;
+    return { repo: slug, viewerUrl, live, installs };
+}
+// Latest GitHub Pages build state for a repo — printed when the viewer URL
+// still 404s after the wait so the user knows whether it's "still building"
+// vs "build errored / Pages misconfigured".
+async function pagesBuildInfo(repo, target) {
+    if (target !== 'pages')
+        return `Cloudflare deploy is async — check the Pages project dashboard; if still 404, rerun: npx excalidrop publish ${repo}`;
+    try {
+        const latest = await ghGet(`/repos/${repo}/pages/builds/latest`);
+        const err = latest?.error?.message ? ` — ${latest.error.message}` : '';
+        return `Pages latest build: ${latest.status}${err} (updated ${latest.updated_at || 'unknown'}). Check https://github.com/${repo}/settings/pages (source should be branch ${PAGES_BRANCH}) — first builds can take several minutes. If stuck, rerun: npx excalidrop publish ${repo}`;
+    }
+    catch {
+        return `Pages build status unknown — check https://github.com/${repo}/settings/pages (source should be branch ${PAGES_BRANCH}).`;
+    }
 }
 function cmdMcp() {
     const child = spawn(process.execPath, [path.join(__dirname, 'mcp.js'), ...process.argv.slice(3)], { stdio: 'inherit', env: process.env });
@@ -419,18 +769,29 @@ async function runTui() {
     const detected = detectSlug();
     const repoAnswer = await clack.text({
         message: 'Which repo holds the canvas?',
-        placeholder: detected || 'owner/repo',
+        placeholder: detected || SLUG_HINT,
         initialValue: detected || '',
-        validate: (v) => (/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(v.trim()) ? undefined : 'Use owner/repo'),
+        validate: (v) => (normalizeRepoSlug(v) ? undefined : `Use ${SLUG_HINT}`),
     });
     if (clack.isCancel(repoAnswer)) {
         clack.cancel('Aborted.');
         process.exit(0);
     }
-    const slug = repoAnswer.trim().toLowerCase();
+    const slug = normalizeRepoSlug(repoAnswer);
     const priv = await isPrivateRepo(slug);
     if (priv !== null)
         clack.log.info(`Repo is ${priv ? 'private' : 'public'} — recommended host: ${priv ? 'Cloudflare Pages' : 'GitHub Pages'}.`);
+    // Visibility drift: repo flipped public<->private since last setup, so the
+    // stored target + viewer URL no longer match — nudge to re-pick below.
+    try {
+        const prevRaw = fs.readFileSync(path.join(findProjectRoot(process.cwd()), CONFIG_NAME), 'utf8');
+        const prevTarget = JSON.parse(prevRaw).target;
+        const want = priv === true ? 'cloudflare' : 'pages';
+        if (prevTarget && prevTarget !== want && priv !== null) {
+            clack.log.warn(`Visibility changed since last setup (host: ${prevTarget}, repo now ${priv ? 'private' : 'public'}). Pick ${want} below to migrate — see README "Migrating public<->private".`);
+        }
+    }
+    catch { /* first setup — nothing to compare */ }
     if (!ghAuthed() && !process.env.GITHUB_TOKEN) {
         const how = await clack.select({
             message: 'GitHub auth missing. How to log in?',
@@ -461,75 +822,189 @@ async function runTui() {
             process.exit(1);
         }
     }
-    const auto = await resolveTarget(slug);
+    // No auto option: GitHub Pages can't serve private repos on free plans
+    // and public repos need zero config, so visibility pre-selects the right
+    // host — the user just confirms or flips. Non-interactive `--target` still
+    // goes through resolveTarget() in cmdSetup.
+    const recommended = priv === true ? 'cloudflare' : 'pages';
     const hostAnswer = await clack.select({
-        message: `Where to host the viewer? (auto: ${auto})`,
+        message: 'Where to host the viewer?',
+        initialValue: recommended,
         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' },
+            { value: 'pages', label: 'GitHub Pages (public repo)', hint: 'zero config' },
+            { value: 'cloudflare', label: 'Cloudflare Pages (private repo)', hint: 'needs wrangler login' },
         ],
     });
     if (clack.isCancel(hostAnswer)) {
         clack.cancel('Aborted.');
         process.exit(0);
     }
-    const target = (hostAnswer === 'auto' ? auto : hostAnswer);
-    const editorAnswer = await clack.multiselect({
+    const target = hostAnswer;
+    // Cloudflare project name = the *.pages.dev subdomain. Offer the choice
+    // up front so the URL is predictable (and re-runnable without surprises).
+    let project = projectNameForRepo(slug);
+    if (target === 'cloudflare') {
+        const nameAnswer = await clack.text({
+            message: 'Cloudflare project name (viewer host)?',
+            placeholder: project,
+            initialValue: project,
+            validate: (v) => (normalizeProjectName(v, '') ? undefined : 'Lowercase letters, numbers, hyphens.'),
+        });
+        if (clack.isCancel(nameAnswer)) {
+            clack.cancel('Aborted.');
+            process.exit(0);
+        }
+        project = normalizeProjectName(nameAnswer, project);
+    }
+    // Cloudflare deploys run under the USER's own wrangler identity and quota.
+    // Verify login up front (with an offer to log in now) instead of failing
+    // minutes later mid-deploy.
+    if (target === 'cloudflare') {
+        let acct = wranglerAccount();
+        if (!acct.ok) {
+            const login = await clack.confirm({
+                message: 'Wrangler is not logged into Cloudflare. Log in now (opens a browser)?',
+            });
+            if (clack.isCancel(login)) {
+                clack.cancel('Aborted.');
+                process.exit(0);
+            }
+            if (login) {
+                spawnSync('npx', [...WRANGLER, 'login'], { stdio: 'inherit', env: process.env });
+                acct = wranglerAccount();
+            }
+            if (!acct.ok) {
+                clack.log.error('Cloudflare login is required for Cloudflare Pages hosting — pick GitHub Pages, or run `npx -y wrangler@4 login` first.');
+                process.exit(1);
+            }
+        }
+        clack.log.info(`Cloudflare account: ${acct.display} — the viewer deploys to YOUR account and quota.`);
+    }
+    const projectRoot = findProjectRoot(process.cwd());
+    // Step 1: pick harnesses. Preselect ones already wired to this repo;
+    // fall back to the historical default when nothing is installed yet.
+    const detectedHarnesses = HARNESSES.filter((h) => HARNESS_EDITORS[h].some((id) => detectEditorState(id, slug, projectRoot).status === 'current'));
+    const harnessAnswer = 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'],
+        options: HARNESSES.map((h) => ({
+            value: h,
+            label: `${HARNESS_LABELS[h]} (${harnessSummary(h, slug, projectRoot)})`,
+        })),
+        initialValues: detectedHarnesses.length > 0 ? detectedHarnesses : ['claude'],
         required: false,
     });
-    if (clack.isCancel(editorAnswer)) {
+    if (clack.isCancel(harnessAnswer)) {
         clack.cancel('Aborted.');
         process.exit(0);
     }
-    const editors = editorAnswer;
+    const harnesses = harnessAnswer;
+    // Step 2: per multi-scope harness, pick where to install.
+    const editors = [];
+    for (const h of harnesses) {
+        const ids = HARNESS_EDITORS[h];
+        if (ids.length === 1) {
+            editors.push(ids[0]);
+            continue;
+        }
+        const current = ids.filter((id) => detectEditorState(id, slug, projectRoot).status === 'current');
+        const scopeAnswer = await clack.select({
+            message: `Where to install for ${HARNESS_LABELS[h]}?`,
+            initialValue: current.length === 1 ? current[0] : ids[0],
+            options: [
+                ...ids.map((id) => scopeOption(id, slug, projectRoot)),
+                { value: '__both__', label: 'Both scopes' },
+            ],
+        });
+        if (clack.isCancel(scopeAnswer)) {
+            clack.cancel('Aborted.');
+            process.exit(0);
+        }
+        if (scopeAnswer === '__both__')
+            editors.push(...ids);
+        else
+            editors.push(scopeAnswer);
+    }
+    // Stale Claude entries can't be overwritten by `add` (it exits 0 with
+    // "already exists" and changes nothing) — offer an explicit repoint before
+    // the deploy phase so the install below actually lands.
+    for (const id of editors) {
+        if (id !== 'claude-user' && id !== 'claude-project')
+            continue;
+        const st = detectEditorState(id, slug, projectRoot);
+        if (st.status !== 'stale')
+            continue;
+        const ok = await clack.confirm({
+            message: `${EDITOR_LABELS[id]} points at ${st.repo ?? 'unknown'} — repoint to ${slug}?`,
+        });
+        if (clack.isCancel(ok)) {
+            clack.cancel('Aborted.');
+            process.exit(0);
+        }
+        if (ok) {
+            const scope = id === 'claude-project' ? 'project' : 'user';
+            runCapture('claude', ['mcp', 'remove', 'excalidrop', '-s', scope]);
+        }
+    }
     const s = clack.spinner();
     s.start('Publishing viewer + wiring MCP…');
     let viewerUrl;
+    let live = false;
+    let installs = [];
     try {
-        ({ viewerUrl } = await cmdSetup(['--no-prompt', slug, `--target=${target}`], editors));
+        ({ viewerUrl, live, installs } = await cmdSetup(['--no-prompt', slug, `--target=${target}`], editors, { fromTui: true, project }));
         s.stop('Setup complete.');
     }
     catch (e) {
         s.stop('Setup failed: ' + e.message);
         process.exit(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).`);
+    // Always show what ran where: installing to user scope prints the command
+    // itself; file writes print the path; stale entries print the update command.
+    for (const r of installs) {
+        const target = editorTarget(r.id, projectRoot);
+        const cmd = editorCommand(r.id, slug).split('\n').join('\n  ');
+        if (r.outcome === 'added')
+            clack.log.success(`MCP → ${target}:\n  ${cmd}\n  ${r.detail}`);
+        else if (r.outcome === 'already-current')
+            clack.log.success(`MCP → ${target}: ${r.detail} — skipped.`);
+        else if (r.outcome === 'stale')
+            clack.log.warn(`MCP → ${target}: ${r.detail}`);
+        else
+            clack.log.warn(`MCP → ${target} failed: ${r.detail}`);
+    }
+    // Post-deploy readability probe: one retry — right after a deploy the
+    // first API read intermittently fails at TCP level ("fetch failed")
+    // while the retry succeeds, and a false "not readable" scares users.
+    let scene = null;
+    let sceneError = null;
+    for (let attempt = 0; attempt < 2 && !scene; attempt++) {
+        if (attempt > 0)
+            await new Promise((r) => setTimeout(r, 3000));
+        try {
+            scene = await getScene(slug);
         }
-        else {
-            clack.log.info(`${EDITOR_LABELS[id]} config:\n${editorCommand(id, slug)}`);
+        catch (e) {
+            sceneError = e;
         }
     }
-    try {
-        const scene = await getScene(slug);
+    if (scene) {
         clack.log.success(`Scene readable: ${scene.elements.length} elements @${CANVAS_BRANCH}.`);
     }
-    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.');
+    else {
+        clack.log.warn(`Scene not readable yet: ${sceneError?.message || sceneError} — draw once to create it.`);
     }
-    clack.outro(`Canvas live: ${viewerUrl}`);
+    if (live)
+        clack.log.success('Viewer is serving.');
+    else
+        clack.log.warn('Viewer was not live after 7 minutes — check the Pages/Cloudflare build, then retry the URL.');
+    clack.outro(live ? `Canvas live: ${viewerUrl}` : `Canvas pending: ${viewerUrl}`);
 }
 function printHelp() {
     console.log(`excalidrop — remote GitHub-backed canvas (no local server)
 
 Usage:
   npx excalidrop                          interactive setup TUI
-  npx excalidrop setup owner/repo [--target pages|cloudflare] [--editor claude-project,codex,cursor,desktop,opencode] [--no-prompt]
+  npx excalidrop setup owner/repo [--target pages|cloudflare] [--editor claude-project,claude-user,codex,cursor,cursor-user,desktop,opencode,opencode-user] [--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
@@ -564,9 +1039,19 @@ async function main() {
         case 'publish':
             await cmdSetup(['--no-prompt', ...rest]);
             break;
-        case 'add':
-            printEditorCommands(parseEditorsFlag(rest) || [...EDITOR_IDS], rest.find((a) => a.includes('/')) || detectSlug() || 'owner/repo');
+        case 'add': {
+            const root = findProjectRoot(process.cwd());
+            const ids = parseEditorsFlag(rest) || [...EDITOR_IDS];
+            const raw = rest.find((a) => a.includes('/') || a.includes('github.com')) || detectSlug() || 'owner/repo';
+            const repo = normalizeRepoSlug(raw) || raw;
+            console.log('Add excalidrop to your AI agent (no install, always latest):\n');
+            for (const id of ids) {
+                const st = repo.includes('/') ? detectEditorState(id, repo, root) : null;
+                const mark = st?.status === 'current' ? ' (installed)' : st?.status === 'stale' ? ` (installed → ${st.repo ?? 'unknown'})` : '';
+                console.log(`## ${EDITOR_LABELS[id]} → ${editorTarget(id, root)}${mark}\n${editorCommand(id, repo)}\n`);
+            }
             break;
+        }
         case 'init':
         case 'up':
         case 'remote':