@akala/pm 14.4.42 → 14.5.1

package/package.json

@@ -4,7 +4,7 @@
     "pm": "dist/esm/cli.js",
     "pm-fork": "dist/esm/fork.js"
   },
-  "version": "14.4.42",
+  "version": "14.5.1",
   "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,9 +29,9 @@
     "src/fork.ts"
   ],
   "dependencies": {
-    "@akala/cli": "^5.5.32",
-    "@akala/commands": "^13.0.2",
-    "@akala/config": "^6.0.56",
+    "@akala/cli": "^5.6.0",
+    "@akala/commands": "^13.0.4",
+    "@akala/config": "^6.0.58",
     "@akala/core": "^39.0.0",
     "@akala/json-rpc-ws": "^11.0.75",
     "reflect-metadata": "^0.2.2",

package/src/akala.mts

@@ -1,15 +1,16 @@
 import * as path from 'path'
-import { Processors, Metadata, Container, ICommandProcessor, Triggers, Cli, connect } from '@akala/commands';
+import { Processors, Metadata, Container, ICommandProcessor, Triggers, Cli, connect, registerCommands } from '@akala/commands';
 import { platform, homedir } from 'os';
-import start from './commands/start.js'
 import { Readable } from 'stream';
 
 import { spawnAsync } from '@akala/cli/cli-helper';
-import State, { StateConfiguration } from './state.js';
+import { StateConfiguration } from './state.js';
 import { CliContext, ErrorMessage, InteractError, NamespaceMiddleware, unparse } from '@akala/cli';
 import { eachAsync, logger, LogLevels, NotHandled, ObservableObject, Parser } from '@akala/core';
 import module from 'module'
 import commands from './container.js';
+import cliCommands from './cli-container.js';
+import Configuration from '@akala/config';
 
 const log = logger('akala:pm');
 
@@ -37,23 +38,26 @@ const truncate = '…';
 type CliOptions = { output: string, verbose: number, pmSock: string | number, tls: boolean, help: boolean };
 export default async function (_config, program: NamespaceMiddleware<{ configFile: string, verbose: number }>)
 {
+
+
     const cli = program.command('pm').state<{ pm?: StateConfiguration }>().options<CliOptions>({
         output: { aliases: ['o'], needsValue: true, doc: 'output as `table` if array otherwise falls back to standard node output' },
         verbose: { aliases: ['v'] }, tls: { doc: "enables tls connection to the `pmSock`" },
         pmSock: { aliases: ['pm-sock'], needsValue: true, doc: "path to the unix socket or destination in the form host:port" },
         help: { doc: "displays this help message" }
     });
-    cli.command('start pm')
-        .option<boolean>()('inspect', { doc: "starts the process with --inspect-brk parameter to help debugging" })
-        .option<boolean>()('keepAttached', { doc: "keeps the process attached" })
-        .action(c =>
-        {
-            c.options.configFile += '#pm';
-            return start.call({ config: c.state.pm } as unknown as State, null, 'pm', { name: 'pm', ...c.options }, c);
-        });
 
-    const metaContainer = commands.meta;
+    const pm = new Container('pm-cli', {});
+
+    const fs = new Processors.FileSystem();
+
+    registerCommands(cliCommands.meta.commands, fs, pm);
+
+    await pm.attach(Triggers.cli, cli);
+
     let container: Container<unknown>;
+    const metaContainer = commands.meta;
+
     cli.preAction(async c =>
     {
         process.stdin.pause();
@@ -73,8 +77,12 @@ export default async function (_config, program: NamespaceMiddleware<{ configFil
                 container = await connect(new URL('jsonrpc+unix://\\\\?\\pipe\\pm'), c.abort.signal, metaContainer);
             else
             {
-                if (c.state?.pm?.mapping.pm?.connect)
-                    await eachAsync(c.state.pm.mapping.pm.connect, async (config, connectionString) =>
+                let connectMapping = c.state?.pm?.mapping.pm?.connect;
+                if (connectMapping)
+                    if (connectMapping instanceof Configuration)
+                        connectMapping = connectMapping.extract();
+                if (connectMapping)
+                    await eachAsync(connectMapping, async (config, connectionString) =>
                     {
                         if (container)
                             return;

package/src/cli-commands/$init-akala.json

@@ -2,7 +2,7 @@
     "$schema": "https://raw.githubusercontent.com/npenin/akala/main/packages/commands/command-schema.json",
     "cli": {
         "inject": [
-            "options.pmSock"
+            "context"
         ],
         "options": {
             "pmSock": {
@@ -13,4 +13,4 @@
             }
         }
     }
-}
+}

package/src/cli-commands/$init-akala.ts

@@ -4,7 +4,8 @@ import { connect, Container } from "@akala/commands";
 import { platform } from "os";
 import { Triggers } from "@akala/commands";
 import { ProxyConfiguration } from "@akala/config";
-import { ErrorWithStatus, HttpStatusCode } from "@akala/core";
+import { eachAsync } from "@akala/core";
+import commands from "../container.js";
 
 type CliOptions = { pmSock: string | number, tls: boolean };
 
@@ -25,13 +26,34 @@ export default async function (c: CliContext<CliOptions, ProxyConfiguration<{ pm
         container = await connect('unix://\\\\?\\pipe\\pm', c.abort.signal)
     else
     {
-        const connectOptions = c.state?.pm?.mapping?.pm?.connect?.extract();
-        if (connectOptions)
-            container = await connect(Object.keys(connectOptions)[0], c.abort.signal);
+        const connectMapping = c.state?.pm?.mapping.pm?.connect;
+        await eachAsync(connectMapping.extract(), async (config, connectionString) =>
+        {
+            if (container)
+                return;
+            try
+            {
+                c.logger.verbose('trying to connect to ' + connectionString);
+                const url = new URL(connectionString);
+                if (url.hostname == '0.0.0.0')
+                    url.hostname = 'localhost';
+                container = await connect(url, c.abort.signal, commands.meta);
+            }
+            catch (e)
+            {
+                c.logger.silly('failed to connect to ' + connectionString);
+                c.logger.silly(e)
+                if (e.code == 'ENOENT' || e.code == 'ECONNREFUSED')
+                    return;
+                c.logger.error(e);
+                throw e;
+            }
+
+        })
     }
 
-    if (!container)
-        throw new ErrorWithStatus(HttpStatusCode.BadGateway, 'no connection option specified');
+    if (container)
+        await container.attach(Triggers.cli, program.command('pm'));
+    // throw new ErrorWithStatus(HttpStatusCode.BadGateway, 'no connection option specified');
 
-    await container.attach(Triggers.cli, program.command('pm'));
-}
+}

package/src/cli-commands/start.json

@@ -2,7 +2,6 @@
     "$schema": "https://raw.githubusercontent.com/npenin/akala/main/packages/commands/command-schema.json",
     "": {
         "inject": [
-            "$container",
             "param.0",
             "param.1"
         ]
@@ -34,6 +33,13 @@
             "help": {
                 "doc": "displays this help message"
             },
+            "keepAttached": {
+                "aliases": [
+                    "keep-attached"
+                ],
+                "needsValue": false,
+                "doc": "keeps the process attached to the current terminal"
+            },
             "wait": {
                 "aliases": [
                     "w"
@@ -57,10 +63,9 @@
             }
         },
         "inject": [
-            "$container",
             "options.program",
             "context"
         ],
         "usage": "start pm"
     }
-}
+}

package/src/cli-commands/start.ts

@@ -1,51 +1,19 @@
-import { Container } from "@akala/commands";
 import State, { } from '../state.js';
-import { spawn, ChildProcess, StdioOptions } from "child_process";
-import pmContainer from '../container.js';
+import { StdioOptions } from "child_process";
 import { CliContext, unparseOptions } from "@akala/cli";
-import { ErrorWithStatus } from "@akala/core";
-import getRandomName from "../commands/name.js";
-import path from 'path'
-import { fileURLToPath } from 'url'
+import ChildProcess from '../runtimes/child_process.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, context?: CliContext<{ new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean }>): Promise<void | { execPath: string, args: string[], cwd: string, stdio: StdioOptions, shell: boolean, windowsHide: boolean }>
+export default async function start(this: State, name: string, context?: CliContext<{ configFile: string, new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean }>): Promise<void | { execPath: string, args: string[], cwd: string, stdio: StdioOptions, shell: boolean, windowsHide: boolean }>
 {
-    let args: string[];
-
-    if (!context.options.name && context.options.new)
-        context.options.name = getRandomName();
-    else if (!context.options.name)
-        context.options.name = name;
-
-    if (this.isDaemon)
-        throw new ErrorWithStatus(40, 'pm is already running');
-    else
-    {
-        if (name != 'pm')
-            throw new ErrorWithStatus(40, 'this command needs to run through daemon process');
-
-        args = [...context.args, ...unparseOptions({ ...context.options, inspect: undefined })];
-    }
-
-    args.unshift(path.resolve(_dirname, '../fork.js'))
-
-    if (context.options && context.options.inspect)
-        args.unshift('--inspect-brk');
-
-    args.unshift(...process.execArgv);
-
-    if (context.options && context.options.verbose)
-        args.push('-v')
-
-    let cp: ChildProcess;
-    if (context.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'] });
+    const args = [...context.args, ...unparseOptions({
+        ...context.options,
+        configFile: context.options.configFile + '#pm',
+        name: 'pm',
+        program: new URL('../../../commands.json', import.meta.url).toString(),
+        inspect: undefined, new: undefined, wait: undefined
+    })];
+
+    const cp = ChildProcess.build(args, { ...context.options, inheritStdio: context.options.keepAttached }, context.abort.signal);
     cp.on('exit', function (...args: unknown[])
     {
         console.log(args);
@@ -53,8 +21,8 @@ export default async function start(this: State, pm: pmContainer.container & Con
     cp.on('message', function (message)
     {
         console.log(message);
-        // cp.disconnect();
     });
+
     return new Promise<void>((resolve) =>
     {
         cp.on('disconnect', function ()
@@ -66,7 +34,7 @@ export default async function start(this: State, pm: pmContainer.container & Con
             }
             resolve();
         })
-    })
+    });
 }
 
 start.$inject = ['$container', 'param.0', 'options']

package/src/cli.ts

@@ -41,7 +41,7 @@ cli.command('start pm')
         c.options['name'] = 'pm'
         c.options['program'] = new URL('../../commands.json', import.meta.url).toString();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return start.call({} as unknown as State, null, 'pm', c as any);
+        return start.call({} as unknown as State, null, c as any);
     });
 
 let socket: Socket;

package/src/commands/$init.json

@@ -23,8 +23,19 @@
                 ]
             },
             "keepAttached": {
-                "needsValue": true
+                "aliases": [
+                    "keep-attached"
+                ],
+                "needsValue": false,
+                "doc": "keeps the process attached to the current terminal"
+            },
+            "wait": {
+                "aliases": [
+                    "w"
+                ],
+                "needsValue": false,
+                "doc": "waits for the program to be started before returning, otherwise, returns after the start command is sent to the pm daemon"
             }
         }
     }
-}
+}

