@vincentt-xr/harness 0.4.0 → 1.0.0

package/dist/preview/net.js

@@ -1,56 +0,0 @@
-// TCP/HTTP port helpers for the preview runner: pick a free port for the internal
-// servers, detect a dev server already listening (so we reuse it instead of
-// spawning a second one), and wait for the app to actually serve before we hand
-// back a public URL.
-import { createServer, connect } from "node:net";
-import { get as httpGet } from "node:http";
-/** Ask the OS for an unused ephemeral port. */
-export function getFreePort() {
-    return new Promise((resolve, reject) => {
-        const srv = createServer();
-        srv.on("error", reject);
-        srv.listen(0, "127.0.0.1", () => {
-            const { port } = srv.address();
-            srv.close(() => resolve(port));
-        });
-    });
-}
-/** True if something already accepts TCP connections on the port (e.g. a dev server). */
-export function isPortListening(port, host = "127.0.0.1") {
-    return new Promise((resolve) => {
-        const sock = connect(port, host);
-        const done = (v) => {
-            sock.destroy();
-            resolve(v);
-        };
-        sock.setTimeout(400);
-        sock.once("connect", () => done(true));
-        sock.once("timeout", () => done(false));
-        sock.once("error", () => resolve(false));
-    });
-}
-/** Poll the app for any non-5xx HTTP response until it's ready or the timeout hits. */
-export function waitForApp(port, timeoutMs) {
-    const probe = () => new Promise((resolve) => {
-        const req = httpGet({ host: "127.0.0.1", port, path: "/", timeout: 1000 }, (res) => {
-            res.resume();
-            resolve((res.statusCode ?? 500) < 500);
-        });
-        req.on("error", () => resolve(false));
-        req.on("timeout", () => {
-            req.destroy();
-            resolve(false);
-        });
-    });
-    return new Promise((resolve) => {
-        const deadline = Date.now() + timeoutMs;
-        const tick = async () => {
-            if (await probe())
-                return resolve(true);
-            if (Date.now() >= deadline)
-                return resolve(false);
-            setTimeout(() => void tick(), 300);
-        };
-        void tick();
-    });
-}

package/dist/preview/proxy.d.ts

@@ -1,4 +0,0 @@
-import { type IncomingMessage, type ServerResponse } from "node:http";
-import type { Duplex } from "node:stream";
-export declare function proxyWeb(req: IncomingMessage, res: ServerResponse, targetPort: number): void;
-export declare function proxyWs(req: IncomingMessage, socket: Duplex, head: Buffer, targetPort: number): void;

package/dist/preview/proxy.js

