chainlesschain 0.37.6

package/README.md

@@ -0,0 +1,182 @@
+# chainlesschain CLI
+
+Command-line interface for installing, configuring, and managing [ChainlessChain](https://www.chainlesschain.com) — a decentralized personal AI management system with hardware-level security.
+
+## Quick Start
+
+```bash
+npm install -g chainlesschain
+chainlesschain setup
+```
+
+## Requirements
+
+- **Node.js** >= 22.12.0
+- **Docker** (optional, for backend services)
+
+## Commands
+
+### `chainlesschain setup`
+
+Interactive setup wizard. Checks prerequisites, configures LLM provider, downloads the desktop binary, and optionally starts Docker services.
+
+```bash
+chainlesschain setup
+chainlesschain setup --skip-download    # Skip binary download
+chainlesschain setup --skip-services    # Skip Docker setup
+```
+
+### `chainlesschain start`
+
+Launch the ChainlessChain desktop application.
+
+```bash
+chainlesschain start                    # Launch GUI app
+chainlesschain start --headless         # Start backend services only (no GUI)
+chainlesschain start --services         # Also start Docker services
+```
+
+### `chainlesschain stop`
+
+Stop ChainlessChain.
+
+```bash
+chainlesschain stop                     # Stop desktop app
+chainlesschain stop --services          # Stop Docker services only
+chainlesschain stop --all               # Stop app + Docker services
+```
+
+### `chainlesschain status`
+
+Show status of the desktop app, Docker services, and port availability.
+
+```bash
+chainlesschain status
+```
+
+### `chainlesschain services <action>`
+
+Manage Docker backend services (Ollama, Qdrant, PostgreSQL, Redis, etc.).
+
+```bash
+chainlesschain services up              # Start all services
+chainlesschain services up ollama redis  # Start specific services
+chainlesschain services down            # Stop all services
+chainlesschain services logs            # View logs
+chainlesschain services logs -f         # Follow logs
+chainlesschain services pull            # Pull latest images
+```
+
+### `chainlesschain config <action>`
+
+Manage configuration.
+
+```bash
+chainlesschain config list              # Show all config values
+chainlesschain config get llm.provider  # Get a specific value
+chainlesschain config set llm.provider openai
+chainlesschain config set llm.apiKey sk-...
+chainlesschain config edit              # Open in $EDITOR
+chainlesschain config reset             # Reset to defaults
+```
+
+### `chainlesschain update`
+
+Check for and install updates.
+
+```bash
+chainlesschain update                   # Update to latest stable
+chainlesschain update --check           # Check only, don't download
+chainlesschain update --channel beta    # Use beta channel
+chainlesschain update --channel dev     # Use dev channel
+chainlesschain update --force           # Re-download even if exists
+```
+
+### `chainlesschain doctor`
+
+Diagnose your environment.
+
+```bash
+chainlesschain doctor
+```
+
+Checks: Node.js version, npm, Docker, Docker Compose, Git, config directory, binary installation, setup status, port availability, disk space.
+
+## Global Options
+
+```bash
+chainlesschain --version   # Show version
+chainlesschain --help      # Show help
+chainlesschain --verbose   # Enable verbose output
+chainlesschain --quiet     # Suppress non-essential output
+```
+
+## Configuration
+
+Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and manages this file automatically during setup.
+
+### Config Schema
+
+```json
+{
+  "setupCompleted": true,
+  "completedAt": "2026-03-11T00:00:00.000Z",
+  "edition": "personal",
+  "llm": {
+    "provider": "ollama",
+    "apiKey": null,
+    "baseUrl": "http://localhost:11434",
+    "model": "qwen2:7b"
+  },
+  "enterprise": {
+    "serverUrl": null,
+    "apiKey": null,
+    "tenantId": null
+  },
+  "services": {
+    "autoStart": false,
+    "dockerComposePath": null
+  },
+  "update": {
+    "channel": "stable",
+    "autoCheck": true
+  }
+}
+```
+
+### Supported LLM Providers
+
+| Provider            | Default Model | API Key Required |
+| ------------------- | ------------- | ---------------- |
+| Ollama (Local)      | qwen2:7b      | No               |
+| OpenAI              | gpt-4o        | Yes              |
+| DashScope (Alibaba) | qwen-max      | Yes              |
+| DeepSeek            | deepseek-chat | Yes              |
+| Custom              | —             | Yes              |
+
+## File Structure
+
+```
+~/.chainlesschain/
+├── config.json        # Configuration
+├── bin/               # Downloaded binaries
+├── state/             # Runtime state (PID files)
+├── services/          # Service configurations
+├── logs/              # CLI logs
+└── cache/             # Download cache
+```
+
+## Development
+
+```bash
+cd packages/cli
+npm install
+npm test                # Run all tests
+npm run test:unit       # Unit tests only
+npm run test:integration # Integration tests
+npm run test:e2e        # End-to-end tests
+```
+
+## License
+
+MIT

package/bin/chainlesschain.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { createProgram } from "../src/index.js";
+
+const program = createProgram();
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "chainlesschain",
+  "version": "0.37.6",
+  "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
+  "type": "module",
+  "bin": {
+    "chainlesschain": "./bin/chainlesschain.js"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "vitest run",
+    "test:unit": "vitest run __tests__/unit/",
+    "test:integration": "vitest run __tests__/integration/",
+    "test:e2e": "vitest run __tests__/e2e/",
+    "test:watch": "vitest watch",
+    "lint": "eslint src/ bin/ --ext .js",
+    "format": "prettier --write \"src/**/*.js\" \"bin/**/*.js\" \"__tests__/**/*.js\""
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "chainlesschain",
+    "ai",
+    "cli",
+    "electron",
+    "decentralized",
+    "knowledge-base"
+  ],
+  "author": "ChainlessChain Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourname/chainlesschain.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://www.chainlesschain.com",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "@inquirer/prompts": "^7.2.0",
+    "chalk": "^5.4.1",
+    "ora": "^8.1.1",
+    "semver": "^7.6.3"
+  },
+  "devDependencies": {
+    "vitest": "^3.1.1"
+  }
+}

