flarepilot 0.1.0

package/src/commands/deploy.js

@@ -0,0 +1,289 @@
+import {
+  getConfig,
+  getAppConfig,
+  pushAppConfig,
+  getRegistryCredentials,
+  uploadWorker,
+  buildWorkerMetadata,
+  getWorkersSubdomain,
+  enableWorkerSubdomain,
+  getDONamespaceId,
+  findContainerApp,
+  createContainerApp,
+  modifyContainerApp,
+  createRollout,
+  CF_REGISTRY,
+} from "../lib/cf.js";
+import { dockerBuild, dockerTag, dockerPush, dockerLogin } from "../lib/docker.js";
+import { createInterface } from "readline";
+import { getWorkerBundle, templateHash } from "../lib/bundle.js";
+import { phase, status, success, hint, fatal, fmt, generateAppName } from "../lib/output.js";
+import { readLink, linkApp } from "../lib/link.js";
+
+function buildContainerConfig(appConfig) {
+  var cfg = {
+    image: appConfig.image,
+    observability: { logs: { enabled: appConfig.observability !== false } },
+  };
+
+  // Explicit resources take priority over instance_type
+  if (appConfig.vcpu || appConfig.memory || appConfig.disk) {
+    if (appConfig.vcpu) cfg.vcpu = appConfig.vcpu;
+    if (appConfig.memory) cfg.memory_mib = appConfig.memory;
+    if (appConfig.disk) cfg.disk = { size_mb: appConfig.disk };
+  } else {
+    cfg.instance_type = appConfig.instanceType || "lite";
+  }
+
+  return cfg;
+}
+
+var VALID_HINTS = [
+  "wnam", "enam", "sam", "weur", "eeur", "apac", "oc", "afr", "me",
+];
+
+export async function deploy(nameOrPath, path, options) {
+  var config = getConfig();
+
+  // If first arg looks like a path, shift args and auto-generate name
+  var name;
+  var dockerPath;
+  if (!nameOrPath) {
+    // No args — use linked name or auto-generate
+    name = readLink() || generateAppName();
+    dockerPath = ".";
+  } else if (nameOrPath.startsWith(".") || nameOrPath.startsWith("/") || nameOrPath.startsWith("~")) {
+    // First arg is a path — use linked name or auto-generate
+    name = readLink() || generateAppName();
+    dockerPath = nameOrPath;
+  } else {
+    name = nameOrPath;
+    dockerPath = path || ".";
+  }
+
+  var tag = options.tag || `${Date.now()}`;
+  var localTag = `flarepilot-${name}:${tag}`;
+  var remoteTag = `${CF_REGISTRY}/${config.accountId}/flarepilot-${name}:${tag}`;
+
+  // Load existing config from deployed worker (null on first deploy)
+  var appConfig;
+  try {
+    appConfig = await getAppConfig(config, name);
+  } catch {
+    appConfig = null;
+  }
+
+  var isFirstDeploy = !appConfig;
+
+  if (appConfig) {
+    // Existing app — update image, merge any flags
+    appConfig.image = remoteTag;
+    appConfig.deployedAt = new Date().toISOString();
+
+    if (options.env) {
+      for (var v of options.env) {
+        var eq = v.indexOf("=");
+        if (eq !== -1) appConfig.env[v.substring(0, eq)] = v.substring(eq + 1);
+      }
+    }
+    if (options.regions)
+      appConfig.regions = options.regions.split(",").map((r) => r.trim());
+    if (options.instances) appConfig.instances = options.instances;
+    if (options.port) appConfig.port = options.port;
+    if (options.sleep) appConfig.sleepAfter = options.sleep;
+    if (options.instanceType) appConfig.instanceType = options.instanceType;
+    if (options.vcpu) appConfig.vcpu = options.vcpu;
+    if (options.memory) appConfig.memory = options.memory;
+    if (options.disk) appConfig.disk = options.disk;
+    if (options.observability === false) appConfig.observability = false;
+  } else {
+    // First deploy — build config from flags + defaults
+    var env = {};
+    if (options.env) {
+      for (var v of options.env) {
+        var eq = v.indexOf("=");
+        if (eq !== -1) env[v.substring(0, eq)] = v.substring(eq + 1);
+      }
+    }
+
+    var regions = options.regions
+      ? options.regions.split(",").map((r) => r.trim())
+      : ["enam"];
+
+    for (var r of regions) {
+      if (!VALID_HINTS.includes(r)) {
+        fatal(
+          `Invalid region '${r}'.`,
+          `Valid regions: ${VALID_HINTS.join(", ")}`
+        );
+      }
+    }
+
+    appConfig = {
+      name,
+      regions,
+      instances: options.instances || 2,
+      port: options.port || 8080,
+      sleepAfter: options.sleep || "30s",
+      instanceType: options.instanceType || "lite",
+      vcpu: options.vcpu || undefined,
+      memory: options.memory || undefined,
+      disk: options.disk || undefined,
+      env,
+      domains: [],
+      image: remoteTag,
+      createdAt: new Date().toISOString(),
+      deployedAt: new Date().toISOString(),
+    };
+
+  }
+
+  // --- Summary & confirmation ---
+  var instanceDesc = appConfig.vcpu
+    ? `${appConfig.vcpu} vCPU, ${appConfig.memory || "default"} MiB`
+    : appConfig.instanceType || "lite";
+
+  process.stderr.write(`\n${fmt.bold("Deploy summary")}\n`);
+  process.stderr.write(`${fmt.dim("─".repeat(40))}\n`);
+  process.stderr.write(`  ${fmt.bold("App:")}        ${fmt.app(name)}${isFirstDeploy ? fmt.dim(" (new)") : ""}\n`);
+  process.stderr.write(`  ${fmt.bold("Path:")}       ${dockerPath}\n`);
+  process.stderr.write(`  ${fmt.bold("Image:")}      ${remoteTag}\n`);
+  process.stderr.write(`  ${fmt.bold("Regions:")}    ${appConfig.regions.join(", ")}\n`);
+  process.stderr.write(`  ${fmt.bold("Instances:")}  ${appConfig.instances || 2} per region\n`);
+  process.stderr.write(`  ${fmt.bold("Type:")}       ${instanceDesc}\n`);
+  process.stderr.write(`  ${fmt.bold("Port:")}       ${appConfig.port || 8080}\n`);
+  process.stderr.write(`  ${fmt.bold("Sleep:")}      ${appConfig.sleepAfter || "30s"}\n`);
+  process.stderr.write(`${fmt.dim("─".repeat(40))}\n`);
+
+  if (!options.yes) {
+    var rl = createInterface({ input: process.stdin, output: process.stderr });
+    var answer = await new Promise((resolve) =>
+      rl.question("\nProceed? [Y/n] ", resolve)
+    );
+    rl.close();
+    if (answer && !answer.match(/^y(es)?$/i)) {
+      process.stderr.write("Deploy cancelled.\n");
+      process.exit(0);
+    }
+  }
+
+  // 1. Build Docker image
+  phase("Building image");
+  status(`${localTag} for linux/amd64`);
+  dockerBuild(dockerPath, localTag);
+
+  // 2. Push to Cloudflare Registry
+  phase("Pushing to Cloudflare Registry");
+  status("Authenticating with registry.cloudflare.com...");
+  var creds = await getRegistryCredentials(config);
+  dockerLogin(CF_REGISTRY, creds.username, creds.password);
+  status(`Pushing ${remoteTag}...`);
+  dockerTag(localTag, remoteTag);
+  dockerPush(remoteTag);
+
+  // 3. Deploy worker
+  phase("Deploying worker");
+  var scriptName = `flarepilot-${name}`;
+  var currentHash = templateHash();
+  var needsWorkerUpload = isFirstDeploy || appConfig.templateHash !== currentHash;
+
+  if (needsWorkerUpload) {
+    status("Bundling worker template...");
+    var bundledCode = getWorkerBundle();
+    appConfig.templateHash = currentHash;
+    status(`Uploading ${scriptName}...`);
+    var metadata = buildWorkerMetadata(appConfig, { firstDeploy: isFirstDeploy });
+    await uploadWorker(config, scriptName, bundledCode, metadata);
+  } else {
+    status("Updating app config...");
+    await pushAppConfig(config, name, appConfig);
+  }
+
+  // 4. Deploy container application
+  phase("Deploying container");
+
+  status("Resolving DO namespace...");
+  var namespaceId = await getDONamespaceId(config, scriptName, "AppContainer");
+  if (!namespaceId) {
+    fatal(
+      "Could not find Durable Object namespace for AppContainer.",
+      "The worker upload may have failed. Try again."
+    );
+  }
+
+  var existingApp = await findContainerApp(config, scriptName);
+
+  var maxInstances = (appConfig.regions?.length || 1) * (appConfig.instances || 2);
+
+  if (existingApp) {
+    // Update max_instances if changed
+    if (existingApp.max_instances !== maxInstances) {
+      status("Updating max instances...");
+      await modifyContainerApp(config, existingApp.id, {
+        max_instances: maxInstances,
+      });
+    }
+    // Roll out new image + config
+    status("Rolling out new version...");
+    await createRollout(config, existingApp.id, {
+      description: `Deploy ${remoteTag}`,
+      strategy: "rolling",
+      kind: "full_auto",
+      step_percentage: 100,
+      target_configuration: buildContainerConfig(appConfig),
+    });
+  } else {
+    // Create new container app
+    status("Creating container application...");
+    await createContainerApp(config, {
+      name: scriptName,
+      scheduling_policy: "default",
+      instances: 0,
+      max_instances: maxInstances,
+      configuration: buildContainerConfig(appConfig),
+      durable_objects: {
+        namespace_id: namespaceId,
+      },
+    });
+  }
+
+  // 5. Enable workers.dev route
+  status("Enabling workers.dev subdomain...");
+  try {
+    await enableWorkerSubdomain(config, scriptName);
+  } catch {}
+
+  // 6. Resolve URL and report
+  var subdomain = await getWorkersSubdomain(config);
+  var url = subdomain
+    ? `https://flarepilot-${name}.${subdomain}.workers.dev`
+    : null;
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          name,
+          image: remoteTag,
+          url,
+          regions: appConfig.regions,
+          instances: appConfig.instances,
+          firstDeploy: isFirstDeploy,
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    success(`App ${fmt.app(name)} deployed!`);
+    process.stderr.write(`  ${fmt.bold("Name:")}  ${fmt.app(name)}\n`);
+    process.stderr.write(`  ${fmt.bold("Image:")} ${remoteTag}\n`);
+    process.stderr.write(
+      `  ${fmt.bold("URL:")}   ${url ? fmt.url(url) : fmt.dim("(configure workers.dev subdomain to see URL)")}\n`
+    );
+    hint("Next", `flarepilot open ${name}`);
+  }
+
+  // Link this directory to the app
+  linkApp(name);
+}

