@stacksjs/stx 0.2.94 → 0.2.96

package/dist/deploy/config-generators.js

@@ -1,2 +1,214 @@
-// @bun
-import{Mn as a,Nn as b,On as c,Pn as d,Qn as e,Rn as f}from"../chunk-eh8hact1.js";import"../chunk-3jm3snz8.js";export{d as writeNetlifyConfig,f as readNetlifyConfig,e as hasNetlifyConfig,a as generateNetlifyToml,b as detectProjectConfig,c as createDefaultNetlifyConfig};
+import fs from "node:fs";
+import path from "node:path";
+export function generateNetlifyToml(config) {
+  const lines = [];
+  lines.push("[build]");
+  lines.push(`  command = "${escapeTomlString(config.build.command)}"`);
+  lines.push(`  publish = "${escapeTomlString(config.build.publish)}"`);
+  if (config.build.functions)
+    lines.push(`  functions = "${escapeTomlString(config.build.functions)}"`);
+  if (config.build.edge_functions)
+    lines.push(`  edge_functions = "${escapeTomlString(config.build.edge_functions)}"`);
+  if (config.build.environment && Object.keys(config.build.environment).length > 0) {
+    lines.push("");
+    lines.push("[build.environment]");
+    for (const [key, value] of Object.entries(config.build.environment))
+      lines.push(`  ${key} = "${escapeTomlString(value)}"`);
+  }
+  if (config.functions) {
+    lines.push("");
+    lines.push("[functions]");
+    if (config.functions.directory)
+      lines.push(`  directory = "${escapeTomlString(config.functions.directory)}"`);
+    if (config.functions.node_bundler)
+      lines.push(`  node_bundler = "${config.functions.node_bundler}"`);
+    if (config.functions.external_node_modules && config.functions.external_node_modules.length > 0)
+      lines.push(`  external_node_modules = [${config.functions.external_node_modules.map((m) => `"${m}"`).join(", ")}]`);
+  }
+  if (config.edge_functions && config.edge_functions.length > 0) {
+    lines.push("");
+    for (const ef of config.edge_functions) {
+      lines.push("[[edge_functions]]");
+      lines.push(`  function = "${escapeTomlString(ef.function)}"`);
+      lines.push(`  path = "${escapeTomlString(ef.path)}"`);
+    }
+  }
+  if (config.redirects && config.redirects.length > 0) {
+    lines.push("");
+    for (const redirect of config.redirects) {
+      lines.push("[[redirects]]");
+      lines.push(`  from = "${escapeTomlString(redirect.from)}"`);
+      lines.push(`  to = "${escapeTomlString(redirect.to)}"`);
+      if (redirect.status !== void 0)
+        lines.push(`  status = ${redirect.status}`);
+      if (redirect.force !== void 0)
+        lines.push(`  force = ${redirect.force}`);
+      if (redirect.conditions && Object.keys(redirect.conditions).length > 0) {
+        lines.push("  [redirects.conditions]");
+        for (const [key, value] of Object.entries(redirect.conditions))
+          lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+      }
+    }
+  }
+  if (config.headers && config.headers.length > 0) {
+    lines.push("");
+    for (const header of config.headers) {
+      lines.push("[[headers]]");
+      lines.push(`  for = "${escapeTomlString(header.for)}"`);
+      lines.push("  [headers.values]");
+      for (const [key, value] of Object.entries(header.values))
+        lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+    }
+  }
+  if (config.plugins && config.plugins.length > 0) {
+    lines.push("");
+    for (const plugin of config.plugins) {
+      lines.push("[[plugins]]");
+      lines.push(`  package = "${escapeTomlString(plugin.package)}"`);
+      if (plugin.inputs && Object.keys(plugin.inputs).length > 0) {
+        lines.push("  [plugins.inputs]");
+        for (const [key, value] of Object.entries(plugin.inputs))
+          if (typeof value === "string")
+            lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+          else if (typeof value === "boolean" || typeof value === "number")
+            lines.push(`    ${key} = ${value}`);
+      }
+    }
+  }
+  if (config.context && Object.keys(config.context).length > 0)
+    for (const [contextName, contextConfig] of Object.entries(config.context)) {
+      lines.push("");
+      lines.push(`[context.${contextName}]`);
+      if (contextConfig.command)
+        lines.push(`  command = "${escapeTomlString(contextConfig.command)}"`);
+      if (contextConfig.publish)
+        lines.push(`  publish = "${escapeTomlString(contextConfig.publish)}"`);
+      if (contextConfig.environment && Object.keys(contextConfig.environment).length > 0) {
+        lines.push(`  [context.${contextName}.environment]`);
+        for (const [key, value] of Object.entries(contextConfig.environment))
+          lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+      }
+    }
+  return lines.join(`
+`) + `
+`;
+}
+function escapeTomlString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+export async function detectProjectConfig(directory) {
+  const config = {
+    framework: "stx",
+    buildCommand: "bun run build",
+    outputDir: "dist"
+  }, packageJsonPath = path.join(directory, "package.json");
+  if (await Bun.file(packageJsonPath).exists())
+    try {
+      const packageJson = JSON.parse(await Bun.file(packageJsonPath).text());
+      if (packageJson.scripts?.build)
+        config.buildCommand = "bun run build";
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if (deps["@stacksjs/stx"] || deps.stx)
+        config.framework = "stx";
+    } catch {}
+  const stxConfigPath = path.join(directory, "stx.config.ts"), stxConfigAltPath = path.join(directory, ".config", "stx.config.ts");
+  if (await Bun.file(stxConfigPath).exists() || await Bun.file(stxConfigAltPath).exists())
+    config.framework = "stx";
+  const possibleOutputDirs = ["dist", "build", "out", "public", ".output"];
+  for (const dir of possibleOutputDirs) {
+    const fullPath = path.join(directory, dir);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+      config.outputDir = dir;
+      break;
+    }
+  }
+  const possibleFunctionsDirs = ["functions", "netlify/functions", "api"];
+  for (const dir of possibleFunctionsDirs) {
+    const fullPath = path.join(directory, dir);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+      config.functionsDir = dir;
+      break;
+    }
+  }
+  const edgeFunctionsDir = path.join(directory, "netlify", "edge-functions");
+  if (fs.existsSync(edgeFunctionsDir))
+    config.edgeFunctionsDir = "netlify/edge-functions";
+  const distPath = path.join(directory, config.outputDir || "dist");
+  if (fs.existsSync(distPath)) {
+    const hasIndexHtml = fs.existsSync(path.join(distPath, "index.html")), htmlFiles = fs.readdirSync(distPath).filter((f) => f.endsWith(".html"));
+    config.isSPA = hasIndexHtml && htmlFiles.length === 1;
+  }
+  return config;
+}
+export function createDefaultNetlifyConfig(projectConfig = {}) {
+  const config = {
+    build: {
+      command: projectConfig.buildCommand || "bun run build",
+      publish: projectConfig.outputDir || "dist"
+    }
+  };
+  if (projectConfig.functionsDir) {
+    config.build.functions = projectConfig.functionsDir;
+    config.functions = {
+      directory: projectConfig.functionsDir,
+      node_bundler: "esbuild"
+    };
+  }
+  if (projectConfig.edgeFunctionsDir)
+    config.build.edge_functions = projectConfig.edgeFunctionsDir;
+  config.headers = [
+    {
+      for: "/*",
+      values: {
+        "X-Frame-Options": "DENY",
+        "X-Content-Type-Options": "nosniff",
+        "X-XSS-Protection": "1; mode=block",
+        "Referrer-Policy": "strict-origin-when-cross-origin"
+      }
+    },
+    {
+      for: "/assets/*",
+      values: {
+        "Cache-Control": "public, max-age=31536000, immutable"
+      }
+    }
+  ];
+  if (projectConfig.isSPA !== !1)
+    config.redirects = [
+      {
+        from: "/*",
+        to: "/index.html",
+        status: 200
+      }
+    ];
+  config.context = {
+    production: {
+      environment: {
+        NODE_ENV: "production"
+      }
+    },
+    "deploy-preview": {
+      environment: {
+        NODE_ENV: "development"
+      }
+    }
+  };
+  return config;
+}
+export async function writeNetlifyConfig(directory, config) {
+  const projectConfig = await detectProjectConfig(directory), netlifyConfig = config || createDefaultNetlifyConfig(projectConfig), content = generateNetlifyToml(netlifyConfig), filePath = path.join(directory, "netlify.toml");
+  await Bun.write(filePath, content);
+  return filePath;
+}
+export function hasNetlifyConfig(directory) {
+  return fs.existsSync(path.join(directory, "netlify.toml"));
+}
+export async function readNetlifyConfig(directory) {
+  const filePath = path.join(directory, "netlify.toml");
+  if (!await Bun.file(filePath).exists())
+    return null;
+  return Bun.file(filePath).text();
+}

