@clawops/cli 2.0.0 → 2.0.2

package/README.md

@@ -12,6 +12,83 @@ and Cursor drive them through typed MCP tools with explicit safety controls.
 
 ---
 
+## What's new in 2.0.1
+
+A patch release, and a large one: in 2.0.0 no cloud deploy succeeded by any path. Every item
+below is a fix or an addition in 2.0.1. The reasoning behind each one is in its commit message,
+and the decisions that came out of them are in [`docs/decisions/`](docs/decisions/).
+
+### Deploying to a cloud
+
+- `clawops plan` → `clawops apply` provisions a cloud stack and deploys OpenClaw onto it.
+- `clawops up` deploys to AWS, GCP and Azure, running the same path as `plan` → `apply`.
+- clawops installs the Pulumi CLI it needs into `~/.clawops/.pulumi-cli`, or uses a compatible
+  one already on `$PATH` ([ADR 0010](docs/decisions/0010-pulumi-cli-bootstrap.md)).
+- clawops creates and stores the passphrase its state backend requires
+  ([ADR 0011](docs/decisions/0011-state-passphrase.md)).
+- `clawops plan` takes `--ssh-cidr`, `--gateway-cidr` and `--publish-gateway`, and `apply`
+  passes them to the cloud firewall. `auto` resolves this machine's address.
+- `clawops plan` stops, and names the cause, when it cannot open the state backend.
+- `--instance-type` takes a clawops alias (`micro`–`gpu`) or a machine type your cloud names
+  itself, and the plan records the concrete type.
+- Deploys pin the account they were planned against: `gcp:project` on GCP,
+  `azure-native:subscriptionId` on Azure.
+
+### Checking the account before you spend
+
+- `clawops doctor --provider <cloud>` checks one cloud's credentials and account setup, with or
+  without a stack. `--instance-type` points the size check at the size you are deploying.
+- **AWS** — the account the credentials resolve to, the state bucket, and whether the instance
+  type is offered in the region.
+- **GCP** — the project, the APIs a deploy needs, and the state bucket.
+- **Azure** — the subscription, the resource providers, the VM size, and the azblob credentials
+  Pulumi authenticates with.
+- `clawops setup` runs the same checks and offers to fix what it safely can — enabling an API,
+  creating a state bucket with versioning on and public access blocked — naming the change
+  before making it.
+- A check clawops could not perform reports as a warning naming the error, rather than as a
+  pass or a failure.
+- Azure accepts your `az login`; a service principal is no longer required.
+
+### Naming, config and setup
+
+- clawops names the state backend after the account it is deploying into, instead of asking you
+  for a name or writing a placeholder
+  ([ADR 0012](docs/decisions/0012-state-bucket-naming.md)).
+- A name you type instead is checked against the rules of the cloud that has to accept it.
+- `clawops init` keeps the stacks already in your config.
+- `clawops init` generates an SSH key that clawops can read. If you ran `init` before this
+  release, `clawops doctor` will tell you whether yours is usable.
+- `gcloud config set project` is honoured.
+- The setup wizard writes model configuration that OpenClaw accepts, and installs the plugin
+  your chosen provider needs.
+- Amazon Bedrock works: the right transport, and an inference profile resolved against your
+  deployment region and recorded in the plan. Needs `bedrock:ListInferenceProfiles`.
+
+### While a deploy is running
+
+- `apply` waits for SSH, then waits for the gateway to answer, before reporting success.
+- `apply` reports progress as it goes instead of going quiet for minutes.
+- A deploy that times out prints what the host was doing, from its bootstrap log.
+- A host still installing Docker is treated as still booting rather than as a failed deploy.
+
+### Day-two commands
+
+- `clawops logs` reads from the gateway on AWS.
+- `doctor --stack`, `ssh`, `logs`, `gateway`, `config` and `agents` work against a freshly
+  deployed stack.
+- `clawops doctor` validates cloud credentials.
+- clawops tells a refused Docker socket from a missing container, and says which it found.
+- `clawops destroy` forgets the instance's host key, so redeploying onto an address the cloud
+  has recycled no longer fails verification.
+
+### Documentation
+
+- The GCP guide names the credential source clawops actually reads, and describes 2.0
+  firewall behaviour.
+- The smoke-test plan covers 2.0, and `pnpm test:cloud aws|gcp|azure` runs it against a real
+  deployment and destroys it afterwards.
+
 ## What's new in 2.0
 
 clawops 2.x targets **OpenClaw >= 2026.9.2**. The 1.x line continues for OpenClaw
