@settlemint/dalp-cli 3.1.33-main.43433008600 → 3.1.33-release.43440124932

package/src/hosted-mcp.ts

@@ -1,145 +0,0 @@
-import { fromJsonSchema, type McpServer } from "@modelcontextprotocol/server";
-import type { DalpClient } from "@settlemint/dalp-sdk";
-import { Cli, Mcp, z } from "incur";
-import { listCliOperations, type OperationDescriptor } from "./lib/operation-inventory.ts";
-import { registerGeneratedOperations } from "./lib/register-operations.ts";
-import { CLI_VERSION, cliVars } from "./lib/vars.ts";
-
-export type { OperationDescriptor };
-
-export const HOSTED_MCP_VERSION: string = CLI_VERSION;
-
-export const HOSTED_EXECUTION_MODES: readonly ["inbox", "mandate"] = ["inbox", "mandate"];
-export type HostedExecutionMode = (typeof HOSTED_EXECUTION_MODES)[number];
-
-export const PREPARE_GROUP = "prepare";
-
-export const PREPARE_GROUP_DESCRIPTION =
-  "Prepare a write for a person to review and sign in DALP. With execution mandate, a tool that runs under a mandate executes the write at once as the organisation's agent principal, and no person signs.";
-
-export interface PrepareToolField {
-  readonly description: string;
-  readonly required: boolean;
-  readonly options?: ReadonlyArray<string>;
-}
-
-export interface PrepareTool {
-  readonly name: string;
-  readonly description: string;
-  readonly fields: Readonly<Record<string, PrepareToolField>>;
-  readonly runsUnderMandate: boolean;
-}
-
-export interface PrepareCall {
-  readonly tool: string;
-  readonly assetId: string;
-  readonly fields: Readonly<Record<string, string>>;
-  readonly execution: HostedExecutionMode;
-  readonly agentId: string | undefined;
-  readonly idempotencyKey: string | undefined;
-}
-
-export type PrepareOutcome =
-  | { readonly prepared: unknown }
-  | { readonly refused: { readonly code: string; readonly message: string } };
-
-export type PrepareExecutor = (call: PrepareCall) => Promise<PrepareOutcome>;
-
-export interface HostedMcpRequest {
-  readonly client: DalpClient;
-  readonly prepare: PrepareExecutor;
-}
-
-export interface HostedMcpTools {
-  readonly reads: ReadonlyArray<OperationDescriptor>;
-  readonly register: (server: McpServer, request: HostedMcpRequest) => void;
-}
-
-const hostedVars = cliVars.extend({ prepare: z.custom<PrepareExecutor>().optional() });
-
-const executionOption = z
-  .enum(HOSTED_EXECUTION_MODES)
-  .default("inbox")
-  .describe(
-    "inbox (default): post the prepared write to the member's DALP inbox, where a person reviews and signs it. mandate: execute the write at once as the organisation's agent principal, only inside its mandate, and no person signs."
-  );
-
-const fieldOption = (field: PrepareToolField) => {
-  const value = field.options === undefined ? z.string() : z.enum(field.options);
-  const described = value.describe(field.description);
-  return field.required ? described : described.optional();
-};
-
-type PrepareOptions = Readonly<Record<string, string | undefined>>;
-
-const prepareCommand = (tool: PrepareTool) => ({
-  description: tool.description,
-  mcp: { annotations: { readOnlyHint: false, destructiveHint: tool.runsUnderMandate, idempotentHint: false } },
-  options: z.object({
-    assetId: z.string().describe("The asset the write acts on: its contract address."),
-    ...Object.fromEntries(Object.entries(tool.fields).map(([name, field]) => [name, fieldOption(field)])),
-    execution: executionOption,
-    agentId: z
-      .string()
-      .optional()
-      .describe("With execution mandate only: the agent principal that acts, its pp_ id from the Agents page."),
-    idempotencyKey: z
-      .string()
-      .optional()
-      .describe(
-        "Required with execution mandate: a key you choose for this write and send again, unchanged, on a retry, so the write never runs twice."
-      ),
-  }),
-  run: async (context: {
-    readonly options: PrepareOptions;
-    readonly var: { readonly prepare?: PrepareExecutor | undefined };
-    readonly error: (error: { readonly code: string; readonly message: string }) => unknown;
-  }) => {
-    const { assetId, execution, agentId, idempotencyKey, ...rest } = context.options;
-    if (context.var.prepare === undefined || typeof assetId !== "string") {
-      return context.error({ code: "PREPARE_UNAVAILABLE", message: "This server does not prepare writes." });
-    }
-    const fields = Object.fromEntries(
-      Object.entries(rest).flatMap(([name, value]) => (typeof value === "string" ? [[name, value]] : []))
-    );
-    const outcome = await context.var.prepare({
-      tool: tool.name,
-      assetId,
-      fields,
-      execution: execution === "mandate" ? "mandate" : "inbox",
-      agentId,
-      idempotencyKey,
-    });
-    return "refused" in outcome ? context.error(outcome.refused) : outcome.prepared;
-  },
-});
-
-export function makeHostedMcpTools(input: { readonly prepareTools: ReadonlyArray<PrepareTool> }): HostedMcpTools {
-  const reads = listCliOperations().filter((descriptor) => descriptor.method === "GET");
-  const cli = Cli.create("dalp", { version: CLI_VERSION, vars: hostedVars });
-  registerGeneratedOperations(cli, reads);
-  const prepare = Cli.create(PREPARE_GROUP, {
-    description: PREPARE_GROUP_DESCRIPTION,
-    vars: hostedVars,
-  });
-  for (const tool of input.prepareTools) {
-    prepare.command(tool.name, prepareCommand(tool));
-  }
-  cli.command(prepare);
-  const registered: WeakMap<object, Map<string, unknown>> = Cli.toCommands;
-  const commands = registered.get(cli) ?? new Map<string, unknown>();
-  return {
-    reads,
-    register: (server, request) =>
-      Mcp.registerTools(server, commands, {
-        fromJsonSchema,
-        name: "dalp",
-        version: CLI_VERSION,
-        vars: hostedVars.extend({
-          client: z.custom<DalpClient>().default(() => request.client),
-          prepare: z.custom<PrepareExecutor>().default(() => request.prepare),
-        }),
-        sendNotification: (notification) => server.server.notification(notification),
-      }),
-  };
-}

