@clankid/cli 0.17.0

package/src/lib/config.ts

@@ -0,0 +1,239 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { CliError } from "./errors";
+import { getConfigPath } from "./paths";
+import type { ConfigFile, OutputMode, ProfileConfig } from "../types/api";
+
+const DEFAULT_BASE_URL = "https://clank.id";
+const DEFAULT_PROFILE = "default";
+
+function defaultProfile(baseUrl?: string): ProfileConfig {
+  return {
+    baseUrl: resolveBaseUrl(baseUrl),
+    output: "table",
+    identityKeys: {}
+  };
+}
+
+function defaultConfig(baseUrl?: string): ConfigFile {
+  return {
+    version: 2,
+    activeProfile: DEFAULT_PROFILE,
+    profiles: {
+      [DEFAULT_PROFILE]: defaultProfile(baseUrl)
+    }
+  };
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+export function resolveBaseUrl(baseUrl?: string, fallback = DEFAULT_BASE_URL): string {
+  return normalizeBaseUrl(baseUrl ?? process.env.CLANKID_BASE_URL ?? fallback);
+}
+
+export async function loadConfig(configPath = getConfigPath()): Promise<ConfigFile> {
+  try {
+    const raw = await readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw) as ConfigFile;
+
+    if (
+      parsed.version !== 2 ||
+      typeof parsed.activeProfile !== "string" ||
+      !parsed.profiles ||
+      !profilesHaveIdentityKeys(parsed.profiles)
+    ) {
+      throw new CliError(`Unsupported config format in ${configPath}`);
+    }
+
+    return parsed;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return defaultConfig();
+    }
+
+    if (error instanceof CliError) {
+      throw error;
+    }
+
+    throw new CliError(`Failed to read config from ${configPath}: ${(error as Error).message}`);
+  }
+}
+
+function profilesHaveIdentityKeys(profiles: ConfigFile["profiles"]): boolean {
+  return Object.values(profiles).every(
+    (profile) =>
+      profile &&
+      typeof profile === "object" &&
+      profile.identityKeys &&
+      typeof profile.identityKeys === "object" &&
+      !Array.isArray(profile.identityKeys),
+  );
+}
+
+export async function saveConfig(config: ConfigFile, configPath = getConfigPath()): Promise<void> {
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+export async function updateConfig(
+  mutate: (config: ConfigFile) => void,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  const config = await loadConfig(configPath);
+  mutate(config);
+  await saveConfig(config, configPath);
+  return config;
+}
+
+export async function updateProfile(
+  profileName: string,
+  mutate: (profile: ProfileConfig, config: ConfigFile) => void,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  return updateConfig((config) => {
+    config.profiles[profileName] ??= defaultProfile();
+    mutate(config.profiles[profileName], config);
+    config.profiles[profileName].baseUrl = normalizeBaseUrl(config.profiles[profileName].baseUrl);
+  }, configPath);
+}
+
+export async function ensureConfig(configPath = getConfigPath(), baseUrl?: string): Promise<ConfigFile> {
+  return updateConfig((config) => {
+    config.profiles[config.activeProfile] ??= defaultProfile(baseUrl);
+    const activeProfile = config.profiles[config.activeProfile]!;
+
+    if (baseUrl) {
+      activeProfile.baseUrl = normalizeBaseUrl(baseUrl);
+    }
+  }, configPath);
+}
+
+export async function ensureProfile(
+  profileName: string,
+  configPath = getConfigPath(),
+  baseUrl?: string
+): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (profile) => {
+      if (baseUrl) {
+        profile.baseUrl = baseUrl;
+      }
+    },
+    configPath
+  );
+}
+
+export function resolveProfileName(config: ConfigFile, profileName?: string): string {
+  return profileName ?? process.env.CLANKID_PROFILE ?? config.activeProfile;
+}
+
+export function resolveProfile(
+  config: ConfigFile,
+  profileName?: string,
+  baseUrl?: string,
+): { profileName: string; profile: ProfileConfig } {
+  const resolvedName = resolveProfileName(config, profileName);
+  const profile = config.profiles[resolvedName];
+
+  if (!profile) {
+    throw new CliError(`Unknown profile "${resolvedName}"`);
+  }
+
+  return {
+    profileName: resolvedName,
+    profile: {
+      ...profile,
+      baseUrl: resolveBaseUrl(baseUrl, profile.baseUrl),
+    },
+  };
+}
+
+export async function setActiveProfile(profileName: string, configPath = getConfigPath()): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (_profile, config) => {
+      config.activeProfile = profileName;
+    },
+    configPath
+  );
+}
+
+export async function setProfileBaseUrl(
+  profileName: string,
+  baseUrl: string,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (profile) => {
+      profile.baseUrl = baseUrl;
+    },
+    configPath
+  );
+}
+
+export async function setProfileOutput(
+  profileName: string,
+  output: OutputMode,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (profile) => {
+      profile.output = output;
+    },
+    configPath
+  );
+}
+
+export async function setMasterToken(
+  profileName: string,
+  token: string | undefined,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (profile) => {
+      profile.masterToken = token;
+    },
+    configPath
+  );
+}
+
+export async function setReadOnlyToken(
+  profileName: string,
+  token: string | undefined,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (profile) => {
+      profile.readOnlyToken = token;
+    },
+    configPath
+  );
+}
+
+export async function storeIdentityKey(
+  profileName: string,
+  identityId: string,
+  token: string,
+  configPath = getConfigPath()
+): Promise<ConfigFile> {
+  return updateProfile(
+    profileName,
+    (profile) => {
+      profile.identityKeys[identityId] = {
+        token,
+        updatedAt: new Date().toISOString()
+      };
+    },
+    configPath
+  );
+}
+
+export { DEFAULT_BASE_URL };

