@akala/pm 3.5.19 → 3.7.0

package/src/commands/$init.ts

@@ -3,12 +3,11 @@ import { homedir } from 'os';
 import fs from 'fs/promises';
 import { join } from 'path';
 import pmContainer from '../container';
-import { Container, Metadata, ignoredCommands, configure, ServeOptions, SelfDefinedCommand } from '@akala/commands';
-import { eachAsync } from '@akala/core';
-import { PassThrough, Readable } from 'stream';
+import { Container, Metadata, ignoredCommands, configure, SelfDefinedCommand } from '@akala/commands';
+import { PassThrough } from 'stream';
 import { EventEmitter } from 'events';
 import { CliContext } from '@akala/cli';
-import Configuration, { ProxyConfiguration } from '@akala/config';
+import Configuration from '@akala/config';
 
 export async function metadata(container: Container<unknown>, deep?: boolean): Promise<Metadata.Container>
 {
@@ -45,7 +44,7 @@ export async function metadata(container: Container<unknown>, deep?: boolean): P
     return metacontainer;
 }
 
-export function isRunningContainer(c: Container<any>): c is RunningContainer
+export function isRunningContainer(c: Container<unknown>): c is RunningContainer
 {
     return 'running' in c;
 }
@@ -60,16 +59,18 @@ export default async function (this: State, container: RunningContainer & pmCont
     process.stderr.write = function (...args)
     {
         stderr.call(process.stderr, ...args);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return stderrPT.write(...args as [any, BufferEncoding]);
-    } as any;
+    } as typeof process.stderr.write;
 
     const stdout = process.stdout.write;
     const stdoutPT = new PassThrough();
     process.stdout.write = function (...args)
     {
         stdout.call(process.stdout, ...args);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return stdoutPT.write(...args as [any, BufferEncoding]);
-    } as any;
+    } 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

package/src/commands/bridge.ts

@@ -1,4 +1,3 @@
-import { Container } from "@akala/commands";
 import { SocketAdapter } from "@akala/json-rpc-ws";
 import State from "../state";
 

package/src/commands/config.ts

@@ -1,7 +1,6 @@
 import * as cli from "@akala/cli";
 import { CliContext } from "@akala/cli";
 import State from '../state';
