@akala/pm 15.9.6 → 15.10.1

package/package.json

@@ -4,7 +4,7 @@
     "pm": "dist/esm/cli.js",
     "pm-fork": "dist/esm/fork.js"
   },
-  "version": "15.9.6",
+  "version": "15.10.1",
   "scripts": {
     "test": "echo 1",
     "generate": "akala sdk generate dist/esm/commands commands.json --name pm && akala sdk generate dist/esm/cli-commands cli-commands.json --name pm",
@@ -29,11 +29,11 @@
     "src/fork.ts"
   ],
   "dependencies": {
-    "@akala/cli": "^5.13.4",
-    "@akala/commands": "^17.7.0",
-    "@akala/config": "^7.0.6",
+    "@akala/cli": "^5.13.6",
+    "@akala/commands": "^17.7.2",
+    "@akala/config": "^7.0.8",
     "@akala/core": "^42.3.0",
-    "@akala/fs": "^2.1.27",
+    "@akala/fs": "^2.2.0",
     "@akala/json-rpc-ws": "^14.3.17",
     "reflect-metadata": "^0.2.2"
   },

package/src/cli-commands/map.ts

@@ -1,12 +1,34 @@
+import fsHandler from '@akala/fs';
 import type State from '../state.js';
 import type { SidecarMetadata } from '../state.js';
 import { isAbsolute, resolve } from "path";
+import { pathToFileURL } from 'url';
+import { Metadata } from '@akala/commands';
 
-export default async function map<TName extends string>(config: State['config'], name: TName, targetPath: string | URL, runtime: SidecarMetadata['type'], cwd?: string, options?: { commandable?: boolean })
+export default async function map<TName extends string>(config: State['config'], name: TName, targetPath: string | URL, runtimeName: SidecarMetadata['type'], cwd?: string, options?: { commandable?: boolean })
 {
     if (typeof targetPath == 'string' && !URL.canParse(targetPath) && !isAbsolute(targetPath))
         targetPath = resolve(cwd || process.cwd(), targetPath);
-    config.containers.set(name, { type: runtime, path: targetPath.toString(), commandable: !!options?.commandable });
+
+    let dependencies: string[];
+    if (!!options?.commandable)
+    {
+        const url = targetPath instanceof URL ? targetPath : !URL.canParse(targetPath) ? pathToFileURL(targetPath) : new URL(targetPath);
+
+        const fs = await fsHandler.process(url);
+
+        const container = await fs.readFile<Metadata.Container>(url, { encoding: 'json' });
+
+        if (container.dependencies)
+            dependencies = container.dependencies;
+    }
+
+    config.containers.set(name, {
+        type: runtimeName,
+        path: targetPath.toString(),
+        commandable: !!options?.commandable,
+        dependencies
+    });
     await config.commit();
     return name
 }

package/src/cli-commands/start.ts

@@ -13,7 +13,7 @@ export default async function start(this: State, name: string, context?: CliCont
         inspect: undefined, new: undefined, wait: undefined
     })];
 
