@decohere/cli 0.0.1-dev.100

package/commonjs/src/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("./logger.setup.js");
+const _scribe = require("@decohere/scribe");
+const _product = require("./product.js");
+const configIndex = process.argv.indexOf("--config-file");
+const configFile = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+const logLevelIndex = process.argv.indexOf("--log-level");
+const logLevel = logLevelIndex !== -1 ? process.argv[logLevelIndex + 1] : undefined;
+_scribe.scribe.withPinoPretty({
+    logLevel: (0, _scribe.resolveLogLevel)(logLevel) ?? _scribe.DefaultLogLevel,
+    when: "always"
+});
+const logger = _scribe.scribe.logger("@decohere/cli");
+const app = await _product.productCli.create({
+    configFile,
+    logLevel
+});
+let exitCode = 0;
+try {
+    await app.run();
+} catch (err) {
+    logger.error(err);
+    exitCode = 1;
+} finally{
+    _scribe.scribe.flush(()=>process.exit(exitCode));
+}

package/commonjs/src/flux.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("./logger.setup.js");
+const _flux = require("@decohere/flux");
+const _scribe = require("@decohere/scribe");
+const _rootmodule = require("./root.module.js");
+const configIndex = process.argv.indexOf("--config-file");
+const configFile = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+const logLevelIndex = process.argv.indexOf("--log-level");
+const logLevel = logLevelIndex !== -1 ? process.argv[logLevelIndex + 1] : undefined;
+_scribe.scribe.withPinoPretty({
+    logLevel: (0, _scribe.resolveLogLevel)(logLevel) ?? _scribe.DefaultLogLevel,
+    when: "always"
+});
+const logger = _scribe.scribe.logger("@decohere/cli");
+const app = await _rootmodule.RootModule.create([
+    _flux.FluxModule
+], {
+    configFile,
+    logLevel
+});
+try {
+    // Route directly to the flux module — users invoke as `flux serve`, not `flux flux serve`
+    logger.trace("running flux");
+    await app.run([
+        "flux",
+        ...process.argv.slice(2)
+    ]);
+    // Don't force an exit: let the script's pending work (timers, open handles) finish, like
+    // `node script.js` does (#504).
+    _scribe.scribe.flush();
+} catch (err) {
+    logger.error(err);
+    _scribe.scribe.flush(()=>process.exit(1));
+}

package/commonjs/src/forge.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("./logger.setup.js");
+const _forge = require("@decohere/forge");
+const _scribe = require("@decohere/scribe");
+const _rootmodule = require("./root.module.js");
+const configIndex = process.argv.indexOf("--config-file");
+const configFile = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+const logLevelIndex = process.argv.indexOf("--log-level");
+const logLevel = logLevelIndex !== -1 ? process.argv[logLevelIndex + 1] : undefined;
+_scribe.scribe.withPinoPretty({
+    logLevel: (0, _scribe.resolveLogLevel)(logLevel) ?? _scribe.DefaultLogLevel,
+    when: "always"
+});
+const logger = _scribe.scribe.logger("@decohere/cli");
+const app = await _rootmodule.RootModule.create([
+    _forge.ForgeModule
+], {
+    configFile,
+    logLevel
+});
+let exitCode = 0;
+try {
+    // Route directly to the forge module — users invoke as `forge build`, not `forge forge build`
+    await app.run([
+        "forge",
+        ...process.argv.slice(2)
+    ]);
+} catch (err) {
+    logger.error("Error running forge", err);
+    exitCode = 1;
+} finally{
+    _scribe.scribe.flush(()=>process.exit(exitCode));
+}

package/commonjs/src/logger.setup.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+require("@decohere/scribe-pino");
+require("pino-pretty");

