@peerbit/server 2.0.0 → 4.0.0

package/lib/esm/cli.js

@@ -1,21 +1,88 @@
 import { createTestDomain, getDomainFromConfig, loadConfig, startCertbot, } from "./domain.js";
 import { startServerWithNode } from "./server.js";
-import { createRecord } from "./aws.js";
-import { getHomeConfigDir, getPackageName, getRemotesPath } from "./config.js";
+import { AWS_LINUX_ARM_AMIs, createRecord, launchNodes, terminateNode, } from "./aws.js";
+import { getHomeConfigDir, getKeypair, getPackageName, getRemotesPath, } from "./config.js";
 import chalk from "chalk";
-import { client } from "./client.js";
+import { createClient, waitForDomain } from "./client.js";
 import { exit } from "process";
 import readline from "readline";
 import fs from "fs";
 import path from "path";
 import { toBase64 } from "@peerbit/crypto";
-import { Remotes } from "./remotes.js";
-const padString = function (string, padding, padChar = " ") {
+import { DEFAULT_REMOTE_GROUP, Remotes } from "./remotes.js";
+import { peerIdFromString } from "@libp2p/peer-id";
+import { LOCAL_API_PORT } from "./routes.js";
+const colors = [
+    "#00FF00",
+    "#0000FF",
+    "#FF0000",
+    "#01FFFE",
+    "#FFA6FE",
+    "#FFDB66",
+    "#006401",
+    "#010067",
+    "#95003A",
+    "#007DB5",
+    "#FF00F6",
+    "#FFEEE8",
+    "#774D00",
+    "#90FB92",
+    "#0076FF",
+    "#D5FF00",
+    "#FF937E",
+    "#6A826C",
+    "#FF029D",
+    "#FE8900",
+    "#7A4782",
+    "#7E2DD2",
+    "#85A900",
+    "#FF0056",
+    "#A42400",
+    "#00AE7E",
+    "#683D3B",
+    "#BDC6FF",
+    "#263400",
+    "#BDD393",
+    "#00B917",
+    "#9E008E",
+    "#001544",
+    "#C28C9F",
+    "#FF74A3",
+    "#01D0FF",
+    "#004754",
+    "#E56FFE",
+    "#788231",
+    "#0E4CA1",
+    "#91D0CB",
+    "#BE9970",
+    "#968AE8",
+    "#BB8800",
+    "#43002C",
+    "#DEFF74",
+    "#00FFC6",
+    "#FFE502",
+    "#620E00",
+    "#008F9C",
+    "#98FF52",
+    "#7544B1",
+    "#B500FF",
+    "#00FF78",
+    "#FF6E41",
+    "#005F39",
+    "#6B6882",
+    "#5FAD4E",
+    "#A75740",
+    "#A5FFD2",
+    "#FFB167",
+    "#009BFF",
+    "#E85EBE",
+];
+const padString = function (string, padding, padChar = " ", stringLength = string.valueOf().length) {
     const val = string.valueOf();
-    if (Math.abs(padding) <= val.length) {
+    if (Math.abs(padding) <= stringLength) {
         return val;
     }
-    const m = Math.max(Math.abs(padding) - string.length || 0, 0);
+    const m = Math.max(Math.abs(padding) - stringLength || 0, 0);
     const pad = Array(m + 1).join(String(padChar).charAt(0));
     //      var pad = String(c || ' ').charAt(0).repeat(Math.abs(n) - this.length);
     return padding < 0 ? pad + val : val + pad;
@@ -45,18 +112,19 @@ export const cli = async (args) => {
                 describe: "Whether to connect to bootstap nodes on startup",
                 type: "boolean",
                 default: false,
+            })
+                .option("grant-access", {
+                describe: "Grant access to public keys on start",
+                defaultDescription: "The publickey of this device located in 'directory'",
+                type: "string",
+                array: true,
+                alias: "ga",
             })
                 .option("reset", {
                 describe: "If true, then programs opened during last session will not be opened",
                 type: "boolean",
                 default: false,
                 alias: "r",
-            })
-                .option("password", {
-                describe: "Setup password so you can interact with the node remotely",
-                type: "string",
-                defaultDescription: "The password from the last session will be used or a password will be generated",
-                default: undefined,
             })
                 .option("port-api", {
                 describe: "Set API server port. Only modify this when testing locally, since NGINX config depends on the default value",
@@ -76,9 +144,27 @@ export const cli = async (args) => {
                 domain: await loadConfig().then((config) => config ? getDomainFromConfig(config) : undefined),
                 ports: { api: args["port-api"], node: args["port-node"] },
                 bootstrap: args.bootstrap,
-                password: args.password,
                 newSession: args.reset,
+                grantAccess: args["grant-access"],
+            });
+        },
+    })
+        .command({
+        command: "id",
+        describe: "Get peer id",
+        builder: (yargs) => {
+            yargs.option("directory", {
+                describe: "Peerbit directory",
+                defaultDescription: "~.peerbit",
+                type: "string",
+                alias: "d",
+                default: getHomeConfigDir(),
             });
+            return yargs;
+        },
+        handler: async (args) => {
+            const kp = await getKeypair(args.directory);
+            console.log((await kp.toPeerId()).toString());
         },
     })
         .command("domain", "Setup a domain and certificate for this node", (yargs) => {
@@ -183,6 +269,156 @@ export const cli = async (args) => {
     })
         .command("remote", "Handle remote nodes", (innerYargs) => {
         innerYargs
+            .command("spawn", "Spawn remote nodes", (spawnYargs) => {
+            spawnYargs
+                .command({
+                command: "aws",
+                describe: "Spawn remote nodes on AWS",
+                builder: (awsArgs) => {
+                    awsArgs.option("count", {
+                        describe: "Amount of nodes to spawn",
+                        defaultDescription: "One node",
+                        type: "number",
+                        alias: "c",
+                        default: 1,
+                    });
+                    awsArgs.option("region", {
+                        describe: "Region",
+                        type: "string",
+                        defaultDescription: "Region defined in ~.aws/config",
+                        choices: Object.keys(AWS_LINUX_ARM_AMIs),
+                    });
+                    awsArgs.option("group", {
+                        describe: "Remote group to launch nodes in",
+                        type: "string",
+                        alias: "g",
+                        default: DEFAULT_REMOTE_GROUP,
+                    });
+                    awsArgs.option("size", {
+                        describe: "Instance size",
+                        type: "string",
+                        alias: "s",
+                        choices: [
+                            "micro",
+                            "small",
+                            "medium",
+                            "large",
+                            "xlarge",
+                            "2xlarge",
+                        ],
+                        default: "micro",
+                    });
+                    awsArgs.option("name", {
+                        describe: "Name prefix for spawned nodes",
+                        type: "string",
+                        alias: "n",
+                        default: "peerbit-node",
+                    });
+                    awsArgs.option("grant-access", {
+                        describe: "Grant access to public keys on start",
+                        defaultDescription: "The publickey of this device located in 'directory'",
+                        type: "string",
+                        array: true,
+                        alias: "ga",
+                    });
+                    awsArgs.option("directory", {
+                        describe: "Peerbit directory",
+                        defaultDescription: "~.peerbit",
+                        type: "string",
+                        alias: "d",
+                        default: getHomeConfigDir(),
+                    });
+                    return awsArgs;
+                },
+                handler: async (args) => {
+                    const accessGrant = args.access?.length > 0
+                        ? args.access.map((x) => peerIdFromString(x))
+                        : [
+                            await (await getKeypair(args.directory)).publicKey.toPeerId(),
+                        ];
+                    const nodes = await launchNodes({
+                        email: "marcus@dao.xyz",
+                        count: args.number,
+                        namePrefix: args.name,
+                        region: args.region,
+                        grantAccess: accessGrant,
+                        size: args.size,
+                    });
+                    console.log(`Waiting for ${args.count} ${args.count > 1 ? "nodes" : "node"} to spawn. This might take a few minutes. You can watch the progress in your AWS console.`);
+                    const twirlTimer = (function () {
+                        const P = ["\\", "|", "/", "-"];
+                        let x = 0;
+                        return setInterval(function () {
+                            process.stdout.write("\r" + "Loading: " + chalk.hex(colors[x])(P[x++]));
+                            x &= 3;
+                        }, 250);
+                    })();
+                    try {
+                        for (const node of nodes) {
+                            const domain = await waitForDomain(node.publicIp);
+                            const remotes = new Remotes(getRemotesPath(args.directory));
+                            remotes.add({
+                                name: node.name,
+                                address: domain,
+                                group: args.group,
+                                origin: {
+                                    type: "aws",
+                                    instanceId: node.instanceId,
+                                    region: node.region,
+                                },
+                            });
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error waiting for domains to be available: " +
+                            error?.toString());
+                    }
+                    finally {
+                        clearInterval(twirlTimer);
+                        process.stdout.write("\r");
+                    }
+                    console.log(`New nodes available ${nodes.length}:`);
+                    for (const node of nodes) {
+                        console.log(chalk.green(node.name));
+                    }
+                },
+            })
+                .strict()
+                .demandCommand();
+        })
+            .command({
+            command: "terminate [name...]",
+            describe: "Terminate remote instances that was previously spawned",
+            builder: (killArgs) => {
+                killArgs.option("all", {
+                    describe: "Kill all nodes",
+                    type: "boolean",
+                    default: false,
+                });
+                killArgs.positional("name", {
+                    type: "string",
+                    describe: "Remote name",
+                    default: "localhost",
+                    demandOption: false,
+                    array: true,
+                });
+                return killArgs;
+            },
+            handler: async (args) => {
+                const remotes = new Remotes(getRemotesPath(args.directory));
+                const allRemotes = await remotes.all();
+                for (const remote of allRemotes) {
+                    if (args.all || args.name.includes(remote.name)) {
+                        if (remote.origin?.type === "aws") {
+                            await terminateNode({
+                                instanceId: remote.origin.instanceId,
+                                region: remote.origin.region,
+                            });
+                        }
+                    }
+                }
+            },
+        })
             .command({
             command: "list",
             aliases: "ls",
@@ -207,8 +443,9 @@ export const cli = async (args) => {
                 }, 0);
                 const all = await remotes.all();
                 if (all.length > 0) {
+                    console.log(padString("Name", maxNameLength + 10), padString("Group" || "", 10), "Address");
                     for (const remote of all) {
-                        console.log(padString(remote.name, maxNameLength + 10), remote.address);
+                        console.log(padString(remote.name, maxNameLength + 10), padString(remote.group || "", 10), remote.address);
                     }
                 }
                 else {
@@ -217,24 +454,25 @@ export const cli = async (args) => {
             },
         })
             .command({
-            command: "add <name> <address> <password>",
+            command: "add <name> <address>",
             describe: "Add remote",
             builder: (yargs) => {
                 yargs
-                    .positional("address", {
-                    type: "string",
-                    describe: "Remote name",
-                    demandOption: true,
-                })
                     .positional("name", {
                     type: "string",
                     describe: "Remote address",
                     demandOption: true,
                 })
-                    .positional("password", {
+                    .positional("address", {
                     type: "string",
-                    describe: "Password",
+                    describe: "Remote name",
                     demandOption: true,
+                })
+                    .option("group", {
+                    describe: "Group name",
+                    type: "string",
+                    alias: "g",
+                    default: DEFAULT_REMOTE_GROUP,
                 })
                     .option("directory", {
                     describe: "Peerbit directory",
@@ -249,7 +487,9 @@ export const cli = async (args) => {
                 if (args.name === "localhost") {
                     throw new Error("Remote can not be named 'localhost'");
                 }
-                const api = await client(args.password, args.address);
+                const api = await createClient(await getKeypair(args.directory), {
+                    address: args.address,
+                });
                 try {
                     await api.program.list();
                 }
@@ -260,7 +500,11 @@ export const cli = async (args) => {
                     fs.mkdirSync(args.directory, { recursive: true });
                 }
                 const remotes = new Remotes(getRemotesPath(args.directory));
-                remotes.add(args.name, args.address, args.password);
+                remotes.add({
+                    name: args.name,
+                    address: args.address,
+                    group: args.group,
+                });
             },
         })
             .command({
@@ -303,6 +547,18 @@ export const cli = async (args) => {
                     default: "localhost",
                     demandOption: false,
                     array: true,
+                })
+                    .option("all", {
+                    type: "boolean",
+                    describe: "Connect to all nodes",
+                    default: false,
+                })
+                    .option("group", {
+                    type: "string",
+                    describe: "Remote group name",
+                    alias: "g",
+                    default: [],
+                    array: true,
                 })
                     .option("directory", {
                     describe: "Peerbit directory",
@@ -314,19 +570,24 @@ export const cli = async (args) => {
                 return yargs;
             },
             handler: async (connectArgs) => {
-                const names = connectArgs.name;
+                const remotes = new Remotes(getRemotesPath(connectArgs.directory));
+                let names = connectArgs.name;
+                if (names.length === 0 ||
+                    connectArgs.all ||
+                    connectArgs.group.length > 0) {
+                    names = (await remotes.all()).map((x) => x.name);
+                }
                 const apis = [];
-                console.log(getRemotesPath(connectArgs.directory));
+                const config = await import("./config.js");
+                const keypair = await config.getKeypair(connectArgs.directory);
+                const selectedRemotes = [];
                 if (names.length > 0) {
-                    const remotes = new Remotes(getRemotesPath(connectArgs.directory));
-                    for (const name of names) {
+                    for (const [ix, name] of names.entries()) {
                         if (name === "localhost") {
-                            const config = await import("./config.js");
-                            const adminPassword = await config.loadPassword(config.getServerConfigPath(connectArgs.directory));
-                            apis.push({
-                                log: (string) => console.log("localhost: " + string),
+                            selectedRemotes.push({
+                                address: "http://localhost:" + LOCAL_API_PORT,
                                 name: "localhost",
-                                api: await client(adminPassword),
+                                group: DEFAULT_REMOTE_GROUP,
                             });
                         }
                         else {
@@ -334,311 +595,365 @@ export const cli = async (args) => {
                             if (!remote) {
                                 throw new Error("Missing remote with name: " + name);
                             }
-                            let logFn;
-                            if (names.length > 0) {
-                                logFn = (string) => console.log(name + ": " + string);
+                            if (connectArgs.group.length > 0 &&
+                                !connectArgs.group.includes(remote.group)) {
+                                continue;
                             }
-                            else {
-                                logFn = (string) => console.log(string);
-                            }
-                            apis.push({
-                                log: logFn,
-                                name,
-                                api: await client(remote.password, remote.address),
-                            });
+                            selectedRemotes.push(remote);
                         }
                     }
                 }
-                // try if authenticated
-                for (const api of apis) {
-                    try {
-                        await api.api.program.list();
+                const maxNameLength = selectedRemotes
+                    .map((x) => x.name.length)
+                    .reduce((prev, c, i) => {
+                    return Math.max(prev, c);
+                }, 0);
+                if (selectedRemotes.length === 0) {
+                    console.log(chalk.red("No remotes matched your connection condition"));
+                }
+                else {
+                    console.log(`Connected to (${selectedRemotes.length}):`);
+                    for (const [ix, remote] of selectedRemotes.entries()) {
+                        const chalkBg = chalk.bgHex(colors[ix]);
+                        console.log(chalkBg(remote.name));
+                        const logFn = (string) => console.log(padString(chalkBg(remote.name), maxNameLength, " ", remote.name.length) +
+                            ": " +
+                            string);
+                        apis.push({
+                            log: logFn,
+                            name: remote.name,
+                            api: await createClient(keypair, remote),
+                        });
                     }
-                    catch (error) {
-                        throw new Error(`Failed to connect to '${api.name}': ${error?.toString()}`);
+                    // try if authenticated
+                    for (const api of apis) {
+                        try {
+                            await api.api.program.list();
+                        }
+                        catch (error) {
+                            throw new Error(`Failed to connect to '${api.name}': ${error?.toString()}`);
+                        }
                     }
-                }
-                const capi = () => yargs
-                    .default()
-                    .command("peer", "Peer info", (yargs) => {
-                    yargs
-                        .command({
-                        command: "id",
-                        describe: "Get peer id",
-                        handler: async (args) => {
-                            for (const api of apis) {
-                                api.log((await api.api.peer.id.get()).toString());
-                            }
-                        },
+                    const rl = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout,
+                        terminal: true,
+                        historySize: 100,
+                    });
+                    console.log("Write 'help' to show commands.\n");
+                    rl.prompt(false);
+                    const capi = () => yargs
+                        .default()
+                        .command("peer", "Peer info", (yargs) => {
+                        yargs
+                            .command({
+                            command: "id",
+                            describe: "Get peer id",
+                            handler: async (args) => {
+                                for (const api of apis) {
+                                    api.log((await api.api.peer.id.get()).toString());
+                                }
+                            },
+                        })
+                            .command({
+                            command: "address",
+                            describe: "Get addresses",
+                            handler: async (args) => {
+                                for (const api of apis) {
+                                    (await api.api.peer.addresses.get()).forEach((x) => api.log(x.toString()));
+                                }
+                            },
+                        })
+                            .strict()
+                            .demandCommand();
+                        return yargs;
                     })
-                        .command({
-                        command: "address",
-                        describe: "Get addresses",
-                        handler: async (args) => {
-                            for (const api of apis) {
-                                (await api.api.peer.addresses.get()).forEach((x) => api.log(x.toString()));
-                            }
-                        },
+                        .command("access", "Modify access control for this node", (yargs) => {
+                        yargs
+                            .command({
+                            command: "grant <peer-id>",
+                            describe: "Give a peer-id admin capabilities",
+                            builder: (yargs) => {
+                                yargs.positional("peer-id", {
+                                    describe: "Peer id",
+                                    type: "string",
+                                    demandOption: true,
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                const peerId = peerIdFromString(args["peer-id"]);
+                                for (const api of apis) {
+                                    await api.api.access.allow(peerId);
+                                }
+                            },
+                        })
+                            .command({
+                            command: "deny <peer-id>",
+                            describe: "Remove admin capabilities from peer-id",
+                            builder: (yargs) => {
+                                yargs.positional("peer-id", {
+                                    describe: "Peer id",
+                                    demandOption: true,
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                const peerId = peerIdFromString(args["peer-id"]);
+                                for (const api of apis) {
+                                    await api.api.access.deny(peerId);
+                                }
+                            },
+                        })
+                            .strict()
+                            .demandCommand();
                     })
-                        .strict()
-                        .demandCommand();
-                    return yargs;
-                })
-                    .command("network", "Manage network", (yargs) => {
-                    yargs
-                        .command({
-                        command: "bootstrap",
-                        describe: "Connect to bootstrap nodes",
-                        handler: async () => {
-                            for (const api of apis) {
-                                await api.api.network.bootstrap();
-                            }
-                        },
+                        .command("network", "Manage network", (yargs) => {
+                        yargs
+                            .command({
+                            command: "bootstrap",
+                            describe: "Connect to bootstrap nodes",
+                            handler: async () => {
+                                for (const api of apis) {
+                                    await api.api.network.bootstrap();
+                                }
+                            },
+                        })
+                            .strict()
+                            .demandCommand();
                     })
-                        .strict()
-                        .demandCommand();
-                })
-                    .command("topic", "Manage topics the node is listening to", (yargs) => {
-                    yargs
-                        .command({
-                        command: "list",
-                        aliases: "ls",
-                        describe: "List all topics",
-                        builder: (yargs) => {
-                            yargs.option("replicate", {
-                                type: "boolean",
-                                describe: "Replicate data on this topic",
-                                aliases: "r",
-                                default: false,
-                            });
-                            return yargs;
-                        },
-                        handler: async (args) => {
-                            /* const c = await client();
-                const topics = await c.topics.get(args.replicate);
-                if (topics?.length > 0) {
-                    console.log("Topic (" + topics.length + "):");
-                    for (const t of topics) {
-                        console.log(t);
-                    }
-                } else {
-                    console.log("Not subscribed to any topics");
-                } */
-                            console.error("Not implemented");
-                        },
+                        .command("topic", "Manage topics the node is listening to", (yargs) => {
+                        yargs
+                            .command({
+                            command: "list",
+                            aliases: "ls",
+                            describe: "List all topics",
+                            builder: (yargs) => {
+                                yargs.option("replicate", {
+                                    type: "boolean",
+                                    describe: "Replicate data on this topic",
+                                    aliases: "r",
+                                    default: false,
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                /* const c = await client();
+                    const topics = await c.topics.get(args.replicate);
+                    if (topics?.length > 0) {
+                        console.log("Topic (" + topics.length + "):");
+                        for (const t of topics) {
+                            console.log(t);
+                        }
+                    } else {
+                        console.log("Not subscribed to any topics");
+                    } */
+                                console.error("Not implemented");
+                            },
+                        })
+                            .strict()
+                            .demandCommand();
+                        return yargs;
                     })
-                        .strict()
-                        .demandCommand();
-                    return yargs;
-                })
-                    .command("program", "Manage programs", (yargs) => {
-                    yargs
-                        .command({
-                        command: "status <address>",
-                        describe: "Is a program open",
-                        builder: (yargs) => {
-                            yargs.positional("address", {
-                                type: "string",
-                                describe: "Program address",
-                                demandOption: true,
-                            });
-                            return yargs;
-                        },
-                        handler: async (args) => {
-                            for (const api of apis) {
-                                const program = await api.api.program.has(args.address);
-                                if (!program) {
-                                    api.log(chalk.red("Closed"));
+                        .command("program", "Manage programs", (yargs) => {
+                        yargs
+                            .command({
+                            command: "status <address>",
+                            describe: "Is a program open",
+                            builder: (yargs) => {
+                                yargs.positional("address", {
+                                    type: "string",
+                                    describe: "Program address",
+                                    demandOption: true,
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                for (const api of apis) {
+                                    const program = await api.api.program.has(args.address);
+                                    if (!program) {
+                                        api.log(chalk.red("Closed"));
+                                    }
+                                    else {
+                                        api.log(chalk.green("Open"));
+                                    }
                                 }
-                                else {
-                                    api.log(chalk.green("Open"));
+                            },
+                        })
+                            .command({
+                            command: "drop <address>",
+                            describe: "Drop a program",
+                            builder: (yargs) => {
+                                yargs.positional("address", {
+                                    type: "string",
+                                    describe: "Program address",
+                                    demandOption: true,
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                for (const api of apis) {
+                                    try {
+                                        await api.api.program.drop(args.address);
+                                    }
+                                    catch (error) {
+                                        api.log(chalk.red(`Failed to drop ${args.address}: ${error.toString()}`));
+                                    }
                                 }
-                            }
-                        },
-                    })
-                        .command({
-                        command: "drop <address>",
-                        describe: "Drop a program",
-                        builder: (yargs) => {
-                            yargs.positional("address", {
-                                type: "string",
-                                describe: "Program address",
-                                demandOption: true,
-                            });
-                            return yargs;
-                        },
-                        handler: async (args) => {
-                            for (const api of apis) {
-                                try {
-                                    await api.api.program.drop(args.address);
+                            },
+                        })
+                            .command({
+                            command: "close <address>",
+                            describe: "Close a program",
+                            builder: (yargs) => {
+                                yargs.positional("address", {
+                                    type: "string",
+                                    describe: "Program address",
+                                    demandOption: true,
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                for (const api of apis) {
+                                    await api.api.program.close(args.address);
                                 }
-                                catch (error) {
-                                    api.log(chalk.red(`Failed to drop ${args.address}: ${error.toString()}`));
+                            },
+                        })
+                            .command({
+                            command: "list",
+                            describe: "List all running programs",
+                            aliases: "ls",
+                            handler: async (args) => {
+                                for (const api of apis) {
+                                    const list = await api.api.program.list();
+                                    api.log(`Running programs (${list.length}):`);
+                                    list.forEach((p) => {
+                                        api.log(chalk.green(p));
+                                    });
                                 }
-                            }
-                        },
+                            },
+                        })
+                            .command({
+                            command: "open [program]",
+                            describe: "Open program",
+                            builder: (yargs) => {
+                                yargs.positional("program", {
+                                    type: "string",
+                                    describe: "Identifier",
+                                    demandOption: true,
+                                });
+                                yargs.option("base64", {
+                                    type: "string",
+                                    describe: "Base64 encoded serialized",
+                                    aliases: "b",
+                                });
+                                yargs.option("variant", {
+                                    type: "string",
+                                    describe: "Variant name",
+                                    aliases: "v",
+                                });
+                                return yargs;
+                            },
+                            handler: async (args) => {
+                                if (!args.base64 && !args.variant) {
+                                    throw new Error("Either base64 or variant argument needs to be provided");
+                                }
+                                let startArg;
+                                if (args.base64) {
+                                    startArg = {
+                                        base64: args.base64,
+                                    };
+                                }
+                                else {
+                                    startArg = {
+                                        variant: args.variant,
+                                    };
+                                }
+                                for (const api of apis) {
+                                    const address = await api.api.program.open(startArg);
+                                    api.log("Started program with address: ");
+                                    api.log(chalk.green(address.toString()));
+                                }
+                            },
+                        })
+                            .strict()
+                            .demandCommand();
+                        return yargs;
                     })
                         .command({
-                        command: "close <address>",
-                        describe: "Close a program",
+                        command: "install <package-spec>",
+                        describe: "install and import a dependency",
                         builder: (yargs) => {
-                            yargs.positional("address", {
+                            yargs.positional("package-spec", {
                                 type: "string",
-                                describe: "Program address",
+                                describe: "Installed dependency will be loaded with js import(...)",
                                 demandOption: true,
                             });
                             return yargs;
                         },
                         handler: async (args) => {
+                            // if ends with .tgz assume it is a file
+                            let installCommand;
+                            const packageName = args["package-spec"];
+                            if (packageName.endsWith(".tgz")) {
+                                const packagePath = path.isAbsolute(packageName)
+                                    ? packageName
+                                    : path.join(process.cwd(), packageName);
+                                const buffer = fs.readFileSync(packagePath);
+                                const base64 = toBase64(buffer);
+                                installCommand = {
+                                    type: "tgz",
+                                    name: await getPackageName(packageName),
+                                    base64,
+                                };
+                            }
+                            else {
+                                installCommand = { type: "npm", name: packageName };
+                            }
                             for (const api of apis) {
-                                await api.api.program.close(args.address);
+                                const newPrograms = await api.api.dependency.install(installCommand);
+                                api.log(`New programs available (${newPrograms.length}):`);
+                                newPrograms.forEach((p) => {
+                                    api.log(chalk.green(p));
+                                });
                             }
                         },
                     })
                         .command({
-                        command: "list",
-                        describe: "List all running programs",
-                        aliases: "ls",
-                        handler: async (args) => {
+                        command: "restart",
+                        describe: "Restart the server",
+                        handler: async () => {
                             for (const api of apis) {
-                                const list = await api.api.program.list();
-                                api.log(`Running programs (${list.length}):`);
-                                list.forEach((p) => {
-                                    api.log(chalk.green(p));
-                                });
+                                await api.api.restart();
                             }
                         },
                     })
                         .command({
-                        command: "open [program]",
-                        describe: "Open program",
-                        builder: (yargs) => {
-                            yargs.positional("program", {
-                                type: "string",
-                                describe: "Identifier",
-                                demandOption: true,
-                            });
-                            yargs.option("base64", {
-                                type: "string",
-                                describe: "Base64 encoded serialized",
-                                aliases: "b",
-                            });
-                            yargs.option("variant", {
-                                type: "string",
-                                describe: "Variant name",
-                                aliases: "v",
-                            });
-                            return yargs;
-                        },
-                        handler: async (args) => {
-                            if (!args.base64 && !args.variant) {
-                                throw new Error("Either base64 or variant argument needs to be provided");
-                            }
-                            let startArg;
-                            if (args.base64) {
-                                startArg = {
-                                    base64: args.base64,
-                                };
-                            }
-                            else {
-                                startArg = {
-                                    variant: args.variant,
-                                };
-                            }
+                        command: "stop",
+                        describe: "Stop the server",
+                        handler: async () => {
                             for (const api of apis) {
-                                const address = await api.api.program.open(startArg);
-                                api.log("Started program with address: ");
-                                api.log(chalk.green(address.toString()));
+                                await api.api.stop();
                             }
                         },
                     })
+                        .help()
                         .strict()
-                        .demandCommand();
-                    return yargs;
-                })
-                    .command({
-                    command: "install <package-spec>",
-                    describe: "install and import a dependency",
-                    builder: (yargs) => {
-                        yargs.positional("package-spec", {
-                            type: "string",
-                            describe: "Installed dependency will be loaded with js import(...)",
-                            demandOption: true,
-                        });
-                        return yargs;
-                    },
-                    handler: async (args) => {
-                        // if ends with .tgz assume it is a file
-                        let installCommand;
-                        const packageName = args["package-spec"];
-                        if (packageName.endsWith(".tgz")) {
-                            const packagePath = path.isAbsolute(packageName)
-                                ? packageName
-                                : path.join(process.cwd(), packageName);
-                            const buffer = fs.readFileSync(packagePath);
-                            const base64 = toBase64(buffer);
-                            installCommand = {
-                                type: "tgz",
-                                name: await getPackageName(packageName),
-                                base64,
-                            };
+                        .scriptName("")
+                        .demandCommand()
+                        .showHelpOnFail(true)
+                        .exitProcess(false);
+                    rl.on("line", async (cargs) => {
+                        const cmds = capi();
+                        try {
+                            await cmds.parse(cargs);
                         }
-                        else {
-                            installCommand = { type: "npm", name: packageName };
-                        }
-                        for (const api of apis) {
-                            const newPrograms = await api.api.dependency.install(installCommand);
-                            api.log(`New programs available (${newPrograms.length}):`);
-                            newPrograms.forEach((p) => {
-                                api.log(chalk.green(p));
-                            });
+                        catch (error) {
+                            /* console.log(chalk.red("Error parsing command: " + cargs))*/
                         }
-                    },
-                })
-                    .command({
-                    command: "restart",
-                    describe: "Restart the server",
-                    handler: async () => {
-                        for (const api of apis) {
-                            await api.api.restart();
-                        }
-                    },
-                })
-                    .command({
-                    command: "terminate",
-                    describe: "Terminate the server",
-                    handler: async () => {
-                        for (const api of apis) {
-                            await api.api.terminate();
-                        }
-                    },
-                })
-                    .help()
-                    .strict()
-                    .scriptName("")
-                    .demandCommand()
-                    .showHelpOnFail(true)
-                    .exitProcess(false);
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                    terminal: true,
-                    historySize: 100,
-                });
-                console.log(chalk.green("Connected"));
-                console.log("Write 'help' to show commands.\n");
-                const first = true;
-                rl.prompt(false);
-                rl.on("line", async (cargs) => {
-                    const cmds = capi();
-                    try {
-                        await cmds.parse(cargs);
-                    }
-                    catch (error) {
-                        /* console.log(chalk.red("Error parsing command: " + cargs))*/
-                    }
-                    rl.prompt(true);
-                });
+                        rl.prompt(true);
+                    });
+                }
             },
         })
             .help()