tanuki-telemetry 1.3.4 → 1.3.6

package/Dockerfile

@@ -0,0 +1,22 @@
+FROM node:22-alpine
+
+WORKDIR /app
+
+# Install backend deps
+COPY package.json ./
+RUN npm install
+
+# Build backend
+COPY tsconfig.json ./
+COPY src/ ./src/
+RUN npm run build
+
+# Build frontend
+COPY frontend/package.json ./frontend/
+RUN cd frontend && npm install --legacy-peer-deps
+COPY frontend/ ./frontend/
+RUN cd frontend && npx tsc -b && npx vite build
+
+RUN mkdir -p /data
+
+ENTRYPOINT ["node", "dist/dashboard-server.js"]

package/bin/tanuki.mjs

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
+const VERSION = pkg.version;
+const TANUKI_DIR = process.env.TANUKI_DIR || path.join(os.homedir(), ".tanuki");
+const DATA_DIR = process.env.TANUKI_DATA || path.join(os.homedir(), ".tanuki/data");
+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}     | ${w}o${g}  __  ${w}o${g} |${r}
+${g}      \\  /  \\  /${r}
+${g}       \\/    \\/${r}
+`;
+
+const BANNER = `  ${g}${b}TANUKI${r} ${d}v${VERSION}${r}
+  ${d}workflow monitor for claude code${r}
+`;
+
+const HELP = `
+${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 skills${r}   install/update skills
+    ${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) {
+      fail(e.message);
+      process.exit(1);
+    }
+    return "";
+  }
+}
+
+function checkRequirements() {
+  let allOk = true;
+
+  try {
+    execSync("docker --version", { stdio: "pipe" });
+  } catch {
+    fail("docker not installed — https://docker.com/products/docker-desktop");
+    allOk = false;
+  }
+
+  if (allOk) {
+    try {
+      execSync("docker info", { stdio: "pipe" });
+    } catch {
+      fail("docker is not running — start Docker Desktop");
+      allOk = false;
+    }
+  }
+
+  const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+  if (nodeVersion < 18) {
+    fail(`node ${process.versions.node} — need 18+`);
+    allOk = false;
+  }
+
+  try {
+    execSync("curl --version", { stdio: "pipe" });
+  } catch {
+    fail("curl not found");
+    allOk = false;
+  }
+
+  // cmux (optional but recommended)
+  let hasCmux = false;
+  try {
+    execSync("cmux --version", { stdio: "pipe" });
+    hasCmux = true;
+  } catch {}
+
+  if (!allOk) {
+    log("");
+    fail("fix the above and try again");
+    process.exit(1);
+  }
+
+  ok(`docker, node, curl${hasCmux ? ", cmux" : ""}`);
+  if (!hasCmux) {
+    info(`${y}cmux not found — needed for /coordinate and workspace skills${r}`);
+    info(`${d}install: https://github.com/anthropics/cmux${r}`);
+  }
+}
+
+function isRunning() {
+  try {
+    const out = execSync("docker ps --filter name=tanuki-dashboard --format '{{.ID}}'", { encoding: "utf-8", stdio: "pipe" });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function copySourceToTanukiDir() {
+  const srcDir = path.resolve(path.dirname(import.meta.url.replace("file://", "")), "..");
+  if (srcDir === TANUKI_DIR) return;
+
+  fs.mkdirSync(TANUKI_DIR, { recursive: true });
+
+  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));
+  }
+
+  for (const d of ["src", "frontend"]) {
+    const src = path.join(srcDir, d);
+    if (fs.existsSync(src)) copyDirSync(src, path.join(TANUKI_DIR, d));
+  }
+}
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (["node_modules", "dist", ".git"].includes(entry.name)) continue;
+    if (entry.isDirectory()) copyDirSync(srcPath, destPath);
+    else fs.copyFileSync(srcPath, destPath);
+  }
+}
+
+function buildImages() {
+  run(`docker build -t tanuki-mcp:latest -t tanuki-dashboard:latest -t telemetry-mcp:latest -t telemetry-dashboard:latest "${TANUKI_DIR}" -q`);
+}
+
+function startDashboard() {
+  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 });
+  run(`docker run -d --rm --name tanuki-dashboard -p ${PORT}:3333 -v "${DATA_DIR}:/data" tanuki-dashboard:latest`, { quiet: true });
+}
+
+function getMcpEntry() {
+  return {
+    type: "stdio",
+    command: "docker",
+    args: ["run", "--rm", "-i", "-v", `${DATA_DIR}:/data`, "--entrypoint", "node", "tanuki-mcp:latest", "dist/index.js"]
+  };
+}
+
+function installSkills() {
+  const skillsDir = path.resolve(path.dirname(import.meta.url.replace("file://", "")), "../skills");
+  const targetDir = path.join(os.homedir(), ".claude", "commands");
+
+  if (!fs.existsSync(skillsDir)) {
+    info("skills directory not found in package");
+    return 0;
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const skills = fs.readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+  let installed = 0;
+
+  for (const skill of skills) {
+    const src = path.join(skillsDir, skill);
+    const dest = path.join(targetDir, skill);
+
+    if (fs.existsSync(dest)) {
+      // Check if ours is newer/different
+      const srcContent = fs.readFileSync(src, "utf-8");
+      const destContent = fs.readFileSync(dest, "utf-8");
+      if (srcContent === destContent) continue;
+
+      // Back up existing
+      fs.copyFileSync(dest, dest + ".bak");
+    }
+
+    fs.copyFileSync(src, dest);
+    installed++;
+  }
+
+  if (installed > 0) {
+    ok(`${installed} skill${installed > 1 ? "s" : ""} installed to ~/.claude/commands/`);
+  } else {
+    ok(`${skills.length} skills up to date`);
+  }
+  return installed;
+}
+
+function autoConfigureClaude() {
+  const claudeConfig = path.join(os.homedir(), ".claude.json");
+
+  if (!fs.existsSync(claudeConfig)) {
+    const config = { mcpServers: { telemetry: getMcpEntry() } };
+    fs.writeFileSync(claudeConfig, JSON.stringify(config, null, 2) + "\n");
+    ok("created ~/.claude.json with MCP config");
+    return true;
+  }
+
+  try {
+    const raw = fs.readFileSync(claudeConfig, "utf-8");
+    const config = JSON.parse(raw);
+
+    if (config.mcpServers?.telemetry) {
+      ok("MCP already configured");
+      return false;
+    }
+
+    if (!config.mcpServers) config.mcpServers = {};
+    config.mcpServers.telemetry = getMcpEntry();
+    fs.writeFileSync(claudeConfig, JSON.stringify(config, null, 2) + "\n");
+    ok("added MCP config to ~/.claude.json");
+    return true;
+  } catch {
+    fail("could not auto-configure ~/.claude.json");
+    return false;
+  }
+}
+
+// --- Commands ---
+
+if (command === "help" || command === "--help" || command === "-h") {
+  log(LOGO);
+  log(HELP);
+  process.exit(0);
+}
+
+if (command === "version" || command === "--version" || command === "-v") {
+  log(`${g}tanuki${r} ${d}v${VERSION}${r}`);
+  process.exit(0);
+}
+
+if (command === "start") {
+  log(LOGO);
+  log(BANNER);
+
+  step(1, 5, "checking requirements");
+  checkRequirements();
+
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+
+  if (isRunning()) {
+    log("");
+    log(`  ${g}already running${r} at ${cy}http://localhost:${PORT}${r}`);
+    log("");
+    process.exit(0);
+  }
+
+  copySourceToTanukiDir();
+
+  const hasImage = (() => {
+    try { execSync("docker image inspect tanuki-dashboard:latest", { stdio: "pipe" }); return true; }
+    catch { return false; }
+  })();
+
+  step(2, 5, hasImage ? "docker images" : "building docker images");
+  if (!hasImage) {
+    info("first run — this takes ~30s...");
+    buildImages();
+  }
+  ok(hasImage ? "cached" : "images built");
+
+  step(3, 5, "starting dashboard");
+  startDashboard();
+
+  let healthy = false;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const res = execSync(`curl -s http://localhost:${PORT}/health`, { encoding: "utf-8", stdio: "pipe" });
+      if (res.includes('"ok":true')) { healthy = true; break; }
+    } catch {}
+    execSync("sleep 1", { stdio: "pipe" });
+  }
+  ok(healthy ? `running on port ${PORT}` : `starting — check port ${PORT}`);
+
+  step(4, 5, "configuring claude code");
+  autoConfigureClaude();
+
+  step(5, 5, "installing skills");
+  installSkills();
+
+  log("");
+  log(`  ${d}─────────────────────────────────────────${r}`);
+  log("");
+  log(`  ${g}${b}ready${r}`);
+  log("");
+  log(`  ${w}dashboard${r}   ${cy}http://localhost:${PORT}${r}`);
+  log(`  ${w}data${r}        ${d}${DATA_DIR}${r}`);
+  log("");
+  log(`  ${w}skills installed:${r}`);
+  log(`    ${g}/start-work${r}    ${d}autonomous dev — context to PR${r}`);
+  log(`    ${g}/coordinate${r}    ${d}manage cmux workspaces${r}`);
+  log(`    ${g}/walkthrough${r}   ${d}execute UI test scenarios${r}`);
+  log(`    ${g}/debug${r}         ${d}systematic bug investigation${r}`);
+  log(`    ${g}/review-code${r}   ${d}PR code review${r}`);
+  log(`    ${g}/sessions${r}      ${d}browse past sessions${r}`);
+  log(`    ${g}/create-path${r}   ${d}generate walkthrough scenarios${r}`);
+  log(`    ${g}/edit-path${r}     ${d}update walkthrough scenarios${r}`);
+  log(`    ${g}/cmux-guide${r}    ${d}workspace navigation ref${r}`);
+  log("");
+  log(`  ${y}restart claude code to load MCP tools + skills${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 });
+  log(`  ${g}stopped${r}`);
+  log("");
+}
+
+else if (command === "status") {
+  if (isRunning()) {
+    try {
+      const health = execSync(`curl -s http://localhost:${PORT}/health`, { encoding: "utf-8", stdio: "pipe" });
+      const parsed = JSON.parse(health);
+      log(`  ${g}running${r} at ${cy}http://localhost:${PORT}${r} ${d}(v${parsed.version})${r}`);
+    } catch {
+      log(`  ${y}container running but health check failed${r}`);
+    }
+  } else {
+    log(`  ${d}not running${r} — ${cy}npx tanuki-telemetry${r} to start`);
+  }
+  log("");
+}
+
+else if (command === "setup") {
+  log(BANNER);
+  autoConfigureClaude();
+  installSkills();
+  log("");
+}
+
+else if (command === "skills") {
+  log(BANNER);
+  installSkills();
+  log("");
+}
+
+else if (command === "update") {
+  log(BANNER);
+  step(1, 2, "rebuilding images");
+  checkRequirements();
+  copySourceToTanukiDir();
+  buildImages();
+  ok("images rebuilt");
+
+  if (isRunning()) {
+    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();
+    ok(`running at http://localhost:${PORT}`);
+  } else {
+    step(2, 2, "done");
+    info("run 'npx tanuki-telemetry' to start");
+  }
+  log("");
+}
+
+else {
+  log(`  ${c.red}unknown command: ${command}${r}`);
+  log(HELP);
+  process.exit(1);
+}

package/frontend/eslint.config.js

@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])

package/frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>tanuki</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>