@vincentt-xr/cli 0.17.0 → 0.18.0

package/dist/publish/manifest.js

@@ -11,13 +11,178 @@ import { normalizePath, validatePathSet } from "./paths.js";
 export class ManifestError extends Error {
     reason;
     offendingPath;
-    constructor(reason, offendingPath, message) {
+    paths;
+    stats;
+    constructor(reason, offendingPath, message, detail = {}) {
         super(message);
         this.reason = reason;
         this.offendingPath = offendingPath;
         this.name = "ManifestError";
+        this.paths = detail.paths ?? [];
+        this.stats = detail.stats;
     }
 }
+/** The only dotted names allowed, and only at the output root. Case-insensitive. */
+const ALLOWED_ROOT_DIR = ".well-known";
+const ALLOWED_ROOT_FILE = ".nojekyll";
+const LFS_POINTER_MAX_BYTES = 1024;
+const LFS_FIRST_LINE = "version https://git-lfs.github.com/spec/v1";
+function isInside(child, parent) {
+    const rel = path.relative(parent, child);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function hasDottedSegment(rel) {
+    return rel.split(/[\\/]/).some((seg) => seg.startsWith("."));
+}
+/**
+ * The leak walk. Unlike `walkDist` it records what it does not upload: a dotted
+ * name is an offender (a folder once, with a trailing slash, never descended),
+ * and every symlink is resolved and judged against the real repo root.
+ */
+async function walkOutput(outReal, rootReal) {
+    const files = [];
+    const offenders = [];
+    const visit = async (dir) => {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            const rel = path.relative(outReal, full).split(path.sep).join("/");
+            const atRoot = dir === outReal;
+            const lower = entry.name.toLowerCase();
+            if (entry.name.startsWith(".")) {
+                const allowed = atRoot &&
+                    ((lower === ALLOWED_ROOT_DIR && entry.isDirectory()) ||
+                        (lower === ALLOWED_ROOT_FILE && entry.isFile()));
+                if (!allowed) {
+                    offenders.push({ path: entry.isDirectory() ? `${rel}/` : rel });
+                    continue;
+                }
+            }
+            if (entry.isSymbolicLink()) {
+                const target = await symlinkTarget(full);
+                if (!isInside(target, rootReal)) {
+                    offenders.push({ path: rel, target });
+                }
+                else if (hasDottedSegment(path.relative(rootReal, target))) {
+                    offenders.push({
+                        path: rel,
+                        target: path.relative(rootReal, target).split(path.sep).join("/"),
+                    });
+                }
+                // A symlink that resolves cleanly inside is not uploaded, as before.
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await visit(full);
+            }
+            else if (entry.isFile()) {
+                const stat = await fs.stat(full);
+                files.push({ rel, size: stat.size });
+            }
+        }
+    };
+    await visit(outReal);
+    return { files, offenders };
+}
+/** Where a symlink lands: its realpath, or its lexical target when it dangles. */
+async function symlinkTarget(link) {
+    try {
+        return await fs.realpath(link);
+    }
+    catch {
+        const raw = await fs.readlink(link).catch(() => link);
+        return path.resolve(path.dirname(link), raw);
+    }
+}
+/** A Git LFS pointer file: at most 1 KB, the spec's exact first line, and an oid line. */
+export async function isLfsPointer(absPath, size) {
+    if (size > LFS_POINTER_MAX_BYTES)
+        return false;
+    const head = await fs.readFile(absPath, "utf8");
+    const lines = head.split("\n");
+    if (lines[0] !== LFS_FIRST_LINE)
+        return false;
+    return lines.some((l) => l.startsWith("oid sha256:"));
+}
+/**
+ * The leak and LFS checks, in that order, before anything is hashed or sent.
+ * Throws ManifestError; returns nothing on a clean output.
+ */
+/**
+ * Folders an output must never be, or sit inside: the repository's history and
+ * the Vincentt binding. Compared case-insensitively, as a default macOS volume
+ * resolves `.GIT` to `.git`. Other dotted parents stay allowed (`.output/public`).
+ */
+const FORBIDDEN_OUTPUT_SEGMENTS = new Set([".git", ".vincentt"]);
+function forbiddenSegmentIn(rel) {
+    return rel
+        .split(/[\\/]/)
+        .find((seg) => FORBIDDEN_OUTPUT_SEGMENTS.has(seg.toLowerCase()));
+}
+/**
+ * The leak and LFS checks, in that order, before anything is hashed or sent.
+ * Returns the output-relative file list the checks passed, which is exactly the
+ * list the manifest is built from: what is checked is what is uploaded.
+ */
+export async function checkOutput(distDir, repoRoot) {
+    const rootReal = await fs.realpath(repoRoot).catch(() => path.resolve(repoRoot));
+    const lexical = path.resolve(distDir);
+    const lexicalRoot = path.resolve(repoRoot);
+    if (lexical === lexicalRoot) {
+        throw new ManifestError("output_is_repo_root", distDir, `${distDir} is the repo root`);
+    }
+    if (!isInside(lexical, lexicalRoot) && !isInside(lexical, rootReal)) {
+        throw new ManifestError("output_outside_repo", distDir, `${distDir} is outside the repo`);
+    }
+    let outReal;
+    try {
+        outReal = await fs.realpath(distDir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new ManifestError("no_dist", distDir, `no dist at ${distDir}`);
+        }
+        throw err;
+    }
+    if (outReal === rootReal) {
+        throw new ManifestError("output_is_repo_root", distDir, `${distDir} resolves to the repo root`);
+    }
+    if (!isInside(outReal, rootReal)) {
+        throw new ManifestError("output_outside_repo", distDir, `${distDir} resolves outside the repo`);
+    }
+    const hiddenParent = forbiddenSegmentIn(path.relative(lexicalRoot, lexical)) ??
+        forbiddenSegmentIn(path.relative(rootReal, outReal));
+    if (hiddenParent !== undefined) {
+        throw new ManifestError("output_in_hidden", hiddenParent, `${distDir} is inside ${hiddenParent}`);
+    }
+    if (!(await fs.stat(outReal)).isDirectory()) {
+        throw new ManifestError("no_dist", distDir, `no dist at ${distDir}`);
+    }
+    const walk = await walkOutput(outReal, rootReal);
+    const stats = {
+        files: walk.files.length,
+        bytes: walk.files.reduce((n, f) => n + f.size, 0),
+    };
+    if (walk.offenders.length > 0) {
+        throw new ManifestError("secret_path", walk.offenders[0].path, "hidden paths in the output", {
+            paths: walk.offenders,
+            stats,
+        });
+    }
+    const pointers = [];
+    for (const f of walk.files) {
+        if (await isLfsPointer(path.join(outReal, f.rel), f.size))
+            pointers.push({ path: f.rel });
+    }
+    if (pointers.length > 0) {
+        throw new ManifestError("lfs_pointer", pointers[0].path, "Git LFS pointers in the output", {
+            paths: pointers,
+            stats,
+        });
+    }
+    return walk.files;
+}
 /** Recursively list files under `dir` as dir-relative POSIX paths. Symlinks are not followed. */
 export async function walkDist(dir, base = dir) {
     let entries;
@@ -54,8 +219,12 @@ export async function hashFile(absPath) {
  * hashed, so the string this returns is the string the API validates, signs, and
  * later lists — there is no second form anywhere.
  */
-export async function buildManifest(distDir) {
-    const raw = await walkDist(distDir);
+export async function buildManifest(distDir, opts = {}) {
+    // With a repo root, the list the leak and LFS checks passed IS the upload
+    // list. A second walk could see a file created after the checks ran.
+    const raw = opts.repoRoot !== undefined
+        ? (await checkOutput(distDir, opts.repoRoot)).map((f) => f.rel)
+        : await walkDist(distDir);
     const normalized = [];
     for (const rel of raw) {
         const result = normalizePath(rel);

package/dist/publish/prompt.d.ts

@@ -3,5 +3,9 @@ export type Confirm = (prompt: string, defaultYes: boolean) => Promise<boolean>;
 export declare function stdinConfirm(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): Confirm;
 /** Reads one free-text line. An empty answer takes the offered default. */
 export type Ask = (prompt: string, fallback: string) => Promise<string>;
+/** Input ended (Ctrl-D, a closed pipe) before a free-text question was answered. */
+export declare class PromptClosedError extends Error {
+    constructor();
+}
 export declare function stdinAsk(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): Ask;
 export declare function interpretAnswer(answer: string, defaultYes: boolean): boolean;

package/dist/publish/prompt.js

@@ -32,11 +32,25 @@ export function stdinConfirm(input = process.stdin, output = process.stdout) {
         }
     };
 }
+/** Input ended (Ctrl-D, a closed pipe) before a free-text question was answered. */
+export class PromptClosedError extends Error {
+    constructor() {
+        super("Input ended before the question was answered. Nothing more was done.");
+        this.name = "PromptClosedError";
+    }
+}
 export function stdinAsk(input = process.stdin, output = process.stdout) {
     return async (prompt, fallback) => {
         const rl = readline.createInterface({ input, output });
         try {
-            const answer = await new Promise((resolve) => rl.question(prompt, resolve));
+            // EOF is a refusal, not an empty answer: taking the fallback here would
+            // register a name or address the creator never agreed to.
+            const answer = await new Promise((resolve) => {
+                rl.question(prompt, resolve);
+                rl.once("close", () => resolve(undefined));
+            });
+            if (answer === undefined)
+                throw new PromptClosedError();
             return answer.trim() === "" ? fallback : answer.trim();
         }
         finally {

package/dist/publish/upload.d.ts

@@ -22,6 +22,12 @@ export interface UploadOptions {
     /** Per-file retries for a transient network/5xx failure. A BadDigest is retried once. */
     maxAttempts?: number;
 }
+/**
+ * One PUT's deadline: a minute, plus the time the file takes at 64 KB/s. A fixed
+ * deadline would fail every large file on a slow uplink; none at all lets a
+ * stalled connection hang the publish forever.
+ */
+export declare function putDeadlineMs(bytes: number): number;
 /**
  * PUT every file. A re-run that finds files already landed simply uploads
  * fewer — resumption is silent, because the creator did not ask for a resume,

package/dist/publish/upload.js

@@ -10,6 +10,7 @@
 // The CLI never synthesizes a MIME type and never parses the presigned URL.
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { withDeadline } from "../shared/http.js";
 export class UploadFailed extends Error {
     path;
     status;
@@ -23,6 +24,14 @@ export class UploadFailed extends Error {
     }
 }
 const DEFAULT_CONCURRENCY = 6;
+/**
+ * One PUT's deadline: a minute, plus the time the file takes at 64 KB/s. A fixed
+ * deadline would fail every large file on a slow uplink; none at all lets a
+ * stalled connection hang the publish forever.
+ */
+export function putDeadlineMs(bytes) {
+    return 60_000 + Math.ceil(bytes / 64_000) * 1000;
+}
 /**
  * PUT every file. A re-run that finds files already landed simply uploads
  * fewer — resumption is silent, because the creator did not ask for a resume,
@@ -60,12 +69,13 @@ export async function uploadAll(opts) {
 async function putOne(target, distDir, fetchImpl, maxAttempts) {
     const abs = path.join(distDir, ...target.path.split("/"));
     const body = await fs.readFile(abs);
+    const put = withDeadline(fetchImpl, putDeadlineMs(body.byteLength));
     let lastStatus = 0;
     let sawBadDigest = false;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         let res;
         try {
-            res = await fetchImpl(target.url, {
+            res = await put(target.url, {
                 method: "PUT",
                 // VERBATIM. No key dropped, no key added, no key renamed.
                 headers: { ...target.headers },

package/dist/publish/visibility.d.ts

@@ -0,0 +1,21 @@
+/** The longest the CLI waits for the address to serve the new version. */
+export declare const VISIBILITY_WAIT_MS = 90000;
+export interface VisibilityDeps {
+    fetchImpl: typeof fetch;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    /** Called once, before the first wait, and only if the first probe missed. */
+    onWaiting?: () => void;
+}
+export interface VisibilityResult {
+    visible: boolean;
+    waitedMs: number;
+}
+/**
+ * Probe `liveUrl` until its body hashes to `indexSha256` (std base64, as in the
+ * manifest) or `VISIBILITY_WAIT_MS` passes. Never throws: a failed probe is a miss.
+ *
+ * Elapsed time is the larger of the clock and the summed sleeps, so the bound
+ * holds under a frozen test clock as well as against slow probes.
+ */
+export declare function waitUntilServing(liveUrl: string, indexSha256: string, deps: VisibilityDeps): Promise<VisibilityResult>;

package/dist/publish/visibility.js

@@ -0,0 +1,68 @@
+// After commit, wait until the public address serves the version just committed.
+//
+// The api flips the slug pointer in CloudFront KeyValueStore, which is eventually
+// consistent: staging measured 13 to 36 s between "committed" and the edge serving
+// the new bytes. The marker is index.html itself. The CLI already holds its sha256
+// from the manifest, so a probe hashes the served body and compares; nothing new
+// has to be added to the bundle, the router or the api.
+//
+// Used by publish/command.ts. IO (fetch, clock, sleep) is injected for tests.
+import { createHash } from "node:crypto";
+import { withDeadline } from "../shared/http.js";
+/** The longest the CLI waits for the address to serve the new version. */
+export const VISIBILITY_WAIT_MS = 90_000;
+const FIRST_DELAY_MS = 1_000;
+const MAX_DELAY_MS = 5_000;
+const PROBE_DEADLINE_MS = 10_000;
+/**
+ * Probe `liveUrl` until its body hashes to `indexSha256` (std base64, as in the
+ * manifest) or `VISIBILITY_WAIT_MS` passes. Never throws: a failed probe is a miss.
+ *
+ * Elapsed time is the larger of the clock and the summed sleeps, so the bound
+ * holds under a frozen test clock as well as against slow probes.
+ */
+export async function waitUntilServing(liveUrl, indexSha256, deps) {
+    const probe = withDeadline(deps.fetchImpl, PROBE_DEADLINE_MS);
+    const startedAt = deps.now();
+    let slept = 0;
+    let delay = FIRST_DELAY_MS;
+    const elapsed = () => Math.max(deps.now() - startedAt, slept);
+    for (let attempt = 1;; attempt++) {
+        if (await serves(probe, liveUrl, indexSha256, attempt)) {
+            return { visible: true, waitedMs: elapsed() };
+        }
+        const left = VISIBILITY_WAIT_MS - elapsed();
+        if (left <= 0)
+            return { visible: false, waitedMs: elapsed() };
+        if (attempt === 1)
+            deps.onWaiting?.();
+        const step = Math.min(delay, left);
+        await deps.sleep(step);
+        slept += step;
+        delay = Math.min(delay * 2, MAX_DELAY_MS);
+    }
+}
+async function serves(probe, liveUrl, indexSha256, attempt) {
+    try {
+        const res = await probe(bustedUrl(liveUrl, attempt), {
+            headers: { "cache-control": "no-cache", pragma: "no-cache" },
+        });
+        if (!res.ok)
+            return false;
+        const body = Buffer.from(await res.arrayBuffer());
+        return createHash("sha256").update(body).digest("base64") === indexSha256;
+    }
+    catch {
+        return false;
+    }
+}
+function bustedUrl(liveUrl, attempt) {
+    try {
+        const u = new URL(liveUrl);
+        u.searchParams.set("vincentt-check", `${Date.now().toString(36)}-${attempt}`);
+        return u.toString();
+    }
+    catch {
+        return liveUrl;
+    }
+}

package/dist/relay/annotations.js

@@ -74,7 +74,7 @@ export class AnnotationStore {
         };
         this.items.push(annotation);
         await fs.appendFile(path.join(this.dir, STORE_FILE), JSON.stringify(annotation) + "\n");
-        this.wake(annotation);
+        this.wake();
         return annotation;
     }
     /** The first annotation with seq greater than `after`, if one is already held. */
@@ -113,12 +113,17 @@ export class AnnotationStore {
             this.waiters.push(waiter);
         });
     }
-    wake(a) {
+    // A waiter gets the LOWEST held seq past its cursor, not the annotation whose
+    // write just finished: concurrent adds can finish persisting out of seq order,
+    // and handing over the later one first moves the consumer's cursor past the
+    // earlier one for good.
+    wake() {
         const remaining = [];
         for (const w of this.waiters) {
-            if (a.seq > w.after) {
+            const next = this.peekAfter(w.after);
+            if (next) {
                 clearTimeout(w.timer);
-                w.resolve({ kind: "annotation", annotation: a });
+                w.resolve({ kind: "annotation", annotation: next });
             }
             else {
                 remaining.push(w);

package/dist/relay/server.d.ts

@@ -1,9 +1,16 @@
+import { type IncomingMessage } from "node:http";
 import { EventStore } from "./store.js";
 import { TesterRegistry } from "./testers.js";
 import { AnnotationStore } from "./annotations.js";
 import type { DiagEvent } from "@vincentt-xr/harness/events";
 export interface RelayOptions {
     port?: number;
+    /**
+     * The interface to listen on. Loopback by default and in every caller: the
+     * phone reaches the relay only through the tunnel client on this machine,
+     * which dials loopback, and `/query` and `feedback/next` are local-only.
+     */
+    host?: string;
     /** WS path the client connects to (default matches HarnessProvider). */
     path?: string;
     capacity?: number;
@@ -92,6 +99,20 @@ export declare function startRelay(opts?: RelayOptions): RelayHandle;
  * does not match is not a label, and the events simply carry no viewer.
  */
 export declare function readViewerLabel(raw: string | string[] | undefined): string | undefined;
+/**
+ * Whether a request arrived through the preview tunnel. The tunnel client stamps
+ * `x-vincentt-viewer` on EVERY request it forwards, after it has sanitised the
+ * viewer's headers, so a viewer cannot remove it; a local CLI never sends it.
+ * Any value counts, including a malformed or duplicated one: presence is the
+ * signal, and a viewer adding a second copy only makes it more present.
+ */
+export declare function cameThroughTunnel(req: IncomingMessage): boolean;
+/**
+ * A raw request path the relay refuses before `URL` normalises it: a `.` or `..`
+ * segment, or an encoded dot or separator. Without this, `/__harness/../query`
+ * normalises onto a local-only route.
+ */
+export declare function isUnsafeRelayPath(rawUrl: string): boolean;
 /**
  * Clamp the hold to `[0, MAX]`, explicitly, with `0` meaning ANSWER NOW.
  *

package/dist/relay/server.js

@@ -117,7 +117,8 @@ export function startRelay(opts = {}) {
         });
         ws.on("close", () => log("client disconnected"));
     });
-    http.listen(port, () => log(`relay listening on :${port} (ws ${wsPath}, http /query)`));
+    const host = opts.host ?? "127.0.0.1";
+    http.listen(port, host, () => log(`relay listening on ${host}:${port} (ws ${wsPath}, http /query)`));
     return {
         store,
         annotations,
@@ -140,9 +141,42 @@ export function readViewerLabel(raw) {
         return undefined;
     return VIEWER_LABEL_RE.test(raw) ? raw : undefined;
 }
+/**
+ * Whether a request arrived through the preview tunnel. The tunnel client stamps
+ * `x-vincentt-viewer` on EVERY request it forwards, after it has sanitised the
+ * viewer's headers, so a viewer cannot remove it; a local CLI never sends it.
+ * Any value counts, including a malformed or duplicated one: presence is the
+ * signal, and a viewer adding a second copy only makes it more present.
+ */
+export function cameThroughTunnel(req) {
+    return req.headers[VIEWER_STAMP_HEADER] !== undefined;
+}
+/**
+ * A raw request path the relay refuses before `URL` normalises it: a `.` or `..`
+ * segment, or an encoded dot or separator. Without this, `/__harness/../query`
+ * normalises onto a local-only route.
+ */
+export function isUnsafeRelayPath(rawUrl) {
+    const raw = rawUrl.split("?")[0] ?? "";
+    if (/%(2e|2f|5c)/i.test(raw) || raw.includes("\\"))
+        return true;
+    return raw.split("/").some((s) => s === "." || s === "..");
+}
 function handleHttp(req, res, ctx) {
+    if (isUnsafeRelayPath(req.url ?? "/")) {
+        res.writeHead(404).end();
+        return;
+    }
     const url = new URL(req.url ?? "/", "http://localhost");
     const p = url.pathname;
+    // Local-only: the diagnostics read and the reverse-channel drain belong to
+    // the creator's own CLI. A link holder reaches the relay only through the
+    // tunnel, and is refused here even if a route to it were ever opened.
+    const localOnly = p === "/query" || p === `${ctx.wsPath}/feedback/next`;
+    if (localOnly && cameThroughTunnel(req)) {
+        res.writeHead(404).end();
+        return;
+    }
     if (p === "/query") {
         handleQuery(req, res, url, ctx);
         return;

package/dist/shared/authError.d.ts

@@ -1 +1,28 @@
+export declare const AUTH_EXPIRED_MESSAGE = "Your Vincentt access token is no longer valid. Run `vincentt login` to sign in again.";
 export declare function authFailureMessage(label: string, status: number, detail: string): string;
+/**
+ * The api refused the token. Distinct from every other refusal because the
+ * remedy is the same wherever it happens and it is not a retry: a command that
+ * reads it prints authExpiredLines() and exits EXIT.NOT_AUTHENTICATED.
+ */
+export declare class AuthExpiredError extends Error {
+    readonly status = 401;
+    constructor();
+}
+/**
+ * Every authenticated api client calls this on a non-OK response before it
+ * reads the error body. authPaths.test.ts drives each client with a 401 and
+ * fails if one reaches its own error arm instead.
+ */
+export declare function rejectAuthExpired(res: Response): void;
+export declare function authExpiredLines(): string[];
+export declare const NOT_SIGNED_IN_LINES: readonly string[];
+/** No token on this machine. Thrown where a verb needs one and cannot ask for it. */
+export declare class NotSignedInError extends Error {
+    constructor();
+}
+/**
+ * The api refused the token, in either shape a client reports it: the shared
+ * AuthExpiredError, or a client error carrying the 401 status.
+ */
+export declare function isAuthRefused(err: unknown): boolean;

package/dist/shared/authError.js

@@ -2,10 +2,54 @@
 // universal first-run state: every existing `vct_` token was invalidated, so the raw
 // "(401): <body>" is unactionable noise for every user at once. Name the cause and give
 // the one instruction that fixes it. Any other status keeps its existing "(<n>): <body>"
-// shape — a 500/timeout is a different problem and must not be mislabeled a stale token.
+// shape: a 500/timeout is a different problem and must not be mislabeled a stale token.
+export const AUTH_EXPIRED_MESSAGE = "Your Vincentt access token is no longer valid. Run `vincentt login` to sign in again.";
 export function authFailureMessage(label, status, detail) {
-    if (status === 401) {
-        return "Your Vincentt access token is no longer valid — run `vincentt login` to sign in again.";
-    }
+    if (status === 401)
+        return AUTH_EXPIRED_MESSAGE;
     return `${label} (${status})${detail ? `: ${detail}` : ""}`;
 }
+/**
+ * The api refused the token. Distinct from every other refusal because the
+ * remedy is the same wherever it happens and it is not a retry: a command that
+ * reads it prints authExpiredLines() and exits EXIT.NOT_AUTHENTICATED.
+ */
+export class AuthExpiredError extends Error {
+    status = 401;
+    constructor() {
+        super(AUTH_EXPIRED_MESSAGE);
+        this.name = "AuthExpiredError";
+    }
+}
+/**
+ * Every authenticated api client calls this on a non-OK response before it
+ * reads the error body. authPaths.test.ts drives each client with a 401 and
+ * fails if one reaches its own error arm instead.
+ */
+export function rejectAuthExpired(res) {
+    if (res.status === 401)
+        throw new AuthExpiredError();
+}
+export function authExpiredLines() {
+    return ["", `✗ ${AUTH_EXPIRED_MESSAGE}`, ""];
+}
+export const NOT_SIGNED_IN_LINES = [
+    "✗ You're not signed in.",
+    "  Run `vincentt login` to connect this machine to your Vincentt account.",
+];
+/** No token on this machine. Thrown where a verb needs one and cannot ask for it. */
+export class NotSignedInError extends Error {
+    constructor() {
+        super(NOT_SIGNED_IN_LINES.join("\n"));
+        this.name = "NotSignedInError";
+    }
+}
+/**
+ * The api refused the token, in either shape a client reports it: the shared
+ * AuthExpiredError, or a client error carrying the 401 status.
+ */
+export function isAuthRefused(err) {
+    if (err instanceof AuthExpiredError)
+        return true;
+    return err instanceof Error && err.status === 401;
+}

package/dist/shared/config.d.ts

@@ -117,7 +117,27 @@ export interface ResolvedConfig {
     apiUrl: string;
     pat: string;
 }
-export declare const DEFAULT_API_URL = "http://localhost:5051";
+/**
+ * Every environment variable the CLI reads a credential from. They are removed
+ * from the environment of the creator's dev command, which is repo-controlled.
+ * A credential read added to this file without a name here fails a unit test.
+ */
+export declare const CLI_CREDENTIAL_ENV: readonly string[];
+export declare function withoutCliCredentials(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare const DEFAULT_API_URL = "https://api.vincentt.studio";
+/**
+ * The API host the person running the command configured: an explicit flag, then
+ * VINCENTT_API_URL, then the machine config, then the default. Every verb reads
+ * its host through here, so a token is never sent to one host by one verb and to
+ * another by the next. A binding's override is layered on top by decideApiUrl.
+ */
+export declare function configuredApiUrl(input: {
+    flagApiUrl?: string;
+    envApiUrl?: string;
+    machineApiUrl?: string;
+}): string;
+/** configuredApiUrl from this process's environment and a machine config already read. */
+export declare function machineApiUrl(machine: Partial<MachineConfig>, flagApiUrl?: string): string;
 export interface ResolveConfigOptions {
     /** Honor a binding's apiUrl override (the `--allow-custom-api` flag). */
     allowCustomApi?: boolean;