@akala/pm 3.3.4 → 3.5.0

package/src/container.ts

@@ -5,18 +5,20 @@ namespace commands
 {
 	export interface container 
 	{
-		dispatch (cmd:'connect', ...args: [Argument0<typeof import('./commands/connect').default>, Argument1<typeof import('./commands/connect').default>]): ReturnType<typeof import('./commands/connect').default>
-		dispatch (cmd:'config', ...args: [Argument0<typeof import('./commands/config').default>, Argument1<typeof import('./commands/config').default>]): ReturnType<typeof import('./commands/config').default>
-		dispatch (cmd:'install', ...args: [Argument0<typeof import('./commands/install').default>]): ReturnType<typeof import('./commands/install').default>
 		dispatch (cmd:'$init', ...args: [Argument1<typeof import('./commands/$init').default>]): ReturnType<typeof import('./commands/$init').default>
+		dispatch (cmd:'bridge', ...args: [Argument0<typeof import('./commands/bridge').default>, Argument1<typeof import('./commands/bridge').default>]): ReturnType<typeof import('./commands/bridge').default>
+		dispatch (cmd:'config', ...args: [Argument0<typeof import('./commands/config').default>, Argument1<typeof import('./commands/config').default>]): ReturnType<typeof import('./commands/config').default>
+		dispatch (cmd:'connect', ...args: [Argument0<typeof import('./commands/connect').default>, Argument1<typeof import('./commands/connect').default>]): ReturnType<typeof import('./commands/connect').default>
 		dispatch (cmd:'discover', ...args: [Argument0<typeof import('./commands/discover').default>, Argument1<typeof import('./commands/discover').default>]): ReturnType<typeof import('./commands/discover').default>
+		dispatch (cmd:'install', ...args: [Argument0<typeof import('./commands/install').default>]): ReturnType<typeof import('./commands/install').default>
 		dispatch (cmd:'link', ...args: [Argument0<typeof import('./commands/link').default>, Argument1<typeof import('./commands/link').default>]): ReturnType<typeof import('./commands/link').default>
-		dispatch (cmd:'ls', ...args: []): ReturnType<typeof import('./commands/ls').default>
-		dispatch (cmd:'name', ...args: [Argument0<typeof import('./commands/name').default>]): ReturnType<typeof import('./commands/name').default>
 		dispatch (cmd:'log', ...args: [Argument0<typeof import('./commands/log').default>]): ReturnType<typeof import('./commands/log').default>
-		dispatch (cmd:'reload-metadata', ...args: [Argument0<typeof import('./commands/reload-metadata').default>]): ReturnType<typeof import('./commands/reload-metadata').default>
+		dispatch (cmd:'ls', ...args: []): ReturnType<typeof import('./commands/ls').default>
 		dispatch (cmd:'map', ...args: [Argument0<typeof import('./commands/map').default>, Argument1<typeof import('./commands/map').default>, Argument2<typeof import('./commands/map').default>, Argument3<typeof import('./commands/map').default>]): ReturnType<typeof import('./commands/map').default>
+		dispatch (cmd:'name', ...args: [Argument0<typeof import('./commands/name').default>]): ReturnType<typeof import('./commands/name').default>
+		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:'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>
@@ -25,18 +27,20 @@ namespace commands
 	}
 	export interface proxy 
 	{
-		'connect'(...args: [Argument0<typeof import('./commands/connect').default>, Argument1<typeof import('./commands/connect').default>]): ReturnType<typeof import('./commands/connect').default>
-		'config'(...args: [Argument0<typeof import('./commands/config').default>, Argument1<typeof import('./commands/config').default>]): ReturnType<typeof import('./commands/config').default>
-		'install'(...args: [Argument0<typeof import('./commands/install').default>]): ReturnType<typeof import('./commands/install').default>
 		'$init'(...args: [Argument1<typeof import('./commands/$init').default>]): ReturnType<typeof import('./commands/$init').default>
+		'bridge'(...args: [Argument0<typeof import('./commands/bridge').default>, Argument1<typeof import('./commands/bridge').default>]): ReturnType<typeof import('./commands/bridge').default>
+		'config'(...args: [Argument0<typeof import('./commands/config').default>, Argument1<typeof import('./commands/config').default>]): ReturnType<typeof import('./commands/config').default>
+		'connect'(...args: [Argument0<typeof import('./commands/connect').default>, Argument1<typeof import('./commands/connect').default>]): ReturnType<typeof import('./commands/connect').default>
 		'discover'(...args: [Argument0<typeof import('./commands/discover').default>, Argument1<typeof import('./commands/discover').default>]): ReturnType<typeof import('./commands/discover').default>
+		'install'(...args: [Argument0<typeof import('./commands/install').default>]): ReturnType<typeof import('./commands/install').default>
 		'link'(...args: [Argument0<typeof import('./commands/link').default>, Argument1<typeof import('./commands/link').default>]): ReturnType<typeof import('./commands/link').default>
-		'ls'(...args: []): ReturnType<typeof import('./commands/ls').default>
-		'name'(...args: [Argument0<typeof import('./commands/name').default>]): ReturnType<typeof import('./commands/name').default>
 		'log'(...args: [Argument0<typeof import('./commands/log').default>]): ReturnType<typeof import('./commands/log').default>
-		'reload-metadata'(...args: [Argument0<typeof import('./commands/reload-metadata').default>]): ReturnType<typeof import('./commands/reload-metadata').default>
+		'ls'(...args: []): ReturnType<typeof import('./commands/ls').default>
 		'map'(...args: [Argument0<typeof import('./commands/map').default>, Argument1<typeof import('./commands/map').default>, Argument2<typeof import('./commands/map').default>, Argument3<typeof import('./commands/map').default>]): ReturnType<typeof import('./commands/map').default>
+		'name'(...args: [Argument0<typeof import('./commands/name').default>]): ReturnType<typeof import('./commands/name').default>
+		'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>
 		'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

@@ -4,12 +4,13 @@ sms.install();
 import * as path from 'path'
 import * as ac from '@akala/commands';
 import { lstat } from 'fs/promises';
-import { IpcAdapter } from './commands/start';
+import { IpcAdapter } from "./ipc-adapter";
 import { Socket } from 'net';
 import { logger, Logger, module as coreModule } from '@akala/core';
 import program, { buildCliContextFromProcess, NamespaceMiddleware } from '@akala/cli';
 import { Stats } from 'fs';
-import { registerCommands } from '@akala/commands';
+import { registerCommands, SelfDefinedCommand } from '@akala/commands';
+import { parseMetadata } from '@akala/commands/src/serve-metadata';
 
 var isPm = false;
 
@@ -25,7 +26,7 @@ let folderOrFile: Stats;
 let cliContainer: ac.Container<unknown>;
 let processor: ac.CommandProcessor;
 let log: Logger;
-const logMiddleware = new NamespaceMiddleware<{ program: string, name: string }>(null).option<string, 'verbose'>('verbose', { aliases: ['v',] });
+const logMiddleware = new NamespaceMiddleware<{ program: string, name: string, tls: boolean }>(null).option<string, 'verbose'>('verbose', { aliases: ['v',] });
 logMiddleware.preAction(async c =>
 {
     if (c.options.verbose)
@@ -37,8 +38,8 @@ logMiddleware.preAction(async c =>
 
     await ac.Processors.FileSystem.discoverCommands(c.options.program, cliContainer, { processor: processor, isDirectory: folderOrFile.isDirectory() });
 });
-const initMiddleware = new NamespaceMiddleware<{ program: string, name: string }>(null);
-program.option<string, 'program'>('program', { needsValue: true }).option<string, 'name'>('name', { needsValue: true }).
+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
     {
         folderOrFile = await lstat(c.options.program);
@@ -71,7 +72,10 @@ program.option<string, 'program'>('program', { needsValue: true }).option<string
 
             initMiddleware.option<string, 'pmSocket'>('pmSocket', { aliases: ['pm-socket', 'pm-sock'] }).action(async c =>
             {
+
                 let pm: ac.Container<unknown>;
+                let pmConnectInfo: ac.ServeMetadata;
+
                 if (!isPm)
                 {
                     if (process.connected)
@@ -81,25 +85,27 @@ program.option<string, 'program'>('program', { needsValue: true }).option<string
                     else
                     {
                         const pmSocket = new Socket();
-                        await new Promise<void>((resolve, reject) =>
-                        {
-                            pmSocket.on('error', reject)
-                            const remote = /^(?:([^:]+):)?(\d+)$/.exec(c.options.pmSocket);
-                            if (!remote)
-                            {
-                                pmSocket.connect(c.options.pmSocket, resolve);
-                            }
-                            else
-                            {
-                                const host = remote[1];
-                                const port = remote[2];
-                                if (host)
-                                    pmSocket.connect(Number(port), host, resolve);
-                                else
-                                    pmSocket.connect(Number(port), resolve);
-                            }
-                        })
-                        pm = new ac.Container('pm', null, new ac.Processors.JsonRpc(ac.Processors.JsonRpc.getConnection(new ac.NetSocketAdapter(pmSocket), cliContainer), true));
+                        const x = await ac.connectByPreference(pmConnectInfo = parseMetadata(c.options.pmSocket, c.options.tls), { container: cliContainer });
+                        pm = x.container;
+                        // await new Promise<void>((resolve, reject) =>
+                        // {
+                        //     pmSocket.on('error', reject)
+                        //     const remote = /^(?:([^:]+):)?(\d+)$/.exec(c.options.pmSocket);
+                        //     if (!remote)
+                        //     {
+                        //         pmSocket.connect(c.options.pmSocket, resolve);
+                        //     }
+                        //     else
+                        //     {
+                        //         const host = remote[1];
+                        //         const port = remote[2];
+                        //         if (host)
+                        //             pmSocket.connect(Number(port), host, resolve);
+                        //         else
+                        //             pmSocket.connect(Number(port), resolve);
+                        //     }
+                        // })
+                        // pm = new ac.Container('pm', null, new ac.Processors.JsonRpc(ac.Processors.JsonRpc.getConnection(new ac.NetSocketAdapter(pmSocket), cliContainer), true));
                     }
                     // eslint-disable-next-line @typescript-eslint/no-var-requires
                     registerCommands(require('../commands.json').commands.map(ac.Metadata.extractCommandMetadata), null, pm);
@@ -112,6 +118,15 @@ program.option<string, 'program'>('program', { needsValue: true }).option<string
 
                 coreModule('@akala/pm').register('container', pm);
 
+                cliContainer.register(new SelfDefinedCommand(async (connectionId: string) =>
+                {
+                    if (!pmConnectInfo)
+                        pmConnectInfo = await pm.dispatch('connect', 'pm');
+                    var pm2 = await ac.connectByPreference(pmConnectInfo, { container: cliContainer });
+                    await pm2.container.dispatch('bridge', connectionId);
+                }, '$bridge'));
+
+
                 if (init)
                     await cliContainer.dispatch(init, { options: c.options, param: c.args, _trigger: 'cli', pm: pm, context: c });
 

package/src/index.ts

@@ -1,4 +1,4 @@
-import { connectByPreference, Container, Metadata, NetSocketAdapter, Processors, registerCommands, ServeMetadata, ConnectionPreference, Cli } from "@akala/commands";
+import { Container, Metadata, NetSocketAdapter, Processors, registerCommands, ServeMetadata, ConnectionPreference, Cli } from "@akala/commands";
 import { Socket } from "net";
 import { module } from "@akala/core";
 
@@ -54,57 +54,9 @@ export function connect(name: string): Promise<{ connect: Promise<ServeMetadata>
     })();
 }
 
-const defaultOrders: (keyof ServeMetadata)[] = ['ssocket', 'socket', 'wss', 'ws'];
+export const defaultOrders: (keyof ServeMetadata)[] = ['ssocket', 'socket', 'wss', 'ws'];
 
-type SideCarConnectionPreference = { [key in keyof SidecarMap]?: Partial<ConnectionPreference> & { orders?: (keyof ServeMetadata)[] } };
-
-export function sidecar(options?: Omit<ConnectionPreference, 'metadata'> | SideCarConnectionPreference | Omit<ConnectionPreference, 'metadata'> & SideCarConnectionPreference, noCache?: boolean): Sidecar
-{
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new Proxy<Sidecar>({} as any, {
-        get(target, property)
-        {
-            if (typeof (property) !== 'string')
-                return Reflect.get(target, property);
-
-            const orders = options && options[property] && options[property].orders || defaultOrders;
-            if (!options)
-                options = {};
-            if (typeof options.preferRemote == 'undefined')
-                options.preferRemote = !process.connected;
-            if (noCache || typeof (target[property]) == 'undefined')
-                Object.defineProperty(target, property, {
-                    value: connect(property).then(async meta => 
-                    {
-                        try
-                        {
-                            const c = await connectByPreference(await meta.connect, Object.assign({ metadata: meta.container }, options, options && options[property]), ...orders);
-                            return c.container;
-                        }
-                        catch (e)
-                        {
-                            if (e && e.statusCode == 404 || !meta.connect)
-                            {
-                                var c = new Container(meta.container.name, null, module('@akala/pm').resolve('container').processor);
-                                c.processor.useMiddleware(1, {
-                                    handle(origin, cmd, param)
-                                    {
-                                        if (cmd.name.startsWith(meta.container.name + '.'))
-                                            return undefined;
-                                        return c.processor.handle(origin, Object.assign({}, cmd, { name: meta.container.name + '.' + cmd.name }), param);
-                                    }
-                                });
-                                meta.container.commands.forEach(cmd => c.register(cmd));
-                                return c;
-                            }
-                            throw e;
-                        }
-                    })
-                });
-            return target[property];
-        }
-    });
-}
+export type SideCarConnectionPreference = { [key in keyof SidecarMap]?: Partial<ConnectionPreference> & { orders?: (keyof ServeMetadata)[] } };
 
 export interface ContainerLite
 {
@@ -119,5 +71,8 @@ export interface SidecarMap
     pm: pmContainer
 }
 
+
 import getRandomName from './commands/name';
+import sidecarSingleton, { sidecar } from "./sidecar";
+export { sidecar, sidecarSingleton };
 export { getRandomName };

package/src/ipc-adapter.ts

@@ -0,0 +1,65 @@
+import { ChildProcess } from "child_process";
+import * as jsonrpc from '@akala/json-rpc-ws';
+import { SocketAdapterEventMap } from "@akala/json-rpc-ws";
+
+
+export class IpcAdapter implements jsonrpc.SocketAdapter
+{
+    get open(): boolean { return !!this.cp.pid; }
+
+
+    pipe(socket: jsonrpc.SocketAdapter<unknown>)
+    {
+        this.on('message', (message) => socket.send(message));
+        this.on('close', () => socket.close());
+    }
+
+    close(): void
+    {
+        this.cp.disconnect();
+    }
+    send(data: string): void
+    {
+        if (this.cp.send)
+            this.cp.send(data + '\n');
+
+        else
+            console.warn(`process ${this.cp.pid} does not support send over IPC`);
+    }
+    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('disconnect', () => handler(null));
+                break;
+        }
+    }
+
+    constructor(private cp: ChildProcess | NodeJS.Process)
+    {
+    }
+
+}

package/src/sidecar.ts

@@ -0,0 +1,54 @@
+import { connectByPreference, Container, ConnectionPreference, registerCommands } from "@akala/commands";
+import { module } from "@akala/core";
+import { SideCarConnectionPreference, Sidecar, defaultOrders, connect } from "./index";
+
+let instance: Sidecar;
+
+export default function (options?: Omit<ConnectionPreference, 'metadata'> | SideCarConnectionPreference | Omit<ConnectionPreference, 'metadata'> & SideCarConnectionPreference, noCache?: boolean): Sidecar
+{
+    return instance || (instance = sidecar(options, noCache));
+}
+
+export function sidecar(options?: Omit<ConnectionPreference, 'metadata'> | SideCarConnectionPreference | Omit<ConnectionPreference, 'metadata'> & SideCarConnectionPreference, noCache?: boolean): Sidecar
+{
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new Proxy<Sidecar>({} as any, {
+        get(target, property)
+        {
+            if (typeof (property) !== 'string')
+                return Reflect.get(target, property);
+
+            const orders = options && options[property] && options[property].orders || defaultOrders;
+            if (!options)
+                options = {};
+            if (typeof options.preferRemote == 'undefined')
+                options.preferRemote = !process.connected;
+            if (noCache || typeof (target[property]) == 'undefined')
+                Object.defineProperty(target, property, {
+                    value: connect(property).then(async (meta) =>
+                    {
+                        try
+                        {
+                            const c = await connectByPreference(await meta.connect, Object.assign({ metadata: meta.container }, options, options && options[property]), ...orders);
+                            return c.container;
+                        }
+                        catch (e)
+                        {
+                            if (e && e.statusCode == 404 || !meta.connect)
+                            {
+                                return await connect('pm').then(async (meta) =>
+                                {
+                                    const c = await connectByPreference(await meta.connect, Object.assign({ metadata: meta.container }, options, options && options[property]), ...orders);
+                                    await c.container.dispatch('proxy', property);
+                                    registerCommands((await c.container.dispatch('$metadata', true)).commands, c.processor, c.container);
+                                    return c.container;
+                                });
+                            }
+                            throw e;
+                        }
+                    })
+                });
+            return target[property];
+        }
+    });
+}

package/src/state.ts

@@ -1,6 +1,6 @@
 import { Container } from "@akala/commands";
 import { ChildProcess } from "child_process";
-import { Deferred, SerializableObject } from "@akala/json-rpc-ws";
+import { Deferred, SerializableObject, SocketAdapter } from "@akala/json-rpc-ws";
 import { ServeMetadata } from "@akala/commands";
 import Configuration, { ProxyConfiguration } from "@akala/config";
 
@@ -9,6 +9,7 @@ export default interface State
     processes: { [key: string]: RunningContainer };
     isDaemon: boolean;
     config: ProxyConfiguration<StateConfiguration>
+    bridges: { [key: string]: SocketAdapter }
 }
 
 export interface StateConfiguration