package/src/commands/doctor.js

@@ -0,0 +1,93 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import {
+  cfApi,
+  tryGetConfig,
+  getWorkersSubdomain,
+  getRegistryCredentials,
+} from "../lib/cf.js";
+import kleur from "kleur";
+
+var CONFIG_PATH = join(homedir(), ".flarepilot", "config.json");
+
+var PASS = kleur.green("[ok]");
+var FAIL = kleur.red("[!!]");
+
+export async function doctor() {
+  process.stderr.write(`\n${kleur.bold("flarepilot doctor")}\n`);
+  process.stderr.write(`${kleur.dim("─".repeat(40))}\n\n`);
+  var allGood = true;
+
+  allGood =
+    check("Docker installed", () => {
+      execSync("docker --version", { stdio: "pipe" });
+    }) && allGood;
+
+  allGood =
+    check("Docker daemon running", () => {
+      execSync("docker info", { stdio: "pipe", timeout: 5000 });
+    }) && allGood;
+
+  allGood =
+    check("Auth config exists", () => {
+      if (!existsSync(CONFIG_PATH)) throw new Error("Not found");
+    }) && allGood;
+
+  var config = tryGetConfig();
+  if (config) {
+    allGood =
+      (await asyncCheck("API token valid", async () => {
+        await cfApi("GET", "/user/tokens/verify", null, config.apiToken);
+      })) && allGood;
+
+    allGood =
+      (await asyncCheck("Account accessible", async () => {
+        var res = await cfApi("GET", "/accounts", null, config.apiToken);
+        if (!res.result?.length) throw new Error("No accounts");
+      })) && allGood;
+
+    allGood =
+      (await asyncCheck("Workers subdomain configured", async () => {
+        var sub = await getWorkersSubdomain(config);
+        if (!sub) throw new Error("Not configured");
+      })) && allGood;
+
+    allGood =
+      (await asyncCheck("Registry credentials obtainable", async () => {
+        await getRegistryCredentials(config);
+      })) && allGood;
+  }
+
+  process.stderr.write(`\n${kleur.dim("─".repeat(40))}\n`);
+  if (allGood) {
+    process.stderr.write(kleur.green("All checks passed.\n\n"));
+  } else {
+    process.stderr.write(
+      kleur.yellow("Some checks failed. Fix the issues above and re-run.\n\n")
+    );
+  }
+}
+
+function check(label, fn) {
+  try {
+    fn();
+    process.stderr.write(`  ${PASS}  ${label}\n`);
+    return true;
+  } catch {
+    process.stderr.write(`  ${FAIL}  ${label}\n`);
+    return false;
+  }
+}
+
+async function asyncCheck(label, fn) {
+  try {
+    await fn();
+    process.stderr.write(`  ${PASS}  ${label}\n`);
+    return true;
+  } catch {
+    process.stderr.write(`  ${FAIL}  ${label}\n`);
+    return false;
+  }
+}