-    const cp = ChildProcess.build(args, { ...context.options, inheritStdio: true }, context.abort.signal);
+    const cp = await ChildProcess.build(args, { ...context.options, inheritStdio: true }, context.abort.signal);
     cp.on('exit', function (...args: unknown[])
     {
         console.log(args);

package/src/commands/start.ts

@@ -8,9 +8,10 @@ import getRandomName from "./name.js";
 import { type ProxyConfiguration, unwrap } from "@akala/config";
 import path from 'path'
 import { fileURLToPath } from 'url'
-import { type RuntimeInstance } from "../runtimes/shared.js";
+import { RuntimeEventMap, type RuntimeInstance } from "../runtimes/shared.js";
 import ChildProcess from "../runtimes/child_process.js";
 import Worker from "../runtimes/worker.js";
+import Docker from "../runtimes/docker.js";
 
 
 //eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -48,7 +49,7 @@ export default async function start(this: State, pm: pmContainer.container & Con
 
     var container = this.processes[options.name || name];
     if (container?.running)
-        throw new Error(container.name + ' is already started');
+        throw new ErrorWithStatus(HttpStatusCode.Conflict, container.name + ' is already started');
 
     args = [];
 
@@ -90,7 +91,18 @@ export default async function start(this: State, pm: pmContainer.container & Con
             if (dep === name)
                 return;
             if (!this.processes[dep])
-                await pm.dispatch('start', dep, { wait: true })
+            {
+                try
+                {
+                    await pm.dispatch('start', dep, { wait: true })
+                }
+                catch (e)
+                {
+                    if (e.statusCode !== HttpStatusCode.Conflict)
+                        throw e;
+                    await new Promise(resolve => this.processes[dep].ready?.addListener(resolve, { once: true }));
+                }
+            }
             else
                 await new Promise(resolve => this.processes[dep].ready?.addListener(resolve, { once: true }));
         });
@@ -99,11 +111,13 @@ export default async function start(this: State, pm: pmContainer.container & Con
     switch (def?.type)
     {
         case 'worker':
-            cp = Worker.build(args, options);
+            cp = await Worker.build(args, options);
             break;
+        case 'docker':
+            cp = await Docker.build(args, options);
         case 'nodejs':
             args.push('--pm-sock', 'ipc://')
-            cp = ChildProcess.build(args, { ...options, keepAttached: true });
+            cp = await ChildProcess.build(args, { ...options, keepAttached: true }) as RuntimeInstance<RuntimeEventMap>;
             break;
         default:
             throw new ErrorWithStatus(400, `container with type ${this.config.containers[name]?.type} are not yet supported`);

package/src/runtimes/child_process.ts

@@ -7,17 +7,25 @@ import { EventEmitter, SocketAdapter, type IEvent } from "@akala/core";
 import { fileURLToPath } from "url";
 import { JsonRpcSocketAdapter, Payload } from "@akala/json-rpc-ws";
 
-export type ChildProcessRuntimeEventMap = {
+export interface ChildProcessRuntimeEventMap extends RuntimeEventMap
+{
     "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?: number, wait?: boolean, inheritStdio?: boolean }
+export type ChildProcessRuntimeOptions = {
+    new?: boolean,
+    name: string,
+    keepAttached?: boolean,
+    inspect?: boolean,
+    verbose?: number,
+    wait?: boolean,
+    inheritStdio?: boolean
+}
 
 export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> implements RuntimeInstance<ChildProcessRuntimeEventMap>
 {
@@ -40,7 +48,7 @@ export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> i
             this.stderrPrefixer.pipe(process.stderr);
             this.stdoutPrefixer = this.cp.stdout?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: process.stdout.isTTY }), { end: true });
             this.stdoutPrefixer.pipe(process.stdout);
-            this.on('disconnect', () =>
+            this.cp.on('disconnect', () =>
             {
                 this.cp.stderr?.unpipe();
                 this.cp.stdout?.unpipe();
@@ -90,9 +98,7 @@ export default class Runtime extends EventEmitter<ChildProcessRuntimeEventMap> i
 
     public static build(args: string[], options: ChildProcessRuntimeOptions, signal?: AbortSignal)
     {
-        return new Runtime(args, options, signal) as Runtime & RuntimeInstance;
-
-
+        return Promise.resolve(new Runtime(args, options, signal));
     }
 
     public unref()

package/src/runtimes/docker.ts

@@ -50,13 +50,13 @@ function demuxDockerStream(stream: Readable, stdout: PassThrough, stderr: PassTh
     });
 }
 
-export class Runtime extends EventEmitter<RuntimeEventMap> implements RuntimeInstance
+export default class Runtime extends EventEmitter<RuntimeEventMap> implements RuntimeInstance
 {
     static readonly name = "docker";
 
     static async build(
         args: string[],
-        options: { new?: boolean; name: string; keepAttached?: boolean; inspect?: boolean; verbose?: boolean; wait?: boolean }
+        options: { new?: boolean; name: string; keepAttached?: boolean; inspect?: boolean; verbose?: number; wait?: boolean }
     ): Promise<Runtime>
     {
         const image = args[0];

package/src/runtimes/shared.ts

@@ -5,7 +5,7 @@ import { Readable } from "stream";
 export interface Runtime
 {
     name: string;
-    build(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: boolean, wait?: boolean }): RuntimeInstance;
+    build(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean }): Promise<RuntimeInstance>;
 }
 
 export interface RuntimeEventMap

package/src/runtimes/worker.ts

@@ -15,7 +15,7 @@ export default class Runtime extends EventEmitter<RuntimeEventMap> implements Ru
     private readonly cp: Worker;
     public readonly adapter: SocketAdapter<Payload<Readable>>;
     private _running: boolean;
-    constructor(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean })
+    constructor(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean }, signal?: AbortSignal)
     {
         super();
         this.cp = new Worker(require.resolve('../fork'), { argv: args, stderr: true, stdout: true })
@@ -23,15 +23,21 @@ export default class Runtime extends EventEmitter<RuntimeEventMap> implements Ru
         this.cp.stdout?.pipe(new NewLinePrefixer(options.name + ' ', { useColors: true })).pipe(process.stdout);
         this.adapter = new JsonRpcSocketAdapter(new MessagePortAdapter(this.cp));
         this.cp.on('exit', () => { this._running = false; this.emit('runningChanged') })
+
+        signal?.addEventListener('abort', () =>
+        {
+            this.stop();
+        })
     }
-    stop(): Promise<number>
+
+    public stop()
     {
         return this.cp.terminate();
     }
 
-    public static build(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean })
+    public static build(args: string[], options: { new?: boolean, name: string, keepAttached?: boolean, inspect?: boolean, verbose?: number, wait?: boolean }, signal?: AbortSignal)
     {
-        return new Runtime(args, options);
+        return Promise.resolve(new Runtime(args, options, signal));
     }
 
     get stderr(): Readable { return this.cp.stderr }

package/src/state.ts

@@ -25,7 +25,7 @@ export interface SidecarMetadata
     stateless: boolean;
     dependencies?: string[];
     commandable: boolean;
-    type: 'nodejs' | 'worker';
+    type: 'nodejs' | 'worker' | 'docker';
 }
 
 export interface SidecarConfiguration<T extends string | SerializableObject = SerializableObject>