@scalepad/cli 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,86 @@
+# @scalepad/cli
+
+Command line interface for the public ScalePad Core API and Lifecycle Manager API.
+
+This is the primary supported developer interface for this repo. The `@scalepad/sdk-core` and `@scalepad/sdk-lm` packages are intentionally thinner helper packages used by the CLI.
+
+## Install
+
+```bash
+npm install -g @scalepad/cli
+```
+
+## Quick start
+
+```bash
+scalepad auth login
+scalepad auth whoami
+scalepad core clients list --limit 5
+scalepad lm action-items list --limit 5
+```
+
+The CLI resolves credentials in this order:
+
+1. `--api-key`
+2. `SCALEPAD_API_KEY`
+3. Stored profile credential
+
+When keychain access is available, credentials are stored with `keytar`. Otherwise the CLI falls back to a local credential file with locked permissions.
+
+## Commands
+
+Authentication:
+
+```bash
+scalepad auth login
+scalepad auth whoami
+scalepad auth logout
+```
+
+Core API:
+
+```bash
+scalepad core clients list
+scalepad core clients get <id>
+scalepad core integrations configurations list
+scalepad core hardware-assets list
+scalepad core tickets list
+```
+
+Lifecycle Manager API:
+
+```bash
+scalepad lm action-items list
+scalepad lm action-items get <id>
+```
+
+## Common options
+
+- `--profile <name>`: use a named credential profile
+- `--api-key <key>`: override the stored credential for a single command
+- `--json`, `--jsonl`, `--csv`, `--table`: choose the output format
+- `--fields <a,b,c>`: project specific response fields
+- `--limit <count>`, `--cursor <cursor>`, `--all`: pagination controls for list endpoints
+- `--filter <field=expr>`: repeatable filter expression
+- `--sort <field>` and `--desc`: sorting for list endpoints
+- `--query <name=value>`: pass raw query parameters through to the API
+
+## Examples
+
+```bash
+scalepad core clients list --limit 25 --table
+scalepad core tickets list --filter status=open --sort created_at --desc --json
+scalepad lm action-items get 12345 --fields id,title,status --table
+```
+
+## Development
+
+From the monorepo root:
+
+```bash
+pnpm install
+pnpm fetch:specs
+pnpm generate:sdk
+pnpm build
+node packages/cli/dist/index.js --help
+```

package/dist/index.js

