@anakonn/ankk 0.1.1 → 0.1.3

package/README.md

@@ -30,6 +30,61 @@ ankk upgrade --dry-run
 The CLI uses the `latest` npm dist-tag. Release versions use three-part numeric
 SemVer such as `0.1.1`.
 
+## Initial Setup
+
+Create `~/.ankk/config.json` after installing the CLI:
+
+```bash
+ankk config setup
+```
+
+For CI or other non-interactive environments:
+
+```bash
+ANKK_API_KEY=spk_... ankk config setup --base-url https://api-public.ankk.app --api-key-env ANKK_API_KEY --yes
+```
+
+The setup command creates `~/.ankk/` when needed and writes the config file with
+owner-only permissions. It never prints the full API key.
+
+Runtime config precedence is:
+
+1. CLI flags: `--api-key`, `--base-url`, `--config`
+2. Environment variables: `ANKK_API_KEY`, `ANKK_BASE_URL`
+3. Config file: `~/.ankk/config.json`
+4. Built-in default base URL: `https://api-public.ankk.app`
+
+Inspect the resolved config without exposing the full key:
+
+```bash
+ankk config show
+```
+
+## SNS Content
+
+Use `content` for Ankk-managed work items: create, schedule, inspect publish
+state, cancel scheduled content, and delete mutable content.
+
+Use `posts` for provider posts that already exist on SNS providers. Scheduled
+content appears in `content`, not `posts`. Provider-origin posts may appear in
+`posts` even when Ankk did not create them. An Ankk content item appears in
+`posts` only after it has provider post identity such as `provider_post_id`.
+
+Publish immediately from a JSON request body:
+
+```bash
+ankk content publish --file payload.json
+```
+
+Schedule the same payload with an ISO timestamp:
+
+```bash
+ankk content publish --file payload.json --scheduled-for 2026-06-18T09:00:00Z
+```
+
+If `payload.json` also contains `scheduled_for`, it must match `--scheduled-for`.
+Relative inputs such as `10m` are not supported yet.
+
 ## Publish
 
 Public npm publish runs automatically when CLI-related changes reach the
