@spike-forms/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2287 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as fs3 from 'fs';
+import * as path3 from 'path';
+import * as os2 from 'os';
+import { platform } from 'os';
+import chalk from 'chalk';
+import { SpikeClient, SpikeError } from '@spike-forms/sdk';
+import { spawn, exec, execSync } from 'child_process';
+import * as http from 'http';
+import * as crypto from 'crypto';
+
+var DEFAULT_CONFIG = {
+  apiKey: "",
+  baseUrl: "https://api.spike.ac"
+};
+var ENV_VARS = {
+  API_KEY: "SPIKE_API_KEY",
+  TOKEN: "SPIKE_TOKEN",
+  API_URL: "SPIKE_API_URL"
+};
+function getConfigPath() {
+  const homeDir = os2.homedir();
+  return path3.join(homeDir, ".spike", "config.json");
+}
+function getConfigDir() {
+  const homeDir = os2.homedir();
+  return path3.join(homeDir, ".spike");
+}
+function loadConfigFromFile() {
+  const configPath = getConfigPath();
+  try {
+    if (!fs3.existsSync(configPath)) {
+      return {};
+    }
+    const fileContent = fs3.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(fileContent);
+    const config = {};
+    if (typeof parsed.apiKey === "string") {
+      config.apiKey = parsed.apiKey;
+    }
+    if (typeof parsed.baseUrl === "string") {
+      config.baseUrl = parsed.baseUrl;
+    }
+    return config;
+  } catch {
+    return {};
+  }
+}
+function loadConfigFromEnv() {
+  const config = {};
+  const apiKey = process.env[ENV_VARS.API_KEY] || process.env[ENV_VARS.TOKEN];
+  if (apiKey) {
+    config.apiKey = apiKey;
+  }
+  const apiUrl = process.env[ENV_VARS.API_URL];
+  if (apiUrl) {
+    config.baseUrl = apiUrl;
+  }
+  return config;
+}
+function loadConfig() {
+  const fileConfig = loadConfigFromFile();
+  const envConfig = loadConfigFromEnv();
+  return {
+    ...DEFAULT_CONFIG,
+    ...fileConfig,
+    ...envConfig
+  };
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  if (!fs3.existsSync(configDir)) {
+    fs3.mkdirSync(configDir, { recursive: true });
+  }
+  const existingConfig = loadConfigFromFile();
+  const mergedConfig = {
+    ...existingConfig,
+    ...config
+  };
+  const cleanConfig = {};
+  if (mergedConfig.apiKey) {
+    cleanConfig.apiKey = mergedConfig.apiKey;
+  }
+  if (mergedConfig.baseUrl) {
+    cleanConfig.baseUrl = mergedConfig.baseUrl;
+  }
+  fs3.writeFileSync(configPath, JSON.stringify(cleanConfig, null, 2) + "\n", "utf-8");
+}
+function output(data, format = "table") {
+  if (format === "json") {
+    outputJson(data);
+  } else {
+    outputTable(data);
+  }
+}
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function outputTable(data) {
+  if (data === null || data === void 0) {
+    console.log("No data");
+    return;
+  }
+  if (Array.isArray(data)) {
+    outputArrayAsTable(data);
+  } else if (typeof data === "object") {
+    outputObjectAsTable(data);
+  } else {
+    console.log(String(data));
+  }
+}
+function outputArrayAsTable(data) {
+  if (data.length === 0) {
+    console.log("No items found");
+    return;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  for (const item of data) {
+    if (item && typeof item === "object") {
+      Object.keys(item).forEach((key) => keys.add(key));
+    }
+  }
+  const columns = Array.from(keys);
+  if (columns.length === 0) {
+    data.forEach((item) => console.log(String(item)));
+    return;
+  }
+  const columnWidths = /* @__PURE__ */ new Map();
+  for (const col of columns) {
+    let maxWidth = col.length;
+    for (const item of data) {
+      if (item && typeof item === "object") {
+        const value = formatCellValue(item[col]);
+        maxWidth = Math.max(maxWidth, value.length);
+      }
+    }
+    columnWidths.set(col, Math.min(maxWidth, 50));
+  }
+  const headerRow = columns.map((col) => padRight(col.toUpperCase(), columnWidths.get(col))).join("  ");
+  console.log(chalk.bold(headerRow));
+  const separator = columns.map((col) => "-".repeat(columnWidths.get(col))).join("  ");
+  console.log(separator);
+  for (const item of data) {
+    if (item && typeof item === "object") {
+      const row = columns.map((col) => {
+        const value = formatCellValue(item[col]);
+        return padRight(truncate(value, columnWidths.get(col)), columnWidths.get(col));
+      }).join("  ");
+      console.log(row);
+    }
+  }
+  console.log("");
+  console.log(chalk.dim(`${data.length} item${data.length === 1 ? "" : "s"}`));
+}
+function outputObjectAsTable(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0) {
+    console.log("No data");
+    return;
+  }
+  const maxKeyLength = Math.max(...entries.map(([key]) => key.length));
+  for (const [key, value] of entries) {
+    const formattedKey = chalk.bold(padRight(key, maxKeyLength));
+    const formattedValue = formatCellValue(value);
+    console.log(`${formattedKey}  ${formattedValue}`);
+  }
+}
+function formatCellValue(value) {
+  if (value === null || value === void 0) {
+    return "-";
+  }
+  if (typeof value === "boolean") {
+    return value ? chalk.green("yes") : chalk.dim("no");
+  }
+  if (typeof value === "object") {
+    if (Array.isArray(value)) {
+      return `[${value.length} items]`;
+    }
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function padRight(str, length) {
+  const visibleLength = stripAnsi(str).length;
+  if (visibleLength >= length) {
+    return str;
+  }
+  return str + " ".repeat(length - visibleLength);
+}
+function truncate(str, maxLength) {
+  const visibleLength = stripAnsi(str).length;
+  if (visibleLength <= maxLength) {
+    return str;
+  }
+  return str.slice(0, maxLength - 3) + "...";
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+function success(message) {
+  console.log(chalk.green(`\u2713 ${message}`));
+}
+function error(message) {
+  console.error(chalk.red(`\u2717 ${message}`));
+}
+function warn(message) {
+  console.log(chalk.yellow(`\u26A0 ${message}`));
+}
+function info(message) {
+  console.log(chalk.cyan(`\u2139 ${message}`));
+}
+function maskApiKey(apiKey) {
+  if (!apiKey) {
+    return "";
+  }
+  if (apiKey.length <= 11) {
+    const visibleStart = Math.min(4, apiKey.length - 1);
+    return apiKey.slice(0, visibleStart) + "...";
+  }
+  const prefix = apiKey.slice(0, 7);
+  const suffix = apiKey.slice(-4);
+  return `${prefix}...${suffix}`;
+}
+
+// src/commands/config.ts
+var VALID_KEYS = ["api-key", "base-url"];
+var KEY_MAP = {
+  "api-key": "apiKey",
+  "base-url": "baseUrl"
+};
+function isValidKey(key) {
+  return VALID_KEYS.includes(key);
+}
+function createConfigCommand() {
+  const configCommand = new Command("config").description("Manage CLI configuration");
+  configCommand.command("set").description("Set a configuration value").argument("<key>", `Configuration key (${VALID_KEYS.join(", ")})`).argument("<value>", "Configuration value").action((key, value) => {
+    handleSet(key, value);
+  });
+  configCommand.command("get").description("Get configuration value(s)").argument("[key]", `Configuration key (${VALID_KEYS.join(", ")})`).option("-f, --format <format>", "Output format (json, table)", "table").action((key, options) => {
+    handleGet(key, options.format);
+  });
+  return configCommand;
+}
+function handleSet(key, value) {
+  if (!isValidKey(key)) {
+    error(`Invalid configuration key: ${key}`);
+    info(`Valid keys are: ${VALID_KEYS.join(", ")}`);
+    process.exit(1);
+  }
+  const internalKey = KEY_MAP[key];
+  try {
+    saveConfig({ [internalKey]: value });
+    success(`Configuration '${key}' has been set`);
+  } catch (err) {
+    error(`Failed to save configuration: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+function handleGet(key, format) {
+  const config = loadConfig();
+  if (key !== void 0) {
+    if (!isValidKey(key)) {
+      error(`Invalid configuration key: ${key}`);
+      info(`Valid keys are: ${VALID_KEYS.join(", ")}`);
+      process.exit(1);
+    }
+    const internalKey = KEY_MAP[key];
+    let value = config[internalKey];
+    if (key === "api-key" && value) {
+      value = maskApiKey(value);
+    }
+    if (!value) {
+      info(`Configuration '${key}' is not set`);
+      return;
+    }
+    if (format === "json") {
+      output({ [key]: value }, format);
+    } else {
+      console.log(value);
+    }
+  } else {
+    const displayConfig = {};
+    if (config.apiKey) {
+      displayConfig["api-key"] = maskApiKey(config.apiKey);
+    } else {
+      displayConfig["api-key"] = "(not set)";
+    }
+    displayConfig["base-url"] = config.baseUrl || "(not set)";
+    info(`Configuration file: ${getConfigPath()}`);
+    console.log("");
+    output(displayConfig, format);
+  }
+}
+var SSE_SCRIPT = `<script>
+(function() {
+  var es = new EventSource('/__live-reload');
+  es.onmessage = function(event) {
+    if (event.data === 'reload') {
+      location.reload();
+    }
+  };
+  es.onerror = function() {
+    console.log('[Live Preview] Connection lost, attempting to reconnect...');
+  };
+})();
+</script>`;
+function injectLiveReload(html) {
+  const bodyCloseRegex = /<\/body>/i;
+  const match = html.match(bodyCloseRegex);
+  if (match && match.index !== void 0) {
+    return html.slice(0, match.index) + SSE_SCRIPT + html.slice(match.index);
+  }
+  return html + SSE_SCRIPT;
+}
+function startLivePreviewServer(filePath) {
+  return new Promise((resolve3, reject) => {
+    const absolutePath = path3.resolve(filePath);
+    const sseClients = [];
+    let debounceTimer = null;
+    function broadcastToClients(message) {
+      const data = `data: ${message}
+
+`;
+      for (let i = sseClients.length - 1; i >= 0; i--) {
+        const client = sseClients[i];
+        if (!client) continue;
+        try {
+          if (!client.writableEnded) {
+            client.write(data);
+          } else {
+            sseClients.splice(i, 1);
+          }
+        } catch {
+          sseClients.splice(i, 1);
+        }
+      }
+    }
+    function onFileChange() {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(() => {
+        broadcastToClients("reload");
+        debounceTimer = null;
+      }, 100);
+    }
+    function handleRequest(req, res) {
+      const url = req.url || "/";
+      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.push(res);
+        req.on("close", () => {
+          const index = sseClients.indexOf(res);
+          if (index !== -1) {
+            sseClients.splice(index, 1);
+          }
+        });
+        return;
+      }
+      if (url === "/" && req.method === "GET") {
+        try {
+          const html = fs3.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/plain" });
+          res.end(`Error reading file: ${errorMessage}`);
+        }
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    }
+    const server = http.createServer(handleRequest);
+    server.on("error", (err) => {
+      reject(err);
+    });
+    let watcher = null;
+    try {
+      watcher = fs3.watch(absolutePath, (eventType) => {
+        if (eventType === "change") {
+          onFileChange();
+        }
+      });
+      watcher.on("error", (err) => {
+        console.error("[Live Preview] File watcher error:", err.message);
+      });
+    } catch (err) {
+      console.warn("[Live Preview] Could not start file watcher:", err instanceof Error ? err.message : "Unknown error");
+    }
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        resolve3(port);
+      } else {
+        reject(new Error("Failed to get server address"));
+      }
+    });
+  });
+}
+async function openBrowser(url) {
+  const currentPlatform = platform();
+  let command;
+  switch (currentPlatform) {
+    case "darwin":
+      command = `open "${url}"`;
+      break;
+    case "linux":
+      command = `xdg-open "${url}"`;
+      break;
+    case "win32":
+      command = `start "" "${url}"`;
+      break;
+    default:
+      return false;
+  }
+  return new Promise((resolve3) => {
+    exec(command, (error2) => {
+      if (error2) {
+        resolve3(false);
+      } else {
+        resolve3(true);
+      }
+    });
+  });
+}
+
+// src/commands/forms.ts
+function createClient() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    error("API key not configured. Run `spike config set api-key <your-key>` to set it.");
+    process.exit(1);
+  }
+  return new SpikeClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError(err) {
+  if (err instanceof SpikeError) {
+    error(err.message);
+    if (err.code) {
+      info(`Error code: ${err.code}`);
+    }
+  } else if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+var PREVIEW_PID_FILE = path3.join(os2.tmpdir(), "spike-preview.pid");
+var PREVIEW_PORT_FILE = path3.join(os2.tmpdir(), "spike-preview.port");
+var PREVIEW_FORM_ID_FILE = path3.join(os2.tmpdir(), "spike-preview.formid");
+function generateFormHtml(form) {
+  const config = loadConfig();
+  const baseUrl = config.baseUrl || "https://api.spike.ac";
+  const actionUrl = `${baseUrl}/f/${form.slug}`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${form.name}</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 600px;
+      margin: 40px auto;
+      padding: 20px;
+      background: #f5f5f5;
+    }
+    form {
+      background: white;
+      padding: 30px;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    h1 {
+      margin-top: 0;
+      color: #333;
+    }
+    label {
+      display: block;
+      margin-bottom: 5px;
+      font-weight: 500;
+      color: #555;
+    }
+    input, textarea {
+      width: 100%;
+      padding: 10px;
+      margin-bottom: 20px;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      box-sizing: border-box;
+      font-size: 16px;
+    }
+    textarea {
+      min-height: 100px;
+      resize: vertical;
+    }
+    button {
+      background: #0070f3;
+      color: white;
+      padding: 12px 24px;
+      border: none;
+      border-radius: 4px;
+      font-size: 16px;
+      cursor: pointer;
+      transition: background 0.2s;
+    }
+    button:hover {
+      background: #0051a8;
+    }
+  </style>
+</head>
+<body>
+  <form action="${actionUrl}" method="POST">
+    <h1>${form.name}</h1>
+    
+    <label for="name">Name</label>
+    <input type="text" id="name" name="name" required>
+    
+    <label for="email">Email</label>
+    <input type="email" id="email" name="email" required>
+    
+    <label for="message">Message</label>
+    <textarea id="message" name="message" required></textarea>
+    
+    <button type="submit">Submit</button>
+  </form>
+</body>
+</html>`;
+}
+function killExistingPreviewServer() {
+  try {
+    if (!fs3.existsSync(PREVIEW_PID_FILE)) {
+      return false;
+    }
+    const pidStr = fs3.readFileSync(PREVIEW_PID_FILE, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+      cleanupPreviewTempFiles();
+      return false;
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+      info(`Stopped existing preview server (PID: ${pid})`);
+    } catch {
+    }
+    cleanupPreviewTempFiles();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanupPreviewTempFiles() {
+  try {
+    if (fs3.existsSync(PREVIEW_PID_FILE)) {
+      fs3.unlinkSync(PREVIEW_PID_FILE);
+    }
+  } catch {
+  }
+  try {
+    if (fs3.existsSync(PREVIEW_PORT_FILE)) {
+      fs3.unlinkSync(PREVIEW_PORT_FILE);
+    }
+  } catch {
+  }
+  try {
+    if (fs3.existsSync(PREVIEW_FORM_ID_FILE)) {
+      fs3.unlinkSync(PREVIEW_FORM_ID_FILE);
+    }
+  } catch {
+  }
+}
+function createFormsCommand() {
+  const formsCommand = new Command("forms").description("Manage forms");
+  formsCommand.command("list").description("List all forms").option("-l, --limit <number>", "Maximum number of forms to return", parseInt).option("-p, --project-id <id>", "Filter forms by project ID").option("-i, --include-inactive", "Include inactive forms in the results").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleList(options);
+  });
+  formsCommand.command("get").description("Get a specific form by ID").argument("<id>", "Form ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleGet2(id, options.format);
+  });
+  formsCommand.command("create").description("Create a new form").requiredOption("-n, --name <name>", "Name for the form").option("-p, --project-id <id>", "Project ID to add the form to").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleCreate(options);
+  });
+  formsCommand.command("update").description("Update a form").argument("<id>", "Form ID").option("-n, --name <name>", "New name for the form").option("-p, --project-id <id>", "Project ID to move the form to").option("--is-active <boolean>", "Whether the form should be active", (value) => {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    throw new Error('--is-active must be "true" or "false"');
+  }).option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleUpdate(id, options);
+  });
+  formsCommand.command("delete").description("Delete a form").argument("<id>", "Form ID").action(async (id) => {
+    await handleDelete(id);
+  });
+  formsCommand.command("edit").description("Edit a form with live preview").argument("<id>", "Form ID").option("--file <path>", "Output file path for the HTML", "./form.html").option("--background", "Run preview server as a detached background process").action(async (id, options) => {
+    await handleEdit(id, options);
+  });
+  formsCommand.command("stop-preview").description("Stop the background preview server").action(async () => {
+    await handleStopPreview();
+  });
+  formsCommand.command("save").description("Save local HTML changes to server").argument("[id]", "Form ID (optional if preview server is running)").option("--file <path>", "Path to the HTML file", "./form.html").action(async (id, options) => {
+    await handleSave(id, options);
+  });
+  formsCommand.command("create-page").description("Create a new form and generate an HTML form page (beta)").requiredOption("-n, --name <name>", "Name for the form").option("-p, --project-id <id>", "Project ID to add the form to").option("--file <path>", "Output file path for the HTML", "./form.html").option("--preview", "Start preview server after creation").action(async (options) => {
+    await handleCreatePage(options);
+  });
+  return formsCommand;
+}
+async function handleList(options) {
+  try {
+    const client = createClient();
+    const forms = await client.forms.list({
+      limit: options.limit,
+      project_id: options.projectId,
+      include_inactive: options.includeInactive
+    });
+    if (forms.length === 0) {
+      info("No forms found");
+      return;
+    }
+    output(forms, options.format);
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleGet2(id, format) {
+  try {
+    const client = createClient();
+    const form = await client.forms.get(id);
+    output(form, format);
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleCreate(options) {
+  try {
+    const client = createClient();
+    const form = await client.forms.create({
+      name: options.name,
+      project_id: options.projectId
+    });
+    success(`Form "${form.name}" created successfully`);
+    console.log("");
+    output(form, options.format);
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleUpdate(id, options) {
+  try {
+    if (options.name === void 0 && options.projectId === void 0 && options.isActive === void 0) {
+      error("No update options provided. Use --name, --project-id, or --is-active to update the form.");
+      process.exit(1);
+    }
+    const client = createClient();
+    const updateData = {};
+    if (options.name !== void 0) {
+      updateData.name = options.name;
+    }
+    if (options.projectId !== void 0) {
+      updateData.project_id = options.projectId;
+    }
+    if (options.isActive !== void 0) {
+      updateData.is_active = options.isActive;
+    }
+    const form = await client.forms.update(id, updateData);
+    success(`Form "${form.name}" updated successfully`);
+    console.log("");
+    output(form, options.format);
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleDelete(id) {
+  try {
+    const client = createClient();
+    await client.forms.delete(id);
+    success(`Form "${id}" deleted successfully`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleStopPreview() {
+  try {
+    if (!fs3.existsSync(PREVIEW_PID_FILE)) {
+      info("No preview server is currently running");
+      return;
+    }
+    const pidStr = fs3.readFileSync(PREVIEW_PID_FILE, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+      cleanupPreviewTempFiles();
+      info("No preview server is currently running");
+      return;
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+      success(`Preview server stopped (PID: ${pid})`);
+    } catch (killError) {
+      if (killError instanceof Error && "code" in killError && killError.code === "ESRCH") {
+        info("Preview server was not running");
+      } else {
+        throw killError;
+      }
+    }
+    cleanupPreviewTempFiles();
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleCreatePage(options) {
+  try {
+    console.log("\u26A0\uFE0F  Note: The create-page command is currently in beta.\n");
+    const client = createClient();
+    info(`Creating form "${options.name}"...`);
+    const form = await client.forms.create({
+      name: options.name,
+      project_id: options.projectId
+    });
+    success(`Form "${form.name}" created successfully`);
+    const html = generateFormHtml(form);
+    info("Saving form HTML to server...");
+    const saveResult = await client.forms.saveHtml(form.id, html);
+    if (saveResult.success) {
+      success("Form HTML saved to server");
+    }
+    const filePath = path3.resolve(options.file);
+    fs3.writeFileSync(filePath, html, "utf-8");
+    success(`Form HTML saved locally to ${filePath}`);
+    fs3.writeFileSync(PREVIEW_FORM_ID_FILE, form.id, "utf-8");
+    if (options.preview) {
+      killExistingPreviewServer();
+      info("\nMake changes to the HTML file and save to see them in the browser.");
+      info("When done, run `spike forms save` to upload changes to the server.\n");
+      await startForegroundPreviewServer(filePath);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleEdit(id, options) {
+  try {
+    const client = createClient();
+    info(`Fetching form ${id}...`);
+    const form = await client.forms.get(id);
+    info("Fetching form HTML from server...");
+    const { html } = await client.forms.getHtml(id);
+    const filePath = path3.resolve(options.file);
+    fs3.writeFileSync(filePath, html, "utf-8");
+    success(`Form HTML saved to ${filePath}`);
+    fs3.writeFileSync(PREVIEW_FORM_ID_FILE, id, "utf-8");
+    killExistingPreviewServer();
+    info(`
+Editing form: ${form.name}`);
+    info("Make changes to the HTML file and save to see them in the browser.");
+    info("When done, run `spike forms save` to upload changes to the server.\n");
+    if (options.background) {
+      await startBackgroundPreviewServer(filePath);
+    } else {
+      await startForegroundPreviewServer(filePath);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function handleSave(id, options) {
+  try {
+    let formId = id;
+    if (!formId) {
+      if (fs3.existsSync(PREVIEW_FORM_ID_FILE)) {
+        formId = fs3.readFileSync(PREVIEW_FORM_ID_FILE, "utf-8").trim();
+      }
+      if (!formId) {
+        error("No form ID provided and no active preview session found.");
+        info("Usage: spike forms save <form-id> --file ./form.html");
+        process.exit(1);
+      }
+    }
+    const filePath = path3.resolve(options.file);
+    if (!fs3.existsSync(filePath)) {
+      error(`File not found: ${filePath}`);
+      process.exit(1);
+    }
+    const html = fs3.readFileSync(filePath, "utf-8");
+    if (!html.trim()) {
+      error("HTML file is empty");
+      process.exit(1);
+    }
+    const client = createClient();
+    info(`Saving form HTML to server...`);
+    const result = await client.forms.saveHtml(formId, html);
+    if (result.success) {
+      success("Form HTML saved successfully!");
+      if (result.html_url) {
+        info(`Stored at: ${result.html_url}`);
+      }
+    } else {
+      error("Failed to save form HTML");
+      process.exit(1);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function startForegroundPreviewServer(filePath) {
+  const port = await startLivePreviewServer(filePath);
+  const previewUrl = `http://127.0.0.1:${port}`;
+  success(`Preview server running at ${previewUrl}`);
+  info("Press Ctrl+C to stop the server");
+  const browserOpened = await openBrowser(previewUrl);
+  if (!browserOpened) {
+    info(`Open ${previewUrl} in your browser to preview the form`);
+  }
+  await new Promise(() => {
+    process.on("SIGINT", () => {
+      info("\nStopping preview server...");
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      info("\nStopping preview server...");
+      process.exit(0);
+    });
+  });
+}
+async function startBackgroundPreviewServer(filePath) {
+  const serverCode = `
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const filePath = ${JSON.stringify(filePath)};
+const pidFile = path.join(os.tmpdir(), 'spike-preview.pid');
+const portFile = path.join(os.tmpdir(), 'spike-preview.port');
+
+const SSE_SCRIPT = \`<script>
+(function() {
+  var es = new EventSource('/__live-reload');
+  es.onmessage = function(event) {
+    if (event.data === 'reload') {
+      location.reload();
+    }
+  };
+  es.onerror = function() {
+    console.log('[Live Preview] Connection lost, attempting to reconnect...');
+  };
+})();
+</script>\`;
+
+function injectLiveReload(html) {
+  const bodyCloseRegex = /<\\/body>/i;
+  const match = html.match(bodyCloseRegex);
+  if (match && match.index !== undefined) {
+    return html.slice(0, match.index) + SSE_SCRIPT + html.slice(match.index);
+  }
+  return html + SSE_SCRIPT;
+}
+
+const sseClients = [];
+let debounceTimer = null;
+
+function broadcastToClients(message) {
+  const data = 'data: ' + message + '\\n\\n';
+  for (let i = sseClients.length - 1; i >= 0; i--) {
+    const client = sseClients[i];
+    if (!client) continue;
+    try {
+      if (!client.writableEnded) {
+        client.write(data);
+      } else {
+        sseClients.splice(i, 1);
+      }
+    } catch {
+      sseClients.splice(i, 1);
+    }
+  }
+}
+
+function onFileChange() {
+  if (debounceTimer) clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(() => {
+    broadcastToClients('reload');
+    debounceTimer = null;
+  }, 100);
+}
+
+function cleanup() {
+  try { fs.unlinkSync(pidFile); } catch {}
+  try { fs.unlinkSync(portFile); } catch {}
+  process.exit(0);
+}
+
+process.on('SIGTERM', cleanup);
+process.on('SIGINT', cleanup);
+
+const server = http.createServer((req, res) => {
+  const url = req.url || '/';
+  
+  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.push(res);
+    req.on('close', () => {
+      const index = sseClients.indexOf(res);
+      if (index !== -1) sseClients.splice(index, 1);
+    });
+    return;
+  }
+  
+  if (url === '/' && req.method === 'GET') {
+    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/plain' });
+      res.end('Error reading file: ' + err.message);
+    }
+    return;
+  }
+  
+  res.writeHead(404, { 'Content-Type': 'text/plain' });
+  res.end('Not Found');
+});
+
+try {
+  fs.watch(filePath, (eventType) => {
+    if (eventType === 'change') onFileChange();
+  });
+} catch {}
+
+server.listen(0, '127.0.0.1', () => {
+  const address = server.address();
+  const port = address.port;
+  
+  // Write PID and port to temp files
+  fs.writeFileSync(pidFile, process.pid.toString(), 'utf-8');
+  fs.writeFileSync(portFile, port.toString(), 'utf-8');
+  
+  // Output port for parent process to read
+  console.log('PORT:' + port);
+});
+`;
+  return new Promise((resolve3, reject) => {
+    const child = spawn("node", ["-e", serverCode], {
+      detached: true,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let portReceived = false;
+    let outputBuffer = "";
+    child.stdout?.on("data", (data) => {
+      outputBuffer += data.toString();
+      const match = outputBuffer.match(/PORT:(\d+)/);
+      if (match && !portReceived) {
+        portReceived = true;
+        const port = parseInt(match[1], 10);
+        const previewUrl = `http://127.0.0.1:${port}`;
+        success(`Background preview server started at ${previewUrl}`);
+        info(`PID: ${child.pid}`);
+        info("Run `spike forms stop-preview` to stop the server");
+        openBrowser(previewUrl).then((browserOpened) => {
+          if (!browserOpened) {
+            info(`Open ${previewUrl} in your browser to preview the form`);
+          }
+          child.unref();
+          resolve3();
+        });
+      }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to start background server: ${err.message}`));
+    });
+    setTimeout(() => {
+      if (!portReceived) {
+        child.kill();
+        reject(new Error("Timeout waiting for background server to start"));
+      }
+    }, 1e4);
+  });
+}
+function createClient2() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    error("API key not configured. Run `spike config set api-key <your-key>` to set it.");
+    process.exit(1);
+  }
+  return new SpikeClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError2(err) {
+  if (err instanceof SpikeError) {
+    error(err.message);
+    if (err.code) {
+      info(`Error code: ${err.code}`);
+    }
+  } else if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createSubmissionsCommand() {
+  const submissionsCommand = new Command("submissions").description("Manage form submissions");
+  submissionsCommand.command("list").description("List submissions for a form").argument("<form-id>", "Form ID").option("-l, --limit <number>", "Maximum number of submissions to return", parseInt).option("-s, --status <status>", "Filter by status (read, unread, spam, starred)").option("--from <date>", "Filter submissions from this date (ISO 8601 format)").option("--to <date>", "Filter submissions to this date (ISO 8601 format)").option("-o, --order <order>", "Sort order (asc, desc)", "desc").option("-f, --format <format>", "Output format (json, table)", "table").action(async (formId, options) => {
+    await handleList2(formId, options);
+  });
+  submissionsCommand.command("export").description("Export all submissions for a form").argument("<form-id>", "Form ID").option("-f, --format <format>", "Output format (json, csv)", "json").action(async (formId, options) => {
+    await handleExport(formId, options.format);
+  });
+  submissionsCommand.command("stats").description("Display submission statistics for a form").argument("<form-id>", "Form ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (formId, options) => {
+    await handleStats(formId, options.format);
+  });
+  return submissionsCommand;
+}
+async function handleList2(formId, options) {
+  try {
+    const client = createClient2();
+    const params = {};
+    if (options.limit !== void 0) {
+      params.limit = options.limit;
+    }
+    if (options.from) {
+      params.since = options.from;
+    }
+    if (options.order === "asc" || options.order === "desc") {
+      params.order = options.order;
+    }
+    if (options.status) {
+      switch (options.status.toLowerCase()) {
+        case "read":
+          params.is_read = true;
+          break;
+        case "unread":
+          params.is_read = false;
+          break;
+        case "spam":
+          params.is_spam = true;
+          break;
+        case "starred":
+          break;
+        default:
+          error(`Invalid status: ${options.status}. Valid values are: read, unread, spam, starred`);
+          process.exit(1);
+      }
+    }
+    const submissions = await client.submissions.list(formId, params);
+    let filteredSubmissions = submissions;
+    if (options.status?.toLowerCase() === "starred") {
+      filteredSubmissions = submissions.filter((s) => s.is_starred);
+    }
+    if (options.to) {
+      const toDate = new Date(options.to);
+      filteredSubmissions = filteredSubmissions.filter((s) => new Date(s.created_at) <= toDate);
+    }
+    if (filteredSubmissions.length === 0) {
+      info("No submissions found");
+      return;
+    }
+    const displayData = filteredSubmissions.map((s) => ({
+      id: s.id,
+      created_at: s.created_at,
+      is_read: s.is_read,
+      is_spam: s.is_spam,
+      is_starred: s.is_starred,
+      data: JSON.stringify(s.data).slice(0, 50) + (JSON.stringify(s.data).length > 50 ? "..." : "")
+    }));
+    output(displayData, options.format);
+  } catch (err) {
+    handleError2(err);
+  }
+}
+async function handleExport(formId, format) {
+  try {
+    const client = createClient2();
+    const submissions = await client.submissions.export(formId);
+    if (submissions.length === 0) {
+      info("No submissions to export");
+      return;
+    }
+    if (format === "csv") {
+      outputCsv(submissions);
+    } else {
+      console.log(JSON.stringify(submissions, null, 2));
+    }
+    success(`Exported ${submissions.length} submission${submissions.length === 1 ? "" : "s"}`);
+  } catch (err) {
+    handleError2(err);
+  }
+}
+function outputCsv(submissions) {
+  if (submissions.length === 0) {
+    return;
+  }
+  const dataKeys = /* @__PURE__ */ new Set();
+  for (const submission of submissions) {
+    Object.keys(submission.data).forEach((key) => dataKeys.add(key));
+  }
+  const baseHeaders = ["id", "form_id", "is_spam", "is_read", "is_starred", "ip_address", "user_agent", "created_at"];
+  const allHeaders = [...baseHeaders, ...Array.from(dataKeys)];
+  console.log(allHeaders.map(escapeCsvValue).join(","));
+  for (const submission of submissions) {
+    const row = [
+      submission.id,
+      submission.form_id,
+      String(submission.is_spam),
+      String(submission.is_read),
+      String(submission.is_starred),
+      submission.ip_address || "",
+      submission.user_agent || "",
+      submission.created_at,
+      ...Array.from(dataKeys).map((key) => {
+        const value = submission.data[key];
+        if (value === void 0 || value === null) {
+          return "";
+        }
+        if (typeof value === "object") {
+          return JSON.stringify(value);
+        }
+        return String(value);
+      })
+    ];
+    console.log(row.map(escapeCsvValue).join(","));
+  }
+}
+function escapeCsvValue(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+async function handleStats(formId, format) {
+  try {
+    const client = createClient2();
+    const stats = await client.submissions.getStats(formId);
+    output(stats, format);
+  } catch (err) {
+    handleError2(err);
+  }
+}
+function createClient3() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    error("API key not configured. Run `spike config set api-key <your-key>` to set it.");
+    process.exit(1);
+  }
+  return new SpikeClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError3(err) {
+  if (err instanceof SpikeError) {
+    error(err.message);
+    if (err.code) {
+      info(`Error code: ${err.code}`);
+    }
+  } else if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createProjectsCommand() {
+  const projectsCommand = new Command("projects").description("Manage projects");
+  projectsCommand.command("list").description("List all projects").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleList3(options.format);
+  });
+  projectsCommand.command("get").description("Get a specific project by ID").argument("<id>", "Project ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleGet3(id, options.format);
+  });
+  projectsCommand.command("create").description("Create a new project").requiredOption("-n, --name <name>", "Name for the project").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleCreate2(options);
+  });
+  projectsCommand.command("update").description("Update a project").argument("<id>", "Project ID").option("-n, --name <name>", "New name for the project").option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleUpdate2(id, options);
+  });
+  projectsCommand.command("delete").description("Delete a project").argument("<id>", "Project ID").action(async (id) => {
+    await handleDelete2(id);
+  });
+  return projectsCommand;
+}
+async function handleList3(format) {
+  try {
+    const client = createClient3();
+    const projects = await client.projects.list();
+    if (projects.length === 0) {
+      info("No projects found");
+      return;
+    }
+    output(projects, format);
+  } catch (err) {
+    handleError3(err);
+  }
+}
+async function handleGet3(id, format) {
+  try {
+    const client = createClient3();
+    const project = await client.projects.get(id);
+    output(project, format);
+  } catch (err) {
+    handleError3(err);
+  }
+}
+async function handleCreate2(options) {
+  try {
+    const client = createClient3();
+    const project = await client.projects.create({
+      name: options.name
+    });
+    success(`Project "${project.name}" created successfully`);
+    console.log("");
+    output(project, options.format);
+  } catch (err) {
+    handleError3(err);
+  }
+}
+async function handleUpdate2(id, options) {
+  try {
+    if (options.name === void 0) {
+      error("No update options provided. Use --name to update the project.");
+      process.exit(1);
+    }
+    const client = createClient3();
+    const updateData = {};
+    if (options.name !== void 0) {
+      updateData.name = options.name;
+    }
+    const project = await client.projects.update(id, updateData);
+    success(`Project "${project.name}" updated successfully`);
+    console.log("");
+    output(project, options.format);
+  } catch (err) {
+    handleError3(err);
+  }
+}
+async function handleDelete2(id) {
+  try {
+    const client = createClient3();
+    await client.projects.delete(id);
+    success(`Project "${id}" deleted successfully`);
+  } catch (err) {
+    handleError3(err);
+  }
+}
+function createClient4() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    error("API key not configured. Run `spike config set api-key <your-key>` to set it.");
+    process.exit(1);
+  }
+  return new SpikeClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError4(err) {
+  if (err instanceof SpikeError) {
+    error(err.message);
+    if (err.code) {
+      info(`Error code: ${err.code}`);
+    }
+  } else if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createTeamsCommand() {
+  const teamsCommand = new Command("teams").description("Manage teams");
+  teamsCommand.command("list").description("List all teams").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleList4(options.format);
+  });
+  teamsCommand.command("get").description("Get a specific team by ID").argument("<id>", "Team ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleGet4(id, options.format);
+  });
+  teamsCommand.command("create").description("Create a new team").requiredOption("-n, --name <name>", "Name for the team").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleCreate3(options);
+  });
+  teamsCommand.command("members").description("List members of a team").argument("<id>", "Team ID").option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleMembers(id, options.format);
+  });
+  teamsCommand.command("invite").description("Invite a user to a team").argument("<id>", "Team ID").requiredOption("-e, --email <email>", "Email address of the user to invite").requiredOption("-r, --role <role>", "Role for the invited user (admin, member)").option("-f, --format <format>", "Output format (json, table)", "table").action(async (id, options) => {
+    await handleInvite(id, options);
+  });
+  return teamsCommand;
+}
+async function handleList4(format) {
+  try {
+    const client = createClient4();
+    const teams = await client.teams.list();
+    if (teams.length === 0) {
+      info("No teams found");
+      return;
+    }
+    output(teams, format);
+  } catch (err) {
+    handleError4(err);
+  }
+}
+async function handleGet4(id, format) {
+  try {
+    const client = createClient4();
+    const team = await client.teams.get(id);
+    output(team, format);
+  } catch (err) {
+    handleError4(err);
+  }
+}
+async function handleCreate3(options) {
+  try {
+    const client = createClient4();
+    const team = await client.teams.create({
+      name: options.name
+    });
+    success(`Team "${team.name}" created successfully`);
+    console.log("");
+    output(team, options.format);
+  } catch (err) {
+    handleError4(err);
+  }
+}
+async function handleMembers(id, format) {
+  try {
+    const client = createClient4();
+    const members = await client.teams.listMembers(id);
+    if (members.length === 0) {
+      info("No members found");
+      return;
+    }
+    const displayData = members.map((member) => ({
+      id: member.id,
+      user_id: member.user_id,
+      name: member.user.name,
+      email: member.user.email,
+      role: member.role,
+      created_at: member.created_at
+    }));
+    output(displayData, format);
+  } catch (err) {
+    handleError4(err);
+  }
+}
+async function handleInvite(id, options) {
+  try {
+    const role = options.role.toLowerCase();
+    if (role !== "admin" && role !== "member") {
+      error("Invalid role. Valid values are: admin, member");
+      process.exit(1);
+    }
+    const client = createClient4();
+    const invitation = await client.teams.invite(id, {
+      email: options.email,
+      role
+    });
+    success(`Invitation sent to "${options.email}" as ${role}`);
+    console.log("");
+    output(invitation, options.format);
+  } catch (err) {
+    handleError4(err);
+  }
+}
+function createClient5() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    error("API key not configured. Run `spike config set api-key <your-key>` to set it.");
+    process.exit(1);
+  }
+  return new SpikeClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function handleError5(err) {
+  if (err instanceof SpikeError) {
+    error(err.message);
+    if (err.code) {
+      info(`Error code: ${err.code}`);
+    }
+  } else if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exit(1);
+}
+function createUserCommand() {
+  const userCommand = new Command("user").description("Manage user profile and API keys");
+  userCommand.option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleGetProfile(options.format);
+  });
+  userCommand.command("update").description("Update user profile").option("-n, --name <name>", "New name for the user").option("-e, --email <email>", "New email address for the user").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleUpdateProfile(options);
+  });
+  const apiKeysCommand = new Command("api-keys").description("Manage user API keys");
+  apiKeysCommand.option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleListApiKeys(options.format);
+  });
+  apiKeysCommand.command("create").description("Create a new API key").requiredOption("-n, --name <name>", "Name for the API key").option("-f, --format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await handleCreateApiKey(options);
+  });
+  apiKeysCommand.command("delete").description("Delete an API key").argument("<id>", "API key ID").action(async (id) => {
+    await handleDeleteApiKey(id);
+  });
+  userCommand.addCommand(apiKeysCommand);
+  return userCommand;
+}
+async function handleGetProfile(format) {
+  try {
+    const client = createClient5();
+    const user = await client.user.get();
+    output(user, format);
+  } catch (err) {
+    handleError5(err);
+  }
+}
+async function handleUpdateProfile(options) {
+  try {
+    if (options.name === void 0 && options.email === void 0) {
+      error("No update options provided. Use --name or --email to update the profile.");
+      process.exit(1);
+    }
+    const client = createClient5();
+    const updateData = {};
+    if (options.name !== void 0) {
+      updateData.name = options.name;
+    }
+    if (options.email !== void 0) {
+      updateData.email = options.email;
+    }
+    const user = await client.user.update(updateData);
+    success("Profile updated successfully");
+    console.log("");
+    output(user, options.format);
+  } catch (err) {
+    handleError5(err);
+  }
+}
+async function handleListApiKeys(format) {
+  try {
+    const client = createClient5();
+    const apiKeys = await client.user.listApiKeys();
+    if (apiKeys.length === 0) {
+      info("No API keys found");
+      return;
+    }
+    const displayData = apiKeys.map((key) => ({
+      id: key.id,
+      name: key.name,
+      key: key.key ? maskApiKey(key.key) : "-",
+      last_used_at: key.last_used_at || "Never",
+      created_at: key.created_at
+    }));
+    output(displayData, format);
+  } catch (err) {
+    handleError5(err);
+  }
+}
+async function handleCreateApiKey(options) {
+  try {
+    const client = createClient5();
+    const apiKey = await client.user.createApiKey({
+      name: options.name
+    });
+    success(`API key "${apiKey.name}" created successfully`);
+    console.log("");
+    if (options.format === "json") {
+      output(apiKey, "json");
+    } else {
+      console.log("Your new API key (save this - it will not be shown again):");
+      console.log("");
+      console.log(`  ${apiKey.key}`);
+      console.log("");
+      output({
+        id: apiKey.id,
+        name: apiKey.name,
+        created_at: apiKey.created_at
+      }, "table");
+    }
+  } catch (err) {
+    handleError5(err);
+  }
+}
+async function handleDeleteApiKey(id) {
+  try {
+    const client = createClient5();
+    await client.user.deleteApiKey(id);
+    success(`API key "${id}" deleted successfully`);
+  } catch (err) {
+    handleError5(err);
+  }
+}
+function generateState() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function verifyState(received, expected) {
+  return received === expected;
+}
+function parseCallbackParams(url) {
+  try {
+    let searchParams;
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      const parsed = new URL(url);
+      searchParams = parsed.searchParams;
+    } else {
+      const queryIndex = url.indexOf("?");
+      if (queryIndex === -1) {
+        return {};
+      }
+      searchParams = new URLSearchParams(url.slice(queryIndex + 1));
+    }
+    return {
+      key: searchParams.get("key") ?? void 0,
+      state: searchParams.get("state") ?? void 0,
+      error: searchParams.get("error") ?? void 0,
+      message: searchParams.get("message") ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+var SUCCESS_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Login Successful - Spike 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: white;
+    }
+    .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 0.5rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u2713</div>
+    <h1>Login Successful!</h1>
+    <p>You can close this window and return to the terminal.</p>
+  </div>
+</body>
+</html>`;
+function getErrorHtml(errorMessage) {
+  const escapedMessage = errorMessage.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Login Failed - Spike 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, #f093fb 0%, #f5576c 100%);
+      color: white;
+    }
+    .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 0.5rem 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>Login Failed</h1>
+    <p>Something went wrong during authentication.</p>
+    <div class="error-message">${escapedMessage}</div>
+  </div>
+</body>
+</html>`;
+}
+function createCallbackServer() {
+  let server = null;
+  let port = 0;
+  let expectedState = null;
+  let callbackResolve = null;
+  let timeoutId = null;
+  let callbackReceived = false;
+  function handleRequest(req, res) {
+    if (req.method !== "GET" || !req.url?.startsWith("/callback")) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+      return;
+    }
+    const params = parseCallbackParams(req.url);
+    if (params.error) {
+      const errorMessage = params.message || params.error;
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(getErrorHtml(errorMessage));
+      if (callbackResolve && !callbackReceived) {
+        callbackReceived = true;
+        callbackResolve({
+          success: false,
+          error: errorMessage
+        });
+      }
+      return;
+    }
+    if (!params.state || !expectedState || !verifyState(params.state, expectedState)) {
+      const errorMessage = "State verification failed. This may be a security issue.";
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(getErrorHtml(errorMessage));
+      if (callbackResolve && !callbackReceived) {
+        callbackReceived = true;
+        callbackResolve({
+          success: false,
+          error: errorMessage
+        });
+      }
+      return;
+    }
+    if (!params.key) {
+      const errorMessage = "No API key received in callback.";
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(getErrorHtml(errorMessage));
+      if (callbackResolve && !callbackReceived) {
+        callbackReceived = true;
+        callbackResolve({
+          success: false,
+          error: errorMessage
+        });
+      }
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(SUCCESS_HTML);
+    if (callbackResolve && !callbackReceived) {
+      callbackReceived = true;
+      callbackResolve({
+        success: true,
+        apiKey: params.key
+      });
+    }
+  }
+  return {
+    async start() {
+      return new Promise((resolve3, reject) => {
+        server = http.createServer(handleRequest);
+        server.on("error", (err) => {
+          reject(err);
+        });
+        server.listen(0, "127.0.0.1", () => {
+          const address = server.address();
+          if (address && typeof address === "object") {
+            port = address.port;
+            const url = `http://127.0.0.1:${port}`;
+            resolve3({ port, url });
+          } else {
+            reject(new Error("Failed to get server address"));
+          }
+        });
+      });
+    },
+    async waitForCallback(state, timeoutMs) {
+      expectedState = state;
+      callbackReceived = false;
+      return new Promise((resolve3) => {
+        callbackResolve = resolve3;
+        timeoutId = setTimeout(() => {
+          if (!callbackReceived) {
+            callbackReceived = true;
+            resolve3({
+              success: false,
+              error: "Login timed out. Please try again."
+            });
+          }
+        }, timeoutMs);
+      });
+    },
+    async stop() {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (server) {
+        return new Promise((resolve3) => {
+          server.close(() => {
+            server = null;
+            resolve3();
+          });
+        });
+      }
+    }
+  };
+}
+
+// src/commands/login.ts
+var DEFAULT_TIMEOUT_SECONDS = 120;
+var DEFAULT_DASHBOARD_URL = "https://app.spike.ac";
+function getDashboardUrl() {
+  return process.env.SPIKE_DASHBOARD_URL || DEFAULT_DASHBOARD_URL;
+}
+function buildAuthorizationUrl(state, callbackPort) {
+  const dashboardUrl = getDashboardUrl();
+  const callbackUrl = `http://127.0.0.1:${callbackPort}/callback`;
+  const url = new URL("/cli/authorize", dashboardUrl);
+  url.searchParams.set("state", state);
+  url.searchParams.set("callback_url", callbackUrl);
+  return url.toString();
+}
+function createLoginCommand() {
+  const loginCommand = new Command("login").description("Authenticate the CLI via browser").option(
+    "-t, --timeout <seconds>",
+    "Timeout for the login flow in seconds",
+    String(DEFAULT_TIMEOUT_SECONDS)
+  ).option(
+    "--no-browser",
+    "Skip automatic browser opening and display URL only"
+  ).action(async (options) => {
+    await handleLogin(options);
+  });
+  return loginCommand;
+}
+async function handleLogin(options) {
+  const timeoutSeconds = parseInt(options.timeout, 10);
+  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+    error("Invalid timeout value. Please provide a positive number of seconds.");
+    process.exit(1);
+  }
+  const timeoutMs = timeoutSeconds * 1e3;
+  info("Starting login flow...");
+  const state = generateState();
+  const callbackServer = createCallbackServer();
+  let serverInfo;
+  try {
+    serverInfo = await callbackServer.start();
+  } catch (err) {
+    error(`Failed to start callback server: ${err instanceof Error ? err.message : String(err)}`);
+    info("You can manually configure your API key with: spike config set api-key <your-key>");
+    process.exit(1);
+  }
+  const authUrl = buildAuthorizationUrl(state, serverInfo.port);
+  if (options.browser) {
+    info("Opening browser for authentication...");
+    const browserOpened = await openBrowser(authUrl);
+    if (!browserOpened) {
+      info("Could not open browser automatically.");
+      console.log("");
+      info("Please open the following URL in your browser:");
+      console.log("");
+      console.log(`  ${authUrl}`);
+      console.log("");
+    }
+  } else {
+    info("Please open the following URL in your browser:");
+    console.log("");
+    console.log(`  ${authUrl}`);
+    console.log("");
+  }
+  info(`Waiting for authentication (timeout: ${timeoutSeconds}s)...`);
+  try {
+    const result = await callbackServer.waitForCallback(state, timeoutMs);
+    if (result.success && result.apiKey) {
+      saveConfig({ apiKey: result.apiKey });
+      console.log("");
+      success("Login successful! API key has been saved.");
+      info("You can now use the CLI to manage your forms and submissions.");
+    } else {
+      console.log("");
+      error(result.error || "Login failed. Please try again.");
+      process.exit(1);
+    }
+  } catch (err) {
+    error(`Login error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  } finally {
+    await callbackServer.stop();
+  }
+}
+var SKILL_FILE_CONTENT = `# Spike Forms CLI Skill
+
+This skill provides knowledge about the Spike Forms CLI (\`spike\`) commands for managing forms, submissions, projects, teams, and configuration.
+
+## Overview
+
+Spike Forms is a form backend service that handles form submissions. The CLI provides commands to manage all aspects of the service.
+
+## Authentication
+
+### Login via Browser
+
+\`\`\`bash
+# Authenticate via browser (recommended)
+spike login
+
+# Login with custom timeout (in seconds)
+spike login --timeout 60
+
+# Login without automatic browser opening (displays URL to copy)
+spike login --no-browser
+\`\`\`
+
+The login command opens your browser to authorize the CLI and automatically saves your API key.
+
+### Manual Configuration
+
+\`\`\`bash
+# Set API key manually
+spike config set api-key <your-api-key>
+
+# View current configuration
+spike config get api-key
+spike config get base-url
+
+# Set custom API base URL
+spike config set base-url https://custom.api.url
+\`\`\`
+
+## Forms Management
+
+### List Forms
+
+\`\`\`bash
+# List all forms
+spike forms list
+
+# List with options
+spike forms list --limit 10
+spike forms list --project-id <project-id>
+spike forms list --include-inactive
+spike forms list --format json
+\`\`\`
+
+### Get Form Details
+
+\`\`\`bash
+# Get a specific form
+spike forms get <form-id>
+spike forms get <form-id> --format json
+\`\`\`
+
+### Create Forms
+
+\`\`\`bash
+# Create a new form
+spike forms create --name "Contact Form"
+spike forms create --name "Feedback" --project-id <project-id>
+\`\`\`
+
+### Update Forms
+
+\`\`\`bash
+# Update form name
+spike forms update <form-id> --name "New Name"
+
+# Update form status
+spike forms update <form-id> --is-active true
+spike forms update <form-id> --is-active false
+
+# Move form to a project
+spike forms update <form-id> --project-id <project-id>
+\`\`\`
+
+### Delete Forms
+
+\`\`\`bash
+# Delete a form
+spike forms delete <form-id>
+\`\`\`
+
+## Live Preview Workflow (Form Editing)
+
+The CLI provides a live preview server with hot-reload for editing form HTML templates.
+
+### Edit Existing Form
+
+\`\`\`bash
+# Fetch form and start live preview (foreground)
+spike forms edit <form-id>
+
+# Save to custom file path
+spike forms edit <form-id> --file ./my-form.html
+
+# Run preview server in background
+spike forms edit <form-id> --background
+\`\`\`
+
+### Create Form Page (Beta)
+
+\`\`\`bash
+# Create a new form and generate HTML page
+spike forms create-page --name "Contact Form"
+
+# Save to custom file path
+spike forms create-page --name "Contact Form" --file ./contact.html
+
+# Create and immediately start preview
+spike forms create-page --name "Contact Form" --preview
+
+# Create in a specific project
+spike forms create-page --name "Contact Form" --project-id <project-id>
+\`\`\`
+
+### Stop Background Preview
+
+\`\`\`bash
+# Stop the background preview server
+spike forms stop-preview
+\`\`\`
+
+### Live Preview Features
+
+- **Hot Reload**: Changes to the HTML file automatically refresh the browser
+- **SSE Connection**: Uses Server-Sent Events for instant updates
+- **Local Server**: Runs on http://127.0.0.1 with a dynamic port
+- **Background Mode**: Run the server detached and continue working
+
+## Submissions Management
+
+### List Submissions
+
+\`\`\`bash
+# List submissions for a form
+spike submissions list --form-id <form-id>
+
+# List with options
+spike submissions list --form-id <form-id> --limit 20
+spike submissions list --form-id <form-id> --format json
+\`\`\`
+
+### Get Submission Details
+
+\`\`\`bash
+# Get a specific submission
+spike submissions get <submission-id>
+spike submissions get <submission-id> --format json
+\`\`\`
+
+### Delete Submissions
+
+\`\`\`bash
+# Delete a submission
+spike submissions delete <submission-id>
+\`\`\`
+
+## Projects Management
+
+### List Projects
+
+\`\`\`bash
+# List all projects
+spike projects list
+spike projects list --format json
+\`\`\`
+
+### Get Project Details
+
+\`\`\`bash
+# Get a specific project
+spike projects get <project-id>
+\`\`\`
+
+### Create Projects
+
+\`\`\`bash
+# Create a new project
+spike projects create --name "My Project"
+spike projects create --name "My Project" --team-id <team-id>
+\`\`\`
+
+### Update Projects
+
+\`\`\`bash
+# Update project name
+spike projects update <project-id> --name "New Name"
+\`\`\`
+
+### Delete Projects
+
+\`\`\`bash
+# Delete a project
+spike projects delete <project-id>
+\`\`\`
+
+## Teams Management
+
+### List Teams
+
+\`\`\`bash
+# List all teams
+spike teams list
+spike teams list --format json
+\`\`\`
+
+### Get Team Details
+
+\`\`\`bash
+# Get a specific team
+spike teams get <team-id>
+\`\`\`
+
+### Create Teams
+
+\`\`\`bash
+# Create a new team
+spike teams create --name "My Team"
+\`\`\`
+
+### Update Teams
+
+\`\`\`bash
+# Update team name
+spike teams update <team-id> --name "New Name"
+\`\`\`
+
+### Delete Teams
+
+\`\`\`bash
+# Delete a team
+spike teams delete <team-id>
+\`\`\`
+
+## Configuration Commands
+
+\`\`\`bash
+# Get configuration values
+spike config get api-key
+spike config get base-url
+
+# Set configuration values
+spike config set api-key <your-api-key>
+spike config set base-url <api-url>
+
+# Configuration file location: ~/.spike/config.json
+\`\`\`
+
+## Global Options
+
+All commands support these global options:
+
+\`\`\`bash
+# Output format (json or table)
+spike <command> --format json
+spike <command> --format table
+
+# Help
+spike --help
+spike <command> --help
+\`\`\`
+
+## Common Workflows
+
+### Setting Up a New Form
+
+1. Login to authenticate: \`spike login\`
+2. Create a form: \`spike forms create --name "Contact Form"\`
+3. Edit with live preview: \`spike forms edit <form-id>\`
+4. Make changes to the HTML file and see them instantly in the browser
+
+### Managing Form Submissions
+
+1. List forms: \`spike forms list\`
+2. View submissions: \`spike submissions list --form-id <form-id>\`
+3. Get submission details: \`spike submissions get <submission-id>\`
+
+### Organizing with Projects and Teams
+
+1. Create a team: \`spike teams create --name "Marketing"\`
+2. Create a project: \`spike projects create --name "Website Forms" --team-id <team-id>\`
+3. Create forms in the project: \`spike forms create --name "Contact" --project-id <project-id>\`
+
+## Environment Variables
+
+- \`SPIKE_API_KEY\` or \`SPIKE_TOKEN\`: API key for authentication
+- \`SPIKE_API_URL\`: Custom API base URL
+- \`SPIKE_DASHBOARD_URL\`: Custom dashboard URL for login flow
+`;
+function getSkillsDir() {
+  const homeDir = os2.homedir();
+  return path3.join(homeDir, ".config", "opencode", "skills", "spike");
+}
+function getSkillFilePath() {
+  return path3.join(getSkillsDir(), "SKILL.md");
+}
+function isOpenCodeInstalled() {
+  try {
+    const command = process.platform === "win32" ? "where opencode" : "which opencode";
+    execSync(command, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureSkillInstalled() {
+  const skillsDir = getSkillsDir();
+  const skillFilePath = getSkillFilePath();
+  if (!fs3.existsSync(skillsDir)) {
+    fs3.mkdirSync(skillsDir, { recursive: true });
+  }
+  fs3.writeFileSync(skillFilePath, SKILL_FILE_CONTENT, "utf-8");
+}
+function installOpenCode() {
+  try {
+    info("Installing OpenCode via npm...");
+    execSync("npm install -g opencode", { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createAgentCommand() {
+  const agentCommand = new Command("agent").description("Launch OpenCode AI agent with Spike Forms knowledge").option("--install", "Install OpenCode via npm if not already installed").option("--model <model>", "Model to use with OpenCode").action(async (options) => {
+    await handleAgent(options);
+  });
+  return agentCommand;
+}
+async function handleAgent(options) {
+  if (!isOpenCodeInstalled()) {
+    if (options.install) {
+      const installed = installOpenCode();
+      if (!installed) {
+        error("Failed to install OpenCode via npm.");
+        info("Please install OpenCode manually:");
+        console.log("");
+        console.log("  npm install -g opencode");
+        console.log("");
+        info("Or visit: https://opencode.ai for more installation options.");
+        process.exit(1);
+      }
+      success("OpenCode installed successfully");
+    } else {
+      error("OpenCode is not installed.");
+      info("Install OpenCode using one of these methods:");
+      console.log("");
+      console.log("  # Install via npm");
+      console.log("  npm install -g opencode");
+      console.log("");
+      console.log("  # Or use the --install flag");
+      console.log("  spike agent --install");
+      console.log("");
+      info("Or visit: https://opencode.ai for more installation options.");
+      process.exit(1);
+    }
+  }
+  try {
+    ensureSkillInstalled();
+    info("Spike Forms skill installed for OpenCode");
+  } catch (err) {
+    warn(`Could not install skill file: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const args = [];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  info("Launching OpenCode...");
+  console.log("");
+  const opencode = spawn("opencode", args, {
+    stdio: "inherit"
+  });
+  opencode.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+  opencode.on("error", (err) => {
+    error(`Failed to launch OpenCode: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("spike").description("Command-line interface for the Spike Forms API").version("0.1.0");
+program.option(
+  "-f, --format <format>",
+  "Output format (json, table)",
+  "table"
+);
+program.addCommand(createConfigCommand());
+program.addCommand(createFormsCommand());
+program.addCommand(createSubmissionsCommand());
+program.addCommand(createProjectsCommand());
+program.addCommand(createTeamsCommand());
+program.addCommand(createUserCommand());
+program.addCommand(createLoginCommand());
+program.addCommand(createAgentCommand());
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    handleFatalError(err);
+  }
+}
+function handleFatalError(err) {
+  if (err instanceof Error) {
+    error(err.message);
+  } else {
+    error("An unexpected error occurred");
+  }
+  process.exitCode = 1;
+}
+process.on("uncaughtException", (err) => {
+  handleFatalError(err);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  handleFatalError(reason instanceof Error ? reason : new Error(String(reason)));
+  process.exit(1);
+});
+main();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map