@@ -1,49 +0,0 @@
-// A minimal same-host reverse proxy: forward HTTP requests and WebSocket upgrades
-// to a localhost target port. Enough for the preview front proxy (app + harness
-// relay behind one origin); not a general proxy. No deps.
-import { connect } from "node:net";
-import { request, } from "node:http";
-// Rewrite Host to the loopback target. cloudflared forwards the public Host, and
-// esbuild's `serve` 403s any Host it doesn't recognize — so the phone would get a
-// 403. The origin only needs a Host it accepts; the browser never sees this value.
-function localHeaders(headers, targetPort) {
-    return { ...headers, host: `localhost:${targetPort}` };
-}
-export function proxyWeb(req, res, targetPort) {
-    const proxyReq = request({
-        host: "127.0.0.1",
-        port: targetPort,
-        path: req.url,
-        method: req.method,
-        headers: localHeaders(req.headers, targetPort),
-    }, (proxyRes) => {
-        res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
-        proxyRes.pipe(res);
-    });
-    proxyReq.on("error", () => {
-        if (!res.headersSent)
-            res.writeHead(502);
-        res.end();
-    });
-    req.pipe(proxyReq);
-}
-export function proxyWs(req, socket, head, targetPort) {
-    // Re-issue the upgrade handshake against the target and splice the sockets.
-    const headers = localHeaders(req.headers, targetPort);
-    const upstream = connect(targetPort, "127.0.0.1", () => {
-        const headerLines = [
-            `${req.method} ${req.url} HTTP/1.1`,
-            ...Object.entries(headers).map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(", ") : v}`),
-            "",
-            "",
-        ].join("\r\n");
-        upstream.write(headerLines);
-        if (head && head.length)
-            upstream.write(head);
-        upstream.pipe(socket);
-        socket.pipe(upstream);
-    });
-    const bail = () => socket.destroy();
-    upstream.on("error", bail);
-    socket.on("error", bail);
-}

package/dist/preview/runner.d.ts

@@ -1,45 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-export interface StartPreviewOptions {
-    /** Project directory — its .vincentt binding + dev script drive the preview. */
-    projectCwd: string;
-    /** App dev-serve port (default 5173). If a server is already listening here, it
-     *  is reused instead of spawning a second one. */
-    appPort?: number;
-    /** Relay port. Default: an OS-assigned free port (returned as relayPort). */
-    relayPort?: number;
-    /** Front-proxy port the tunnel points at. Default: an OS-assigned free port. */
-    frontPort?: number;
-    /** Path routed to the relay instead of the app (default /__harness). */
-    harnessPath?: string;
-    /** Command that starts the app dev serve on $PORT (default `npm run dev`). */
-    devCommand?: string[];
-    /** 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). */
-    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;
-     *  a not-yet-ready app still returns (appReady=false), it isn't an error. */
-    appReadyTimeoutMs?: number;
-    /** Progress sink (relay/cloudflared lines). Never write app stdout to MCP stdout. */
-    onLog?: (message: string) => void;
-}
-export interface RunningPreview {
-    /** Public https URL to open on the device. */
-    url: string;
-    /** Relay port the diag_* tools query (may be OS-assigned). */
-    relayPort: number;
-    /** The app dev-serve port the tunnel ultimately serves. */
-    appPort: number;
-    /** Whether the app was responding when we returned (false = URL may be blank). */
-    appReady: boolean;
-    /** Tear down tunnel (+ DNS route), app dev serve, front proxy, and relay. */
-    stop: () => Promise<void>;
-}
-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.
- */
-export declare function waitForRegister(tunnel: ChildProcess, timeoutMs: number): Promise<void>;

package/dist/preview/runner.js

@@ -1,110 +0,0 @@
-// The whole preview stack behind one call. Stands up, in order: the app dev serve
-// (on an internal port), the harness relay (WS event sink + localhost /query), a
-// front proxy unifying them on one origin (`/__harness` → relay, else → app), and
-// a cloudflared tunnel to that origin so a phone gets ONE https URL that serves
-// both the app (secure context → live camera) and the diagnostics socket.
-//
-// Returns the public URL plus a `stop()` that reaps everything. A failure at any
-// step tears down what was already started, so the caller never leaks a child
-// process or a live backend tunnel. Used by both the CLI (`npm run preview`) and
-// the MCP verbs (preview_start / preview_stop).
-import { spawn } from "node:child_process";
-import { createServer } from "node:http";
-import { startRelay } from "../relay/server.js";
-import { ensureCloudflared } from "./cloudflared.js";
-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;
-    // 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.
-    const appPort = opts.appPort ?? 5173;
-    const relayPort = opts.relayPort ?? (await getFreePort());
-    const frontPort = opts.frontPort ?? (await getFreePort());
-    // If a dev server is already up on appPort, reuse it — don't spawn a second one
-    // that would fail to bind and leave the tunnel serving a broken origin.
-    const reuseApp = await isPortListening(appPort);
-    // Track every resource so any failure below can unwind exactly what started.
-    let app;
-    let relay;
-    let front;
-    let session;
-    let tunnel;
-    const stop = async () => {
-        tunnel?.kill();
-        app?.kill();
-        front?.close();
-        if (relay)
-            await relay.close();
-        if (session)
-            await session.reap();
-    };
-    try {
-        // Resolve cloudflared up front so a fresh host provisions it before we mint a
-        // tunnel we couldn't otherwise run.
-        const cloudflaredBin = await ensureCloudflared({ onLog });
-        if (reuseApp) {
-            onLog(`reusing the dev server already on :${appPort}`);
-        }
-        else {
-            app = spawn(devCommand[0], devCommand.slice(1), {
-                cwd: projectCwd,
-                env: { ...process.env, PORT: String(appPort) },
-                stdio: appStdio,
-                // Windows: npm/pnpm are .cmd shims — spawn needs a shell to resolve them.
-                shell: process.platform === "win32",
-            });
-        }
-        relay = startRelay({
-            port: relayPort,
-            path: harnessPath,
-            onLog: (m) => onLog(`[relay] ${m}`),
-        });
-        front = createServer((req, res) => proxyWeb(req, res, req.url?.startsWith(harnessPath) ? relayPort : appPort));
-        front.on("upgrade", (req, socket, head) => proxyWs(req, socket, head, req.url?.startsWith(harnessPath) ? relayPort : appPort));
-        await new Promise((resolve) => front.listen(frontPort, resolve));
-        session = await startSessionTunnel(projectCwd, frontPort);
-        tunnel = spawn(cloudflaredBin, ["tunnel", "run", "--token", session.runToken], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        await waitForRegister(tunnel, registerTimeoutMs);
-        // 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);
-        if (!appReady) {
-            onLog(`app on :${appPort} isn't responding yet — the URL may be blank until it builds`);
-        }
-        return { url: session.url, relayPort, appPort, appReady, stop };
-    }
-    catch (err) {
-        await stop();
-        throw err;
-    }
-}
-/**
- * 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.
- */
-export function waitForRegister(tunnel, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const finish = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            fn();
-        };
-        const scan = (buf) => {
-            if (/Registered tunnel connection|Connection [^ ]+ registered/.test(String(buf))) {
-                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);
-    });
-}