package/commonjs/src/module.factory.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ModuleFactory", {
+    enumerable: true,
+    get: function() {
+        return ModuleFactory;
+    }
+});
+const _crucible = require("@decohere/crucible");
+class ModuleFactory {
+    static create(module, onResponse, config) {
+        const moduleConfig = config?.[module.id];
+        const actions = {
+            ...module.actions,
+            ...moduleConfig?.actions
+        };
+        const commands = {
+            ...module.commands,
+            ...moduleConfig?.commands
+        };
+        const workspaceOptions = {
+            configFile: config?.configFile,
+            rootDir: config?.rootDir
+        };
+        let container;
+        const handler = async (_optionVals, program)=>{
+            const commandOptions = program.optsWithGlobals();
+            container = await buildContainer(module, actions, workspaceOptions);
+            const resolved = resolveActions(container, actions);
+            const response = await program.run(resolved, commandOptions);
+            onResponse(module.id, response);
+        };
+        const command = new module.command(commands, handler);
+        command.name(module.id);
+        return {
+            id: module.id,
+            command,
+            dispose: ()=>container?.[Symbol.dispose](),
+            asyncDispose: ()=>container?.[Symbol.asyncDispose]()
+        };
+    }
+}
+async function buildContainer(module, actions, workspaceOptions) {
+    const builder = new _crucible.CrucibleBuilder();
+    const workspace = await module.createWorkspace(workspaceOptions ?? {});
+    if (workspace !== null) {
+        builder.registerSingleton(workspace.constructor, workspace);
+    }
+    module.registerServices(builder);
+    for (const ActionClass of Object.values(actions)){
+        builder.registerSingleton(ActionClass);
+    }
+    return builder.build();
+}
+function resolveActions(container, actions) {
+    return Object.fromEntries(Object.entries(actions).map(([key, ActionClass])=>[
+            key,
+            container.resolve(ActionClass)
+        ]));
+}

package/commonjs/src/product.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "productCli", {
+    enumerable: true,
+    get: function() {
+        return productCli;
+    }
+});
+const _flux = require("@decohere/flux");
+const _forge = require("@decohere/forge");
+const _rootmodule = require("./root.module.js");
+const _scaffoldhost = require("./scaffold-host.js");
+const modules = [
+    _forge.ForgeModule,
+    _flux.FluxModule,
+    _scaffoldhost.HostCreateModule,
+    _scaffoldhost.HostAddModule,
+    _scaffoldhost.HostAuth0Module
+];
+function create(options) {
+    return _rootmodule.RootModule.create(modules, options);
+}
+const productCli = {
+    create,
+    modules
+};

package/commonjs/src/root.command.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RootCommand", {
+    enumerable: true,
+    get: function() {
+        return RootCommand;
+    }
+});
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _commander = require("commander");
+class RootCommand extends _cli.DecohereCommand {
+    #configFile;
+    constructor(modules, configFile){
+        super();
+        this.#configFile = configFile;
+        this.addOption(new _cli.ConfigFileOption());
+        this.addOption(new _cli.LogLevelOption());
+        this.addOption(new _cli.EnvFileOption());
+        this.addOption(new _cli.EnvFileIfExistsOption());
+        // Explicit opt-in: nothing reads a .env file unless the command line names one.
+        this.hook("preAction", (command)=>{
+            const { envFile, envFileIfExists } = command.opts();
+            if (envFile) process.loadEnvFile(envFile);
+            if (envFileIfExists) loadEnvFileIfExists(envFileIfExists);
+        });
+        for (const mod of modules){
+            this.addCommand(mod.command);
+        }
+    }
+    async parseAsync(argv, options) {
+        if (argv?.includes("--version") || argv?.includes("-V")) {
+            const workspace = await _mesh.WorkspaceFactory.create({
+                configFile: this.#configFile
+            });
+            const version = await workspace.getVersion() ?? "unknown";
+            process.stdout.write(`${version}\n`);
+            throw new _commander.CommanderError(0, "commander.version", version);
+        }
+        return super.parseAsync(argv, options);
+    }
+}
+function loadEnvFileIfExists(path) {
+    try {
+        process.loadEnvFile(path);
+    } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+    }
+}

