flaghoist 0.2.0 → 0.3.1

package/dist/{chunk-S4XXPMMW.js → chunk-HSDDPXCM.js}

@@ -3,6 +3,7 @@ import { parse } from "smol-toml";
 var DEFAULT_CONFIG = {
   name: "team-flags",
   storage: "cloudflare-kv",
+  platform: "cloudflare",
   auth: { admin: "bearer-token", read: "api-key" },
   dashboard: true
 };
@@ -10,23 +11,35 @@ var STORAGE_KINDS = [
   "cloudflare-kv",
   "redis",
   "postgres",
+  "sqlite",
   "memory"
 ];
+var PLATFORM_KINDS = ["cloudflare", "container"];
+function containerStorageDefault(storage) {
+  return storage === "cloudflare-kv" ? "postgres" : storage;
+}
+function asContainer(config) {
+  return { ...config, platform: "container", storage: containerStorageDefault(config.storage) };
+}
 function parseConfig(text) {
   const raw = parse(text);
   const name = typeof raw.name === "string" && raw.name ? raw.name : DEFAULT_CONFIG.name;
   const storage = STORAGE_KINDS.includes(raw.storage) ? raw.storage : DEFAULT_CONFIG.storage;
+  const platform = raw.platform === "container" ? "container" : DEFAULT_CONFIG.platform;
   const authRaw = typeof raw.auth === "object" && raw.auth !== null ? raw.auth : {};
   const admin = authRaw.admin === "oidc" ? "oidc" : "bearer-token";
   const allowedOrigins = Array.isArray(raw.allowedOrigins) ? raw.allowedOrigins.filter((x) => typeof x === "string") : void 0;
   const dashboard = raw.dashboard !== false;
-  return { name, storage, auth: { admin, read: "api-key" }, allowedOrigins, dashboard };
+  return { name, storage, platform, auth: { admin, read: "api-key" }, allowedOrigins, dashboard };
 }
 function serializeConfig(config) {
   const lines = [
     `name = ${JSON.stringify(config.name)}`,
     `storage = ${JSON.stringify(config.storage)}`
   ];
+  if (config.platform !== "cloudflare") {
+    lines.push(`platform = ${JSON.stringify(config.platform)}`);
+  }
   if (config.allowedOrigins && config.allowedOrigins.length > 0) {
     lines.push(`allowedOrigins = ${JSON.stringify(config.allowedOrigins)}`);
   }
@@ -46,6 +59,9 @@ function serializeConfig(config) {
 export {
   DEFAULT_CONFIG,
   STORAGE_KINDS,
+  PLATFORM_KINDS,
+  containerStorageDefault,
+  asContainer,
   parseConfig,
   serializeConfig
 };

package/dist/index.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import {
   DEFAULT_CONFIG,
+  PLATFORM_KINDS,
   STORAGE_KINDS,
+  asContainer,
+  containerStorageDefault,
   parseConfig,
   serializeConfig
-} from "./chunk-S4XXPMMW.js";
+} from "./chunk-HSDDPXCM.js";
 
 // src/index.ts
 import { spawnSync } from "child_process";
@@ -14,78 +17,149 @@ import { createInterface } from "readline/promises";
 import { parseArgs } from "util";
 
 // src/admin.ts
-function createAdminClient(options) {
-  const doFetch = options.fetch ?? ((input, init) => fetch(input, init));
-  const api = `${options.url.replace(/\/+$/, "")}/api/v1`;
-  const headers = {
-    authorization: `Bearer ${options.token}`,
-    "content-type": "application/json"
-  };
-  const path = (key) => `${api}/flags/${encodeURIComponent(key)}`;
-  return {
-    async list() {
-      const res = await doFetch(`${api}/flags`, { headers });
-      if (!res.ok) throw new Error(`Failed to list flags (${res.status})`);
-      return (await res.json()).flags;
-    },
-    async get(key) {
-      const res = await doFetch(path(key), { headers });
-      if (res.status === 404) return null;
-      if (!res.ok) throw new Error(`Failed to read flag "${key}" (${res.status})`);
-      return await res.json();
-    },
-    async put(key, input) {
-      const res = await doFetch(path(key), { method: "PUT", headers, body: JSON.stringify(input) });
-      if (!res.ok)
-        throw new Error(`Failed to save flag "${key}" (${res.status}): ${await res.text()}`);
-      return await res.json();
-    },
-    async delete(key) {
-      const res = await doFetch(path(key), { method: "DELETE", headers });
-      if (!res.ok && res.status !== 404)
-        throw new Error(`Failed to delete flag "${key}" (${res.status})`);
-    }
-  };
+import {
+  createAdminClient,
+  createFlag,
+  setRollout,
+  setRules,
+  toggleFlag
+} from "@flaghoist/admin-client";
+
+// src/generate-container.ts
+var CONTAINER_DEPS = {
+  "@flaghoist/adapter-memory": "^0.1.2",
+  "@flaghoist/adapter-postgres": "^0.1.2",
+  "@flaghoist/adapter-redis": "^0.1.2",
+  "@flaghoist/adapter-sqlite": "^0.1.0",
+  "@flaghoist/server": "^0.3.0",
+  "@hono/node-server": "^2.1.1",
+  "better-sqlite3": "^11.0.0",
+  ioredis: "^5.4.0",
+  pg: "^8.13.0"
+};
+var CONTAINER_PORT = 8080;
+function adminExpr(admin) {
+  return admin === "oidc" ? "oidc({ issuer: env.OIDC_ISSUER, audience: env.OIDC_AUDIENCE, groupsClaim: 'cognito:groups', allowedGroups: (env.ADMIN_GROUPS ?? '').split(',') })" : "bearerToken(env.ADMIN_TOKEN)";
 }
-function requireFlag(flag, key) {
-  if (!flag) throw new Error(`Flag "${key}" not found`);
-  return flag;
+function generateNodeEntry(config) {
+  const defaultStorage = containerStorageDefault(config.storage);
+  const serverImports = [
+    "apiKey",
+    "createFlagServer",
+    "memoryRateLimit",
+    config.auth.admin === "oidc" ? "oidc" : "bearerToken"
+  ].sort();
+  const imports = [
+    `import { memoryAdapter } from '@flaghoist/adapter-memory'`,
+    `import { initPostgres, postgresAdapter } from '@flaghoist/adapter-postgres'`,
+    `import { redisAdapter } from '@flaghoist/adapter-redis'`,
+    `import { initSqlite, sqliteAdapter } from '@flaghoist/adapter-sqlite'`,
+    `import { ${serverImports.join(", ")} } from '@flaghoist/server'`,
+    ...config.dashboard ? [`import { dashboardHtml } from '@flaghoist/server/dashboard'`] : [],
+    `import { serve } from '@hono/node-server'`
+  ].join("\n");
+  const dashboard = config.dashboard ? "\n  dashboard: dashboardHtml," : "";
+  const origins = config.allowedOrigins && config.allowedOrigins.length > 0 ? JSON.stringify(config.allowedOrigins) : "undefined";
+  return `${imports}
+
+// One image, any host. Everything is driven by environment variables, so the same container runs on
+// a plain VPS, Fly.io, Railway, DigitalOcean, Cloud Run, ECS, or Kubernetes, with no code to edit.
+const env = process.env
+const kind = env.FLAGS_STORAGE ?? '${defaultStorage}'
+
+async function makeStorage() {
+  if (kind === 'postgres') {
+    if (!env.DATABASE_URL) throw new Error('FLAGS_STORAGE=postgres requires DATABASE_URL')
+    const { Pool } = await import('pg')
+    const table = env.FLAGS_TABLE ?? 'flaghoist_flags'
+    const pool = new Pool({
+      connectionString: env.DATABASE_URL,
+      // Managed Postgres (Supabase, Neon, Render) requires TLS. Skip this if your URL sets sslmode.
+      ssl: /sslmode=/.test(env.DATABASE_URL) ? undefined : { rejectUnauthorized: false },
+    })
+    await initPostgres(pool, table)
+    return postgresAdapter(pool, { table })
+  }
+
+  if (kind === 'redis') {
+    if (!env.REDIS_URL) throw new Error('FLAGS_STORAGE=redis requires REDIS_URL')
+    const { default: Redis } = await import('ioredis')
+    return redisAdapter(new Redis(env.REDIS_URL), { hashKey: env.FLAGS_HASH_KEY ?? 'flaghoist:flags' })
+  }
+
+  if (kind === 'sqlite') {
+    const { default: Database } = await import('better-sqlite3')
+    const db = new Database(env.DATABASE_PATH ?? '/data/flags.db')
+    initSqlite(db)
+    return sqliteAdapter(db)
+  }
+
+  if (kind === 'memory') {
+    console.warn('[flaghoist] FLAGS_STORAGE=memory: flags are in-process and are lost on restart.')
+    return memoryAdapter()
+  }
+
+  throw new Error(\`Unknown FLAGS_STORAGE "\${kind}". Use postgres, redis, sqlite, or memory.\`)
 }
-function createFlag(client, key, opts) {
-  return client.put(key, {
-    enabled: opts.enabled ?? false,
-    rollout: { percentage: opts.percentage ?? 0 },
-    rules: [],
-    description: opts.description ?? ""
-  });
+
+const app = createFlagServer({
+  storage: await makeStorage(),${dashboard}
+  auth: {
+    admin: ${adminExpr(config.auth.admin)},
+    read: apiKey(env.READ_API_KEY),
+  },
+  rateLimit: memoryRateLimit(),
+  // Comma-separated list of browser origins allowed to read flags cross-origin.
+  allowedOrigins: env.FLAGS_CORS ? env.FLAGS_CORS.split(',').map((o) => o.trim()) : ${origins},
+})
+
+const port = Number(env.PORT ?? ${CONTAINER_PORT})
+serve({ fetch: app.fetch, port, hostname: '0.0.0.0' })
+console.log(\`[flaghoist] listening on :\${port} (storage: \${kind})\`)
+`;
 }
-async function toggleFlag(client, key, to) {
-  const flag = requireFlag(await client.get(key), key);
-  const enabled = to === "flip" ? !flag.enabled : to;
-  return client.put(key, {
-    enabled,
-    rollout: flag.rollout,
-    rules: flag.rules,
-    description: flag.description
-  });
+function generateDockerfile(config) {
+  const defaultStorage = containerStorageDefault(config.storage);
+  return `# Flaghoist as a portable container. Build once, run on any host: a VPS, Fly.io, Railway,
+# DigitalOcean, Cloud Run, ECS, or Kubernetes. Configure it entirely with environment variables.
+FROM node:22-alpine
+
+WORKDIR /app
+
+# Install the published Flaghoist packages. Copying only package.json first keeps this layer cached
+# across code changes.
+COPY package.json ./
+RUN npm install --omit=dev --no-audit --no-fund
+
+COPY server.mjs ./
+
+ENV PORT=${CONTAINER_PORT}
+ENV FLAGS_STORAGE=${defaultStorage}
+EXPOSE ${CONTAINER_PORT}
+
+# The /health route is unauthenticated, so it makes a good container healthcheck.
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s \\
+  CMD node -e "fetch('http://127.0.0.1:${CONTAINER_PORT}/health').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
+
+CMD ["node", "server.mjs"]
+`;
 }
-async function setRollout(client, key, percentage) {
-  const flag = requireFlag(await client.get(key), key);
-  return client.put(key, {
-    enabled: flag.enabled,
-    rollout: { percentage },
-    rules: flag.rules,
-    description: flag.description
-  });
+function generateContainerPackageJson(config) {
+  const pkg = {
+    name: config.name,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts: { start: "node server.mjs" },
+    dependencies: CONTAINER_DEPS
+  };
+  return `${JSON.stringify(pkg, null, 2)}
+`;
 }
-async function setRules(client, key, rules) {
-  const flag = requireFlag(await client.get(key), key);
-  return client.put(key, {
-    enabled: flag.enabled,
-    rollout: flag.rollout,
-    rules,
-    description: flag.description
-  });
+function generateDockerignore() {
+  return ["node_modules", "npm-debug.log", "Dockerfile", ".dockerignore", "README.md", ""].join(
+    "\n"
+  );
 }
 
 // src/generate.ts
@@ -123,9 +197,13 @@ function storageSnippet(storage) {
         expr: "memoryAdapter()",
         pkg: "@flaghoist/adapter-memory"
       };
+    case "sqlite":
+      throw new Error(
+        'SQLite storage requires a Node or container deployment. Use `npx flaghoist deploy` and pick "Another platform".'
+      );
   }
 }
-function adminExpr(admin) {
+function adminExpr2(admin) {
   return admin === "oidc" ? "oidc({ issuer: env.OIDC_ISSUER, audience: env.OIDC_AUDIENCE, groupsClaim: 'cognito:groups', allowedGroups: (env.ADMIN_GROUPS ?? '').split(',') })" : "bearerToken(env.ADMIN_TOKEN)";
 }
 function generateWorkerEntry(config) {
@@ -149,7 +227,7 @@ function generateWorkerEntry(config) {
 export default createFlagServer((env) => ({
   storage: ${storage.expr},
   auth: {
-    admin: ${adminExpr(config.auth.admin)},
+    admin: ${adminExpr2(config.auth.admin)},
     read: apiKey(env.READ_API_KEY),
   },${origins}${dashboard}
 }))
@@ -317,27 +395,49 @@ function runInit(args) {
   const { values } = parseArgs({
     args,
     allowPositionals: true,
-    options: { name: { type: "string" }, storage: { type: "string" } }
+    options: {
+      name: { type: "string" },
+      storage: { type: "string" },
+      platform: { type: "string" }
+    }
   });
   if (existsSync("flaghoist.toml")) throw new Error("flaghoist.toml already exists.");
   if (values.storage && !STORAGE_KINDS.includes(values.storage)) {
     throw new Error(`Unknown storage "${values.storage}". One of: ${STORAGE_KINDS.join(", ")}.`);
   }
-  const config = {
+  if (values.platform && !PLATFORM_KINDS.includes(values.platform)) {
+    throw new Error(`Unknown platform "${values.platform}". One of: ${PLATFORM_KINDS.join(", ")}.`);
+  }
+  const base = {
     ...DEFAULT_CONFIG,
     name: values.name ?? DEFAULT_CONFIG.name,
     storage: values.storage ?? DEFAULT_CONFIG.storage
   };
+  const config = values.platform === "container" ? asContainer(base) : base;
   writeFileSync("flaghoist.toml", serializeConfig(config));
   console.log("Created flaghoist.toml");
   console.log("Next: `flaghoist deploy` to ship it, or `flaghoist eject` to own the code.");
 }
-function writeProject(config, dir) {
-  const files = [
+function entryFile(platform) {
+  return platform === "container" ? "server.mjs" : "src/index.ts";
+}
+function projectFiles(config) {
+  if (config.platform === "container") {
+    return [
+      ["server.mjs", generateNodeEntry(config)],
+      ["Dockerfile", generateDockerfile(config)],
+      [".dockerignore", generateDockerignore()],
+      ["package.json", generateContainerPackageJson(config)]
+    ];
+  }
+  return [
     ["src/index.ts", generateWorkerEntry(config)],
     ["wrangler.toml", generateWranglerToml(config)],
     ["package.json", generatePackageJson(config)]
   ];
+}
+function writeProject(config, dir) {
+  const files = projectFiles(config);
   const existing = files.map(([name]) => name).filter((name) => existsSync(join(dir, name)));
   if (existing.length > 0) {
     throw new Error(
@@ -350,8 +450,15 @@ Flaghoist deploys as its own service, so give it a directory of its own:
 }
 function runEject() {
   const config = loadConfig();
-  if (existsSync("src/index.ts")) throw new Error("src/index.ts already exists. Already ejected?");
+  const entry = entryFile(config.platform);
+  if (existsSync(entry)) throw new Error(`${entry} already exists. Already ejected?`);
   writeProject(config, ".");
+  if (config.platform === "container") {
+    console.log("Ejected to a code project you own: server.mjs, Dockerfile, package.json");
+    console.log("Edit server.mjs freely, then build and run the container, or deploy to a host:");
+    console.log("  https://docs.flaghoist.dev/deploy/overview/");
+    return;
+  }
   console.log("Ejected to a code project you own: src/index.ts, wrangler.toml, package.json");
   if (config.storage === "cloudflare-kv") {
     console.log("Create your KV namespace and paste the id into wrangler.toml:");
@@ -412,30 +519,30 @@ async function promptDeployTarget() {
     rl.close();
   }
 }
-function printOtherTargets() {
+function deployContainer(config) {
+  const container = asContainer(config);
+  if (config.platform !== container.platform || config.storage !== container.storage) {
+    writeFileSync("flaghoist.toml", serializeConfig(container));
+  }
+  if (!existsSync(entryFile("container"))) writeProject(container, ".");
   console.log(`
-Flaghoist runs on any Node, Bun, Deno, or container host, not just Cloudflare.
+Scaffolded a container project: server.mjs, Dockerfile, package.json.
 
-The project scaffolded here is a Cloudflare Worker. To run it elsewhere you serve the same
-createFlagServer() app on Node and point it at Postgres or Redis instead of Workers KV.
+It runs on any container or Node host, configured by environment variables (FLAGS_STORAGE,
+DATABASE_URL, ADMIN_TOKEN, READ_API_KEY). Build and run it with Docker:
 
-Guides:
+  docker build -t ${container.name} .
+  docker run -p 8080:8080 -e ADMIN_TOKEN=... -e READ_API_KEY=... ${container.name}
+
+Or deploy it to a host:
   Render          https://docs.flaghoist.dev/deploy/render/
+  Fly.io          https://docs.flaghoist.dev/deploy/fly/
+  Railway         https://docs.flaghoist.dev/deploy/railway/
   All targets     https://docs.flaghoist.dev/deploy/overview/
 
-More platforms are on the way. Missing one you need? Open an issue at
-https://github.com/flaghoist/flaghoist/issues.`);
+Missing a platform you need? Open an issue at https://github.com/flaghoist/flaghoist/issues.`);
 }
-async function runDeploy(args) {
-  let target = parseDeployTarget(args);
-  if (target === null) {
-    target = process.stdin.isTTY ? await promptDeployTarget() : "cloudflare";
-  }
-  if (target === "other") {
-    printOtherTargets();
-    return;
-  }
-  const config = loadConfig();
+async function deployCloudflare(config) {
   if (!existsSync("src/index.ts")) writeProject(config, ".");
   ensureDependencies();
   ensureKvNamespace(config);
@@ -443,14 +550,24 @@ async function runDeploy(args) {
   const result = spawnSync("npx", ["wrangler", "deploy"], { stdio: "inherit" });
   process.exit(result.status ?? 0);
 }
+async function runDeploy(args) {
+  const config = loadConfig();
+  let target = parseDeployTarget(args);
+  if (target === null) {
+    if (config.platform === "container") target = "other";
+    else target = process.stdin.isTTY ? await promptDeployTarget() : "cloudflare";
+  }
+  if (target === "other") return deployContainer(config);
+  return deployCloudflare(config);
+}
 function printHelp() {
   console.log(`flaghoist ${VERSION} \u2014 hoist your own feature flags
 
 Usage: flaghoist <command>
 
 Scaffolding
-  init [--name N] [--storage cloudflare-kv|redis|postgres|memory]
-  eject                    Generate a code project you own
+  init [--name N] [--storage cloudflare-kv|redis|postgres|memory] [--platform cloudflare|container]
+  eject                    Generate a code project you own (a Worker, or a container)
   deploy [--target T]      Deploy (prompts for the platform; T is cloudflare or other)
 
 Flag management (needs --url/--token or FLAGS_URL/FLAGS_ADMIN_TOKEN)

package/dist/lib.d.ts

@@ -1,8 +1,17 @@
-type StorageKind = 'cloudflare-kv' | 'redis' | 'postgres' | 'memory';
+type StorageKind = 'cloudflare-kv' | 'redis' | 'postgres' | 'sqlite' | 'memory';
 type AdminAuthKind = 'bearer-token' | 'oidc';
+/**
+ * The shape of project `flaghoist deploy`/`eject` scaffolds. `cloudflare` is a Worker plus a
+ * `wrangler.toml`; `container` is a Node entry plus a `Dockerfile`, which runs on any container or
+ * Node host (Render, Fly, Railway, a VPS). Cloudflare is the default, so a config written before
+ * this key existed still scaffolds a Worker.
+ */
+type PlatformKind = 'cloudflare' | 'container';
 interface FlaghoistConfig {
     name: string;
     storage: StorageKind;
+    /** Deploy shape to scaffold. Defaults to `cloudflare`. */
+    platform: PlatformKind;
     auth: {
         admin: AdminAuthKind;
         read: 'api-key';
@@ -14,9 +23,27 @@ interface FlaghoistConfig {
 declare const DEFAULT_CONFIG: FlaghoistConfig;
 /** Every storage backend selectable by name in `flaghoist.toml`. */
 declare const STORAGE_KINDS: readonly StorageKind[];
+/** Every deploy shape selectable by name in `flaghoist.toml`. */
+declare const PLATFORM_KINDS: readonly PlatformKind[];
+/** The stores a container can reach. Cloudflare KV is a Worker binding, so it is not one of them. */
+type ContainerStorage = 'postgres' | 'redis' | 'sqlite' | 'memory';
+/**
+ * The storage a container project uses. Cloudflare KV cannot be reached off Workers, so a config
+ * that still names it (the scaffolding default) becomes postgres, the store every container deploy
+ * guide uses. This is the one rule for a container's storage: the CLI reuses it to write a coherent
+ * `flaghoist.toml`, and the generated entry bakes it as the `FLAGS_STORAGE` default. Every kind
+ * stays overridable at runtime via the env var.
+ */
+declare function containerStorageDefault(storage: StorageKind): ContainerStorage;
+/**
+ * Recast a config for the container platform, running its storage through the container rule so the
+ * result never names a store the platform cannot use. This is the one place the platform switch
+ * rewrites a config, so `init`, `create-flaghoist`, `deploy` and `eject` all stay consistent.
+ */
+declare function asContainer(config: FlaghoistConfig): FlaghoistConfig;
 /** Parse a `flaghoist.toml` into a validated config, falling back to defaults for unknown values. */
 declare function parseConfig(text: string): FlaghoistConfig;
 /** Render a config back to `flaghoist.toml` text. */
 declare function serializeConfig(config: FlaghoistConfig): string;
 
-export { type AdminAuthKind, DEFAULT_CONFIG, type FlaghoistConfig, STORAGE_KINDS, type StorageKind, parseConfig, serializeConfig };
+export { type AdminAuthKind, type ContainerStorage, DEFAULT_CONFIG, type FlaghoistConfig, PLATFORM_KINDS, type PlatformKind, STORAGE_KINDS, type StorageKind, asContainer, containerStorageDefault, parseConfig, serializeConfig };

package/dist/lib.js

@@ -1,12 +1,18 @@
 import {
   DEFAULT_CONFIG,
+  PLATFORM_KINDS,
   STORAGE_KINDS,
+  asContainer,
+  containerStorageDefault,
   parseConfig,
   serializeConfig
-} from "./chunk-S4XXPMMW.js";
+} from "./chunk-HSDDPXCM.js";
 export {
   DEFAULT_CONFIG,
+  PLATFORM_KINDS,
   STORAGE_KINDS,
+  asContainer,
+  containerStorageDefault,
   parseConfig,
   serializeConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flaghoist",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Scaffold, deploy, and manage your Flaghoist feature-flag service from the terminal.",
   "license": "Apache-2.0",
   "type": "module",
@@ -23,12 +23,13 @@
     "node": ">=20"
   },
   "dependencies": {
-    "smol-toml": "^1.8.0"
+    "smol-toml": "^1.8.0",
+    "@flaghoist/admin-client": "0.2.0"
   },
   "devDependencies": {
-    "@flaghoist/core": "0.1.2",
     "@flaghoist/adapter-memory": "0.1.2",
-    "@flaghoist/server": "0.3.0"
+    "@flaghoist/core": "0.1.2",
+    "@flaghoist/server": "0.3.1"
   },
   "publishConfig": {
     "access": "public"