chainlesschain 0.37.6

package/src/lib/config-manager.js

@@ -0,0 +1,94 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { getConfigPath } from "./paths.js";
+import { DEFAULT_CONFIG } from "../constants.js";
+
+export function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return { ...structuredClone(DEFAULT_CONFIG) };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
+  } catch {
+    return { ...structuredClone(DEFAULT_CONFIG) };
+  }
+}
+
+export function saveConfig(config) {
+  const configPath = getConfigPath();
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+export function getConfigValue(key) {
+  const config = loadConfig();
+  return getNestedValue(config, key);
+}
+
+export function setConfigValue(key, value) {
+  const config = loadConfig();
+  setNestedValue(config, key, parseValue(value));
+  saveConfig(config);
+  return config;
+}
+
+export function resetConfig() {
+  const config = structuredClone(DEFAULT_CONFIG);
+  saveConfig(config);
+  return config;
+}
+
+export function listConfig() {
+  return loadConfig();
+}
+
+function getNestedValue(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+function setNestedValue(obj, key, value) {
+  const parts = key.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] == null || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+function parseValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  const num = Number(value);
+  if (!isNaN(num) && value.trim() !== "") return num;
+  return value;
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] &&
+      typeof source[key] === "object" &&
+      !Array.isArray(source[key]) &&
+      target[key] &&
+      typeof target[key] === "object" &&
+      !Array.isArray(target[key])
+    ) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}

package/src/lib/downloader.js