package/src/lib/api-client.ts

@@ -1,30 +0,0 @@
-import { createDalpClient, type CompressionRequestInit, type DalpClient } from "@settlemint/dalp-sdk";
-import type { StoredCredentials } from "./credential-store.ts";
-import { CLI_USER_AGENT } from "./vars.ts";
-
-export interface CliGeneratedClientOptions {
-  readonly fetch?: typeof globalThis.fetch;
-}
-
-const withCliUserAgent = (fetchImpl: typeof globalThis.fetch): typeof globalThis.fetch =>
-  Object.assign(async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const request = new Request(input, init);
-    const headers = new Headers(request.headers);
-    headers.set("User-Agent", CLI_USER_AGENT);
-    const compress = (init as CompressionRequestInit | undefined)?.compress;
-    const transportInit: CompressionRequestInit | undefined = compress === undefined ? undefined : { compress };
-    return fetchImpl(new Request(request, { headers }), transportInit);
-  }, fetchImpl);
-
-export function makeCliClient(
-  apiUrl: string,
-  credentials: StoredCredentials,
-  options: CliGeneratedClientOptions = {}
-): DalpClient {
-  return createDalpClient({
-    apiKey: credentials.apiKey,
-    baseUrl: apiUrl,
-    fetch: withCliUserAgent(options.fetch ?? globalThis.fetch),
-    runtime: "server",
-  });
-}

package/src/lib/auth-request.ts

