@curenorway/kode-cli 1.18.0 → 2.0.0

package/dist/chunk-TLLGB46I.js

@@ -0,0 +1,418 @@
+// 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://app.cure.no"
+  }
+});
+var PROJECT_CONFIG_DIR = ".cure-kode";
+var PROJECT_CONFIG_FILE = "config.json";
+var DEFAULT_SCRIPTS_DIR = ".cure-kode-scripts";
+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 || DEFAULT_SCRIPTS_DIR);
+}
+
+// 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) {
+    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}`;
+    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);
+        }
+      }
+    );
+  }
+  // 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`);
+  }
+  async getPage(pageId) {
+    return this.request(`/api/cdn/pages/${pageId}`);
+  }
+  async createPage(siteId, data) {
+    return this.request(`/api/cdn/sites/${siteId}/pages`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updatePage(pageId, data) {
+    return this.request(`/api/cdn/pages/${pageId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deletePage(pageId) {
+    return this.request(`/api/cdn/pages/${pageId}`, {
+      method: "DELETE"
+    });
+  }
+  async assignScriptToPage(pageId, scriptId, loadOrderOverride) {
+    return this.request(`/api/cdn/pages/${pageId}/scripts`, {
+      method: "POST",
+      body: JSON.stringify({ scriptId, loadOrderOverride })
+    });
+  }
+  async removeScriptFromPage(pageId, scriptId) {
+    return this.request(`/api/cdn/pages/${pageId}/scripts/${scriptId}`, {
+      method: "DELETE"
+    });
+  }
+  async getPageScripts(pageId) {
+    return this.request(`/api/cdn/pages/${pageId}/scripts`);
+  }
+  // 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`);
+  }
+  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`, {
+      method: "POST",
+      body: JSON.stringify({
+        enabled,
+        productionDomain
+      })
+    });
+  }
+  // HTML Fetch
+  async fetchHtml(url) {
+    return this.request("/api/cdn/fetch-html", {
+      method: "POST",
+      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 })
+    });
+  }
+  // Library (global snippets)
+  async listLibrary(search) {
+    const params = new URLSearchParams();
+    if (search) params.set("search", search);
+    const qs = params.toString();
+    return this.request(`/api/cdn/library${qs ? `?${qs}` : ""}`);
+  }
+  async getLibrarySnippet(slugOrId) {
+    return this.request(`/api/cdn/library/${encodeURIComponent(slugOrId)}`);
+  }
+  async createLibrarySnippet(data) {
+    return this.request("/api/cdn/library", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async recordLibraryUsage(snippetId) {
+    await this.request(`/api/cdn/library/${snippetId}`);
+  }
+  async updateLibrarySnippet(slugOrId, data) {
+    return this.request(`/api/cdn/library/${encodeURIComponent(slugOrId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async listLibraryFolders() {
+    return this.request("/api/cdn/library/folders");
+  }
+  async createLibraryFolder(data) {
+    return this.request("/api/cdn/library/folders", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async listLibraryTrash() {
+    return this.request("/api/cdn/library/trash");
+  }
+  async restoreLibrarySnippet(snippetId) {
+    await this.request("/api/cdn/library/trash", {
+      method: "POST",
+      body: JSON.stringify({ action: "restore", snippetId })
+    });
+  }
+  async permanentDeleteLibrarySnippet(snippetId) {
+    await this.request(`/api/cdn/library/trash?snippetId=${encodeURIComponent(snippetId)}`, {
+      method: "DELETE"
+    });
+  }
+  // Webflow Custom Code injection
+  async getWebflowCustomCodeStatus(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/webflow/custom-code`);
+  }
+  async injectWebflowCustomCode(siteId, location = "header") {
+    return this.request(`/api/cdn/sites/${siteId}/webflow/custom-code`, {
+      method: "POST",
+      body: JSON.stringify({ location })
+    });
+  }
+  async removeWebflowCustomCode(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/webflow/custom-code`, {
+      method: "DELETE"
+    });
+  }
+  async getCmsTypes(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/cms-types`);
+  }
+  async getProjectFiles(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/files`);
+  }
+  async updateProjectFiles(siteId, files) {
+    return this.request(`/api/cdn/sites/${siteId}/files`, {
+      method: "PUT",
+      body: JSON.stringify({ files })
+    });
+  }
+};
+function createApiClient(config) {
+  return new KodeApiClient(config);
+}
+
+export {
+  DEFAULT_SCRIPTS_DIR,
+  findProjectRoot,
+  getProjectConfig,
+  saveProjectConfig,
+  getApiUrl,
+  getApiKey,
+  setGlobalConfig,
+  getScriptsDir,
+  KodeApiError,
+  KodeApiClient,
+  createApiClient
+};