package/src/commands/$init.ts

@@ -150,8 +150,13 @@ export default async function (this: State, container: RunningContainer & pmCont
         if (!context.options.keepAttached)
         {
             if (process.send)
-                process.send('disconnecting daemon');
+                await new Promise<void>((resolve, reject) => process.send('disconnecting daemon', err => err ? reject(err) : resolve()));
             process.disconnect();
         }
     }
+
+    context.abort.signal.addEventListener('abort', async () =>
+    {
+        await container.dispatch('stop', { param: ['pm'] });
+    });
 }

package/src/commands/start.ts

@@ -69,12 +69,6 @@ export default async function start(this: State, pm: pmContainer.container & Con
         args = [new URL('../../../commands.json', import.meta.url).toString(), ...(context?.args || []), ...unparseOptions({ ...options, inspect: undefined })];
     }
 
-    if (!def?.type || def.type == 'nodejs')
-    {
-
-        args.unshift(path.resolve(_dirname, '../fork.js'))
-    }
-
     if (options?.inspect)
         args.unshift('--inspect-brk');
 

package/src/fork.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import sms from 'source-map-support'
 sms.install();
-import * as path from 'path'
+import path from 'path'
 import { lstat } from 'fs/promises';
 import pmDef from './container.js';
 import { IpcAdapter } from "./ipc-adapter.js";
