@inblog/cli 0.2.0

package/dist/bin/inblog.js

@@ -0,0 +1,2416 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// bin/inblog.ts
+var import_commander = require("commander");
+
+// src/commands/auth.ts
+var import_prompts = require("@inquirer/prompts");
+var import_open = __toESM(require("open"));
+
+// src/utils/config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var CONFIG_DIR = path.join(os.homedir(), ".config", "inblog");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var LOCAL_CONFIG_FILE = ".inblogrc.json";
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function getGlobalConfigPath() {
+  return CONFIG_FILE;
+}
+function getLocalConfigPath() {
+  const localPath = path.resolve(LOCAL_CONFIG_FILE);
+  return fs.existsSync(localPath) ? localPath : null;
+}
+function readGlobalConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function readLocalConfig() {
+  const localPath = path.resolve(LOCAL_CONFIG_FILE);
+  if (!fs.existsSync(localPath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(localPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function readConfig() {
+  const global = readGlobalConfig();
+  const local = readLocalConfig();
+  return { ...global, ...local };
+}
+function writeGlobalConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function setGlobalConfigValue(key, value) {
+  const config = readGlobalConfig();
+  config[key] = value;
+  writeGlobalConfig(config);
+}
+
+// src/utils/output.ts
+var import_chalk = __toESM(require("chalk"));
+var import_cli_table3 = __toESM(require("cli-table3"));
+function printJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printTable(headers, rows) {
+  const table = new import_cli_table3.default({
+    head: headers.map((h) => import_chalk.default.cyan(h)),
+    style: { head: [], border: [] }
+  });
+  for (const row of rows) {
+    table.push(row.map((cell) => cell == null ? import_chalk.default.dim("\u2014") : String(cell)));
+  }
+  console.log(table.toString());
+}
+function printDetail(entries) {
+  const maxKeyLen = Math.max(...entries.map(([k]) => k.length));
+  for (const [key, value] of entries) {
+    const label = import_chalk.default.cyan(key.padEnd(maxKeyLen));
+    const val = value == null ? import_chalk.default.dim("\u2014") : String(value);
+    console.log(`  ${label}  ${val}`);
+  }
+}
+function printSuccess(message) {
+  console.log(import_chalk.default.green(message));
+}
+function printWarning(message) {
+  console.error(import_chalk.default.yellow(message));
+}
+function printError(message) {
+  console.error(import_chalk.default.red(message));
+}
+function truncate(str, maxLen = 50) {
+  if (!str) return "";
+  return str.length > maxLen ? str.slice(0, maxLen - 1) + "\u2026" : str;
+}
+
+// src/sdk/deserialize.ts
+function resolveRelationship(rel, included) {
+  if (!rel.data) return null;
+  if (Array.isArray(rel.data)) {
+    return rel.data.map((ref2) => {
+      const found2 = included.find((r) => r.type === ref2.type && r.id === ref2.id);
+      return found2 ? flattenResource(found2, included) : { id: ref2.id, type: ref2.type };
+    });
+  }
+  const ref = rel.data;
+  const found = included.find((r) => r.type === ref.type && r.id === ref.id);
+  return found ? flattenResource(found, included) : { id: ref.id, type: ref.type };
+}
+function flattenResource(resource, included = []) {
+  const result = {
+    id: resource.id,
+    ...resource.attributes
+  };
+  if (resource.relationships) {
+    for (const [key, rel] of Object.entries(resource.relationships)) {
+      result[key] = resolveRelationship(rel, included);
+    }
+  }
+  return result;
+}
+function deserialize(response) {
+  const included = response.included ?? [];
+  if (Array.isArray(response.data)) {
+    return response.data.map((r) => flattenResource(r, included));
+  }
+  return flattenResource(response.data, included);
+}
+function extractMeta(response) {
+  return {
+    total: response.meta?.total,
+    page: response.meta?.page,
+    limit: response.meta?.limit,
+    hasNext: !!response.links?.next
+  };
+}
+
+// src/sdk/serialize.ts
+function serialize(type, attributes, id) {
+  const resource = {
+    type,
+    attributes
+  };
+  if (id !== void 0) {
+    resource.id = id;
+  }
+  return { data: resource };
+}
+
+// src/sdk/client.ts
+var InblogApiError = class extends Error {
+  status;
+  code;
+  title;
+  detail;
+  constructor(status, code, title, detail) {
+    super(detail || title);
+    this.name = "InblogApiError";
+    this.status = status;
+    this.code = code;
+    this.title = title;
+    this.detail = detail;
+  }
+};
+var InblogClient = class {
+  apiKey;
+  accessToken;
+  baseUrl;
+  blogId;
+  blogSubdomain;
+  tokenRefresher;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.accessToken = options.accessToken;
+    this.baseUrl = (options.baseUrl ?? "https://inblog.ai").replace(/\/$/, "");
+    this.blogId = options.blogId;
+    this.blogSubdomain = options.blogSubdomain;
+    if (!this.apiKey && !this.accessToken) {
+      throw new Error("Either apiKey or accessToken must be provided");
+    }
+  }
+  setTokenRefresher(fn) {
+    this.tokenRefresher = fn;
+  }
+  async readHeaders() {
+    const token = await this.resolveToken();
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.api+json"
+    };
+    if (this.accessToken && this.blogId) {
+      headers["X-Blog-Id"] = String(this.blogId);
+    }
+    return headers;
+  }
+  async writeHeaders() {
+    const token = await this.resolveToken();
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/vnd.api+json",
+      Accept: "application/vnd.api+json"
+    };
+    if (this.accessToken && this.blogId) {
+      headers["X-Blog-Id"] = String(this.blogId);
+    }
+    return headers;
+  }
+  async resolveToken() {
+    if (this.apiKey) return this.apiKey;
+    if (this.tokenRefresher) {
+      const refreshed = await this.tokenRefresher();
+      if (refreshed) {
+        this.accessToken = refreshed;
+        return refreshed;
+      }
+    }
+    if (this.accessToken) return this.accessToken;
+    throw new Error("No valid authentication token available");
+  }
+  buildUrl(path3, params) {
+    const url = new URL(`/api${path3}`, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value === void 0 || value === null) continue;
+        if (typeof value === "object" && !Array.isArray(value)) {
+          for (const [subKey, subValue] of Object.entries(value)) {
+            if (subValue !== void 0 && subValue !== null) {
+              url.searchParams.set(`${key}[${subKey}]`, String(subValue));
+            }
+          }
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async handleResponse(response) {
+    const text = await response.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : null;
+    } catch {
+      throw new InblogApiError(response.status, "PARSE_ERROR", "Failed to parse API response");
+    }
+    if (!response.ok) {
+      if (body?.errors?.[0]) {
+        const err = body.errors[0];
+        throw new InblogApiError(
+          parseInt(err.status, 10) || response.status,
+          err.code || "UNKNOWN_ERROR",
+          err.title || "API Error",
+          err.detail
+        );
+      }
+      throw new InblogApiError(response.status, "UNKNOWN_ERROR", `HTTP ${response.status}`);
+    }
+    return body;
+  }
+  async get(path3, params) {
+    const url = this.buildUrl(path3, params);
+    const response = await fetch(url, { method: "GET", headers: await this.readHeaders() });
+    const json = await this.handleResponse(response);
+    return {
+      data: deserialize(json),
+      meta: extractMeta(json)
+    };
+  }
+  async list(path3, params) {
+    const url = this.buildUrl(path3, params);
+    const response = await fetch(url, { method: "GET", headers: await this.readHeaders() });
+    const json = await this.handleResponse(response);
+    return {
+      data: deserialize(json),
+      meta: extractMeta(json)
+    };
+  }
+  async create(path3, type, attributes, params) {
+    const url = this.buildUrl(path3, params);
+    const body = serialize(type, attributes);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: await this.writeHeaders(),
+      body: JSON.stringify(body)
+    });
+    const json = await this.handleResponse(response);
+    return {
+      data: deserialize(json),
+      meta: extractMeta(json)
+    };
+  }
+  async update(path3, type, id, attributes) {
+    const url = this.buildUrl(path3);
+    const body = serialize(type, attributes, id);
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: await this.writeHeaders(),
+      body: JSON.stringify(body)
+    });
+    const json = await this.handleResponse(response);
+    return {
+      data: deserialize(json),
+      meta: extractMeta(json)
+    };
+  }
+  async delete(path3) {
+    const url = this.buildUrl(path3);
+    const response = await fetch(url, { method: "DELETE", headers: await this.readHeaders() });
+    if (!response.ok) {
+      await this.handleResponse(response);
+    }
+  }
+  async post(path3, body) {
+    const url = this.buildUrl(path3);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: await this.writeHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const json = await this.handleResponse(response);
+    return {
+      data: deserialize(json),
+      meta: extractMeta(json)
+    };
+  }
+  async patch(path3, body) {
+    const url = this.buildUrl(path3);
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: await this.writeHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const json = await this.handleResponse(response);
+    return {
+      data: deserialize(json),
+      meta: extractMeta(json)
+    };
+  }
+  /**
+   * Raw GET — for non-JSON:API endpoints that return plain JSON.
+   */
+  async rawGet(path3, params) {
+    const url = this.buildUrl(path3, params);
+    const response = await fetch(url, { method: "GET", headers: await this.readHeaders() });
+    return this.handleRawResponse(response);
+  }
+  /**
+   * Raw POST — for non-JSON:API endpoints.
+   */
+  async rawPost(path3, body) {
+    const url = this.buildUrl(path3);
+    const headers = await this.readHeaders();
+    headers["Content-Type"] = "application/json";
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRawResponse(response);
+  }
+  /**
+   * Raw PATCH — for non-JSON:API endpoints.
+   */
+  async rawPatch(path3, body) {
+    const url = this.buildUrl(path3);
+    const headers = await this.readHeaders();
+    headers["Content-Type"] = "application/json";
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRawResponse(response);
+  }
+  /**
+   * Raw DELETE — for non-JSON:API endpoints.
+   */
+  async rawDelete(path3) {
+    const url = this.buildUrl(path3);
+    const response = await fetch(url, { method: "DELETE", headers: await this.readHeaders() });
+    if (response.status === 204) return { success: true };
+    return this.handleRawResponse(response);
+  }
+  async handleRawResponse(response) {
+    const text = await response.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : null;
+    } catch {
+      if (!response.ok) {
+        throw new InblogApiError(response.status, "PARSE_ERROR", "Failed to parse API response");
+      }
+      return text;
+    }
+    if (!response.ok) {
+      if (body?.errors?.[0]) {
+        const err = body.errors[0];
+        throw new InblogApiError(
+          parseInt(err.status, 10) || response.status,
+          err.code || "UNKNOWN_ERROR",
+          err.title || "API Error",
+          err.detail
+        );
+      }
+      throw new InblogApiError(response.status, "UNKNOWN_ERROR", body?.message || `HTTP ${response.status}`);
+    }
+    return body;
+  }
+};
+
+// src/utils/token-store.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var CONFIG_DIR2 = path2.join(os2.homedir(), ".config", "inblog");
+var TOKENS_FILE = path2.join(CONFIG_DIR2, "tokens.json");
+function ensureConfigDir2() {
+  if (!fs2.existsSync(CONFIG_DIR2)) {
+    fs2.mkdirSync(CONFIG_DIR2, { recursive: true });
+  }
+}
+function readSession() {
+  if (!fs2.existsSync(TOKENS_FILE)) return null;
+  try {
+    return JSON.parse(fs2.readFileSync(TOKENS_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeSession(session) {
+  ensureConfigDir2();
+  fs2.writeFileSync(TOKENS_FILE, JSON.stringify(session, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function clearSession() {
+  if (fs2.existsSync(TOKENS_FILE)) {
+    fs2.unlinkSync(TOKENS_FILE);
+  }
+}
+function setActiveBlog(blogId, subdomain, plan) {
+  const session = readSession();
+  if (!session) {
+    throw new Error("Not logged in. Run `inblog auth login` first.");
+  }
+  session.activeBlogId = blogId;
+  session.activeBlogSubdomain = subdomain;
+  if (plan !== void 0) session.activeBlogPlan = plan;
+  writeSession(session);
+}
+
+// src/utils/token-refresh.ts
+var SUPABASE_URL = process.env.INBLOG_SUPABASE_URL || "https://fgobbnslcbjgothosvni.supabase.co";
+var SUPABASE_ANON_KEY = process.env.INBLOG_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImZnb2JibnNsY2JqZ290aG9zdm5pIiwicm9sZSI6ImFub24iLCJpYXQiOjE2Nzc5OTc1MzYsImV4cCI6MTk5MzU3MzUzNn0.cFlx12_PLf42IHJseAxiYOw7MFiS2FOSRgbSZQNDiEo";
+var REFRESH_BUFFER_SECONDS = 60;
+function isTokenExpiringSoon(session) {
+  const now = Math.floor(Date.now() / 1e3);
+  return session.tokens.expires_at - now < REFRESH_BUFFER_SECONDS;
+}
+async function refreshTokens(refreshToken) {
+  const response = await fetch(`${SUPABASE_URL}/auth/v1/token?grant_type=refresh_token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      apikey: SUPABASE_ANON_KEY
+    },
+    body: JSON.stringify({ refresh_token: refreshToken })
+  });
+  if (!response.ok) {
+    throw new Error("Session expired. Run `inblog auth login` to re-authenticate.");
+  }
+  const data = await response.json();
+  return {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Math.floor(Date.now() / 1e3) + data.expires_in,
+    user_id: data.user?.id || ""
+  };
+}
+async function getValidAccessToken() {
+  const session = readSession();
+  if (!session) return null;
+  if (!isTokenExpiringSoon(session)) {
+    return session.tokens.access_token;
+  }
+  const newTokens = await refreshTokens(session.tokens.refresh_token);
+  session.tokens = newTokens;
+  writeSession(session);
+  return newTokens.access_token;
+}
+async function exchangeCodeForTokens(code, codeVerifier) {
+  const response = await fetch(`${SUPABASE_URL}/auth/v1/token?grant_type=pkce`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      apikey: SUPABASE_ANON_KEY
+    },
+    body: JSON.stringify({
+      auth_code: code,
+      code_verifier: codeVerifier
+    })
+  });
+  if (!response.ok) {
+    const errorData = await response.text();
+    throw new Error(`Token exchange failed: ${errorData}`);
+  }
+  const data = await response.json();
+  return {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: Math.floor(Date.now() / 1e3) + data.expires_in,
+    user_id: data.user?.id || ""
+  };
+}
+
+// src/utils/errors.ts
+function checkPlanOrExit() {
+  const session = readSession();
+  if (!session) return;
+  const plan = session.activeBlogPlan;
+  if (plan === "team" || plan === "enterprise") return;
+  if (!plan) return;
+  printError(`CLI features require a Team plan or above. Current plan: ${plan}`);
+  printError(`Upgrade: https://inblog.ai/dashboard/${session.activeBlogSubdomain || ""}/settings/billing`);
+  process.exit(1);
+}
+function handleError(error, json = false) {
+  if (error instanceof InblogApiError) {
+    if (json) {
+      const errorObj = {
+        error: true,
+        status: error.status,
+        code: error.code,
+        title: error.title,
+        detail: error.detail
+      };
+      process.stderr.write(JSON.stringify(errorObj, null, 2) + "\n");
+    } else {
+      printError(`API Error (${error.status}): ${error.title}`);
+      if (error.detail) {
+        printError(`  ${error.detail}`);
+      }
+      if (error.code === "SUBSCRIPTION_REQUIRED") {
+        printError("  API access requires a paid plan. Upgrade at https://inblog.ai/dashboard/settings/billing");
+      }
+    }
+    process.exit(2);
+  }
+  if (error instanceof Error) {
+    if (json) {
+      process.stderr.write(JSON.stringify({ error: true, message: error.message }, null, 2) + "\n");
+    } else {
+      printError(error.message);
+    }
+    process.exit(1);
+  }
+  printError("An unexpected error occurred");
+  process.exit(1);
+}
+
+// src/sdk/endpoints/posts.ts
+var PostsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {};
+    if (options.page) params.page = options.page;
+    if (options.limit) params.limit = options.limit;
+    if (options.sort) params.sort = options.sort;
+    if (options.order) params.order = options.order;
+    if (options.include?.length) params.include = options.include.join(",");
+    if (options.filter) params.filter = options.filter;
+    return this.client.list("/v1/posts", params);
+  }
+  async get(id, include) {
+    const params = {};
+    if (include?.length) params.include = include.join(",");
+    return this.client.get(`/v1/posts/${id}`, params);
+  }
+  async create(input) {
+    const { tag_ids, author_ids, ...attributes } = input;
+    const attrs = { ...attributes };
+    if (tag_ids) attrs.tag_ids = tag_ids;
+    if (author_ids) attrs.author_ids = author_ids;
+    return this.client.create("/v1/posts", "posts", attrs, {
+      include: "tags,authors"
+    });
+  }
+  async update(id, input) {
+    return this.client.update(`/v1/posts/${id}`, "posts", id, input);
+  }
+  async delete(id) {
+    return this.client.delete(`/v1/posts/${id}`);
+  }
+  async publish(id) {
+    return this.client.post(`/v1/posts/${id}/publish`);
+  }
+  async unpublish(id) {
+    return this.client.post(`/v1/posts/${id}/unpublish`);
+  }
+  async schedule(id, scheduledAt) {
+    return this.client.post(`/v1/posts/${id}/schedule`, {
+      data: { type: "posts", attributes: { published_at: scheduledAt } }
+    });
+  }
+  // ── Relationship management ──
+  async listTags(postId) {
+    return this.client.list(`/v1/posts/${postId}/tags`);
+  }
+  async addTags(postId, tagIds) {
+    return this.client.post(`/v1/posts/${postId}/tags`, {
+      data: tagIds.map((id) => ({ id }))
+    });
+  }
+  async removeTag(postId, tagId) {
+    return this.client.delete(`/v1/posts/${postId}/tags/${tagId}`);
+  }
+  async listAuthors(postId) {
+    return this.client.list(`/v1/posts/${postId}/authors`);
+  }
+  async addAuthors(postId, authorIds) {
+    return this.client.post(`/v1/posts/${postId}/authors`, {
+      data: authorIds.map((id) => ({ id }))
+    });
+  }
+  async removeAuthor(postId, authorId) {
+    return this.client.delete(`/v1/posts/${postId}/authors/${authorId}`);
+  }
+};
+
+// src/sdk/endpoints/tags.ts
+var TagsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {};
+    if (options.include?.length) params.include = options.include.join(",");
+    return this.client.list("/v1/tags", params);
+  }
+  async get(id) {
+    return this.client.get(`/v1/tags/${id}`);
+  }
+  async create(input) {
+    return this.client.create("/v1/tags", "tags", input);
+  }
+  async update(id, input) {
+    return this.client.update(`/v1/tags/${id}`, "tags", id, input);
+  }
+  async delete(id) {
+    return this.client.delete(`/v1/tags/${id}`);
+  }
+};
+
+// src/sdk/endpoints/authors.ts
+var AuthorsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {};
+    if (options.page) params.page = options.page;
+    if (options.limit) params.limit = options.limit;
+    if (options.include?.length) params.include = options.include.join(",");
+    return this.client.list("/v1/authors", params);
+  }
+  async get(id) {
+    return this.client.get(`/v1/authors/${id}`);
+  }
+  async update(id, input) {
+    return this.client.update(
+      `/v1/authors/${id}`,
+      "authors",
+      id,
+      input
+    );
+  }
+};
+
+// src/sdk/endpoints/blogs.ts
+var BlogsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async me() {
+    return this.client.get("/v1/blogs/me");
+  }
+  async update(subdomain, input) {
+    return this.client.update(
+      `/v1/blogs/${subdomain}`,
+      "blogs",
+      subdomain,
+      input
+    );
+  }
+  // Domain management (plain JSON endpoints, not JSON:API)
+  async domainConnect(domain) {
+    return this.client.rawPost("/v1/blogs/domain", { custom_domain: domain });
+  }
+  async domainStatus() {
+    return this.client.rawGet("/v1/blogs/domain");
+  }
+  async domainDisconnect() {
+    return this.client.rawDelete("/v1/blogs/domain");
+  }
+  // Custom UI / Banner (plain JSON endpoints)
+  async getCustomUi() {
+    return this.client.rawGet("/v1/blogs/custom-ui");
+  }
+  async updateCustomUi(input) {
+    return this.client.rawPatch("/v1/blogs/custom-ui", input);
+  }
+};
+
+// src/sdk/endpoints/redirects.ts
+var RedirectsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {};
+    if (options.page) params.page = options.page;
+    if (options.limit) params.limit = options.limit;
+    return this.client.list("/v1/redirects", params);
+  }
+  async get(id) {
+    return this.client.get(`/v1/redirects/${id}`);
+  }
+  async create(input) {
+    return this.client.create("/v1/redirects", "redirects", input);
+  }
+  async update(id, input) {
+    return this.client.update(
+      `/v1/redirects/${id}`,
+      "redirects",
+      id,
+      input
+    );
+  }
+  async delete(id) {
+    return this.client.delete(`/v1/redirects/${id}`);
+  }
+};
+
+// src/sdk/endpoints/forms.ts
+var FormsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {};
+    if (options.page) params.page = options.page;
+    if (options.limit) params.limit = options.limit;
+    return this.client.list("/v1/forms", params);
+  }
+  async get(id) {
+    return this.client.get(`/v1/forms/${id}`);
+  }
+};
+var FormResponsesEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {};
+    if (options.page) params.page = options.page;
+    if (options.limit) params.limit = options.limit;
+    if (options.filter) params.filter = options.filter;
+    return this.client.list("/v1/form-responses", params);
+  }
+  async get(id) {
+    return this.client.get(`/v1/form-responses/${id}`);
+  }
+};
+
+// src/sdk/endpoints/search-console.ts
+var SearchConsoleEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async oauthUrl(redirectUri) {
+    const params = {};
+    if (redirectUri) params.redirect_uri = redirectUri;
+    return this.client.rawGet("/v1/blogs/search-console/oauth-url", params);
+  }
+  async connect(code, redirectUri) {
+    return this.client.rawPost("/v1/blogs/search-console/connect", { code, redirect_uri: redirectUri });
+  }
+  async status() {
+    return this.client.rawGet("/v1/blogs/search-console/status");
+  }
+  async disconnect() {
+    return this.client.rawDelete("/v1/blogs/search-console/disconnect");
+  }
+  async keywords(options = {}) {
+    return this.client.rawGet("/v1/blogs/search-console/keywords", options);
+  }
+  async pages(options = {}) {
+    return this.client.rawGet("/v1/blogs/search-console/pages", options);
+  }
+};
+
+// src/sdk/endpoints/analytics.ts
+var AnalyticsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async traffic(options = {}) {
+    return this.client.rawGet("/v1/blogs/analytics/traffic", options);
+  }
+  async posts(options = {}) {
+    return this.client.rawGet("/v1/blogs/analytics/posts", options);
+  }
+  async sources(options = {}) {
+    return this.client.rawGet("/v1/blogs/analytics/sources", options);
+  }
+  async postTraffic(postId, options = {}) {
+    return this.client.rawGet(`/v1/blogs/analytics/posts/${postId}`, options);
+  }
+  async postSources(postId, options = {}) {
+    return this.client.rawGet(`/v1/blogs/analytics/posts/${postId}/sources`, options);
+  }
+};
+
+// src/utils/client-factory.ts
+function createClientFromCommand(cmd) {
+  checkPlanOrExit();
+  const opts = cmd.optsWithGlobals();
+  const config = readConfig();
+  const baseUrl = opts.baseUrl || config.baseUrl || "https://inblog.ai";
+  const session = readSession();
+  if (!session) {
+    throw new Error("Not logged in. Run `inblog auth login` to authenticate.");
+  }
+  if (!session.activeBlogId || !session.activeBlogSubdomain) {
+    throw new Error(
+      "No active blog selected. Run `inblog blogs switch` to select a blog."
+    );
+  }
+  const client = new InblogClient({
+    accessToken: session.tokens.access_token,
+    baseUrl,
+    blogId: session.activeBlogId,
+    blogSubdomain: session.activeBlogSubdomain
+  });
+  client.setTokenRefresher(getValidAccessToken);
+  return {
+    client,
+    posts: new PostsEndpoint(client),
+    tags: new TagsEndpoint(client),
+    authors: new AuthorsEndpoint(client),
+    blogs: new BlogsEndpoint(client),
+    redirects: new RedirectsEndpoint(client),
+    forms: new FormsEndpoint(client),
+    formResponses: new FormResponsesEndpoint(client),
+    searchConsole: new SearchConsoleEndpoint(client),
+    analytics: new AnalyticsEndpoint(client)
+  };
+}
+function isJsonMode(cmd) {
+  return cmd.optsWithGlobals().json === true;
+}
+
+// src/utils/pkce.ts
+var import_node_crypto = require("crypto");
+function generateCodeVerifier() {
+  return (0, import_node_crypto.randomBytes)(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return (0, import_node_crypto.createHash)("sha256").update(verifier).digest("base64url");
+}
+
+// src/utils/callback-server.ts
+var import_node_http = require("http");
+var SUCCESS_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0"><div style="text-align:center"><h1>Login successful!</h1><p>You can close this window and return to the terminal.</p></div></body></html>`;
+var ERROR_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0"><div style="text-align:center"><h1>Login failed</h1><p>Please try again.</p></div></body></html>`;
+function startCallbackServer(options = {}) {
+  const { port = 54321, timeout = 3e5, callbackPath = "/auth/callback" } = options;
+  return new Promise((resolve2, reject) => {
+    let server;
+    let timer;
+    const cleanup = () => {
+      clearTimeout(timer);
+      server.close();
+    };
+    server = (0, import_node_http.createServer)((req, res) => {
+      const url = new URL(req.url || "/", `http://127.0.0.1`);
+      if (url.pathname !== callbackPath) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+      const errorDescription = url.searchParams.get("error_description");
+      if (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(ERROR_HTML);
+        cleanup();
+        reject(new Error(`OAuth error: ${errorDescription || error}`));
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(ERROR_HTML);
+        cleanup();
+        reject(new Error("Missing authorization code in callback"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(SUCCESS_HTML);
+      cleanup();
+      resolve2({ code, port: actualPort });
+    });
+    let actualPort = port;
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        server.listen(0, "127.0.0.1");
+      } else {
+        reject(err);
+      }
+    });
+    server.on("listening", () => {
+      const addr = server.address();
+      if (addr && typeof addr === "object") {
+        actualPort = addr.port;
+      }
+    });
+    server.listen(port, "127.0.0.1");
+    timer = setTimeout(() => {
+      cleanup();
+      reject(new Error("Login timed out. Please try again."));
+    }, timeout);
+  });
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage authentication");
+  auth.command("login").description("Log in with your Google account").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      if (json) {
+        throw new Error("Interactive login is not available in --json mode.");
+      }
+      const existingSession = readSession();
+      if (existingSession) {
+        printWarning("Already logged in. Run `inblog auth logout` first to switch accounts.");
+        return;
+      }
+      const codeVerifier = generateCodeVerifier();
+      const codeChallenge = generateCodeChallenge(codeVerifier);
+      const serverPromise = startCallbackServer();
+      await new Promise((r) => setTimeout(r, 100));
+      const redirectUri = `http://127.0.0.1:54321/auth/callback`;
+      const authUrl = new URL(`${SUPABASE_URL}/auth/v1/authorize`);
+      authUrl.searchParams.set("provider", "google");
+      authUrl.searchParams.set("redirect_to", redirectUri);
+      authUrl.searchParams.set("code_challenge", codeChallenge);
+      authUrl.searchParams.set("code_challenge_method", "S256");
+      console.log("Opening browser for login...");
+      await (0, import_open.default)(authUrl.toString());
+      console.log("Waiting for authentication...");
+      const { code } = await serverPromise;
+      const tokens = await exchangeCodeForTokens(code, codeVerifier);
+      const config = readConfig();
+      const baseUrl = this.optsWithGlobals().baseUrl || config.baseUrl || "https://inblog.ai";
+      const response = await fetch(`${baseUrl}/api/v1/user/blogs`, {
+        headers: {
+          Authorization: `Bearer ${tokens.access_token}`,
+          "X-Blog-Id": "0",
+          Accept: "application/vnd.api+json"
+        }
+      });
+      if (!response.ok) {
+        writeSession({ tokens });
+        printSuccess("Logged in successfully.");
+        printWarning("Could not fetch blog list. Run `inblog blogs list` to select a blog.");
+        return;
+      }
+      const blogsData = await response.json();
+      const blogs = blogsData.data || [];
+      if (blogs.length === 0) {
+        writeSession({ tokens });
+        printSuccess("Logged in, but you have no blogs yet.");
+        return;
+      }
+      let activeBlogId;
+      let activeBlogSubdomain;
+      let activeBlogPlan;
+      if (blogs.length === 1) {
+        activeBlogId = parseInt(blogs[0].id, 10);
+        activeBlogSubdomain = blogs[0].attributes.subdomain;
+        activeBlogPlan = blogs[0].attributes.plan;
+      } else {
+        const choices = blogs.map((b) => ({
+          name: `${b.attributes.title} (${b.attributes.subdomain}) [${b.attributes.permission}]`,
+          value: { id: parseInt(b.id, 10), subdomain: b.attributes.subdomain }
+        }));
+        const selected = await (0, import_prompts.select)({
+          message: "Select a blog to use:",
+          choices
+        });
+        activeBlogId = selected.id;
+        activeBlogSubdomain = selected.subdomain;
+        const selectedBlog = blogs.find((b) => parseInt(b.id, 10) === activeBlogId);
+        activeBlogPlan = selectedBlog?.attributes.plan;
+      }
+      writeSession({
+        tokens,
+        activeBlogId,
+        activeBlogSubdomain,
+        activeBlogPlan
+      });
+      printSuccess(`Logged in. Active blog: ${activeBlogSubdomain}`);
+      if (activeBlogPlan !== "team" && activeBlogPlan !== "enterprise") {
+        printWarning(`Blog "${activeBlogSubdomain}" is on the ${activeBlogPlan || "free"} plan.`);
+        printWarning("  CLI features require a Team plan or above.");
+        printWarning(`  Upgrade: https://inblog.ai/dashboard/${activeBlogSubdomain}/settings/billing`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  auth.command("logout").description("Log out and clear stored session").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const session = readSession();
+      if (!session) {
+        if (json) {
+          printJson({ success: true, message: "Already logged out" });
+        } else {
+          printWarning("Already logged out.");
+        }
+        return;
+      }
+      clearSession();
+      if (json) {
+        printJson({ success: true, message: "Logged out" });
+      } else {
+        printSuccess("Logged out.");
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  auth.command("status").description("Show current login status").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const session = readSession();
+      if (!session) {
+        if (json) {
+          printJson({ loggedIn: false });
+        } else {
+          console.log("Not logged in. Run `inblog auth login` to authenticate.");
+        }
+        return;
+      }
+      const expiresAt = new Date(session.tokens.expires_at * 1e3).toISOString();
+      if (json) {
+        printJson({
+          loggedIn: true,
+          userId: session.tokens.user_id,
+          activeBlogId: session.activeBlogId,
+          activeBlogSubdomain: session.activeBlogSubdomain,
+          tokenExpiresAt: expiresAt
+        });
+      } else {
+        printDetail([
+          ["User ID", session.tokens.user_id],
+          ["Active Blog", session.activeBlogSubdomain || "\u2014"],
+          ["Active Blog ID", session.activeBlogId || "\u2014"],
+          ["Token Expires", expiresAt]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/posts.ts
+var fs3 = __toESM(require("fs"));
+function formatPost(post) {
+  return [
+    ["ID", post.id],
+    ["Title", post.title],
+    ["Slug", post.slug],
+    ["Published", post.published ? "Yes" : "No"],
+    ["Published At", post.published_at],
+    ["Content Type", post.content_type],
+    ["Description", post.description],
+    ["Image", post.image?.url],
+    ["Canonical URL", post.canonical_url],
+    ["Meta Title", post.meta_title],
+    ["Meta Description", post.meta_description],
+    ["Tags", post.tags?.map((t) => t.name).join(", ")],
+    ["Authors", post.authors?.map((a) => a.author_name).join(", ")]
+  ];
+}
+function registerPostsCommands(program2) {
+  const posts = program2.command("posts").description("CRUD, publish, schedule posts + manage tags/authors");
+  posts.command("list").description("List posts with pagination, filters, and sorting").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "10").option("-s, --sort <field>", "Sort field (published_at, created_at, title)").option("-o, --order <dir>", "Sort order (asc, desc)").option("--published", "Only published posts").option("--draft", "Only draft posts").option("--tag-id <id>", "Filter by tag ID").option("--author-id <id>", "Filter by author ID").option("--include <rels>", "Include relationships (tags,authors)", "tags,authors").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      const filter = {};
+      if (opts.published) filter.published = true;
+      if (opts.draft) filter.published = false;
+      if (opts.tagId) filter.tag_id = parseInt(opts.tagId, 10);
+      if (opts.authorId) filter.author_id = opts.authorId;
+      const { data, meta } = await endpoint.list({
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10),
+        sort: opts.sort,
+        order: opts.order,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        include: opts.include ? opts.include.split(",") : void 0
+      });
+      if (json) {
+        printJson({ data, meta });
+      } else {
+        printTable(
+          ["ID", "Title", "Slug", "Published", "Published At", "Tags"],
+          data.map((p) => [
+            p.id,
+            truncate(p.title, 40),
+            truncate(p.slug, 30),
+            p.published ? "Yes" : "No",
+            p.published_at ? new Date(p.published_at).toLocaleDateString() : "\u2014",
+            p.tags?.map((t) => t.name).join(", ") ?? ""
+          ])
+        );
+        if (meta.total) {
+          console.log(`
+Showing page ${meta.page ?? 1} (${data.length} of ${meta.total} posts)`);
+        }
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("get <id>").description("Get post details by ID (integer)").option("--include <rels>", "Include relationships", "tags,authors").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.get(id, opts.include?.split(","));
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail(formatPost(data));
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("create").description("Create post (draft by default, use --published to publish)").requiredOption("-t, --title <title>", "Post title").option("-s, --slug <slug>", "Post slug").option("-d, --description <desc>", "Post description").option("--content <html>", "HTML content").option("--content-file <path>", "Read HTML content from file").option("--notion-url <url>", "Notion page URL").option("--published", "Publish immediately").option("--tag-ids <ids>", "Comma-separated tag IDs").option("--author-ids <ids>", "Comma-separated author IDs").option("--canonical-url <url>", "Canonical URL").option("--meta-title <title>", "Meta title").option("--meta-description <desc>", "Meta description").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      let contentHtml = opts.content;
+      if (opts.contentFile) {
+        contentHtml = fs3.readFileSync(opts.contentFile, "utf-8");
+      }
+      const input = { title: opts.title };
+      if (opts.slug) input.slug = opts.slug;
+      if (opts.description) input.description = opts.description;
+      if (contentHtml) input.content_html = contentHtml;
+      if (opts.notionUrl) input.notion_url = opts.notionUrl;
+      if (opts.published) input.published = true;
+      if (opts.canonicalUrl) input.canonical_url = opts.canonicalUrl;
+      if (opts.metaTitle) input.meta_title = opts.metaTitle;
+      if (opts.metaDescription) input.meta_description = opts.metaDescription;
+      if (opts.tagIds) input.tag_ids = opts.tagIds.split(",").map(Number);
+      if (opts.authorIds) input.author_ids = opts.authorIds.split(",");
+      const { data } = await endpoint.create(input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Post created: "${data.title}" (ID: ${data.id})`);
+        printDetail(formatPost(data));
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("update <id>").description("Update post fields (title, slug, content, SEO metadata)").option("-t, --title <title>", "Post title").option("-s, --slug <slug>", "Post slug").option("-d, --description <desc>", "Post description").option("--content <html>", "HTML content").option("--content-file <path>", "Read HTML content from file").option("--canonical-url <url>", "Canonical URL").option("--meta-title <title>", "Meta title").option("--meta-description <desc>", "Meta description").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      let contentHtml = opts.content;
+      if (opts.contentFile) {
+        contentHtml = fs3.readFileSync(opts.contentFile, "utf-8");
+      }
+      const input = {};
+      if (opts.title) input.title = opts.title;
+      if (opts.slug) input.slug = opts.slug;
+      if (opts.description) input.description = opts.description;
+      if (contentHtml) input.content_html = contentHtml;
+      if (opts.canonicalUrl !== void 0) input.canonical_url = opts.canonicalUrl || null;
+      if (opts.metaTitle !== void 0) input.meta_title = opts.metaTitle || null;
+      if (opts.metaDescription !== void 0) input.meta_description = opts.metaDescription || null;
+      if (Object.keys(input).length === 0) {
+        throw new Error("No fields to update. Provide at least one option.");
+      }
+      const { data } = await endpoint.update(id, input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Post updated: "${data.title}" (ID: ${data.id})`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("delete <id>").description("Permanently delete a post").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      await endpoint.delete(id);
+      if (json) {
+        printJson({ success: true, id });
+      } else {
+        printSuccess(`Post ${id} deleted.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("publish <id>").description("Set post as published (immediately visible)").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.publish(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Post "${data.title}" published.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("unpublish <id>").description("Revert published post to draft").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.unpublish(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Post "${data.title}" unpublished.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("schedule <id>").description("Schedule post for future publishing (ISO 8601 date)").requiredOption("--at <iso-date>", "ISO 8601 date for scheduled publish").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.schedule(id, opts.at);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Post "${data.title}" scheduled for ${opts.at}.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("tags <id>").description("List tags for a post").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.listTags(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printTable(["ID", "Name", "Slug"], data.map((t) => [t.id, t.name, t.slug]));
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("add-tags <id>").description("Add tags to a post").requiredOption("--tag-ids <ids>", "Comma-separated tag IDs").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      const tagIds = opts.tagIds.split(",").map(Number);
+      const { data } = await endpoint.addTags(id, tagIds);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Tags added to post ${id}.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("remove-tag <postId> <tagId>").description("Remove a tag from a post").action(async function(postId, tagId) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      await endpoint.removeTag(postId, tagId);
+      if (json) {
+        printJson({ success: true, postId, tagId });
+      } else {
+        printSuccess(`Tag ${tagId} removed from post ${postId}.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("authors <id>").description("List authors for a post").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.listAuthors(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printTable(
+          ["ID", "Name", "Avatar URL"],
+          data.map((a) => [a.id, a.author_name, truncate(a.avatar_url, 40)])
+        );
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("add-authors <id>").description("Add authors to a post").requiredOption("--author-ids <ids>", "Comma-separated author IDs").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { posts: endpoint } = createClientFromCommand(this);
+      const authorIds = opts.authorIds.split(",");
+      const { data } = await endpoint.addAuthors(id, authorIds);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Authors added to post ${id}.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  posts.command("remove-author <postId> <authorId>").description("Remove an author from a post").action(async function(postId, authorId) {
+    const json = isJsonMode(this);
+    try {
+      const { posts: endpoint } = createClientFromCommand(this);
+      await endpoint.removeAuthor(postId, authorId);
+      if (json) {
+        printJson({ success: true, postId, authorId });
+      } else {
+        printSuccess(`Author ${authorId} removed from post ${postId}.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/tags.ts
+function registerTagsCommands(program2) {
+  const tags = program2.command("tags").description("CRUD tags (no pagination, sorted by priority)");
+  tags.command("list").description("List all tags (returns all, sorted by priority)").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const { tags: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.list();
+      if (json) {
+        printJson(data);
+      } else {
+        printTable(
+          ["ID", "Name", "Slug", "Priority"],
+          data.map((t) => [t.id, t.name, t.slug, t.priority])
+        );
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  tags.command("get <id>").description("Get a tag by ID").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { tags: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.get(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["ID", data.id],
+          ["Name", data.name],
+          ["Slug", data.slug],
+          ["Priority", data.priority]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  tags.command("create").description("Create a new tag").requiredOption("-n, --name <name>", "Tag name").option("-s, --slug <slug>", "Tag slug").option("-p, --priority <number>", "Tag priority").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { tags: endpoint } = createClientFromCommand(this);
+      const input = { name: opts.name };
+      if (opts.slug) input.slug = opts.slug;
+      if (opts.priority !== void 0) input.priority = parseInt(opts.priority, 10);
+      const { data } = await endpoint.create(input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Tag created: "${data.name}" (ID: ${data.id})`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  tags.command("update <id>").description("Update a tag").option("-n, --name <name>", "Tag name").option("-s, --slug <slug>", "Tag slug").option("-p, --priority <number>", "Tag priority").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { tags: endpoint } = createClientFromCommand(this);
+      const input = {};
+      if (opts.name) input.name = opts.name;
+      if (opts.slug) input.slug = opts.slug;
+      if (opts.priority !== void 0) input.priority = parseInt(opts.priority, 10);
+      if (Object.keys(input).length === 0) {
+        throw new Error("No fields to update. Provide at least one option.");
+      }
+      const { data } = await endpoint.update(id, input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Tag updated: "${data.name}" (ID: ${data.id})`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  tags.command("delete <id>").description("Delete a tag").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { tags: endpoint } = createClientFromCommand(this);
+      await endpoint.delete(id);
+      if (json) {
+        printJson({ success: true, id });
+      } else {
+        printSuccess(`Tag ${id} deleted.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/authors.ts
+function registerAuthorsCommands(program2) {
+  const authors = program2.command("authors").description("List, view, update authors (create not available)");
+  authors.command("list").description("List authors (only profiles with posts, UUID IDs)").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "10").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { authors: endpoint } = createClientFromCommand(this);
+      const { data, meta } = await endpoint.list({
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      if (json) {
+        printJson({ data, meta });
+      } else {
+        printTable(
+          ["ID", "Name", "Avatar"],
+          data.map((a) => [a.id, a.author_name, truncate(a.avatar_url, 40)])
+        );
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  authors.command("get <id>").description("Get an author by ID").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { authors: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.get(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["ID", data.id],
+          ["Name", data.author_name],
+          ["Avatar URL", data.avatar_url]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  authors.command("update <id>").description("Update an author").option("-n, --name <name>", "Author name").option("--avatar-url <url>", "Avatar URL").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { authors: endpoint } = createClientFromCommand(this);
+      const input = {};
+      if (opts.name) input.author_name = opts.name;
+      if (opts.avatarUrl !== void 0) input.avatar_url = opts.avatarUrl || null;
+      if (Object.keys(input).length === 0) {
+        throw new Error("No fields to update. Provide at least one option.");
+      }
+      const { data } = await endpoint.update(id, input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Author updated: "${data.author_name}" (ID: ${data.id})`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/blogs.ts
+var import_prompts2 = require("@inquirer/prompts");
+function registerBlogsCommands(program2) {
+  const blogs = program2.command("blogs").description("Manage blogs \u2014 list, switch, view, and update blog settings");
+  blogs.command("me").description("Show blog info (title, subdomain, plan, domain)").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const { blogs: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.me();
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["ID", data.id],
+          ["Title", data.title],
+          ["Subdomain", data.subdomain],
+          ["Description", data.description],
+          ["Plan", data.plan],
+          ["Language", data.blog_language],
+          ["Custom Domain", data.custom_domain],
+          ["Domain Verified", data.custom_domain_verified],
+          ["Logo", data.logo_url],
+          ["Favicon", data.favicon],
+          ["OG Image", data.og_image],
+          ["GA ID", data.ga_measurement_id],
+          ["Search Console", data.is_search_console_connected ? `Connected (${data.search_console_url})` : "Not connected"],
+          ["Created At", data.created_at]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  blogs.command("list").description("List all blogs you have access to (OAuth only)").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const session = readSession();
+      if (!session) {
+        throw new Error("OAuth session required. Run `inblog auth login` first.");
+      }
+      const accessToken = await getValidAccessToken();
+      if (!accessToken) {
+        throw new Error("Session expired. Run `inblog auth login` to re-authenticate.");
+      }
+      const config = readConfig();
+      const baseUrl = this.optsWithGlobals().baseUrl || config.baseUrl || "https://inblog.ai";
+      const response = await fetch(`${baseUrl}/api/v1/user/blogs`, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "X-Blog-Id": "0",
+          Accept: "application/vnd.api+json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch blogs: HTTP ${response.status}`);
+      }
+      const blogsData = await response.json();
+      const blogsList = blogsData.data || [];
+      if (json) {
+        printJson(blogsList.map((b) => ({
+          id: parseInt(b.id, 10),
+          ...b.attributes
+        })));
+        return;
+      }
+      if (blogsList.length === 0) {
+        printWarning("No blogs found.");
+        return;
+      }
+      const activeBlogId = session.activeBlogId;
+      printTable(
+        ["", "ID", "Title", "Subdomain", "Permission", "Plan"],
+        blogsList.map((b) => {
+          const id = parseInt(b.id, 10);
+          const active = id === activeBlogId ? "*" : "";
+          return [active, id, b.attributes.title, b.attributes.subdomain, b.attributes.permission, b.attributes.plan];
+        })
+      );
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  blogs.command("switch [blog-id]").description("Switch active blog (OAuth only)").action(async function(blogIdArg) {
+    const json = isJsonMode(this);
+    try {
+      const session = readSession();
+      if (!session) {
+        throw new Error("OAuth session required. Run `inblog auth login` first.");
+      }
+      const accessToken = await getValidAccessToken();
+      if (!accessToken) {
+        throw new Error("Session expired. Run `inblog auth login` to re-authenticate.");
+      }
+      const config = readConfig();
+      const baseUrl = this.optsWithGlobals().baseUrl || config.baseUrl || "https://inblog.ai";
+      const response = await fetch(`${baseUrl}/api/v1/user/blogs`, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "X-Blog-Id": "0",
+          Accept: "application/vnd.api+json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch blogs: HTTP ${response.status}`);
+      }
+      const blogsData = await response.json();
+      const blogsList = blogsData.data || [];
+      if (blogsList.length === 0) {
+        throw new Error("No blogs found for your account.");
+      }
+      let selectedBlogId;
+      let selectedSubdomain;
+      if (blogIdArg) {
+        const target = blogsList.find((b) => b.id === blogIdArg || b.attributes.subdomain === blogIdArg);
+        if (!target) {
+          throw new Error(`Blog not found: ${blogIdArg}`);
+        }
+        selectedBlogId = parseInt(target.id, 10);
+        selectedSubdomain = target.attributes.subdomain;
+      } else {
+        if (json) {
+          throw new Error("Blog ID is required in --json mode. Usage: inblog blogs switch <blog-id>");
+        }
+        const choices = blogsList.map((b) => ({
+          name: `${b.attributes.title} (${b.attributes.subdomain}) [${b.attributes.permission}]`,
+          value: { id: parseInt(b.id, 10), subdomain: b.attributes.subdomain }
+        }));
+        const selected = await (0, import_prompts2.select)({
+          message: "Select a blog:",
+          choices
+        });
+        selectedBlogId = selected.id;
+        selectedSubdomain = selected.subdomain;
+      }
+      const targetBlog = blogsList.find((b) => b.id === String(selectedBlogId));
+      const activeBlogPlan = targetBlog?.attributes.plan;
+      setActiveBlog(selectedBlogId, selectedSubdomain, activeBlogPlan);
+      if (json) {
+        printJson({ success: true, blogId: selectedBlogId, subdomain: selectedSubdomain });
+      } else {
+        printSuccess(`Switched to blog: ${selectedSubdomain}`);
+      }
+      if (activeBlogPlan !== "team" && activeBlogPlan !== "enterprise") {
+        printWarning(`Blog "${selectedSubdomain}" is on the ${activeBlogPlan || "free"} plan.`);
+        printWarning("  CLI features require a Team plan or above.");
+        printWarning(`  Upgrade: https://inblog.ai/dashboard/${selectedSubdomain}/settings/billing`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  blogs.command("update").description("Update blog title, description, language, or timezone").option("-t, --title <title>", "Blog title").option("-d, --description <desc>", "Blog description").option("--language <lang>", "Blog language").option("--timezone-diff <hours>", "Timezone offset in hours").option("--logo <url>", "Blog logo image URL").option("--favicon <url>", "Blog favicon image URL").option("--og-image <url>", "Blog OG image URL").option("--ga-id <id>", "Google Analytics measurement ID").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const ctx = createClientFromCommand(this);
+      const { data: blog } = await ctx.blogs.me();
+      const input = {};
+      if (opts.title) input.title = opts.title;
+      if (opts.description) input.description = opts.description;
+      if (opts.language) input.blog_language = opts.language;
+      if (opts.timezoneDiff !== void 0) input.timezone_diff = parseInt(opts.timezoneDiff, 10);
+      if (opts.logo) input.logo = opts.logo;
+      if (opts.favicon) input.favicon = opts.favicon;
+      if (opts.ogImage) input.og_image = opts.ogImage;
+      if (opts.gaId) input.ga_measurement_id = opts.gaId;
+      if (Object.keys(input).length === 0) {
+        throw new Error("No fields to update. Provide at least one option.");
+      }
+      const { data } = await ctx.blogs.update(blog.subdomain, input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Blog updated: "${data.title}"`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  const domain = blogs.command("domain").description("Manage custom domain");
+  domain.command("connect <domain>").description("Connect a custom domain").action(async function(domainArg) {
+    const json = isJsonMode(this);
+    try {
+      const ctx = createClientFromCommand(this);
+      const result = await ctx.blogs.domainConnect(domainArg);
+      if (json) {
+        printJson(result);
+      } else {
+        printSuccess(`Custom domain requested: ${domainArg}`);
+        if (result.dns_records && result.dns_records.length > 0) {
+          printTable(
+            ["Type", "Name", "Value"],
+            result.dns_records.map((r) => [r.type, r.name, r.value])
+          );
+        }
+        printWarning("DNS \uC804\uD30C \uD6C4 `inblog blogs domain status`\uB85C \uD655\uC778\uD558\uC138\uC694.");
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  domain.command("status").description("Check custom domain verification status").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const ctx = createClientFromCommand(this);
+      const result = await ctx.blogs.domainStatus();
+      if (json) {
+        printJson(result);
+      } else {
+        if (!result.custom_domain) {
+          printWarning("No custom domain configured.");
+          return;
+        }
+        printDetail([
+          ["Domain", result.custom_domain],
+          ["Verified", result.verified],
+          ["SSL Status", result.ssl_status]
+        ]);
+        if (result.dns_records && result.dns_records.length > 0) {
+          printTable(
+            ["Type", "Name", "Value"],
+            result.dns_records.map((r) => [r.type, r.name, r.value])
+          );
+        }
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  domain.command("disconnect").description("Disconnect custom domain").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const ctx = createClientFromCommand(this);
+      await ctx.blogs.domainDisconnect();
+      if (json) {
+        printJson({ success: true });
+      } else {
+        printSuccess("Custom domain disconnected.");
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  const banner = blogs.command("banner").description("Manage blog banner settings");
+  banner.command("get").description("Show current banner settings").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const ctx = createClientFromCommand(this);
+      const result = await ctx.blogs.getCustomUi();
+      if (json) {
+        printJson(result);
+      } else {
+        printDetail([
+          ["Banner Image", result.banner_url],
+          ["Title", result.banner_title],
+          ["Subtext", result.banner_subtext],
+          ["Title Color", result.banner_title_color],
+          ["Background Color", result.banner_bg_color]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  banner.command("set").description("Update banner settings").option("--image <url>", "Banner image URL").option("--title <text>", "Banner title text").option("--subtext <text>", "Banner subtext").option("--title-color <hex>", "Banner title color (hex)").option("--bg-color <hex>", "Banner background color (hex)").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const input = {};
+      if (opts.image) input.banner_url = opts.image;
+      if (opts.title) input.banner_title = opts.title;
+      if (opts.subtext) input.banner_subtext = opts.subtext;
+      if (opts.titleColor) input.banner_title_color = opts.titleColor;
+      if (opts.bgColor) input.banner_bg_color = opts.bgColor;
+      if (Object.keys(input).length === 0) {
+        throw new Error("No fields to update. Provide at least one option (--image, --title, --subtext, --title-color, --bg-color).");
+      }
+      const ctx = createClientFromCommand(this);
+      const result = await ctx.blogs.updateCustomUi(input);
+      if (json) {
+        printJson(result);
+      } else {
+        printSuccess("Banner updated.");
+        printDetail([
+          ["Banner Image", result.banner_url],
+          ["Title", result.banner_title],
+          ["Subtext", result.banner_subtext],
+          ["Title Color", result.banner_title_color],
+          ["Background Color", result.banner_bg_color]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  banner.command("remove").description("Remove banner settings").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const ctx = createClientFromCommand(this);
+      await ctx.blogs.updateCustomUi({
+        banner_url: null,
+        banner_title: null,
+        banner_subtext: null
+      });
+      if (json) {
+        printJson({ success: true });
+      } else {
+        printSuccess("Banner removed.");
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/redirects.ts
+function registerRedirectsCommands(program2) {
+  const redirects = program2.command("redirects").description("CRUD URL redirects (307 temporary, 308 permanent)");
+  redirects.command("list").description("List redirects").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "50").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { redirects: endpoint } = createClientFromCommand(this);
+      const { data, meta } = await endpoint.list({
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      if (json) {
+        printJson({ data, meta });
+      } else {
+        printTable(
+          ["ID", "From", "To", "Type"],
+          data.map((r) => [r.id, r.from_path, r.to_path, r.redirect_type])
+        );
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  redirects.command("get <id>").description("Get a redirect by ID").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { redirects: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.get(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["ID", data.id],
+          ["From", data.from_path],
+          ["To", data.to_path],
+          ["Type", data.redirect_type],
+          ["Created At", data.created_at],
+          ["Updated At", data.updated_at]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  redirects.command("create").description("Create a redirect (default: 308 permanent)").requiredOption("--from <path>", "Source path (auto-normalized with /)").requiredOption("--to <path>", "Destination path").option("--type <type>", "Redirect type (307 or 308)", "308").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { redirects: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.create({
+        from_path: opts.from,
+        to_path: opts.to,
+        redirect_type: parseInt(opts.type, 10)
+      });
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Redirect created: ${data.from_path} \u2192 ${data.to_path} (${data.redirect_type})`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  redirects.command("update <id>").description("Update a redirect").option("--from <path>", "Source path").option("--to <path>", "Destination path").option("--type <type>", "Redirect type (307 or 308)").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { redirects: endpoint } = createClientFromCommand(this);
+      const input = {};
+      if (opts.from) input.from_path = opts.from;
+      if (opts.to) input.to_path = opts.to;
+      if (opts.type) input.redirect_type = parseInt(opts.type, 10);
+      if (Object.keys(input).length === 0) {
+        throw new Error("No fields to update. Provide at least one option.");
+      }
+      const { data } = await endpoint.update(id, input);
+      if (json) {
+        printJson(data);
+      } else {
+        printSuccess(`Redirect updated: ${data.from_path} \u2192 ${data.to_path}`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  redirects.command("delete <id>").description("Delete a redirect").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { redirects: endpoint } = createClientFromCommand(this);
+      await endpoint.delete(id);
+      if (json) {
+        printJson({ success: true, id });
+      } else {
+        printSuccess(`Redirect ${id} deleted.`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/forms.ts
+function registerFormsCommands(program2) {
+  const forms = program2.command("forms").description("View lead-capture forms (read-only)");
+  forms.command("list").description("List forms").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "10").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { forms: endpoint } = createClientFromCommand(this);
+      const { data, meta } = await endpoint.list({
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      if (json) {
+        printJson({ data, meta });
+      } else {
+        printTable(
+          ["ID", "Title", "Responses", "Created At"],
+          data.map((f) => [f.id, truncate(f.title, 40), f.response_count, f.created_at])
+        );
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  forms.command("get <id>").description("Get a form by ID").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { forms: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.get(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["ID", data.id],
+          ["Title", data.title],
+          ["Magnet Type", data.magnet_type],
+          ["Responses", data.response_count],
+          ["Created At", data.created_at]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+function registerFormResponsesCommands(program2) {
+  const formResponses = program2.command("form-responses").description("View form submission data (read-only)");
+  formResponses.command("list").description("List form responses").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "10").option("--form-id <id>", "Filter by form ID").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { formResponses: endpoint } = createClientFromCommand(this);
+      const filter = {};
+      if (opts.formId) filter.form_id = opts.formId;
+      const { data, meta } = await endpoint.list({
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10),
+        filter: Object.keys(filter).length > 0 ? filter : void 0
+      });
+      if (json) {
+        printJson({ data, meta });
+      } else {
+        printTable(
+          ["ID", "Email", "Country", "Created At"],
+          data.map((r) => [r.id, r.email, r.country, r.created_at])
+        );
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  formResponses.command("get <id>").description("Get a form response by ID").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const { formResponses: endpoint } = createClientFromCommand(this);
+      const { data } = await endpoint.get(id);
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["ID", data.id],
+          ["Email", data.email],
+          ["Country", data.country],
+          ["City", data.city],
+          ["Region", data.region],
+          ["Language", data.language],
+          ["Created At", data.created_at],
+          ["Response", JSON.stringify(data.response)]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Manage CLI config (~/.config/inblog/config.json)");
+  config.command("list").description("Show all configuration values").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const cfg = readGlobalConfig();
+      if (json) {
+        printJson(cfg);
+      } else {
+        const entries = Object.entries(cfg);
+        if (entries.length === 0) {
+          console.log("No configuration set.");
+        } else {
+          printDetail(
+            entries.map(([k, v]) => [k, typeof v === "object" ? JSON.stringify(v) : v])
+          );
+        }
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  config.command("get <key>").description("Get a configuration value").action(async function(key) {
+    const json = isJsonMode(this);
+    try {
+      const cfg = readGlobalConfig();
+      const value = cfg[key];
+      if (json) {
+        printJson({ [key]: value ?? null });
+      } else if (value === void 0) {
+        console.log(`"${key}" is not set.`);
+      } else {
+        console.log(value);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  config.command("set <key> <value>").description("Set a configuration value").action(async function(key, value) {
+    const json = isJsonMode(this);
+    try {
+      let parsed = value;
+      if (value === "true") parsed = true;
+      else if (value === "false") parsed = false;
+      else if (!isNaN(Number(value)) && value !== "") parsed = Number(value);
+      setGlobalConfigValue(key, parsed);
+      if (json) {
+        printJson({ [key]: parsed });
+      } else {
+        printSuccess(`Set ${key} = ${parsed}`);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  config.command("path").description("Show configuration file paths").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const globalPath = getGlobalConfigPath();
+      const localPath = getLocalConfigPath();
+      if (json) {
+        printJson({ global: globalPath, local: localPath });
+      } else {
+        printDetail([
+          ["Global", globalPath],
+          ["Local", localPath ?? "(none)"]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/search-console.ts
+var import_open2 = __toESM(require("open"));
+function registerSearchConsoleCommands(program2) {
+  const sc = program2.command("search-console").description("Google Search Console integration");
+  sc.command("connect").description("Connect Google Search Console via OAuth").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      if (json) {
+        throw new Error("Interactive OAuth flow is not available in --json mode.");
+      }
+      const { searchConsole } = createClientFromCommand(this);
+      const statusResult = await searchConsole.status();
+      if (statusResult.connected) {
+        printWarning("Search Console is already connected.");
+        printDetail([
+          ["Status", "Connected"],
+          ["Property", statusResult.property || "\u2014"]
+        ]);
+        return;
+      }
+      const callbackPath = "/auth/gsc-callback";
+      const serverPromise = startCallbackServer({ callbackPath });
+      await new Promise((r) => setTimeout(r, 100));
+      const redirectUri = `http://127.0.0.1:54321${callbackPath}`;
+      const oauthResult = await searchConsole.oauthUrl(redirectUri);
+      const url = oauthResult.url;
+      if (!url) {
+        throw new Error("Failed to retrieve OAuth URL from server.");
+      }
+      console.log("Opening browser for Google Search Console authorization...");
+      await (0, import_open2.default)(url);
+      console.log("Waiting for authorization...");
+      const { code } = await serverPromise;
+      await searchConsole.connect(code, redirectUri);
+      printSuccess("Google Search Console connected successfully.");
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  sc.command("status").description("Show Search Console connection status").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const { searchConsole } = createClientFromCommand(this);
+      const data = await searchConsole.status();
+      if (json) {
+        printJson(data);
+      } else {
+        printDetail([
+          ["Connected", data.connected ? "Yes" : "No"],
+          ["Property", data.property || "\u2014"]
+        ]);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  sc.command("disconnect").description("Disconnect Google Search Console").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const { searchConsole } = createClientFromCommand(this);
+      await searchConsole.disconnect();
+      if (json) {
+        printJson({ success: true });
+      } else {
+        printSuccess("Google Search Console disconnected.");
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  sc.command("keywords").description("Show keyword performance data").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("--sort <field>", "Sort by: clicks, impressions, ctr, position", "clicks").option("--order <dir>", "Sort order: asc, desc", "desc").option("-l, --limit <number>", "Max results", "20").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { searchConsole } = createClientFromCommand(this);
+      const data = await searchConsole.keywords({
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        sort: opts.sort,
+        order: opts.order,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (json) {
+        printJson(data);
+      } else {
+        const rows = (data.keywords || data.data || []).map((k) => [
+          k.keyword || k.key,
+          k.clicks,
+          k.impressions,
+          typeof k.ctr === "number" ? `${(k.ctr * 100).toFixed(1)}%` : k.ctr,
+          typeof k.position === "number" ? k.position.toFixed(1) : k.position
+        ]);
+        printTable(["Keyword", "Clicks", "Impressions", "CTR", "Position"], rows);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  sc.command("pages").description("Show page performance data").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("--sort <field>", "Sort by: clicks, impressions, ctr, position", "clicks").option("--order <dir>", "Sort order: asc, desc", "desc").option("-l, --limit <number>", "Max results", "20").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { searchConsole } = createClientFromCommand(this);
+      const data = await searchConsole.pages({
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        sort: opts.sort,
+        order: opts.order,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (json) {
+        printJson(data);
+      } else {
+        const rows = (data.pages || data.data || []).map((p) => [
+          p.page || p.key,
+          p.clicks,
+          p.impressions,
+          typeof p.ctr === "number" ? `${(p.ctr * 100).toFixed(1)}%` : p.ctr,
+          typeof p.position === "number" ? p.position.toFixed(1) : p.position
+        ]);
+        printTable(["Page", "Clicks", "Impressions", "CTR", "Position"], rows);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// src/commands/analytics.ts
+function registerAnalyticsCommands(program2) {
+  const analytics = program2.command("analytics").description("Blog analytics: traffic, post metrics, referrer sources");
+  analytics.command("traffic").description("Show blog overall traffic").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("--interval <interval>", "Interval: day, hour", "day").option("--type <type>", "Page type: all, home, post, category, author", "all").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { analytics: endpoint } = createClientFromCommand(this);
+      const data = await endpoint.traffic({
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        interval: opts.interval,
+        type: opts.type
+      });
+      if (json) {
+        printJson(data);
+      } else {
+        const rows = (data.data || []).map((r) => [
+          r.date || r.period,
+          r.visits,
+          r.clicks,
+          r.organic
+        ]);
+        printTable(["Date", "Visits", "Clicks", "Organic"], rows);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  analytics.command("posts").description("Show post-level metrics").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("--sort <field>", "Sort by: visits, clicks, organic, cvr", "visits").option("--order <dir>", "Sort order: asc, desc", "desc").option("-l, --limit <number>", "Max results", "20").option("--include <fields>", "Include extra fields (e.g. title)").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { analytics: endpoint } = createClientFromCommand(this);
+      const data = await endpoint.posts({
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        sort: opts.sort,
+        order: opts.order,
+        limit: parseInt(opts.limit, 10),
+        include: opts.include
+      });
+      if (json) {
+        printJson(data);
+      } else {
+        const hasTitle = opts.include?.includes("title");
+        const headers = hasTitle ? ["Post ID", "Title", "Visits", "Clicks", "Organic", "CVR"] : ["Post ID", "Visits", "Clicks", "Organic", "CVR"];
+        const rows = (data.data || []).map((r) => {
+          const cvr = typeof r.cvr === "number" ? `${(r.cvr * 100).toFixed(1)}%` : r.cvr ?? "\u2014";
+          if (hasTitle) {
+            return [r.post_id ?? r.id, truncate(r.title, 40), r.visits, r.clicks, r.organic, cvr];
+          }
+          return [r.post_id ?? r.id, r.visits, r.clicks, r.organic, cvr];
+        });
+        printTable(headers, rows);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  analytics.command("sources").description("Show referrer sources").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("-l, --limit <number>", "Max results", "20").action(async function() {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { analytics: endpoint } = createClientFromCommand(this);
+      const data = await endpoint.sources({
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (json) {
+        printJson(data);
+      } else {
+        const rows = (data.data || []).map((r) => [
+          r.referrer || r.source,
+          r.count ?? r.visits
+        ]);
+        printTable(["Referrer", "Count"], rows);
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+  analytics.command("post <id>").description("Show traffic or sources for a single post").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("--interval <interval>", "Interval: day, hour", "day").option("--sources", "Show referrer sources instead of traffic").option("-l, --limit <number>", "Max results (for --sources)", "20").action(async function(id) {
+    const json = isJsonMode(this);
+    try {
+      const opts = this.opts();
+      const { analytics: endpoint } = createClientFromCommand(this);
+      const postId = parseInt(id, 10);
+      if (opts.sources) {
+        const data = await endpoint.postSources(postId, {
+          start_date: opts.startDate,
+          end_date: opts.endDate,
+          limit: parseInt(opts.limit, 10)
+        });
+        if (json) {
+          printJson(data);
+        } else {
+          const rows = (data.data || []).map((r) => [
+            r.referrer || r.source,
+            r.count ?? r.visits
+          ]);
+          printTable(["Referrer", "Count"], rows);
+        }
+      } else {
+        const data = await endpoint.postTraffic(postId, {
+          start_date: opts.startDate,
+          end_date: opts.endDate,
+          interval: opts.interval
+        });
+        if (json) {
+          printJson(data);
+        } else {
+          const rows = (data.data || []).map((r) => [
+            r.date || r.period,
+            r.visits,
+            r.clicks,
+            r.organic
+          ]);
+          printTable(["Date", "Visits", "Clicks", "Organic"], rows);
+        }
+      }
+    } catch (error) {
+      handleError(error, json);
+    }
+  });
+}
+
+// bin/inblog.ts
+var program = new import_commander.Command();
+program.name("inblog").description("CLI for managing inblog.ai blog content (posts, tags, authors, redirects, forms)").version("0.2.0").option("--json", "Output as JSON (for programmatic use)").option("--base-url <url>", "API base URL").option("--no-color", "Disable colored output");
+registerAuthCommands(program);
+registerPostsCommands(program);
+registerTagsCommands(program);
+registerAuthorsCommands(program);
+registerBlogsCommands(program);
+registerRedirectsCommands(program);
+registerFormsCommands(program);
+registerFormResponsesCommands(program);
+registerConfigCommands(program);
+registerSearchConsoleCommands(program);
+registerAnalyticsCommands(program);
+program.parse();
+//# sourceMappingURL=inblog.js.map