threadforge 0.1.0

package/bin/host-commands.js

@@ -0,0 +1,344 @@
+/**
+ * ForgeHost CLI Commands
+ *
+ * Subcommands for `forge host`:
+ *   forge host init          - Scaffold forge.host.js, shared/auth.js, projects/
+ *   forge host start         - Start the multi-project host
+ *   forge host add <path>    - Add a project to forge.host.js
+ *   forge host remove <id>   - Remove a project (keep data unless --drop-data)
+ *   forge host status        - Show per-project status table
+ *   forge host restart <id>  - Restart a specific project's workers
+ *   forge host generate      - Generate nginx + route manifests
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const HOST_CONFIG_NAMES = ["forge.host.js", "forge.host.mjs"];
+
+async function findHostConfig() {
+  const cwd = process.cwd();
+  for (const name of HOST_CONFIG_NAMES) {
+    const fullPath = path.join(cwd, name);
+    try {
+      await fs.promises.access(fullPath);
+      return fullPath;
+    } catch {}
+  }
+  return null;
+}
+
+async function loadHostConfig() {
+  const configPath = await findHostConfig();
+  if (!configPath) {
+    console.error("  Error: No forge.host.js found in current directory.");
+    console.error("  Run `forge host init` to create one.");
+    process.exit(1);
+  }
+  const configUrl = pathToFileURL(configPath).href;
+  const mod = await import(configUrl);
+  return mod.default ?? mod;
+}
+
+async function cmdHostInit() {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, "forge.host.js");
+
+  if (fs.existsSync(configPath)) {
+    console.error("  forge.host.js already exists in this directory.");
+    process.exit(1);
+  }
+
+  // Create directories
+  for (const dir of ["shared", "projects"]) {
+    fs.mkdirSync(path.join(cwd, dir), { recursive: true });
+  }
+
+  // Write host config
+  fs.writeFileSync(
+    configPath,
+    `import { defineHost, postgres, redis } from 'threadforge';
+
+export default defineHost({
+  domain: 'myhost.dev',
+  basePort: 3200,
+
+  shared: {
+    auth: {
+      entry: './shared/auth.js',
+      type: 'edge',
+      port: 3100,
+      prefix: '/auth',
+    },
+  },
+
+  projects: {
+    // Add projects here:
+    // blog: {
+    //   domain: 'blog.myhost.dev',
+    //   config: './projects/blog/forge.config.js',
+    // },
+  },
+
+  plugins: [
+    postgres({ url: process.env.DATABASE_URL }),
+    redis(),
+  ],
+});
+`,
+  );
+
+  // Copy auth template if not exists
+  const authDst = path.join(cwd, "shared", "auth.js");
+  if (!fs.existsSync(authDst)) {
+    const authSrc = path.join(cwd, "node_modules", "threadforge", "shared", "auth.js");
+    if (fs.existsSync(authSrc)) {
+      fs.copyFileSync(authSrc, authDst);
+    } else {
+      fs.writeFileSync(
+        authDst,
+        `// Shared auth service — customize for your deployment
+// See: https://github.com/threadforge/threadforge#forgehost-auth
+import { Service } from 'threadforge';
+
+export default class AuthService extends Service {
+  static contract = {
+    routes: [
+      { method: 'POST', path: '/login', handler: 'login' },
+      { method: 'POST', path: '/register', handler: 'register' },
+    ],
+  };
+
+  async login(body) {
+    // TODO: implement login
+    return { error: 'Not implemented' };
+  }
+
+  async register(body) {
+    // TODO: implement registration
+    return { error: 'Not implemented' };
+  }
+}
+`,
+      );
+    }
+  }
+
+  console.log(`
+  ForgeHost initialized!
+
+  Created:
+    forge.host.js          - Host configuration
+    shared/auth.js         - Shared auth service
+    projects/              - Project directory
+
+  Next steps:
+    1. Edit forge.host.js to add your projects
+    2. forge host start
+  `);
+}
+
+async function cmdHostStart() {
+  const hostConfig = await loadHostConfig();
+  const { ForgeHost } = await import("../src/core/ForgeHost.js");
+
+  const host = new ForgeHost(hostConfig);
+  await host.start();
+}
+
+async function cmdHostAdd(args) {
+  const projectPath = args[0];
+  if (!projectPath) {
+    console.error("  Usage: forge host add <path-to-project>");
+    process.exit(1);
+  }
+
+  const absPath = path.resolve(process.cwd(), projectPath);
+  const configFile = ["forge.config.js", "forge.config.mjs"].find((name) =>
+    fs.existsSync(path.join(absPath, name)),
+  );
+
+  if (!configFile) {
+    console.error(`  No forge.config.js found at ${absPath}`);
+    process.exit(1);
+  }
+
+  const projectId = path.basename(absPath);
+  const relPath = path.relative(process.cwd(), path.join(absPath, configFile));
+
+  console.log(`
+  Add this to your forge.host.js projects:
+
+    ${projectId}: {
+      domain: '${projectId}.myhost.dev',
+      config: './${relPath}',
+    },
+  `);
+}
+
+async function cmdHostRemove(args) {
+  const projectId = args[0];
+  if (!projectId) {
+    console.error("  Usage: forge host remove <project-id> [--drop-data]");
+    process.exit(1);
+  }
+
+  const dropData = args.includes("--drop-data");
+
+  console.log(`
+  To remove project "${projectId}":
+  1. Remove its entry from forge.host.js
+  2. Restart: forge host start
+  ${dropData ? `3. Data will be dropped: DROP SCHEMA project_${projectId} CASCADE` : `3. Data preserved in schema project_${projectId}`}
+  `);
+}
+
+async function cmdHostStatus() {
+  const metricsPort = 9090;
+  try {
+    const res = await fetch(`http://localhost:${metricsPort}/status`);
+    const data = await res.json();
+
+    console.log("");
+    console.log("  ForgeHost Status");
+    console.log("  ────────────────────────────────────");
+
+    if (data.projects) {
+      console.log("");
+      console.log("  ┌──────────────────┬─────────────────────────┬──────────┬─────────┐");
+      console.log("  │ Project          │ Domain                  │ Services │ Workers │");
+      console.log("  ├──────────────────┼─────────────────────────┼──────────┼─────────┤");
+
+      for (const [id, proj] of Object.entries(data.projects)) {
+        const name = id.padEnd(16);
+        const domain = (proj.domain ?? "—").substring(0, 23).padEnd(23);
+        const services = String(proj.services).padEnd(8);
+        const workers = String(proj.workers).padEnd(7);
+        console.log(`  │ ${name} │ ${domain} │ ${services} │ ${workers} │`);
+      }
+
+      console.log("  └──────────────────┴─────────────────────────┴──────────┴─────────┘");
+    } else {
+      console.log("  Not running in host mode.");
+    }
+
+    console.log(`  Uptime: ${Math.floor(data.uptime)}s`);
+    console.log("");
+  } catch {
+    console.error("  Could not connect to ForgeHost runtime.");
+    console.error("  Is it running? (forge host start)");
+    process.exit(1);
+  }
+}
+
+async function cmdHostRestart(args) {
+  const projectId = args[0];
+  if (!projectId) {
+    console.error("  Usage: forge host restart <project-id>");
+    process.exit(1);
+  }
+
+  console.error(`  Error: Per-project restart is not yet implemented.`);
+  console.error(`  Individual project restart requires the ForgeHost supervisor to support`);
+  console.error(`  graceful worker replacement without downtime.`);
+  console.error(``);
+  console.error(`  Workarounds:`);
+  console.error(`    1. Restart the entire host:  forge host start`);
+  console.error(`    2. Use a process manager (systemd, pm2) for zero-downtime restarts`);
+  console.error(`    3. For rolling deploys, use: forge deploy --rolling`);
+  process.exit(1);
+}
+
+async function cmdHostGenerate() {
+  const hostConfig = await loadHostConfig();
+  const { resolveHostConfig } = await import("../src/core/host-config.js");
+  const { generateHostNginxConfig } = await import("../src/deploy/NginxGenerator.js");
+
+  const raw = hostConfig._isHostConfig ? hostConfig._raw : hostConfig;
+  const resolved = await resolveHostConfig(raw);
+  const routesDir = path.join(process.cwd(), "routes");
+  fs.mkdirSync(routesDir, { recursive: true });
+
+  // Generate route manifests
+  let manifestCount = 0;
+  for (const [name, svc] of Object.entries(resolved.services)) {
+    if (svc.type !== "edge") continue;
+    // Generate a minimal manifest for the route
+    const yaml = generateBasicManifest(name, svc, resolved.hostMeta);
+    if (yaml) {
+      const safeName = name.replace(/:/g, "_");
+      fs.writeFileSync(path.join(routesDir, `${safeName}.yaml`), yaml);
+      manifestCount++;
+    }
+  }
+
+  // Generate nginx config
+  const nginxConfig = generateHostNginxConfig({
+    hostMeta: resolved.hostMeta,
+    services: resolved.services,
+  });
+  const deployDir = path.join(process.cwd(), "deploy");
+  fs.mkdirSync(deployDir, { recursive: true });
+  fs.writeFileSync(path.join(deployDir, "nginx.conf"), nginxConfig);
+
+  console.log(`
+  ForgeHost artifacts generated:
+
+    routes/     ${manifestCount} route manifest(s)
+    deploy/     nginx.conf
+
+  ForgeProxy reads ./routes/*.yaml automatically.
+  `);
+}
+
+function generateBasicManifest(serviceName, svc, hostMeta) {
+  const projectId = svc._projectId;
+  const domain = projectId ? hostMeta[projectId]?.domain : null;
+
+  let yaml = `# Auto-generated for ForgeHost\n`;
+  yaml += `service: ${serviceName}\n`;
+  yaml += `prefix: ${svc.prefix ?? "/"}\n`;
+  yaml += `auth: ${svc.auth ?? "required"}\n`;
+  if (projectId) yaml += `project_id: ${projectId}\n`;
+  if (domain) yaml += `host: ${domain}\n`;
+  yaml += `\nroutes:\n`;
+  yaml += `  - method: GET\n`;
+  yaml += `    path: ""\n`;
+  yaml += `    handler: index\n`;
+  return yaml;
+}
+
+export async function cmdHost(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case "init":
+      return cmdHostInit();
+    case "start":
+      return cmdHostStart();
+    case "add":
+      return cmdHostAdd(subArgs);
+    case "remove":
+      return cmdHostRemove(subArgs);
+    case "status":
+      return cmdHostStatus();
+    case "restart":
+      return cmdHostRestart(subArgs);
+    case "generate":
+      return cmdHostGenerate();
+    default:
+      console.log(`
+  ForgeHost Commands:
+
+    forge host init              Scaffold a ForgeHost project
+    forge host start             Start the multi-project host
+    forge host add <path>        Add a project
+    forge host remove <id>       Remove a project
+    forge host status            Show per-project status
+    forge host restart <id>      Restart a project's workers
+    forge host generate          Generate nginx + route manifests
+      `);
+  }
+}