flarepilot 0.1.0

package/src/lib/cf.js

@@ -0,0 +1,450 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+var CONFIG_DIR = join(homedir(), ".flarepilot");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+var CF_API = "https://api.cloudflare.com/client/v4";
+var CF_REGISTRY = "registry.cloudflare.com";
+
+export { CF_REGISTRY };
+
+// --- Auth config (~/.flarepilot/config.json is the only local file) ---
+
+export function getConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    console.error("Not authenticated. Run `flarepilot auth` first.");
+    process.exit(1);
+  }
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+export function tryGetConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+// --- CF API base ---
+
+export async function cfApi(method, path, body, apiToken, contentType) {
+  if (!apiToken) {
+    var config = getConfig();
+    apiToken = config.apiToken;
+  }
+
+  var headers = {
+    Authorization: `Bearer ${apiToken}`,
+  };
+
+  if (contentType) {
+    headers["Content-Type"] = contentType;
+  } else if (body && typeof body === "object") {
+    headers["Content-Type"] = "application/json";
+    body = JSON.stringify(body);
+  }
+
+  var res = await fetch(`${CF_API}${path}`, {
+    method,
+    headers,
+    body: method === "GET" ? undefined : body,
+  });
+
+  if (!res.ok) {
+    var text = await res.text();
+    throw new Error(`CF API ${method} ${path}: ${res.status} ${text}`);
+  }
+
+  var ct = res.headers.get("content-type") || "";
+  if (ct.includes("application/json")) {
+    return res.json();
+  }
+  return res.text();
+}
+
+// --- Registry ---
+
+export async function getRegistryCredentials(config) {
+  var res = await cfApi(
+    "POST",
+    `/accounts/${config.accountId}/containers/registries/${CF_REGISTRY}/credentials`,
+    { permissions: ["push", "pull"], expiration_minutes: 15 },
+    config.apiToken
+  );
+  return res.result;
+}
+
+// --- Worker scripts ---
+
+export async function uploadWorker(config, scriptName, code, metadata) {
+  var form = new FormData();
+  form.append(
+    "metadata",
+    new Blob([JSON.stringify(metadata)], { type: "application/json" })
+  );
+  form.append(
+    "index.js",
+    new Blob([code], { type: "application/javascript+module" }),
+    "index.js"
+  );
+
+  var res = await fetch(
+    `${CF_API}/accounts/${config.accountId}/workers/scripts/${scriptName}`,
+    {
+      method: "PUT",
+      headers: { Authorization: `Bearer ${config.apiToken}` },
+      body: form,
+    }
+  );
+
+  if (!res.ok) {
+    var text = await res.text();
+    throw new Error(`Worker upload failed: ${res.status} ${text}`);
+  }
+
+  return res.json();
+}
+
+export async function deleteWorker(config, scriptName) {
+  return cfApi(
+    "DELETE",
+    `/accounts/${config.accountId}/workers/scripts/${scriptName}`,
+    null,
+    config.apiToken
+  );
+}
+
+export async function patchWorkerSettings(config, scriptName, settings) {
+  var form = new FormData();
+  form.append(
+    "settings",
+    new Blob([JSON.stringify(settings)], { type: "application/json" })
+  );
+
+  var res = await fetch(
+    `${CF_API}/accounts/${config.accountId}/workers/scripts/${scriptName}/settings`,
+    {
+      method: "PATCH",
+      headers: { Authorization: `Bearer ${config.apiToken}` },
+      body: form,
+    }
+  );
+
+  if (!res.ok) {
+    var text = await res.text();
+    throw new Error(`Settings update failed: ${res.status} ${text}`);
+  }
+
+  return res.json();
+}
+
+export async function listWorkerScripts(config) {
+  var res = await cfApi(
+    "GET",
+    `/accounts/${config.accountId}/workers/scripts`,
+    null,
+    config.apiToken
+  );
+  return res.result || [];
+}
+
+// --- App config (stored in the deployed worker's FLAREPILOT_APP_CONFIG binding) ---
+
+export async function getAppConfig(config, name) {
+  var res = await cfApi(
+    "GET",
+    `/accounts/${config.accountId}/workers/scripts/flarepilot-${name}/settings`,
+    null,
+    config.apiToken
+  );
+  var bindings = res.result?.bindings || [];
+  var binding = bindings.find((b) => b.name === "FLAREPILOT_APP_CONFIG");
+  if (!binding) return null;
+  return JSON.parse(binding.text);
+}
+
+export async function pushAppConfig(config, name, appConfig) {
+  var { getWorkerBundle } = await import("./bundle.js");
+  var code = getWorkerBundle();
+  var metadata = buildWorkerMetadata(appConfig, { firstDeploy: false });
+  await uploadWorker(config, `flarepilot-${name}`, code, metadata);
+}
+
+// --- Metadata builder (full deploy) ---
+
+export function buildWorkerMetadata(appConfig, { firstDeploy = false } = {}) {
+  var metadata = {
+    main_module: "index.js",
+    compatibility_date: "2025-10-08",
+    bindings: [
+      {
+        type: "durable_object_namespace",
+        name: "APP_CONTAINER",
+        class_name: "AppContainer",
+      },
+      {
+        type: "plain_text",
+        name: "FLAREPILOT_APP_CONFIG",
+        text: JSON.stringify(appConfig),
+      },
+    ],
+    observability: {
+      enabled: appConfig.observability !== false,
+    },
+    containers: [
+      {
+        class_name: "AppContainer",
+      },
+    ],
+  };
+
+  if (firstDeploy) {
+    metadata.migrations = {
+      new_tag: "v1",
+      new_sqlite_classes: ["AppContainer"],
+    };
+  } else {
+    metadata.migrations = {
+      old_tag: "v1",
+      new_tag: "v1",
+    };
+  }
+
+  return metadata;
+}
+
+// --- Container applications ---
+
+export async function getDONamespaceId(config, scriptName, className) {
+  var res = await cfApi(
+    "GET",
+    `/accounts/${config.accountId}/workers/durable_objects/namespaces`,
+    null,
+    config.apiToken
+  );
+  var namespaces = res.result || [];
+  var ns = namespaces.find(
+    (n) => n.script === scriptName && n.class === className
+  );
+  return ns ? ns.id : null;
+}
+
+export async function listContainerApps(config) {
+  var res = await cfApi(
+    "GET",
+    `/accounts/${config.accountId}/containers/applications`,
+    null,
+    config.apiToken
+  );
+  return res.result || [];
+}
+
+export async function findContainerApp(config, name) {
+  var apps = await listContainerApps(config);
+  return apps.find((a) => a.name === name) || null;
+}
+
+export async function createContainerApp(config, app) {
+  var res = await cfApi(
+    "POST",
+    `/accounts/${config.accountId}/containers/applications`,
+    app,
+    config.apiToken
+  );
+  return res.result;
+}
+
+export async function deleteContainerApp(config, appId) {
+  return cfApi(
+    "DELETE",
+    `/accounts/${config.accountId}/containers/applications/${appId}`,
+    null,
+    config.apiToken
+  );
+}
+
+export async function modifyContainerApp(config, appId, changes) {
+  var res = await cfApi(
+    "PATCH",
+    `/accounts/${config.accountId}/containers/applications/${appId}`,
+    changes,
+    config.apiToken
+  );
+  return res.result;
+}
+
+export async function createRollout(config, appId, rollout) {
+  var res = await cfApi(
+    "POST",
+    `/accounts/${config.accountId}/containers/applications/${appId}/rollouts`,
+    rollout,
+    config.apiToken
+  );
+  return res.result;
+}
+
+// --- Tail/logs ---
+
+export async function createTail(config, scriptName) {
+  var res = await cfApi(
+    "POST",
+    `/accounts/${config.accountId}/workers/scripts/${scriptName}/tails`,
+    {},
+    config.apiToken
+  );
+  return res.result;
+}
+
+export async function deleteTail(config, scriptName, tailId) {
+  return cfApi(
+    "DELETE",
+    `/accounts/${config.accountId}/workers/scripts/${scriptName}/tails/${tailId}`,
+    null,
+    config.apiToken
+  );
+}
+
+// --- Zones ---
+
+export async function listZones(config) {
+  var all = [];
+  var page = 1;
+  while (true) {
+    var res = await cfApi(
+      "GET",
+      `/zones?account.id=${config.accountId}&per_page=50&status=active&page=${page}`,
+      null,
+      config.apiToken
+    );
+    var zones = res.result || [];
+    all.push(...zones);
+    if (zones.length < 50) break;
+    page++;
+  }
+  return all;
+}
+
+export function findZoneForHostname(zones, hostname) {
+  // Find the zone whose name is a suffix of the hostname (longest match wins)
+  var match = null;
+  for (var zone of zones) {
+    if (hostname === zone.name || hostname.endsWith("." + zone.name)) {
+      if (!match || zone.name.length > match.name.length) {
+        match = zone;
+      }
+    }
+  }
+  return match;
+}
+
+// --- DNS records ---
+
+export async function listDnsRecords(config, zoneId, params) {
+  var qs = new URLSearchParams(params || {}).toString();
+  var path = `/zones/${zoneId}/dns_records${qs ? "?" + qs : ""}`;
+  var res = await cfApi("GET", path, null, config.apiToken);
+  return res.result || [];
+}
+
+export async function createDnsRecord(config, zoneId, record) {
+  return cfApi(
+    "POST",
+    `/zones/${zoneId}/dns_records`,
+    record,
+    config.apiToken
+  );
+}
+
+export async function deleteDnsRecord(config, zoneId, recordId) {
+  return cfApi(
+    "DELETE",
+    `/zones/${zoneId}/dns_records/${recordId}`,
+    null,
+    config.apiToken
+  );
+}
+
+// --- Workers custom domains ---
+
+export async function addWorkerDomain(config, scriptName, hostname, zoneId) {
+  return cfApi(
+    "PUT",
+    `/accounts/${config.accountId}/workers/domains`,
+    {
+      hostname,
+      zone_id: zoneId,
+      service: scriptName,
+      environment: "production",
+    },
+    config.apiToken
+  );
+}
+
+export async function removeWorkerDomain(config, hostname) {
+  // Find the domain ID by hostname
+  var res = await cfApi(
+    "GET",
+    `/accounts/${config.accountId}/workers/domains`,
+    null,
+    config.apiToken
+  );
+  var domains = res.result || [];
+  var domain = domains.find((d) => d.hostname === hostname);
+  if (!domain) return;
+
+  return cfApi(
+    "DELETE",
+    `/accounts/${config.accountId}/workers/domains/${domain.id}`,
+    null,
+    config.apiToken
+  );
+}
+
+export async function listWorkerDomainsForService(config, scriptName) {
+  var res = await cfApi(
+    "GET",
+    `/accounts/${config.accountId}/workers/domains`,
+    null,
+    config.apiToken
+  );
+  return (res.result || []).filter((d) => d.service === scriptName);
+}
+
+// --- Workers subdomain ---
+
+export async function getWorkersSubdomain(config) {
+  try {
+    var res = await cfApi(
+      "GET",
+      `/accounts/${config.accountId}/workers/subdomain`,
+      null,
+      config.apiToken
+    );
+    return res.result?.subdomain || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function enableWorkerSubdomain(config, scriptName) {
+  return cfApi(
+    "POST",
+    `/accounts/${config.accountId}/workers/services/${scriptName}/environments/production/subdomain`,
+    { enabled: true },
+    config.apiToken
+  );
+}
+
+export function getAppUrl(subdomain, name) {
+  if (!subdomain) return null;
+  return `https://flarepilot-${name}.${subdomain}.workers.dev`;
+}

package/src/lib/docker.js

@@ -0,0 +1,33 @@
+import { execSync } from "child_process";
+
+function ensureDocker() {
+  try {
+    execSync("docker version", { stdio: "pipe" });
+  } catch {
+    console.error("Docker is not running. Install and start Docker first.");
+    process.exit(1);
+  }
+}
+
+export function dockerBuild(contextPath, tag) {
+  ensureDocker();
+  execSync(
+    `docker build --platform linux/amd64 --provenance=false -t ${tag} ${contextPath}`,
+    { stdio: "pipe" }
+  );
+}
+
+export function dockerTag(source, target) {
+  execSync(`docker tag ${source} ${target}`, { stdio: "pipe" });
+}
+
+export function dockerPush(tag) {
+  execSync(`docker push ${tag}`, { stdio: "pipe" });
+}
+
+export function dockerLogin(registry, username, password) {
+  execSync(
+    `docker login --password-stdin --username ${username} ${registry}`,
+    { input: password, stdio: "pipe" }
+  );
+}

package/src/lib/link.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, unlinkSync } from "fs";
+import { fatal, fmt } from "./output.js";
+
+var LINK_FILE = ".flarepilot.json";
+
+export function readLink() {
+  try {
+    var data = JSON.parse(readFileSync(LINK_FILE, "utf-8"));
+    return data.app || null;
+  } catch {
+    return null;
+  }
+}
+
+export function linkApp(name) {
+  writeFileSync(LINK_FILE, JSON.stringify({ app: name }) + "\n");
+}
+
+export function unlinkApp() {
+  try {
+    unlinkSync(LINK_FILE);
+  } catch {}
+}
+
+export function resolveAppName(name) {
+  if (name) return name;
+  var linked = readLink();
+  if (linked) return linked;
+  fatal(
+    "No app specified.",
+    `Provide an app name or run ${fmt.cmd("flarepilot deploy")} in this directory first.`
+  );
+}

package/src/lib/output.js

@@ -0,0 +1,102 @@
+import kleur from "kleur";
+
+export function phase(msg) {
+  process.stderr.write(`\n${kleur.bold().cyan("==>")} ${kleur.bold(msg)}\n`);
+}
+
+export function status(msg) {
+  process.stderr.write(`    ${msg}\n`);
+}
+
+export function error(msg, fix) {
+  process.stderr.write(`\n${kleur.red("Error:")} ${msg}\n`);
+  if (fix) process.stderr.write(`  ${fix}\n`);
+}
+
+export function fatal(msg, fix) {
+  error(msg, fix);
+  process.exit(1);
+}
+
+export function success(msg) {
+  process.stderr.write(`\n${kleur.green("-->")} ${msg}\n`);
+}
+
+export function hint(label, msg) {
+  process.stderr.write(`\n${kleur.dim(label + ":")} ${msg}\n`);
+}
+
+export var fmt = {
+  app: (name) => kleur.cyan(name),
+  cmd: (cmd) => kleur.bold().cyan(cmd),
+  key: (k) => kleur.green(k),
+  val: (v) => kleur.yellow(v),
+  dim: (t) => kleur.dim(t),
+  bold: (t) => kleur.bold(t),
+  url: (u) => kleur.underline().cyan(u),
+};
+
+function stripAnsi(str) {
+  return String(str).replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+function padEnd(str, len) {
+  var visible = stripAnsi(str).length;
+  return str + " ".repeat(Math.max(0, len - visible));
+}
+
+var ADJECTIVES = [
+  "autumn", "bold", "calm", "crimson", "dawn", "dark", "dry", "dusk",
+  "fading", "flat", "floral", "fragrant", "frosty", "gentle", "green",
+  "hazy", "hidden", "icy", "lively", "long", "misty", "morning", "muddy",
+  "nameless", "old", "patient", "plain", "polished", "proud", "purple",
+  "quiet", "rapid", "red", "restless", "rough", "shy", "silent", "small",
+  "snowy", "solitary", "sparkling", "spring", "still", "summer", "twilight",
+  "wandering", "weathered", "white", "wild", "winter", "withered", "young",
+];
+
+var NOUNS = [
+  "bird", "brook", "bush", "cloud", "creek", "dew", "dream", "dust",
+  "field", "fire", "flower", "fog", "forest", "frost", "gale", "gate",
+  "glacier", "grass", "grove", "haze", "hill", "lake", "leaf", "light",
+  "meadow", "moon", "moss", "night", "paper", "path", "peak", "pine",
+  "pond", "rain", "reef", "ridge", "river", "rock", "rose", "sea",
+  "shadow", "shore", "sky", "smoke", "snow", "sound", "star", "stone",
+  "stream", "sun", "surf", "thunder", "tree", "violet", "water", "wave",
+  "wind", "wood",
+];
+
+export function generateAppName() {
+  var adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+  var noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+  var num = Math.floor(1000 + Math.random() * 9000);
+  return `${adj}-${noun}-${num}`;
+}
+
+export function table(headers, rows) {
+  if (rows.length === 0) return "";
+
+  var allRows = [headers, ...rows];
+  var widths = [];
+  for (var row of allRows) {
+    for (var i = 0; i < row.length; i++) {
+      var len = stripAnsi(String(row[i] || "")).length;
+      if (!widths[i] || len > widths[i]) widths[i] = len;
+    }
+  }
+
+  var lines = [];
+  lines.push(
+    headers
+      .map((h, i) => kleur.bold(padEnd(String(h), widths[i] + 2)))
+      .join("")
+  );
+  lines.push(kleur.dim(widths.map((w) => "─".repeat(w)).join("  ")));
+  for (var row of rows) {
+    lines.push(
+      row.map((cell, i) => padEnd(String(cell || ""), widths[i] + 2)).join("")
+    );
+  }
+
+  return lines.join("\n");
+}

package/worker-template/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@flarepilot/worker-template",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Per-app worker template for Flarepilot",
+  "dependencies": {
+    "@cloudflare/containers": "^0.0.30"
+  }
+}