package/dist/preview/tunnel.d.ts

@@ -1,14 +0,0 @@
-import { type MintedTunnel } from "../mcp/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 "../mcp/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,
-        }),
-    };
-}

package/dist/relay/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/relay/cli.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// `harness-relay` — start the diagnostics relay beside Vite. The preview loop
-// spawns this (or you run it directly). Prints a line the tunnel step can read.
-import { startRelay } from "./server.js";
-const portArg = process.argv.indexOf("--port");
-const port = portArg !== -1 ? Number(process.argv[portArg + 1]) : 7331;
-startRelay({ port, onLog: (m) => console.log(`[harness-relay] ${m}`) });

package/dist/relay/server.d.ts

@@ -1,12 +0,0 @@
-import { EventStore } from "./store.js";
-export interface RelayOptions {
-    port?: number;
-    /** WS path the client connects to (default matches HarnessProvider). */
-    path?: string;
-    capacity?: number;
-    onLog?: (msg: string) => void;
-}
-export declare function startRelay(opts?: RelayOptions): {
-    store: EventStore;
-    close: () => Promise<void>;
-};

package/dist/relay/server.js

@@ -1,85 +0,0 @@
-// The relay: a WebSocket + HTTP server that sits beside Vite. The phone's
-// harness client pushes event batches over WS; the MCP server pulls via a
-// localhost HTTP endpoint. Deliberately tiny — all the buffering/querying logic
-// is in store.ts. One relay process per preview run; the cloudflared tunnel
-// carries the WS path to the phone.
-import { createServer } from "node:http";
-import { WebSocketServer } from "ws";
-import { EventStore } from "./store.js";
-export function startRelay(opts = {}) {
-    const port = opts.port ?? 7331;
-    const path = opts.path ?? "/__harness";
-    const store = new EventStore(opts.capacity);
-    const log = opts.onLog ?? (() => undefined);
-    const http = createServer((req, res) => handleHttp(req, res, store, log));
-    const wss = new WebSocketServer({ server: http, path });
-    wss.on("connection", (ws) => {
-        log("client connected");
-        ws.on("message", (data) => {
-            try {
-                const msg = JSON.parse(String(data));
-                if (msg.type === "events" && Array.isArray(msg.events)) {
-                    store.ingest(msg.sessionId, msg.events);
-                }
-            }
-            catch {
-                // ignore malformed frames — a bad client must not crash the relay
-            }
-        });
-        ws.on("close", () => log("client disconnected"));
-    });
-    http.listen(port, () => log(`relay listening on :${port} (ws ${path}, http /query)`));
-    return {
-        store,
-        close: () => new Promise((resolve) => {
-            wss.close();
-            http.close(() => resolve());
-        }),
-    };
-}
-// The MCP server (running on the same laptop) GETs /query with the RelayQuery
-// as JSON in the body or querystring. Localhost-only by deployment; no auth in
-// the local dev loop (the platform phase adds it).
-function handleHttp(req, res, store, log) {
-    const url = new URL(req.url ?? "/", "http://localhost");
-    if (url.pathname !== "/query") {
-        res.writeHead(404).end();
-        return;
-    }
-    readQuery(req, url)
-        .then((q) => {
-        const result = store.query(q);
-        res
-            .writeHead(200, { "content-type": "application/json" })
-            .end(JSON.stringify(result));
-    })
-        .catch((err) => {
-        log(`query error: ${err}`);
-        res.writeHead(400).end();
-    });
-}
-async function readQuery(req, url) {
-    if (req.method === "POST") {
-        const body = await readBody(req);
-        return body ? JSON.parse(body) : {};
-    }
-    const q = {};
-    const p = url.searchParams;
-    if (p.get("sessionId"))
-        q.sessionId = p.get("sessionId");
-    if (p.get("kind"))
-        q.kind = p.get("kind");
-    if (p.get("since"))
-        q.since = Number(p.get("since"));
-    if (p.get("limit"))
-        q.limit = Number(p.get("limit"));
-    return q;
-}
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        let data = "";
-        req.on("data", (c) => (data += c));
-        req.on("end", () => resolve(data));
-        req.on("error", reject);
-    });
-}

