@socialneuron/mcp-server 1.7.12 → 1.7.14

package/dist/sn.js

@@ -0,0 +1,4201 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/version.ts
+var MCP_VERSION;
+var init_version = __esm({
+  "src/lib/version.ts"() {
+    "use strict";
+    MCP_VERSION = "1.7.14";
+  }
+});
+
+// src/lib/request-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function getRequestUserId() {
+  return requestContext.getStore()?.userId ?? null;
+}
+function getRequestToken() {
+  return requestContext.getStore()?.token ?? null;
+}
+var requestContext;
+var init_request_context = __esm({
+  "src/lib/request-context.ts"() {
+    "use strict";
+    requestContext = new AsyncLocalStorage();
+  }
+});
+
+// src/cli/credentials.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  deleteApiKey: () => deleteApiKey,
+  loadApiKey: () => loadApiKey,
+  loadSupabaseUrl: () => loadSupabaseUrl,
+  saveApiKey: () => saveApiKey,
+  saveSupabaseUrl: () => saveSupabaseUrl
+});
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+function readCredentialsFile() {
+  try {
+    if (!existsSync(CREDENTIALS_FILE)) return {};
+    const raw = readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeCredentialsFile(data) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function macKeychainRead(service) {
+  try {
+    const result = execFileSync(
+      "security",
+      ["find-generic-password", "-a", KEYCHAIN_ACCOUNT, "-s", service, "-w"],
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function macKeychainWrite(service, value) {
+  try {
+    execFileSync(
+      "security",
+      [
+        "add-generic-password",
+        "-a",
+        KEYCHAIN_ACCOUNT,
+        "-s",
+        service,
+        "-w",
+        value,
+        "-U"
+        // update if exists
+      ],
+      { stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function macKeychainDelete(service) {
+  try {
+    execFileSync("security", ["delete-generic-password", "-a", KEYCHAIN_ACCOUNT, "-s", service], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function linuxSecretRead(key) {
+  try {
+    const result = execFileSync(
+      "secret-tool",
+      ["lookup", "service", KEYCHAIN_ACCOUNT, "key", key],
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function linuxSecretWrite(key, value) {
+  try {
+    execFileSync(
+      "secret-tool",
+      ["store", "--label", `Social Neuron ${key}`, "service", KEYCHAIN_ACCOUNT, "key", key],
+      { input: value, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function linuxSecretDelete(key) {
+  try {
+    execFileSync("secret-tool", ["clear", "service", KEYCHAIN_ACCOUNT, "key", key], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadApiKey() {
+  const envKey = process.env.SOCIALNEURON_API_KEY;
+  if (envKey) return envKey;
+  const os = platform();
+  if (os === "darwin") {
+    const key = macKeychainRead(KEYCHAIN_SERVICE_API);
+    if (key) return key;
+  } else if (os === "linux") {
+    const key = linuxSecretRead("api-key");
+    if (key) return key;
+  }
+  const creds = readCredentialsFile();
+  if (creds.apiKey && os === "win32") {
+    console.error(
+      "[MCP] Warning: Loading API key from file on Windows. For better security,\n  set SOCIALNEURON_API_KEY as an environment variable."
+    );
+  }
+  return creds.apiKey || null;
+}
+async function saveApiKey(key) {
+  const os = platform();
+  let saved = false;
+  if (os === "darwin") {
+    saved = macKeychainWrite(KEYCHAIN_SERVICE_API, key);
+  } else if (os === "linux") {
+    saved = linuxSecretWrite("api-key", key);
+  }
+  if (!saved) {
+    const creds = readCredentialsFile();
+    creds.apiKey = key;
+    writeCredentialsFile(creds);
+    if (os === "win32") {
+      console.error(
+        `
+[MCP] WARNING: On Windows, credentials are stored in a local file:
+  ${CREDENTIALS_FILE}
+  NTFS does not enforce Unix-style file permissions (chmod 0600).
+  Other users on this machine may be able to read this file.
+
+  For better security, set the SOCIALNEURON_API_KEY environment variable instead:
+    set SOCIALNEURON_API_KEY=your_key_here
+  Or use: $env:SOCIALNEURON_API_KEY = "your_key_here" (PowerShell)
+`
+      );
+    } else {
+      console.error("[MCP] API key stored in file (keychain unavailable).");
+    }
+  }
+}
+async function deleteApiKey() {
+  const os = platform();
+  if (os === "darwin") {
+    macKeychainDelete(KEYCHAIN_SERVICE_API);
+  } else if (os === "linux") {
+    linuxSecretDelete("api-key");
+  }
+  const creds = readCredentialsFile();
+  if (creds.apiKey) {
+    delete creds.apiKey;
+    if (Object.keys(creds).length === 0) {
+      try {
+        unlinkSync(CREDENTIALS_FILE);
+      } catch {
+      }
+    } else {
+      writeCredentialsFile(creds);
+    }
+  }
+}
+async function loadSupabaseUrl() {
+  const envUrl = process.env.SOCIALNEURON_SUPABASE_URL || process.env.SUPABASE_URL;
+  if (envUrl) return envUrl;
+  const os = platform();
+  if (os === "darwin") {
+    const url = macKeychainRead(KEYCHAIN_SERVICE_URL);
+    if (url) return url;
+  } else if (os === "linux") {
+    const url = linuxSecretRead("supabase-url");
+    if (url) return url;
+  }
+  const creds = readCredentialsFile();
+  return creds.supabaseUrl || null;
+}
+async function saveSupabaseUrl(url) {
+  const os = platform();
+  let saved = false;
+  if (os === "darwin") {
+    saved = macKeychainWrite(KEYCHAIN_SERVICE_URL, url);
+  } else if (os === "linux") {
+    saved = linuxSecretWrite("supabase-url", url);
+  }
+  if (!saved) {
+    const creds = readCredentialsFile();
+    creds.supabaseUrl = url;
+    writeCredentialsFile(creds);
+  }
+}
+var KEYCHAIN_ACCOUNT, KEYCHAIN_SERVICE_API, KEYCHAIN_SERVICE_URL, CONFIG_DIR, CREDENTIALS_FILE;
+var init_credentials = __esm({
+  "src/cli/credentials.ts"() {
+    "use strict";
+    KEYCHAIN_ACCOUNT = "socialneuron";
+    KEYCHAIN_SERVICE_API = "socialneuron-api-key";
+    KEYCHAIN_SERVICE_URL = "socialneuron-supabase-url";
+    CONFIG_DIR = join(homedir(), ".config", "social-neuron");
+    CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
+  }
+});
+
+// src/auth/api-keys.ts
+var api_keys_exports = {};
+__export(api_keys_exports, {
+  validateApiKey: () => validateApiKey
+});
+async function validateApiKey(apiKey, _attempt = 0) {
+  const supabaseUrl = getSupabaseUrl();
+  try {
+    const anonKey = process.env.SUPABASE_ANON_KEY || process.env.SOCIALNEURON_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY || CLOUD_SUPABASE_ANON_KEY;
+    const response = await fetch(
+      `${supabaseUrl}/functions/v1/mcp-auth?action=validate-key-public`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${anonKey}`
+        },
+        body: JSON.stringify({ api_key: apiKey })
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      const retryable = response.status === 429 || response.status >= 500;
+      if (retryable && _attempt < VALIDATE_MAX_RETRIES) {
+        await sleep(300 * (_attempt + 1));
+        return validateApiKey(apiKey, _attempt + 1);
+      }
+      return {
+        valid: false,
+        retryable,
+        error: `Validation failed (HTTP ${response.status}): ${text}`
+      };
+    }
+    return await response.json();
+  } catch (err) {
+    if (_attempt < VALIDATE_MAX_RETRIES) {
+      await sleep(300 * (_attempt + 1));
+      return validateApiKey(apiKey, _attempt + 1);
+    }
+    return {
+      valid: false,
+      retryable: true,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+var VALIDATE_MAX_RETRIES, sleep;
+var init_api_keys = __esm({
+  "src/auth/api-keys.ts"() {
+    "use strict";
+    init_supabase();
+    VALIDATE_MAX_RETRIES = 2;
+    sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  }
+});
+
+// src/lib/posthog.ts
+var posthog_exports = {};
+__export(posthog_exports, {
+  captureToolEvent: () => captureToolEvent,
+  initPostHog: () => initPostHog,
+  shutdownPostHog: () => shutdownPostHog
+});
+import { createHash } from "node:crypto";
+import { PostHog } from "posthog-node";
+function hashUserId(userId) {
+  return createHash("sha256").update(`${POSTHOG_SALT}:${userId}`).digest("hex").substring(0, 32);
+}
+function initPostHog() {
+  if (isTelemetryDisabled()) return;
+  const key = process.env.POSTHOG_KEY || process.env.VITE_POSTHOG_KEY;
+  const host = process.env.POSTHOG_HOST || process.env.VITE_POSTHOG_HOST || "https://eu.i.posthog.com";
+  if (!key) return;
+  client = new PostHog(key, { host, flushAt: 5, flushInterval: 1e4 });
+}
+async function captureToolEvent(args) {
+  if (!client) return;
+  let userId;
+  try {
+    userId = await getDefaultUserId();
+  } catch {
+    userId = "anonymous_mcp";
+  }
+  client.capture({
+    distinctId: hashUserId(userId),
+    event: `mcp_tool_${args.status}`,
+    properties: {
+      tool_name: args.toolName,
+      duration_ms: args.durationMs,
+      ...args.details
+    }
+  });
+}
+async function shutdownPostHog() {
+  if (client) {
+    await client.shutdown();
+    client = null;
+  }
+}
+var POSTHOG_SALT, client;
+var init_posthog = __esm({
+  "src/lib/posthog.ts"() {
+    "use strict";
+    init_supabase();
+    POSTHOG_SALT = "socialneuron-mcp-ph-v1";
+    client = null;
+  }
+});
+
+// src/lib/supabase.ts
+var supabase_exports = {};
+__export(supabase_exports, {
+  CLOUD_SUPABASE_ANON_KEY: () => CLOUD_SUPABASE_ANON_KEY,
+  CLOUD_SUPABASE_URL: () => CLOUD_SUPABASE_URL,
+  getAuthMode: () => getAuthMode,
+  getAuthenticatedApiKey: () => getAuthenticatedApiKey,
+  getAuthenticatedEmail: () => getAuthenticatedEmail,
+  getAuthenticatedExpiresAt: () => getAuthenticatedExpiresAt,
+  getAuthenticatedScopes: () => getAuthenticatedScopes,
+  getDefaultProjectId: () => getDefaultProjectId,
+  getDefaultUserId: () => getDefaultUserId,
+  getMcpRunId: () => getMcpRunId,
+  getServiceKey: () => getServiceKey,
+  getSupabaseClient: () => getSupabaseClient,
+  getSupabaseUrl: () => getSupabaseUrl,
+  initializeAuth: () => initializeAuth,
+  isTelemetryDisabled: () => isTelemetryDisabled,
+  logMcpToolInvocation: () => logMcpToolInvocation
+});
+import { createClient } from "@supabase/supabase-js";
+import { randomUUID } from "node:crypto";
+function getSupabaseClient() {
+  if (!client2) {
+    const url = SUPABASE_URL || getSupabaseUrl();
+    if (!SUPABASE_SERVICE_KEY) {
+      throw new Error(
+        "Missing Supabase service key. Set SOCIALNEURON_SERVICE_KEY or SUPABASE_SERVICE_ROLE_KEY."
+      );
+    }
+    client2 = createClient(url, SUPABASE_SERVICE_KEY);
+  }
+  return client2;
+}
+function getSupabaseUrl() {
+  if (SUPABASE_URL) return SUPABASE_URL;
+  const cloudOverride = process.env.SOCIALNEURON_CLOUD_SUPABASE_URL;
+  if (cloudOverride) return cloudOverride;
+  return CLOUD_SUPABASE_URL;
+}
+function getServiceKey() {
+  if (!SUPABASE_SERVICE_KEY) {
+    throw new Error(
+      "Missing service key. Set SOCIALNEURON_SERVICE_KEY or SUPABASE_SERVICE_ROLE_KEY."
+    );
+  }
+  return SUPABASE_SERVICE_KEY;
+}
+function getServiceKeyOrNull() {
+  return SUPABASE_SERVICE_KEY || null;
+}
+async function getDefaultUserId() {
+  const requestUserId = getRequestUserId();
+  if (requestUserId) return requestUserId;
+  if (authenticatedUserId) return authenticatedUserId;
+  const envUserId = process.env.SOCIALNEURON_USER_ID;
+  if (envUserId) return envUserId;
+  throw new Error("No user ID available. Set SOCIALNEURON_USER_ID or authenticate via API key.");
+}
+async function getDefaultProjectId() {
+  const userId = await getDefaultUserId().catch(() => null);
+  if (userId) {
+    const cached = projectIdCache.get(userId);
+    if (cached) return cached;
+  }
+  const envProjectId = process.env.SOCIALNEURON_PROJECT_ID;
+  if (envProjectId) {
+    if (userId) projectIdCache.set(userId, envProjectId);
+    return envProjectId;
+  }
+  if (!userId) return null;
+  try {
+    const supabase = getSupabaseClient();
+    const { data: memberships } = await supabase.from("organization_members").select("organization_id").eq("user_id", userId);
+    const orgIds = (memberships ?? []).map((m) => m.organization_id);
+    if (orgIds.length === 0) return null;
+    const { data } = await supabase.from("projects").select("id").in("organization_id", orgIds).order("created_at", { ascending: false }).limit(1).maybeSingle();
+    if (data?.id) {
+      projectIdCache.set(userId, data.id);
+      return data.id;
+    }
+  } catch {
+  }
+  return null;
+}
+async function initializeAuth() {
+  const { loadApiKey: loadApiKey2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const apiKey = await loadApiKey2();
+  if (apiKey) {
+    authenticatedApiKey = apiKey;
+    const _quietAuth = !process.argv.includes("--verbose") && (process.env.SN_CLI_QUIET === "1" || ["setup", "login", "logout", "whoami", "health", "sn", "repl"].includes(
+      process.argv[2] ?? ""
+    ));
+    const { validateApiKey: validateApiKey2 } = await Promise.resolve().then(() => (init_api_keys(), api_keys_exports));
+    const result = await validateApiKey2(apiKey);
+    if (result.valid && result.userId) {
+      _authMode = "api-key";
+      authenticatedUserId = result.userId;
+      authenticatedScopes = result.scopes && result.scopes.length > 0 ? result.scopes : ["mcp:read"];
+      authenticatedEmail = result.email || null;
+      authenticatedExpiresAt = result.expiresAt || null;
+      if (!_quietAuth) {
+        console.error(
+          "[MCP] Authenticated via API key (prefix: " + apiKey.substring(0, 6) + "..." + apiKey.slice(-4) + ")"
+        );
+        console.error("[MCP] Scopes: " + authenticatedScopes.join(", "));
+      }
+      if (authenticatedExpiresAt) {
+        const expiresMs = new Date(authenticatedExpiresAt).getTime();
+        const daysLeft = Math.ceil((expiresMs - Date.now()) / (1e3 * 60 * 60 * 24));
+        if (!_quietAuth) console.error("[MCP] Key expires: " + authenticatedExpiresAt);
+        if (daysLeft <= 7) {
+          console.error(
+            `[MCP] Warning: API key expires in ${daysLeft} day(s). Run: npx @socialneuron/mcp-server login`
+          );
+        }
+      }
+      return;
+    } else {
+      authenticatedApiKey = null;
+      if (result.retryable) {
+        throw new Error(
+          "Temporary issue reaching the auth service \u2014 your session is likely still valid. Wait a moment and retry. If it persists, run `sn login`."
+        );
+      }
+      throw new Error(
+        "API key invalid, expired, or revoked. Run `sn login` to reconnect (or `socialneuron-mcp login`)."
+      );
+    }
+  }
+  if (getServiceKeyOrNull()) {
+    throw new Error(
+      "[MCP] Fatal: Legacy service-role auth is disabled for the public MCP package.\n[MCP] Remove SOCIALNEURON_SERVICE_KEY / SUPABASE_SERVICE_ROLE_KEY from this client and run:\n[MCP]   npx @socialneuron/mcp-server login"
+    );
+  }
+  throw new Error(
+    "[MCP] Fatal: No API key configured. Run: npx @socialneuron/mcp-server login\n[MCP] Requires a paid plan (Starter+). See: https://socialneuron.com/pricing"
+  );
+}
+function getMcpRunId() {
+  return MCP_RUN_ID;
+}
+function getAuthenticatedScopes() {
+  return authenticatedScopes;
+}
+function getAuthenticatedEmail() {
+  return authenticatedEmail;
+}
+function getAuthenticatedExpiresAt() {
+  return authenticatedExpiresAt;
+}
+function getAuthMode() {
+  return _authMode;
+}
+function getAuthenticatedApiKey() {
+  return authenticatedApiKey;
+}
+function isTelemetryDisabled() {
+  return process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true" || process.env.SOCIALNEURON_NO_TELEMETRY === "1";
+}
+async function logMcpToolInvocation(args) {
+  if (isTelemetryDisabled()) return;
+  let userId = null;
+  try {
+    userId = await getDefaultUserId();
+  } catch {
+    userId = null;
+  }
+  const details = {
+    runId: MCP_RUN_ID,
+    authMode: _authMode,
+    durationMs: args.durationMs,
+    ...args.details ?? {}
+  };
+  try {
+    await getSupabaseClient().from("activity_logs").insert({
+      user_id: userId,
+      action_type: `mcp_tool_${args.status}`,
+      entity_type: "mcp_tool",
+      details
+    });
+  } catch {
+  }
+  Promise.resolve().then(() => (init_posthog(), posthog_exports)).then(({ captureToolEvent: captureToolEvent2 }) => captureToolEvent2(args)).catch(() => {
+  });
+}
+var SUPABASE_URL, SUPABASE_SERVICE_KEY, client2, _authMode, authenticatedUserId, authenticatedScopes, authenticatedEmail, authenticatedExpiresAt, authenticatedApiKey, MCP_RUN_ID, CLOUD_SUPABASE_URL, CLOUD_SUPABASE_ANON_KEY, projectIdCache;
+var init_supabase = __esm({
+  "src/lib/supabase.ts"() {
+    "use strict";
+    init_request_context();
+    SUPABASE_URL = process.env.SOCIALNEURON_SUPABASE_URL || process.env.SUPABASE_URL || "";
+    SUPABASE_SERVICE_KEY = process.env.SOCIALNEURON_SERVICE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY || "";
+    client2 = null;
+    _authMode = "unauthenticated";
+    authenticatedUserId = null;
+    authenticatedScopes = [];
+    authenticatedEmail = null;
+    authenticatedExpiresAt = null;
+    authenticatedApiKey = null;
+    MCP_RUN_ID = randomUUID();
+    CLOUD_SUPABASE_URL = "https://rhukkjscgzauutioyeei.supabase.co";
+    CLOUD_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InJodWtranNjZ3phdXV0aW95ZWVpIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjQ4NjM4ODYsImV4cCI6MjA4MDQzOTg4Nn0.JVtrviGvN0HaSh0JFS5KNl5FAB5ffG5Y1IMZsQFUrNQ";
+    projectIdCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/cli/sn/parse.ts
+import { createHash as createHash2 } from "node:crypto";
+function parseSnArgs(argv) {
+  const parsed = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith("--")) {
+      parsed._.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      parsed[key] = true;
+      continue;
+    }
+    parsed[key] = next;
+    i += 1;
+  }
+  return parsed;
+}
+function isEnabledFlag(value) {
+  if (value === true) return true;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+  }
+  return false;
+}
+function emitSnResult(payload, asJson) {
+  if (asJson) {
+    const envelope = { schema_version: "1", ...payload };
+    process.stdout.write(JSON.stringify(envelope, null, 2) + "\n");
+  }
+}
+function isValidHttpsUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function checkUrlReachability(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 8e3);
+  try {
+    const head = await fetch(url, {
+      method: "HEAD",
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (head.ok) {
+      return { ok: true, status: head.status };
+    }
+    if (head.status === 405 || head.status === 501) {
+      const get = await fetch(url, {
+        method: "GET",
+        redirect: "follow",
+        signal: controller.signal
+      });
+      return { ok: get.ok, status: get.status };
+    }
+    return { ok: false, status: head.status };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function classifySupabaseCliError(operation, error) {
+  const rawMessage = typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : String(error ?? "Unknown error");
+  const lower = rawMessage.toLowerCase();
+  let hint;
+  if (lower.includes("legacy api keys are disabled")) {
+    hint = "Your Supabase project no longer accepts legacy JWT keys. Regenerate and update SUPABASE_SERVICE_ROLE_KEY (and frontend anon/publishable keys) from Supabase API settings.";
+  } else if (lower.includes("fetch failed") || lower.includes("network")) {
+    hint = "Unable to reach Supabase from this runtime. Check outbound network access, DNS, firewall, and SUPABASE_URL.";
+  } else if (lower.includes("invalid api key") || lower.includes("jwt") || lower.includes("invalid signature") || lower.includes("unauthorized")) {
+    hint = "Supabase credentials appear invalid for this project. Verify SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY match.";
+  }
+  return {
+    message: `Failed to ${operation}: ${rawMessage}`,
+    hint
+  };
+}
+function buildPublishIdempotencyKey(input) {
+  const material = JSON.stringify({
+    mediaUrl: input.mediaUrl,
+    caption: input.caption,
+    platforms: [...input.platforms].sort(),
+    title: input.title ?? "",
+    scheduledAt: input.scheduledAt ?? ""
+  });
+  return `sn_${createHash2("sha256").update(material).digest("hex").slice(0, 24)}`;
+}
+function normalizePlatforms(platformsRaw) {
+  const caseMap = {
+    youtube: "YouTube",
+    tiktok: "TikTok",
+    instagram: "Instagram",
+    twitter: "Twitter",
+    linkedin: "LinkedIn",
+    facebook: "Facebook",
+    threads: "Threads",
+    bluesky: "Bluesky"
+  };
+  return platformsRaw.split(",").map((p) => p.trim().toLowerCase()).filter(Boolean).map((p) => caseMap[p] ?? p);
+}
+function tryGetSupabaseClient() {
+  try {
+    return getSupabaseClient();
+  } catch {
+    return null;
+  }
+}
+var init_parse = __esm({
+  "src/cli/sn/parse.ts"() {
+    "use strict";
+    init_supabase();
+  }
+});
+
+// src/cli/error-handling.ts
+function classifyError(err) {
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : String(err ?? "Unknown error");
+  const lower = message.toLowerCase();
+  if (lower.includes("no authentication") || lower.includes("unauthorized") || lower.includes("api key invalid") || lower.includes("expired") || lower.includes("not logged in") || lower.includes("invalid api key") || lower.includes("invalid signature")) {
+    return {
+      message,
+      errorType: "AUTH",
+      retryable: false,
+      hint: "Run: npx @socialneuron/mcp-server login \u2014 Requires a paid plan (Starter+). See https://socialneuron.com/pricing"
+    };
+  }
+  if (lower.includes("econnrefused") || lower.includes("etimedout") || lower.includes("fetch failed") || lower.includes("aborterror") || lower.includes("network") || lower.includes("dns") || lower.includes("temporary issue")) {
+    return {
+      message,
+      errorType: "NETWORK",
+      retryable: true,
+      hint: "Check your network connection and try again."
+    };
+  }
+  if (lower.includes("rate limit") || lower.includes("429") || lower.includes("too many requests")) {
+    return {
+      message,
+      errorType: "RATE_LIMIT",
+      retryable: true,
+      hint: "Wait a moment and retry."
+    };
+  }
+  if (lower.includes("not found") || lower.includes("404") || lower.includes("no job found")) {
+    return { message, errorType: "NOT_FOUND", retryable: false };
+  }
+  if (lower.includes("missing required") || lower.includes("invalid") || lower.includes("cannot delete builtin")) {
+    return { message, errorType: "VALIDATION", retryable: false };
+  }
+  return { message, errorType: "INTERNAL", retryable: true };
+}
+async function withSnErrorHandling(command, asJson, fn, replMode = false) {
+  try {
+    await fn();
+  } catch (err) {
+    const classified = classifyError(err);
+    if (asJson) {
+      const response = {
+        ok: false,
+        command,
+        error: classified.message,
+        errorType: classified.errorType,
+        retryable: classified.retryable,
+        ...classified.hint ? { hint: classified.hint } : {},
+        schema_version: "1"
+      };
+      process.stdout.write(JSON.stringify(response, null, 2) + "\n");
+    } else {
+      process.stderr.write(`Error [${command}]: ${classified.message}
+`);
+      if (classified.hint) process.stderr.write(`Hint: ${classified.hint}
+`);
+    }
+    if (!replMode) {
+      process.exit(1);
+    }
+  }
+}
+var init_error_handling = __esm({
+  "src/cli/error-handling.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/edge-function.ts
+var edge_function_exports = {};
+__export(edge_function_exports, {
+  callEdgeFunction: () => callEdgeFunction
+});
+function getApiKeyOrNull() {
+  const envKey = process.env.SOCIALNEURON_API_KEY;
+  if (envKey && envKey.trim().length) return envKey.trim();
+  const requestToken = getRequestToken();
+  if (requestToken) return requestToken;
+  return getAuthenticatedApiKey();
+}
+async function callEdgeFunction(functionName, body, options) {
+  const supabaseUrl = getSupabaseUrl();
+  const apiKey = getApiKeyOrNull();
+  const controller = new AbortController();
+  const timeoutMs = options?.timeoutMs ?? 6e4;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const enrichedBody = { ...body };
+  if (!enrichedBody.userId && !enrichedBody.user_id) {
+    try {
+      const defaultId = await getDefaultUserId();
+      enrichedBody.userId = defaultId;
+      enrichedBody.user_id = defaultId;
+    } catch {
+    }
+  } else {
+    if (enrichedBody.userId && !enrichedBody.user_id) enrichedBody.user_id = enrichedBody.userId;
+    if (enrichedBody.user_id && !enrichedBody.userId) enrichedBody.userId = enrichedBody.user_id;
+  }
+  if (!enrichedBody.projectId && !enrichedBody.project_id) {
+    try {
+      const { getDefaultProjectId: getDefaultProjectId2 } = await Promise.resolve().then(() => (init_supabase(), supabase_exports));
+      const defaultProjectId = await getDefaultProjectId2();
+      if (defaultProjectId) {
+        enrichedBody.projectId = defaultProjectId;
+        enrichedBody.project_id = defaultProjectId;
+      }
+    } catch {
+    }
+  }
+  let url;
+  let method = options?.method ?? "POST";
+  let headers;
+  let requestBody;
+  if (!apiKey) {
+    clearTimeout(timer);
+    return {
+      data: null,
+      error: "Not authenticated. Run: npx @socialneuron/mcp-server login \u2014 Requires a paid plan (Starter+). See https://socialneuron.com/pricing"
+    };
+  }
+  url = new URL(`${supabaseUrl}/functions/v1/mcp-gateway`);
+  headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  requestBody = {
+    functionName,
+    body: enrichedBody,
+    query: options?.query,
+    method: method.toUpperCase(),
+    timeoutMs
+  };
+  method = "POST";
+  try {
+    const response = await fetch(url.toString(), {
+      method,
+      headers,
+      body: method === "GET" ? void 0 : JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    const responseText = await response.text();
+    if (!response.ok) {
+      let errorMessage;
+      try {
+        const errorJson = JSON.parse(responseText);
+        errorMessage = errorJson.error || errorJson.message || responseText;
+      } catch {
+        errorMessage = responseText || `HTTP ${response.status}`;
+      }
+      if (response.status === 401) {
+        return {
+          data: null,
+          error: `Authentication failed (HTTP 401). Run 'npx @socialneuron/mcp-server login' to re-authenticate.`
+        };
+      }
+      if (response.status === 403) {
+        return {
+          data: null,
+          error: `Forbidden (HTTP 403): ${errorMessage}. This action isn't permitted for your account, plan, or scope \u2014 your connection is still valid.`
+        };
+      }
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after") || "60";
+        return {
+          data: null,
+          error: `Rate limit exceeded (HTTP 429). Wait ${retryAfter}s before retrying. Reduce request frequency or upgrade your plan.`
+        };
+      }
+      return { data: null, error: errorMessage };
+    }
+    try {
+      const data = JSON.parse(responseText);
+      return { data, error: null };
+    } catch {
+      return { data: { text: responseText }, error: null };
+    }
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return {
+        data: null,
+        error: `Edge Function '${functionName}' timed out after ${timeoutMs}ms`
+      };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return { data: null, error: message };
+  }
+}
+var init_edge_function = __esm({
+  "src/lib/edge-function.ts"() {
+    "use strict";
+    init_supabase();
+    init_request_context();
+  }
+});
+
+// src/lib/quality.ts
+function countHashtags(text) {
+  const matches = text.match(/(^|\s)#[A-Za-z0-9_]+/g);
+  return matches ? matches.length : 0;
+}
+function evaluateQuality(input) {
+  const caption = input.caption.trim();
+  const title = (input.title ?? "").trim();
+  const platforms = input.platforms.map((p) => p.toLowerCase());
+  const firstLine = caption.split("\n")[0]?.trim() ?? "";
+  const hashtags = countHashtags(caption);
+  const threshold = Math.min(35, Math.max(0, input.threshold ?? 26));
+  const blockedTerms = [
+    ...(input.brandAvoidPatterns ?? []).map((t) => t.trim()).filter(Boolean),
+    ...(input.customBannedTerms ?? []).map((t) => t.trim()).filter(Boolean)
+  ];
+  const categories = [];
+  let hookScore = 2;
+  if (firstLine.length >= 20 && firstLine.length <= 120) hookScore += 1;
+  if (/[!?]/.test(firstLine) || /\b\d+(\.\d+)?\b/.test(firstLine)) hookScore += 1;
+  if (/\b(how|why|stop|avoid|build|launch|scale|grow|mistake)\b/i.test(firstLine)) hookScore += 1;
+  categories.push({
+    name: "Hook Strength",
+    score: Math.min(5, hookScore),
+    maxScore: 5,
+    detail: "First line should create curiosity/value within 120 chars."
+  });
+  let clarityScore = 2;
+  if (caption.length >= 80 && caption.length <= 1200) clarityScore += 2;
+  if (title.length > 0 && title.length <= 120) clarityScore += 1;
+  categories.push({
+    name: "Message Clarity",
+    score: Math.min(5, clarityScore),
+    maxScore: 5,
+    detail: "Single clear takeaway with concise wording."
+  });
+  let platformScore = 3;
+  const isLinkedIn = platforms.includes("linkedin");
+  const isTwitter = platforms.includes("twitter");
+  const isYoutube = platforms.includes("youtube");
+  if (isTwitter && caption.length > 560) platformScore -= 1;
+  if (isLinkedIn && caption.length < 120) platformScore -= 1;
+  if (hashtags > 6) platformScore -= 1;
+  if (isYoutube && title.length === 0) platformScore -= 1;
+  categories.push({
+    name: "Platform Fit",
+    score: Math.max(0, Math.min(5, platformScore)),
+    maxScore: 5,
+    detail: "Length, title, and hashtag usage should match target platforms."
+  });
+  let brandScore = 3;
+  const brandKeyword = input.brandKeyword ?? process.env.SOCIALNEURON_BRAND_KEYWORD?.trim();
+  if (brandKeyword && new RegExp("\\b" + brandKeyword + "\\b", "i").test(title + " " + caption))
+    brandScore += 1;
+  if (!/\b(you|your|customer|audience)\b/i.test(caption)) brandScore -= 1;
+  if (blockedTerms.length > 0) {
+    const lowerCombined = `${title} ${caption}`.toLowerCase();
+    const matched = blockedTerms.filter((term) => lowerCombined.includes(term.toLowerCase()));
+    if (matched.length > 0) {
+      brandScore -= Math.min(2, matched.length);
+    }
+  }
+  categories.push({
+    name: "Brand Alignment",
+    score: Math.max(0, Math.min(5, brandScore)),
+    maxScore: 5,
+    detail: "Voice should match brand context and audience focus."
+  });
+  let noveltyScore = 2;
+  if (/\b(case study|framework|workflow|playbook|breakdown|behind the scenes)\b/i.test(caption))
+    noveltyScore += 2;
+  if (/\b(ai-generated|revolutionary|game changer)\b/i.test(caption)) noveltyScore -= 1;
+  if (blockedTerms.length > 0) {
+    const lowerCombined = `${title} ${caption}`.toLowerCase();
+    const matched = blockedTerms.filter((term) => lowerCombined.includes(term.toLowerCase()));
+    if (matched.length > 0) noveltyScore -= Math.min(2, matched.length);
+  }
+  categories.push({
+    name: "Novelty",
+    score: Math.max(0, Math.min(5, noveltyScore)),
+    maxScore: 5,
+    detail: "Avoid generic phrasing; include distinct angle."
+  });
+  let ctaScore = 2;
+  if (/\b(comment|reply|share|save|follow|subscribe|click|try|book|download)\b/i.test(caption))
+    ctaScore += 2;
+  if (/\?$/.test(firstLine)) ctaScore += 1;
+  categories.push({
+    name: "CTA Strength",
+    score: Math.min(5, ctaScore),
+    maxScore: 5,
+    detail: "Should include a clear next action."
+  });
+  let safetyScore = 5;
+  if (/\b(guarantee|guaranteed|no risk|risk-free|always works|100%)\b/i.test(caption))
+    safetyScore -= 2;
+  if (/\b(cure|diagnose|treat)\b/i.test(caption)) safetyScore -= 2;
+  categories.push({
+    name: "Safety/Claims",
+    score: Math.max(0, Math.min(5, safetyScore)),
+    maxScore: 5,
+    detail: "Avoid unverifiable or risky claims."
+  });
+  const total = categories.reduce((sum, c) => sum + c.score, 0);
+  const blockers = categories.filter((c) => c.score < 3).map((c) => c.name + " below threshold (" + c.score + "/5)");
+  if (blockedTerms.length > 0) {
+    const lowerCombined = `${title} ${caption}`.toLowerCase();
+    const matched = blockedTerms.filter((term) => lowerCombined.includes(term.toLowerCase()));
+    for (const term of matched) {
+      blockers.push(`Contains blocked term: "${term}"`);
+    }
+  }
+  return {
+    threshold,
+    total,
+    maxTotal: 35,
+    categories,
+    blockers,
+    passed: total >= threshold && blockers.length === 0
+  };
+}
+var init_quality = __esm({
+  "src/lib/quality.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/sn/content.ts
+var content_exports = {};
+__export(content_exports, {
+  handleE2e: () => handleE2e,
+  handlePublish: () => handlePublish,
+  handleQualityCheck: () => handleQualityCheck
+});
+async function ensureAuth() {
+  await initializeAuth();
+  return getDefaultUserId();
+}
+async function handlePublish(args, asJson) {
+  const mediaUrl = args["media-url"];
+  const caption = args.caption;
+  const platformsRaw = args.platforms;
+  if (typeof mediaUrl !== "string" || typeof caption !== "string" || typeof platformsRaw !== "string") {
+    throw new Error("Missing required flags for publish: --media-url, --caption, --platforms");
+  }
+  const confirmed = isEnabledFlag(args.confirm);
+  if (!confirmed) {
+    throw new Error(
+      "Missing required flag: --confirm. Re-run with --confirm to execute schedule-post."
+    );
+  }
+  const platforms = normalizePlatforms(platformsRaw);
+  const title = typeof args.title === "string" ? args.title : void 0;
+  const scheduledAt = typeof args["schedule-at"] === "string" ? args["schedule-at"] : void 0;
+  const idempotencyKey = typeof args["idempotency-key"] === "string" ? args["idempotency-key"] : buildPublishIdempotencyKey({
+    mediaUrl,
+    caption,
+    platforms,
+    title,
+    scheduledAt
+  });
+  const userId = await ensureAuth();
+  const { data, error } = await callEdgeFunction("schedule-post", {
+    mediaUrl,
+    caption,
+    platforms,
+    title,
+    scheduledAt,
+    idempotencyKey,
+    userId
+  });
+  if (error || !data) {
+    throw new Error(`Publish failed: ${error ?? "Unknown error"}`);
+  }
+  if (asJson) {
+    emitSnResult(
+      {
+        ok: data.success,
+        command: "publish",
+        idempotencyKey,
+        scheduledAt: data.scheduledAt,
+        results: data.results
+      },
+      true
+    );
+  } else {
+    console.error(`Idempotency key: ${idempotencyKey}`);
+    console.error(`Scheduled for: ${data.scheduledAt}`);
+    for (const [platform3, result] of Object.entries(
+      data.results
+    )) {
+      if (result.success) {
+        console.error(`${platform3}: OK (jobId=${result.jobId}, postId=${result.postId})`);
+      } else {
+        console.error(`${platform3}: FAILED (${result.error})`);
+      }
+    }
+  }
+  process.exit(data.success ? 0 : 1);
+}
+async function handleQualityCheck(args, asJson) {
+  const caption = args.caption;
+  if (typeof caption !== "string") {
+    throw new Error("Missing required flag: --caption");
+  }
+  const title = typeof args.title === "string" ? args.title : void 0;
+  const platformsRaw = typeof args.platforms === "string" ? args.platforms : "youtube";
+  const platformsNormalized = normalizePlatforms(platformsRaw);
+  const thresholdRaw = typeof args.threshold === "string" ? Number(args.threshold) : void 0;
+  const quality = evaluateQuality({
+    caption,
+    title,
+    platforms: platformsNormalized,
+    threshold: Number.isFinite(thresholdRaw) ? thresholdRaw : void 0
+  });
+  const payload = {
+    ok: quality.passed,
+    command: "quality-check",
+    platforms: platformsNormalized,
+    threshold: quality.threshold,
+    score: quality.total,
+    maxScore: quality.maxTotal,
+    blockers: quality.blockers,
+    categories: quality.categories
+  };
+  if (asJson) {
+    emitSnResult(payload, true);
+  } else {
+    console.error(
+      "QUALITY SCORE: " + quality.total + "/" + quality.maxTotal + " (threshold " + quality.threshold + ")"
+    );
+    for (const c of quality.categories) {
+      console.error("- " + c.name + ": " + c.score + "/" + c.maxScore);
+    }
+    if (quality.blockers.length) {
+      console.error("Blockers: " + quality.blockers.join("; "));
+    }
+    console.error("Decision: " + (quality.passed ? "Publish-ready" : "Needs revision"));
+  }
+  process.exit(quality.passed ? 0 : 1);
+}
+async function handleE2e(args, asJson) {
+  const mediaUrl = args["media-url"];
+  const caption = args.caption;
+  const platformsRaw = args.platforms;
+  if (typeof mediaUrl !== "string" || typeof caption !== "string" || typeof platformsRaw !== "string") {
+    throw new Error("Missing required flags for e2e: --media-url, --caption, --platforms");
+  }
+  const title = typeof args.title === "string" ? args.title : void 0;
+  const scheduledAt = typeof args["schedule-at"] === "string" ? args["schedule-at"] : void 0;
+  const checkUrls = isEnabledFlag(args["check-urls"]);
+  const dryRun = isEnabledFlag(args["dry-run"]);
+  const force = isEnabledFlag(args.force);
+  const platformsNormalized = normalizePlatforms(platformsRaw);
+  const thresholdRaw = typeof args.threshold === "string" ? Number(args.threshold) : void 0;
+  const userId = await ensureAuth();
+  const supabase = tryGetSupabaseClient();
+  const privacyUrl = process.env.SOCIALNEURON_PRIVACY_POLICY_URL ?? null;
+  const termsUrl = process.env.SOCIALNEURON_TERMS_URL ?? null;
+  const preflightChecks = [];
+  preflightChecks.push({
+    name: "privacy_policy_url_present",
+    ok: Boolean(privacyUrl),
+    detail: privacyUrl ? privacyUrl : "Missing SOCIALNEURON_PRIVACY_POLICY_URL"
+  });
+  preflightChecks.push({
+    name: "terms_url_present",
+    ok: Boolean(termsUrl),
+    detail: termsUrl ? termsUrl : "Missing SOCIALNEURON_TERMS_URL"
+  });
+  if (checkUrls && privacyUrl && isValidHttpsUrl(privacyUrl)) {
+    const r = await checkUrlReachability(privacyUrl);
+    preflightChecks.push({
+      name: "privacy_policy_url_reachable",
+      ok: r.ok,
+      detail: r.ok ? "Reachable (HTTP " + (r.status ?? 200) + ")" : "Unreachable (" + (r.error ?? "HTTP " + (r.status ?? "unknown")) + ")"
+    });
+  }
+  if (checkUrls && termsUrl && isValidHttpsUrl(termsUrl)) {
+    const r = await checkUrlReachability(termsUrl);
+    preflightChecks.push({
+      name: "terms_url_reachable",
+      ok: r.ok,
+      detail: r.ok ? "Reachable (HTTP " + (r.status ?? 200) + ")" : "Unreachable (" + (r.error ?? "HTTP " + (r.status ?? "unknown")) + ")"
+    });
+  }
+  let activeAccounts = [];
+  if (supabase) {
+    const { data: accounts, error: accountsError } = await supabase.from("connected_accounts").select("platform, status, username, expires_at").eq("user_id", userId).eq("status", "active");
+    if (accountsError) {
+      const formatted = classifySupabaseCliError("load connected accounts", accountsError);
+      throw new Error(formatted.message);
+    }
+    activeAccounts = accounts ?? [];
+  } else {
+    const { data: data2, error: error2 } = await callEdgeFunction(
+      "mcp-data",
+      { action: "connected-accounts", userId }
+    );
+    if (error2 || !data2?.success) {
+      throw new Error("Failed to load connected accounts: " + (error2 ?? "Unknown error"));
+    }
+    activeAccounts = data2.accounts ?? [];
+  }
+  const expired = activeAccounts.filter(
+    (a) => a.expires_at && new Date(a.expires_at).getTime() <= Date.now()
+  );
+  preflightChecks.push({
+    name: "oauth_connections_present",
+    ok: activeAccounts.length > 0,
+    detail: activeAccounts.length ? activeAccounts.length + " active account(s)" : "No active connected_accounts found"
+  });
+  preflightChecks.push({
+    name: "oauth_tokens_not_expired",
+    ok: expired.length === 0,
+    detail: expired.length ? "Expired: " + expired.map((a) => a.platform).join(", ") : "No expired tokens detected"
+  });
+  const preflightOk = preflightChecks.every((c) => c.ok);
+  const quality = evaluateQuality({
+    caption,
+    title,
+    platforms: platformsNormalized,
+    threshold: Number.isFinite(thresholdRaw) ? thresholdRaw : void 0
+  });
+  const confirmed = isEnabledFlag(args.confirm);
+  const canPublish = confirmed && preflightOk && quality.passed;
+  const blockedReasons = [];
+  if (!preflightOk) blockedReasons.push("preflight_failed");
+  if (!quality.passed) blockedReasons.push("quality_failed");
+  if (!confirmed) blockedReasons.push("missing_confirm");
+  const report = {
+    ok: canPublish,
+    command: "e2e",
+    dryRun,
+    mediaUrl,
+    platforms: platformsNormalized,
+    scheduledAt: scheduledAt ?? null,
+    preflight: {
+      ok: preflightOk,
+      checks: preflightChecks,
+      connectedPlatforms: activeAccounts.map((a) => ({
+        platform: a.platform,
+        username: a.username,
+        expiresAt: a.expires_at
+      }))
+    },
+    quality: {
+      passed: quality.passed,
+      threshold: quality.threshold,
+      score: quality.total,
+      maxScore: quality.maxTotal,
+      blockers: quality.blockers,
+      categories: quality.categories
+    },
+    blockedReasons
+  };
+  if (dryRun || !canPublish && !force) {
+    if (asJson) {
+      emitSnResult(report, true);
+    } else {
+      console.error("E2E: " + (canPublish ? "READY" : "BLOCKED"));
+      console.error("Preflight: " + (preflightOk ? "PASS" : "FAIL"));
+      console.error(
+        "Quality: " + (quality.passed ? "PASS" : "FAIL") + " (" + quality.total + "/" + quality.maxTotal + ", threshold " + quality.threshold + ")"
+      );
+      if (blockedReasons.length) console.error("Blocked: " + blockedReasons.join(", "));
+      console.error(
+        "Use --dry-run for JSON output; use --force to publish despite blockers (not recommended)."
+      );
+    }
+    process.exit(canPublish ? 0 : 1);
+  }
+  const idempotencyKey = buildPublishIdempotencyKey({
+    mediaUrl,
+    caption,
+    platforms: platformsNormalized,
+    title,
+    scheduledAt
+  });
+  const { data, error } = await callEdgeFunction("schedule-post", {
+    mediaUrl,
+    caption,
+    platforms: platformsNormalized,
+    title,
+    scheduledAt,
+    idempotencyKey,
+    userId
+  });
+  if (error || !data) {
+    throw new Error("Publish failed: " + (error ?? "Unknown error"));
+  }
+  if (asJson) {
+    emitSnResult(
+      {
+        ok: data.success,
+        command: "e2e",
+        idempotencyKey,
+        scheduledAt: data.scheduledAt,
+        results: data.results,
+        report
+      },
+      true
+    );
+  } else {
+    console.error("E2E publish executed. Idempotency key: " + idempotencyKey);
+    console.error("Scheduled for: " + data.scheduledAt);
+    for (const [platform3, result] of Object.entries(data.results)) {
+      if (result.success)
+        console.error(platform3 + ": OK (jobId=" + result.jobId + ", postId=" + result.postId + ")");
+      else console.error(platform3 + ": FAILED (" + result.error + ")");
+    }
+  }
+  process.exit(data.success ? 0 : 1);
+}
+var init_content = __esm({
+  "src/cli/sn/content.ts"() {
+    "use strict";
+    init_edge_function();
+    init_quality();
+    init_supabase();
+    init_parse();
+  }
+});
+
+// src/cli/sn/account.ts
+var account_exports = {};
+__export(account_exports, {
+  handleOauthHealth: () => handleOauthHealth,
+  handleOauthRefresh: () => handleOauthRefresh,
+  handlePreflight: () => handlePreflight
+});
+async function ensureAuth2() {
+  await initializeAuth();
+  return getDefaultUserId();
+}
+async function handleOauthHealth(args, asJson) {
+  const userId = await ensureAuth2();
+  const supabase = tryGetSupabaseClient();
+  const warnDaysRaw = typeof args["warn-days"] === "string" ? Number(args["warn-days"]) : 7;
+  const warnDays = Number.isFinite(warnDaysRaw) && warnDaysRaw > 0 ? Math.min(warnDaysRaw, 90) : 7;
+  const includeAll = isEnabledFlag(args.all);
+  const platformsFilter = typeof args.platforms === "string" ? normalizePlatforms(args.platforms) : null;
+  let accounts = [];
+  if (supabase) {
+    let query = supabase.from("connected_accounts").select("platform, status, username, expires_at, refresh_token, updated_at, created_at").eq("user_id", userId).order("platform");
+    if (!includeAll) {
+      query = query.eq("status", "active");
+    }
+    const { data, error } = await query;
+    if (error) {
+      const formatted = classifySupabaseCliError("load oauth health", error);
+      throw new Error(formatted.message);
+    }
+    accounts = data ?? [];
+  } else {
+    const { data, error } = await callEdgeFunction(
+      "mcp-data",
+      {
+        action: "connected-accounts",
+        userId,
+        includeAll
+      }
+    );
+    if (error || !data?.success) {
+      throw new Error("Failed to load oauth health: " + (error ?? "Unknown error"));
+    }
+    accounts = data.accounts ?? [];
+  }
+  const now = Date.now();
+  const rows = (accounts ?? []).map((a) => {
+    const expiresAtMs = a.expires_at ? new Date(a.expires_at).getTime() : null;
+    const daysLeft = expiresAtMs ? Math.ceil((expiresAtMs - now) / (1e3 * 60 * 60 * 24)) : null;
+    const refreshTokenPresent = Boolean(a.refresh_token ?? a.has_refresh_token);
+    let state = "ok";
+    if (a.status && String(a.status).toLowerCase() !== "active") state = "inactive";
+    if (expiresAtMs && expiresAtMs <= now) state = "expired";
+    else if (daysLeft !== null && daysLeft <= warnDays) state = "expiring_soon";
+    if (!refreshTokenPresent && state === "ok") state = "missing_refresh_token";
+    return {
+      platform: a.platform,
+      username: a.username ?? null,
+      status: a.status,
+      expiresAt: a.expires_at ?? null,
+      daysLeft,
+      refreshTokenPresent,
+      state
+    };
+  });
+  const filtered = platformsFilter ? rows.filter(
+    (r) => platformsFilter.some(
+      (p) => p.toLowerCase() === String(r.platform ?? "").toLowerCase()
+    )
+  ) : rows;
+  const ok = filtered.every((r) => {
+    if (String(r.status).toLowerCase() !== "active") return false;
+    if (r.state === "expired") return false;
+    if (!r.refreshTokenPresent) return false;
+    return true;
+  });
+  const payload = {
+    ok,
+    command: "oauth-health",
+    warnDays,
+    accountCount: filtered.length,
+    accounts: filtered
+  };
+  if (asJson) {
+    emitSnResult(payload, true);
+  } else {
+    console.error("OAuth Health: " + (ok ? "PASS" : "WARN/FAIL"));
+    for (const row of filtered) {
+      const exp = row.daysLeft === null ? "n/a" : row.daysLeft + "d";
+      console.error(
+        String(row.platform).toLowerCase() + " | " + (row.username ?? "(unnamed)") + " | status=" + row.status + " | expires=" + exp + " | refresh=" + (row.refreshTokenPresent ? "yes" : "no") + " | state=" + row.state
+      );
+    }
+    if (!ok) {
+      console.error("");
+      console.error(
+        "Recommended: run oauth-refresh for expiring accounts, or reconnect expired/missing-refresh accounts."
+      );
+    }
+  }
+  process.exit(ok ? 0 : 1);
+}
+async function handleOauthRefresh(args, asJson) {
+  const userId = await ensureAuth2();
+  const supabase = tryGetSupabaseClient();
+  const includeAll = isEnabledFlag(args.all);
+  let platforms = [];
+  if (typeof args.platforms === "string") {
+    platforms = normalizePlatforms(args.platforms);
+  } else if (includeAll) {
+    if (supabase) {
+      const { data: accounts, error } = await supabase.from("connected_accounts").select("platform").eq("user_id", userId).eq("status", "active");
+      if (error) {
+        const formatted = classifySupabaseCliError("load connected accounts", error);
+        throw new Error(formatted.message);
+      }
+      platforms = (accounts ?? []).map((a) => String(a.platform));
+    } else {
+      const { data, error } = await callEdgeFunction(
+        "mcp-data",
+        {
+          action: "connected-accounts",
+          userId
+        }
+      );
+      if (error || !data?.success) {
+        throw new Error("Failed to load connected accounts: " + (error ?? "Unknown error"));
+      }
+      platforms = (data.accounts ?? []).map((a) => String(a.platform));
+    }
+  }
+  if (!platforms.length) {
+    throw new Error('Missing required flags: pass --platforms "youtube,tiktok" or --all');
+  }
+  const results = {};
+  for (const platform3 of platforms) {
+    const { data, error } = await callEdgeFunction(
+      "social-auth",
+      {},
+      { query: { action: "refresh", platform: platform3 }, timeoutMs: 3e4 }
+    );
+    if (error || !data?.success) {
+      results[platform3] = { ok: false, expiresAt: null, error: error ?? "Refresh failed" };
+    } else {
+      results[platform3] = { ok: true, expiresAt: data.expires_at ?? null };
+    }
+  }
+  const ok = Object.values(results).every((r) => r.ok);
+  if (asJson) {
+    emitSnResult({ ok, command: "oauth-refresh", results }, true);
+  } else {
+    console.error("OAuth refresh: " + (ok ? "OK" : "ERRORS"));
+    for (const platform3 of Object.keys(results)) {
+      const result = results[platform3];
+      if (result.ok) {
+        console.error(platform3 + " refreshed (expires_at=" + (result.expiresAt ?? "n/a") + ")");
+      } else {
+        console.error(platform3 + " FAILED (" + result.error + ")");
+      }
+    }
+  }
+  process.exit(ok ? 0 : 1);
+}
+async function handlePreflight(args, asJson) {
+  const userId = await ensureAuth2();
+  const supabase = tryGetSupabaseClient();
+  const privacyFromArg = typeof args["privacy-url"] === "string" ? args["privacy-url"] : null;
+  const termsFromArg = typeof args["terms-url"] === "string" ? args["terms-url"] : null;
+  const privacyUrl = privacyFromArg ?? process.env.SOCIALNEURON_PRIVACY_POLICY_URL ?? null;
+  const termsUrl = termsFromArg ?? process.env.SOCIALNEURON_TERMS_URL ?? null;
+  const checkUrls = isEnabledFlag(args["check-urls"]);
+  const creditCapRaw = process.env.SOCIALNEURON_MAX_CREDITS_PER_RUN ?? "";
+  const assetCapRaw = process.env.SOCIALNEURON_MAX_ASSETS_PER_RUN ?? "";
+  const creditCap = Number(creditCapRaw);
+  const assetCap = Number(assetCapRaw);
+  const checks = [];
+  checks.push({
+    name: "privacy_policy_url_present",
+    ok: Boolean(privacyUrl),
+    detail: privacyUrl ? privacyUrl : "Missing SOCIALNEURON_PRIVACY_POLICY_URL"
+  });
+  checks.push({
+    name: "terms_url_present",
+    ok: Boolean(termsUrl),
+    detail: termsUrl ? termsUrl : "Missing SOCIALNEURON_TERMS_URL"
+  });
+  if (privacyUrl) {
+    checks.push({
+      name: "privacy_policy_url_https",
+      ok: isValidHttpsUrl(privacyUrl),
+      detail: isValidHttpsUrl(privacyUrl) ? "Uses HTTPS" : "Privacy Policy URL must be a valid https:// URL"
+    });
+  }
+  if (termsUrl) {
+    checks.push({
+      name: "terms_url_https",
+      ok: isValidHttpsUrl(termsUrl),
+      detail: isValidHttpsUrl(termsUrl) ? "Uses HTTPS" : "Terms URL must be a valid https:// URL"
+    });
+  }
+  if (checkUrls && privacyUrl && isValidHttpsUrl(privacyUrl)) {
+    const result = await checkUrlReachability(privacyUrl);
+    checks.push({
+      name: "privacy_policy_url_reachable",
+      ok: result.ok,
+      detail: result.ok ? `Reachable (HTTP ${result.status ?? 200})` : `Unreachable (${result.error ?? `HTTP ${result.status ?? "unknown"}`})`
+    });
+  }
+  if (checkUrls && termsUrl && isValidHttpsUrl(termsUrl)) {
+    const result = await checkUrlReachability(termsUrl);
+    checks.push({
+      name: "terms_url_reachable",
+      ok: result.ok,
+      detail: result.ok ? `Reachable (HTTP ${result.status ?? 200})` : `Unreachable (${result.error ?? `HTTP ${result.status ?? "unknown"}`})`
+    });
+  }
+  checks.push({
+    name: "max_credits_per_run_configured",
+    ok: Number.isFinite(creditCap) && creditCap > 0,
+    detail: Number.isFinite(creditCap) && creditCap > 0 ? `${creditCap} credits cap` : "Set SOCIALNEURON_MAX_CREDITS_PER_RUN to a positive number"
+  });
+  checks.push({
+    name: "max_assets_per_run_configured",
+    ok: Number.isFinite(assetCap) && assetCap > 0,
+    detail: Number.isFinite(assetCap) && assetCap > 0 ? `${assetCap} assets cap` : "Set SOCIALNEURON_MAX_ASSETS_PER_RUN to a positive number"
+  });
+  let activeAccounts = [];
+  if (supabase) {
+    const { data: accounts, error: accountsError } = await supabase.from("connected_accounts").select("platform, status, username, expires_at").eq("user_id", userId).eq("status", "active").order("platform");
+    if (accountsError) {
+      const formatted = classifySupabaseCliError("load connected accounts", accountsError);
+      throw new Error(formatted.message);
+    }
+    activeAccounts = accounts ?? [];
+  } else {
+    const { data, error } = await callEdgeFunction(
+      "mcp-data",
+      { action: "connected-accounts", userId }
+    );
+    if (error || !data?.success) {
+      throw new Error("Failed to load connected accounts: " + (error ?? "Unknown error"));
+    }
+    activeAccounts = data.accounts ?? [];
+  }
+  const expiredAccounts = activeAccounts.filter((account) => {
+    if (!account.expires_at) return false;
+    const expiresAt = new Date(account.expires_at);
+    return Number.isFinite(expiresAt.getTime()) && expiresAt.getTime() <= Date.now();
+  });
+  checks.push({
+    name: "oauth_connections_present",
+    ok: activeAccounts.length > 0,
+    detail: activeAccounts.length > 0 ? `${activeAccounts.length} active account(s)` : "No active connected_accounts found"
+  });
+  checks.push({
+    name: "oauth_tokens_not_expired",
+    ok: expiredAccounts.length === 0,
+    detail: expiredAccounts.length === 0 ? "No expired tokens detected" : `Expired: ${expiredAccounts.map((a) => a.platform).join(", ")}`
+  });
+  const ok = checks.every((check) => check.ok);
+  const summary = {
+    ok,
+    command: "preflight",
+    checkCount: checks.length,
+    passed: checks.filter((check) => check.ok).length,
+    failed: checks.filter((check) => !check.ok).length,
+    connectedPlatforms: activeAccounts.map((a) => ({
+      platform: a.platform,
+      username: a.username,
+      expiresAt: a.expires_at
+    })),
+    checks
+  };
+  if (asJson) {
+    emitSnResult(summary, true);
+  } else {
+    console.error(`Preflight: ${ok ? "PASS" : "FAIL"}`);
+    console.error(`Checks: ${summary.passed}/${summary.checkCount} passed`);
+    for (const check of checks) {
+      console.error(`${check.ok ? "[ok]" : "[x]"} ${check.name}: ${check.detail}`);
+    }
+    if (!ok) {
+      console.error("");
+      console.error("Blocking checks failed. Recommended: run in Draft-only mode until fixed.");
+    }
+  }
+  process.exit(ok ? 0 : 1);
+}
+var init_account = __esm({
+  "src/cli/sn/account.ts"() {
+    "use strict";
+    init_edge_function();
+    init_supabase();
+    init_parse();
+  }
+});
+
+// src/cli/sn/analytics.ts
+var analytics_exports = {};
+__export(analytics_exports, {
+  handleLoop: () => handleLoop,
+  handlePosts: () => handlePosts,
+  handleRefreshAnalytics: () => handleRefreshAnalytics
+});
+async function ensureAuth3() {
+  await initializeAuth();
+  return getDefaultUserId();
+}
+async function handlePosts(args, asJson) {
+  const userId = await ensureAuth3();
+  const supabase = tryGetSupabaseClient();
+  const daysRaw = args.days;
+  const days = typeof daysRaw === "string" ? Number(daysRaw) : 7;
+  const lookbackDays = Number.isFinite(days) && days > 0 ? Math.min(days, 90) : 7;
+  const since = /* @__PURE__ */ new Date();
+  since.setDate(since.getDate() - lookbackDays);
+  let posts = [];
+  if (supabase) {
+    let query = supabase.from("posts").select(
+      "id, platform, status, title, external_post_id, scheduled_at, published_at, created_at"
+    ).eq("user_id", userId).gte("created_at", since.toISOString()).order("created_at", { ascending: false }).limit(50);
+    if (typeof args.platform === "string") {
+      query = query.eq("platform", args.platform);
+    }
+    if (typeof args.status === "string") {
+      query = query.eq("status", args.status);
+    }
+    const { data, error } = await query;
+    if (error) {
+      const formatted = classifySupabaseCliError("fetch posts", error);
+      throw new Error(formatted.message);
+    }
+    posts = data ?? [];
+  } else {
+    const { data, error } = await callEdgeFunction("mcp-data", {
+      action: "recent-posts",
+      userId,
+      days: lookbackDays,
+      limit: 50,
+      platform: typeof args.platform === "string" ? args.platform : void 0,
+      status: typeof args.status === "string" ? args.status : void 0
+    });
+    if (error || !data?.success) {
+      throw new Error("Failed to fetch posts: " + (error ?? "Unknown error"));
+    }
+    posts = data.posts ?? [];
+  }
+  if (!posts || posts.length === 0) {
+    if (asJson) {
+      emitSnResult({ ok: true, command: "posts", posts: [] }, true);
+    } else {
+      console.error("No posts found.");
+    }
+    process.exit(0);
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "posts", posts }, true);
+  } else {
+    for (const post of posts) {
+      console.error(
+        `${post.created_at} | ${post.platform} | ${post.status} | ${post.title ?? "(untitled)"} | ${post.id}`
+      );
+    }
+  }
+  process.exit(0);
+}
+async function handleRefreshAnalytics(args, asJson) {
+  await ensureAuth3();
+  const { data, error } = await callEdgeFunction(
+    "fetch-analytics",
+    {}
+  );
+  if (error || !data?.success) {
+    throw new Error(`Analytics refresh failed: ${error ?? "Unknown error"}`);
+  }
+  if (asJson) {
+    emitSnResult(
+      { ok: true, command: "refresh-analytics", postsProcessed: data.postsProcessed },
+      true
+    );
+  } else {
+    console.error(`Analytics refresh queued for ${data.postsProcessed} post(s).`);
+  }
+  process.exit(0);
+}
+async function handleLoop(args, asJson) {
+  const userId = await ensureAuth3();
+  const supabase = tryGetSupabaseClient();
+  let hasProfile;
+  let recentContent;
+  let currentInsights;
+  if (supabase) {
+    const thirtyDaysAgo = /* @__PURE__ */ new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+    const [brandResult, contentResult, insightsResult] = await Promise.all([
+      supabase.from("brand_profiles").select("id").eq("user_id", userId).eq("is_active", true).limit(1).maybeSingle(),
+      supabase.from("content_history").select("id, content_type, created_at").eq("user_id", userId).gte("created_at", thirtyDaysAgo.toISOString()).order("created_at", { ascending: false }).limit(10),
+      supabase.from("performance_insights").select("id, insight_type, generated_at").gte("generated_at", thirtyDaysAgo.toISOString()).gt("expires_at", (/* @__PURE__ */ new Date()).toISOString()).limit(20)
+    ]);
+    hasProfile = !!brandResult.data;
+    recentContent = contentResult.data ?? [];
+    currentInsights = insightsResult.data ?? [];
+  } else {
+    const { data, error } = await callEdgeFunction("mcp-data", { action: "loop-summary", userId });
+    if (error || !data?.success) {
+      throw new Error(`Loop summary failed: ${error ?? data?.error ?? "Unknown error"}`);
+    }
+    hasProfile = data.hasProfile;
+    recentContent = data.recentContent ?? [];
+    currentInsights = data.currentInsights ?? [];
+  }
+  let nextAction = "Generate content to start building your feedback loop";
+  if (!hasProfile) nextAction = "Set up your brand profile first";
+  else if (recentContent.length === 0)
+    nextAction = "Generate and publish content to collect performance data";
+  else if (currentInsights.length === 0)
+    nextAction = "Publish more content \u2014 insights need 5+ data points";
+  else nextAction = "Loop is active \u2014 use insights to improve next content batch";
+  if (asJson) {
+    emitSnResult(
+      {
+        ok: true,
+        command: "loop",
+        brandStatus: { hasProfile },
+        recentContent,
+        currentInsights,
+        recommendedNextAction: nextAction
+      },
+      true
+    );
+  } else {
+    console.error("Feedback Loop Summary");
+    console.error("=====================");
+    console.error(`Brand Profile: ${hasProfile ? "Ready" : "Missing"}`);
+    console.error(`Recent Content: ${recentContent.length} items (last 30 days)`);
+    console.error(`Current Insights: ${currentInsights.length} active`);
+    console.error(`
+Next Action: ${nextAction}`);
+  }
+  process.exit(0);
+}
+var init_analytics = __esm({
+  "src/cli/sn/analytics.ts"() {
+    "use strict";
+    init_edge_function();
+    init_supabase();
+    init_parse();
+  }
+});
+
+// src/cli/sn/system.ts
+var system_exports = {};
+__export(system_exports, {
+  handleAutopilot: () => handleAutopilot,
+  handleCredits: () => handleCredits,
+  handleStatus: () => handleStatus,
+  handleUsage: () => handleUsage
+});
+async function ensureAuth4() {
+  await initializeAuth();
+  return getDefaultUserId();
+}
+async function handleStatus(args, asJson) {
+  const jobId = args["job-id"];
+  if (typeof jobId !== "string") {
+    throw new Error("Missing required flag: --job-id");
+  }
+  const userId = await ensureAuth4();
+  const supabase = tryGetSupabaseClient();
+  let job = null;
+  if (supabase) {
+    const { data: byId, error: byIdError } = await supabase.from("async_jobs").select(
+      "id, external_id, status, job_type, model, result_url, error_message, created_at, completed_at"
+    ).eq("user_id", userId).eq("id", jobId).maybeSingle();
+    if (byIdError) {
+      const formatted = classifySupabaseCliError("fetch job status", byIdError);
+      throw new Error(formatted.message);
+    }
+    if (byId) {
+      job = byId;
+    } else {
+      const { data: byExternal, error: byExternalError } = await supabase.from("async_jobs").select(
+        "id, external_id, status, job_type, model, result_url, error_message, created_at, completed_at"
+      ).eq("user_id", userId).eq("external_id", jobId).maybeSingle();
+      if (byExternalError) {
+        const formatted = classifySupabaseCliError("fetch job status", byExternalError);
+        throw new Error(formatted.message);
+      }
+      job = byExternal;
+    }
+  } else {
+    const { data, error } = await callEdgeFunction("mcp-data", {
+      action: "job-status",
+      userId,
+      jobId
+    });
+    if (error || !data?.success) {
+      throw new Error(`Failed to fetch job status: ${error ?? data?.error ?? "Unknown error"}`);
+    }
+    job = data.job ?? null;
+  }
+  if (!job) {
+    throw new Error(`No job found with ID "${jobId}".`);
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "status", job }, true);
+  } else {
+    console.error(`Job: ${job.id}`);
+    console.error(`Status: ${job.status}`);
+    console.error(`Type: ${job.job_type}`);
+    console.error(`Model: ${job.model}`);
+    if (job.result_url) console.error(`Result URL: ${job.result_url}`);
+    if (job.error_message) console.error(`Error: ${job.error_message}`);
+    console.error(`Created: ${job.created_at}`);
+    if (job.completed_at) console.error(`Completed: ${job.completed_at}`);
+  }
+  process.exit(0);
+}
+async function handleAutopilot(args, asJson) {
+  const userId = await ensureAuth4();
+  const supabase = tryGetSupabaseClient();
+  let activeConfigs;
+  let pendingApprovals;
+  let configs;
+  if (supabase) {
+    const [configsResult, approvalsResult] = await Promise.all([
+      supabase.from("autopilot_configs").select("id, platform, is_enabled, schedule_config, updated_at").eq("user_id", userId).eq("is_enabled", true),
+      supabase.from("approval_queue").select("id").eq("user_id", userId).eq("status", "pending")
+    ]);
+    activeConfigs = configsResult.data?.length ?? 0;
+    pendingApprovals = approvalsResult.data?.length ?? 0;
+    configs = configsResult.data ?? [];
+  } else {
+    const { data, error } = await callEdgeFunction("mcp-data", { action: "autopilot-status", userId });
+    if (error || !data?.success) {
+      throw new Error(`Autopilot status failed: ${error ?? data?.error ?? "Unknown error"}`);
+    }
+    activeConfigs = data.activeConfigs;
+    pendingApprovals = data.pendingApprovals;
+    configs = data.configs ?? [];
+  }
+  if (asJson) {
+    emitSnResult(
+      { ok: true, command: "autopilot", activeConfigs, pendingApprovals, configs },
+      true
+    );
+  } else {
+    console.error("Autopilot Status");
+    console.error("================");
+    console.error(`Active Configs: ${activeConfigs}`);
+    console.error(`Pending Approvals: ${pendingApprovals}`);
+    if (configs.length) {
+      console.error("\nConfigs:");
+      for (const cfg of configs) {
+        console.error(`- ${cfg.platform}: enabled (updated ${cfg.updated_at})`);
+      }
+    }
+  }
+  process.exit(0);
+}
+async function handleUsage(args, asJson) {
+  const userId = await ensureAuth4();
+  const supabase = tryGetSupabaseClient();
+  let totalCalls;
+  let totalCredits;
+  let tools;
+  if (supabase) {
+    const startOfMonth = /* @__PURE__ */ new Date();
+    startOfMonth.setDate(1);
+    startOfMonth.setHours(0, 0, 0, 0);
+    const { data: rows, error: rpcError } = await supabase.rpc("get_mcp_monthly_usage", {
+      p_user_id: userId,
+      p_since: startOfMonth.toISOString()
+    });
+    if (rpcError) {
+      const { data: logs } = await supabase.from("activity_logs").select("action, metadata").eq("user_id", userId).gte("created_at", startOfMonth.toISOString()).like("action", "mcp:%");
+      totalCalls = logs?.length ?? 0;
+      totalCredits = 0;
+      tools = [];
+    } else {
+      tools = rows ?? [];
+      totalCalls = tools.reduce((sum, t) => sum + (t.call_count ?? 0), 0);
+      totalCredits = tools.reduce((sum, t) => sum + (t.credits_total ?? 0), 0);
+    }
+  } else {
+    const { data, error } = await callEdgeFunction("mcp-data", { action: "mcp-usage", userId });
+    if (error || !data?.success) {
+      throw new Error(`Usage fetch failed: ${error ?? data?.error ?? "Unknown error"}`);
+    }
+    totalCalls = data.totalCalls;
+    totalCredits = data.totalCredits;
+    tools = data.tools ?? [];
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "usage", totalCalls, totalCredits, tools }, true);
+  } else {
+    console.error("MCP Usage This Month");
+    console.error("====================");
+    console.error(`Total Calls: ${totalCalls}`);
+    console.error(`Total Credits: ${totalCredits}`);
+    if (tools.length) {
+      console.error("\nPer-Tool Breakdown:");
+      for (const tool of tools) {
+        console.error(
+          `- ${tool.tool_name}: ${tool.call_count} calls, ${tool.credits_total} credits`
+        );
+      }
+    }
+  }
+  process.exit(0);
+}
+async function handleCredits(args, asJson) {
+  const userId = await ensureAuth4();
+  const supabase = tryGetSupabaseClient();
+  let balance;
+  let monthlyUsed;
+  let monthlyLimit;
+  let plan;
+  if (supabase) {
+    const [profileResult, subResult] = await Promise.all([
+      supabase.from("user_profiles").select("credits, monthly_credits_used").eq("id", userId).maybeSingle(),
+      supabase.from("subscriptions").select("tier, status, monthly_credits").eq("user_id", userId).eq("status", "active").order("created_at", { ascending: false }).limit(1).maybeSingle()
+    ]);
+    if (profileResult.error) throw profileResult.error;
+    balance = Number(profileResult.data?.credits || 0);
+    monthlyUsed = Number(profileResult.data?.monthly_credits_used || 0);
+    monthlyLimit = Number(subResult.data?.monthly_credits || 0);
+    plan = subResult.data?.tier || "free";
+  } else {
+    const { data, error } = await callEdgeFunction("mcp-data", { action: "credit-balance", userId });
+    if (error || !data?.success) {
+      throw new Error(`Credit balance failed: ${error ?? data?.error ?? "Unknown error"}`);
+    }
+    balance = data.balance;
+    monthlyUsed = data.monthlyUsed;
+    monthlyLimit = data.monthlyLimit;
+    plan = data.plan;
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "credits", balance, monthlyUsed, monthlyLimit, plan }, true);
+  } else {
+    console.error("Credit Balance");
+    console.error("==============");
+    console.error(`Plan: ${plan.toUpperCase()}`);
+    console.error(`Balance: ${balance} credits`);
+    if (monthlyLimit) {
+      console.error(`Monthly Usage: ${monthlyUsed} / ${monthlyLimit}`);
+    }
+  }
+  process.exit(0);
+}
+var init_system = __esm({
+  "src/cli/sn/system.ts"() {
+    "use strict";
+    init_edge_function();
+    init_supabase();
+    init_parse();
+  }
+});
+
+// src/lib/tool-catalog.ts
+function getToolsByModule(module) {
+  return TOOL_CATALOG.filter((t) => t.module === module);
+}
+function getToolsByScope(scope) {
+  return TOOL_CATALOG.filter((t) => t.scope === scope);
+}
+function getModules() {
+  return [...new Set(TOOL_CATALOG.map((t) => t.module))];
+}
+var TOOL_CATALOG;
+var init_tool_catalog = __esm({
+  "src/lib/tool-catalog.ts"() {
+    "use strict";
+    TOOL_CATALOG = [
+      // ideation
+      {
+        name: "generate_content",
+        description: "Generate social media content ideas based on brand profile and trends",
+        module: "ideation",
+        scope: "mcp:write"
+      },
+      {
+        name: "fetch_trends",
+        description: "Fetch current trending topics for content ideation",
+        module: "ideation",
+        scope: "mcp:read"
+      },
+      // ideation-context
+      {
+        name: "get_ideation_context",
+        description: "Get full ideation context including brand, analytics, and trends",
+        module: "ideation-context",
+        scope: "mcp:read"
+      },
+      // content
+      {
+        name: "adapt_content",
+        description: "Adapt existing content for different platforms",
+        module: "content",
+        scope: "mcp:write"
+      },
+      {
+        name: "generate_video",
+        description: "Generate video content using AI",
+        module: "content",
+        scope: "mcp:write"
+      },
+      {
+        name: "generate_image",
+        description: "Generate images using AI",
+        module: "content",
+        scope: "mcp:write"
+      },
+      {
+        name: "check_status",
+        description: "Check status of async content generation job",
+        module: "content",
+        scope: "mcp:read"
+      },
+      {
+        name: "create_storyboard",
+        description: "Create a video storyboard with scenes and shots",
+        module: "content",
+        scope: "mcp:write"
+      },
+      {
+        name: "generate_voiceover",
+        description: "Generate AI voiceover audio",
+        module: "content",
+        scope: "mcp:write"
+      },
+      {
+        name: "generate_carousel",
+        description: "Generate carousel/slide content",
+        module: "content",
+        scope: "mcp:write"
+      },
+      {
+        name: "create_carousel",
+        description: "End-to-end carousel: generate text + kick off image jobs for each slide",
+        module: "carousel",
+        scope: "mcp:write"
+      },
+      // media
+      {
+        name: "upload_media",
+        description: "Upload local file or external URL to R2 storage",
+        module: "media",
+        scope: "mcp:write"
+      },
+      {
+        name: "get_media_url",
+        description: "Sign an R2 key to get a fresh download URL",
+        module: "media",
+        scope: "mcp:read"
+      },
+      // distribution
+      {
+        name: "schedule_post",
+        description: "Schedule content for publishing to social platforms",
+        module: "distribution",
+        scope: "mcp:distribute"
+      },
+      {
+        name: "list_recent_posts",
+        description: "List recently published or scheduled posts",
+        module: "distribution",
+        scope: "mcp:read"
+      },
+      {
+        name: "list_connected_accounts",
+        description: "List connected social media accounts",
+        module: "distribution",
+        scope: "mcp:read"
+      },
+      {
+        name: "start_platform_connection",
+        description: "Mint a single-use deep link for a user to complete platform OAuth in their browser",
+        module: "distribution",
+        scope: "mcp:distribute"
+      },
+      {
+        name: "wait_for_connection",
+        description: "Poll until a platform connection becomes active or timeout",
+        module: "distribution",
+        scope: "mcp:read"
+      },
+      // analytics
+      {
+        name: "fetch_analytics",
+        description: "Fetch post performance analytics",
+        module: "analytics",
+        scope: "mcp:read"
+      },
+      {
+        name: "refresh_platform_analytics",
+        description: "Refresh analytics data from connected platforms",
+        module: "analytics",
+        scope: "mcp:analytics"
+      },
+      // insights
+      {
+        name: "get_performance_insights",
+        description: "Get AI-generated performance insights",
+        module: "insights",
+        scope: "mcp:read"
+      },
+      {
+        name: "get_best_posting_times",
+        description: "Get recommended posting times based on audience data",
+        module: "insights",
+        scope: "mcp:read"
+      },
+      // brand
+      {
+        name: "extract_brand",
+        description: "Extract brand identity from URL or text",
+        module: "brand",
+        scope: "mcp:read"
+      },
+      {
+        name: "get_brand_profile",
+        description: "Get the current brand profile",
+        module: "brand",
+        scope: "mcp:read"
+      },
+      {
+        name: "get_brand_runtime",
+        description: "Get the full 4-layer brand runtime (messaging, voice, visual, constraints)",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      {
+        name: "explain_brand_system",
+        description: "Explain brand completeness, confidence, and recommendations",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      {
+        name: "check_brand_consistency",
+        description: "Check content text for brand voice/vocabulary/claim consistency",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      {
+        name: "save_brand_profile",
+        description: "Save or update brand profile",
+        module: "brand",
+        scope: "mcp:write"
+      },
+      {
+        name: "update_platform_voice",
+        description: "Update platform-specific brand voice settings",
+        module: "brand",
+        scope: "mcp:write"
+      },
+      // screenshot
+      {
+        name: "capture_screenshot",
+        description: "Capture a screenshot of a URL",
+        module: "screenshot",
+        scope: "mcp:read",
+        localOnly: true
+      },
+      {
+        name: "capture_app_page",
+        description: "Capture a screenshot of an app page",
+        module: "screenshot",
+        scope: "mcp:read",
+        localOnly: true
+      },
+      // remotion
+      {
+        name: "render_demo_video",
+        description: "Render a demo video using Remotion",
+        module: "remotion",
+        scope: "mcp:write"
+      },
+      {
+        name: "list_compositions",
+        description: "List available Remotion video compositions",
+        module: "remotion",
+        scope: "mcp:read"
+      },
+      {
+        name: "render_template_video",
+        description: "Render a template video in the cloud via async job",
+        module: "remotion",
+        scope: "mcp:write"
+      },
+      // youtube-analytics
+      {
+        name: "fetch_youtube_analytics",
+        description: "Fetch YouTube channel analytics data",
+        module: "youtube-analytics",
+        scope: "mcp:analytics"
+      },
+      // comments
+      {
+        name: "list_comments",
+        description: "List comments on published posts",
+        module: "comments",
+        scope: "mcp:comments"
+      },
+      {
+        name: "reply_to_comment",
+        description: "Reply to a comment on a post",
+        module: "comments",
+        scope: "mcp:comments"
+      },
+      {
+        name: "post_comment",
+        description: "Post a new comment",
+        module: "comments",
+        scope: "mcp:comments"
+      },
+      {
+        name: "moderate_comment",
+        description: "Moderate a comment (approve/hide/flag)",
+        module: "comments",
+        scope: "mcp:comments"
+      },
+      {
+        name: "delete_comment",
+        description: "Delete a comment",
+        module: "comments",
+        scope: "mcp:comments"
+      },
+      // planning
+      {
+        name: "plan_content_week",
+        description: "Generate a weekly content plan",
+        module: "planning",
+        scope: "mcp:write"
+      },
+      {
+        name: "save_content_plan",
+        description: "Save a content plan",
+        module: "planning",
+        scope: "mcp:write"
+      },
+      {
+        name: "get_content_plan",
+        description: "Get a specific content plan by ID",
+        module: "planning",
+        scope: "mcp:read"
+      },
+      {
+        name: "update_content_plan",
+        description: "Update an existing content plan",
+        module: "planning",
+        scope: "mcp:write"
+      },
+      {
+        name: "submit_content_plan_for_approval",
+        description: "Submit a content plan for team approval",
+        module: "planning",
+        scope: "mcp:write"
+      },
+      {
+        name: "schedule_content_plan",
+        description: "Schedule all posts in an approved content plan",
+        module: "planning",
+        scope: "mcp:distribute"
+      },
+      {
+        name: "find_next_slots",
+        description: "Find next available scheduling slots",
+        module: "planning",
+        scope: "mcp:read"
+      },
+      // plan-approvals
+      {
+        name: "create_plan_approvals",
+        description: "Create approval requests for a content plan",
+        module: "plan-approvals",
+        scope: "mcp:write"
+      },
+      {
+        name: "respond_plan_approval",
+        description: "Respond to a plan approval request",
+        module: "plan-approvals",
+        scope: "mcp:write"
+      },
+      {
+        name: "list_plan_approvals",
+        description: "List pending plan approval requests",
+        module: "plan-approvals",
+        scope: "mcp:read"
+      },
+      // quality
+      {
+        name: "quality_check",
+        description: "Run quality checks on content before publishing",
+        module: "quality",
+        scope: "mcp:read"
+      },
+      {
+        name: "quality_check_plan",
+        description: "Run quality checks on an entire content plan",
+        module: "quality",
+        scope: "mcp:read"
+      },
+      {
+        name: "visual_quality_check",
+        description: "Pre-render visual QA on carousel slides \u2014 predicts text overflow against per-layout constraints. Run before schedule_post to catch clipped text.",
+        module: "quality",
+        scope: "mcp:read"
+      },
+      {
+        name: "visual_gate_constraints",
+        description: "Read the per-layout field constraints (font size, width, max lines) the visual gate uses. Useful when generating slide text that fits first time.",
+        module: "quality",
+        scope: "mcp:read"
+      },
+      // credits
+      {
+        name: "get_credit_balance",
+        description: "Get current credit balance",
+        module: "credits",
+        scope: "mcp:read"
+      },
+      {
+        name: "get_budget_status",
+        description: "Get budget and spending status",
+        module: "credits",
+        scope: "mcp:read"
+      },
+      // autopilot
+      {
+        name: "list_autopilot_configs",
+        description: "List autopilot configurations",
+        module: "autopilot",
+        scope: "mcp:autopilot"
+      },
+      {
+        name: "update_autopilot_config",
+        description: "Update autopilot configuration",
+        module: "autopilot",
+        scope: "mcp:autopilot"
+      },
+      {
+        name: "get_autopilot_status",
+        description: "Get current autopilot status",
+        module: "autopilot",
+        scope: "mcp:autopilot"
+      },
+      // extraction
+      {
+        name: "extract_url_content",
+        description: "Extract content from a URL for repurposing",
+        module: "extraction",
+        scope: "mcp:read"
+      },
+      // niche research
+      {
+        name: "find_winning_content",
+        description: "Find QA-gated high-performing short-form videos in the project's niche. Returns extracted hook patterns, content structures, and pre-compiled replication prompts (backed by niche_winners view, qa_score >= 0.5).",
+        module: "research",
+        scope: "mcp:read"
+      },
+      // loop-summary
+      {
+        name: "get_loop_summary",
+        description: "Get growth loop summary and recommendations",
+        module: "loop-summary",
+        scope: "mcp:read"
+      },
+      // usage
+      {
+        name: "get_mcp_usage",
+        description: "Get MCP usage statistics for the current billing period",
+        module: "usage",
+        scope: "mcp:read"
+      },
+      // discovery
+      {
+        name: "search_tools",
+        description: "Search and discover available MCP tools",
+        module: "discovery",
+        scope: "mcp:read"
+      },
+      {
+        name: "search",
+        description: "Search public Social Neuron product, integration, developer, and MCP tool knowledge using the ChatGPT-compatible search schema.",
+        module: "discovery",
+        scope: "mcp:read"
+      },
+      {
+        name: "fetch",
+        description: "Fetch one public Social Neuron knowledge document by ID using the ChatGPT-compatible fetch schema.",
+        module: "discovery",
+        scope: "mcp:read"
+      },
+      // pipeline
+      {
+        name: "check_pipeline_readiness",
+        description: "Pre-flight check before running a content pipeline",
+        module: "pipeline",
+        scope: "mcp:read"
+      },
+      {
+        name: "run_content_pipeline",
+        description: "End-to-end content pipeline: plan \u2192 quality \u2192 approve \u2192 schedule",
+        module: "pipeline",
+        scope: "mcp:autopilot"
+      },
+      {
+        name: "get_pipeline_status",
+        description: "Check status of a pipeline run",
+        module: "pipeline",
+        scope: "mcp:read"
+      },
+      {
+        name: "auto_approve_plan",
+        description: "Batch auto-approve posts meeting quality thresholds",
+        module: "pipeline",
+        scope: "mcp:autopilot"
+      },
+      // suggest
+      {
+        name: "suggest_next_content",
+        description: "Suggest next content topics based on performance data",
+        module: "suggest",
+        scope: "mcp:read"
+      },
+      // digest
+      {
+        name: "generate_performance_digest",
+        description: "Generate a performance summary with trends and recommendations",
+        module: "digest",
+        scope: "mcp:analytics"
+      },
+      {
+        name: "detect_anomalies",
+        description: "Detect significant performance changes (spikes, drops, viral)",
+        module: "digest",
+        scope: "mcp:analytics"
+      },
+      // autopilot (addition)
+      {
+        name: "create_autopilot_config",
+        description: "Create a new autopilot configuration",
+        module: "autopilot",
+        scope: "mcp:autopilot"
+      },
+      // brand runtime (additions)
+      {
+        name: "audit_brand_colors",
+        description: "Audit brand color palette for accessibility, contrast, and harmony",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      {
+        name: "export_design_tokens",
+        description: "Export brand design tokens in CSS/Tailwind/JSON formats",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      // carousel (already listed in content section above)
+      // apps (MCP Apps — interactive UI inside the host)
+      {
+        name: "open_content_calendar",
+        description: "Open an interactive drag-drop calendar of the user's scheduled posts inside the host (Claude Desktop / claude.ai). Renders an MCP App; backed by list_recent_posts, schedule_post, find_next_slots \u2014 no new tools needed.",
+        module: "apps",
+        scope: "mcp:read"
+      },
+      // recipes
+      {
+        name: "list_recipes",
+        description: "List available recipe templates for automated content workflows",
+        module: "recipes",
+        scope: "mcp:read"
+      },
+      {
+        name: "get_recipe_details",
+        description: "Get full details of a recipe template including steps and required inputs",
+        module: "recipes",
+        scope: "mcp:read"
+      },
+      {
+        name: "execute_recipe",
+        description: "Execute a recipe template with provided inputs to run a multi-step workflow",
+        module: "recipes",
+        scope: "mcp:write"
+      },
+      {
+        name: "get_recipe_run_status",
+        description: "Check the status and progress of a running recipe execution",
+        module: "recipes",
+        scope: "mcp:read"
+      },
+      // F4 Hyperframes — HTML composition runtime
+      {
+        name: "list_hyperframes_blocks",
+        description: "List the curated subset of pre-built Hyperframes blocks (transitions, social overlays, data-viz, branding, decorative) that can be composed into HTML video compositions",
+        module: "hyperframes",
+        scope: "mcp:read"
+      },
+      {
+        name: "render_hyperframes",
+        description: "Render an HTML video composition (Hyperframes) to MP4. Author the composition as HTML with data-* timing attributes and GSAP timelines \u2014 frame-accurate, no React build step",
+        module: "hyperframes",
+        scope: "mcp:write"
+      },
+      // agentic-harness — learning loop write-back
+      {
+        name: "write_agent_reflection",
+        description: "Persist a verbal reflection for an agent loop. Provenance keys are restricted (Anti-Goodhart safety): only content_history_id, outcome_event_id, prm_score_ids, and handoff_ids are accepted.",
+        module: "harness",
+        scope: "mcp:write"
+      },
+      {
+        name: "record_outcome",
+        description: "Record an outcome for a published decision event. Idempotent on (decision_event_id, horizon). Only horizon=24h triggers a content_bandits posterior update.",
+        module: "harness",
+        scope: "mcp:write"
+      },
+      // agentic-harness — learning loop read-back
+      {
+        name: "read_agent_reflection",
+        description: "Read past agent reflections for a brand. Ordered by created_at DESC, id ASC (deterministic tiebreak). Only active reflections returned (superseded_by IS NULL). Optional generated_by_agent filter.",
+        module: "harness",
+        scope: "mcp:read"
+      },
+      // hermes — autonomous agent integration (closed-loop content)
+      {
+        name: "save_draft_to_library",
+        description: "Save a draft post to the SN content library with origin=hermes. Used by Hermes to persist drafts before the founder approves them.",
+        module: "hermes",
+        scope: "mcp:write"
+      },
+      {
+        name: "record_voice_lesson",
+        description: "Persist a learned voice lesson to brand_profiles.brand_context.voiceProfile.voice_lessons via atomic RPC. Used by Hermes reflection cron.",
+        module: "hermes",
+        scope: "mcp:write"
+      },
+      {
+        name: "record_observation",
+        description: 'Record an agent observation (e.g. "topic X engagement up 23%") for the UnifiedAnalytics > Playbook surface.',
+        module: "hermes",
+        scope: "mcp:write"
+      },
+      {
+        name: "record_intel_signal",
+        description: "Record a research/trend signal from Hermes watchers (news, HN, competitor, etc.) for Niche Intelligence. Dedupes by URL.",
+        module: "hermes",
+        scope: "mcp:write"
+      },
+      {
+        name: "record_campaign_spend",
+        description: "Log a campaign cost line (hermes_drafts, carousel_renders, analytics_pulls, paid_amplification, other). Ownership-checked.",
+        module: "hermes",
+        scope: "mcp:write"
+      },
+      {
+        name: "get_active_campaigns",
+        description: "List currently-running campaigns with thesis, budget, hero format, and current spend. Used by Hermes pitch skill to bias drafts.",
+        module: "hermes",
+        scope: "mcp:read"
+      },
+      // skills (workflow skills — multi-step brand-locked content pipelines)
+      {
+        name: "list_skills",
+        description: "List Social Neuron content workflow skills available to the user. A skill is a brand-locked multi-step pipeline inspired by documented viral patterns (MrBeast 3-second hook, Hormozi pattern interrupt, etc.).",
+        module: "skills",
+        scope: "mcp:read"
+      },
+      {
+        name: "run_skill",
+        description: "Run a Social Neuron workflow skill end-to-end (brand-locked content production). PR #4.4 v1 returns a structured run preview with the step plan, credit cost, and a deep-link to launch in the SN dashboard.",
+        module: "skills",
+        scope: "mcp:write"
+      },
+      // loop observability (growth-loop KPIs + Thompson Sampling bandit posteriors)
+      {
+        name: "get_loop_pulse",
+        description: "Read dynamic loop-health KPIs for the growth loop over the last 7 days (reflection/decision coverage, visual gate pass rate, bandit-update application rate, per-platform uptake, autopilot lag) \u2014 each with an ok/warn/bad status. Use to decide whether the loop is closing or where it is stuck.",
+        module: "loop",
+        scope: "mcp:read"
+      },
+      {
+        name: "get_bandit_state",
+        description: "Read the current Thompson Sampling bandit posteriors for a project \u2014 top-K arms per (arm_type, platform) with Beta(alpha,beta) posterior mean and uncertainty. Use to reason about which hook family / format / timing slot the bandit currently prefers per platform.",
+        module: "loop",
+        scope: "mcp:read"
+      }
+    ];
+  }
+});
+
+// src/cli/sn/discovery.ts
+var discovery_exports = {};
+__export(discovery_exports, {
+  handleInfo: () => handleInfo,
+  handleTools: () => handleTools
+});
+async function handleTools(args, asJson) {
+  let tools = TOOL_CATALOG;
+  const scope = args.scope;
+  if (typeof scope === "string") {
+    tools = getToolsByScope(scope);
+  }
+  const module = args.module;
+  if (typeof module === "string") {
+    tools = getToolsByModule(module);
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "tools", toolCount: tools.length, tools }, true);
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const group = grouped.get(tool.module) ?? [];
+    group.push(tool);
+    grouped.set(tool.module, group);
+  }
+  if (grouped.size === 0) {
+    console.error("No tools found matching the given filters.");
+    process.exit(0);
+    return;
+  }
+  for (const [moduleName, moduleTools] of grouped) {
+    console.error(`
+Module: ${moduleName} (${moduleTools.length} tools)`);
+    const maxNameLen = Math.max(...moduleTools.map((t) => t.name.length));
+    for (const tool of moduleTools) {
+      const padded = tool.name.padEnd(maxNameLen + 2);
+      console.error(`  ${padded}${tool.description}`);
+    }
+  }
+  console.error("");
+  process.exit(0);
+}
+async function handleInfo(args, asJson) {
+  const info = {
+    version: MCP_VERSION,
+    toolCount: TOOL_CATALOG.length,
+    modules: getModules()
+  };
+  try {
+    const { loadApiKey: loadApiKey2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+    const { validateApiKey: validateApiKey2 } = await Promise.resolve().then(() => (init_api_keys(), api_keys_exports));
+    const apiKey = await loadApiKey2();
+    if (apiKey) {
+      const result = await validateApiKey2(apiKey);
+      if (result.valid) {
+        info.auth = {
+          email: result.email || null,
+          scopes: result.scopes || [],
+          expiresAt: result.expiresAt || null
+        };
+      }
+    }
+  } catch {
+    info.auth = null;
+  }
+  if (info.auth) {
+    try {
+      const { callEdgeFunction: callEdgeFunction2 } = await Promise.resolve().then(() => (init_edge_function(), edge_function_exports));
+      const { data } = await callEdgeFunction2("mcp-data", {
+        action: "credit-balance"
+      });
+      info.creditBalance = data?.balance ?? null;
+    } catch {
+      info.creditBalance = null;
+    }
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "info", data: info }, true);
+    process.exit(0);
+    return;
+  }
+  console.error(`Version: ${info.version}`);
+  console.error(`Tools: ${info.toolCount}`);
+  console.error(`Modules: ${info.modules.join(", ")}`);
+  if (info.auth === null) {
+    console.error("Auth: not configured");
+  } else if (info.auth) {
+    const auth = info.auth;
+    console.error(`Auth: ${auth.email ?? "authenticated"}`);
+    console.error(`Scopes: ${auth.scopes.length > 0 ? auth.scopes.join(", ") : "none"}`);
+    if (auth.expiresAt) {
+      console.error(`Expires: ${auth.expiresAt}`);
+    }
+  }
+  if (info.creditBalance !== void 0) {
+    console.error(`Credits: ${info.creditBalance !== null ? info.creditBalance : "unavailable"}`);
+  }
+  console.error("");
+  process.exit(0);
+}
+var init_discovery = __esm({
+  "src/cli/sn/discovery.ts"() {
+    "use strict";
+    init_tool_catalog();
+    init_parse();
+    init_version();
+  }
+});
+
+// src/cli/sn/planning.ts
+var planning_exports = {};
+__export(planning_exports, {
+  handlePlan: () => handlePlan
+});
+async function ensureAuth5() {
+  await initializeAuth();
+  return getDefaultUserId();
+}
+async function handlePlanList(args, asJson) {
+  const status = typeof args.status === "string" ? args.status : void 0;
+  const userId = await ensureAuth5();
+  const body = { action: "list-content-plans", userId };
+  if (status) {
+    body.status = status;
+  }
+  const { data, error } = await callEdgeFunction("mcp-data", body);
+  if (error || !data) {
+    throw new Error(`Failed to list plans: ${error ?? "Unknown error"}`);
+  }
+  const plans = data.plans ?? [];
+  if (asJson) {
+    emitSnResult({ ok: true, command: "plan list", plans }, true);
+  } else {
+    if (plans.length === 0) {
+      console.error("No content plans found.");
+    } else {
+      console.error("plan-id | status | created_at | title");
+      console.error("--------|--------|------------|------");
+      for (const p of plans) {
+        const title = p.title ?? p.summary ?? "(untitled)";
+        console.error(`${p.id} | ${p.status} | ${p.created_at} | ${title}`);
+      }
+    }
+  }
+}
+async function handlePlanView(args, asJson) {
+  const planId = args["plan-id"];
+  if (typeof planId !== "string") {
+    throw new Error("Missing required flag: --plan-id");
+  }
+  const userId = await ensureAuth5();
+  const { data, error } = await callEdgeFunction("mcp-data", {
+    action: "get-content-plan",
+    userId,
+    planId
+  });
+  if (error || !data) {
+    throw new Error(`Failed to view plan: ${error ?? "Unknown error"}`);
+  }
+  const plan = data.plan;
+  if (asJson) {
+    emitSnResult({ ok: true, command: "plan view", plan }, true);
+  } else {
+    const title = plan.title ?? plan.summary ?? "(untitled)";
+    console.error(`Plan: ${plan.id}`);
+    console.error(`Title: ${title}`);
+    console.error(`Status: ${plan.status}`);
+    console.error(`Created: ${plan.created_at}`);
+    if (plan.plan_payload) {
+      console.error(`Payload: ${JSON.stringify(plan.plan_payload, null, 2)}`);
+    }
+  }
+}
+async function handlePlanApprove(args, asJson) {
+  const planId = args["plan-id"];
+  if (typeof planId !== "string") {
+    throw new Error("Missing required flag: --plan-id");
+  }
+  const userId = await ensureAuth5();
+  const { data, error } = await callEdgeFunction("mcp-data", {
+    action: "respond-plan-approval",
+    userId,
+    planId,
+    response: "approved"
+  });
+  if (error || !data) {
+    throw new Error(`Failed to approve plan: ${error ?? "Unknown error"}`);
+  }
+  if (asJson) {
+    emitSnResult(
+      {
+        ok: data.success,
+        command: "plan approve",
+        planId,
+        message: data.message ?? "Plan approved"
+      },
+      true
+    );
+  } else {
+    console.error(`Plan ${planId}: ${data.success ? "Approved" : "Failed"}`);
+    if (data.message) {
+      console.error(data.message);
+    }
+  }
+}
+async function handlePlan(args, asJson) {
+  const subcommand = args._[0];
+  if (!subcommand || args.help === true) {
+    console.error(PLAN_USAGE);
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      return handlePlanList({ ...args, _: args._.slice(1) }, asJson);
+    case "view":
+      return handlePlanView({ ...args, _: args._.slice(1) }, asJson);
+    case "approve":
+      return handlePlanApprove({ ...args, _: args._.slice(1) }, asJson);
+    default:
+      throw new Error(`Unknown plan subcommand: '${subcommand}'. Run 'sn plan --help' for usage.`);
+  }
+}
+var PLAN_USAGE;
+var init_planning = __esm({
+  "src/cli/sn/planning.ts"() {
+    "use strict";
+    init_edge_function();
+    init_supabase();
+    init_parse();
+    PLAN_USAGE = `Usage: sn plan <subcommand> [flags]
+
+Subcommands:
+  list      List content plans
+  view      View a single content plan
+  approve   Approve a content plan
+
+Flags:
+  list:
+    --status <draft|submitted|approved>   Filter by status (optional)
+
+  view:
+    --plan-id <id>                        Plan ID (required)
+
+  approve:
+    --plan-id <id>                        Plan ID (required)
+`;
+  }
+});
+
+// src/cli/sn/presets.ts
+var presets_exports = {};
+__export(presets_exports, {
+  BUILTIN_PRESETS: () => BUILTIN_PRESETS,
+  handlePreset: () => handlePreset,
+  resolvePreset: () => resolvePreset
+});
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function loadUserPresets() {
+  if (!existsSync2(PRESETS_FILE)) return [];
+  try {
+    const raw = readFileSync2(PRESETS_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function saveUserPresets(presets) {
+  if (!existsSync2(PRESETS_DIR)) {
+    mkdirSync2(PRESETS_DIR, { recursive: true });
+  }
+  writeFileSync2(PRESETS_FILE, JSON.stringify(presets, null, 2) + "\n", "utf-8");
+}
+function resolvePreset(name) {
+  const lower = name.toLowerCase();
+  const builtin = BUILTIN_PRESETS.find((p) => p.name === lower);
+  if (builtin) return builtin;
+  const userPresets = loadUserPresets();
+  return userPresets.find((p) => p.name === lower) ?? null;
+}
+function handlePresetList(asJson) {
+  const all = [...BUILTIN_PRESETS, ...loadUserPresets()];
+  if (asJson) {
+    emitSnResult({ ok: true, command: "preset", presets: all, count: all.length }, asJson);
+    return;
+  }
+  const header = "NAME                 PLATFORM     MAX-LEN  RATIO    SOURCE";
+  const lines = all.map((p) => {
+    const name = p.name.padEnd(20);
+    const plat = p.platform.padEnd(12);
+    const len = String(p.maxLength).padEnd(8);
+    const ratio = (p.aspectRatio ?? "-").padEnd(8);
+    const src = p.builtin ? "builtin" : "user";
+    return `${name} ${plat} ${len} ${ratio} ${src}`;
+  });
+  process.stdout.write(header + "\n" + lines.join("\n") + "\n");
+}
+function handlePresetShow(args, asJson) {
+  const name = args["name"];
+  if (!name || typeof name !== "string") {
+    throw new Error('--name is required for "preset show"');
+  }
+  const preset = resolvePreset(name);
+  if (!preset) {
+    throw new Error(`Preset "${name}" not found`);
+  }
+  if (asJson) {
+    emitSnResult({ ok: true, command: "preset", preset }, asJson);
+    return;
+  }
+  process.stdout.write(
+    `name:       ${preset.name}
+platform:   ${preset.platform}
+maxLength:  ${preset.maxLength}
+aspectRatio: ${preset.aspectRatio ?? "-"}
+source:     ${preset.builtin ? "builtin" : "user"}
+`
+  );
+}
+function handlePresetSave(args, asJson) {
+  const name = args["name"];
+  if (!name || typeof name !== "string") {
+    throw new Error('--name is required for "preset save"');
+  }
+  const platform3 = args["platform"];
+  if (!platform3 || typeof platform3 !== "string") {
+    throw new Error('--platform is required for "preset save"');
+  }
+  const maxLengthRaw = args["max-length"];
+  if (!maxLengthRaw) {
+    throw new Error('--max-length is required for "preset save"');
+  }
+  const maxLength = Number(maxLengthRaw);
+  if (!Number.isFinite(maxLength) || maxLength <= 0) {
+    throw new Error("--max-length must be a positive number");
+  }
+  const lowerName = name.toLowerCase();
+  if (BUILTIN_PRESETS.some((p) => p.name === lowerName)) {
+    throw new Error(`Cannot overwrite builtin preset "${lowerName}"`);
+  }
+  const aspectRatio = typeof args["aspect-ratio"] === "string" ? args["aspect-ratio"] : void 0;
+  const preset = {
+    name: lowerName,
+    platform: platform3,
+    maxLength,
+    aspectRatio,
+    builtin: false
+  };
+  const userPresets = loadUserPresets();
+  const idx = userPresets.findIndex((p) => p.name === lowerName);
+  if (idx >= 0) {
+    userPresets[idx] = preset;
+  } else {
+    userPresets.push(preset);
+  }
+  saveUserPresets(userPresets);
+  if (asJson) {
+    emitSnResult({ ok: true, command: "preset", saved: preset }, asJson);
+    return;
+  }
+  process.stdout.write(`Preset "${lowerName}" saved.
+`);
+}
+function handlePresetDelete(args, asJson) {
+  const name = args["name"];
+  if (!name || typeof name !== "string") {
+    throw new Error('--name is required for "preset delete"');
+  }
+  const lowerName = name.toLowerCase();
+  if (BUILTIN_PRESETS.some((p) => p.name === lowerName)) {
+    throw new Error(`Cannot delete builtin preset "${lowerName}"`);
+  }
+  const userPresets = loadUserPresets();
+  const idx = userPresets.findIndex((p) => p.name === lowerName);
+  if (idx < 0) {
+    throw new Error(`User preset "${lowerName}" not found`);
+  }
+  userPresets.splice(idx, 1);
+  saveUserPresets(userPresets);
+  if (asJson) {
+    emitSnResult({ ok: true, command: "preset", deleted: lowerName }, asJson);
+    return;
+  }
+  process.stdout.write(`Preset "${lowerName}" deleted.
+`);
+}
+async function handlePreset(args, asJson) {
+  const sub = args._[0];
+  if (!sub || sub === "--help" || args["help"] === true) {
+    process.stdout.write(USAGE);
+    return;
+  }
+  switch (sub) {
+    case "list":
+      return handlePresetList(asJson);
+    case "show":
+      return handlePresetShow(args, asJson);
+    case "save":
+      return handlePresetSave(args, asJson);
+    case "delete":
+      return handlePresetDelete(args, asJson);
+    default:
+      throw new Error(`Unknown preset sub-command: "${sub}". Run "sn preset --help" for usage.`);
+  }
+}
+var BUILTIN_PRESETS, PRESETS_DIR, PRESETS_FILE, USAGE;
+var init_presets = __esm({
+  "src/cli/sn/presets.ts"() {
+    "use strict";
+    init_parse();
+    BUILTIN_PRESETS = [
+      {
+        name: "instagram-reel",
+        platform: "Instagram",
+        maxLength: 2200,
+        aspectRatio: "9:16",
+        builtin: true
+      },
+      {
+        name: "instagram-post",
+        platform: "Instagram",
+        maxLength: 2200,
+        aspectRatio: "1:1",
+        builtin: true
+      },
+      { name: "tiktok", platform: "TikTok", maxLength: 4e3, aspectRatio: "9:16", builtin: true },
+      {
+        name: "youtube-short",
+        platform: "YouTube",
+        maxLength: 5e3,
+        aspectRatio: "9:16",
+        builtin: true
+      },
+      { name: "linkedin-post", platform: "LinkedIn", maxLength: 3e3, builtin: true },
+      { name: "twitter-post", platform: "Twitter", maxLength: 280, builtin: true }
+    ];
+    PRESETS_DIR = join2(homedir2(), ".config", "socialneuron");
+    PRESETS_FILE = join2(PRESETS_DIR, "presets.json");
+    USAGE = `Usage: sn preset <sub-command> [options]
+
+Sub-commands:
+  list                          List all presets (builtin + user)
+  show   --name <preset>        Show a single preset
+  save   --name <n> --platform <p> --max-length <len> [--aspect-ratio <r>]
+  delete --name <preset>        Delete a user preset
+`;
+  }
+});
+
+// src/cli/sn.ts
+var sn_exports = {};
+__export(sn_exports, {
+  printSnUsage: () => printSnUsage,
+  runSnCli: () => runSnCli
+});
+function lazyContent(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_content(), content_exports));
+    return mod[name](args, asJson);
+  };
+}
+function lazyAccount(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_account(), account_exports));
+    return mod[name](args, asJson);
+  };
+}
+function lazyAnalytics(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_analytics(), analytics_exports));
+    return mod[name](args, asJson);
+  };
+}
+function lazySystem(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_system(), system_exports));
+    return mod[name](args, asJson);
+  };
+}
+function lazyDiscovery(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+    return mod[name](args, asJson);
+  };
+}
+function lazyPlanning(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_planning(), planning_exports));
+    return mod[name](args, asJson);
+  };
+}
+function lazyPresets(name) {
+  return async (args, asJson) => {
+    const mod = await Promise.resolve().then(() => (init_presets(), presets_exports));
+    return mod[name](args, asJson);
+  };
+}
+function printSnUsage() {
+  console.error("");
+  console.error("Usage: socialneuron-mcp sn <command> [flags]");
+  console.error("");
+  console.error("Discovery:");
+  console.error("  tools [--scope <scope>] [--module <module>] [--json]");
+  console.error("  info [--json]");
+  console.error("");
+  console.error("Content:");
+  console.error(
+    "  publish --media-url <url> --caption <text> --platforms <comma-list> --confirm [--title <text>] [--schedule-at <iso8601>] [--idempotency-key <key>] [--json]"
+  );
+  console.error(
+    "  quality-check --caption <text> [--title <text>] [--platforms <comma-list>] [--threshold <0-35>] [--json]"
+  );
+  console.error(
+    "  e2e --media-url <url> --caption <text> --platforms <comma-list> --confirm [--title <text>] [--schedule-at <iso8601>] [--check-urls] [--threshold <0-35>] [--dry-run] [--force] [--json]"
+  );
+  console.error(
+    "  plan (list|view|approve) [--plan-id <id>] [--status <draft|submitted|approved>] [--json]"
+  );
+  console.error(
+    "  preset (list|show|save|delete) [--name <name>] [--platform <name>] [--max-length <n>] [--aspect-ratio <ratio>] [--json]"
+  );
+  console.error("");
+  console.error("Account:");
+  console.error("  preflight [--privacy-url <url>] [--terms-url <url>] [--check-urls] [--json]");
+  console.error("  oauth-health [--warn-days <1-90>] [--platforms <comma-list>] [--all] [--json]");
+  console.error("  oauth-refresh (--platforms <comma-list> | --all) [--json]");
+  console.error("");
+  console.error("Analytics:");
+  console.error(
+    "  posts [--days <1-90>] [--platform <name>] [--status <draft|scheduled|published|failed>] [--json]"
+  );
+  console.error("  refresh-analytics [--json]");
+  console.error("  loop [--json]");
+  console.error("");
+  console.error("System:");
+  console.error("  status --job-id <id> [--json]");
+  console.error("  autopilot [--json]");
+  console.error("  usage [--json]");
+  console.error("  credits [--json]");
+  console.error("");
+}
+async function runSnCli(argv) {
+  const [first, ...rest] = argv;
+  if (!first) {
+    printSnUsage();
+    process.exit(1);
+  }
+  if (GROUP_COMMANDS[first]) {
+    const [subcommand, ...groupRest] = rest;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+      console.error(`
+Commands in "${first}" group:`);
+      for (const cmd of GROUP_COMMANDS[first]) {
+        console.error(`  ${cmd}`);
+      }
+      console.error("");
+      process.exit(subcommand ? 0 : 1);
+    }
+    const entry2 = COMMAND_REGISTRY[subcommand];
+    if (!entry2 || entry2.group !== first) {
+      console.error(`Unknown ${first} subcommand: ${subcommand}`);
+      console.error(`Available: ${GROUP_COMMANDS[first].join(", ")}`);
+      process.exit(1);
+    }
+    const args2 = parseSnArgs(groupRest);
+    const asJson2 = isEnabledFlag(args2.json);
+    await withSnErrorHandling(subcommand, asJson2, () => entry2.handler(args2, asJson2));
+    return;
+  }
+  const entry = COMMAND_REGISTRY[first];
+  if (!entry) {
+    console.error(`Unknown subcommand: ${first}`);
+    printSnUsage();
+    process.exit(1);
+  }
+  const args = parseSnArgs(rest);
+  const asJson = isEnabledFlag(args.json);
+  await withSnErrorHandling(first, asJson, () => entry.handler(args, asJson));
+}
+var COMMAND_REGISTRY, GROUP_COMMANDS;
+var init_sn = __esm({
+  "src/cli/sn.ts"() {
+    "use strict";
+    init_parse();
+    init_error_handling();
+    COMMAND_REGISTRY = {
+      publish: { handler: lazyContent("handlePublish"), needsAuth: true, group: "content" },
+      "quality-check": {
+        handler: lazyContent("handleQualityCheck"),
+        needsAuth: false,
+        group: "content"
+      },
+      e2e: { handler: lazyContent("handleE2e"), needsAuth: true, group: "content" },
+      "oauth-health": {
+        handler: lazyAccount("handleOauthHealth"),
+        needsAuth: true,
+        group: "account"
+      },
+      "oauth-refresh": {
+        handler: lazyAccount("handleOauthRefresh"),
+        needsAuth: true,
+        group: "account"
+      },
+      preflight: { handler: lazyAccount("handlePreflight"), needsAuth: true, group: "account" },
+      status: { handler: lazySystem("handleStatus"), needsAuth: true, group: "system" },
+      autopilot: { handler: lazySystem("handleAutopilot"), needsAuth: true, group: "system" },
+      usage: { handler: lazySystem("handleUsage"), needsAuth: true, group: "system" },
+      credits: { handler: lazySystem("handleCredits"), needsAuth: true, group: "system" },
+      posts: { handler: lazyAnalytics("handlePosts"), needsAuth: true, group: "analytics" },
+      "refresh-analytics": {
+        handler: lazyAnalytics("handleRefreshAnalytics"),
+        needsAuth: true,
+        group: "analytics"
+      },
+      loop: { handler: lazyAnalytics("handleLoop"), needsAuth: true, group: "analytics" },
+      tools: { handler: lazyDiscovery("handleTools"), needsAuth: false, group: "discovery" },
+      info: { handler: lazyDiscovery("handleInfo"), needsAuth: false, group: "discovery" },
+      plan: { handler: lazyPlanning("handlePlan"), needsAuth: true, group: "content" },
+      preset: { handler: lazyPresets("handlePreset"), needsAuth: false, group: "content" }
+    };
+    GROUP_COMMANDS = {
+      content: ["publish", "quality-check", "e2e", "plan", "preset"],
+      account: ["oauth-health", "oauth-refresh", "preflight"],
+      analytics: ["posts", "refresh-analytics", "loop"],
+      system: ["status", "autopilot", "usage", "credits"],
+      discovery: ["tools", "info"]
+    };
+  }
+});
+
+// src/cli/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  generatePKCE: () => generatePKCE,
+  getAppBaseUrl: () => getAppBaseUrl,
+  runLogout: () => runLogout,
+  runSetup: () => runSetup
+});
+import { createHash as createHash3, randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import { createServer } from "node:http";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3, platform as platform2 } from "node:os";
+import { join as join3 } from "node:path";
+function base64url(buffer) {
+  return buffer.toString("base64url");
+}
+function generatePKCE() {
+  const verifierBytes = randomBytes(32);
+  const codeVerifier = base64url(verifierBytes);
+  const challengeHash = createHash3("sha256").update(codeVerifier).digest();
+  const codeChallenge = base64url(challengeHash);
+  return { codeVerifier, codeChallenge };
+}
+function getAppBaseUrl() {
+  return process.env.SOCIALNEURON_APP_URL || "https://www.socialneuron.com";
+}
+function getDefaultSupabaseUrl() {
+  return process.env.SOCIALNEURON_SUPABASE_URL || process.env.SUPABASE_URL || CLOUD_SUPABASE_URL;
+}
+function getConfigPaths() {
+  const paths = [];
+  const os = platform2();
+  if (os === "darwin") {
+    paths.push({
+      path: join3(
+        homedir3(),
+        "Library",
+        "Application Support",
+        "Claude",
+        "claude_desktop_config.json"
+      ),
+      name: "Claude Desktop"
+    });
+  } else if (os === "linux") {
+    paths.push({
+      path: join3(homedir3(), ".config", "claude", "claude_desktop_config.json"),
+      name: "Claude Desktop"
+    });
+  }
+  const claudeCodeGlobal = join3(homedir3(), ".claude", ".mcp.json");
+  if (existsSync3(claudeCodeGlobal)) {
+    paths.push({ path: claudeCodeGlobal, name: "Claude Code (global)" });
+  }
+  const projectConfig = join3(process.cwd(), ".mcp.json");
+  if (existsSync3(projectConfig)) {
+    paths.push({ path: projectConfig, name: "Claude Code (project)" });
+  }
+  return paths;
+}
+function configureMcpClient(configPath) {
+  try {
+    let config = {};
+    if (existsSync3(configPath)) {
+      const raw = readFileSync3(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } else {
+      const dir = join3(configPath, "..");
+      if (!existsSync3(dir)) {
+        mkdirSync3(dir, { recursive: true });
+      }
+    }
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    config.mcpServers["socialneuron"] = {
+      command: "npx",
+      args: ["-y", "@socialneuron/mcp-server"]
+    };
+    writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function completePkceExchange(codeVerifier, state) {
+  const supabaseUrl = getDefaultSupabaseUrl();
+  try {
+    const response = await fetch(`${supabaseUrl}/functions/v1/mcp-auth?action=exchange-key`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code_verifier: codeVerifier, state })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(`  PKCE exchange failed: ${text}`);
+      return false;
+    }
+    const data = await response.json();
+    return data.success === true;
+  } catch (err) {
+    console.error(`  PKCE exchange error: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+async function runSetup() {
+  console.error("");
+  console.error("  Social Neuron MCP Server Setup");
+  console.error("  ==============================");
+  console.error("");
+  console.error("  Privacy Notice:");
+  console.error("  - Your API key is stored locally in your OS keychain");
+  console.error("  - Tool invocations are logged for usage metering (no content stored)");
+  console.error("  - Set DO_NOT_TRACK=1 to disable telemetry");
+  console.error("  - Data export/delete: https://www.socialneuron.com/settings");
+  console.error("");
+  const { codeVerifier, codeChallenge } = generatePKCE();
+  const state = randomUUID2();
+  const { server, port } = await new Promise((resolve, reject) => {
+    const srv = createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      resolve({ server: srv, port: addr.port });
+    });
+    srv.on("error", reject);
+  });
+  const baseUrl = getAppBaseUrl();
+  const authorizeUrl = new URL("/mcp/authorize", baseUrl);
+  authorizeUrl.searchParams.set("callback_port", String(port));
+  authorizeUrl.searchParams.set("code_challenge", codeChallenge);
+  authorizeUrl.searchParams.set("code_challenge_method", "S256");
+  authorizeUrl.searchParams.set("state", state);
+  try {
+    const open = (await import("open")).default;
+    await open(authorizeUrl.toString());
+    console.error("  Opening browser for authorization...");
+    console.error(`  URL: ${authorizeUrl.toString()}`);
+    console.error("");
+    console.error("  Waiting for authorization (timeout: 120s)...");
+  } catch {
+    console.error("  Could not open browser automatically.");
+    console.error("  Please open the following URL manually:");
+    console.error("");
+    console.error(`  ${authorizeUrl.toString()}`);
+    console.error("");
+    console.error("  Waiting for authorization (timeout: 120s)...");
+  }
+  const result = await new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      resolve({ error: "Authorization timed out after 120 seconds." });
+    }, 12e4);
+    server.on("request", async (req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method === "POST" && req.url === "/callback") {
+        try {
+          const body = await readBody(req);
+          const data = JSON.parse(body);
+          if (data.state !== state) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "State mismatch" }));
+            return;
+          }
+          if (!data.api_key) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Missing api_key" }));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true }));
+          clearTimeout(timeout);
+          server.close();
+          resolve({ apiKey: data.api_key });
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid request" }));
+        }
+        return;
+      }
+      res.writeHead(404);
+      res.end("Not found");
+    });
+  });
+  if ("error" in result) {
+    console.error("");
+    console.error(`  Error: ${result.error}`);
+    console.error('  Run "npx @socialneuron/mcp-server setup" to try again.');
+    process.exit(1);
+  }
+  console.error("");
+  console.error("  Completing PKCE verification...");
+  const exchangeSuccess = await completePkceExchange(codeVerifier, state);
+  if (!exchangeSuccess) {
+    console.error("  Warning: PKCE exchange failed. Key may not be activated.");
+    console.error("  The key will still work if the server was in legacy mode.");
+  } else {
+    console.error("  PKCE verification complete.");
+  }
+  const apiKey = result.apiKey;
+  await saveApiKey(apiKey);
+  const supabaseUrl = getDefaultSupabaseUrl();
+  await saveSupabaseUrl(supabaseUrl);
+  console.error("");
+  console.error("  API key stored securely.");
+  console.error(`  Key prefix: ${apiKey.substring(0, 12)}...`);
+  const configPaths = getConfigPaths();
+  let configured = false;
+  for (const { path, name } of configPaths) {
+    if (configureMcpClient(path)) {
+      console.error(`  Configured ${name}: ${path}`);
+      configured = true;
+    }
+  }
+  if (!configured) {
+    console.error("");
+    console.error("  No MCP client config found. Add this to your MCP config manually:");
+    console.error("");
+    console.error('    "socialneuron": {');
+    console.error('      "command": "npx",');
+    console.error('      "args": ["-y", "@socialneuron/mcp-server"]');
+    console.error("    }");
+  }
+  console.error("");
+  console.error("  Setup complete!");
+  console.error("");
+}
+async function runLogout() {
+  await deleteApiKey();
+  console.error("");
+  console.error("  Logged out. API key removed.");
+  console.error("");
+}
+var init_setup = __esm({
+  "src/cli/setup.ts"() {
+    "use strict";
+    init_credentials();
+    init_supabase();
+  }
+});
+
+// src/lib/validation-cache.ts
+var validation_cache_exports = {};
+__export(validation_cache_exports, {
+  clearValidationCache: () => clearValidationCache,
+  keyFingerprint: () => keyFingerprint,
+  readValidationCache: () => readValidationCache,
+  writeValidationCache: () => writeValidationCache
+});
+import { createHash as createHash4 } from "node:crypto";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, chmodSync } from "node:fs";
+import { join as join4 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+function keyFingerprint(apiKey) {
+  return `sha256:${createHash4("sha256").update(apiKey, "utf8").digest("hex")}`;
+}
+function readValidationCache(apiKey) {
+  try {
+    const raw = readFileSync4(CACHE_FILE, "utf-8");
+    const cached = JSON.parse(raw);
+    if (cached.keyFingerprint !== keyFingerprint(apiKey)) {
+      return null;
+    }
+    if (Date.now() - cached.cachedAt > CACHE_TTL_MS) {
+      return null;
+    }
+    if (!cached.result.valid) {
+      return null;
+    }
+    if (cached.result.expiresAt) {
+      const expiresMs = new Date(cached.result.expiresAt).getTime();
+      if (expiresMs <= Date.now()) {
+        return null;
+      }
+    }
+    return cached.result;
+  } catch {
+    return null;
+  }
+}
+function writeValidationCache(apiKey, result) {
+  if (!result.valid) return;
+  try {
+    mkdirSync4(CONFIG_DIR2, { recursive: true });
+    const entry = {
+      keyFingerprint: keyFingerprint(apiKey),
+      result,
+      cachedAt: Date.now()
+    };
+    writeFileSync4(CACHE_FILE, JSON.stringify(entry, null, 2), { mode: 384 });
+    try {
+      chmodSync(CACHE_FILE, 384);
+    } catch {
+    }
+  } catch {
+  }
+}
+function clearValidationCache() {
+  try {
+    writeFileSync4(CACHE_FILE, "{}", { mode: 384 });
+  } catch {
+  }
+}
+var CONFIG_DIR2, CACHE_FILE, CACHE_TTL_MS;
+var init_validation_cache = __esm({
+  "src/lib/validation-cache.ts"() {
+    "use strict";
+    CONFIG_DIR2 = join4(homedir4(), ".config", "socialneuron");
+    CACHE_FILE = join4(CONFIG_DIR2, "validation-cache.json");
+    CACHE_TTL_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/cli/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  runHealthCheck: () => runHealthCheck,
+  runLogin: () => runLogin,
+  runLogoutCommand: () => runLogoutCommand,
+  runWhoami: () => runWhoami
+});
+import { createInterface } from "node:readline";
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function getDefaultSupabaseUrl2() {
+  return process.env.SOCIALNEURON_SUPABASE_URL || process.env.SUPABASE_URL || CLOUD_SUPABASE_URL;
+}
+async function runLogin(method) {
+  if (method === "browser") {
+    await runSetup();
+    return;
+  }
+  if (method === "paste") {
+    await runLoginPaste();
+    return;
+  }
+  if (method === "device") {
+    await runLoginDevice();
+    return;
+  }
+}
+async function runLoginPaste() {
+  console.error("");
+  console.error("  Social Neuron - Paste API Key");
+  console.error("  =============================");
+  console.error("");
+  console.error("  Paste your API key (starts with snk_live_):");
+  const key = await prompt("  > ");
+  if (!key || !key.startsWith("snk_live_")) {
+    console.error("");
+    console.error("  Error: Invalid key format. Must start with snk_live_");
+    process.exit(1);
+  }
+  console.error("");
+  console.error("  Validating key...");
+  const result = await validateApiKey(key);
+  if (!result.valid) {
+    console.error(
+      `  Error: Key validation failed. ${result.error || "Key may be revoked or expired."}`
+    );
+    process.exit(1);
+  }
+  await saveApiKey(key);
+  await saveSupabaseUrl(getDefaultSupabaseUrl2());
+  console.error("");
+  console.error("  API key saved securely.");
+  console.error(`  User: ${result.email || "unknown"}`);
+  console.error(`  Scopes: ${result.scopes?.join(", ") || "mcp:full"}`);
+  if (result.expiresAt) {
+    const daysLeft = Math.ceil(
+      (new Date(result.expiresAt).getTime() - Date.now()) / (1e3 * 60 * 60 * 24)
+    );
+    console.error(`  Expires: ${result.expiresAt} (${daysLeft} days)`);
+  }
+  console.error("");
+}
+async function runLoginDevice() {
+  console.error("");
+  console.error("  Social Neuron - Device Authorization");
+  console.error("  ====================================");
+  console.error("");
+  const supabaseUrl = getDefaultSupabaseUrl2();
+  const response = await fetch(`${supabaseUrl}/functions/v1/mcp-auth?action=device-code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    console.error(`  Error: Failed to create device code. ${text}`);
+    process.exit(1);
+  }
+  const data = await response.json();
+  console.error(`  Go to: ${data.verification_uri}`);
+  console.error("");
+  console.error(`  Enter code: ${data.user_code}`);
+  console.error("");
+  console.error(
+    `  Waiting for authorization (expires in ${Math.floor(data.expires_in / 60)} min)...`
+  );
+  try {
+    const open = (await import("open")).default;
+    await open(data.verification_uri);
+  } catch {
+  }
+  const pollInterval = (data.interval || 5) * 1e3;
+  const GRACE_MS = 3e4;
+  const deadline = Date.now() + data.expires_in * 1e3 + GRACE_MS;
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    if (Date.now() > deadline) {
+      break;
+    }
+    let pollResponse;
+    try {
+      pollResponse = await fetch(`${supabaseUrl}/functions/v1/mcp-auth?action=device-poll`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: data.device_code })
+      });
+    } catch {
+      continue;
+    }
+    if (pollResponse.status === 200) {
+      const pollData = await pollResponse.json();
+      if (pollData.api_key) {
+        try {
+          await saveApiKey(pollData.api_key);
+        } catch (saveErr) {
+          console.error("");
+          console.error("  Warning: Could not save API key securely.");
+          console.error(`  Error: ${saveErr instanceof Error ? saveErr.message : String(saveErr)}`);
+          console.error("");
+          console.error("  For security, the API key was not printed to the terminal.");
+          console.error("  Create or copy an API key from your Social Neuron dashboard, then run:");
+          console.error("  npx @socialneuron/mcp-server login --paste");
+          console.error("");
+          return;
+        }
+        try {
+          await saveSupabaseUrl(supabaseUrl);
+        } catch (saveErr) {
+          console.error("");
+          console.error("  Authorized!");
+          console.error(`  Key prefix: ${pollData.api_key.substring(0, 12)}...`);
+          console.error("");
+          console.error("  Warning: API key saved, but could not save the Supabase URL.");
+          console.error(`  Error: ${saveErr instanceof Error ? saveErr.message : String(saveErr)}`);
+          console.error("  If needed, set SOCIALNEURON_SUPABASE_URL to your Supabase URL.");
+          console.error("");
+          return;
+        }
+        console.error("");
+        console.error("  Authorized!");
+        console.error(`  Key prefix: ${pollData.api_key.substring(0, 12)}...`);
+        console.error("");
+        return;
+      }
+    }
+    if (pollResponse.status === 410) {
+      const expiredData = await pollResponse.json().catch(() => ({}));
+      if (expiredData.authorized) {
+        const dashUrl = expiredData.dashboard_url || "https://www.socialneuron.com/settings?tab=api-keys";
+        console.error("");
+        console.error("  Your browser confirmed the code and a key WAS issued on the server,");
+        console.error("  but the CLI polled after the 15-minute server TTL elapsed.");
+        console.error("");
+        console.error("  To recover your key:");
+        console.error(`  1. Open: ${dashUrl}`);
+        console.error('  2. Copy the key named "Device Auth (\u2026)"');
+        console.error("  3. Run: npx @socialneuron/mcp-server login --paste");
+        console.error("");
+        process.exit(1);
+      }
+      console.error("");
+      console.error("  Error: Device code expired. Please try again.");
+      process.exit(1);
+    }
+  }
+  console.error("");
+  console.error("  Error: Authorization timed out. Please try again.");
+  process.exit(1);
+}
+async function runLogoutCommand(options) {
+  const asJson = options?.json ?? false;
+  if (!asJson) {
+    console.error("");
+    console.error("  Social Neuron - Logout");
+    console.error("  ======================");
+    console.error("");
+  }
+  const apiKey = await loadApiKey();
+  if (apiKey) {
+    try {
+      const validation = await validateApiKey(apiKey);
+      if (validation.valid && !asJson) {
+        console.error("  Key removed from this device.");
+        console.error(
+          "  Note: To revoke the key server-side, visit https://www.socialneuron.com/settings/developer"
+        );
+      }
+    } catch {
+    }
+  }
+  await deleteApiKey();
+  const { clearValidationCache: clearValidationCache2 } = await Promise.resolve().then(() => (init_validation_cache(), validation_cache_exports));
+  clearValidationCache2();
+  if (asJson) {
+    process.stdout.write(
+      JSON.stringify({ ok: true, message: "Credentials removed", schema_version: "1" }, null, 2) + "\n"
+    );
+  } else {
+    console.error("  Credentials removed from keychain.");
+    console.error("");
+  }
+}
+async function runWhoami(options) {
+  const asJson = options?.json ?? false;
+  const apiKey = await loadApiKey();
+  if (!apiKey) {
+    if (asJson) {
+      process.stdout.write(
+        JSON.stringify({ ok: false, error: "Not logged in", schema_version: "1" }, null, 2) + "\n"
+      );
+    } else {
+      console.error("");
+      console.error("  Not logged in.");
+      console.error("  Run: npx @socialneuron/mcp-server login");
+      console.error("");
+    }
+    process.exit(1);
+  }
+  if (!asJson) {
+    console.error("");
+    console.error("  Social Neuron - Current Identity");
+    console.error("  ================================");
+    console.error("");
+    console.error("  Validating key...");
+  }
+  const result = await validateApiKey(apiKey);
+  if (!result.valid) {
+    if (asJson) {
+      process.stdout.write(
+        JSON.stringify(
+          { ok: false, error: result.error || "Key invalid or expired", schema_version: "1" },
+          null,
+          2
+        ) + "\n"
+      );
+    } else {
+      console.error("  Key is invalid or expired.");
+      console.error(`  Error: ${result.error || "Unknown"}`);
+      console.error("  Run: npx @socialneuron/mcp-server login");
+      console.error("");
+    }
+    process.exit(1);
+  }
+  if (asJson) {
+    const payload = {
+      ok: true,
+      email: result.email || null,
+      userId: result.userId,
+      keyPrefix: apiKey.substring(0, 12) + "...",
+      scopes: result.scopes || ["mcp:full"],
+      schema_version: "1"
+    };
+    if (result.expiresAt) payload.expiresAt = result.expiresAt;
+    process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+  } else {
+    console.error("");
+    console.error(`  Email:    ${result.email || "(not available)"}`);
+    console.error(`  User ID:  ${result.userId}`);
+    console.error(`  Key:      ${apiKey.substring(0, 12)}...`);
+    console.error(`  Scopes:   ${result.scopes?.join(", ") || "mcp:full"}`);
+    if (result.expiresAt) {
+      const expiresMs = new Date(result.expiresAt).getTime();
+      const daysLeft = Math.ceil((expiresMs - Date.now()) / (1e3 * 60 * 60 * 24));
+      console.error(`  Expires:  ${result.expiresAt} (${daysLeft} days)`);
+      if (daysLeft <= 7) {
+        console.error("");
+        console.error(`  Warning: Key expires in ${daysLeft} day(s).`);
+        console.error("  Run: npx @socialneuron/mcp-server login");
+      }
+    } else {
+      console.error("  Expires:  never");
+    }
+    console.error("");
+  }
+}
+async function runHealthCheck(options) {
+  const asJson = options?.json ?? false;
+  if (!asJson) {
+    console.error("");
+    console.error("  Social Neuron \u2014 Health Check");
+    console.error("  ============================");
+    console.error("");
+  }
+  const checks = [];
+  const apiKey = await loadApiKey();
+  if (!apiKey) {
+    checks.push({
+      name: "API Key",
+      ok: false,
+      detail: "No key stored. Run: socialneuron-mcp login"
+    });
+  } else {
+    checks.push({ name: "API Key", ok: true, detail: `${apiKey.substring(0, 12)}...` });
+    try {
+      const result = await validateApiKey(apiKey);
+      if (result.valid) {
+        checks.push({
+          name: "Key Valid",
+          ok: true,
+          detail: `User: ${result.email || result.userId}`
+        });
+        checks.push({
+          name: "Scopes",
+          ok: (result.scopes?.length ?? 0) > 0,
+          detail: result.scopes?.join(", ") || "none"
+        });
+        if (result.expiresAt) {
+          const daysLeft = Math.ceil(
+            (new Date(result.expiresAt).getTime() - Date.now()) / (1e3 * 60 * 60 * 24)
+          );
+          checks.push({
+            name: "Expiry",
+            ok: daysLeft > 7,
+            detail: daysLeft > 0 ? `${daysLeft} days remaining` : "EXPIRED"
+          });
+        } else {
+          checks.push({ name: "Expiry", ok: true, detail: "No expiration" });
+        }
+      } else {
+        checks.push({ name: "Key Valid", ok: false, detail: result.error || "Invalid or revoked" });
+      }
+    } catch (err) {
+      checks.push({
+        name: "Connectivity",
+        ok: false,
+        detail: err instanceof Error ? err.message : "Failed to reach server"
+      });
+    }
+  }
+  const supabaseUrl = getSupabaseUrl();
+  checks.push({
+    name: "Supabase URL",
+    ok: supabaseUrl.startsWith("https://"),
+    detail: supabaseUrl
+  });
+  try {
+    const response = await fetch(`${supabaseUrl}/rest/v1/`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3)
+    });
+    checks.push({
+      name: "Connectivity",
+      ok: response.status < 500,
+      detail: `HTTP ${response.status}`
+    });
+  } catch (err) {
+    checks.push({
+      name: "Connectivity",
+      ok: false,
+      detail: err instanceof Error ? err.message : "Network error"
+    });
+  }
+  if (apiKey) {
+    try {
+      const { callEdgeFunction: callEdgeFunction2 } = await Promise.resolve().then(() => (init_edge_function(), edge_function_exports));
+      const { data, error } = await callEdgeFunction2("mcp-data", { action: "credit-balance" });
+      if (!error && data?.success && data.balance !== void 0) {
+        checks.push({
+          name: "Credits",
+          ok: data.balance > 0,
+          detail: `${data.balance} credits available`
+        });
+      }
+    } catch {
+    }
+  }
+  const allOk = checks.every((c) => c.ok);
+  if (asJson) {
+    const checksObj = {};
+    for (const check of checks) {
+      checksObj[check.name.toLowerCase().replace(/\s+/g, "_")] = {
+        status: check.ok ? "pass" : "fail",
+        detail: check.detail
+      };
+    }
+    process.stdout.write(
+      JSON.stringify({ ok: allOk, checks: checksObj, schema_version: "1" }, null, 2) + "\n"
+    );
+  } else {
+    for (const check of checks) {
+      const icon = check.ok ? "\u2713" : "\u2717";
+      console.error(`  ${icon} ${check.name}: ${check.detail}`);
+    }
+    console.error("");
+    console.error(`  Overall: ${allOk ? "All checks passed" : "Some checks failed"}`);
+    console.error("");
+  }
+  if (!allOk) {
+    process.exit(1);
+  }
+}
+var init_commands = __esm({
+  "src/cli/commands.ts"() {
+    "use strict";
+    init_credentials();
+    init_setup();
+    init_api_keys();
+    init_supabase();
+  }
+});
+
+// src/cli/repl.ts
+var repl_exports = {};
+__export(repl_exports, {
+  runRepl: () => runRepl
+});
+import { createInterface as createInterface2 } from "node:readline";
+async function runRepl() {
+  process.stderr.write(`
+Social Neuron CLI v${MCP_VERSION} \u2014 Interactive Mode
+`);
+  process.stderr.write("Type a command, .help for help, or .exit to quit.\n\n");
+  let authEmail = null;
+  try {
+    const { loadApiKey: loadApiKey2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+    const { validateApiKey: validateApiKey2 } = await Promise.resolve().then(() => (init_api_keys(), api_keys_exports));
+    const key = await loadApiKey2();
+    if (key) {
+      const result = await validateApiKey2(key);
+      if (result.valid) {
+        authEmail = result.email || null;
+        process.stderr.write(`  Authenticated as: ${authEmail || "unknown"}
+
+`);
+      }
+    }
+  } catch {
+    process.stderr.write("  Not authenticated (some commands will require login)\n\n");
+  }
+  const COMPLETIONS = [
+    "publish",
+    "quality-check",
+    "e2e",
+    "oauth-health",
+    "oauth-refresh",
+    "preflight",
+    "posts",
+    "refresh-analytics",
+    "loop",
+    "status",
+    "autopilot",
+    "usage",
+    "credits",
+    "tools",
+    "info",
+    "plan",
+    "preset",
+    "content",
+    "account",
+    "analytics",
+    "system",
+    ".help",
+    ".exit",
+    ".clear"
+  ];
+  const promptStr = authEmail ? `sn[${authEmail.split("@")[0]}]> ` : "sn> ";
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stderr,
+    prompt: promptStr,
+    completer: (line) => {
+      const hits = COMPLETIONS.filter((c) => c.startsWith(line.trim()));
+      return [hits.length ? hits : COMPLETIONS, line];
+    }
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === ".exit" || trimmed === "exit" || trimmed === "quit") {
+      process.stderr.write("Goodbye.\n");
+      rl.close();
+      process.exit(0);
+    }
+    if (trimmed === ".help") {
+      process.stderr.write("\nREPL Commands:\n");
+      process.stderr.write("  .help     Show this help\n");
+      process.stderr.write("  .clear    Clear the screen\n");
+      process.stderr.write("  .exit     Exit the REPL\n");
+      process.stderr.write("\nCLI Commands:\n");
+      process.stderr.write("  publish, quality-check, e2e, posts, credits, etc.\n");
+      process.stderr.write('  Type any sn subcommand directly (no "sn" prefix needed)\n\n');
+      rl.prompt();
+      return;
+    }
+    if (trimmed === ".clear") {
+      process.stderr.write("\x1B[2J\x1B[H");
+      rl.prompt();
+      return;
+    }
+    const originalExit = process.exit;
+    process.exit = ((_code) => {
+    });
+    try {
+      const { runSnCli: runSnCli2 } = await Promise.resolve().then(() => (init_sn(), sn_exports));
+      const argv = splitArgs(trimmed);
+      await runSnCli2(argv);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+    } finally {
+      process.exit = originalExit;
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function splitArgs(line) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === " " && !inQuotes) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) args.push(current);
+  return args;
+}
+var init_repl = __esm({
+  "src/cli/repl.ts"() {
+    "use strict";
+    init_version();
+  }
+});
+
+// src/sn.ts
+init_version();
+init_sn();
+process.env.SN_CLI_QUIET = "1";
+async function main() {
+  const command = process.argv[2];
+  const wantsJson = process.argv.includes("--json");
+  if (command === "--version" || command === "-v") {
+    if (wantsJson) {
+      process.stdout.write(
+        JSON.stringify(
+          { ok: true, command: "version", version: MCP_VERSION, name: "sn", schema_version: "1" },
+          null,
+          2
+        ) + "\n"
+      );
+    } else {
+      console.log(`sn (Social Neuron CLI) v${MCP_VERSION}`);
+    }
+    process.exit(0);
+  }
+  if (!command || command === "--help" || command === "-h") {
+    printSnUsage();
+    process.exit(0);
+  }
+  switch (command) {
+    case "setup":
+    case "login": {
+      const flags = process.argv.slice(3);
+      if (flags.includes("--paste")) {
+        const { runLogin: runLogin2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+        await runLogin2("paste");
+      } else if (flags.includes("--device")) {
+        const { runLogin: runLogin2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+        await runLogin2("device");
+      } else {
+        const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+        await runSetup2();
+      }
+      process.exit(0);
+    }
+    case "logout": {
+      const { runLogoutCommand: runLogoutCommand2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+      await runLogoutCommand2({ json: wantsJson });
+      process.exit(0);
+    }
+    case "whoami": {
+      const { runWhoami: runWhoami2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+      await runWhoami2({ json: wantsJson });
+      process.exit(0);
+    }
+    case "health": {
+      const { runHealthCheck: runHealthCheck2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+      await runHealthCheck2({ json: wantsJson });
+      process.exit(0);
+    }
+    case "repl": {
+      const { runRepl: runRepl2 } = await Promise.resolve().then(() => (init_repl(), repl_exports));
+      await runRepl2();
+      return;
+    }
+    default: {
+      await runSnCli(process.argv.slice(2));
+      await new Promise((resolve) => {
+        process.stdout.write("", () => resolve());
+      });
+      process.exit(0);
+    }
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`sn: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});