chainlesschain 0.37.6

package/src/commands/setup.js

@@ -0,0 +1,193 @@
+import chalk from "chalk";
+import ora from "ora";
+import semver from "semver";
+import {
+  MIN_NODE_VERSION,
+  LLM_PROVIDERS,
+  EDITIONS,
+  VERSION,
+} from "../constants.js";
+import { ensureHomeDir, getConfigPath } from "../lib/paths.js";
+import { loadConfig, saveConfig } from "../lib/config-manager.js";
+import {
+  isDockerAvailable,
+  isDockerComposeAvailable,
+  servicesUp,
+  findComposeFile,
+} from "../lib/service-manager.js";
+import { downloadRelease } from "../lib/downloader.js";
+import {
+  askConfirm,
+  askSelect,
+  askInput,
+  askPassword,
+} from "../lib/prompts.js";
+import logger from "../lib/logger.js";
+
+export function registerSetupCommand(program) {
+  program
+    .command("setup")
+    .description("Interactive setup wizard for ChainlessChain")
+    .option("--skip-download", "Skip binary download")
+    .option("--skip-services", "Skip Docker service setup")
+    .action(async (options) => {
+      try {
+        await runSetup(options);
+      } catch (err) {
+        if (err.name === "ExitPromptError") {
+          logger.log("\nSetup cancelled.");
+          process.exit(0);
+        }
+        logger.error(`Setup failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+async function runSetup(options) {
+  logger.log(chalk.bold("\n  ChainlessChain Setup Wizard\n"));
+  logger.log(`  Version: ${VERSION}`);
+  logger.log(`  Config: ${getConfigPath()}\n`);
+
+  // Step 1: Check Node version
+  const nodeVersion = process.versions.node;
+  if (!semver.gte(nodeVersion, MIN_NODE_VERSION)) {
+    logger.error(
+      `Node.js ${MIN_NODE_VERSION}+ required (current: ${nodeVersion})`,
+    );
+    process.exit(1);
+  }
+  logger.success(`Node.js ${nodeVersion}`);
+
+  // Step 2: Check Docker
+  const dockerOk = isDockerAvailable();
+  const composeOk = isDockerComposeAvailable();
+  if (dockerOk) {
+    logger.success("Docker available");
+  } else {
+    logger.warn("Docker not found (optional - needed for backend services)");
+  }
+  if (composeOk) {
+    logger.success("Docker Compose available");
+  }
+
+  // Step 3: Ensure home directory
+  ensureHomeDir();
+  logger.success("Configuration directory ready");
+  logger.newline();
+
+  // Step 4: Select edition
+  const edition = await askSelect("Select edition:", [
+    {
+      name: `${EDITIONS.personal.name} - ${EDITIONS.personal.description}`,
+      value: "personal",
+    },
+    {
+      name: `${EDITIONS.enterprise.name} - ${EDITIONS.enterprise.description}`,
+      value: "enterprise",
+    },
+  ]);
+
+  // Step 5: Configure LLM
+  const providerChoices = Object.entries(LLM_PROVIDERS).map(([key, info]) => ({
+    name: info.name,
+    value: key,
+  }));
+  const provider = await askSelect("Select LLM provider:", providerChoices);
+  const providerInfo = LLM_PROVIDERS[provider];
+
+  let apiKey = null;
+  let baseUrl = providerInfo.defaultBaseUrl;
+  let model = providerInfo.defaultModel;
+
+  if (providerInfo.requiresApiKey) {
+    apiKey = await askPassword(`Enter ${providerInfo.name} API key:`);
+  }
+
+  if (provider === "custom") {
+    baseUrl = await askInput("Enter API base URL:");
+    model = await askInput("Enter model name:");
+  } else {
+    const customizeModel = await askConfirm(
+      `Use default model (${model})?`,
+      true,
+    );
+    if (!customizeModel) {
+      model = await askInput("Enter model name:");
+    }
+  }
+
+  // Step 6: Download binary
+  if (!options.skipDownload) {
+    logger.newline();
+    const doDownload = await askConfirm(
+      "Download ChainlessChain desktop application?",
+      true,
+    );
+    if (doDownload) {
+      try {
+        await downloadRelease(VERSION);
+      } catch (err) {
+        logger.warn(`Download failed: ${err.message}`);
+        logger.info(
+          "You can download manually later with: chainlesschain update",
+        );
+      }
+    }
+  }
+
+  // Step 7: Save config
+  const config = loadConfig();
+  config.setupCompleted = true;
+  config.completedAt = new Date().toISOString();
+  config.edition = edition;
+  config.llm.provider = provider;
+  config.llm.apiKey = apiKey;
+  config.llm.baseUrl = baseUrl;
+  config.llm.model = model;
+  saveConfig(config);
+  logger.success("Configuration saved");
+
+  // Step 8: Docker services
+  if (!options.skipServices && dockerOk && composeOk) {
+    logger.newline();
+    const startServices = await askConfirm(
+      "Start Docker backend services?",
+      false,
+    );
+    if (startServices) {
+      const composePath = findComposeFile([process.cwd(), "backend/docker"]);
+      if (composePath) {
+        const spinner = ora("Starting services...").start();
+        try {
+          servicesUp(composePath);
+          spinner.succeed("Docker services started");
+        } catch (err) {
+          spinner.fail(`Failed to start services: ${err.message}`);
+        }
+      } else {
+        logger.warn(
+          'docker-compose.yml not found. Run from the project root or use "chainlesschain services up".',
+        );
+      }
+    }
+  }
+
+  // Done
+  logger.newline();
+  logger.log(chalk.bold.green("  Setup complete!\n"));
+  logger.log("  Next steps:");
+  logger.log(
+    `    ${chalk.cyan("chainlesschain start")}      Launch the desktop app`,
+  );
+  logger.log(
+    `    ${chalk.cyan("chainlesschain services up")} Start backend services`,
+  );
+  logger.log(
+    `    ${chalk.cyan("chainlesschain status")}     Check system status`,
+  );
+  logger.log(
+    `    ${chalk.cyan("chainlesschain doctor")}     Diagnose environment`,
+  );
+  logger.newline();
+}

package/src/commands/start.js

@@ -0,0 +1,68 @@
+import chalk from "chalk";
+import { startApp, isAppRunning } from "../lib/process-manager.js";
+import {
+  servicesUp,
+  findComposeFile,
+  isDockerAvailable,
+} from "../lib/service-manager.js";
+import { loadConfig } from "../lib/config-manager.js";
+import logger from "../lib/logger.js";
+
+export function registerStartCommand(program) {
+  program
+    .command("start")
+    .description("Launch ChainlessChain desktop application")
+    .option("--headless", "Start backend services only (no GUI)")
+    .option("--services", "Also start Docker services")
+    .action(async (options) => {
+      try {
+        const config = loadConfig();
+
+        if (!config.setupCompleted) {
+          logger.warn('Setup not completed. Run "chainlesschain setup" first.');
+          process.exit(1);
+        }
+
+        if (options.services || options.headless) {
+          if (!isDockerAvailable()) {
+            logger.error(
+              "Docker is required for --headless and --services modes",
+            );
+            process.exit(1);
+          }
+          const composePath = findComposeFile([
+            process.cwd(),
+            "backend/docker",
+          ]);
+          if (composePath) {
+            logger.info("Starting Docker services...");
+            servicesUp(composePath);
+            logger.success("Docker services started");
+          } else {
+            logger.warn("docker-compose.yml not found");
+          }
+        }
+
+        if (!options.headless) {
+          if (isAppRunning()) {
+            logger.info("ChainlessChain is already running");
+            return;
+          }
+
+          logger.info("Starting ChainlessChain...");
+          const pid = startApp({ headless: false });
+
+          if (pid) {
+            logger.success(`ChainlessChain started (PID: ${pid})`);
+          } else {
+            logger.warn("App was already running");
+          }
+        } else {
+          logger.success("Backend services running in headless mode");
+        }
+      } catch (err) {
+        logger.error(`Failed to start: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/status.js

@@ -0,0 +1,105 @@
+import chalk from "chalk";
+import { createConnection } from "node:net";
+import { isAppRunning, getAppPid } from "../lib/process-manager.js";
+import {
+  isDockerAvailable,
+  getServiceStatus,
+  findComposeFile,
+} from "../lib/service-manager.js";
+import { loadConfig } from "../lib/config-manager.js";
+import { DEFAULT_PORTS } from "../constants.js";
+import logger from "../lib/logger.js";
+
+export function registerStatusCommand(program) {
+  program
+    .command("status")
+    .description("Show status of ChainlessChain app and services")
+    .action(async () => {
+      try {
+        const config = loadConfig();
+
+        // App status
+        logger.log(chalk.bold("\n  App Status\n"));
+        if (isAppRunning()) {
+          const pid = getAppPid();
+          logger.log(`  ${chalk.green("●")} Desktop app running (PID: ${pid})`);
+        } else {
+          logger.log(`  ${chalk.gray("○")} Desktop app not running`);
+        }
+
+        // Setup status
+        if (config.setupCompleted) {
+          logger.log(
+            `  ${chalk.green("●")} Setup completed (${config.completedAt || "unknown"})`,
+          );
+          logger.log(`    Edition: ${config.edition}`);
+          logger.log(`    LLM: ${config.llm.provider} (${config.llm.model})`);
+        } else {
+          logger.log(`  ${chalk.yellow("●")} Setup not completed`);
+        }
+
+        // Docker services
+        logger.log(chalk.bold("\n  Docker Services\n"));
+        if (isDockerAvailable()) {
+          const composePath = findComposeFile([
+            process.cwd(),
+            "backend/docker",
+          ]);
+          if (composePath) {
+            const status = getServiceStatus(composePath);
+            if (status && Array.isArray(status)) {
+              for (const svc of status) {
+                const running = svc.State === "running";
+                const icon = running ? chalk.green("●") : chalk.red("●");
+                logger.log(
+                  `  ${icon} ${svc.Service || svc.Name}: ${svc.State}`,
+                );
+              }
+            } else if (status) {
+              logger.log(`  ${status}`);
+            } else {
+              logger.log(`  ${chalk.gray("○")} No services running`);
+            }
+          } else {
+            logger.log(`  ${chalk.gray("○")} docker-compose.yml not found`);
+          }
+        } else {
+          logger.log(`  ${chalk.gray("○")} Docker not available`);
+        }
+
+        // Port checks
+        logger.log(chalk.bold("\n  Ports\n"));
+        const portChecks = Object.entries(DEFAULT_PORTS).map(
+          async ([name, port]) => {
+            const open = await checkPort(port);
+            const icon = open ? chalk.green("●") : chalk.gray("○");
+            return `  ${icon} ${name}: ${port}`;
+          },
+        );
+        const results = await Promise.all(portChecks);
+        for (const line of results) {
+          logger.log(line);
+        }
+
+        logger.newline();
+      } catch (err) {
+        logger.error(`Status check failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+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);
+    });
+  });
+}

package/src/commands/stop.js

@@ -0,0 +1,49 @@
+import { stopApp, isAppRunning } from "../lib/process-manager.js";
+import {
+  servicesDown,
+  findComposeFile,
+  isDockerAvailable,
+} from "../lib/service-manager.js";
+import logger from "../lib/logger.js";
+
+export function registerStopCommand(program) {
+  program
+    .command("stop")
+    .description("Stop ChainlessChain")
+    .option("--services", "Stop Docker services only")
+    .option("--all", "Stop both app and Docker services")
+    .action(async (options) => {
+      try {
+        if (options.services || options.all) {
+          if (isDockerAvailable()) {
+            const composePath = findComposeFile([
+              process.cwd(),
+              "backend/docker",
+            ]);
+            if (composePath) {
+              logger.info("Stopping Docker services...");
+              servicesDown(composePath);
+              logger.success("Docker services stopped");
+            } else {
+              logger.warn("docker-compose.yml not found");
+            }
+          } else {
+            logger.warn("Docker not available");
+          }
+        }
+
+        if (!options.services) {
+          if (isAppRunning()) {
+            logger.info("Stopping ChainlessChain...");
+            stopApp();
+            logger.success("ChainlessChain stopped");
+          } else {
+            logger.info("ChainlessChain is not running");
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed to stop: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/update.js

@@ -0,0 +1,78 @@
+import chalk from "chalk";
+import { checkForUpdates } from "../lib/version-checker.js";
+import { downloadRelease } from "../lib/downloader.js";
+import { VERSION } from "../constants.js";
+import { askConfirm } from "../lib/prompts.js";
+import logger from "../lib/logger.js";
+
+export function registerUpdateCommand(program) {
+  program
+    .command("update")
+    .description("Check for and install updates")
+    .option("--check", "Only check for updates (do not download)")
+    .option(
+      "--channel <channel>",
+      "Release channel: stable, beta, dev",
+      "stable",
+    )
+    .option("--force", "Re-download even if binary exists")
+    .action(async (options) => {
+      try {
+        logger.info(`Current version: ${VERSION}`);
+        logger.info(`Channel: ${options.channel}`);
+        logger.newline();
+
+        const result = await checkForUpdates({ channel: options.channel });
+
+        if (result.error) {
+          logger.warn(`Update check failed: ${result.error}`);
+          return;
+        }
+
+        if (!result.updateAvailable) {
+          logger.success("You are on the latest version");
+          return;
+        }
+
+        logger.log(
+          chalk.bold(
+            `\n  Update available: ${result.currentVersion} → ${chalk.green(result.latestVersion)}\n`,
+          ),
+        );
+
+        if (result.publishedAt) {
+          logger.log(
+            `  Published: ${new Date(result.publishedAt).toLocaleDateString()}`,
+          );
+        }
+        if (result.releaseUrl) {
+          logger.log(`  Release: ${result.releaseUrl}`);
+        }
+        logger.newline();
+
+        if (options.check) {
+          return;
+        }
+
+        const doUpdate = await askConfirm(
+          `Download v${result.latestVersion}?`,
+          true,
+        );
+        if (!doUpdate) {
+          logger.info("Update cancelled");
+          return;
+        }
+
+        await downloadRelease(result.latestVersion, { force: options.force });
+        logger.success(`Updated to v${result.latestVersion}`);
+        logger.info("Restart ChainlessChain to use the new version.");
+      } catch (err) {
+        if (err.name === "ExitPromptError") {
+          logger.log("\nUpdate cancelled.");
+          process.exit(0);
+        }
+        logger.error(`Update failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/constants.js

@@ -0,0 +1,112 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+const pkg = require(join(__dirname, "..", "package.json"));
+
+export const VERSION = pkg.version;
+
+export const GITHUB_OWNER = "yourname";
+export const GITHUB_REPO = "chainlesschain";
+export const GITHUB_API_BASE = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}`;
+export const GITHUB_RELEASES_URL = `${GITHUB_API_BASE}/releases`;
+
+export const DEFAULT_PORTS = {
+  vite: 5173,
+  signaling: 9001,
+  ollama: 11434,
+  qdrant: 6333,
+  postgresql: 5432,
+  redis: 6379,
+  projectService: 9090,
+  aiService: 8001,
+};
+
+export const LLM_PROVIDERS = {
+  ollama: {
+    name: "Ollama (Local)",
+    defaultBaseUrl: "http://localhost:11434",
+    defaultModel: "qwen2:7b",
+    requiresApiKey: false,
+  },
+  openai: {
+    name: "OpenAI",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o",
+    requiresApiKey: true,
+  },
+  dashscope: {
+    name: "DashScope (Alibaba)",
+    defaultBaseUrl: "https://dashscope.aliyuncs.com/api/v1",
+    defaultModel: "qwen-max",
+    requiresApiKey: true,
+  },
+  deepseek: {
+    name: "DeepSeek",
+    defaultBaseUrl: "https://api.deepseek.com/v1",
+    defaultModel: "deepseek-chat",
+    requiresApiKey: true,
+  },
+  custom: {
+    name: "Custom Provider",
+    defaultBaseUrl: "",
+    defaultModel: "",
+    requiresApiKey: true,
+  },
+};
+
+export const EDITIONS = {
+  personal: {
+    name: "Personal",
+    description: "For individual use with local AI and privacy-first design",
+  },
+  enterprise: {
+    name: "Enterprise",
+    description: "For teams with SSO, RBAC, audit logging, and org management",
+  },
+};
+
+export const BINARY_NAMES = {
+  win32: { x64: "chainlesschain-desktop-vue-{version}-win-x64.exe" },
+  darwin: {
+    x64: "chainlesschain-desktop-vue-{version}-mac-x64.dmg",
+    arm64: "chainlesschain-desktop-vue-{version}-mac-arm64.dmg",
+  },
+  linux: { x64: "chainlesschain-desktop-vue-{version}-linux-x64.deb" },
+};
+
+export const CONFIG_DIR_NAME = ".chainlesschain";
+
+export const DEFAULT_CONFIG = {
+  setupCompleted: false,
+  completedAt: null,
+  edition: "personal",
+  paths: {
+    projectRoot: null,
+    database: null,
+  },
+  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,
+  },
+};
+
+export const MIN_NODE_VERSION = "22.12.0";

package/src/index.js

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import { VERSION } from "./constants.js";
+import { registerSetupCommand } from "./commands/setup.js";
+import { registerStartCommand } from "./commands/start.js";
+import { registerStopCommand } from "./commands/stop.js";
+import { registerStatusCommand } from "./commands/status.js";
+import { registerServicesCommand } from "./commands/services.js";
+import { registerConfigCommand } from "./commands/config.js";
+import { registerUpdateCommand } from "./commands/update.js";
+import { registerDoctorCommand } from "./commands/doctor.js";
+
+export function createProgram() {
+  const program = new Command();
+
+  program
+    .name("chainlesschain")
+    .description(
+      "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
+    )
+    .version(VERSION, "-v, --version")
+    .option("--verbose", "Enable verbose output")
+    .option("--quiet", "Suppress non-essential output");
+
+  registerSetupCommand(program);
+  registerStartCommand(program);
+  registerStopCommand(program);
+  registerStatusCommand(program);
+  registerServicesCommand(program);
+  registerConfigCommand(program);
+  registerUpdateCommand(program);
+  registerDoctorCommand(program);
+
+  return program;
+}

package/src/lib/checksum.js

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+
+export function computeSha256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+export function verifySha256(filePath, expectedHash) {
+  return computeSha256(filePath).then((actual) => ({
+    valid: actual === expectedHash.toLowerCase(),
+    actual,
+    expected: expectedHash.toLowerCase(),
+  }));
+}