package/dist/relay/store.d.ts

@@ -1,13 +0,0 @@
-import type { DiagEvent, RelayQuery, RelayResult } from "../shared/events.js";
-export declare class EventStore {
-    private readonly capacity;
-    private readonly buf;
-    private readonly sessionsSeen;
-    private latest;
-    constructor(capacity?: number);
-    /** Ingest a batch from a client. Tracks the session and advances latestSeq. */
-    ingest(sessionId: string, events: DiagEvent[]): void;
-    /** Answer an MCP query against the buffer. Newest-biased when limited. */
-    query(q?: RelayQuery): RelayResult;
-    size(): number;
-}

package/dist/relay/store.js

@@ -1,68 +0,0 @@
-// The relay's memory: a bounded ring buffer of recent diagnostics events,
-// queryable the way the MCP server asks ("network events since seq 40", "last
-// 20 errors"). Pure and dependency-free so it is fully unit-testable; the WS
-// server in server.ts is a thin wrapper that feeds this and answers queries
-// from it.
-export class EventStore {
-    capacity;
-    buf = [];
-    sessionsSeen = new Set();
-    latest = -1;
-    constructor(capacity = 5000) {
-        this.capacity = capacity;
-    }
-    /** Ingest a batch from a client. Tracks the session and advances latestSeq. */
-    ingest(sessionId, events) {
-        this.sessionsSeen.add(sessionId);
-        for (const e of events) {
-            // Tag ownership on the stored copy so cross-session queries can filter.
-            this.buf.push(withSession(e, sessionId));
-            if (e.seq > this.latest)
-                this.latest = e.seq;
-        }
-        // Ring: drop oldest beyond capacity.
-        if (this.buf.length > this.capacity) {
-            this.buf.splice(0, this.buf.length - this.capacity);
-        }
-    }
-    /** Answer an MCP query against the buffer. Newest-biased when limited. */
-    query(q = {}) {
-        let out = this.buf.filter((e) => {
-            if (q.sessionId && sessionOf(e) !== q.sessionId)
-                return false;
-            if (q.kind && e.kind !== q.kind)
-                return false;
-            if (q.since !== undefined && e.seq <= q.since)
-                return false;
-            return true;
-        });
-        if (q.limit !== undefined && out.length > q.limit) {
-            out = out.slice(out.length - q.limit); // keep the newest `limit`
-        }
-        return {
-            events: out.map(stripSession),
-            latestSeq: this.latest,
-            sessions: [...this.sessionsSeen],
-        };
-    }
-    size() {
-        return this.buf.length;
-    }
-}
-// The store tags each event with its owning session out-of-band (a symbol key)
-// so it survives in the buffer without polluting the wire type. Queries strip
-// it before returning.
-const SESSION = Symbol("session");
-function withSession(e, sessionId) {
-    return Object.assign(Object.create(Object.getPrototypeOf(e)), e, {
-        [SESSION]: sessionId,
-    });
-}
-function sessionOf(e) {
-    return e[SESSION];
-}
-function stripSession(e) {
-    const copy = { ...e };
-    delete copy[SESSION];
-    return copy;
-}

package/dist/scaffold/index.d.ts

@@ -1,26 +0,0 @@
-export declare const TEMPLATE_REPO = "https://github.com/vincentt-xr/v2-template.git";
-/** Injectable git runner (real git by default; a fake in tests avoids the network). */
-export type GitRunner = (args: string[]) => Promise<void>;
-/**
- * True when `dir` has no app yet (no package.json) → safe to scaffold into.
- * A directory that already holds an app is left untouched (project_create just binds).
- */
-export declare function needsScaffold(dir: string): Promise<boolean>;
-export interface ScaffoldOptions {
-    repo?: string;
-    /** Test seam — defaults to spawning real git. */
-    runGit?: GitRunner;
-}
-/**
- * Scaffold the template into `targetDir`. Clones to a temp dir, strips `.git`,
- * copies the files in (never overwriting anything already there), then inits a
- * 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>;
-/**
- * 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.
- */
-export declare function installDependencies(dir: string): Promise<void>;

