@cordisjs/cli-cordis 0.0.0 → 2.0.0-rc.0

package/README.md

@@ -0,0 +1 @@
+# @cordisjs/cli-cordis

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'cordis';
+import type { Config } from './worker/index.ts';
+export declare const name = "cli-cordis";
+export declare const inject: string[];
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { fork } from "node:child_process";
+import { extname, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import kleur from "kleur";
+var name = "cli-cordis";
+var inject = ["cli"];
+function apply(ctx, config) {
+  ctx.cli.command("", "Meta-framework of spatiotemporal composability").option("-v, --version", "Show version").action(({ options }) => {
+    if (options.version) {
+      const require2 = createRequire(import.meta.url);
+      const { version } = require2("cordis/package.json");
+      return `cordis ${version}`;
+    }
+  });
+  ctx.cli.command("run [url]", "Start a Cordis application").option("-d, --daemon", "Run as daemon", { default: config.daemon.enabled }).action(async ({ args, options }) => {
+    const workerConfig = { ...config };
+    workerConfig.baseUrl ??= ctx.baseUrl;
+    if (args[0]) {
+      workerConfig.path = args[0];
+    }
+    if (options.daemon) {
+      createWorker(workerConfig);
+    } else {
+      const { start } = await import("./worker/index.js");
+      await start(workerConfig);
+    }
+  });
+}
+__name(apply, "apply");
+var child;
+function createWorker(config) {
+  let timer;
+  let started = false;
+  let exiting = false;
+  process.env.CORDIS_SHARED = JSON.stringify({
+    startTime: Date.now()
+  });
+  const filename = fileURLToPath(import.meta.url);
+  child = fork(resolve(filename, `../worker/main${extname(filename)}`), [], {
+    execArgv: [
+      ...process.execArgv,
+      ...config.execArgv || [],
+      "--expose-internals"
+    ],
+    env: {
+      ...process.env,
+      CORDIS_LOADER_OPTIONS: JSON.stringify(config)
+    }
+  });
+  child.on("message", (message) => {
+    if (message.type === "start") {
+      started = true;
+      timer = config.daemon?.heartbeatTimeout && setTimeout(() => {
+        console.log(kleur.red("daemon: heartbeat timeout"));
+        child.kill("SIGKILL");
+      }, config.daemon?.heartbeatTimeout);
+    } else if (message.type === "shared") {
+      process.env.CORDIS_SHARED = message.body;
+    } else if (message.type === "heartbeat") {
+      if (timer) timer.refresh();
+    } else if (message.type === "exit") {
+      exiting = true;
+    }
+  });
+  const signals = [
+    "SIGABRT",
+    "SIGBREAK",
+    "SIGBUS",
+    "SIGFPE",
+    "SIGHUP",
+    "SIGILL",
+    "SIGINT",
+    "SIGKILL",
+    "SIGSEGV",
+    "SIGSTOP",
+    "SIGTERM"
+  ];
+  function shouldExit(code, signal) {
+    if (!started) return true;
+    if (exiting) return true;
+    if (code === 0) return true;
+    if (signals.includes(signal)) return true;
+    if (code === 51) return false;
+    if (code === 52) return true;
+    return !config.daemon?.autoRestart;
+  }
+  __name(shouldExit, "shouldExit");
+  child.on("exit", (code, signal) => {
+    if (shouldExit(code, signal)) {
+      process.exit(code);
+    }
+    createWorker(config);
+  });
+}
+__name(createWorker, "createWorker");
+export {
+  apply,
+  inject,
+  name
+};

package/lib/worker/daemon.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'cordis';
+export interface Config {
+    enabled?: boolean;
+    autoRestart?: boolean;
+    heartbeatInterval?: number;
+    heartbeatTimeout?: number;
+    exitTimeout?: number;
+}
+export declare const name = "daemon";
+export declare function apply(ctx: Context, config?: Config): Generator<() => void, void, unknown>;

package/lib/worker/index.d.ts

@@ -0,0 +1,10 @@
+import { EntryOptions } from '@cordisjs/loader';
+import * as daemon from './daemon.ts';
+export interface Config {
+    baseUrl?: string;
+    execArgv?: string[];
+    path: string;
+    daemon: daemon.Config;
+    prelude?: EntryOptions[];
+}
+export declare function start(config: Config): Promise<void>;

package/lib/worker/index.js

@@ -0,0 +1,103 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
+// src/worker/index.ts
+import { Context } from "cordis";
+import { noop } from "cosmokit";
+import Fs from "@cordisjs/fs";
+import NodeFs from "@cordisjs/fs-node";
+import { Loader } from "@cordisjs/loader";
+
+// src/worker/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  apply: () => apply,
+  name: () => name
+});
+var name = "daemon";
+var closedErrors = ["EPIPE", "ECONNRESET", "ERR_IPC_CHANNEL_CLOSED"];
+function* apply(ctx, config = {}) {
+  let exiting = false;
+  function send(message) {
+    process.send?.(message, (error) => {
+      if (!error || closedErrors.includes(error.code)) return;
+      ctx.logger.warn(error);
+    });
+  }
+  __name(send, "send");
+  function exit(signal, reason) {
+    if (exiting) return;
+    exiting = true;
+    setTimeout(() => process.exit(1), config.exitTimeout ?? 1e4).unref();
+    ctx.logger.info(reason);
+    ctx.parallel("exit", signal).finally(() => process.exit());
+  }
+  __name(exit, "exit");
+  function handleSignal(signal) {
+    process.stderr.write("\x1B[2K\r");
+    send({ type: "exit" });
+    exit(signal, `terminated by ${signal}`);
+  }
+  __name(handleSignal, "handleSignal");
+  function handleDisconnect() {
+    exit("SIGHUP", "parent process disconnected");
+  }
+  __name(handleDisconnect, "handleDisconnect");
+  process.on("SIGINT", handleSignal);
+  yield () => process.off("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  yield () => process.off("SIGTERM", handleSignal);
+  process.on("disconnect", handleDisconnect);
+  yield () => process.off("disconnect", handleDisconnect);
+  if (process.send && !process.connected) {
+    handleDisconnect();
+    return;
+  }
+  send({ type: "start", body: config });
+  if (config.heartbeatInterval) {
+    const timer = setInterval(() => {
+      send({ type: "heartbeat" });
+    }, config.heartbeatInterval);
+    yield () => clearInterval(timer);
+  }
+}
+__name(apply, "apply");
+
+// src/worker/index.ts
+async function start(config) {
+  const ctx = new Context();
+  process.stdout.on("error", noop);
+  process.stderr.on("error", noop);
+  process.on("uncaughtException", (error) => {
+    ctx.logger.error(error);
+    process.exitCode = 1;
+  });
+  process.on("unhandledRejection", (error) => {
+    ctx.logger.warn(error);
+  });
+  ctx.baseUrl = config.baseUrl;
+  if (config.daemon.enabled) {
+    await ctx.use(daemon_exports, config.daemon);
+  }
+  await ctx.use(Fs);
+  await ctx.use(NodeFs);
+  await ctx.use(Loader);
+  for (const options of config.prelude ?? []) {
+    await ctx.loader.create(options);
+  }
+  await ctx.loader.create({
+    name: "@cordisjs/include",
+    config: {
+      path: config.path,
+      enableLogs: true
+    }
+  });
+}
+__name(start, "start");
+export {
+  start
+};

package/lib/worker/main.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker/main.js

@@ -0,0 +1,5 @@
+// src/worker/main.ts
+import assert from "node:assert";
+import { start } from "./index.js";
+assert.ok(process.env.CORDIS_LOADER_OPTIONS);
+start(JSON.parse(process.env.CORDIS_LOADER_OPTIONS));

package/package.json

@@ -1 +1,59 @@
-{ "name": "@cordisjs/cli-cordis", "version": "0.0.0" }
+{
+  "name": "@cordisjs/cli-cordis",
+  "version": "2.0.0-rc.0",
+  "description": "Commands for running Cordis applications",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "sideEffects": [
+    "./lib/worker/main.js",
+    "./src/worker/main.ts"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./worker": {
+      "types": "./lib/worker/index.d.ts",
+      "default": "./lib/worker/index.js"
+    },
+    "./main": "./lib/worker/main.js",
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src"
+  ],
+  "author": "Shigma <shigma10826@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cordiverse/cordis.git",
+    "directory": "packages/cli-cordis"
+  },
+  "bugs": {
+    "url": "https://github.com/cordiverse/cordis/issues"
+  },
+  "homepage": "https://github.com/cordiverse/cordis",
+  "peerDependencies": {
+    "@cordisjs/cli": "^4.0.0",
+    "@cordisjs/fs": "^2.0.0-rc.0",
+    "@cordisjs/fs-node": "^0.1.0",
+    "@cordisjs/loader": "^1.0.0-rc.10",
+    "cordis": "^4.0.0-rc.13"
+  },
+  "devDependencies": {
+    "@cordisjs/cli": "^4.0.0",
+    "@cordisjs/fs": "^2.0.0-rc.0",
+    "@cordisjs/fs-node": "^0.1.0",
+    "@cordisjs/loader": "^1.0.0-rc.10",
+    "@cordisjs/logger-console": "^1.0.1",
+    "cordis": "^4.0.0-rc.13"
+  },
+  "dependencies": {
+    "cosmokit": "^1.8.1",
+    "kleur": "^4.1.5"
+  }
+}