@@ -346,7 +346,7 @@ async function run() {
     program
         .name("scalepad")
         .description("ScalePad public CLI for Core API and Lifecycle Manager")
-        .version("0.1.0");
+        .version("0.1.1");
     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")

package/package.json

@@ -1,17 +1,25 @@
 {
   "name": "@scalepad/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "description": "ScalePad command line interface for the Core API and Lifecycle Manager API.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
     "scalepad": "dist/index.js"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "@inquirer/prompts": "^7.8.4",
     "commander": "^14.0.1",
-    "@scalepad/sdk-lm": "0.1.0",
-    "@scalepad/sdk-core": "0.1.0"
+    "@scalepad/sdk-lm": "0.1.2",
+    "@scalepad/sdk-core": "0.1.2"
   },
   "optionalDependencies": {
     "keytar": "^7.9.0"

package/src/config.ts

@@ -1,66 +0,0 @@
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-export interface ProfileMetadata {
-  storage?: "keytar" | "file";
-}
-
-export interface CliConfig {
-  currentProfile: string;
-  profiles: Record<string, ProfileMetadata>;
-}
-
-const DEFAULT_CONFIG: CliConfig = {
-  currentProfile: "default",
-  profiles: {}
-};
-
-function configRoot(): string {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg) {
-    return join(xdg, "scalepad-cli");
-  }
-
-  return join(homedir(), ".config", "scalepad-cli");
-}
-
-export function getConfigPath(): string {
-  return join(configRoot(), "config.json");
-}
-
-export function getFallbackCredentialsPath(): string {
-  return join(configRoot(), "credentials.json");
-}
-
-export async function ensureConfigDir(): Promise<void> {
-  await mkdir(configRoot(), { recursive: true });
-}
-
-export async function loadConfig(): Promise<CliConfig> {
-  try {
-    const raw = await readFile(getConfigPath(), "utf8");
-    const parsed = JSON.parse(raw) as Partial<CliConfig>;
-    return {
-      currentProfile: parsed.currentProfile ?? "default",
-      profiles: parsed.profiles ?? {}
-    };
-  } catch {
-    return structuredClone(DEFAULT_CONFIG);
-  }
-}
-
-export async function saveConfig(config: CliConfig): Promise<void> {
-  await ensureConfigDir();
-  const path = getConfigPath();
-  await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-  await chmod(path, 0o600);
-}
-
-export async function writePrivateJson(path: string, value: unknown): Promise<void> {
-  await ensureConfigDir();
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-  await chmod(path, 0o600);
-}
-

package/src/credentials.ts

@@ -1,125 +0,0 @@
-import { chmod, readFile, rm } from "node:fs/promises";
-import { getFallbackCredentialsPath, loadConfig, saveConfig, writePrivateJson } from "./config.js";
-
-const SERVICE_NAME = "@scalepad/cli";
-
-interface KeytarModule {
-  getPassword(service: string, account: string): Promise<string | null>;
-  setPassword(service: string, account: string, password: string): Promise<void>;
-  deletePassword(service: string, account: string): Promise<boolean>;
-}
-
-interface FallbackCredentialFile {
-  profiles: Record<string, string>;
-}
-
-async function maybeLoadKeytar(): Promise<KeytarModule | null> {
-  try {
-    const module = await import("keytar");
-    return module.default as KeytarModule;
-  } catch {
-    return null;
-  }
-}
-
-function accountName(profile: string): string {
-  return `profile:${profile}`;
-}
-
-async function readFallbackFile(): Promise<FallbackCredentialFile> {
-  try {
-    const raw = await readFile(getFallbackCredentialsPath(), "utf8");
-    const parsed = JSON.parse(raw) as Partial<FallbackCredentialFile>;
-    return { profiles: parsed.profiles ?? {} };
-  } catch {
-    return { profiles: {} };
-  }
-}
-
-async function writeFallbackFile(value: FallbackCredentialFile): Promise<void> {
-  await writePrivateJson(getFallbackCredentialsPath(), value);
-}
-
-export async function storeApiKey(profile: string, apiKey: string): Promise<"keytar" | "file"> {
-  const config = await loadConfig();
-  const keytar = await maybeLoadKeytar();
-
-  if (keytar) {
-    await keytar.setPassword(SERVICE_NAME, accountName(profile), apiKey);
-    config.profiles[profile] = { storage: "keytar" };
-    config.currentProfile = profile;
-    await saveConfig(config);
-    return "keytar";
-  }
-
-  const fallback = await readFallbackFile();
-  fallback.profiles[profile] = apiKey;
-  await writeFallbackFile(fallback);
-  await chmod(getFallbackCredentialsPath(), 0o600);
-
-  config.profiles[profile] = { storage: "file" };
-  config.currentProfile = profile;
-  await saveConfig(config);
-  return "file";
-}
-
-export async function readStoredApiKey(profile: string): Promise<string | null> {
-  const keytar = await maybeLoadKeytar();
-  if (keytar) {
-    const key = await keytar.getPassword(SERVICE_NAME, accountName(profile));
-    if (key) {
-      return key;
-    }
-  }
-
-  const fallback = await readFallbackFile();
-  return fallback.profiles[profile] ?? null;
-}
-
-export async function deleteStoredApiKey(profile: string): Promise<boolean> {
-  const config = await loadConfig();
-  let removed = false;
-
-  const keytar = await maybeLoadKeytar();
-  if (keytar) {
-    removed = (await keytar.deletePassword(SERVICE_NAME, accountName(profile))) || removed;
-  }
-
-  const fallback = await readFallbackFile();
-  if (profile in fallback.profiles) {
-    delete fallback.profiles[profile];
-    await writeFallbackFile(fallback);
-    removed = true;
-  }
-
-  delete config.profiles[profile];
-  if (config.currentProfile === profile) {
-    config.currentProfile = "default";
-  }
-  await saveConfig(config);
-
-  if (Object.keys(fallback.profiles).length === 0) {
-    await rm(getFallbackCredentialsPath(), { force: true });
-  }
-
-  return removed;
-}
-
-export interface ResolveApiKeyOptions {
-  explicitApiKey?: string;
-  envApiKey?: string;
-  profile: string;
-}
-
-export async function resolveApiKey(options: ResolveApiKeyOptions): Promise<string | null> {
-  if (options.explicitApiKey) {
-    return options.explicitApiKey;
-  }
-
-  if (options.envApiKey) {
-    return options.envApiKey;
-  }
-
-  return readStoredApiKey(options.profile);
-}
-

package/src/filters.ts

@@ -1,73 +0,0 @@
-export function parseFilterArgs(values: string[]): Record<string, string> {
-  const filters: Record<string, string> = {};
-  for (const rawValue of values) {
-    const separatorIndex = rawValue.indexOf("=");
-    if (separatorIndex <= 0 || separatorIndex === rawValue.length - 1) {
-      throw new Error(`Invalid filter '${rawValue}'. Expected field=expression.`);
-    }
-
-    const field = rawValue.slice(0, separatorIndex).trim();
-    const expression = rawValue.slice(separatorIndex + 1).trim();
-    if (!field || !expression) {
-      throw new Error(`Invalid filter '${rawValue}'. Expected field=expression.`);
-    }
-
-    filters[field] = expression;
-  }
-
-  return filters;
-}
-
-export function buildSort(sortField: string | undefined, desc: boolean): string | undefined {
-  if (!sortField) {
-    return undefined;
-  }
-
-  return `${desc ? "-" : "+"}${sortField}`;
-}
-
-type JsonLike = Record<string, unknown>;
-
-function getNestedValue(record: JsonLike, path: string): unknown {
-  const segments = path.split(".");
-  let current: unknown = record;
-  for (const segment of segments) {
-    if (current == null || typeof current !== "object") {
-      return undefined;
-    }
-    current = (current as JsonLike)[segment];
-  }
-
-  return current;
-}
-
-export function projectRecord(record: JsonLike, fields: string[] | undefined): JsonLike {
-  if (!fields || fields.length === 0) {
-    return record;
-  }
-
-  return Object.fromEntries(fields.map((field) => [field, getNestedValue(record, field)]));
-}
-
-export function flattenRecord(value: JsonLike, prefix = ""): Record<string, string> {
-  const flattened: Record<string, string> = {};
-
-  for (const [key, fieldValue] of Object.entries(value)) {
-    const nextKey = prefix ? `${prefix}.${key}` : key;
-
-    if (Array.isArray(fieldValue)) {
-      flattened[nextKey] = JSON.stringify(fieldValue);
-      continue;
-    }
-
-    if (fieldValue != null && typeof fieldValue === "object") {
-      Object.assign(flattened, flattenRecord(fieldValue as JsonLike, nextKey));
-      continue;
-    }
-
-    flattened[nextKey] = fieldValue == null ? "" : String(fieldValue);
-  }
-
-  return flattened;
-}
-

package/src/format.ts

@@ -1,210 +0,0 @@
-import { flattenRecord, projectRecord } from "./filters.js";
-
-export type JsonLike = Record<string, unknown>;
-export type OutputFormat = "table" | "json" | "jsonl" | "csv";
-
-export interface FormatFlags {
-  json?: boolean;
-  jsonl?: boolean;
-  csv?: boolean;
-  table?: boolean;
-}
-
-export interface ExtractedList {
-  items: JsonLike[];
-  nextCursor?: string | null;
-  totalCount?: number | null;
-}
-
-export function resolveOutputFormat(flags: FormatFlags): OutputFormat {
-  if (flags.json) {
-    return "json";
-  }
-  if (flags.jsonl) {
-    return "jsonl";
-  }
-  if (flags.csv) {
-    return "csv";
-  }
-  return "table";
-}
-
-export function extractList(payload: unknown): ExtractedList {
-  if (Array.isArray(payload)) {
-    return { items: payload.filter(isJsonLike) };
-  }
-
-  if (!isJsonLike(payload)) {
-    return { items: [] };
-  }
-
-  const dataCandidate = payload.data;
-  const nextCursor = typeof payload.next_cursor === "string" ? payload.next_cursor : null;
-  const totalCount = typeof payload.total_count === "number" ? payload.total_count : null;
-
-  if (Array.isArray(dataCandidate)) {
-    return {
-      items: dataCandidate.filter(isJsonLike),
-      nextCursor,
-      totalCount
-    };
-  }
-
-  return { items: [payload], nextCursor, totalCount };
-}
-
-function isJsonLike(value: unknown): value is JsonLike {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-
-function formatScalar(value: unknown): string {
-  if (value == null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-
-  return JSON.stringify(value);
-}
-
-function renderTable(records: JsonLike[]): string {
-  if (records.length === 0) {
-    return "No records found.";
-  }
-
-  const columnSet = new Set<string>();
-  const rows = records.map((record) => flattenRecord(record));
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      columnSet.add(key);
-    }
-  }
-
-  const columns = [...columnSet];
-  const widths = columns.map((column) => column.length);
-
-  rows.forEach((row) => {
-    columns.forEach((column, index) => {
-      widths[index] = Math.max(widths[index] ?? 0, (row[column] ?? "").length);
-    });
-  });
-
-  const header = columns.map((column, index) => column.padEnd(widths[index] ?? column.length)).join("  ");
-  const separator = columns.map((column, index) => "-".repeat(widths[index] ?? column.length)).join("  ");
-  const body = rows.map((row) => columns.map((column, index) => (row[column] ?? "").padEnd(widths[index] ?? column.length)).join("  "));
-
-  return [header, separator, ...body].join("\n");
-}
-
-function renderCsv(records: JsonLike[]): string {
-  if (records.length === 0) {
-    return "";
-  }
-
-  const flattened = records.map((record) => flattenRecord(record));
-  const columns = [...new Set(flattened.flatMap((record) => Object.keys(record)))];
-  const escapeValue = (value: string): string => {
-    if (value.includes(",") || value.includes("\"") || value.includes("\n")) {
-      return `"${value.replaceAll("\"", "\"\"")}"`;
-    }
-    return value;
-  };
-
-  const lines = [
-    columns.join(","),
-    ...flattened.map((record) => columns.map((column) => escapeValue(record[column] ?? "")).join(","))
-  ];
-
-  return lines.join("\n");
-}
-
-export function printList(
-  payload: unknown,
-  format: OutputFormat,
-  fields?: string[],
-  metadataWriter: (message: string) => void = console.error
-): void {
-  if (format === "json") {
-    console.log(JSON.stringify(payload, null, 2));
-    return;
-  }
-
-  const extracted = extractList(payload);
-  const projected = extracted.items.map((item) => projectRecord(item, fields));
-
-  switch (format) {
-    case "jsonl":
-      projected.forEach((item) => {
-        console.log(JSON.stringify(item));
-      });
-      break;
-    case "csv":
-      console.log(renderCsv(projected));
-      break;
-    case "table":
-      console.log(renderTable(projected));
-      break;
-    default:
-      break;
-  }
-
-  const parts: string[] = [];
-  parts.push(`items=${projected.length}`);
-  if (extracted.totalCount != null) {
-    parts.push(`total_count=${extracted.totalCount}`);
-  }
-  if (extracted.nextCursor) {
-    parts.push(`next_cursor=${extracted.nextCursor}`);
-  }
-  metadataWriter(parts.join(" "));
-}
-
-export function printObject(payload: unknown, format: OutputFormat, fields?: string[]): void {
-  if (!isJsonLike(payload)) {
-    console.log(JSON.stringify(payload, null, 2));
-    return;
-  }
-
-  const projected = projectRecord(payload, fields);
-
-  if (format === "json" || format === "jsonl") {
-    console.log(JSON.stringify(projected, null, format === "json" ? 2 : 0));
-    return;
-  }
-
-  if (format === "csv") {
-    console.log(renderCsv([projected]));
-    return;
-  }
-
-  console.log(renderTable([projected]));
-}
-
-export function parseFields(value: string | undefined): string[] | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  return value.split(",").map((field) => field.trim()).filter(Boolean);
-}
-
-export function formatApiError(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  return String(error);
-}
-
-export function toPlainMessage(value: unknown): string {
-  if (typeof value === "string") {
-    return value;
-  }
-
-  return formatScalar(value);
-}
-

