nerdsystem 0.0.0-stage → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nerdsystem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# nerdsystem
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`nerd`: deploy apps built with coding agents to [nerdsystem](https://nerdsystem.com), with sign-in, roles, a database, file storage, previews per pull request, and security gates on every deploy.
+
+```sh
+npx nerdsystem init my-app
+cd my-app && pnpm install
+nerd dev       # run locally with real sign-in
+nerd verify    # secrets, dependencies, policy, PII, types
+nerd deploy    # checks, builds, migrates, ships
+```
+
+Every command takes `--json` for agents. `nerd help` lists them all.

package/dist/api.d.ts

@@ -0,0 +1,58 @@
+export interface ApiErrorBody {
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+export declare class ApiClient {
+    readonly apiUrl: string;
+    private readonly token;
+    constructor(apiUrl: string, token: string | undefined);
+    static fromConfig(opts?: {
+        requireAuth?: boolean;
+    }): ApiClient;
+    request<T>(method: string, path: string, body?: unknown | FormData): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body: unknown): Promise<T>;
+    patch<T>(path: string, body: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+export interface Me {
+    user: {
+        id: string;
+        email: string;
+        name: string;
+    };
+    orgs: {
+        id: string;
+        slug: string;
+        name: string;
+        role: string;
+    }[];
+}
+export interface Project {
+    id: string;
+    orgId: string;
+    slug: string;
+    name: string;
+    scriptName: string;
+    url: string;
+}
+export interface Deployment {
+    id: string;
+    status: "uploading" | "live" | "failed";
+    moduleCount: number;
+    assetCount: number;
+    bundleBytes: number;
+    error: string | null;
+    createdAt: string;
+    finishedAt: string | null;
+}
+export interface TenantConfig {
+    projectId: string;
+    roles: string[];
+    defaultRole: string;
+    allowSignup: boolean;
+}

package/dist/api.js

@@ -0,0 +1,59 @@
+import { loadConfig } from "./config.js";
+import { CliError } from "./util.js";
+export class ApiClient {
+    apiUrl;
+    token;
+    constructor(apiUrl, token) {
+        this.apiUrl = apiUrl;
+        this.token = token;
+    }
+    static fromConfig(opts = {}) {
+        const cfg = loadConfig();
+        if (opts.requireAuth !== false && !cfg.token) {
+            throw new CliError("Not logged in. Run `nerd login --token nsk_...` (or set NERD_TOKEN).");
+        }
+        return new ApiClient(cfg.apiUrl, cfg.token);
+    }
+    async request(method, path, body) {
+        const isForm = body instanceof FormData;
+        const res = await fetch(`${this.apiUrl}${path}`, {
+            method,
+            headers: {
+                ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
+                ...(body !== undefined && !isForm ? { "content-type": "application/json" } : {}),
+            },
+            body: body === undefined ? null : isForm ? body : JSON.stringify(body),
+        }).catch((err) => {
+            throw new CliError(`Could not reach ${this.apiUrl}: ${err.message}`);
+        });
+        const text = await res.text();
+        let json = null;
+        try {
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            throw new CliError(`API returned non-JSON (${res.status}): ${text.slice(0, 200)}`);
+        }
+        if (!res.ok) {
+            const err = json?.error;
+            const details = err?.details ? `\n${JSON.stringify(err.details, null, 2)}` : "";
+            throw new CliError(`${err?.code ?? "error"} (${res.status}): ${err?.message ?? "request failed"}${details}`);
+        }
+        return json;
+    }
+    get(path) {
+        return this.request("GET", path);
+    }
+    post(path, body) {
+        return this.request("POST", path, body);
+    }
+    put(path, body) {
+        return this.request("PUT", path, body);
+    }
+    patch(path, body) {
+        return this.request("PATCH", path, body);
+    }
+    delete(path) {
+        return this.request("DELETE", path);
+    }
+}

package/dist/commands/agents.d.ts

@@ -0,0 +1,9 @@
+export declare function renderAgentFiles(root: string): {
+    files: Record<string, string>;
+    hash: string;
+};
+/** Returns the agent files that are missing or generated from an older skill. */
+export declare function staleAgentFiles(root: string): string[];
+export declare function agentsSync(opts: {
+    json: boolean;
+}): Promise<void>;

package/dist/commands/agents.js

@@ -0,0 +1,45 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { findProjectRoot } from "../project.js";
+import { CliError, log } from "../util.js";
+/** The agent files generated from the skill, and the front matter each needs. */
+const TARGETS = {
+    "AGENTS.md": (s, b) => `${s}\n\n${b}`,
+    "GEMINI.md": (s, b) => `${s}\n\n${b}`,
+    ".github/copilot-instructions.md": (s, b) => `${s}\n\n${b}`,
+    ".cursor/rules/nerdsystem.mdc": (s, b) => `---\ndescription: How to build, run, and deploy this app on nerdsystem. Applies to server, database, auth, and deploy work.\nalwaysApply: true\n---\n${s}\n\n${b}`,
+};
+export function renderAgentFiles(root) {
+    const skillPath = path.join(root, ".claude/skills/nerdsystem/SKILL.md");
+    if (!existsSync(skillPath))
+        throw new CliError("No .claude/skills/nerdsystem/SKILL.md in this project.");
+    const body = readFileSync(skillPath, "utf8").replace(/^---[\s\S]*?---\s*/, "");
+    const hash = createHash("sha256").update(body).digest("hex").slice(0, 12);
+    const stamp = `<!-- generated from .claude/skills/nerdsystem/SKILL.md (${hash}); edit the skill, then run: nerd agents sync -->`;
+    const files = {};
+    for (const [file, render] of Object.entries(TARGETS))
+        files[file] = render(stamp, body);
+    return { files, hash };
+}
+/** Returns the agent files that are missing or generated from an older skill. */
+export function staleAgentFiles(root) {
+    const { files, hash } = renderAgentFiles(root);
+    return Object.keys(files).filter((f) => {
+        const p = path.join(root, f);
+        return !existsSync(p) || !readFileSync(p, "utf8").includes(`(${hash})`);
+    });
+}
+export async function agentsSync(opts) {
+    const root = findProjectRoot();
+    const { files, hash } = renderAgentFiles(root);
+    for (const [f, content] of Object.entries(files)) {
+        const p = path.join(root, f);
+        mkdirSync(path.dirname(p), { recursive: true });
+        writeFileSync(p, content);
+    }
+    if (opts.json)
+        process.stdout.write(`${JSON.stringify({ synced: Object.keys(files), hash })}\n`);
+    else
+        log.ok(`Synced ${Object.keys(files).length} agent files from the skill (${hash}): ${Object.keys(files).join(", ")}`);
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,7 @@
+export declare function authConfig(opts: {
+    json: boolean;
+    roles?: string;
+    "default-role"?: string;
+    signup?: string;
+}): Promise<void>;
+export declare function authSecret(): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,25 @@
+import { ApiClient } from "../api.js";
+import { findProjectRoot, projectPath, readNerdJson } from "../project.js";
+import { log, printJson } from "../util.js";
+import { ensureDevVars } from "./dev.js";
+export async function authConfig(opts) {
+    const nerd = readNerdJson(findProjectRoot());
+    const api = ApiClient.fromConfig();
+    const patch = {};
+    if (opts.roles)
+        patch.roles = opts.roles.split(",").map((r) => r.trim()).filter(Boolean);
+    if (opts["default-role"])
+        patch.defaultRole = opts["default-role"];
+    if (opts.signup)
+        patch.allowSignup = opts.signup === "on" || opts.signup === "true";
+    const r = Object.keys(patch).length
+        ? await api.patch(projectPath(nerd, "/auth"), patch)
+        : await api.get(projectPath(nerd, "/auth"));
+    if (opts.json)
+        return printJson(r);
+    log.info(`roles: ${r.auth.roles.join(", ")}\ndefault role: ${r.auth.defaultRole}\nsignup: ${r.auth.allowSignup ? "on" : "off"}`);
+}
+export async function authSecret() {
+    await ensureDevVars(findProjectRoot());
+    log.ok("Development tenant secret is in .dev.vars");
+}

package/dist/commands/billing.d.ts

@@ -0,0 +1,14 @@
+export declare function billingShow(opts: {
+    json: boolean;
+    org?: string;
+}): Promise<void>;
+export declare function billingUpgrade(opts: {
+    json: boolean;
+    org?: string;
+    plan?: string;
+    annual?: boolean;
+}): Promise<void>;
+export declare function billingPortal(opts: {
+    json: boolean;
+    org?: string;
+}): Promise<void>;

package/dist/commands/billing.js

@@ -0,0 +1,42 @@
+import { ApiClient } from "../api.js";
+import { findProjectRoot, readNerdJson } from "../project.js";
+import { CliError, log, printJson } from "../util.js";
+function orgSlug(opts) {
+    if (opts.org)
+        return opts.org;
+    return readNerdJson(findProjectRoot()).org;
+}
+const n = (v) => (v < 0 ? "unlimited" : String(v));
+export async function billingShow(opts) {
+    const org = orgSlug(opts);
+    const b = await ApiClient.fromConfig().get(`/v1/orgs/${org}/billing`);
+    if (opts.json)
+        return printJson(b);
+    log.info(`${org}: ${b.limits.name} plan${b.subscriptionStatus ? ` (${b.subscriptionStatus})` : ""}`);
+    log.info(`  projects       ${b.usage.projects} of ${n(b.limits.projects)}`);
+    log.info(`  active users   ${b.usage.monthlyActiveUsers} of ${b.limits.monthlyActiveUsers} this month`);
+    log.info(`  build minutes  ${b.usage.buildMinutesThisMonth} of ${b.limits.buildMinutesPerMonth} this month`);
+    log.info(`  members        ${b.usage.members} of ${n(b.limits.members)}`);
+    for (const w of b.warnings)
+        log.warn(w);
+    if (b.billedThrough)
+        log.info(`  billed through ${b.billedThrough} (a Studio client org)`);
+    if (b.effectivePlan === "free" && !b.billedThrough)
+        log.info(`\nUpgrade: nerd billing upgrade --plan pro ($${b.plans.pro?.priceUsdMonth}/mo) or --plan studio ($${b.plans.studio?.priceUsdMonth}/mo, agencies: one org per client)`);
+}
+export async function billingUpgrade(opts) {
+    const org = orgSlug(opts);
+    if (opts.plan !== "pro" && opts.plan !== "studio")
+        throw new CliError("Usage: nerd billing upgrade --plan pro|studio [--annual]");
+    const r = await ApiClient.fromConfig().post(`/v1/orgs/${org}/billing/checkout`, { plan: opts.plan, interval: opts.annual ? "annual" : "monthly", returnPath: `/app/${org}/billing` });
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Open this link to complete checkout:\n\n  ${r.url}`);
+}
+export async function billingPortal(opts) {
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().post(`/v1/orgs/${org}/billing/portal`, { returnPath: `/app/${org}/billing` });
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Manage cards, invoices, and your plan here:\n\n  ${r.url}`);
+}

package/dist/commands/builds.d.ts

@@ -0,0 +1,12 @@
+export declare function buildsList(opts: {
+    json: boolean;
+    limit: string;
+}): Promise<void>;
+export declare function buildsShow(id: string | undefined, opts: {
+    json: boolean;
+}): Promise<void>;
+export declare function buildsTrigger(opts: {
+    json: boolean;
+    branch?: string;
+    commit?: string;
+}): Promise<void>;

package/dist/commands/builds.js

@@ -0,0 +1,40 @@
+import { ApiClient } from "../api.js";
+import { findProjectRoot, projectPath, readNerdJson } from "../project.js";
+import { CliError, log, printJson, table } from "../util.js";
+export async function buildsList(opts) {
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().get(projectPath(nerd, `/builds?limit=${Number(opts.limit) || 10}`));
+    if (opts.json)
+        return printJson(r);
+    table(r.builds.map((b) => ({ id: b.id, status: b.status, env: b.environment, trigger: b.trigger, ref: b.prNumber ? `PR #${b.prNumber}` : b.branch, commit: b.commitSha.slice(0, 7), created: b.createdAt, error: (b.error ?? "").split("\n")[0] })), ["id", "status", "env", "trigger", "ref", "commit", "created", "error"]);
+}
+export async function buildsShow(id, opts) {
+    if (!id)
+        throw new CliError("Usage: nerd builds show <buildId>");
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().get(projectPath(nerd, `/builds/${id}`));
+    if (opts.json)
+        return printJson(r);
+    const b = r.build;
+    log.info(`${b.id}  ${b.status}  ${b.environment}  ${b.trigger}  ${b.commitSha.slice(0, 7)}  ${b.url}`);
+    if (b.error)
+        log.warn(b.error);
+    for (const c of b.checks ?? []) {
+        log.info(`  ${c.status === "pass" ? "✓" : c.status === "fail" ? "✗" : c.status === "warn" ? "!" : "–"} ${c.title}: ${c.summary}`);
+        for (const f of c.findings.slice(0, 10))
+            log.info(`      ${f.severity}: ${f.file ? `${f.file}${f.line ? `:${f.line}` : ""} ` : ""}${f.message}`);
+    }
+    process.stdout.write(r.log.endsWith("\n") || !r.log ? r.log : `${r.log}\n`);
+}
+export async function buildsTrigger(opts) {
+    const nerd = readNerdJson(findProjectRoot());
+    const body = {};
+    if (opts.branch)
+        body.branch = opts.branch;
+    if (opts.commit)
+        body.commitSha = opts.commit;
+    const r = await ApiClient.fromConfig().post(projectPath(nerd, "/builds"), body);
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Queued build ${r.build.id} of ${r.build.branch} → ${r.build.url}\n  Follow it with: nerd builds show ${r.build.id}`);
+}

package/dist/commands/check.d.ts

@@ -0,0 +1,20 @@
+export interface CheckResult {
+    ok: boolean;
+    problems: string[];
+}
+/** Removes line and block comments and trailing commas from JSONC without touching string contents. */
+export declare function stripJsonComments(input: string): string;
+/**
+ * Static rules the platform relies on. These mirror the rules in the template's CLAUDE.md so an
+ * agent gets a concrete failure instead of a silent misdeploy.
+ */
+export declare function staticChecks(root: string): string[];
+export declare function runChecks(root: string, opts: {
+    remote: boolean;
+    typecheck: boolean;
+}): Promise<CheckResult>;
+export declare function check(opts: {
+    json: boolean;
+    "no-typecheck": boolean;
+    "no-remote": boolean;
+}): Promise<void>;

package/dist/commands/check.js

@@ -0,0 +1,145 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { ApiClient } from "../api.js";
+import { findProjectRoot, projectPath, readNerdJson } from "../project.js";
+import { CliError, log, run } from "../util.js";
+import { staleAgentFiles } from "./agents.js";
+const ALLOWED_BINDINGS = new Set(["DB", "STORAGE", "ASSETS"]);
+/** Removes line and block comments and trailing commas from JSONC without touching string contents. */
+export function stripJsonComments(input) {
+    let out = "";
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        const next = input[i + 1];
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < input.length && input[j] !== '"')
+                j += input[j] === "\\" ? 2 : 1;
+            out += input.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (ch === "/" && next === "/") {
+            while (i < input.length && input[i] !== "\n")
+                i++;
+        }
+        else if (ch === "/" && next === "*") {
+            const end = input.indexOf("*/", i + 2);
+            i = end === -1 ? input.length : end + 2;
+        }
+        else {
+            out += ch;
+            i++;
+        }
+    }
+    return out.replace(/,(\s*[}\]])/g, "$1");
+}
+/**
+ * Static rules the platform relies on. These mirror the rules in the template's CLAUDE.md so an
+ * agent gets a concrete failure instead of a silent misdeploy.
+ */
+export function staticChecks(root) {
+    const problems = [];
+    const entry = path.join(root, "src/server/index.ts");
+    if (!existsSync(entry)) {
+        problems.push("src/server/index.ts is missing; it must be the Worker entry.");
+    }
+    else {
+        const src = readFileSync(entry, "utf8");
+        if (!/from\s+["']@nerdsystem\/sdk["']/.test(src))
+            problems.push("src/server/index.ts must import from @nerdsystem/sdk.");
+        if (!/createNerdApp\s*</.test(src) && !/createNerdApp\s*\(/.test(src))
+            problems.push("src/server/index.ts must create the app with createNerdApp().");
+        if (/new\s+Hono\s*[<(]/.test(src))
+            problems.push("src/server/index.ts must not create a bare `new Hono()` root; use createNerdApp(). Sub-routers in other files are fine.");
+        if (!/export\s+default\s+app/.test(src))
+            problems.push("src/server/index.ts must `export default app`.");
+    }
+    const wranglerPath = ["wrangler.jsonc", "wrangler.json"].map((f) => path.join(root, f)).find(existsSync);
+    if (!wranglerPath) {
+        problems.push("wrangler.jsonc is missing.");
+    }
+    else {
+        let cfg;
+        try {
+            cfg = JSON.parse(stripJsonComments(readFileSync(wranglerPath, "utf8")));
+        }
+        catch {
+            problems.push(`${path.basename(wranglerPath)} is not valid JSON.`);
+            cfg = {};
+        }
+        const bindingNames = [];
+        for (const key of ["d1_databases", "r2_buckets", "kv_namespaces", "services", "queues", "vectorize", "hyperdrive", "ai", "browser"]) {
+            const v = cfg[key];
+            if (Array.isArray(v)) {
+                for (const b of v)
+                    if (b.binding)
+                        bindingNames.push(b.binding);
+            }
+            else if (v && typeof v === "object" && "binding" in v) {
+                bindingNames.push(String(v.binding));
+            }
+        }
+        if (cfg.durable_objects)
+            problems.push("wrangler.jsonc: Durable Objects are not supported on nerdsystem yet.");
+        for (const b of bindingNames)
+            if (!ALLOWED_BINDINGS.has(b))
+                problems.push(`wrangler.jsonc: binding "${b}" is not provisioned by the platform. Allowed: ${[...ALLOWED_BINDINGS].join(", ")}.`);
+        const assets = cfg.assets;
+        if (!assets || !Array.isArray(assets.run_worker_first) || !assets.run_worker_first.includes("/api/*")) {
+            problems.push('wrangler.jsonc: assets.run_worker_first must include "/api/*" so API routes reach the Worker.');
+        }
+    }
+    const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+    for (const [name, cmd] of Object.entries(pkg.scripts ?? {})) {
+        if (/wrangler\s+(deploy|publish|secret|d1\s+migrations\s+apply(?!.*--local))/.test(cmd))
+            problems.push(`package.json script "${name}" runs wrangler against Cloudflare directly. Use nerd commands.`);
+    }
+    if (!pkg.dependencies?.["@nerdsystem/sdk"])
+        problems.push("package.json must depend on @nerdsystem/sdk.");
+    if (!existsSync(path.join(root, ".github/dependabot.yml"))) {
+        problems.push("No .github/dependabot.yml: add it so dependency updates arrive as pull requests that get built and checked (warning).");
+    }
+    if (existsSync(path.join(root, ".claude/skills/nerdsystem/SKILL.md"))) {
+        const stale = staleAgentFiles(root);
+        if (stale.length)
+            problems.push(`Agent instruction files are out of date with the skill: ${stale.join(", ")}. Run \`nerd agents sync\`.`);
+    }
+    return problems;
+}
+export async function runChecks(root, opts) {
+    const problems = staticChecks(root);
+    if (opts.remote) {
+        const nerd = readNerdJson(root);
+        try {
+            await ApiClient.fromConfig().get(projectPath(nerd));
+        }
+        catch (err) {
+            problems.push(`Remote project ${nerd.org}/${nerd.project} is not reachable: ${err.message}`);
+        }
+    }
+    if (opts.typecheck && problems.every((p) => p.endsWith("(warning)") || p.startsWith("Agent instruction files"))) {
+        log.step("Typechecking");
+        const code = await run("npx", ["tsc", "-b", "--pretty"], { cwd: root });
+        if (code !== 0)
+            problems.push("Typecheck failed (see errors above).");
+    }
+    return { ok: problems.length === 0, problems };
+}
+export async function check(opts) {
+    const root = findProjectRoot();
+    const result = await runChecks(root, { remote: !opts["no-remote"], typecheck: !opts["no-typecheck"] });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    else if (result.ok) {
+        log.ok("All checks passed");
+    }
+    else {
+        for (const p of result.problems)
+            log.warn(p);
+    }
+    const blocking = result.problems.filter((p) => !p.endsWith("(warning)") && !p.startsWith("Agent instruction files"));
+    if (blocking.length)
+        throw new CliError(`${blocking.length} problem(s) found`, 2);
+}

package/dist/commands/db.d.ts

@@ -0,0 +1,9 @@
+export declare function dbQuery(sql: string | undefined, opts: {
+    json: boolean;
+}): Promise<void>;
+export declare function dbMigrate(opts: {
+    json: boolean;
+}): Promise<void>;
+export declare function dbMigrations(opts: {
+    json: boolean;
+}): Promise<void>;

package/dist/commands/db.js

@@ -0,0 +1,32 @@
+import { ApiClient } from "../api.js";
+import { findProjectRoot, projectPath, readNerdJson } from "../project.js";
+import { CliError, log, printJson, table } from "../util.js";
+import { applyRemoteMigrations } from "./deploy.js";
+export async function dbQuery(sql, opts) {
+    if (!sql)
+        throw new CliError('Usage: nerd db query "select * from todos limit 5"');
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().post(projectPath(nerd, "/db/query"), { sql });
+    if (opts.json)
+        return printJson(r);
+    for (const res of r.results) {
+        if (res.results.length)
+            table(res.results, Object.keys(res.results[0]));
+        else
+            log.info(`  ok (${JSON.stringify(res.meta)})`);
+    }
+}
+export async function dbMigrate(opts) {
+    const root = findProjectRoot();
+    const r = await applyRemoteMigrations(root, ApiClient.fromConfig());
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Applied: ${r.applied.join(", ") || "none"}; already applied: ${r.skipped.length}`);
+}
+export async function dbMigrations(opts) {
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().get(projectPath(nerd, "/db/migrations"));
+    if (opts.json)
+        return printJson(r);
+    table(r.migrations, ["name", "appliedAt"]);
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,27 @@
+import { ApiClient } from "../api.js";
+interface BuildOutput {
+    workerDir: string;
+    main: string;
+    modules: string[];
+    assetsDir: string | undefined;
+    assets: string[];
+    compatibilityDate: string | undefined;
+    compatibilityFlags: string[];
+}
+/** Locates the Vite build output: dist/<worker>/wrangler.json names the entry and the assets dir. */
+export declare function readBuildOutput(root: string): BuildOutput;
+export declare function applyRemoteMigrations(root: string, api: ApiClient): Promise<{
+    applied: string[];
+    skipped: string[];
+}>;
+export declare function deploy(opts: {
+    json: boolean;
+    "skip-check": boolean;
+    "skip-build": boolean;
+    note?: string | undefined;
+}): Promise<void>;
+export declare function deployments(opts: {
+    json: boolean;
+    limit: string;
+}): Promise<void>;
+export {};