package/commonjs/src/root.module.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RootModule", {
+    enumerable: true,
+    get: function() {
+        return RootModule;
+    }
+});
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _commander = require("commander");
+const _modulefactory = require("./module.factory.js");
+const _rootcommand = require("./root.command.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class RootModule {
+    static async create(moduleTypes, options) {
+        const userConfig = await _mesh.UserConfigFactory.getUserConfig(options?.configFile);
+        return new RootModule(moduleTypes, {
+            ...userConfig,
+            configFile: options?.configFile,
+            rootDir: options?.rootDir
+        });
+    }
+    #command;
+    #modules;
+    #lastResponse = {};
+    constructor(manifestClasses, config){
+        const modules = manifestClasses.map((ManifestClass)=>{
+            const manifest = new ManifestClass();
+            return _modulefactory.ModuleFactory.create(manifest, this.onResponse, config);
+        });
+        this.#modules = modules;
+        this.#command = new _rootcommand.RootCommand(modules, config.configFile);
+    }
+    onResponse = (_moduleId, response)=>{
+        this.#lastResponse = response;
+    };
+    async run(argv) {
+        try {
+            await this.#command.parseAsync(argv, argv ? {
+                from: "user"
+            } : undefined);
+            if (this.isBlocking(this.#lastResponse)) {
+                await untilStopSignal();
+            }
+            return this.#lastResponse;
+        } catch (error) {
+            if (this.isCommanderHelpOrVersion(error)) {
+                return _cli.CommandResponse.help();
+            }
+            throw error;
+        } finally{
+            await this[Symbol.asyncDispose]();
+        }
+    }
+    get commands() {
+        return this.#command.commands;
+    }
+    [Symbol.dispose]() {
+        for (const mod of this.#modules){
+            mod.dispose?.();
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        for (const mod of this.#modules){
+            await mod.asyncDispose?.();
+        }
+    }
+    isBlocking(response) {
+        return Object.values(response).some((r)=>r?.blocking === true);
+    }
+    isCommanderHelpOrVersion(error) {
+        const isCommanderError = error instanceof _commander.CommanderError;
+        const helpCodes = [
+            "commander.helpDisplayed",
+            "commander.version",
+            "commander.help"
+        ];
+        return isCommanderError && helpCodes.includes(error.code);
+    }
+}
+RootModule = _ts_decorate([
+    _diagnostics.Trace,
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        typeof Record === "undefined" ? Object : Record
+    ])
+], RootModule);
+/**
+ * Resolves on Ctrl+C (SIGINT) or SIGTERM (Docker, CI, process managers), so long-running
+ * commands like `flux serve` shut down cleanly either way (#520).
+ */ function untilStopSignal() {
+    return new Promise((resolve)=>{
+        const stop = ()=>{
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+            resolve();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    });
+}

package/commonjs/src/scaffold-host.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get HostAddModule () {
+        return HostAddModule;
+    },
+    get HostAuth0Module () {
+        return HostAuth0Module;
+    },
+    get HostCreateModule () {
+        return HostCreateModule;
+    }
+});
+const _create = require("@decohere/create");
+const _decorators = require("@decohere/crucible/decorators");
+const _scaffold = require("@decohere/scaffold");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class HostWebapiAction extends _scaffold.WebapiAction {
+    async run(options) {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            (0, _create.runInBuilder)((0, _create.containerArgvFromHost)(process.argv));
+        }
+        return super.run(options);
+    }
+}
+HostWebapiAction = _ts_decorate([
+    (0, _decorators.injectable)()
+], HostWebapiAction);
+class HostAddApiAction extends _scaffold.AddApiAction {
+    async run(options) {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            (0, _create.runInBuilder)((0, _create.containerArgvFromHost)(process.argv));
+        }
+        return super.run(options);
+    }
+}
+HostAddApiAction = _ts_decorate([
+    (0, _decorators.injectable)()
+], HostAddApiAction);
+class HostCreateModule extends _scaffold.CreateModule {
+    actions = {
+        webapi: HostWebapiAction
+    };
+}
+class HostAddModule extends _scaffold.AddModule {
+    actions = {
+        api: HostAddApiAction
+    };
+}
+class HostAuth0LoginAction extends _scaffold.Auth0LoginAction {
+    async run() {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            (0, _create.runInBuilder)((0, _create.containerArgvFromHost)(process.argv));
+        }
+        return super.run();
+    }
+}
+HostAuth0LoginAction = _ts_decorate([
+    (0, _decorators.injectable)()
+], HostAuth0LoginAction);
+class HostAuth0ConfigureAction extends _scaffold.Auth0ConfigureAction {
+    async run(options) {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            (0, _create.runInBuilder)((0, _create.containerArgvFromHost)(process.argv));
+        }
+        return super.run(options);
+    }
+}
+HostAuth0ConfigureAction = _ts_decorate([
+    (0, _decorators.injectable)()
+], HostAuth0ConfigureAction);
+class HostAuth0Module extends _scaffold.Auth0Module {
+    actions = {
+        login: HostAuth0LoginAction,
+        configure: HostAuth0ConfigureAction
+    };
+}