package/src/commands/domains.js

@@ -0,0 +1,273 @@
+import { createInterface } from "readline";
+import {
+  getConfig,
+  getAppConfig,
+  pushAppConfig,
+  getWorkersSubdomain,
+  listZones,
+  findZoneForHostname,
+  addWorkerDomain,
+  removeWorkerDomain,
+  listWorkerDomainsForService,
+  listDnsRecords,
+  createDnsRecord,
+  deleteDnsRecord,
+} from "../lib/cf.js";
+import { phase, status, success, fatal, hint, fmt } from "../lib/output.js";
+import { resolveAppName } from "../lib/link.js";
+import kleur from "kleur";
+
+function prompt(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+export async function domainsList(name, options) {
+  name = resolveAppName(name);
+  var config = getConfig();
+  var scriptName = `flarepilot-${name}`;
+
+  var subdomain = await getWorkersSubdomain(config);
+  var defaultDomain = subdomain
+    ? `flarepilot-${name}.${subdomain}.workers.dev`
+    : null;
+
+  // Get live domains from CF API
+  var domains = await listWorkerDomainsForService(config, scriptName);
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          default: defaultDomain,
+          custom: domains.map((d) => d.hostname),
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  if (defaultDomain) {
+    console.log(
+      `\n${fmt.bold("Default:")} ${fmt.url(`https://${defaultDomain}`)}`
+    );
+  }
+
+  if (domains.length === 0) {
+    console.log(`${fmt.bold("Custom:")}  ${fmt.dim("(none)")}`);
+    hint("Add", `flarepilot domains add ${name}`);
+    return;
+  }
+
+  console.log(`\n${fmt.bold("Custom domains:")}`);
+  for (var d of domains) {
+    console.log(`  ${d.hostname}`);
+  }
+}
+
+export async function domainsAdd(args) {
+  var name, domain;
+
+  // Parse args: 0 args = interactive, 1 arg = domain or name, 2 args = name + domain
+  if (args.length === 2) {
+    name = args[0];
+    domain = args[1];
+  } else if (args.length === 1) {
+    // Could be a domain or just an app name — check if it looks like a domain
+    if (args[0].includes(".")) {
+      name = resolveAppName(null);
+      domain = args[0];
+    } else {
+      name = args[0];
+      domain = null;
+    }
+  } else {
+    name = resolveAppName(null);
+    domain = null;
+  }
+
+  var config = getConfig();
+  var scriptName = `flarepilot-${name}`;
+
+  var appConfig = await getAppConfig(config, name);
+  if (!appConfig) {
+    fatal(
+      `App ${fmt.app(name)} not found.`,
+      `Run ${fmt.cmd(`flarepilot deploy ${name} .`)} first.`
+    );
+  }
+
+  // Fetch zones
+  status("Loading zones...");
+  var zones = await listZones(config);
+
+  if (zones.length === 0) {
+    fatal(
+      "No active zones found in this account.",
+      "Add a domain to your Cloudflare account first."
+    );
+  }
+
+  var rl = createInterface({ input: process.stdin, output: process.stderr });
+  var zone;
+
+  if (domain) {
+    // Domain provided — find matching zone
+    zone = findZoneForHostname(zones, domain);
+    if (!zone) {
+      rl.close();
+      var zoneList = zones.map((z) => `  ${z.name}`).join("\n");
+      fatal(
+        `No zone found for '${domain}'.`,
+        `Available zones:\n${zoneList}`
+      );
+    }
+  } else {
+    // Interactive — pick zone
+    process.stderr.write(`\n${kleur.bold("Available zones:")}\n\n`);
+    for (var i = 0; i < zones.length; i++) {
+      process.stderr.write(
+        `  ${kleur.bold(`[${i + 1}]`)} ${zones[i].name}\n`
+      );
+    }
+    process.stderr.write("\n");
+
+    var zoneChoice = await prompt(rl, `Select zone [1-${zones.length}]: `);
+    var zoneIdx = parseInt(zoneChoice, 10) - 1;
+    if (isNaN(zoneIdx) || zoneIdx < 0 || zoneIdx >= zones.length) {
+      rl.close();
+      fatal("Invalid selection.");
+    }
+    zone = zones[zoneIdx];
+
+    // Pick root or subdomain
+    process.stderr.write(`\n${kleur.bold("Route type:")}\n\n`);
+    process.stderr.write(`  ${kleur.bold("[1]")} Root domain (${zone.name})\n`);
+    process.stderr.write(`  ${kleur.bold("[2]")} Subdomain (*.${zone.name})\n`);
+    process.stderr.write("\n");
+
+    var routeChoice = await prompt(rl, "Select [1-2]: ");
+
+    if (routeChoice.trim() === "1") {
+      domain = zone.name;
+    } else if (routeChoice.trim() === "2") {
+      var sub = await prompt(rl, `Subdomain: ${fmt.dim("___." + zone.name + " → ")} `);
+      sub = (sub || "").trim();
+      if (!sub) {
+        rl.close();
+        fatal("No subdomain provided.");
+      }
+      domain = `${sub}.${zone.name}`;
+    } else {
+      rl.close();
+      fatal("Invalid selection.");
+    }
+  }
+
+  rl.close();
+
+  // Check for existing DNS records — never overwrite
+  status(`Checking existing DNS records for ${domain}...`);
+  var existing = await listDnsRecords(config, zone.id, { name: domain });
+
+  if (existing.length > 0) {
+    var types = existing.map((r) => `${r.type} → ${r.content}`).join("\n  ");
+    fatal(
+      `DNS record already exists for ${domain}.`,
+      `Existing records:\n  ${types}\n\nRemove the existing record first, or choose a different domain.`
+    );
+  }
+
+  // Attach domain to worker via CF API first (validates no external conflicts)
+  status(`Attaching ${domain} to ${scriptName} (zone: ${zone.name})...`);
+  try {
+    await addWorkerDomain(config, scriptName, domain, zone.id);
+  } catch (e) {
+    if (e.message.includes("already has externally managed DNS records")) {
+      fatal(
+        `DNS record already exists for ${domain} (externally managed).`,
+        "Remove the existing DNS record first, or choose a different domain."
+      );
+    }
+    throw e;
+  }
+
+  // Create CNAME record pointing to workers.dev (only after domain is attached)
+  var subdomain = await getWorkersSubdomain(config);
+  var target = subdomain ? `flarepilot-${name}.${subdomain}.workers.dev` : null;
+
+  if (target) {
+    status(`Creating CNAME ${domain} → ${target}...`);
+    try {
+      await createDnsRecord(config, zone.id, {
+        type: "CNAME",
+        name: domain,
+        content: target,
+        proxied: true,
+      });
+    } catch (e) {
+      // Not fatal — worker domain is already attached, CNAME is optional
+      if (!e.message.includes("already exists")) {
+        process.stderr.write(`  ${fmt.dim(`Warning: could not create CNAME: ${e.message}`)}\n`);
+      }
+    }
+  }
+
+  // Update app config metadata
+  if (!appConfig.domains) appConfig.domains = [];
+  if (!appConfig.domains.includes(domain)) {
+    appConfig.domains.push(domain);
+    await pushAppConfig(config, name, appConfig);
+  }
+
+  success(`Domain ${fmt.bold(domain)} added to ${fmt.app(name)}.`);
+  process.stderr.write(`  ${fmt.url(`https://${domain}`)}\n`);
+}
+
+export async function domainsRemove(args) {
+  // 1 arg = domain (resolve name from link). 2 args = name + domain.
+  var name, domain;
+  if (args.length === 2) {
+    name = args[0];
+    domain = args[1];
+  } else if (args.length === 1) {
+    name = resolveAppName(null);
+    domain = args[0];
+  } else {
+    fatal("Usage: flarepilot domains remove [name] <domain>");
+  }
+
+  var config = getConfig();
+
+  var appConfig = await getAppConfig(config, name);
+  if (!appConfig) {
+    fatal(
+      `App ${fmt.app(name)} not found.`,
+      `Run ${fmt.cmd(`flarepilot deploy ${name} .`)} first.`
+    );
+  }
+
+  // Remove Worker Domain route
+  status(`Removing ${domain}...`);
+  await removeWorkerDomain(config, domain);
+
+  // Remove CNAME record if it exists
+  var zones = await listZones(config);
+  var zone = findZoneForHostname(zones, domain);
+  if (zone) {
+    var records = await listDnsRecords(config, zone.id, {
+      type: "CNAME",
+      name: domain,
+    });
+    for (var record of records) {
+      await deleteDnsRecord(config, zone.id, record.id);
+    }
+  }
+
+  // Update app config metadata
+  appConfig.domains = (appConfig.domains || []).filter((d) => d !== domain);
+  await pushAppConfig(config, name, appConfig);
+
+  success(`Domain ${fmt.bold(domain)} removed from ${fmt.app(name)}.`);
+}