cf-orbs 0.1.1 → 0.2.2

package/dist/commands/init.js

@@ -1,18 +1,24 @@
 // cf-orbs init [dir]: zero to a live provider. plan() is pure (options + probes → steps); runInit() executes.
 // Re-runnable: reuses the control token, keeps the Amp token secret when none is given, keeps user files.
+// --no-deploy (git mode): no Docker, no deploy. Scaffold a repo for Workers Builds, create the Worker with its
+// secrets, print the dashboard steps. Workers Builds then builds the images and deploys on each push.
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { expectOk, makeApi, providerInfo } from "../api.js";
 import { flagBool, flagString } from "../args.js";
 import { CONFIG_FILE, findTopLevelValue, instanceForVcpu, loadConfig, setTopLevelJsonc, } from "../config.js";
 import { CliError, registerSecret } from "../errors.js";
+import { filesWithSecrets, gitTrackedFiles } from "../file-checks.js";
 import { dockerOk, nodeMajor, whoami } from "../probes.js";
-import { generateToken, materialize, readControlToken, readState, writeControlToken, writeState, } from "../project.js";
+import { cliVersion, GIT_DEPLOY_COMMAND, generateToken, gitPackageJson, materialize, missingDockerfiles, readControlToken, readState, withSecretsFile, writeControlToken, writeState, writeWranglerConfig, } from "../project.js";
 import { checkSubdomain, registerSubdomain, suggestSubdomain, wranglerBearer } from "../subdomain.js";
 import { ask, askHidden } from "../ui.js";
-import { makeWrangler } from "../wrangler.js";
+import { classifyDeployFailure, deployFailureError, lastErrorLine, makeWrangler, WRANGLER_PIN, } from "../wrangler.js";
 import { deployProject, startPrewarm } from "./deploy.js";
 export const PROVIDER_WAIT_MS = 90_000;
+/** How long init waits for the prewarm instances (a first start on a cold host pulls the image). */
+export const SELFTEST_WAIT_MS = 180_000;
 /** Provider must stay up this long with no reject, no second-provider line and no restart. */
 export const PROVIDER_STABLE_MS = 15_000;
 const CRON_PERIOD_MS = 5 * 60_000;
@@ -29,7 +35,13 @@ export function plan(o, p) {
             error: new CliError(`Node ${p.nodeVersion} is too old; cf-orbs needs Node 22 or later`, "install Node 22+ (https://nodejs.org) and rerun"),
         });
     }