package/es6/src/cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import "./logger.setup.js";
+import { DefaultLogLevel, resolveLogLevel, scribe } from "@decohere/scribe";
+import { productCli } from "./product.js";
+const configIndex = process.argv.indexOf("--config-file");
+const configFile = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+const logLevelIndex = process.argv.indexOf("--log-level");
+const logLevel = logLevelIndex !== -1 ? process.argv[logLevelIndex + 1] : undefined;
+scribe.withPinoPretty({
+    logLevel: resolveLogLevel(logLevel) ?? DefaultLogLevel,
+    when: "always"
+});
+const logger = scribe.logger("@decohere/cli");
+const app = await productCli.create({
+    configFile,
+    logLevel
+});
+let exitCode = 0;
+try {
+    await app.run();
+} catch (err) {
+    logger.error(err);
+    exitCode = 1;
+} finally{
+    scribe.flush(()=>process.exit(exitCode));
+}

package/es6/src/flux.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import "./logger.setup.js";
+import { FluxModule } from "@decohere/flux";
+import { DefaultLogLevel, resolveLogLevel, scribe } from "@decohere/scribe";
+import { RootModule } from "./root.module.js";
+const configIndex = process.argv.indexOf("--config-file");
+const configFile = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+const logLevelIndex = process.argv.indexOf("--log-level");
+const logLevel = logLevelIndex !== -1 ? process.argv[logLevelIndex + 1] : undefined;
+scribe.withPinoPretty({
+    logLevel: resolveLogLevel(logLevel) ?? DefaultLogLevel,
+    when: "always"
+});
+const logger = scribe.logger("@decohere/cli");
+const app = await RootModule.create([
+    FluxModule
+], {
+    configFile,
+    logLevel
+});
+try {
+    // Route directly to the flux module — users invoke as `flux serve`, not `flux flux serve`
+    logger.trace("running flux");
+    await app.run([
+        "flux",
+        ...process.argv.slice(2)
+    ]);
+    // Don't force an exit: let the script's pending work (timers, open handles) finish, like
+    // `node script.js` does (#504).
+    scribe.flush();
+} catch (err) {
+    logger.error(err);
+    scribe.flush(()=>process.exit(1));
+}

package/es6/src/forge.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import "./logger.setup.js";
+import { ForgeModule } from "@decohere/forge";
+import { DefaultLogLevel, resolveLogLevel, scribe } from "@decohere/scribe";
+import { RootModule } from "./root.module.js";
+const configIndex = process.argv.indexOf("--config-file");
+const configFile = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+const logLevelIndex = process.argv.indexOf("--log-level");
+const logLevel = logLevelIndex !== -1 ? process.argv[logLevelIndex + 1] : undefined;
+scribe.withPinoPretty({
+    logLevel: resolveLogLevel(logLevel) ?? DefaultLogLevel,
+    when: "always"
+});
+const logger = scribe.logger("@decohere/cli");
+const app = await RootModule.create([
+    ForgeModule
+], {
+    configFile,
+    logLevel
+});
+let exitCode = 0;
+try {
+    // Route directly to the forge module — users invoke as `forge build`, not `forge forge build`
+    await app.run([
+        "forge",
+        ...process.argv.slice(2)
+    ]);
+} catch (err) {
+    logger.error("Error running forge", err);
+    exitCode = 1;
+} finally{
+    scribe.flush(()=>process.exit(exitCode));
+}

