@ductape/cli 0.2.22 → 0.3.0

package/DB_MIGRATE_PLAN.md

@@ -1,223 +0,0 @@
-# `ductape db migrate` — Research & Implementation Plan
-
-## What already exists
-
-### 1. `ductape init` creates `.ductape/`
-[`src/commands/init.ts`](src/commands/init.ts) calls `writeInitArtifacts()` and `saveProjectConfig()`.
-[`src/lib/config.ts`](src/lib/config.ts) line 13 defines:
-```ts
-export const PROJECT_CONFIG_DIR = '.ductape';
-export const PROJECT_CONFIG_PATH = path.join(PROJECT_CONFIG_DIR, 'config.json');
-```
-This is the only change needed in `config.ts` to rename to `ductape/`.
-
-### 2. `ductape db <verb>` — proxy passthrough
-[`src/commands/db.ts`](src/commands/db.ts) is a generic proxy that already understands `migration.list` and `migration.run` as method strings (defined in [`src/lib/db-methods.ts`](src/lib/db-methods.ts)). These work today but require a JSON body file (`-f`) and are not user-friendly for the workflow we're building.
-
-### 3. SDK `MigrationEngine` — fully built
-[`sdk/ts/src/database/migrations/migration-engine.ts`](../sdk/ts/src/database/migrations/migration-engine.ts):
-- Tracks applied migrations in a `_ductape_migrations` table/collection created automatically on first run.
-- `migrate(migrations[])` — runs all pending (not yet in `_ductape_migrations`) in dependency order.
-- `rollback(count)` / `rollbackAll()` / `reset()`.
-- `getPendingMigrations(migrations[])` — diffs supplied list against `_ductape_migrations`.
-- `getAppliedMigrations()` — returns history with tag, name, checksum, appliedAt.
-- `getStatus(migrations[])` — returns `{ total, completed, pending, pendingMigrations[], appliedMigrations[] }`.
-- Works across PostgreSQL, MySQL, MariaDB, MongoDB, DynamoDB, Cassandra.
-
-### 4. SDK `SchemaManager` + `MigrationBuilder`
-[`sdk/ts/src/database/schema/schema-manager.ts`](../sdk/ts/src/database/schema/schema-manager.ts):
-- `createCollection(name, fields[], options?)` — generates an `IMigration` (up: createCollection, down: dropCollection).
-- `addField()`, `dropField()`, `renameField()`, `modifyField()` — each generates a reversible `IMigration`.
-- `createIndex()`, `dropIndex()`, `addConstraint()`, `dropConstraint()`.
-- `MigrationBuilder` — fluent API for batching multiple operations into one migration object.
-- All operations produce `IMigration` objects with `up[]` and `down[]` — the same shape the engine consumes.
-
-### 5. `IFieldDefinition` type system
-Supported field types: `string`, `text`, `integer`, `bigint`, `smallint`, `decimal`, `float`, `double`, `uuid`, `boolean`, `date`, `time`, `datetime`, `timestamp`, `binary`, `blob`, `json`, `object`, `array`, `enum`.
-
-Field options: `nullable`, `unique`, `primaryKey`, `autoGenerate` (auto-increment/SERIAL), `defaultValue`, `maxLength`, `precision`, `scale`, `enumValues`, `arrayElementType`.
-
----
-
-## What does not exist yet
-
-### Gap 1 — `ductape/` folder structure (not `.ductape/`)
-Currently `PROJECT_CONFIG_DIR = '.ductape'`. Needs to become `'ductape'`.
-
-`ductape init` should also scaffold:
-```
-ductape/
-  config.json          ← existing (project linking)
-  database/
-    schema.json        ← NEW: declarative schema definition
-    migrations/        ← NEW: generated migration files (one JSON per migration)
-```
-
-### Gap 2 — `ductape/database/schema.json` format
-No parser, type-mapper, or loader exists. This needs to be written.
-
-User-specified format:
-```json
-[
-  {
-    "db": "dbTag",
-    "tables": {
-      "users": {
-        "name":  { "type": "String", "required": true },
-        "email": { "type": "String", "unique": true },
-        "age":   { "type": "Number" }
-      },
-      "orders": {
-        "userId":    { "type": "String", "required": true },
-        "total":     { "type": "Number" },
-        "createdAt": { "type": "Date", "default": "now" }
-      }
-    }
-  }
-]
-```
-
-The CLI must translate this mongoose-style syntax to `IFieldDefinition[]` before it can call `SchemaManager` or `MigrationEngine`. Mapping table needed (see below).
-
-### Gap 3 — `ductape db migrate` command
-No high-level migrate command exists. The existing `ductape db migration.run` requires a structured JSON body and is a raw proxy call, not schema-aware.
-
-### Gap 4 — Schema diff logic
-The CLI needs to determine which tables and fields in `schema.json` are new (not yet migrated). Two available signals:
-- `migration.list` via proxy — returns `_ductape_migrations` history (knows what ran).
-- `schema.describe` / `schema.list` via proxy — introspects current DB structure directly.
-
-The safer approach is to use the migration history (what the CLI itself applied) as the source of truth, and use `schema.describe` only as a secondary check. This keeps the system append-only and prevents false positives from manual DB changes.
-
-### Gap 5 — Generated migration files
-When the CLI generates a migration from a schema diff, it should write a timestamped JSON file to `ductape/database/migrations/`:
-```
-ductape/database/migrations/
-  20250703_120000_create_users.json
-  20250703_120001_create_orders.json
-```
-These files are the local record of what was generated and are committed to version control. On `ductape db migrate`, the CLI reads all files from this folder, diffs against applied migrations, and runs the pending ones.
-
-### Gap 6 — Remote schema sync (deferred — see below)
-No mechanism exists to push/pull `schema.json` to/from a remote location. This is the biggest open architectural question.
-
----
-
-## Mongoose-to-Ductape type mapping
-
-| Mongoose style | `FieldType` |
-|---|---|
-| `String` | `string` |
-| `Number` | `integer` (default) or `decimal` if `float: true` |
-| `Boolean` | `boolean` |
-| `Date` | `datetime` |
-| `Buffer` | `binary` |
-| `Mixed` / `Object` | `object` |
-| `Array` | `array` |
-| `ObjectId` / `UUID` | `uuid` |
-| `Map` | `object` |
-| `Decimal128` | `decimal` |
-
-Mongoose field options → `IFieldDefinition`:
-| Mongoose | `IFieldDefinition` |
-|---|---|
-| `required: true` | `nullable: false` |
-| `unique: true` | `unique: true` |
-| `default: value` | `defaultValue: value` |
-| `default: 'now'` | `defaultValue: 'CURRENT_TIMESTAMP'` |
-| `maxlength: N` | `maxLength: N` |
-| `enum: [...]` | `type: 'enum', enumValues: [...]` |
-| `index: true` | generates a separate `createIndex` operation |
-| `primaryKey: true` | `primaryKey: true` |
-| `autoGenerate: true` | `autoGenerate: true` |
-
----
-
-## Proposed command surface
-
-```
-ductape db migrate              Run all pending migrations for all dbs in schema.json
-ductape db migrate --env <tag>  Run against a specific environment
-ductape db migrate --dry-run    Print what would run without applying
-ductape db migrate --db <tag>   Limit to one db entry from schema.json
-
-ductape db migrate status       Show applied vs pending migrations
-ductape db migrate rollback     Roll back the last migration
-ductape db migrate rollback -n 3  Roll back the last 3
-
-ductape db schema generate      Diff schema.json vs applied migrations and write new migration files to migrations/ WITHOUT running them
-ductape db schema push          Push local schema.json to remote (Ductape platform storage) — deferred
-ductape db schema pull          Fetch remote schema.json to local — deferred
-```
-
-The core flow for `ductape db migrate`:
-1. Load `ductape/database/schema.json`.
-2. For each `{ db, tables }` entry:
-   a. Resolve the db tag to a database_context via `db connect`.
-   b. Load all migration files from `ductape/database/migrations/` that match this db.
-   c. Call `migration.list` via proxy to get already-applied migration tags.
-   d. Filter to pending migrations (files whose tag is not in applied list).
-   e. Call `migration.run` via proxy for each pending migration in order.
-3. Report results.
-
-The `ductape db schema generate` flow:
-1. Load `schema.json`.
-2. Load existing migration files from `migrations/`.
-3. Reconstruct the "current intended schema" from applied migrations (replay up-ops in memory).
-4. Diff declared schema (from `schema.json`) vs current intended schema.
-5. For new tables → generate `createCollection` migration.
-6. For new fields on existing tables → generate `addField` migration.
-7. For removed fields/tables → refuse by default; require `--destructive` flag.
-8. Write each generated migration as a JSON file in `migrations/`.
-
----
-
-## Things to watch out for
-
-### Non-destructive by default
-`ductape db schema generate` must never emit `dropCollection` or `dropField` operations unless `--destructive` is explicitly passed. Removing a field from `schema.json` silently generating a drop migration could wipe production data.
-
-### Schema.json vs migration files as source of truth
-`schema.json` expresses intent. Migration files express history. The CLI generates migration files from `schema.json` changes. Once a migration file exists, it is the immutable record — `schema.json` can diverge (e.g., someone deletes a table definition) but the migration file should not be regenerated or deleted automatically.
-
-### db tag resolution
-Each `{ db: 'dbTag' }` in schema.json needs to be connected before migrations can run. The existing `ductape db connect` / `database_context` mechanism handles this. The `migrate` command should do a `connect` call per db entry before running its migrations.
-
-### Migration ordering across tables
-When generating migrations for multiple new tables in one run, ordering matters if tables have foreign keys. The user can declare `dependencies` on a migration to enforce order. For the initial scaffold, generate one migration file per table in the order they appear in `schema.json`. A future improvement could auto-detect FK dependencies.
-
-### Idempotency
-`migration.run` via the engine already checks `_ductape_migrations` before applying. Re-running `ductape db migrate` is safe — it skips already-applied migrations.
-
-### Checksum integrity
-The `MigrationEngine` records a SHA-256 checksum of the migration content at apply time. If a migration file is edited after being applied, the engine will detect a mismatch. The CLI should warn about this rather than silently failing.
-
----
-
-## The multi-codebase schema sync problem
-
-This is the hardest part of the system and is explicitly deferred.
-
-**The problem:** Team member A adds `products` table to `schema.json` and runs `ductape db schema generate`, producing `20250703_create_products.json`. Team member B pulls code and gets the migration file. But if B's `schema.json` is out of date, running `ductape db schema generate` again might produce a duplicate or conflicting migration.
-
-**Proposed approach (to validate before implementing):**
-- Migration files (`ductape/database/migrations/*.json`) are committed to version control. This is the primary sync mechanism — same as Prisma, Flyway, Liquibase.
-- `schema.json` is the declarative desired state. It should also be committed, but is the secondary source. Migration files take precedence.
-- `ductape db schema push` uploads `schema.json` to a `_ductape_schema` collection (or Ductape platform storage) so other machines can fetch it.
-- `ductape db schema pull` fetches the remote schema.json and merges it — or simply overwrites the local one (simpler, with a warning).
-- The authoritative migration history is always `_ductape_migrations` in the actual database. The CLI's job is just to generate and apply files; the DB is always the final word on what ran.
-
-**Key constraint to solve before implementing sync:** If two developers generate migrations from different `schema.json` states at the same time (e.g., both add different tables locally), their migration files will have different tags and could conflict when both are applied to the same DB. This is the same problem Git branch migrations have in Prisma. The recommended solution is to treat migration file generation as a gated step that only runs on `main` / via CI, not locally in parallel. This is a workflow decision that should be locked in before the sync commands are built.
-
----
-
-## Implementation order
-
-1. Rename `PROJECT_CONFIG_DIR` from `.ductape` to `ductape` in `config.ts`.
-2. Update `writeInitArtifacts()` in `templates.ts` to scaffold `database/schema.json` and `database/migrations/`.
-3. Write `src/lib/schema-loader.ts` — loads and validates `schema.json`, maps mongoose types to `IFieldDefinition`.
-4. Write `src/lib/migration-files.ts` — reads/writes migration JSON files from `ductape/database/migrations/`.
-5. Add `ductape db schema generate` subcommand.
-6. Add `ductape db migrate` subcommand (run pending migration files via proxy).
-7. Add `ductape db migrate status` and `ductape db migrate rollback`.
-8. Deferred: `ductape db schema push` / `ductape db schema pull`.