@@ -23,14 +23,15 @@ let log: Logger;
 const logMiddleware = new NamespaceMiddleware<{ program: string, name: string, tls: boolean }>(null).option<string>()('verbose', { aliases: ['v',] });
 logMiddleware.preAction(async c =>
 {
+    const fs: Processors.FileSystem = new Processors.FileSystem(path.dirname(c.options.program));
     if (c.options.verbose)
-        processor = new Processors.LogProcessor((_c, cmd, params) =>
+        processor = new Processors.LogEventProcessor(fs, c.abort.signal, (_c, cmd, params) =>
         {
             log.verbose({ cmd, params });
-            return undefined;
         });
 
-    await Processors.FileSystem.discoverCommands(c.options.program, cliContainer, { processor: processor, isDirectory: folderOrFile.isDirectory() });
+    const options: Processors.DiscoveryOptions = { processor: processor, isDirectory: folderOrFile.isDirectory() };
+    await Processors.FileSystem.discoverCommands(c.options.program, cliContainer, options);
 });
 let initMiddleware = new NamespaceMiddleware<{ program: string, name: string, tls: boolean }>(null);
 const controller = new AbortController();
@@ -39,6 +40,7 @@ program.option<string>()('program', { needsValue: true, normalize: true, positio
     option<string>()('name', { needsValue: true, positional: true, position: 1, optional: true }).
     option<boolean>()('tls', { needsValue: false }).
     option<string>()('configFile', { needsValue: false }).
+    option<number>()('verbose', { aliases: ['v'], needsValue: false }).
     options<{
         port?: number,
         tcpPort?: string,
@@ -175,7 +177,9 @@ program.option<string>()('program', { needsValue: true, normalize: true, positio
                         const serveArgs = await pm.dispatch('connect', c.options.name);
                         // console.log(serveArgs)
                         // serveArgs.signal = controller.signal;
-                        await cliContainer.dispatch('$serve', serveArgs, controller.signal);
+                        if (!serveArgs && (!('socketName' in c.options) || !c.options.socketName))
+                            c.options['socketName'] = c.options.name;
+                        await cliContainer.dispatch('$serve', serveArgs || c, controller.signal);
                     }
                     catch (e)
                     {

package/src/runtimes/child_process.ts

@@ -22,10 +22,10 @@ export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> i
 {
     private readonly cp: ChildProcess;
     public readonly adapter: IpcAdapter;
-    constructor(args: string[], options: ChildProcessRuntimeOptions)
+    constructor(args: string[], options: ChildProcessRuntimeOptions, signal?: AbortSignal)
     {
         super();
-        args.unshift(fileURLToPath(new URL('../fork', import.meta.url)));
+        args.unshift(fileURLToPath(new URL('../fork.js', import.meta.url)));
         if (options.inspect)
             args.unshift("--inspect-brk");
         this.cp = spawn(process.execPath, 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 });
@@ -36,15 +36,22 @@ export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> i
         }
         this.adapter = new IpcAdapter(this.cp);
         this.cp.on('close', (code, signal) => { this.emit('close', code, signal); this.emit('exit') });
+        this.cp.on('message', (message, sendHandle) => this.emit('message', message, sendHandle));
 
+        this.cp.on('disconnect', () => { this.emit('disconnect'); });
         if (options.keepAttached)
-            this.cp.on('disconnect', () => this.emit('exit'));
+            this.cp.on('disconnect', () => { this.emit('exit') });
+
+        signal?.addEventListener('abort', () =>
+        {
+            return this.stop(5000);
+        })
     }
     stop(timeoutInMs?: number): Promise<number>
     {
         return new Promise((resolve) =>
         {
-            this.cp.on('exit', (code, signal) =>
+            this.cp.on('exit', (code) =>
             {
                 clearTimeout(timeout);
                 resolve(code);
@@ -54,9 +61,11 @@ export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> i
         })
     }
 
-    public static build(args: string[], options: ChildProcessRuntimeOptions)
+    public static build(args: string[], options: ChildProcessRuntimeOptions, signal?: AbortSignal)
     {
-        return new Runtime(args, options) as Runtime & RuntimeInstance;
+        return new Runtime(args, options, signal) as Runtime & RuntimeInstance;
+
+
     }
 
     public unref()