package/src/commands/config.js

@@ -0,0 +1,105 @@
+import chalk from "chalk";
+import {
+  loadConfig,
+  getConfigValue,
+  setConfigValue,
+  resetConfig,
+  saveConfig,
+} from "../lib/config-manager.js";
+import { getConfigPath } from "../lib/paths.js";
+import logger from "../lib/logger.js";
+
+export function registerConfigCommand(program) {
+  const cmd = program
+    .command("config")
+    .description("Manage ChainlessChain configuration");
+
+  cmd
+    .command("list")
+    .description("Show all configuration values")
+    .action(() => {
+      const config = loadConfig();
+      logger.log(chalk.bold(`\n  Config: ${getConfigPath()}\n`));
+      printConfig(config, "  ");
+      logger.newline();
+    });
+
+  cmd
+    .command("get")
+    .description("Get a configuration value")
+    .argument("<key>", "Config key (dot-notation, e.g. llm.provider)")
+    .action((key) => {
+      const value = getConfigValue(key);
+      if (value === undefined) {
+        logger.error(`Key not found: ${key}`);
+        process.exit(1);
+      }
+      if (typeof value === "object") {
+        logger.log(JSON.stringify(value, null, 2));
+      } else {
+        logger.log(String(value));
+      }
+    });
+
+  cmd
+    .command("set")
+    .description("Set a configuration value")
+    .argument("<key>", "Config key (dot-notation)")
+    .argument("<value>", "Value to set")
+    .action((key, value) => {
+      setConfigValue(key, value);
+      logger.success(`Set ${key} = ${value}`);
+    });
+
+  cmd
+    .command("edit")
+    .description("Open config file in default editor")
+    .action(async () => {
+      const configPath = getConfigPath();
+      const editor =
+        process.env.EDITOR ||
+        process.env.VISUAL ||
+        (process.platform === "win32" ? "notepad" : "vi");
+      const { execSync } = await import("node:child_process");
+      try {
+        execSync(`${editor} "${configPath}"`, { stdio: "inherit" });
+      } catch (err) {
+        logger.error(`Failed to open editor: ${err.message}`);
+        logger.info(`Config file is at: ${configPath}`);
+      }
+    });
+
+  cmd
+    .command("reset")
+    .description("Reset configuration to defaults")
+    .action(async () => {
+      const { askConfirm } = await import("../lib/prompts.js");
+      const confirmed = await askConfirm(
+        "Reset all configuration to defaults?",
+        false,
+      );
+      if (confirmed) {
+        resetConfig();
+        logger.success("Configuration reset to defaults");
+      } else {
+        logger.info("Reset cancelled");
+      }
+    });
+}
+
+function printConfig(obj, indent = "") {
+  for (const [key, value] of Object.entries(obj)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      logger.log(`${indent}${chalk.cyan(key)}:`);
+      printConfig(value, indent + "  ");
+    } else {
+      const displayValue =
+        value === null
+          ? chalk.gray("null")
+          : key.toLowerCase().includes("key") && value
+            ? chalk.yellow("****")
+            : String(value);
+      logger.log(`${indent}${chalk.cyan(key)}: ${displayValue}`);
+    }
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,178 @@
+import chalk from "chalk";
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { createConnection } from "node:net";
+import semver from "semver";
+import { MIN_NODE_VERSION, DEFAULT_PORTS, VERSION } from "../constants.js";
+import { getHomeDir, getConfigPath, getBinDir } from "../lib/paths.js";
+import {
+  isDockerAvailable,
+  isDockerComposeAvailable,
+} from "../lib/service-manager.js";
+import { loadConfig } from "../lib/config-manager.js";
+import logger from "../lib/logger.js";
+
+export function registerDoctorCommand(program) {
+  program
+    .command("doctor")
+    .description("Diagnose your ChainlessChain environment")
+    .action(async () => {
+      logger.log(chalk.bold("\n  ChainlessChain Doctor\n"));
+
+      const checks = [];
+
+      // Node.js
+      const nodeVersion = process.versions.node;
+      const nodeOk = semver.gte(nodeVersion, MIN_NODE_VERSION);
+      checks.push({
+        name: `Node.js ${nodeVersion}`,
+        ok: nodeOk,
+        detail: nodeOk ? "" : `Requires >=${MIN_NODE_VERSION}`,
+      });
+
+      // npm
+      try {
+        const npmVersion = execSync("npm --version", {
+          encoding: "utf-8",
+        }).trim();
+        checks.push({ name: `npm ${npmVersion}`, ok: true });
+      } catch {
+        checks.push({ name: "npm", ok: false, detail: "Not found" });
+      }
+
+      // Docker
+      checks.push({
+        name: "Docker",
+        ok: isDockerAvailable(),
+        detail: isDockerAvailable() ? "" : "Not installed (optional)",
+      });
+      checks.push({
+        name: "Docker Compose",
+        ok: isDockerComposeAvailable(),
+        detail: isDockerComposeAvailable() ? "" : "Not installed (optional)",
+      });
+
+      // Git
+      try {
+        const gitVersion = execSync("git --version", {
+          encoding: "utf-8",
+        }).trim();
+        checks.push({ name: gitVersion, ok: true });
+      } catch {
+        checks.push({ name: "Git", ok: false, detail: "Not found" });
+      }
+
+      // Config directory
+      const homeDir = getHomeDir();
+      checks.push({
+        name: `Config dir: ${homeDir}`,
+        ok: existsSync(homeDir),
+        detail: existsSync(homeDir) ? "" : 'Run "chainlesschain setup"',
+      });
+
+      // Config file
+      const configPath = getConfigPath();
+      checks.push({
+        name: "Config file",
+        ok: existsSync(configPath),
+        detail: existsSync(configPath) ? "" : 'Run "chainlesschain setup"',
+      });
+
+      // Binary
+      const binDir = getBinDir();
+      const hasBin = existsSync(binDir) && readdirSafe(binDir).length > 0;
+      checks.push({
+        name: "Desktop binary",
+        ok: hasBin,
+        detail: hasBin
+          ? ""
+          : 'Run "chainlesschain setup" or "chainlesschain update"',
+      });
+
+      // Setup completed
+      const config = loadConfig();
+      checks.push({
+        name: "Setup completed",
+        ok: config.setupCompleted,
+        detail: config.setupCompleted ? "" : 'Run "chainlesschain setup"',
+      });
+
+      // Print results
+      for (const check of checks) {
+        const icon = check.ok ? chalk.green("✔") : chalk.red("✖");
+        const detail = check.detail ? chalk.gray(` (${check.detail})`) : "";
+        logger.log(`  ${icon} ${check.name}${detail}`);
+      }
+
+      // Port scan
+      logger.log(chalk.bold("\n  Port Status\n"));
+      for (const [name, port] of Object.entries(DEFAULT_PORTS)) {
+        const open = await checkPort(port);
+        const icon = open ? chalk.green("●") : chalk.gray("○");
+        logger.log(`  ${icon} ${name}: ${port}`);
+      }
+
+      // Disk space (basic)
+      try {
+        const { statfsSync } = await import("node:fs");
+        // statfsSync available in Node 22+
+        if (statfsSync) {
+          const stats = statfsSync(homeDir);
+          const freeGB = (stats.bavail * stats.bsize) / (1024 * 1024 * 1024);
+          const ok = freeGB > 2;
+          logger.log(chalk.bold("\n  Disk\n"));
+          const icon = ok ? chalk.green("✔") : chalk.yellow("⚠");
+          logger.log(`  ${icon} Free space: ${freeGB.toFixed(1)} GB`);
+        }
+      } catch {
+        // statfsSync not available on all platforms
+      }
+
+      // Summary
+      const failures = checks.filter((c) => !c.ok);
+      logger.newline();
+      if (failures.length === 0) {
+        logger.log(chalk.bold.green("  All checks passed!\n"));
+      } else {
+        const critical = failures.filter(
+          (c) => !c.detail?.includes("optional"),
+        );
+        if (critical.length > 0) {
+          logger.log(
+            chalk.bold.red(
+              `  ${critical.length} issue(s) found. See details above.\n`,
+            ),
+          );
+        } else {
+          logger.log(
+            chalk.bold.yellow(
+              `  ${failures.length} optional component(s) missing.\n`,
+            ),
+          );
+        }
+      }
+    });
+}
+
+function checkPort(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const socket = createConnection({ port, host, timeout: 1000 });
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}

package/src/commands/services.js

@@ -0,0 +1,94 @@
+import {
+  isDockerAvailable,
+  isDockerComposeAvailable,
+  servicesUp,
+  servicesDown,
+  servicesLogs,
+  servicesPull,
+  findComposeFile,
+} from "../lib/service-manager.js";
+import logger from "../lib/logger.js";
+
+export function registerServicesCommand(program) {
+  const cmd = program
+    .command("services")
+    .description("Manage Docker backend services");
+
+  cmd
+    .command("up")
+    .description("Start Docker services")
+    .argument("[services...]", "Specific services to start")
+    .action(async (services) => {
+      await withCompose((composePath) => {
+        logger.info("Starting services...");
+        servicesUp(composePath, {
+          services: services.length ? services : undefined,
+        });
+        logger.success("Services started");
+      });
+    });
+
+  cmd
+    .command("down")
+    .description("Stop Docker services")
+    .action(async () => {
+      await withCompose((composePath) => {
+        logger.info("Stopping services...");
+        servicesDown(composePath);
+        logger.success("Services stopped");
+      });
+    });
+
+  cmd
+    .command("logs")
+    .description("View service logs")
+    .option("-f, --follow", "Follow log output")
+    .option("--tail <lines>", "Number of lines to show", "100")
+    .argument("[services...]", "Specific services")
+    .action(async (services, options) => {
+      await withCompose(async (composePath) => {
+        await servicesLogs(composePath, {
+          follow: options.follow,
+          tail: options.tail,
+          services: services.length ? services : undefined,
+        });
+      });
+    });
+
+  cmd
+    .command("pull")
+    .description("Pull latest service images")
+    .action(async () => {
+      await withCompose((composePath) => {
+        logger.info("Pulling images...");
+        servicesPull(composePath);
+        logger.success("Images updated");
+      });
+    });
+}
+
+async function withCompose(fn) {
+  try {
+    if (!isDockerAvailable()) {
+      logger.error("Docker is not installed or not running");
+      process.exit(1);
+    }
+    if (!isDockerComposeAvailable()) {
+      logger.error("Docker Compose is not available");
+      process.exit(1);
+    }
+
+    const composePath = findComposeFile([process.cwd(), "backend/docker"]);
+    if (!composePath) {
+      logger.error(
+        "docker-compose.yml not found. Run from the project root directory.",
+      );
+      process.exit(1);
+    }
+
+    await fn(composePath);
+  } catch (err) {
+    logger.error(`Service operation failed: ${err.message}`);
+    process.exit(1);
+  }
+}