-    if (!p.docker) {
+    if (o.noDeploy && o.mode === "external") {
+        fails.push({
+            kind: "fail",
+            error: new CliError("--no-deploy supports only --provider cloudflare", "drop --provider external, or run cf-orbs init --provider external without --no-deploy"),
+        });
+    }
+    if (!p.docker && !o.noDeploy) {
         fails.push({
             kind: "fail",
             error: new CliError("Docker is not running (wrangler builds the orb image locally)", "start Docker Desktop or the docker daemon, check `docker info`, then rerun"),
@@ -80,7 +92,17 @@ export function plan(o, p) {
         }
     }
     let ampSource;
-    if (o.mode === "cloudflare") {
+    const hadProvider = p.prevMode === "cloudflare" || p.prevMode === "git";
+    if (o.noDeploy) {
+        // the Amp token is optional here: set it now or later, the Worker starts the provider once it has one
+        if (o.tokenFile)
+            ampSource = "file";
+        else if (p.envToken)
+            ampSource = "env";
+        else if (interactive)
+            ampSource = "prompt";
+    }
+    else if (o.mode === "cloudflare") {
         if (o.tokenFile)
             ampSource = "file";
         else if (p.envToken)
@@ -88,7 +110,7 @@ export function plan(o, p) {
         else if (interactive)
             ampSource = "prompt";
         // Keep only a secret that exists: external mode deletes it from the Worker.
-        else if (p.deployed && p.prevMode === "cloudflare")
+        else if (p.deployed && hadProvider)
             ampSource = "keep";
         else if (p.deployed) {
             fails.push({
@@ -105,15 +127,24 @@ export function plan(o, p) {
     }
     if (fails.length > 0)
         return fails;
-    const steps = [account, { kind: "scaffold", mode: o.mode }];
+    const steps = [
+        account,
+        { kind: "plan-check" },
+        { kind: "scaffold", mode: o.mode, git: Boolean(o.noDeploy) },
+    ];
     steps.push({ kind: "control-token", action: p.hasControlToken ? "reuse" : "generate" });
     if (ampSource)
         steps.push({ kind: "amp-token", source: ampSource });
+    if (o.noDeploy) {
+        steps.push({ kind: "subdomain" }, { kind: "git-files" }, { kind: "git-secrets" }, { kind: "selftest" }, { kind: "git-next" });
+        steps.push({ kind: "done", command: helloCommand(o.providerName) });
+        return steps;
+    }
     const secrets = ["CONTROL_TOKEN"];
     // "prompt" may still end as keep (Enter on a re-run); the executor drops the secret then.
     if (ampSource && ampSource !== "keep")
         secrets.push("AMP_ORB_PROVIDER_TOKEN");
-    steps.push({ kind: "subdomain" }, { kind: "deploy", secrets }, { kind: "health" }, { kind: "status" });
+    steps.push({ kind: "subdomain" }, { kind: "deploy", secrets }, { kind: "health" }, { kind: "status" }, { kind: "selftest" });
     if (o.mode === "cloudflare") {
         steps.push({ kind: "start-provider" }, { kind: "wait-provider", timeoutMs: PROVIDER_WAIT_MS });
     }
@@ -122,9 +153,10 @@ export function plan(o, p) {
     steps.push({ kind: "done", command: helloCommand(o.providerName) });
     return steps;
 }
-export async function gatherProbes(ctx) {
+/** noDeploy: git mode needs no Docker, so the probe is skipped. */
+export async function gatherProbes(ctx, o = {}) {
     const [docker, who, ct, state] = await Promise.all([
-        dockerOk(ctx.run),
+        o.noDeploy ? false : dockerOk(ctx.run),
         whoami(ctx.run),
         readControlToken(ctx.paths),
         readState(ctx.paths),
@@ -150,6 +182,41 @@ function checkAmpToken(ctx, t) {
     registerSecret(t);
     return t;
 }
+function warmLast(body) {
+    const b = (body && typeof body === "object" ? body : {});
+    return (b.last && typeof b.last === "object" ? b.last : {});
+}
+/** One finished prewarm run: ok > 0 passes, ok = 0 fails init. */
+function reportSelftest(ui, view) {
+    const count = Number(view.count) || 0;
+    const ok = Number(view.ok) || 0;
+    const ms = Array.isArray(view.msPerInstance) ? view.msPerInstance : [];
+    if (ok === 0) {
+        const jobs = Array.isArray(view.jobs) ? view.jobs : [];
+        const why = jobs.find((j) => typeof j.error === "string")?.error;
+        throw new CliError(`orb self-test failed: no instance started from the new image${why ? ` (${String(why)})` : ""}`, "run cf-orbs logs --provider and cf-orbs status, check the image build, then run cf-orbs deploy");
+    }
+    const t = ms.length > 0 ? ` in ${ms.map((m) => `${(m / 1000).toFixed(0)} s`).join(" and ")}` : "";
+    if (ok < count)
+        ui.warn(`self-test: only ${ok} of ${count} instances started${t}`);
+    else
+        ui.step(`self-test: orb image starts (${ok} of ${count} ready${t})`);
+}
+/** --no-deploy: the last prewarm run of an already built Worker, or undefined. Never throws. */
+async function lastPrewarm(url, token, ctx) {
+    if (!url || !token)
+        return undefined;
+    try {
+        const r = await makeApi(url, token, ctx.fetch).get("/v1/warm");
+        if (r.status !== 200)
+            return undefined;
+        const last = warmLast(r.body);
+        return typeof last.at === "string" ? last : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function runInit(ctx, o, steps) {
     const { ui, paths } = ctx;
     let state = await readState(paths);
@@ -165,6 +232,11 @@ export async function runInit(ctx, o, steps) {
     let providerStartedByCron = false;
     let accountName;
     let providerName = o.providerName;
+    let prewarmStarted = -1;
+    let prewarmAt = 0;
+    let subdomain;
+    let repoExisted = false;
+    let git;
     // Show every failed precondition in one run, not one per rerun.
     const fails = steps.filter((s) => s.kind === "fail");
     for (const f of fails.slice(0, -1))
@@ -197,6 +269,7 @@ export async function runInit(ctx, o, steps) {
                     break; // unknown auth type: wrangler deploy reports a missing subdomain itself
                 const c = await checkSubdomain(ctx.fetch, accountId, bearer);
                 if (c.kind === "has") {
+                    subdomain = c.subdomain;
                     ui.step(`workers.dev subdomain: ${c.subdomain}`);
                     break;
                 }
@@ -211,6 +284,7 @@ export async function runInit(ctx, o, steps) {
                     name = (await ask(`This account has no workers.dev subdomain. Name for it [${def}]: `)) || def;
                 }
                 await registerSubdomain(ctx.fetch, accountId, bearer, name);
+                subdomain = name;
                 ui.step(`workers.dev subdomain: registered ${name}.workers.dev`);
                 break;
             }
@@ -218,6 +292,7 @@ export async function runInit(ctx, o, steps) {
                 const r = await materialize(paths, {
                     templates: ctx.templates,
                     configOverrides: { providerHost: s.mode },
+                    git: s.git,
                 });
                 if (r.wroteConfig)
                     ui.step(`scaffold: wrote ${CONFIG_FILE}`);
@@ -231,6 +306,11 @@ export async function runInit(ctx, o, steps) {
                     config = await loadConfig(paths.config);
                     ui.step(`scaffold: providerHost set to ${s.mode}`);
                 }
+                if (o.name !== undefined && config.name !== o.name) {
+                    await writeFile(paths.config, setTopLevelJsonc(await readFile(paths.config, "utf8"), "name", o.name));
+                    config = await loadConfig(paths.config);
+                    ui.step(`scaffold: name set to ${o.name}`);
+                }
                 // --vcpu overwrites "instance"; without it a re-run keeps what the config has
                 if (o.vcpu !== undefined && !sameInstance(config.instance, instanceForVcpu(o.vcpu))) {
                     const t = await readFile(paths.config, "utf8");
@@ -238,7 +318,13 @@ export async function runInit(ctx, o, steps) {
                     config = await loadConfig(paths.config);
                     ui.step(`scaffold: instance set to ${o.vcpu} vCPU, ${o.vcpu * 3} GiB, 20 GB disk`);
                 }
-                state = { ...state, accountId, providerName: o.providerName, mode: s.mode, workerName: config.name };
+                state = {
+                    ...state,
+                    accountId,
+                    providerName: o.providerName,
+                    mode: s.git ? "git" : s.mode,
+                    workerName: config.name,
+                };
                 await writeState(paths, state);
                 break;
             }
@@ -253,6 +339,10 @@ export async function runInit(ctx, o, steps) {
                     ui.step("control token: reusing .cf-orbs/control-token");
                 break;
             case "amp-token":
+                // No interactive name question here: say so if the name is a fallback, not given
+                if (s.source !== "prompt" &&
+                    (o.providerNameSource === "config" || o.providerNameSource === "default"))
+                    ui.warn(`provider name ${providerName} was not given explicitly; it must match the name in Amp Settings → Orbs (pass --provider-name <name> if it differs)`);
                 if (s.source === "env")
                     ampToken = checkAmpToken(ctx, (ctx.env.AMP_ORB_PROVIDER_TOKEN ?? "").trim());
                 else if (s.source === "file") {
@@ -263,9 +353,16 @@ export async function runInit(ctx, o, steps) {
                 }
                 else if (s.source === "prompt") {
                     // Keep only a secret that exists: external mode deleted it from the Worker.
-                    const keep = Boolean(state.url) && prevMode === "cloudflare";
-                    const t = await askHidden(`Amp provider token (aop_live_…, not shown)${keep ? "; Enter keeps the current one" : ""}: `);
-                    if (t === "" && keep)
+                    const keep = Boolean(state.url) && (prevMode === "cloudflare" || prevMode === "git");
+                    const enter = o.noDeploy
+                        ? "; Enter skips (set it later)"
+                        : keep
+                            ? "; Enter keeps the current one"
+                            : "";
+                    const t = await askHidden(`Amp provider token (aop_live_…, not shown; create or copy it in Amp Settings → Orbs → Add Provider)${enter}: `);
+                    if (t === "" && o.noDeploy)
+                        ui.step("amp token: not given; set it later (see the steps below)");
+                    else if (t === "" && keep)
                         ui.step("amp token: keeping the current Worker secret");
                     else
                         ampToken = checkAmpToken(ctx, t);
@@ -320,8 +417,69 @@ export async function runInit(ctx, o, steps) {
                 lastStatus = expectOk(await api.get("/v1/status"), "status check");
                 ui.step("health: /v1/status ok (control token accepted)");
                 if (config)
-                    await startPrewarm(ctx, api, config);
+                    prewarmStarted = (await startPrewarm(ctx, api, config)).started;
+                prewarmAt = ctx.now();
                 break;
+            case "selftest": {
+                if (o.noDeploy) {
+                    // Workers Builds deploys later, so this run started no prewarm. Report an earlier run if the
+                    // Worker has one (a rerun after a build); else skip.
+                    const last = await lastPrewarm(url, controlToken, ctx);
+                    if (last && Number(last.pending) === 0 && Number(last.count) > 0) {
+                        // an old failed run does not fail init: the next build may fix the image
+                        if (Number(last.ok) > 0)
+                            reportSelftest(ui, last);
+                        else
+                            ui.warn("self-test: the last prewarm run started no instance; check the build, then cf-orbs status");
+                    }
+                    else
+                        ui.step("self-test: skipped (Workers Builds deploys later; after the first build, cf-orbs status shows the prewarm result)");
+                    break;
+                }
+                // The prewarm run starts throwaway orbs from the new image. If one becomes ready, the image,
+                // the registry and the container runtime work. No Amp thread and no debug route needed.
+                if (prewarmStarted === 0) {
+                    ui.step('self-test: skipped (no prewarm instance was started; set "prewarm" above 0 to enable)');
+                    break;
+                }
+                const until = ctx.now() + SELFTEST_WAIT_MS;
+                let view = {};
+                for (;;) {
+                    const r = await api.get("/v1/warm");
+                    const last = warmLast(r.body);
+                    // Ignore the result of an earlier run.
+                    if (typeof last.at === "string" && Date.parse(last.at) >= prewarmAt - 10_000) {
+                        view = last;
+                        if (Number(last.pending) === 0)
+                            break;
+                    }
+                    if (ctx.now() >= until)
+                        break;
+                    await ctx.sleep(3_000);
+                }
+                if (Number(view.count) > 0 && Number(view.pending) === 0)
+                    reportSelftest(ui, view);
+                else
+                    ui.warn("self-test: still running after 3 min; the first start on a new host pulls the image. Check cf-orbs status");
+                break;
+            }
+            case "plan-check": {
+                // Before the image build: a Free account fails here in seconds, not after a 1.8 GB push.
+                // Best effort: only a clear plan or login error stops init; any other error is a warning.
+                const r = await makeWrangler(ctx.run, { accountId }).run(["containers", "list", "--json"], {
+                    timeoutMs: 60_000,
+                });
+                if (r.code === 0) {
+                    ui.step("plan: Containers are available on this account");
+                    break;
+                }
+                const out = `${r.stdout}\n${r.stderr}`;
+                const kind = classifyDeployFailure(out);
+                if (kind === "paid" || kind === "auth")
+                    throw deployFailureError(kind, out);
+                ui.warn(`plan check skipped (wrangler containers list failed: ${lastErrorLine(out)})`);
+                break;
+            }
             case "start-provider": {
                 const r = await api.post("/v1/provider/start");
                 if (r.status === 404 || r.status === 405) {
@@ -365,6 +523,52 @@ export async function runInit(ctx, o, steps) {
                 }
                 break;
             }
+            case "git-files": {
+                if (!config)
+                    throw new Error("init plan bug: git-files before scaffold");
+                const missing = missingDockerfiles(paths, config);
+                if (missing.length > 0)
+                    throw new CliError(`image Dockerfile missing: ${missing.join(", ")}`, "create it, or remove its key from images in cf-orbs.config.jsonc");
+                await writeWranglerConfig(paths, config, accountId);
+                ui.step("git: wrote .cf-orbs/wrangler.jsonc (Workers Builds deploys with it)");
+                if (!existsSync(paths.packageJson)) {
+                    await writeFile(paths.packageJson, gitPackageJson(config.name, WRANGLER_PIN));
+                    ui.step(`git: wrote package.json (wrangler ${WRANGLER_PIN} for Workers Builds)`);
+                }
+                await writeLockfile(ctx);
+                repoExisted = await gitCommitNew(ctx, ampToken);
+                break;
+            }
+            case "git-secrets": {
+                if (!config || !controlToken)
+                    throw new Error("init plan bug: git-secrets before scaffold");
+                const secrets = { CONTROL_TOKEN: controlToken };
+                if (ampToken)
+                    secrets.AMP_ORB_PROVIDER_TOKEN = ampToken;
+                await putSecrets(ctx, config.name, accountId, secrets);
+                url = subdomain ? `https://${config.name}.${subdomain}.workers.dev` : state.url;
+                if (!url)
+                    ui.warn("Failed: could not read the account's workers.dev subdomain, so state.json has no URL — fix: after the first build, pass --url https://<name>.<subdomain>.workers.dev to status and doctor");
+                state = {
+                    ...state,
+                    url,
+                    accountId,
+                    mode: "git",
+                    workerName: config.name,
+                    cliVersion: await cliVersion(),
+                };
+                await writeState(paths, state);
+                break;
+            }
+            case "git-next":
+                git = gitNext({
+                    worker: config?.name ?? "cf-orbs",
+                    repoExisted,
+                    ampTokenGiven: Boolean(ampToken),
+                });
+                for (const l of git.lines)
+                    ui.out(l);
+                break;
             case "print-external-env":
                 ui.out("External provider mode. On an always-on host with the amp CLI, run:");
                 ui.out("  export AMP_ORB_PROVIDER_TOKEN=<your aop_live_ token>");
@@ -379,7 +583,123 @@ export async function runInit(ctx, o, steps) {
                 break;
         }
     }
-    return { url, command, providerName };
+    return { url, command, providerName, ...(git ? { git } : {}) };
+}
+/** Workers Builds settings for the dashboard (Settings → Builds → Connect), as tested on 2026-11-02. */
+export const GIT_PATH_FILTERS = ["image/**", ".cf-orbs/**", "cf-orbs.config.jsonc", "package*.json"];
+/** The next steps init --no-deploy prints. Pure. */
+export function gitNext(o) {
+    const settings = {
+        worker: o.worker,
+        branch: "main",
+        buildCommand: "",
+        deployCommand: GIT_DEPLOY_COMMAND,
+        rootDirectory: "/",
+        previews: false,
+        apiToken: "default build token",
+        buildWatchPaths: GIT_PATH_FILTERS,
+    };
+    const push = o.repoExisted
+        ? [
+            "1. Commit these files, then push the repo to GitHub or GitLab:",
+            "     git add -A && git commit -m 'cf-orbs init'",
+            "     git push",
+        ]
+        : [
+            "1. Make an empty repo on GitHub or GitLab. Push this directory to it:",
+            "     git remote add origin <repo URL>",
+            "     git push -u origin main",
+        ];
+    const lines = [
+        "",
+        "Next steps. Workers Builds builds the images in your Cloudflare account; this machine needs no Docker.",
+        ...push,
+        `2. Connect the repo: Cloudflare dashboard → Workers & Pages → ${o.worker} → Settings → Builds → Connect.`,
+        "     Repository:         the repo from step 1",
+        `     Branch:             ${settings.branch}${o.repoExisted ? " (the branch you push)" : ""}`,
+        "     Build command:      (leave empty)",
+        `     Deploy command:     ${settings.deployCommand}`,
+        `     Root directory:     ${settings.rootDirectory}`,
+        "     Previews (builds for non-production branches): off",
+        "     API token:          the default build token",
+        `     Build watch paths:  include ${settings.buildWatchPaths.join(", ")}`,
+        "   If no build starts, push a commit. Measured: first build 10.6 min, plus 2-4 min in the queue.",
+        "3. After the first build: cf-orbs status",
+        "   The 5-min cron starts the provider. The first spawn on each host pulls the image (40-50 s).",
+        ...(o.ampTokenGiven
+            ? []
+            : [
+                "4. No Amp token given. If the Worker has none yet, set it with:",
+                "     cf-orbs init --no-deploy --token-file <file>   (no build needed)",
+            ]),
+        "Upgrades: edit image/Dockerfile or cf-orbs.config.jsonc (or cf-orbs upgrade --digest sha256:<hex> --no-deploy), commit, push.",
+        "Docs: https://github.com/meirdick/cf-orbs/blob/main/docs/install-workers-builds.md",
+        "Then try it (spends Amp credits):",
+    ];
+    return { settings, lines };
+}
+/** package-lock.json for npm clean-install in Workers Builds. A failure is one warning. */
+async function writeLockfile(ctx) {
+    const { paths, ui } = ctx;
+    if (existsSync(join(paths.dir, "package-lock.json")))
+        return;
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const r = await ctx.run(npm, ["install", "--package-lock-only", "--ignore-scripts", "--no-audit", "--no-fund"], {
+        cwd: paths.dir,
+        timeoutMs: 180_000,
+    });
+    if (r.code === 0)
+        ui.step("git: wrote package-lock.json");
+    else
+        ui.warn(`Failed: could not write package-lock.json (${lastErrorLine(`${r.stdout}\n${r.stderr}`)}) — fix: run npm install --package-lock-only in ${paths.dir}, then commit it`);
+}
+/**
+ * git init + first commit when dir is in no git work tree. Returns true when a repo was there already.
+ * Checks the staged files for tokens before the commit.
+ */
+async function gitCommitNew(ctx, ampToken) {
+    const { paths, ui } = ctx;
+    const g = (args) => ctx.run("git", ["-C", paths.dir, ...args], { timeoutMs: 60_000 });
+    if ((await g(["rev-parse", "--is-inside-work-tree"])).code === 0) {
+        ui.step("git: this directory is in a git repo already; commit and push the changes yourself");
+        return true;
+    }
+    const init = await g(["init", "-b", "main"]);
+    if (init.code !== 0) {
+        ui.warn(`Failed: git init did not run (${lastErrorLine(`${init.stdout}\n${init.stderr}`)}) — fix: install git, then run git init -b main && git add -A && git commit -m 'cf-orbs init' in ${paths.dir}`);
+        return false;
+    }
+    await g(["add", "-A"]);
+    const ct = await readControlToken(paths);
+    const staged = (await gitTrackedFiles(ctx.run, paths.dir)) ?? [];
+    const hits = await filesWithSecrets(paths.dir, staged, [
+        ...(ct ? [ct] : []),
+        ...(ampToken ? [ampToken] : []),
+    ]);
+    if (hits.length > 0) {
+        await g(["reset", "-q"]);
+        throw new CliError(`a token is in file(s) staged for the first commit: ${hits.join(", ")}`, "remove the token from those files (or add them to .gitignore), then rerun cf-orbs init --no-deploy");
+    }
+    const c = await g(["commit", "-q", "-m", "cf-orbs init (Workers Builds)"]);
+    if (c.code === 0)
+        ui.step(`git: made a repo on branch main with a first commit (${staged.length} files)`);
+    else
+        ui.warn(`Failed: git commit did not run (${lastErrorLine(`${c.stdout}\n${c.stderr}`)}) — fix: set git config user.name and user.email, then git commit -m 'cf-orbs init' in ${paths.dir}`);
+    return false;
+}
+/** wrangler secret bulk from a 0600 temp file. Creates the Worker (a placeholder) when it does not exist. */
+async function putSecrets(ctx, name, accountId, secrets) {
+    const w = makeWrangler(ctx.run, { configPath: ctx.paths.wrangler, accountId });
+    const r = await withSecretsFile(secrets, (file) => w.run(["secret", "bulk", file], { env: { CI: "1" }, timeoutMs: 120_000 }));
+    const out = `${r.stdout}\n${r.stderr}`;
+    if (r.code !== 0 || /Secrets failed to upload|No content found/i.test(out)) {
+        throw classifyDeployFailure(out) === "auth"
+            ? new CliError("wrangler is not logged in or the token lacks permissions", "run npx wrangler login, then rerun")
+            : new CliError(`wrangler secret bulk failed: ${lastErrorLine(out)}`, "check npx wrangler whoami, then rerun cf-orbs init --no-deploy");
+    }
+    if (/Creating new Worker/i.test(out))
+        ctx.ui.step(`worker: created ${name} (a placeholder until the first build)`);
+    ctx.ui.step(`secrets: set ${Object.keys(secrets).join(" and ")} on Worker ${name}`);
 }
 /**
  * Read the provider log tail from /v1/status. Only lines since the last container start count.
@@ -425,16 +745,22 @@ export function parseVcpuFlag(v) {
         throw new CliError(`--vcpu must be 1, 2, 3 or 4, got ${JSON.stringify(v)}`, "pass --vcpu 4 (default, 12 GiB) or --vcpu 2 (6 GiB, about half the cost)");
     return Number(v);
 }
+const WORKER_NAME_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
 export function initOptions(ctx, existing) {
     const modeFlag = flagString(ctx.args, "provider");
     if (modeFlag !== undefined && modeFlag !== "cloudflare" && modeFlag !== "external") {
         throw new CliError(`--provider must be cloudflare or external, got ${modeFlag}`, "pass --provider cloudflare (default) or --provider external");
     }
+    const name = flagString(ctx.args, "name");
+    if (name !== undefined && !WORKER_NAME_RE.test(name))
+        throw new CliError(`--name ${JSON.stringify(name)} is not a valid Worker name (a-z, 0-9, -; max 63)`, "pass --name cf-orbs or another lowercase name");
     const explicitName = flagString(ctx.args, "provider-name") ?? ctx.env.AMP_ORB_PROVIDER_NAME ?? existing?.providerName;
     return {
         providerNameExplicit: explicitName !== undefined,
         subdomain: flagString(ctx.args, "subdomain") ?? ctx.env.CF_ORBS_SUBDOMAIN ?? undefined,
         vcpu: parseVcpuFlag(flagString(ctx.args, "vcpu")),
+        name,
+        noDeploy: flagBool(ctx.args, "no-deploy"),
         mode: modeFlag ?? existing?.providerHost ?? "cloudflare",
         nonInteractive: flagBool(ctx.args, "non-interactive") || Boolean(ctx.env.CI),
         tokenFile: flagString(ctx.args, "token-file"),
@@ -444,6 +770,15 @@ export function initOptions(ctx, existing) {
             existing?.providerName ??
             existing?.name ??
             "cf-orbs",
+        providerNameSource: flagString(ctx.args, "provider-name") !== undefined
+            ? "flag"
+            : ctx.env.AMP_ORB_PROVIDER_NAME !== undefined
+                ? "env"
+                : existing?.providerName !== undefined
+                    ? "saved"
+                    : existing?.name !== undefined
+                        ? "config"
+                        : "default",
     };
 }
 export async function initCommand(ctx) {
@@ -455,11 +790,23 @@ export async function initCommand(ctx) {
     }
     existing.providerName = (await readState(paths)).providerName;
     const o = initOptions(ctx, existing);
-    ui.step(`cf-orbs init in ${paths.dir} (provider host: ${o.mode})`);
-    const probes = await gatherProbes(ctx);
+    ui.step(`cf-orbs init in ${paths.dir} (provider host: ${o.mode}${o.noDeploy ? "; --no-deploy: Workers Builds deploys" : ""})`);
+    const probes = await gatherProbes(ctx, o);
     const steps = plan(o, probes);
     const r = await runInit(ctx, o, steps);
-    ui.result({ ok: true, url: r.url, mode: o.mode, providerName: r.providerName, next: r.command });
+    if (r.git)
+        ui.result({
+            ok: true,
+            mode: "git",
+            providerHost: o.mode,
+            url: r.url,
+            providerName: r.providerName,
+            settings: r.git.settings,
+            steps: r.git.lines.filter((l) => l !== ""),
+            next: r.command,
+        });
+    else
+        ui.result({ ok: true, url: r.url, mode: o.mode, providerName: r.providerName, next: r.command });
     if (r.command)
         ui.out(r.command);
     return 0;

package/dist/commands/upgrade.js

@@ -8,7 +8,7 @@ import { makeApi } from "../api.js";
 import { flagBool, flagString } from "../args.js";
 import { AMP_DEFAULT_IMAGE_REPO, CONFIG_FILE, loadConfig, parseConfigText, setTopLevelJsonc, } from "../config.js";
 import { CliError } from "../errors.js";
-import { readState, requireControlToken } from "../project.js";
+import { materialize, readState, requireControlToken, writeWranglerConfig } from "../project.js";
 import { deployProject, restartProviderAfterDeploy, startPrewarm } from "./deploy.js";
 import { AMP_CACHE_STEPS } from "./snapshots.js";
 const DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
@@ -73,7 +73,16 @@ export async function upgradeCommand(ctx) {
     ui.warn("paused orbs may not restore after upgrade (their snapshots name image key orb, which is now the new image); push or commit their work first");
     ui.warn("awake orbs keep the old Worker code until they pause; keep the old key until their snapshots expire (30 days)");
     if (flagBool(ctx.args, "no-deploy")) {
-        ui.out("Run cf-orbs deploy to build and push the new image.");
+        const state = await readState(paths);
+        if (state.mode === "git") {
+            // Workers Builds deploys the committed wrangler.jsonc, so write it now with the new images entry
+            await materialize(paths, { templates: ctx.templates, git: true });
+            await writeWranglerConfig(paths, await loadConfig(paths.config), state.accountId);
+            ui.step("upgrade: wrote .cf-orbs/wrangler.jsonc");
+        }
+        ui.out(state.mode === "git"
+            ? "Commit and push: Workers Builds builds and deploys the new image."
+            : "Run cf-orbs deploy to build and push the new image.");
         for (const l of AMP_CACHE_STEPS)
             ui.out(l);
         ui.result({ ok: true, changed: true, deployed: false, oldKey: p.oldKey, nextSteps: AMP_CACHE_STEPS });

package/dist/config.js

@@ -307,7 +307,7 @@ export function validateInstance(v) {
 export function instanceMemoryMib(i) {
     if (typeof i === "object")
         return i.memoryMib;
-    return { lite: 256, "standard-1": 4096, "standard-2": 6144, "standard-3": 8192, "standard-4": 12288 }[i];
+    return { "standard-1": 4096, "standard-2": 6144, "standard-3": 8192, "standard-4": 12288 }[i];
 }
 /** fastTmpfsGb: 0-8, and at most the orb memory minus 3 GiB. Same rule as worker validateFastTmpfs. */
 export function validateFastTmpfs(v, instance) {