@vincentt-xr/cli 0.1.0 → 0.1.2

package/dist/cli/index.js

@@ -12,7 +12,7 @@
 import os from "node:os";
 import path from "node:path";
 import { runLogin } from "../login/login.js";
-import { clearMachineToken, loadMachineConfig, } from "../shared/config.js";
+import { clearMachineToken, clearProjectBinding, loadMachineConfig, } from "../shared/config.js";
 import { getMe } from "../lib/backend.js";
 import { diagQuery, diagRead, previewStart, previewStop, projectCreate, projectPublish, } from "../lib/lifecycle.js";
 import { fetchNext, readCursor, writeCursor } from "../lib/feedback.js";
@@ -82,10 +82,23 @@ async function create() {
         name: flag("--name"),
         slug: flag("--slug"),
         scaffold: has("--no-scaffold") ? false : undefined,
+        force: has("--force"),
+        onProgress: (m) => console.error(`  ${m}`),
     });
     console.log(result.message);
-    if (result.alreadyBound)
+    if (result.alreadyBound) {
         process.exitCode = 1;
+        return;
+    }
+    // Chain straight into the dev loop when asked.
+    if (has("--preview")) {
+        console.log("");
+        await preview();
+    }
+}
+async function unbind() {
+    const { path: p, hadBinding } = await clearProjectBinding(projectDir());
+    console.log(hadBinding ? `✓ Unbound. Removed ${p}` : "This directory has no project binding.");
 }
 async function publish() {
     const result = await projectPublish(projectDir(), {
@@ -182,9 +195,11 @@ function usage() {
         `Auth\n` +
         `  login              Sign in; save an access token to ~/.vincentt/config.json\n` +
         `  logout             Remove the saved access token\n` +
-        `  whoami             Show the signed-in account (via GET /me)\n\n` +
+        `  whoami             Show the signed-in account (via GET /network/me)\n\n` +
         `Dev loop\n` +
-        `  create             Create/bind a project (scaffolds the starter if empty)\n` +
+        `  create             Scaffold + bind a project (empty dir → full starter)\n` +
+        `                       [--name <s>] [--slug <s>] [--preview] [--force]\n` +
+        `  unbind             Detach this directory from its project\n` +
         `  publish            Upload the built dist; go live at <slug>.vincentt.app\n` +
         `  preview            Serve + tunnel the app for on-device preview\n\n` +
         `Diagnostics (need a running preview)\n` +
@@ -210,6 +225,8 @@ async function main() {
             return whoami();
         case "create":
             return create();
+        case "unbind":
+            return unbind();
         case "publish":
             return publish();
         case "preview":

package/dist/lib/backend.js

@@ -137,9 +137,9 @@ export async function publishUpload(cfg, projectId, distDir, opts = {}) {
 /** Resolve the signed-in identity for `vincentt whoami`. Throws on any non-2xx so
  *  the caller can degrade to "token present, unverified". */
 export async function getMe(cfg) {
-    const res = await authFetch(cfg, "/me");
+    const res = await authFetch(cfg, "/network/me");
     if (!res.ok) {
-        throw new BackendError(`/me failed (${res.status}): ${await safeText(res)}`, res.status);
+        throw new BackendError(`/network/me failed (${res.status}): ${await safeText(res)}`, res.status);
     }
     return (await res.json());
 }

package/dist/lib/lifecycle.d.ts

@@ -5,6 +5,10 @@ export interface CreateOptions {
     name?: string;
     slug?: string;
     scaffold?: boolean;
+    /** Rebind a directory that already has a binding (drops the old one). */
+    force?: boolean;
+    /** Step-level progress for slow phases (scaffold, install). CLI prints; MCP omits. */
+    onProgress?: (message: string) => void;
 }
 export interface CreateResult {
     message: string;

package/dist/lib/lifecycle.js

@@ -4,56 +4,96 @@
 // MCP SDK concerns leak in here. Both surfaces render the returned data their
 // own way.
 import path from "node:path";
-import { createProject, gitHeadSha, publishUpload } from "./backend.js";
+import { BackendError, createProject, gitHeadSha, publishUpload } from "./backend.js";
+import { slugify } from "./slug.js";
 import { filterErrors, httpRelayClient, renderResult, } from "./diagnostics.js";
 import { clearRelayInfo, readRelayInfo, writeRelayInfo } from "./relayInfo.js";
-import { loadProjectBinding, resolveConfig, writeProjectBinding, } from "../shared/config.js";
-import { installDependencies, needsScaffold, scaffoldFromTemplate, } from "../scaffold/index.js";
+import { clearProjectBinding, loadProjectBinding, resolveConfig, writeProjectBinding, } from "../shared/config.js";
+import { detectPackageManager, installDependencies, needsScaffold, scaffoldFromTemplate, } from "../scaffold/index.js";
 import { startPreview } from "../preview/index.js";
 export async function projectCreate(projectCwd, opts = {}) {
+    const progress = opts.onProgress ?? (() => { });
     const existing = await loadProjectBinding(projectCwd);
-    if (existing) {
+    if (existing && !opts.force) {
         return {
-            message: `This directory is already bound to project ${existing.projectId} (slug ${existing.slug}). Delete .vincentt/project.json to rebind.`,
+            message: `This directory is already bound to project ${existing.projectId} (slug ${existing.slug}).\n` +
+                `Run \`vincentt create --force\` to rebind, or \`vincentt unbind\` to detach.`,
             alreadyBound: true,
             slug: existing.slug,
             projectId: existing.projectId,
         };
     }
+    if (existing)
+        await clearProjectBinding(projectCwd);
     // Resolve config first so a missing PAT fails before any clone/side effect.
     const cfg = await resolveConfig(projectCwd);
     let scaffolded = false;
     if (opts.scaffold !== false && (await needsScaffold(projectCwd))) {
+        progress("Scaffolding the v2-template starter…");
         await scaffoldFromTemplate(projectCwd);
         scaffolded = true;
     }
-    const created = await createProject(cfg, opts.name ?? path.basename(projectCwd), opts.slug);
+    const name = opts.name ?? path.basename(projectCwd);
+    progress("Registering the project…");
+    const created = await createProjectPreferringSlug(cfg, name, opts.slug);
     const bindingPath = await writeProjectBinding(projectCwd, {
         projectId: created.projectId,
         slug: created.slug,
     });
-    let scaffoldNote = "";
+    const steps = [];
     if (scaffolded) {
-        scaffoldNote = "Scaffolded the v2-template starter into this directory.\n";
+        steps.push("Scaffolded v2-template into this directory.");
+        const pm = await detectPackageManager(projectCwd);
+        progress(`Installing dependencies (${pm} install — this can take a minute)…`);
         try {
             await installDependencies(projectCwd);
-            scaffoldNote += "Installed dependencies (npm install).\n";
+            steps.push(`Installed dependencies (${pm}).`);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            scaffoldNote += `Note: \`npm install\` failed (${msg}) — run it manually before preview.\n`;
+            steps.push(`Dependencies NOT installed (${msg}) — run \`${pm} install\` before preview.`);
         }
     }
+    const preamble = steps.length ? steps.map((s) => `✓ ${s}`).join("\n") + "\n" : "";
     return {
-        message: scaffoldNote +
-            `Created "${created.name}" → slug ${created.slug} (id ${created.projectId}).\n` +
-            `Binding written to ${bindingPath} (gitignored).\n` +
-            `Build locally, then publish to go live at ${created.slug}.vincentt.app.`,
+        message: preamble +
+            `✓ Created "${created.name}" — slug: ${created.slug} (id ${created.projectId})\n` +
+            `  Live URL after publish: https://${created.slug}.vincentt.app\n` +
+            `  Binding: ${bindingPath} (gitignored)\n\n` +
+            `Next:\n` +
+            `  vincentt preview     open a live URL on your phone\n` +
+            `  vincentt publish     go live at ${created.slug}.vincentt.app`,
         alreadyBound: false,
         slug: created.slug,
         projectId: created.projectId,
     };
 }
+/**
+ * Create the backend project, preferring a slug derived from the name so the live
+ * URL reads like the app (`my-app.vincentt.app`) instead of a random one. An
+ * explicit `slug` is authoritative — a collision surfaces so the caller re-asks.
+ * A derived slug is best-effort: on any 4xx we fall back to a platform-assigned
+ * slug rather than failing create over a name we chose.
+ */
+async function createProjectPreferringSlug(cfg, name, explicitSlug) {
+    if (explicitSlug)
+        return createProject(cfg, name, explicitSlug);
+    const candidate = slugify(name);
+    if (!candidate)
+        return createProject(cfg, name);
+    try {
+        return await createProject(cfg, name, candidate);
+    }
+    catch (err) {
+        if (err instanceof BackendError &&
+            err.status !== undefined &&
+            err.status >= 400 &&
+            err.status < 500) {
+            return createProject(cfg, name); // taken/invalid derived slug → let the platform pick
+        }
+        throw err;
+    }
+}
 export async function projectPublish(projectCwd, opts = {}) {
     const binding = await loadProjectBinding(projectCwd);
     if (!binding) {

package/dist/lib/slug.d.ts

@@ -0,0 +1 @@
+export declare function slugify(input: string): string;

package/dist/lib/slug.js

@@ -0,0 +1,14 @@
+// Derive a DNS-safe slug candidate from a human name. The slug becomes the
+// permanent <slug>.vincentt.app host, so it must be lowercase (DNS lowercases,
+// S3 does not — the platform enforces lowercase end-to-end) and a single DNS
+// label (<= 63 chars). Returns "" when the name has no usable characters, in
+// which case the caller lets the backend auto-assign.
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 63)
+        .replace(/-+$/g, "");
+}

package/dist/preview/runner.d.ts

@@ -16,7 +16,9 @@ export interface StartPreviewOptions {
     /** stdio for the app dev serve. "ignore" (default) keeps an MCP server's stdout
      *  clean; a CLI can pass "inherit" to surface build output. */
     appStdio?: "ignore" | "inherit";
-    /** How long to wait for cloudflared to register before giving up (default 45s). */
+    /** How long to wait for cloudflared to register before giving up (default 90s).
+     *  Generous because on a network that blocks the QUIC edge, cloudflared spends
+     *  ~20-30s failing QUIC before it falls back to the http2 edge, which does work. */
     registerTimeoutMs?: number;
     /** How long to wait for the app to serve before returning anyway (default 8s).
      *  Kept short so an MCP tool call stays within strict clients' ~30s timeout;
@@ -40,6 +42,9 @@ export interface RunningPreview {
 export declare function startPreview(opts: StartPreviewOptions): Promise<RunningPreview>;
 /**
  * Resolve once cloudflared reports a live edge connection, reject if it exits
- * first or never registers. Exported for unit testing the log-scan/timeout logic.
+ * first or never registers. On failure the rejection carries cloudflared's own
+ * recent output — otherwise "did not register" hides the real cause (an invalid
+ * run token, or a network that blocks the QUIC edge, the two common culprits).
+ * `onLine` streams each log line out live. Exported for unit testing.
  */
-export declare function waitForRegister(tunnel: ChildProcess, timeoutMs: number): Promise<void>;
+export declare function waitForRegister(tunnel: ChildProcess, timeoutMs: number, onLine?: (line: string) => void): Promise<void>;

package/dist/preview/runner.js

@@ -16,7 +16,7 @@ import { startSessionTunnel } from "./tunnel.js";
 import { proxyWeb, proxyWs } from "./proxy.js";
 import { getFreePort, isPortListening, waitForApp } from "./net.js";
 export async function startPreview(opts) {
-    const { projectCwd, harnessPath = "/__harness", devCommand = ["npm", "run", "dev"], appStdio = "ignore", registerTimeoutMs = 45_000, appReadyTimeoutMs = 8_000, onLog = () => undefined, } = opts;
+    const { projectCwd, harnessPath = "/__harness", devCommand = ["npm", "run", "dev"], appStdio = "ignore", registerTimeoutMs = 90_000, appReadyTimeoutMs = 8_000, onLog = () => undefined, } = opts;
     // Resolve ports. The app port defaults to 5173; the relay + front ports are
     // harness-internal, so auto-pick free ones (the relay port is returned for the
     // MCP diag_* tools to point at) instead of colliding on fixed defaults.
@@ -70,7 +70,7 @@ export async function startPreview(opts) {
         tunnel = spawn(cloudflaredBin, ["tunnel", "run", "--token", session.runToken], {
             stdio: ["ignore", "pipe", "pipe"],
         });
-        await waitForRegister(tunnel, registerTimeoutMs);
+        await waitForRegister(tunnel, registerTimeoutMs, (line) => onLog(`[cloudflared] ${line}`));
         // Don't hand back a live URL that serves a blank page: wait for the app to
         // actually respond. Non-fatal — a slow build still returns, flagged not-ready.
         const appReady = reuseApp ? true : await waitForApp(appPort, appReadyTimeoutMs);
@@ -86,11 +86,15 @@ export async function startPreview(opts) {
 }
 /**
  * Resolve once cloudflared reports a live edge connection, reject if it exits
- * first or never registers. Exported for unit testing the log-scan/timeout logic.
+ * first or never registers. On failure the rejection carries cloudflared's own
+ * recent output — otherwise "did not register" hides the real cause (an invalid
+ * run token, or a network that blocks the QUIC edge, the two common culprits).
+ * `onLine` streams each log line out live. Exported for unit testing.
  */
-export function waitForRegister(tunnel, timeoutMs) {
+export function waitForRegister(tunnel, timeoutMs, onLine) {
     return new Promise((resolve, reject) => {
         let settled = false;
+        const recent = [];
         const finish = (fn) => {
             if (settled)
                 return;
@@ -98,14 +102,25 @@ export function waitForRegister(tunnel, timeoutMs) {
             clearTimeout(timer);
             fn();
         };
+        const tail = () => {
+            const lines = recent.slice(-15).join("\n").trim();
+            return lines ? `\ncloudflared output:\n${lines}` : "";
+        };
         const scan = (buf) => {
-            if (/Registered tunnel connection|Connection [^ ]+ registered/.test(String(buf))) {
+            const text = String(buf);
+            for (const line of text.split(/\r?\n/)) {
+                if (!line.trim())
+                    continue;
+                recent.push(line);
+                onLine?.(line);
+            }
+            if (/Registered tunnel connection|Connection [^ ]+ registered/.test(text)) {
                 finish(resolve);
             }
         };
         tunnel.stdout?.on("data", scan);
         tunnel.stderr?.on("data", scan);
-        tunnel.on("exit", (code) => finish(() => reject(new Error(`cloudflared exited before registering (code ${code}).`))));
-        const timer = setTimeout(() => finish(() => reject(new Error(`cloudflared did not register within ${timeoutMs}ms.`))), timeoutMs);
+        tunnel.on("exit", (code) => finish(() => reject(new Error(`cloudflared exited before registering (code ${code}).${tail()}`))));
+        const timer = setTimeout(() => finish(() => reject(new Error(`cloudflared did not register within ${timeoutMs}ms.${tail()}`))), timeoutMs);
     });
 }

package/dist/scaffold/index.d.ts

@@ -17,10 +17,19 @@ export interface ScaffoldOptions {
  * fresh repo. Throws a clear error if the clone fails (e.g. no git access).
  */
 export declare function scaffoldFromTemplate(targetDir: string, opts?: ScaffoldOptions): Promise<void>;
+export type PackageManager = "pnpm" | "yarn" | "npm";
 /**
- * Install a freshly scaffolded project's dependencies so the first preview/build
- * doesn't fail on a missing node_modules. Throws on failure (no network, no npm);
- * the caller surfaces it as a "run npm install yourself" hint rather than aborting
- * project creation.
+ * Pick the package manager the scaffolded template is set up for, by its lockfile.
+ * The template ships a pnpm-lock.yaml + `node-linker=hoisted` (the hoisted layout
+ * the esbuild singleton aliasing needs), so installing with the wrong manager
+ * leaves a second lockfile and an unproven node_modules layout. Defaults to npm.
  */
-export declare function installDependencies(dir: string): Promise<void>;
+export declare function detectPackageManager(dir: string): Promise<PackageManager>;
+/**
+ * Install a freshly scaffolded project's dependencies (with the template's own
+ * package manager) so the first preview/build doesn't fail on a missing
+ * node_modules. Throws on failure (no network, manager not installed); the caller
+ * surfaces it as a "run <pm> install yourself" hint rather than aborting create.
+ * Returns the manager used so the caller can name it in messages.
+ */
+export declare function installDependencies(dir: string): Promise<PackageManager>;

package/dist/scaffold/index.js

@@ -71,15 +71,40 @@ async function isGitRepo(dir) {
     }
 }
 /**
- * Install a freshly scaffolded project's dependencies so the first preview/build
- * doesn't fail on a missing node_modules. Throws on failure (no network, no npm);
- * the caller surfaces it as a "run npm install yourself" hint rather than aborting
- * project creation.
+ * Pick the package manager the scaffolded template is set up for, by its lockfile.
+ * The template ships a pnpm-lock.yaml + `node-linker=hoisted` (the hoisted layout
+ * the esbuild singleton aliasing needs), so installing with the wrong manager
+ * leaves a second lockfile and an unproven node_modules layout. Defaults to npm.
+ */
+export async function detectPackageManager(dir) {
+    const has = async (f) => {
+        try {
+            await fs.access(path.join(dir, f));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (await has("pnpm-lock.yaml"))
+        return "pnpm";
+    if (await has("yarn.lock"))
+        return "yarn";
+    return "npm";
+}
+/**
+ * Install a freshly scaffolded project's dependencies (with the template's own
+ * package manager) so the first preview/build doesn't fail on a missing
+ * node_modules. Throws on failure (no network, manager not installed); the caller
+ * surfaces it as a "run <pm> install yourself" hint rather than aborting create.
+ * Returns the manager used so the caller can name it in messages.
  */
 export async function installDependencies(dir) {
-    // Windows: npm is npm.cmd — execFile needs a shell to resolve it.
-    await execFileAsync("npm", ["install"], {
+    const pm = await detectPackageManager(dir);
+    // Windows: the managers are .cmd shims — execFile needs a shell to resolve them.
+    await execFileAsync(pm, ["install"], {
         cwd: dir,
         shell: process.platform === "win32",
     });
+    return pm;
 }

package/dist/shared/config.d.ts

@@ -35,6 +35,11 @@ export declare function loadProjectBinding(cwd: string): Promise<ProjectBinding
  * secret-free-but-tenant-scoped binding never rides a commit or `git archive`).
  */
 export declare function writeProjectBinding(cwd: string, binding: ProjectBinding): Promise<string>;
+/** Remove the per-tree binding so the directory can be re-created/rebound. */
+export declare function clearProjectBinding(cwd: string): Promise<{
+    path: string;
+    hadBinding: boolean;
+}>;
 export interface ResolvedConfig {
     apiUrl: string;
     pat: string;

package/dist/shared/config.js

@@ -72,6 +72,13 @@ export async function writeProjectBinding(cwd, binding) {
     await ensureGitignored(cwd, `${BINDING_DIR}/`);
     return p;
 }
+/** Remove the per-tree binding so the directory can be re-created/rebound. */
+export async function clearProjectBinding(cwd) {
+    const p = projectBindingPath(cwd);
+    const hadBinding = (await readJsonIfExists(p)) !== undefined;
+    await fs.rm(p, { force: true });
+    return { path: p, hadBinding };
+}
 /** Append a pattern to the repo's .gitignore if not already present (best-effort). */
 async function ensureGitignored(cwd, pattern) {
     const gitignore = path.join(cwd, ".gitignore");
@@ -80,7 +87,9 @@ async function ensureGitignored(cwd, pattern) {
         const has = current.split(/\r?\n/).some((l) => l.trim() === pattern.trim());
         if (has)
             return;
-        const next = current && !current.endsWith("\n") ? `${current}\n${pattern}\n` : `${current}${pattern}\n`;
+        const next = current && !current.endsWith("\n")
+            ? `${current}\n${pattern}\n`
+            : `${current}${pattern}\n`;
         await fs.writeFile(gitignore, next, "utf8");
     }
     catch {
@@ -95,7 +104,10 @@ async function ensureGitignored(cwd, pattern) {
 export async function resolveConfig(cwd) {
     const machine = await loadMachineConfig();
     const binding = await loadProjectBinding(cwd);
-    const apiUrl = binding?.apiUrl ?? process.env.VINCENTT_API_URL ?? machine.apiUrl ?? "http://localhost:5051";
+    const apiUrl = binding?.apiUrl ??
+        process.env.VINCENTT_API_URL ??
+        machine.apiUrl ??
+        "http://localhost:5051";
     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}, ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincentt-xr/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Vincentt CLI — the vincentt command-line dev loop (login, create, publish, preview, diagnostics, feedback, relay, mcp)",
   "license": "UNLICENSED",
   "type": "module",