@chvor/cli 0.1.0

package/bin/chvor.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+await import('../dist/cli.js');

package/dist/cli.js

@@ -0,0 +1,226 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8"));
+const program = new Command()
+    .name("chvor")
+    .description("Your own AI — install and run chvor.")
+    .version(pkg.version);
+program
+    .action(async () => {
+    const { isOnboarded } = await import("./lib/config.js");
+    if (!isOnboarded()) {
+        const { onboard } = await import("./commands/onboard.js");
+        await onboard();
+    }
+    else {
+        const { start } = await import("./commands/start.js");
+        await start({});
+    }
+});
+program
+    .command("start")
+    .description("Start the chvor server")
+    .option("-p, --port <port>", "Server port")
+    .option("--foreground", "Run in foreground (no detach)")
+    .option("-i, --instance <name>", "Named instance to start")
+    .action(async (opts) => {
+    if (opts.instance) {
+        const { setInstance } = await import("./lib/paths.js");
+        setInstance(opts.instance);
+    }
+    if (opts.port) {
+        const { validatePort } = await import("./lib/validate.js");
+        validatePort(opts.port);
+    }
+    const { start } = await import("./commands/start.js");
+    await start(opts);
+});
+program
+    .command("stop")
+    .description("Stop the running chvor server")
+    .option("-i, --instance <name>", "Named instance to stop")
+    .action(async (opts) => {
+    if (opts.instance) {
+        const { setInstance } = await import("./lib/paths.js");
+        setInstance(opts.instance);
+    }
+    const { stop } = await import("./commands/stop.js");
+    await stop();
+});
+program
+    .command("init")
+    .description("Set up a new agent from a template")
+    .option("-t, --template <name>", "Template name or ID")
+    .option("-n, --name <instance>", "Instance name for multi-instance support")
+    .option("--from <path>", "Local template directory path")
+    .action(async (opts) => {
+    const { init } = await import("./commands/init.js");
+    await init(opts);
+});
+const instancesCmd = program
+    .command("instances")
+    .description("Manage chvor instances");
+instancesCmd
+    .action(async () => {
+    const { listInstances } = await import("./commands/instances.js");
+    await listInstances();
+});
+instancesCmd
+    .command("start <name>")
+    .description("Start a named instance")
+    .action(async (name) => {
+    const { startInstance } = await import("./commands/instances.js");
+    await startInstance(name);
+});
+instancesCmd
+    .command("stop <name>")
+    .description("Stop a named instance")
+    .action(async (name) => {
+    const { stopInstance } = await import("./commands/instances.js");
+    await stopInstance(name);
+});
+program
+    .command("onboard")
+    .description("Interactive first-time setup wizard")
+    .action(async () => {
+    const { onboard } = await import("./commands/onboard.js");
+    await onboard();
+});
+program
+    .command("update")
+    .description("Update to the latest chvor release")
+    .action(async () => {
+    const { update } = await import("./commands/update.js");
+    await update();
+});
+program
+    .command("docker")
+    .description("Pull and run chvor as a Docker container")
+    .option("-p, --port <port>", "Host port", "3001")
+    .action(async (opts) => {
+    const { docker } = await import("./commands/docker.js");
+    await docker(opts);
+});
+const skillCmd = program
+    .command("skill")
+    .description("Manage skills from the community registry");
+skillCmd
+    .command("search <query>")
+    .description("Search the skill registry")
+    .action(async (query) => {
+    const { skillSearch } = await import("./commands/skill.js");
+    await skillSearch(query);
+});
+skillCmd
+    .command("install <name>")
+    .description("Install a skill from the registry")
+    .action(async (name) => {
+    const { skillInstall } = await import("./commands/skill.js");
+    await skillInstall(name);
+});
+skillCmd
+    .command("uninstall <name>")
+    .description("Uninstall a registry skill")
+    .action(async (name) => {
+    const { skillUninstall } = await import("./commands/skill.js");
+    await skillUninstall(name);
+});
+skillCmd
+    .command("update [name]")
+    .description("Update one or all registry skills")
+    .action(async (name) => {
+    const { skillUpdate } = await import("./commands/skill.js");
+    await skillUpdate(name);
+});
+skillCmd
+    .command("list")
+    .description("List all installed skills")
+    .action(async () => {
+    const { skillList } = await import("./commands/skill.js");
+    await skillList();
+});
+skillCmd
+    .command("info <name>")
+    .description("Show details for a registry skill")
+    .action(async (name) => {
+    const { skillInfo } = await import("./commands/skill.js");
+    await skillInfo(name);
+});
+skillCmd
+    .command("publish <path>")
+    .description("Validate a skill file for publishing")
+    .action(async (path) => {
+    const { skillPublish } = await import("./commands/skill.js");
+    await skillPublish(path);
+});
+const toolCmd = program
+    .command("tool")
+    .description("Manage tools from the community registry");
+toolCmd
+    .command("search <query>")
+    .description("Search the tool registry")
+    .action(async (query) => {
+    const { toolSearch } = await import("./commands/skill.js");
+    await toolSearch(query);
+});
+toolCmd
+    .command("install <name>")
+    .description("Install a tool from the registry")
+    .action(async (name) => {
+    const { toolInstall } = await import("./commands/skill.js");
+    await toolInstall(name);
+});
+toolCmd
+    .command("uninstall <name>")
+    .description("Uninstall a registry tool")
+    .action(async (name) => {
+    const { toolUninstall } = await import("./commands/skill.js");
+    await toolUninstall(name);
+});
+toolCmd
+    .command("update [name]")
+    .description("Update one or all registry tools")
+    .action(async (name) => {
+    const { toolUpdate } = await import("./commands/skill.js");
+    await toolUpdate(name);
+});
+toolCmd
+    .command("list")
+    .description("List all installed tools")
+    .action(async () => {
+    const { toolList } = await import("./commands/skill.js");
+    await toolList();
+});
+toolCmd
+    .command("info <name>")
+    .description("Show details for a registry tool")
+    .action(async (name) => {
+    const { toolInfo } = await import("./commands/skill.js");
+    await toolInfo(name);
+});
+toolCmd
+    .command("publish <path>")
+    .description("Validate and publish a tool file")
+    .action(async (path) => {
+    const { toolPublish } = await import("./commands/skill.js");
+    await toolPublish(path);
+});
+const authCmd = program
+    .command("auth")
+    .description("Manage authentication");
+authCmd
+    .command("reset")
+    .description("Reset authentication credentials (requires access to data directory)")
+    .option("-i, --instance <name>", "Named instance to reset")
+    .action(async (opts) => {
+    if (opts.instance) {
+        const { setInstance } = await import("./lib/paths.js");
+        setInstance(opts.instance);
+    }
+    const { authReset } = await import("./commands/auth.js");
+    await authReset();
+});
+await program.parseAsync(process.argv);