package/src/index.ts

@@ -0,0 +1,112 @@
+import { ChildProcess, fork } from 'node:child_process'
+import { extname, resolve } from 'node:path'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import { Context } from 'cordis'
+import type {} from '@cordisjs/cli'
+import type { Config } from './worker/index.ts'
+import kleur from 'kleur'
+
+export const name = 'cli-cordis'
+export const inject = ['cli']
+
+interface Event {
+  type: 'start' | 'shared' | 'heartbeat' | 'exit'
+  body?: string
+}
+
+export function apply(ctx: Context, config: Config) {
+  ctx.cli
+    .command('', 'Meta-framework of spatiotemporal composability')
+    .option('-v, --version', 'Show version')
+    .action(({ options }) => {
+      if (options.version) {
+        const require = createRequire(import.meta.url)
+        const { version } = require('cordis/package.json')
+        return `cordis ${version}`
+      }
+    })
+
+  ctx.cli
+    .command('run [url]', 'Start a Cordis application')
+    .option('-d, --daemon', 'Run as daemon', { default: config.daemon.enabled })
+    .action(async ({ args, options }) => {
+      const workerConfig: Config = { ...config }
+      workerConfig.baseUrl ??= ctx.baseUrl
+      if (args[0]) {
+        workerConfig.path = args[0]
+      }
+
+      if (options.daemon) {
+        createWorker(workerConfig)
+      } else {
+        // Direct mode: load in the same process
+        const { start } = await import('./worker/index.ts')
+        await start(workerConfig)
+      }
+    })
+}
+
+let child: ChildProcess
+
+function createWorker(config: Config) {
+  let timer: 0 | NodeJS.Timeout | undefined
+  let started = false
+  let exiting = false
+
+  process.env.CORDIS_SHARED = JSON.stringify({
+    startTime: Date.now(),
+  })
+
+  const filename = fileURLToPath(import.meta.url)
+  child = fork(resolve(filename, `../worker/main${extname(filename)}`), [], {
+    execArgv: [
+      ...process.execArgv,
+      ...config.execArgv || [],
+      '--expose-internals',
+    ],
+    env: {
+      ...process.env,
+      CORDIS_LOADER_OPTIONS: JSON.stringify(config),
+    },
+  })
+
+  child.on('message', (message: Event) => {
+    if (message.type === 'start') {
+      started = true
+      timer = config.daemon?.heartbeatTimeout && setTimeout(() => {
+        // eslint-disable-next-line no-console
+        console.log(kleur.red('daemon: heartbeat timeout'))
+        child.kill('SIGKILL')
+      }, config.daemon?.heartbeatTimeout)
+    } else if (message.type === 'shared') {
+      process.env.CORDIS_SHARED = message.body
+    } else if (message.type === 'heartbeat') {
+      if (timer) timer.refresh()
+    } else if (message.type === 'exit') {
+      exiting = true
+    }
+  })
+
+  const signals: NodeJS.Signals[] = [
+    'SIGABRT', 'SIGBREAK', 'SIGBUS', 'SIGFPE', 'SIGHUP',
+    'SIGILL', 'SIGINT', 'SIGKILL', 'SIGSEGV', 'SIGSTOP', 'SIGTERM',
+  ]
+
+  function shouldExit(code: number, signal: NodeJS.Signals) {
+    if (!started) return true
+    if (exiting) return true
+    if (code === 0) return true
+    if (signals.includes(signal)) return true
+    if (code === 51) return false
+    if (code === 52) return true
+    return !config.daemon?.autoRestart
+  }
+
+  child.on('exit', (code, signal) => {
+    if (shouldExit(code!, signal!)) {
+      process.exit(code!)
+    }
+    createWorker(config)
+  })
+}

