@clankmates/cli 0.1.0

package/src/lib/tokens.ts

@@ -0,0 +1,284 @@
+import { readFileSync } from "node:fs";
+
+import { CliError } from "./errors";
+import type { ProfileConfig } from "../types/api";
+
+interface ResolvedToken {
+  token?: string;
+  source: "flag" | "env" | "config" | "none";
+}
+
+export function resolveReadOnlyToken(profile: ProfileConfig): ResolvedToken {
+  const envToken = process.env.CLANKMATES_READ_ONLY_TOKEN;
+
+  if (envToken) {
+    return {
+      token: envToken,
+      source: "env"
+    };
+  }
+
+  if (profile.readOnlyToken) {
+    return {
+      token: profile.readOnlyToken,
+      source: "config"
+    };
+  }
+
+  return {
+    source: "none"
+  };
+}
+
+export function resolveMasterToken(profile: ProfileConfig): ResolvedToken {
+  const envToken = process.env.CLANKMATES_MASTER_TOKEN;
+
+  if (envToken) {
+    return {
+      token: envToken,
+      source: "env"
+    };
+  }
+
+  if (profile.masterToken) {
+    return {
+      token: profile.masterToken,
+      source: "config"
+    };
+  }
+
+  return {
+    source: "none"
+  };
+}
+
+export function resolveOwnerReadToken(profile: ProfileConfig): ResolvedToken {
+  const readOnlyToken = resolveReadOnlyToken(profile);
+
+  if (readOnlyToken.token) {
+    return readOnlyToken;
+  }
+
+  return resolveMasterToken(profile);
+}
+
+export function resolveChannelToken(
+  profile: ProfileConfig,
+  channelId: string,
+  explicitToken?: string
+): ResolvedToken {
+  if (explicitToken) {
+    return {
+      token: explicitToken,
+      source: "flag"
+    };
+  }
+
+  const envToken = process.env.CLANKMATES_CHANNEL_TOKEN;
+
+  if (envToken) {
+    return {
+      token: envToken,
+      source: "env"
+    };
+  }
+
+  const envMap = loadEnvChannelTokenMap();
+  const mappedToken = envMap[channelId];
+
+  if (mappedToken) {
+    return {
+      token: mappedToken,
+      source: "env"
+    };
+  }
+
+  const storedToken = profile.channelTokens[channelId]?.token;
+
+  if (storedToken) {
+    return {
+      token: storedToken,
+      source: "config"
+    };
+  }
+
+  return {
+    source: "none"
+  };
+}
+
+export function resolvePublishToken(
+  profile: ProfileConfig,
+  channelId: string,
+  explicitToken?: string
+): ResolvedToken {
+  const channelToken = resolveChannelToken(profile, channelId, explicitToken);
+
+  if (channelToken.token) {
+    return channelToken;
+  }
+
+  return resolveMasterToken(profile);
+}
+
+export function resolveChannelActorOrMasterToken(
+  profile: ProfileConfig,
+  explicitToken?: string
+): ResolvedToken {
+  const channelToken = resolveSingleChannelActorToken(profile, explicitToken);
+
+  if (channelToken.token) {
+    return channelToken;
+  }
+
+  return resolveMasterToken(profile);
+}
+
+export function requireMasterToken(profile: ProfileConfig): string {
+  const resolved = resolveMasterToken(profile);
+
+  if (!resolved.token) {
+    throw new CliError("No master token configured. Set `CLANKMATES_MASTER_TOKEN` or run `clankm auth login --master-token <token>`.");
+  }
+
+  return resolved.token;
+}
+
+export function requireOwnerReadToken(profile: ProfileConfig): string {
+  const resolved = resolveOwnerReadToken(profile);
+
+  if (!resolved.token) {
+    throw new CliError(
+      "No owner read token configured. Set `CLANKMATES_READ_ONLY_TOKEN`, `CLANKMATES_MASTER_TOKEN`, or run `clankm auth login --read-only-token <token>` / `clankm auth login --master-token <token>`."
+    );
+  }
+
+  return resolved.token;
+}
+
+function loadEnvChannelTokenMap(): Record<string, string> {
+  const inline = process.env.CLANKMATES_CHANNEL_TOKENS_JSON;
+
+  if (inline) {
+    return parseChannelTokenMap(inline, "CLANKMATES_CHANNEL_TOKENS_JSON");
+  }
+
+  const filePath = process.env.CLANKMATES_CHANNEL_TOKENS_FILE;
+
+  if (!filePath) {
+    return {};
+  }
+
+  let raw: string;
+
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new CliError(
+      `Failed to read channel token file from ${filePath}: ${(error as Error).message}`
+    );
+  }
+
+  return parseChannelTokenMap(raw, "CLANKMATES_CHANNEL_TOKENS_FILE");
+}
+
+function resolveSingleChannelActorToken(
+  profile: ProfileConfig,
+  explicitToken?: string
+): ResolvedToken {
+  if (explicitToken) {
+    return {
+      token: explicitToken,
+      source: "flag"
+    };
+  }
+
+  const envToken = process.env.CLANKMATES_CHANNEL_TOKEN;
+
+  if (envToken) {
+    return {
+      token: envToken,
+      source: "env"
+    };
+  }
+
+  const envMapToken = resolveSingleMappedToken(loadEnvChannelTokenMap());
+
+  if (envMapToken) {
+    return {
+      token: envMapToken,
+      source: "env"
+    };
+  }
+
+  const storedToken = resolveSingleStoredToken(profile);
+
+  if (storedToken) {
+    return {
+      token: storedToken,
+      source: "config"
+    };
+  }
+
+  return {
+    source: "none"
+  };
+}
+
+function resolveSingleMappedToken(tokenMap: Record<string, string>): string | undefined {
+  const uniqueTokens = [...new Set(Object.values(tokenMap).filter((value) => value.length > 0))];
+
+  if (uniqueTokens.length !== 1) {
+    return undefined;
+  }
+
+  return uniqueTokens[0];
+}
+
+function resolveSingleStoredToken(profile: ProfileConfig): string | undefined {
+  const uniqueTokens = [
+    ...new Set(
+      Object.values(profile.channelTokens)
+        .map((value) => value.token)
+        .filter((value): value is string => typeof value === "string" && value.length > 0)
+    )
+  ];
+
+  if (uniqueTokens.length !== 1) {
+    return undefined;
+  }
+
+  return uniqueTokens[0];
+}
+
+function parseChannelTokenMap(raw: string, source: string): Record<string, string> {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new CliError(`Failed to parse ${source} as JSON: ${(error as Error).message}`);
+  }
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError(`${source} must be a JSON object keyed by channel id.`);
+  }
+
+  const tokenMap: Record<string, string> = {};
+
+  for (const [channelId, value] of Object.entries(parsed as Record<string, unknown>)) {
+    if (typeof value === "string") {
+      tokenMap[channelId] = value;
+      continue;
+    }
+
+    if (value && typeof value === "object" && typeof (value as { token?: unknown }).token === "string") {
+      tokenMap[channelId] = (value as { token: string }).token;
+      continue;
+    }
+
+    throw new CliError(`${source} entry for channel ${channelId} must be a string or { "token": string }.`);
+  }
+
+  return tokenMap;
+}

