@peerbit/server 1.1.2 → 2.0.0

package/lib/esm/cli.js

@@ -1,9 +1,26 @@
 import { createTestDomain, getDomainFromConfig, loadConfig, startCertbot, } from "./domain.js";
 import { startServerWithNode } from "./server.js";
 import { createRecord } from "./aws.js";
-import { getHomeConfigDir } from "./config.js";
+import { getHomeConfigDir, getPackageName, getRemotesPath } from "./config.js";
 import chalk from "chalk";
 import { client } 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 = " ") {
+    const val = string.valueOf();
+    if (Math.abs(padding) <= val.length) {
+        return val;
+    }
+    const m = Math.max(Math.abs(padding) - string.length || 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;
+    //      return (n < 0) ? val + pad : pad + val;
+};
 export const cli = async (args) => {
     const yargs = await import("yargs");
     if (!args) {
@@ -15,28 +32,56 @@ export const cli = async (args) => {
         .command({
         command: "start",
         describe: "Start node",
-        builder: {
-            directory: {
-                describe: "Directory for all data created by the node",
+        builder: (yargs) => {
+            yargs
+                .option("directory", {
+                describe: "Peerbit directory",
                 defaultDescription: "~.peerbit",
                 type: "string",
-                default: await getHomeConfigDir(),
-            },
-            bootstrap: {
+                alias: "d",
+                default: getHomeConfigDir(),
+            })
+                .option("bootstrap", {
                 describe: "Whether to connect to bootstap nodes on startup",
                 type: "boolean",
                 default: false,
-            },
+            })
+                .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",
+                type: "number",
+                default: undefined,
+            })
+                .option("port-node", {
+                describe: "Set Libp2p listen port. Only modify this when testing locally, since NGINX config depends on the default value",
+                type: "number",
+                default: undefined,
+            });
+            return yargs;
         },
         handler: async (args) => {
             await startServerWithNode({
                 directory: args.directory,
                 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,
             });
         },
     })
-        .command("domain", "Setup a domain and certificate", (yargs) => {
+        .command("domain", "Setup a domain and certificate for this node", (yargs) => {
         yargs
             .command({
             command: "test",
@@ -62,7 +107,6 @@ export const cli = async (args) => {
             handler: async (args) => {
                 const domain = await createTestDomain();
                 await startCertbot(domain, args.email, args.outdir, args.wait);
-                const { exit } = await import("process");
                 exit();
             },
         })
@@ -131,193 +175,476 @@ export const cli = async (args) => {
                         : undefined,
                 });
                 await startCertbot(args.domain, args.email, args.outdir, args.wait);
-                const { exit } = await import("process");
                 exit();
             },
         })
             .strict()
             .demandCommand();
     })
-        .command("network", "Manage network", (yargs) => {
-        yargs
-            .command({
-            command: "bootstrap",
-            describe: "Connect to bootstrap nodes",
-            handler: async () => {
-                const c = await client();
-                await c.network.bootstrap();
-            },
-        })
-            .strict()
-            .demandCommand();
-    })
-        .command("topic", "Manage topics the node is listening to", (yargs) => {
-        yargs
+        .command("remote", "Handle remote nodes", (innerYargs) => {
+        innerYargs
             .command({
             command: "list",
             aliases: "ls",
-            describe: "List all topics",
-            builder: (yargs) => {
-                yargs.option("replicate", {
-                    type: "boolean",
-                    describe: "Replicate data on this topic",
-                    alias: "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;
-    })
-        .command("program", "Manage programs", (yargs) => {
-        yargs
-            .command({
-            command: "status <address>",
-            describe: "Is a program open",
+            describe: "List remotes",
             builder: (yargs) => {
-                yargs.positional("address", {
+                yargs.option("directory", {
+                    describe: "Peerbit directory",
+                    defaultDescription: "~.peerbit",
                     type: "string",
-                    describe: "Program address",
-                    demandOption: true,
+                    alias: "d",
+                    default: getHomeConfigDir(),
                 });
                 return yargs;
             },
             handler: async (args) => {
-                const c = await client();
-                const program = await c.program.has(args.address);
-                if (!program) {
-                    console.log(chalk.red("Closed"));
+                const remotes = new Remotes(getRemotesPath(args.directory));
+                const allRemotes = await remotes.all();
+                const maxNameLength = allRemotes
+                    .map((x) => x.name.length)
+                    .reduce((prev, c, i) => {
+                    return Math.max(prev, c);
+                }, 0);
+                const all = await remotes.all();
+                if (all.length > 0) {
+                    for (const remote of all) {
+                        console.log(padString(remote.name, maxNameLength + 10), remote.address);
+                    }
                 }
                 else {
-                    console.log(chalk.green("Open"));
+                    console.log("No remotes found!");
                 }
             },
         })
             .command({
-            command: "drop <address>",
-            describe: "Drop a program",
+            command: "add <name> <address> <password>",
+            describe: "Add remote",
             builder: (yargs) => {
-                yargs.positional("address", {
+                yargs
+                    .positional("address", {
                     type: "string",
-                    describe: "Program address",
+                    describe: "Remote name",
                     demandOption: true,
+                })
+                    .positional("name", {
+                    type: "string",
+                    describe: "Remote address",
+                    demandOption: true,
+                })
+                    .positional("password", {
+                    type: "string",
+                    describe: "Password",
+                    demandOption: true,
+                })
+                    .option("directory", {
+                    describe: "Peerbit directory",
+                    defaultDescription: "~.peerbit",
+                    type: "string",
+                    alias: "d",
+                    default: getHomeConfigDir(),
                 });
                 return yargs;
             },
             handler: async (args) => {
-                const c = await client();
-                await c.program.drop(args.address);
+                if (args.name === "localhost") {
+                    throw new Error("Remote can not be named 'localhost'");
+                }
+                const api = await client(args.password, args.address);
+                try {
+                    await api.program.list();
+                }
+                catch (error) {
+                    throw new Error("Failed to add remote: " + error?.toString());
+                }
+                if (!fs.existsSync(args.directory)) {
+                    fs.mkdirSync(args.directory, { recursive: true });
+                }
+                const remotes = new Remotes(getRemotesPath(args.directory));
+                remotes.add(args.name, args.address, args.password);
             },
         })
             .command({
-            command: "close <address>",
-            describe: "Close a program",
+            command: "remove <name>",
+            describe: "Remove a remote",
             builder: (yargs) => {
-                yargs.positional("address", {
+                yargs
+                    .positional("name", {
                     type: "string",
-                    describe: "Program address",
+                    describe: "Remote address",
                     demandOption: true,
+                })
+                    .option("directory", {
+                    describe: "Peerbit directory",
+                    defaultDescription: "~.peerbit",
+                    type: "string",
+                    alias: "d",
+                    default: getHomeConfigDir(),
                 });
                 return yargs;
             },
             handler: async (args) => {
-                const c = await client();
-                await c.program.close(args.address);
-            },
-        })
-            .command({
-            command: "list",
-            describe: "List all running programs",
-            aliases: "ls",
-            handler: async (args) => {
-                const c = await client();
-                const list = await c.program.list();
-                console.log(`Running programs (${list.length}):`);
-                list.forEach((p) => {
-                    console.log(chalk.green(p));
-                });
+                const remotes = new Remotes(getRemotesPath(args.directory));
+                if (remotes.remove(args.name)) {
+                    console.log(chalk.green("Removed remote with name: " + args.name));
+                }
+                else {
+                    console.log(chalk.red("Did not find any remote with name: " + args.name));
+                }
             },
         })
             .command({
-            command: "open [program]",
-            describe: "Open program",
+            command: "connect [name...]",
+            describe: "Connect to remote(s)",
             builder: (yargs) => {
-                yargs.positional("program", {
+                yargs
+                    .positional("name", {
                     type: "string",
-                    describe: "Identifier",
-                    demandOption: true,
-                });
-                yargs.option("base64", {
-                    type: "string",
-                    describe: "Base64 encoded serialized",
-                    alias: "b",
-                });
-                yargs.option("variant", {
+                    describe: "Remote name",
+                    default: "localhost",
+                    demandOption: false,
+                    array: true,
+                })
+                    .option("directory", {
+                    describe: "Peerbit directory",
+                    defaultDescription: "~.peerbit",
                     type: "string",
-                    describe: "Variant name",
-                    alias: "v",
+                    alias: "d",
+                    default: getHomeConfigDir(),
                 });
                 return yargs;
             },
-            handler: async (args) => {
-                const c = await client();
-                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,
-                    };
+            handler: async (connectArgs) => {
+                const names = connectArgs.name;
+                const apis = [];
+                console.log(getRemotesPath(connectArgs.directory));
+                if (names.length > 0) {
+                    const remotes = new Remotes(getRemotesPath(connectArgs.directory));
+                    for (const name of names) {
+                        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),
+                                name: "localhost",
+                                api: await client(adminPassword),
+                            });
+                        }
+                        else {
+                            const remote = remotes.getByName(name);
+                            if (!remote) {
+                                throw new Error("Missing remote with name: " + name);
+                            }
+                            let logFn;
+                            if (names.length > 0) {
+                                logFn = (string) => console.log(name + ": " + string);
+                            }
+                            else {
+                                logFn = (string) => console.log(string);
+                            }
+                            apis.push({
+                                log: logFn,
+                                name,
+                                api: await client(remote.password, remote.address),
+                            });
+                        }
+                    }
                 }
-                else {
-                    startArg = {
-                        variant: args.variant,
-                    };
+                // 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 address = await c.program.open(startArg);
-                console.log("Started program with address: ");
-                console.log(chalk.green(address.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());
+                            }
+                        },
+                    })
+                        .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("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();
+                })
+                    .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;
+                })
+                    .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"));
+                                }
+                            }
+                        },
+                    })
+                        .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: "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);
+                            }
+                        },
+                    })
+                        .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: "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,
+                            };
+                        }
+                        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));
+                            });
+                        }
+                    },
+                })
+                    .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);
+                });
             },
         })
+            .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) => {
-            const c = await client();
-            const newPrograms = await c.dependency.install(args["package-spec"]);
-            console.log(`New programs available (${newPrograms.length}):`);
-            newPrograms.forEach((p) => {
-                console.log(chalk.green(p));
-            });
-        },
+        return innerYargs;
     })
         .help()
         .strict()