package/src/worker/daemon.ts

@@ -0,0 +1,72 @@
+import { Context } from 'cordis'
+
+export interface Config {
+  enabled?: boolean
+  autoRestart?: boolean
+  heartbeatInterval?: number
+  heartbeatTimeout?: number
+  exitTimeout?: number
+}
+
+export const name = 'daemon'
+
+// errors raised by writing to an IPC channel whose peer has gone
+const closedErrors = ['EPIPE', 'ECONNRESET', 'ERR_IPC_CHANNEL_CLOSED']
+
+export function* apply(ctx: Context, config: Config = {}) {
+  let exiting = false
+
+  // `process.send` is undefined when the worker is not forked with an IPC channel
+  function send(message: any) {
+    // A callback receives write errors that would otherwise be emitted on `process`.
+    // `process.connected` may still be true when the peer has already closed.
+    process.send?.(message, (error: any) => {
+      if (!error || closedErrors.includes(error.code)) return
+      ctx.logger.warn(error)
+    })
+  }
+
+  function exit(signal: NodeJS.Signals, reason: string) {
+    if (exiting) return
+    exiting = true
+    // an `exit` listener that never settles must not keep the worker alive
+    setTimeout(() => process.exit(1), config.exitTimeout ?? 10000).unref()
+    ctx.logger.info(reason)
+    ctx.parallel('exit', signal).finally(() => process.exit())
+  }
+
+  function handleSignal(signal: NodeJS.Signals) {
+    process.stderr.write('\x1b[2K\r')
+    // the parent process must not restart a worker that is exiting on request,
+    // regardless of the exit code produced by the cleanup
+    send({ type: 'exit' })
+    exit(signal, `terminated by ${signal}`)
+  }
+
+  // the parent process has exited, so no one supervises or restarts this worker
+  function handleDisconnect() {
+    exit('SIGHUP', 'parent process disconnected')
+  }
+
+  process.on('SIGINT', handleSignal)
+  yield () => process.off('SIGINT', handleSignal)
+  process.on('SIGTERM', handleSignal)
+  yield () => process.off('SIGTERM', handleSignal)
+  process.on('disconnect', handleDisconnect)
+  yield () => process.off('disconnect', handleDisconnect)
+
+  // `disconnect` is not emitted again for a channel that closed before the
+  // listener was registered, such as during module loading or preloading
+  if (process.send && !process.connected) {
+    handleDisconnect()
+    return
+  }
+
+  send({ type: 'start', body: config })
+  if (config.heartbeatInterval) {
+    const timer = setInterval(() => {
+      send({ type: 'heartbeat' })
+    }, config.heartbeatInterval)
+    yield () => clearInterval(timer)
+  }
+}

