tanuki-telemetry 1.1.2 → 1.1.3

package/bin/tanuki.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { execSync, spawn } from "child_process";
+import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import os from "os";
@@ -17,29 +17,75 @@ const PORT = process.env.TANUKI_PORT || "3333";
 const args = process.argv.slice(2);
 const command = args[0] || "start";
 
+// --- Colors ---
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  gray: "\x1b[90m",
+  red: "\x1b[31m",
+  bgGreen: "\x1b[42m",
+  bgRed: "\x1b[41m",
+};
+
+const g = c.green;
+const d = c.dim;
+const w = c.white;
+const r = c.reset;
+const b = c.bold;
+const y = c.yellow;
+const cy = c.cyan;
+
+const LOGO = `
+${g}        ╱▔▔╲   ╱▔▔╲${r}
+${g}       ╱ ◆  ╲▁╱  ◆ ╲${r}
+${g}      ▕   ▔▔▔▔▔▔▔   ▏${r}
+${g}       ╲  ╱▔▔▔▔▔╲  ╱${r}
+${g}        ╲╱  ▕▔▔▏  ╲╱${r}
+${g}         ╲▁▁▕▁▁▏▁▁╱${r}
+`;
+
+const BANNER = `
+${d}  ┌─────────────────────────────────────────┐${r}
+${d}  │${r}  ${g}${b}TANUKI${r} ${d}v${VERSION}${r}                            ${d}│${r}
+${d}  │${r}  ${d}workflow monitor for claude code${r}         ${d}│${r}
+${d}  └─────────────────────────────────────────┘${r}
+`;
+
 const HELP = `
-  tanuki v${VERSION} — workflow monitor for Claude Code
-
-  Usage:
-    npx tanuki-telemetry          Start dashboard (default)
-    npx tanuki-telemetry start    Start dashboard on port ${PORT}
-    npx tanuki-telemetry stop     Stop dashboard
-    npx tanuki-telemetry status   Check if running
-    npx tanuki-telemetry setup    Configure Claude Code MCP
-    npx tanuki-telemetry update   Rebuild with latest code
-    npx tanuki-telemetry version  Show version
-
-  Environment:
-    TANUKI_PORT    Dashboard port (default: 3333)
-    TANUKI_DATA    Data directory (default: ~/.tanuki/data)
+${g}${b}  tanuki${r} ${d}v${VERSION}${r} — workflow monitor for Claude Code
+
+${w}  Usage:${r}
+    ${cy}npx tanuki-telemetry${r}          start dashboard
+    ${cy}npx tanuki-telemetry stop${r}     stop dashboard
+    ${cy}npx tanuki-telemetry status${r}   check if running
+    ${cy}npx tanuki-telemetry setup${r}    configure claude code
+    ${cy}npx tanuki-telemetry update${r}   rebuild with latest
+    ${cy}npx tanuki-telemetry version${r}  show version
+
+${w}  Environment:${r}
+    ${d}TANUKI_PORT    dashboard port (default: 3333)${r}
+    ${d}TANUKI_DATA    data directory (default: ~/.tanuki/data)${r}
 `;
 