@@ -87,6 +142,29 @@ Use live production pull only for dogfooding or deployed-contract comparison:
 (cd apps/cli && bun run src/entry/index.ts --json openapi pull --dry-run)
 ```
 
+## Content Payload Examples
+
+TikTok photo publishing uses `provider_settings.tiktok.postMode` because TikTok
+separates Direct Post from upload-to-inbox. Photo URLs must be publicly
+reachable and allowed by the app's TikTok verified URL prefix/domain.
+
+```json
+{
+	"brand_ref": "<brand_ref>",
+	"connection_id": "<tiktok_connection_id>",
+	"idempotency_key": "tiktok-photo-upload-to-inbox-2026-06-17",
+	"sns_type": "tiktok",
+	"text": "Photo caption",
+	"media": [{ "asset_ref": "https://cdn.example.com/photo.jpg" }],
+	"provider_settings": {
+		"content_type": "photo",
+		"tiktok": {
+			"postMode": "upload_to_inbox"
+		}
+	}
+}
+```
+
 ## Smoke
 
 Use environment variables or `~/.ankk/config.json` for credentials. Do not paste

package/dist/index.js

@@ -2157,7 +2157,7 @@ var {
 // package.json
 var package_default = {
   name: "@anakonn/ankk",
-  version: "0.1.1",
+  version: "0.1.3",
   description: "Bun-first CLI for the ankk public API.",
   private: false,
   license: "UNLICENSED",
@@ -2684,8 +2684,184 @@ var messageFromBody = (body) => {
   return typeof error === "string" && error.trim() ? error : undefined;
 };
 
+// src/commander-output.ts
+var configureCommanderOutput = (program2, io) => {
+  program2.configureOutput({
+    writeErr: (chunk) => {
+      io.stderr.write(chunk);
+    },
+    writeOut: (chunk) => {
+      io.stdout.write(chunk);
+    }
+  });
+};
+var isSuccessfulCommanderExit = (error) => typeof error === "object" && error !== null && ("exitCode" in error) && error.exitCode === 0;
+
+// src/brand-image-upload.ts
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+
+// src/output.ts
+var defaultIo = {
+  stderr: process.stderr,
+  stdout: process.stdout
+};
+var writeOutput = (io, mode, value, human) => {
+  if (mode === "json") {
+    io.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  io.stdout.write(`${human}
+`);
+};
+var writeError = (io, error, mode = "human") => {
+  if (mode === "json") {
+    io.stderr.write(`${JSON.stringify(errorJson(error), null, 2)}
+`);
+    return;
+  }
+  if (error instanceof CliHttpError) {
+    io.stderr.write(`${error.message}
+`);
+    return;
+  }
+  if (error instanceof Error) {
+    io.stderr.write(`${error.message}
+`);
+    return;
+  }
+  io.stderr.write(`Unexpected CLI error.
+`);
+};
+var errorJson = (error) => {
+  if (error instanceof CliHttpError) {
+    const body = error.body && typeof error.body === "object" && !Array.isArray(error.body) ? error.body : {};
+    return {
+      error: "http_error",
+      message: error.message,
+      ...body,
+      status: error.status
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      error: "cli_error",
+      message: error.message
+    };
+  }
+  return {
+    error: "unexpected_cli_error",
+    message: "Unexpected CLI error."
+  };
+};
+
+// src/brand-image-upload.ts
+var runBrandImageUploadCommand = async ({
+  alt,
+  brandRef,
+  client,
+  contentType,
+  description,
+  fetch,
+  file,
+  io,
+  outputMode,
+  type
+}) => {
+  const upload = await readBrandImageUploadFile(file, contentType);
+  const prepared = responseOrThrow(await client.POST("/v1/brand-images/uploads", {
+    body: {
+      brand_ref: brandRef,
+      content_type: upload.contentType,
+      filename: upload.filename,
+      size: upload.size
+    }
+  }));
+  const uploaded = await fetch(prepared.upload_url, {
+    body: upload.data,
+    headers: {
+      "content-type": prepared.content_type
+    },
+    method: prepared.method
+  });
+  if (!uploaded.ok) {
+    throw new Error(`Brand image upload failed with HTTP ${uploaded.status}.`);
+  }
+  const image = responseOrThrow(await client.POST("/v1/brand-images", {
+    body: {
+      brand_ref: brandRef,
+      origin_url: prepared.origin_url,
+      ...type ? { type } : {},
+      ...alt !== undefined ? { alt } : {},
+      ...description !== undefined ? { description } : {}
+    }
+  }));
+  writeOutput(io, outputMode, {
+    ...image,
+    uploaded: true
+  }, `image_ref: ${image.image_ref}
+url: ${image.url}`);
+};
+var brandImageUploadPolicies = {
+  ".gif": { contentType: "image/gif", maxSize: 20 * 1024 * 1024 },
+  ".jpeg": { contentType: "image/jpeg", maxSize: 20 * 1024 * 1024 },
+  ".jpg": { contentType: "image/jpeg", maxSize: 20 * 1024 * 1024 },
+  ".png": { contentType: "image/png", maxSize: 20 * 1024 * 1024 },
+  ".webp": { contentType: "image/webp", maxSize: 20 * 1024 * 1024 }
+};
+var readBrandImageUploadFile = async (file, contentTypeOverride) => {
+  const filename = basename(file);
+  const extension = brandImageExtension(filename);
+  const extensionPolicy = brandImageUploadPolicies[extension];
+  const contentType = contentTypeOverride?.trim().toLowerCase() || extensionPolicy.contentType;
+  const contentTypePolicy = brandImageUploadPolicyForContentType(contentType);
+  if (!contentTypePolicy) {
+    throw new Error(`Unsupported brand image content type: ${contentType}`);
+  }
+  if (!contentTypePolicy.extensions.includes(extension)) {
+    throw new Error(`Brand image file extension does not match content type: ${filename} (${contentType})`);
+  }
+  const info = await stat(file);
+  if (!info.isFile()) {
+    throw new Error(`Brand image path is not a file: ${file}`);
+  }
+  if (info.size <= 0) {
+    throw new Error("Brand image file is empty.");
+  }
+  if (info.size > contentTypePolicy.maxSize) {
+    throw new Error(`Brand image file exceeds ${contentTypePolicy.maxSize} bytes.`);
+  }
+  return {
+    contentType,
+    data: await readFile(file),
+    filename,
+    size: info.size
+  };
+};
+var brandImageExtension = (filename) => {
+  const index = filename.lastIndexOf(".");
+  const extension = index > 0 ? filename.slice(index).toLowerCase() : "";
+  if (extension in brandImageUploadPolicies)
+    return extension;
+  throw new Error(`Unsupported brand image file extension: ${filename}`);
+};
+var brandImageUploadPolicyForContentType = (contentType) => {
+  const extensions = Object.entries(brandImageUploadPolicies).filter(([, policy]) => policy.contentType === contentType).map(([extension]) => extension);
+  if (extensions.length === 0)
+    return null;
+  return {
+    extensions,
+    maxSize: brandImageUploadPolicies[extensions[0] ?? ".jpg"].maxSize
+  };
+};
+
+// src/config-command.ts
+import { createInterface } from "readline/promises";
+import { Writable } from "stream";
+
 // src/config.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import { dirname, join } from "path";
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -16982,7 +17158,7 @@ var defaultConfigPath = ({
 };
 var loadConfig = async (path) => {
   try {
-    const raw = await readFile(path, "utf8");
+    const raw = await readFile2(path, "utf8");
     return configSchema.parse(JSON.parse(raw));
   } catch (error51) {
     if (isMissingFileError(error51))
@@ -16990,6 +17166,23 @@ var loadConfig = async (path) => {
     throw error51;
   }
 };
+var configFileExists = async (path) => {
+  try {
+    await readFile2(path, "utf8");
+    return true;
+  } catch (error51) {
+    if (isMissingFileError(error51))
+      return false;
+    throw error51;
+  }
+};
+var writeConfig = async (path, config2) => {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(config2, null, 2)}
+`, {
+    mode: 384
+  });
+};
 var resolveRuntimeConfig = async ({
   apiKey,
   baseUrl,
@@ -17015,10 +17208,264 @@ var redactApiKey = (apiKey) => {
 var normalizeBaseUrl = (value) => value.replace(/\/+$/, "");
 var isMissingFileError = (error51) => typeof error51 === "object" && error51 !== null && ("code" in error51) && error51.code === "ENOENT";
 
+// src/config-command.ts
+var registerConfigCommands = ({
+  env,
+  fetch,
+  io,
+  program: program2,
+  prompt = createDefaultPrompt(io)
+}) => {
+  const config2 = program2.command("config").description("Manage CLI config");
+  config2.command("show").description("Show resolved CLI config").action(async () => {
+    const options = program2.opts();
+    const runtimeConfig = await resolveRuntimeConfig({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      configPath: options.config ?? defaultConfigPath({ env }),
+      env
+    });
+    const value = {
+      api_key: redactApiKey(runtimeConfig.apiKey),
+      base_url: runtimeConfig.baseUrl,
+      config_path: runtimeConfig.configPath
+    };
+    writeOutput(io, outputMode(options), value, `base_url: ${value.base_url}
+api_key: ${value.api_key ?? "(not set)"}
+config_path: ${value.config_path}`);
+  });
+  config2.command("setup").description("Create or update the CLI config file").option("--api-key <key>", "Public API key to store").option("--api-key-env <name>", "Read the public API key from an environment variable").option("--base-url <url>", "API base URL to store").option("--skip-health", "Do not run the health check after writing config").option("--yes", "Overwrite existing config and use defaults without prompting").action(async (options) => {
+    const globalOptions = program2.opts();
+    const configPath = globalOptions.config ?? defaultConfigPath({ env });
+    const existingConfig = await loadConfig(configPath);
+    const exists = await configFileExists(configPath);
+    const overwrite = exists ? Boolean(options.yes) || await prompt.confirm({
+      defaultValue: false,
+      message: `Overwrite existing config at ${configPath}?`
+    }) : true;
+    if (!overwrite) {
+      const value2 = {
+        config_path: configPath,
+        wrote: false
+      };
+      writeOutput(io, outputMode(globalOptions), value2, `Config unchanged: ${configPath}`);
+      return;
+    }
+    const baseUrl = await setupBaseUrl({
+      defaultValue: globalOptions.baseUrl ?? env.ANKK_BASE_URL ?? existingConfig.base_url ?? defaultBaseUrl,
+      optionValue: options.baseUrl,
+      prompt,
+      yes: Boolean(options.yes)
+    });
+    const apiKey = await setupApiKey({
+      env,
+      existingValue: existingConfig.api_key,
+      globalValue: globalOptions.apiKey,
+      optionEnvName: options.apiKeyEnv,
+      optionValue: options.apiKey,
+      prompt,
+      yes: Boolean(options.yes)
+    });
+    await writeConfig(configPath, {
+      api_key: apiKey,
+      base_url: baseUrl
+    });
+    const health = options.skipHealth ? null : await fetchHealth({ baseUrl, fetch });
+    const value = {
+      api_key: redactApiKey(apiKey),
+      base_url: baseUrl,
+      config_path: configPath,
+      health,
+      next_commands: ["ankk brands list", "ankk config show"],
+      wrote: true
+    };
+    writeOutput(io, outputMode(globalOptions), value, [
+      `Config saved: ${configPath}`,
+      `base_url: ${baseUrl}`,
+      `api_key: ${redactApiKey(apiKey)}`,
+      ...health ? [`health: ${health.service} ${health.status}`] : [],
+      "next: ankk brands list"
+    ].join(`
+`));
+  });
+};
+var setupBaseUrl = async ({
+  defaultValue,
+  optionValue,
+  prompt,
+  yes
+}) => {
+  const value = optionValue ?? (yes ? defaultValue : await prompt.text({ defaultValue, message: "API base URL" }));
+  return normalizeBaseUrl2(value || defaultValue);
+};
+var setupApiKey = async ({
+  env,
+  existingValue,
+  globalValue,
+  optionEnvName,
+  optionValue,
+  prompt,
+  yes
+}) => {
+  const envValue = optionEnvName ? env[optionEnvName] : undefined;
+  if (optionEnvName && !envValue) {
+    throw new Error(`API key environment variable ${optionEnvName} is not set.`);
+  }
+  const value = optionValue ?? globalValue ?? envValue ?? env.ANKK_API_KEY ?? (yes ? existingValue : await prompt.secret({ message: "API key" }));
+  if (!value) {
+    throw new Error("API key is required. Pass --api-key-env ANKK_API_KEY, --api-key, or set ANKK_API_KEY.");
+  }
+  return value;
+};
+var fetchHealth = async ({ baseUrl, fetch }) => {
+  const response = await fetch(`${baseUrl}/v1/health`);
+  if (!response.ok)
+    throw new Error(`Config saved, but health check failed with HTTP ${response.status}.`);
+  const body = await response.json();
+  if (!isHealthResponse(body))
+    throw new Error("Config saved, but health check response was invalid.");
+  return body;
+};
+var createDefaultPrompt = (io) => {
+  const prompt = {
+    async confirm({ defaultValue = false, message }) {
+      const suffix = defaultValue ? " [Y/n]" : " [y/N]";
+      const answer = await prompt.text({ message: `${message}${suffix}` });
+      const normalized = answer.trim().toLowerCase();
+      if (!normalized)
+        return defaultValue;
+      return normalized === "y" || normalized === "yes";
+    },
+    async secret({ message }) {
+      io.stderr.write(`${message}: `);
+      const reader = createInterface({
+        input: process.stdin,
+        output: new MuteWritable,
+        terminal: true
+      });
+      try {
+        return (await reader.question("")).trim();
+      } finally {
+        reader.close();
+        io.stderr.write(`
+`);
+      }
+    },
+    async text({ defaultValue, message }) {
+      const suffix = defaultValue ? ` [${defaultValue}]` : "";
+      const reader = createInterface({
+        input: process.stdin,
+        output: process.stderr
+      });
+      try {
+        const value = (await reader.question(`${message}${suffix}: `)).trim();
+        return value || defaultValue || "";
+      } finally {
+        reader.close();
+      }
+    }
+  };
+  return prompt;
+};
+
+class MuteWritable extends Writable {
+  _write(_chunk, _encoding, callback) {
+    callback();
+  }
+}
+var normalizeBaseUrl2 = (value) => {
+  const normalized = value.replace(/\/+$/, "");
+  new URL(normalized);
+  return normalized;
+};
+var outputMode = (options) => options.json ? "json" : "human";
+var isHealthResponse = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const record2 = value;
+  return typeof record2.service === "string" && typeof record2.status === "string";
+};
+
+// src/content-publish.ts
+var applyScheduledForOption = (body, scheduledFor) => {
+  if (!scheduledFor)
+    return body;
+  const normalized = normalizeIsoTimestamp(scheduledFor, "--scheduled-for");
+  const existing = body.scheduled_for;
+  if (existing === undefined || existing === null) {
+    return { ...body, scheduled_for: normalized };
+  }
+  if (typeof existing !== "string") {
+    throw new Error("scheduled_for in SNS content publish body must be an ISO timestamp string or null.");
+  }
+  if (normalizeIsoTimestamp(existing, "scheduled_for") !== normalized) {
+    throw new Error("scheduled_for in SNS content publish body conflicts with --scheduled-for.");
+  }
+  return { ...body, scheduled_for: normalized };
+};
+var formatContentPublishResult = (response, body) => {
+  const lines = [`content_id: ${response.content_id}`, `publish_job_id: ${response.publish_job_id}`, `status: ${response.status}`];
+  if (response.scheduled_for) {
+    lines.push(`scheduled_for: ${response.scheduled_for}`);
+    const brandRef = typeof body.brand_ref === "string" ? body.brand_ref : "<brand_ref>";
+    lines.push(`next: ankk content cancel ${response.content_id} --brand-ref ${brandRef}`);
+  }
+  return lines.join(`
+`);
+};
+var normalizeIsoTimestamp = (value, name) => {
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value)) {
+    throw new Error(`${name} must be an ISO timestamp, for example 2026-06-18T09:00:00Z.`);
+  }
+  const timestamp = new Date(value);
+  if (Number.isNaN(timestamp.getTime())) {
+    throw new Error(`${name} must be an ISO timestamp, for example 2026-06-18T09:00:00Z.`);
+  }
+  return timestamp.toISOString();
+};
+
+// src/content-output.ts
+var formatSnsContent = (response) => {
+  const lines = [
+    `content_id: ${response.content_id}`,
+    `status: ${response.status}`,
+    `sns_type: ${response.sns_type}`,
+    `connection_id: ${response.connection_id}`
+  ];
+  if (response.title)
+    lines.push(`title: ${response.title}`);
+  if (response.provider_post_id)
+    lines.push(`provider_post_id: ${response.provider_post_id}`);
+  if (response.provider_post_status)
+    lines.push(`provider_post_status: ${response.provider_post_status}`);
+  if (response.permalink)
+    lines.push(`permalink: ${response.permalink}`);
+  if (response.latest_publish_job) {
+    lines.push(`latest_publish_job: ${response.latest_publish_job.status} (${response.latest_publish_job.publish_job_id})`);
+    if (response.latest_publish_job.scheduled_for)
+      lines.push(`scheduled_for: ${response.latest_publish_job.scheduled_for}`);
+    if (response.latest_publish_job.last_error_code)
+      lines.push(`last_error_code: ${response.latest_publish_job.last_error_code}`);
+    if (response.latest_publish_job.last_error_message)
+      lines.push(`last_error_message: ${response.latest_publish_job.last_error_message}`);
+  }
+  if (response.latest_delete_job) {
+    lines.push(`latest_delete_job: ${response.latest_delete_job.status} (${response.latest_delete_job.delete_job_id})`);
+    if (response.latest_delete_job.scheduled_for)
+      lines.push(`delete_scheduled_for: ${response.latest_delete_job.scheduled_for}`);
+    if (response.latest_delete_job.last_error_code)
+      lines.push(`delete_last_error_code: ${response.latest_delete_job.last_error_code}`);
+    if (response.latest_delete_job.last_error_message)
+      lines.push(`delete_last_error_message: ${response.latest_delete_job.last_error_message}`);
+  }
+  return lines.join(`
+`);
+};
+
 // src/json-input.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 var readJsonInput = async (path, { readStdin = readProcessStdin } = {}) => {