package/src/worker/index.ts

@@ -0,0 +1,51 @@
+import { Context } from 'cordis'
+import { noop } from 'cosmokit'
+import Fs from '@cordisjs/fs'
+import NodeFs from '@cordisjs/fs-node'
+import { EntryOptions, Loader } from '@cordisjs/loader'
+import * as daemon from './daemon.ts'
+
+export interface Config {
+  baseUrl?: string
+  execArgv?: string[]
+  path: string
+  daemon: daemon.Config
+  prelude?: EntryOptions[]
+}
+
+export async function start(config: Config) {
+  const ctx = new Context()
+
+  // Output to stdio is best-effort. A write error, such as EPIPE after the
+  // reader has gone, would otherwise become an uncaught exception, whose log
+  // entry is written to the same stream and raises the next one.
+  process.stdout.on('error', noop)
+  process.stderr.on('error', noop)
+
+  process.on('uncaughtException', (error) => {
+    ctx.logger.error(error)
+    process.exitCode = 1
+  })
+
+  process.on('unhandledRejection', (error) => {
+    ctx.logger.warn(error)
+  })
+
+  ctx.baseUrl = config.baseUrl
+  if (config.daemon.enabled) {
+    await ctx.use(daemon, config.daemon)
+  }
+  await ctx.use(Fs)
+  await ctx.use(NodeFs)
+  await ctx.use(Loader)
+  for (const options of config.prelude ?? []) {
+    await ctx.loader.create(options)
+  }
+  await ctx.loader.create({
+    name: '@cordisjs/include',
+    config: {
+      path: config.path,
+      enableLogs: true,
+    },
+  })
+}

package/src/worker/main.ts

@@ -0,0 +1,6 @@
+import assert from 'node:assert'
+import { start } from './index.ts'
+
+assert.ok(process.env.CORDIS_LOADER_OPTIONS)
+
+start(JSON.parse(process.env.CORDIS_LOADER_OPTIONS))