@@ -26,9 +103,6 @@ Pin the tag in CI — `latest` moves to 2.x, so an unpinned pipeline will change
 [`CHANGELOG.md`](CHANGELOG.md) carries the full history; this section covers what changed
 about *how clawops behaves*.
 
-> **Release in progress.** 2.0 has not shipped yet. This section is written as the work
-> lands so the flows stay documented while they are being changed, not reconstructed after.
-
 ### Your deployment keeps its state
 
 OpenClaw 2.0 stores sessions, transcripts and credentials in SQLite. clawops mounted no
@@ -355,6 +429,9 @@ was invisible.
 whole internet, on the path most first-time users take. It offers your own IP as a `/32` now,
 and when that cannot be detected it offers no default and requires an answer.
 
+**`clawops plan` could not express any of it, and `apply` never passed any of it to Pulumi.**
+Both are fixed in 2.0.1 — see the list at the top of this section.
+
 ### The gateway port comes from the plan
 
 ```jsonc
@@ -377,7 +454,7 @@ Local deployments use `clawops up --gateway-port 9443`.
 
 ```mermaid
 flowchart TD
-    A["clawops doctor"] --> B["local: Node, Pulumi home,<br/>config, SSH key, credentials"]
+    A["clawops doctor"] --> B["local: Node, Pulumi CLI + home,<br/>config, SSH key, credentials"]
     B --> C{"--stack given?"}
     C -- no --> Z["report"]
     C -- yes --> D["container state"]
@@ -444,7 +521,8 @@ every agent on the host. Use `clawops gateway restart`, or stay on `@clawops/cli
 ## What clawops does
 
 - Provisions and tears down OpenClaw infrastructure on **AWS, GCP, Azure, and local VMs** using
-  the Pulumi Automation API (embedded — no `pulumi` binary required).
+  the Pulumi Automation API — you do not install Pulumi; clawops installs the CLI it needs into
+  `~/.clawops/.pulumi-cli` on first use.
 - Manages day-to-day operations: status, logs, SSH, tunnels, config, agents, gateway, backups.
 - Exposes every operation as a **typed MCP tool** so AI agents can drive ops safely.
 - Enforces a **plan → review → apply** discipline for cloud deployments.
@@ -515,6 +593,8 @@ and prints a direct dashboard URL:
 
 **Prerequisites:** Node.js ≥ 22, an SSH key, and either an SSH-reachable Linux/macOS host or a
 cloud account with CLI credentials configured (`aws configure`, `gcloud auth login`, or `az login`).
+You do not need Pulumi — the first cloud deployment installs the CLI clawops drives into
+`~/.clawops/.pulumi-cli` and says so while it does.
 
 For a full narrated walkthrough with example output, see [`docs/demo-script.md`](docs/demo-script.md).
 
@@ -547,10 +627,14 @@ clawops init --provider aws
 
 # Edit ~/.clawops/config.json — set stateUrl to your S3 bucket
 
-clawops plan --provider aws --stack default --out /tmp/plan.json
+clawops plan --provider aws --stack default --ssh-cidr auto --out /tmp/plan.json
 clawops apply /tmp/plan.json
 ```
 
+`--ssh-cidr auto` allows SSH from this machine's public IP, resolved while the plan is
+generated and written into it. Without it the plan allows no ingress at all and nothing —
+including clawops — will be able to connect.
+
 ---
 
 ## Connect an AI editor
@@ -626,12 +710,12 @@ clawops down --yes          # Destroy local-provider stack
 | Command | Description |
 |---|---|
 | `setup` | First-run wizard — guided LLM, integrations, and deploy-plan generation |
-| `init` | Register a stack in `~/.clawops/config.json` without provisioning |
+| `init` | Register a stack in `~/.clawops/config.json` without provisioning. Additive — existing stacks are kept; `--force` is needed only to overwrite one |
 | `up` | Provision or update stack (`--dry-run` for preview, `--gateway-port` for a non-default port) |
 | `down` | Destroy local-provider stack (requires `--yes`; `--dry-run` shows current outputs) |
 | `destroy` | Destroy cloud-provider stack with confirmation prompt (`--dry-run` shows current outputs) |
 | `status` | Show stack outputs: IP, gateway URL, region, provisioned time |
