@akala/pm 14.0.20 → 14.1.0

package/package.json

@@ -4,7 +4,7 @@
     "pm": "dist/esm/cli.js",
     "pm-fork": "dist/esm/fork.js"
   },
-  "version": "14.0.20",
+  "version": "14.1.0",
   "scripts": {
     "test": "echo 1",
     "generate": "ac generate dist/esm/commands commands.json --name pm && ac generate dist/esm/cli-commands cli-commands.json --name pm",
@@ -29,11 +29,11 @@
     "src/fork.ts"
   ],
   "dependencies": {
-    "@akala/cli": "^4.1.6",
-    "@akala/commands": "^11.3.20",
-    "@akala/config": "^5.0.59",
-    "@akala/core": "^23.1.1",
-    "@akala/json-rpc-ws": "^11.0.22",
+    "@akala/cli": "^5.0.0",
+    "@akala/commands": "^11.4.0",
+    "@akala/config": "^5.0.61",
+    "@akala/core": "^23.2.0",
+    "@akala/json-rpc-ws": "^11.0.24",
     "reflect-metadata": "^0.2.2",
     "source-map-support": "^0.5.21"
   },

package/src/commands/$init.ts

@@ -3,11 +3,11 @@ import fs from 'fs/promises';
 import pmContainer from '../container.js';
 import { Container, Metadata, ignoredCommands, configure, SelfDefinedCommand } from '@akala/commands';
 import { PassThrough } from 'stream';
-import { EventEmitter } from 'events';
 import { CliContext } from '@akala/cli';
 import { Configuration } from '@akala/config';
 import { fileURLToPath } from 'url';
 import { eachAsync } from '@akala/core';
+import Process from '../runtimes/process.js';
 
 export async function metadata(container: Container<unknown>, deep?: boolean): Promise<Metadata.Container>
 {
@@ -71,22 +71,10 @@ export default async function (this: State, container: RunningContainer & pmCont
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return stdoutPT.write(...args as [any, BufferEncoding]);
     } as typeof process.stdout.write;
-    container.process = Object.assign(new EventEmitter(), {
-        stdout: stdoutPT, stderr: stderrPT, stdio: null, stdin: process.stdin, pid: process.pid, connected: false
-        , exitCode: undefined
-        , signalCode: undefined
-        , spawnargs: process.argv
-        , spawnfile: null
-        , kill: process.exit.bind(process)
-        , send: null
-        , disconnect: null
-        , unref: null
-        , ref: null
-        , killed: false,
-        [Symbol.dispose]()
-        {
-
-        }
+    container.process = new Process({
+        stdout: stdoutPT,
+        stderr: stderrPT,
+        stdin: process.stdin
     });
 
     const configPath = context.options.configFile || './.pm.config.json';
@@ -166,4 +154,4 @@ export default async function (this: State, container: RunningContainer & pmCont
             process.disconnect();
         }
     }
-}
+}

package/src/commands/start.ts

@@ -1,22 +1,22 @@
 import { Container, Processors, Metadata, Cli, updateCommands } from "@akala/commands";
 import State, { RunningContainer, SidecarMetadata } from '../state.js';
-import { spawn, ChildProcess, StdioOptions } from "child_process";
 import pmContainer from '../container.js';
 import { eachAsync, Event } from "@akala/core";
-import { NewLinePrefixer } from "../new-line-prefixer.js";
 import { CliContext, unparseOptions } from "@akala/cli";
 import { ErrorWithStatus } from "@akala/core";
 import getRandomName from "./name.js";
 import { ProxyConfiguration } from "@akala/config";
-import { IpcAdapter } from "../ipc-adapter.js";
 import path from 'path'
 import { fileURLToPath } from 'url'
+import { RuntimeInstance } from "../runtimes/shared.js";
+import ChildProcess from "../runtimes/child_process.js";
+import Worker from "../runtimes/worker.js";
 
 //eslint-disable-next-line @typescript-eslint/ban-ts-comment
 //@ts-ignore
 const _dirname = typeof __dirname !== 'undefined' ? __dirname : path.dirname(fileURLToPath(import.meta.url))
 
