@nodetool-ai/cli 0.7.0-rc.11

package/dist/commands/deploy.js

@@ -0,0 +1,645 @@
+/**
+ * `nodetool deploy` CLI commands — registered on a Commander `Command`
+ * via `registerDeployCommands(program)`. See docs/ for the full spec.
+ */
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as yaml from "js-yaml";
+import { ComputeType, CPUFlavor, DataCenter, GPUType, configureDocker, configureGCP, configureRunPod, getDeploymentConfigPath, initDeploymentConfig, loadDeploymentConfig, saveDeploymentConfig, WorkflowSyncer } from "@nodetool-ai/deploy";
+import { getCollection } from "@nodetool-ai/vectorstore";
+import { asJson, buildStubDeployment, confirm, getAdminClient, getDeploymentOrExit, getManager, getUserManager, loadConfigOrExit, makeSyncerDeps, parseParamPairs, printTable, promptLine, runEditor } from "./deploy-helpers.js";
+const SUPPORTED_TYPES = [
+    "docker",
+    "runpod",
+    "gcp",
+    "fly",
+    "railway",
+    "huggingface"
+];
+/** Common GCP Cloud Run regions. Hardcoded because not exported by @nodetool-ai/deploy. */
+const GCP_REGIONS = [
+    "us-central1",
+    "us-east1",
+    "us-east4",
+    "us-east5",
+    "us-south1",
+    "us-west1",
+    "us-west2",
+    "us-west3",
+    "us-west4",
+    "northamerica-northeast1",
+    "northamerica-northeast2",
+    "southamerica-east1",
+    "southamerica-west1",
+    "europe-central2",
+    "europe-north1",
+    "europe-southwest1",
+    "europe-west1",
+    "europe-west2",
+    "europe-west3",
+    "europe-west4",
+    "europe-west6",
+    "europe-west8",
+    "europe-west9",
+    "europe-west10",
+    "europe-west12",
+    "asia-east1",
+    "asia-east2",
+    "asia-northeast1",
+    "asia-northeast2",
+    "asia-northeast3",
+    "asia-south1",
+    "asia-south2",
+    "asia-southeast1",
+    "asia-southeast2",
+    "australia-southeast1",
+    "australia-southeast2",
+    "me-central1",
+    "me-central2",
+    "me-west1",
+    "africa-south1"
+];
+// ---------------------------------------------------------------------------
+// Wrapper to unify error handling on every sub-command
+// ---------------------------------------------------------------------------
+function runAction(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (err) {
+            console.error(String(err));
+            process.exit(1);
+        }
+    };
+}
+/** Parse a positive integer string or throw a clear error. */
+function parsePositiveInt(raw, label) {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+        throw new Error(`Invalid ${label} '${raw}': expected a positive integer.`);
+    }
+    return n;
+}
+/** Parse a port number (1–65535) or throw. */
+function parsePort(raw, label) {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new Error(`Invalid ${label} '${raw}': expected an integer in the range 1–65535.`);
+    }
+    return n;
+}
+// ---------------------------------------------------------------------------
+// Public registration hooks
+// ---------------------------------------------------------------------------
+export function registerDeployCommands(program) {
+    const deploy = program
+        .command("deploy")
+        .description("Manage deployments (docker, runpod, gcp, fly, railway, huggingface)");
+    registerInit(deploy);
+    registerList(deploy);
+    registerShow(deploy);
+    registerAdd(deploy);
+    registerEdit(deploy);
+    registerPlan(deploy);
+    registerApply(deploy);
+    registerStatus(deploy);
+    registerLogs(deploy);
+    registerDestroy(deploy);
+    registerWorkflows(deploy);
+    registerDatabase(deploy);
+    registerCollections(deploy);
+    registerUsers(deploy);
+}
+export function registerListGcpOptions(program) {
+    program
+        .command("list-gcp-options")
+        .description("List supported GCP Cloud Run regions and RunPod GPU/CPU/data-center options")
+        .option("--json", "Output as JSON")
+        .action(runAction(async (opts) => {
+        const data = {
+            gcp_regions: GCP_REGIONS,
+            runpod_gpu_types: Object.values(GPUType),
+            runpod_cpu_flavors: Object.values(CPUFlavor),
+            runpod_data_centers: Object.values(DataCenter),
+            runpod_compute_types: Object.values(ComputeType)
+        };
+        if (opts.json) {
+            asJson(data);
+            return;
+        }
+        console.log("\nGCP Cloud Run regions:");
+        printTable(data.gcp_regions.map((r) => ({ region: r })));
+        console.log("\nRunPod GPU types:");
+        printTable(data.runpod_gpu_types.map((g) => ({ gpu_type: g })));
+        console.log("\nRunPod CPU flavors:");
+        printTable(data.runpod_cpu_flavors.map((c) => ({ cpu_flavor: c })));
+        console.log("\nRunPod compute types:");
+        printTable(data.runpod_compute_types.map((c) => ({ compute_type: c })));
+        console.log("\nRunPod data centers:");
+        printTable(data.runpod_data_centers.map((d) => ({ data_center: d })));
+        console.log();
+    }));
+}
+// ---------------------------------------------------------------------------
+// init / list / show / add / edit
+// ---------------------------------------------------------------------------
+function registerInit(deploy) {
+    deploy
+        .command("init")
+        .description("Initialize deployment.yaml with defaults")
+        .action(runAction(async () => {
+        const configPath = getDeploymentConfigPath();
+        if (fs.existsSync(configPath)) {
+            const ok = await confirm(`${configPath} already exists. Overwrite?`);
+            if (!ok)
+                return;
+            await fsp.unlink(configPath);
+        }
+        await initDeploymentConfig();
+        console.log(`Created ${configPath}`);
+        console.log("\nNext steps:");
+        console.log("  nodetool deploy add <name> --type docker|runpod|gcp|fly|railway|huggingface");
+        console.log("  nodetool deploy plan <name>");
+        console.log("  nodetool deploy apply <name>");
+    }));
+}
+function registerList(deploy) {
+    deploy
+        .command("list")
+        .description("List configured deployments with status")
+        .option("--json", "Output as JSON")
+        .action(runAction(async (opts) => {
+        const mgr = await getManager();
+        const rows = await mgr.listDeployments();
+        if (opts.json) {
+            asJson(rows);
+            return;
+        }
+        if (rows.length === 0) {
+            console.log("(no deployments configured)");
+            return;
+        }
+        printTable(rows, [
+            "name",
+            "type",
+            "status",
+            "last_deployed",
+            "host",
+            "container",
+            "pod_id",
+            "project",
+            "region",
+            "service"
+        ]);
+    }));
+}
+function registerShow(deploy) {
+    deploy
+        .command("show <name>")
+        .description("Print deployment config as YAML")
+        .action(runAction(async (name) => {
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, name);
+        process.stdout.write(yaml.dump({ [name]: dep }, { sortKeys: false, noCompatMode: true }));
+    }));
+}
+function registerAdd(deploy) {
+    deploy
+        .command("add <name>")
+        .description("Add a deployment via interactive prompts")
+        .requiredOption("--type <type>", `Deployment type (${SUPPORTED_TYPES.join("|")})`)
+        .action(runAction(async (name, opts) => {
+        const type = opts.type;
+        if (!SUPPORTED_TYPES.includes(type)) {
+            throw new Error(`Invalid --type '${opts.type}'. Must be one of: ${SUPPORTED_TYPES.join(", ")}`);
+        }
+        let config;
+        try {
+            config = await loadDeploymentConfig();
+        }
+        catch {
+            const shouldInit = await confirm("No deployment.yaml found. Create one now?");
+            if (!shouldInit) {
+                console.error("Run 'nodetool deploy init' first to create deployment.yaml.");
+                process.exit(1);
+            }
+            config = await initDeploymentConfig();
+        }
+        if (config.deployments[name]) {
+            throw new Error(`Deployment '${name}' already exists`);
+        }
+        let deployment;
+        switch (type) {
+            case "docker": {
+                const host = await promptLine("Docker host (IP/hostname or localhost)", {
+                    default: "localhost"
+                });
+                const isLocal = host === "localhost" ||
+                    host === "127.0.0.1" ||
+                    host === "::1" ||
+                    host === "0.0.0.0";
+                const sshUser = isLocal
+                    ? undefined
+                    : await promptLine("SSH user", { default: "root" });
+                const sshKeyPath = isLocal
+                    ? undefined
+                    : await promptLine("SSH key path", { default: "~/.ssh/id_rsa" });
+                const imageName = await promptLine("Docker image name", {
+                    default: "ghcr.io/nodetool-ai/nodetool"
+                });
+                const imageTag = await promptLine("Image tag", {
+                    default: "latest"
+                });
+                const containerName = await promptLine("Container name", {
+                    default: `nodetool-${name}`
+                });
+                const containerPortRaw = await promptLine("Container port", {
+                    default: "8000"
+                });
+                const containerPort = parsePort(containerPortRaw, "Container port");
+                deployment = configureDocker(name, {
+                    host,
+                    sshUser,
+                    sshKeyPath,
+                    imageName,
+                    imageTag,
+                    containerName,
+                    containerPort
+                });
+                break;
+            }
+            case "runpod": {
+                const imageName = await promptLine("RunPod Docker image name (e.g. user/nodetool)");
+                const imageTag = await promptLine("Image tag", {
+                    default: "latest"
+                });
+                const registry = await promptLine("Registry", {
+                    default: "docker.io"
+                });
+                deployment = configureRunPod(name, { imageName, imageTag, registry });
+                break;
+            }
+            case "gcp": {
+                const projectId = await promptLine("GCP project ID");
+                const region = await promptLine("Region", {
+                    default: "us-central1"
+                });
+                const serviceName = await promptLine("Cloud Run service name", {
+                    default: name
+                });
+                const imageRepository = await promptLine("Image repository (e.g. project/repo/image)");
+                const imageTag = await promptLine("Image tag", {
+                    default: "latest"
+                });
+                deployment = configureGCP(name, {
+                    projectId,
+                    region,
+                    serviceName,
+                    imageRepository,
+                    imageTag
+                });
+                break;
+            }
+            case "fly":
+            case "railway":
+            case "huggingface":
+                deployment = buildStubDeployment(type, name);
+                break;
+        }
+        config.deployments[name] = deployment;
+        await saveDeploymentConfig(config);
+        console.log(`Added '${name}' to ${getDeploymentConfigPath()}`);
+        if (type === "fly" || type === "railway" || type === "huggingface") {
+            console.log(`Stub deployment written — run 'nodetool deploy edit ${name}' to finish configuring.`);
+        }
+    }));
+}
+function registerEdit(deploy) {
+    deploy
+        .command("edit")
+        .description("Open deployment.yaml in $EDITOR")
+        .action(runAction(async () => {
+        const configPath = getDeploymentConfigPath();
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`No deployment.yaml at ${configPath}. Run 'nodetool deploy init' first.`);
+        }
+        const status = runEditor(configPath);
+        if (status !== 0)
+            process.exit(status);
+    }));
+}
+// ---------------------------------------------------------------------------
+// lifecycle: plan / apply / status / logs / destroy
+// ---------------------------------------------------------------------------
+function registerPlan(deploy) {
+    deploy
+        .command("plan <name>")
+        .description("Show what 'apply' would do")
+        .action(runAction(async (name) => {
+        const mgr = await getManager();
+        const plan = await mgr.plan(name);
+        asJson(plan);
+    }));
+}
+function registerApply(deploy) {
+    deploy
+        .command("apply <name>")
+        .description("Deploy to its target platform")
+        .option("--dry-run", "Show what would be done without executing")
+        .action(runAction(async (name, opts) => {
+        const mgr = await getManager();
+        const result = await mgr.apply(name, { dryRun: Boolean(opts.dryRun) });
+        asJson(result);
+        if (result["status"] === "error")
+            process.exit(1);
+    }));
+}
+function registerStatus(deploy) {
+    deploy
+        .command("status <name>")
+        .description("Show the current status of a deployment")
+        .action(runAction(async (name) => {
+        const mgr = await getManager();
+        const status = await mgr.status(name);
+        asJson(status);
+    }));
+}
+function registerLogs(deploy) {
+    deploy
+        .command("logs <name>")
+        .description("Fetch deployment logs (streaming for --follow depends on platform support)")
+        .option("--service <service>", "Service/container name")
+        .option("-f, --follow", "Follow logs")
+        .option("--tail <n>", "Number of lines to tail", "100")
+        .action(runAction(async (name, opts) => {
+        const tail = parsePositiveInt(opts.tail, "--tail");
+        const mgr = await getManager();
+        const text = await mgr.logs(name, {
+            service: opts.service,
+            follow: Boolean(opts.follow),
+            tail
+        });
+        process.stdout.write(text);
+        if (!text.endsWith("\n"))
+            process.stdout.write("\n");
+    }));
+}
+function registerDestroy(deploy) {
+    deploy
+        .command("destroy <name>")
+        .description("Tear down a deployment")
+        .option("--force", "Skip confirmation")
+        .action(runAction(async (name, opts) => {
+        const ok = await confirm(`Destroy '${name}'? This action is irreversible.`, { force: Boolean(opts.force) });
+        if (!ok)
+            return;
+        const mgr = await getManager();
+        const result = await mgr.destroy(name, {
+            force: Boolean(opts.force)
+        });
+        asJson(result);
+    }));
+}
+// ---------------------------------------------------------------------------
+// workflows subgroup
+// ---------------------------------------------------------------------------
+function registerWorkflows(deploy) {
+    const wf = deploy
+        .command("workflows")
+        .description("Manage workflows on a remote deployment");
+    wf.command("sync <deployment> <workflow_id>")
+        .description("Sync a local workflow (and its assets/models) to the deployment")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, workflowId, opts) => {
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        const syncer = new WorkflowSyncer(client, makeSyncerDeps());
+        const ok = await syncer.syncWorkflow(workflowId);
+        if (!ok)
+            process.exit(1);
+        console.log(`Synced '${workflowId}' to '${deploymentName}'`);
+    }));
+    wf.command("list <deployment>")
+        .description("List workflows on a deployment")
+        .option("--token <token>", "Admin bearer token")
+        .option("--json", "Output as JSON")
+        .action(runAction(async (deploymentName, opts) => {
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        const result = await client.listWorkflows();
+        const rows = (result["workflows"] ?? []);
+        if (opts.json) {
+            asJson(rows);
+            return;
+        }
+        printTable(rows.map((r) => ({
+            id: r["id"],
+            name: r["name"],
+            updated_at: r["updated_at"]
+        })));
+    }));
+    wf.command("delete <deployment> <workflow_id>")
+        .description("Delete a workflow on the deployment")
+        .option("--force", "Skip confirmation")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, workflowId, opts) => {
+        const ok = await confirm(`Delete workflow '${workflowId}' on '${deploymentName}'?`, { force: Boolean(opts.force) });
+        if (!ok)
+            return;
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        await client.deleteWorkflow(workflowId);
+        console.log(`deleted '${workflowId}'`);
+    }));
+    wf.command("run <deployment> <workflow_id>")
+        .description("Run a workflow on the deployment")
+        .option("-p, --param <k=v>", "Parameter k=v (repeatable)", (val, acc = []) => {
+        acc.push(val);
+        return acc;
+    }, [])
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, workflowId, opts) => {
+        const params = parseParamPairs(opts.param ?? []);
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        const result = await client.runWorkflow(workflowId, params);
+        asJson(result);
+    }));
+}
+// ---------------------------------------------------------------------------
+// database subgroup
+// ---------------------------------------------------------------------------
+function registerDatabase(deploy) {
+    const db = deploy.command("database").description("Remote DB row management");
+    db.command("get <deployment> <table> <key>")
+        .description("Read a DB row")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, table, key, opts) => {
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        const row = await client.dbGet(table, key);
+        asJson(row);
+    }));
+    db.command("save <deployment> <table> <json_data>")
+        .description("Upsert a DB row (positional JSON string)")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, table, jsonData, opts) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonData);
+        }
+        catch (e) {
+            throw new Error(`Invalid JSON for <json_data>: ${String(e)}`);
+        }
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        const row = await client.dbSave(table, parsed);
+        asJson(row);
+    }));
+    db.command("delete <deployment> <table> <key>")
+        .description("Delete a DB row")
+        .option("--force", "Skip confirmation")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, table, key, opts) => {
+        const ok = await confirm(`Delete '${table}/${key}' on '${deploymentName}'?`, { force: Boolean(opts.force) });
+        if (!ok)
+            return;
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        await client.dbDelete(table, key);
+        console.log("deleted");
+    }));
+}
+// ---------------------------------------------------------------------------
+// collections sync
+// ---------------------------------------------------------------------------
+function registerCollections(deploy) {
+    const coll = deploy
+        .command("collections")
+        .description("Sync local vector collections to a deployment");
+    coll
+        .command("sync <deployment> <collection>")
+        .description("Sync a local collection to the deployment")
+        .option("--token <token>", "Admin bearer token")
+        .option("--batch-size <n>", "Batch size for uploads", "100")
+        .action(runAction(async (deploymentName, collectionName, opts) => {
+        const batchSize = parsePositiveInt(opts.batchSize, "--batch-size");
+        const collection = await getCollection(collectionName);
+        if (!collection) {
+            throw new Error(`Local collection not found: ${collectionName}`);
+        }
+        const metadata = collection
+            .metadata ?? {};
+        const embeddingModel = metadata["embedding_model"] ?? "";
+        if (!embeddingModel) {
+            throw new Error(`Local collection '${collectionName}' has no embedding_model in metadata — cannot sync without embeddings.`);
+        }
+        // Inspect the local collection BEFORE creating anything on the
+        // remote, so partial failures don't leave an empty/orphan collection
+        // on the deployment.
+        const withGet = collection;
+        const page = await withGet.get({ limit: batchSize, offset: 0 });
+        if (page.ids.length > 0) {
+            throw new Error("deploy collections sync: re-embedding of local documents during sync is not yet implemented in the Node CLI. " +
+                `Found ${page.ids.length} document(s) locally but cannot upload without embeddings. ` +
+                "No remote collection was created.");
+        }
+        // Empty collection — safe to create on the remote as a no-op sync.
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const client = await getAdminClient(dep, deploymentName, opts);
+        await client.createCollection(collectionName, embeddingModel);
+        console.log(`Collection '${collectionName}' is empty — created an empty collection on '${deploymentName}'.`);
+    }));
+}
+// ---------------------------------------------------------------------------
+// users-* commands
+// ---------------------------------------------------------------------------
+function registerUsers(deploy) {
+    deploy
+        .command("users-add <deployment> <username>")
+        .description("Add an API user to the deployment")
+        .option("--role <role>", "User role (admin|user)", "user")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, username, opts) => {
+        if (opts.role !== "admin" && opts.role !== "user") {
+            throw new Error(`Invalid --role '${opts.role}'. Must be 'admin' or 'user'.`);
+        }
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const mgr = await getUserManager(dep, deploymentName, opts);
+        const result = await mgr.addUser(username, opts.role);
+        console.log(`Created user '${result.username}' (role: ${result.role}, id: ${result.user_id})`);
+        if (result.token) {
+            console.log("");
+            console.log(`  Token: ${result.token}`);
+            console.log("");
+            console.log("  WARNING: save this token now — it will not be shown again.");
+        }
+    }));
+    deploy
+        .command("users-list <deployment>")
+        .description("List API users on the deployment")
+        .option("--token <token>", "Admin bearer token")
+        .option("--json", "Output as JSON")
+        .action(runAction(async (deploymentName, opts) => {
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const mgr = await getUserManager(dep, deploymentName, opts);
+        const users = await mgr.listUsers();
+        if (opts.json) {
+            asJson(users);
+            return;
+        }
+        printTable(users.map((u) => ({
+            username: u.username,
+            user_id: u.user_id,
+            role: u.role,
+            token_hash_preview: u.token_hash
+                ? `${u.token_hash.slice(0, 16)}...`
+                : "",
+            created_at: (u.created_at ?? "").slice(0, 19)
+        })), ["username", "user_id", "role", "token_hash_preview", "created_at"]);
+    }));
+    deploy
+        .command("users-remove <deployment> <username>")
+        .description("Remove an API user")
+        .option("--force", "Skip confirmation")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, username, opts) => {
+        const ok = await confirm(`Remove user '${username}' from '${deploymentName}'?`, { force: Boolean(opts.force) });
+        if (!ok)
+            return;
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const mgr = await getUserManager(dep, deploymentName, opts);
+        await mgr.removeUser(username);
+        console.log(`removed '${username}'`);
+    }));
+    deploy
+        .command("users-reset-token <deployment> <username>")
+        .description("Rotate a user's API token")
+        .option("--token <token>", "Admin bearer token")
+        .action(runAction(async (deploymentName, username, opts) => {
+        const config = await loadConfigOrExit();
+        const dep = getDeploymentOrExit(config, deploymentName);
+        const mgr = await getUserManager(dep, deploymentName, opts);
+        const result = await mgr.resetToken(username);
+        console.log(`Rotated token for '${result.username}'`);
+        if (result.token) {
+            console.log("");
+            console.log(`  New token: ${result.token}`);
+            console.log("");
+            console.log("  The previous token is now invalid. Save this token — it will not be shown again.");
+        }
+    }));
+}
+//# sourceMappingURL=deploy.js.map