package/src/lib/content.ts

@@ -0,0 +1,149 @@
+import { booleanFlag, stringFlag, type ParsedArgs } from "./args";
+import type { ContentFilter, ContentFormat, PayloadOp } from "../types/api";
+import { resolveBodyInput } from "./body-input";
+import { CliError } from "./errors";
+import { resolveJsonInput } from "./json-input";
+
+export interface StructuredContentInput {
+  body?: string;
+  payload?: Record<string, unknown>;
+  contentFormat?: ContentFormat;
+}
+
+export interface PayloadFilters {
+  contentFormat?: ContentFilter;
+  payloadContains?: string;
+  payloadPath?: string;
+  payloadOp?: PayloadOp;
+  payloadValue?: string;
+}
+
+export async function resolveStructuredContentInput(
+  args: ParsedArgs,
+  options: { requireContent?: boolean; label?: string } = {},
+): Promise<StructuredContentInput> {
+  if (booleanFlag(args.flags, "stdin") && booleanFlag(args.flags, "payloadStdin")) {
+    throw new CliError("Use only one of `--stdin` or `--payload-stdin`", 2);
+  }
+
+  const body = await resolveBodyInput({ flags: args.flags });
+  const payload = await resolveJsonInput({
+    flags: args.flags,
+    inlineKey: "payload",
+    fileKey: "payloadFile",
+    stdinKey: "payloadStdin",
+    label: options.label ?? "Payload",
+  });
+  const explicitFormat = parseContentFormat(stringFlag(args.flags, "content"), {
+    allowAll: false,
+  }) as ContentFormat | undefined;
+  const contentFormat = explicitFormat ?? (payload ? "json" : undefined);
+
+  if (explicitFormat === "markdown" && payload) {
+    throw new CliError("`--content markdown` cannot be used with JSON payload input", 2);
+  }
+
+  if (explicitFormat === "json" && !payload) {
+    throw new CliError("`--content json` requires `--payload`, `--payload-file`, or `--payload-stdin`", 2);
+  }
+
+  if (options.requireContent && body === undefined && payload === undefined) {
+    throw new CliError(
+      "Provide at least one of `--body`, `--body-file`, `--stdin`, `--payload`, `--payload-file`, or `--payload-stdin`",
+      2,
+    );
+  }
+
+  return { body, payload, contentFormat };
+}
+
+export function payloadFilters(args: ParsedArgs): PayloadFilters {
+  const payloadContains = stringFlag(args.flags, "payloadContains");
+  const payloadPath = stringFlag(args.flags, "payloadPath");
+  const payloadOp = parsePayloadOp(stringFlag(args.flags, "payloadOp"));
+  const payloadValue = stringFlag(args.flags, "payloadValue");
+
+  if (payloadContains !== undefined) {
+    return {
+      ...payloadFilterFields(args, payloadPath, payloadOp, payloadValue),
+      payloadContains: compactJsonObject(payloadContains, "--payload-contains"),
+    };
+  }
+
+  return payloadFilterFields(args, payloadPath, payloadOp, payloadValue);
+}
+
+function payloadFilterFields(
+  args: ParsedArgs,
+  payloadPath: string | undefined,
+  payloadOp: PayloadOp | undefined,
+  payloadValue: string | undefined,
+): PayloadFilters {
+  if (payloadValue !== undefined && payloadOp !== "eq") {
+    throw new CliError("`--payload-value` requires `--payload-op eq`", 2);
+  }
+
+  if (payloadOp !== undefined && payloadPath === undefined) {
+    throw new CliError("`--payload-op` requires `--payload-path`", 2);
+  }
+
+  if (payloadOp === "eq" && payloadValue === undefined) {
+    throw new CliError("`--payload-op eq` requires `--payload-value`", 2);
+  }
+
+  return {
+    contentFormat: parseContentFormat(stringFlag(args.flags, "content"), {
+      allowAll: true,
+    }),
+    payloadPath,
+    payloadOp,
+    payloadValue,
+  };
+}
+
+function parseContentFormat(
+  value: string | undefined,
+  options: { allowAll: boolean },
+): ContentFilter | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  const allowed = options.allowAll ? ["markdown", "json", "all"] : ["markdown", "json"];
+
+  if (!allowed.includes(value)) {
+    throw new CliError(`--content must be one of: ${allowed.join(", ")}`, 2);
+  }
+
+  return value as ContentFilter;
+}
+
+function parsePayloadOp(value: string | undefined): PayloadOp | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (value !== "exists" && value !== "eq") {
+    throw new CliError("--payload-op must be one of: exists, eq", 2);
+  }
+
+  return value;
+}
+
+function compactJsonObject(value: string, label: string): string {
+  try {
+    const parsed = JSON.parse(value);
+
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new CliError(`${label} must be a JSON object`, 2);
+    }
+
+    return JSON.stringify(parsed);
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+
+    throw new CliError(`${label} must be valid JSON`, 2);
+  }
+}

