driggsby 0.1.42 → 0.2.0

package/dist/deploy/api-session.js

@@ -0,0 +1,85 @@
+// Shared plumbing for the deploy command family: resolve the saved app token
+// and map every failure to one clear, fix-naming message. The deploy package
+// signs requests; this layer decides what a person or agent reads when
+// something goes wrong.
+import { DeployApiError, DeployError } from "@driggsby/deploy";
+import { apiBaseUrl, apiHost, baseUrlMayReceiveSavedSignIn } from "../api/base-url.js";
+import { blockedNetworkError } from "../api/network-error.js";
+import { CliError } from "../cli-error.js";
+import { readStoredToken, } from "../credentials/store.js";
+import { capForTerminal, wrapProse } from "../terminal-text.js";
+const LOGIN_COMMAND = "npx driggsby@latest login";
+const MAX_ERROR_DESCRIPTION_CHARS = 300;
+// Server-supplied display strings go through capForTerminal (sanitize plus
+// a hard length bound) with bounds sized to each string's real contract so
+// a legitimate value is never truncated: a slug tops out at 63 characters,
+// while the app URL wraps the slug in a scheme and domain
+// (https://<slug>.driggsby.dev, up to 84 characters). Anything longer is a
+// server bug and gets cut rather than allowed to garble the output.
+export const MAX_SERVER_TEXT_CHARS = 80;
+export const MAX_SERVER_URL_CHARS = 200;
+export async function requireDeploySession(environment) {
+    const baseUrl = apiBaseUrl(environment.env);
+    const stored = await readStoredToken(environment);
+    if (stored === null) {
+        throw new CliError("You're not signed in on this machine yet. Sign in first — it takes\n" +
+            `about a minute:\n  ${LOGIN_COMMAND}`, 1);
+    }
+    // The saved sign-in unlocks this person's financial data, so it only ever
+    // travels to Driggsby itself (plus loopback for local development). A
+    // DRIGGSBY_BASE_URL pointing anywhere else must bring its own token via
+    // DRIGGSBY_TOKEN (source "env") — without this pin, setting that one
+    // environment variable would redirect the saved credential to an
+    // arbitrary host.
+    if (stored.source !== "env" && !baseUrlMayReceiveSavedSignIn(baseUrl)) {
+        throw new CliError(wrapProse("Your saved Driggsby sign-in is only ever sent to Driggsby itself (or a local dev server on this machine), and DRIGGSBY_BASE_URL points somewhere else. Unset DRIGGSBY_BASE_URL, or set DRIGGSBY_TOKEN to a token that belongs to that server."), 1);
+    }
+    return { baseUrl, token: stored.token };
+}
+// Turns any failure from a deploy-family command into the CliError the user
+// sees. `retryCommand` names the exact command to run again.
+export function deployFailure(error, baseUrl, retryCommand) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    // A DeployApiError is a real HTTP response from the server, never a
+    // connection failure — and its `code` is a server-supplied string, so it
+    // could collide with an errno name like ECONNRESET and turn a genuine
+    // refusal into firewall advice if blockedNetworkError saw it first.
+    if (error instanceof DeployApiError) {
+        return apiFailure(error, retryCommand);
+    }
+    if (error instanceof DeployError) {
+        return new CliError(error.message, 1);
+    }
+    const blocked = blockedNetworkError(error, { host: apiHost(baseUrl), retryCommand });
+    if (blocked !== null) {
+        return blocked;
+    }
+    return new CliError(`We weren't able to finish this just now. Please try again:\n  ${retryCommand}`, 1);
+}
+function apiFailure(error, retryCommand) {
+    // A 503's server description talks to the protocol client ("retry the same
+    // PUT"), so it gets CLI-authored copy naming the actual re-run instead.
+    // The copy stays neutral about what failed: a 503 can come from any
+    // endpoint, including ones that upload nothing.
+    if (error.status === 503) {
+        return new CliError(`Driggsby is briefly unavailable just now. Please try again:\n  ${retryCommand}`, 1);
+    }
+    if (error.status === 401) {
+        return new CliError("Your sign-in on this machine isn't valid anymore. Sign in again:\n" +
+            `  ${LOGIN_COMMAND}`, 1);
+    }
+    if (error.code === "deploy_scope_required") {
+        return new CliError("Your saved sign-in can read your Driggsby data but wasn't approved for\n" +
+            `deploys. Sign in again and approve deploy access:\n  ${LOGIN_COMMAND}`, 1);
+    }
+    // The server's error_description gets the same treatment as every other
+    // string this CLI did not author: stripped of terminal control bytes and
+    // length-bounded before it reaches the terminal.
+    const description = capForTerminal(error.message, MAX_ERROR_DESCRIPTION_CHARS).trim();
+    if (description === "") {
+        return new CliError("The Driggsby deploy API refused this request without saying why. Please\ntry again in a minute.", 1);
+    }
+    return new CliError(wrapProse(description), 1);
+}