package/dist/scaffold/index.js

@@ -1,85 +0,0 @@
-// Scaffold a new app from the v2-template GitHub template as part of
-// project_create. Shallow-clones the template, drops its git history, copies the
-// files into the target, and inits a fresh repo the creator owns — the local-first
-// equivalent of GitHub's "Use this template". Node-only (spawns git); not imported
-// by browser consumers.
-import { execFile } from "node:child_process";
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-export const TEMPLATE_REPO = "https://github.com/vincentt-xr/v2-template.git";
-const realGit = async (args) => {
-    await execFileAsync("git", args);
-};
-/**
- * True when `dir` has no app yet (no package.json) → safe to scaffold into.
- * A directory that already holds an app is left untouched (project_create just binds).
- */
-export async function needsScaffold(dir) {
-    try {
-        await fs.access(path.join(dir, "package.json"));
-        return false;
-    }
-    catch {
-        return true;
-    }
-}
-/**
- * Scaffold the template into `targetDir`. Clones to a temp dir, strips `.git`,
- * copies the files in (never overwriting anything already there), then inits a
- * fresh repo. Throws a clear error if the clone fails (e.g. no git access).
- */
-export async function scaffoldFromTemplate(targetDir, opts = {}) {
-    const repo = opts.repo ?? TEMPLATE_REPO;
-    const runGit = opts.runGit ?? realGit;
-    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "vincentt-tmpl-"));
-    try {
-        try {
-            await runGit(["clone", "--depth", "1", repo, tmp]);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`Could not clone the ${repo} template (check your git access): ${msg}`);
-        }
-        await fs.rm(path.join(tmp, ".git"), { recursive: true, force: true });
-        // Copy template contents in without clobbering anything already in the target.
-        for (const entry of await fs.readdir(tmp)) {
-            await fs.cp(path.join(tmp, entry), path.join(targetDir, entry), {
-                recursive: true,
-                force: false,
-                errorOnExist: false,
-            });
-        }
-        // Fresh history the creator owns (skip if the target is already a repo).
-        if (!(await isGitRepo(targetDir))) {
-            await runGit(["-C", targetDir, "init"]);
-        }
-    }
-    finally {
-        await fs.rm(tmp, { recursive: true, force: true });
-    }
-}
-async function isGitRepo(dir) {
-    try {
-        await execFileAsync("git", ["-C", dir, "rev-parse", "--git-dir"]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 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.
- */
-export async function installDependencies(dir) {
-    // Windows: npm is npm.cmd — execFile needs a shell to resolve it.
-    await execFileAsync("npm", ["install"], {
-        cwd: dir,
-        shell: process.platform === "win32",
-    });
-}

package/dist/shared/config.d.ts

@@ -1,39 +0,0 @@
-export interface MachineConfig {
-    /** Base URL of the Vincentt backend API (e.g. https://api.vincentt.studio). */
-    apiUrl: string;
-    /** Personal access token (bearer) for machine auth. */
-    pat: string;
-}
-export interface ProjectBinding {
-    /** The backend Project id this working tree publishes to. */
-    projectId: string;
-    /** The project's slug — its <slug>.<apex> host. Informational (server-authoritative). */
-    slug: string;
-    /** Optional per-project API override; else the machine config's apiUrl. */
-    apiUrl?: string;
-}
-export declare const MACHINE_CONFIG_PATH: string;
-export declare function projectBindingPath(cwd: string): string;
-export declare function loadMachineConfig(): Promise<Partial<MachineConfig>>;
-/**
- * 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.
- */
-export declare function writeMachineConfig(patch: Partial<MachineConfig>): Promise<string>;
-export declare function loadProjectBinding(cwd: string): Promise<ProjectBinding | undefined>;
-/**
- * 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`).
- */
-export declare function writeProjectBinding(cwd: string, binding: ProjectBinding): Promise<string>;
-export interface ResolvedConfig {
-    apiUrl: string;
-    pat: string;
-}
-/**
- * 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.
- */
-export declare function resolveConfig(cwd: string): Promise<ResolvedConfig>;