package/ductape.example.ts

@@ -1,18 +0,0 @@
-/**
- * Ductape SDK example — product/env defaults are set on the constructor only.
- * CLI: `ductape login` + `ductape link` (see .ductape/config.json).
- */
-import Ductape from '@ductape/sdk';
-
-const ductape = new Ductape({
-  accessKey: process.env.DUCTAPE_ACCESS_KEY!,
-  product: process.env.DUCTAPE_PRODUCT!,
-  env: process.env.DUCTAPE_ENV ?? 'dev',
-});
-
-async function main() {
-  // await ductape.databases.connect({ database: 'main-db' });
-  console.log('Ductape client ready');
-}
-
-main().catch(console.error);

package/src/commands/apply.ts

@@ -1,153 +0,0 @@
-import { findProjectConfig } from '../lib/config.js';
-import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
-import { fail } from '../lib/output.js';
-import { buildCrudParams } from '../lib/resources.js';
-import {
-  loadSessions,
-  loadNotifications,
-  loadEvents,
-  type ApplyItem,
-} from '../lib/apply-loaders.js';
-import type { SDKModule } from '../lib/proxy/sdk-proxy.js';
-
-export type ApplyType = 'sessions' | 'notifications' | 'events';
-
-interface ApplyOpts {
-  dryRun?: boolean;
-}
-
-const MODULE_FOR: Record<ApplyType, SDKModule> = {
-  sessions: 'sessions',
-  notifications: 'notifications',
-  events: 'messageBrokers',
-};
-
-async function syncItems(
-  type: ApplyType,
-  items: ApplyItem[],
-  productTag: string,
-  proxy: ReturnType<typeof getSdkProxy>,
-  dryRun: boolean,
-): Promise<void> {
-  const module = MODULE_FOR[type];
-
-  const listResult = await proxy.execute<unknown>(module, 'list', buildCrudParams(module, 'list', productTag, {}));
-  const existingList = Array.isArray(listResult) ? listResult : [];
-  const existingTags = new Set(
-    existingList.map((r) => (r as { tag?: string }).tag ?? '').filter(Boolean),
-  );
-  const existingNotificationMessages = new Set<string>();
-  if (type === 'notifications') {
-    for (const notification of existingList) {
-      const record = notification as { tag?: string; messages?: Array<{ tag?: string }> };
-      for (const message of record.messages ?? []) {
-        if (record.tag && message.tag) {
-          existingNotificationMessages.add(
-            message.tag.includes(':') ? message.tag : `${record.tag}:${message.tag}`,
-          );
-        }
-      }
-    }
-  }
-
-  for (const item of items) {
-    if (!item.tag) {
-      console.warn(`  [${type}] skipped — missing "tag" field`);
-      continue;
-    }
-
-    const verb: 'create' | 'update' = existingTags.has(item.tag) ? 'update' : 'create';
-    const nestedMessages =
-      type === 'notifications' && Array.isArray(item.messages)
-        ? item.messages as Array<Record<string, unknown>>
-        : [];
-    const componentBody =
-      type === 'notifications'
-        ? Object.fromEntries(Object.entries(item).filter(([key]) => key !== 'messages'))
-        : item;
-
-    if (dryRun) {
-      console.log(`  [${type}] would ${verb}: ${item.tag}`);
-      for (const message of nestedMessages) {
-        const rawTag = String(message.tag ?? '');
-        const fullTag = rawTag.includes(':') ? rawTag : `${item.tag}:${rawTag}`;
-        const messageVerb = existingNotificationMessages.has(fullTag) ? 'update' : 'create';
-        console.log(`  [notifications] would ${messageVerb} message: ${fullTag}`);
-      }
-      continue;
-    }
-
-    try {
-      const params = buildCrudParams(module, verb, productTag, {
-        tag: item.tag,
-        body: componentBody,
-      });
-      await proxy.execute(module, verb, params);
-      console.log(`  [${type}] ${verb}d: ${item.tag}`);
-
-      for (const message of nestedMessages) {
-        const rawTag = String(message.tag ?? '');
-        if (!rawTag) throw new Error(`notification "${item.tag}" contains a message without "tag"`);
-        const fullTag = rawTag.includes(':') ? rawTag : `${item.tag}:${rawTag}`;
-        if (!fullTag.startsWith(`${item.tag}:`)) {
-          throw new Error(
-            `message tag "${fullTag}" must belong to notification "${item.tag}"`,
-          );
-        }
-        const messageBody = { ...message, tag: fullTag };
-        const messageVerb = existingNotificationMessages.has(fullTag) ? 'update' : 'create';
-        const messageParams =
-          messageVerb === 'create'
-            ? [productTag, messageBody]
-            : [productTag, fullTag, messageBody];
-        await proxy.execute('notifications', `messages.${messageVerb}`, messageParams);
-        console.log(`  [notifications] ${messageVerb}d message: ${fullTag}`);
-      }
-    } catch (err) {
-      console.error(
-        `  [${type}] ${verb} failed for "${item.tag}": ${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-  }
-}
-
-export async function runApply(type: ApplyType | undefined, opts: ApplyOpts): Promise<void> {
-  const found = findProjectConfig();
-  if (!found) fail('No linked project. Run `ductape link` from your project directory.');
-
-  const { dir } = found;
-  const session = requireSession();
-  const proxy = getSdkProxy(session);
-  const productTag = session.project.product_tag;
-  const dryRun = Boolean(opts.dryRun);
-
-  const targets: ApplyType[] = type ? [type] : ['sessions', 'notifications', 'events'];
-
-  const loaders: Record<ApplyType, () => ApplyItem[] | null> = {
-    sessions: () => loadSessions(dir),
-    notifications: () => loadNotifications(dir),
-    events: () => loadEvents(dir),
-  };
-
-  for (const t of targets) {
-    let items: ApplyItem[] | null;
-    try {
-      items = loaders[t]();
-    } catch (err) {
-      fail(`[${t}] parse error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-
-    if (items === null) {
-      console.log(`[${t}] no ductape/${t}.json found — skipping`);
-      continue;
-    }
-
-    if (items.length === 0) {
-      console.log(`[${t}] empty — nothing to apply`);
-      continue;
-    }
-
-    console.log(`[${t}] applying ${items.length} item(s)${dryRun ? ' (dry run)' : ''}...`);
-    await syncItems(t, items, productTag, proxy, dryRun);
-  }
-}

package/src/commands/apps-import.ts

@@ -1,43 +0,0 @@
-import path from 'node:path';
-import { getApp } from '../lib/platform-api.js';
-import { importAppFromFile, parseImportFormat } from '../lib/app-import.js';
-import { printJson, success } from '../lib/output.js';
-import { requireWorkspaceContext } from '../lib/workspace-context.js';
-
-export async function runAppsImport(
-  file: string,
-  opts: {
-    profile?: string;
-    type: string;
-    appId?: string;
-    appTag?: string;
-    update?: boolean;
-    version?: string;
-    json?: boolean;
-  },
-): Promise<void> {
-  const ctx = requireWorkspaceContext({ profile: opts.profile });
-  const format = parseImportFormat(opts.type);
-
-  let appId = opts.appId;
-  if (!appId && opts.appTag) {
-    const app = (await getApp(ctx, { tag: opts.appTag })) as { _id?: string };
-    appId = app._id;
-    if (!appId) throw new Error(`App not found for tag: ${opts.appTag}`);
-  }
-
-  const result = await importAppFromFile(ctx, {
-    filePath: path.resolve(file),
-    format,
-    appId,
-    update: Boolean(opts.update),
-    version: opts.version,
-  });
-
-  if (opts.json) {
-    printJson(result, true);
-    return;
-  }
-  const label = format === 'postman' ? 'Postman v2.1' : 'OpenAPI 3.0';
-  success(`Imported ${label} collection from ${path.basename(file)}`);
-}

package/src/commands/apps.ts

@@ -1,92 +0,0 @@
-import { schemaKeyForEntity } from '../lib/forms/index.js';
-import { isInteractive, promptTag } from '../lib/forms/prompt.js';
-import { toInteractiveOpts, type CommandInteractiveFlags } from '../lib/interactive-opts.js';
-import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
-import {
-  createApp,
-  deleteApp,
-  getApp,
-  listApps,
-  updateApp,
-  updateAppViaProxy,
-} from '../lib/platform-api.js';
-import { printJson } from '../lib/output.js';
-import { requireWorkspaceContext } from '../lib/workspace-context.js';
-
-const VERBS = ['list', 'get', 'create', 'update', 'delete'] as const;
-type Verb = (typeof VERBS)[number];
-
-export async function runApps(
-  verb: string,
-  opts: {
-    profile?: string;
-    status?: string;
-    id?: string;
-    tag?: string;
-    file?: string;
-    json?: boolean;
-    proxy?: boolean;
-  } & CommandInteractiveFlags,
-  extraArgs: string[],
-): Promise<void> {
-  const v = verb.toLowerCase() as Verb;
-  if (!VERBS.includes(v)) {
-    throw new Error(`Unknown apps verb "${verb}". Use: ${VERBS.join(', ')}`);
-  }
-
-  const ctx = requireWorkspaceContext({ profile: opts.profile });
-  const status = opts.status ?? 'all';
-  const interactive = toInteractiveOpts(opts);
-  const schemaKey = schemaKeyForEntity('apps', v);
-  const body =
-    v === 'create' || v === 'update'
-      ? await resolveBody({
-          ...interactive,
-          file: opts.file,
-          schemaKey,
-          patch: v === 'update',
-          requireBody: v === 'create',
-        })
-      : undefined;
-  const id = opts.id ?? extraArgs[0];
-  let tag = opts.tag ?? (extraArgs[0] && !opts.id ? extraArgs[0] : undefined);
-  if (v === 'update' && (opts.proxy || !id) && !tag && isInteractive(interactive)) {
-    tag = await promptTag('App tag');
-  }
-
-  let result: unknown;
-
-  switch (v) {
-    case 'list':
-      result = await listApps(ctx, status);
-      break;
-    case 'get':
-      result = await getApp(ctx, { id, tag });
-      break;
-    case 'create':
-      if (!body || Object.keys(body).length === 0) {
-        throw new Error(`create requires a body. ${bodyRequiredHint('apps:create')}`);
-      }
-      result = await createApp(ctx, body);
-      break;
-    case 'update': {
-      if (opts.proxy || tag) {
-        const appTag = tag ?? (body?.tag as string | undefined);
-        if (!appTag) throw new Error('update via proxy requires --tag <app_tag>');
-        result = await updateAppViaProxy(ctx, appTag, body ?? {});
-        break;
-      }
-      if (!id) throw new Error('update requires --id <app_id> or --tag with --proxy');
-      result = await updateApp(ctx, id, body ?? {});
-      break;
-    }
-    case 'delete':
-      if (!id) throw new Error('delete requires --id <app_id>');
-      result = await deleteApp(ctx, id);
-      break;
-    default:
-      throw new Error(`Unsupported: apps ${v}`);
-  }
-
-  printJson(result, Boolean(opts.json));
-}

package/src/commands/cloud.ts

@@ -1,68 +0,0 @@
-import { readJsonBody } from '../lib/read-body.js';
-import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
-import { printJson } from '../lib/output.js';
-import { listCloudTiers } from '../lib/platform-api.js';
-import { requireWorkspaceContext } from '../lib/workspace-context.js';
-
-type CloudTarget = 'connections' | 'resources' | 'tiers';
-
-export async function runCloud(
-  target: CloudTarget,
-  verb: string,
-  opts: { id?: string; file?: string; provider?: string; type?: string; dbType?: string; tier?: string; json?: boolean },
-  extraArgs: string[],
-): Promise<void> {
-  if (target === 'tiers') {
-    const ctx = requireWorkspaceContext();
-    const result = await listCloudTiers(ctx, {
-      provider: opts.provider,
-      resource_type: opts.type,
-      db_type: opts.dbType,
-    });
-    printJson(result, Boolean(opts.json));
-    return;
-  }
-
-  requireSession();
-  const proxy = getSdkProxy();
-  let body = readJsonBody(opts.file);
-  if (opts.tier) {
-    body = { ...(body && typeof body === 'object' && !Array.isArray(body) ? body as Record<string, unknown> : {}), tier: opts.tier };
-  }
-  const id = opts.id ?? extraArgs[0];
-
-  let method: string;
-  let params: unknown[];
-
-  if (target === 'connections') {
-    const map: Record<string, [string, unknown[]]> = {
-      create: ['connections.create', [body]],
-      list: ['connections.list', []],
-      get: ['connections.fetch', [id]],
-      fetch: ['connections.fetch', [id]],
-      delete: ['connections.delete', [id]],
-      update: ['connections.update', [id, body]],
-      complete: ['connections.complete', [id, body]],
-      validate: ['connections.validate', [id]],
-    };
-    const entry = map[verb.toLowerCase()];
-    if (!entry) throw new Error(`Unknown cloud connections verb: ${verb}`);
-    [method, params] = entry;
-  } else {
-    const map: Record<string, [string, unknown[]]> = {
-      list: ['resources.list', [body]],
-      import: ['resources.import', [body]],
-      provision: ['resources.provision', [body]],
-      'import-persist': ['resources.importAndPersist', [body]],
-      'import-persist-all': ['resources.importAndPersistAll', [body]],
-      'provision-persist': ['resources.provisionAndPersist', [body]],
-      'provision-persist-all': ['resources.provisionAndPersistAll', [body]],
-    };
-    const entry = map[verb.toLowerCase()];
-    if (!entry) throw new Error(`Unknown cloud resources verb: ${verb}`);
-    [method, params] = entry;
-  }
-
-  const result = await proxy.execute('cloud', method, params);
-  printJson(result, Boolean(opts.json));
-}