package/dist/deploy/deploy-command.js

@@ -0,0 +1,126 @@
+// driggsby deploy: read driggsby.json, hash the serve folder, upload what
+// Driggsby doesn't have, and make the new version live (or hold it as a
+// ready-but-not-live version with --preview).
+import { collectDeployFiles, deployProjectFiles, formatBytes, readProjectConfig, } from "@driggsby/deploy";
+import { apiBaseUrl } from "../api/base-url.js";
+import { defaultCredentialEnvironment, } from "../credentials/store.js";
+import { capForTerminal, quotedForTerminal, wrapProse } from "../terminal-text.js";
+import { deployFailure, MAX_SERVER_TEXT_CHARS, MAX_SERVER_URL_CHARS, requireDeploySession, } from "./api-session.js";
+const DEPLOY_RETRY_COMMAND = "npx driggsby@latest deploy";
+function defaultDeployIo() {
+    return {
+        out: (text) => {
+            process.stdout.write(text);
+        },
+        now: () => Date.now(),
+    };
+}
+export async function runDeploy(options, environment = defaultCredentialEnvironment(), io = defaultDeployIo()) {
+    const projectDirectory = options.projectDirectory ?? process.cwd();
+    // Resolved before the try so an invalid DRIGGSBY_BASE_URL reports its own
+    // message instead of being re-wrapped as a deploy failure.
+    const baseUrl = apiBaseUrl(environment.env);
+    try {
+        const config = await readProjectConfig(projectDirectory);
+        const session = await requireDeploySession(environment);
+        // The serve value is arbitrary text from driggsby.json (a cloned or
+        // agent-generated file), so it prints through quotedForTerminal —
+        // sanitized, length-bounded, and inside quotes the value can't break out
+        // of, so it reads as a name, never as the CLI's own sentence. The slug
+        // needs no quotes: readProjectConfig already validated it against the
+        // strict slug rules. The whole line is wrapped because a maximum-length
+        // slug pushes it past 80 columns.
+        io.out(`${wrapProse(`Deploying ${config.slug} from ${quotedForTerminal(config.serve, MAX_SERVER_TEXT_CHARS)}${options.preview ? " (preview)" : ""}`)}\n\n`);
+        const collected = await collectDeployFiles(config.serveDirectory);
+        io.out(`${hashedLine(collected.files.length)}\n`);
+        const startedAt = io.now();
+        const { outcome, createdApp } = await deployProjectFiles({ baseUrl: session.baseUrl, token: session.token }, projectDirectory, config.slug, collected, {
+            live: !options.preview,
+            // The assigned slug is server text, so it prints quoted and
+            // length-bounded like every other string this CLI did not author.
+            // A validated slug tops out at 63 characters, so the line never
+            // passes 80 columns; the closing note explains where it is saved.
+            onAppCreated: (created) => {
+                io.out(`✓ Created   ${quotedForTerminal(created.appSlug, MAX_SERVER_TEXT_CHARS)}\n`);
+            },
+        });
+        const seconds = (io.now() - startedAt) / 1_000;
+        io.out(`${changedNote(outcome)}\n`);
+        io.out(`${uploadedLine(outcome, seconds)}\n`);
+        io.out(`${resultLine(outcome)}\n`);
+        if (outcome.url !== null) {
+            io.out(`\n  ${capForTerminal(outcome.url, MAX_SERVER_URL_CHARS)}\n`);
+        }
+        if (collected.skippedNodeModules.length > 0) {
+            io.out(`\n${wrapProse("Note: node_modules doesn't deploy — Driggsby serves your app as static files, so it isn't needed.")}\n`);
+        }
+        if (collected.skippedSymlinks.length > 0) {
+            io.out(`\n${symlinkNote(collected.skippedSymlinks)}\n`);
+        }
+        if (createdApp !== null) {
+            io.out(`\n${wrapProse(`This deploy created your app. Its address is assigned by Driggsby — the name you picked plus a unique ending — and it's saved in driggsby.json, so every later deploy targets it. If this project lives in git, commit the updated driggsby.json: it's the only record of your app's address, and a fresh checkout without it would create a second app.`)}\n`);
+        }
+        io.out(`\n${nextSection(outcome)}`);
+        return 0;
+    }
+    catch (error) {
+        throw deployFailure(error, baseUrl, DEPLOY_RETRY_COMMAND);
+    }
+}
+function hashedLine(fileCount) {
+    return `✓ Hashed    ${fileCount} ${fileCount === 1 ? "file" : "files"}`;
+}
+// What the manifest exchange revealed: how much of the app Driggsby already
+// had. Printed as its own line right after hashing.
+function changedNote(outcome) {
+    const changed = outcome.fileCount - outcome.unchangedFileCount;
+    if (outcome.unchangedFileCount === 0) {
+        return "✓ Compared  all new to Driggsby";
+    }
+    if (changed === 0) {
+        return "✓ Compared  no file changed since the last deploy";
+    }
+    return `✓ Compared  ${changed} changed · ${outcome.unchangedFileCount} already on Driggsby`;
+}
+function uploadedLine(outcome, seconds) {
+    if (outcome.uploadedBlobCount === 0) {
+        return "✓ Uploaded  nothing — Driggsby already had every file";
+    }
+    return `✓ Uploaded  ${formatBytes(outcome.uploadedBytes)} in ${formatSeconds(seconds)}`;
+}
+function resultLine(outcome) {
+    if (outcome.live) {
+        // "at:" only when the URL that line promises actually follows.
+        return outcome.url === null
+            ? `✓ Live      v${outcome.versionNumber}`
+            : `✓ Live      v${outcome.versionNumber}, at:`;
+    }
+    return `✓ Ready     v${outcome.versionNumber} is uploaded but not live — what visitors see is unchanged`;
+}
+function symlinkNote(skipped) {
+    // Symlink names come straight off the filesystem and skip the manifest's
+    // character validation, so each one prints through quotedForTerminal —
+    // sanitized, length-bounded, and inside quotes the name can't break out
+    // of, so it reads as a name, not as part of the CLI's own sentence.
+    const shown = skipped
+        .slice(0, 3)
+        .map((name) => quotedForTerminal(name, 40))
+        .join(", ");
+    const more = skipped.length > 3 ? ` and ${skipped.length - 3} more` : "";
+    return wrapProse(`Note: symlinks don't deploy — skipped ${shown}${more}.`);
+}
+function nextSection(outcome) {
+    if (!outcome.live) {
+        return ("Next:\n" +
+            `  Make v${outcome.versionNumber} live with npx driggsby@latest rollback --to ${outcome.versionNumber}\n`);
+    }
+    return ("Next:\n" +
+        "  Deploy again any time — only changed files upload. Switch back to an\n" +
+        "  earlier version with npx driggsby@latest rollback.\n");
+}
+function formatSeconds(seconds) {
+    if (seconds < 0.05) {
+        return "under a second";
+    }
+    return seconds >= 10 ? `${Math.round(seconds)}s` : `${seconds.toFixed(1)}s`;
+}

package/dist/deploy/rollback-command.js

@@ -0,0 +1,100 @@
+// driggsby rollback: switch which kept version of the app is live. Nothing
+// re-uploads — the switch is a pointer change on Driggsby's side. With --to N
+// it acts directly; without it, it shows the choices and asks (or, when not
+// attached to a person, explains how to re-run with --to).
+import { setLiveVersion, readProjectConfig } from "@driggsby/deploy";
+import { apiBaseUrl } from "../api/base-url.js";
+import { CliError } from "../cli-error.js";
+import { defaultCredentialEnvironment, } from "../credentials/store.js";
+import { capForTerminal, wrapProse } from "../terminal-text.js";
+import { deployFailure, MAX_SERVER_URL_CHARS, requireDeploySession, } from "./api-session.js";
+import { fetchVersionList, renderVersionRows } from "./versions-command.js";
+const ROLLBACK_RETRY_COMMAND = "npx driggsby@latest rollback";
+function defaultRollbackIo() {
+    return {
+        out: (text) => {
+            process.stdout.write(text);
+        },
+        ask: async (question) => {
+            const { createInterface } = await import("node:readline/promises");
+            const readline = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                return await readline.question(question);
+            }
+            finally {
+                readline.close();
+            }
+        },
+        interactive: process.stdin.isTTY && process.stdout.isTTY,
+    };
+}
+export async function runRollback(options, environment = defaultCredentialEnvironment(), io = defaultRollbackIo()) {
+    const projectDirectory = options.projectDirectory ?? process.cwd();
+    const baseUrl = apiBaseUrl(environment.env);
+    try {
+        const config = await readProjectConfig(projectDirectory);
+        const session = await requireDeploySession(environment);
+        const api = { baseUrl: session.baseUrl, token: session.token };
+        const list = await fetchVersionList(api, config.slug);
+        const readyNumbers = list.versions
+            .filter((version) => version.status === "ready")
+            .map((version) => version.number);
+        if (readyNumbers.length === 0) {
+            throw new CliError(`${wrapProse(`${config.slug} has no completed versions to switch between yet. Deploy one first:`)}\n` +
+                "  npx driggsby@latest deploy", 1);
+        }
+        const target = options.toVersion ?? (await chooseVersion(list, readyNumbers, io));
+        if (target === list.liveVersionNumber) {
+            io.out(`v${target} is already live — nothing changed.\n\n` +
+                "Next:\n  See every version with npx driggsby@latest versions\n");
+            return 0;
+        }
+        if (!readyNumbers.includes(target)) {
+            throw new CliError(`${wrapProse(`v${target} isn't one of ${config.slug}'s ready versions. Ready: ${readyNumbers.map((number) => `v${number}`).join(", ")}.`)}\n\n` +
+                "See the full list with:\n  npx driggsby@latest versions", 1);
+        }
+        const previousLive = list.liveVersionNumber;
+        const result = await setLiveVersion(api, config.slug, target);
+        const was = previousLive === null ? "" : ` (was v${previousLive})`;
+        // "at:" only when the URL that line promises actually follows; the URL
+        // is a server-supplied string, sanitized before printing.
+        const atSuffix = result.url === null ? "" : ", at:";
+        io.out(`✓ Live      v${result.versionNumber} is what visitors see now${was}${atSuffix}\n`);
+        if (result.url !== null) {
+            io.out(`\n  ${capForTerminal(result.url, MAX_SERVER_URL_CHARS)}\n`);
+        }
+        io.out(`\n${wrapProse(`Nothing re-uploaded — Driggsby already had v${result.versionNumber} in full.`)}\n` +
+            "\nNext:\n  See every version with npx driggsby@latest versions\n");
+        return 0;
+    }
+    catch (error) {
+        throw deployFailure(error, baseUrl, ROLLBACK_RETRY_COMMAND);
+    }
+}
+// Without --to: show the same rows `versions` prints, then ask (a person) or
+// explain the exact re-run (an agent or script).
+async function chooseVersion(list, readyNumbers, io) {
+    // Only "ready" versions can go live, so only those are offered here — an
+    // "incomplete" row under this heading would list a choice that gets
+    // refused.
+    const rows = renderVersionRows({
+        ...list,
+        versions: list.versions.filter((version) => version.status === "ready"),
+    });
+    if (!io.interactive) {
+        throw new CliError(`These versions can go live:\n\n${rows}\n\n` +
+            "This terminal can't prompt for a choice, so name one directly:\n" +
+            "  npx driggsby@latest rollback --to <VERSION>", 2);
+    }
+    io.out(`${rows}\n\n`);
+    const answer = (await io.ask("Make which version live? (a number like 2) ")).trim();
+    const normalized = /^[vV]/.test(answer) ? answer.slice(1) : answer;
+    const parsed = Number.parseInt(normalized, 10);
+    // Same guard as --to: a digit string past Number.MAX_SAFE_INTEGER must be
+    // refused here too, not rendered back as "vInfinity isn't one of ...".
+    if (!/^[0-9]+$/.test(normalized) || !Number.isSafeInteger(parsed)) {
+        throw new CliError(`${wrapProse(`That wasn't a version number. Choose one of: ${readyNumbers.map((number) => `v${number}`).join(", ")}, or run:`)}\n` +
+            "  npx driggsby@latest rollback --to <VERSION>", 1);
+    }
+    return parsed;
+}

