threadforge 0.1.0

package/src/core/ForgeHost.js

@@ -0,0 +1,122 @@
+/**
+ * ForgeHost — Multi-Project Hosting Platform
+ *
+ * Wraps Supervisor via composition to manage multiple projects
+ * sharing one machine, one Postgres, one Redis, and one auth system.
+ *
+ * Usage:
+ *
+ *   import { ForgeHost, defineHost } from 'threadforge';
+ *
+ *   const hostConfig = defineHost({ ... });
+ *   const host = new ForgeHost(hostConfig);
+ *   await host.start();
+ */
+
+import { Supervisor } from "./Supervisor.js";
+import { resolveAndDefine, resolveHostConfig } from "./host-config.js";
+
+export class ForgeHost {
+  /**
+   * @param {Object} hostConfig - Output from defineHost() or raw host config
+   * @param {Object} [options] - Supervisor options override
+   */
+  constructor(hostConfig, options = {}) {
+    this._hostConfig = hostConfig;
+    this._options = options;
+    this._supervisor = null;
+    this._resolvedConfig = null;
+    this._hostMeta = null;
+  }
+
+  /**
+   * Resolve all project configs, merge into one flat config,
+   * and start the Supervisor.
+   */
+  async start() {
+    // Resolve host config → flat service map → defineServices()
+    this._resolvedConfig = await resolveAndDefine(this._hostConfig);
+    this._hostMeta = this._resolvedConfig._hostMeta;
+
+    // Store host meta as JSON for workers to read
+    this._resolvedConfig._hostMetaJSON = JSON.stringify(this._hostMeta);
+
+    // Create and start the Supervisor with the merged config
+    this._supervisor = new Supervisor(this._resolvedConfig, this._options);
+    await this._supervisor.start();
+
+    this._printHostInfo();
+  }
+
+  /**
+   * Gracefully shut down the entire host.
+   */
+  async shutdown() {
+    if (this._supervisor) {
+      await this._supervisor.shutdown();
+    }
+  }
+
+  /**
+   * Get status with per-project breakdown.
+   */
+  status() {
+    if (!this._supervisor || !this._hostMeta) return null;
+
+    const base = this._supervisor._status();
+    const projects = {};
+
+    for (const [projectId, meta] of Object.entries(this._hostMeta)) {
+      const projectGroups = base.processGroups.filter((pg) =>
+        pg.services.some((s) => meta.services.includes(s.name)),
+      );
+
+      projects[projectId] = {
+        domain: meta.domain,
+        services: meta.services.length,
+        workers: projectGroups.reduce((sum, pg) => sum + pg.workers, 0),
+        schema: meta.schema,
+        keyPrefix: meta.keyPrefix,
+      };
+    }
+
+    return {
+      ...base,
+      hostMode: true,
+      domain: this._resolvedConfig._hostDomain,
+      projects,
+    };
+  }
+
+  /**
+   * Get the list of project IDs.
+   */
+  get projectIds() {
+    return Object.keys(this._hostMeta ?? {});
+  }
+
+  /**
+   * Get metadata for a specific project.
+   */
+  getProject(projectId) {
+    return this._hostMeta?.[projectId] ?? null;
+  }
+
+  _printHostInfo() {
+    console.log(`\n  ForgeHost — Multi-Project Platform`);
+    console.log(`  ─────────────────────────────────────`);
+    if (this._resolvedConfig._hostDomain) {
+      console.log(`  Domain: ${this._resolvedConfig._hostDomain}`);
+    }
+    console.log(`  Projects: ${Object.keys(this._hostMeta).length}`);
+    console.log("");
+
+    for (const [projectId, meta] of Object.entries(this._hostMeta)) {
+      const domain = meta.domain ? ` (${meta.domain})` : "";
+      console.log(`    ${projectId}${domain}`);
+      console.log(`      Services: ${meta.services.join(", ")}`);
+      console.log(`      Schema:   ${meta.schema}`);
+    }
+    console.log("");
+  }
+}

package/src/core/ForgePlatform.js

