excalidrop 0.2.14 → 0.2.15

package/dist/cli.d.ts

@@ -8,5 +8,6 @@ export type EditorStatus = {
     repo: string | null;
     where: string;
     outdatedForm?: boolean;
+    pinned?: boolean;
 };
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":";AA8QA,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQ5E;AA4JD,sFAAsF;AACtF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASvD;AAwJD,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":";AA8QA,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQ5E;AAuKD,sFAAsF;AACtF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASvD;AAqKD,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC"}

package/dist/cli.js

@@ -345,13 +345,25 @@ function wranglerAccount() {
     const m = r.out.match(/[\w.+-]+@[\w-]+\.[\w.]+/);
     return { ok: true, display: m?.[0] ?? 'logged in' };
 }
+/** Create a Pages project (idempotent). 'taken' = global subdomain collision
+ *  owned by someone else; 'ok' = created or already owned by this account. */
+function createCfProject(project) {
+    const create = spawnSync('npx', [...WRANGLER, 'pages', 'project', 'create', project, '--force', '--production-branch=main'], { stdio: 'pipe', encoding: 'utf8', env: wranglerEnv() });
+    const createOut = (create.stdout || '') + (create.stderr || '');
+    if (create.status === 0 || /already exists/i.test(createOut))
+        return 'ok';
+    if (/taken|already in use|not available|conflict|8007|8008/i.test(createOut))
+        return 'taken';
+    throw new Error(`wrangler pages project create failed:\n${createOut.slice(-800)}\nRun \`wrangler login\` first (or set CLOUDFLARE_API_TOKEN).`);
+}
 function deployToCloudflarePages(project, dir) {
     // 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 create = spawnSync('npx', [...WRANGLER, 'pages', 'project', 'create', project, '--force', '--production-branch=main'], { stdio: 'pipe', encoding: 'utf8', env: wranglerEnv() });
-    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).`);
+    // The TUI pre-flights this; headless runs land here (create is idempotent).
+    const st = createCfProject(project);
+    if (st === 'taken') {
+        const [o] = project.split('-');
+        throw new Error(`The project name "${project}" is already taken on Cloudflare Pages (${project}.pages.dev is global, owned by someone else). Choose another name and re-run with --project-name <name> (e.g. --project-name "${project}-${o || 'app'}").`);
     }
     const r = spawnSync('npx', [...WRANGLER, 'pages', 'deploy', dir || viewerDir(), '--project-name', project, '--force'], { stdio: 'inherit', env: wranglerEnv() });
     if (r.status !== 0)
@@ -498,13 +510,21 @@ function ensureNpxPrefix() {
     }
     catch { /* spawn will surface real errors */ }
 }
+// User-scope (global) entries are repo-less: the server resolves the canvas
+// at spawn time (--repo flag → $EXCALIDROP_REPO → .excalidrop.json → git
+// origin → last-used repo) and remembers the last repo. Pinning --repo in a
+// global entry would freeze every editor on one canvas and force a "repoint"
+// on every setup. Project-scope entries keep their --repo pin (per-project).
+// Pass repo=null for user-scope, the slug for project-scope.
 function mcpArgs(repo) {
     // --prefix isolates the npx install from the caller's project: when an
     // editor spawns this from inside a checkout whose package.json is ALSO
     // named excalidrop at a satisfying version, bare `npx -y excalidrop@latest`
     // resolves to the local (possibly bin-less/stale) tree and dies with
     // "command not found". A neutral prefix forces the registry fetch.
-    return ['--prefix', NPX_PREFIX, '-y', 'excalidrop@latest', 'mcp', '--repo', repo];
+    return repo
+        ? ['--prefix', NPX_PREFIX, '-y', 'excalidrop@latest', 'mcp', '--repo', repo]
+        : ['--prefix', NPX_PREFIX, '-y', 'excalidrop@latest', 'mcp'];
 }
 // Quote one argv element for display/manual-run strings (arrays stay raw).
 function shellQuote(a) {
@@ -513,18 +533,22 @@ function shellQuote(a) {
 function mcpArgsDisplay(repo) {
     return mcpArgs(repo).map(shellQuote).join(' ');
 }
+/** Repo arg for an editor install: null (dynamic) for user-scope, slug for project-scope. */
+function installRepo(id, repo) {
+    return editorScope(id) === 'user' ? null : repo;
+}
 const EDITOR_IDS = ['claude-project', 'claude-user', 'codex', 'cursor', 'cursor-user', 'desktop', 'opencode', 'opencode-user'];
 function editorCommand(id, repo) {
-    const a = mcpArgsDisplay(repo);
+    const a = mcpArgsDisplay(installRepo(id, repo));
     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':
         case 'cursor-user':
-        case 'desktop': return JSON.stringify({ mcpServers: { excalidrop: { command: 'npx', args: mcpArgs(repo) } } }, null, 2);
+        case 'desktop': return JSON.stringify({ mcpServers: { excalidrop: { command: 'npx', args: mcpArgs(installRepo(id, repo)) } } }, 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);
+        case 'opencode-user': return JSON.stringify({ $schema: 'https://opencode.ai/config.json', mcp: { excalidrop: { type: 'local', command: ['npx', ...mcpArgs(installRepo(id, repo))], enabled: true } } }, null, 2);
     }
 }
 function editorScope(id) {
@@ -614,22 +638,49 @@ function codexMcpRepo() {
 }
 function detectEditorState(id, repo, root) {
     const want = repo.toLowerCase();
+    // User-scope (global) entries must stay repo-less — the server remembers
+    // the last/current canvas at runtime. A legacy --repo pin is stale (migrate
+    // once to dynamic, then it stays current forever). Project-scope entries
+    // keep the pinned-repo comparison.
+    const dynamic = editorScope(id) === 'user';
     if (id === 'codex') {
         const s = codexMcpRepo();
         if (!s.present)
             return { status: 'missing', repo: null, where: '~/.codex/config.toml' };
-        if (s.repo === want && s.modern)
+        if (!s.modern)
+            return { status: 'stale', repo: s.repo, where: '~/.codex/config.toml', outdatedForm: true, pinned: !!s.repo };
+        if (dynamic)
+            return s.repo
+                ? { status: 'stale', repo: s.repo, where: '~/.codex/config.toml', pinned: true }
+                : { status: 'current', repo: null, where: '~/.codex/config.toml' };
+        if (s.repo === want)
             return { status: 'current', repo: s.repo, where: '~/.codex/config.toml' };
-        return { status: 'stale', repo: s.repo, where: '~/.codex/config.toml', outdatedForm: s.repo === want && !s.modern };
+        return { 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 };
-    if (s.repo === want && s.modern)
+    if (!s.modern)
+        return { status: 'stale', repo: s.repo, where, outdatedForm: true, pinned: !!s.repo };
+    if (dynamic)
+        return s.repo
+            ? { status: 'stale', repo: s.repo, where, pinned: true }
+            : { status: 'current', repo: null, where };
+    if (s.repo === want)
         return { status: 'current', repo: s.repo, where };
-    return { status: 'stale', repo: s.repo, where, outdatedForm: s.repo === want && !s.modern };
+    return { status: 'stale', repo: s.repo, where };
+}
+/** Human-readable reason a stale entry needs rewriting. */
+function staleWhy(st) {
+    if (st.outdatedForm && st.pinned)
+        return `pinned to ${st.repo} with outdated npx form — unpin to dynamic (remembers last repo)`;
+    if (st.outdatedForm)
+        return 'outdated npx form (missing --prefix)';
+    if (st.pinned)
+        return `pinned to ${st.repo} — global entry must stay repo-less (remembers last repo)`;
+    return `points at ${st.repo ?? 'unknown'}`;
 }
 function updateCommand(id, repo) {
     if (id === 'claude-project' || id === 'claude-user') {
@@ -697,23 +748,23 @@ function opencodeEntry(repo) {
 }
 function installEditor(id, repo, root) {
     const fail = (detail) => ({ id, outcome: 'failed', detail });
+    const want = installRepo(id, repo);
+    const at = (r) => (r ?? 'dynamic (remembers last repo)');
     // 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'
-        ? (st.outdatedForm ? ' (outdated npx form — needs --prefix)' : ` (currently → ${st.repo ?? 'unknown'})`)
-        : '';
+        return { id, outcome: 'already-current', detail: `${st.where} already → ${at(st.repo)}` };
+    const staleNote = st.status === 'stale' ? ` (${staleWhy(st)})` : '';
     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)]
+            ? ['mcp', 'add', 'excalidrop', '--scope', 'project', '--', 'npx', ...mcpArgs(want)]
             : id === 'claude-user'
-                ? ['mcp', 'add', 'excalidrop', '--scope', 'user', '--', 'npx', ...mcpArgs(repo)]
-                : ['mcp', 'add', 'excalidrop', '--', 'npx', ...mcpArgs(repo)];
+                ? ['mcp', 'add', 'excalidrop', '--scope', 'user', '--', 'npx', ...mcpArgs(want)]
+                : ['mcp', 'add', 'excalidrop', '--', 'npx', ...mcpArgs(want)];
         const r = runCapture(bin, cargs);
         if (r.status === 0 && !/already exists/i.test(r.out)) {
             // detail must NOT repeat the command — callers already print editorCommand.
@@ -724,17 +775,16 @@ function installEditor(id, repo, root) {
             // 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}` };