@@ -0,0 +1,122 @@
+import { createWriteStream, existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import ora from "ora";
+import { GITHUB_RELEASES_URL } from "../constants.js";
+import { getBinDir, ensureDir } from "./paths.js";
+import { getBinaryName } from "./platform.js";
+import { verifySha256 } from "./checksum.js";
+import logger from "./logger.js";
+
+export async function downloadRelease(version, options = {}) {
+  const binaryName = getBinaryName(version);
+  const binDir = ensureDir(getBinDir());
+  const destPath = join(binDir, binaryName);
+
+  if (existsSync(destPath) && !options.force) {
+    logger.info(`Binary already exists: ${binaryName}`);
+    return destPath;
+  }
+
+  const releaseUrl =
+    options.url || (await resolveAssetUrl(version, binaryName));
+  const spinner = ora(`Downloading ${binaryName}...`).start();
+
+  try {
+    const response = await fetch(releaseUrl, {
+      headers: { Accept: "application/octet-stream" },
+      redirect: "follow",
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Download failed: HTTP ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const totalBytes = parseInt(
+      response.headers.get("content-length") || "0",
+      10,
+    );
+    let downloadedBytes = 0;
+
+    const reader = response.body.getReader();
+    const stream = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        downloadedBytes += value.byteLength;
+        if (totalBytes > 0) {
+          const pct = ((downloadedBytes / totalBytes) * 100).toFixed(1);
+          spinner.text = `Downloading ${binaryName}... ${pct}% (${formatBytes(downloadedBytes)}/${formatBytes(totalBytes)})`;
+        }
+        controller.enqueue(value);
+      },
+    });
+
+    const nodeStream = Readable.fromWeb(stream);
+    await pipeline(nodeStream, createWriteStream(destPath));
+
+    spinner.succeed(
+      `Downloaded ${binaryName} (${formatBytes(downloadedBytes)})`,
+    );
+
+    if (options.checksum) {
+      const verifySpinner = ora("Verifying checksum...").start();
+      const result = await verifySha256(destPath, options.checksum);
+      if (!result.valid) {
+        unlinkSync(destPath);
+        verifySpinner.fail("Checksum verification failed");
+        throw new Error(
+          `SHA256 mismatch: expected ${result.expected}, got ${result.actual}`,
+        );
+      }
+      verifySpinner.succeed("Checksum verified");
+    }
+
+    return destPath;
+  } catch (err) {
+    spinner.fail(`Download failed: ${err.message}`);
+    if (existsSync(destPath)) {
+      unlinkSync(destPath);
+    }
+    throw err;
+  }
+}
+
+async function resolveAssetUrl(version, binaryName) {
+  const tagName = `v${version}`;
+  const url = `${GITHUB_RELEASES_URL}/tags/${tagName}`;
+
+  const response = await fetch(url, {
+    headers: { Accept: "application/vnd.github.v3+json" },
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to find release ${tagName}: HTTP ${response.status}`,
+    );
+  }
+
+  const release = await response.json();
+  const asset = release.assets.find((a) => a.name === binaryName);
+  if (!asset) {
+    throw new Error(`Asset ${binaryName} not found in release ${tagName}`);
+  }
+
+  return asset.browser_download_url;
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024)
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+
+export { resolveAssetUrl, formatBytes };

package/src/lib/logger.js

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+
+let verboseEnabled = false;
+let quietEnabled = false;
+
+export function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+
+export function setQuiet(enabled) {
+  quietEnabled = enabled;
+}
+
+export function info(message, ...args) {
+  if (!quietEnabled) {
+    console.log(chalk.blue("ℹ"), message, ...args);
+  }
+}
+
+export function success(message, ...args) {
+  if (!quietEnabled) {
+    console.log(chalk.green("✔"), message, ...args);
+  }
+}
+
+export function warn(message, ...args) {
+  console.log(chalk.yellow("⚠"), message, ...args);
+}
+
+export function error(message, ...args) {
+  console.error(chalk.red("✖"), message, ...args);
+}
+
+export function verbose(message, ...args) {
+  if (verboseEnabled) {
+    console.log(chalk.gray("⋯"), message, ...args);
+  }
+}
+
+export function log(message, ...args) {
+  if (!quietEnabled) {
+    console.log(message, ...args);
+  }
+}
+
+export function newline() {
+  if (!quietEnabled) {
+    console.log();
+  }
+}
+
+export const logger = {
+  info,
+  success,
+  warn,
+  error,
+  verbose,
+  log,
+  newline,
+  setVerbose,
+  setQuiet,
+};
+export default logger;

package/src/lib/paths.js

@@ -0,0 +1,80 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, existsSync } from "node:fs";
+import { CONFIG_DIR_NAME } from "../constants.js";
+import { getPlatform } from "./platform.js";
+
+export function getHomeDir() {
+  return join(homedir(), CONFIG_DIR_NAME);
+}
+
+export function getBinDir() {
+  return join(getHomeDir(), "bin");
+}
+
+export function getConfigPath() {
+  return join(getHomeDir(), "config.json");
+}
+
+export function getStatePath() {
+  return join(getHomeDir(), "state");
+}
+
+export function getPidFilePath() {
+  return join(getStatePath(), "app.pid");
+}
+
+export function getServicesDir() {
+  return join(getHomeDir(), "services");
+}
+
+export function getLogsDir() {
+  return join(getHomeDir(), "logs");
+}
+
+export function getCacheDir() {
+  return join(getHomeDir(), "cache");
+}
+
+export function getElectronUserDataDir() {
+  const p = getPlatform();
+  const appName = "chainlesschain-desktop-vue";
+  switch (p) {
+    case "win32":
+      return join(
+        process.env.APPDATA || join(homedir(), "AppData", "Roaming"),
+        appName,
+      );
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", appName);
+    case "linux":
+      return join(
+        process.env.XDG_CONFIG_HOME || join(homedir(), ".config"),
+        appName,
+      );
+    default:
+      return join(homedir(), appName);
+  }
+}
+
+export function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+  return dirPath;
+}
+
+export function ensureHomeDir() {
+  const dirs = [
+    getHomeDir(),
+    getBinDir(),
+    getStatePath(),
+    getServicesDir(),
+    getLogsDir(),
+    getCacheDir(),
+  ];
+  for (const dir of dirs) {
+    ensureDir(dir);
+  }
+  return getHomeDir();
+}

package/src/lib/platform.js

@@ -0,0 +1,53 @@
+import { platform, arch } from "node:os";
+import { BINARY_NAMES } from "../constants.js";
+
+export function getPlatform() {
+  return platform();
+}
+
+export function getArch() {
+  const a = arch();
+  if (a === "arm64") return "arm64";
+  if (a === "x64" || a === "x86_64") return "x64";
+  return a;
+}
+
+export function getBinaryName(version) {
+  const p = getPlatform();
+  const a = getArch();
+  const platformBinaries = BINARY_NAMES[p];
+  if (!platformBinaries) {
+    throw new Error(`Unsupported platform: ${p}`);
+  }
+  const template = platformBinaries[a];
+  if (!template) {
+    throw new Error(`Unsupported architecture: ${a} on ${p}`);
+  }
+  return template.replace("{version}", version);
+}
+
+export function getBinaryExtension() {
+  const p = getPlatform();
+  switch (p) {
+    case "win32":
+      return ".exe";
+    case "darwin":
+      return ".dmg";
+    case "linux":
+      return ".deb";
+    default:
+      return "";
+  }
+}
+
+export function isWindows() {
+  return getPlatform() === "win32";
+}
+
+export function isMac() {
+  return getPlatform() === "darwin";
+}
+
+export function isLinux() {
+  return getPlatform() === "linux";
+}

package/src/lib/process-manager.js

@@ -0,0 +1,128 @@
+import { spawn, execSync } from "node:child_process";
+import {
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+  readdirSync,
+} from "node:fs";
+import { join } from "node:path";
+import { getPidFilePath, getBinDir, ensureDir, getStatePath } from "./paths.js";
+import { isWindows } from "./platform.js";
+import logger from "./logger.js";
+
+export function startApp(options = {}) {
+  ensureDir(getStatePath());
+  const pidFile = getPidFilePath();
+
+  if (isAppRunning()) {
+    logger.warn("ChainlessChain is already running");
+    return null;
+  }
+
+  const binDir = getBinDir();
+  let appPath;
+
+  if (options.appPath) {
+    appPath = options.appPath;
+  } else if (isWindows()) {
+    appPath = findExecutable(binDir, ".exe");
+  } else {
+    appPath = findExecutable(binDir);
+  }
+
+  if (!appPath) {
+    throw new Error(
+      'ChainlessChain binary not found. Run "chainlesschain setup" first.',
+    );
+  }
+
+  const args = [];
+  if (options.headless) {
+    args.push("--headless");
+  }
+
+  logger.verbose(`Starting: ${appPath} ${args.join(" ")}`);
+
+  const child = spawn(appPath, args, {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, ...options.env },
+  });
+
+  child.unref();
+
+  writeFileSync(pidFile, String(child.pid), "utf-8");
+  logger.verbose(`PID ${child.pid} written to ${pidFile}`);
+
+  return child.pid;
+}
+
+export function stopApp() {
+  const pidFile = getPidFilePath();
+
+  if (!existsSync(pidFile)) {
+    logger.warn("No PID file found. App may not be running.");
+    return false;
+  }
+
+  const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+
+  try {
+    if (isWindows()) {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore" });
+    } else {
+      process.kill(pid, "SIGTERM");
+    }
+    logger.verbose(`Sent stop signal to PID ${pid}`);
+  } catch (err) {
+    logger.verbose(`Process ${pid} may have already exited: ${err.message}`);
+  }
+
+  unlinkSync(pidFile);
+  return true;
+}
+
+export function isAppRunning() {
+  const pidFile = getPidFilePath();
+
+  if (!existsSync(pidFile)) {
+    return false;
+  }
+
+  const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    unlinkSync(pidFile);
+    return false;
+  }
+}
+
+export function getAppPid() {
+  const pidFile = getPidFilePath();
+  if (!existsSync(pidFile)) return null;
+  return parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+}
+
+function findExecutable(binDir, extension) {
+  if (!existsSync(binDir)) return null;
+  try {
+    const files = readdirSync(binDir);
+    const match = files.find((f) => {
+      const isChainless = f.toLowerCase().includes("chainlesschain");
+      if (extension) return isChainless && f.endsWith(extension);
+      return (
+        isChainless &&
+        !f.endsWith(".dmg") &&
+        !f.endsWith(".deb") &&
+        !f.endsWith(".sha256")
+      );
+    });
+    return match ? join(binDir, match) : null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/prompts.js

@@ -0,0 +1,17 @@
+import { confirm, select, input, password } from "@inquirer/prompts";
+
+export async function askConfirm(message, defaultValue = true) {
+  return confirm({ message, default: defaultValue });
+}
+
+export async function askSelect(message, choices) {
+  return select({ message, choices });
+}
+
+export async function askInput(message, defaultValue = "") {
+  return input({ message, default: defaultValue });
+}
+
+export async function askPassword(message) {
+  return password({ message, mask: "*" });
+}

package/src/lib/service-manager.js

@@ -0,0 +1,123 @@
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import logger from "./logger.js";
+
+export function isDockerAvailable() {
+  try {
+    execSync("docker --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isDockerComposeAvailable() {
+  try {
+    execSync("docker compose version", { stdio: "ignore" });
+    return true;
+  } catch {
+    try {
+      execSync("docker-compose --version", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function getComposeCommand() {
+  try {
+    execSync("docker compose version", { stdio: "ignore" });
+    return "docker compose";
+  } catch {
+    return "docker-compose";
+  }
+}
+
+export function findComposeFile(searchPaths) {
+  const names = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+  ];
+  for (const dir of searchPaths) {
+    for (const name of names) {
+      const filePath = join(dir, name);
+      if (existsSync(filePath)) {
+        return filePath;
+      }
+    }
+  }
+  return null;
+}
+
+export function servicesUp(composePath, options = {}) {
+  const cmd = getComposeCommand();
+  const args = ["-f", composePath, "up", "-d"];
+  if (options.services) {
+    args.push(...options.services);
+  }
+  return runCompose(cmd, args);
+}
+
+export function servicesDown(composePath) {
+  const cmd = getComposeCommand();
+  return runCompose(cmd, ["-f", composePath, "down"]);
+}
+
+export function servicesLogs(composePath, options = {}) {
+  const cmd = getComposeCommand();
+  const args = ["-f", composePath, "logs"];
+  if (options.follow) args.push("-f");
+  if (options.tail) args.push("--tail", String(options.tail));
+  if (options.services) args.push(...options.services);
+
+  const parts = cmd.split(" ");
+  const child = spawn(parts[0], [...parts.slice(1), ...args], {
+    stdio: "inherit",
+  });
+
+  return new Promise((resolve, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`docker compose logs exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+
+export function servicesPull(composePath) {
+  const cmd = getComposeCommand();
+  return runCompose(cmd, ["-f", composePath, "pull"]);
+}
+
+export function getServiceStatus(composePath) {
+  const cmd = getComposeCommand();
+  try {
+    const output = execSync(`${cmd} -f "${composePath}" ps --format json`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+    });
+    try {
+      return JSON.parse(`[${output.trim().split("\n").join(",")}]`);
+    } catch {
+      return output.trim();
+    }
+  } catch {
+    return null;
+  }
+}
+
+function runCompose(cmd, args) {
+  const fullCmd = `${cmd} ${args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}`;
+  logger.verbose(`Running: ${fullCmd}`);
+  try {
+    execSync(fullCmd, { stdio: "inherit" });
+    return true;
+  } catch (err) {
+    logger.error(`Command failed: ${fullCmd}`);
+    throw err;
+  }
+}