-| `plan` | Generate a deploy-plan JSON artifact (dry-run safe) |
+| `plan` | Generate a deploy-plan JSON artifact (dry-run safe). `--ssh-cidr <list\|auto>` and `--gateway-cidr` decide who may connect; `--publish-gateway loopback\|all` decides what is listening |
 | `apply` | Apply a previously reviewed plan file (`--dry-run` validates and shows diff without applying) |
 | `ssh` | Interactive SSH session or run a remote command |
 | `logs` | Stream OpenClaw logs (`-f`, `--tail N`, `--since 5m`) |
@@ -641,7 +725,7 @@ clawops down --yes          # Destroy local-provider stack
 | `gateway` | Restart the OpenClaw gateway service |
 | `backup` | Create and restore OpenClaw state backups (`restore` expands into a staging directory, never in place) |
 | `stacks` | List named stacks and their state |
-| `doctor` | Check the local machine; with `--stack`, the deployment's health too. `--json` for the report. Exits 1 on any failure |
+| `doctor` | Check the local machine; with `--stack`, the deployment's health too; with `--provider`, one cloud's credentials and account setup whether or not a stack exists; with `--instance-type`, account checks ask about that size rather than the provider default. `--json` for the report. Exits 1 on any failure |
 | `secret` | Manage secrets: `list`, `set`, `delete`, `rotate`, `audit` |
 | `monitor` | Live dashboard: gateway health, container stats, log tail, stack picker |
 | `mcp serve` | Start the embedded MCP server (stdio, or HTTP with `--http <port> --token <t>`) |
@@ -661,7 +745,8 @@ For non-local providers, clawops enforces a review-before-apply discipline:
 
 ```bash
 # 1. Generate a plan — runs `pulumi preview` internally, produces JSON
-clawops plan --provider aws --region us-east-1 --out /tmp/plan.json
+#    --ssh-cidr decides who may connect. `auto` means this machine; omit it and nobody can.
+clawops plan --provider aws --region us-east-1 --ssh-cidr auto --out /tmp/plan.json
 
 # 2. Review plan.json — the `diff` field shows projected changes at plan-generation time
 cat /tmp/plan.json | jq .diff
@@ -827,7 +912,7 @@ clawops
 
 Key design decisions:
 
-- **Pulumi Automation API (embedded):** no `pulumi` binary required; Pulumi home is sandboxed to `~/.clawops/.pulumi`; stack programs are inline TypeScript closures
+- **Pulumi Automation API:** the user installs no Pulumi — clawops installs the CLI the API drives into `~/.clawops/.pulumi-cli`, pinned to the bundled SDK, without editing `$PATH` (ADR 0010); Pulumi home is sandboxed to `~/.clawops/.pulumi`; stack programs are inline TypeScript closures
 - **State in cloud blob storage:** GCS (`gs://`), S3 (`s3://`), Azure Blob — no local state files, no `pulumi.yaml`
 - **SSH via `ssh2`:** never shells out to `/usr/bin/ssh`; TOFU host verification against `~/.clawops/known_hosts`; connection pool with 5-min idle TTL
 - **Plan → apply discipline:** every non-local deployment goes through `generatePlan()` → review → `applyPlan()`; destructive changes always require human review of the plan JSON
@@ -926,13 +1011,15 @@ pnpm dev doctor        # verify toolchain
 ```bash
 pnpm dev                   # run CLI from src/ via tsx
 pnpm build                 # tsup → dist/
-pnpm test                  # vitest (1210 tests, ~13s)
+pnpm test                  # vitest (1669 tests, ~12s)
 pnpm test:changed          # vitest --changed (fast edit loop)
 pnpm test:integration      # Docker-based SSH integration tests
 pnpm typecheck             # tsc --noEmit
 pnpm lint                  # eslint src/ tests/ scripts/ (--max-warnings=0)
 pnpm gen:schemas           # regenerate src/providers/types.ts + src/mcp/tools/_generated.ts
 pnpm gen:schemas --check   # CI guard: committed generated files match spec
+pnpm graph                 # local coupling report (--base <ref> for this branch's delta)
+pnpm verify:pack           # install the packed tarball elsewhere and run it (CI gate)
 pnpm changeset             # record a release note before merging
 ```
 

