@ours.network/cli 0.1.0 → 0.1.1

package/dist/operations.d.ts

@@ -1,10 +1,21 @@
 import type { OursClient } from '@ours.network/sdk/client';
-type FieldKind = 'string' | 'boolean' | 'integer' | 'string[]' | 'integer[]' | 'cursor';
-interface FieldSpec {
+export type FieldKind = 'string' | 'boolean' | 'integer' | 'string[]' | 'integer[]' | 'cursor';
+export interface FieldSpec {
     kind: FieldKind;
+    help: string;
+    valueName: string;
     required?: boolean;
     values?: readonly string[];
     positive?: boolean;
+    allowEmpty?: boolean;
+}
+export interface OperationSpec {
+    method: keyof OursClient;
+    fields: Readonly<Record<string, FieldSpec>>;
+    summary: string;
+    effects: string;
+    exampleInput?: Readonly<Record<string, unknown>>;
+    refine?: (input: Record<string, unknown>) => void;
 }
 export declare const OPERATION_SPECS: {
     readonly 'create-identity': {
@@ -15,6 +26,14 @@ export declare const OPERATION_SPECS: {
             readonly exposeLocal: FieldSpec;
             readonly localAutoAccept: FieldSpec;
         };
+        readonly summary: "Create a persistent identity and bind this CLI session to it.";
+        readonly effects: "Writes identity state. With a Human identity, the new identity becomes its role; otherwise the first persistent identity becomes the Human identity.";
+        readonly exampleInput: {
+            readonly name: "BuildBot";
+            readonly bio: "Build coordinator";
+            readonly exposeLocal: true;
+            readonly localAutoAccept: true;
+        };
     };
     readonly 'create-temporary-identity': {
         readonly method: "createTemporaryIdentity";
@@ -24,12 +43,25 @@ export declare const OPERATION_SPECS: {
             readonly exposeLocal: FieldSpec;
             readonly localAutoAccept: FieldSpec;
         };
+        readonly summary: "Create and bind a session-owned temporary identity.";
+        readonly effects: "Writes temporary identity state. Session teardown or lease release closes it, sends best-effort remove-me notices, and permanently deletes its local state.";
+        readonly exampleInput: {
+            readonly name: "ScratchBot";
+            readonly bio: "Short-lived test operator";
+            readonly exposeLocal: false;
+            readonly localAutoAccept: true;
+        };
     };
     readonly 'close-temporary-identity': {
         readonly method: "closeTemporaryIdentityOp";
         readonly fields: {
             readonly name: FieldSpec;
         };
+        readonly summary: "Close a temporary identity owned by this session, or reclaim one whose owner is stale.";
+        readonly effects: "Destructive: queues best-effort remove-me notices and permanently deletes local identity state. A live owner cannot be evicted.";
+        readonly exampleInput: {
+            readonly name: "ScratchBot";
+        };
     };
     readonly 'create-root-identity': {
         readonly method: "createRootIdentity";
@@ -40,6 +72,15 @@ export declare const OPERATION_SPECS: {
             readonly localAutoAccept: FieldSpec;
             readonly skipIfRootExists: FieldSpec;
         };
+        readonly summary: "Create the host Human identity and bind this CLI session to it.";
+        readonly effects: "Writes identity state and may adopt existing persistent identities as roles. If a Human identity already exists, a non-skipped creation becomes a role under it.";
+        readonly exampleInput: {
+            readonly name: "Alice@laptop";
+            readonly bio: "Alice on laptop";
+            readonly exposeLocal: true;
+            readonly localAutoAccept: true;
+            readonly skipIfRootExists: true;
+        };
     };
     readonly 'define-local-identity-file': {
         readonly method: "defineLocalIdentityFile";
@@ -51,6 +92,16 @@ export declare const OPERATION_SPECS: {
             readonly localAutoAccept: FieldSpec;
             readonly overwrite: FieldSpec;
         };
+        readonly summary: "Write an advisory .ours-identity workspace pin.";
+        readonly effects: "Writes only the workspace pin file. It does not create or bind an identity.";
+        readonly exampleInput: {
+            readonly name: "BuildBot";
+            readonly path: "/srv/project";
+            readonly force: false;
+            readonly exposeLocal: true;
+            readonly localAutoAccept: true;
+            readonly overwrite: false;
+        };
     };
     readonly 'choose-identity': {
         readonly method: "chooseIdentity";
@@ -58,24 +109,41 @@ export declare const OPERATION_SPECS: {
             readonly name: FieldSpec;
             readonly force: FieldSpec;
         };
+        readonly summary: "Bind an existing identity to this CLI lease.";
+        readonly effects: "Changes lease ownership. Force can evict another live session; temporary identities still enforce their session owner.";
+        readonly exampleInput: {
+            readonly name: "BuildBot";
+            readonly force: false;
+        };
     };
     readonly 'list-identities': {
         readonly method: "listIdentities";
         readonly fields: {};
+        readonly summary: "List identities, hierarchy, temporary ownership, and lease state.";
+        readonly effects: "Read-only.";
     };
     readonly 'current-identity': {
         readonly method: "currentIdentity";
         readonly fields: {};
+        readonly summary: "Show the identity bound to this CLI lease, including its profile and hierarchy.";
+        readonly effects: "Read-only.";
     };
     readonly 'remove-identity': {
         readonly method: "removeIdentity";
         readonly fields: {
             readonly name: FieldSpec;
         };
+        readonly summary: "Permanently remove an identity.";
+        readonly effects: "Destructive: deletes local identity state. A Human identity cannot be removed while it still has roles; temporary identities follow their close lifecycle.";
+        readonly exampleInput: {
+            readonly name: "OldBot";
+        };
     };
     readonly 'release-lease': {
         readonly method: "releaseLease";
         readonly fields: {};
+        readonly summary: "Release every identity lease held by this CLI client token.";
+        readonly effects: "Changes lease state. Owned temporary identities begin asynchronous permanent closure and best-effort contact notification.";
     };
     readonly 'generate-invite': {
         readonly method: "generateInvite";
@@ -83,16 +151,29 @@ export declare const OPERATION_SPECS: {
             readonly name: FieldSpec;
             readonly mode: FieldSpec;
         };
+        readonly summary: "Generate encrypted contact-introduction material for out-of-band sharing.";
+        readonly effects: "Creates an outstanding invite. Omitted mode defaults to one_time; public invites cannot pre-assign a name.";
+        readonly exampleInput: {
+            readonly name: "Peer";
+            readonly mode: "one_time";
+        };
     };
     readonly 'list-invites': {
         readonly method: "listInvites";
         readonly fields: {};
+        readonly summary: "List outstanding one-time and public invites.";
+        readonly effects: "Read-only.";
     };
     readonly 'revoke-invite': {
         readonly method: "revokeInvite";
         readonly fields: {
             readonly invite_id: FieldSpec;
         };
+        readonly summary: "Revoke an outstanding invite.";
+        readonly effects: "Destructive and idempotent. It prevents future redemption but does not remove existing contacts.";
+        readonly exampleInput: {
+            readonly invite_id: "INVITE_ID";
+        };
     };
     readonly 'add-contact': {
         readonly method: "addContact";
@@ -100,14 +181,24 @@ export declare const OPERATION_SPECS: {
             readonly invite: FieldSpec;
             readonly name: FieldSpec;
         };
+        readonly summary: "Redeem an invite and begin an encrypted contact handshake.";
+        readonly effects: "Sends the first handshake leg. The contact remains pending until the inviter verifies and replies.";
+        readonly exampleInput: {
+            readonly invite: "<invite-from-peer>";
+            readonly name: "Peer";
+        };
     };
     readonly 'list-contacts': {
         readonly method: "listContacts";
         readonly fields: {};
+        readonly summary: "List established contacts and pending local introductions.";
+        readonly effects: "Read-only.";
     };
     readonly 'list-local-contact-book': {
         readonly method: "listLocalContactBook";
         readonly fields: {};
+        readonly summary: "List same-host identities published for invite-free introduction.";
+        readonly effects: "Read-only.";
     };
     readonly 'set-local-book-policy': {
         readonly method: "setLocalBookPolicy";
@@ -115,6 +206,12 @@ export declare const OPERATION_SPECS: {
             readonly expose: FieldSpec;
             readonly auto_accept: FieldSpec;
         };
+        readonly summary: "Change local contact-book exposure and/or introduction approval policy.";
+        readonly effects: "Writes identity-local policy. At least one of expose or auto_accept is required.";
+        readonly exampleInput: {
+            readonly expose: true;
+            readonly auto_accept: false;
+        };
         readonly refine: (a: Record<string, unknown>) => void;
     };
     readonly 'remove-contact': {
@@ -122,6 +219,11 @@ export declare const OPERATION_SPECS: {
         readonly fields: {
             readonly contact: FieldSpec;
         };
+        readonly summary: "Forget a contact locally.";
+        readonly effects: "Destructive: removes the local contact and queues one best-effort remove-me notice; remote deletion is not guaranteed.";
+        readonly exampleInput: {
+            readonly contact: "OldPeer";
+        };
     };
     readonly 'rename-contact': {
         readonly method: "renameContact";
@@ -129,6 +231,12 @@ export declare const OPERATION_SPECS: {
             readonly contact: FieldSpec;
             readonly name: FieldSpec;
         };
+        readonly summary: "Rename a contact locally without changing keys or the encrypted channel.";
+        readonly effects: "Changes only the local display name.";
+        readonly exampleInput: {
+            readonly contact: "Peer";
+            readonly name: "PeerLaptop";
+        };
     };
     readonly 'respond-to-introduction': {
         readonly method: "respondToIntroduction";
@@ -136,18 +244,34 @@ export declare const OPERATION_SPECS: {
             readonly contact: FieldSpec;
             readonly action: FieldSpec;
         };
+        readonly summary: "Approve or reject a queued local introduction.";
+        readonly effects: "Approval establishes the contact and moves queued messages into the inbox; rejection drops the queue.";
+        readonly exampleInput: {
+            readonly contact: "LocalBot";
+            readonly action: "approve";
+        };
     };
     readonly 'set-bio': {
         readonly method: "setBio";
         readonly fields: {
             readonly bio: FieldSpec;
         };
+        readonly summary: "Replace the bound identity’s public bio.";
+        readonly effects: "Writes public profile state. Updating a Human identity also refreshes its profile in role delegation chains.";
+        readonly exampleInput: {
+            readonly bio: "Build coordinator";
+        };
     };
     readonly 'set-persona': {
         readonly method: "setPersona";
         readonly fields: {
             readonly persona: FieldSpec;
         };
+        readonly summary: "Replace the bound identity’s local persona.";
+        readonly effects: "Writes local profile state. Personas are not shared in invites.";
+        readonly exampleInput: {
+            readonly persona: "Handle build coordination only.";
+        };
     };
     readonly 'send-message': {
         readonly method: "sendMessage";
@@ -157,6 +281,12 @@ export declare const OPERATION_SPECS: {
             readonly reply_to_wire_id: FieldSpec;
             readonly reply_to_sentence: FieldSpec;
         };
+        readonly summary: "Send an end-to-end-encrypted text message.";
+        readonly effects: "Sends data. A verified same-host identity may be introduced automatically when it is not already a contact.";
+        readonly exampleInput: {
+            readonly contact: "Peer";
+            readonly text: "Build finished.";
+        };
     };
     readonly 'send-file': {
         readonly method: "sendFile";
@@ -169,77 +299,132 @@ export declare const OPERATION_SPECS: {
             readonly reply_to_wire_id: FieldSpec;
             readonly reply_to_sentence: FieldSpec;
         };
+        readonly summary: "Send an end-to-end-encrypted file from a path or inline base64.";
+        readonly effects: "Reads the selected local file when path is used and sends bytes. Exactly one of path or data_base64 is required; data_base64 also requires filename.";
+        readonly exampleInput: {
+            readonly contact: "Peer";
+            readonly path: "/tmp/report.pdf";
+        };
         readonly refine: (a: Record<string, unknown>) => void;
     };
     readonly 'list-incoming-messages': {
         readonly method: "listIncomingMessages";
         readonly fields: {};
+        readonly summary: "List inbox metadata and status without revealing message bodies.";
+        readonly effects: "Read-only; message status is unchanged.";
     };
     readonly 'get-messages': {
         readonly method: "getMessages";
         readonly fields: {};
+        readonly summary: "Return every unread message body and mark those messages processed.";
+        readonly effects: "Mutates inbox status. This is the only message-body read and is exactly-once unless the returned message IDs are deferred.";
     };
     readonly 'defer-messages': {
         readonly method: "deferMessages";
         readonly fields: {
             readonly msg_ids: FieldSpec;
         };
+        readonly summary: "Return processed messages to the unread queue.";
+        readonly effects: "Mutates inbox status.";
+        readonly exampleInput: {
+            readonly msg_ids: readonly [12, 13];
+        };
     };
     readonly 'defer-files': {
         readonly method: "deferFiles";
         readonly fields: {
             readonly file_ids: FieldSpec;
         };
+        readonly summary: "Return processed files to the unread queue.";
+        readonly effects: "Mutates inbox status; already-unread files are left unchanged.";
+        readonly exampleInput: {
+            readonly file_ids: readonly [4, 5];
+        };
     };
     readonly 'get-conversation': {
         readonly method: "getConversation";
         readonly fields: {
             readonly contact: FieldSpec;
         };
+        readonly summary: "Show retained conversation history with one contact, oldest first.";
+        readonly effects: "Read-only. It is empty when history retention is disabled.";
+        readonly exampleInput: {
+            readonly contact: "Peer";
+        };
     };
     readonly 'get-receipts': {
         readonly method: "getReceipts";
         readonly fields: {
             readonly contact: FieldSpec;
         };
+        readonly summary: "Show delivered/read receipts received for sent messages.";
+        readonly effects: "Read-only. Receipts are retained only when conversation history is enabled.";
+        readonly exampleInput: {
+            readonly contact: "Peer";
+        };
     };
     readonly 'mark-read': {
         readonly method: "markRead";
         readonly fields: {
             readonly contact: FieldSpec;
         };
+        readonly summary: "Mark unread inbound entries in one conversation as read.";
+        readonly effects: "Mutates conversation state and sends read receipts for newly marked messages.";
+        readonly exampleInput: {
+            readonly contact: "Peer";
+        };
     };
     readonly 'set-conversation-policy': {
         readonly method: "setConversationPolicy";
         readonly fields: {
             readonly keep_history: FieldSpec;
         };
+        readonly summary: "Set conversation-history policy for the bound identity.";
+        readonly effects: "Writes identity-local policy. Existing contacts learn newly enabled receipt capability on later outbound traffic.";
+        readonly exampleInput: {
+            readonly keep_history: true;
+        };
     };
     readonly 'list-incoming-files': {
         readonly method: "listIncomingFiles";
         readonly fields: {};
+        readonly summary: "List incoming-file metadata for authorization.";
+        readonly effects: "Read-only: returns no bytes and does not change file status. Authorize using the authenticated sender ID, not its display name.";
     };
     readonly 'get-files': {
         readonly method: "getFiles";
         readonly fields: {
             readonly wire_ids: FieldSpec;
         };
+        readonly summary: "Write approved unread files into the bound identity’s files directory.";
+        readonly effects: "Writes received bytes and marks retrieved files processed. An explicit selection must contain 1–32 unique 64-hex wire IDs.";
+        readonly exampleInput: {
+            readonly wire_ids: readonly ["0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"];
+        };
     };
     readonly version: {
         readonly method: "version";
         readonly fields: {};
+        readonly summary: "Show the selected daemon’s version and protocol information.";
+        readonly effects: "Read-only.";
     };
     readonly 'state-dir': {
         readonly method: "stateDir";
         readonly fields: {};
+        readonly summary: "Show the selected daemon’s canonical state directory.";
+        readonly effects: "Read-only.";
     };
     readonly identities: {
         readonly method: "identities";
         readonly fields: {};
+        readonly summary: "Show the selected daemon’s identity summary.";
+        readonly effects: "Read-only.";
     };
     readonly unread: {
         readonly method: "unread";
         readonly fields: {};
+        readonly summary: "Show body-free unread counts and sender metadata.";
+        readonly effects: "Read-only; it never reveals message bodies or changes inbox status.";
     };
     readonly 'watch-notifications': {
         readonly method: "watchNotifications";
@@ -247,21 +432,36 @@ export declare const OPERATION_SPECS: {
             readonly identity: FieldSpec;
             readonly since: {
                 readonly kind: "cursor";
+                readonly help: "Byte cursor to resume from, or tip to wait only for new events; omitted defaults to tip.";
+                readonly valueName: "N|tip";
             };
         };
+        readonly summary: "Stream body-free notification events until interrupted.";
+        readonly effects: "Long-running read. It does not reveal message bodies or change inbox status.";
+        readonly exampleInput: {
+            readonly identity: "BuildBot";
+            readonly since: "tip";
+        };
     };
     readonly 'fetch-file': {
         readonly method: "fetchFile";
         readonly fields: {
             readonly wire_id: FieldSpec;
         };
+        readonly summary: "Return one already-stored received file as base64.";
+        readonly effects: "Read-only; file bytes are emitted in the command result, so protect redirected output.";
+        readonly exampleInput: {
+            readonly wire_id: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+        };
     };
 };
 export type OperationName = keyof typeof OPERATION_SPECS;
 export declare const operationNames: () => OperationName[];
 export declare const isOperationName: (value: string) => value is OperationName;
 export declare function parseOperationJson(raw: string | undefined, operation: OperationName): Record<string, unknown>;
+export declare const fieldFlag: (name: string) => string;
+export declare function operationSpec(operation: OperationName): OperationSpec;
 export declare function operationValueFlags(operation: OperationName): Set<string>;
+export declare function operationEmptyValueFlags(operation: OperationName): Set<string>;
 export declare function operationInputFromFlags(operation: OperationName, values: Record<string, string>, defaults?: Record<string, unknown>): Record<string, unknown>;
 export declare function invokeOperation(client: OursClient, operation: OperationName, input: Record<string, unknown>): Promise<unknown>;
-export {};

package/dist/operations.js

@@ -1,19 +1,25 @@
 import {
   OPERATION_SPECS,
+  fieldFlag,
   invokeOperation,
   isOperationName,
+  operationEmptyValueFlags,
   operationInputFromFlags,
   operationNames,
+  operationSpec,
   operationValueFlags,
   parseOperationJson
-} from "./chunk-IUZOQT4D.js";
-import "./chunk-AXXFFER2.js";
+} from "./chunk-QRNZFPNJ.js";
+import "./chunk-6NFATG6P.js";
 export {
   OPERATION_SPECS,
+  fieldFlag,
   invokeOperation,
   isOperationName,
+  operationEmptyValueFlags,
   operationInputFromFlags,
   operationNames,
+  operationSpec,
   operationValueFlags,
   parseOperationJson
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Transport-neutral operator CLI for the ours shared daemon",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",

package/dist/chunk-IUZOQT4D.js

@@ -1,152 +0,0 @@
-import {
-  CliUsageError,
-  parseBoolean
-} from "./chunk-AXXFFER2.js";
-
-// src/operations.ts
-var str = (required = false, values) => ({ kind: "string", required, values });
-var bool = (required = false) => ({ kind: "boolean", required });
-var integer = (required = false, positive = false) => ({ kind: "integer", required, positive });
-var strings = (required = false) => ({ kind: "string[]", required });
-var integers = (required = false) => ({ kind: "integer[]", required });
-var none = {};
-var OPERATION_SPECS = {
-  "create-identity": { method: "createIdentity", fields: { name: str(true), bio: str(true), exposeLocal: bool(true), localAutoAccept: bool(true) } },
-  "create-temporary-identity": { method: "createTemporaryIdentity", fields: { name: str(), bio: str(true), exposeLocal: bool(true), localAutoAccept: bool(true) } },
-  "close-temporary-identity": { method: "closeTemporaryIdentityOp", fields: { name: str() } },
-  "create-root-identity": { method: "createRootIdentity", fields: { name: str(true), bio: str(true), exposeLocal: bool(true), localAutoAccept: bool(true), skipIfRootExists: bool(true) } },
-  "define-local-identity-file": { method: "defineLocalIdentityFile", fields: { name: str(true), path: str(true), force: bool(true), exposeLocal: bool(true), localAutoAccept: bool(true), overwrite: bool(true) } },
-  "choose-identity": { method: "chooseIdentity", fields: { name: str(true), force: bool(true) } },
-  "list-identities": { method: "listIdentities", fields: none },
-  "current-identity": { method: "currentIdentity", fields: none },
-  "remove-identity": { method: "removeIdentity", fields: { name: str(true) } },
-  "release-lease": { method: "releaseLease", fields: none },
-  "generate-invite": { method: "generateInvite", fields: { name: str(), mode: str(false, ["one_time", "public"]) } },
-  "list-invites": { method: "listInvites", fields: none },
-  "revoke-invite": { method: "revokeInvite", fields: { invite_id: str(true) } },
-  "add-contact": { method: "addContact", fields: { invite: str(true), name: str() } },
-  "list-contacts": { method: "listContacts", fields: none },
-  "list-local-contact-book": { method: "listLocalContactBook", fields: none },
-  "set-local-book-policy": {
-    method: "setLocalBookPolicy",
-    fields: { expose: bool(), auto_accept: bool() },
-    refine: (a) => {
-      if (a.expose === void 0 && a.auto_accept === void 0) throw new CliUsageError("set-local-book-policy requires expose and/or auto_accept");
-    }
-  },
-  "remove-contact": { method: "removeContact", fields: { contact: str(true) } },
-  "rename-contact": { method: "renameContact", fields: { contact: str(true), name: str(true) } },
-  "respond-to-introduction": { method: "respondToIntroduction", fields: { contact: str(true), action: str(true, ["approve", "reject"]) } },
-  "set-bio": { method: "setBio", fields: { bio: str(true) } },
-  "set-persona": { method: "setPersona", fields: { persona: str(true) } },
-  "send-message": { method: "sendMessage", fields: { contact: str(true), text: str(true), reply_to_wire_id: str(), reply_to_sentence: integer(false, true) } },
-  "send-file": {
-    method: "sendFile",
-    fields: { contact: str(true), path: str(), data_base64: str(), filename: str(), mime: str(), reply_to_wire_id: str(), reply_to_sentence: integer(false, true) },
-    refine: (a) => {
-      if (a.path === void 0 === (a.data_base64 === void 0)) throw new CliUsageError("send-file requires exactly one of path or data_base64");
-      if (a.data_base64 !== void 0 && a.filename === void 0) throw new CliUsageError("send-file requires filename with data_base64");
-    }
-  },
-  "list-incoming-messages": { method: "listIncomingMessages", fields: none },
-  "get-messages": { method: "getMessages", fields: none },
-  "defer-messages": { method: "deferMessages", fields: { msg_ids: integers(true) } },
-  "defer-files": { method: "deferFiles", fields: { file_ids: integers(true) } },
-  "get-conversation": { method: "getConversation", fields: { contact: str(true) } },
-  "get-receipts": { method: "getReceipts", fields: { contact: str(true) } },
-  "mark-read": { method: "markRead", fields: { contact: str(true) } },
-  "set-conversation-policy": { method: "setConversationPolicy", fields: { keep_history: bool(true) } },
-  "list-incoming-files": { method: "listIncomingFiles", fields: none },
-  "get-files": { method: "getFiles", fields: { wire_ids: strings() } },
-  version: { method: "version", fields: none },
-  "state-dir": { method: "stateDir", fields: none },
-  identities: { method: "identities", fields: none },
-  unread: { method: "unread", fields: none },
-  "watch-notifications": { method: "watchNotifications", fields: { identity: str(true), since: { kind: "cursor" } } },
-  "fetch-file": { method: "fetchFile", fields: { wire_id: str(true) } }
-};
-var operationNames = () => Object.keys(OPERATION_SPECS).sort();
-var isOperationName = (value) => Object.prototype.hasOwnProperty.call(OPERATION_SPECS, value);
-function validateInput(input, operation) {
-  const spec = OPERATION_SPECS[operation];
-  for (const key of Object.keys(input)) {
-    if (!Object.prototype.hasOwnProperty.call(spec.fields, key)) throw new CliUsageError(`${operation}: unknown input field ${JSON.stringify(key)}`);
-  }
-  for (const [name, field] of Object.entries(spec.fields)) {
-    const item = input[name];
-    if (item === void 0) {
-      if (field.required) throw new CliUsageError(`${operation}: missing required input field ${JSON.stringify(name)}`);
-      continue;
-    }
-    let valid = false;
-    if (field.kind === "string") valid = typeof item === "string" && (field.values === void 0 || field.values.includes(item));
-    else if (field.kind === "boolean") valid = typeof item === "boolean";
-    else if (field.kind === "integer") valid = Number.isSafeInteger(item) && (!field.positive || Number(item) >= 1);
-    else if (field.kind === "string[]") valid = Array.isArray(item) && item.every((v) => typeof v === "string");
-    else if (field.kind === "integer[]") valid = Array.isArray(item) && item.every((v) => Number.isSafeInteger(v));
-    else valid = item === "tip" || Number.isSafeInteger(item) && Number(item) >= 0;
-    if (!valid) {
-      const expected = field.values ? field.values.map((value) => JSON.stringify(value)).join(" or ") : field.kind;
-      throw new CliUsageError(`${operation}: input field ${JSON.stringify(name)} must be ${expected}`);
-    }
-  }
-  spec.refine?.(input);
-  return input;
-}
-function parseOperationJson(raw, operation) {
-  let value = {};
-  if (raw !== void 0) {
-    try {
-      value = JSON.parse(raw);
-    } catch (error) {
-      throw new CliUsageError(`--input is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new CliUsageError("--input must be a JSON object");
-  return validateInput(value, operation);
-}
-var fieldFlag = (name) => `--${name.replaceAll("_", "-").replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}`;
-function operationValueFlags(operation) {
-  return new Set(Object.keys(OPERATION_SPECS[operation].fields).map(fieldFlag));
-}
-function operationInputFromFlags(operation, values, defaults = {}) {
-  const input = { ...defaults };
-  for (const [name, field] of Object.entries(OPERATION_SPECS[operation].fields)) {
-    const flag = fieldFlag(name);
-    const raw = values[flag];
-    if (raw === void 0) continue;
-    if (field.kind === "boolean") input[name] = parseBoolean(raw, flag);
-    else if (field.kind === "integer") input[name] = parseCliInteger(raw, flag, field.positive === true);
-    else if (field.kind === "integer[]") input[name] = raw === "" ? [] : raw.split(",").map((v) => parseCliInteger(v, flag));
-    else if (field.kind === "string[]") input[name] = raw === "" ? [] : raw.split(",");
-    else if (field.kind === "cursor") input[name] = raw === "tip" ? "tip" : parseCliInteger(raw, flag);
-    else input[name] = raw;
-  }
-  return validateInput(input, operation);
-}
-function parseCliInteger(raw, flag, positive = false) {
-  if (!/^[0-9]+$/.test(raw)) throw new CliUsageError(`${flag} must be an integer`);
-  const value = Number(raw);
-  if (!Number.isSafeInteger(value) || positive && value < 1) throw new CliUsageError(`${flag} is outside the supported integer range`);
-  return value;
-}
-async function invokeOperation(client, operation, input) {
-  if (operation === "watch-notifications") throw new Error("watch-notifications is a streaming operation");
-  if (operation === "fetch-file") {
-    const bytes = await client.fetchFile(input.wire_id);
-    return { wire_id: input.wire_id, bytes: bytes.byteLength, data_base64: Buffer.from(bytes).toString("base64") };
-  }
-  const spec = OPERATION_SPECS[operation];
-  const fn = client[spec.method];
-  return Object.keys(spec.fields).length === 0 ? fn.call(client) : fn.call(client, input);
-}
-
-export {
-  OPERATION_SPECS,
-  operationNames,
-  isOperationName,
-  parseOperationJson,
-  operationValueFlags,
-  operationInputFromFlags,
-  invokeOperation
-};