flaghoist 0.1.3 → 0.3.0

package/dist/{chunk-S4XXPMMW.js → chunk-HOSNPNBP.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
 };
@@ -12,21 +13,32 @@ var STORAGE_KINDS = [
   "postgres",
   "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 +58,9 @@ function serializeConfig(config) {
 export {
   DEFAULT_CONFIG,
   STORAGE_KINDS,
+  PLATFORM_KINDS,
+  containerStorageDefault,
+  asContainer,
   parseConfig,
   serializeConfig
 };

package/dist/index.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
 import {
   DEFAULT_CONFIG,
+  PLATFORM_KINDS,
   STORAGE_KINDS,
+  asContainer,
+  containerStorageDefault,
   parseConfig,
   serializeConfig
-} from "./chunk-S4XXPMMW.js";
+} from "./chunk-HOSNPNBP.js";
 
 // src/index.ts
 import { spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
+import { createInterface } from "readline/promises";
 import { parseArgs } from "util";
 
 // src/admin.ts
@@ -87,6 +91,133 @@ async function setRules(client, key, rules) {
   });
 }
 
+// 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/server": "^0.3.0",
+  "@hono/node-server": "^2.1.1",
+  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 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 { ${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 === '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, or memory.\`)
+}
+
+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})\`)
+`;
+}
+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"]
+`;
+}
+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)}
+`;
+}
+function generateDockerignore() {
+  return ["node_modules", "npm-debug.log", "Dockerfile", ".dockerignore", "README.md", ""].join(
+    "\n"
+  );
+}
+
 // src/generate.ts
 function storageSnippet(storage) {
   switch (storage) {
@@ -124,7 +255,7 @@ function storageSnippet(storage) {
       };
   }
 }
-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) {
@@ -148,7 +279,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}
 }))
@@ -316,27 +447,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(
@@ -349,8 +502,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:");
@@ -392,8 +552,49 @@ function ensureDependencies() {
     throw new Error("`npm install` failed. Run it yourself, then `flaghoist deploy` again.");
   }
 }
-function runDeploy() {
-  const config = loadConfig();
+function parseDeployTarget(args) {
+  const i = args.indexOf("--target");
+  if (i < 0) return null;
+  const value = args[i + 1]?.toLowerCase();
+  if (value === "cloudflare" || value === "cf" || value === "workers") return "cloudflare";
+  return "other";
+}
+async function promptDeployTarget() {
+  console.log("Where do you want to deploy?");
+  console.log("  1) Cloudflare Workers   recommended, deploys in one command");
+  console.log("  2) Another platform     Render, a container, any Node host");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question("Choose [1]: ")).trim().toLowerCase();
+    return answer === "2" || answer.startsWith("o") || answer.startsWith("r") ? "other" : "cloudflare";
+  } finally {
+    rl.close();
+  }
+}
+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(`
+Scaffolded a container project: server.mjs, Dockerfile, package.json.
+
+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:
+
+  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/
+
+Missing a platform you need? Open an issue at https://github.com/flaghoist/flaghoist/issues.`);
+}
+async function deployCloudflare(config) {
   if (!existsSync("src/index.ts")) writeProject(config, ".");
   ensureDependencies();
   ensureKvNamespace(config);
@@ -401,15 +602,25 @@ function runDeploy() {
   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
-  deploy                   Deploy to Cloudflare via wrangler
+  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)
   flag list
@@ -430,7 +641,7 @@ async function main() {
     case "eject":
       return runEject();
     case "deploy":
-      return runDeploy();
+      return runDeploy(rest);
     case "-v":
     case "--version":
       return console.log(VERSION);

package/dist/lib.d.ts

@@ -1,8 +1,17 @@
 type StorageKind = 'cloudflare-kv' | 'redis' | 'postgres' | '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' | '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-HOSNPNBP.js";
 export {
   DEFAULT_CONFIG,
+  PLATFORM_KINDS,
   STORAGE_KINDS,
+  asContainer,
+  containerStorageDefault,
   parseConfig,
   serializeConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flaghoist",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Scaffold, deploy, and manage your Flaghoist feature-flag service from the terminal.",
   "license": "Apache-2.0",
   "type": "module",
@@ -26,9 +26,9 @@
     "smol-toml": "^1.8.0"
   },
   "devDependencies": {
-    "@flaghoist/adapter-memory": "0.1.1",
-    "@flaghoist/core": "0.1.1",
-    "@flaghoist/server": "0.1.2"
+    "@flaghoist/adapter-memory": "0.1.2",
+    "@flaghoist/core": "0.1.2",
+    "@flaghoist/server": "0.3.1"
   },
   "publishConfig": {
     "access": "public"