@akala/pm 7.1.4 → 8.0.0

package/src/cli-commands/start-self.json

@@ -0,0 +1,66 @@
+{
+    "$schema": "https://raw.githubusercontent.com/npenin/akala/master/packages/commands/command-schema.json",
+    "": {
+        "inject": [
+            "$container",
+            "param.0",
+            "param.1"
+        ]
+    },
+    "cli": {
+        "options": {
+            "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"
+            },
+            "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"
+            },
+            "inspect": {
+                "needsValue": false,
+                "doc": "starts the process with --inspect-brk parameter to help debugging"
+            },
+            "new": {
+                "needsValue": false
+            },
+            "name": {
+                "doc": "name to assign to the process",
+                "needsValue": true
+            },
+            "program": {
+                "doc": "program to start"
+            }
+        },
+        "inject": [
+            "$container",
+            "options.program",
+            "context"
+        ],
+        "usage": "start pm"
+    }
+}

package/src/cli-commands/start-self.ts

@@ -0,0 +1,74 @@
+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 { Deferred, eachAsync } from "@akala/core";
+import { NewLinePrefixer } from "../new-line-prefixer.js";
+import { CliContext, unparseOptions } from "@akala/cli";
+import { ErrorWithStatus } from "@akala/core";
+import getRandomName from "../commands/name.js";
+import { ProxyConfiguration } from "@akala/config";
+import { IpcAdapter } from "../ipc-adapter.js";
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+//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?: boolean, 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'))
+
+    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'] });
+    cp.on('exit', function (...args: unknown[])
+    {
+        console.log(args);
+    })
+    cp.on('message', function (message)
+    {
+        console.log(message);
+        // cp.disconnect();
+    });
+    return new Promise<void>((resolve) =>
+    {
+        cp.on('disconnect', function ()
+        {
+            if (!context.options.keepAttached)
+                cp.unref();
+            console.log('pm started');
+            resolve();
+        })
+    })
+}
+
+start.$inject = ['$container', 'param.0', 'options']

package/src/cli.ts

@@ -4,13 +4,14 @@ import { Processors, NetSocketAdapter, Metadata, Container, proxy, Triggers, Cli
 import { Socket } from 'net';
 import { TLSSocket } from 'tls';
 import { platform, homedir } from 'os';
-import start from './commands/start.js'
+import start from './cli-commands/start-self.js'
 import { Readable } from 'stream';
 
-import State from './state.js';
+import State, { StateConfiguration } from './state.js';
 import { program, buildCliContextFromProcess, ErrorMessage } from '@akala/cli';
 import { InteractError } from './index.js';
 import { Binding } from '@akala/core';
+import { open } from 'fs/promises';
 
 const tableChars = {
     'top': '─'
@@ -81,25 +82,24 @@ cli.preAction(async c =>
                 netsocket.connect('\\\\?\\pipe\\pm')
             else
             {
-                try
+                open('./.pm.config.json').then(d =>
                 {
-                    // eslint-disable-next-line @typescript-eslint/no-var-requires
-                    import(path.join(homedir(), './.pm.config.json'), { assert: { type: 'json' } }).then(config =>
-                        netsocket.connect(config.default.mapping.pm.connect.socket[0])
-                    );
-                }
-                catch (e)
+                    d.readFile({ encoding: 'utf-8' }).then(d => JSON.parse(d)).then((config: StateConfiguration) =>
+                    {
+                        netsocket.connect(config.mapping.pm.connect.socket[0]);
+                    }).finally(() => d.close());
+                }, e =>
                 {
-                    if (e.code != 'MODULE_NOT_FOUND')
-                        reject(e);
+                    if (e.code === 'ENOENT' && e.path === './.pm.config.json')
+                        socket.destroy(e);
                     else
                     {
-                        e.code = 'ENOENT';
-                        socket.destroy(e);
+                        reject(e);
+                        throw e;
                     }
-
-                }
+                });
             }
+
             if (c.options.tls)
             {
                 // socket.on('data', function (e) { console.log(e) });

package/src/commands/$init.ts

@@ -83,10 +83,14 @@ export default async function (this: State, container: RunningContainer & pmCont
         , disconnect: null
         , unref: null
         , ref: null
-        , killed: false
+        , killed: false,
+        [Symbol.dispose]()
+        {
+
+        }
     });
 
-    const configPath = context.options.configFile || join(homedir(), './.pm.config.json');
+    const configPath = context.options.configFile || './.pm.config.json';
     this.config = await Configuration.load<StateConfiguration>(configPath, true);
 
     if (this.config?.mapping?.pm)

package/src/commands/connect.ts

@@ -14,13 +14,14 @@ export default async function connect(this: State, name: string, context?: Serve
         mapping = Configuration.new(null, this.processes[name] as SidecarConfiguration);
     // console.log(name);
     // console.log(mapping);
-    // console.log(options);
-    if (context && context.args.length > 0)
+    // console.log(mapping.connect);
+    // console.log(context);
+    if (context?.args?.length > 0)
     {
         if (!mapping)
-            this.config.mapping.set(`${name}.connect`, serveMetadata({ args: context.args, options: { ...context.options, socketName: context.options.socketName || name } }));
+            this.config.mapping.set(`${name}.connect`, serveMetadata({ args: context.args, options: { ...context.options, socketName: context.options?.socketName || name } }));
         else
-            mapping.set('connect', serveMetadata({ args: context.args, options: { ...context.options, socketName: context.options.socketName || name } }));
+            mapping.set('connect', serveMetadata({ args: context.args, options: { ...context.options, socketName: context.options?.socketName || name } }));
     }
     else
     {

package/src/fork.ts

@@ -10,6 +10,7 @@ import { logger, Logger, MiddlewareComposite, module as coreModule } from '@akal
 import { program, buildCliContextFromProcess, ErrorMessage, NamespaceMiddleware } from '@akala/cli';
 import { Stats } from 'fs';
 import { registerCommands, SelfDefinedCommand, parseMetadata, StructuredParameters } from '@akala/commands';
+import { fileURLToPath } from 'url';
 
 var isPm = false;
 
@@ -50,6 +51,18 @@ program.option<string, 'program'>('program', { needsValue: true, normalize: true
     }).
     preAction(async c => //If pure js file
     {
+        try
+        {
+            const url = new URL(c.options.program);
+            if (url.protocol == 'file:')
+                c.options.program = fileURLToPath(url);
+            else
+                throw new Error('remote commands are not yet supported');
+        }
+        catch (e)
+        {
+            console.log(e);
+        }
         folderOrFile = await lstat(c.options.program);
         if (folderOrFile.isFile() && path.extname(c.options.program) === '.js')
             return require(c.options.program);
@@ -158,6 +171,7 @@ program.option<string, 'program'>('program', { needsValue: true, normalize: true
                     try
                     {
                         const serveArgs: ac.ServeMetadataWithSignal = await pm.dispatch('connect', c.options.name);
+                        // console.log(serveArgs)
                         serveArgs.signal = controller.signal;
                         await cliContainer.dispatch('$serve', serveArgs);
                     }