package/dist/apply-WOUTUUQH.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  applyPlan
+} from "./chunk-ZMMRIWFS.js";
+import "./chunk-BOPSG2LI.js";
+import "./chunk-6ZFIFDBJ.js";
+import "./chunk-2I7KCMXZ.js";
+import "./chunk-HSPHXG6W.js";
+import "./chunk-AEEMRFZV.js";
+import "./chunk-BSLIYB5Q.js";
+import "./chunk-WTZ2CT35.js";
+import "./chunk-NUDIHZEH.js";
+import "./chunk-JW5A7E3X.js";
+import "./chunk-LEVIW2PV.js";
+import "./chunk-GIEVAGEK.js";
+import "./chunk-VOEJYRIK.js";
+import "./chunk-EI7CQQ7D.js";
+import "./chunk-FEK7VJAY.js";
+import "./chunk-RHOWYIWT.js";
+import "./chunk-N4WZLWJ4.js";
+import "./chunk-A2I76FTA.js";
+import "./chunk-CX5SL5HP.js";
+import "./chunk-KGXPLI7W.js";
+import "./chunk-VUFMZEIM.js";
+export {
+  applyPlan
+};

package/dist/automation-UKRM3BD2.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import {
+  ensurePulumiCli
+} from "./chunk-PSOSBJVO.js";
+import {
+  ensurePassphrase
+} from "./chunk-V25QRZRB.js";
+import {
+  getConfigDir
+} from "./chunk-CX5SL5HP.js";
+import "./chunk-KGXPLI7W.js";
+
+// src/pulumi/automation.ts
+import path from "path";
+import { LocalWorkspace } from "@pulumi/pulumi/automation/index.js";
+async function getOrCreateStack(opts) {
+  const configDir = opts.configDir ?? getConfigDir();
+  const pulumiCommand = await ensurePulumiCli({ configDir, onInstall: opts.onInstall });
+  const passphrase = ensurePassphrase(configDir);
+  return await LocalWorkspace.createOrSelectStack(
+    {
+      stackName: opts.stack,
+      projectName: "clawops",
+      program: opts.program
+    },
+    {
+      pulumiCommand,
+      pulumiHome: path.join(configDir, ".pulumi"),
+      envVars: {
+        PULUMI_BACKEND_URL: opts.stateUrl,
+        PULUMI_SKIP_UPDATE_CHECK: "1",
+        // A self-managed backend has no key service, so a new stack cannot be created without
+        // a secrets manager, and the only one available is a passphrase. Undefined when the
+        // operator supplies their own — overriding it would orphan their existing stacks.
+        // See ./passphrase.ts and ADR 0011.
+        ...passphrase ? { PULUMI_CONFIG_PASSPHRASE: passphrase } : {}
+        // R6: cloud credentials inherited from process.env, never set here
+      }
+    }
+  );
+}
+export {
+  getOrCreateStack
+};

package/dist/bedrock-XVASJX2K.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/openclaw/bedrock.ts
+function resolveInferenceProfile(foundationModelId, profiles, region) {
+  const candidates = profiles.map((p) => p.inferenceProfileId).filter((id) => id.endsWith(`.${foundationModelId}`));
+  if (candidates.length === 0) {
+    return {
+      ok: false,
+      error: `No Bedrock inference profile for "${foundationModelId}" in ${region}. Bedrock refuses bare foundation-model ids for on-demand inference, so this model cannot be used there. Check the model is enabled in this region, or choose another.`
+    };
+  }
+  const geo = geographyFor(region);
+  const regional = candidates.find((id) => id.startsWith(`${geo}.`));
+  if (regional) return { ok: true, profileId: regional, why: `${geo} profile for ${region}` };
+  const global = candidates.find((id) => id.startsWith("global."));
+  if (global) {
+    return {
+      ok: true,
+      profileId: global,
+      why: `no ${geo} profile for ${region}; using the global profile`
+    };
+  }
+  return {
+    ok: false,
+    error: `Bedrock has inference profiles for "${foundationModelId}" (${candidates.join(", ")}) but none for ${region} or global. Using one would route inference to another geography; choose a region where the model is offered.`
+  };
+}
+function geographyFor(region) {
+  const prefix = region.split("-")[0] ?? region;
+  if (prefix === "ap") return "apac";
+  return prefix;
+}
+async function fetchInferenceProfiles(region, signal) {
+  try {
+    const { BedrockClient, ListInferenceProfilesCommand } = await import("@aws-sdk/client-bedrock");
+    const client = new BedrockClient({ region });
+    const profiles = [];
+    let nextToken;
+    do {
+      const page = await client.send(
+        new ListInferenceProfilesCommand({ maxResults: 100, nextToken }),
+        { abortSignal: signal }
+      );
+      for (const p of page.inferenceProfileSummaries ?? []) {
+        if (p.inferenceProfileId) profiles.push({ inferenceProfileId: p.inferenceProfileId });
+      }
+      nextToken = page.nextToken;
+    } while (nextToken);
+    return { ok: true, profiles };
+  } catch (err) {
+    return {
+      ok: false,
+      error: `Could not list Bedrock inference profiles in ${region}: ${err instanceof Error ? err.message : String(err)}. The deploying identity needs bedrock:ListInferenceProfiles.`
+    };
+  }
+}
+export {
+  fetchInferenceProfiles,
+  geographyFor,
+  resolveInferenceProfile
+};