package/src/index.ts

@@ -1,603 +0,0 @@
-#!/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();

package/test/cli.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createCoreClient, ScalepadApiError } from "@scalepad/sdk-core";
-import { buildSort, flattenRecord, parseFilterArgs, projectRecord } from "../src/filters.js";
-import { extractList, parseFields, resolveOutputFormat } from "../src/format.js";
-
-describe("filter helpers", () => {
-  it("parses filter arguments into API query expressions", () => {
-    expect(parseFilterArgs([
-      "name=cont:acme",
-      "client_id=eq:2220324"
-    ])).toEqual({
-      name: "cont:acme",
-      client_id: "eq:2220324"
-    });
-  });
-
-  it("builds sort expressions", () => {
-    expect(buildSort("name", false)).toBe("+name");
-    expect(buildSort("name", true)).toBe("-name");
-  });
-
-  it("projects and flattens records", () => {
-    const record = {
-      id: "123",
-      name: "Acme",
-      nested: {
-        count: 4
-      }
-    };
-
-    expect(projectRecord(record, ["id", "nested.count"])).toEqual({
-      id: "123",
-      "nested.count": 4
-    });
-
-    expect(flattenRecord(record)).toEqual({
-      id: "123",
-      name: "Acme",
-      "nested.count": "4"
-    });
-  });
-});
-
-describe("format helpers", () => {
-  it("resolves output flags", () => {
-    expect(resolveOutputFormat({ json: true })).toBe("json");
-    expect(resolveOutputFormat({ jsonl: true })).toBe("jsonl");
-    expect(resolveOutputFormat({ csv: true })).toBe("csv");
-    expect(resolveOutputFormat({})).toBe("table");
-  });
-
-  it("extracts paginated list payloads", () => {
-    expect(extractList({
-      data: [{ id: "1" }],
-      total_count: 10,
-      next_cursor: "cursor-2"
-    })).toEqual({
-      items: [{ id: "1" }],
-      totalCount: 10,
-      nextCursor: "cursor-2"
-    });
-  });
-
-  it("parses field selections", () => {
-    expect(parseFields("id,name,nested.count")).toEqual(["id", "name", "nested.count"]);
-  });
-});
-
-describe("core SDK retry behavior", () => {
-  it("retries 429 responses before succeeding", async () => {
-    const fetchImpl = vi.fn()
-      .mockResolvedValueOnce(new Response(JSON.stringify({ error: "slow down" }), {
-        status: 429,
-        headers: {
-          "content-type": "application/json",
-          "retry-after": "0"
-        }
-      }))
-      .mockResolvedValueOnce(new Response(JSON.stringify({
-        data: [{ id: "1" }],
-        total_count: 1,
-        next_cursor: null
-      }), {
-        status: 200,
-        headers: {
-          "content-type": "application/json"
-        }
-      }));
-
-    const client = createCoreClient({
-      apiKey: "secret",
-      fetchImpl: fetchImpl as typeof fetch,
-      maxRetries: 1
-    });
-
-    await expect(client.listClients({ pageSize: 1 })).resolves.toMatchObject({
-      data: [{ id: "1" }],
-      total_count: 1
-    });
-    expect(fetchImpl).toHaveBeenCalledTimes(2);
-  });
-
-  it("throws a typed error on non-retriable failures", async () => {
-    const fetchImpl = vi.fn().mockResolvedValue(new Response(JSON.stringify({ error: "nope" }), {
-      status: 401,
-      headers: {
-        "content-type": "application/json"
-      }
-    }));
-
-    const client = createCoreClient({
-      apiKey: "secret",
-      fetchImpl: fetchImpl as typeof fetch
-    });
-
-    await expect(client.listClients()).rejects.toBeInstanceOf(ScalepadApiError);
-  });
-});

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"]
-}