@scalepad/cli 0.1.0

package/src/credentials.ts

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,210 @@
+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);
+}
+