+function log(msg) { console.log(msg); }
+function step(n, total, msg) { log(`  ${g}[${n}/${total}]${r} ${msg}`); }
+function ok(msg) { log(`  ${d}     ${g}✓${r} ${d}${msg}${r}`); }
+function fail(msg) { log(`  ${c.red}     ✗ ${msg}${r}`); }
+function info(msg) { log(`  ${d}     ${msg}${r}`); }
+
 function run(cmd, opts = {}) {
   try {
     return execSync(cmd, { encoding: "utf-8", stdio: opts.quiet ? "pipe" : "inherit", ...opts });
   } catch (e) {
     if (!opts.ignoreError) {
-      console.error(`  Error: ${e.message}`);
+      fail(e.message);
       process.exit(1);
     }
     return "";
@@ -47,46 +93,44 @@ function run(cmd, opts = {}) {
 }
 
 function checkRequirements() {
-  let ok = true;
+  let allOk = true;
 
-  // Docker installed?
   try {
     execSync("docker --version", { stdio: "pipe" });
   } catch {
-    console.error("  ✗ Docker not installed — install Docker Desktop: https://docker.com/products/docker-desktop");
-    ok = false;
+    fail("docker not installed — https://docker.com/products/docker-desktop");
+    allOk = false;
   }
 
-  // Docker running?
-  if (ok) {
+  if (allOk) {
     try {
       execSync("docker info", { stdio: "pipe" });
     } catch {
-      console.error("  ✗ Docker is not running — start Docker Desktop first");
-      ok = false;
+      fail("docker is not running — start Docker Desktop");
+      allOk = false;
     }
   }
 
-  // Node version
   const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
   if (nodeVersion < 18) {
-    console.error(`  ✗ Node ${process.versions.node} — need Node 18+ (current: ${process.versions.node})`);
-    ok = false;
+    fail(`node ${process.versions.node} — need 18+`);
+    allOk = false;
   }
 
-  // curl (used for health checks)
   try {
     execSync("curl --version", { stdio: "pipe" });
   } catch {
-    console.error("  ✗ curl not found — needed for health checks");
-    ok = false;
+    fail("curl not found");
+    allOk = false;
   }
 
-  if (!ok) {
-    console.error("");
-    console.error("  Fix the above and try again.");
+  if (!allOk) {
+    log("");
+    fail("fix the above and try again");
     process.exit(1);
   }
+
+  ok("docker, node, curl");
 }
 
 function isRunning() {
@@ -99,29 +143,19 @@ function isRunning() {
 }
 
 function copySourceToTanukiDir() {
-  // The source code is wherever this package was installed/run from
   const srcDir = path.resolve(path.dirname(import.meta.url.replace("file://", "")), "..");
+  if (srcDir === TANUKI_DIR) return;
 
-  if (srcDir === TANUKI_DIR) return; // already in place
-
-  // Copy source to TANUKI_DIR for Docker builds
   fs.mkdirSync(TANUKI_DIR, { recursive: true });
 
-  const filesToCopy = ["package.json", "tsconfig.json", "Dockerfile"];
-  const dirsToCopy = ["src", "frontend"];
-
-  for (const f of filesToCopy) {
+  for (const f of ["package.json", "tsconfig.json", "Dockerfile"]) {
     const src = path.join(srcDir, f);
-    if (fs.existsSync(src)) {
-      fs.copyFileSync(src, path.join(TANUKI_DIR, f));
-    }
+    if (fs.existsSync(src)) fs.copyFileSync(src, path.join(TANUKI_DIR, f));
   }
 
-  for (const d of dirsToCopy) {
+  for (const d of ["src", "frontend"]) {
     const src = path.join(srcDir, d);
-    if (fs.existsSync(src)) {
-      copyDirSync(src, path.join(TANUKI_DIR, d));
-    }
+    if (fs.existsSync(src)) copyDirSync(src, path.join(TANUKI_DIR, d));
   }
 }
 
@@ -130,12 +164,9 @@ function copyDirSync(src, dest) {
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
-    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-    if (entry.isDirectory()) {
-      copyDirSync(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
+    if (["node_modules", "dist", ".git"].includes(entry.name)) continue;
+    if (entry.isDirectory()) copyDirSync(srcPath, destPath);
+    else fs.copyFileSync(srcPath, destPath);
   }
 }
 
@@ -161,10 +192,9 @@ function autoConfigureClaude() {
   const claudeConfig = path.join(os.homedir(), ".claude.json");
 
   if (!fs.existsSync(claudeConfig)) {
-    // Create new config
     const config = { mcpServers: { telemetry: getMcpEntry() } };
     fs.writeFileSync(claudeConfig, JSON.stringify(config, null, 2) + "\n");
-    console.log("  Created ~/.claude.json with MCP config");
+    ok("created ~/.claude.json with MCP config");
     return true;
   }
 
@@ -173,19 +203,17 @@ function autoConfigureClaude() {
     const config = JSON.parse(raw);
 
     if (config.mcpServers?.telemetry) {
-      console.log("  MCP already configured in ~/.claude.json");
+      ok("MCP already configured");
       return false;
     }
 
-    // Add telemetry to existing config
     if (!config.mcpServers) config.mcpServers = {};
     config.mcpServers.telemetry = getMcpEntry();
     fs.writeFileSync(claudeConfig, JSON.stringify(config, null, 2) + "\n");
-    console.log("  Added MCP config to ~/.claude.json");
+    ok("added MCP config to ~/.claude.json");
     return true;
-  } catch (e) {
-    console.log("  Could not auto-configure ~/.claude.json — add manually:");
-    console.log(JSON.stringify({ telemetry: getMcpEntry() }, null, 2));
+  } catch {
+    fail("could not auto-configure ~/.claude.json");
     return false;
   }
 }
@@ -193,58 +221,47 @@ function autoConfigureClaude() {
 // --- Commands ---
 
 if (command === "help" || command === "--help" || command === "-h") {
-  console.log(HELP);
+  log(LOGO);
+  log(HELP);
   process.exit(0);
 }
 
 if (command === "version" || command === "--version" || command === "-v") {
-  console.log(`tanuki v${VERSION}`);
+  log(`${g}tanuki${r} ${d}v${VERSION}${r}`);
   process.exit(0);
 }
 
-console.log("");
-
 if (command === "start") {
-  console.log("  ┌─────────────────────────────────────┐");
-  console.log(`  │  TANUKI v${VERSION}                       │`);
-  console.log("  │  workflow monitor for claude code    │");
-  console.log("  └─────────────────────────────────────┘");
-  console.log("");
-
-  // Requirements
-  console.log("  [1/4] checking requirements...");
+  log(LOGO);
+  log(BANNER);
+
+  step(1, 4, "checking requirements");
   checkRequirements();
-  console.log("         docker, node, curl — ok");
 
   fs.mkdirSync(DATA_DIR, { recursive: true });
 
   if (isRunning()) {
-    console.log("");
-    console.log(`  already running at http://localhost:${PORT}`);
-    console.log("");
+    log("");
+    log(`  ${g}already running${r} at ${cy}http://localhost:${PORT}${r}`);
+    log("");
     process.exit(0);
   }
 
   copySourceToTanukiDir();
 
-  // Build
   const hasImage = (() => {
-    try {
-      execSync("docker image inspect tanuki-dashboard:latest", { stdio: "pipe" });
-      return true;
-    } catch { return false; }
+    try { execSync("docker image inspect tanuki-dashboard:latest", { stdio: "pipe" }); return true; }
+    catch { return false; }
   })();
 
+  step(2, 4, hasImage ? "docker images" : "building docker images");
   if (!hasImage) {
-    console.log("  [2/4] building docker images (first run, ~30s)...");
+    info("first run — this takes ~30s...");
     buildImages();
-    console.log("         images built");
-  } else {
-    console.log("  [2/4] docker images — cached");
   }
+  ok(hasImage ? "cached" : "images built");
 
-  // Start
-  console.log("  [3/4] starting dashboard...");
+  step(3, 4, "starting dashboard");
   startDashboard();
 
   let healthy = false;
@@ -255,39 +272,31 @@ if (command === "start") {
     } catch {}
     execSync("sleep 1", { stdio: "pipe" });
   }
+  ok(healthy ? `running on port ${PORT}` : `starting — check port ${PORT}`);
 
-  if (healthy) {
-    console.log(`         running on port ${PORT}`);
-  } else {
-    console.log(`         starting up — check port ${PORT}`);
-  }
-
-  // Configure
-  console.log("  [4/4] configuring claude code...");
+  step(4, 4, "configuring claude code");
   autoConfigureClaude();
 
-  // Done
-  console.log("");
-  console.log("  ────────────────────────────────────");
-  console.log("");
-  console.log(`  dashboard  http://localhost:${PORT}`);
-  console.log(`  data       ${DATA_DIR}`);
-  console.log("");
-  console.log("  if claude code is already open,");
-  console.log("  restart it to load MCP tools.");
-  console.log("");
-  console.log("  commands:");
-  console.log("    npx tanuki-telemetry stop");
-  console.log("    npx tanuki-telemetry status");
-  console.log("    npx tanuki-telemetry update");
-  console.log("");
+  log("");
+  log(`  ${d}─────────────────────────────────────────${r}`);
+  log("");
+  log(`  ${w}dashboard${r}  ${cy}http://localhost:${PORT}${r}`);
+  log(`  ${w}data${r}       ${d}${DATA_DIR}${r}`);
+  log("");
+  log(`  ${y}if claude code is already open,${r}`);
+  log(`  ${y}restart it to load MCP tools.${r}`);
+  log("");
+  log(`  ${d}npx tanuki-telemetry stop${r}`);
+  log(`  ${d}npx tanuki-telemetry status${r}`);
+  log(`  ${d}npx tanuki-telemetry update${r}`);
+  log("");
 }
 
 else if (command === "stop") {
   run("docker rm -f tanuki-dashboard 2>/dev/null || true", { quiet: true, ignoreError: true });
   run("docker rm -f telemetry-dashboard 2>/dev/null || true", { quiet: true, ignoreError: true });
-  console.log("  stopped");
-  console.log("");
+  log(`  ${g}stopped${r}`);
+  log("");
 }
 
 else if (command === "status") {
@@ -295,40 +304,45 @@ else if (command === "status") {
     try {
       const health = execSync(`curl -s http://localhost:${PORT}/health`, { encoding: "utf-8", stdio: "pipe" });
       const parsed = JSON.parse(health);
-      console.log(`  running at http://localhost:${PORT} (v${parsed.version})`);
+      log(`  ${g}running${r} at ${cy}http://localhost:${PORT}${r} ${d}(v${parsed.version})${r}`);
     } catch {
-      console.log("  container running but health check failed");
+      log(`  ${y}container running but health check failed${r}`);
     }
   } else {
-    console.log("  not running — npx tanuki-telemetry to start");
+    log(`  ${d}not running${r} — ${cy}npx tanuki-telemetry${r} to start`);
   }
-  console.log("");
+  log("");
 }
 
 else if (command === "setup") {
+  log(BANNER);
   autoConfigureClaude();
-  console.log("");
+  log("");
 }
 
 else if (command === "update") {
+  log(BANNER);
+  step(1, 2, "rebuilding images");
   checkRequirements();
   copySourceToTanukiDir();
   buildImages();
+  ok("images rebuilt");
 
   if (isRunning()) {
-    console.log("  Restarting dashboard...");
+    step(2, 2, "restarting dashboard");
     run("docker rm -f tanuki-dashboard 2>/dev/null || true", { quiet: true, ignoreError: true });
     run("docker rm -f telemetry-dashboard 2>/dev/null || true", { quiet: true, ignoreError: true });
     startDashboard();
-    console.log(`  Updated and running at http://localhost:${PORT}`);
+    ok(`running at http://localhost:${PORT}`);
   } else {
-    console.log("  Images rebuilt. Run 'npx tanuki-telemetry start' to launch.");
+    step(2, 2, "done");
+    info("run 'npx tanuki-telemetry' to start");
   }
-  console.log("");
+  log("");
 }
 
 else {
-  console.error(`  Unknown command: ${command}`);
-  console.log(HELP);
+  log(`  ${c.red}unknown command: ${command}${r}`);
+  log(HELP);
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tanuki-telemetry",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Workflow monitor and telemetry dashboard for Claude Code autonomous agents",
   "type": "module",
   "bin": {