package/dist/commands/auth.js

@@ -0,0 +1,50 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { confirm } from "@inquirer/prompts";
+import { getDataDir } from "../lib/paths.js";
+export async function authReset() {
+    const dataDir = getDataDir();
+    const dbPath = join(dataDir, "chvor.db");
+    if (!existsSync(dbPath)) {
+        console.error("No database found at", dbPath);
+        console.error("Nothing to reset.");
+        process.exit(1);
+    }
+    const confirmed = await confirm({
+        message: "This will remove all authentication data (login credentials, sessions, API keys).\nYou will need to set up new credentials on next login.\n\nContinue?",
+        default: false,
+    });
+    if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+    }
+    // Dynamic import — better-sqlite3 is an optional peer dep for the CLI
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let Database;
+    try {
+        const mod = await import("better-sqlite3");
+        Database = mod.default;
+    }
+    catch {
+        console.error("better-sqlite3 is not installed. Install it to use auth reset:\n  npm install better-sqlite3");
+        process.exit(1);
+    }
+    const db = new Database(dbPath);
+    try {
+        // Check if auth tables exist
+        const hasAuthConfig = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='auth_config'")
+            .get();
+        if (!hasAuthConfig) {
+            console.log("Auth tables not found — nothing to reset.");
+            return;
+        }
+        db.exec("DELETE FROM auth_config");
+        db.exec("DELETE FROM auth_sessions");
+        db.exec("DELETE FROM api_keys");
+        console.log("\nAuthentication reset successfully.\nYou will be prompted to set up new credentials on next login.");
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/commands/docker.js

@@ -0,0 +1,17 @@
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { validatePort } from "../lib/validate.js";
+export async function docker(opts) {
+    const port = validatePort(opts.port ?? "3001");
+    const image = "ghcr.io/luka-zivkovic/chvor:latest";
+    console.log("Pulling latest chvor Docker image...");
+    execFileSync("docker", ["pull", image], { stdio: "inherit" });
+    console.log("Starting chvor container...");
+    execFileSync("docker", [
+        "run", "-d", "--name", "chvor",
+        "-p", `${port}:3001`,
+        "-v", `${homedir()}/.chvor:/home/node/.chvor`,
+        image,
+    ], { stdio: "inherit" });
+    console.log(`chvor is running at http://localhost:${port}`);
+}

package/dist/commands/init.js

@@ -0,0 +1,221 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { input, select, password, confirm } from "@inquirer/prompts";
+import { writeConfig } from "../lib/config.js";
+import { validatePort } from "../lib/validate.js";
+import { getChvorHome, getDataDir, setInstance, ensureDir, } from "../lib/paths.js";
+import { downloadRelease, isInstalled } from "../lib/download.js";
+import { spawnServer, pollHealth } from "../lib/process.js";
+import { resolveTemplate, resolveRegistryTemplate, listBundledTemplates, } from "../lib/template-loader.js";
+import { provision } from "../lib/template-provisioner.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf8"));
+async function pickTemplate() {
+    const bundled = listBundledTemplates();
+    if (bundled.length === 0) {
+        throw new Error("No bundled templates found. Use --template <path> or --from <path> to specify a template directory.");
+    }
+    const choice = await select({
+        message: "Choose a template:",
+        choices: bundled.map((t) => ({
+            name: `${t.name} — ${t.description}`,
+            value: t.id,
+        })),
+    });
+    return resolveTemplate(choice);
+}
+async function collectCredentials(credentialDefs, port, token) {
+    if (!credentialDefs.length)
+        return;
+    console.log("\n  This template requires the following credentials:\n");
+    for (const cred of credentialDefs) {
+        console.log(`  ${cred.name}: ${cred.description}`);
+        const data = {};
+        for (const field of cred.fields) {
+            if (field.secret) {
+                data[field.name] = await password({ message: `  ${field.label}:` });
+            }
+            else {
+                data[field.name] = await input({ message: `  ${field.label}:` });
+            }
+        }
+        const res = await fetch(`http://localhost:${port}/api/credentials`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                name: cred.name,
+                type: cred.type,
+                data,
+            }),
+        });
+        if (!res.ok) {
+            console.warn(`  Warning: failed to save ${cred.name} credential (${res.status}).`);
+        }
+        else {
+            console.log(`  ${cred.name} credential saved.`);
+        }
+    }
+}
+export async function init(opts) {
+    console.log("\n  chvor init — set up a new agent from a template.\n");
+    // 1. Resolve template
+    let templatePath;
+    let manifest;
+    let isRegistryTemplate = false;
+    const source = opts.from || opts.template;
+    if (source?.startsWith("registry:")) {
+        const id = source.slice("registry:".length);
+        console.log(`  Fetching template "${id}" from registry...`);
+        const result = await resolveRegistryTemplate(id);
+        templatePath = result.path;
+        manifest = result.manifest;
+        isRegistryTemplate = true;
+    }
+    else if (source) {
+        const result = resolveTemplate(source);
+        templatePath = result.path;
+        manifest = result.manifest;
+    }
+    else {
+        const result = await pickTemplate();
+        templatePath = result.path;
+        manifest = result.manifest;
+    }
+    console.log(`  Template: ${manifest.name} (v${manifest.version})`);
+    if (manifest.description) {
+        console.log(`  ${manifest.description}\n`);
+    }
+    // 2. Instance name
+    const instanceName = opts.name ?? await input({
+        message: "Instance name (leave blank for default):",
+        default: "",
+    });
+    if (instanceName) {
+        // Validate instance name: alphanumeric, hyphens, underscores
+        if (!/^[a-zA-Z0-9_-]+$/.test(instanceName)) {
+            throw new Error("Instance name must contain only letters, numbers, hyphens, and underscores.");
+        }
+        setInstance(instanceName);
+    }
+    const home = getChvorHome();
+    if (existsSync(join(home, "config.json"))) {
+        const overwrite = await confirm({
+            message: `Instance directory ${home} already exists. Overwrite?`,
+            default: false,
+        });
+        if (!overwrite) {
+            console.log("  Aborted.");
+            return;
+        }
+    }
+    // 3. Basic onboarding prompts
+    const userName = await input({ message: "What's your name?" });
+    const detectedTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timezone = await input({
+        message: "Your timezone?",
+        default: detectedTimezone,
+    });
+    const provider = await select({
+        message: "LLM provider?",
+        choices: [
+            { name: "Anthropic (Claude)", value: "anthropic" },
+            { name: "OpenAI (GPT)", value: "openai" },
+            { name: "Google (Gemini)", value: "google-ai" },
+        ],
+    });
+    const apiKey = await password({ message: "API key:" });
+    const defaultPort = instanceName ? "3002" : "3001";
+    const port = validatePort(await input({ message: "Port?", default: defaultPort }));
+    const token = randomBytes(32).toString("hex");
+    // 4. Write config
+    writeConfig({
+        port,
+        token,
+        onboarded: true,
+        llmProvider: provider,
+        instanceName: instanceName || undefined,
+        templateName: manifest.name,
+    });
+    ensureDir(getDataDir());
+    // 5. Download release if needed
+    const version = pkg.version;
+    if (!isInstalled(version)) {
+        await downloadRelease(version);
+    }
+    // 6. Start server
+    await spawnServer({ port });
+    const healthy = await pollHealth(port, token);
+    if (!healthy) {
+        console.warn("  Server started but health check did not pass within timeout.");
+        return;
+    }
+    // 7. Save LLM provider credential
+    const providerNames = {
+        anthropic: "Anthropic",
+        openai: "OpenAI",
+        "google-ai": "Google AI",
+    };
+    await fetch(`http://localhost:${port}/api/credentials`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            name: providerNames[provider],
+            type: provider,
+            data: { apiKey },
+        }),
+    });
+    // 8. Save persona (user name + timezone + template persona)
+    await fetch(`http://localhost:${port}/api/persona`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            name: userName,
+            timezone,
+            onboarded: true,
+        }),
+    });
+    // 9. Collect template-specific credentials
+    const templateCredentials = (manifest.credentials ?? []).filter((c) => c.type !== provider // Skip if already collected as LLM provider
+    );
+    await collectCredentials(templateCredentials, port, token);
+    // 10. Provision template
+    await provision({
+        port,
+        token,
+        templatePath,
+        manifest,
+    });
+    // Clean up temp directory from registry template
+    if (isRegistryTemplate) {
+        try {
+            rmSync(templatePath, { recursive: true, force: true });
+        }
+        catch { /* non-critical */ }
+    }
+    // 11. Done
+    const label = instanceName ? ` (instance: ${instanceName})` : "";
+    console.log(`\n  chvor is running at http://localhost:${port}${label}`);
+    console.log("  Open this URL in your browser to get started.\n");
+    console.log("  Useful commands:");
+    if (instanceName) {
+        console.log(`    chvor stop --instance ${instanceName}     Stop this instance`);
+        console.log(`    chvor start --instance ${instanceName}    Start this instance`);
+        console.log("    chvor instances                          List all instances");
+    }
+    else {
+        console.log("    chvor stop     Stop the server");
+        console.log("    chvor start    Start the server");
+    }
+    console.log("    chvor update   Update to latest version\n");
+}

