@andocorp/cli 0.1.3 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ando Corp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,11 +1,10 @@
 # Ando CLI
 
-`ando` is a terminal client for humans and agents.
+`ando` provides agent-first terminal commands for Ando. It is built on the
+public `@andocorp/sdk` package and authenticates with an Ando API key.
 
 ## Installation
 
-### npm (Recommended)
-
 ```sh
 npm install -g @andocorp/cli
 ```
@@ -16,75 +15,129 @@ Or run without installing:
 npx @andocorp/cli
 ```
 
-### Alternative: Standalone Binaries
-
-Standalone binaries are available for users who prefer not to install Node.js/npm. Contact hello@ando.so for access.
-
-## Commands
+## Authentication
 
-Open the interactive terminal UI:
+Log in once:
 
 ```sh
-ando
+ando login
 ```
 
-Show help:
+The command opens a browser authorization page, prints a verification code to
+confirm in the browser, and stores the returned API key in the system keyring
+by default. Non-secret metadata is stored at `~/.config/ando/config.json`.
+
+For remote shells or agents that cannot open a browser directly, start a
+two-step login:
 
 ```sh
-ando help
-ando --help
+ando login --no-browser
 ```
 
-List channels:
+Open the printed URL, confirm the verification code, then run the printed
+`ando login poll` command in the original shell to finish authentication.
+
+For headless scripts and CI, provide an API key directly:
 
 ```sh
-ando list-channels
-ando list-channels --json
+ando login --api-key ando_sk_...
 ```
 
-List direct-message conversations:
+You can also set `ANDO_API_KEY` for one-off or CI usage.
 
-```sh
-ando list-dms
-ando list-dms --json
-```
+Set `ANDO_KEYRING=0` to use file-based auth instead of the system keyring. In
+that mode the API key is stored in `auth.json` under the Ando config directory.
+Set `ANDO_HOME` to override the config and auth state directory; otherwise the
+CLI uses the platform config directory.
+
+Optional endpoint flags:
 
-List messages from a channel, DM, or conversation id:
+- `--base-url`: login and SDK REST base URL
+- `--api-host`: public API base URL for agent-first commands
+- `--realtime-host`: realtime host for SDK subscriptions
+
+Check local auth health or remove local credentials:
 
 ```sh
-ando list-messages --channel engineering
-ando list-messages --dm alex
-ando list-messages --conversation <conversation-id>
-ando list-messages --channel engineering --limit 20
-ando list-messages -c engineering -n 20 --json
+ando doctor
+ando doctor --json
+ando whoami
+ando whoami --json
+ando logout
 ```
 
-Read a thread by message id:
+`ando whoami` prints the member and workspace resolved by the active API key.
+`ando logout` revokes browser-created CLI credentials before removing local auth
+state. API keys supplied manually or through `ANDO_API_KEY` remain local-only.
+
+## Commands
+
+The raw public API escape hatch mirrors the generated Ando API surface. It is
+useful for scripts and agents that need an endpoint before a dedicated CLI
+workflow exists.
 
 ```sh
-ando thread --message-id <message-id>
-ando thread -m <message-id> --json
+ando api ls
+ando api ls --json
+ando api searchMessages q==incident mode==semantic
+ando api getMember memberId=<member-id>
+ando api /v1/search/messages q==incident mode==semantic
+ando api /v1/conversations/<conversation-id>/messages \
+  markdown_content="hello" \
+  Idempotency-Key:<key>
+echo '{"markdown_content":"hello"}' | ando api /v1/conversations/<conversation-id>/messages --data -
+ando api /v1/search/messages --help
+ando api /v1/search/messages --spec
 ```
 
-Post a new message to a channel, DM, or conversation id:
+`ando api` accepts `name==value` query parameters, `Header:Value` declared
+request headers, `field=value` JSON string body fields, `field:=json` typed JSON
+body fields, and `--data <json|->` for complete request bodies. The target can
+be a public path or an operation ID from `ando api ls`; query and header names
+are validated against the generated public API metadata. For operation ID
+targets, supply required path parameters as `name=value`.
 
 ```sh