@@ -0,0 +1,145 @@
+/**
+ * ForgePlatform — Platform Mode Orchestrator
+ *
+ * Wraps ForgeHost to provide a platform-level lifecycle with
+ * domain-based multi-app routing, shared services, and
+ * platform-specific banner output.
+ *
+ * Usage:
+ *
+ *   import { ForgePlatform, definePlatform } from 'threadforge';
+ *
+ *   const config = definePlatform({ ... });
+ *   const platform = new ForgePlatform(config);
+ *   await platform.start();
+ */
+
+import { ForgeHost } from "./ForgeHost.js";
+import { resolveAppDomains, transformToHostConfig } from "./platform-config.js";
+
+export class ForgePlatform {
+  /**
+   * @param {Object} platformConfig - Output from definePlatform() or raw platform config
+   * @param {Object} [options] - Supervisor options override
+   */
+  constructor(platformConfig, options = {}) {
+    this._platformConfig = platformConfig;
+    this._options = options;
+    this._host = null;
+    this._resolvedConfig = null;
+    this._hostMeta = null;
+    this._platformApps = null;
+  }
+
+  /**
+   * Start the platform: resolve config, create ForgeHost, start.
+   */
+  async start() {
+    const raw = this._platformConfig._isPlatformConfig
+      ? this._platformConfig._raw
+      : this._platformConfig;
+
+    const hostConfig = transformToHostConfig(raw);
+    this._platformApps = raw.platform.apps;
+
+    this._host = new ForgeHost(hostConfig, this._options);
+    await this._host.start();
+
+    this._resolvedConfig = this._host._resolvedConfig;
+    this._hostMeta = this._host._resolvedConfig._hostMeta;
+    this._resolvedConfig._isPlatformMode = true;
+
+    this._printPlatformBanner();
+  }
+
+  /**
+   * Gracefully shut down the platform.
+   */
+  async shutdown() {
+    if (this._host) {
+      await this._host.shutdown();
+    }
+  }
+
+  /**
+   * Get the apps map: appId → { domains, services, schema }
+   */
+  get apps() {
+    if (!this._platformApps || !this._hostMeta) return {};
+
+    const result = {};
+    for (const [appId, app] of Object.entries(this._platformApps)) {
+      const meta = this._hostMeta[appId];
+      result[appId] = {
+        domains: resolveAppDomains(app),
+        services: meta?.services ?? [],
+        schema: meta?.schema ?? appId,
+        static: app.static ?? null,
+      };
+    }
+    return result;
+  }
+
+  /**
+   * Get the host metadata (from ForgeHost).
+   */
+  get hostMeta() {
+    return this._hostMeta ?? {};
+  }
+
+  /**
+   * Get platform status with per-app breakdown.
+   */
+  status() {
+    if (!this._host) return null;
+
+    const base = this._host.status();
+    return {
+      ...base,
+      platformMode: true,
+      apps: this.apps,
+    };
+  }
+
+  /**
+   * Collect all service names that belong to a project (not shared).
+   */
+  _collectProjectServiceNames() {
+    const names = new Set();
+    for (const meta of Object.values(this._hostMeta ?? {})) {
+      for (const svc of meta.services) names.add(svc);
+    }
+    return names;
+  }
+
+  _printPlatformBanner() {
+    console.log(`\n  ForgePlatform — Multi-App Platform Mode`);
+    console.log(`  ──────────────────────────────────────────`);
+
+    const apps = this._platformApps;
+    if (!apps) return;
+
+    console.log(`  Apps: ${Object.keys(apps).length}`);
+    console.log("");
+
+    for (const [appId, app] of Object.entries(apps)) {
+      const domains = resolveAppDomains(app);
+      const meta = this._hostMeta?.[appId];
+      console.log(`    ${appId}`);
+      console.log(`      Domains:  ${domains.join(", ")}`);
+      if (meta) {
+        console.log(`      Services: ${meta.services.join(", ")}`);
+        console.log(`      Schema:   ${meta.schema}`);
+      }
+    }
+
+    const projectServices = this._collectProjectServiceNames();
+    const allServices = Object.keys(this._resolvedConfig?.services ?? {});
+    const sharedServices = allServices.filter((s) => !projectServices.has(s));
+
+    if (sharedServices.length > 0) {
+      console.log(`\n    Shared: ${sharedServices.join(", ")}`);
+    }
+    console.log("");
+  }
+}