@mcpcloud/cli 0.22.3 → 0.23.0-next-20260916020438

package/README.md

@@ -510,6 +510,11 @@ _Generated from the live command tree by `bun run docs:readme` — do not edit b
 | `mcp servers env list <server>` | List a server's env bindings (metadata only; values are never returned). |
 | `mcp servers env set <server> <bindingName> [value]` | Create or replace an env binding's value. Schedules a Cloudflare-runtime push when the server has an active deployment. |
 | `mcp servers env unset <server> <bindingName>` | Remove an env binding. Idempotent — succeeds even if the binding is already gone. |
+| `mcp servers environments` | Manage deployment lanes (dev, staging, …) — each a separate worker, hostname, config overlay and credential scope. |
+| `mcp servers environments get <server> <name>` | Show one environment: overlay, hostname, credentials, lane deployment. |
+| `mcp servers environments list <server>` | List a server's environments with their hostname, upstream, access mode and active deployment. |
+| `mcp servers environments remove <server> <name>` | Delete an environment. Requires --confirm "<exact name>". Retire its live deployment first. |
+| `mcp servers environments set <server> <name>` | Create or update an environment. Only the flags you pass are sent; everything else keeps its value. |
 | `mcp servers export <server>` | Export a self-host bundle (Dockerfile + node entry + config) for a server |
 | `mcp servers generate <server>` | Generate the server's TypeScript bundle (the exact code `deploy` ships) and optionally write it to disk — a dry-run for the codegen path. Wraps POST /api/v1/server/generate. |
 | `mcp servers get <server>` | Get details for a single server (accepts id, name, or slug) |
@@ -523,6 +528,7 @@ _Generated from the live command tree by `bun run docs:readme` — do not edit b
 | `mcp servers logs <server>` | Show recent deployment events for a server's latest deployment |
 | `mcp servers oauth-connections <server>` | List OAuth provider connections bound to this server |
 | `mcp servers pause <server>` | Pause the server's latest active deployment (traffic stops; worker is preserved) |
+| `mcp servers promote <server>` | Ship the bytes a lane is serving into another lane. Config, secrets and member credentials stay with the target. |
 | `mcp servers prompts` | Author the prompts a client reads as this server’s workflows (list / set / rm) |
 | `mcp servers prompts list <server>` | List the prompts authored on a server. |
 | `mcp servers prompts rm <server> <name>` | Remove a prompt by name. |
@@ -534,6 +540,7 @@ _Generated from the live command tree by `bun run docs:readme` — do not edit b
 | `mcp servers resources rm <server> <uri>` | Remove a resource by URI. |
 | `mcp servers resources set <server> <uri>` | Create or replace a resource by URI. Re-running with the same URI updates it. |
 | `mcp servers resume <server>` | Resume the server's paused deployment (flips dispatch routing back on; only platformWorker deployments support instant resume) |
+| `mcp servers retire <server>` | Tear down the deployment in one non-production lane. Requires --confirm "<exact environment name>". |
 | `mcp servers score <server>` | Score whether an agent handed this catalog picks the right tool (starts a run, or reads the last one) |
 | `mcp servers shape <server>` | Propose task-shaped tools over this server’s endpoints (starts a run, or reads the last one) |
 | `mcp servers test-runs` | Inspect and trigger server sandbox test runs |

package/dist/index.js

@@ -6362,6 +6362,329 @@ async function confirmUnset(bindingName, serverId) {
   return ch === "y";
 }
 
