clawreform 0.3.1 → 0.3.4

package/README.md

@@ -8,6 +8,15 @@ Installs the native `clawreform` CLI from GitHub Releases and exposes it on your
 npm install -g clawreform
 ```
 
+## Launch
+
+```bash
+clawreform
+```
+
+When run with no args in an interactive terminal, this npm launcher opens the web dashboard flow by default.
+On first run, it also performs `clawreform setup --quick` automatically when config is missing.
+
 ## Verify
 
 ```bash
@@ -18,3 +27,4 @@ clawreform --version
 
 - This package downloads the matching binary for Linux, macOS, and Windows.
 - No third-party runtime dependencies are used in this npm package.
+- You can disable no-arg auto-dashboard behavior with `CLAWREFORM_NO_AUTO_DASHBOARD=1`.

package/bin/clawreform.js

@@ -1,8 +1,239 @@
 #!/usr/bin/env node
 
-const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawn, spawnSync } = require("node:child_process");
 const { ensureBinaryInstalled } = require("../lib/install");
 
+const API_KEY_VARS = [
+  "OPENROUTER_API_KEY",
+  "GROQ_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "MINIMAX_API_KEY",
+  "MISTRAL_API_KEY",
+  "TOGETHER_API_KEY",
+  "FIREWORKS_API_KEY",
+  "COHERE_API_KEY",
+  "PERPLEXITY_API_KEY",
+  "XAI_API_KEY"
+];
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeArgs(argv) {
+  const args = argv.slice(2);
+
+  // UX default for npm installs:
+  // In an interactive terminal, no-arg invocation should open the GUI dashboard.
+  const noArgs = args.length === 0;
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const autoDashboardDisabled =
+    process.env.CLAWREFORM_NO_AUTO_DASHBOARD === "1" ||
+    process.env.CLAWREFORM_NO_AUTO_DASHBOARD === "true";
+
+  if (noArgs && interactive && !autoDashboardDisabled) {
+    process.stderr.write("No command provided. Launching web dashboard.\n");
+    return ["dashboard"];
+  }
+
+  // Friendly aliases for non-technical users.
+  if (args[0] === "gui" || args[0] === "web") {
+    return ["dashboard", ...args.slice(1)];
+  }
+
+  return args;
+}
+
+function clawreformHome() {
+  return path.join(os.homedir(), ".clawreform");
+}
+
+function configPath() {
+  return path.join(clawreformHome(), "config.toml");
+}
+
+function daemonInfoPath() {
+  return path.join(clawreformHome(), "daemon.json");
+}
+
+function dotEnvPath() {
+  return path.join(clawreformHome(), ".env");
+}
+
+function daemonBaseUrlFromFile() {
+  try {
+    const raw = fs.readFileSync(daemonInfoPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.listen_addr === "string" && parsed.listen_addr.trim()) {
+      return `http://${parsed.listen_addr.replace("0.0.0.0", "127.0.0.1")}`;
+    }
+  } catch {
+    // ignore
+  }
+  return `http://127.0.0.1:4332`;
+}
+
+function hasConfiguredApiKey() {
+  for (const key of API_KEY_VARS) {
+    const value = process.env[key];
+    if (typeof value === "string" && value.trim()) {
+      return true;
+    }
+  }
+
+  try {
+    const content = fs.readFileSync(dotEnvPath(), "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const idx = trimmed.indexOf("=");
+      if (idx <= 0) {
+        continue;
+      }
+      const key = trimmed.slice(0, idx).trim();
+      const rawValue = trimmed.slice(idx + 1).trim();
+      const value = rawValue.replace(/^['"]|['"]$/g, "").trim();
+      if (API_KEY_VARS.includes(key) && value) {
+        return true;
+      }
+    }
+  } catch {
+    // ignore missing/unreadable .env
+  }
+
+  return false;
+}
+
+async function daemonHealthy(baseUrl) {
+  try {
+    const response = await fetch(`${baseUrl}/api/health`, {
+      headers: { "User-Agent": "clawreform-npm-launcher" }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForDaemonReady(timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const baseUrl = daemonBaseUrlFromFile();
+    if (await daemonHealthy(baseUrl)) {
+      return baseUrl;
+    }
+    await sleep(500);
+  }
+  return null;
+}
+
+function runQuickSetup(binaryPath) {
+  if (fs.existsSync(configPath())) {
+    return true;
+  }
+
+  process.stderr.write("First run detected. Applying quick setup...\n");
+  const result = spawnSync(binaryPath, ["setup", "--quick"], {
+    stdio: "inherit",
+    env: process.env
+  });
+
+  if (result.error) {
+    process.stderr.write(`Quick setup failed: ${result.error.message}\n`);
+    return false;
+  }
+  return result.status === 0;
+}
+
+function spawnDaemon(binaryPath, injectPlaceholderKeys) {
+  const env = { ...process.env };
+  if (injectPlaceholderKeys) {
+    for (const key of API_KEY_VARS) {
+      if (!env[key] || !String(env[key]).trim()) {
+        env[key] = "clawreform-placeholder-key";
+      }
+    }
+  }
+
+  try {
+    const child = spawn(binaryPath, ["start"], {
+      detached: true,
+      stdio: "ignore",
+      env,
+      windowsHide: true
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      return spawnSync("open", [url], { stdio: "ignore" }).status === 0;
+    }
+    if (process.platform === "win32") {
+      return (
+        spawnSync("cmd.exe", ["/c", "start", "", url], {
+          stdio: "ignore",
+          windowsHide: true
+        }).status === 0
+      );
+    }
+    return spawnSync("xdg-open", [url], { stdio: "ignore" }).status === 0;
+  } catch {
+    return false;
+  }
+}
+
+async function runDashboardFlow(binaryPath) {
+  if (!runQuickSetup(binaryPath)) {
+    process.stderr.write("Setup did not complete. Run: clawreform setup --quick\n");
+    return 1;
+  }
+
+  let baseUrl = await waitForDaemonReady(2000);
+  if (!baseUrl) {
+    const injectPlaceholderKeys = !hasConfiguredApiKey();
+    if (injectPlaceholderKeys) {
+      process.stderr.write(
+        "No API key found yet. Starting in setup mode so you can finish setup in the dashboard.\n"
+      );
+    }
+    process.stderr.write("Starting background daemon...\n");
+    if (!spawnDaemon(binaryPath, injectPlaceholderKeys)) {
+      process.stderr.write("Could not start daemon process.\n");
+      process.stderr.write("Run manually: clawreform start\n");
+      return 1;
+    }
+    baseUrl = await waitForDaemonReady(45000);
+  }
+
+  if (!baseUrl) {
+    process.stderr.write("Daemon did not become ready in time.\n");
+    process.stderr.write("Run manually: clawreform start\n");
+    return 1;
+  }
+
+  const url = `${baseUrl}/`;
+  process.stderr.write(`Opening dashboard: ${url}\n`);
+  if (!openBrowser(url)) {
+    process.stderr.write(`Open this URL manually: ${url}\n`);
+  }
+  return 0;
+}
+
 async function main() {
   let binaryPath;
   try {
@@ -13,7 +244,13 @@ async function main() {
     process.exit(1);
   }
 
-  const result = spawnSync(binaryPath, process.argv.slice(2), {
+  const args = normalizeArgs(process.argv);
+
+  if (args[0] === "dashboard") {
+    process.exit(await runDashboardFlow(binaryPath));
+  }
+
+  const result = spawnSync(binaryPath, args, {
     stdio: "inherit",
     env: process.env
   });

package/lib/install.js

@@ -52,13 +52,32 @@ async function downloadToFile(url, destination) {
   });
 
   if (!response.ok) {
-    throw new Error(`Download failed (${response.status}): ${url}`);
+    const error = new Error(`Download failed (${response.status}): ${url}`);
+    error.status = response.status;
+    throw error;
   }
 
   const arrayBuffer = await response.arrayBuffer();
   fs.writeFileSync(destination, Buffer.from(arrayBuffer));
 }
 
+async function fetchLatestReleaseTag() {
+  const url = `https://api.github.com/repos/${REPO}/releases/latest`;
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "clawreform-npm-installer"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch latest release tag (${response.status})`);
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload.tag_name !== "string" || !payload.tag_name.trim()) {
+    throw new Error("Latest release payload did not include tag_name.");
+  }
+  return payload.tag_name.trim();
+}
+
 function extractArchive(archivePath, destinationPath, ext) {
   if (ext === "tar.gz") {
     const result = spawnSync("tar", ["-xzf", archivePath, "-C", destinationPath], {
@@ -120,9 +139,8 @@ function installedBinaryPath() {
 
 async function installBinary(options = {}) {
   const log = typeof options.log === "function" ? options.log : console.log;
-  const version = normalizeVersion(options.version || process.env.CLAWREFORM_VERSION || require("../package.json").version);
+  const preferredVersion = normalizeVersion(options.version || process.env.CLAWREFORM_VERSION || require("../package.json").version);
   const { target, ext, binName } = resolveTarget();
-  const downloadUrl = assetUrl(version, target, ext);
 
   const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "clawreform-npm-"));
   const archivePath = path.join(tmpRoot, `clawreform.${ext}`);
@@ -130,8 +148,44 @@ async function installBinary(options = {}) {
   fs.mkdirSync(extractPath, { recursive: true });
 
   try {
-    log(`clawreform npm: downloading ${version} (${target})`);
-    await downloadToFile(downloadUrl, archivePath);
+    let downloadedVersion = null;
+    const versionsToTry = [preferredVersion];
+    try {
+      const latestTag = normalizeVersion(await fetchLatestReleaseTag());
+      if (!versionsToTry.includes(latestTag)) {
+        versionsToTry.push(latestTag);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log(`clawreform npm: warning: unable to resolve latest release tag (${message})`);
+    }
+
+    let lastError = null;
+    for (const version of versionsToTry) {
+      const downloadUrl = assetUrl(version, target, ext);
+      try {
+        log(`clawreform npm: downloading ${version} (${target})`);
+        await downloadToFile(downloadUrl, archivePath);
+        downloadedVersion = version;
+        break;
+      } catch (error) {
+        lastError = error;
+        const status = error && typeof error === "object" ? error.status : null;
+        if (status === 404) {
+          continue;
+        }
+        throw error;
+      }
+    }
+
+    if (!downloadedVersion) {
+      throw lastError || new Error("Could not download a matching clawreform release asset.");
+    }
+
+    if (downloadedVersion !== preferredVersion) {
+      log(`clawreform npm: release ${preferredVersion} was unavailable, using ${downloadedVersion} instead`);
+    }
+
     extractArchive(archivePath, extractPath, ext);
 
     const sourceBinary = findFileRecursively(extractPath, binName);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "clawreform",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "description": "Cross-platform npm launcher for clawREFORM by aegntic.ai CLI",
   "license": "MIT",
   "author": "clawREFORM by aegntic.ai Team",
   "repository": {
     "type": "git",
-    "url": "https://github.com/aegntic/clawreform"
+    "url": "git+https://github.com/aegntic/clawreform.git"
   },
   "bugs": {
     "url": "https://github.com/aegntic/clawreform/issues"
@@ -23,7 +23,7 @@
     "node": ">=18.0.0"
   },
   "bin": {
-    "clawreform": "./bin/clawreform.js"
+    "clawreform": "bin/clawreform.js"
   },
   "scripts": {
     "postinstall": "node ./scripts/postinstall.js"