package/es6/src/logger.setup.js

@@ -0,0 +1,2 @@
+import "@decohere/scribe-pino";
+import "pino-pretty";

package/es6/src/module.factory.js

@@ -0,0 +1,56 @@
+import { CrucibleBuilder } from "@decohere/crucible";
+/**
+ * Wires a ModuleManifest into a fully functional ApplicationModule.
+ * Handles DI container setup, action registration/resolution, and
+ * forwarding the command response to the caller.
+ */ export class ModuleFactory {
+    static create(module, onResponse, config) {
+        const moduleConfig = config?.[module.id];
+        const actions = {
+            ...module.actions,
+            ...moduleConfig?.actions
+        };
+        const commands = {
+            ...module.commands,
+            ...moduleConfig?.commands
+        };
+        const workspaceOptions = {
+            configFile: config?.configFile,
+            rootDir: config?.rootDir
+        };
+        let container;
+        const handler = async (_optionVals, program)=>{
+            const commandOptions = program.optsWithGlobals();
+            container = await buildContainer(module, actions, workspaceOptions);
+            const resolved = resolveActions(container, actions);
+            const response = await program.run(resolved, commandOptions);
+            onResponse(module.id, response);
+        };
+        const command = new module.command(commands, handler);
+        command.name(module.id);
+        return {
+            id: module.id,
+            command,
+            dispose: ()=>container?.[Symbol.dispose](),
+            asyncDispose: ()=>container?.[Symbol.asyncDispose]()
+        };
+    }
+}
+async function buildContainer(module, actions, workspaceOptions) {
+    const builder = new CrucibleBuilder();
+    const workspace = await module.createWorkspace(workspaceOptions ?? {});
+    if (workspace !== null) {
+        builder.registerSingleton(workspace.constructor, workspace);
+    }
+    module.registerServices(builder);
+    for (const ActionClass of Object.values(actions)){
+        builder.registerSingleton(ActionClass);
+    }
+    return builder.build();
+}
+function resolveActions(container, actions) {
+    return Object.fromEntries(Object.entries(actions).map(([key, ActionClass])=>[
+            key,
+            container.resolve(ActionClass)
+        ]));
+}

package/es6/src/product.js

@@ -0,0 +1,18 @@
+import { FluxModule } from "@decohere/flux";
+import { ForgeModule } from "@decohere/forge";
+import { RootModule } from "./root.module.js";
+import { HostAddModule, HostAuth0Module, HostCreateModule } from "./scaffold-host.js";
+const modules = [
+    ForgeModule,
+    FluxModule,
+    HostCreateModule,
+    HostAddModule,
+    HostAuth0Module
+];
+function create(options) {
+    return RootModule.create(modules, options);
+}
+/** Shipped `decohere` bin — forge, flux, create, add, auth0. */ export const productCli = {
+    create,
+    modules
+};

package/es6/src/root.command.js

@@ -0,0 +1,41 @@
+import { WorkspaceFactory } from "@decohere/mesh";
+import { ConfigFileOption, DecohereCommand, EnvFileIfExistsOption, EnvFileOption, LogLevelOption } from "@decohere/nexus/cli";
+import { CommanderError } from "commander";
+export class RootCommand extends DecohereCommand {
+    #configFile;
+    constructor(modules, configFile){
+        super();
+        this.#configFile = configFile;
+        this.addOption(new ConfigFileOption());
+        this.addOption(new LogLevelOption());
+        this.addOption(new EnvFileOption());
+        this.addOption(new EnvFileIfExistsOption());
+        // Explicit opt-in: nothing reads a .env file unless the command line names one.
+        this.hook("preAction", (command)=>{
+            const { envFile, envFileIfExists } = command.opts();
+            if (envFile) process.loadEnvFile(envFile);
+            if (envFileIfExists) loadEnvFileIfExists(envFileIfExists);
+        });
+        for (const mod of modules){
+            this.addCommand(mod.command);
+        }
+    }
+    async parseAsync(argv, options) {
+        if (argv?.includes("--version") || argv?.includes("-V")) {
+            const workspace = await WorkspaceFactory.create({
+                configFile: this.#configFile
+            });
+            const version = await workspace.getVersion() ?? "unknown";
+            process.stdout.write(`${version}\n`);
+            throw new CommanderError(0, "commander.version", version);
+        }
+        return super.parseAsync(argv, options);
+    }
+}
+function loadEnvFileIfExists(path) {
+    try {
+        process.loadEnvFile(path);
+    } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+    }
+}