-            const why = now.outdatedForm ? 'outdated npx form (missing --prefix)' : `→ ${now.repo ?? 'unknown'}`;
-            return { id, outcome: 'stale', detail: `already exists (${why}) — not updated. Run:\n${updateCommand(id, repo)}` };
+                return { id, outcome: 'already-current', detail: `${now.where} already → ${at(now.repo)}` };
+            return { id, outcome: 'stale', detail: `already exists (${staleWhy(now)}) — not updated. Run:\n${updateCommand(id, repo)}` };
         }
         return fail((r.out.trim() || `${bin} exited ${r.status}`).slice(0, 300));
     }
     // 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);
+    const entry = id === 'cursor' || id === 'cursor-user' || id === 'desktop' ? cursorEntry(want) : opencodeEntry(want);
     if (upsertJsonMcp(f.path, f.key, entry)) {
-        return { id, outcome: 'added', detail: `wrote ${shortenHome(f.path)}${staleNote} → ${repo}` };
+        return { id, outcome: 'added', detail: `wrote ${shortenHome(f.path)}${staleNote} → ${at(want)}` };
     }
     return fail(`${shortenHome(f.path)} is not valid JSON — leaving it untouched. Add manually:\n${editorCommand(id, repo)}`);
 }
@@ -774,6 +824,8 @@ function stateHint(st) {
         return 'installed';
     if (st.status !== 'stale')
         return undefined;
+    if (st.pinned)
+        return `pinned → ${st.repo}`;
     if (st.outdatedForm)
         return 'outdated entry (old npx form)';
     return `installed → ${st.repo ?? 'unknown'}`;
@@ -783,7 +835,7 @@ function harnessSummary(h, slug, root) {
     const parts = ids.map((id) => {
         const st = detectEditorState(id, slug, root);
         const cur = st.status === 'current' ? 'installed' : st.status === 'stale'
-            ? (st.outdatedForm ? 'outdated entry' : `installed → ${st.repo ?? 'unknown'}`)
+            ? (st.pinned ? `pinned → ${st.repo}` : st.outdatedForm ? 'outdated entry' : `installed → ${st.repo ?? 'unknown'}`)
             : '—';
         return ids.length > 1 ? `${editorScope(id)}: ${cur}` : cur;
     });
@@ -869,12 +921,29 @@ async function cmdSetup(args, editorOverride, opts = {}) {
         await ghGet(`/repos/${slug}`);
     }
     catch (e) {
-        if (String(e.message).includes('→ 404')) {
+        const msg = String(e.message || '');
+        if (msg.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);
         }
+        if (/installations and requests .* disabled|oauth .* restricted|organization .* blocked|access restricted by/i.test(msg)) {
+            const [owner, name] = slug.split('/');
+            console.error([
+                `Organization "${owner}" disables OAuth/GitHub-App installs and requests ("Installations and requests are disabled").`,
+                `OAuth login cannot unlock this canvas. Use a fine-grained PAT instead:`,
+                ``,
+                `  1. Create: https://github.com/settings/personal-access-tokens/new?name=excalidrop-${owner}-${name}&resource_owner=${owner}`,
+                `     Scope: ONLY repository ${slug} → Contents: Read & write. Tokens for other repos or classic ghp_ are rejected.`,
+                `  2. Export it for this command: GITHUB_TOKEN=github_pat_... npx excalidrop setup ${slug}`,
+                `  3. In the viewer, open "Use PAT" and paste the same token.`,
+            ].join('\n'));
+            process.exit(1);
+        }
         throw e;
     }
+    if (/^ghp_/i.test(process.env.GITHUB_TOKEN || '')) {
+        console.warn('Warning: GITHUB_TOKEN looks like a classic PAT (ghp_) with broad access. Prefer a fine-grained PAT (github_pat_) scoped to this repo only with Contents: Read & write.');
+    }
     const explicitTarget = parseFlag(args, 'target');
     const target = await resolveTarget(slug, explicitTarget);
     console.log(`Repo: ${slug}\nHost: ${target}${explicitTarget ? (opts.fromTui ? ' (selected)' : ' (explicit)') : ' (auto: private→cloudflare, public→pages)'}\n`);
@@ -1151,26 +1220,46 @@ async function runTui() {
         process.exit(0);
     }
     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).
-    // Suggest the simplest free name (bare repo first, availability-checked
-    // against this account); republish keeps the current project for URL stability.
+    // Cloudflare project name = the GLOBAL *.pages.dev subdomain. Offer the
+    // choice up front so the URL is predictable (and re-runnable without
+    // surprises). suggestProjectName only checks THIS account's project list —
+    // a short name like `test` can still be taken globally, so the message
+    // must not promise "free" and the create step retries on taken names.
+    // Republish keeps the current project for URL stability.
     let project = projectNameForRepo(slug);
     if (target === 'cloudflare') {
         const suggested = suggestProjectName(slug, findProjectRoot(process.cwd()));
         if (suggested !== project)
-            clack.log.info(`Shortest free project name: ${suggested} (default was ${project}).`);
-        const nameAnswer = await clack.text({
-            message: 'Cloudflare project name (viewer host)?',
-            placeholder: suggested,
-            initialValue: suggested,
-            validate: (v) => (normalizeProjectName(v, '') ? undefined : 'Lowercase letters, numbers, hyphens.'),
-        });
-        if (clack.isCancel(nameAnswer)) {
-            clack.cancel('Aborted.');
-            process.exit(0);
+            clack.log.info(`Shortest available name in your account: ${suggested}. Note: *.pages.dev is global — a short name may still be taken; you'll be asked again if so.`);
+        const askProject = async (initial) => {
+            const nameAnswer = await clack.text({
+                message: 'Cloudflare project name (viewer host)?',
+                placeholder: initial,
+                initialValue: initial,
+                validate: (v) => (normalizeProjectName(v, '') ? undefined : 'Lowercase letters, numbers, hyphens.'),
+            });
+            if (clack.isCancel(nameAnswer)) {
+                clack.cancel('Aborted.');
+                process.exit(0);
+            }
+            return normalizeProjectName(nameAnswer, project);
+        };
+        project = await askProject(suggested);
+        // Pre-flight: `project create` fails when the subdomain is taken globally
+        // (even if absent from this account). Retry in the prompt instead of
+        // dying mid-deploy. `createCfProject` returns 'taken' for a global
+        // collision, 'ok' when created or already owned by this account.
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const st = createCfProject(project);
+            if (st === 'ok')
+                break;
+            const [owner, name] = slug.split('/');
+            const alts = [`${owner}-${name}`, projectNameForRepo(slug), `${project}-${owner}`]
+                .map((s) => normalizeProjectName(s, '')).filter(Boolean)
+                .filter((s, i, a) => a.indexOf(s) === i && s !== project);
+            clack.log.warn(`The name "${project}" is already taken on Cloudflare Pages (${project}.pages.dev is global, owned by someone else)${alts.length > 0 ? `. Try: ${alts.slice(0, 3).join(', ')}` : ''}.`);
+            project = await askProject(alts[0] || `${project}-2`);
         }
-        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
@@ -1241,19 +1330,21 @@ async function runTui() {
             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. Same-repo entries
-    // in the old npx form count as stale too (they break when spawned from
-    // inside an excalidrop checkout).
+    // "already exists" and changes nothing) — offer an explicit rewrite before
+    // the deploy phase so the install below actually lands. That covers the old
+    // npx form, legacy --repo pins on user-scope entries (global entries stay
+    // repo-less), and project-scope entries pointing at another repo.
     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 what = st.outdatedForm
-            ? `${EDITOR_LABELS[id]} uses the old npx form (breaks inside excalidrop checkouts) — rewrite it for ${slug}?`
-            : `${EDITOR_LABELS[id]} points at ${st.repo ?? 'unknown'} — repoint to ${slug}?`;
+        const what = st.pinned && editorScope(id) === 'user'
+            ? `${EDITOR_LABELS[id]} is pinned to ${st.repo} — make it dynamic (remember last repo)?`
+            : st.outdatedForm
+                ? `${EDITOR_LABELS[id]} uses the old npx form (breaks inside excalidrop checkouts) — rewrite it${editorScope(id) === 'user' ? ' (dynamic, no repo pin)' : ` for ${slug}`}?`
+                : `${EDITOR_LABELS[id]} points at ${st.repo ?? 'unknown'} — repoint to ${slug}?`;
         const ok = await clack.confirm({ message: what });
         if (clack.isCancel(ok)) {
             clack.cancel('Aborted.');
@@ -1324,7 +1415,7 @@ function printHelp() {
 Usage:
   npx excalidrop                          interactive setup TUI
   npx excalidrop setup owner/repo [--target pages|cloudflare] [--relay shared|self] [--editor claude-project,claude-user,codex,cursor,cursor-user,desktop,opencode,opencode-user] [--no-prompt]
-  npx --prefix ~/.excalidrop-npx -y excalidrop@latest mcp --repo owner/repo   run MCP stdio server (editors use this)
+  npx --prefix ~/.excalidrop-npx -y excalidrop@latest mcp   run MCP stdio server, repo auto-resolved (--repo owner/repo overrides)
   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
@@ -1366,7 +1457,9 @@ async function main() {
             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' ? (st.outdatedForm ? ' (outdated npx form)' : ` (installed → ${st.repo ?? 'unknown'})`) : '';
+                const mark = st?.status === 'current'
+                    ? (editorScope(id) === 'user' ? ' (installed, dynamic)' : ' (installed)')
+                    : st?.status === 'stale' ? (st.pinned ? ` (pinned → ${st.repo})` : st.outdatedForm ? ' (outdated npx form)' : ` (installed → ${st.repo ?? 'unknown'})`) : '';
                 console.log(`## ${EDITOR_LABELS[id]} → ${editorTarget(id, root)}${mark}\n${editorCommand(id, repo)}\n`);
             }
             break;