-ando post-message --channel engineering --text "hello"
-ando post-message --dm alex --text "want to pair?"
-ando post-message --conversation <conversation-id> --text "status update"
-ando post-message -c engineering -t "hello" --json
+ando messages --channel engineering --limit 10
+ando messages -c engineering -m 10
+ando messages --dm alex --before <cursor> --json
+ando messages --conversation <conversation-id>
 ```
 
-Reply inside an existing thread:
-
 ```sh
-ando reply --message-id <message-id> --text "on it"
-ando reply -m <message-id> -t "on it" --json
+ando search "incident"
+ando search "alice" --type members
+ando search "standup" --type conversations
+ando search "launch checklist" --type clipboard
+ando search "migration" --type calls --after 2026-01-01T00:00:00.000Z
 ```
 
-Add a reaction to a message:
+```sh
+ando get message <message-id>
+ando get member <member-id>
+ando get clipboard <clipboard-id>
+ando get call <call-id>
+ando get transcript <call-id> --limit 100 --cursor <cursor>
+```
 
 ```sh
-ando react --message-id <message-id> --emoji 👍
-ando react -m <message-id> -e 👍 --json
+ando thread <thread-root-message-id>
+ando thread <thread-root-message-id> --limit 50 --after <cursor>
+ando thread -m <message-id> --json
 ```
+
+Every agent-first command supports `--json` for machine-readable output.
+Without `--json`, commands print tab-separated rows.
+
+## Environment
+
+- `ANDO_API_KEY`: API key for SDK and public API requests
+- `ANDO_KEYRING`: set to `0` to use file-based auth instead of keyring
+- `ANDO_HOME`: config and auth state directory
+- `ANDO_BASE_URL`: login and SDK REST base URL
+- `ANDO_API_HOST`: public API base URL for agent-first commands
+- `ANDO_REALTIME_HOST`: realtime host for SDK subscriptions
+- `XDG_CONFIG_HOME`: fallback base directory for config/auth state
+
+Flags take precedence over environment variables, and environment variables
+take precedence over saved config.

package/dist/agent-commands.js

@@ -0,0 +1,297 @@
+import { getStringFlag, hasFlag } from "./args.js";
+import { resolveConversation } from "./cli-helpers.js";
+import { printJson } from "./output.js";
+async function resolveConversationId(cliClient, parsedArgs) {
+    const channelQuery = getStringFlag(parsedArgs, "channel", "c");
+    const dmQuery = getStringFlag(parsedArgs, "dm", "d");
+    const conversationQuery = getStringFlag(parsedArgs, "conversation");
+    if (conversationQuery != null && channelQuery == null && dmQuery == null) {
+        return conversationQuery;
+    }
+    const query = channelQuery ?? dmQuery ?? conversationQuery;
+    if (query == null) {
+        throw new Error("messages requires --channel, --dm, or --conversation.");
+    }
+    const memberships = await cliClient.getAllMemberships();
+    const membership = resolveConversation(memberships, {
+        allowChannels: dmQuery == null,
+        allowDms: channelQuery == null,
+        query,
+    });
+    return membership.conversation.id;
+}
+export async function runMessagesCommand(params) {
+    const conversationId = await resolveConversationId(params.cliClient, params.parsedArgs);
+    const limit = getStringFlag(params.parsedArgs, "limit", "m") ??
+        getStringFlag(params.parsedArgs, "n", "n");
+    const before = getStringFlag(params.parsedArgs, "before");
+    const messageParams = {
+        conversationId,
+    };
+    if (limit != null) {
+        messageParams.limit = limit;
+    }
+    if (before != null) {
+        messageParams.before = before;
+    }
+    const response = await params.apiClient.listConversationMessages(messageParams);
+    if (hasFlag(params.parsedArgs, "json")) {
+        printJson(response);
+        return;
+    }
+    printMessageResults(response.items);
+}
+function printMessageResults(items) {
+    for (const item of items) {
+        const author = item.author_name ?? "unknown";
+        const content = (item.content ?? "").replace(/\s+/g, " ").trim();
+        process.stdout.write(`${item.id}\t${item.created_at}\t${author}\t${content}\n`);
+    }
+}
+async function runSearchMessages(apiClient, parsedArgs, query, jsonFlag) {
+    const searchParams = { q: query };
+    const author = getStringFlag(parsedArgs, "author");
+    const conversation = getStringFlag(parsedArgs, "conversation");
+    const thread = getStringFlag(parsedArgs, "thread");
+    const after = getStringFlag(parsedArgs, "after");
+    const before = getStringFlag(parsedArgs, "before");
+    const mode = parseSearchMode(getStringFlag(parsedArgs, "mode"));
+    if (author != null) {
+        searchParams.author = author;
+    }
+    if (conversation != null) {
+        searchParams.conversation = conversation;
+    }
+    if (thread != null) {
+        searchParams.thread = thread;
+    }
+    if (after != null) {
+        searchParams.after = after;
+    }
+    if (before != null) {
+        searchParams.before = before;
+    }
+    if (mode != null) {
+        searchParams.mode = mode;
+    }
+    const response = await apiClient.searchMessages(searchParams);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    printMessageResults(response.items);
+}
+async function runSearchMembers(apiClient, query, jsonFlag) {
+    const response = await apiClient.searchMembers({ q: query });
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    for (const item of response.items) {
+        const title = item.title == null || item.title === "" ? "" : ` (${item.title})`;
+        process.stdout.write(`${item.id}\t${item.display_name ?? ""}\t${item.email ?? ""}${title}\n`);
+    }
+}
+async function runSearchConversations(apiClient, query, jsonFlag) {
+    const response = await apiClient.searchConversations({ q: query });
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    for (const item of response.items) {
+        process.stdout.write(`${item.id}\t${item.type}\t${item.name ?? ""}\t${item.human_members_count} members\n`);
+    }
+}
+async function runSearchClipboard(apiClient, query, jsonFlag) {
+    const response = await apiClient.searchClipboards({ q: query });
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    for (const item of response.items) {
+        process.stdout.write(`${item.id}\t${item.created_at}\t${item.title ?? ""}\t${item.item_count} items\n`);
+    }
+}
+async function runSearchCalls(apiClient, parsedArgs, query, jsonFlag) {
+    const searchParams = { q: query };
+    const conversation = getStringFlag(parsedArgs, "conversation");
+    const after = getStringFlag(parsedArgs, "after");
+    const before = getStringFlag(parsedArgs, "before");
+    if (conversation != null) {
+        searchParams.conversation = conversation;
+    }
+    if (after != null) {
+        searchParams.after = after;
+    }
+    if (before != null) {
+        searchParams.before = before;
+    }
+    const response = await apiClient.searchCalls(searchParams);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    for (const item of response.items) {
+        process.stdout.write(`${item.id}\t${item.status}\t${item.conversation_name ?? ""}\t${item.duration_seconds ?? "-"}s\n`);
+    }
+}
+export async function runSearchCommand(params) {
+    const query = params.parsedArgs.positionals[1];
+    const type = (getStringFlag(params.parsedArgs, "type", "t") ?? "messages").toLowerCase();
+    const jsonFlag = hasFlag(params.parsedArgs, "json");
+    if (query == null || query.trim() === "") {
+        throw new Error('search requires a query, e.g. ando search "incident".');
+    }
+    switch (type) {
+        case "messages": {
+            await runSearchMessages(params.apiClient, params.parsedArgs, query, jsonFlag);
+            return;
+        }
+        case "members": {
+            await runSearchMembers(params.apiClient, query, jsonFlag);
+            return;
+        }
+        case "conversations": {
+            await runSearchConversations(params.apiClient, query, jsonFlag);
+            return;
+        }
+        case "clipboard": {
+            await runSearchClipboard(params.apiClient, query, jsonFlag);
+            return;
+        }
+        case "calls": {
+            await runSearchCalls(params.apiClient, params.parsedArgs, query, jsonFlag);
+            return;
+        }
+        default:
+            throw new Error(`Unknown search --type "${type}". Expected messages, members, conversations, clipboard, or calls.`);
+    }
+}
+function parseSearchMode(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (value === "full-text" || value === "semantic") {
+        return value;
+    }
+    throw new Error(`Unknown --mode "${value}". Expected full-text or semantic.`);
+}
+async function runGetMessage(apiClient, id, jsonFlag) {
+    const response = await apiClient.getConversationMessageResult(id);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    printMessageResults([response]);
+}
+async function runGetMember(apiClient, id, jsonFlag) {
+    const response = await apiClient.getMember(id);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    const title = response.title == null ? "" : ` (${response.title})`;
+    process.stdout.write(`${response.id}\t${response.display_name ?? ""}\t${response.email ?? ""}${title}\n`);
+}
+async function runGetClipboard(apiClient, id, jsonFlag) {
+    const response = await apiClient.getClipboard(id);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    process.stdout.write(`${response.id}\t${response.title ?? ""}\t${response.created_at}\n`);
+    for (const item of response.items) {
+        process.stdout.write(`  - ${item.type}\t${item.id}\t${item.name ?? item.display_name ?? item.author_name ?? ""}\n`);
+    }
+}
+async function runGetCall(apiClient, id, jsonFlag) {
+    const response = await apiClient.getCall(id);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    process.stdout.write(`${response.id}\t${response.status}\t${response.conversation_name ?? ""}\t${response.duration_seconds ?? "-"}s\n`);
+    for (const participant of response.participants) {
+        process.stdout.write(`  - ${participant.id}\t${participant.name ?? ""}\n`);
+    }
+}
+async function runGetTranscript(apiClient, parsedArgs, id, jsonFlag) {
+    const transcriptParams = {
+        callId: id,
+    };
+    const limit = getStringFlag(parsedArgs, "limit");
+    const cursor = getStringFlag(parsedArgs, "cursor");
+    if (limit != null) {
+        transcriptParams.limit = limit;
+    }
+    if (cursor != null) {
+        transcriptParams.cursor = cursor;
+    }
+    const response = await apiClient.getCallTranscript(transcriptParams);
+    if (jsonFlag) {
+        printJson(response);
+        return;
+    }
+    for (const segment of response.segments) {
+        process.stdout.write(`${segment.start_ms}\t${segment.end_ms}\t${segment.speaker_name ?? ""}\t${segment.content}\n`);
+    }
+}
+export async function runGetCommand(params) {
+    const entity = params.parsedArgs.positionals[1];
+    const id = params.parsedArgs.positionals[2];
+    const jsonFlag = hasFlag(params.parsedArgs, "json");
+    if (entity == null || id == null || id.trim() === "") {
+        throw new Error("get requires an entity type and id, e.g. ando get message <id>.");
+    }
+    switch (entity) {
+        case "message": {
+            await runGetMessage(params.apiClient, id, jsonFlag);
+            return;
+        }
+        case "member": {
+            await runGetMember(params.apiClient, id, jsonFlag);
+            return;
+        }
+        case "clipboard": {
+            await runGetClipboard(params.apiClient, id, jsonFlag);
+            return;
+        }
+        case "call": {
+            await runGetCall(params.apiClient, id, jsonFlag);
+            return;
+        }
+        case "transcript": {
+            await runGetTranscript(params.apiClient, params.parsedArgs, id, jsonFlag);
+            return;
+        }
+        default:
+            throw new Error(`Unknown get entity "${entity}". Expected message, member, clipboard, call, or transcript.`);
+    }
+}
+export async function runAgentThreadCommand(params) {
+    const positionalId = params.parsedArgs.positionals[1];
+    const messageId = positionalId ?? getStringFlag(params.parsedArgs, "message-id", "m");
+    if (messageId == null || messageId.trim() === "") {
+        throw new Error("thread requires a thread root message id.");
+    }
+    const threadParams = {
+        messageId,
+    };
+    const limit = getStringFlag(params.parsedArgs, "limit");
+    const after = getStringFlag(params.parsedArgs, "after");
+    if (limit != null) {
+        threadParams.limit = limit;
+    }
+    if (after != null) {
+        threadParams.after = after;
+    }
+    const response = await params.apiClient.listThreadReplies(threadParams);
+    if (hasFlag(params.parsedArgs, "json")) {
+        printJson(response);
+        return;
+    }
+    for (const reply of response.items) {
+        const content = (reply.content ?? "").replace(/\s+/g, " ").trim();
+        process.stdout.write(`${reply.id}\t${reply.created_at}\t${reply.author_name ?? ""}\t${content}\n`);
+    }
+}

package/dist/api-command.js

@@ -0,0 +1,187 @@
+import { requestAndoPublicApi, } from "@andocorp/sdk";
+import { buildBodyFromAssignments, defaultReadStdin, flagValue, parseInlineInputs, readDataFlagBody, } from "./api-inputs.js";
+import { applyPathParameterAssignments, buildOperationSpec, buildOperationUrl, listOperations, matchingOperations, operationCanUseConcretePath, printEndpointHelp, selectOperation, selectedMatches, validateOperationInputs, } from "./api-operations.js";
+import { hasFlag } from "./args.js";
+import { printJson } from "./output.js";
+import { getConfiguredApiHost } from "./session.js";
+import { DEFAULT_CLI_REQUEST_TIMEOUT_MS } from "./timeouts.js";
+function getRequestedMethod(parsedArgs) {
+    return flagValue(parsedArgs, "method", "X")?.toUpperCase();
+}
+function printApiCommandHelp() {
+    process.stdout.write(`
+ando api
+
+Usage:
+  ando api ls [--json]
+  ando api <path|operation-id> [--method|-X <method>] [--data|-d <json|-] [name==value] [Header:Value] [field=value] [field:=json]
+  ando api <path|operation-id> --help
+  ando api <path|operation-id> --spec
+
+Examples:
+  ando api ls
+  ando api searchMessages q==incident mode==semantic
+  ando api getMember memberId=<member-id>
+  ando api /v1/search/messages q==incident mode==semantic
+  ando api /v1/conversations/<conversation-id>/messages markdown_content="hello" Idempotency-Key:<key>
+  echo '{"markdown_content":"hello"}' | ando api /v1/conversations/<conversation-id>/messages --data -
+
+Input syntax:
+  name==value       query string parameter
+  Header:Value      declared request header
+  field=value       JSON body string field
+  field:=json       JSON body field parsed as JSON
+  --data <json>     complete JSON request body
+  --data -          read complete JSON request body from stdin
+
+Targets can be public paths or operation IDs from "ando api ls".
+For operation ID targets, supply required path parameters as name=value.
+`.trim() + "\n");
+}
+function formatErrorDetail(value) {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+function printResponse(response) {
+    if (response.empty) {
+        process.stdout.write(`${response.status} ${response.statusText}\n`);
+        return;
+    }
+    if (typeof response.body === "string") {
+        process.stdout.write(response.body.endsWith("\n") ? response.body : `${response.body}\n`);
+        return;
+    }
+    printJson(response.body);
+}
+function requestBodyFromInputs(params) {
+    if (params.dataBody !== undefined && params.assignmentBody !== undefined) {
+        throw new Error("Use either --data or inline body fields, not both.");
+    }
+    return params.dataBody !== undefined ? params.dataBody : params.assignmentBody;
+}
+function rejectMixedBodySourcesBeforeRead(params) {
+    if (params.inlineBodyFieldCount > 0 && hasFlag(params.parsedArgs, "data", "d")) {
+        throw new Error("Use either --data or inline body fields, not both.");
+    }
+}
+function selectPathParameterMatch(params) {
+    if (params.requestedMethod != null) {
+        return selectOperation(params.rawPath, params.matches, params.requestedMethod);
+    }
+    const match = params.matches[0];
+    if (match == null) {
+        throw new Error(`No public API operation matches ${params.rawPath}.`);
+    }
+    return match;
+}
+function createRawApiTimeoutSignal() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort(new Error(`[ando-cli] api request timed out after ${DEFAULT_CLI_REQUEST_TIMEOUT_MS}ms`));
+    }, DEFAULT_CLI_REQUEST_TIMEOUT_MS);
+    return {
+        signal: controller.signal,
+        clear: () => {
+            clearTimeout(timeout);
+        },
+    };
+}
+async function prepareApiRequest(params) {
+    const inlineInputs = parseInlineInputs(params.parsedArgs.positionals.slice(2));
+    const pathParameterMatch = selectPathParameterMatch({
+        matches: params.matches,
+        rawPath: params.rawPath,
+        requestedMethod: params.requestedMethod,
+    });
+    const pathParameterInputs = applyPathParameterAssignments({
+        bodyAssignments: inlineInputs.bodyAssignments,
+        match: pathParameterMatch,
+    });
+    rejectMixedBodySourcesBeforeRead({
+        parsedArgs: params.parsedArgs,
+        inlineBodyFieldCount: pathParameterInputs.bodyAssignments.length,
+    });
+    const dataBody = await readDataFlagBody({
+        parsedArgs: params.parsedArgs,
+        readStdin: params.readStdin,
+    });
+    const assignmentBody = pathParameterInputs.bodyAssignments.length > 0
+        ? buildBodyFromAssignments(pathParameterInputs.bodyAssignments)
+        : undefined;
+    const body = requestBodyFromInputs({ assignmentBody, dataBody });
+    const method = params.requestedMethod ?? (body === undefined ? "GET" : "POST");
+    const selectedMatch = selectOperation(params.rawPath, params.matches, method);
+    const { match } = applyPathParameterAssignments({
+        bodyAssignments: inlineInputs.bodyAssignments,
+        match: selectedMatch,
+    });
+    if (!operationCanUseConcretePath(match)) {
+        throw new Error(`Supply concrete path values before calling ${match.id}. Use ${match.operation.pathParameters.map((name) => `${name}=<value>`).join(" ")}.`);
+    }
+    validateOperationInputs({
+        body,
+        headers: inlineInputs.headers,
+        inlineQuery: inlineInputs.query,
+        match,
+    });
+    const config = await params.loadConfig();
+    return {
+        apiKey: config.apiKey,
+        body,
+        headers: inlineInputs.headers,
+        method,
+        url: buildOperationUrl({
+            apiHost: getConfiguredApiHost(params.parsedArgs, config.apiHost ?? null),
+            concretePath: match.concretePath,
+            pathQueryString: match.queryString,
+            inlineQuery: inlineInputs.query,
+        }),
+    };
+}
+async function runPreparedRequest(params) {
+    const timeout = createRawApiTimeoutSignal();
+    try {
+        const response = await params.requestApi({
+            ...params.request,
+            signal: params.request.signal ?? timeout.signal,
+        });
+        if (!response.ok) {
+            const detail = response.empty ? "" : `\n${formatErrorDetail(response.body)}`;
+            throw new Error(`Public API request failed: ${response.status} ${response.statusText}${detail}`);
+        }
+        printResponse(response);
+    }
+    finally {
+        timeout.clear();
+    }
+}
+export async function runApiCommand({ parsedArgs, loadConfig, requestApi = requestAndoPublicApi, readStdin = defaultReadStdin, }) {
+    const rawPath = parsedArgs.positionals[1];
+    if (rawPath == null || rawPath === "help") {
+        printApiCommandHelp();
+        return;
+    }
+    if (rawPath === "ls" || rawPath === "list") {
+        listOperations(parsedArgs);
+        return;
+    }
+    const matches = matchingOperations(rawPath);
+    const requestedMethod = getRequestedMethod(parsedArgs);
+    const visibleMatches = selectedMatches(matches, requestedMethod);
+    if (hasFlag(parsedArgs, "help", "h")) {
+        printEndpointHelp(rawPath, visibleMatches);
+        return;
+    }
+    if (hasFlag(parsedArgs, "spec")) {
+        printJson(buildOperationSpec(visibleMatches));
+        return;
+    }
+    const request = await prepareApiRequest({
+        loadConfig,
+        matches,
+        parsedArgs,
+        rawPath,
+        readStdin,
+        requestedMethod,
+    });
+    await runPreparedRequest({ request, requestApi });
+}