package/es6/src/root.module.js

@@ -0,0 +1,104 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { UserConfigFactory } from "@decohere/mesh";
+import { CommandResponse } from "@decohere/nexus/cli";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { CommanderError } from "commander";
+import { ModuleFactory } from "./module.factory.js";
+import { RootCommand } from "./root.command.js";
+export class RootModule {
+    static async create(moduleTypes, options) {
+        const userConfig = await UserConfigFactory.getUserConfig(options?.configFile);
+        return new RootModule(moduleTypes, {
+            ...userConfig,
+            configFile: options?.configFile,
+            rootDir: options?.rootDir
+        });
+    }
+    #command;
+    #modules;
+    #lastResponse = {};
+    constructor(manifestClasses, config){
+        const modules = manifestClasses.map((ManifestClass)=>{
+            const manifest = new ManifestClass();
+            return ModuleFactory.create(manifest, this.onResponse, config);
+        });
+        this.#modules = modules;
+        this.#command = new RootCommand(modules, config.configFile);
+    }
+    onResponse = (_moduleId, response)=>{
+        this.#lastResponse = response;
+    };
+    async run(argv) {
+        try {
+            await this.#command.parseAsync(argv, argv ? {
+                from: "user"
+            } : undefined);
+            if (this.isBlocking(this.#lastResponse)) {
+                await untilStopSignal();
+            }
+            return this.#lastResponse;
+        } catch (error) {
+            if (this.isCommanderHelpOrVersion(error)) {
+                return CommandResponse.help();
+            }
+            throw error;
+        } finally{
+            await this[Symbol.asyncDispose]();
+        }
+    }
+    get commands() {
+        return this.#command.commands;
+    }
+    [Symbol.dispose]() {
+        for (const mod of this.#modules){
+            mod.dispose?.();
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        for (const mod of this.#modules){
+            await mod.asyncDispose?.();
+        }
+    }
+    isBlocking(response) {
+        return Object.values(response).some((r)=>r?.blocking === true);
+    }
+    isCommanderHelpOrVersion(error) {
+        const isCommanderError = error instanceof CommanderError;
+        const helpCodes = [
+            "commander.helpDisplayed",
+            "commander.version",
+            "commander.help"
+        ];
+        return isCommanderError && helpCodes.includes(error.code);
+    }
+}
+RootModule = _ts_decorate([
+    Trace,
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Object,
+        typeof Record === "undefined" ? Object : Record
+    ])
+], RootModule);
+/**
+ * Resolves on Ctrl+C (SIGINT) or SIGTERM (Docker, CI, process managers), so long-running
+ * commands like `flux serve` shut down cleanly either way (#520).
+ */ function untilStopSignal() {
+    return new Promise((resolve)=>{
+        const stop = ()=>{
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+            resolve();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    });
+}

package/es6/src/scaffold-host.js

@@ -0,0 +1,69 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { containerArgvFromHost, runInBuilder } from "@decohere/create";
+import { injectable } from "@decohere/crucible/decorators";
+import { AddApiAction, AddModule, Auth0ConfigureAction, Auth0LoginAction, Auth0Module, CreateModule, WebapiAction } from "@decohere/scaffold";
+class HostWebapiAction extends WebapiAction {
+    async run(options) {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            runInBuilder(containerArgvFromHost(process.argv));
+        }
+        return super.run(options);
+    }
+}
+HostWebapiAction = _ts_decorate([
+    injectable()
+], HostWebapiAction);
+class HostAddApiAction extends AddApiAction {
+    async run(options) {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            runInBuilder(containerArgvFromHost(process.argv));
+        }
+        return super.run(options);
+    }
+}
+HostAddApiAction = _ts_decorate([
+    injectable()
+], HostAddApiAction);
+/** Host `decohere create` — Docker-delegates unless already inside the builder image. */ export class HostCreateModule extends CreateModule {
+    actions = {
+        webapi: HostWebapiAction
+    };
+}
+/** Host `decohere add` — Docker-delegates unless already inside the builder image. */ export class HostAddModule extends AddModule {
+    actions = {
+        api: HostAddApiAction
+    };
+}
+class HostAuth0LoginAction extends Auth0LoginAction {
+    async run() {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            runInBuilder(containerArgvFromHost(process.argv));
+        }
+        return super.run();
+    }
+}
+HostAuth0LoginAction = _ts_decorate([
+    injectable()
+], HostAuth0LoginAction);
+class HostAuth0ConfigureAction extends Auth0ConfigureAction {
+    async run(options) {
+        if (process.env.DECOHERE_BUILDER !== "1") {
+            runInBuilder(containerArgvFromHost(process.argv));
+        }
+        return super.run(options);
+    }
+}
+HostAuth0ConfigureAction = _ts_decorate([
+    injectable()
+], HostAuth0ConfigureAction);
+/** Host `decohere auth0` — Docker-delegates unless already inside the builder image. */ export class HostAuth0Module extends Auth0Module {
+    actions = {
+        login: HostAuth0LoginAction,
+        configure: HostAuth0ConfigureAction
+    };
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@decohere/cli",
+  "version": "0.0.1-dev.100",
+  "description": "CLI for the Decohere toolchain — build, serve, publish, and manage TypeScript monorepos",
+  "keywords": [
+    "typescript",
+    "cli",
+    "monorepo",
+    "build",
+    "decohere"
+  ],
+  "license": "ISC",
+  "author": "Typesmiths",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/src/index.d.ts",
+      "import": "./es6/src/index.js",
+      "require": "./commonjs/src/index.js"
+    }
+  },
+  "bin": {
+    "decohere": "./es6/src/cli.js",
+    "forge": "./es6/src/forge.js",
+    "flux": "./es6/src/flux.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@decohere/create": "0.0.1-dev.100",
+    "@decohere/crucible": "0.0.1-dev.100",
+    "@decohere/flux": "0.0.1-dev.100",
+    "@decohere/forge": "0.0.1-dev.100",
+    "@decohere/mesh": "0.0.1-dev.100",
+    "@decohere/nexus": "0.0.1-dev.100",
+    "@decohere/scaffold": "0.0.1-dev.100",
+    "@decohere/scribe": "0.0.1-dev.100",
+    "@decohere/scribe-pino": "0.0.1-dev.100",
+    "commander": "^13.1.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {}
+}

