lindoai-cli 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2900 @@
+#!/usr/bin/env node
+'use strict';
+
+var http = require('http');
+var fs3 = require('fs');
+var path3 = require('path');
+var os2 = require('os');
+var commander = require('commander');
+var lindoai = require('lindoai');
+var child_process = require('child_process');
+var url = require('url');
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+
+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/server/live-preview-server.ts
+var live_preview_server_exports = {};
+__export(live_preview_server_exports, {
+  LIVE_RELOAD_SCRIPT: () => LIVE_RELOAD_SCRIPT,
+  injectLiveReload: () => injectLiveReload,
+  startLivePreviewServer: () => startLivePreviewServer
+});
+function injectLiveReload(html) {
+  const bodyCloseTagRegex = /<\/body>/i;
+  const match = html.match(bodyCloseTagRegex);
+  if (match && match.index !== void 0) {
+    return html.slice(0, match.index) + LIVE_RELOAD_SCRIPT + html.slice(match.index);
+  }
+  return html + LIVE_RELOAD_SCRIPT;
+}
+function startLivePreviewServer(filePath) {
+  return new Promise((resolve4, reject) => {
+    const absolutePath = path3__namespace.resolve(filePath);
+    const sseClients = /* @__PURE__ */ new Set();
+    let debounceTimer = null;
+    const DEBOUNCE_MS = 100;
+    function notifyClients() {
+      for (const client of sseClients) {
+        try {
+          client.write("data: reload\n\n");
+        } catch {
+          sseClients.delete(client);
+        }
+      }
+    }
+    function handleFileChange() {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(() => {
+        notifyClients();
+        debounceTimer = null;
+      }, DEBOUNCE_MS);
+    }
+    function handleRequest(req, res) {
+      const url = req.url || "/";
+      const method = req.method || "GET";
+      if (method !== "GET") {
+        res.writeHead(405, { "Content-Type": "text/plain" });
+        res.end("Method Not Allowed");
+        return;
+      }
+      if (url === "/__live-reload") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.write("data: connected\n\n");
+        sseClients.add(res);
+        req.on("close", () => {
+          sseClients.delete(res);
+        });
+        return;
+      }
+      if (url === "/" || url === "/index.html") {
+        try {
+          const html = fs3__namespace.readFileSync(absolutePath, "utf-8");
+          const injectedHtml = injectLiveReload(html);
+          res.writeHead(200, {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": "no-cache"
+          });
+          res.end(injectedHtml);
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : "Unknown error";
+          res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(`<!DOCTYPE html>
+<html>
+<head><title>Error</title></head>
+<body>
+<h1>Error loading file</h1>
+<p>${errorMessage}</p>
+</body>
+</html>`);
+        }
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(`<!DOCTYPE html>
+<html>
+<head><title>Not Found</title></head>
+<body>
+<h1>404 Not Found</h1>
+<p>The requested resource was not found.</p>
+</body>
+</html>`);
+    }
+    const server = http__namespace.createServer(handleRequest);
+    let watcher = null;
+    server.on("error", (err) => {
+      reject(new Error(`Failed to start preview server: ${err.message}`));
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      try {
+        watcher = fs3__namespace.watch(absolutePath, (eventType) => {
+          if (eventType === "change") {
+            handleFileChange();
+          }
+        });
+        watcher.on("error", (err) => {
+          console.error(`[Live Preview] File watcher error: ${err.message}`);
+        });
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Unknown error";
+        console.error(`[Live Preview] Failed to watch file: ${errorMessage}`);
+      }
+      const handleShutdown = () => {
+        if (watcher) {
+          watcher.close();
+          watcher = null;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+          debounceTimer = null;
+        }
+        for (const client of sseClients) {
+          try {
+            client.end();
+          } catch {
+          }
+        }
+        sseClients.clear();
+        const pidFilePath = path3__namespace.join(os2__namespace.tmpdir(), "lindoai-pages-preview.pid");
+        const portFilePath = path3__namespace.join(os2__namespace.tmpdir(), "lindoai-pages-preview.port");
+        try {
+          if (fs3__namespace.existsSync(pidFilePath)) {
+            fs3__namespace.unlinkSync(pidFilePath);
+          }
+        } catch {
+        }
+        try {
+          if (fs3__namespace.existsSync(portFilePath)) {
+            fs3__namespace.unlinkSync(portFilePath);
+          }
+        } catch {
+        }
+        server.close(() => {
+          process.exit(0);
+        });
+        setTimeout(() => {
+          process.exit(0);
+        }, 1e3);
+      };
+      process.on("SIGTERM", handleShutdown);
+      process.on("SIGINT", handleShutdown);
+      resolve4(port);
+    });
+  });
+}
+var LIVE_RELOAD_SCRIPT;
+var init_live_preview_server = __esm({
+  "src/server/live-preview-server.ts"() {
+    LIVE_RELOAD_SCRIPT = `<script>
+(function() {
+  var eventSource = new EventSource('/__live-reload');
+  eventSource.onmessage = function(event) {
+    if (event.data === 'reload') {
+      window.location.reload();
+    }
+  };
+  eventSource.onerror = function() {
+    console.log('[Live Reload] Connection lost, attempting to reconnect...');
+  };
+})();
+</script>`;
+  }
+});
+var ENV_API_KEY = "LINDO_API_KEY";
+var ENV_BASE_URL = "LINDO_BASE_URL";
+var CONFIG_DIR = ".lindo";
+var CONFIG_FILE = "config.json";
+var DEFAULT_BASE_URL = "https://api.lindo.ai";
+function getConfigDir() {
+  return path3__namespace.join(os2__namespace.homedir(), CONFIG_DIR);
+}
+function getConfigPath() {
+  return path3__namespace.join(getConfigDir(), CONFIG_FILE);
+}
+function readConfigFile() {
+  const configPath = getConfigPath();
+  try {
+    if (fs3__namespace.existsSync(configPath)) {
+      const content = fs3__namespace.readFileSync(configPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function writeConfigFile(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  if (!fs3__namespace.existsSync(configDir)) {
+    fs3__namespace.mkdirSync(configDir, { recursive: true });
+  }
+  fs3__namespace.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function loadConfig() {
+  const fileConfig = readConfigFile();
+  const apiKey = process.env[ENV_API_KEY] || fileConfig.apiKey;
+  const baseUrl = process.env[ENV_BASE_URL] || fileConfig.baseUrl || DEFAULT_BASE_URL;
+  return {
+    apiKey,
+    baseUrl
+  };
+}
+function saveApiKey(apiKey) {
+  const config = readConfigFile();
+  config.apiKey = apiKey;
+  writeConfigFile(config);
+}
+function saveConfig(key, value) {
+  const config = readConfigFile();
+  switch (key) {
+    case "apiKey":
+      config.apiKey = value;
+      break;
+    case "baseUrl":
+      config.baseUrl = value;
+      break;
+    default:
+      throw new Error(`Unknown configuration key: ${key}`);
+  }
+  writeConfigFile(config);
+}
+function getConfigValue(key) {
+  const config = loadConfig();
+  switch (key) {
+    case "apiKey":
+      return config.apiKey;
+    case "baseUrl":
+      return config.baseUrl;
+    default:
+      return void 0;
+  }
+}
+function hasApiKey() {
+  const config = loadConfig();
+  return !!config.apiKey;
+}
+
+// src/output.ts
+var colors = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m"
+};
+function useColors() {
+  return !process.env.NO_COLOR && process.stdout.isTTY !== false;
+}
+function colorize(text, color) {
+  if (!useColors()) {
+    return text;
+  }
+  return `${color}${text}${colors.reset}`;
+}
+function success(message) {
+  console.log(colorize(`\u2713 ${message}`, colors.green));
+}
+function error(message) {
+  console.error(colorize(`\u2717 ${message}`, colors.red));
+}
+function info(message) {
+  console.log(colorize(`\u2139 ${message}`, colors.blue));
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatTable(data) {
+  if (data === null || data === void 0) {
+    return "";
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      return "No data";
+    }
+    const keys = /* @__PURE__ */ new Set();
+    for (const item of data) {
+      if (typeof item === "object" && item !== null) {
+        Object.keys(item).forEach((key) => keys.add(key));
+      }
+    }
+    if (keys.size === 0) {
+      return data.map((item) => String(item)).join("\n");
+    }
+    const columns = Array.from(keys);
+    return formatTableFromRows(columns, data);
+  }
+  if (typeof data === "object") {
+    const obj = data;
+    const entries = Object.entries(obj);
+    if (entries.length === 0) {
+      return "No data";
+    }
+    const maxKeyLength = Math.max(...entries.map(([key]) => key.length));
+    return entries.map(([key, value]) => {
+      const paddedKey = key.padEnd(maxKeyLength);
+      const formattedValue = formatValue(value);
+      return `${colorize(paddedKey, colors.cyan)}  ${formattedValue}`;
+    }).join("\n");
+  }
+  return String(data);
+}
+function formatTableFromRows(columns, rows) {
+  const widths = {};
+  for (const col of columns) {
+    widths[col] = col.length;
+  }
+  for (const row of rows) {
+    if (typeof row === "object" && row !== null) {
+      const obj = row;
+      for (const col of columns) {
+        const value = formatValue(obj[col]);
+        widths[col] = Math.max(widths[col], value.length);
+      }
+    }
+  }
+  const header = columns.map((col) => colorize(col.padEnd(widths[col]), colors.bold)).join("  ");
+  const separator = columns.map((col) => "-".repeat(widths[col])).join("  ");
+  const dataRows = rows.map((row) => {
+    if (typeof row === "object" && row !== null) {
+      const obj = row;
+      return columns.map((col) => formatValue(obj[col]).padEnd(widths[col])).join("  ");
+    }
+    return String(row);
+  });
+  return [header, separator, ...dataRows].join("\n");
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return colorize("-", colors.gray);
+  }
+  if (typeof value === "boolean") {
+    return value ? colorize("true", colors.green) : colorize("false", colors.red);
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    if (Array.isArray(value)) {
+      return `[${value.length} items]`;
+    }
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function output(data, format) {
+  if (format === "json") {
+    console.log(formatJson(data));
+  } else {
+    console.log(formatTable(data));
+  }
+}
+
+// src/commands/config.ts
+var VALID_KEYS = ["apiKey", "baseUrl"];
+function createConfigCommand() {
+  const config = new commander.Command("config").description("Manage CLI configuration");
+  config.command("set <key> <value>").description("Set a configuration value").action((key, value) => {
+    if (!VALID_KEYS.includes(key)) {
+      error(`Invalid configuration key: ${key}`);
+      info(`Valid keys: ${VALID_KEYS.join(", ")}`);
+      process.exit(1);
+    }
+    try {
+      saveConfig(key, value);
+      success(`Configuration saved: ${key}`);
+      info(`Config file: ${getConfigPath()}`);
+    } catch (err) {
+      error(`Failed to save configuration: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+  config.command("get <key>").description("Get a configuration value").option("-f, --format <format>", "Output format (json, table)", "table").action((key, options) => {
+    const value = getConfigValue(key);
+    if (value === void 0) {
+      if (options.format === "json") {
+        output({ key, value: null }, options.format);
+      } else {
+        info(`Configuration key '${key}' is not set`);
+      }
+      return;
+    }
+    if (options.format === "json") {
+      output({ key, value }, options.format);
+    } else {
+      const displayValue = key === "apiKey" ? maskApiKey(value) : value;
+      console.log(`${key}: ${displayValue}`);
+    }
+  });
+  config.command("list").description("List all configuration values").option("-f, --format <format>", "Output format (json, table)", "table").action((options) => {
+    const resolvedConfig = loadConfig();
+    const configData = {
+      apiKey: resolvedConfig.apiKey ? maskApiKey(resolvedConfig.apiKey) : "(not set)",
+      baseUrl: resolvedConfig.baseUrl,
+      configFile: getConfigPath()
+    };
+    if (options.format === "json") {
+      output(
+        {
+          apiKey: resolvedConfig.apiKey ? maskApiKey(resolvedConfig.apiKey) : null,
+          baseUrl: resolvedConfig.baseUrl,
+          configFile: getConfigPath()
+        },
+        options.format
+      );
+    } else {
+      output(configData, options.format);
+    }
+  });
+  config.command("path").description("Show the config file path").action(() => {
+    console.log(getConfigPath());
+  });
+  return config;
+}
+function maskApiKey(apiKey) {
+  if (apiKey.length <= 8) {
+    return "*".repeat(apiKey.length);
+  }
+  return `${apiKey.slice(0, 4)}${"*".repeat(apiKey.length - 8)}${apiKey.slice(-4)}`;
+}
+function createAgentsCommand() {
+  const agents = new commander.Command("agents").description("Run AI agents");
+  agents.command("run <agent-id>").description("Run an AI agent").option("-i, --input <json>", "Input data as JSON string", "{}").option("-s, --stream", "Stream the response", false).option("-f, --format <format>", "Output format (json, table)", "table").action(async (agentId, options) => {
+    if (!hasApiKey()) {
+      error("API key not configured");
+      info("Run: lindo config set apiKey <your-api-key>");
+      info("Or set the LINDO_API_KEY environment variable");
+      process.exit(1);
+    }
+    const config = loadConfig();
+    const client = new lindoai.LindoClient({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl
+    });
+    let input;
+    try {
+      input = JSON.parse(options.input);
+    } catch {
+      error("Invalid JSON input");
+      info(`Example: --input '{"prompt": "Hello!"}'`);
+      process.exit(1);
+    }
+    try {
+      info(`Running agent: ${agentId}`);
+      const result = await client.agents.run({
+        agent_id: agentId,
+        input,
+        stream: options.stream
+      });
+      if (result.success) {
+        success("Agent run completed");
+        output(result, options.format);
+      } else {
+        error(`Agent run failed: ${result.error || "Unknown error"}`);
+        output(result, options.format);
+        process.exit(1);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return agents;
+}
+function handleError(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createWorkflowsCommand() {
+  const workflows = new commander.Command("workflows").description("Manage workflows");
+  workflows.command("list").description("List workflow logs").option("-n, --name <name>", "Filter by workflow name").option("-s, --status <status>", "Filter by status").option("-w, --website <id>", "Filter by website ID").option("-c, --client <id>", "Filter by client ID").option("-l, --limit <number>", "Maximum number of results", "50").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient();
+    try {
+      const result = await client.workflows.list({
+        workflow_name: options.name,
+        status: options.status,
+        website_id: options.website,
+        client_id: options.client,
+        limit: parseInt(options.limit)
+      });
+      if (result.success) {
+        output(result.data, options.format);
+      } else {
+        error("Failed to list workflows");
+        process.exit(1);
+      }
+    } catch (err) {
+      handleError2(err);
+    }
+  });
+  workflows.command("start <workflow-name>").description("Start a workflow").option("-p, --params <json>", "Workflow parameters as JSON string", "{}").option("-f, --format <format>", "Output format (json, table)", "table").action(async (workflowName, options) => {
+    const client = getClient();
+    let params;
+    try {
+      params = JSON.parse(options.params);
+    } catch {
+      error("Invalid JSON params");
+      info(`Example: --params '{"page_id": "page-123"}'`);
+      process.exit(1);
+    }
+    try {
+      info(`Starting workflow: ${workflowName}`);
+      const result = await client.workflows.start({
+        workflow_name: workflowName,
+        params
+      });
+      if (result.success) {
+        success(`Workflow started: ${result.instance_id}`);
+        output(result, options.format);
+      } else {
+        error("Failed to start workflow");
+        output(result, options.format);
+        process.exit(1);
+      }
+    } catch (err) {
+      handleError2(err);
+    }
+  });
+  workflows.command("status <instance-id>").description("Get workflow status").option("-f, --format <format>", "Output format (json, table)", "table").action(async (instanceId, options) => {
+    const client = getClient();
+    try {
+      const status = await client.workflows.getStatus(instanceId);
+      output(status, options.format);
+    } catch (err) {
+      handleError2(err);
+    }
+  });
+  workflows.command("pause <instance-id>").description("Pause a running workflow").option("-f, --format <format>", "Output format (json, table)", "table").action(async (instanceId, options) => {
+    const client = getClient();
+    try {
+      info(`Pausing workflow: ${instanceId}`);
+      const result = await client.workflows.pause(instanceId);
+      if (result.success) {
+        success(result.message);
+      } else {
+        error(result.message);
+        process.exit(1);
+      }
+      output(result, options.format);
+    } catch (err) {
+      handleError2(err);
+    }
+  });
+  workflows.command("resume <instance-id>").description("Resume a paused workflow").option("-f, --format <format>", "Output format (json, table)", "table").action(async (instanceId, options) => {
+    const client = getClient();
+    try {
+      info(`Resuming workflow: ${instanceId}`);
+      const result = await client.workflows.resume(instanceId);
+      if (result.success) {
+        success(result.message);
+      } else {
+        error(result.message);
+        process.exit(1);
+      }
+      output(result, options.format);
+    } catch (err) {
+      handleError2(err);
+    }
+  });
+  workflows.command("terminate <instance-id>").description("Terminate a workflow").option("-f, --format <format>", "Output format (json, table)", "table").action(async (instanceId, options) => {
+    const client = getClient();
+    try {
+      info(`Terminating workflow: ${instanceId}`);
+      const result = await client.workflows.terminate(instanceId);
+      if (result.success) {
+        success(result.message);
+      } else {
+        error(result.message);
+        process.exit(1);
+      }
+      output(result, options.format);
+    } catch (err) {
+      handleError2(err);
+    }
+  });
+  return workflows;
+}
+function getClient() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError2(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createWorkspaceCommand() {
+  const workspace = new commander.Command("workspace").description("Workspace operations");
+  workspace.command("get").description("Get workspace details").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.get();
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("credits").description("Get workspace credit balance").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const credits = await client.workspace.getCredits();
+      output(credits, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("client-credits").description("Get credit balance for a specific client").requiredOption("-c, --client <id>", "Client ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const credits = await client.workspace.getClientCredits(options.client);
+      output(credits, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("update").description("Update workspace settings").option("-n, --name <name>", "Workspace name").option("-l, --language <lang>", "Workspace language").option("-w, --webhook <url>", "Webhook URL").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.update({
+        workspace_name: options.name,
+        workspace_language: options.language,
+        webhook_url: options.webhook
+      });
+      if (response.success) {
+        success("Workspace updated");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("team-add").description("Add a team member to the workspace").requiredOption("-e, --email <email>", "Team member email").option("-r, --role <role>", "Role (Team)", "Team").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.addTeamMember(options.email, options.role);
+      if (response.success) {
+        success("Team member added");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("team-remove").description("Remove a team member from the workspace").requiredOption("-m, --member <id>", "Member ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.removeTeamMember(options.member);
+      if (response.success) {
+        success("Team member removed");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("integration-add").description("Add an integration to the workspace").requiredOption("-t, --type <type>", "Integration type (e.g., matomo)").requiredOption("-c, --config <json>", "Integration config as JSON").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    let config;
+    try {
+      config = JSON.parse(options.config);
+    } catch {
+      error("Invalid JSON config");
+      process.exit(1);
+    }
+    try {
+      const response = await client.workspace.addIntegration({
+        integration_type: options.type,
+        config
+      });
+      if (response.success) {
+        success("Integration added");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("integration-remove").description("Remove an integration from the workspace").requiredOption("-t, --type <type>", "Integration type").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.removeIntegration(options.type);
+      if (response.success) {
+        success("Integration removed");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("whitelabel").description("Setup or update whitelabel settings").option("-d, --domain <domain>", "Custom domain").option("-s, --subdomain <domain>", "Subdomain domain").option("-e, --email-sender <email>", "Email sender address").option("--enable-register", "Enable client registration").option("--disable-register", "Disable client registration").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.setupWhitelabel({
+        domain: options.domain,
+        subdomain_domain: options.subdomain,
+        email_sender: options.emailSender,
+        wl_client_register: options.enableRegister ? true : options.disableRegister ? false : void 0
+      });
+      if (response.success) {
+        success("Whitelabel settings updated");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  workspace.command("appearance").description("Update workspace appearance settings").option("-p, --primary <color>", "Primary color (hex)").option("-s, --secondary <color>", "Secondary color (hex)").option("-m, --mode <mode>", "Theme mode (light/dark)").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient2();
+    try {
+      const response = await client.workspace.updateAppearance({
+        primary_color: options.primary,
+        secondary_color: options.secondary,
+        theme_mode: options.mode
+      });
+      if (response.success) {
+        success("Appearance settings updated");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError3(err);
+    }
+  });
+  return workspace;
+}
+function getClient2() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError3(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createAnalyticsCommand() {
+  const analytics = new commander.Command("analytics").description("Analytics operations");
+  analytics.command("workspace").description("Get workspace analytics").option("--from <date>", "Start date (ISO format)").option("--to <date>", "End date (ISO format)").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient3();
+    try {
+      const analytics2 = await client.analytics.getWorkspace({
+        from: options.from,
+        to: options.to
+      });
+      output(analytics2, options.format);
+    } catch (err) {
+      handleError4(err);
+    }
+  });
+  analytics.command("website").description("Get website analytics").requiredOption("-w, --website <id>", "Website ID (required)").option("--from <date>", "Start date (ISO format)").option("--to <date>", "End date (ISO format)").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient3();
+    try {
+      const analytics2 = await client.analytics.getWebsite({
+        website_id: options.website,
+        from: options.from,
+        to: options.to
+      });
+      output(analytics2, options.format);
+    } catch (err) {
+      handleError4(err);
+    }
+  });
+  return analytics;
+}
+function getClient3() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError4(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createClientsCommand() {
+  const clients = new commander.Command("clients").description("Client management operations");
+  clients.command("list").description("List all workspace clients").option("-p, --page <page>", "Page number", "1").option("-s, --search <search>", "Search term").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient4();
+    try {
+      const response = await client.clients.list({
+        page: parseInt(options.page, 10),
+        search: options.search
+      });
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        if (response.clients && response.clients.length > 0) {
+          console.log("\nClients:");
+          console.log("--------");
+          for (const c of response.clients) {
+            console.log(`  ID: ${c.record_id}`);
+            console.log(`  Email: ${c.email}`);
+            console.log(`  Website Limit: ${c.website_limit ?? "N/A"}`);
+            console.log(`  Suspended: ${c.suspended ?? false}`);
+            console.log("");
+          }
+          console.log(`Total: ${response.total ?? response.clients.length}`);
+        } else {
+          info("No clients found");
+        }
+      }
+    } catch (err) {
+      handleError5(err);
+    }
+  });
+  clients.command("create").description("Create a new workspace client").requiredOption("-e, --email <email>", "Client email address").option("-l, --limit <limit>", "Website limit", "5").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient4();
+    try {
+      const response = await client.clients.create({
+        email: options.email,
+        website_limit: parseInt(options.limit, 10)
+      });
+      if (response.success && response.client) {
+        success(`Client created: ${response.client.record_id}`);
+        output(response.client, options.format);
+      } else {
+        error("Failed to create client");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError5(err);
+    }
+  });
+  clients.command("update").description("Update a workspace client").requiredOption("-i, --id <id>", "Client ID").option("-l, --limit <limit>", "Website limit").option("--suspend", "Suspend the client").option("--unsuspend", "Unsuspend the client").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient4();
+    try {
+      const response = await client.clients.update({
+        client_id: options.id,
+        website_limit: options.limit ? parseInt(options.limit, 10) : void 0,
+        suspended: options.suspend ? true : options.unsuspend ? false : void 0
+      });
+      if (response.success) {
+        success("Client updated");
+        if (response.client) {
+          output(response.client, options.format);
+        }
+      } else {
+        error("Failed to update client");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError5(err);
+    }
+  });
+  clients.command("delete").description("Delete a workspace client").requiredOption("-i, --id <id>", "Client ID").action(async (options) => {
+    const client = getClient4();
+    try {
+      const response = await client.clients.delete(options.id);
+      if (response.success) {
+        success("Client deleted");
+      } else {
+        error("Failed to delete client");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError5(err);
+    }
+  });
+  clients.command("magic-link").description("Create a magic link for client authentication").requiredOption("-e, --email <email>", "Client email address").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient4();
+    try {
+      const response = await client.clients.createMagicLink(options.email);
+      if (response.success) {
+        success("Magic link created");
+        output(response, options.format);
+      } else {
+        error("Failed to create magic link");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError5(err);
+    }
+  });
+  return clients;
+}
+function getClient4() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError5(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createWebsitesCommand() {
+  const websites = new commander.Command("websites").description("Website management operations");
+  websites.command("list").description("List all workspace websites").option("-p, --page <page>", "Page number", "1").option("-s, --search <search>", "Search term").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.list({
+        page: parseInt(options.page, 10),
+        search: options.search
+      });
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        if (response.websites && response.websites.length > 0) {
+          console.log("\nWebsites:");
+          console.log("---------");
+          for (const w of response.websites) {
+            console.log(`  ID: ${w.record_id}`);
+            console.log(`  Business Name: ${w.business_name ?? "N/A"}`);
+            console.log(`  Preview URL: ${w.preview_url ?? "N/A"}`);
+            console.log(`  Activated: ${w.activated ?? false}`);
+            console.log("");
+          }
+          console.log(`Total: ${response.total ?? response.websites.length}`);
+        } else {
+          info("No websites found");
+        }
+      }
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("get").description("Get website details").requiredOption("-i, --id <id>", "Website ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.getDetails(options.id);
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("update").description("Update a website").requiredOption("-i, --id <id>", "Website ID").option("-n, --name <name>", "Business name").option("--activate", "Activate the website").option("--deactivate", "Deactivate the website").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.update({
+        website_id: options.id,
+        business_name: options.name,
+        activated: options.activate ? true : options.deactivate ? false : void 0
+      });
+      if (response.success) {
+        success("Website updated");
+        if (response.website) {
+          output(response.website, options.format);
+        }
+      } else {
+        error("Failed to update website");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("settings").description("Update website settings").requiredOption("-i, --id <id>", "Website ID").option("-n, --name <name>", "Business name").option("-l, --language <lang>", "Language").option("-d, --description <desc>", "Business description").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.updateSettings(options.id, {
+        business_name: options.name,
+        language: options.language,
+        business_description: options.description
+      });
+      if (response.success) {
+        success("Website settings updated");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("delete").description("Delete a website").requiredOption("-i, --id <id>", "Website ID").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.delete(options.id);
+      if (response.success) {
+        success("Website deleted");
+      } else {
+        error("Failed to delete website");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("assign").description("Assign a website to a client").requiredOption("-w, --website <id>", "Website ID").requiredOption("-c, --client <id>", "Client ID").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.assign({
+        website_id: options.website,
+        client_id: options.client
+      });
+      if (response.success) {
+        success("Website assigned to client");
+      } else {
+        error("Failed to assign website");
+        if (response.errors) {
+          for (const e of response.errors) {
+            error(`  ${e}`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("domain-add").description("Add a custom domain to a website").requiredOption("-i, --id <id>", "Website ID").requiredOption("-d, --domain <domain>", "Custom domain").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.addDomain(options.id, options.domain);
+      if (response.success) {
+        success("Domain added");
+        if (response.result?.dns_records) {
+          console.log("\nDNS Records to configure:");
+          for (const record of response.result.dns_records) {
+            console.log(`  ${record.record_type} ${record.host} -> ${record.value}`);
+          }
+        }
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("domain-remove").description("Remove a custom domain from a website").requiredOption("-i, --id <id>", "Website ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.removeDomain(options.id);
+      if (response.success) {
+        success("Domain removed");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("integration-add").description("Add an integration to a website").requiredOption("-i, --id <id>", "Website ID").requiredOption("-t, --type <type>", "Integration type (e.g., matomo)").requiredOption("-c, --config <json>", "Integration config as JSON").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    let config;
+    try {
+      config = JSON.parse(options.config);
+    } catch {
+      error("Invalid JSON config");
+      process.exit(1);
+    }
+    try {
+      const response = await client.websites.addIntegration(options.id, {
+        integration_type: options.type,
+        config
+      });
+      if (response.success) {
+        success("Integration added");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("integration-remove").description("Remove an integration from a website").requiredOption("-i, --id <id>", "Website ID").requiredOption("-t, --type <type>", "Integration type").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.removeIntegration(options.id, options.type);
+      if (response.success) {
+        success("Integration removed");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("team-add").description("Add a team member to a website").requiredOption("-i, --id <id>", "Website ID").requiredOption("-e, --email <email>", "Team member email").requiredOption("-r, --role <role>", "Role (Editor or Commenter)").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.addTeamMember(options.id, options.email, options.role);
+      if (response.success) {
+        success("Team member added");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  websites.command("team-remove").description("Remove a team member from a website").requiredOption("-i, --id <id>", "Website ID").requiredOption("-m, --member <memberId>", "Member ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient5();
+    try {
+      const response = await client.websites.removeTeamMember(options.id, options.member);
+      if (response.success) {
+        success("Team member removed");
+      }
+      output(response, options.format);
+    } catch (err) {
+      handleError6(err);
+    }
+  });
+  return websites;
+}
+function getClient5() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError6(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function openBrowser(url) {
+  return new Promise((resolve4) => {
+    const currentPlatform = os2.platform();
+    let command;
+    switch (currentPlatform) {
+      case "darwin":
+        command = `open "${url}"`;
+        break;
+      case "win32":
+        command = `start "" "${url}"`;
+        break;
+      default:
+        command = `xdg-open "${url}"`;
+        break;
+    }
+    child_process.exec(command, (error2) => {
+      if (error2) {
+        resolve4(false);
+      } else {
+        resolve4(true);
+      }
+    });
+  });
+}
+
+// src/commands/pages.ts
+var PID_FILE = path3__namespace.join(os2__namespace.tmpdir(), "lindoai-pages-preview.pid");
+var PORT_FILE = path3__namespace.join(os2__namespace.tmpdir(), "lindoai-pages-preview.port");
+function createPagesCommand() {
+  const pages = new commander.Command("pages").description("Page management operations");
+  pages.command("list").description("List all pages for a website").requiredOption("-w, --website <id>", "Website ID").option("-p, --page <page>", "Page number", "1").option("-s, --search <search>", "Search term").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient6();
+    try {
+      const response = await client.pages.list(options.website, {
+        page: parseInt(options.page, 10),
+        search: options.search
+      });
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        const result = response.result;
+        if (result?.list && result.list.length > 0) {
+          console.log("\nPages:");
+          console.log("------");
+          for (const p of result.list) {
+            console.log(`  ID: ${p.page_id}`);
+            console.log(`  Name: ${p.name ?? "N/A"}`);
+            console.log(`  Path: ${p.path ?? "N/A"}`);
+            console.log(`  Status: ${p.status ?? "N/A"}`);
+            console.log(`  Published: ${p.publish_date ? new Date(p.publish_date * 1e3).toISOString() : "No"}`);
+            console.log("");
+          }
+          console.log(`Total: ${result.total ?? result.list.length}`);
+        } else {
+          info("No pages found");
+        }
+      }
+    } catch (err) {
+      handleError7(err);
+    }
+  });
+  pages.command("get").description("Get details of a specific page").requiredOption("-w, --website <id>", "Website ID").requiredOption("-i, --id <id>", "Page ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient6();
+    try {
+      const response = await client.pages.get(options.website, options.id);
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        const result = response.result;
+        if (result) {
+          console.log("\nPage Details:");
+          console.log("-------------");
+          console.log(`  ID: ${result.page_id}`);
+          console.log(`  Name: ${result.name ?? "N/A"}`);
+          console.log(`  Path: ${result.path ?? "N/A"}`);
+          console.log(`  Status: ${result.status ?? "N/A"}`);
+          console.log(`  Published: ${result.publish_date ? new Date(result.publish_date * 1e3).toISOString() : "No"}`);
+          console.log(`  Created: ${result.created_date ?? "N/A"}`);
+        } else {
+          error("Page not found");
+        }
+      }
+    } catch (err) {
+      handleError7(err);
+    }
+  });
+  pages.command("publish").description("Publish a page").requiredOption("-w, --website <id>", "Website ID").requiredOption("-i, --id <id>", "Page ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient6();
+    try {
+      const response = await client.pages.publish(options.website, options.id);
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        if (response.success) {
+          success("Page published successfully");
+          console.log(`  Page ID: ${response.result?.page_id}`);
+          console.log(`  Published at: ${response.result?.publish_date ? new Date(response.result.publish_date * 1e3).toISOString() : "N/A"}`);
+        } else {
+          error("Failed to publish page");
+        }
+      }
+    } catch (err) {
+      handleError7(err);
+    }
+  });
+  pages.command("unpublish").description("Unpublish a page").requiredOption("-w, --website <id>", "Website ID").requiredOption("-i, --id <id>", "Page ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient6();
+    try {
+      const response = await client.pages.unpublish(options.website, options.id);
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        if (response.success) {
+          success("Page unpublished successfully");
+          console.log(`  Page ID: ${response.result?.page_id}`);
+        } else {
+          error("Failed to unpublish page");
+        }
+      }
+    } catch (err) {
+      handleError7(err);
+    }
+  });
+  pages.command("edit").description("Edit a page with live preview").argument("<website_id>", "Website ID").argument("<page_id>", "Page ID").option("--file <path>", "Output file path", "./page.html").option("--background", "Run preview server in background").action(async (websiteId, pageId, options) => {
+    const client = getClient6();
+    try {
+      info("Fetching page details...");
+      const pageResponse = await client.pages.get(websiteId, pageId);
+      if (!pageResponse.result) {
+        error("Page not found");
+        process.exit(1);
+      }
+      const pagePath = pageResponse.result.path;
+      const websiteResponse = await client.websites.getDetails(websiteId);
+      if (!websiteResponse.result) {
+        error("Website not found");
+        process.exit(1);
+      }
+      const baseUrl = websiteResponse.result.custom_domain || websiteResponse.result.verified_domain || websiteResponse.result.preview_url;
+      if (!baseUrl) {
+        error("Could not determine website URL");
+        process.exit(1);
+      }
+      const pageUrl = `https://${baseUrl}${pagePath}`;
+      info(`Fetching HTML from ${pageUrl}...`);
+      const htmlResponse = await fetch(pageUrl);
+      if (!htmlResponse.ok) {
+        error(`Failed to fetch page HTML: ${htmlResponse.status} ${htmlResponse.statusText}`);
+        info("Make sure the page is published before editing");
+        process.exit(1);
+      }
+      const html = await htmlResponse.text();
+      const outputPath = path3__namespace.resolve(options.file);
+      fs3__namespace.writeFileSync(outputPath, html, "utf-8");
+      success(`HTML saved to ${outputPath}`);
+      await terminateExistingPreviewServer();
+      if (options.background) {
+        await startBackgroundPreviewServer(outputPath);
+      } else {
+        await startForegroundPreviewServer(outputPath);
+      }
+    } catch (err) {
+      handleError7(err);
+    }
+  });
+  pages.command("update").description("Update a page").argument("<website_id>", "Website ID").argument("<page_id>", "Page ID").option("--html-file <path>", "Path to local HTML file to upload").option("-f, --format <format>", "Output format (json, table)", "table").action(async (websiteId, pageId, options) => {
+    const client = getClient6();
+    const config = loadConfig();
+    try {
+      if (!options.htmlFile) {
+        error("--html-file option is required");
+        info("Usage: lindoai pages update <website_id> <page_id> --html-file <path>");
+        process.exit(1);
+      }
+      const htmlPath = path3__namespace.resolve(options.htmlFile);
+      if (!fs3__namespace.existsSync(htmlPath)) {
+        error(`File not found: ${htmlPath}`);
+        process.exit(1);
+      }
+      const html = fs3__namespace.readFileSync(htmlPath, "utf-8");
+      info(`Read ${html.length} bytes from ${htmlPath}`);
+      const pageResponse = await client.pages.get(websiteId, pageId);
+      if (!pageResponse.result) {
+        error("Page not found");
+        process.exit(1);
+      }
+      const pagePath = pageResponse.result.path;
+      info("Updating page...");
+      const apiBaseUrl = config.baseUrl || "https://api.lindo.ai";
+      const updateUrl = `${apiBaseUrl}/v1/workspace/website/${websiteId}/pages/${pageId}/update`;
+      const response = await fetch(updateUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+          html,
+          path: pagePath
+        })
+      });
+      const result = await response.json();
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        if (result.success) {
+          success("Page updated successfully");
+          console.log(`  Page ID: ${result.result?.page_id}`);
+          if (result.result?.publish_date) {
+            console.log(`  Published at: ${new Date(result.result.publish_date * 1e3).toISOString()}`);
+          }
+        } else {
+          error("Failed to update page");
+          if (result.errors) {
+            for (const err of result.errors) {
+              console.log(`  ${err}`);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      handleError7(err);
+    }
+  });
+  pages.command("stop-preview").description("Stop the background preview server").action(async () => {
+    try {
+      if (!fs3__namespace.existsSync(PID_FILE)) {
+        info("No preview server is running");
+        return;
+      }
+      const pid = parseInt(fs3__namespace.readFileSync(PID_FILE, "utf-8").trim(), 10);
+      if (isNaN(pid)) {
+        error("Invalid PID file");
+        cleanupPidFiles();
+        return;
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+        success(`Preview server (PID ${pid}) stopped`);
+      } catch (killErr) {
+        if (killErr.code === "ESRCH") {
+          info("Preview server process not found (may have already stopped)");
+        } else {
+          error(`Failed to stop preview server: ${killErr.message}`);
+        }
+      }
+      cleanupPidFiles();
+    } catch (err) {
+      if (err instanceof Error) {
+        error(err.message);
+      } else {
+        error("An unexpected error occurred");
+      }
+      process.exit(1);
+    }
+  });
+  return pages;
+}
+function getClient6() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError7(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function cleanupPidFiles() {
+  try {
+    if (fs3__namespace.existsSync(PID_FILE)) {
+      fs3__namespace.unlinkSync(PID_FILE);
+    }
+  } catch {
+  }
+  try {
+    if (fs3__namespace.existsSync(PORT_FILE)) {
+      fs3__namespace.unlinkSync(PORT_FILE);
+    }
+  } catch {
+  }
+}
+async function terminateExistingPreviewServer() {
+  if (!fs3__namespace.existsSync(PID_FILE)) {
+    return;
+  }
+  try {
+    const pid = parseInt(fs3__namespace.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    if (!isNaN(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+        info(`Terminated existing preview server (PID ${pid})`);
+        await new Promise((resolve4) => setTimeout(resolve4, 500));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  cleanupPidFiles();
+}
+async function startBackgroundPreviewServer(filePath) {
+  const absolutePath = path3__namespace.resolve(filePath);
+  const serverCode = `
+    const http = require('node:http');
+    const fs = require('node:fs');
+    const path = require('node:path');
+    const os = require('node:os');
+
+    const LIVE_RELOAD_SCRIPT = \`<script>
+    (function() {
+      var eventSource = new EventSource('/__live-reload');
+      eventSource.onmessage = function(event) {
+        if (event.data === 'reload') {
+          window.location.reload();
+        }
+      };
+      eventSource.onerror = function() {
+        console.log('[Live Reload] Connection lost, attempting to reconnect...');
+      };
+    })();
+    </script>\`;
+
+    const filePath = ${JSON.stringify(absolutePath)};
+    const pidFile = path.join(os.tmpdir(), 'lindoai-pages-preview.pid');
+    const portFile = path.join(os.tmpdir(), 'lindoai-pages-preview.port');
+    const sseClients = new Set();
+    let debounceTimer = null;
+
+    function injectLiveReload(html) {
+      const bodyCloseTagRegex = /<\\/body>/i;
+      const match = html.match(bodyCloseTagRegex);
+      if (match && match.index !== undefined) {
+        return html.slice(0, match.index) + LIVE_RELOAD_SCRIPT + html.slice(match.index);
+      }
+      return html + LIVE_RELOAD_SCRIPT;
+    }
+
+    function notifyClients() {
+      for (const client of sseClients) {
+        try {
+          client.write('data: reload\\n\\n');
+        } catch {
+          sseClients.delete(client);
+        }
+      }
+    }
+
+    function handleFileChange() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        notifyClients();
+        debounceTimer = null;
+      }, 100);
+    }
+
+    const server = http.createServer((req, res) => {
+      const url = req.url || '/';
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'text/plain' });
+        res.end('Method Not Allowed');
+        return;
+      }
+
+      if (url === '/__live-reload') {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+        });
+        res.write('data: connected\\n\\n');
+        sseClients.add(res);
+        req.on('close', () => sseClients.delete(res));
+        return;
+      }
+
+      if (url === '/' || url === '/index.html') {
+        try {
+          const html = fs.readFileSync(filePath, 'utf-8');
+          const injectedHtml = injectLiveReload(html);
+          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-cache' });
+          res.end(injectedHtml);
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end('<h1>Error loading file</h1><p>' + err.message + '</p>');
+        }
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end('<h1>404 Not Found</h1>');
+    });
+
+    let watcher = null;
+
+    const handleShutdown = () => {
+      if (watcher) watcher.close();
+      if (debounceTimer) clearTimeout(debounceTimer);
+      for (const client of sseClients) {
+        try { client.end(); } catch {}
+      }
+      sseClients.clear();
+      try { if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile); } catch {}
+      try { if (fs.existsSync(portFile)) fs.unlinkSync(portFile); } catch {}
+      server.close(() => process.exit(0));
+      setTimeout(() => process.exit(0), 1000);
+    };
+
+    process.on('SIGTERM', handleShutdown);
+    process.on('SIGINT', handleShutdown);
+
+    server.listen(0, '127.0.0.1', () => {
+      const port = server.address().port;
+      fs.writeFileSync(pidFile, process.pid.toString(), 'utf-8');
+      fs.writeFileSync(portFile, port.toString(), 'utf-8');
+      
+      try {
+        watcher = fs.watch(filePath, (eventType) => {
+          if (eventType === 'change') handleFileChange();
+        });
+      } catch {}
+    });
+  `;
+  const child = child_process.spawn(process.execPath, ["-e", serverCode], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  let port = null;
+  for (let i = 0; i < 50; i++) {
+    await new Promise((resolve4) => setTimeout(resolve4, 100));
+    if (fs3__namespace.existsSync(PORT_FILE)) {
+      try {
+        port = parseInt(fs3__namespace.readFileSync(PORT_FILE, "utf-8").trim(), 10);
+        if (!isNaN(port)) break;
+      } catch {
+      }
+    }
+  }
+  if (!port) {
+    error("Failed to start preview server");
+    process.exit(1);
+  }
+  const previewUrl = `http://127.0.0.1:${port}/`;
+  const browserOpened = await openBrowser(previewUrl);
+  if (!browserOpened) {
+    info(`Could not open browser. Visit: ${previewUrl}`);
+  }
+  success("Preview server started in background");
+  console.log(`  URL: ${previewUrl}`);
+  console.log(`  PID: ${child.pid}`);
+  console.log("");
+  info("To update the page: lindoai pages update <website_id> <page_id> --html-file <path>");
+  info("To stop the server: lindoai pages stop-preview");
+}
+async function startForegroundPreviewServer(filePath) {
+  const { startLivePreviewServer: startLivePreviewServer2 } = await Promise.resolve().then(() => (init_live_preview_server(), live_preview_server_exports));
+  info("Starting preview server...");
+  const port = await startLivePreviewServer2(filePath);
+  const previewUrl = `http://127.0.0.1:${port}/`;
+  fs3__namespace.writeFileSync(PID_FILE, process.pid.toString(), "utf-8");
+  fs3__namespace.writeFileSync(PORT_FILE, port.toString(), "utf-8");
+  const browserOpened = await openBrowser(previewUrl);
+  if (!browserOpened) {
+    info(`Could not open browser. Visit: ${previewUrl}`);
+  }
+  success("Preview server started");
+  console.log(`  URL: ${previewUrl}`);
+  console.log("");
+  info("Press Ctrl+C to stop the server");
+  info("Edit the HTML file and save to see changes in the browser");
+}
+var PID_FILE2 = path3__namespace.join(os2__namespace.tmpdir(), "lindoai-blogs-preview.pid");
+var PORT_FILE2 = path3__namespace.join(os2__namespace.tmpdir(), "lindoai-blogs-preview.port");
+function createBlogsCommand() {
+  const blogs = new commander.Command("blogs").description("Blog management operations");
+  blogs.command("list").description("List all blogs for a website").requiredOption("-w, --website <id>", "Website ID").option("-p, --page <page>", "Page number", "1").option("-s, --search <search>", "Search term").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient7();
+    try {
+      const response = await client.blogs.list(options.website, {
+        page: parseInt(options.page, 10),
+        search: options.search
+      });
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        const result = response.result;
+        if (result?.list && result.list.length > 0) {
+          console.log("\nBlogs:");
+          console.log("------");
+          for (const b of result.list) {
+            console.log(`  ID: ${b.blog_id}`);
+            console.log(`  Name: ${b.name ?? "N/A"}`);
+            console.log(`  Path: ${b.path ?? "N/A"}`);
+            console.log(`  Status: ${b.status ?? "N/A"}`);
+            console.log(`  Published: ${b.publish_date ? new Date(b.publish_date * 1e3).toISOString() : "No"}`);
+            console.log("");
+          }
+          console.log(`Total: ${result.total ?? result.list.length}`);
+        } else {
+          info("No blogs found");
+        }
+      }
+    } catch (err) {
+      handleError8(err);
+    }
+  });
+  blogs.command("get").description("Get details of a specific blog").requiredOption("-w, --website <id>", "Website ID").requiredOption("-i, --id <id>", "Blog ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient7();
+    try {
+      const response = await client.blogs.get(options.website, options.id);
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        const result = response.result;
+        if (result) {
+          console.log("\nBlog Details:");
+          console.log("-------------");
+          console.log(`  ID: ${result.blog_id}`);
+          console.log(`  Name: ${result.name ?? "N/A"}`);
+          console.log(`  Path: ${result.path ?? "N/A"}`);
+          console.log(`  Status: ${result.status ?? "N/A"}`);
+          console.log(`  Published: ${result.publish_date ? new Date(result.publish_date * 1e3).toISOString() : "No"}`);
+          console.log(`  Created: ${result.created_date ?? "N/A"}`);
+        } else {
+          error("Blog not found");
+        }
+      }
+    } catch (err) {
+      handleError8(err);
+    }
+  });
+  blogs.command("publish").description("Publish a blog").requiredOption("-w, --website <id>", "Website ID").requiredOption("-i, --id <id>", "Blog ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient7();
+    try {
+      const response = await client.blogs.publish(options.website, options.id);
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        if (response.success) {
+          success("Blog published successfully");
+          console.log(`  Blog ID: ${response.result?.blog_id}`);
+          console.log(`  Published at: ${response.result?.publish_date ? new Date(response.result.publish_date * 1e3).toISOString() : "N/A"}`);
+        } else {
+          error("Failed to publish blog");
+        }
+      }
+    } catch (err) {
+      handleError8(err);
+    }
+  });
+  blogs.command("unpublish").description("Unpublish a blog").requiredOption("-w, --website <id>", "Website ID").requiredOption("-i, --id <id>", "Blog ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    const client = getClient7();
+    try {
+      const response = await client.blogs.unpublish(options.website, options.id);
+      if (options.format === "json") {
+        output(response, "json");
+      } else {
+        if (response.success) {
+          success("Blog unpublished successfully");
+          console.log(`  Blog ID: ${response.result?.blog_id}`);
+        } else {
+          error("Failed to unpublish blog");
+        }
+      }
+    } catch (err) {
+      handleError8(err);
+    }
+  });
+  blogs.command("edit").description("Edit a blog with live preview").argument("<website_id>", "Website ID").argument("<blog_id>", "Blog ID").option("--file <path>", "Output file path", "./blog.html").option("--background", "Run preview server in background").action(async (websiteId, blogId, options) => {
+    const client = getClient7();
+    try {
+      info("Fetching blog details...");
+      const blogResponse = await client.blogs.get(websiteId, blogId);
+      if (!blogResponse.result) {
+        error("Blog not found");
+        process.exit(1);
+      }
+      const blogPath = blogResponse.result.path;
+      const websiteResponse = await client.websites.getDetails(websiteId);
+      if (!websiteResponse.result) {
+        error("Website not found");
+        process.exit(1);
+      }
+      const baseUrl = websiteResponse.result.custom_domain || websiteResponse.result.verified_domain || websiteResponse.result.preview_url;
+      if (!baseUrl) {
+        error("Could not determine website URL");
+        process.exit(1);
+      }
+      const blogUrl = `https://${baseUrl}${blogPath}`;
+      info(`Fetching HTML from ${blogUrl}...`);
+      const htmlResponse = await fetch(blogUrl);
+      if (!htmlResponse.ok) {
+        error(`Failed to fetch blog HTML: ${htmlResponse.status} ${htmlResponse.statusText}`);
+        info("Make sure the blog is published before editing");
+        process.exit(1);
+      }
+      const html = await htmlResponse.text();
+      const outputPath = path3__namespace.resolve(options.file);
+      fs3__namespace.writeFileSync(outputPath, html, "utf-8");
+      success(`HTML saved to ${outputPath}`);
+      await terminateExistingPreviewServer2();
+      if (options.background) {
+        await startBackgroundPreviewServer2(outputPath);
+      } else {
+        await startForegroundPreviewServer2(outputPath);
+      }
+    } catch (err) {
+      handleError8(err);
+    }
+  });
+  blogs.command("update").description("Update a blog").argument("<website_id>", "Website ID").argument("<blog_id>", "Blog ID").option("--html-file <path>", "Path to local HTML file to upload").option("-f, --format <format>", "Output format (json, table)", "table").action(async (websiteId, blogId, options) => {
+    const client = getClient7();
+    const config = loadConfig();
+    try {
+      if (!options.htmlFile) {
+        error("--html-file option is required");
+        info("Usage: lindoai blogs update <website_id> <blog_id> --html-file <path>");
+        process.exit(1);
+      }
+      const htmlPath = path3__namespace.resolve(options.htmlFile);
+      if (!fs3__namespace.existsSync(htmlPath)) {
+        error(`File not found: ${htmlPath}`);
+        process.exit(1);
+      }
+      const html = fs3__namespace.readFileSync(htmlPath, "utf-8");
+      info(`Read ${html.length} bytes from ${htmlPath}`);
+      const blogResponse = await client.blogs.get(websiteId, blogId);
+      if (!blogResponse.result) {
+        error("Blog not found");
+        process.exit(1);
+      }
+      const blogPath = blogResponse.result.path;
+      info("Updating blog...");
+      const apiBaseUrl = config.baseUrl || "https://api.lindo.ai";
+      const updateUrl = `${apiBaseUrl}/v1/workspace/website/${websiteId}/blogs/${blogId}/update`;
+      const response = await fetch(updateUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+          html,
+          path: blogPath
+        })
+      });
+      const result = await response.json();
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        if (result.success) {
+          success("Blog updated successfully");
+          console.log(`  Blog ID: ${result.result?.blog_id}`);
+          if (result.result?.publish_date) {
+            console.log(`  Published at: ${new Date(result.result.publish_date * 1e3).toISOString()}`);
+          }
+        } else {
+          error("Failed to update blog");
+          if (result.errors) {
+            for (const err of result.errors) {
+              console.log(`  ${err}`);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      handleError8(err);
+    }
+  });
+  blogs.command("stop-preview").description("Stop the background preview server").action(async () => {
+    try {
+      if (!fs3__namespace.existsSync(PID_FILE2)) {
+        info("No preview server is running");
+        return;
+      }
+      const pid = parseInt(fs3__namespace.readFileSync(PID_FILE2, "utf-8").trim(), 10);
+      if (isNaN(pid)) {
+        error("Invalid PID file");
+        cleanupPidFiles2();
+        return;
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+        success(`Preview server (PID ${pid}) stopped`);
+      } catch (killErr) {
+        if (killErr.code === "ESRCH") {
+          info("Preview server process not found (may have already stopped)");
+        } else {
+          error(`Failed to stop preview server: ${killErr.message}`);
+        }
+      }
+      cleanupPidFiles2();
+    } catch (err) {
+      if (err instanceof Error) {
+        error(err.message);
+      } else {
+        error("An unexpected error occurred");
+      }
+      process.exit(1);
+    }
+  });
+  return blogs;
+}
+function getClient7() {
+  if (!hasApiKey()) {
+    error("API key not configured");
+    info("Run: lindo config set apiKey <your-api-key>");
+    info("Or set the LINDO_API_KEY environment variable");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  return new lindoai.LindoClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError8(err) {
+  if (err instanceof lindoai.AuthenticationError) {
+    error("Authentication failed");
+    info("Your API key may be invalid or expired");
+    info("Run: lindo config set apiKey <your-api-key>");
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function cleanupPidFiles2() {
+  try {
+    if (fs3__namespace.existsSync(PID_FILE2)) {
+      fs3__namespace.unlinkSync(PID_FILE2);
+    }
+  } catch {
+  }
+  try {
+    if (fs3__namespace.existsSync(PORT_FILE2)) {
+      fs3__namespace.unlinkSync(PORT_FILE2);
+    }
+  } catch {
+  }
+}
+async function terminateExistingPreviewServer2() {
+  if (!fs3__namespace.existsSync(PID_FILE2)) {
+    return;
+  }
+  try {
+    const pid = parseInt(fs3__namespace.readFileSync(PID_FILE2, "utf-8").trim(), 10);
+    if (!isNaN(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+        info(`Terminated existing preview server (PID ${pid})`);
+        await new Promise((resolve4) => setTimeout(resolve4, 500));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  cleanupPidFiles2();
+}
+async function startBackgroundPreviewServer2(filePath) {
+  const absolutePath = path3__namespace.resolve(filePath);
+  const serverCode = `
+    const http = require('node:http');
+    const fs = require('node:fs');
+    const path = require('node:path');
+    const os = require('node:os');
+
+    const LIVE_RELOAD_SCRIPT = \`<script>
+    (function() {
+      var eventSource = new EventSource('/__live-reload');
+      eventSource.onmessage = function(event) {
+        if (event.data === 'reload') {
+          window.location.reload();
+        }
+      };
+      eventSource.onerror = function() {
+        console.log('[Live Reload] Connection lost, attempting to reconnect...');
+      };
+    })();
+    </script>\`;
+
+    const filePath = ${JSON.stringify(absolutePath)};
+    const pidFile = path.join(os.tmpdir(), 'lindoai-blogs-preview.pid');
+    const portFile = path.join(os.tmpdir(), 'lindoai-blogs-preview.port');
+    const sseClients = new Set();
+    let debounceTimer = null;
+
+    function injectLiveReload(html) {
+      const bodyCloseTagRegex = /<\\/body>/i;
+      const match = html.match(bodyCloseTagRegex);
+      if (match && match.index !== undefined) {
+        return html.slice(0, match.index) + LIVE_RELOAD_SCRIPT + html.slice(match.index);
+      }
+      return html + LIVE_RELOAD_SCRIPT;
+    }
+
+    function notifyClients() {
+      for (const client of sseClients) {
+        try {
+          client.write('data: reload\\n\\n');
+        } catch {
+          sseClients.delete(client);
+        }
+      }
+    }
+
+    function handleFileChange() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        notifyClients();
+        debounceTimer = null;
+      }, 100);
+    }
+
+    const server = http.createServer((req, res) => {
+      const url = req.url || '/';
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'text/plain' });
+        res.end('Method Not Allowed');
+        return;
+      }
+
+      if (url === '/__live-reload') {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+        });
+        res.write('data: connected\\n\\n');
+        sseClients.add(res);
+        req.on('close', () => sseClients.delete(res));
+        return;
+      }
+
+      if (url === '/' || url === '/index.html') {
+        try {
+          const html = fs.readFileSync(filePath, 'utf-8');
+          const injectedHtml = injectLiveReload(html);
+          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-cache' });
+          res.end(injectedHtml);
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end('<h1>Error loading file</h1><p>' + err.message + '</p>');
+        }
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end('<h1>404 Not Found</h1>');
+    });
+
+    let watcher = null;
+
+    const handleShutdown = () => {
+      if (watcher) watcher.close();
+      if (debounceTimer) clearTimeout(debounceTimer);
+      for (const client of sseClients) {
+        try { client.end(); } catch {}
+      }
+      sseClients.clear();
+      try { if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile); } catch {}
+      try { if (fs.existsSync(portFile)) fs.unlinkSync(portFile); } catch {}
+      server.close(() => process.exit(0));
+      setTimeout(() => process.exit(0), 1000);
+    };
+
+    process.on('SIGTERM', handleShutdown);
+    process.on('SIGINT', handleShutdown);
+
+    server.listen(0, '127.0.0.1', () => {
+      const port = server.address().port;
+      fs.writeFileSync(pidFile, process.pid.toString(), 'utf-8');
+      fs.writeFileSync(portFile, port.toString(), 'utf-8');
+      
+      try {
+        watcher = fs.watch(filePath, (eventType) => {
+          if (eventType === 'change') handleFileChange();
+        });
+      } catch {}
+    });
+  `;
+  const child = child_process.spawn(process.execPath, ["-e", serverCode], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  let port = null;
+  for (let i = 0; i < 50; i++) {
+    await new Promise((resolve4) => setTimeout(resolve4, 100));
+    if (fs3__namespace.existsSync(PORT_FILE2)) {
+      try {
+        port = parseInt(fs3__namespace.readFileSync(PORT_FILE2, "utf-8").trim(), 10);
+        if (!isNaN(port)) break;
+      } catch {
+      }
+    }
+  }
+  if (!port) {
+    error("Failed to start preview server");
+    process.exit(1);
+  }
+  const previewUrl = `http://127.0.0.1:${port}/`;
+  const browserOpened = await openBrowser(previewUrl);
+  if (!browserOpened) {
+    info(`Could not open browser. Visit: ${previewUrl}`);
+  }
+  success("Preview server started in background");
+  console.log(`  URL: ${previewUrl}`);
+  console.log(`  PID: ${child.pid}`);
+  console.log("");
+  info("To update the blog: lindoai blogs update <website_id> <blog_id> --html-file <path>");
+  info("To stop the server: lindoai blogs stop-preview");
+}
+async function startForegroundPreviewServer2(filePath) {
+  const { startLivePreviewServer: startLivePreviewServer2 } = await Promise.resolve().then(() => (init_live_preview_server(), live_preview_server_exports));
+  info("Starting preview server...");
+  const port = await startLivePreviewServer2(filePath);
+  const previewUrl = `http://127.0.0.1:${port}/`;
+  fs3__namespace.writeFileSync(PID_FILE2, process.pid.toString(), "utf-8");
+  fs3__namespace.writeFileSync(PORT_FILE2, port.toString(), "utf-8");
+  const browserOpened = await openBrowser(previewUrl);
+  if (!browserOpened) {
+    info(`Could not open browser. Visit: ${previewUrl}`);
+  }
+  success("Preview server started");
+  console.log(`  URL: ${previewUrl}`);
+  console.log("");
+  info("Press Ctrl+C to stop the server");
+  info("Edit the HTML file and save to see changes in the browser");
+}
+function generateState() {
+  return crypto__namespace.randomBytes(32).toString("hex");
+}
+function verifyState(received, expected) {
+  return received === expected;
+}
+
+// src/server/callback.ts
+function parseCallbackParams(url$1) {
+  try {
+    const fullUrl = url$1.startsWith("http") ? url$1 : `http://localhost${url$1}`;
+    const parsed = new url.URL(fullUrl);
+    const params = parsed.searchParams;
+    return {
+      key: params.get("key") ?? void 0,
+      state: params.get("state") ?? void 0,
+      error: params.get("error") ?? void 0,
+      message: params.get("message") ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function generateSuccessHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Authorization Successful - Lindo CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: #fff;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      backdrop-filter: blur(10px);
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u2713</div>
+    <h1>Authorization Successful</h1>
+    <p>You can close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>`;
+}
+function generateErrorHtml(errorMessage) {
+  const escapedMessage = errorMessage.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Authorization Failed - Lindo CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #e74c3c 0%, #c0392b 100%);
+      color: #fff;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      backdrop-filter: blur(10px);
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+    }
+    .error-message {
+      margin-top: 1rem;
+      padding: 1rem;
+      background: rgba(0, 0, 0, 0.2);
+      border-radius: 8px;
+      font-family: monospace;
+      font-size: 0.9rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u2717</div>
+    <h1>Authorization Failed</h1>
+    <p>Something went wrong during authorization.</p>
+    <div class="error-message">${escapedMessage}</div>
+  </div>
+</body>
+</html>`;
+}
+function generate404Html() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Not Found - Lindo CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: #f5f5f5;
+      color: #333;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    h1 {
+      font-size: 3rem;
+      margin: 0 0 1rem 0;
+      color: #999;
+    }
+    p {
+      margin: 0;
+      color: #666;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>404</h1>
+    <p>This endpoint is not available.</p>
+  </div>
+</body>
+</html>`;
+}
+function createCallbackServer() {
+  let server = null;
+  let pendingCallback = null;
+  function handleRequest(req, res) {
+    const url = req.url || "/";
+    const method = req.method || "GET";
+    const isCallbackPath = url === "/callback" || url.startsWith("/callback?");
+    if (method !== "GET" || !isCallbackPath) {
+      res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generate404Html());
+      return;
+    }
+    const params = parseCallbackParams(url);
+    if (!pendingCallback) {
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateErrorHtml("No pending authorization request"));
+      return;
+    }
+    const { expectedState, resolve: resolve4, timeoutId } = pendingCallback;
+    clearTimeout(timeoutId);
+    pendingCallback = null;
+    if (params.error) {
+      const errorMessage = params.message || params.error;
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateErrorHtml(errorMessage));
+      resolve4({
+        success: false,
+        error: errorMessage
+      });
+      return;
+    }
+    if (!params.state || !verifyState(params.state, expectedState)) {
+      const errorMessage = "State token mismatch - possible CSRF attack";
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateErrorHtml(errorMessage));
+      resolve4({
+        success: false,
+        error: errorMessage
+      });
+      return;
+    }
+    if (!params.key) {
+      const errorMessage = "No API key received";
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateErrorHtml(errorMessage));
+      resolve4({
+        success: false,
+        error: errorMessage
+      });
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(generateSuccessHtml());
+    resolve4({
+      success: true,
+      apiKey: params.key
+    });
+  }
+  return {
+    async start() {
+      return new Promise((resolve4, reject) => {
+        server = http__namespace.createServer(handleRequest);
+        server.on("error", (err) => {
+          reject(new Error(`Failed to start callback server: ${err.message}`));
+        });
+        server.listen(0, "127.0.0.1", () => {
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            reject(new Error("Failed to get server address"));
+            return;
+          }
+          const port = address.port;
+          const url = `http://127.0.0.1:${port}/callback`;
+          resolve4({ port, url });
+        });
+      });
+    },
+    waitForCallback(state, timeoutMs) {
+      return new Promise((resolve4) => {
+        const timeoutId = setTimeout(() => {
+          if (pendingCallback) {
+            pendingCallback = null;
+            resolve4({
+              success: false,
+              error: "Login timed out waiting for authorization"
+            });
+          }
+        }, timeoutMs);
+        pendingCallback = {
+          expectedState: state,
+          resolve: resolve4,
+          timeoutId
+        };
+      });
+    },
+    async stop() {
+      return new Promise((resolve4) => {
+        if (pendingCallback) {
+          clearTimeout(pendingCallback.timeoutId);
+          pendingCallback = null;
+        }
+        if (server) {
+          server.close(() => {
+            server = null;
+            resolve4();
+          });
+        } else {
+          resolve4();
+        }
+      });
+    }
+  };
+}
+
+// src/commands/login.ts
+var WEBAPP_BASE_URL = "https://app.lindo.ai";
+var DEFAULT_TIMEOUT_SECONDS = 120;
+function buildAuthorizationUrl(state, callbackPort) {
+  const callbackUrl = `http://127.0.0.1:${callbackPort}/callback`;
+  const params = new URLSearchParams({
+    state,
+    callback_url: callbackUrl
+  });
+  return `${WEBAPP_BASE_URL}/cli/authorize?${params.toString()}`;
+}
+function createLoginCommand() {
+  const login = new commander.Command("login").description("Authenticate via browser to configure your API key").option(
+    "-t, --timeout <seconds>",
+    "Timeout in seconds for the login flow",
+    String(DEFAULT_TIMEOUT_SECONDS)
+  ).option(
+    "--no-browser",
+    "Display the authorization URL without opening the browser"
+  ).action(async (options) => {
+    const timeoutSeconds = parseInt(options.timeout, 10);
+    const timeoutMs = timeoutSeconds * 1e3;
+    const shouldOpenBrowser = options.browser;
+    const server = createCallbackServer();
+    let serverStarted = false;
+    try {
+      info("Starting authentication flow...");
+      const { port } = await server.start();
+      serverStarted = true;
+      const state = generateState();
+      const authUrl = buildAuthorizationUrl(state, port);
+      if (shouldOpenBrowser) {
+        info("Opening browser for authorization...");
+        const browserOpened = await openBrowser(authUrl);
+        if (!browserOpened) {
+          info("Could not open browser automatically.");
+          console.log("\nPlease open this URL in your browser:");
+          console.log(`
+  ${authUrl}
+`);
+        }
+      } else {
+        console.log("\nPlease open this URL in your browser:");
+        console.log(`
+  ${authUrl}
+`);
+      }
+      info(`Waiting for authorization (timeout: ${timeoutSeconds}s)...`);
+      const result = await server.waitForCallback(state, timeoutMs);
+      if (result.success && result.apiKey) {
+        saveApiKey(result.apiKey);
+        success("Successfully authenticated!");
+        info(`API key saved to: ${getConfigPath()}`);
+      } else {
+        error(result.error || "Authentication failed");
+        process.exit(1);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "An unexpected error occurred");
+      process.exit(1);
+    } finally {
+      if (serverStarted) {
+        await server.stop();
+      }
+    }
+  });
+  return login;
+}
+var OPENCODE_SKILLS_DIR = path3__namespace.join(os2__namespace.homedir(), ".config", "opencode", "skills", "lindoai");
+var SKILL_FILE_PATH = path3__namespace.join(OPENCODE_SKILLS_DIR, "SKILL.md");
+var SKILL_FILE_CONTENT = `---
+name: lindoai
+description: Lindo AI CLI - Command-line interface for the Lindo API
+---
+
+# Lindo AI CLI
+
+The \`lindoai\` CLI provides commands for interacting with the Lindo API, including website management, page editing, blog management, and more.
+
+## Authentication
+
+### Login via Browser
+\`\`\`bash
+lindoai login
+\`\`\`
+Opens your browser to authenticate and automatically configures your API key.
+
+Options:
+- \`--timeout <seconds>\` - Timeout for the login flow (default: 120)
+- \`--no-browser\` - Display the authorization URL without opening the browser
+
+### Manual Configuration
+\`\`\`bash
+lindoai config set apiKey <your-api-key>
+\`\`\`
+
+## Website Management
+
+### List Websites
+\`\`\`bash
+lindoai websites list
+\`\`\`
+
+### Get Website Details
+\`\`\`bash
+lindoai websites get <website_id>
+\`\`\`
+
+## Page Management
+
+### List Pages
+\`\`\`bash
+lindoai pages list <website_id>
+\`\`\`
+
+### Get Page Details
+\`\`\`bash
+lindoai pages get <website_id> <page_id>
+\`\`\`
+
+### Live Preview Editing Workflow
+
+1. **Start editing with live preview:**
+\`\`\`bash
+lindoai pages edit <website_id> <page_id> --background
+\`\`\`
+This fetches the page HTML, saves it locally, starts a preview server, and opens your browser.
+
+Options:
+- \`--file <path>\` - Save HTML to a specific path (default: ./page.html)
+- \`--background\` - Run the preview server in the background
+
+2. **Edit the HTML file** in your editor. The browser will automatically refresh when you save.
+
+3. **Update the page** when you're done:
+\`\`\`bash
+lindoai pages update <website_id> <page_id> --html-file ./page.html
+\`\`\`
+
+4. **Stop the preview server:**
+\`\`\`bash
+lindoai pages stop-preview
+\`\`\`
+
+## Blog Management
+
+### List Blogs
+\`\`\`bash
+lindoai blogs list <website_id>
+\`\`\`
+
+### Get Blog Details
+\`\`\`bash
+lindoai blogs get <website_id> <blog_id>
+\`\`\`
+
+### Live Preview Editing Workflow
+
+1. **Start editing with live preview:**
+\`\`\`bash
+lindoai blogs edit <website_id> <blog_id> --background
+\`\`\`
+
+Options:
+- \`--file <path>\` - Save HTML to a specific path (default: ./blog.html)
+- \`--background\` - Run the preview server in the background
+
+2. **Edit the HTML file** in your editor. The browser will automatically refresh when you save.
+
+3. **Update the blog** when you're done:
+\`\`\`bash
+lindoai blogs update <website_id> <blog_id> --html-file ./blog.html
+\`\`\`
+
+4. **Stop the preview server:**
+\`\`\`bash
+lindoai blogs stop-preview
+\`\`\`
+
+## AI Agents
+
+### Run an Agent
+\`\`\`bash
+lindoai agents run <agent_id> --input '{"prompt": "Hello!"}'
+\`\`\`
+
+Options:
+- \`--input <json>\` - Input data as JSON string
+- \`--stream\` - Stream the response
+- \`--format <format>\` - Output format (json, table)
+
+## Workflows
+
+### Start a Workflow
+\`\`\`bash
+lindoai workflows start <workflow_id> --params '{"key": "value"}'
+\`\`\`
+
+### Get Workflow Status
+\`\`\`bash
+lindoai workflows status <instance_id>
+\`\`\`
+
+## Workspace
+
+### Get Workspace Credits
+\`\`\`bash
+lindoai workspace credits
+\`\`\`
+
+## Analytics
+
+### Get Workspace Analytics
+\`\`\`bash
+lindoai analytics workspace --from 2024-01-01 --to 2024-01-31
+\`\`\`
+
+## Configuration
+
+### View Configuration
+\`\`\`bash
+lindoai config get apiKey
+lindoai config get baseUrl
+\`\`\`
+
+### Set Configuration
+\`\`\`bash
+lindoai config set apiKey <value>
+lindoai config set baseUrl <value>
+\`\`\`
+
+## Tips for AI Agents
+
+1. **Always authenticate first** using \`lindoai login\` or by setting the API key.
+2. **Use the live preview workflow** for editing pages and blogs - it provides instant visual feedback.
+3. **Run preview servers in background mode** (\`--background\`) to keep the terminal available.
+4. **Remember to stop preview servers** when done editing with \`stop-preview\`.
+5. **Use JSON format** (\`--format json\`) when you need to parse command output programmatically.
+`;
+function isOpenCodeInstalled() {
+  try {
+    const command = process.platform === "win32" ? "where opencode" : "which opencode";
+    child_process.execSync(command, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installOpenCode() {
+  try {
+    info("Installing OpenCode...");
+    child_process.execSync("npm install -g opencode-ai@latest", { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureSkillInstalled() {
+  if (!fs3__namespace.existsSync(OPENCODE_SKILLS_DIR)) {
+    fs3__namespace.mkdirSync(OPENCODE_SKILLS_DIR, { recursive: true });
+  }
+  fs3__namespace.writeFileSync(SKILL_FILE_PATH, SKILL_FILE_CONTENT, "utf-8");
+}
+function createAgentCommand() {
+  const agent = new commander.Command("agent").description("Launch an AI agent that understands all CLI commands").option("--install", "Install OpenCode if not already installed").option("--model <model>", "Specify the model to use with OpenCode").action(async (options) => {
+    if (!isOpenCodeInstalled()) {
+      if (options.install) {
+        const installed = installOpenCode();
+        if (!installed) {
+          error("Failed to install OpenCode");
+          info("Please install manually: npm install -g opencode-ai@latest");
+          process.exit(1);
+        }
+        success("OpenCode installed successfully");
+      } else {
+        error("OpenCode is not installed");
+        info("");
+        info("To install OpenCode, run one of the following:");
+        info("  lindoai agent --install");
+        info("  npm install -g opencode-ai@latest");
+        process.exit(1);
+      }
+    }
+    try {
+      ensureSkillInstalled();
+      info(`Skill file installed to: ${SKILL_FILE_PATH}`);
+    } catch (err) {
+      error(`Failed to install skill file: ${err instanceof Error ? err.message : "Unknown error"}`);
+      process.exit(1);
+    }
+    const args = [];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    info("Launching OpenCode...");
+    const opencode = child_process.spawn("opencode", args, {
+      stdio: "inherit",
+      shell: true
+    });
+    opencode.on("error", (err) => {
+      error(`Failed to launch OpenCode: ${err.message}`);
+      process.exit(1);
+    });
+    opencode.on("close", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+  return agent;
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+function createProgram() {
+  const program = new commander.Command();
+  program.name("lindo").description("Command-line interface for the Lindo API").version(VERSION, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command");
+  program.addCommand(createConfigCommand());
+  program.addCommand(createAgentsCommand());
+  program.addCommand(createWorkflowsCommand());
+  program.addCommand(createWorkspaceCommand());
+  program.addCommand(createAnalyticsCommand());
+  program.addCommand(createClientsCommand());
+  program.addCommand(createWebsitesCommand());
+  program.addCommand(createPagesCommand());
+  program.addCommand(createBlogsCommand());
+  program.addCommand(createLoginCommand());
+  program.addCommand(createAgentCommand());
+  program.exitOverride((err) => {
+    if (err.code === "commander.help") {
+      process.exit(0);
+    }
+    if (err.code === "commander.version") {
+      process.exit(0);
+    }
+    if (err.code === "commander.missingArgument") {
+      error(err.message);
+      process.exit(1);
+    }
+    if (err.code === "commander.unknownCommand") {
+      error(err.message);
+      info('Run "lindo --help" for available commands');
+      process.exit(1);
+    }
+    throw err;
+  });
+  return program;
+}
+function handleAuthenticationError(_err) {
+  error("Authentication failed");
+  info("");
+  info("Your API key may be invalid or expired.");
+  info("");
+  info("To configure your API key:");
+  info("  1. Run: lindo config set apiKey <your-api-key>");
+  info("  2. Or set the LINDO_API_KEY environment variable");
+  info("");
+  info("To get an API key:");
+  info("  Visit https://app.lindo.ai/settings/api-keys");
+}
+async function main() {
+  const program = createProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof lindoai.AuthenticationError) {
+      handleAuthenticationError();
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+main().catch((err) => {
+  if (err instanceof Error) {
+    error(`Unexpected error: ${err.message}`);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+});
+
+exports.createProgram = createProgram;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map