@ornncompute/cli 1.0.144 → 1.0.145

package/README.md

@@ -259,6 +259,8 @@ never contains admin children. There is no second parser or command registry.
 An eligible human context requires TTY stdin and TTY stdout and no JSON/NDJSON
 format. Human commands may guide selection and render a normalized summary;
 mutations execute immediately without a confirmation prompt.
+This also applies to `volumes clear` when a noninteractive caller supplies an
+explicit output format.
 
 Automation supplies complete semantic inputs and an explicit format:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ornncompute/cli",
-  "version": "1.0.144",
+  "version": "1.0.145",
   "description": "Command-line interface for Ornn compute access workflows.",
   "type": "module",
   "bin": {

package/src/storage-commands.mjs

@@ -1,5 +1,14 @@
 import * as storageApi from "../vendor/api-client/orchestrator.js";
-import { bucketListCapability, volumeFilesListCapability } from "../vendor/capabilities/cli.js";
+import {
+  bucketListCapability,
+  volumeListCapability,
+  volumeShowCapability,
+  volumeCreateCapability,
+  volumeRefreshCapability,
+  volumeClearCapability,
+  volumeDeleteCapability,
+  volumeFilesListCapability,
+} from "../vendor/capabilities/cli.js";
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
@@ -300,7 +309,10 @@ export async function fetchDrivePage(runtime, { limit = 25, cursor, scope = "all
             { actor: "", role: "user", fetch: runtime.fetch },
             input
           )
-        : await storageApi.listDrives(runtime.fetch, { ...input, scope });
+        : await volumeListCapability.execute(
+            { actor: "", role: "user", fetch: runtime.fetch },
+            { ...input, scope }
+          );
     return { drives: volumeRows(payload), next_cursor: payload?.next_cursor ?? null };
   } catch (error) {
     throw safeStorageError(error, "Volumes could not be loaded safely.");
@@ -349,7 +361,10 @@ function resolveFromRows(rows, reference, { source = false } = {}) {
 
 export async function resolveVolume(runtime, reference) {
   if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(reference)) {
-    const drive = await storageApi.getDrive(runtime.fetch, reference);
+    const drive = await volumeShowCapability.execute(
+      { actor: "", role: "user", fetch: runtime.fetch },
+      { driveId: reference }
+    );
     return resolveFromRows([drive], reference);
   }
   return resolveFromRows(await fetchDrives(runtime), reference);
@@ -395,11 +410,15 @@ async function createVolume(input, runtime) {
     });
   }
 
-  const body = { name, source_drive_id: source ? String(source.id) : null };
   try {
-    const created = await storageApi.createDrive(runtime.fetch, body, {
-      headers: idempotencyHeaders(input),
-    });
+    const created = await volumeCreateCapability.execute(
+      { actor: "", role: "user", fetch: runtime.fetch },
+      {
+        name,
+        sourceDriveId: source ? String(source.id) : undefined,
+        idempotencyKey: String(input.idempotencyKey ?? "").trim() || undefined,
+      }
+    );
     return runtime.interaction.result({
       data: { effective_input: effective, replayed: false, volume: safeVolume(created) },
       outcome: { class: "ready", phase: "created" },
@@ -454,7 +473,10 @@ async function showVolume(input, runtime, { refresh = false } = {}) {
     return runtime.interaction.result({ data: { volume: safeVolume(drive) } });
   }
   try {
-    const refreshed = await storageApi.getDrive(runtime.fetch, String(drive.id), { refresh: true });
+    const refreshed = await volumeRefreshCapability.execute(
+      { actor: "", role: "user", fetch: runtime.fetch },
+      { driveId: String(drive.id) }
+    );
     return runtime.interaction.result({
       data: { volume: safeVolume(refreshed) },
       outcome: { class: "ready", phase: "refreshed" },
@@ -469,7 +491,10 @@ async function clearVolume(input, runtime) {
   const [reference] = positionals(input, 1, "Usage: ornn volumes clear <volume>");
   const drive = await resolveVolume(runtime, reference);
   try {
-    const payload = await storageApi.clearDriveContents(runtime.fetch, String(drive.id));
+    const payload = await volumeClearCapability.execute(
+      { actor: "", role: "user", fetch: runtime.fetch },
+      { driveId: String(drive.id) }
+    );
     return runtime.interaction.result({
       data: {
         cleared: true,
@@ -504,11 +529,12 @@ async function deleteVolume(input, runtime) {
   requireMachineMutationKey(input, runtime);
   const drive = await resolveVolume(runtime, reference);
   try {
-    await storageApi.deleteDrive(
-      runtime.fetch,
-      String(drive.id),
-      {},
-      { headers: idempotencyHeaders(input) }
+    await volumeDeleteCapability.execute(
+      { actor: "", role: "user", fetch: runtime.fetch },
+      {
+        driveId: String(drive.id),
+        idempotencyKey: String(input.idempotencyKey ?? "").trim() || undefined,
+      }
     );
     return runtime.interaction.result({
       data: { deleted: true, volume: safeVolume(drive) },

package/vendor/capabilities/cli.js

@@ -6492,74 +6492,188 @@ var volumeFilesListCapability = defineCapability({
     }
   }
 });
-var volumeCapabilities = [
-  storageCapability({
-    id: "storage.volumes.list",
-    command: ["volumes", "list"],
-    description: "List managed volumes in one bounded page.",
-    mutation: "read",
-    outcome: "List durable managed volumes independently from their mounts.",
-    human: "ornn volumes list [--limit <1-100>] [--cursor <cursor>]",
-    automation: "ornn volumes list --limit 50 --format json",
-    related: ["volumes show", "volumes create"]
+var volumePageInput = z32.object({
+  limit: z32.number().int().min(1).max(100).optional(),
+  cursor: z32.string().optional()
+});
+var driveInput = z32.object({ driveId: z32.string() });
+var driveWrite = driveInput.extend({ confirm: z32.boolean().optional() });
+var volumeCreateInput = z32.object({
+  name: z32.string(),
+  sourceDriveId: z32.string().optional(),
+  confirm: z32.boolean().optional()
+});
+var volumeListCapability = defineCapability({
+  id: "storage.volumes.list",
+  domain: "storage",
+  roles: ["user"],
+  description: "List a page of storage volumes, newest updated first. Pass next_cursor as cursor to continue.",
+  mutation: "read",
+  input: volumePageInput.extend({ scope: z32.enum(["all", "managed"]).optional() }),
+  mcp: { name: "storage_volumes_list", input: volumePageInput },
+  slack: false,
+  execute: (context, input) => listDrives(context.fetch, {
+    limit: input.limit ?? 25,
+    ...input.cursor ? { cursor: input.cursor } : {},
+    ...input.scope ? { scope: input.scope } : {}
   }),
-  storageCapability({
-    id: "storage.volumes.show",
+  cli: {
+    command: ["volumes", "list"],
+    input: storageCliInput,
+    execute: (context, input) => storageExecutor(context)("storage.volumes.list", input),
+    vnext: {
+      arguments: "semantic",
+      audience: "customer",
+      category: "resource",
+      outcome: "List durable managed volumes independently from their mounts.",
+      human: "ornn volumes list [--limit <1-100>] [--cursor <cursor>]",
+      automation: "ornn volumes list --limit 50 --format json",
+      related: ["volumes show", "volumes create"]
+    }
+  }
+});
+var volumeShowCapability = defineCapability({
+  id: "storage.volumes.show",
+  domain: "storage",
+  roles: ["user"],
+  description: "Show a single storage volume (drive) by id.",
+  mutation: "read",
+  input: driveInput,
+  mcp: { name: "storage_volumes_show" },
+  slack: false,
+  execute: (context, input) => getDrive(context.fetch, input.driveId),
+  cli: {
     command: ["volumes", "show"],
-    description: "Inspect one managed volume by canonical ID or exact unique name.",
-    mutation: "read",
-    outcome: "Inspect one durable volume without changing its lifecycle.",
-    human: "ornn volumes show <volume>",
-    automation: "ornn volumes show <volume-id> --format json",
-    acceptedReferences: ["canonical volume ID", "exact unique volume name"],
-    related: ["volumes files list", "volume-mounts show"]
-  }),
-  storageCapability({
-    id: "storage.volumes.create",
+    input: storageCliInput,
+    execute: (context, input) => storageExecutor(context)("storage.volumes.show", input),
+    vnext: {
+      arguments: "semantic",
+      audience: "customer",
+      category: "resource",
+      outcome: "Inspect one durable volume without changing its lifecycle.",
+      human: "ornn volumes show <volume>",
+      automation: "ornn volumes show <volume-id> --format json",
+      acceptedReferences: ["canonical volume ID", "exact unique volume name"],
+      related: ["volumes files list", "volume-mounts show"]
+    }
+  }
+});
+var volumeCreateCapability = defineCapability({
+  id: "storage.volumes.create",
+  domain: "storage",
+  roles: ["user"],
+  description: "Create a storage volume (drive), optionally cloned from an existing source drive.",
+  mutation: "preview-confirm",
+  input: volumeCreateInput.extend({ idempotencyKey: z32.string().optional() }),
+  mcp: { name: "storage_volumes_create", input: volumeCreateInput },
+  slack: false,
+  execute: (context, input) => createDrive(context.fetch, { name: input.name, source_drive_id: input.sourceDriveId ?? null }, input.idempotencyKey ? { headers: { "Idempotency-Key": input.idempotencyKey } } : void 0),
+  cli: {
     command: ["volumes", "create"],
-    description: "Create or rediscover a uniquely named managed volume.",
-    mutation: "preview-confirm",
-    outcome: "Create one durable volume or safely replay its normalized intent.",
-    human: "ornn volumes create --name <name> [--source <volume>] []",
-    automation: "ornn volumes create --name <name> [--source <volume-id>]  --idempotency-key <key> --format json",
-    acceptedReferences: ["canonical source volume ID", "exact unique source volume name"],
-    related: ["volumes show", "volumes files upload"]
-  }),
-  storageCapability({
-    id: "storage.volumes.refresh",
+    input: storageCliInput,
+    execute: (context, input) => storageExecutor(context)("storage.volumes.create", input),
+    vnext: {
+      arguments: "semantic",
+      audience: "customer",
+      category: "resource",
+      outcome: "Create one durable volume or safely replay its normalized intent.",
+      human: "ornn volumes create --name <name> [--source <volume>] []",
+      automation: "ornn volumes create --name <name> [--source <volume-id>]  --idempotency-key <key> --format json",
+      acceptedReferences: ["canonical source volume ID", "exact unique source volume name"],
+      related: ["volumes show", "volumes files upload"]
+    }
+  }
+});
+var volumeRefreshCapability = defineCapability({
+  id: "storage.volumes.refresh",
+  domain: "storage",
+  roles: ["user"],
+  description: "Refresh a storage volume's (drive's) reported usage/state.",
+  mutation: "preview-confirm",
+  input: driveWrite,
+  mcp: { name: "storage_volumes_refresh" },
+  slack: false,
+  execute: (context, input) => getDrive(context.fetch, input.driveId, { refresh: true }),
+  cli: {
     command: ["volumes", "refresh"],
-    description: "Refresh the owner-backed view of one managed volume.",
-    mutation: "read",
-    outcome: "Refresh and inspect the current durable volume state.",
-    human: "ornn volumes refresh <volume>",
-    automation: "ornn volumes refresh <volume-id> --format json",
-    acceptedReferences: ["canonical volume ID", "exact unique volume name"],
-    related: ["volumes show"]
-  }),
-  storageCapability({
-    id: "storage.volumes.clear",
+    input: storageCliInput,
+    execute: (context, input) => storageExecutor(context)("storage.volumes.refresh", input),
+    vnext: {
+      arguments: "semantic",
+      audience: "customer",
+      category: "resource",
+      outcome: "Refresh and inspect the current durable volume state.",
+      human: "ornn volumes refresh <volume>",
+      automation: "ornn volumes refresh <volume-id> --format json",
+      acceptedReferences: ["canonical volume ID", "exact unique volume name"],
+      related: ["volumes show"]
+    }
+  }
+});
+var volumeClearCapability = defineCapability({
+  id: "storage.volumes.clear",
+  domain: "storage",
+  roles: ["user"],
+  description: "Clear (empty) a storage volume's (drive's) contents without deleting the drive.",
+  mutation: "preview-confirm",
+  input: driveWrite,
+  mcp: { name: "storage_volumes_clear" },
+  slack: false,
+  execute: (context, input) => clearDriveContents(context.fetch, input.driveId),
+  cli: {
     command: ["volumes", "clear"],
-    description: "Erase every file in one volume after a live default-no confirmation.",
-    mutation: "preview-confirm",
-    outcome: "Permanently clear one volume only from a live interactive terminal.",
-    human: "ornn volumes clear <volume>",
-    automation: "Unsupported: this command requires a live interactive terminal.",
-    acceptedReferences: ["canonical volume ID", "exact unique volume name"],
-    review: "Every file and folder in the volume is permanently deleted.",
-    related: ["volumes files list", "volume-mounts detach"]
-  }),
-  storageCapability({
-    id: "storage.volumes.delete",
+    input: storageCliInput,
+    execute: (context, input) => storageExecutor(context)("storage.volumes.clear", input),
+    vnext: {
+      arguments: "semantic",
+      audience: "customer",
+      category: "resource",
+      outcome: "Permanently clear every file and folder from one volume.",
+      human: "ornn volumes clear <volume>",
+      automation: "ornn volumes clear <volume-id> --format json",
+      acceptedReferences: ["canonical volume ID", "exact unique volume name"],
+      review: "Every file and folder in the volume is permanently deleted.",
+      related: ["volumes files list", "volume-mounts detach"]
+    }
+  }
+});
+var volumeDeleteCapability = defineCapability({
+  id: "storage.volumes.delete",
+  domain: "storage",
+  roles: ["user"],
+  description: "Delete a storage volume (drive).",
+  mutation: "preview-confirm",
+  input: driveWrite.extend({ idempotencyKey: z32.string().optional() }),
+  mcp: { name: "storage_volumes_delete", input: driveWrite },
+  slack: false,
+  execute: async (context, input) => {
+    await deleteDrive(context.fetch, input.driveId, {}, input.idempotencyKey ? { headers: { "Idempotency-Key": input.idempotencyKey } } : void 0);
+    return { deleted: true, drive_id: input.driveId };
+  },
+  cli: {
     command: ["volumes", "delete"],
-    description: "Delete an explicitly selected, relationship-free managed volume.",
-    mutation: "preview-confirm",
-    outcome: "Delete one detached volume after explicit consent.",
-    human: "ornn volumes delete <volume>",
-    automation: "ornn volumes delete <volume-id>  --idempotency-key <key> --format json",
-    acceptedReferences: ["canonical volume ID", "exact unique volume name"],
-    review: "The volume and all of its data are permanently deleted.",
-    related: ["volume-mounts detach", "volumes show"]
-  }),
+    input: storageCliInput,
+    execute: (context, input) => storageExecutor(context)("storage.volumes.delete", input),
+    vnext: {
+      arguments: "semantic",
+      audience: "customer",
+      category: "resource",
+      outcome: "Delete one detached volume after explicit consent.",
+      human: "ornn volumes delete <volume>",
+      automation: "ornn volumes delete <volume-id>  --idempotency-key <key> --format json",
+      acceptedReferences: ["canonical volume ID", "exact unique volume name"],
+      review: "The volume and all of its data are permanently deleted.",
+      related: ["volume-mounts detach", "volumes show"]
+    }
+  }
+});
+var volumeCapabilities = [
+  volumeListCapability,
+  volumeShowCapability,
+  volumeCreateCapability,
+  volumeRefreshCapability,
+  volumeClearCapability,
+  volumeDeleteCapability,
   volumeFilesListCapability,
   storageCapability({
     id: "storage.volumes.files.upload",
@@ -6610,8 +6724,6 @@ var volumeCapabilities = [
 ];
 var reservationInput2 = z32.object({ reservationId: z32.string() });
 var reservationWrite = reservationInput2.extend({ confirm: z32.boolean().optional() });
-var driveInput = z32.object({ driveId: z32.string() });
-var driveWrite = driveInput.extend({ confirm: z32.boolean().optional() });
 var bucketConnectInput = z32.object({
   provider: z32.enum(["gcs", "s3", "r2"]),
   bucket: z32.string(),
@@ -6675,92 +6787,6 @@ var storageVerbCapabilities = [
     slack: false,
     execute: (ctx) => listStorageTargets(ctx.fetch)
   }),
-  defineCapability({
-    id: "volume.list",
-    domain: "storage",
-    roles: ["user"],
-    description: "List a page of storage volumes, newest updated first. Pass next_cursor as cursor to continue.",
-    mutation: "read",
-    input: z32.object({
-      limit: z32.number().int().min(1).max(100).optional(),
-      cursor: z32.string().optional()
-    }),
-    mcp: { name: "storage_volumes_list" },
-    slack: false,
-    execute: (ctx, input) => listDrives(ctx.fetch, {
-      limit: input.limit ?? 25,
-      ...input.cursor ? { cursor: input.cursor } : {}
-    })
-  }),
-  defineCapability({
-    id: "volume.show",
-    domain: "storage",
-    roles: ["user"],
-    description: "Show a single storage volume (drive) by id.",
-    mutation: "read",
-    input: driveInput,
-    mcp: { name: "storage_volumes_show" },
-    slack: false,
-    execute: (ctx, input) => getDrive(ctx.fetch, input.driveId)
-  }),
-  defineCapability({
-    id: "volume.create",
-    domain: "storage",
-    roles: ["user"],
-    description: "Create a storage volume (drive), optionally cloned from an existing source drive.",
-    mutation: "preview-confirm",
-    input: z32.object({
-      name: z32.string(),
-      sourceDriveId: z32.string().optional(),
-      confirm: z32.boolean().optional()
-    }),
-    mcp: { name: "storage_volumes_create" },
-    slack: false,
-    execute: (ctx, input) => createDrive(ctx.fetch, {
-      name: input.name,
-      source_drive_id: input.sourceDriveId ?? null
-    })
-  }),
-  defineCapability({
-    id: "volume.refresh",
-    domain: "storage",
-    roles: ["user"],
-    description: "Refresh a storage volume's (drive's) reported usage/state.",
-    mutation: "preview-confirm",
-    input: driveWrite,
-    mcp: { name: "storage_volumes_refresh" },
-    slack: false,
-    execute: (ctx, input) => getDrive(ctx.fetch, input.driveId, { refresh: true })
-  }),
-  defineCapability({
-    id: "volume.clear",
-    domain: "storage",
-    roles: ["user"],
-    description: "Clear (empty) a storage volume's (drive's) contents without deleting the drive.",
-    mutation: "preview-confirm",
-    input: driveWrite,
-    mcp: { name: "storage_volumes_clear" },
-    slack: false,
-    // The route answers 204, so report which volume was cleared.
-    execute: async (ctx, input) => {
-      await clearDriveContents(ctx.fetch, input.driveId);
-      return { cleared: true, drive_id: input.driveId };
-    }
-  }),
-  defineCapability({
-    id: "volume.delete",
-    domain: "storage",
-    roles: ["user"],
-    description: "Delete a storage volume (drive).",
-    mutation: "preview-confirm",
-    input: driveWrite,
-    mcp: { name: "storage_volumes_delete" },
-    slack: false,
-    execute: async (ctx, input) => {
-      await deleteDrive(ctx.fetch, input.driveId);
-      return { deleted: true, drive_id: input.driveId };
-    }
-  }),
   defineCapability({
     id: "bucket.connect",
     domain: "storage",
@@ -7158,7 +7184,13 @@ export {
   sshKeyDeleteCapability,
   sshKeyDeliveryStatus,
   sshKeyListCapability,
+  volumeClearCapability,
+  volumeCreateCapability,
+  volumeDeleteCapability,
   volumeFilesListCapability,
+  volumeListCapability,
+  volumeRefreshCapability,
+  volumeShowCapability,
   vpnConnectionConfigureCapability,
   vpnConnectionDisconnectCapability,
   vpnConnectionListCapability