@curenorway/kode-cli 1.9.0 → 1.10.0

package/dist/{chunk-HKPZVOMY.js → chunk-CUZJE4JZ.js}

@@ -1337,11 +1337,16 @@ async function initCommand(options) {
   console.log(chalk.bold("\n\u{1F680} Cure Kode Setup\n"));
   const { apiKey } = await prompt([
     {
-      type: "password",
+      type: "input",
       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"
+      validate: (value) => {
+        if (value.length === 0) return "API key is required";
+        if (!value.startsWith("ck_")) return "API key should start with ck_";
+        if (value.length < 30) return "API key looks truncated - make sure you copied the full key";
+        return true;
+      }
     }
   ]);
   const spinner = ora("Validating API key...").start();
@@ -1405,7 +1410,7 @@ config.json
     mcpConfig.mcpServers["cure-kode"] = {
       type: "stdio",
       command: "npx",
-      args: ["-y", "@curenorway/kode-mcp"]
+      args: ["-y", "@curenorway/kode-mcp@^1.3.0"]
     };
     let webflowToken = site.webflow_token;
     let webflowMcpMethod = null;
@@ -1456,7 +1461,7 @@ config.json
       mcpConfig.mcpServers["webflow"] = {
         type: "stdio",
         command: "npx",
-        args: ["-y", "webflow-mcp-server@latest"],
+        args: ["-y", "webflow-mcp-server@^0.6.0"],
         env: {
           WEBFLOW_TOKEN: webflowToken
         }
@@ -1470,7 +1475,7 @@ config.json
     mcpConfig.mcpServers["playwright"] = {
       type: "stdio",
       command: "npx",
-      args: ["-y", "@playwright/mcp@latest"]
+      args: ["-y", "@playwright/mcp@^0.0.21"]
     };
     spinner.start("Generating AI context files...");
     writeFileSync3(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + "\n");
@@ -1641,6 +1646,80 @@ config.json
   }
 }
 