package/dist/deploy/versions-command.js

@@ -0,0 +1,97 @@
+// driggsby versions: list the deployed app's kept versions, which one is
+// live, and the numbers rollback accepts. rollback reuses the fetch and the
+// row rendering here so both commands describe versions identically.
+import { DeployApiError, formatBytes, listVersions, readProjectConfig, } from "@driggsby/deploy";
+import { apiBaseUrl } from "../api/base-url.js";
+import { CliError } from "../cli-error.js";
+import { defaultCredentialEnvironment, } from "../credentials/store.js";
+import { capForTerminal, quotedForTerminal, wrapProse } from "../terminal-text.js";
+import { deployFailure, MAX_SERVER_TEXT_CHARS, MAX_SERVER_URL_CHARS, requireDeploySession, } from "./api-session.js";
+function defaultVersionsIo() {
+    return {
+        out: (text) => {
+            process.stdout.write(text);
+        },
+    };
+}
+export async function runVersions(options, environment = defaultCredentialEnvironment(), io = defaultVersionsIo()) {
+    const projectDirectory = options.projectDirectory ?? process.cwd();
+    const baseUrl = apiBaseUrl(environment.env);
+    try {
+        const config = await readProjectConfig(projectDirectory);
+        const session = await requireDeploySession(environment);
+        const list = await fetchVersionList({ baseUrl: session.baseUrl, token: session.token }, config.slug);
+        // The slug and URL are server-supplied strings, sanitized and
+        // length-bounded like every other text this CLI did not author — and
+        // the slug prints through quotedForTerminal, inside quotes it can't
+        // break out of, so it reads as a name, never as the CLI's own sentence.
+        const count = list.versions.length;
+        io.out(`${wrapProse(`${quotedForTerminal(list.appSlug, MAX_SERVER_TEXT_CHARS)} — ${count} ${count === 1 ? "version" : "versions"}`)}\n\n`);
+        io.out(`${renderVersionRows(list)}\n`);
+        if (list.liveVersionNumber !== null) {
+            io.out(`\nYour app:\n\n  ${capForTerminal(list.url, MAX_SERVER_URL_CHARS)}\n`);
+        }
+        else {
+            io.out("\nNothing is live yet, so your app's address shows nothing.\n");
+        }
+        io.out("\nNext:\n" +
+            '  Make any "ready" version live with npx driggsby@latest rollback --to <VERSION>\n');
+        return 0;
+    }
+    catch (error) {
+        throw deployFailure(error, baseUrl, "npx driggsby@latest versions");
+    }
+}
+// A 404 here means the app has never been deployed from this account, and
+// the fix is a deploy — not a retry.
+export async function fetchVersionList(api, slug) {
+    try {
+        return await listVersions(api, slug);
+    }
+    catch (error) {
+        if (error instanceof DeployApiError && error.status === 404) {
+            throw new CliError(`${wrapProse(`There's no app named ${slug} on your Driggsby account yet. Its first deploy creates it:`)}\n` +
+                "  npx driggsby@latest deploy", 1);
+        }
+        throw error;
+    }
+}
+export function renderVersionRows(list) {
+    const rows = list.versions.map((version) => ({
+        label: `v${version.number}`,
+        status: version.live ? "live now" : version.status === "ready" ? "ready" : "incomplete",
+        files: `${version.fileCount} ${version.fileCount === 1 ? "file" : "files"}`,
+        size: formatBytes(version.totalBytes),
+        date: formatCreatedAt(version.createdAt),
+    }));
+    if (rows.length === 0) {
+        return "  (no versions yet)";
+    }
+    const labelWidth = widestLength(rows.map((row) => row.label));
+    const statusWidth = widestLength(rows.map((row) => row.status));
+    const filesWidth = widestLength(rows.map((row) => row.files));
+    const sizeWidth = widestLength(rows.map((row) => row.size));
+    return rows
+        .map((row) => `  ${row.label.padEnd(labelWidth)}  ${row.status.padEnd(statusWidth)}  ` +
+        `${row.files.padStart(filesWidth)}  ${row.size.padStart(sizeWidth)}  ${row.date}`)
+        .join("\n");
+}
+// reduce, not Math.max(...spread): the server controls this array's length,
+// and a spread call throws once the argument list gets long enough.
+function widestLength(values) {
+    return values.reduce((widest, value) => Math.max(widest, value.length), 0);
+}
+// "2026-08-21T17:04:00.000Z" -> "2026-08-21 17:04 UTC". The API always sends
+// ISO-8601 UTC; anything unexpected is shown as-is (sanitized and capped)
+// rather than guessed at. Real values keep the row inside 80 columns; this
+// bound keeps a garbage timestamp from stretching it without limit — a real
+// timestamp is at most 24 characters.
+const MAX_CREATED_AT_CELL_CHARS = 30;
+function formatCreatedAt(createdAt) {
+    const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/.exec(createdAt);
+    if (match === null) {
+        return capForTerminal(createdAt, MAX_CREATED_AT_CELL_CHARS);
+    }
+    const [, date, time] = match;
+    return `${date ?? ""} ${time ?? ""} UTC`;
+}