-import Configuration from "@akala/config";
 
 export default async function config(this: State, name: string | undefined | void, options: CliContext['options'] | undefined | void): Promise<string[] | State['config'] | State['config']['containers']['']>
 {

package/src/commands/proxy.ts

@@ -11,7 +11,7 @@ export default async function (this: State, name: string, socket: SocketAdapter)
     const connectionId = randomUUID();
     this.bridges[connectionId] = { left: socket };
     cp.dispatch('$bridge', connectionId);
-    return new Promise<void>((resolve, reject) =>
+    return new Promise<void>((resolve) =>
     {
         const x = setInterval(() =>
         {

package/src/commands/restart.json

@@ -0,0 +1,27 @@
+{
+    "$schema": "https://raw.githubusercontent.com/npenin/akala/master/packages/commands/command-schema.json",
+    "": {
+        "inject": [
+            "$container",
+            "param.0",
+            "param.1"
+        ]
+    },
+    "cli": {
+        "options": {
+            "wait": {
+                "aliases": [
+                    "w"
+                ]
+            },
+            "inspect": {},
+            "new": {},
+            "name": {}
+        },
+        "inject": [
+            "$container",
+            "param.0",
+            "context"
+        ]
+    }
+}

package/src/commands/restart.ts

@@ -0,0 +1,9 @@
+import { StdioOptions } from "child_process";
+import pmContainer from '../container';
+import { CliContext } from "@akala/cli";
+
+export default async function restart(pm: pmContainer.container, name: string, context?: CliContext<{ new?: boolean, name: string, inspect?: boolean, verbose?: boolean, wait?: boolean }>): Promise<void | { execPath: string, args: string[], cwd: string, stdio: StdioOptions, shell: boolean, windowsHide: boolean }>
+{
+    await pm.dispatch('stop', name);
+    await pm.dispatch('start', name, context);
+}

package/src/commands/start.ts

@@ -3,7 +3,7 @@ import State, { RunningContainer, SidecarMetadata } from '../state';
 import { spawn, ChildProcess, StdioOptions } from "child_process";
 import pmContainer from '../container';
 import * as jsonrpc from '@akala/json-rpc-ws'
-import { eachAsync, lazy, logger } from "@akala/core";
+import { eachAsync } from "@akala/core";
 import { NewLinePrefixer } from "../new-line-prefixer.js";
 import { CliContext, ErrorWithStatus } from "@akala/cli";
 import getRandomName from "./name";
@@ -66,7 +66,6 @@ export default async function start(this: State, pm: pmContainer.container & Con
     if (context.options && context.options.verbose)
         args.push('-v')
 
-    const log = logger('akala:pm:' + context.options.name);
     let cp: ChildProcess;
     if (!this.isDaemon)
     {

package/src/container.ts

@@ -19,6 +19,7 @@ namespace commands
 		dispatch (cmd:'proxy', ...args: [Argument0<typeof import('./commands/proxy').default>, Argument1<typeof import('./commands/proxy').default>]): ReturnType<typeof import('./commands/proxy').default>
 		dispatch (cmd:'ready', ...args: []): ReturnType<typeof import('./commands/ready').default>
 		dispatch (cmd:'reload-metadata', ...args: [Argument0<typeof import('./commands/reload-metadata').default>]): ReturnType<typeof import('./commands/reload-metadata').default>
+		dispatch (cmd:'restart', ...args: [Argument1<typeof import('./commands/restart').default>, Argument2<typeof import('./commands/restart').default>]): ReturnType<typeof import('./commands/restart').default>
 		dispatch (cmd:'start', ...args: [Argument1<typeof import('./commands/start').default>, Argument2<typeof import('./commands/start').default>]): ReturnType<typeof import('./commands/start').default>
 		dispatch (cmd:'status', ...args: [Argument0<typeof import('./commands/status').default>]): ReturnType<typeof import('./commands/status').default>
 		dispatch (cmd:'stop', ...args: [Argument0<typeof import('./commands/stop').default>]): ReturnType<typeof import('./commands/stop').default>
@@ -41,6 +42,7 @@ namespace commands
 		'proxy'(...args: [Argument0<typeof import('./commands/proxy').default>, Argument1<typeof import('./commands/proxy').default>]): ReturnType<typeof import('./commands/proxy').default>
 		'ready'(...args: []): ReturnType<typeof import('./commands/ready').default>
 		'reload-metadata'(...args: [Argument0<typeof import('./commands/reload-metadata').default>]): ReturnType<typeof import('./commands/reload-metadata').default>
+		'restart'(...args: [Argument1<typeof import('./commands/restart').default>, Argument2<typeof import('./commands/restart').default>]): ReturnType<typeof import('./commands/restart').default>
 		'start'(...args: [Argument1<typeof import('./commands/start').default>, Argument2<typeof import('./commands/start').default>]): ReturnType<typeof import('./commands/start').default>
 		'status'(...args: [Argument0<typeof import('./commands/status').default>]): ReturnType<typeof import('./commands/status').default>
 		'stop'(...args: [Argument0<typeof import('./commands/stop').default>]): ReturnType<typeof import('./commands/stop').default>

package/src/fork.ts

@@ -5,15 +5,14 @@ import * as path from 'path'
 import * as ac from '@akala/commands';
 import { lstat } from 'fs/promises';
 import { IpcAdapter } from "./ipc-adapter";
-import { Socket } from 'net';
-import { logger, Logger, module as coreModule } from '@akala/core';
+import { logger, Logger, MiddlewareComposite, module as coreModule } from '@akala/core';
 import program, { buildCliContextFromProcess, NamespaceMiddleware } from '@akala/cli';
 import { Stats } from 'fs';
 import { registerCommands, SelfDefinedCommand, parseMetadata, StructuredParameters } from '@akala/commands';
 
 var isPm = false;
 
-program.useMiddleware({
+program.useMiddleware(null, {
     handle: async c =>
     {
         isPm = c.options.program == 'pm';
@@ -39,120 +38,115 @@ logMiddleware.preAction(async c =>
 });
 const initMiddleware = new NamespaceMiddleware<{ program: string, name: string, tls: boolean }>(null);
 program.option<string, 'program'>('program', { needsValue: true }).option<string, 'name'>('name', { needsValue: true }).option<boolean, 'tls'>('tls', { needsValue: false }).
-    use(async c => //If pure js file
+    preAction(async c => //If pure js file
     {
         folderOrFile = await lstat(c.options.program);
-        if (!folderOrFile.isFile() || path.extname(c.options.program) !== '.js')
-            throw undefined;
+        if (folderOrFile.isFile() && path.extname(c.options.program) === '.js')
+            return require(c.options.program);
 
-        return require(c.options.program);
-    }).
-    useMiddleware({
-        handle: async c => //if commandable
-        {
-            log = logger(c.options.name);
+        log = logger(c.options.name);
 
-            cliContainer = new ac.Container('cli', {});
+        cliContainer = new ac.Container('cli', {});
 
-            if (folderOrFile.isFile())
-                processor = new ac.Processors.FileSystem(path.dirname(c.options.program));
-            else
-                processor = new ac.Processors.FileSystem(c.options.program);
-        }
+        if (folderOrFile.isFile())
+            processor = new ac.Processors.FileSystem(path.dirname(c.options.program));
+        else
+            processor = new ac.Processors.FileSystem(c.options.program);
     }).
-    useMiddleware(logMiddleware).
-    useMiddleware({
-        handle: async c =>
+    useMiddleware(null, MiddlewareComposite.new(logMiddleware,
         {
-            cliContainer.name = c.options.name;
-            const init = cliContainer.resolve('$init');
-            if (init && init.config && init.config.cli && init.config.cli.options)
-                ac.Triggers.addCliOptions(init, initMiddleware);
-
-            initMiddleware.option<string, 'pmSocket'>('pmSocket', { aliases: ['pm-socket', 'pm-sock'] }).action(async c =>
+            handle: async c =>
             {
+                cliContainer.name = c.options.name;
+                const init = cliContainer.resolve('$init');
+                if (init && init.config && init.config.cli && init.config.cli.options)
+                    ac.Triggers.addCliOptions(init, initMiddleware);
 
-                let pm: ac.Container<unknown>;
-                let pmConnectInfo: ac.ServeMetadata;
-
-                if (!isPm)
+                initMiddleware.option<string, 'pmSocket'>('pmSocket', { aliases: ['pm-socket', 'pm-sock'] }).action(async c =>
                 {
-                    const pmMeta = require('../commands.json');
-                    if (process.connected)
+
+                    let pm: ac.Container<unknown>;
+                    let pmConnectInfo: ac.ServeMetadata;
+
+                    if (!isPm)
                     {
-                        pm = new ac.Container('pm', null, new ac.Processors.JsonRpc(ac.Processors.JsonRpc.getConnection(new IpcAdapter(process), cliContainer), true));
-                        registerCommands(pmMeta.commands, null, pm);
+                        //eslint-disable-next-line @typescript-eslint/no-var-requires
+                        const pmMeta = require('../commands.json');
+                        if (process.connected)
+                        {
+                            pm = new ac.Container('pm', null, new ac.Processors.JsonRpc(ac.Processors.JsonRpc.getConnection(new IpcAdapter(process), cliContainer), true));
+                            registerCommands(pmMeta.commands, null, pm);
+                        }
+                        else
+                        {
+                            if (c.options.pmSocket)
+                                pmConnectInfo = parseMetadata(c.options.pmSocket, c.options.tls);
+                            else
+                                pmConnectInfo = ac.serveMetadata('pm', { args: ['local'], options: {} })
+                            const x = await ac.connectByPreference(pmConnectInfo, { metadata: pmMeta, container: cliContainer });
+                            pm = x.container;
+                            pm.processor.useMiddleware(20, x.processor);
+                            const connect = pm.resolve('connect');
+                            pm.unregister('connect');
+                            pm.register(new SelfDefinedCommand((name: string, param: StructuredParameters<unknown[]>) =>
+                            {
+                                if (name == 'pm')
+                                    return pmConnectInfo;
+                                return x.processor.handle(pm, connect, param).then(e => { throw e }, r => r);
+                            }, 'connect', [
+                                "param.0",
+                                "$param"
+                            ]));
+                        }
+                        // eslint-disable-next-line @typescript-eslint/no-var-requires
+                        pm.unregister(ac.Cli.Metadata.name);
+                        pm.register(ac.Metadata.extractCommandMetadata(ac.Cli.Metadata));
                     }
                     else
+                        pm = cliContainer;
+
+                    coreModule('@akala/pm').register('container', pm);
+
+                    cliContainer.register(new SelfDefinedCommand(async (connectionId: string) =>
                     {
-                        if (c.options.pmSocket)
-                            pmConnectInfo = parseMetadata(c.options.pmSocket, c.options.tls);
-                        else
-                            pmConnectInfo = ac.serveMetadata('pm', { args: ['local'], options: {} })
-                        const x = await ac.connectByPreference(pmConnectInfo, { metadata: pmMeta, container: cliContainer });
-                        pm = x.container;
-                        pm.processor.useMiddleware(20, x.processor);
-                        const connect = pm.resolve('connect');
-                        pm.unregister('connect');
-                        pm.register(new SelfDefinedCommand((name: string, param: StructuredParameters<unknown[]>) =>
-                        {
-                            if (name == 'pm')
-                                return pmConnectInfo;
-                            return x.processor.handle(pm, connect, param).then(e => { throw e }, r => r);
-                        }, 'connect', [
-                            "param.0",
-                            "$param"
-                        ]));
+                        if (!pmConnectInfo)
+                            pmConnectInfo = await pm.dispatch('connect', 'pm');
+                        var pm2 = await ac.connectByPreference(pmConnectInfo, { container: cliContainer });
+                        pm2.container.processor.useMiddleware(20, pm2.processor);
+                        pm2.container.unregister(ac.Cli.Metadata.name);
+                        pm2.container.register(ac.Metadata.extractCommandMetadata(ac.Cli.Metadata));
+                        pm2.container.register(ac.Metadata.extractCommandMetadata(pm.resolve('bridge')));
+                        if (await pm2.container.dispatch('bridge', connectionId))
+                            throw undefined;
+                    }, '$bridge'));
+
+
+                    if (init)
+                        await cliContainer.dispatch(init, { options: c.options, param: c.args, _trigger: 'cli', pm: pm, context: c });
+
+                    let stop: (...args: unknown[]) => Promise<void>;
+                    try
+                    {
+                        const serveArgs: ac.ServeMetadata = await pm.dispatch('connect', c.options.name);
+                        stop = await cliContainer.dispatch('$serve', serveArgs) as (...args: unknown[]) => Promise<void>;
+                    }
+                    catch (e)
+                    {
+                        if (!e || e.statusCode !== 404)
+                            throw e;
+                        console.warn(e.message);
                     }
-                    // eslint-disable-next-line @typescript-eslint/no-var-requires
-                    pm.unregister(ac.Cli.Metadata.name);
-                    pm.register(ac.Metadata.extractCommandMetadata(ac.Cli.Metadata));
-                }
-                else
-                    pm = cliContainer;
 
-                coreModule('@akala/pm').register('container', pm);
+                    if (pm !== cliContainer)
+                        await pm.dispatch('ready')
 
-                cliContainer.register(new SelfDefinedCommand(async (connectionId: string) =>
-                {
-                    if (!pmConnectInfo)
-                        pmConnectInfo = await pm.dispatch('connect', 'pm');
-                    var pm2 = await ac.connectByPreference(pmConnectInfo, { container: cliContainer });
-                    pm2.container.processor.useMiddleware(20, pm2.processor);
-                    pm2.container.unregister(ac.Cli.Metadata.name);
-                    pm2.container.register(ac.Metadata.extractCommandMetadata(ac.Cli.Metadata));
-                    pm2.container.register(ac.Metadata.extractCommandMetadata(pm.resolve('bridge')));
-                    if (await pm2.container.dispatch('bridge', connectionId))
-                        throw undefined;
-                }, '$bridge'));
-
-
-                if (init)
-                    await cliContainer.dispatch(init, { options: c.options, param: c.args, _trigger: 'cli', pm: pm, context: c });
-
-                let stop: (...args: unknown[]) => Promise<void>;
-                try
-                {
-                    const serveArgs: ac.ServeMetadata = await pm.dispatch('connect', c.options.name);
-                    stop = await cliContainer.dispatch('$serve', serveArgs) as (...args: unknown[]) => Promise<void>;
-                }
-                catch (e)
-                {
-                    if (!e || e.statusCode !== 404)
-                        throw e;
-                    console.warn(e.message);
-                }
-
-                if (pm !== cliContainer)
-                    await pm.dispatch('ready')
-
-                if (stop && typeof stop == 'function')
-                    process.on('SIGINT', stop);
-                process.on('SIGINT', () => process.exit());
-            });
-        }
-    })
-    .useMiddleware(initMiddleware);
+                    if (stop && typeof stop == 'function')
+                        process.on('SIGINT', stop);
+                    process.on('SIGINT', () => process.exit());
+                });
+            }
+        },
+        initMiddleware));
 
 if (require.main == module)
     program.process(buildCliContextFromProcess()).catch(e =>

package/src/index.ts

@@ -50,10 +50,10 @@ export function connect(name: string): Promise<{ connect: Promise<ServeMetadata>
     {
         if (name === 'pm')
         {
-            let metaContainer = await container.dispatch('$metadata') as Metadata.Container;
+            const metaContainer = await container.dispatch('$metadata') as Metadata.Container;
             return { connect: container.dispatch('connect', name) as Promise<ServeMetadata>, container: metaContainer };
         }
-        let metaContainer = await container.dispatch('$metadata', true) as Metadata.Container;
+        const metaContainer = await container.dispatch('$metadata', true) as Metadata.Container;
 
         return { connect: container.dispatch('connect', name) as Promise<ServeMetadata>, container: { name, commands: metaContainer.commands.filter(c => c.name.startsWith(name + '.')).map(c => ({ name: c.name.substring(name.length + 1), inject: c.inject, config: c.config })) } };
     })();

package/src/sidecar.ts

@@ -1,5 +1,4 @@
-import { connectByPreference, Container, ConnectionPreference, registerCommands, updateCommands } from "@akala/commands";
-import { module } from "@akala/core";
+import { connectByPreference, ConnectionPreference, updateCommands } from "@akala/commands";
 import { SideCarConnectionPreference, Sidecar, defaultOrders, connect } from "./index";
 import * as ac from '@akala/commands'
 

package/src/state.ts

@@ -2,7 +2,7 @@ import { Container } from "@akala/commands";
 import { ChildProcess } from "child_process";
 import { Deferred, SerializableObject, SocketAdapter } from "@akala/json-rpc-ws";
 import { ServeMetadata } from "@akala/commands";
-import Configuration, { ProxyConfiguration } from "@akala/config";
+import { ProxyConfiguration } from "@akala/config";
 
 export default interface State
 {
@@ -35,6 +35,7 @@ export interface SidecarConfiguration<T extends string | SerializableObject = Se
     config?: T;
 }
 
+//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;