@elnora-ai/cli 1.1.0

package/dist/cli.js

@@ -0,0 +1,4383 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/config.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function getVersion() {
+  try {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(dir, "../../package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0-dev";
+  } catch {
+    return "0.0.0-dev";
+  }
+}
+function buildUrl(endpointKey, params, baseUrl) {
+  const path = ENDPOINTS[endpointKey];
+  if (!path) throw new Error(`Unknown endpoint: ${endpointKey}`);
+  let resolved = path;
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      resolved = resolved.replace(`{${key}}`, value);
+    }
+  }
+  return `${baseUrl ?? BASE_URL}${resolved}`;
+}
+var VERSION, BASE_URL, AI_SERVER_URL, ENDPOINTS, DEFAULT_HEADERS;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    VERSION = getVersion();
+    BASE_URL = "https://platform.elnora.ai/api/v1";
+    AI_SERVER_URL = process.env.ELNORA_AI_SERVER_URL ?? "https://platform.elnora.ai/ai-server";
+    ENDPOINTS = {
+      // Projects
+      projects: "/projects",
+      project: "/projects/{id}",
+      project_tasks: "/projects/{id}/tasks",
+      project_files: "/projects/{id}/files",
+      project_folders: "/projects/{id}/folders",
+      project_members: "/projects/{id}/members",
+      project_member_role: "/projects/{id}/members/{uid}/role",
+      project_member: "/projects/{id}/members/{uid}",
+      project_leave: "/projects/{id}/leave",
+      // Tasks
+      tasks: "/tasks",
+      task: "/tasks/{id}",
+      task_messages: "/tasks/{id}/messages",
+      // Files
+      files: "/files",
+      file: "/files/{id}",
+      file_content: "/files/{id}/content",
+      file_download: "/files/{id}/download",
+      file_upload: "/files/upload",
+      file_upload_confirm: "/files/{id}/upload/confirm",
+      file_versions: "/files/{id}/versions",
+      file_version_content: "/files/{id}/versions/{vid}/content",
+      file_version_restore: "/files/{id}/versions/{vid}/restore",
+      file_promote: "/files/{id}/promote",
+      file_fork: "/files/{id}/fork",
+      file_working_copy: "/files/{id}/working-copy",
+      file_commit: "/files/{id}/commit",
+      file_upload_batch: "/files/upload/batch",
+      // Folders
+      folder: "/folders/{id}",
+      folder_move: "/folders/{id}/move",
+      // Organizations
+      organizations: "/organizations",
+      organization: "/organizations/{id}",
+      organization_members: "/organizations/{id}/members",
+      organization_member_role: "/organizations/{id}/members/{mid}/role",
+      organization_member: "/organizations/{id}/members/{mid}",
+      organization_billing: "/organizations/{id}/billing-status",
+      organization_stripe_customer: "/organizations/{id}/stripe-customer",
+      organization_set_default: "/organizations/{id}/set-default",
+      organizations_all: "/organizations/all",
+      org_files: "/organizations/{orgId}/files",
+      // Organization invitations
+      org_invitations: "/organizations/{orgId}/invitations",
+      org_invitation: "/organizations/{orgId}/invitations/{invId}",
+      // Public invitations
+      invitation_info: "/invitations/{token}",
+      invitation_accept: "/invitations/{token}/accept",
+      // Organization library
+      library_files: "/organizations/{orgId}/library/files",
+      library_folders: "/organizations/{orgId}/library/folders",
+      library_folder: "/organizations/{orgId}/library/folders/{id}",
+      // Search
+      search_tasks: "/search/tasks",
+      search_files: "/search/files",
+      search_all: "/search",
+      search_file_content: "/search/file-content",
+      // API Keys
+      api_keys: "/api-keys",
+      api_key: "/api-keys/{id}",
+      api_key_policy: "/api-keys/policy",
+      // Audit
+      audit_log: "/organizations/{orgId}/audit-log",
+      // Feedback
+      feedback: "/feedback",
+      // Account
+      account_user: "/account/user/{id}",
+      account_delete: "/account/me",
+      account_users: "/account/user/list",
+      // User agreements
+      user_agreements: "/userAgreement/userAgreements",
+      user_agreement: "/userAgreement/userAgreement",
+      // Legal docs (anonymous)
+      legal_doc_version: "/userAgreement/legalDocumentVersion",
+      legal_doc_version_id: "/userAgreement/legalDocumentVersion/{id}",
+      // Feature flags (SystemAdmin)
+      feature_flags: "/globalFeatureFlags",
+      feature_flag: "/globalFeatureFlags/{key}",
+      // Auth
+      auth_validate: "/auth/validate-token",
+      // Health (outside /api/v1 prefix — handled specially by buildUrl)
+      health: "/health"
+    };
+    DEFAULT_HEADERS = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": `Elnora-CLI/${VERSION}`
+    };
+  }
+});
+
+// src/lib/errors.ts
+function scrub(text) {
+  let result = text;
+  const envKeys = ["ELNORA_API_KEY", "ELNORA_MCP_API_KEY"];
+  for (const envVar of envKeys) {
+    const key = process.env[envVar];
+    if (key && result.includes(key)) {
+      result = result.replaceAll(key, "[REDACTED]");
+    }
+  }
+  result = result.replace(SCRUB_KEY_VALUE_RE, "[REDACTED]");
+  result = result.replace(SCRUB_LONG_TOKEN_RE, "[REDACTED]");
+  return result;
+}
+function scrubData(obj) {
+  if (typeof obj === "string") return scrub(obj);
+  if (Array.isArray(obj)) return obj.map(scrubData);
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      result[k] = scrubData(v);
+    }
+    return result;
+  }
+  return obj;
+}
+function getExitCode(err) {
+  for (const [ErrorClass, code] of EXIT_CODES) {
+    if (err instanceof ErrorClass) return code;
+  }
+  return 1;
+}
+function formatErrorPayload(err) {
+  const payload = { error: scrub(err.message) };
+  if (err instanceof ElnoraError) {
+    payload.code = err.code;
+    if (err.suggestion) payload.suggestion = err.suggestion;
+  } else {
+    payload.code = err.constructor.name;
+  }
+  return payload;
+}
+var ElnoraError, AuthError, NotFoundError, RateLimitError, ValidationError, ServerError, EXIT_CODES, SCRUB_KEY_VALUE_RE, SCRUB_LONG_TOKEN_RE;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    ElnoraError = class extends Error {
+      code;
+      suggestion;
+      constructor(message, options) {
+        super(message);
+        this.name = "ElnoraError";
+        this.code = options?.code ?? "ELNORA_ERROR";
+        this.suggestion = options?.suggestion;
+      }
+    };
+    AuthError = class extends ElnoraError {
+      constructor(message, options) {
+        super(message ?? "No Elnora API key found. Set ELNORA_API_KEY environment variable.", {
+          code: "AUTH_FAILED",
+          suggestion: options?.suggestion ?? "Get your API key from platform.elnora.ai > Settings > API Keys"
+        });
+        this.name = "AuthError";
+      }
+    };
+    NotFoundError = class extends ElnoraError {
+      constructor(entity, identifier) {
+        super(`${entity} not found: ${identifier}`, {
+          code: "NOT_FOUND",
+          suggestion: "Check the identifier and try again."
+        });
+        this.name = "NotFoundError";
+      }
+    };
+    RateLimitError = class extends ElnoraError {
+      constructor(message) {
+        super(message ?? "Elnora API rate limit exceeded.", {
+          code: "RATE_LIMITED",
+          suggestion: "Wait a moment and retry."
+        });
+        this.name = "RateLimitError";
+      }
+    };
+    ValidationError = class extends ElnoraError {
+      constructor(message, suggestion) {
+        super(message, { code: "VALIDATION_ERROR", suggestion });
+        this.name = "ValidationError";
+      }
+    };
+    ServerError = class extends ElnoraError {
+      constructor(message) {
+        super(message ?? "Elnora API server error.", {
+          code: "SERVER_ERROR",
+          suggestion: "Try again later. If the issue persists, contact support@elnora.ai."
+        });
+        this.name = "ServerError";
+      }
+    };
+    EXIT_CODES = /* @__PURE__ */ new Map([
+      [ValidationError, 2],
+      [AuthError, 3],
+      [NotFoundError, 4],
+      [RateLimitError, 5],
+      [ServerError, 6]
+    ]);
+    SCRUB_KEY_VALUE_RE = /"?(?:ELNORA_API_KEY|ELNORA_MCP_API_KEY|api_key|x-api-key)"?\s*[=:]\s*"?([^\s"']+)"?/gi;
+    SCRUB_LONG_TOKEN_RE = /elnora_live_[a-zA-Z0-9_-]{8,}|[a-zA-Z0-9_-]{40,}/g;
+  }
+});
+
+// src/lib/profiles.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function validateProfileName(name) {
+  if (!PROFILE_NAME_RE.test(name)) {
+    throw new ValidationError(
+      `Invalid profile name '${name}'. Must be 1-32 chars, lowercase alphanumeric and hyphens, starting with alphanumeric.`,
+      "Examples: default, work, university, lab-2"
+    );
+  }
+  return name;
+}
+function parseProfilesToml(text) {
+  const profiles = {};
+  let currentSection = null;
+  for (const line of text.split("\n")) {
+    const stripped = line.trim();
+    if (!stripped || stripped.startsWith("#")) continue;
+    if (stripped.startsWith("[") && stripped.endsWith("]")) {
+      const header = stripped.slice(1, -1).trim();
+      if (header === "default") {
+        currentSection = "default";
+        profiles.default ??= {};
+      } else if (header.startsWith("profiles.")) {
+        currentSection = header.slice("profiles.".length);
+        profiles[currentSection] ??= {};
+      } else {
+        currentSection = null;
+      }
+      continue;
+    }
+    if (currentSection !== null && stripped.includes("=")) {
+      const eqIdx = stripped.indexOf("=");
+      const key = stripped.slice(0, eqIdx).trim();
+      let val = stripped.slice(eqIdx + 1).trim();
+      val = val.replace(/^["']|["']$/g, "");
+      profiles[currentSection][key] = val;
+    }
+  }
+  return profiles;
+}
+function serializeProfiles(profiles) {
+  const parts = ["# Elnora CLI profiles", "# Managed by: elnora auth login", ""];
+  if (profiles.default) {
+    parts.push("[default]");
+    for (const [k, v] of Object.entries(profiles.default)) {
+      parts.push(`${k} = "${v}"`);
+    }
+    parts.push("");
+  }
+  for (const name of Object.keys(profiles).sort()) {
+    if (name === "default") continue;
+    parts.push(`[profiles.${name}]`);
+    for (const [k, v] of Object.entries(profiles[name])) {
+      parts.push(`${k} = "${v}"`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function writeSecureFile(filePath, content) {
+  const dir = join2(filePath, "..");
+  mkdirSync(dir, { recursive: true });
+  if (process.platform !== "win32") {
+    try {
+      chmodSync(dir, 448);
+    } catch {
+    }
+  }
+  writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+}
+function loadProfiles() {
+  if (!existsSync(PROFILES_FILE)) return {};
+  try {
+    const text = readFileSync2(PROFILES_FILE, "utf-8");
+    return parseProfilesToml(text);
+  } catch {
+    return {};
+  }
+}
+function saveProfile(name, apiKey) {
+  validateProfileName(name);
+  const profiles = loadProfiles();
+  profiles[name] = { api_key: apiKey };
+  writeSecureFile(PROFILES_FILE, serializeProfiles(profiles));
+  return PROFILES_FILE;
+}
+function removeProfile(name) {
+  const profiles = loadProfiles();
+  if (!(name in profiles)) return false;
+  delete profiles[name];
+  if (Object.keys(profiles).length === 0) {
+    try {
+      unlinkSync(PROFILES_FILE);
+    } catch {
+    }
+    return true;
+  }
+  writeSecureFile(PROFILES_FILE, serializeProfiles(profiles));
+  return true;
+}
+function getApiKey(profileName = "default") {
+  const profiles = loadProfiles();
+  if (!(profileName in profiles)) {
+    const available = Object.keys(profiles);
+    const suggestion = available.length > 0 ? `Available profiles: ${available.join(", ")}` : "Run 'elnora auth login' to set up a profile.";
+    throw new AuthError(`Profile '${profileName}' not found.`, { suggestion });
+  }
+  const key = profiles[profileName].api_key ?? "";
+  if (!key) {
+    throw new AuthError(`Profile '${profileName}' has no API key.`, {
+      suggestion: `Run: elnora auth login --profile ${profileName}`
+    });
+  }
+  return key;
+}
+function listProfileNames() {
+  return Object.keys(loadProfiles());
+}
+function migrateConfigIfNeeded() {
+  if (existsSync(PROFILES_FILE)) return false;
+  if (!existsSync(LEGACY_CONFIG_FILE)) return false;
+  let apiKey = "";
+  try {
+    const text = readFileSync2(LEGACY_CONFIG_FILE, "utf-8");
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (trimmed.slice(0, eqIdx).trim() === "api_key") {
+        apiKey = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+        break;
+      }
+    }
+  } catch {
+    return false;
+  }
+  if (!apiKey) return false;
+  saveProfile("default", apiKey);
+  return true;
+}
+function resolveApiKey(profileName) {
+  const envKey = process.env.ELNORA_API_KEY ?? process.env.ELNORA_MCP_API_KEY;
+  if (envKey) return envKey;
+  migrateConfigIfNeeded();
+  return getApiKey(profileName ?? "default");
+}
+var CONFIG_DIR, PROFILES_FILE, LEGACY_CONFIG_FILE, PROFILE_NAME_RE;
+var init_profiles = __esm({
+  "src/lib/profiles.ts"() {
+    "use strict";
+    init_errors();
+    CONFIG_DIR = join2(homedir(), ".elnora");
+    PROFILES_FILE = join2(CONFIG_DIR, "profiles.toml");
+    LEGACY_CONFIG_FILE = join2(CONFIG_DIR, "config.toml");
+    PROFILE_NAME_RE = /^[a-z0-9][a-z0-9-]{0,31}$/;
+  }
+});
+
+// src/lib/client.ts
+function validateApiUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new ElnoraError(`SSRF blocked: refusing non-HTTPS connection to ${parsed.hostname}`, {
+      code: "SSRF_BLOCKED"
+    });
+  }
+  if (!ALLOWED_API_HOSTS.includes(parsed.hostname)) {
+    throw new ElnoraError(`SSRF blocked: refusing to connect to ${parsed.hostname}`, {
+      code: "SSRF_BLOCKED"
+    });
+  }
+  if (url.split("?")[0].includes("@")) {
+    throw new ElnoraError("SSRF blocked: URL contains userinfo (@)", { code: "SSRF_BLOCKED" });
+  }
+}
+function validateUploadUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new ValidationError(
+      `Upload URL must use HTTPS, got '${parsed.protocol.replace(":", "")}'.`,
+      "Contact support \u2014 the API returned an insecure upload URL."
+    );
+  }
+  if (url.split("?")[0].includes("@")) {
+    throw new ValidationError(
+      "Upload URL contains userinfo (@).",
+      "Contact support \u2014 the API returned a suspicious upload URL."
+    );
+  }
+  const hostname = parsed.hostname;
+  if (!ALLOWED_UPLOAD_SUFFIXES.some((suffix) => hostname.endsWith(suffix))) {
+    throw new ValidationError(
+      `Upload URL hostname '${hostname}' is not an allowed storage provider.`,
+      "Contact support \u2014 the API returned an unexpected upload URL host."
+    );
+  }
+}
+var ALLOWED_API_HOSTS, ALLOWED_UPLOAD_SUFFIXES, MIN_REQUEST_INTERVAL_MS, REQUEST_TIMEOUT_MS, MAX_RETRIES, RETRY_DELAYS_MS, JITTER_FACTOR, ElnoraApiClient;
+var init_client = __esm({
+  "src/lib/client.ts"() {
+    "use strict";
+    init_config();
+    init_errors();
+    init_profiles();
+    ALLOWED_API_HOSTS = ["platform.elnora.ai"];
+    ALLOWED_UPLOAD_SUFFIXES = [
+      ".amazonaws.com",
+      ".storage.googleapis.com",
+      "storage.googleapis.com",
+      ".blob.core.windows.net"
+    ];
+    MIN_REQUEST_INTERVAL_MS = 100;
+    REQUEST_TIMEOUT_MS = 3e4;
+    MAX_RETRIES = 3;
+    RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
+    JITTER_FACTOR = 0.25;
+    ElnoraApiClient = class _ElnoraApiClient {
+      apiKey;
+      baseUrl;
+      timeout;
+      lastRequestTime = 0;
+      constructor(apiKey, options) {
+        this.apiKey = apiKey;
+        this.baseUrl = options?.baseUrl ?? BASE_URL;
+        this.timeout = options?.timeout ?? REQUEST_TIMEOUT_MS;
+      }
+      static fromEnv(profileName, options) {
+        const key = resolveApiKey(profileName);
+        return new _ElnoraApiClient(key, options);
+      }
+      async request(endpoint, options) {
+        const method = options?.method ?? "GET";
+        let url;
+        if (endpoint.startsWith("/")) {
+          url = `${this.baseUrl}${endpoint}`;
+        } else if (endpoint in ENDPOINTS) {
+          url = buildUrl(endpoint, options?.pathParams, this.baseUrl);
+        } else {
+          url = `${this.baseUrl}${endpoint}`;
+        }
+        if (options?.queryParams) {
+          const qs = new URLSearchParams();
+          for (const [k, v] of Object.entries(options.queryParams)) {
+            qs.set(k, String(v));
+          }
+          url = `${url}?${qs.toString()}`;
+        }
+        if (this.baseUrl === BASE_URL) {
+          validateApiUrl(url);
+        }
+        const now = Date.now();
+        const elapsed = now - this.lastRequestTime;
+        if (elapsed < MIN_REQUEST_INTERVAL_MS) {
+          await new Promise((r) => setTimeout(r, MIN_REQUEST_INTERVAL_MS - elapsed));
+        }
+        this.lastRequestTime = Date.now();
+        const headers = {
+          ...DEFAULT_HEADERS,
+          "X-API-Key": this.apiKey,
+          "User-Agent": `Elnora-CLI/${VERSION}`
+        };
+        if (method === "GET" || method === "DELETE") {
+          delete headers["Content-Type"];
+        }
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+          try {
+            const response = await fetch(url, {
+              method,
+              headers,
+              body: options?.body ? JSON.stringify(options.body) : void 0,
+              redirect: "manual",
+              signal: AbortSignal.timeout(this.timeout)
+            });
+            if (response.status >= 300 && response.status < 400) {
+              const location = response.headers.get("location") ?? "unknown";
+              let hostname;
+              try {
+                hostname = new URL(location, url).hostname;
+              } catch {
+                hostname = "unknown";
+              }
+              throw new ElnoraError(`Unexpected redirect to ${hostname} (blocked for security)`, {
+                code: "UNEXPECTED_REDIRECT"
+              });
+            }
+            if (response.ok) {
+              const text = await response.text();
+              if (!text) return void 0;
+              try {
+                return JSON.parse(text);
+              } catch {
+                return text;
+              }
+            }
+            let bodyText = "";
+            try {
+              bodyText = scrub(await response.text());
+            } catch {
+            }
+            if (response.status === 401 || response.status === 403) {
+              throw new AuthError(bodyText.slice(0, 200) || "Authentication failed");
+            }
+            if (response.status === 404) {
+              throw new NotFoundError("resource", bodyText.slice(0, 200) || "not found");
+            }
+            if (response.status === 422) {
+              throw new ValidationError(bodyText.slice(0, 500) || "Validation error");
+            }
+            if (response.status === 429) {
+              if (attempt < MAX_RETRIES) {
+                const retryAfter = response.headers.get("retry-after");
+                const baseDelay = retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : RETRY_DELAYS_MS[attempt];
+                const jitter = baseDelay * JITTER_FACTOR * (2 * Math.random() - 1);
+                await new Promise((r) => setTimeout(r, baseDelay + jitter));
+                continue;
+              }
+              throw new RateLimitError();
+            }
+            if (response.status >= 500) {
+              throw new ServerError(`Server error (HTTP ${response.status}): ${bodyText.slice(0, 500)}`);
+            }
+            throw new ElnoraError(`API error (HTTP ${response.status}): ${bodyText.slice(0, 500)}`, {
+              code: `HTTP_${response.status}`
+            });
+          } catch (err) {
+            if (err instanceof ElnoraError) throw err;
+            if (err instanceof DOMException && err.name === "TimeoutError") {
+              throw new ElnoraError("Request timed out", {
+                code: "TIMEOUT",
+                suggestion: "Check your internet connection and try again."
+              });
+            }
+            throw new ElnoraError(`Network error: ${scrub(String(err))}`, {
+              code: "NETWORK_ERROR",
+              suggestion: "Check your internet connection and try again."
+            });
+          }
+        }
+        throw new RateLimitError("Rate limit exceeded after retries");
+      }
+      // Convenience methods
+      async get(endpoint, opts) {
+        return this.request(endpoint, { method: "GET", ...opts });
+      }
+      async post(endpoint, body, opts) {
+        return this.request(endpoint, { method: "POST", body, ...opts });
+      }
+      async put(endpoint, body, opts) {
+        return this.request(endpoint, { method: "PUT", body, ...opts });
+      }
+      async patch(endpoint, body, opts) {
+        return this.request(endpoint, { method: "PATCH", body, ...opts });
+      }
+      async del(endpoint, opts) {
+        return this.request(endpoint, { method: "DELETE", ...opts });
+      }
+    };
+  }
+});
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createElnoraServer(registry2, getContext) {
+  const server = new McpServer({ name: "elnora", version: VERSION });
+  for (const command of registry2.all()) {
+    const toolName = `elnora_${command.name.replace(/\./g, "_")}`;
+    server.registerTool(
+      toolName,
+      {
+        title: toolName,
+        description: command.description,
+        inputSchema: command.inputSchema,
+        annotations: {
+          readOnlyHint: command.annotations?.readOnlyHint ?? false,
+          destructiveHint: command.annotations?.destructiveHint ?? false,
+          idempotentHint: command.annotations?.idempotentHint ?? false
+        }
+      },
+      async (params) => {
+        try {
+          const ctx = getContext();
+          const client = new ElnoraApiClient(ctx.apiKey ?? ctx.bearerToken ?? "");
+          const input = command.inputSchema.parse(params);
+          const commandCtx = {
+            client,
+            profileName: "mcp",
+            mode: "mcp",
+            output: { format: "json", compact: false }
+          };
+          const result = await command.execute(input, commandCtx);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result) }]
+          };
+        } catch (error) {
+          const payload = formatErrorPayload(error instanceof Error ? error : new Error(String(error)));
+          return {
+            content: [{ type: "text", text: JSON.stringify(payload) }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  return server;
+}
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_client();
+    init_config();
+    init_errors();
+  }
+});
+
+// src/mcp/stdio-server.ts
+var stdio_server_exports = {};
+__export(stdio_server_exports, {
+  startStdioServer: () => startStdioServer
+});
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startStdioServer(registry2) {
+  const apiKey = resolveApiKey();
+  const getContext = () => ({
+    apiKey,
+    clientId: "stdio",
+    scopes: ["*"]
+  });
+  const server = createElnoraServer(registry2, getContext);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var init_stdio_server = __esm({
+  "src/mcp/stdio-server.ts"() {
+    "use strict";
+    init_profiles();
+    init_server();
+  }
+});
+
+// src/mcp/http-server.ts
+var http_server_exports = {};
+__export(http_server_exports, {
+  startHttpServer: () => startHttpServer
+});
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import rateLimit from "express-rate-limit";
+async function startHttpServer(registry2, config) {
+  const app = express();
+  app.set("trust proxy", 1);
+  app.use((_req, res, next) => {
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("X-Frame-Options", "DENY");
+    res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+    res.setHeader("Strict-Transport-Security", "max-age=63072000; includeSubDomains");
+    res.setHeader("Cache-Control", "no-store");
+    next();
+  });
+  app.use(express.json({ limit: "1mb" }));
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", service: "elnora-mcp" });
+  });
+  app.use(
+    "/mcp",
+    rateLimit({
+      windowMs: 6e4,
+      limit: 150,
+      standardHeaders: "draft-7",
+      legacyHeaders: false,
+      keyGenerator: (req) => {
+        const apiKey = req.headers["x-api-key"];
+        if (apiKey) return `key:${fnvHash(String(apiKey))}`;
+        return `ip:${req.ip ?? "unknown"}`;
+      },
+      message: { error: "rate_limit_exceeded", error_description: "Too many requests. Please retry later." }
+    })
+  );
+  app.post("/mcp", async (req, res) => {
+    const apiKey = req.headers["x-api-key"];
+    if (!apiKey) {
+      res.status(401).json({ error: "missing_api_key", error_description: "X-API-Key header required" });
+      return;
+    }
+    const userId = await validateApiKeyWithPlatform(apiKey, config);
+    if (!userId) {
+      res.status(401).json({ error: "invalid_api_key", error_description: "API key rejected by platform" });
+      return;
+    }
+    let server;
+    let transport;
+    try {
+      const getContext = () => ({
+        apiKey,
+        clientId: `apikey:${userId}`,
+        scopes: ["*"]
+      });
+      server = createElnoraServer(registry2, getContext);
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      res.on("close", () => {
+        transport?.close().catch(() => {
+        });
+        server?.close().catch(() => {
+        });
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+    } catch (error) {
+      transport?.close().catch(() => {
+      });
+      server?.close().catch(() => {
+      });
+      console.error("MCP request error:", error);
+      if (!res.headersSent) {
+        res.status(500).json({ error: "internal_error", error_description: "MCP request failed" });
+      }
+    }
+  });
+  app.get("/mcp", (_req, res) => {
+    res.status(405).json({ error: "method_not_allowed", error_description: "Stateless server \u2014 use POST" });
+  });
+  app.delete("/mcp", (_req, res) => {
+    res.status(405).json({ error: "method_not_allowed", error_description: "Sessions not supported" });
+  });
+  const httpServer = app.listen(config.port, config.host, () => {
+    console.error(`Elnora MCP server running on http://${config.host}:${config.port}/mcp`);
+    console.error(`Health check: http://localhost:${config.port}/health`);
+    console.error("API Key auth: Send X-API-Key header");
+  });
+  const shutdown = (signal) => {
+    console.error(`${signal} received \u2014 shutting down gracefully`);
+    httpServer.close(() => process.exit(0));
+    setTimeout(() => process.exit(1), 25e3).unref();
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  httpServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`Port ${config.port} is already in use`);
+    } else {
+      console.error("HTTP server error:", err);
+    }
+    process.exit(1);
+  });
+}
+function fnvHash(value) {
+  let h = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    h ^= value.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+async function validateApiKeyWithPlatform(apiKey, config) {
+  try {
+    const response = await fetch(config.tokenValidationUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Service-Key": config.mcpServiceKey },
+      body: JSON.stringify({ token: apiKey }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    const data = await response.json();
+    if (data.valid && data.user_id) return String(data.user_id);
+    return null;
+  } catch {
+    return null;
+  }
+}
+var init_http_server = __esm({
+  "src/mcp/http-server.ts"() {
+    "use strict";
+    init_server();
+  }
+});
+
+// src/adapters/cli.ts
+init_client();
+init_errors();
+import { Command } from "commander";
+
+// src/lib/output.ts
+init_errors();
+function filterFields(data, fields) {
+  if (Array.isArray(data)) {
+    return data.map((row) => {
+      if (typeof row !== "object" || row === null) return row;
+      const filtered = {};
+      for (const f of fields) {
+        if (f in row) filtered[f] = row[f];
+      }
+      return filtered;
+    });
+  }
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    if ("items" in obj && Array.isArray(obj.items)) {
+      return { ...obj, items: filterFields(obj.items, fields) };
+    }
+    const filtered = {};
+    for (const f of fields) {
+      if (f in obj) filtered[f] = obj[f];
+    }
+    return filtered;
+  }
+  return data;
+}
+function toRows(data) {
+  if (Array.isArray(data)) return data;
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    if ("items" in obj && Array.isArray(obj.items)) return obj.items;
+    return [obj];
+  }
+  return [{ value: data }];
+}
+function toCsv(rows) {
+  if (rows.length === 0) return "";
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const k of Object.keys(row)) {
+      if (!seen.has(k)) {
+        keys.push(k);
+        seen.add(k);
+      }
+    }
+  }
+  const csvEscape = (v) => {
+    const s = String(v ?? "");
+    return s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  const lines = [keys.join(",")];
+  for (const row of rows) {
+    lines.push(keys.map((k) => csvEscape(row[k])).join(","));
+  }
+  return lines.join("\n");
+}
+function formatOutput(data, options) {
+  let output = scrubData(data);
+  if (options.fields) {
+    output = filterFields(output, options.fields);
+  }
+  if (options.format === "csv") {
+    return toCsv(toRows(output));
+  }
+  if (options.compact) {
+    return JSON.stringify(output);
+  }
+  return JSON.stringify(output, null, 2);
+}
+
+// src/adapters/cli.ts
+function unwrapZodDef(schema) {
+  const s = schema;
+  const description = s.description ?? "";
+  let required = !s.isOptional?.();
+  let defaultValue;
+  let isBoolean = false;
+  let isNumber = false;
+  let choices;
+  const def = s._zod?.def ?? s._def;
+  const type = def?.type ?? "";
+  if (type === "default") {
+    defaultValue = def.defaultValue;
+    required = false;
+    const innerType = def.innerType?._zod?.def?.type ?? def.innerType?._def?.type ?? "";
+    if (innerType === "boolean") isBoolean = true;
+    if (innerType === "number" || innerType === "int") isNumber = true;
+  } else if (type === "optional" || type === "nullable") {
+    required = false;
+    const innerType = def.innerType?._zod?.def?.type ?? def.innerType?._def?.type ?? "";
+    if (innerType === "boolean") isBoolean = true;
+    if (innerType === "number" || innerType === "int") isNumber = true;
+  } else if (type === "boolean") {
+    isBoolean = true;
+  } else if (type === "number" || type === "int") {
+    isNumber = true;
+  } else if (type === "enum") {
+    const entries = def.entries;
+    if (entries && typeof entries === "object") {
+      choices = Object.values(entries);
+    }
+  }
+  return { description, required, defaultValue, isBoolean, isNumber, choices };
+}
+function zodToCommanderOptions(schema) {
+  const options = [];
+  const s = schema;
+  const def = s._zod?.def ?? s._def;
+  const shape = def?.shape;
+  if (!shape || typeof shape !== "object") return options;
+  const shapeObj = shape;
+  for (const [key, fieldSchema] of Object.entries(shapeObj)) {
+    const meta = unwrapZodDef(fieldSchema);
+    const kebabKey = camelToKebab(key);
+    const isPositional = meta.required && !meta.isBoolean && !meta.choices && key.endsWith("Id");
+    if (isPositional) {
+      options.push({
+        flags: `<${kebabKey}>`,
+        description: meta.description,
+        required: true,
+        isArgument: true
+      });
+      continue;
+    }
+    if (meta.isBoolean) {
+      options.push({
+        flags: `--${kebabKey}`,
+        description: meta.description,
+        required: false,
+        defaultValue: meta.defaultValue ?? false
+      });
+      continue;
+    }
+    const valuePlaceholder = meta.required ? ` <value>` : ` [value]`;
+    options.push({
+      flags: `--${kebabKey}${valuePlaceholder}`,
+      description: meta.description,
+      required: meta.required,
+      defaultValue: meta.defaultValue,
+      choices: meta.choices
+    });
+  }
+  return options;
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function buildProgram(registry2) {
+  const program2 = new Command().name("elnora").description("Elnora AI Platform CLI").version("0.0.1").option("--compact", "Token-efficient minimal output", false).option("--output <format>", "Output format (json, csv)", "json").option("--fields <fields>", "Comma-separated fields to include").option("--profile <name>", "Named profile to use").option("--json", "Force JSON output", false);
+  for (const group of registry2.groups()) {
+    const groupCmd = new Command(group).description(`Manage ${group}`);
+    const commands = registry2.byGroup(group);
+    for (const cmd of commands) {
+      const subName = cmd.name.split(".").slice(1).join("-");
+      const sub = new Command(subName).description(cmd.description);
+      const opts = zodToCommanderOptions(cmd.inputSchema);
+      for (const opt of opts) {
+        if (opt.isArgument) {
+          sub.argument(opt.flags, opt.description);
+        }
+      }
+      for (const opt of opts) {
+        if (opt.isArgument) continue;
+        if (opt.choices) {
+          sub.option(opt.flags, opt.description, opt.defaultValue);
+        } else {
+          sub.option(opt.flags, opt.description, opt.defaultValue);
+        }
+      }
+      sub.action(async (...actionArgs) => {
+        try {
+          const parentOpts = program2.opts();
+          const commanderOpts = actionArgs[actionArgs.length - 2];
+          const positionalArgs = actionArgs.slice(0, -2);
+          const input = { ...commanderOpts };
+          const argDefs = opts.filter((o) => o.isArgument);
+          for (let i = 0; i < argDefs.length; i++) {
+            const fieldName = kebabToCamel(argDefs[i].flags.replace(/[<>]/g, ""));
+            if (i < positionalArgs.length) {
+              input[fieldName] = positionalArgs[i];
+            }
+          }
+          for (const opt of opts) {
+            if (opt.isArgument) continue;
+            const fieldName = kebabToCamel(opt.flags.replace(/--/, "").replace(/ .+/, ""));
+            if (fieldName in input && typeof input[fieldName] === "string") {
+              const numVal = Number(input[fieldName]);
+              if (!Number.isNaN(numVal) && opt.defaultValue !== void 0 && typeof opt.defaultValue === "number") {
+                input[fieldName] = numVal;
+              }
+            }
+          }
+          const profileName = parentOpts.profile ?? "default";
+          const client = ElnoraApiClient.fromEnv(profileName);
+          const ctx = {
+            client,
+            profileName,
+            mode: "cli",
+            output: {
+              format: (parentOpts.json ? "json" : parentOpts.output) ?? "json",
+              compact: parentOpts.compact ?? false,
+              fields: parentOpts.fields ? parentOpts.fields.split(",").map((f) => f.trim()) : void 0
+            }
+          };
+          const parsed = cmd.inputSchema.parse(input);
+          const result = await cmd.execute(parsed, ctx);
+          const formatted = formatOutput(result, {
+            format: ctx.output.format,
+            compact: ctx.output.compact,
+            fields: ctx.output.fields
+          });
+          process.stdout.write(`${formatted}
+`);
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          const payload = formatErrorPayload(error);
+          process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+          process.exit(getExitCode(error));
+        }
+      });
+      groupCmd.addCommand(sub);
+    }
+    program2.addCommand(groupCmd);
+  }
+  return program2;
+}
+
+// src/commands/account/accept-terms.ts
+import { z } from "zod";
+var inputSchema = z.object({
+  documentVersionId: z.string().describe("Document version ID to accept")
+});
+var accountAcceptTerms = {
+  name: "account.acceptTerms",
+  group: "account",
+  description: "Accept a user agreement / terms of service",
+  inputSchema,
+  outputSchema: z.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("user_agreement", {
+      documentVersionId: input.documentVersionId
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/add-legal-doc.ts
+import { z as z2 } from "zod";
+var inputSchema2 = z2.object({
+  documentType: z2.string().min(1).describe("Document type"),
+  version: z2.string().min(1).describe("Document version string"),
+  content: z2.string().min(1).describe("Document content"),
+  effectiveDate: z2.string().optional().describe("Effective date (ISO 8601)")
+});
+var accountAddLegalDoc = {
+  name: "account.addLegalDoc",
+  group: "account",
+  description: "Add a legal document version (SystemAdmin only)",
+  inputSchema: inputSchema2,
+  outputSchema: z2.any(),
+  async execute(input, ctx) {
+    const body = {
+      documentType: input.documentType,
+      version: input.version,
+      content: input.content
+    };
+    if (input.effectiveDate) body.effectiveDate = input.effectiveDate;
+    return ctx.client.post("legal_doc_version", body);
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/agreements.ts
+import { z as z3 } from "zod";
+var inputSchema3 = z3.object({});
+var accountAgreements = {
+  name: "account.agreements",
+  group: "account",
+  description: "List user agreements",
+  inputSchema: inputSchema3,
+  outputSchema: z3.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    return ctx.client.get("user_agreements");
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/delete.ts
+import { z as z4 } from "zod";
+
+// src/commands/_shared/confirm.ts
+import { createInterface } from "node:readline/promises";
+async function confirmDestructive(prompt, requiredInput) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(prompt);
+    if (requiredInput) return answer.trim() === requiredInput;
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/account/delete.ts
+var inputSchema4 = z4.object({
+  yes: z4.boolean().optional().default(false).describe("Skip confirmation prompt")
+});
+var accountDelete = {
+  name: "account.delete",
+  group: "account",
+  description: "Delete your own account",
+  inputSchema: inputSchema4,
+  outputSchema: z4.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    if (!input.yes) {
+      const confirmed = await confirmDestructive("Type DELETE to confirm account deletion: ", "DELETE");
+      if (!confirmed) {
+        return { deleted: false };
+      }
+    }
+    await ctx.client.del("account_delete");
+    return { deleted: true };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return String(output.deleted);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/delete-legal-doc.ts
+import { z as z5 } from "zod";
+var inputSchema5 = z5.object({
+  versionId: z5.string().describe("Legal document version ID"),
+  yes: z5.boolean().optional().default(false).describe("Skip confirmation prompt")
+});
+var accountDeleteLegalDoc = {
+  name: "account.deleteLegalDoc",
+  group: "account",
+  description: "Delete a legal document version (SystemAdmin only)",
+  inputSchema: inputSchema5,
+  outputSchema: z5.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    if (!input.yes) {
+      const confirmed = await confirmDestructive(
+        `Are you sure you want to delete legal document version ${input.versionId}? [y/N] `
+      );
+      if (!confirmed) {
+        return { deleted: false, versionId: input.versionId };
+      }
+    }
+    await ctx.client.del("legal_doc_version_id", {
+      pathParams: { id: input.versionId }
+    });
+    return { deleted: true, versionId: input.versionId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.versionId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/get.ts
+import { z as z6 } from "zod";
+var inputSchema6 = z6.object({
+  userId: z6.string().describe("User ID")
+});
+var accountGet = {
+  name: "account.get",
+  group: "account",
+  description: "Get account details for a user",
+  inputSchema: inputSchema6,
+  outputSchema: z6.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("account_user", {
+      pathParams: { id: input.userId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/update.ts
+init_errors();
+import { z as z7 } from "zod";
+var inputSchema7 = z7.object({
+  userId: z7.string().describe("User ID"),
+  firstName: z7.string().optional().describe("First name"),
+  lastName: z7.string().optional().describe("Last name")
+});
+var accountUpdate = {
+  name: "account.update",
+  group: "account",
+  description: "Update account details for a user",
+  inputSchema: inputSchema7,
+  outputSchema: z7.any(),
+  async execute(input, ctx) {
+    const body = {};
+    if (input.firstName !== void 0) body.firstName = input.firstName;
+    if (input.lastName !== void 0) body.lastName = input.lastName;
+    if (Object.keys(body).length === 0) {
+      throw new ValidationError("At least one of --firstName or --lastName is required");
+    }
+    return ctx.client.patch("account_user", body, {
+      pathParams: { id: input.userId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/update-legal-doc.ts
+init_errors();
+import { z as z8 } from "zod";
+var inputSchema8 = z8.object({
+  versionId: z8.string().describe("Legal document version ID"),
+  content: z8.string().optional().describe("Updated content"),
+  effectiveDate: z8.string().optional().describe("Updated effective date (ISO 8601)")
+});
+var accountUpdateLegalDoc = {
+  name: "account.updateLegalDoc",
+  group: "account",
+  description: "Update a legal document version (SystemAdmin only)",
+  inputSchema: inputSchema8,
+  outputSchema: z8.any(),
+  async execute(input, ctx) {
+    const body = {};
+    if (input.content !== void 0) body.content = input.content;
+    if (input.effectiveDate !== void 0) body.effectiveDate = input.effectiveDate;
+    if (Object.keys(body).length === 0) {
+      throw new ValidationError("At least one of --content or --effectiveDate is required");
+    }
+    return ctx.client.patch("legal_doc_version_id", body, {
+      pathParams: { id: input.versionId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/users.ts
+import { z as z9 } from "zod";
+var inputSchema9 = z9.object({
+  state: z9.enum(["Active", "Pending", "Deleted"]).optional().describe("Filter by user state"),
+  refCode: z9.string().optional().describe("Filter by referral code")
+});
+var accountUsers = {
+  name: "account.users",
+  group: "account",
+  description: "List all users (admin)",
+  inputSchema: inputSchema9,
+  outputSchema: z9.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    const queryParams = {};
+    if (input.state) queryParams.state = input.state;
+    if (input.refCode) queryParams.refCode = input.refCode;
+    return ctx.client.get("account_users", {
+      queryParams: Object.keys(queryParams).length > 0 ? queryParams : void 0
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/account/index.ts
+function registerAccountCommands() {
+  return [
+    accountGet,
+    accountUpdate,
+    accountAgreements,
+    accountAcceptTerms,
+    accountDelete,
+    accountUsers,
+    accountAddLegalDoc,
+    accountUpdateLegalDoc,
+    accountDeleteLegalDoc
+  ];
+}
+
+// src/commands/api-keys/create.ts
+import { z as z10 } from "zod";
+var inputSchema10 = z10.object({
+  name: z10.string().min(1).describe("API key name"),
+  scopes: z10.string().optional().describe("Comma-separated list of scopes")
+});
+var apiKeysCreate = {
+  name: "api-keys.create",
+  group: "api-keys",
+  description: "Create a new API key",
+  inputSchema: inputSchema10,
+  outputSchema: z10.any(),
+  async execute(input, ctx) {
+    const parsedScopes = input.scopes ? input.scopes.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : void 0;
+    return ctx.client.post("api_keys", { name: input.name, scopes: parsedScopes });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/api-keys/get-policy.ts
+import { z as z11 } from "zod";
+var inputSchema11 = z11.object({});
+var apiKeysGetPolicy = {
+  name: "api-keys.getPolicy",
+  group: "api-keys",
+  description: "Get the API key creation policy",
+  inputSchema: inputSchema11,
+  outputSchema: z11.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    return ctx.client.get("api_key_policy");
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/api-keys/list.ts
+import { z as z12 } from "zod";
+var inputSchema12 = z12.object({});
+var apiKeysList = {
+  name: "api-keys.list",
+  group: "api-keys",
+  description: "List all API keys",
+  inputSchema: inputSchema12,
+  outputSchema: z12.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    return ctx.client.get("api_keys");
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/api-keys/revoke.ts
+import { z as z13 } from "zod";
+var inputSchema13 = z13.object({
+  keyId: z13.string().uuid().describe("API key ID to revoke")
+});
+var apiKeysRevoke = {
+  name: "api-keys.revoke",
+  group: "api-keys",
+  description: "Revoke an API key",
+  inputSchema: inputSchema13,
+  outputSchema: z13.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("api_key", {
+      pathParams: { id: input.keyId }
+    });
+    return { revoked: true, keyId: input.keyId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.keyId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/api-keys/set-policy.ts
+import { z as z14 } from "zod";
+var inputSchema14 = z14.object({
+  policy: z14.enum(["all_members", "admins_only"]).describe("API key creation policy")
+});
+var apiKeysSetPolicy = {
+  name: "api-keys.setPolicy",
+  group: "api-keys",
+  description: "Set the API key creation policy",
+  inputSchema: inputSchema14,
+  outputSchema: z14.any(),
+  async execute(input, ctx) {
+    return ctx.client.put("api_key_policy", { policy: input.policy });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/api-keys/index.ts
+function registerApiKeyCommands() {
+  return [apiKeysCreate, apiKeysList, apiKeysRevoke, apiKeysGetPolicy, apiKeysSetPolicy];
+}
+
+// src/commands/audit/list.ts
+import { z as z16 } from "zod";
+
+// src/commands/_shared/pagination.ts
+import { z as z15 } from "zod";
+var paginationInput = {
+  page: z15.number().int().min(1).default(1).describe("Page number"),
+  pageSize: z15.number().int().min(1).max(100).default(25).describe("Results per page")
+};
+
+// src/commands/audit/list.ts
+var inputSchema15 = z16.object({
+  org: z16.string().uuid().describe("Organization ID"),
+  ...paginationInput,
+  action: z16.string().optional().describe("Filter by action type"),
+  userId: z16.string().optional().describe("Filter by user ID")
+});
+var auditList = {
+  name: "audit.list",
+  group: "audit",
+  description: "List audit log entries for an organization",
+  inputSchema: inputSchema15,
+  outputSchema: z16.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    const queryParams = {
+      page: input.page,
+      pageSize: input.pageSize
+    };
+    if (input.action) queryParams.action = input.action;
+    if (input.userId) queryParams.userId = input.userId;
+    return ctx.client.get("audit_log", {
+      pathParams: { orgId: input.org },
+      queryParams
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/audit/index.ts
+function registerAuditCommands() {
+  return [auditList];
+}
+
+// src/commands/auth/login.ts
+init_client();
+init_errors();
+init_profiles();
+import { z as z17 } from "zod";
+var inputSchema16 = z17.object({
+  apiKey: z17.string().optional().describe("Elnora API key (elnora_live_...)"),
+  profile: z17.string().default("default").describe("Profile name to save key under")
+});
+var authLogin = {
+  name: "auth.login",
+  group: "auth",
+  description: "Set up authentication by saving an API key to a profile",
+  inputSchema: inputSchema16,
+  outputSchema: z17.any(),
+  async execute(input, _ctx) {
+    const apiKey = input.apiKey;
+    if (!apiKey) {
+      throw new ValidationError(
+        "API key is required. Use --api-key flag to provide it.",
+        "Get your API key from: https://platform.elnora.ai > Settings > API Keys"
+      );
+    }
+    const key = apiKey.trim();
+    if (!key.startsWith("elnora_live_")) {
+      throw new AuthError("API key must start with 'elnora_live_'.");
+    }
+    if (key.length < 20) {
+      throw new AuthError("API key looks too short. Check your key and try again.");
+    }
+    const profileName = input.profile;
+    validateProfileName(profileName);
+    const tempClient = new ElnoraApiClient(key);
+    await tempClient.get("projects", { queryParams: { page: 1, pageSize: 1 } });
+    const configPath = saveProfile(profileName, key);
+    return { profile: profileName, verified: true, configPath };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.profile ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/auth/logout.ts
+init_profiles();
+import { z as z18 } from "zod";
+var inputSchema17 = z18.object({
+  profile: z18.string().optional().describe("Profile name to remove (default: 'default')"),
+  all: z18.boolean().default(false).describe("Remove all profiles")
+});
+var authLogout = {
+  name: "auth.logout",
+  group: "auth",
+  description: "Remove saved credentials",
+  inputSchema: inputSchema17,
+  outputSchema: z18.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, _ctx) {
+    if (input.all) {
+      const names = listProfileNames();
+      for (const name of names) {
+        removeProfile(name);
+      }
+      return { loggedOut: true, profile: "all", removedCount: names.length };
+    }
+    const profileName = input.profile ?? "default";
+    const removed = removeProfile(profileName);
+    return { loggedOut: true, profile: profileName, removed };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.profile ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/auth/profiles.ts
+init_profiles();
+import { z as z19 } from "zod";
+var inputSchema18 = z19.object({});
+var authProfiles = {
+  name: "auth.profiles",
+  group: "auth",
+  description: "List all configured profiles",
+  inputSchema: inputSchema18,
+  outputSchema: z19.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, _ctx) {
+    const profiles = loadProfiles();
+    const items = [];
+    for (const [name, data] of Object.entries(profiles)) {
+      const key = data.api_key ?? "";
+      const masked = key.length > 16 ? `${key.slice(0, 12)}...${key.slice(-4)}` : "[invalid]";
+      items.push({ name, apiKey: masked });
+    }
+    return { profiles: items };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") {
+      const profiles = output.profiles ?? [];
+      return profiles.map((p) => p.name).join(", ");
+    }
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/auth/status.ts
+import { z as z20 } from "zod";
+var inputSchema19 = z20.object({});
+var authStatus = {
+  name: "auth.status",
+  group: "auth",
+  description: "Verify API key and show connection info",
+  inputSchema: inputSchema19,
+  outputSchema: z20.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    const result = await ctx.client.get("projects", {
+      queryParams: { page: 1, pageSize: 1 }
+    });
+    const projectCount = result.totalCount ?? result.items?.length ?? 0;
+    return { profile: ctx.profileName, authenticated: true, projectCount };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return String(output.authenticated ?? "");
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/auth/validate.ts
+init_profiles();
+import { z as z21 } from "zod";
+var inputSchema20 = z21.object({
+  token: z21.string().optional().describe("Token to validate (defaults to current API key)")
+});
+var authValidate = {
+  name: "auth.validate",
+  group: "auth",
+  description: "Validate a JWT or API key token",
+  inputSchema: inputSchema20,
+  outputSchema: z21.any(),
+  async execute(input, ctx) {
+    const tokenToValidate = input.token ?? resolveApiKey();
+    return ctx.client.post("auth_validate", { token: tokenToValidate });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/auth/index.ts
+function registerAuthCommands() {
+  return [authLogin, authStatus, authLogout, authProfiles, authValidate];
+}
+
+// src/commands/completion.ts
+function extractCommandTree(cmd) {
+  return {
+    name: cmd.name(),
+    description: cmd.description(),
+    subcommands: cmd.commands.map(extractCommandTree),
+    options: cmd.options.map((o) => ({
+      flags: o.long ?? o.short ?? "",
+      description: o.description
+    }))
+  };
+}
+function generateBash(root) {
+  const lines = [
+    "# Bash completion for elnora",
+    "# Install: elnora completion bash > ~/.local/share/bash-completion/completions/elnora",
+    "",
+    "_elnora() {",
+    '  local cur="${COMP_WORDS[COMP_CWORD]}"',
+    '  local prev="${COMP_WORDS[COMP_CWORD-1]}"',
+    ""
+  ];
+  const topCmds = root.subcommands.map((c) => c.name).join(" ");
+  lines.push(`  if [ "$COMP_CWORD" -eq 1 ]; then`);
+  lines.push(`    COMPREPLY=( $(compgen -W "${topCmds}" -- "$cur") )`);
+  lines.push("    return");
+  lines.push("  fi");
+  lines.push("");
+  lines.push('  case "${COMP_WORDS[1]}" in');
+  for (const group of root.subcommands) {
+    if (group.subcommands.length > 0) {
+      const subs = group.subcommands.map((s) => s.name).join(" ");
+      lines.push(`    ${group.name})`);
+      lines.push(`      COMPREPLY=( $(compgen -W "${subs}" -- "$cur") )`);
+      lines.push("      ;;");
+    }
+  }
+  lines.push("  esac");
+  lines.push("}");
+  lines.push("");
+  lines.push("complete -F _elnora elnora");
+  return lines.join("\n");
+}
+function generateZsh(root) {
+  const lines = [
+    "#compdef elnora",
+    "# Zsh completion for elnora",
+    "# Install: elnora completion zsh > ~/.zfunc/_elnora",
+    "",
+    "_elnora() {",
+    "  local -a commands",
+    ""
+  ];
+  lines.push("  if (( CURRENT == 2 )); then");
+  lines.push("    commands=(");
+  for (const cmd of root.subcommands) {
+    lines.push(`      '${cmd.name}:${cmd.description.replace(/'/g, "")}'`);
+  }
+  lines.push("    )");
+  lines.push("    _describe 'command' commands");
+  lines.push("    return");
+  lines.push("  fi");
+  lines.push("");
+  lines.push("  case $words[2] in");
+  for (const group of root.subcommands) {
+    if (group.subcommands.length > 0) {
+      lines.push(`    ${group.name})`);
+      lines.push("      local -a subcommands");
+      lines.push("      subcommands=(");
+      for (const sub of group.subcommands) {
+        lines.push(`        '${sub.name}:${sub.description.replace(/'/g, "")}'`);
+      }
+      lines.push("      )");
+      lines.push("      _describe 'subcommand' subcommands");
+      lines.push("      ;;");
+    }
+  }
+  lines.push("  esac");
+  lines.push("}");
+  lines.push("");
+  lines.push("_elnora");
+  return lines.join("\n");
+}
+function generateFish(root) {
+  const lines = [
+    "# Fish completion for elnora",
+    "# Install: elnora completion fish > ~/.config/fish/completions/elnora.fish",
+    ""
+  ];
+  for (const cmd of root.subcommands) {
+    lines.push(
+      `complete -c elnora -n "__fish_use_subcommand" -a "${cmd.name}" -d "${cmd.description.replace(/"/g, '\\"')}"`
+    );
+  }
+  lines.push("");
+  for (const group of root.subcommands) {
+    for (const sub of group.subcommands) {
+      lines.push(
+        `complete -c elnora -n "__fish_seen_subcommand_from ${group.name}" -a "${sub.name}" -d "${sub.description.replace(/"/g, '\\"')}"`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function addCompletionCommand(program2) {
+  program2.command("completion").argument("<shell>", "Shell type: bash, zsh, fish").description("Generate shell completion script").action((shell) => {
+    const tree = extractCommandTree(program2);
+    switch (shell) {
+      case "bash":
+        console.log(generateBash(tree));
+        break;
+      case "zsh":
+        console.log(generateZsh(tree));
+        break;
+      case "fish":
+        console.log(generateFish(tree));
+        break;
+      default:
+        console.error(`Unsupported shell: ${shell}. Use bash, zsh, or fish.`);
+        process.exit(1);
+    }
+  });
+}
+
+// src/commands/doctor.ts
+init_client();
+init_config();
+init_profiles();
+import { existsSync as existsSync2, statSync } from "node:fs";
+import pc from "picocolors";
+
+// src/lib/tty.ts
+function isTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function isColorEnabled() {
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.FORCE_COLOR !== void 0) return true;
+  return isTTY();
+}
+
+// src/commands/doctor.ts
+function addDoctorCommand(program2) {
+  program2.command("doctor").description("Check Elnora CLI configuration and connectivity").action(async () => {
+    const color = isColorEnabled();
+    const ok = (msg) => color ? `  ${pc.green("\u2713")} ${msg}` : `  \u2713 ${msg}`;
+    const fail = (msg) => color ? `  ${pc.red("\u2717")} ${msg}` : `  \u2717 ${msg}`;
+    const warn = (msg) => color ? `  ${pc.yellow("!")} ${msg}` : `  ! ${msg}`;
+    console.error(`
+Elnora CLI v${VERSION}
+`);
+    let passed = 0;
+    let total = 0;
+    total++;
+    try {
+      const start = Date.now();
+      const res = await fetch("https://platform.elnora.ai/health", { signal: AbortSignal.timeout(5e3) });
+      const ms = Date.now() - start;
+      if (res.ok) {
+        console.error(ok(`API reachable         platform.elnora.ai (${res.status} OK, ${ms}ms)`));
+        passed++;
+      } else console.error(fail(`API unreachable       platform.elnora.ai (HTTP ${res.status})`));
+    } catch (e) {
+      console.error(
+        fail(`API unreachable       platform.elnora.ai (${e instanceof Error ? e.message : "network error"})`)
+      );
+    }
+    total++;
+    try {
+      const key = resolveApiKey();
+      const client = new ElnoraApiClient(key);
+      const result = await client.get("projects", {
+        queryParams: { page: 1, pageSize: 1 }
+      });
+      const count = result?.totalCount ?? result?.items?.length ?? 0;
+      console.error(ok(`Authenticated         profile: default (${count} projects accessible)`));
+      passed++;
+    } catch (e) {
+      console.error(fail(`Authentication failed ${e instanceof Error ? e.message : "no API key"}`));
+    }
+    total++;
+    try {
+      const res = await fetch("https://registry.npmjs.org/@elnora-ai/cli/latest", {
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const latest = data.version ?? "unknown";
+        if (latest === VERSION || latest === "unknown") {
+          console.error(ok(`Version current       v${VERSION} (latest: v${latest})`));
+        } else {
+          console.error(warn(`Update available      v${VERSION} \u2192 v${latest}`));
+        }
+        passed++;
+      } else {
+        console.error(ok(`Version               v${VERSION} (registry check failed)`));
+        passed++;
+      }
+    } catch {
+      console.error(ok(`Version               v${VERSION} (registry unreachable)`));
+      passed++;
+    }
+    total++;
+    if (process.platform === "win32") {
+      console.error(ok("Config permissions    (skipped on Windows)"));
+      passed++;
+    } else if (!existsSync2(PROFILES_FILE)) {
+      console.error(warn("Config permissions    ~/.elnora/profiles.toml not found"));
+    } else {
+      const mode = statSync(PROFILES_FILE).mode & 511;
+      if (mode === 384) {
+        console.error(ok(`Config permissions    ${PROFILES_FILE} (0600)`));
+        passed++;
+      } else {
+        console.error(warn(`Config permissions    ${PROFILES_FILE} (0${mode.toString(8)}) \u2014 should be 0600`));
+      }
+    }
+    total++;
+    try {
+      const start = Date.now();
+      const res = await fetch(`${AI_SERVER_URL}/health`, { signal: AbortSignal.timeout(5e3) });
+      const ms = Date.now() - start;
+      if (res.ok) {
+        console.error(ok(`AI Server reachable   ${new URL(AI_SERVER_URL).hostname} (${res.status} OK, ${ms}ms)`));
+        passed++;
+      } else console.error(fail(`AI Server unreachable ${new URL(AI_SERVER_URL).hostname} (HTTP ${res.status})`));
+    } catch {
+      console.error(fail(`AI Server unreachable ${AI_SERVER_URL}`));
+    }
+    console.error("");
+    if (passed === total) {
+      console.error("All checks passed.");
+    } else {
+      console.error(`${passed}/${total} checks passed.`);
+      if (!existsSync2(PROFILES_FILE)) console.error("\nRun: elnora auth login");
+    }
+  });
+}
+
+// src/commands/feedback/submit.ts
+import { z as z22 } from "zod";
+var inputSchema21 = z22.object({
+  title: z22.string().min(1).describe("Feedback title"),
+  description: z22.string().min(1).describe("Feedback description")
+});
+var feedbackSubmit = {
+  name: "feedback.submit",
+  group: "feedback",
+  description: "Submit feedback",
+  inputSchema: inputSchema21,
+  outputSchema: z22.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("feedback", {
+      title: input.title,
+      description: input.description
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/feedback/index.ts
+function registerFeedbackCommands() {
+  return [feedbackSubmit];
+}
+
+// src/commands/files/archive.ts
+import { z as z23 } from "zod";
+var inputSchema22 = z23.object({
+  fileId: z23.string().uuid().describe("File ID to archive")
+});
+var filesArchive = {
+  name: "files.archive",
+  group: "files",
+  description: "Archive (delete) a file",
+  inputSchema: inputSchema22,
+  outputSchema: z23.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("file", {
+      pathParams: { id: input.fileId }
+    });
+    return { archived: true, fileId: input.fileId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.fileId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/commit.ts
+import { z as z24 } from "zod";
+var inputSchema23 = z24.object({
+  fileId: z24.string().uuid().describe("File ID to commit")
+});
+var filesCommit = {
+  name: "files.commit",
+  group: "files",
+  description: "Commit a file's working copy",
+  inputSchema: inputSchema23,
+  outputSchema: z24.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("file_commit", void 0, {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/confirm-upload.ts
+import { z as z25 } from "zod";
+var inputSchema24 = z25.object({
+  fileId: z25.string().uuid().describe("File ID to confirm upload")
+});
+var filesConfirmUpload = {
+  name: "files.confirmUpload",
+  group: "files",
+  description: "Confirm a file upload",
+  inputSchema: inputSchema24,
+  outputSchema: z25.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("file_upload_confirm", void 0, {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/content.ts
+import { z as z26 } from "zod";
+var inputSchema25 = z26.object({
+  fileId: z26.string().uuid().describe("File ID")
+});
+var filesContent = {
+  name: "files.content",
+  group: "files",
+  description: "Get the raw content of a file",
+  inputSchema: inputSchema25,
+  outputSchema: z26.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("file_content", {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, _format) {
+    if (typeof output === "string") return output;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/create.ts
+import { z as z27 } from "zod";
+var inputSchema26 = z27.object({
+  project: z27.string().uuid().describe("Project ID"),
+  name: z27.string().min(1).describe("File name"),
+  type: z27.string().min(1).describe("File type"),
+  folder: z27.string().uuid().optional().describe("Folder ID")
+});
+var filesCreate = {
+  name: "files.create",
+  group: "files",
+  description: "Create a new file",
+  inputSchema: inputSchema26,
+  outputSchema: z27.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("files", {
+      projectId: input.project,
+      name: input.name,
+      type: input.type,
+      folderId: input.folder
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/create-version.ts
+import { z as z28 } from "zod";
+var inputSchema27 = z28.object({
+  fileId: z28.string().uuid().describe("File ID"),
+  content: z28.string().optional().describe("Version content")
+});
+var filesCreateVersion = {
+  name: "files.createVersion",
+  group: "files",
+  description: "Create a new version of a file",
+  inputSchema: inputSchema27,
+  outputSchema: z28.any(),
+  async execute(input, ctx) {
+    const body = {};
+    if (input.content !== void 0) body.content = input.content;
+    return ctx.client.post("file_versions", body, {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/download.ts
+import { z as z29 } from "zod";
+var inputSchema28 = z29.object({
+  fileId: z29.string().uuid().describe("File ID to download")
+});
+var filesDownload = {
+  name: "files.download",
+  group: "files",
+  description: "Download a file",
+  inputSchema: inputSchema28,
+  outputSchema: z29.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("file_download", {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, _format) {
+    if (typeof output === "string") return output;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/fork.ts
+import { z as z30 } from "zod";
+var inputSchema29 = z30.object({
+  fileId: z30.string().uuid().describe("File ID to fork"),
+  targetProject: z30.string().uuid().describe("Target project ID")
+});
+var filesFork = {
+  name: "files.fork",
+  group: "files",
+  description: "Fork a file to another project",
+  inputSchema: inputSchema29,
+  outputSchema: z30.any(),
+  async execute(input, ctx) {
+    return ctx.client.post(
+      "file_fork",
+      { targetProjectId: input.targetProject },
+      {
+        pathParams: { id: input.fileId }
+      }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/get.ts
+import { z as z31 } from "zod";
+var inputSchema30 = z31.object({
+  fileId: z31.string().uuid().describe("File ID")
+});
+var filesGet = {
+  name: "files.get",
+  group: "files",
+  description: "Get details of a specific file",
+  inputSchema: inputSchema30,
+  outputSchema: z31.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("file", {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/list.ts
+import { z as z32 } from "zod";
+var inputSchema31 = z32.object({
+  project: z32.string().uuid().describe("Project ID"),
+  ...paginationInput
+});
+var filesList = {
+  name: "files.list",
+  group: "files",
+  description: "List files in a project",
+  inputSchema: inputSchema31,
+  outputSchema: z32.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("project_files", {
+      pathParams: { id: input.project },
+      queryParams: { page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/promote.ts
+import { z as z33 } from "zod";
+var inputSchema32 = z33.object({
+  fileId: z33.string().uuid().describe("File ID"),
+  visibility: z33.string().min(1).describe("Visibility level")
+});
+var filesPromote = {
+  name: "files.promote",
+  group: "files",
+  description: "Promote a file to a new visibility level",
+  inputSchema: inputSchema32,
+  outputSchema: z33.any(),
+  async execute(input, ctx) {
+    return ctx.client.post(
+      "file_promote",
+      { visibility: input.visibility },
+      {
+        pathParams: { id: input.fileId }
+      }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/restore.ts
+import { z as z34 } from "zod";
+var inputSchema33 = z34.object({
+  fileId: z34.string().uuid().describe("File ID"),
+  versionId: z34.string().uuid().describe("Version ID to restore")
+});
+var filesRestore = {
+  name: "files.restore",
+  group: "files",
+  description: "Restore a file to a specific version",
+  inputSchema: inputSchema33,
+  outputSchema: z34.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("file_version_restore", void 0, {
+      pathParams: { id: input.fileId, vid: input.versionId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/search-content.ts
+import { z as z35 } from "zod";
+var inputSchema34 = z35.object({
+  query: z35.string().min(1).describe("Search query"),
+  project: z35.string().uuid().optional().describe("Project ID to scope search"),
+  ...paginationInput
+});
+var filesSearchContent = {
+  name: "files.searchContent",
+  group: "files",
+  description: "Search file content across projects",
+  inputSchema: inputSchema34,
+  outputSchema: z35.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    const queryParams = {
+      q: input.query,
+      page: input.page,
+      pageSize: input.pageSize
+    };
+    if (input.project) queryParams.projectId = input.project;
+    return ctx.client.get("search_file_content", { queryParams });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/update.ts
+init_errors();
+import { z as z36 } from "zod";
+var inputSchema35 = z36.object({
+  fileId: z36.string().uuid().describe("File ID"),
+  name: z36.string().min(1).optional().describe("New file name"),
+  folder: z36.string().uuid().optional().describe("New folder ID")
+});
+var filesUpdate = {
+  name: "files.update",
+  group: "files",
+  description: "Update a file's metadata",
+  inputSchema: inputSchema35,
+  outputSchema: z36.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    const { fileId, ...fields } = input;
+    if (!fields.name && !fields.folder) {
+      throw new ValidationError(
+        "At least one field (name, folder) must be provided.",
+        "Provide at least one field to update."
+      );
+    }
+    const body = {};
+    if (fields.name) body.name = fields.name;
+    if (fields.folder) body.folderId = fields.folder;
+    return ctx.client.patch("file", body, {
+      pathParams: { id: fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/upload.ts
+init_client();
+import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { basename } from "node:path";
+import { z as z37 } from "zod";
+var inputSchema36 = z37.object({
+  project: z37.string().uuid().describe("Project ID"),
+  filePath: z37.string().min(1).describe("Local file path to upload"),
+  fileName: z37.string().optional().describe("Override file name"),
+  contentType: z37.string().optional().describe("MIME content type")
+});
+var filesUpload = {
+  name: "files.upload",
+  group: "files",
+  description: "Upload a file to a project (three-stage: presign, PUT, confirm)",
+  inputSchema: inputSchema36,
+  outputSchema: z37.any(),
+  async execute(input, ctx) {
+    const fileBuffer = readFileSync3(input.filePath);
+    const fileName = input.fileName ?? basename(input.filePath);
+    const contentType = input.contentType ?? "application/octet-stream";
+    const fileSize = statSync2(input.filePath).size;
+    const uploadInfo = await ctx.client.post("file_upload", {
+      projectId: input.project,
+      fileName,
+      contentType,
+      fileSizeBytes: fileSize
+    });
+    const presignedUrl = uploadInfo.uploadUrl ?? uploadInfo.url;
+    const fileId = uploadInfo.fileId ?? uploadInfo.id;
+    validateUploadUrl(presignedUrl);
+    await fetch(presignedUrl, {
+      method: "PUT",
+      body: fileBuffer,
+      headers: { "Content-Type": contentType, "Content-Length": String(fileSize) }
+    });
+    return ctx.client.post("file_upload_confirm", void 0, {
+      pathParams: { id: fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/upload-batch.ts
+init_client();
+init_errors();
+import { readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { basename as basename2 } from "node:path";
+import { z as z38 } from "zod";
+var inputSchema37 = z38.object({
+  project: z38.string().uuid().describe("Project ID"),
+  filePaths: z38.string().min(1).describe("Comma-separated local file paths to upload"),
+  folder: z38.string().uuid().optional().describe("Folder ID")
+});
+var filesUploadBatch = {
+  name: "files.uploadBatch",
+  group: "files",
+  description: "Upload multiple files to a project (max 50)",
+  inputSchema: inputSchema37,
+  outputSchema: z38.any(),
+  async execute(input, ctx) {
+    const paths = input.filePaths.split(",").map((p) => p.trim()).filter(Boolean);
+    if (paths.length === 0) {
+      throw new ValidationError("No file paths provided.", "Provide comma-separated file paths.");
+    }
+    if (paths.length > 50) {
+      throw new ValidationError(
+        `Too many files (${paths.length}). Maximum is 50.`,
+        "Split the upload into batches of 50 or fewer."
+      );
+    }
+    const results = [];
+    for (const filePath of paths) {
+      const fileName = basename2(filePath);
+      try {
+        const fileBuffer = readFileSync4(filePath);
+        const contentType = "application/octet-stream";
+        const fileSize = statSync3(filePath).size;
+        const uploadInfo = await ctx.client.post("file_upload", {
+          projectId: input.project,
+          fileName,
+          contentType,
+          fileSizeBytes: fileSize,
+          folderId: input.folder
+        });
+        const presignedUrl = uploadInfo.uploadUrl ?? uploadInfo.url;
+        const fileId = uploadInfo.fileId ?? uploadInfo.id;
+        validateUploadUrl(presignedUrl);
+        await fetch(presignedUrl, {
+          method: "PUT",
+          body: fileBuffer,
+          headers: { "Content-Type": contentType, "Content-Length": String(fileSize) }
+        });
+        await ctx.client.post("file_upload_confirm", void 0, {
+          pathParams: { id: fileId }
+        });
+        results.push({ fileName, success: true, fileId });
+      } catch (err) {
+        results.push({
+          fileName,
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    return results;
+  },
+  formatOutput(output, format) {
+    if (format === "compact") {
+      const results = output;
+      return results.map((r) => `${r.fileName}: ${r.success ? "ok" : "FAILED"}`).join(", ");
+    }
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/version-content.ts
+import { z as z39 } from "zod";
+var inputSchema38 = z39.object({
+  fileId: z39.string().uuid().describe("File ID"),
+  versionId: z39.string().uuid().describe("Version ID")
+});
+var filesVersionContent = {
+  name: "files.versionContent",
+  group: "files",
+  description: "Get the raw content of a specific file version",
+  inputSchema: inputSchema38,
+  outputSchema: z39.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("file_version_content", {
+      pathParams: { id: input.fileId, vid: input.versionId }
+    });
+  },
+  formatOutput(output, _format) {
+    if (typeof output === "string") return output;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/versions.ts
+import { z as z40 } from "zod";
+var inputSchema39 = z40.object({
+  fileId: z40.string().uuid().describe("File ID"),
+  ...paginationInput
+});
+var filesVersions = {
+  name: "files.versions",
+  group: "files",
+  description: "List versions of a file",
+  inputSchema: inputSchema39,
+  outputSchema: z40.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("file_versions", {
+      pathParams: { id: input.fileId },
+      queryParams: { page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/working-copy.ts
+import { z as z41 } from "zod";
+var inputSchema40 = z41.object({
+  fileId: z41.string().uuid().describe("File ID"),
+  task: z41.string().uuid().optional().describe("Task ID")
+});
+var filesWorkingCopy = {
+  name: "files.workingCopy",
+  group: "files",
+  description: "Create a working copy of a file",
+  inputSchema: inputSchema40,
+  outputSchema: z41.any(),
+  async execute(input, ctx) {
+    const body = {};
+    if (input.task !== void 0) body.taskId = input.task;
+    return ctx.client.post("file_working_copy", body, {
+      pathParams: { id: input.fileId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/files/index.ts
+function registerFileCommands() {
+  return [
+    filesList,
+    filesGet,
+    filesContent,
+    filesCreate,
+    filesUpload,
+    filesUploadBatch,
+    filesConfirmUpload,
+    filesDownload,
+    filesUpdate,
+    filesArchive,
+    filesVersions,
+    filesVersionContent,
+    filesCreateVersion,
+    filesRestore,
+    filesPromote,
+    filesFork,
+    filesWorkingCopy,
+    filesCommit,
+    filesSearchContent
+  ];
+}
+
+// src/commands/flags/get.ts
+import { z as z42 } from "zod";
+var inputSchema41 = z42.object({
+  key: z42.string().min(1).describe("Feature flag key")
+});
+var flagsGet = {
+  name: "flags.get",
+  group: "flags",
+  description: "Get a feature flag by key",
+  inputSchema: inputSchema41,
+  outputSchema: z42.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("feature_flag", {
+      pathParams: { key: input.key }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/flags/list.ts
+import { z as z43 } from "zod";
+var inputSchema42 = z43.object({});
+var flagsList = {
+  name: "flags.list",
+  group: "flags",
+  description: "List all feature flags",
+  inputSchema: inputSchema42,
+  outputSchema: z43.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    return ctx.client.get("feature_flags");
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/flags/set.ts
+import { z as z44 } from "zod";
+var inputSchema43 = z44.object({
+  key: z44.string().min(1).describe("Feature flag key"),
+  value: z44.enum(["true", "false"]).describe("Feature flag value"),
+  yes: z44.boolean().optional().default(false).describe("Skip confirmation prompt")
+});
+var flagsSet = {
+  name: "flags.set",
+  group: "flags",
+  description: "Set a feature flag value",
+  inputSchema: inputSchema43,
+  outputSchema: z44.any(),
+  async execute(input, ctx) {
+    if (!input.yes) {
+      const confirmed = await confirmDestructive(`Set feature flag "${input.key}" to ${input.value}? [y/N] `);
+      if (!confirmed) {
+        return { updated: false, key: input.key };
+      }
+    }
+    const boolValue = input.value === "true";
+    return ctx.client.put(
+      "feature_flag",
+      { value: boolValue },
+      {
+        pathParams: { key: input.key }
+      }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/flags/index.ts
+function registerFlagCommands() {
+  return [flagsList, flagsGet, flagsSet];
+}
+
+// src/commands/folders/create.ts
+import { z as z45 } from "zod";
+var inputSchema44 = z45.object({
+  projectId: z45.string().uuid().describe("Project ID"),
+  name: z45.string().min(1).describe("Folder name"),
+  parentId: z45.string().uuid().optional().describe("Parent folder ID")
+});
+var foldersCreate = {
+  name: "folders.create",
+  group: "folders",
+  description: "Create a new folder in a project",
+  inputSchema: inputSchema44,
+  outputSchema: z45.any(),
+  async execute(input, ctx) {
+    const body = { name: input.name };
+    if (input.parentId) body.parentId = input.parentId;
+    return ctx.client.post("project_folders", body, {
+      pathParams: { id: input.projectId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/folders/delete.ts
+import { z as z46 } from "zod";
+var inputSchema45 = z46.object({
+  folderId: z46.string().uuid().describe("Folder ID to delete")
+});
+var foldersDelete = {
+  name: "folders.delete",
+  group: "folders",
+  description: "Delete a folder",
+  inputSchema: inputSchema45,
+  outputSchema: z46.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("folder", {
+      pathParams: { id: input.folderId }
+    });
+    return { deleted: true, folderId: input.folderId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.folderId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/folders/list.ts
+import { z as z47 } from "zod";
+var inputSchema46 = z47.object({
+  projectId: z47.string().uuid().describe("Project ID")
+});
+var foldersList = {
+  name: "folders.list",
+  group: "folders",
+  description: "List folders in a project",
+  inputSchema: inputSchema46,
+  outputSchema: z47.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("project_folders", {
+      pathParams: { id: input.projectId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/folders/move.ts
+init_errors();
+import { z as z48 } from "zod";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var inputSchema47 = z48.object({
+  folderId: z48.string().uuid().describe("Folder ID to move"),
+  parentId: z48.string().min(1).describe("Target parent folder ID, or 'root' to move to project root")
+});
+var foldersMove = {
+  name: "folders.move",
+  group: "folders",
+  description: "Move a folder to a new parent (or to root)",
+  inputSchema: inputSchema47,
+  outputSchema: z48.any(),
+  async execute(input, ctx) {
+    let parentValue;
+    if (input.parentId === "root") {
+      parentValue = null;
+    } else if (UUID_RE.test(input.parentId)) {
+      parentValue = input.parentId;
+    } else {
+      throw new ValidationError(
+        "parent must be a valid UUID or 'root'.",
+        "Provide a folder UUID or the literal string 'root'."
+      );
+    }
+    return ctx.client.put(
+      "folder_move",
+      { parentId: parentValue },
+      {
+        pathParams: { id: input.folderId }
+      }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/folders/rename.ts
+import { z as z49 } from "zod";
+var inputSchema48 = z49.object({
+  folderId: z49.string().uuid().describe("Folder ID"),
+  name: z49.string().min(1).describe("New folder name")
+});
+var foldersRename = {
+  name: "folders.rename",
+  group: "folders",
+  description: "Rename a folder",
+  inputSchema: inputSchema48,
+  outputSchema: z49.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    return ctx.client.put(
+      "folder",
+      { name: input.name },
+      {
+        pathParams: { id: input.folderId }
+      }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/folders/index.ts
+function registerFolderCommands() {
+  return [foldersList, foldersCreate, foldersRename, foldersMove, foldersDelete];
+}
+
+// src/commands/health.ts
+import { z as z50 } from "zod";
+var healthInput = z50.object({});
+var healthOutput = z50.object({
+  status: z50.string(),
+  timestamp: z50.string()
+});
+var healthCheck = {
+  name: "health.check",
+  group: "health",
+  description: "Check Elnora API health status",
+  inputSchema: healthInput,
+  outputSchema: healthOutput,
+  annotations: { readOnlyHint: true },
+  async execute(_input, _ctx) {
+    const response = await fetch("https://platform.elnora.ai/health", {
+      signal: AbortSignal.timeout(5e3)
+    });
+    const text = await response.text();
+    let status;
+    try {
+      const data = JSON.parse(text);
+      status = data?.status ?? "ok";
+    } catch {
+      status = response.ok ? text.trim() || "ok" : `error (HTTP ${response.status})`;
+    }
+    return { status, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.status;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/library/create-folder.ts
+import { z as z51 } from "zod";
+var inputSchema49 = z51.object({
+  org: z51.string().uuid().describe("Organization ID"),
+  name: z51.string().min(1).describe("Folder name"),
+  parent: z51.string().uuid().optional().describe("Parent folder ID")
+});
+var libraryCreateFolder = {
+  name: "library.createFolder",
+  group: "library",
+  description: "Create a folder in the organization library",
+  inputSchema: inputSchema49,
+  outputSchema: z51.any(),
+  async execute(input, ctx) {
+    const body = { name: input.name };
+    if (input.parent) body.parentId = input.parent;
+    return ctx.client.post("library_folders", body, {
+      pathParams: { orgId: input.org }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/library/delete-folder.ts
+import { z as z52 } from "zod";
+var inputSchema50 = z52.object({
+  org: z52.string().uuid().describe("Organization ID"),
+  folderId: z52.string().uuid().describe("Folder ID to delete")
+});
+var libraryDeleteFolder = {
+  name: "library.deleteFolder",
+  group: "library",
+  description: "Delete a folder from the organization library",
+  inputSchema: inputSchema50,
+  outputSchema: z52.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("library_folder", {
+      pathParams: { orgId: input.org, id: input.folderId }
+    });
+    return { deleted: true, folderId: input.folderId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.folderId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/library/files.ts
+import { z as z53 } from "zod";
+var inputSchema51 = z53.object({
+  org: z53.string().uuid().describe("Organization ID"),
+  ...paginationInput
+});
+var libraryFiles = {
+  name: "library.files",
+  group: "library",
+  description: "List files in the organization library",
+  inputSchema: inputSchema51,
+  outputSchema: z53.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("library_files", {
+      pathParams: { orgId: input.org },
+      queryParams: { page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/library/folders.ts
+import { z as z54 } from "zod";
+var inputSchema52 = z54.object({
+  org: z54.string().uuid().describe("Organization ID")
+});
+var libraryFolders = {
+  name: "library.folders",
+  group: "library",
+  description: "List folders in the organization library",
+  inputSchema: inputSchema52,
+  outputSchema: z54.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("library_folders", {
+      pathParams: { orgId: input.org }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/library/rename-folder.ts
+import { z as z55 } from "zod";
+var inputSchema53 = z55.object({
+  org: z55.string().uuid().describe("Organization ID"),
+  folderId: z55.string().uuid().describe("Folder ID to rename"),
+  name: z55.string().min(1).describe("New folder name")
+});
+var libraryRenameFolder = {
+  name: "library.renameFolder",
+  group: "library",
+  description: "Rename a folder in the organization library",
+  inputSchema: inputSchema53,
+  outputSchema: z55.any(),
+  async execute(input, ctx) {
+    return ctx.client.put(
+      "library_folder",
+      { name: input.name },
+      {
+        pathParams: { orgId: input.org, id: input.folderId }
+      }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/library/index.ts
+function registerLibraryCommands() {
+  return [libraryFiles, libraryFolders, libraryCreateFolder, libraryRenameFolder, libraryDeleteFolder];
+}
+
+// src/commands/mcp/serve.ts
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Required environment variable ${name} is not set`);
+  }
+  return value;
+}
+function addMcpCommands(program2, registry2) {
+  const mcp = program2.command("mcp").description("MCP server management");
+  mcp.command("serve").description("Start MCP server exposing all CLI commands as tools").option("--http", "HTTP transport (default, for deployment)").option("--stdio", "stdio transport (for local MCP clients)").option("--port <port>", "HTTP port", process.env.PORT ?? "3000").option("--host <host>", "HTTP bind address", process.env.HOST ?? "0.0.0.0").action(async (opts) => {
+    if (opts.stdio) {
+      const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_stdio_server(), stdio_server_exports));
+      await startStdioServer2(registry2);
+    } else {
+      const { startHttpServer: startHttpServer2 } = await Promise.resolve().then(() => (init_http_server(), http_server_exports));
+      await startHttpServer2(registry2, {
+        port: Number.parseInt(opts.port, 10),
+        host: opts.host,
+        tokenValidationUrl: requireEnv("ELNORA_TOKEN_VALIDATION_URL"),
+        mcpServiceKey: requireEnv("ELNORA_MCP_SERVICE_KEY")
+      });
+    }
+  });
+}
+
+// src/commands/open.ts
+import { exec } from "node:child_process";
+var URLS = {
+  "": "https://platform.elnora.ai",
+  platform: "https://platform.elnora.ai",
+  docs: "https://docs.elnora.ai",
+  keys: "https://platform.elnora.ai/settings/api-keys",
+  billing: "https://platform.elnora.ai/settings/billing",
+  github: "https://github.com/Elnora-AI/elnora-cli"
+};
+function openUrl(url) {
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, (err) => {
+    if (err) {
+      console.error(`Failed to open browser: ${err.message}`);
+      console.log(url);
+    }
+  });
+}
+function addOpenCommand(program2) {
+  program2.command("open").argument("[page]", "Page to open: platform, docs, keys, billing, github").description("Open Elnora platform in the browser").action((page) => {
+    const key = page ?? "";
+    const url = URLS[key];
+    if (!url) {
+      console.error(`Unknown page: ${page}`);
+      console.error(`Available: ${Object.keys(URLS).filter(Boolean).join(", ")}`);
+      process.exit(1);
+    }
+    openUrl(url);
+    console.log(`Opening ${url}...`);
+  });
+}
+
+// src/commands/orgs/accept-invite.ts
+import { z as z56 } from "zod";
+var inputSchema54 = z56.object({
+  token: z56.string().min(1).describe("Invitation token")
+});
+var orgsAcceptInvite = {
+  name: "orgs.acceptInvite",
+  group: "orgs",
+  description: "Accept an organization invitation by token",
+  inputSchema: inputSchema54,
+  outputSchema: z56.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("invitation_accept", void 0, {
+      pathParams: { token: input.token }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/billing.ts
+import { z as z57 } from "zod";
+var inputSchema55 = z57.object({
+  orgId: z57.string().uuid().describe("Organization ID")
+});
+var orgsBilling = {
+  name: "orgs.billing",
+  group: "orgs",
+  description: "Get billing status for an organization",
+  inputSchema: inputSchema55,
+  outputSchema: z57.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("organization_billing", {
+      pathParams: { id: input.orgId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/cancel-invite.ts
+import { z as z58 } from "zod";
+var inputSchema56 = z58.object({
+  orgId: z58.string().uuid().describe("Organization ID"),
+  invitationId: z58.string().uuid().describe("Invitation ID to cancel")
+});
+var orgsCancelInvite = {
+  name: "orgs.cancelInvite",
+  group: "orgs",
+  description: "Cancel a pending organization invitation",
+  inputSchema: inputSchema56,
+  outputSchema: z58.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("org_invitation", {
+      pathParams: { orgId: input.orgId, invId: input.invitationId }
+    });
+    return { cancelled: true, invitationId: input.invitationId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.invitationId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/create.ts
+import { z as z59 } from "zod";
+var inputSchema57 = z59.object({
+  name: z59.string().min(1).describe("Organization name"),
+  description: z59.string().optional().describe("Organization description")
+});
+var orgsCreate = {
+  name: "orgs.create",
+  group: "orgs",
+  description: "Create a new organization",
+  inputSchema: inputSchema57,
+  outputSchema: z59.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("organizations", input);
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/delete.ts
+import { z as z60 } from "zod";
+var inputSchema58 = z60.object({
+  orgId: z60.string().uuid().describe("Organization ID to delete"),
+  yes: z60.boolean().optional().default(false).describe("Skip confirmation prompt")
+});
+var orgsDelete = {
+  name: "orgs.delete",
+  group: "orgs",
+  description: "Delete an organization",
+  inputSchema: inputSchema58,
+  outputSchema: z60.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    if (!input.yes) {
+      const confirmed = await confirmDestructive(`Are you sure you want to delete organization ${input.orgId}? [y/N] `);
+      if (!confirmed) {
+        return { deleted: false, orgId: input.orgId };
+      }
+    }
+    await ctx.client.del("organization", {
+      pathParams: { id: input.orgId }
+    });
+    return { deleted: true, orgId: input.orgId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.orgId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/files.ts
+import { z as z61 } from "zod";
+var inputSchema59 = z61.object({
+  orgId: z61.string().uuid().describe("Organization ID"),
+  ...paginationInput
+});
+var orgsFiles = {
+  name: "orgs.files",
+  group: "orgs",
+  description: "List files belonging to an organization",
+  inputSchema: inputSchema59,
+  outputSchema: z61.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("org_files", {
+      pathParams: { orgId: input.orgId },
+      queryParams: { page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/get.ts
+import { z as z62 } from "zod";
+var inputSchema60 = z62.object({
+  orgId: z62.string().uuid().describe("Organization ID")
+});
+var orgsGet = {
+  name: "orgs.get",
+  group: "orgs",
+  description: "Get details of a specific organization",
+  inputSchema: inputSchema60,
+  outputSchema: z62.any(),
+  async execute(input, ctx) {
+    return ctx.client.get("organization", {
+      pathParams: { id: input.orgId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/invitation-info.ts
+import { z as z63 } from "zod";
+var inputSchema61 = z63.object({
+  token: z63.string().min(1).describe("Invitation token")
+});
+var orgsInvitationInfo = {
+  name: "orgs.invitationInfo",
+  group: "orgs",
+  description: "Get information about an invitation by token",
+  inputSchema: inputSchema61,
+  outputSchema: z63.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("invitation_info", {
+      pathParams: { token: input.token }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/invitations.ts
+import { z as z64 } from "zod";
+var inputSchema62 = z64.object({
+  orgId: z64.string().uuid().describe("Organization ID")
+});
+var orgsInvitations = {
+  name: "orgs.invitations",
+  group: "orgs",
+  description: "List pending invitations for an organization",
+  inputSchema: inputSchema62,
+  outputSchema: z64.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("org_invitations", {
+      pathParams: { orgId: input.orgId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/invite.ts
+import { z as z65 } from "zod";
+var inputSchema63 = z65.object({
+  orgId: z65.string().uuid().describe("Organization ID"),
+  email: z65.string().email().describe("Email address to invite"),
+  role: z65.string().optional().default("Member").describe("Role to assign (default: Member)")
+});
+var orgsInvite = {
+  name: "orgs.invite",
+  group: "orgs",
+  description: "Invite a user to an organization by email",
+  inputSchema: inputSchema63,
+  outputSchema: z65.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    const existing = await ctx.client.get("org_invitations", {
+      pathParams: { orgId: input.orgId }
+    });
+    const items = Array.isArray(existing) ? existing : existing?.items ?? [];
+    const match = items.find(
+      (inv) => inv.email?.toLowerCase() === input.email.toLowerCase() && inv.status === "Pending"
+    );
+    if (match) return match;
+    return ctx.client.post(
+      "org_invitations",
+      { email: input.email, role: input.role ?? "Member" },
+      { pathParams: { orgId: input.orgId } }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/list.ts
+import { z as z66 } from "zod";
+var inputSchema64 = z66.object({});
+var orgsList = {
+  name: "orgs.list",
+  group: "orgs",
+  description: "List all organizations the current user belongs to",
+  inputSchema: inputSchema64,
+  outputSchema: z66.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    return ctx.client.get("organizations");
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/list-all.ts
+import { z as z67 } from "zod";
+var inputSchema65 = z67.object({});
+var orgsListAll = {
+  name: "orgs.listAll",
+  group: "orgs",
+  description: "List all organizations (admin)",
+  inputSchema: inputSchema65,
+  outputSchema: z67.any(),
+  annotations: { readOnlyHint: true },
+  async execute(_input, ctx) {
+    return ctx.client.get("organizations_all");
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/members.ts
+import { z as z68 } from "zod";
+var inputSchema66 = z68.object({
+  orgId: z68.string().uuid().describe("Organization ID")
+});
+var orgsMembers = {
+  name: "orgs.members",
+  group: "orgs",
+  description: "List members of an organization",
+  inputSchema: inputSchema66,
+  outputSchema: z68.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("organization_members", {
+      pathParams: { id: input.orgId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/remove-member.ts
+import { z as z69 } from "zod";
+var inputSchema67 = z69.object({
+  orgId: z69.string().uuid().describe("Organization ID"),
+  membershipId: z69.string().uuid().describe("Membership ID of the member to remove")
+});
+var orgsRemoveMember = {
+  name: "orgs.removeMember",
+  group: "orgs",
+  description: "Remove a member from an organization",
+  inputSchema: inputSchema67,
+  outputSchema: z69.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("organization_member", {
+      pathParams: { id: input.orgId, mid: input.membershipId }
+    });
+    return { removed: true };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return String(output.removed);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/set-default.ts
+import { z as z70 } from "zod";
+var inputSchema68 = z70.object({
+  orgId: z70.string().uuid().describe("Organization ID to set as default")
+});
+var orgsSetDefault = {
+  name: "orgs.setDefault",
+  group: "orgs",
+  description: "Set an organization as the default",
+  inputSchema: inputSchema68,
+  outputSchema: z70.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    return ctx.client.put("organization_set_default", void 0, {
+      pathParams: { id: input.orgId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/set-stripe.ts
+import { z as z71 } from "zod";
+var inputSchema69 = z71.object({
+  orgId: z71.string().uuid().describe("Organization ID"),
+  customerId: z71.string().min(1).describe("Stripe customer ID (e.g. cus_xxx)")
+});
+var orgsSetStripe = {
+  name: "orgs.setStripe",
+  group: "orgs",
+  description: "Set the Stripe customer ID for an organization",
+  inputSchema: inputSchema69,
+  outputSchema: z71.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    return ctx.client.put(
+      "organization_stripe_customer",
+      { customerId: input.customerId },
+      { pathParams: { id: input.orgId } }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/update.ts
+init_errors();
+import { z as z72 } from "zod";
+var inputSchema70 = z72.object({
+  orgId: z72.string().uuid().describe("Organization ID"),
+  name: z72.string().min(1).optional().describe("New organization name"),
+  description: z72.string().optional().describe("New organization description")
+});
+var orgsUpdate = {
+  name: "orgs.update",
+  group: "orgs",
+  description: "Update an existing organization",
+  inputSchema: inputSchema70,
+  outputSchema: z72.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    const { orgId, ...fields } = input;
+    if (!fields.name && !fields.description) {
+      throw new ValidationError(
+        "At least one field (name, description) must be provided.",
+        "Provide at least one field to update."
+      );
+    }
+    return ctx.client.patch("organization", fields, {
+      pathParams: { id: orgId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/update-role.ts
+import { z as z73 } from "zod";
+var inputSchema71 = z73.object({
+  orgId: z73.string().uuid().describe("Organization ID"),
+  membershipId: z73.string().uuid().describe("Membership ID of the member"),
+  role: z73.string().min(1).describe("New role to assign")
+});
+var orgsUpdateRole = {
+  name: "orgs.updateRole",
+  group: "orgs",
+  description: "Update an organization member's role",
+  inputSchema: inputSchema71,
+  outputSchema: z73.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    return ctx.client.put(
+      "organization_member_role",
+      { role: input.role },
+      { pathParams: { id: input.orgId, mid: input.membershipId } }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/orgs/index.ts
+function registerOrgCommands() {
+  return [
+    orgsList,
+    orgsGet,
+    orgsCreate,
+    orgsUpdate,
+    orgsDelete,
+    orgsMembers,
+    orgsUpdateRole,
+    orgsRemoveMember,
+    orgsBilling,
+    orgsSetStripe,
+    orgsSetDefault,
+    orgsInvite,
+    orgsInvitations,
+    orgsCancelInvite,
+    orgsInvitationInfo,
+    orgsAcceptInvite,
+    orgsFiles,
+    orgsListAll
+  ];
+}
+
+// src/commands/projects/add-member.ts
+import { z as z74 } from "zod";
+var inputSchema72 = z74.object({
+  projectId: z74.string().uuid().describe("Project ID"),
+  userId: z74.string().uuid().describe("User ID to add"),
+  role: z74.string().default("Member").describe("Role to assign (default: Member)")
+});
+var projectsAddMember = {
+  name: "projects.addMember",
+  group: "projects",
+  description: "Add a member to a project",
+  inputSchema: inputSchema72,
+  outputSchema: z74.any(),
+  async execute(input, ctx) {
+    return ctx.client.post(
+      "project_members",
+      { userId: input.userId, role: input.role },
+      { pathParams: { id: input.projectId } }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/archive.ts
+import { z as z75 } from "zod";
+var inputSchema73 = z75.object({
+  projectId: z75.string().uuid().describe("Project ID to archive")
+});
+var projectsArchive = {
+  name: "projects.archive",
+  group: "projects",
+  description: "Archive (delete) a project",
+  inputSchema: inputSchema73,
+  outputSchema: z75.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("project", {
+      pathParams: { id: input.projectId }
+    });
+    return { archived: true, projectId: input.projectId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.projectId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/create.ts
+import { z as z76 } from "zod";
+var inputSchema74 = z76.object({
+  name: z76.string().min(1).describe("Project name"),
+  description: z76.string().optional().describe("Project description"),
+  icon: z76.string().optional().describe("Project icon")
+});
+var projectsCreate = {
+  name: "projects.create",
+  group: "projects",
+  description: "Create a new project",
+  inputSchema: inputSchema74,
+  outputSchema: z76.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("projects", input);
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/get.ts
+import { z as z77 } from "zod";
+var inputSchema75 = z77.object({
+  projectId: z77.string().uuid().describe("Project ID")
+});
+var projectsGet = {
+  name: "projects.get",
+  group: "projects",
+  description: "Get details of a specific project",
+  inputSchema: inputSchema75,
+  outputSchema: z77.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("project", {
+      pathParams: { id: input.projectId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/leave.ts
+import { z as z78 } from "zod";
+var inputSchema76 = z78.object({
+  projectId: z78.string().uuid().describe("Project ID to leave")
+});
+var projectsLeave = {
+  name: "projects.leave",
+  group: "projects",
+  description: "Leave a project",
+  inputSchema: inputSchema76,
+  outputSchema: z78.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    return ctx.client.post("project_leave", void 0, {
+      pathParams: { id: input.projectId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/list.ts
+import { z as z79 } from "zod";
+var inputSchema77 = z79.object({
+  ...paginationInput
+});
+var projectsList = {
+  name: "projects.list",
+  group: "projects",
+  description: "List all projects accessible to the current user",
+  inputSchema: inputSchema77,
+  outputSchema: z79.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("projects", {
+      queryParams: { page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/members.ts
+import { z as z80 } from "zod";
+var inputSchema78 = z80.object({
+  projectId: z80.string().uuid().describe("Project ID")
+});
+var projectsMembers = {
+  name: "projects.members",
+  group: "projects",
+  description: "List members of a project",
+  inputSchema: inputSchema78,
+  outputSchema: z80.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("project_members", {
+      pathParams: { id: input.projectId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/remove-member.ts
+import { z as z81 } from "zod";
+var inputSchema79 = z81.object({
+  projectId: z81.string().uuid().describe("Project ID"),
+  userId: z81.string().uuid().describe("User ID to remove")
+});
+var projectsRemoveMember = {
+  name: "projects.removeMember",
+  group: "projects",
+  description: "Remove a member from a project",
+  inputSchema: inputSchema79,
+  outputSchema: z81.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("project_member", {
+      pathParams: { id: input.projectId, uid: input.userId }
+    });
+    return { removed: true };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return String(output.removed);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/update.ts
+init_errors();
+import { z as z82 } from "zod";
+var inputSchema80 = z82.object({
+  projectId: z82.string().uuid().describe("Project ID"),
+  name: z82.string().min(1).optional().describe("New project name"),
+  description: z82.string().optional().describe("New project description"),
+  icon: z82.string().optional().describe("New project icon")
+});
+var projectsUpdate = {
+  name: "projects.update",
+  group: "projects",
+  description: "Update an existing project",
+  inputSchema: inputSchema80,
+  outputSchema: z82.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    const { projectId, ...fields } = input;
+    if (!fields.name && !fields.description && !fields.icon) {
+      throw new ValidationError(
+        "At least one field (name, description, icon) must be provided.",
+        "Provide at least one field to update."
+      );
+    }
+    return ctx.client.patch("project", fields, {
+      pathParams: { id: projectId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/update-role.ts
+import { z as z83 } from "zod";
+var inputSchema81 = z83.object({
+  projectId: z83.string().uuid().describe("Project ID"),
+  userId: z83.string().uuid().describe("User ID of the member"),
+  role: z83.string().min(1).describe("New role to assign")
+});
+var projectsUpdateRole = {
+  name: "projects.updateRole",
+  group: "projects",
+  description: "Update a project member's role",
+  inputSchema: inputSchema81,
+  outputSchema: z83.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    return ctx.client.put(
+      "project_member_role",
+      { role: input.role },
+      { pathParams: { id: input.projectId, uid: input.userId } }
+    );
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/projects/index.ts
+function registerProjectCommands() {
+  return [
+    projectsList,
+    projectsGet,
+    projectsCreate,
+    projectsUpdate,
+    projectsArchive,
+    projectsMembers,
+    projectsAddMember,
+    projectsUpdateRole,
+    projectsRemoveMember,
+    projectsLeave
+  ];
+}
+
+// src/commands/search/all.ts
+import { z as z84 } from "zod";
+var inputSchema82 = z84.object({
+  query: z84.string().min(1).describe("Search query"),
+  ...paginationInput
+});
+var searchAll = {
+  name: "search.all",
+  group: "search",
+  description: "Search across all entities",
+  inputSchema: inputSchema82,
+  outputSchema: z84.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("search_all", {
+      queryParams: { q: input.query, page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/search/file-content.ts
+import { z as z85 } from "zod";
+var inputSchema83 = z85.object({
+  query: z85.string().min(1).describe("Search query"),
+  projectId: z85.string().uuid().optional().describe("Filter by project ID"),
+  ...paginationInput
+});
+var searchFileContent = {
+  name: "search.fileContent",
+  group: "search",
+  description: "Search within file contents",
+  inputSchema: inputSchema83,
+  outputSchema: z85.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    const queryParams = {
+      q: input.query,
+      page: input.page,
+      pageSize: input.pageSize
+    };
+    if (input.projectId) queryParams.project = input.projectId;
+    return ctx.client.get("search_file_content", { queryParams });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/search/files.ts
+import { z as z86 } from "zod";
+var inputSchema84 = z86.object({
+  query: z86.string().min(1).describe("Search query"),
+  ...paginationInput
+});
+var searchFiles = {
+  name: "search.files",
+  group: "search",
+  description: "Search files by query",
+  inputSchema: inputSchema84,
+  outputSchema: z86.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("search_files", {
+      queryParams: { q: input.query, page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/search/tasks.ts
+import { z as z87 } from "zod";
+var inputSchema85 = z87.object({
+  query: z87.string().min(1).describe("Search query"),
+  ...paginationInput
+});
+var searchTasks = {
+  name: "search.tasks",
+  group: "search",
+  description: "Search tasks by query",
+  inputSchema: inputSchema85,
+  outputSchema: z87.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("search_tasks", {
+      queryParams: { q: input.query, page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/search/index.ts
+function registerSearchCommands() {
+  return [searchTasks, searchFiles, searchAll, searchFileContent];
+}
+
+// src/commands/tasks/archive.ts
+import { z as z88 } from "zod";
+var inputSchema86 = z88.object({
+  taskId: z88.string().uuid().describe("Task ID to archive")
+});
+var tasksArchive = {
+  name: "tasks.archive",
+  group: "tasks",
+  description: "Archive (delete) a task",
+  inputSchema: inputSchema86,
+  outputSchema: z88.any(),
+  annotations: { destructiveHint: true },
+  async execute(input, ctx) {
+    await ctx.client.del("task", {
+      pathParams: { id: input.taskId }
+    });
+    return { archived: true, taskId: input.taskId };
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.taskId;
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/create.ts
+import { z as z89 } from "zod";
+var inputSchema87 = z89.object({
+  project: z89.string().uuid().describe("Project ID"),
+  title: z89.string().optional().describe("Task title"),
+  message: z89.string().optional().describe("Initial message")
+});
+var tasksCreate = {
+  name: "tasks.create",
+  group: "tasks",
+  description: "Create a new task in a project",
+  inputSchema: inputSchema87,
+  outputSchema: z89.any(),
+  async execute(input, ctx) {
+    return ctx.client.post("tasks", {
+      projectId: input.project,
+      title: input.title,
+      initialMessage: input.message
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/get.ts
+import { z as z90 } from "zod";
+var inputSchema88 = z90.object({
+  taskId: z90.string().uuid().describe("Task ID")
+});
+var tasksGet = {
+  name: "tasks.get",
+  group: "tasks",
+  description: "Get details of a specific task",
+  inputSchema: inputSchema88,
+  outputSchema: z90.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    return ctx.client.get("task", {
+      pathParams: { id: input.taskId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/list.ts
+import { z as z91 } from "zod";
+var inputSchema89 = z91.object({
+  project: z91.string().uuid().optional().describe("Project ID to filter by"),
+  ...paginationInput
+});
+var tasksList = {
+  name: "tasks.list",
+  group: "tasks",
+  description: "List tasks, optionally filtered by project",
+  inputSchema: inputSchema89,
+  outputSchema: z91.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    if (input.project) {
+      return ctx.client.get("project_tasks", {
+        pathParams: { id: input.project },
+        queryParams: { page: input.page, pageSize: input.pageSize }
+      });
+    }
+    return ctx.client.get("tasks", {
+      queryParams: { page: input.page, pageSize: input.pageSize }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/messages.ts
+import { z as z92 } from "zod";
+var inputSchema90 = z92.object({
+  taskId: z92.string().uuid().describe("Task ID"),
+  cursor: z92.string().optional().describe("Pagination cursor"),
+  limit: z92.number().int().min(1).max(100).default(50).describe("Results per page")
+});
+var tasksMessages = {
+  name: "tasks.messages",
+  group: "tasks",
+  description: "List messages for a task",
+  inputSchema: inputSchema90,
+  outputSchema: z92.any(),
+  annotations: { readOnlyHint: true },
+  async execute(input, ctx) {
+    const queryParams = { limit: input.limit };
+    if (input.cursor) {
+      queryParams.cursor = input.cursor;
+    }
+    return ctx.client.get("task_messages", {
+      pathParams: { id: input.taskId },
+      queryParams
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/send.ts
+init_errors();
+init_profiles();
+import { z as z93 } from "zod";
+
+// src/lib/stream.ts
+init_config();
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["completed", "error", "timeout"]);
+var STREAM_TIMEOUT_MS = 3e5;
+async function* streamTask(taskId, apiKey, options) {
+  const baseUrl = options?.aiServerBaseUrl ?? AI_SERVER_URL;
+  const url = `${baseUrl}/api/v1/tasks/${taskId}/stream`;
+  const response = await fetch(url, {
+    headers: {
+      "X-API-Key": apiKey,
+      Accept: "text/event-stream"
+    },
+    signal: options?.signal ?? AbortSignal.timeout(STREAM_TIMEOUT_MS)
+  });
+  if (!response.ok || !response.body) {
+    yield { type: "error", content: `Stream connection failed: HTTP ${response.status}` };
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let eventType = "";
+  let dataLines = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          eventType = line.slice(7).trim();
+        } else if (line.startsWith("data: ")) {
+          dataLines.push(line.slice(6));
+        } else if (line === "") {
+          if (dataLines.length > 0) {
+            const raw = dataLines.join("\n");
+            try {
+              const parsed = JSON.parse(raw);
+              const event = eventType ? { ...parsed, type: eventType } : parsed;
+              yield event;
+              if (TERMINAL_EVENTS.has(event.type)) return;
+            } catch {
+            }
+            dataLines = [];
+          }
+          eventType = "";
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function collectStreamResponse(taskId, apiKey, options) {
+  let content = "";
+  for await (const event of streamTask(taskId, apiKey, options)) {
+    if (event.type === "token") {
+      content += event.content;
+    } else if (event.type === "error") {
+      throw new Error(event.content);
+    }
+  }
+  return content;
+}
+
+// src/lib/stream-renderer.ts
+import pc2 from "picocolors";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 80;
+var StreamRenderer = class {
+  spinnerInterval = null;
+  spinnerFrame = 0;
+  currentLabel = "";
+  useColor;
+  constructor() {
+    this.useColor = isColorEnabled();
+  }
+  renderEvent(event) {
+    switch (event.type) {
+      case "think":
+        this.startSpinner("Thinking...");
+        break;
+      case "tool_start":
+        this.stopSpinner();
+        this.startSpinner(`Using ${event.tool}...`);
+        break;
+      case "tool_end": {
+        this.stopSpinner();
+        const toolEvent = event;
+        const icon = toolEvent.success ? this.useColor ? pc2.green("\u2713") : "\u2713" : this.useColor ? pc2.red("\u2717") : "\u2717";
+        const suffix = toolEvent.result ? ` (${toolEvent.result})` : "";
+        process.stderr.write(`  ${icon} ${toolEvent.tool}${suffix}
+`);
+        break;
+      }
+      case "progress":
+        this.stopSpinner();
+        process.stderr.write(
+          `  ${this.useColor ? pc2.dim(event.content) : event.content}
+`
+        );
+        break;
+      case "token":
+        this.stopSpinner();
+        process.stdout.write(event.content);
+        break;
+      case "completed":
+        this.stopSpinner();
+        process.stdout.write("\n");
+        break;
+      case "error":
+        this.stopSpinner();
+        process.stderr.write(
+          `
+${this.useColor ? pc2.red("Error:") : "Error:"} ${event.content}
+`
+        );
+        break;
+      case "timeout":
+        this.stopSpinner();
+        process.stderr.write(`
+${this.useColor ? pc2.yellow("Stream timed out.") : "Stream timed out."}
+`);
+        break;
+    }
+  }
+  startSpinner(label) {
+    this.stopSpinner();
+    this.currentLabel = label;
+    this.spinnerFrame = 0;
+    if (!process.stderr.isTTY) {
+      process.stderr.write(`  ${label}
+`);
+      return;
+    }
+    this.writeSpinnerFrame();
+    this.spinnerInterval = setInterval(() => {
+      this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
+      this.writeSpinnerFrame();
+    }, SPINNER_INTERVAL_MS);
+  }
+  writeSpinnerFrame() {
+    const frame = SPINNER_FRAMES[this.spinnerFrame];
+    const text = this.useColor ? pc2.dim(`${frame} ${this.currentLabel}`) : `${frame} ${this.currentLabel}`;
+    process.stderr.write(`\r  ${text}`);
+  }
+  stopSpinner() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+      if (process.stderr.isTTY) {
+        process.stderr.write("\r\x1B[K");
+      }
+    }
+  }
+};
+
+// src/commands/tasks/send.ts
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var inputSchema91 = z93.object({
+  taskId: z93.string().uuid().describe("Task ID"),
+  message: z93.string().min(1).describe("Message content"),
+  fileRefs: z93.string().optional().describe("Comma-separated file reference UUIDs"),
+  wait: z93.boolean().default(false).describe("Wait for agent response (polling)"),
+  stream: z93.boolean().default(false).describe("Stream agent response in real-time (SSE)")
+});
+async function pollForResponse(client, taskId, userMessageSequence, timeoutMs = 12e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const messages = await client.get("task_messages", {
+      pathParams: { id: taskId },
+      queryParams: { limit: 10 }
+    });
+    const items = Array.isArray(messages) ? messages : messages?.items ?? [];
+    if (Array.isArray(items)) {
+      const assistantMsg = items.find((m) => {
+        const msg = m;
+        return (msg.role === "assistant" || msg.role === "Assistant") && (msg.sequence ?? msg.sequenceNumber ?? 0) > userMessageSequence;
+      });
+      if (assistantMsg) return assistantMsg;
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  throw new ElnoraError("Timed out waiting for agent response (120s)", {
+    code: "RESPONSE_TIMEOUT",
+    suggestion: "The agent may still be processing. Check with: elnora tasks messages <task-id>"
+  });
+}
+var tasksSend = {
+  name: "tasks.send",
+  group: "tasks",
+  description: "Send a message to a task",
+  inputSchema: inputSchema91,
+  outputSchema: z93.any(),
+  async execute(input, ctx) {
+    let referencedFileIds;
+    if (input.fileRefs) {
+      referencedFileIds = input.fileRefs.split(",").map((s) => s.trim()).filter((s) => s.length > 0).filter((s) => UUID_RE2.test(s));
+    }
+    const result = await ctx.client.post(
+      "task_messages",
+      {
+        content: input.message,
+        referencedFileIds
+      },
+      { pathParams: { id: input.taskId } }
+    );
+    if (ctx.mode === "mcp") {
+      try {
+        const apiKey = resolveApiKey(ctx.profileName);
+        const content = await collectStreamResponse(input.taskId, apiKey);
+        return { sent: true, taskId: input.taskId, response: content };
+      } catch {
+        const seq = result?.sequence ?? 0;
+        return pollForResponse(ctx.client, input.taskId, seq);
+      }
+    }
+    if (!input.wait && !input.stream) {
+      return result;
+    }
+    if (input.stream) {
+      const apiKey = resolveApiKey(ctx.profileName);
+      const renderer = new StreamRenderer();
+      for await (const event of streamTask(input.taskId, apiKey)) {
+        renderer.renderEvent(event);
+      }
+      renderer.stopSpinner();
+      return { sent: true, taskId: input.taskId, streamed: true };
+    }
+    const sequence = result?.sequence ?? result?.sequenceNumber ?? 0;
+    return pollForResponse(ctx.client, input.taskId, sequence);
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/update.ts
+init_errors();
+import { z as z94 } from "zod";
+var inputSchema92 = z94.object({
+  taskId: z94.string().uuid().describe("Task ID"),
+  title: z94.string().min(1).optional().describe("New task title"),
+  status: z94.string().optional().describe("New task status")
+});
+var tasksUpdate = {
+  name: "tasks.update",
+  group: "tasks",
+  description: "Update an existing task",
+  inputSchema: inputSchema92,
+  outputSchema: z94.any(),
+  annotations: { idempotentHint: true },
+  async execute(input, ctx) {
+    const { taskId, ...fields } = input;
+    if (!fields.title && !fields.status) {
+      throw new ValidationError(
+        "At least one field (title, status) must be provided.",
+        "Provide at least one field to update."
+      );
+    }
+    return ctx.client.patch("task", fields, {
+      pathParams: { id: taskId }
+    });
+  },
+  formatOutput(output, format) {
+    if (format === "compact") return output.id ?? JSON.stringify(output);
+    return JSON.stringify(output, null, 2);
+  }
+};
+
+// src/commands/tasks/index.ts
+function registerTaskCommands() {
+  return [tasksList, tasksGet, tasksCreate, tasksSend, tasksMessages, tasksUpdate, tasksArchive];
+}
+
+// src/commands/whoami.ts
+init_client();
+init_profiles();
+function addWhoamiCommand(program2) {
+  program2.command("whoami").description("Show current authentication context").action(async () => {
+    const parentOpts = program2.opts();
+    const profileName = parentOpts.profile ?? "default";
+    try {
+      const key = resolveApiKey(profileName);
+      const masked = key.length > 20 ? `${key.slice(0, 16)}...${key.slice(-4)}` : `${key.slice(0, 4)}...`;
+      let orgName = "unknown";
+      try {
+        const client = new ElnoraApiClient(key);
+        const orgs = await client.get("organizations");
+        const orgList = Array.isArray(orgs) ? orgs : orgs?.items ?? [];
+        if (orgList.length > 0) orgName = orgList[0]?.name ?? "unknown";
+      } catch {
+      }
+      if (parentOpts.json) {
+        console.log(JSON.stringify({ profile: profileName, apiKey: masked, orgName }, null, 2));
+      } else {
+        console.log(`
+Profile:  ${profileName}`);
+        console.log(`API Key:  ${masked}`);
+        console.log(`Org:      ${orgName}`);
+        console.log("");
+      }
+    } catch (e) {
+      console.error(e instanceof Error ? e.message : "Not authenticated");
+      console.error("Run: elnora auth login");
+      process.exit(3);
+    }
+  });
+}
+
+// src/core/registry.ts
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  register(command) {
+    if (this.commands.has(command.name)) {
+      throw new Error(`Duplicate command: ${command.name}`);
+    }
+    this.commands.set(command.name, command);
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  all() {
+    return Array.from(this.commands.values());
+  }
+  byGroup(group) {
+    return this.all().filter((cmd) => cmd.group === group);
+  }
+  groups() {
+    const groups = /* @__PURE__ */ new Set();
+    for (const cmd of this.commands.values()) {
+      groups.add(cmd.group);
+    }
+    return Array.from(groups).sort();
+  }
+};
+
+// src/cli.ts
+init_errors();
+
+// src/lib/update-check.ts
+init_config();
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+import pc3 from "picocolors";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@elnora-ai/cli/latest";
+var CACHE_DIR = join3(homedir2(), ".elnora");
+var CACHE_FILE = join3(CACHE_DIR, ".update-check");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function shouldSkip() {
+  if (process.env.CI || process.env.GITHUB_ACTIONS) return true;
+  if (process.env.ELNORA_NO_UPDATE_CHECK) return true;
+  if (!process.stderr.isTTY) return true;
+  return false;
+}
+function readCache() {
+  try {
+    if (!existsSync3(CACHE_FILE)) return null;
+    const raw = readFileSync5(CACHE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(entry) {
+  try {
+    mkdirSync2(CACHE_DIR, { recursive: true });
+    writeFileSync2(CACHE_FILE, JSON.stringify(entry), "utf-8");
+  } catch {
+  }
+}
+function showUpdateNotice(latest) {
+  const color = isColorEnabled();
+  const msg = color ? `
+${pc3.yellow(`Update available: v${VERSION} \u2192 v${latest}`)}
+Run: curl -fsSL https://cli.elnora.ai/install.sh | bash
+` : `
+Update available: v${VERSION} \u2192 v${latest}
+Run: curl -fsSL https://cli.elnora.ai/install.sh | bash
+`;
+  process.stderr.write(msg);
+}
+function registerUpdateCheck() {
+  if (shouldSkip()) return;
+  const cached = readCache();
+  if (cached) {
+    const elapsed = Date.now() - new Date(cached.checkedAt).getTime();
+    if (elapsed < CHECK_INTERVAL_MS) {
+      if (cached.latest && cached.latest !== VERSION && cached.latest !== "unknown") {
+        if (cached.latest > VERSION) {
+          showUpdateNotice(cached.latest);
+        }
+      }
+      return;
+    }
+  }
+  setTimeout(async () => {
+    try {
+      const response = await fetch(NPM_REGISTRY_URL, {
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+      });
+      if (!response.ok) return;
+      const data = await response.json();
+      const latest = data.version ?? "unknown";
+      writeCache({ checkedAt: (/* @__PURE__ */ new Date()).toISOString(), latest });
+      if (latest !== VERSION && latest !== "unknown" && latest > VERSION) {
+        showUpdateNotice(latest);
+      }
+    } catch {
+    }
+  }, 0);
+}
+
+// src/cli.ts
+process.on("uncaughtException", (err) => {
+  const payload = formatErrorPayload(err);
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+  process.exit(getExitCode(err));
+});
+process.on("unhandledRejection", (reason) => {
+  const err = reason instanceof Error ? reason : new Error(String(reason));
+  const payload = formatErrorPayload(err);
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+  process.exit(1);
+});
+var registry = new CommandRegistry();
+var commandGroups = [
+  [healthCheck],
+  registerAuthCommands(),
+  registerProjectCommands(),
+  registerTaskCommands(),
+  registerFileCommands(),
+  registerOrgCommands(),
+  registerFolderCommands(),
+  registerSearchCommands(),
+  registerLibraryCommands(),
+  registerAccountCommands(),
+  registerApiKeyCommands(),
+  registerAuditCommands(),
+  registerFeedbackCommands(),
+  registerFlagCommands()
+];
+for (const commands of commandGroups) {
+  for (const cmd of commands) {
+    registry.register(cmd);
+  }
+}
+var program = buildProgram(registry);
+addMcpCommands(program, registry);
+addDoctorCommand(program);
+addWhoamiCommand(program);
+addOpenCommand(program);
+addCompletionCommand(program);
+registerUpdateCheck();
+program.parseAsync(process.argv);