@@ -1,86 +0,0 @@
-import { DalpApiError } from "@settlemint/dalp-sdk";
-import { z } from "incur";
-import type { StoredCredentials } from "./credential-store.ts";
-import { CLI_USER_AGENT } from "./vars.ts";
-
-const TRAILING_SLASHES_PATTERN = /\/+$/u;
-
-const AUTH_REQUEST_TIMEOUT_MS = 10_000;
-
-export async function authRequest(
-  apiUrl: string,
-  credentials: StoredCredentials,
-  route: `/${string}`,
-  init?: { readonly method: "GET" | "POST"; readonly body?: unknown }
-): Promise<unknown> {
-  const request = init ?? { method: "GET" as const };
-  const headers = new Headers({ Accept: "application/json", "User-Agent": CLI_USER_AGENT });
-  if (credentials.apiKey !== undefined) {
-    headers.set("X-Api-Key", credentials.apiKey);
-  }
-  if (request.body !== undefined) {
-    headers.set("Content-Type", "application/json");
-  }
-  const deadline = new AbortController();
-  const timer = setTimeout(() => deadline.abort(), AUTH_REQUEST_TIMEOUT_MS);
-  let response: Response;
-  let text: string;
-  try {
-    // fallow-ignore-next-line security-sink -- apiUrl is the saved credentials.apiUrl (credential-store.ts:21, z.url()), written at login from the validated base (login.ts:406, 458). Client-side CLI; the stored host is the user's own instance, not attacker-set.
-    response = await fetch(`${apiUrl.replace(TRAILING_SLASHES_PATTERN, "")}/api/auth${route}`, {
-      method: request.method,
-      headers,
-      signal: deadline.signal,
-      ...(request.body === undefined ? {} : { body: JSON.stringify(request.body) }),
-    });
-    text = await response.text();
-  } catch (error) {
-    if (!deadline.signal.aborted) {
-      throw error;
-    }
-    throw new DalpApiError({
-      message: `Auth request timed out: ${route}`,
-      code: "sdk.transport.REQUEST_FAILED",
-      category: "dependency",
-      retryable: true,
-      why: `The auth surface did not answer ${route} within ${String(AUTH_REQUEST_TIMEOUT_MS / 1000)} seconds.`,
-      fix: "Check that the platform URL is reachable, then retry.",
-      cause: error,
-    });
-  } finally {
-    clearTimeout(timer);
-  }
-  const payload: unknown = text === "" ? undefined : JSON.parse(text);
-  if (!response.ok) {
-    throw new DalpApiError({
-      message: `Auth request failed: ${String(response.status)} ${route}`,
-      code: `sdk.transport.HTTP_${response.status}`,
-      category: "dependency",
-      retryable: response.status >= 500,
-      why: `The auth surface answered ${String(response.status)} for ${route}.`,
-      fix: "Check the API key and the platform URL, then retry.",
-      status: response.status,
-      cause: payload,
-    });
-  }
-  return payload;
-}
-
-export type KeyRevocation = { readonly _tag: "Revoked" } | { readonly _tag: "Unconfirmed"; readonly cause: unknown };
-
-const KeyDisabledAnswerSchema = z.object({ code: z.literal("KEY_DISABLED") });
-
-const keyNoLongerExists = (error: unknown): boolean =>
-  error instanceof DalpApiError && error.status === 401 && !KeyDisabledAnswerSchema.safeParse(error.cause).success;
-
-export async function revokeOwnApiKey(credentials: StoredCredentials): Promise<KeyRevocation> {
-  try {
-    await authRequest(credentials.apiUrl, credentials, "/api-key/delete", {
-      method: "POST",
-      body: { keyId: credentials.apiKeyId },
-    });
-    return { _tag: "Revoked" };
-  } catch (error) {
-    return keyNoLongerExists(error) ? { _tag: "Revoked" } : { _tag: "Unconfirmed", cause: error };
-  }
-}

package/src/lib/cli-config.ts

