@vincentt-xr/cli 0.1.5 → 0.2.0

package/dist/shared/config.js

@@ -7,6 +7,7 @@
 //     remixer would inherit — and publish over — the original's project.
 // Env vars (VINCENTT_API_URL / VINCENTT_PAT) override the file for local/dogfood
 // runs so a creator can point at a dev backend without editing the machine config.
+// The binding's optional apiUrl does NOT — see decideApiUrl.
 import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -30,19 +31,30 @@ export async function loadMachineConfig() {
     return (await readJsonIfExists(MACHINE_CONFIG_PATH)) ?? {};
 }
 /**
- * Merge a patch into ~/.vincentt/config.json (used by `harness login` to persist
- * a freshly minted PAT). Preserves any other fields already present. The file
- * holds a bearer credential, so the dir/file get owner-only perms.
+ * Persist the machine config with owner-only perms. `writeFile`'s `mode` only applies when
+ * it CREATES the file, so a pre-existing config.json with looser perms (e.g. 0644) would keep
+ * them and leave a bearer credential world-readable. An explicit chmod after the write tightens
+ * it to 0600 every time, whether the file was just created or already existed.
  */
-export async function writeMachineConfig(patch) {
-    const next = { ...(await loadMachineConfig()), ...patch };
+async function persistMachineConfig(next) {
     await fs.mkdir(path.dirname(MACHINE_CONFIG_PATH), { recursive: true, mode: 0o700 });
     await fs.writeFile(MACHINE_CONFIG_PATH, JSON.stringify(next, null, 2) + "\n", {
         encoding: "utf8",
         mode: 0o600,
     });
+    await fs.chmod(MACHINE_CONFIG_PATH, 0o600);
     return MACHINE_CONFIG_PATH;
 }
+/**
+ * Merge a patch into ~/.vincentt/config.json (used by `harness login` to persist
+ * a freshly minted PAT). Preserves any other fields already present. The file
+ * holds a bearer credential, so the dir/file get owner-only perms (enforced on
+ * every write, even when the file pre-existed with looser perms).
+ */
+export async function writeMachineConfig(patch) {
+    const next = { ...(await loadMachineConfig()), ...patch };
+    return persistMachineConfig(next);
+}
 /**
  * Remove the stored PAT from ~/.vincentt/config.json (used by `vincentt logout`),
  * preserving apiUrl and any other fields. Returns whether a token was present.
@@ -51,16 +63,44 @@ export async function clearMachineToken() {
     const current = await loadMachineConfig();
     const hadToken = Boolean(current.pat);
     delete current.pat;
-    await fs.mkdir(path.dirname(MACHINE_CONFIG_PATH), { recursive: true, mode: 0o700 });
-    await fs.writeFile(MACHINE_CONFIG_PATH, JSON.stringify(current, null, 2) + "\n", {
-        encoding: "utf8",
-        mode: 0o600,
-    });
+    await persistMachineConfig(current);
     return { path: MACHINE_CONFIG_PATH, hadToken };
 }
 export async function loadProjectBinding(cwd) {
     return readJsonIfExists(projectBindingPath(cwd));
 }
+/**
+ * Locate the binding by PRECEDENCE, never inference: cwd, then each ancestor up
+ * to and including the git root. Nothing is guessed from the folder name and
+ * there is no "you only have one project" fallback — a wrong-but-plausible
+ * binding is silent retargeting, which B12 forbids.
+ *
+ * The walk stops at the git root so a binding in a parent repo cannot capture an
+ * unrelated sibling tree, and at the filesystem root when there is no repo.
+ */
+export async function locateProjectBinding(cwd) {
+    let dir = path.resolve(cwd);
+    for (;;) {
+        const binding = await readJsonIfExists(projectBindingPath(dir));
+        if (binding)
+            return { binding, dir, path: projectBindingPath(dir) };
+        if (await isGitRoot(dir))
+            return undefined;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+async function isGitRoot(dir) {
+    try {
+        await fs.access(path.join(dir, ".git"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Write the per-tree binding and make sure `.vincentt/` is gitignored (so the
  * secret-free-but-tenant-scoped binding never rides a commit or `git archive`).
@@ -96,22 +136,95 @@ async function ensureGitignored(cwd, pattern) {
         // A missing/unwritable .gitignore must not fail project creation.
     }
 }
+export const DEFAULT_API_URL = "http://localhost:5051";
+export function decideApiUrl(input) {
+    const configuredUrl = input.envApiUrl ?? input.machineApiUrl ?? DEFAULT_API_URL;
+    const binding = input.bindingApiUrl;
+    if (!binding || strip(binding) === strip(configuredUrl)) {
+        return { apiUrl: configuredUrl, configuredUrl };
+    }
+    if (input.allowCustomApi) {
+        return { apiUrl: binding, configuredUrl, usedBindingApiUrl: binding };
+    }
+    return { apiUrl: configuredUrl, configuredUrl, ignoredBindingApiUrl: binding };
+}
+function strip(url) {
+    return url.replace(/\/$/, "");
+}
 /**
- * Resolve the API URL + PAT for a machine call. Precedence: a project binding's
- * apiUrl wins for the URL; env vars override the machine-config file; the file is
- * the base. Throws a clear, actionable error when no PAT is configured.
+ * Resolve the API URL + PAT for a machine call. Throws a clear, actionable error
+ * when no PAT is configured. When a binding's apiUrl diverges from the configured
+ * one, the safe branch has ALREADY been taken by the time the advisory prints —
+ * it reports a decision rather than asking for one.
  */
-export async function resolveConfig(cwd) {
+export async function resolveConfig(cwd, opts = {}) {
     const machine = await loadMachineConfig();
-    const binding = await loadProjectBinding(cwd);
-    const apiUrl = binding?.apiUrl ??
-        process.env.VINCENTT_API_URL ??
-        machine.apiUrl ??
-        "http://localhost:5051";
+    const located = await locateProjectBinding(cwd);
+    const decided = decideApiUrl({
+        bindingApiUrl: located?.binding.apiUrl,
+        envApiUrl: process.env.VINCENTT_API_URL,
+        machineApiUrl: machine.apiUrl,
+        allowCustomApi: opts.allowCustomApi,
+    });
+    const warn = opts.warn;
+    if (warn) {
+        for (const line of apiUrlAdvisory(decided, {
+            bindingPath: located ? relativeBindingPath(cwd, located) : BINDING_REL_PATH,
+        })) {
+            warn(line);
+        }
+    }
     const pat = process.env.VINCENTT_PAT ?? machine.pat;
     if (!pat) {
         throw new Error(`No Vincentt access token found. Add {"apiUrl":"…","pat":"…"} to ${MACHINE_CONFIG_PATH}, ` +
             `or set the VINCENTT_PAT env var.`);
     }
-    return { apiUrl: apiUrl.replace(/\/$/, ""), pat };
+    return { apiUrl: strip(decided.apiUrl), pat };
+}
+const BINDING_REL_PATH = `${BINDING_DIR}/${BINDING_FILE}`;
+function relativeBindingPath(cwd, located) {
+    const rel = path.relative(path.resolve(cwd), located.path);
+    return rel.startsWith("..") ? located.path : rel;
+}
+/**
+ * The Flow L12 transcripts. Ignoring an override is the loud case (both hosts on
+ * their own aligned lines, the mechanism named, and where to go look); honoring one
+ * on purpose is two quiet lines, because a creator who typed the flag has already
+ * stated intent and re-reading the lecture every run is how advisories get
+ * filtered out mentally — taking the un-flagged one with them.
+ */
+export function apiUrlAdvisory(decided, ctx) {
+    if (decided.usedBindingApiUrl) {
+        return [
+            `!  Using this folder's API override: ${decided.usedBindingApiUrl}`,
+            `   (your machine config is ${decided.configuredUrl})`,
+            "",
+        ];
+    }
+    if (!decided.ignoredBindingApiUrl)
+        return [];
+    const label = `binding (${ctx.bindingPath}):`;
+    const pad = " ".repeat(Math.max(1, label.length - "your machine config:".length));
+    return [
+        "!  This folder's binding points at a different Vincentt API.",
+        "",
+        `     ${label}  ${decided.ignoredBindingApiUrl}`,
+        `     your machine config:${pad}  ${decided.configuredUrl}`,
+        "",
+        "   Your access token is sent with every request, so it would go to",
+        `   ${hostOf(decided.ignoredBindingApiUrl)}. A binding file travels with a repository —`,
+        "   anyone who can commit to it can set this.",
+        "",
+        "   Ignoring the binding and using your machine config.",
+        "   To use the binding's API on purpose, re-run with --allow-custom-api.",
+        "",
+    ];
+}
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincentt-xr/cli",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Vincentt CLI — the vincentt command-line dev loop (login, create, publish, preview, diagnostics, feedback, relay, mcp)",
   "license": "UNLICENSED",
   "type": "module",
@@ -22,11 +22,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "cloudflared": "^0.7.1",
     "qrcode": "^1.5.4",
     "ws": "^8.18.0",
     "zod": "^3.23.8",
-    "@vincentt-xr/harness": "1.0.0"
+    "@vincentt-xr/harness": "1.1.0"
   },
   "devDependencies": {
     "@types/qrcode": "^1.5.5",

package/dist/login/login.d.ts

@@ -1,34 +0,0 @@
-export interface LoginOptions {
-    /** Editor base URL that serves the /oauth consent page. */
-    editorUrl: string;
-    /** Backend API base URL the minted PAT authenticates against (paired with editorUrl). */
-    apiUrl: string;
-    /** Human label stored with the token (shown in the editor's token list). */
-    tokenName: string;
-    /** Abort if the browser round-trip doesn't complete in time. Default 5 min. */
-    timeoutMs?: number;
-    /** Set false to skip launching a browser (tests / headless). Default true. */
-    openInBrowser?: boolean;
-    /** Called with the authorize URL once the listener is up (for a printable fallback). */
-    onUrl?: (url: string) => void;
-}
-/** Prefix a scheme when the user passed a bare host; localhost defaults to http. */
-export declare function normalizeBaseUrl(u: string): string;
-export declare function buildAuthorizeUrl(editorBase: string, redirectUri: string, state: string, tokenName: string): string;
-export type CallbackResult = {
-    ok: true;
-    token: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** Interpret the editor's loopback redirect. State is verified first, always. */
-export declare function parseCallback(params: URLSearchParams, expectedState: string): CallbackResult;
-/**
- * Run the loopback OAuth round-trip and persist the resulting PAT. Resolves with
- * the apiUrl written to config; rejects on cancel, state mismatch, or timeout.
- */
-export declare function runLogin(opts: LoginOptions): Promise<{
-    apiUrl: string;
-    configPath: string;
-}>;

package/dist/login/login.js

@@ -1,148 +0,0 @@
-// `harness login` — obtain a Personal Access Token via the editor's /oauth flow.
-//
-// The CLI can't mint a PAT directly (POST /access-tokens is Cognito-only, so a
-// machine token can never mint another). Instead it delegates to the editor:
-//   1. Start a loopback HTTP listener on 127.0.0.1:<ephemeral port>.
-//   2. Open the browser to <editor>/oauth?redirect_uri=…&state=…&name=… — the
-//      editor reuses its own passwordless login + a consent screen and mints the
-//      PAT on the user's behalf.
-//   3. The editor redirects ?token=<vpat_…>&state=… back to the loopback.
-//   4. Verify state, write the PAT to ~/.vincentt/config.json.
-// The PAT crosses only over loopback on the user's own machine.
-import { spawn } from "node:child_process";
-import { createServer } from "node:http";
-import { randomBytes } from "node:crypto";
-import { getFreePort } from "../preview/net.js";
-import { writeMachineConfig } from "../shared/config.js";
-/** Prefix a scheme when the user passed a bare host; localhost defaults to http. */
-export function normalizeBaseUrl(u) {
-    if (/^https?:\/\//i.test(u))
-        return u;
-    const local = /^(localhost|127\.0\.0\.1)(:|\/|$)/i.test(u);
-    return `${local ? "http" : "https"}://${u}`;
-}
-export function buildAuthorizeUrl(editorBase, redirectUri, state, tokenName) {
-    const u = new URL("/oauth", normalizeBaseUrl(editorBase));
-    u.searchParams.set("redirect_uri", redirectUri);
-    u.searchParams.set("state", state);
-    u.searchParams.set("name", tokenName);
-    return u.toString();
-}
-/** Interpret the editor's loopback redirect. State is verified first, always. */
-export function parseCallback(params, expectedState) {
-    if (params.get("state") !== expectedState) {
-        return { ok: false, message: "State mismatch — ignoring an unexpected callback." };
-    }
-    const error = params.get("error");
-    if (error) {
-        return {
-            ok: false,
-            message: error === "access_denied" ? "Authorization was cancelled." : `Authorization failed: ${error}`,
-        };
-    }
-    const token = params.get("token");
-    if (!token)
-        return { ok: false, message: "No token in the authorization response." };
-    return { ok: true, token };
-}
-function escapeHtml(s) {
-    return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
-}
-// Standalone success/failure page shown in the browser tab after the loopback
-// round-trip. Fully self-contained (inline CSS, no assets) since it's served off
-// the CLI's own listener; theme-aware to match the editor's sand/ink palette.
-function browserPage(ok, heading, body) {
-    const accent = ok ? "#16a34a" : "#dc2626";
-    const glyph = ok ? "&check;" : "&times;";
-    return `<!doctype html>
-<html lang="en"><head><meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1"><title>Vincentt XR</title>
-<style>
-  :root { color-scheme: light dark; }
-  * { box-sizing: border-box; }
-  body { margin:0; min-height:100vh; display:flex; align-items:center; justify-content:center;
-    font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
-    background:#f4efe6; color:#1c1917; }
-  .card { width:min(92vw,380px); background:#fff; border:1px solid #e7e0d3; border-radius:16px;
-    padding:40px 36px; text-align:center; box-shadow:0 10px 40px rgba(0,0,0,.08); }
-  .brand { display:flex; align-items:center; justify-content:center; gap:8px; margin-bottom:26px;
-    font-weight:700; font-size:15px; letter-spacing:-.01em; }
-  .dot { width:26px; height:26px; border-radius:8px; background:linear-gradient(135deg,#7c3aed,#2563eb); }
-  .glyph { width:48px; height:48px; margin:0 auto 16px; border-radius:50%; color:#fff;
-    display:flex; align-items:center; justify-content:center; font-size:26px; line-height:1; background:${accent}; }
-  h1 { font-size:19px; margin:0 0 6px; }
-  p { font-size:13px; opacity:.7; margin:0; line-height:1.5; }
-  @media (prefers-color-scheme: dark) {
-    body { background:#1c1917; color:#f4efe6; }
-    .card { background:#292524; border-color:#3f3a36; }
-  }
-</style></head>
-<body><div class="card">
-  <div class="brand"><span class="dot"></span>Vincentt XR</div>
-  <div class="glyph">${glyph}</div>
-  <h1>${escapeHtml(heading)}</h1>
-  <p>${escapeHtml(body)}</p>
-</div></body></html>`;
-}
-function openBrowser(url) {
-    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
-    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-    try {
-        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-        child.on("error", () => { });
-        child.unref();
-    }
-    catch {
-        // Falls back to the printed URL (onUrl) — never fatal.
-    }
-}
-/**
- * Run the loopback OAuth round-trip and persist the resulting PAT. Resolves with
- * the apiUrl written to config; rejects on cancel, state mismatch, or timeout.
- */
-export async function runLogin(opts) {
-    const state = randomBytes(16).toString("hex");
-    const port = await getFreePort();
-    const redirectUri = `http://127.0.0.1:${port}/callback`;
-    const authorizeUrl = buildAuthorizeUrl(opts.editorUrl, redirectUri, state, opts.tokenName);
-    const token = await new Promise((resolve, reject) => {
-        const server = createServer((req, res) => {
-            const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
-            if (url.pathname !== "/callback") {
-                res.writeHead(404, { "content-type": "text/plain" });
-                res.end("Not found");
-                return;
-            }
-            const result = parseCallback(url.searchParams, state);
-            res.writeHead(result.ok ? 200 : 400, { "content-type": "text/html; charset=utf-8" });
-            res.end(result.ok
-                ? browserPage(true, "You're signed in", "You can close this tab and return to your terminal.")
-                : browserPage(false, "Sign-in failed", result.message));
-            // A state-mismatch response is answered but must NOT settle the flow — a
-            // stray/forged request shouldn't tear down the listener the real callback
-            // still needs.
-            if (result.ok) {
-                server.close();
-                resolve(result.token);
-            }
-            else if (url.searchParams.get("state") === state) {
-                server.close();
-                reject(new Error(result.message));
-            }
-        });
-        server.on("error", reject);
-        server.listen(port, "127.0.0.1", () => {
-            opts.onUrl?.(authorizeUrl);
-            if (opts.openInBrowser !== false)
-                openBrowser(authorizeUrl);
-        });
-        const timer = setTimeout(() => {
-            server.close();
-            reject(new Error("Timed out waiting for browser authorization."));
-        }, opts.timeoutMs ?? 5 * 60_000);
-        timer.unref();
-    });
-    const apiUrl = opts.apiUrl.replace(/\/$/, "");
-    const configPath = await writeMachineConfig({ apiUrl, pat: token });
-    return { apiUrl, configPath };
-}

package/dist/preview/cloudflared.d.ts

@@ -1,13 +0,0 @@
-export interface EnsureCloudflaredOptions {
-    /** Progress sink for the one-time download (it is ~40MB and takes a few seconds). */
-    onLog?: (message: string) => void;
-}
-/**
- * Return a spawnable cloudflared command/path, provisioning one if the host has
- * none. Resolves to `"cloudflared"` when a system install is on PATH, else to the
- * `cloudflared` package's managed binary (already fetched by its postinstall, or
- * downloaded here on demand when install scripts were skipped). Throws only if the
- * download itself fails (offline / blocked egress) — surface that to the user
- * with the manual `brew install cloudflared` fallback.
- */
-export declare function ensureCloudflared(opts?: EnsureCloudflaredOptions): Promise<string>;

package/dist/preview/cloudflared.js

@@ -1,46 +0,0 @@
-// Resolve a runnable cloudflared binary so a preview never hard-fails on a
-// missing system install. The tunnel protocol is proprietary QUIC to Cloudflare's
-// edge — there is no pure-Node connector, so *some* cloudflared binary is
-// required. We prefer one already on PATH (respects a user's own install) and
-// otherwise fall back to the copy the `cloudflared` npm package provisions, so a
-// fresh machine that installed only the harness can still preview on a device.
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-function isOnPath() {
-    // `which`/`where` exits 0 only when the binary resolves on PATH.
-    const probe = process.platform === "win32" ? "where" : "which";
-    return spawnSync(probe, ["cloudflared"], { stdio: "ignore" }).status === 0;
-}
-/**
- * Return a spawnable cloudflared command/path, provisioning one if the host has
- * none. Resolves to `"cloudflared"` when a system install is on PATH, else to the
- * `cloudflared` package's managed binary (already fetched by its postinstall, or
- * downloaded here on demand when install scripts were skipped). Throws only if the
- * download itself fails (offline / blocked egress) — surface that to the user
- * with the manual `brew install cloudflared` fallback.
- */
-export async function ensureCloudflared(opts = {}) {
-    if (isOnPath())
-        return "cloudflared";
-    const cloudflared = await import("cloudflared");
-    if (existsSync(cloudflared.bin))
-        return cloudflared.bin;
-    // Reached only when the package's postinstall was skipped (e.g. --ignore-scripts).
-    const log = opts.onLog ?? (() => undefined);
-    log("cloudflared not found — downloading a one-time copy…");
-    await mkdir(path.dirname(cloudflared.bin), { recursive: true });
-    // The download may print progress. On an MCP stdio server, ANY stdout write
-    // corrupts the JSON-RPC stream — redirect stdout→stderr for its duration.
-    const realWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = process.stderr.write.bind(process.stderr);
-    try {
-        await cloudflared.install(cloudflared.bin);
-    }
-    finally {
-        process.stdout.write = realWrite;
-    }
-    log(`cloudflared ready at ${cloudflared.bin}`);
-    return cloudflared.bin;
-}

package/dist/preview/tunnel.d.ts

@@ -1,14 +0,0 @@
-import { type MintedTunnel } from "../lib/backend.js";
-export interface SessionTunnel extends MintedTunnel {
-    /** Public https URL to open on the device. */
-    url: string;
-    /** Tear the tunnel down (DNS route + tunnel). Idempotent; call on SIGINT. */
-    reap: () => Promise<void>;
-}
-/**
- * Mint a per-session dev tunnel for the project bound to `projectCwd`, routing
- * <slug>-<token>.<apex> to the local `localPort`. Returns the URL to open and a
- * `reap()` for teardown. Throws with an actionable message when the directory is
- * unbound (run project_create) or no backend/PAT is configured.
- */
-export declare function startSessionTunnel(projectCwd: string, localPort: number): Promise<SessionTunnel>;

package/dist/preview/tunnel.js

@@ -1,28 +0,0 @@
-// Per-session dev tunnel: resolve the project binding + machine config and mint a
-// named tunnel via the backend (which holds the Cloudflare account creds). Stays
-// free of any child-process / cloudflared coupling — the caller runs cloudflared
-// with the returned run token (see runner.ts) and calls reap() on exit.
-import { loadProjectBinding, resolveConfig } from "../shared/config.js";
-import { mintTunnel, reapTunnel } from "../lib/backend.js";
-/**
- * Mint a per-session dev tunnel for the project bound to `projectCwd`, routing
- * <slug>-<token>.<apex> to the local `localPort`. Returns the URL to open and a
- * `reap()` for teardown. Throws with an actionable message when the directory is
- * unbound (run project_create) or no backend/PAT is configured.
- */
-export async function startSessionTunnel(projectCwd, localPort) {
-    const binding = await loadProjectBinding(projectCwd);
-    if (!binding) {
-        throw new Error("No project bound to this directory — run project_create first.");
-    }
-    const cfg = await resolveConfig(projectCwd);
-    const minted = await mintTunnel(cfg, binding.projectId, localPort);
-    return {
-        ...minted,
-        url: `https://${minted.hostname}`,
-        reap: () => reapTunnel(cfg, binding.projectId, {
-            tunnelId: minted.tunnelId,
-            dnsRecordId: minted.dnsRecordId,
-        }),
-    };
-}