@curenorway/kode-cli 1.0.0

package/dist/chunk-NWXEBN2N.js

@@ -0,0 +1,980 @@
+// src/config.ts
+import Conf from "conf";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+var globalConfig = new Conf({
+  projectName: "cure-kode",
+  defaults: {
+    apiUrl: "https://cure-app-v2-production.up.railway.app"
+  }
+});
+var PROJECT_CONFIG_DIR = ".cure-kode";
+var PROJECT_CONFIG_FILE = "config.json";
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== dirname(currentDir)) {
+    const configPath = join(currentDir, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+    if (existsSync(configPath)) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+function getProjectConfig(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  if (!root) return null;
+  const configPath = join(root, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+  if (!existsSync(configPath)) return null;
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveProjectConfig(config, projectRoot = process.cwd()) {
+  const configDir = join(projectRoot, PROJECT_CONFIG_DIR);
+  const configPath = join(configDir, PROJECT_CONFIG_FILE);
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function getApiUrl(projectConfig) {
+  return projectConfig?.apiUrl || globalConfig.get("apiUrl");
+}
+function getApiKey(projectConfig) {
+  return projectConfig?.apiKey || globalConfig.get("defaultApiKey") || null;
+}
+function setGlobalConfig(key, value) {
+  globalConfig.set(key, value);
+}
+function getScriptsDir(projectRoot, projectConfig) {
+  return join(projectRoot, projectConfig?.scriptsDir || "scripts");
+}
+
+// src/commands/init.ts
+import chalk from "chalk";
+import ora from "ora";
+import { prompt } from "enquirer";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+async function initCommand(options) {
+  const cwd = process.cwd();
+  const existingRoot = findProjectRoot(cwd);
+  if (existingRoot && !options.force) {
+    console.log(
+      chalk.yellow("\u26A0\uFE0F  Cure Kode is already initialized in this directory tree.")
+    );
+    console.log(chalk.dim(`   Config found at: ${existingRoot}/.cure-kode/config.json`));
+    console.log(chalk.dim("   Use --force to reinitialize."));
+    return;
+  }
+  console.log(chalk.bold("\n\u{1F680} Cure Kode Setup\n"));
+  const answers = await prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "API Key (from Cure App \u2192 Tools \u2192 Kode \u2192 API Keys):",
+      initial: options.apiKey,
+      validate: (value) => value.length > 0 ? true : "API key is required"
+    },
+    {
+      type: "input",
+      name: "siteSlug",
+      message: 'Site slug (e.g., "swipp"):',
+      initial: options.siteSlug,
+      validate: (value) => /^[a-z0-9-]+$/.test(value) ? true : "Slug must be lowercase letters, numbers, and hyphens only"
+    },
+    {
+      type: "input",
+      name: "siteName",
+      message: "Site name (for display):",
+      initial: (answers2) => answers2.siteSlug ? answers2.siteSlug.charAt(0).toUpperCase() + answers2.siteSlug.slice(1) : ""
+    },
+    {
+      type: "input",
+      name: "siteId",
+      message: "Site ID (UUID from Cure App):",
+      validate: (value) => /^[0-9a-f-]{36}$/.test(value) ? true : "Must be a valid UUID"
+    },
+    {
+      type: "input",
+      name: "scriptsDir",
+      message: "Scripts directory:",
+      initial: "scripts"
+    },
+    {
+      type: "select",
+      name: "environment",
+      message: "Default environment:",
+      choices: [
+        { name: "staging", message: "Staging (recommended for development)" },
+        { name: "production", message: "Production" }
+      ],
+      initial: 0
+    }
+  ]);
+  const spinner = ora("Validating configuration...").start();
+  try {
+    const response = await fetch(
+      `https://cure-app-v2-production.up.railway.app/api/cdn/sites/${answers.siteId}`,
+      {
+        headers: {
+          "X-API-Key": answers.apiKey
+        }
+      }
+    );
+    if (!response.ok) {
+      spinner.fail("Invalid API key or site ID");
+      console.log(chalk.red("\nCould not validate your credentials."));
+      console.log(chalk.dim("Make sure your API key has access to this site."));
+      return;
+    }
+    spinner.succeed("Configuration validated");
+    const config = {
+      siteId: answers.siteId,
+      siteSlug: answers.siteSlug,
+      siteName: answers.siteName,
+      apiKey: answers.apiKey,
+      scriptsDir: answers.scriptsDir,
+      environment: answers.environment
+    };
+    saveProjectConfig(config, cwd);
+    const scriptsPath = join2(cwd, answers.scriptsDir);
+    if (!existsSync2(scriptsPath)) {
+      mkdirSync2(scriptsPath, { recursive: true });
+    }
+    const gitignorePath = join2(cwd, ".cure-kode", ".gitignore");
+    const gitignoreContent = `# Keep config.json private - contains API key
+config.json
+`;
+    const fs = await import("fs");
+    fs.writeFileSync(gitignorePath, gitignoreContent);
+    console.log(chalk.green("\n\u2705 Cure Kode initialized successfully!\n"));
+    console.log(chalk.dim("Project structure:"));
+    console.log(chalk.dim(`  ${cwd}/`));
+    console.log(chalk.dim(`  \u251C\u2500\u2500 .cure-kode/`));
+    console.log(chalk.dim(`  \u2502   \u251C\u2500\u2500 config.json   (your configuration)`));
+    console.log(chalk.dim(`  \u2502   \u2514\u2500\u2500 .gitignore    (protects API key)`));
+    console.log(chalk.dim(`  \u2514\u2500\u2500 ${answers.scriptsDir}/`));
+    console.log(chalk.dim(`      \u2514\u2500\u2500 (your scripts will be here)`));
+    console.log(chalk.bold("\nNext steps:"));
+    console.log(chalk.cyan("  1. kode pull     ") + chalk.dim("Download existing scripts"));
+    console.log(chalk.cyan("  2. kode watch    ") + chalk.dim("Watch for changes and auto-push"));
+    console.log(chalk.cyan("  3. kode deploy   ") + chalk.dim("Deploy to staging/production"));
+  } catch (error) {
+    spinner.fail("Initialization failed");
+    console.error(chalk.red("\nError:"), error);
+  }
+}
+
+// src/api.ts
+var KodeApiError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "KodeApiError";
+  }
+};
+var KodeApiClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = getApiUrl(config);
+    const apiKey = getApiKey(config);
+    if (!apiKey) {
+      throw new Error('API key is required. Run "kode init" first.');
+    }
+    this.apiKey = apiKey;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey,
+        ...options.headers
+      }
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new KodeApiError(
+        data.error || `Request failed with status ${response.status}`,
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  // Sites
+  async getSite(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}`);
+  }
+  async listSites() {
+    return this.request("/api/cdn/sites");
+  }
+  // Scripts
+  async listScripts(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/scripts`);
+  }
+  async getScript(scriptId) {
+    return this.request(`/api/cdn/scripts/${scriptId}`);
+  }
+  async createScript(siteId, data) {
+    return this.request(`/api/cdn/sites/${siteId}/scripts`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateScript(scriptId, data) {
+    return this.request(`/api/cdn/scripts/${scriptId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteScript(scriptId) {
+    await this.request(`/api/cdn/scripts/${scriptId}`, {
+      method: "DELETE"
+    });
+  }
+  // Upload (alternative endpoint that works with API keys)
+  async uploadScript(data) {
+    return this.request("/api/cdn/upload", {
+      method: "POST",
+      body: JSON.stringify({
+        ...data,
+        apiKey: this.apiKey
+      })
+    });
+  }
+  // Pages
+  async listPages(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/pages`);
+  }
+  // Deployments
+  async deploy(siteId, environment = "staging") {
+    return this.request("/api/cdn/deploy", {
+      method: "POST",
+      body: JSON.stringify({
+        siteId,
+        environment,
+        apiKey: this.apiKey
+      })
+    });
+  }
+  async promoteToProduction(siteId, stagingDeploymentId) {
+    return this.request("/api/cdn/deploy/promote", {
+      method: "POST",
+      body: JSON.stringify({
+        siteId,
+        stagingDeploymentId,
+        apiKey: this.apiKey
+      })
+    });
+  }
+  async getDeploymentStatus(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/deployments/status`);
+  }
+  // HTML Fetch
+  async fetchHtml(url) {
+    return this.request("/api/cdn/fetch-html", {
+      method: "POST",
+      body: JSON.stringify({ url })
+    });
+  }
+};
+function createApiClient(config) {
+  return new KodeApiClient(config);
+}
+
+// src/commands/pull.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+async function pullCommand(options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk2.red("\u274C Not in a Cure Kode project."));
+    console.log(chalk2.dim('   Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk2.red("\u274C Could not read project configuration."));
+    return;
+  }
+  const spinner = ora2("Fetching scripts...").start();
+  try {
+    const client = createApiClient(config);
+    const scripts = await client.listScripts(config.siteId);
+    if (scripts.length === 0) {
+      spinner.info("No scripts found on remote.");
+      console.log(chalk2.dim('\nCreate scripts in Cure App or use "kode push" to upload local scripts.'));
+      return;
+    }
+    spinner.succeed(`Found ${scripts.length} script(s)`);
+    const scriptsDir = getScriptsDir(projectRoot, config);
+    if (!existsSync3(scriptsDir)) {
+      mkdirSync3(scriptsDir, { recursive: true });
+    }
+    const scriptsToPull = options.script ? scripts.filter((s) => s.slug === options.script || s.name === options.script) : scripts;
+    if (options.script && scriptsToPull.length === 0) {
+      console.log(chalk2.yellow(`
+\u26A0\uFE0F  Script "${options.script}" not found.`));
+      console.log(chalk2.dim("Available scripts:"));
+      scripts.forEach((s) => {
+        console.log(chalk2.dim(`  - ${s.slug} (${s.name})`));
+      });
+      return;
+    }
+    console.log();
+    let pulled = 0;
+    let skipped = 0;
+    for (const script of scriptsToPull) {
+      const ext = script.type === "javascript" ? "js" : "css";
+      const fileName = `${script.slug}.${ext}`;
+      const filePath = join3(scriptsDir, fileName);
+      if (existsSync3(filePath) && !options.force) {
+        const localContent = await import("fs").then(
+          (fs) => fs.readFileSync(filePath, "utf-8")
+        );
+        if (localContent !== script.content) {
+          console.log(
+            chalk2.yellow(`  \u26A0 ${fileName}`) + chalk2.dim(" (local changes exist, use --force to overwrite)")
+          );
+          skipped++;
+          continue;
+        }
+      }
+      writeFileSync2(filePath, script.content);
+      const scopeTag = script.scope === "global" ? chalk2.blue("[G]") : chalk2.magenta("[P]");
+      console.log(
+        chalk2.green(`  \u2713 ${fileName}`) + chalk2.dim(` v${script.current_version} ${scopeTag}`)
+      );
+      pulled++;
+    }
+    console.log();
+    if (pulled > 0) {
+      console.log(chalk2.green(`\u2705 Pulled ${pulled} script(s) to ${config.scriptsDir}/`));
+    }
+    if (skipped > 0) {
+      console.log(chalk2.yellow(`\u26A0\uFE0F  Skipped ${skipped} script(s) with local changes`));
+    }
+    const metadataPath = join3(projectRoot, ".cure-kode", "scripts.json");
+    const metadata = scripts.map((s) => ({
+      id: s.id,
+      slug: s.slug,
+      name: s.name,
+      type: s.type,
+      scope: s.scope,
+      version: s.current_version,
+      loadOrder: s.load_order
+    }));
+    writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2));
+  } catch (error) {
+    spinner.fail("Failed to pull scripts");
+    console.error(chalk2.red("\nError:"), error);
+  }
+}
+
+// src/commands/push.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { readFileSync as readFileSync2, existsSync as existsSync4, readdirSync } from "fs";
+import { join as join4, basename, extname } from "path";
+async function pushCommand(options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk3.red("\u274C Not in a Cure Kode project."));
+    console.log(chalk3.dim('   Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk3.red("\u274C Could not read project configuration."));
+    return;
+  }
+  const scriptsDir = getScriptsDir(projectRoot, config);
+  if (!existsSync4(scriptsDir)) {
+    console.log(chalk3.yellow("\u26A0\uFE0F  Scripts directory not found."));
+    console.log(chalk3.dim(`   Expected: ${scriptsDir}`));
+    console.log(chalk3.dim('   Run "kode pull" first or create scripts manually.'));
+    return;
+  }
+  const metadataPath = join4(projectRoot, ".cure-kode", "scripts.json");
+  let metadata = [];
+  if (existsSync4(metadataPath)) {
+    metadata = JSON.parse(readFileSync2(metadataPath, "utf-8"));
+  }
+  const files = readdirSync(scriptsDir).filter(
+    (f) => f.endsWith(".js") || f.endsWith(".css")
+  );
+  if (files.length === 0) {
+    console.log(chalk3.yellow("\u26A0\uFE0F  No script files found."));
+    console.log(chalk3.dim(`   Add .js or .css files to ${scriptsDir}/`));
+    return;
+  }
+  const filesToPush = options.script ? files.filter(
+    (f) => basename(f, extname(f)) === options.script || f === options.script || f === `${options.script}.js` || f === `${options.script}.css`
+  ) : files;
+  if (options.script && filesToPush.length === 0) {
+    console.log(chalk3.yellow(`\u26A0\uFE0F  Script "${options.script}" not found locally.`));
+    console.log(chalk3.dim("Available local scripts:"));
+    files.forEach((f) => {
+      console.log(chalk3.dim(`  - ${f}`));
+    });
+    return;
+  }
+  const spinner = ora3("Pushing scripts...").start();
+  try {
+    const client = createApiClient(config);
+    const remoteScripts = await client.listScripts(config.siteId);
+    let pushed = 0;
+    let created = 0;
+    let skipped = 0;
+    spinner.stop();
+    console.log();
+    for (const file of filesToPush) {
+      const filePath = join4(scriptsDir, file);
+      const content = readFileSync2(filePath, "utf-8");
+      const slug = basename(file, extname(file));
+      const type = extname(file) === ".js" ? "javascript" : "css";
+      const remoteScript = remoteScripts.find((s) => s.slug === slug);
+      const localMeta = metadata.find((m) => m.slug === slug);
+      if (remoteScript) {
+        if (remoteScript.content === content && !options.all) {
+          console.log(chalk3.dim(`  - ${file} (no changes)`));
+          skipped++;
+          continue;
+        }
+        const updateSpinner = ora3(`Updating ${file}...`).start();
+        await client.updateScript(remoteScript.id, {
+          content,
+          changeSummary: options.message || `Updated via CLI`
+        });
+        updateSpinner.succeed(
+          chalk3.green(`  \u2713 ${file}`) + chalk3.dim(` \u2192 v${remoteScript.current_version + 1}`)
+        );
+        pushed++;
+      } else {
+        const createSpinner = ora3(`Creating ${file}...`).start();
+        const newScript = await client.createScript(config.siteId, {
+          name: slug.charAt(0).toUpperCase() + slug.slice(1).replace(/-/g, " "),
+          slug,
+          type,
+          scope: localMeta?.scope || "global",
+          content
+        });
+        createSpinner.succeed(
+          chalk3.green(`  \u2713 ${file}`) + chalk3.cyan(" (new)")
+        );
+        created++;
+      }
+    }
+    console.log();
+    if (pushed > 0) {
+      console.log(chalk3.green(`\u2705 Updated ${pushed} script(s)`));
+    }
+    if (created > 0) {
+      console.log(chalk3.cyan(`\u2705 Created ${created} new script(s)`));
+    }
+    if (skipped > 0) {
+      console.log(chalk3.dim(`   Skipped ${skipped} unchanged script(s)`));
+    }
+    const updatedScripts = await client.listScripts(config.siteId);
+    const updatedMetadata = updatedScripts.map((s) => ({
+      id: s.id,
+      slug: s.slug,
+      name: s.name,
+      type: s.type,
+      scope: s.scope,
+      version: s.current_version,
+      loadOrder: s.load_order
+    }));
+    const fs = await import("fs");
+    fs.writeFileSync(metadataPath, JSON.stringify(updatedMetadata, null, 2));
+  } catch (error) {
+    spinner.fail("Failed to push scripts");
+    console.error(chalk3.red("\nError:"), error);
+  }
+}
+
+// src/commands/watch.ts
+import chalk4 from "chalk";
+import chokidar from "chokidar";
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join5, basename as basename2, extname as extname2 } from "path";
+async function watchCommand(options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk4.red("\u274C Not in a Cure Kode project."));
+    console.log(chalk4.dim('   Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk4.red("\u274C Could not read project configuration."));
+    return;
+  }
+  const scriptsDir = getScriptsDir(projectRoot, config);
+  if (!existsSync5(scriptsDir)) {
+    console.log(chalk4.yellow("\u26A0\uFE0F  Scripts directory not found."));
+    console.log(chalk4.dim(`   Expected: ${scriptsDir}`));
+    console.log(chalk4.dim('   Run "kode pull" first.'));
+    return;
+  }
+  console.log(chalk4.bold("\n\u{1F440} Watching for changes...\n"));
+  console.log(chalk4.dim(`   Directory: ${scriptsDir}`));
+  console.log(chalk4.dim(`   Site: ${config.siteName} (${config.siteSlug})`));
+  console.log(chalk4.dim(`   Environment: ${config.environment || "staging"}`));
+  if (options.deploy) {
+    console.log(chalk4.cyan(`   Auto-deploy: enabled`));
+  }
+  console.log();
+  console.log(chalk4.dim("Press Ctrl+C to stop.\n"));
+  const client = createApiClient(config);
+  const metadataPath = join5(projectRoot, ".cure-kode", "scripts.json");
+  let metadata = [];
+  if (existsSync5(metadataPath)) {
+    metadata = JSON.parse(readFileSync3(metadataPath, "utf-8"));
+  }
+  let remoteScripts = [];
+  try {
+    remoteScripts = await client.listScripts(config.siteId);
+    console.log(chalk4.dim(`Loaded ${remoteScripts.length} remote script(s)
+`));
+  } catch (error) {
+    console.log(chalk4.yellow("\u26A0\uFE0F  Could not load remote scripts. Will create new on change."));
+  }
+  const pendingChanges = /* @__PURE__ */ new Map();
+  const DEBOUNCE_MS = 500;
+  const handleChange = async (filePath) => {
+    const fileName = basename2(filePath);
+    const slug = basename2(fileName, extname2(fileName));
+    const type = extname2(fileName) === ".js" ? "javascript" : "css";
+    if (pendingChanges.has(filePath)) {
+      clearTimeout(pendingChanges.get(filePath));
+    }
+    const timeout = setTimeout(async () => {
+      pendingChanges.delete(filePath);
+      try {
+        const content = readFileSync3(filePath, "utf-8");
+        const remoteScript = remoteScripts.find((s) => s.slug === slug);
+        const localMeta = metadata.find((m) => m.slug === slug);
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("nb-NO");
+        if (remoteScript) {
+          if (remoteScript.content === content) {
+            return;
+          }
+          await client.updateScript(remoteScript.id, {
+            content,
+            changeSummary: "Updated via watch"
+          });
+          remoteScript.content = content;
+          remoteScript.current_version++;
+          console.log(
+            chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.dim(` \u2192 v${remoteScript.current_version}`)
+          );
+          if (options.deploy) {
+            try {
+              await client.deploy(config.siteId, config.environment || "staging");
+              console.log(
+                chalk4.dim(`[${timestamp}] `) + chalk4.cyan(`  \u21B3 Deployed to ${config.environment || "staging"}`)
+              );
+            } catch (deployError) {
+              console.log(
+                chalk4.dim(`[${timestamp}] `) + chalk4.red(`  \u21B3 Deploy failed`)
+              );
+            }
+          }
+        } else {
+          const newScript = await client.createScript(config.siteId, {
+            name: slug.charAt(0).toUpperCase() + slug.slice(1).replace(/-/g, " "),
+            slug,
+            type,
+            scope: localMeta?.scope || "global",
+            content
+          });
+          remoteScripts.push(newScript);
+          console.log(
+            chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.cyan(" (created)")
+          );
+          const updatedMetadata = remoteScripts.map((s) => ({
+            id: s.id,
+            slug: s.slug,
+            name: s.name,
+            type: s.type,
+            scope: s.scope,
+            version: s.current_version,
+            loadOrder: s.load_order
+          }));
+          const fs = await import("fs");
+          fs.writeFileSync(metadataPath, JSON.stringify(updatedMetadata, null, 2));
+        }
+      } catch (error) {
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("nb-NO");
+        console.log(
+          chalk4.dim(`[${timestamp}] `) + chalk4.red(`\u2717 ${fileName}`) + chalk4.dim(` - ${error.message || "Unknown error"}`)
+        );
+      }
+    }, DEBOUNCE_MS);
+    pendingChanges.set(filePath, timeout);
+  };
+  const watcher = chokidar.watch(join5(scriptsDir, "**/*.{js,css}"), {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+  watcher.on("change", handleChange);
+  watcher.on("add", handleChange);
+  watcher.on("unlink", (filePath) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("nb-NO");
+    const fileName = basename2(filePath);
+    console.log(
+      chalk4.dim(`[${timestamp}] `) + chalk4.yellow(`\u26A0 ${fileName} deleted locally`) + chalk4.dim(" (remote not affected)")
+    );
+  });
+  process.on("SIGINT", () => {
+    console.log(chalk4.dim("\n\nStopping watch...\n"));
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+// src/commands/deploy.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+async function deployCommand(environment, options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk5.red("\u274C Not in a Cure Kode project."));
+    console.log(chalk5.dim('   Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk5.red("\u274C Could not read project configuration."));
+    return;
+  }
+  const env = environment || config.environment || "staging";
+  if (options?.promote) {
+    const spinner2 = ora4("Promoting staging to production...").start();
+    try {
+      const client = createApiClient(config);
+      const deployment = await client.promoteToProduction(config.siteId);
+      spinner2.succeed("Promoted to production");
+      console.log();
+      console.log(chalk5.dim("Deployment details:"));
+      console.log(chalk5.dim(`  Version: ${deployment.version}`));
+      console.log(chalk5.dim(`  Status: ${deployment.status}`));
+      console.log();
+      console.log(chalk5.green("\u2705 Production is now running the latest staging version!"));
+    } catch (error) {
+      spinner2.fail("Promotion failed");
+      console.error(chalk5.red("\nError:"), error.message || error);
+    }
+    return;
+  }
+  const spinner = ora4(`Deploying to ${env}...`).start();
+  try {
+    const client = createApiClient(config);
+    const deployment = await client.deploy(config.siteId, env);
+    spinner.succeed(`Deployed to ${env}`);
+    console.log();
+    console.log(chalk5.dim("Deployment details:"));
+    console.log(chalk5.dim(`  Version: ${deployment.version}`));
+    console.log(chalk5.dim(`  Status: ${deployment.status}`));
+    console.log(chalk5.dim(`  Started: ${new Date(deployment.started_at).toLocaleString("nb-NO")}`));
+    console.log();
+    if (env === "staging") {
+      console.log(chalk5.cyan('\u{1F4A1} Tip: Use "kode deploy production" or "kode deploy --promote" to go live.'));
+    } else {
+      console.log(chalk5.green("\u2705 Changes are now live!"));
+    }
+  } catch (error) {
+    spinner.fail("Deployment failed");
+    console.error(chalk5.red("\nError:"), error.message || error);
+  }
+}
+
+// src/commands/html.ts
+import chalk6 from "chalk";
+import ora5 from "ora";
+async function htmlCommand(url, options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk6.red("\u274C Not in a Cure Kode project."));
+    console.log(chalk6.dim('   Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk6.red("\u274C Could not read project configuration."));
+    return;
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url.startsWith("http") ? url : `https://${url}`);
+  } catch {
+    console.log(chalk6.red("\u274C Invalid URL."));
+    return;
+  }
+  const spinner = ora5(`Fetching ${parsedUrl.hostname}${parsedUrl.pathname}...`).start();
+  try {
+    const client = createApiClient(config);
+    const result = await client.fetchHtml(parsedUrl.toString());
+    spinner.succeed("HTML fetched");
+    if (options?.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log();
+    console.log(chalk6.bold(result.title || parsedUrl.hostname));
+    console.log(chalk6.dim(result.url));
+    console.log();
+    const hasCureKode = result.scripts.cureKode.length > 0;
+    if (hasCureKode) {
+      console.log(chalk6.green("\u2705 Cure Kode installed"));
+    } else {
+      console.log(chalk6.yellow("\u26A0\uFE0F  Cure Kode not found"));
+      console.log(chalk6.dim("   Add this to your Webflow site:"));
+      console.log(chalk6.cyan(`   <script src="https://cure-app-v2-production.up.railway.app/api/cdn/${config.siteSlug}/init.js"></script>`));
+    }
+    console.log();
+    console.log(chalk6.dim("\u2500".repeat(50)));
+    console.log(
+      `  Scripts: ${result.stats.totalScripts}` + chalk6.dim(` (${result.stats.externalScripts} external, ${result.stats.inlineScripts} inline)`)
+    );
+    console.log(`  Styles: ${result.stats.totalStyles}`);
+    console.log(chalk6.dim("\u2500".repeat(50)));
+    console.log();
+    if (!options?.styles) {
+      console.log(chalk6.bold("Scripts"));
+      console.log();
+      if (result.scripts.webflow.length > 0) {
+        console.log(chalk6.blue("  Webflow:"));
+        result.scripts.webflow.forEach((s) => {
+          console.log(chalk6.dim(`    ${s.src || "(inline)"}`));
+        });
+      }
+      if (result.scripts.cureKode.length > 0) {
+        console.log(chalk6.green("  Cure Kode:"));
+        result.scripts.cureKode.forEach((s) => {
+          console.log(chalk6.dim(`    ${s.src || "(inline)"}`));
+        });
+      }
+      if (result.scripts.thirdParty.length > 0) {
+        console.log(chalk6.yellow("  Third-party:"));
+        result.scripts.thirdParty.forEach((s) => {
+          console.log(chalk6.dim(`    ${s.src || "(inline)"}`));
+        });
+      }
+      if (result.scripts.custom.length > 0) {
+        console.log(chalk6.magenta("  Custom:"));
+        result.scripts.custom.forEach((s) => {
+          const label = s.src || (s.inline ? `(inline, ${s.content?.length || 0} chars)` : "(inline)");
+          console.log(chalk6.dim(`    ${label}`));
+        });
+      }
+      console.log();
+    }
+    if (result.detectedComponents.length > 0) {
+      console.log(chalk6.bold("Detected Components"));
+      console.log();
+      result.detectedComponents.forEach((comp) => {
+        console.log(chalk6.dim(`  \u2022 ${comp}`));
+      });
+      console.log();
+    }
+    if (options?.styles) {
+      console.log(chalk6.bold("Stylesheets"));
+      console.log();
+      result.styles.forEach((style) => {
+        if (style.href) {
+          const isWebflow = style.isWebflow ? chalk6.blue(" [WF]") : "";
+          console.log(chalk6.dim(`  ${style.href}${isWebflow}`));
+        } else {
+          console.log(chalk6.dim("  (inline style)"));
+        }
+      });
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch HTML");
+    console.error(chalk6.red("\nError:"), error.message || error);
+  }
+}
+
+// src/commands/status.ts
+import chalk7 from "chalk";
+import ora6 from "ora";
+import { readFileSync as readFileSync4, existsSync as existsSync6, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join6, basename as basename3, extname as extname3 } from "path";
+async function statusCommand(options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk7.red("\u274C Not in a Cure Kode project."));
+    console.log(chalk7.dim('   Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk7.red("\u274C Could not read project configuration."));
+    return;
+  }
+  console.log();
+  console.log(chalk7.bold(`\u{1F4E6} ${config.siteName}`));
+  console.log(chalk7.dim(`   Slug: ${config.siteSlug}`));
+  console.log(chalk7.dim(`   ID: ${config.siteId}`));
+  console.log();
+  const spinner = ora6("Fetching status...").start();
+  try {
+    const client = createApiClient(config);
+    const [remoteScripts, deployStatus] = await Promise.all([
+      client.listScripts(config.siteId),
+      client.getDeploymentStatus(config.siteId)
+    ]);
+    spinner.stop();
+    console.log(chalk7.bold("Environments"));
+    console.log();
+    const stagingStatus = deployStatus.staging.lastSuccessful;
+    if (stagingStatus) {
+      console.log(
+        chalk7.blue("  Staging: ") + chalk7.green("\u25CF") + chalk7.dim(` v${stagingStatus.version}`) + chalk7.dim(` (${formatDate(stagingStatus.completedAt)})`)
+      );
+    } else {
+      console.log(chalk7.blue("  Staging: ") + chalk7.yellow("\u25CB") + chalk7.dim(" No deployments"));
+    }
+    const prodStatus = deployStatus.production.lastSuccessful;
+    if (prodStatus) {
+      console.log(
+        chalk7.green("  Production: ") + chalk7.green("\u25CF") + chalk7.dim(` v${prodStatus.version}`) + chalk7.dim(` (${formatDate(prodStatus.completedAt)})`)
+      );
+    } else {
+      console.log(
+        chalk7.green("  Production: ") + chalk7.yellow("\u25CB") + chalk7.dim(" No deployments")
+      );
+    }
+    if (deployStatus.canPromote) {
+      console.log();
+      console.log(
+        chalk7.cyan('  \u{1F4A1} Staging is ahead of production. Run "kode deploy --promote" to update.')
+      );
+    }
+    console.log();
+    console.log(chalk7.bold("Scripts"));
+    console.log();
+    const scriptsDir = getScriptsDir(projectRoot, config);
+    const localFiles = existsSync6(scriptsDir) ? readdirSync2(scriptsDir).filter((f) => f.endsWith(".js") || f.endsWith(".css")) : [];
+    const localBySlug = /* @__PURE__ */ new Map();
+    for (const file of localFiles) {
+      const slug = basename3(file, extname3(file));
+      const filePath = join6(scriptsDir, file);
+      const content = readFileSync4(filePath, "utf-8");
+      const stats = statSync(filePath);
+      localBySlug.set(slug, { file, content, modified: stats.mtime });
+    }
+    const remoteBySlug = /* @__PURE__ */ new Map();
+    for (const script of remoteScripts) {
+      remoteBySlug.set(script.slug, script);
+    }
+    const allSlugs = /* @__PURE__ */ new Set([...localBySlug.keys(), ...remoteBySlug.keys()]);
+    for (const slug of allSlugs) {
+      const local = localBySlug.get(slug);
+      const remote = remoteBySlug.get(slug);
+      if (local && remote) {
+        const isChanged = local.content !== remote.content;
+        const scopeTag = remote.scope === "global" ? chalk7.blue("[G]") : chalk7.magenta("[P]");
+        if (isChanged) {
+          console.log(
+            chalk7.yellow("  M ") + `${local.file}` + chalk7.dim(` v${remote.current_version} ${scopeTag}`) + chalk7.yellow(" (modified)")
+          );
+        } else {
+          console.log(
+            chalk7.green("  \u2713 ") + chalk7.dim(`${local.file}`) + chalk7.dim(` v${remote.current_version} ${scopeTag}`)
+          );
+        }
+      } else if (local && !remote) {
+        console.log(
+          chalk7.cyan("  + ") + `${local.file}` + chalk7.cyan(" (new, not pushed)")
+        );
+      } else if (!local && remote) {
+        const ext = remote.type === "javascript" ? "js" : "css";
+        const fileName = `${slug}.${ext}`;
+        console.log(
+          chalk7.red("  - ") + chalk7.dim(`${fileName}`) + chalk7.red(" (remote only, not pulled)")
+        );
+      }
+    }
+    if (allSlugs.size === 0) {
+      console.log(chalk7.dim("  No scripts yet."));
+    }
+    console.log();
+    const modified = [...allSlugs].filter((slug) => {
+      const local = localBySlug.get(slug);
+      const remote = remoteBySlug.get(slug);
+      return local && remote && local.content !== remote.content;
+    }).length;
+    const newLocal = [...allSlugs].filter(
+      (slug) => localBySlug.has(slug) && !remoteBySlug.has(slug)
+    ).length;
+    const remoteOnly = [...allSlugs].filter(
+      (slug) => !localBySlug.has(slug) && remoteBySlug.has(slug)
+    ).length;
+    if (modified > 0 || newLocal > 0) {
+      console.log(chalk7.bold("Actions"));
+      console.log();
+      if (modified > 0) {
+        console.log(chalk7.yellow(`  ${modified} modified`) + chalk7.dim(' \u2192 Run "kode push" to upload'));
+      }
+      if (newLocal > 0) {
+        console.log(chalk7.cyan(`  ${newLocal} new local`) + chalk7.dim(' \u2192 Run "kode push" to create'));
+      }
+      if (remoteOnly > 0) {
+        console.log(chalk7.red(`  ${remoteOnly} remote only`) + chalk7.dim(' \u2192 Run "kode pull" to download'));
+      }
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch status");
+    console.error(chalk7.red("\nError:"), error.message || error);
+  }
+}
+function formatDate(dateStr) {
+  if (!dateStr) return "Unknown";
+  const date = new Date(dateStr);
+  return date.toLocaleString("nb-NO", {
+    day: "2-digit",
+    month: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+
+export {
+  findProjectRoot,
+  getProjectConfig,
+  saveProjectConfig,
+  getApiUrl,
+  getApiKey,
+  setGlobalConfig,
+  getScriptsDir,
+  initCommand,
+  KodeApiError,
+  KodeApiClient,
+  createApiClient,
+  pullCommand,
+  pushCommand,
+  watchCommand,
+  deployCommand,
+  htmlCommand,
+  statusCommand
+};