@@ -1,104 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import path from "node:path";
-import { z } from "zod";
-import { makeCliError } from "./errors.ts";
-
-const PROJECT_CONFIG_FILE = ".dalprc.json";
-
-const DalpConfigSchema = z.object({
-  apiUrl: z.string().optional(),
-  defaultOrg: z.string().optional(),
-  format: z.enum(["toon", "json", "yaml", "md"]).optional(),
-});
-
-export type DalpConfig = z.infer<typeof DalpConfigSchema>;
-
-export function getConfigDir(): string {
-  const override = process.env.DALP_CONFIG_DIR;
-  if (override !== undefined && override.trim() !== "") {
-    return override;
-  }
-  return path.join(homedir(), ".config", "dalp");
-}
-
-export interface CliConfigPaths {
-  readonly configDir?: string;
-  readonly cwd?: string;
-  readonly environment?: () => DalpConfig;
-}
-
-const defaultEnvironment = (): DalpConfig => ({
-  ...(process.env.DALP_URL === undefined || process.env.DALP_URL === "" ? {} : { apiUrl: process.env.DALP_URL }),
-  ...(process.env.DALP_ORG === undefined || process.env.DALP_ORG === "" ? {} : { defaultOrg: process.env.DALP_ORG }),
-});
-
-const mergeConfig = (
-  globalConfig: DalpConfig,
-  projectConfig: DalpConfig,
-  environmentConfig: DalpConfig,
-  overrides: Partial<DalpConfig>
-): DalpConfig => ({
-  ...globalConfig,
-  ...projectConfig,
-  ...environmentConfig,
-  ...Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== undefined)),
-});
-
-async function readConfigFile(file: string): Promise<DalpConfig> {
-  try {
-    const raw = await readFile(file, "utf8");
-    return DalpConfigSchema.parse(JSON.parse(raw));
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return {};
-    }
-    if (error instanceof z.ZodError) {
-      throw makeCliError({
-        code: "kit.cli.CONFIG_INVALID",
-        message: `Invalid config at ${file}: ${error.message}`,
-        why: "The configuration file does not match the expected schema.",
-        fix: `Edit ${file} or delete it and re-run 'dalp config set'.`,
-        cause: error,
-      });
-    }
-    throw makeCliError({
-      code: "kit.cli.CONFIG_READ_FAILED",
-      message: error instanceof Error ? error.message : "Failed to read CLI configuration",
-      cause: error,
-    });
-  }
-}
-
-async function ensureConfigDir(configDir: string = getConfigDir()): Promise<void> {
-  await mkdir(configDir, { recursive: true, mode: 0o700 });
-}
-
-export async function loadGlobalConfig(configDir: string = getConfigDir()): Promise<DalpConfig> {
-  return readConfigFile(path.join(configDir, "config.json"));
-}
-
-async function loadProjectConfig(cwd: string = process.cwd()): Promise<DalpConfig> {
-  return readConfigFile(path.join(cwd, PROJECT_CONFIG_FILE));
-}
-
-export async function resolveConfig(
-  overrides: Partial<DalpConfig> = {},
-  paths: CliConfigPaths = {}
-): Promise<DalpConfig> {
-  const configDir = paths.configDir ?? getConfigDir();
-  const cwd = paths.cwd ?? process.cwd();
-  const environment = paths.environment ?? defaultEnvironment;
-  const [globalConfig, projectConfig] = await Promise.all([loadGlobalConfig(configDir), loadProjectConfig(cwd)]);
-  return mergeConfig(globalConfig, projectConfig, environment(), overrides);
-}
-
-export async function saveGlobalConfig(
-  updates: Partial<DalpConfig>,
-  configDir: string = getConfigDir()
-): Promise<void> {
-  await ensureConfigDir(configDir);
-  const existing = await loadGlobalConfig(configDir);
-  const next = DalpConfigSchema.parse({ ...existing, ...updates });
-  await writeFile(path.join(configDir, "config.json"), `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
-}

package/src/lib/cli-cta.ts

@@ -1,296 +0,0 @@
-import { z } from "incur";
-import { cliCommandFor, routeTable } from "@settlemint/dalp-sdk/routes";
-
-export interface CliCtaCommandObject {
-  readonly command: string;
-  readonly description?: string;
-  readonly args?: Readonly<Record<string, string | number | boolean>>;
-  readonly options?: Readonly<Record<string, string | number | boolean>>;
-}
-
-export type CliCtaCommand = string | CliCtaCommandObject;
-
-export interface CliCtaBlock {
-  readonly description: string;
-  readonly commands: Array<CliCtaCommand>;
-}
-
-export type ResourceLinks = Readonly<Record<string, string | null | undefined>>;
-
-const LINK_REL_ORDER = ["next", "prev", "first", "last", "self", "history"] as const;
-
-const REL_DESCRIPTION: Readonly<Record<string, string>> = {
-  next: "Fetch the next page",
-  prev: "Fetch the previous page",
-  first: "Fetch the first page",
-  last: "Fetch the last page",
-  self: "Re-fetch this resource",
-  history: "Fetch related history",
-};
-
-const jsonBagSchema = z.record(z.string(), z.json());
-
-export type JsonBag = z.output<typeof jsonBagSchema>;
-
-const isJsonBag = (value: unknown): value is JsonBag => jsonBagSchema.safeParse(value).success;
-
-export function extractResourceLinks(value: unknown): ResourceLinks | undefined {
-  if (!isJsonBag(value)) {
-    return undefined;
-  }
-  const { links: direct, data } = value;
-  if (isJsonBag(direct)) {
-    return linksFromRecord(direct);
-  }
-  if (isJsonBag(data)) {
-    const { links: nested } = data;
-    if (isJsonBag(nested)) {
-      return linksFromRecord(nested);
-    }
-  }
-  return undefined;
-}
-
-function linksFromRecord(record: JsonBag): ResourceLinks | undefined {
-  const out: Record<string, string | null> = {};
-  let any = false;
-  for (const [key, entry] of Object.entries(record)) {
-    if (entry === null) {
-      out[key] = null;
-      any = true;
-      continue;
-    }
-    if (typeof entry === "string" && entry.trim() !== "") {
-      out[key] = entry;
-      any = true;
-    }
-  }
-  return any ? out : undefined;
-}
-
-function parseHref(href: string): { pathname: string; searchParams: URLSearchParams } | undefined {
-  try {
-    const url =
-      href.startsWith("http://") || href.startsWith("https://") ? new URL(href) : new URL(href, "https://dalp.local");
-    return { pathname: url.pathname, searchParams: url.searchParams };
-  } catch {
-    return undefined;
-  }
-}
-
-const API_PREFIX = /^\/api(?:\/v2)?(?=\/)/u;
-const BRACKETED_KEY = /^([^[\]]+)\[([^\]]+)\]$/u;
-
-const readRoutes = Object.entries(routeTable.routes).flatMap(([routeId, row]) =>
-  row === undefined || row.method.toUpperCase() !== "GET"
-    ? []
-    : [{ routeId, segments: row.path.split("/").filter((segment) => segment.length > 0) }]
-);
-
-const isParameterSegment = (segment: string): boolean =>
-  (segment.startsWith("{") && segment.endsWith("}")) || segment.startsWith(":");
-
-function matchReadRoute(
-  pathname: string
-): { readonly routeId: string; readonly params: Record<string, string> } | undefined {
-  const hrefSegments = pathname
-    .replace(API_PREFIX, "")
-    .split("/")
-    .filter((segment) => segment.length > 0);
-  let best: { routeId: string; params: Record<string, string>; statics: number } | undefined;
-  for (const { routeId, segments } of readRoutes) {
-    if (segments.length !== hrefSegments.length) {
-      continue;
-    }
-    const params: Record<string, string> = {};
-    let statics = 0;
-    const matches = segments.every((segment, index) => {
-      const actual = hrefSegments[index]!;
-      if (!isParameterSegment(segment)) {
-        statics += 1;
-        return segment === actual;
-      }
-      params[segment.startsWith(":") ? segment.slice(1) : segment.slice(1, -1)] = decodeURIComponent(actual);
-      return true;
-    });
-    if (matches && (best === undefined || statics > best.statics)) {
-      best = { routeId, params, statics };
-    }
-  }
-  return best;
-}
-
-export function mapApiHrefToCliCommand(href: string): { readonly command: string } | undefined {
-  const parsed = parseHref(href);
-  if (parsed === undefined) {
-    return undefined;
-  }
-  const { pathname, searchParams } = parsed;
-  if (!(pathname.includes("/api/v2/") || pathname.startsWith("/api/"))) {
-    return undefined;
-  }
-  const route = matchReadRoute(pathname);
-  if (route === undefined) {
-    return undefined;
-  }
-  const query: Record<string, string | Record<string, string>> = {};
-  for (const [key, value] of searchParams.entries()) {
-    const bracketed = BRACKETED_KEY.exec(key);
-    if (bracketed === null) {
-      query[key] = value;
-      continue;
-    }
-    const [, name, member] = bracketed;
-    const nested = query[name!];
-    query[name!] = { ...(typeof nested === "object" ? nested : {}), [member!]: value };
-  }
-  const command = cliCommandFor(route.routeId, { params: route.params, query });
-  return command === null ? undefined : { command: command.text };
-}
-
-export function commandsFromLinks(links: ResourceLinks | undefined): Array<CliCtaCommandObject> {
-  if (links === undefined) {
-    return [];
-  }
-  const orderedKeys = [
-    ...LINK_REL_ORDER.filter((rel) => rel in links),
-    ...Object.keys(links)
-      .filter((key) => !(LINK_REL_ORDER as ReadonlyArray<string>).includes(key))
-      .sort((left, right) => left.localeCompare(right)),
-  ];
-  const commands: Array<CliCtaCommandObject> = [];
-  const seen = new Set<string>();
-  for (const rel of orderedKeys) {
-    const href = links[rel];
-    if (href === null || href === undefined || href === "") {
-      continue;
-    }
-    const mapped = mapApiHrefToCliCommand(href);
-    if (mapped === undefined) {
-      continue;
-    }
-    if (seen.has(mapped.command)) {
-      continue;
-    }
-    seen.add(mapped.command);
-    commands.push({
-      command: mapped.command,
-      description: REL_DESCRIPTION[rel] ?? `Follow ${rel} link`,
-    });
-  }
-  return commands;
-}
-
-function commandsFromErrorHints(input: {
-  readonly code?: string;
-  readonly category?: string;
-  readonly fix: string;
-}): Array<CliCtaCommandObject> {
-  const code = (input.code ?? "").toUpperCase();
-  const category = (input.category ?? "").toLowerCase();
-  const fix = input.fix.toLowerCase();
-  const commands: Array<CliCtaCommandObject> = [];
-
-  const auth =
-    category === "auth" ||
-    code.includes("AUTH") ||
-    code.includes("NOT_AUTHENTICATED") ||
-    code.includes("UNAUTHORIZED") ||
-    fix.includes("authenticate") ||
-    fix.includes("log in") ||
-    fix.includes("sign in") ||
-    fix.includes("api key");
-  if (auth) {
-    commands.push({ command: "login", description: "Authenticate with device authorization" });
-  }
-
-  const org =
-    category === "permission" ||
-    code.includes("ORGANIZATION") ||
-    code.includes("ACTIVE_ORG") ||
-    fix.includes("organization") ||
-    fix.includes("org ");
-  if (org) {
-    commands.push({ command: "org switch", description: "Save the key's organization as active" });
-    commands.push({ command: "whoami", description: "Show current user and organization" });
-  }
-
-  if (commands.length === 0 && (category === "client" || category === "config")) {
-    commands.push({ command: "whoami", description: "Check the active session" });
-    commands.push({ command: "config get", description: "Inspect local CLI configuration" });
-  }
-
-  return commands;
-}
-
-function dedupeCommands(commands: ReadonlyArray<CliCtaCommand>): Array<CliCtaCommand> {
-  const seen = new Set<string>();
-  const out: Array<CliCtaCommand> = [];
-  for (const command of commands) {
-    const key =
-      typeof command === "string"
-        ? command
-        : `${command.command}|${JSON.stringify(command.args ?? {})}|${JSON.stringify(command.options ?? {})}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    out.push(command);
-  }
-  return out;
-}
-
-export function buildErrorCta(input: {
-  readonly why: string;
-  readonly fix: string;
-  readonly code?: string;
-  readonly category?: string;
-  readonly links?: ResourceLinks;
-}): CliCtaBlock {
-  const fromLinks = commandsFromLinks(input.links);
-  const fromHints = commandsFromErrorHints(input);
-  let commands = dedupeCommands([...fromLinks, ...fromHints]);
-  if (commands.length === 0) {
-    commands = [{ command: "whoami", description: input.fix }];
-  }
-  return {
-    description: `Why: ${input.why}\nFix: ${input.fix}`,
-    commands,
-  };
-}
-
-function formatCtaCommand(cliName: string, entry: CliCtaCommand): { command: string; description?: string } {
-  if (typeof entry === "string") {
-    return { command: `${cliName} ${entry}` };
-  }
-  const prefixed = entry.command === cliName || entry.command.startsWith(`${cliName} `);
-  let command = prefixed ? entry.command : `${cliName} ${entry.command}`;
-  for (const [key, value] of Object.entries(entry.args ?? {})) {
-    command += value === true ? ` <${key}>` : ` ${String(value)}`;
-  }
-  for (const [key, value] of Object.entries(entry.options ?? {})) {
-    command += value === true ? ` --${key} <${key}>` : ` --${key} ${String(value)}`;
-  }
-  return entry.description === undefined ? { command } : { command, description: entry.description };
-}
-
-export function renderCtaText(cliName: string, block: CliCtaBlock): string {
-  const commands = block.commands.map((entry) => formatCtaCommand(cliName, entry));
-  const width = Math.max(0, ...commands.map((entry) => entry.command.length));
-  const lines = commands.map((entry) =>
-    entry.description === undefined ? `  ${entry.command}` : `  ${entry.command.padEnd(width)}  # ${entry.description}`
-  );
-  return [block.description, ...lines].join("\n");
-}
-
-export function buildSuccessCtaFromResult(result: unknown): CliCtaBlock | undefined {
-  const links = extractResourceLinks(result);
-  const commands = commandsFromLinks(links);
-  if (commands.length === 0) {
-    return undefined;
-  }
-  return {
-    description: commands.length === 1 ? "Related:" : "Related:",
-    commands,
-  };
-}