@scalepad/cli 0.1.0

package/src/index.ts

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+
+import { readFile } from "node:fs/promises";
+import { confirm, password } from "@inquirer/prompts";
+import {
+  coreOperations,
+  createCoreClient,
+  GeneratedCoreClient,
+  ScalepadApiError,
+  type GeneratedCoreOperation
+} from "@scalepad/sdk-core";
+import {
+  createLifecycleManagerClient,
+  GeneratedLifecycleManagerClient,
+  lifecycleManagerOperations,
+  ScalepadLmApiError,
+  type GeneratedLifecycleManagerOperation
+} from "@scalepad/sdk-lm";
+import { Command } from "commander";
+import { loadConfig } from "./config.js";
+import { deleteStoredApiKey, readStoredApiKey, resolveApiKey, storeApiKey } from "./credentials.js";
+import { buildSort, parseFilterArgs } from "./filters.js";
+import { formatApiError, parseFields, printList, printObject, resolveOutputFormat } from "./format.js";
+
+type GeneratedOperation = GeneratedCoreOperation | GeneratedLifecycleManagerOperation;
+type OperationFamily = "core" | "lm";
+
+interface SharedOptions {
+  profile?: string;
+  apiKey?: string;
+}
+
+interface OperationOptions extends SharedOptions {
+  json?: boolean;
+  jsonl?: boolean;
+  csv?: boolean;
+  table?: boolean;
+  all?: boolean;
+  limit?: string;
+  cursor?: string;
+  filter?: string[];
+  sort?: string;
+  desc?: boolean;
+  fields?: string;
+  query?: string[];
+  body?: string;
+  bodyFile?: string;
+  yes?: boolean;
+}
+
+function collect(value: string, previous: string[]): string[] {
+  previous.push(value);
+  return previous;
+}
+
+function humanizeSegment(segment: string): string {
+  return segment.replaceAll("-", " ");
+}
+
+function listSubcommands(command: Command, prefix = ""): string[] {
+  const lines: string[] = [];
+
+  for (const subcommand of command.commands) {
+    if (subcommand.name() === "help") {
+      continue;
+    }
+
+    const fullName = [prefix, subcommand.name()].filter(Boolean).join(" ");
+    const description = subcommand.description();
+    const paddedName = fullName.padEnd(40, " ");
+    lines.push(`  ${paddedName} ${description}`);
+    lines.push(...listSubcommands(subcommand, fullName));
+  }
+
+  return lines;
+}
+
+function addExpandedHelp(command: Command, prefix = command.name()): void {
+  const lines = listSubcommands(command, prefix);
+  if (lines.length === 0) {
+    return;
+  }
+
+  command.addHelpText("after", `\nAvailable Commands:\n${lines.join("\n")}`);
+}
+
+async function resolveProfile(profile?: string): Promise<string> {
+  if (profile) {
+    return profile;
+  }
+
+  const config = await loadConfig();
+  return config.currentProfile || "default";
+}
+
+async function getApiKeyForCommand(options: SharedOptions): Promise<{ apiKey: string; profile: string }> {
+  const profile = await resolveProfile(options.profile);
+  const apiKey = await resolveApiKey({
+    explicitApiKey: options.apiKey,
+    envApiKey: process.env.SCALEPAD_API_KEY,
+    profile
+  });
+
+  if (!apiKey) {
+    throw new Error(`No API key configured for profile '${profile}'. Run 'scalepad auth login'.`);
+  }
+
+  return { apiKey, profile };
+}
+
+async function probeCoreAccess(coreClient: ReturnType<typeof createCoreClient>): Promise<boolean> {
+  try {
+    await coreClient.listClients({ pageSize: 1 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function probeLifecycleManagerAccess(apiKey: string): Promise<boolean> {
+  const response = await fetch("https://api.scalepad.com/lifecycle-manager/v1/meeting-types", {
+    headers: {
+      accept: "application/json",
+      "x-api-key": apiKey,
+      "user-agent": "@scalepad/cli"
+    }
+  });
+
+  return response.ok;
+}
+
+function addSharedAuthOptions(command: Command): Command {
+  return command
+    .option("--profile <name>", "credential profile name")
+    .option("--api-key <key>", "override API key for this command");
+}
+
+function addOutputOptions(command: Command): Command {
+  return command
+    .option("--json", "print JSON")
+    .option("--jsonl", "print newline-delimited JSON")
+    .option("--csv", "print CSV")
+    .option("--table", "print a table")
+    .option("--fields <fields>", "comma-separated output fields");
+}
+
+function addOperationOptions(command: Command, operation: GeneratedOperation): Command {
+  const configured = addOutputOptions(addSharedAuthOptions(command))
+    .option("--query <name=value>", "raw query parameter", collect, []);
+
+  if (operation.queryParams.length > 0) {
+    configured
+      .option("--all", "walk cursor pagination until exhaustion")
+      .option("--limit <count>", "page size for list requests")
+      .option("--cursor <cursor>", "starting cursor")
+      .option("--filter <field=expr>", "filter expression", collect, [])
+      .option("--sort <field>", "sortable field")
+      .option("--desc", "sort descending");
+  }
+
+  if (operation.hasBody) {
+    configured
+      .option("--body <json-or-@file>", "inline JSON body or @path/to/file.json")
+      .option("--body-file <path>", "path to a JSON body file");
+  }
+
+  if (operation.method !== "get") {
+    configured.option("--yes", "skip interactive confirmation");
+  }
+
+  return configured;
+}
+
+function hasAdvancedQueryFlags(options: OperationOptions): boolean {
+  return Boolean(
+    options.limit
+    || options.cursor
+    || (options.filter?.length ?? 0) > 0
+    || options.sort
+    || options.desc
+  );
+}
+
+function parseKeyValueArgs(values: string[]): Record<string, string> {
+  const entries: Record<string, string> = {};
+
+  for (const value of values) {
+    const separatorIndex = value.indexOf("=");
+    if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+      throw new Error(`Invalid key/value argument '${value}'. Expected name=value.`);
+    }
+
+    const key = value.slice(0, separatorIndex).trim();
+    const entryValue = value.slice(separatorIndex + 1).trim();
+
+    if (!key || !entryValue) {
+      throw new Error(`Invalid key/value argument '${value}'. Expected name=value.`);
+    }
+
+    entries[key] = entryValue;
+  }
+
+  return entries;
+}
+
+function buildQueryFromOptions(operation: GeneratedOperation, options: OperationOptions): Record<string, string> | undefined {
+  const rawQuery = parseKeyValueArgs(options.query ?? []);
+  const hasFriendlyQueryFlags = hasAdvancedQueryFlags(options);
+
+  if (operation.queryParams.length === 0) {
+    if (Object.keys(rawQuery).length > 0 || hasFriendlyQueryFlags) {
+      throw new Error(`Command '${[...operation.commandPath, operation.action].join(" ")}' does not accept query parameters.`);
+    }
+
+    return undefined;
+  }
+
+  const query = { ...rawQuery };
+
+  if (options.limit) {
+    const pageSize = Number(options.limit);
+    if (!Number.isInteger(pageSize) || pageSize <= 0) {
+      throw new Error(`Invalid --limit value '${options.limit}'. Expected a positive integer.`);
+    }
+    query.page_size = String(pageSize);
+  }
+
+  if (options.cursor) {
+    query.cursor = options.cursor;
+  }
+
+  const sort = buildSort(options.sort, Boolean(options.desc));
+  if (sort) {
+    query.sort = sort;
+  }
+
+  for (const [field, expression] of Object.entries(parseFilterArgs(options.filter ?? []))) {
+    query[`filter[${field}]`] = expression;
+  }
+
+  return Object.keys(query).length === 0 ? undefined : query;
+}
+
+async function loadBodyFromOptions(operation: GeneratedOperation, options: OperationOptions): Promise<unknown> {
+  if (!operation.hasBody) {
+    if (options.body || options.bodyFile) {
+      throw new Error(`Command '${[...operation.commandPath, operation.action].join(" ")}' does not accept a request body.`);
+    }
+
+    return undefined;
+  }
+
+  if (options.body && options.bodyFile) {
+    throw new Error("Use either --body or --body-file, not both.");
+  }
+
+  let rawInput: string | undefined;
+
+  if (options.bodyFile) {
+    rawInput = await readFile(options.bodyFile, "utf8");
+  } else if (options.body) {
+    if (options.body.startsWith("@")) {
+      rawInput = await readFile(options.body.slice(1), "utf8");
+    } else {
+      rawInput = options.body;
+    }
+  }
+
+  if (rawInput == null) {
+    throw new Error(`Command '${[...operation.commandPath, operation.action].join(" ")}' requires --body or --body-file.`);
+  }
+
+  try {
+    return JSON.parse(rawInput);
+  } catch (error) {
+    throw new Error(`Invalid JSON body: ${formatApiError(error)}`);
+  }
+}
+
+async function confirmMutation(operation: GeneratedOperation, options: OperationOptions): Promise<boolean> {
+  if (operation.method === "get" || options.yes) {
+    return true;
+  }
+
+  return confirm({
+    message: `${operation.method.toUpperCase()} ${operation.path}?`,
+    default: false
+  });
+}
+
+function buildPathParams(operation: GeneratedOperation, pathValues: string[]): Record<string, string> {
+  return Object.fromEntries(operation.pathParams.map((name, index) => [name, pathValues[index] ?? ""]));
+}
+
+function createGeneratedClient(family: OperationFamily, apiKey: string): GeneratedCoreClient | GeneratedLifecycleManagerClient {
+  return family === "core"
+    ? new GeneratedCoreClient({ apiKey })
+    : new GeneratedLifecycleManagerClient({ apiKey });
+}
+
+async function invokeOperation(
+  family: OperationFamily,
+  operation: GeneratedOperation,
+  options: OperationOptions,
+  pathValues: string[],
+  queryOverride?: Record<string, string>
+): Promise<unknown> {
+  const { apiKey } = await getApiKeyForCommand(options);
+  const client = createGeneratedClient(family, apiKey) as unknown as Record<string, (...args: unknown[]) => Promise<unknown>>;
+  const method = client[operation.methodName];
+
+  if (typeof method !== "function") {
+    throw new Error(`Generated client is missing method '${operation.methodName}'. Re-run 'pnpm generate:sdk'.`);
+  }
+
+  const query = queryOverride ?? buildQueryFromOptions(operation, options);
+  const body = await loadBodyFromOptions(operation, options);
+  const args: unknown[] = [];
+
+  if (operation.pathParams.length > 0) {
+    args.push(buildPathParams(operation, pathValues));
+  }
+
+  if (operation.queryParams.length > 0) {
+    args.push(query);
+  }
+
+  if (operation.hasBody) {
+    args.push(body);
+  }
+
+  return method.apply(client, args);
+}
+
+async function executeOperation(
+  family: OperationFamily,
+  operation: GeneratedOperation,
+  options: OperationOptions,
+  pathValues: string[]
+): Promise<void> {
+  const format = resolveOutputFormat(options);
+  const fields = parseFields(options.fields);
+
+  if (!(await confirmMutation(operation, options))) {
+    console.log("Aborted.");
+    return;
+  }
+
+  if (operation.output === "list") {
+    const initialQuery = buildQueryFromOptions(operation, options) ?? {};
+    let nextCursor = initialQuery.cursor;
+
+    while (true) {
+      const query = nextCursor ? { ...initialQuery, cursor: nextCursor } : initialQuery;
+      const payload = await invokeOperation(family, operation, options, pathValues, query);
+      printList(payload, format, fields);
+
+      if (!options.all) {
+        return;
+      }
+
+      const cursor = (payload as { next_cursor?: string | null })?.next_cursor;
+      if (typeof cursor !== "string" || cursor.length === 0) {
+        return;
+      }
+
+      nextCursor = cursor;
+    }
+  }
+
+  const payload = await invokeOperation(family, operation, options, pathValues);
+  printObject(payload, format, fields);
+}
+
+function getOperationSortKey(operation: GeneratedOperation): string {
+  const actionOrder = ["list", "get", "create", "update", "delete"];
+  return `${operation.commandPath.join("/")}:${actionOrder.indexOf(operation.action).toString().padStart(2, "0")}:${operation.pathParams.length}`;
+}
+
+function extractApiVersion(path: string): number {
+  const match = path.match(/\/v(\d+)\//);
+  return match ? Number(match[1]) : 0;
+}
+
+function stripLeadingVersion(commandPath: readonly string[]): string[] {
+  if (commandPath.length > 0 && /^v\d+$/i.test(commandPath[0] ?? "")) {
+    return commandPath.slice(1);
+  }
+
+  return [...commandPath];
+}
+
+function operationIdentity(operation: GeneratedOperation): string {
+  return [
+    operation.commandPath.join("/"),
+    operation.action,
+    operation.pathParams.join(",")
+  ].join("|");
+}
+
+function buildLatestLifecycleManagerOperations(): GeneratedOperation[] {
+  const preferred = new Map<string, GeneratedOperation>();
+
+  for (const operation of lifecycleManagerOperations) {
+    const normalized = {
+      ...operation,
+      commandPath: stripLeadingVersion(operation.commandPath)
+    };
+    const key = operationIdentity(normalized);
+    const existing = preferred.get(key);
+
+    if (!existing || extractApiVersion(normalized.path) > extractApiVersion(existing.path)) {
+      preferred.set(key, normalized);
+    }
+  }
+
+  return [...preferred.values()];
+}
+
+function registerOperations(
+  root: Command,
+  family: OperationFamily,
+  operations: readonly GeneratedOperation[]
+): void {
+  const commandCache = new Map<string, Command>([["", root]]);
+
+  for (const operation of [...operations].sort((left, right) => getOperationSortKey(left).localeCompare(getOperationSortKey(right)))) {
+    let current = root;
+    const pathSoFar: string[] = [];
+
+    for (const segment of operation.commandPath) {
+      pathSoFar.push(segment);
+      const key = pathSoFar.join("/");
+      const existing = commandCache.get(key);
+
+      if (existing) {
+        current = existing;
+        continue;
+      }
+
+      const group = current.command(segment).description(`${humanizeSegment(segment)} commands`);
+      commandCache.set(key, group);
+      current = group;
+    }
+
+    const leaf = current.command(operation.action).description(operation.summary);
+    for (const pathParam of operation.pathParams) {
+      leaf.argument(`<${pathParam}>`, `${pathParam} path parameter`);
+    }
+
+    addOperationOptions(leaf, operation).action(async (...actionArgs: unknown[]) => {
+      const options = actionArgs[actionArgs.length - 1] as OperationOptions;
+      const pathValues = actionArgs.slice(0, -1).map((value) => String(value));
+      await executeOperation(family, operation, options, pathValues);
+    });
+  }
+}
+
+function findOperation(
+  operations: readonly GeneratedOperation[],
+  path: string,
+  method: GeneratedOperation["method"]
+): GeneratedOperation {
+  const operation = operations.find((entry) => entry.path === path && entry.method === method);
+  if (!operation) {
+    throw new Error(`Missing generated operation for ${method.toUpperCase()} ${path}.`);
+  }
+
+  return operation;
+}
+
+function buildCoreAliasOperations(): GeneratedOperation[] {
+  return [
+    { ...findOperation(coreOperations, "/core/v1/assets/hardware", "get"), commandPath: ["hardware-assets"] },
+    { ...findOperation(coreOperations, "/core/v1/assets/hardware/{id}", "get"), commandPath: ["hardware-assets"] },
+    { ...findOperation(coreOperations, "/core/v1/service/tickets", "get"), commandPath: ["tickets"] },
+    { ...findOperation(coreOperations, "/core/v1/service/tickets/{id}", "get"), commandPath: ["tickets"] },
+    { ...findOperation(coreOperations, "/core/v1/service/contracts", "get"), commandPath: ["contracts"] },
+    { ...findOperation(coreOperations, "/core/v1/service/contracts/{id}", "get"), commandPath: ["contracts"] },
+    { ...findOperation(coreOperations, "/core/v1/assets/saas", "get"), commandPath: ["saas-assets"] },
+    { ...findOperation(coreOperations, "/core/v1/assets/saas/{id}", "get"), commandPath: ["saas-assets"] }
+  ];
+}
+
+async function run(): Promise<void> {
+  const program = new Command();
+
+  program
+    .name("scalepad")
+    .description("ScalePad public CLI for Core API and Lifecycle Manager")
+    .version("0.1.0");
+
+  const auth = program.command("auth").description("manage API credentials");
+
+  addSharedAuthOptions(
+    auth.command("login")
+      .description("authenticate with an API key and store it under a profile")
+      .action(async (options: SharedOptions) => {
+        const profile = await resolveProfile(options.profile);
+        const suppliedApiKey = options.apiKey ?? await password({
+          message: "Enter your ScalePad API key",
+          mask: "*"
+        });
+
+        const coreClient = createCoreClient({ apiKey: suppliedApiKey });
+        const coreAccess = await probeCoreAccess(coreClient);
+        const lmAccess = await probeLifecycleManagerAccess(suppliedApiKey);
+
+        if (!coreAccess && !lmAccess) {
+          throw new Error("Unable to validate the API key against Core API or Lifecycle Manager.");
+        }
+
+        const storage = await storeApiKey(profile, suppliedApiKey);
+        console.log(`Authenticated profile '${profile}'.`);
+        console.log(`Stored credential using ${storage}.`);
+        console.log(`Core access: ${coreAccess ? "yes" : "no"}`);
+        console.log(`Lifecycle Manager access: ${lmAccess ? "yes" : "no"}`);
+      })
+  );
+
+  addSharedAuthOptions(
+    auth.command("whoami")
+      .description("show the current profile and accessible API families")
+      .action(async (options: SharedOptions) => {
+        const profile = await resolveProfile(options.profile);
+        const apiKey = await resolveApiKey({
+          explicitApiKey: options.apiKey,
+          envApiKey: process.env.SCALEPAD_API_KEY,
+          profile
+        });
+
+        if (!apiKey) {
+          throw new Error(`No API key configured for profile '${profile}'.`);
+        }
+
+        const stored = !options.apiKey && !process.env.SCALEPAD_API_KEY ? await readStoredApiKey(profile) : null;
+        const coreClient = createCoreClient({ apiKey });
+        const result = {
+          profile,
+          credential_source: options.apiKey ? "flag" : process.env.SCALEPAD_API_KEY ? "env" : stored ? "stored" : "unknown",
+          core_access: false,
+          lifecycle_manager_access: false
+        };
+
+        result.core_access = await probeCoreAccess(coreClient);
+        result.lifecycle_manager_access = await probeLifecycleManagerAccess(apiKey);
+
+        console.log(JSON.stringify(result, null, 2));
+      })
+  );
+
+  addSharedAuthOptions(
+    auth.command("logout")
+      .description("remove the stored credential for a profile")
+      .action(async (options: SharedOptions) => {
+        const profile = await resolveProfile(options.profile);
+        const confirmed = await confirm({
+          message: `Remove the stored API key for profile '${profile}'?`,
+          default: true
+        });
+
+        if (!confirmed) {
+          console.log("Aborted.");
+          return;
+        }
+
+        const removed = await deleteStoredApiKey(profile);
+        if (!removed) {
+          console.log(`No stored credential found for profile '${profile}'.`);
+          return;
+        }
+
+        console.log(`Removed stored credential for profile '${profile}'.`);
+      })
+  );
+
+  const core = program.command("core").description("ScalePad Core API commands");
+  const lm = program.command("lm").description("Lifecycle Manager API commands");
+
+  registerOperations(core, "core", [...coreOperations, ...buildCoreAliasOperations()]);
+  registerOperations(lm, "lm", buildLatestLifecycleManagerOperations());
+
+  addExpandedHelp(program, "");
+  addExpandedHelp(auth);
+  addExpandedHelp(core);
+  addExpandedHelp(lm);
+
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof ScalepadApiError || error instanceof ScalepadLmApiError) {
+      console.error(formatApiError(error));
+      console.error(JSON.stringify(error.payload, null, 2));
+      process.exitCode = 1;
+      return;
+    }
+
+    console.error(formatApiError(error));
+    process.exitCode = 1;
+  }
+}
+
+void run();