velaclaw-dev 0.2.0

package/dist/cli.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const SCAFFOLD_FILES = [
+    ".gitignore",
+    "ARCHITECTURE.md",
+    "README.md",
+    "README.dev.md",
+    "README.public.md",
+    "TESTING.md",
+    "RELEASING.md",
+    "provision-member.md",
+    "members/README.md",
+    "members/LAUNCH_CHECKLIST.md",
+    "team-assets/README.md",
+    "shared-snapshots/README.md",
+    "services/litellm/docker-compose.yml",
+    "services/litellm/config.yaml",
+    "services/litellm/litellm.env.example",
+    "members/member-template/runtime/docker-compose.yml",
+    "members/member-template/runtime/config/openclaw.json",
+    "members/member-template/runtime/secrets/.gitkeep",
+    "members/member-template/runtime/workspace/.gitkeep",
+    "pic/banner.jpg"
+];
+const SCAFFOLD_DIRS = [
+    "members/member-template/runtime/config/local-plugins",
+    "members/member-template/private-memory",
+    "members/member-template/private-skills",
+    "members/member-template/private-tools",
+    "members/member-template/private-docs",
+    "services/litellm",
+    "state",
+    "teams",
+    "artifacts"
+];
+function printUsage() {
+    console.log([
+        "Velaclaw CLI",
+        "",
+        "Usage:",
+        "  velaclaw init <dir>",
+        "  velaclaw start [--root <dir>] [--port <port>]",
+        "  velaclaw verify [--root <dir>] [--base-url <url>]",
+        "  velaclaw smoke skills [--root <dir>]",
+        "  velaclaw smoke assets [--root <dir>]",
+        "  velaclaw smoke load-test [--root <dir>]",
+        "  velaclaw version"
+    ].join("\n"));
+}
+function parseFlag(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0) {
+        return undefined;
+    }
+    return args[index + 1];
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureEmptyOrMissingDir(targetDir, force) {
+    if (!(await pathExists(targetDir))) {
+        return;
+    }
+    const entries = await fs.readdir(targetDir);
+    if (!entries.length || force) {
+        return;
+    }
+    throw new Error(`target directory is not empty: ${targetDir}`);
+}
+async function copyIntoTarget(targetRoot) {
+    for (const dir of SCAFFOLD_DIRS) {
+        await fs.mkdir(path.join(targetRoot, dir), { recursive: true });
+    }
+    for (const relPath of SCAFFOLD_FILES) {
+        const source = path.join(PKG_ROOT, relPath);
+        const destination = path.join(targetRoot, relPath);
+        await fs.mkdir(path.dirname(destination), { recursive: true });
+        await fs.cp(source, destination, { recursive: true, force: true });
+    }
+    const pluginSource = path.join(PKG_ROOT, "members", "member-template", "runtime", "config", "local-plugins");
+    const pluginDest = path.join(targetRoot, "members", "member-template", "runtime", "config", "local-plugins");
+    if (await pathExists(pluginSource)) {
+        await fs.cp(pluginSource, pluginDest, { recursive: true, force: true });
+    }
+    await fs.writeFile(path.join(targetRoot, "state", ".gitkeep"), "", "utf8");
+}
+function runNodeScript(scriptPath, options) {
+    const child = spawn(process.execPath, [scriptPath], {
+        cwd: options.cwd,
+        env: {
+            ...process.env,
+            ...(options.env || {})
+        },
+        stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+        process.exitCode = code ?? 1;
+    });
+}
+function resolveRoot(args) {
+    const raw = parseFlag(args, "--root");
+    return path.resolve(raw || process.cwd());
+}
+async function runInit(args) {
+    const targetArg = args[0];
+    if (!targetArg) {
+        throw new Error("init requires a target directory");
+    }
+    const targetRoot = path.resolve(targetArg);
+    const force = hasFlag(args, "--force");
+    await fs.mkdir(targetRoot, { recursive: true });
+    await ensureEmptyOrMissingDir(targetRoot, force);
+    await copyIntoTarget(targetRoot);
+    console.log([
+        `Initialized Velaclaw workspace at ${targetRoot}`,
+        "",
+        "Next steps:",
+        `  cp ${path.join(targetRoot, "services/litellm/litellm.env.example")} ~/.config/velaclaw/litellm.env`,
+        `  cd ${targetRoot}`,
+        "  docker compose -f services/litellm/docker-compose.yml up -d",
+        "  velaclaw start",
+        "  velaclaw verify"
+    ].join("\n"));
+}
+async function runStart(args) {
+    const root = resolveRoot(args);
+    const port = parseFlag(args, "--port");
+    if (!(await pathExists(path.join(root, "members", "member-template", "runtime", "config", "openclaw.json")))) {
+        throw new Error(`not a Velaclaw workspace: ${root}. Run 'velaclaw init <dir>' first.`);
+    }
+    runNodeScript(path.join(PKG_ROOT, "dist", "server.js"), {
+        cwd: root,
+        env: port ? { PORT: port } : undefined
+    });
+}
+async function runVerify(args) {
+    const root = resolveRoot(args);
+    const baseUrl = parseFlag(args, "--base-url");
+    runNodeScript(path.join(PKG_ROOT, "scripts", "verify-install.mjs"), {
+        cwd: root,
+        env: {
+            VELACLAW_ROOT: root,
+            ...(baseUrl ? { VELACLAW_BASE_URL: baseUrl } : {})
+        }
+    });
+}
+async function runSmoke(args) {
+    const mode = args[0];
+    const root = resolveRoot(args);
+    const baseEnv = {
+        VELACLAW_ROOT: root
+    };
+    if (mode === "skills") {
+        runNodeScript(path.join(PKG_ROOT, "scripts", "shared-skill-combo-test.mjs"), { cwd: root, env: baseEnv });
+        return;
+    }
+    if (mode === "assets") {
+        runNodeScript(path.join(PKG_ROOT, "scripts", "shared-asset-stack-test.mjs"), { cwd: root, env: baseEnv });
+        return;
+    }
+    if (mode === "load-test") {
+        runNodeScript(path.join(PKG_ROOT, "scripts", "team-load-test.mjs"), { cwd: root, env: baseEnv });
+        return;
+    }
+    throw new Error(`unsupported smoke target: ${mode || "(missing)"}`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command || command === "--help" || command === "-h") {
+        printUsage();
+        return;
+    }
+    if (command === "version") {
+        const pkg = JSON.parse(await fs.readFile(path.join(PKG_ROOT, "package.json"), "utf8"));
+        console.log(pkg.version || "unknown");
+        return;
+    }
+    if (command === "init") {
+        await runInit(args.slice(1));
+        return;
+    }
+    if (command === "start") {
+        await runStart(args.slice(1));
+        return;
+    }
+    if (command === "verify") {
+        await runVerify(args.slice(1));
+        return;
+    }
+    if (command === "smoke") {
+        await runSmoke(args.slice(1));
+        return;
+    }
+    throw new Error(`unknown command: ${command}`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});