package/dist/{bootstrap-DMRPWJGN.js → bootstrap-HNGKY6WW.js}

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
 import {
   acquireSession
-} from "./chunk-3WYA2QDM.js";
-import "./chunk-AHAAEXWC.js";
+} from "./chunk-2Z7J3ERQ.js";
+import "./chunk-E4NJSJ54.js";
+import "./chunk-MC5ATCXS.js";
+import {
+  gatewayRunArgs,
+  gatewayRunCommand
+} from "./chunk-GIEVAGEK.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-VOEJYRIK.js";
+import "./chunk-EI7CQQ7D.js";
 import {
   writeLocalState
 } from "./chunk-A2I76FTA.js";
@@ -10,12 +19,6 @@ import "./chunk-CX5SL5HP.js";
 import {
   ProviderError
 } from "./chunk-KGXPLI7W.js";
-import {
-  GATEWAY_PORT,
-  gatewayRunArgs,
-  gatewayRunCommand
-} from "./chunk-6TIYVHPX.js";
-import "./chunk-EI7CQQ7D.js";
 
 // src/providers/local/bootstrap.ts
 import { readFileSync, existsSync } from "fs";

package/dist/{chunk-N44K3LHE.js → chunk-2I7KCMXZ.js}

@@ -4,15 +4,17 @@ import {
 } from "./chunk-NUDIHZEH.js";
 import {
   CONTAINER_UID,
-  GATEWAY_PORT,
-  IMAGE_INSPECT_CMD,
   PUBLISH_INSPECT_CMD,
   configPathForOS,
   gatewayRunCommand,
-  imageForRestart,
   publishForRestart,
   stateDirForOS
-} from "./chunk-6TIYVHPX.js";
+} from "./chunk-GIEVAGEK.js";
+import {
+  GATEWAY_PORT,
+  IMAGE_INSPECT_CMD,
+  imageForRestart
+} from "./chunk-VOEJYRIK.js";
 
 // src/plan/remote-config.ts
 var OPENCLAW_CONFIG_LINUX = configPathForOS("Linux");

package/dist/{chunk-3WYA2QDM.js → chunk-2Z7J3ERQ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   connect
-} from "./chunk-AHAAEXWC.js";
+} from "./chunk-E4NJSJ54.js";
 import {
   NetworkError
 } from "./chunk-KGXPLI7W.js";

package/dist/chunk-3OLUJPCB.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  execPrivileged
+} from "./chunk-NUDIHZEH.js";
+
+// src/openclaw/docker.ts
+function looksLikeStillBooting(detail) {
+  const text = detail.toLowerCase();
+  return text.includes("command not found") || text.includes("cannot connect to the docker daemon") || text.includes("is the docker daemon running") || text.includes("no such file or directory");
+}
+function saysNoSuchObject(text) {
+  return /no such (object|container)/i.test(text);
+}
+async function inspectContainer(session, name, format, signal, dockerCmd = "docker") {
+  const result = await execPrivileged(
+    session,
+    `${dockerCmd} inspect ${name} --format '${format}'`,
+    signal
+  );
+  if (result.code === 0) return { kind: "ok", value: result.stdout.trim() };
+  const text = `${result.stderr} ${result.stdout}`.trim();
+  if (saysNoSuchObject(text)) return { kind: "missing" };
+  return { kind: "error", detail: text === "" ? `docker inspect exited ${result.code}` : text };
+}
+async function containerStatus(session, name = "openclaw", signal) {
+  const result = await inspectContainer(session, name, "{{.State.Status}}", signal);
+  if (result.kind === "ok") return { status: result.value || "unknown" };
+  if (result.kind === "missing") return { status: "not found" };
+  return { status: "unknown", error: result.detail };
+}
+
+export {
+  looksLikeStillBooting,
+  inspectContainer,
+  containerStatus
+};