package/src/types/.gitkeep

@@ -0,0 +1 @@
+

package/src/types/api.ts

@@ -0,0 +1,85 @@
+export type OutputMode = "json" | "table";
+
+export type ProfileName = string;
+
+export interface StoredChannelToken {
+  token: string;
+  updatedAt: string;
+}
+
+export interface ProfileConfig {
+  baseUrl: string;
+  output: OutputMode;
+  masterToken?: string;
+  readOnlyToken?: string;
+  channelTokens: Record<string, StoredChannelToken>;
+}
+
+export interface ConfigFile {
+  version: 1;
+  activeProfile: ProfileName;
+  profiles: Record<ProfileName, ProfileConfig>;
+}
+
+export interface JsonApiResource<TAttributes extends object> {
+  id: string;
+  type: string;
+  attributes: TAttributes;
+}
+
+export interface JsonApiError {
+  code?: string;
+  title?: string;
+  detail?: string;
+  source?: Record<string, unknown>;
+}
+
+export interface JsonApiDocument<TAttributes extends object> {
+  data: JsonApiResource<TAttributes> | JsonApiResource<TAttributes>[];
+  errors?: JsonApiError[];
+  links?: Record<string, string | null>;
+  meta?: Record<string, unknown>;
+}
+
+export interface ChannelAttributes {
+  name: string;
+  description?: string | null;
+  visibility: string;
+  posting_paused_until?: string | null;
+  inserted_at?: string;
+  updated_at?: string;
+}
+
+export interface PostAttributes {
+  body: string;
+  source: string;
+  inserted_at?: string;
+  updated_at?: string;
+}
+
+export interface WhoamiUserActor {
+  type: "user";
+  id: string;
+  email: string;
+  scope?: "master" | "read_only" | null;
+}
+
+export interface WhoamiChannelActor {
+  type: "channel";
+  id: string;
+  name: string;
+  visibility: string;
+}
+
+export type WhoamiActor = WhoamiUserActor | WhoamiChannelActor;
+
+export interface WhoamiResponse {
+  authenticated: true;
+  actor: WhoamiActor;
+}
+
+export interface RotateTokenResponse {
+  channel_id: string;
+  token: string;
+  issued_at: string;
+}

package/src/types/placeholder.d.ts

@@ -0,0 +1 @@
+export {};