package/dist/commands/instances.js

@@ -0,0 +1,126 @@
+import { readdirSync, existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { setInstance } from "../lib/paths.js";
+import { readConfig } from "../lib/config.js";
+import { stopServer } from "../lib/process.js";
+function discoverInstances() {
+    const home = homedir();
+    const instances = [];
+    // Check default instance
+    const defaultConfig = join(home, ".chvor", "config.json");
+    if (existsSync(defaultConfig)) {
+        try {
+            const config = JSON.parse(readFileSync(defaultConfig, "utf-8"));
+            // Check if running
+            const pidPath = join(home, ".chvor", "chvor.pid");
+            let running = false;
+            let pid;
+            if (existsSync(pidPath)) {
+                const rawPid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+                if (!isNaN(rawPid)) {
+                    try {
+                        process.kill(rawPid, 0);
+                        running = true;
+                        pid = rawPid;
+                    }
+                    catch {
+                        // not running
+                    }
+                }
+            }
+            instances.push({
+                name: "(default)",
+                port: config.port || "3001",
+                running,
+                pid,
+                template: config.templateName,
+            });
+        }
+        catch (err) {
+            console.warn(`  Warning: could not read default instance config: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    // Scan for named instances (~/.chvor-*/config.json)
+    const entries = readdirSync(home, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const match = entry.name.match(/^\.chvor-(.+)$/);
+        if (!match)
+            continue;
+        const instanceName = match[1];
+        const configPath = join(home, entry.name, "config.json");
+        if (!existsSync(configPath))
+            continue;
+        try {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            const pidPath = join(home, entry.name, "chvor.pid");
+            let running = false;
+            let pid;
+            if (existsSync(pidPath)) {
+                const rawPid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+                if (!isNaN(rawPid)) {
+                    try {
+                        process.kill(rawPid, 0);
+                        running = true;
+                        pid = rawPid;
+                    }
+                    catch {
+                        // not running
+                    }
+                }
+            }
+            instances.push({
+                name: instanceName,
+                port: config.port || "?",
+                running,
+                pid,
+                template: config.templateName,
+            });
+        }
+        catch (err) {
+            console.warn(`  Warning: could not read instance "${instanceName}" config: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    return instances;
+}
+export async function listInstances() {
+    const instances = discoverInstances();
+    if (instances.length === 0) {
+        console.log("  No chvor instances found. Run 'chvor init' to create one.");
+        return;
+    }
+    console.log("\n  Chvor instances:\n");
+    console.log("  " +
+        "NAME".padEnd(20) +
+        "PORT".padEnd(8) +
+        "STATUS".padEnd(12) +
+        "TEMPLATE");
+    console.log("  " + "-".repeat(60));
+    for (const inst of instances) {
+        const status = inst.running
+            ? `running (${inst.pid})`
+            : "stopped";
+        console.log("  " +
+            inst.name.padEnd(20) +
+            inst.port.padEnd(8) +
+            status.padEnd(12) +
+            (inst.template || "-"));
+    }
+    console.log();
+}
+export async function startInstance(name) {
+    setInstance(name);
+    const config = readConfig();
+    if (!config.onboarded) {
+        console.log(`Instance "${name}" has not been set up. Run 'chvor init --name ${name}' first.`);
+        return;
+    }
+    const { start } = await import("./start.js");
+    await start({});
+}
+export async function stopInstance(name) {
+    setInstance(name);
+    await stopServer();
+}