package/dist/deploy/index.js

@@ -1,2 +1,203 @@
-// @bun
-import{Jn as m,Kn as n,Ln as o}from"../chunk-vpe6napb.js";import{Mn as h,Nn as i,On as j,Pn as k,Qn as l}from"../chunk-eh8hact1.js";import{Sn as a,Tn as b,Un as c,Vn as d,Wn as e,Xn as f,Yn as g}from"../chunk-xhkjhxsp.js";import"../chunk-3jm3snz8.js";export{k as writeNetlifyConfig,n as initNetlify,l as hasNetlifyConfig,g as getTotalSize,h as generateNetlifyToml,f as formatSize,e as filterRequiredFiles,i as detectProjectConfig,m as deploy,a as createNetlifyClient,d as createFileManifest,j as createDefaultNetlifyConfig,c as collectDeployFiles,b as calculateSha1,o as DeployError};
+import fs from "node:fs";
+import path from "node:path";
+import {
+  createNetlifyClient,
+  collectDeployFiles,
+  createFileManifest,
+  filterRequiredFiles,
+  formatSize,
+  getTotalSize
+} from "./netlify.js";
+import {
+  detectProjectConfig,
+  createDefaultNetlifyConfig,
+  generateNetlifyToml,
+  writeNetlifyConfig,
+  hasNetlifyConfig
+} from "./config-generators.js";
+export async function deploy(config = {}) {
+  const startTime = Date.now(), logs = [], cwd = config.cwd || process.cwd(), log = (msg) => {
+    logs.push(msg);
+  }, progress = (status) => {
+    if (config.onProgress)
+      config.onProgress(status);
+  }, directory = path.resolve(cwd, config.directory || "dist"), token = config.token || process.env.NETLIFY_AUTH_TOKEN, siteId = config.siteId || process.env.NETLIFY_SITE_ID;
+  if (!token)
+    throw new DeployError(`No Netlify auth token found.
+
+To deploy to Netlify:
+1. Create account at https://app.netlify.com
+2. Get token at https://app.netlify.com/user/applications#personal-access-tokens
+3. Set NETLIFY_AUTH_TOKEN environment variable
+
+   export NETLIFY_AUTH_TOKEN=your_token_here`, "NO_TOKEN");
+  if (!siteId)
+    throw new DeployError(`No Netlify site ID found.
+
+Either:
+1. Set NETLIFY_SITE_ID environment variable
+2. Pass --site-id option
+3. Run \`stx deploy --init\` to set up
+
+Find your site ID at: https://app.netlify.com/sites/YOUR_SITE/settings/general`, "NO_SITE_ID");
+  if (!fs.existsSync(directory))
+    throw new DeployError(`Build directory not found: ${directory}
+
+Run \`stx build\` first or specify a different directory with --directory`, "NO_BUILD_DIR");
+  if (!(fs.readdirSync(directory).length > 0))
+    throw new DeployError(`Build directory is empty: ${directory}
+
+Run \`stx build\` to generate files`, "EMPTY_BUILD_DIR");
+  if (config.dryRun) {
+    progress({ stage: "collect", message: "Collecting files..." });
+    const files = await collectDeployFiles(directory), totalSize = getTotalSize(files);
+    log(`Would deploy ${files.length} files (${formatSize(totalSize)})`);
+    log(`From: ${directory}`);
+    log(`To: Site ${siteId}`);
+    log(`Mode: ${config.production ? "production" : "draft"}`);
+    return {
+      success: !0,
+      url: `https://${siteId}.netlify.app (dry-run)`,
+      deployId: "dry-run",
+      logs,
+      duration: Date.now() - startTime,
+      filesUploaded: files.length,
+      totalSize
+    };
+  }
+  const client = createNetlifyClient({ token });
+  progress({ stage: "collect", message: "Verifying site..." });
+  try {
+    const site = await client.getSite(siteId);
+    log(`Deploying to: ${site.name} (${site.url})`);
+  } catch (error) {
+    if (error.status === 404)
+      throw new DeployError(`Site not found: ${siteId}
+
+Check your site ID or create a new site at https://app.netlify.com`, "SITE_NOT_FOUND");
+    throw error;
+  }
+  progress({ stage: "collect", message: "Collecting files..." });
+  const files = await collectDeployFiles(directory), totalSize = getTotalSize(files);
+  log(`Found ${files.length} files (${formatSize(totalSize)})`);
+  if (files.length === 0)
+    throw new DeployError(`No files found in ${directory}`, "NO_FILES");
+  const manifest = createFileManifest(files);
+  progress({ stage: "upload", message: "Creating deploy...", percent: 0 });
+  const deployResponse = await client.createDeploy(siteId, {
+    title: config.message || "Deploy from stx CLI",
+    draft: !config.production,
+    files: manifest
+  });
+  log(`Created deploy: ${deployResponse.id}`);
+  const requiredFiles = filterRequiredFiles(files, deployResponse.required || []);
+  log(`Uploading ${requiredFiles.length} files...`);
+  if (requiredFiles.length > 0) {
+    let uploaded = 0;
+    const uploadSize = getTotalSize(requiredFiles);
+    for (const file of requiredFiles) {
+      await client.uploadFile(deployResponse.id, file.path, file.content);
+      uploaded++;
+      const percent = Math.round(uploaded / requiredFiles.length * 100);
+      progress({
+        stage: "upload",
+        message: `Uploading: ${file.path}`,
+        percent,
+        details: { uploaded, total: requiredFiles.length }
+      });
+    }
+    log(`Uploaded ${formatSize(uploadSize)}`);
+  } else
+    log("All files already on CDN (no upload needed)");
+  progress({ stage: "process", message: "Processing deploy..." });
+  const finalDeploy = await client.waitForDeploy(deployResponse.id, {
+    onProgress: (deploy) => {
+      progress({
+        stage: "process",
+        message: `Status: ${deploy.state}`,
+        details: deploy
+      });
+    }
+  }), duration = Date.now() - startTime;
+  progress({ stage: "done", message: "Deploy complete!" });
+  log(`Deploy complete in ${(duration / 1000).toFixed(1)}s`);
+  log(`URL: ${finalDeploy.deploy_ssl_url}`);
+  if (config.production)
+    log(`Site: ${finalDeploy.ssl_url}`);
+  if (config.open) {
+    const url = config.production ? finalDeploy.ssl_url : finalDeploy.deploy_ssl_url;
+    openUrl(url);
+  }
+  return {
+    success: !0,
+    url: finalDeploy.deploy_ssl_url,
+    siteUrl: config.production ? finalDeploy.ssl_url : void 0,
+    deployId: finalDeploy.id,
+    logs,
+    duration,
+    filesUploaded: requiredFiles.length,
+    totalSize: getTotalSize(requiredFiles)
+  };
+}
+export async function initNetlify(config = {}) {
+  const directory = config.directory || process.cwd();
+  let configPath;
+  if (hasNetlifyConfig(directory))
+    configPath = path.join(directory, "netlify.toml");
+  else {
+    const projectConfig = await detectProjectConfig(directory);
+    configPath = await writeNetlifyConfig(directory, createDefaultNetlifyConfig(projectConfig));
+  }
+  if (config.siteId) {
+    const envPath = path.join(directory, ".env.local");
+    let envContent = "";
+    if (await Bun.file(envPath).exists()) {
+      envContent = await Bun.file(envPath).text();
+      envContent = envContent.split(`
+`).filter((line) => !line.startsWith("NETLIFY_SITE_ID=")).join(`
+`);
+      if (envContent && !envContent.endsWith(`
+`))
+        envContent += `
+`;
+    }
+    envContent += `NETLIFY_SITE_ID=${config.siteId}
+`;
+    await Bun.write(envPath, envContent);
+  }
+  return {
+    configPath,
+    siteId: config.siteId
+  };
+}
+
+export class DeployError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "DeployError";
+    this.code = code;
+  }
+}
+function openUrl(url) {
+  const platform = process.platform, command = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  Bun.spawn([command, url], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+}
+export {
+  createNetlifyClient,
+  collectDeployFiles,
+  createFileManifest,
+  filterRequiredFiles,
+  formatSize,
+  getTotalSize,
+  calculateSha1
+} from "./netlify.js";
+export {
+  generateNetlifyToml,
+  detectProjectConfig,
+  createDefaultNetlifyConfig,
+  writeNetlifyConfig,
+  hasNetlifyConfig
+} from "./config-generators.js";

package/dist/deploy/netlify.js

@@ -1,2 +1,167 @@
-// @bun
-import{Sn as a,Tn as b,Un as c,Vn as d,Wn as e,Xn as f,Yn as g}from"../chunk-xhkjhxsp.js";import"../chunk-3jm3snz8.js";export{g as getTotalSize,f as formatSize,e as filterRequiredFiles,a as createNetlifyClient,d as createFileManifest,c as collectDeployFiles,b as calculateSha1};
+const NETLIFY_API_BASE = "https://api.netlify.com/api/v1";
+export function createNetlifyClient(config) {
+  const { token, baseUrl = NETLIFY_API_BASE } = config;
+  async function request(method, path, options = {}) {
+    const url = `${baseUrl}${path}`, headers = {
+      Authorization: `Bearer ${token}`,
+      "User-Agent": "stx-deploy/1.0"
+    };
+    let body;
+    if (options.rawBody) {
+      headers["Content-Type"] = options.contentType || "application/octet-stream";
+      body = options.rawBody;
+    } else if (options.body) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body
+    });
+    if (!response.ok) {
+      const error = Error(`Netlify API error: ${response.status} ${response.statusText}`);
+      error.status = response.status;
+      try {
+        const data = await response.json();
+        error.message = data.message || error.message;
+        error.code = data.code;
+        error.details = data;
+      } catch {}
+      throw error;
+    }
+    const text = await response.text();
+    if (!text)
+      return {};
+    return JSON.parse(text);
+  }
+  return {
+    async getSite(siteId) {
+      return request("GET", `/sites/${siteId}`);
+    },
+    async listSites() {
+      return request("GET", "/sites");
+    },
+    async createSite(name) {
+      const body = {};
+      if (name)
+        body.name = name;
+      return request("POST", "/sites", { body });
+    },
+    async createDeploy(siteId, options) {
+      const body = {
+        files: options.files,
+        draft: options.draft ?? !0,
+        async: options.async ?? !0
+      };
+      if (options.title)
+        body.title = options.title;
+      if (options.branch)
+        body.branch = options.branch;
+      if (options.functions)
+        body.functions = options.functions;
+      return request("POST", `/sites/${siteId}/deploys`, { body });
+    },
+    async uploadFile(deployId, path, content) {
+      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+      await request("PUT", `/deploys/${deployId}/files/${normalizedPath}`, {
+        rawBody: content,
+        contentType: "application/octet-stream"
+      });
+    },
+    async uploadFiles(deployId, files) {
+      const CONCURRENCY = 5, queue = [...files], uploadNext = async () => {
+        while (queue.length > 0) {
+          const file = queue.shift();
+          if (file)
+            await this.uploadFile(deployId, file.path, file.content);
+        }
+      }, workers = Array.from({ length: Math.min(CONCURRENCY, files.length) }, () => uploadNext());
+      await Promise.all(workers);
+    },
+    async getDeploy(deployId) {
+      return request("GET", `/deploys/${deployId}`);
+    },
+    async waitForDeploy(deployId, options = {}) {
+      const {
+        timeout = 300000,
+        pollInterval = 2000,
+        onProgress
+      } = options, startTime = Date.now();
+      while (!0) {
+        const deploy = await this.getDeploy(deployId);
+        if (onProgress)
+          onProgress(deploy);
+        if (deploy.state === "ready")
+          return deploy;
+        if (deploy.state === "error") {
+          const error = Error(`Deploy failed: ${deploy.error_message || "Unknown error"}`);
+          error.status = 500;
+          error.details = deploy;
+          throw error;
+        }
+        if (Date.now() - startTime > timeout) {
+          const error = Error(`Deploy timed out after ${timeout}ms`);
+          error.status = 408;
+          error.details = deploy;
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+    },
+    async lockDeploy(deployId) {
+      return request("POST", `/deploys/${deployId}/lock`);
+    },
+    async unlockDeploy(deployId) {
+      return request("POST", `/deploys/${deployId}/unlock`);
+    }
+  };
+}
+export async function calculateSha1(content) {
+  const hashBuffer = await crypto.subtle.digest("SHA-1", content);
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export async function collectDeployFiles(directory, options = {}) {
+  const { ignore = ["node_modules", ".git", ".env*", "*.map"] } = options, files = [], glob = new Bun.Glob("**/*");
+  for await (const relativePath of glob.scan({
+    cwd: directory,
+    onlyFiles: !0,
+    dot: !1
+  })) {
+    if (ignore.some((pattern) => {
+      if (pattern.includes("*"))
+        return new RegExp(`^${pattern.replace(/\*/g, ".*")}$`).test(relativePath);
+      return relativePath.includes(pattern);
+    }))
+      continue;
+    const fullPath = `${directory}/${relativePath}`, content = await Bun.file(fullPath).arrayBuffer(), sha1 = await calculateSha1(content);
+    files.push({
+      path: relativePath,
+      content: new Uint8Array(content),
+      sha1
+    });
+  }
+  return files;
+}
+export function createFileManifest(files) {
+  const manifest = {};
+  for (const file of files)
+    manifest[`/${file.path}`] = file.sha1;
+  return manifest;
+}
+export function filterRequiredFiles(files, required) {
+  const requiredSet = new Set(required.map((p) => p.startsWith("/") ? p.slice(1) : p));
+  return files.filter((f) => requiredSet.has(f.path));
+}
+export function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1073741824)
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+  return `${(bytes / 1073741824).toFixed(1)} GB`;
+}
+export function getTotalSize(files) {
+  return files.reduce((sum, f) => sum + f.content.byteLength, 0);
+}