-  const raw = path === "-" ? await readStdin() : await readFile2(path, "utf8");
+  const raw = path === "-" ? await readStdin() : await readFile3(path, "utf8");
   try {
     return JSON.parse(raw);
   } catch (error51) {
@@ -17030,6 +17477,98 @@ var readJsonInput = async (path, { readStdin = readProcessStdin } = {}) => {
 };
 var readProcessStdin = async () => Bun.stdin.text();
 
+// src/media-upload.ts
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { basename as basename2 } from "path";
+var runMediaUploadCommand = async ({
+  brandRef,
+  client,
+  contentType,
+  fetch,
+  file: file2,
+  io,
+  outputMode: outputMode2
+}) => {
+  const upload = await readMediaUploadFile(file2, contentType);
+  const prepared = responseOrThrow(await client.POST("/v1/media/uploads", {
+    body: {
+      brand_ref: brandRef,
+      content_type: upload.contentType,
+      filename: upload.filename,
+      size: upload.size
+    }
+  }));
+  const uploaded = await fetch(prepared.upload_url, {
+    body: upload.data,
+    headers: {
+      "content-type": prepared.content_type
+    },
+    method: prepared.method
+  });
+  if (!uploaded.ok) {
+    throw new Error(`Media upload failed with HTTP ${uploaded.status}.`);
+  }
+  writeOutput(io, outputMode2, {
+    ...prepared,
+    uploaded: true
+  }, `asset_ref: ${prepared.asset_ref}`);
+};
+var mediaUploadPolicies = {
+  ".gif": { contentType: "image/gif", maxSize: 20 * 1024 * 1024 },
+  ".jpeg": { contentType: "image/jpeg", maxSize: 20 * 1024 * 1024 },
+  ".jpg": { contentType: "image/jpeg", maxSize: 20 * 1024 * 1024 },
+  ".mov": { contentType: "video/quicktime", maxSize: 500 * 1024 * 1024 },
+  ".mp4": { contentType: "video/mp4", maxSize: 500 * 1024 * 1024 },
+  ".png": { contentType: "image/png", maxSize: 20 * 1024 * 1024 },
+  ".webm": { contentType: "video/webm", maxSize: 500 * 1024 * 1024 },
+  ".webp": { contentType: "image/webp", maxSize: 20 * 1024 * 1024 }
+};
+var readMediaUploadFile = async (file2, contentTypeOverride) => {
+  const filename = basename2(file2);
+  const extension = mediaExtension(filename);
+  const extensionPolicy = mediaUploadPolicies[extension];
+  const contentType = contentTypeOverride?.trim().toLowerCase() || extensionPolicy.contentType;
+  const contentTypePolicy = mediaUploadPolicyForContentType(contentType);
+  if (!contentTypePolicy) {
+    throw new Error(`Unsupported media content type: ${contentType}`);
+  }
+  if (!contentTypePolicy.extensions.includes(extension)) {
+    throw new Error(`Media file extension does not match content type: ${filename} (${contentType})`);
+  }
+  const info = await stat2(file2);
+  if (!info.isFile()) {
+    throw new Error(`Media path is not a file: ${file2}`);
+  }
+  if (info.size <= 0) {
+    throw new Error("Media file is empty.");
+  }
+  if (info.size > contentTypePolicy.maxSize) {
+    throw new Error(`Media file exceeds ${contentTypePolicy.maxSize} bytes.`);
+  }
+  return {
+    contentType,
+    data: await readFile4(file2),
+    filename,
+    size: info.size
+  };
+};
+var mediaExtension = (filename) => {
+  const index = filename.lastIndexOf(".");
+  const extension = index > 0 ? filename.slice(index).toLowerCase() : "";
+  if (extension in mediaUploadPolicies)
+    return extension;
+  throw new Error(`Unsupported media file extension: ${filename}`);
+};
+var mediaUploadPolicyForContentType = (contentType) => {
+  const extensions = Object.entries(mediaUploadPolicies).filter(([, policy]) => policy.contentType === contentType).map(([extension]) => extension);
+  if (extensions.length === 0)
+    return null;
+  return {
+    extensions,
+    maxSize: mediaUploadPolicies[extensions[0] ?? ".jpg"].maxSize
+  };
+};
+
 // src/openapi.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
@@ -17052,49 +17591,24 @@ var writeOpenApiSnapshot = async (path, spec) => {
 `);
 };
 
-// src/output.ts
-var defaultIo = {
-  stderr: process.stderr,
-  stdout: process.stdout
-};
-var writeOutput = (io, mode, value, human) => {
-  if (mode === "json") {
-    io.stdout.write(`${JSON.stringify(value, null, 2)}
-`);
-    return;
-  }
-  io.stdout.write(`${human}
-`);
-};
-var writeError = (io, error51) => {
-  if (error51 instanceof CliHttpError) {
-    io.stderr.write(`${error51.message}
-`);
-    return;
-  }
-  if (error51 instanceof Error) {
-    io.stderr.write(`${error51.message}
-`);
-    return;
-  }
-  io.stderr.write(`Unexpected CLI error.
-`);
-};
-
 // src/program.ts
 var runCli = async ({
   argv,
   commandRunner = runProcess,
   env = process.env,
   fetch = globalThis.fetch,
-  io = defaultIo
+  io = defaultIo,
+  prompt
 }) => {
-  const program2 = createProgram({ commandRunner, env, fetch, io });
+  const program2 = createProgram({ commandRunner, env, fetch, io, prompt });
   try {
     await program2.parseAsync(argv, { from: "user" });
     return 0;
   } catch (error51) {
-    writeError(io, error51);
+    if (isSuccessfulCommanderExit(error51)) {
+      return 0;
+    }
+    writeError(io, error51, program2.opts().json ? "json" : "human");
     return 1;
   }
 };
@@ -17102,25 +17616,27 @@ var createProgram = ({
   commandRunner = runProcess,
   env = process.env,
   fetch = globalThis.fetch,
-  io = defaultIo
+  io = defaultIo,
+  prompt
 } = {}) => {
   const program2 = new Command;
-  program2.name("ankk").description("CLI for the ankk public API").option("--base-url <url>", "API base URL").option("--api-key <key>", "Public API key").option("--config <path>", "Config file path").option("--json", "Print JSON output").exitOverride();
+  configureCommanderOutput(program2, io);
+  program2.name("ankk").description("CLI for the ankk public API").version(packageVersion, "-V, --version", "Print version").option("--base-url <url>", "API base URL").option("--api-key <key>", "Public API key").option("--config <path>", "Config file path").option("--json", "Print JSON output").exitOverride();
   program2.command("health").description("Check api-public health").action(async () => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
-    const result = await fetchHealth({
+    const result = await fetchHealth2({
       baseUrl: context.config.baseUrl,
       fetch
     });
     writeOutput(context.io, context.outputMode, result, `${result.service}: ${result.status}`);
   });
   program2.command("upgrade").description("Upgrade the ankk CLI global installation").option("--dry-run", "Print the upgrade command without running it").action(async (options) => {
-    const outputMode = program2.opts().json ? "json" : "human";
+    const outputMode2 = program2.opts().json ? "json" : "human";
     const result = await upgradeCli({
       commandRunner,
       dryRun: Boolean(options.dryRun)
     });
-    writeOutput(io, outputMode, result, options.dryRun ? `Would run: ${result.command.join(" ")}` : `Upgraded ${result.package} via ${result.tag}`);
+    writeOutput(io, outputMode2, result, options.dryRun ? `Would run: ${result.command.join(" ")}` : `Upgraded ${result.package} via ${result.tag}`);
   });
   const brands = program2.command("brands").description("Manage brands available to the API key");
   brands.command("list").description("List brands available to the API key").action(async () => {
@@ -17178,8 +17694,8 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  const content = program2.command("content").description("Read SNS contents");
-  withBrandRef(content.command("list").description("List SNS contents")).option("--connection-id <connection_id>", "Connection id filter").option("--status <status>", "Content status filter").action(async (options) => {
+  const content = program2.command("content").description("Create, schedule, and manage Ankk SNS content work items");
+  withBrandRef(content.command("list").description("List Ankk SNS content work items")).option("--connection-id <connection_id>", "Connection id filter").option("--status <status>", "Content status filter").action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.GET("/v1/content", {
       params: queryParams({
@@ -17190,7 +17706,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  withBrandRef(content.command("get").description("Get SNS content").argument("<content_id>", "Content id")).option("--connection-id <connection_id>", "Connection id filter").option("--status <status>", "Content status filter").action(async (contentId, options) => {
+  withBrandRef(content.command("get").description("Get an Ankk SNS content work item").argument("<content_id>", "Content id")).option("--connection-id <connection_id>", "Connection id filter").option("--status <status>", "Content status filter").action(async (contentId, options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.GET("/v1/content/{content_id}", {
       params: {
@@ -17204,16 +17720,91 @@ var createProgram = ({
         })
       }
     }));
-    writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
+    writeOutput(context.io, context.outputMode, result, formatSnsContent(result));
   });
-  content.command("publish").description("Publish or schedule SNS content").requiredOption("--file <path>", "JSON request body file, or - for stdin").action(async (options) => {
+  content.command("publish").description("Publish or schedule SNS content").requiredOption("--file <path>", "JSON request body file, or - for stdin").option("--scheduled-for <timestamp>", "Schedule publish at an ISO timestamp, for example 2026-06-18T09:00:00Z").action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
-    const body = readObjectBody(await readJsonInput(options.file), "SNS content publish body");
+    const body = applyScheduledForOption(readObjectBody(await readJsonInput(options.file), "SNS content publish body"), options.scheduledFor);
     const result = responseOrThrow(await context.client.POST("/v1/content", {
       body: apiBody(body)
     }));
+    writeOutput(context.io, context.outputMode, result, formatContentPublishResult(result, body));
+  });
+  const media = program2.command("media").description("Upload media for SNS publishing");
+  withBrandRef(media.command("upload").description("Upload an image or video file").argument("<file>", "Media file path")).option("--content-type <content_type>", "Override detected MIME type").action(async (file2, options) => {
+    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
+    await runMediaUploadCommand({
+      brandRef: options.brandRef,
+      client: context.client,
+      contentType: options.contentType,
+      fetch,
+      file: file2,
+      io: context.io,
+      outputMode: context.outputMode
+    });
+  });
+  const brandImages = program2.command("brand-images").description("Manage brand images shown in the web brand image screen");
+  withBrandRef(brandImages.command("list").description("List brand images")).option("--type <type>", "Image type filter: logo, banner, product, gallery, other").action(async (options) => {
+    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
+    const type = options.type ? parseBrandImageType(options.type) : undefined;
+    const result = responseOrThrow(await context.client.GET("/v1/brand-images", {
+      params: {
+        query: {
+          brand_ref: options.brandRef,
+          ...type ? { type } : {}
+        }
+      }
+    }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
+  withBrandRef(brandImages.command("upload").description("Upload and register a brand image").argument("<file>", "Image file path")).option("--type <type>", "Image type: logo, banner, product, gallery, other").option("--alt <text>", "Alternative text").option("--description <text>", "Image description").option("--content-type <content_type>", "Override detected MIME type").action(async (file2, options) => {
+    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
+    await runBrandImageUploadCommand({
+      alt: options.alt,
+      brandRef: options.brandRef,
+      client: context.client,
+      contentType: options.contentType,
+      description: options.description,
+      fetch,
+      file: file2,
+      io: context.io,
+      outputMode: context.outputMode,
+      type: options.type ? parseBrandImageType(options.type) : undefined
+    });
+  });
+  withBrandRef(brandImages.command("update").description("Update brand image metadata").argument("<image_ref>", "Brand image reference")).option("--type <type>", "Image type: logo, banner, product, gallery, other").option("--alt <text>", "Alternative text").option("--description <text>", "Image description").action(async (imageRef, options) => {
+    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
+    const result = responseOrThrow(await context.client.PATCH("/v1/brand-images/{image_ref}", {
+      body: apiBody({
+        ...options.type ? { type: parseBrandImageType(options.type) } : {},
+        ...options.alt !== undefined ? { alt: options.alt } : {},
+        ...options.description !== undefined ? { description: options.description } : {}
+      }),
+      params: {
+        path: {
+          image_ref: imageRef
+        },
+        query: {
+          brand_ref: options.brandRef
+        }
+      }
+    }));
+    writeOutput(context.io, context.outputMode, result, `Brand image updated: ${result.image_ref}`);
+  });
+  withBrandRef(brandImages.command("delete").description("Delete brand image metadata").argument("<image_ref>", "Brand image reference")).action(async (imageRef, options) => {
+    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
+    const result = responseOrThrow(await context.client.DELETE("/v1/brand-images/{image_ref}", {
+      params: {
+        path: {
+          image_ref: imageRef
+        },
+        query: {
+          brand_ref: options.brandRef
+        }
+      }
+    }));
+    writeOutput(context.io, context.outputMode, result, `Brand image deleted: ${result.image_ref}`);
+  });
   withBrandRef(content.command("cancel").description("Cancel scheduled SNS content").argument("<content_id>", "Content id")).option("--file <path>", "JSON request body file, or - for stdin").action(async (contentId, options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const body = await readBodyOrBrandRef(options, "SNS content cancel body");
@@ -17241,7 +17832,7 @@ var createProgram = ({
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
   const references = program2.command("references").description("Create SNS references");
-  references.command("create").description("Create or get a public SNS reference").requiredOption("--file <path>", "JSON request body file, or - for stdin").action(async (options) => {
+  references.command("create").description("Create or get a public post reference where direct provider lookup is supported").requiredOption("--file <path>", "JSON request body file, or - for stdin").action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const body = readObjectBody(await readJsonInput(options.file), "SNS reference body");
     const result = responseOrThrow(await context.client.POST("/v1/references", {
@@ -17249,8 +17840,8 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  const posts = program2.command("posts").description("Read posts");
-  withBrandRef(posts.command("list").description("List posts")).action(async (options) => {
+  const posts = program2.command("posts").description("Read or delete provider posts that exist on SNS providers");
+  withBrandRef(posts.command("list").description("List provider posts")).action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.GET("/v1/posts", {
       params: queryParams({
@@ -17259,7 +17850,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  withBrandRef(posts.command("get").description("Get post").argument("<post_id>", "Post id")).action(async (postId, options) => {
+  withBrandRef(posts.command("get").description("Get a provider post").argument("<post_id>", "Post id returned by posts list")).action(async (postId, options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.GET("/v1/posts/{post_id}", {
       params: {
@@ -17273,7 +17864,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  withBrandRef(posts.command("delete").description("Delete post").argument("<post_id>", "Post id")).action(async (postId, options) => {
+  withBrandRef(posts.command("delete").description("Delete a provider post").argument("<post_id>", "Post id returned by posts list")).action(async (postId, options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.DELETE("/v1/posts/{post_id}", {
       params: {
@@ -17287,7 +17878,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  const comments = program2.command("comments").description("Read comments");
+  const comments = program2.command("comments").description("Read and create comments");
   withBrandRef(comments.command("list").description("List comments")).action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.GET("/v1/comments", {
@@ -17311,6 +17902,14 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
+  comments.command("create").description("Create a top-level comment on a provider post").requiredOption("--file <path>", "JSON request body file, or - for stdin").action(async (options) => {
+    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
+    const body = readObjectBody(await readJsonInput(options.file), "Comment create body");
+    const result = responseOrThrow(await context.client.POST("/v1/comments", {
+      body: apiBody(body)
+    }));
+    writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
+  });
   comments.command("moderate").description("Create comment moderation action").argument("<comment_id>", "Comment id").requiredOption("--file <path>", "JSON request body file, or - for stdin").action(async (commentId, options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const body = readObjectBody(await readJsonInput(options.file), "Comment moderation body");
@@ -17371,7 +17970,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  withBrandRef(analytics.command("overview").description("Get social analytics overview")).option("--from <date>", "Start date").option("--to <date>", "End date").action(async (options) => {
+  withBrandRef(analytics.command("overview").description("Get compact brand-level analytics counters using the same default 30-day range as analytics get")).option("--from <date>", "Start date").option("--to <date>", "End date").action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const result = responseOrThrow(await context.client.GET("/v1/analytics/overview", {
       params: queryParams({
@@ -17414,7 +18013,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  webhooks.command("update").description("Update webhook subscription").argument("<webhook_id>", "Webhook id").requiredOption("--file <path>", "JSON request body file, or - for stdin").action(async (webhookId, options) => {
+  withBrandRef(webhooks.command("update").description("Update webhook subscription").argument("<webhook_id>", "Webhook id").requiredOption("--file <path>", "JSON request body file, or - for stdin")).action(async (webhookId, options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
     const body = readObjectBody(await readJsonInput(options.file), "Webhook update body");
     const result = responseOrThrow(await context.client.PATCH("/v1/webhooks/{webhook_id}", {
@@ -17422,7 +18021,10 @@ var createProgram = ({
       params: {
         path: {
           webhook_id: webhookId
-        }
+        },
+        ...queryParams({
+          brand_ref: options.brandRef
+        })
       }
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
@@ -17441,18 +18043,7 @@ var createProgram = ({
     }));
     writeOutput(context.io, context.outputMode, result, formatGenericRead(result));
   });
-  const config2 = program2.command("config").description("Manage CLI config");
-  config2.command("show").description("Show resolved CLI config").action(async () => {
-    const context = await resolveCommandContext({ env, fetch, io, program: program2 });
-    const value = {
-      api_key: redactApiKey(context.config.apiKey),
-      base_url: context.config.baseUrl,
-      config_path: context.config.configPath
-    };
-    writeOutput(context.io, context.outputMode, value, `base_url: ${value.base_url}
-api_key: ${value.api_key ?? "(not set)"}
-config_path: ${value.config_path}`);
-  });
+  registerConfigCommands({ env, fetch, io, program: program2, prompt });
   const openapi = program2.command("openapi").description("Manage api-public OpenAPI schema");
   openapi.command("pull").description("Pull the api-public OpenAPI schema").option("--dry-run", "Fetch and report without writing").option("--output <path>", "Snapshot output path").action(async (options) => {
     const context = await resolveCommandContext({ env, fetch, io, program: program2 });
@@ -17485,7 +18076,7 @@ var resolveCommandContext = async ({
     configPath,
     env
   });
-  const outputMode = options.json ? "json" : "human";
+  const outputMode2 = options.json ? "json" : "human";
   return {
     client: createApiPublicClient({
       apiKey: config2.apiKey,
@@ -17494,7 +18085,7 @@ var resolveCommandContext = async ({
     }),
     config: config2,
     io,
-    outputMode
+    outputMode: outputMode2
   };
 };
 var safeDefaultConfigPath = (env) => defaultConfigPath({ env });
@@ -17573,6 +18164,12 @@ var readObjectBody = (value, name) => {
   return value;
 };
 var apiBody = (body) => body;
+var brandImageTypes = ["logo", "banner", "product", "gallery", "other"];
+var parseBrandImageType = (value) => {
+  if (brandImageTypes.includes(value))
+    return value;
+  throw new Error(`Unsupported brand image type: ${value}`);
+};
 var readBodyOrBrandRef = async (options, name) => {
   if (options.file) {
     return readObjectBody(await readJsonInput(options.file), name);
@@ -17581,17 +18178,17 @@ var readBodyOrBrandRef = async (options, name) => {
     brand_ref: options.brandRef
   };
 };
-var fetchHealth = async ({ baseUrl, fetch }) => {
+var fetchHealth2 = async ({ baseUrl, fetch }) => {
   const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/v1/health`);
   if (!response.ok)
     throw new Error(`Health check failed with HTTP ${response.status}.`);
   const body = await response.json();
-  if (!isHealthResponse(body)) {
+  if (!isHealthResponse2(body)) {
     throw new Error("Health check response was invalid.");
   }
   return body;
 };
-var isHealthResponse = (value) => {
+var isHealthResponse2 = (value) => {
   if (!value || typeof value !== "object")
     return false;
   const record2 = value;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@anakonn/ankk",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"description": "Bun-first CLI for the ankk public API.",
 	"private": false,
 	"license": "UNLICENSED",