package/src/lib/context.ts

@@ -0,0 +1,43 @@
+import { loadConfig, resolveProfile } from "./config";
+import { booleanFlag, stringFlag, type ParsedArgs } from "./args";
+import { getConfigPath } from "./paths";
+import { ClankmatesClient } from "./client";
+import type { Io } from "./output";
+import type { ConfigFile, OutputMode, ProfileConfig } from "../types/api";
+
+export interface CommandContext {
+  config: ConfigFile;
+  configPath: string;
+  profileName: string;
+  profile: ProfileConfig;
+  outputMode: OutputMode;
+  client: ClankmatesClient;
+  io: Io;
+}
+
+export async function createCommandContext(args: ParsedArgs, io: Io): Promise<CommandContext> {
+  const configPath = getConfigPath();
+  const config = await loadConfig(configPath);
+  const { profileName, profile } = resolveProfile(
+    config,
+    stringFlag(args.flags, "profile"),
+    stringFlag(args.flags, "baseUrl"),
+  );
+
+  return {
+    config,
+    configPath,
+    profileName,
+    profile,
+    outputMode: resolveOutputMode(profile, args.flags),
+    client: new ClankmatesClient(profile),
+    io
+  };
+}
+
+export function resolveOutputMode(
+  profile: Pick<ProfileConfig, "output">,
+  flags: ParsedArgs["flags"]
+): OutputMode {
+  return booleanFlag(flags, "json") ? "json" : profile.output;
+}

package/src/lib/errors.ts

@@ -0,0 +1,17 @@
+export class CliError extends Error {
+  readonly exitCode: number;
+
+  constructor(message: string, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+
+export function assertPresent(value: string | undefined, message: string): string {
+  if (!value) {
+    throw new CliError(message, 2);
+  }
+
+  return value;
+}