+// src/lib/validate-choice.ts
+function validateChoice(name, value, allowed) {
+  const trimmed = value.trim();
+  const match = allowed.find((option) => option.toLowerCase() === trimmed.toLowerCase());
+  if (!match) {
+    throw new Error(`Invalid --${name}: ${value}. Expected one of: ${allowed.join(", ")}.`);
+  }
+  return match;
+}
+
+// src/commands/servers-environments-shared.ts
+var PRODUCTION_ENVIRONMENT = "production";
+var ENVIRONMENTS_PATH = "/api/v1/server/environments";
+var PROMOTE_PATH = "/api/v1/server/promote";
+var RETIRE_PATH = "/api/v1/server/retire";
+var ENVIRONMENT_ACCESS_MODES = [
+  "privateOrg",
+  "unlisted",
+  "public"
+];
+async function resolveServerScope2(serverRef, opts) {
+  const orgId = await resolveOrgId(opts.org);
+  const projectId = await resolveOptionalProjectId(opts.project, orgId);
+  const serverId = await resolveServerId(serverRef, orgId, projectId);
+  return { orgId, projectId, serverId };
+}
+var TIER_LABELS = {
+  free: "Free",
+  starter: "Starter",
+  pro: "Pro",
+  max: "Max",
+  enterprise: "Enterprise"
+};
+function describeUpgradePath(details) {
+  if (!details)
+    return null;
+  const billing = `${getAppUrl()}/settings/billing`;
+  const tier = details["requiredTierKey"];
+  if (typeof tier === "string" && tier.length > 0) {
+    return `Upgrade to ${TIER_LABELS[tier] ?? tier} or higher: ${billing}`;
+  }
+  if (typeof details["max"] === "number") {
+    return `Remove a lane, or raise the cap by upgrading: ${billing}`;
+  }
+  return null;
+}
+function reportEnvironmentApiError(action, err) {
+  if (err instanceof McpCloudApiError) {
+    printError(`${action} failed (HTTP ${err.status}): ${err.error.message}`);
+    const upgrade = describeUpgradePath(err.error.details);
+    if (upgrade)
+      printInfo(`  ${c.dim("→")} ${upgrade}`);
+    if (err.error.docsUrl)
+      printInfo(`  ${c.dim("docs:")} ${err.error.docsUrl}`);
+  } else {
+    printError(`${action} failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  throw new CliExitError(1);
+}
+var DEPLOY_CHANNELS = ["stable", "beta"];
+function resolveDeployEnvironment(args) {
+  if (args.env !== undefined && args.channel !== undefined) {
+    throw new Error("--env and --channel are mutually exclusive. --channel beta is the old spelling of --env beta.");
+  }
+  if (args.channel !== undefined) {
+    const channel = validateChoice("channel", args.channel, DEPLOY_CHANNELS);
+    return channel === "beta" ? "beta" : undefined;
+  }
+  if (args.env === undefined)
+    return;
+  const env = args.env.trim();
+  if (env.length === 0) {
+    throw new Error("--env needs an environment name.");
+  }
+  return env.toLowerCase() === PRODUCTION_ENVIRONMENT ? undefined : env;
+}
+function describeActiveDeployment(env) {
+  const dep = env.activeDeployment;
+  if (!dep)
+    return "—";
+  return `${dep.status} ${dep.version} (${dep.healthStatus})`;
+}
+function describeUpstream(env) {
+  return env.upstreamBaseUrl ?? "(spec default)";
+}
+var NO_FALLBACK_SENTENCE = "Credentials never fall back between environments; a lane with no secrets deploys credential-less";
+function printEnvironmentDetail(env) {
+  printKeyValue({
+    name: env.name,
+    "display name": env.displayName ?? "—",
+    hostname: env.hostname ?? "—",
+    upstream: describeUpstream(env),
+    "key header": env.upstreamApiKeyHeader ?? "—",
+    "key prefix": env.upstreamApiKeyPrefix ?? "—",
+    "custom headers": env.upstreamCustomHeaders ?? "—",
+    "plain bindings": env.additionalPlainTextBindings ?? "—",
+    "access mode": env.defaultAccessMode,
+    credentials: env.credentialState,
+    "git branch": env.boundGitBranch ?? "—",
+    "auto-deploy on push": env.autoDeployOnPush ? "yes" : "no",
+    "active deployment": describeActiveDeployment(env),
+    "runtime version": env.activeDeployment?.runtimeVersion ?? "—",
+    updated: formatDate(env.updatedAt)
+  });
+}
+
+// src/commands/servers-environments-write.ts
+function registerServerEnvironmentWriteCommands(environments) {
+  environments.command("set <server> <name>").description("Create or update an environment. Only the flags you pass are sent; everything else keeps its value.").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").option("--display-name <label>", "Human label for the lane (UI only)").option("--upstream-base-url <url>", "Upstream API base URL this lane points at (omit to use the spec default)").option("--upstream-api-key-header <header>", "Header the lane injects its upstream key on (default: Authorization)").option("--upstream-api-key-prefix <prefix>", `Prefix for the lane's upstream key value (e.g. "Bearer ")`).option("--access-mode <mode>", `Default access mode for deploys into this lane: ${ENVIRONMENT_ACCESS_MODES.join(" | ")} (default: privateOrg)`).addHelpText("after", [
+    "",
+    `${NO_FALLBACK_SENTENCE}.`,
+    "Set a lane's own upstream key with `mcp servers env set <server> <binding>`;",
+    "until it has one, `environments list` shows Creds = none for that lane.",
+    "",
+    "Names are lowercase letters and digits, 2–16 characters, starting with a",
+    "letter. production, prod, stable, live and main are reserved.",
+    "",
+    "Examples:",
+    "  $ mcp servers environments set srv_123 staging \\",
+    "       --upstream-base-url https://staging.api.example.com",
+    "  $ mcp servers envs set srv_123 dev --access-mode unlisted"
+  ].join(`
+`)).action(runAction(async (serverRef, name, opts) => {
+    const accessMode = opts.accessMode ? validateChoice("access-mode", opts.accessMode, ENVIRONMENT_ACCESS_MODES) : undefined;
+    const { orgId, serverId } = await resolveServerScope2(serverRef, opts);
+    const body = {
+      organizationId: orgId,
+      serverId,
+      name,
+      ...opts.displayName !== undefined ? { displayName: opts.displayName } : {},
+      ...opts.upstreamBaseUrl !== undefined ? { upstreamBaseUrl: opts.upstreamBaseUrl } : {},
+      ...opts.upstreamApiKeyHeader !== undefined ? { upstreamApiKeyHeader: opts.upstreamApiKeyHeader } : {},
+      ...opts.upstreamApiKeyPrefix !== undefined ? { upstreamApiKeyPrefix: opts.upstreamApiKeyPrefix } : {},
+      ...accessMode ? { defaultAccessMode: accessMode } : {}
+    };
+    let data;
+    try {
+      data = await api.put(ENVIRONMENTS_PATH, body);
+    } catch (err) {
+      reportEnvironmentApiError("Saving the environment", err);
+    }
+    if (isJsonMode()) {
+      printJson({ serverId, environment: data.environment });
+      return;
+    }
+    printSuccess(`Environment ${c.bold(data.environment.name)} saved on ${c.bold(serverId)}.`);
+    printEnvironmentDetail(data.environment);
+    if (data.environment.credentialState === "none") {
+      printInfo(`  ${c.dim(`${NO_FALLBACK_SENTENCE}.`)}`);
+    }
+  }));
+  environments.command("remove <server> <name>").description('Delete an environment. Requires --confirm "<exact name>". Retire its live deployment first.').option("--confirm <name>", "The exact environment name, typed to confirm the destructive action").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").addHelpText("after", [
+    "",
+    "The API refuses while a deployment is live in the lane — run",
+    "`mcp servers retire <server> --env <name> --confirm <name>` first.",
+    "",
+    "Examples:",
+    "  $ mcp servers environments remove srv_123 dev --confirm dev"
+  ].join(`
+`)).action(runAction(async (serverRef, name, opts) => {
+    assertConfirmMatches({
+      entityKind: "environment",
+      entityName: name,
+      confirm: opts.confirm
+    });
+    const { orgId, serverId } = await resolveServerScope2(serverRef, opts);
+    let data;
+    try {
+      data = await api.delete(ENVIRONMENTS_PATH, { organizationId: orgId, serverId, name });
+    } catch (err) {
+      reportEnvironmentApiError("Removing the environment", err);
+    }
+    if (isJsonMode()) {
+      printJson({ serverId, name, removed: data.removed });
+      return;
+    }
+    printSuccess(`Removed environment ${c.bold(name)} from ${c.bold(serverId)}.`);
+  }));
+}
+
+// src/commands/servers-environments.ts
+function describeLimit(max, used) {
+  if (max === null)
+    return `${used} environment(s) — no cap on this plan.`;
+  return `${used} of ${max} environment(s) used on this plan.`;
+}
+async function loadEnvironments(serverRef, opts, action) {
+  const { orgId, serverId } = await resolveServerScope2(serverRef, opts);
+  try {
+    const data = await api.get(ENVIRONMENTS_PATH, {
+      organizationId: orgId,
+      serverId
+    });
+    return { serverId, data };
+  } catch (err) {
+    reportEnvironmentApiError(action, err);
+  }
+}
+function registerServerEnvironmentCommands(servers) {
+  const environments = servers.command("environments").alias("envs").description("Manage deployment lanes (dev, staging, …) — each a separate worker, hostname, config overlay and credential scope.");
+  environments.command("list <server>").description("List a server's environments with their hostname, upstream, access mode and active deployment.").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").addHelpText("after", [
+    "",
+    "production is implicit and always present — it is what an ordinary",
+    "deploy targets. Every other row is a lane you created.",
+    "",
+    "Examples:",
+    "  $ mcp servers environments list srv_123",
+    "  $ mcp --json servers envs list srv_123 | jq '.limit'"
+  ].join(`
+`)).action(runAction(async (serverRef, opts) => {
+    const { serverId, data } = await loadEnvironments(serverRef, opts, "Listing environments");
+    printList(data.environments.map((env) => ({
+      name: env.name,
+      hostname: env.hostname ?? "—",
+      upstream: describeUpstream(env),
+      access: env.defaultAccessMode,
+      deployment: describeActiveDeployment(env),
+      credentials: env.credentialState
+    })), [
+      { key: "name", label: "Name", width: 14 },
+      { key: "hostname", label: "Hostname", width: 34 },
+      { key: "upstream", label: "Upstream", width: 30 },
+      { key: "access", label: "Access", width: 12 },
+      { key: "deployment", label: "Active Deployment", width: 26 },
+      { key: "credentials", label: "Creds", width: 8 }
+    ], { serverId, environments: data.environments, limit: data.limit });
+    if (!isJsonMode() && getListFormat() === "table") {
+      printInfo(c.dim(`  ${describeLimit(data.limit.max, data.limit.used)}`));
+    }
+  }));
+  environments.command("get <server> <name>").description("Show one environment: overlay, hostname, credentials, lane deployment.").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").action(runAction(async (serverRef, name, opts) => {
+    const { serverId, data } = await loadEnvironments(serverRef, opts, "Reading the environment");
+    const env = data.environments.find((row) => row.name === name);
+    if (!env) {
+      reportEnvironmentApiError("Reading the environment", new Error(`No environment named "${name}" on ${serverId}. Existing: ${data.environments.map((row) => row.name).join(", ") || "(none)"}.`));
+    }
+    if (isJsonMode()) {
+      printJson({ serverId, environment: env });
+      return;
+    }
+    printEnvironmentDetail(env);
+  }));
+  registerServerEnvironmentWriteCommands(environments);
+}
+
+// src/commands/servers-environments-promote.ts
+function registerServerPromoteCommands(servers) {
+  servers.command("promote <server>").description("Ship the bytes a lane is serving into another lane. Config, secrets and member credentials stay with the target.").requiredOption("--from <environment>", "Source environment (lane) name").option("--to <environment>", "Destination environment (lane) name", PRODUCTION_ENVIRONMENT).option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").addHelpText("after", [
+    "",
+    "Promote works between any two lanes — dev to staging, staging to",
+    "production, or production back into a lane to reset it. Only --from",
+    "equal to --to is refused.",
+    "",
+    "Examples:",
+    "  $ mcp servers promote srv_123 --from staging",
+    "  $ mcp servers promote srv_123 --from dev --to staging"
+  ].join(`
+`)).action(runAction(async (serverRef, opts) => {
+    if (opts.from === opts.to) {
+      reportEnvironmentApiError("Promote", new Error(`--from and --to are both "${opts.from}". Pick two different lanes.`));
+    }
+    const { orgId, serverId } = await resolveServerScope2(serverRef, opts);
+    if (!isJsonMode()) {
+      printStep(`Promoting ${c.bold(opts.from)} → ${c.bold(opts.to)} on ${c.bold(serverId)}…`);
+    }
+    let data;
+    try {
+      data = await api.post(PROMOTE_PATH, {
+        organizationId: orgId,
+        serverId,
+        from: opts.from,
+        to: opts.to
+      });
+    } catch (err) {
+      reportEnvironmentApiError("Promote", err);
+    }
+    if (isJsonMode()) {
+      printJson({
+        serverId,
+        from: opts.from,
+        to: opts.to,
+        deploymentId: data.deploymentId,
+        status: data.status
+      });
+      return;
+    }
+    printSuccess(`Promoted ${c.bold(opts.from)} → ${c.bold(opts.to)}: deployment ${c.bold(data.deploymentId)} (${data.status}).`);
+    printInfo(`  ${c.dim(`${opts.to} keeps its own upstream config and credentials — only the bytes moved.`)}`);
+  }));
+  servers.command("retire <server>").description('Tear down the deployment in one non-production lane. Requires --confirm "<exact environment name>".').requiredOption("--env <environment>", "Environment (lane) to retire").option("--confirm <name>", "The exact environment name, typed to confirm the destructive action").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").addHelpText("after", [
+    "",
+    "The lane row survives — retire removes the running worker and its",
+    "hostname so the lane can be redeployed later. Use",
+    "`mcp servers environments remove` to delete the lane itself.",
+    "",
+    "Examples:",
+    "  $ mcp servers retire srv_123 --env staging --confirm staging"
+  ].join(`
+`)).action(runAction(async (serverRef, opts) => {
+    assertConfirmMatches({
+      entityKind: "environment deployment",
+      entityName: opts.env,
+      confirm: opts.confirm
+    });
+    const { orgId, serverId } = await resolveServerScope2(serverRef, opts);
+    let data;
+    try {
+      data = await api.post(RETIRE_PATH, {
+        organizationId: orgId,
+        serverId,
+        environment: opts.env
+      });
+    } catch (err) {
+      reportEnvironmentApiError("Retire", err);
+    }
+    if (isJsonMode()) {
+      printJson({ serverId, environment: opts.env, retired: data.retired });
+      return;
+    }
+    printSuccess(`Retired the ${c.bold(opts.env)} deployment on ${c.bold(serverId)}.`);
+  }));
+}
+
 // src/commands/servers-sandbox-variables.ts
 function parseVariableAssignments(pairs) {
   return pairs.map((pair) => {
@@ -7038,6 +7361,16 @@ async function probeServerSurface(args) {
     reachable: true
   };
 }
+function printEnvironmentsBlock(environments) {
+  if (!environments || environments.length === 0)
+    return;
+  printInfo("");
+  printInfo("Environments");
+  for (const env of environments) {
+    printInfo(`  ${env.name.padEnd(14)} ${env.hostname ?? "—"}`);
+  }
+  printInfo("  (mcp servers environments list <server> for upstream, access and credentials)");
+}
 function registerServerGetCommand(servers) {
   servers.command("get <server>").description("Get details for a single server (accepts id, name, or slug)").option("--org <organizationId>", "Organization ID").option("--probe", "Also call the deployed endpoint and report what it actually serves, flagging anything the configuration promises that the endpoint does not").addHelpText("after", [
     "",
@@ -7088,6 +7421,7 @@ function registerServerGetCommand(servers) {
         observed: probe.reachable ? describeObservedSurface(probe.observed) : `unreachable — ${probe.message}`
       } : {}
     });
+    printEnvironmentsBlock(data.environments);
     if (probe && !probe.reachable) {
       printError(`Could not reach the endpoint: ${probe.message}`);
       throw new CliExitError(1);
@@ -7179,16 +7513,6 @@ function registerServerExportCommands(servers) {
   }));
 }
 
-// src/lib/validate-choice.ts
-function validateChoice(name, value, allowed) {
-  const trimmed = value.trim();
-  const match = allowed.find((option) => option.toLowerCase() === trimmed.toLowerCase());
-  if (!match) {
-    throw new Error(`Invalid --${name}: ${value}. Expected one of: ${allowed.join(", ")}.`);
-  }
-  return match;
-}
-
 // src/commands/servers-lifecycle.ts
 import { existsSync as existsSync6 } from "node:fs";
 import { isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
@@ -7367,7 +7691,7 @@ async function refreshDeploymentRow(args) {
   }
 }
 function registerServerLifecycleCommands(servers) {
-  servers.command("deploy <server>").description("Deploy a server's generated bundle to Cloudflare Workers (closes the spec → deploy loop)").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").option("--target <target>", `Deploy target: ${DEPLOY_TARGETS.join(" | ")}`, "workersDev").option("--access-mode <mode>", `Access mode: ${ACCESS_MODES.join(" | ")} (default: keep the server's current mode). A server with per-member upstream keys needs privateOrg or unlisted — public has no caller identity.`).option("--upstream-base-url <url>", "Upstream API base URL bound into the worker").option("--upstream-api-key <key>", "Upstream API key (encrypted at rest server-side)").option("--upstream-api-key-header <header>", "Header name to inject the upstream API key on (default: Authorization)").option("--upstream-api-key-prefix <prefix>", 'Prefix for the upstream API key value (e.g. "Bearer ")').option("--wait", "Tail deployment events until the deploy reaches a terminal state").option("--wait-timeout <seconds>", "Maximum seconds to wait for terminal state (default 300)", "300").addHelpText("after", [
+  servers.command("deploy <server>").description("Deploy a server's generated bundle to Cloudflare Workers (closes the spec → deploy loop)").option("--org <organizationId>", "Organization ID").option("--project <project>", "Project (id or name; defaults to the server's project)").option("--target <target>", `Deploy target: ${DEPLOY_TARGETS.join(" | ")}`, "workersDev").option("--access-mode <mode>", `Access mode: ${ACCESS_MODES.join(" | ")} (default: keep the server's current mode). A server with per-member upstream keys needs privateOrg or unlisted — public has no caller identity.`).option("--env <environment>", "Deploy into a named environment (lane) — its own worker, hostname and credentials. Omit, or pass production, for the default lane.").option("--channel <channel>", "Deprecated alias for --env: beta means --env beta, stable means production. Mutually exclusive with --env.").option("--upstream-base-url <url>", "Upstream API base URL bound into the worker").option("--upstream-api-key <key>", "Upstream API key (encrypted at rest server-side)").option("--upstream-api-key-header <header>", "Header name to inject the upstream API key on (default: Authorization)").option("--upstream-api-key-prefix <prefix>", 'Prefix for the upstream API key value (e.g. "Bearer ")').option("--wait", "Tail deployment events until the deploy reaches a terminal state").option("--wait-timeout <seconds>", "Maximum seconds to wait for terminal state (default 300)", "300").addHelpText("after", [
     "",
     "Examples:",
     "  # Pair with `mcp dev --spec` to ship the current spec:",
@@ -7378,10 +7702,14 @@ function registerServerLifecycleCommands(servers) {
     "       --upstream-api-key $UPSTREAM_TOKEN --wait",
     "",
     "  # Idempotent retry-safe deploy in CI:",
-    "  $ mcp --ci --idempotency-key $GITHUB_RUN_ID servers deploy srv_123 --wait"
+    "  $ mcp --ci --idempotency-key $GITHUB_RUN_ID servers deploy srv_123 --wait",
+    "",
+    "  # Deploy into a lane (its own hostname, config and credentials):",
+    "  $ mcp servers deploy srv_123 --env staging --wait"
   ].join(`
 `)).action(runAction(async (serverRef, opts) => {
     const target = validateChoice("target", opts.target, DEPLOY_TARGETS);
+    const environment = resolveDeployEnvironment(opts);
     const accessMode = opts.accessMode ? validateChoice("access-mode", opts.accessMode, ACCESS_MODES) : undefined;
     const orgId = await resolveOrgId(opts.org);
     let projectId = await resolveOptionalProjectId(opts.project, orgId);
@@ -7408,10 +7736,11 @@ function registerServerLifecycleCommands(servers) {
       serverId,
       target,
       ...accessMode ? { accessMode } : {},
+      ...environment ? { environment } : {},
       runtimeConfig
     };
     if (!isJsonMode()) {
-      printStep(`Deploying ${c.bold(serverId)} to ${c.cyan(target)}…`);
+      printStep(`Deploying ${c.bold(serverId)} to ${c.cyan(target)}${environment ? ` in ${c.cyan(environment)}` : ""}…`);
     }
     const data = await api.post("/api/v1/server/deploy", body);
     const dep = data.deployment;
@@ -7462,6 +7791,7 @@ function registerServerLifecycleCommands(servers) {
     printSuccess(`Deployment ${c.bold(dep.deploymentId)} created.`);
     printKeyValue({
       id: dep.deploymentId,
+      ...environment ? { environment } : {},
       ...final.deploymentUrl ? { url: final.deploymentUrl } : {},
       exposure: formatDeploymentExposure(final),
       "access mode": dep.accessMode,
@@ -8711,6 +9041,8 @@ function registerServerCommands(program) {
   registerServerResourceCommands(servers);
   registerServerShapingCommands(servers);
   registerServerEnvCommands(servers);
+  registerServerEnvironmentCommands(servers);
+  registerServerPromoteCommands(servers);
   registerServerSandboxVariableCommands(servers);
   registerServerGetCommand(servers);
   registerServerExportCommands(servers);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpcloud/cli",
-  "version": "0.22.3",
+  "version": "0.23.0-next-20260916020438",
   "description": "The official CLI for MCPCloud — manage projects, servers, skills, and API keys from the terminal",
   "type": "module",
   "bin": {