-export default async function start(this: State, pm: pmContainer.container & Container<State>, name: string, options?: CliContext<{ configFile?: string, new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean, autostart?: boolean }>['options'], context?: Pick<CliContext<{}>, 'args'>): Promise<void | { execPath: string, args: string[], cwd: string, stdio: StdioOptions, shell: boolean, windowsHide: boolean }>
+export default async function start(this: State, pm: pmContainer.container & Container<State>, name: string, options?: CliContext<{ configFile?: string, new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean, autostart?: boolean }>['options'], context?: Pick<CliContext<{}>, 'args'>): Promise<void | { execPath: string, args: string[], cwd: string, shell: boolean, windowsHide: boolean }>
 {
     let args: string[];
     if (options)
@@ -87,25 +87,17 @@ export default async function start(this: State, pm: pmContainer.container & Con
     if (options && options.verbose)
         args.push('-v')
 
-    let cp: ChildProcess;
     if (!this.isDaemon)
     {
-        if (options.keepAttached)
-            cp = spawn(process.execPath, args, { cwd: process.cwd(), stdio: ['inherit', 'inherit', 'inherit', 'ipc'] });
-        else
-            cp = spawn(process.execPath, args, { cwd: process.cwd(), detached: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
-        cp.on('exit', function (...args: unknown[])
+        const cp = ChildProcess.build(args, { inheritStdio: true, name: options.name });
+        cp.on('exit', function ()
         {
             console.log(args);
         })
-        cp.on('message', function (message)
-        {
-            console.log(message);
-            // cp.disconnect();
-        });
+
         return new Promise<void>((resolve) =>
         {
-            cp.on('disconnect', function ()
+            cp.on('runningChanged', () =>
             {
                 if (!options.keepAttached)
                     cp.unref();
@@ -116,6 +108,8 @@ export default async function start(this: State, pm: pmContainer.container & Con
     }
     else
     {
+        let cp: RuntimeInstance;
+
         if (!container && def.dependencies?.length)
         {
             var missingDeps = def.dependencies.filter(d => !this.config.containers[d] && !this.config.mapping[d]);
@@ -125,17 +119,22 @@ export default async function start(this: State, pm: pmContainer.container & Con
             await eachAsync(def.dependencies, async (dep) => { await pm.dispatch('start', dep, { name: options.name + '-' + dep, wait: true }) });
         }
 
-        if (def?.type && def.type !== 'nodejs')
-            throw new ErrorWithStatus(400, `container with type ${this.config.containers[name]?.type} are not yet supported`);
-        cp = spawn(process.execPath, args, { cwd: process.cwd(), detached: !options.keepAttached, env: Object.assign({ DEBUG_COLORS: true }, process.env), stdio: ['ignore', 'pipe', 'pipe', 'ipc'], shell: false, windowsHide: true });
-        cp.stderr?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stderr);
-        cp.stdout?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stdout);
+        switch (def?.type)
+        {
+            default:
+                throw new ErrorWithStatus(400, `container with type ${this.config.containers[name]?.type} are not yet supported`);
+            case 'worker':
+                cp = Worker.build(args, options);
+                break;
+            case 'nodejs':
+                cp = ChildProcess.build(args, options);
+                break;
+        }
 
         if (!container || !container.running)
         {
-            const socket = new IpcAdapter(cp);
             container = new Container(options.name, null) as RunningContainer;
-            const connection = Processors.JsonRpc.getConnection(socket, pm, (params) =>
+            const connection = Processors.JsonRpc.getConnection(cp.adapter, pm, (params) =>
             {
                 params.process = cp;
                 Object.defineProperty(params, 'connectionAsContainer', Object.assign({ value: container }));
@@ -206,6 +205,6 @@ export default async function start(this: State, pm: pmContainer.container & Con
         }
         if (options.wait)
             await new Promise<void>(resolve => container.ready?.addListener(resolve));
-        return { execPath: process.execPath, args: args, cwd: process.cwd(), stdio: ['inherit', 'inherit', 'inherit', 'ipc'], shell: false, windowsHide: true };
+        return { execPath: process.execPath, args: args, cwd: process.cwd(), shell: false, windowsHide: true };
     }
-}
+}

package/src/commands/stop.ts

@@ -5,7 +5,7 @@ export default async function stop(this: State, name: string, container: Contain
 {
     await Promise.all(Object.values(this.processes).filter(p => p.name == name && p.process).map(cp =>
     {
-        return new Promise<unknown>((resolve) =>
+        return new Promise<void>((resolve) =>
         {
             if (cp.process && cp.running)
             {
@@ -20,22 +20,12 @@ export default async function stop(this: State, name: string, container: Contain
                         console.error(e);
                     }
                 }
-                const timeout = setTimeout(function ()
-                {
-                    cp.process.kill();
-                }, 5000)
-                cp.process.on('exit', (_code, signal) =>
-                {
-                    container.unregister(cp.name);
-                    delete this.processes[cp.name];
-                    clearTimeout(timeout);
-                    resolve(signal);
-                })
 
-                cp.process.kill(2);
+                cp.process.stop().then(() => resolve());
+
             }
             else
-                resolve(null)
+                resolve()
         })
     })).then(() =>
     {
@@ -44,4 +34,4 @@ export default async function stop(this: State, name: string, container: Contain
             process.emit('SIGINT', 'SIGINT');
         }
     });
-}
+}

package/src/messageport-adapter.ts

@@ -0,0 +1,81 @@
+import { SocketAdapter, SocketAdapterEventMap } from "@akala/json-rpc-ws";
+import { MessagePort, Worker } from "worker_threads";
+
+export class MessagePortAdapter implements SocketAdapter
+{
+    private isOpen: boolean = true;
+
+    get open(): boolean { return this.isOpen; }
+    close(): void
+    {
+        if (this.cp instanceof Worker)
+            this.cp.terminate();
+        else
+            this.cp.close();
+    }
+    send(data: string): void
+    {
+        this.cp.postMessage(data);
+    }
+    on<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+    {
+        switch (event)
+        {
+            case 'message':
+                this.cp.on('message', handler);
+                break;
+            case 'open':
+                handler(null);
+                break;
+            case 'close':
+                this.cp.on('disconnect', handler);
+                break;
+        }
+    }
+
+    once<K extends keyof SocketAdapterEventMap>(event: K, handler: (ev: SocketAdapterEventMap[K]) => void): void
+    {
+        switch (event)
+        {
+            case 'message':
+                this.cp.once('message', handler);
+                break;
+            case 'open':
+                handler(null);
+                break;
+            case 'close':
+                this.cp.once('close', () => handler(null));
+                break;
+        }
+    }
+
+    constructor(private cp: MessagePort | Worker)
+    {
+        cp.on('close', () => this.isOpen = false);
+    }
+    off<K extends keyof SocketAdapterEventMap>(event: K, handler?: (this: unknown, ev: SocketAdapterEventMap[K]) => void): void
+    {
+        this.cp.off(event, handler);
+    }
+
+    pipe(socket: SocketAdapter<unknown>)
+    {
+        this.on('message', (message) => socket.send(message));
+        this.on('close', () => socket.close());
+    }
+
+    // _write(chunk: string | Buffer, encoding: string, callback: (error?: any) => void)
+    // {
+    //     // The underlying source only deals with strings.
+    //     if (Buffer.isBuffer(chunk))
+    //         chunk = chunk.toString('utf8');
+    //     if (this.cp.send)
+    //         this.cp.send(chunk + '\n', callback);
+    //     else
+    //         callback(new Error('there is no send method on this process'));
+    // }
+
+    // _read()
+    // {
+    // }
+}

package/src/runtimes/child_process.ts

@@ -0,0 +1,71 @@
+import { ChildProcess, SendHandle, Serializable, spawn } from "child_process";
+import { Readable } from "stream";
+import { IpcAdapter } from "../ipc-adapter.js";
+import { NewLinePrefixer } from "../new-line-prefixer.js";
+import { RuntimeEventMap, RuntimeInstance } from "./shared.js";
+import { EventEmitter, IEvent } from "@akala/core";
+import { fileURLToPath } from "url";
+
+export type ChildProcessRuntimeEventMap = {
+    "close": IEvent<[code: number | null, signal: NodeJS.Signals | null], void>
+    "disconnect": IEvent<[], void>
+    "error": IEvent<[err: Error], void>
+    "exit": IEvent<[code: number | null, signal: NodeJS.Signals | null], void>
+    "message": IEvent<[message: Serializable, sendHandle: SendHandle], void>
+    "spawn": IEvent<[], void>
+
+} & RuntimeEventMap;
+
+export type ChildPRocessRuntimeOptions = { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean, inheritStdio?: boolean }
+
+export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> implements RuntimeInstance
+{
+    private readonly cp: ChildProcess;
+    public readonly adapter: IpcAdapter;
+    constructor(args: string[], options: ChildPRocessRuntimeOptions)
+    {
+        super();
+        args.unshift(fileURLToPath(new URL('../fork', import.meta.url)));
+        if (options.inspect)
+            args.unshift("--inspect-brk");
+        this.cp = spawn(process.execPath, [require.resolve('../fork')].concat(args), { cwd: process.cwd(), detached: !options.keepAttached, env: Object.assign({ DEBUG_COLORS: process.stdout.isTTY }, process.env), stdio: ['ignore', options.inheritStdio ? 'inherit' : 'pipe', options.inheritStdio ? 'inherit' : 'pipe', 'ipc'], shell: false, windowsHide: true });
+        if (!options.inheritStdio)
+        {
+            this.cp.stderr?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stderr);
+            this.cp.stdout?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stdout);
+        }
+        this.adapter = new IpcAdapter(this.cp);
+        this.cp.on('close', () => this.emit('exit'));
+
+        if (options.keepAttached)
+            this.cp.on('disconnect', () => this.emit('exit'));
+    }
+    stop(timeoutInMs?: number): Promise<number>
+    {
+        return new Promise((resolve) =>
+        {
+            this.cp.on('exit', (code, signal) =>
+            {
+                clearTimeout(timeout);
+                resolve(code);
+            })
+            this.cp.kill('SIGINT');
+            const timeout = setTimeout(() => { this.cp.kill() }, timeoutInMs || 5000)
+        })
+    }
+
+    public static build(args: string[], options: ChildPRocessRuntimeOptions)
+    {
+        return new Runtime(args, options);
+    }
+
+    public unref()
+    {
+        this.cp.unref();
+    }
+
+    get stderr(): Readable { return this.cp.stderr }
+    get stdout(): Readable { return this.cp.stdout }
+
+    get running() { return this.cp.exitCode === null }
+}

package/src/runtimes/process.ts

@@ -0,0 +1,34 @@
+import { Readable, Writable } from "stream";
+import { IpcAdapter } from "../ipc-adapter.js";
+import { RuntimeEventMap, RuntimeInstance } from "./shared.js";
+import { EventEmitter } from "@akala/core";
+
+export default class Runtime extends EventEmitter<RuntimeEventMap> implements RuntimeInstance
+{
+    public readonly adapter: IpcAdapter;
+    private stdio: { stderr: Readable, stdout: Readable, stdin: Writable }
+    constructor(stdio?: { stderr: Readable, stdout: Readable, stdin: Writable })
+    {
+        super();
+        this.adapter = new IpcAdapter(process);
+        if (!stdio)
+            this.stdio = process;
+    }
+    stop(timeoutInMs?: number): Promise<number>
+    {
+        return new Promise((resolve) =>
+        {
+            process.on('exit', (code, signal) =>
+            {
+                clearTimeout(timeout);
+                resolve(code);
+            })
+            process.kill(process.pid, 'SIGINT')
+            const timeout = setTimeout(() => { process.exit() }, timeoutInMs || 5000)
+        })
+    }
+    get stderr(): Readable { return this.stdio.stderr }
+    get stdout(): Readable { return this.stdio.stdout }
+
+    get running() { return true }
+}

package/src/runtimes/shared.ts

@@ -0,0 +1,24 @@
+import { IEvent, EventEmitter } from "@akala/core";
+import { SocketAdapter } from "@akala/json-rpc-ws";
+import { Readable } from "stream";
+
+export interface Runtime
+{
+    build(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean }): RuntimeInstance;
+}
+
+export type RuntimeEventMap = {
+    runningChanged: IEvent<[], void>;
+    exit: IEvent<[], void>;
+}
+
+export interface RuntimeInstance<T extends RuntimeEventMap = RuntimeEventMap> extends EventEmitter<T>
+{
+    stop(): Promise<number>;
+    get adapter(): SocketAdapter;
+
+    get stderr(): Readable;
+    get stdout(): Readable;
+
+    get running(): boolean;
+}

package/src/runtimes/worker.ts

@@ -0,0 +1,38 @@
+import { Worker } from "worker_threads";
+import { Readable } from "stream";
+import { NewLinePrefixer } from "../new-line-prefixer.js";
+import { MessagePortAdapter } from "../messageport-adapter.js";
+import { RuntimeEventMap, RuntimeInstance } from "./shared.js";
+import module from 'module'
+import { EventEmitter } from "@akala/core";
+const require = module.createRequire(import.meta.url);
+
+export default class Runtime extends EventEmitter<RuntimeEventMap> implements RuntimeInstance
+{
+    private readonly cp: Worker;
+    public readonly adapter: MessagePortAdapter;
+    private _running: boolean;
+    constructor(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean })
+    {
+        super();
+        this.cp = new Worker(require.resolve('../fork'), { argv: args, stderr: true, stdout: true })
+        this.cp.stderr?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stderr);
+        this.cp.stdout?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stdout);
+        this.adapter = new MessagePortAdapter(this.cp);
+        this.cp.on('exit', () => { this._running = false; this.emit('runningChanged') })
+    }
+    stop(): Promise<number>
+    {
+        return this.cp.terminate();
+    }
+
+    public static build(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean })
+    {
+        return new Runtime(args, options);
+    }
+
+    get stderr(): Readable { return this.cp.stderr }
+    get stdout(): Readable { return this.cp.stdout }
+
+    get running() { return this._running; }
+}

package/src/state.ts

@@ -1,8 +1,8 @@
 import { Container } from "@akala/commands";
-import { ChildProcess } from "child_process";
 import { Event, SerializableObject } from "@akala/core";
 import { SocketAdapter } from "@akala/json-rpc-ws";
 import { ProxyConfiguration } from "@akala/config";
+import { RuntimeInstance } from "./runtimes/shared.js";
 
 export default interface State
 {
@@ -26,7 +26,7 @@ export interface SidecarMetadata
     stateless: boolean;
     dependencies?: string[];
     commandable: boolean;
-    type?: 'nodejs';
+    type?: 'nodejs' | 'worker';
 }
 
 export interface SidecarConfiguration<T extends string | SerializableObject = SerializableObject>
@@ -42,8 +42,8 @@ export interface SidecarConfiguration<T extends string | SerializableObject = Se
 //eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface RunningContainer<T extends string | SerializableObject = any> extends Container<unknown>, SidecarConfiguration<T>, SidecarMetadata
 {
-    process: ChildProcess;
+    process: RuntimeInstance;
     running?: boolean;
     stateless: boolean;
     ready?: Event<[void]>;
-}
+}