package/tests/__fixtures__/hmr-slice/projects/mod/web/write-marker.mjs

@@ -0,0 +1,6 @@
+import { writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+writeFileSync(join(dirname(fileURLToPath(import.meta.url)), "deferred.marker"), "1");
+setInterval(() => {}, 60_000);

package/types/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./logger.setup.js";

package/types/src/flux.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./logger.setup.js";

package/types/src/forge.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./logger.setup.js";

package/types/src/logger.setup.d.ts

@@ -0,0 +1,2 @@
+import "@decohere/scribe-pino";
+import "pino-pretty";

package/types/src/module.factory.d.ts

@@ -0,0 +1,9 @@
+import type { ApplicationModule, CommandResponse, ModuleManifest } from "@decohere/nexus/cli";
+/**
+ * Wires a ModuleManifest into a fully functional ApplicationModule.
+ * Handles DI container setup, action registration/resolution, and
+ * forwarding the command response to the caller.
+ */
+export declare class ModuleFactory {
+    static create(module: ModuleManifest, onResponse: (moduleId: string, response: CommandResponse) => void, config?: Record<string, unknown>): ApplicationModule;
+}

package/types/src/product.d.ts

@@ -0,0 +1,15 @@
+import { FluxModule } from "@decohere/flux";
+import { ForgeModule } from "@decohere/forge";
+import { RootModule } from "./root.module.js";
+import { HostAddModule, HostAuth0Module, HostCreateModule } from "./scaffold-host.js";
+declare function create(options?: {
+    configFile?: string;
+    logLevel?: string;
+    rootDir?: string;
+}): Promise<RootModule>;
+/** Shipped `decohere` bin — forge, flux, create, add, auth0. */
+export declare const productCli: {
+    create: typeof create;
+    modules: readonly [typeof ForgeModule, typeof FluxModule, typeof HostCreateModule, typeof HostAddModule, typeof HostAuth0Module];
+};
+export {};

package/types/src/root.command.d.ts

@@ -0,0 +1,7 @@
+import { type ApplicationModule, DecohereCommand } from "@decohere/nexus/cli";
+import { type ParseOptions } from "commander";
+export declare class RootCommand extends DecohereCommand {
+    #private;
+    constructor(modules: ApplicationModule[], configFile?: string);
+    parseAsync(argv?: readonly string[], options?: ParseOptions): Promise<this>;
+}

package/types/src/root.module.d.ts

@@ -0,0 +1,20 @@
+import type { Actions, ModuleManifest } from "@decohere/nexus/cli";
+import { CommandResponse } from "@decohere/nexus/cli";
+import type { Constructable } from "@decohere/nexus/reflection";
+import type { Command } from "commander";
+export declare class RootModule {
+    #private;
+    static create(moduleTypes: readonly Constructable<ModuleManifest>[], options?: {
+        configFile?: string;
+        logLevel?: string;
+        rootDir?: string;
+    }): Promise<RootModule>;
+    private constructor();
+    private onResponse;
+    run<TActions extends Actions>(argv?: string[]): Promise<CommandResponse<TActions>>;
+    get commands(): Command[];
+    [Symbol.dispose](): void;
+    [Symbol.asyncDispose](): Promise<void>;
+    private isBlocking;
+    private isCommanderHelpOrVersion;
+}

package/types/src/scaffold-host.d.ts

@@ -0,0 +1,34 @@
+import type { ActionResponse } from "@decohere/nexus/cli";
+import { AddApiAction, type AddApiOptions, AddModule, Auth0ConfigureAction, type Auth0ConfigureOptions, Auth0LoginAction, Auth0Module, CreateModule, WebapiAction, type WebapiOptions } from "@decohere/scaffold";
+declare class HostWebapiAction extends WebapiAction {
+    run(options: WebapiOptions): Promise<ActionResponse>;
+}
+declare class HostAddApiAction extends AddApiAction {
+    run(options: AddApiOptions): Promise<ActionResponse>;
+}
+/** Host `decohere create` — Docker-delegates unless already inside the builder image. */
+export declare class HostCreateModule extends CreateModule {
+    readonly actions: {
+        webapi: typeof HostWebapiAction;
+    };
+}
+/** Host `decohere add` — Docker-delegates unless already inside the builder image. */
+export declare class HostAddModule extends AddModule {
+    readonly actions: {
+        api: typeof HostAddApiAction;
+    };
+}
+declare class HostAuth0LoginAction extends Auth0LoginAction {
+    run(): Promise<ActionResponse>;
+}
+declare class HostAuth0ConfigureAction extends Auth0ConfigureAction {
+    run(options: Auth0ConfigureOptions): Promise<ActionResponse>;
+}
+/** Host `decohere auth0` — Docker-delegates unless already inside the builder image. */
+export declare class HostAuth0Module extends Auth0Module {
+    readonly actions: {
+        login: typeof HostAuth0LoginAction;
+        configure: typeof HostAuth0ConfigureAction;
+    };
+}
+export {};