package/dist/dev/dev-command.js

@@ -0,0 +1,106 @@
+// driggsby dev: preview the app in this folder with the developer's real
+// Driggsby data, in the exact topology it will live in after deploy — the
+// app on its own local origin, embedded by a local host page, talking
+// through the frozen postMessage protocol. The app token stays in this
+// process; the pages carry no credentials.
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { readProjectConfig } from "@driggsby/deploy";
+import { apiBaseUrl, apiHost } from "../api/base-url.js";
+import { blockedNetworkError } from "../api/network-error.js";
+import { CliError } from "../cli-error.js";
+import { defaultCredentialEnvironment, } from "../credentials/store.js";
+import { requireDeploySession } from "../deploy/api-session.js";
+import { tryOpenUrl } from "../login/open-url.js";
+import { wrapProse } from "../terminal-text.js";
+import { startDevServers } from "./dev-servers.js";
+import { McpBroker } from "./mcp-broker.js";
+import { watchDirectory } from "./watcher.js";
+export const DEV_HOST_PORT = 4111;
+export const DEV_APP_PORT = 4112;
+const DEV_RETRY_COMMAND = "npx driggsby@latest dev";
+function defaultDevIo() {
+    return {
+        out: (text) => {
+            process.stdout.write(text);
+        },
+        openUrl: tryOpenUrl,
+        waitForShutdown: async () => {
+            await new Promise((resolve) => {
+                process.once("SIGINT", () => {
+                    resolve();
+                });
+                process.once("SIGTERM", () => {
+                    resolve();
+                });
+            });
+        },
+    };
+}
+export async function runDev(options = {}, environment = defaultCredentialEnvironment(), io = defaultDevIo()) {
+    const projectDirectory = options.projectDirectory ?? process.cwd();
+    const baseUrl = apiBaseUrl(environment.env);
+    const config = await readProjectConfig(projectDirectory);
+    if (config.devCommand !== null) {
+        throw new CliError(`${wrapProse('This driggsby.json sets "dev_command", which driggsby dev doesn\'t support yet. Remove it to preview the folder\'s files directly, or run your own dev server and deploy with:')}\n` +
+            "  npx driggsby@latest deploy", 1);
+    }
+    const session = await requireDeploySession(environment);
+    const sdkBundle = await loadSdkBundle();
+    const broker = new McpBroker({ baseUrl: session.baseUrl, token: session.token });
+    let servers;
+    try {
+        servers = await startDevServers({
+            slug: config.slug,
+            serveDirectory: config.serveDirectory,
+            sdkBundle,
+            runToolCall: (tool, argumentsObject) => broker.runToolCall(tool, argumentsObject),
+            hostPort: options.hostPort ?? DEV_HOST_PORT,
+            appPort: options.appPort ?? DEV_APP_PORT,
+        });
+    }
+    catch (error) {
+        throw devStartFailure(error, baseUrl);
+    }
+    const stopWatching = watchDirectory(config.serveDirectory, () => {
+        servers.notifyChange();
+    });
+    try {
+        const opened = await io.openUrl(servers.hostOrigin);
+        io.out(`✓ Ready     ${config.slug} is running with your live Driggsby data${opened ? ", at:" : ":"}\n\n` +
+            `  ${servers.hostOrigin}\n\n` +
+            `${wrapProse("Edit the app's files and the page reloads on save. Press Ctrl+C to stop.")}\n` +
+            "\nNext:\n  Put it live on driggsby.dev with npx driggsby@latest deploy\n");
+        await io.waitForShutdown();
+        return 0;
+    }
+    finally {
+        stopWatching();
+        await servers.close();
+    }
+}
+// The Driggsby SDK bundle ships inside @driggsby/sdk; dev serves it on the
+// app origin at the same path production serves it, so the scaffold's
+// script tag works identically in both places.
+async function loadSdkBundle() {
+    const require = createRequire(import.meta.url);
+    const bundlePath = require.resolve("@driggsby/sdk/driggsby-sdk.js");
+    return await readFile(bundlePath, "utf8");
+}
+function devStartFailure(error, baseUrl) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error.code === "EADDRINUSE") {
+        return new CliError(`${wrapProse(`Ports ${String(DEV_HOST_PORT)} and ${String(DEV_APP_PORT)} are how driggsby dev serves the preview, and something on this machine is already using one of them. Stop that program (often another driggsby dev) and try again:`)}\n` +
+            `  ${DEV_RETRY_COMMAND}`, 1);
+    }
+    const blocked = blockedNetworkError(error, {
+        host: apiHost(baseUrl),
+        retryCommand: DEV_RETRY_COMMAND,
+    });
+    if (blocked !== null) {
+        return blocked;
+    }
+    return new CliError(`We weren't able to start the preview just now. Please try again:\n  ${DEV_RETRY_COMMAND}`, 1);
+}