@lovinka/vitrinka 1.6.0 → 1.7.0

package/dist/cli.js

@@ -10,7 +10,7 @@
 // skills/screenshot/gallery.mjs (offline marker, COPYFILE_DISABLE, control-file excludes,
 // `--key`, repeatable `--chip`). gallery.mjs is now a passthrough shim to this file.
 // Design: vitrinka/docs/plans/2026-07-03-hand-in-hand-tooling-design.md
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync, copyFileSync, mkdtempSync, chmodSync, appendFileSync, statSync, cpSync, openSync, readSync, closeSync, } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync, copyFileSync, mkdtempSync, chmodSync, appendFileSync, statSync, cpSync, openSync, readSync, closeSync, realpathSync, } from 'node:fs';
 import { join, resolve, basename, dirname, extname, relative, sep } from 'node:path';
 import { tmpdir, hostname } from 'node:os';
 import { spawnSync, spawn } from 'node:child_process';
@@ -760,12 +760,45 @@ function loadVitrinkaCfg(root) {
     }
 }
 function shareUrl(cfg) {
-    return `${cfg.base}/${cfg.project}/${cfg.slug}/${cfg.key}`;
+    const ws = cfg.workspace ? `/w/${cfg.workspace}` : '';
+    return `${cfg.base}${ws}/${cfg.project}/${cfg.slug}/${cfg.key}`;
+}
+// resolveWorkspace resolves the multitenant workspace slug for DISPLAY URLs.
+// Precedence: --workspace flag > $VITRINKA_WORKSPACE > GET {base}/api/v1/whoami
+// (token-routed, the token IS the workspace) > "" (single-tenant). whoami is a
+// pure display-URL nicety — any failure (offline, older server, non-JSON) yields
+// "" and must never fail the command that called it.
+async function resolveWorkspace(args, base) {
+    const flag = strArg(args.workspace);
+    if (flag)
+        return flag;
+    if (process.env.VITRINKA_WORKSPACE)
+        return process.env.VITRINKA_WORKSPACE;
+    try {
+        const headers = {};
+        const token = readToken();
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
+        const res = await fetch(`${base}/api/v1/whoami`, { headers, signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            return '';
+        return String((await res.json()).workspace || '');
+    }
+    catch {
+        // Best-effort: unreachable/older server (no whoami) ⇒ single-tenant display URLs.
+        return '';
+    }
 }
-function remoteInitCmd(root, args) {
+async function remoteInitCmd(root, args) {
     if (existsSync(vitrinkaCfgPath(root))) {
         // Sticky per session dir — reuse, so re-activation never forks the set.
         const cfg = loadVitrinkaCfg(root);
+        // Older descriptors predate the workspace field — resolve + persist once so
+        // display URLs carry /w/<ws> without a whoami call on every re-activation.
+        if (cfg.workspace === undefined) {
+            cfg.workspace = await resolveWorkspace(args, cfg.base);
+            writeFileSync(vitrinkaCfgPath(root), JSON.stringify(cfg, null, 2) + '\n');
+        }
         console.log(`vitrinka set (existing) → ${shareUrl(cfg)}`);
         return cfg;
     }
@@ -795,6 +828,7 @@ function remoteInitCmd(root, args) {
         kind: args.kind && args.kind !== true ? String(args.kind) : 'screenshots',
         issue: args.issue && args.issue !== true ? String(args.issue) : '',
     };
+    cfg.workspace = await resolveWorkspace(args, base);
     mkdirSync(root, { recursive: true });
     ensureRootSelfIgnored(root);
     writeFileSync(vitrinkaCfgPath(root), JSON.stringify(cfg, null, 2) + '\n');
@@ -982,6 +1016,86 @@ async function nameCmd(rest, args) {
     else
         console.log(`named ${segs[0]}/${segs[1]}/${segs[2]} → ${base}/${segs[0]}/${segs[1]}/${encodeURIComponent(newName)}`);
 }
+// ---------- login: the CLI device dance ----------
+// loginCmd — `vitrinka login`: the multitenant sign-in. Starts a device-code
+// request, opens the browser approval page (the signed-in user confirms the
+// code and picks a workspace), polls until the server parks the minted PAT,
+// and saves it to ~/.config/vitrinka/token. On single-tenant/mesh installs
+// (no /api/v1/cli/auth route) it explains the shared-token path instead.
+async function loginCmd(args) {
+    const base = (strArg(args.base) || process.env.VITRINKA_URL || process.env.VITRINKA_BASE_URL
+        || 'https://vitrinka.lovinka.com').replace(/\/+$/, '');
+    let start;
+    try {
+        start = await fetch(`${base}/api/v1/cli/auth`, { method: 'POST', signal: AbortSignal.timeout(15_000) });
+    }
+    catch (e) {
+        fail(`login: ${base} unreachable (${e instanceof Error ? e.message : String(e)})`);
+        return;
+    }
+    if (start.status === 404) {
+        fail(`login: ${base} has no CLI sign-in (single-tenant install?) — use the shared token instead:\n\n${tokenHelp()}`);
+        return;
+    }
+    if (!start.ok)
+        fail(`login: ${base} refused (${start.status})`);
+    const s = (await start.json());
+    const verifyUrl = `${base}${s.verify_path}`;
+    console.log('');
+    console.log(`  Confirm this code in your browser:  ${s.user_code}`);
+    console.log(`  ${verifyUrl}`);
+    console.log('');
+    // Best-effort browser launch; the printed URL is the real contract.
+    const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    spawnSync(opener, [verifyUrl], { stdio: 'ignore' });
+    const intervalMs = Math.max(1, s.interval ?? 2) * 1000;
+    const deadline = Date.now() + (s.expires_in ?? 600) * 1000;
+    process.stdout.write('  waiting for approval …');
+    while (Date.now() < deadline) {
+        await new Promise((f) => setTimeout(f, intervalMs));
+        let res;
+        try {
+            res = await fetch(`${base}/api/v1/cli/auth/claim`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ device_code: s.device_code }),
+                signal: AbortSignal.timeout(15_000),
+            });
+        }
+        catch {
+            process.stdout.write('.'); // transient network blip — keep polling
+            continue;
+        }
+        if (res.status === 202) {
+            process.stdout.write('.');
+            continue;
+        }
+        if (!res.ok) {
+            console.log('');
+            fail(`login: ${res.status === 404 ? 'code expired — run vitrinka login again' : `claim failed (${res.status})`}`);
+        }
+        const { token } = (await res.json());
+        const p = tokenPath();
+        mkdirSync(dirname(p), { recursive: true });
+        writeFileSync(p, token + '\n', { mode: 0o600 });
+        console.log('\n');
+        // The token IS the workspace — show which one this machine now acts in.
+        try {
+            const who = await fetch(`${base}/api/v1/whoami`, {
+                headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(15_000),
+            });
+            const w = (await who.json());
+            console.log(`  ✓ signed in — token saved to ${p}${w.workspace ? ` (workspace: ${w.workspace})` : ''}`);
+        }
+        catch {
+            console.log(`  ✓ signed in — token saved to ${p}`);
+        }
+        console.log('  next: vitrinka install   (skills + MCP + shim, if not done yet)');
+        return;
+    }
+    console.log('');
+    fail('login: approval timed out (10 min) — run vitrinka login again');
+}
 // ---------- operator: the board-attribution persona ----------
 // operatorCmd manages the operator persona name — how vitrinka credits this
 // machine's writes on boards.
@@ -1628,8 +1742,9 @@ export function hasBoardFooterLink(settings) {
 // original command is recorded on the VITRINKA_ORIG line (single-quoted), both
 // to run it and so a re-run can recover it instead of wrapping the wrapper.
 // Board detection mirrors the CLI's capture-root contract: .screenshots/.vitrinka
-// with {base, key} → ${base}/boards/${key}. Needs jq (like the statusline
-// examples in Claude's own docs); without jq it degrades to pass-through.
+// with {base, key[, workspace]} → ${base}[/w/${workspace}]/boards/${key}. Needs jq
+// (like the statusline examples in Claude's own docs); without jq it degrades to
+// pass-through.
 export function buildStatuslineWrapper(origCmd) {
     const quoted = origCmd.replaceAll("'", `'\\''`);
     return `#!/bin/bash
@@ -1660,7 +1775,9 @@ for VJSON in "$DIR/.screenshots/.vitrinka" "$PROJECT_DIR/.screenshots/.vitrinka"
   [ -f "$VJSON" ] || continue
   VBASE=$(jq -r '.base // empty' "$VJSON" 2>/dev/null)
   VKEY=$(jq -r '.key // empty' "$VJSON" 2>/dev/null)
+  VWS=$(jq -r '.workspace // empty' "$VJSON" 2>/dev/null)
   if [ -n "$VBASE" ] && [ -n "$VKEY" ]; then
+    [ -n "$VWS" ] && VBASE="$VBASE/w/$VWS"
     BOARD=$(printf '\\033[35m🧷\\033[0m \\033[2m%s\\033[0m' "$VBASE/boards/$VKEY")
   fi
   break
@@ -1782,7 +1899,8 @@ function boardUrlOf(root) {
     if (!existsSync(vitrinkaCfgPath(root)))
         return '';
     const cfg = loadVitrinkaCfg(root);
-    return `${cfg.base}/boards/${cfg.key}`;
+    const ws = cfg.workspace ? `/w/${cfg.workspace}` : '';
+    return `${cfg.base}${ws}/boards/${cfg.key}`;
 }
 // openCmd opens the thing you're working on: the capture root's live board when
 // one exists, else the vitrinka home. --qr renders the URL as a terminal QR
@@ -2570,7 +2688,7 @@ createRoot(document.getElementById('root')).render(html\`<\${App} />\`);
 </html>
 `;
 }
-function artifactInitCmd(args) {
+async function artifactInitCmd(args) {
     const slugRaw = strArg(args.slug);
     if (!slugRaw) {
         console.error('artifact-init: --slug <slug> is required');
@@ -2589,11 +2707,11 @@ function artifactInitCmd(args) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(indexPath, blankScaffold(title, existsSync(join(dir, 'data.json'))));
     ensureGitIgnored(process.cwd(), '.artifacts/');
-    remoteInitCmd(dir, { ...args, key: slug, kind });
+    await remoteInitCmd(dir, { ...args, key: slug, kind });
     console.log(`scaffolded ${indexPath}`);
     console.log(`author the App, then: node ${CLI_PATH} push --root ${dir} --title "<Human title>"`);
 }
-function artifactFromSetCmd(args) {
+async function artifactFromSetCmd(args) {
     const slugRaw = strArg(args.slug);
     if (!slugRaw) {
         console.error('artifact-from-set: --slug <slug> is required');
@@ -2619,7 +2737,7 @@ function artifactFromSetCmd(args) {
     const title = strArg(args.title) || (fromManifest.journey && fromManifest.journey.title) || slug;
     writeFileSync(indexPath, composedScaffold(title, `${slug}.zip`));
     ensureGitIgnored(process.cwd(), '.artifacts/');
-    remoteInitCmd(dir, { ...args, key: slug, kind: strArg(args.kind) || 'report' });
+    await remoteInitCmd(dir, { ...args, key: slug, kind: strArg(args.kind) || 'report' });
     // Record the source screenshot set (project/branchSlug/key) so push sends ?source= and
     // vitrinka can cross-link set ↔ artifact both ways.
     let source = strArg(args.source);
@@ -2699,6 +2817,11 @@ export const COMMANDS = [
         usage: '[<name>] [--base <url>]', positional: '[<name>]', flags: [BASE_FLAG],
         examples: ['vitrinka operator', 'vitrinka operator "Lukáš"'],
     },
+    {
+        name: 'login', summary: 'Sign this machine in: browser approval mints a personal, workspace-scoped token',
+        usage: '[--base <url>]', flags: [BASE_FLAG],
+        examples: ['vitrinka login', 'vitrinka login --base https://vitrinka.lovinka.com'],
+    },
     {
         name: 'doctor', summary: 'Check this machine\'s setup (server, token, operator, skills, shim, MCP); --fix repairs it',
         usage: '[--fix] [--base <url>]',
@@ -3335,7 +3458,11 @@ async function boardFromSetCmd(root, args) {
         process.exit(1);
     }
     const out = await imp.json();
-    console.log(`flow board: ${cfg.base}/boards/${slug}  (${out.cards.length} cards, ${out.edges.length} edges)`);
+    // Prefer the server-authoritative board url (carries /w/<workspace>); compose
+    // the workspace-prefixed path only as a fallback for older servers.
+    const ws = cfg.workspace ? `/w/${cfg.workspace}` : '';
+    const boardUrl = out.board?.url || `${cfg.base}${ws}/boards/${slug}`;
+    console.log(`flow board: ${boardUrl}  (${out.cards.length} cards, ${out.edges.length} edges)`);
     // The board is about to be annotated — make sure its autocomplete index is fresh.
     await pushProjectIndex(dirname(root), cfg.base, cfg.project);
 }
@@ -3599,13 +3726,15 @@ async function runSub(argv) {
     else if (cmd === 'meta')
         metaCmd(root, args);
     else if (cmd === 'remote-init')
-        remoteInitCmd(root, args);
+        await remoteInitCmd(root, args);
     else if (cmd === 'push')
         await pushCmd(root, args);
     else if (cmd === 'name')
         await nameCmd(argv, args);
     else if (cmd === 'operator')
         await operatorCmd(argv, args);
+    else if (cmd === 'login')
+        await loginCmd(args);
     else if (cmd === 'doctor')
         await doctorCmd(args);
     else if (cmd === 'install')
@@ -3635,9 +3764,9 @@ async function runSub(argv) {
     else if (cmd === 'embed-shots')
         embedShotsCmd(root, args);
     else if (cmd === 'artifact-init')
-        artifactInitCmd(args);
+        await artifactInitCmd(args);
     else if (cmd === 'artifact-from-set')
-        artifactFromSetCmd(args);
+        await artifactFromSetCmd(args);
     else
         throw new Error(`runSub: unhandled command ${JSON.stringify(cmd)}`); // guarded by the caller
 }
@@ -3646,7 +3775,20 @@ async function runSub(argv) {
 // calling it here — before its definition below — is fine, and keeping the
 // entry block adjacent to runSub keeps the help/completion cases out of the
 // runSub-vs-registry source scan in dx.test.ts.
-const IS_MAIN = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href === import.meta.url : false;
+// realpathSync resolves the PATH symlink (e.g. ~/.bun/bin/vitrinka →
+// .../dist/cli.js) so the entry path matches import.meta.url — resolve() alone
+// doesn't follow symlinks, so the bin shim would otherwise never be IS_MAIN and
+// the CLI would silently exit 0. Fall back to the raw resolve() if the entry
+// somehow can't be realpath'd (never on a real run, but keep it non-fatal).
+function entryHref(argvPath) {
+    try {
+        return pathToFileURL(realpathSync(resolve(argvPath))).href;
+    }
+    catch {
+        return pathToFileURL(resolve(argvPath)).href;
+    }
+}
+const IS_MAIN = process.argv[1] ? entryHref(process.argv[1]) === import.meta.url : false;
 if (IS_MAIN) {
     await main(process.argv.slice(2));
 }