+// src/lib/retry.ts
+function isRetryableError(error) {
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
+  }
+  const err = error;
+  const statusCode = err.statusCode || err.status;
+  if (statusCode && statusCode >= 400 && statusCode < 500) {
+    return false;
+  }
+  if (statusCode && statusCode >= 500) {
+    return true;
+  }
+  if (err.code === "ECONNRESET" || err.code === "ETIMEDOUT" || err.code === "ENOTFOUND") {
+    return true;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("network") || message.includes("timeout") || message.includes("connection") || message.includes("socket")) {
+      return true;
+    }
+  }
+  return false;
+}
+function calculateDelay(attempt, baseDelayMs, maxDelayMs, backoffMultiplier, jitter) {
+  const exponentialDelay = baseDelayMs * Math.pow(backoffMultiplier, attempt - 1);
+  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+  if (!jitter) {
+    return cappedDelay;
+  }
+  const jitterRange = cappedDelay * 0.25;
+  const jitterOffset = (Math.random() - 0.5) * 2 * jitterRange;
+  return Math.max(0, Math.round(cappedDelay + jitterOffset));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 500,
+    maxDelayMs = 5e3,
+    backoffMultiplier = 2,
+    jitter = true,
+    isRetryable = isRetryableError,
+    onRetry
+  } = options;
+  let lastError;
+  let totalDelayMs = 0;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= maxAttempts || !isRetryable(error)) {
+        throw lastError;
+      }
+      const delayMs = calculateDelay(
+        attempt,
+        baseDelayMs,
+        maxDelayMs,
+        backoffMultiplier,
+        jitter
+      );
+      totalDelayMs += delayMs;
+      if (onRetry) {
+        onRetry(attempt, error, delayMs);
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+
 // src/api.ts
 var KodeApiError = class extends Error {
   constructor(message, statusCode, response) {
@@ -1663,23 +1742,38 @@ var KodeApiClient = class {
   }
   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
+    return withRetry(
+      async () => {
+        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;
+      },
+      {
+        maxAttempts: 3,
+        baseDelayMs: 500,
+        // Custom retry check: retry on network errors and 5xx, but not 4xx
+        isRetryable: (error) => {
+          if (error instanceof KodeApiError) {
+            return error.statusCode >= 500;
+          }
+          return isRetryableError(error);
+        }
       }
-    });
-    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) {
@@ -1750,6 +1844,15 @@ var KodeApiClient = class {
   async getDeploymentStatus(siteId) {
     return this.request(`/api/cdn/sites/${siteId}/deployments/status`);
   }
+  async rollback(siteId, environment = "staging") {
+    return this.request("/api/cdn/deploy/rollback", {
+      method: "POST",
+      body: JSON.stringify({
+        siteId,
+        environment
+      })
+    });
+  }
   // Production enabled toggle (v2.3)
   async setProductionEnabled(siteId, enabled, productionDomain) {
     return this.request(`/api/cdn/sites/${siteId}/production`, {
@@ -1767,6 +1870,16 @@ var KodeApiClient = class {
       body: JSON.stringify({ url })
     });
   }
+  // Lock management
+  async getLockStatus(siteId) {
+    return this.request(`/api/cdn/deploy/lock?siteId=${siteId}`);
+  }
+  async forceReleaseLock(siteId) {
+    return this.request("/api/cdn/deploy/lock", {
+      method: "DELETE",
+      body: JSON.stringify({ siteId })
+    });
+  }
 };
 function createApiClient(config) {
   return new KodeApiClient(config);
@@ -1923,11 +2036,16 @@ async function pushCommand(options) {
     let skipped = 0;
     spinner.stop();
     console.log();
+    let emptyScriptCount = 0;
     for (const file of filesToPush) {
       const filePath = join5(scriptsDir, file);
       const content = readFileSync4(filePath, "utf-8");
       const slug = basename(file, extname(file));
       const type = extname(file) === ".js" ? "javascript" : "css";
+      if (content.trim().length === 0) {
+        console.log(chalk3.yellow(`  \u26A0 ${file}`) + chalk3.dim(" (empty file)"));
+        emptyScriptCount++;
+      }
       const remoteScript = remoteScripts.find((s) => s.slug === slug);
       const localMeta = metadata.find((m) => m.slug === slug);
       if (remoteScript) {
@@ -1974,6 +2092,11 @@ async function pushCommand(options) {
     if (skipped > 0) {
       console.log(chalk3.dim(`   Skipped ${skipped} unchanged script(s)`));
     }
+    if (emptyScriptCount > 0) {
+      console.log(chalk3.yellow(`
+\u26A0\uFE0F  ${emptyScriptCount} empty script(s) pushed`));
+      console.log(chalk3.dim("   Empty scripts will have no effect when deployed."));
+    }
     const updatedScripts = await client.listScripts(config.siteId);
     const updatedMetadata = updatedScripts.map((s) => ({
       id: s.id,
@@ -2042,15 +2165,59 @@ async function watchCommand(options) {
   }
   const pendingChanges = /* @__PURE__ */ new Map();
   const DEBOUNCE_MS = 500;
-  const handleChange = async (filePath) => {
+  const failedSyncs = /* @__PURE__ */ new Map();
+  let successCount = 0;
+  let errorCount = 0;
+  const RETRY_DELAY_MS = 3e4;
+  const MAX_RETRY_ATTEMPTS = 3;
+  const printStatus = () => {
+    if (failedSyncs.size === 0 && successCount === 0) return;
+    const statusParts = [];
+    if (successCount > 0) {
+      statusParts.push(chalk4.green(`${successCount} synced`));
+    }
+    if (failedSyncs.size > 0) {
+      statusParts.push(chalk4.red(`${failedSyncs.size} pending errors`));
+    }
+    console.log(chalk4.dim(`
+\u2500\u2500\u2500 Status: ${statusParts.join(", ")} \u2500\u2500\u2500
+`));
+  };
+  const retryFailedSyncs = async () => {
+    for (const [filePath, failed] of failedSyncs.entries()) {
+      if (!existsSync6(filePath)) {
+        failedSyncs.delete(filePath);
+        continue;
+      }
+      if (failed.attempts >= MAX_RETRY_ATTEMPTS) {
+        continue;
+      }
+      const timeSinceLastAttempt = Date.now() - failed.lastAttempt.getTime();
+      if (timeSinceLastAttempt < RETRY_DELAY_MS) {
+        continue;
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("nb-NO");
+      console.log(
+        chalk4.dim(`[${timestamp}] `) + chalk4.yellow(`\u21BB Retrying ${failed.fileName}...`) + chalk4.dim(` (attempt ${failed.attempts + 1}/${MAX_RETRY_ATTEMPTS})`)
+      );
+      await handleChange(
+        filePath,
+        true
+        /* isRetry */
+      );
+    }
+  };
+  const retryInterval = setInterval(retryFailedSyncs, RETRY_DELAY_MS);
+  const handleChange = async (filePath, isRetry = false) => {
     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));
+    if (!isRetry) {
+      if (pendingChanges.has(filePath)) {
+        clearTimeout(pendingChanges.get(filePath));
+      }
     }
-    const timeout = setTimeout(async () => {
-      pendingChanges.delete(filePath);
+    const syncFile = async () => {
       try {
         const content = readFileSync5(filePath, "utf-8");
         const remoteScript = remoteScripts.find((s) => s.slug === slug);
@@ -2058,6 +2225,9 @@ async function watchCommand(options) {
         const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("nb-NO");
         if (remoteScript) {
           if (remoteScript.content === content) {
+            if (failedSyncs.has(filePath)) {
+              failedSyncs.delete(filePath);
+            }
             return;
           }
           await client.updateScript(remoteScript.id, {
@@ -2066,9 +2236,24 @@ async function watchCommand(options) {
           });
           remoteScript.content = content;
           remoteScript.current_version++;
-          console.log(
-            chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.dim(` \u2192 v${remoteScript.current_version}`)
-          );
+          if (failedSyncs.has(filePath)) {
+            const wasRetry = failedSyncs.get(filePath).attempts > 0;
+            failedSyncs.delete(filePath);
+            if (wasRetry) {
+              console.log(
+                chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.dim(` \u2192 v${remoteScript.current_version}`) + chalk4.cyan(" (recovered)")
+              );
+            } else {
+              console.log(
+                chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.dim(` \u2192 v${remoteScript.current_version}`)
+              );
+            }
+          } else {
+            console.log(
+              chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.dim(` \u2192 v${remoteScript.current_version}`)
+            );
+          }
+          successCount++;
           if (options.deploy) {
             try {
               await client.deploy(config.siteId, config.environment || "staging");
@@ -2077,7 +2262,7 @@ async function watchCommand(options) {
               );
             } catch (deployError) {
               console.log(
-                chalk4.dim(`[${timestamp}] `) + chalk4.red(`  \u21B3 Deploy failed`)
+                chalk4.dim(`[${timestamp}] `) + chalk4.red(`  \u21B3 Deploy failed: ${deployError.message || "Unknown error"}`)
               );
             }
           }
@@ -2090,9 +2275,17 @@ async function watchCommand(options) {
             content
           });
           remoteScripts.push(newScript);
-          console.log(
-            chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.cyan(" (created)")
-          );
+          if (failedSyncs.has(filePath)) {
+            failedSyncs.delete(filePath);
+            console.log(
+              chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.cyan(" (created, recovered)")
+            );
+          } else {
+            console.log(
+              chalk4.dim(`[${timestamp}] `) + chalk4.green(`\u2713 ${fileName}`) + chalk4.cyan(" (created)")
+            );
+          }
+          successCount++;
           const updatedMetadata = remoteScripts.map((s) => ({
             id: s.id,
             slug: s.slug,
@@ -2107,10 +2300,36 @@ async function watchCommand(options) {
         }
       } 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"}`)
-        );
+        const errorMessage = error.message || "Unknown error";
+        const existing = failedSyncs.get(filePath);
+        const attempts = existing ? existing.attempts + 1 : 1;
+        failedSyncs.set(filePath, {
+          filePath,
+          fileName,
+          error: errorMessage,
+          attempts,
+          lastAttempt: /* @__PURE__ */ new Date()
+        });
+        errorCount++;
+        if (attempts >= MAX_RETRY_ATTEMPTS) {
+          console.log(
+            chalk4.dim(`[${timestamp}] `) + chalk4.red(`\u2717 ${fileName}`) + chalk4.dim(` - ${errorMessage}`) + chalk4.red(` (gave up after ${MAX_RETRY_ATTEMPTS} attempts)`)
+          );
+        } else {
+          console.log(
+            chalk4.dim(`[${timestamp}] `) + chalk4.red(`\u2717 ${fileName}`) + chalk4.dim(` - ${errorMessage}`) + chalk4.yellow(` (will retry in ${RETRY_DELAY_MS / 1e3}s)`)
+          );
+        }
+        printStatus();
       }
+    };
+    if (isRetry) {
+      await syncFile();
+      return;
+    }
+    const timeout = setTimeout(async () => {
+      pendingChanges.delete(filePath);
+      await syncFile();
     }, DEBOUNCE_MS);
     pendingChanges.set(filePath, timeout);
   };
@@ -2132,7 +2351,21 @@ async function watchCommand(options) {
     );
   });
   process.on("SIGINT", () => {
+    clearInterval(retryInterval);
     console.log(chalk4.dim("\n\nStopping watch...\n"));
+    if (successCount > 0 || failedSyncs.size > 0) {
+      console.log(chalk4.bold("Session summary:"));
+      if (successCount > 0) {
+        console.log(chalk4.green(`  \u2713 ${successCount} file(s) synced`));
+      }
+      if (failedSyncs.size > 0) {
+        console.log(chalk4.red(`  \u2717 ${failedSyncs.size} file(s) failed:`));
+        for (const failed of failedSyncs.values()) {
+          console.log(chalk4.dim(`    - ${failed.fileName}: ${failed.error}`));
+        }
+      }
+      console.log();
+    }
     watcher.close();
     process.exit(0);
   });
@@ -2155,10 +2388,10 @@ async function deployCommand(environment, options) {
   }
   const shouldPromote = options?.promote || environment === "production";
   if (shouldPromote) {
-    const client = createApiClient(config);
+    const client2 = createApiClient(config);
     const spinner2 = ora4("Sjekker produksjonsstatus...").start();
     try {
-      const status = await client.getDeploymentStatus(config.siteId);
+      const status = await client2.getDeploymentStatus(config.siteId);
       if (!status.productionEnabled) {
         spinner2.fail("Produksjon er ikke aktivert");
         console.log();
@@ -2169,7 +2402,7 @@ async function deployCommand(environment, options) {
         return;
       }
       spinner2.text = "Promoterer staging til produksjon...";
-      const deployment = await client.promoteToProduction(config.siteId);
+      const deployment = await client2.promoteToProduction(config.siteId);
       spinner2.succeed("Promoted to production");
       console.log();
       console.log(chalk5.dim("Deployment details:"));
@@ -2186,9 +2419,62 @@ async function deployCommand(environment, options) {
     }
     return;
   }
+  const client = createApiClient(config);
+  if (options?.force) {
+    const forceSpinner = ora4("Sjekker l\xE5s...").start();
+    try {
+      const lockStatus = await client.getLockStatus(config.siteId);
+      if (lockStatus.isLocked) {
+        if (lockStatus.isStale) {
+          forceSpinner.text = "Frigj\xF8r gammel l\xE5s...";
+        } else {
+          forceSpinner.warn("Aktiv l\xE5s funnet");
+          console.log(chalk5.yellow("\n\u26A0\uFE0F  Deployment er l\xE5st av en annen prosess."));
+          console.log(chalk5.dim(`   L\xE5st siden: ${lockStatus.acquiredAt ? new Date(lockStatus.acquiredAt).toLocaleString("nb-NO") : "ukjent"}`));
+          console.log(chalk5.dim(`   L\xE5s-ID: ${lockStatus.lockHolder}`));
+          console.log();
+          console.log(chalk5.yellow("   Hvis du er sikker p\xE5 at l\xE5sen er foreldet, kj\xF8r med --force igjen."));
+          console.log(chalk5.dim("   L\xE5sen vil utl\xF8pe automatisk etter 10 minutter."));
+          return;
+        }
+        const result = await client.forceReleaseLock(config.siteId);
+        if (result.wasLocked) {
+          forceSpinner.succeed("L\xE5s frigjort");
+          console.log(chalk5.dim(`   Tidligere l\xE5s fra: ${result.acquiredAt ? new Date(result.acquiredAt).toLocaleString("nb-NO") : "ukjent"}`));
+          console.log();
+        } else {
+          forceSpinner.info("Ingen l\xE5s \xE5 frigj\xF8re");
+        }
+      } else {
+        forceSpinner.info("Ingen l\xE5s aktiv");
+      }
+    } catch (error) {
+      forceSpinner.fail("Kunne ikke sjekke/frigj\xF8re l\xE5s");
+      console.error(chalk5.red("\nError:"), error.message || error);
+      return;
+    }
+  }
+  const preCheckSpinner = ora4("Sjekker scripts...").start();
+  try {
+    const scripts = await client.listScripts(config.siteId);
+    const emptyScripts = scripts.filter(
+      (s) => s.is_active && (!s.content || s.content.trim().length === 0)
+    );
+    if (emptyScripts.length > 0) {
+      preCheckSpinner.warn(`${emptyScripts.length} tomme script(s) funnet`);
+      console.log(chalk5.yellow("\n\u26A0\uFE0F  F\xF8lgende scripts er tomme:"));
+      emptyScripts.forEach((s) => {
+        console.log(chalk5.dim(`   - ${s.slug}.${s.type === "javascript" ? "js" : "css"}`));
+      });
+      console.log(chalk5.dim("   Tomme scripts har ingen effekt n\xE5r de er deployet.\n"));
+    } else {
+      preCheckSpinner.succeed(`${scripts.filter((s) => s.is_active).length} script(s) klare`);
+    }
+  } catch {
+    preCheckSpinner.info("Kunne ikke sjekke scripts");
+  }
   const spinner = ora4("Deploying to staging...").start();
   try {
-    const client = createApiClient(config);
     const deployment = await client.deploy(config.siteId, "staging");
     spinner.succeed("Deployed to staging");
     console.log();