@gzmagyari/kanbanboard 1.0.0

package/README.md

@@ -0,0 +1,138 @@
+# Jarvis Kanban Dashboard
+
+A lightweight kanban board for managing tasks for Jarvis/Clawdbot — now with Projects + basic task hierarchy (sub-tickets).
+
+- Frontend: **Vue 2 + Vuetify 2** (CDN, no build step)
+- Backend: **Node.js (Express) + SQLite**
+- Drag & drop: SortableJS via vuedraggable
+
+## Columns
+- Ideas
+- To do
+- In Progress
+- Review
+- Testing
+- Done
+
+Jarvis should only pick up tasks in **To do** and **In Progress**.
+
+## Run
+
+```bash
+cd /home/clawdbot/clawd/kanban-dashboard
+npm install
+HOST=0.0.0.0 PORT=3000 npm start
+```
+
+Open: `http://<server-ip>:3000/`
+
+## API (summary)
+- `GET /api/health`
+- `GET /api/columns`
+
+- `GET /api/ai/health` (shows whether LLM is configured/enabled)
+- `POST /api/ai/tasks/merge` (AI create: enhance + optional breakdown into sub-tickets; returns plan + created tasks when applied)
+- `POST /api/ai/projects/:id/evolve` (AI: propose new tickets based on current state)
+- `POST /api/ai/projects/:id/remove-concept` (AI: remove/unmerge a concept from the hierarchy)
+- `POST /api/ai/projects/:id/init` (AI: generate/overwrite project scope from a repo path; optional seed tickets)
+
+- `GET /api/tasks/:id/ancestors` (optional `?include_self=1`)
+- `GET /api/tasks/:id/descendants` (optional `?mode=flat|tree&include_self=1`)
+- `GET /api/tasks/:id/context`
+- `POST /api/tasks/:id/next` (select next leaf sub-ticket; LLM-assisted when enabled, heuristic fallback)
+
+- `GET /api/projects`
+- `POST /api/projects`
+- `GET /api/projects/:id`
+- `PATCH /api/projects/:id`
+- `DELETE /api/projects/:id` (reassigns tickets to default project, then deletes)
+
+- `GET /api/tasks` (optional `?status=todo&project_id=default&parent_id=<id>`)
+- `POST /api/tasks` (supports `project_id` + `parent_id`)
+- `GET /api/tasks/:id`
+- `PATCH /api/tasks/:id` (supports `status`, `project_id`, `parent_id`)
+- `POST /api/tasks/:id/comments`
+- `POST /api/tasks/:id/updates` (append-only progress log)
+- `GET /api/tasks/:id/updates?limit=5`
+
+## Database
+SQLite file: `kanban-dashboard/data/kanban.db`
+
+Tables:
+- `projects` (project scope/context lives here)
+- `tasks`
+- `automation_tasks` (recurring/scheduled; now also linked to projects)
+- `comments`
+- `progress_updates`
+- `llm_plans` (stores validated AI "plans" and whether they were applied)
+- `llm_runs` (stores raw LLM request/response/error logs for auditing)
+
+## LLM / AI (Phase 3)
+Phase 3 adds:
+- `llm_runs` table (logs LLM requests/responses/errors)
+- `/api/ai/health`
+- `POST /api/tasks/:id/next` (LLM-assisted next-leaf selection)
+
+### Environment variables
+The backend uses an **OpenAI-compatible** Chat Completions endpoint (works with LiteLLM Proxy, OpenRouter direct, etc).
+
+Common setup (LiteLLM proxy):
+```bash
+LLM_ENABLED=1
+LLM_BASE_URL=http://127.0.0.1:4000
+LLM_API_KEY=sk-...              # optional depending on your proxy
+LLM_MODEL=openrouter/google/gemini-3-pro-preview
+```
+
+Optional tuning:
+```bash
+LLM_TIMEOUT_MS=45000
+LLM_TEMPERATURE=0
+```
+
+## AI create (Phase 4)
+`POST /api/ai/tasks/merge` accepts:
+```json
+{
+  "project_id": "default",
+  "parent_id": null,
+  "status": "todo",
+  "text": "Add OAuth login...\n\nMore details...",
+  "breakdown": true,
+  "max_depth": 3,
+  "apply": true
+}
+```
+
+Response (when `apply=true`) returns:
+- `plan_id`
+- `llm_run_id`
+- `root_task`
+- `created_tasks[]`
+
+## Guardrails / safety (Phase 5)
+### Optional API key for AI endpoints
+If set, all `/api/ai/*` endpoints require `X-API-Key: <value>`.
+```bash
+AI_API_KEY=changeme
+```
+
+### Rate limiting (in-memory)
+Simple per-IP rate limiting for AI/LLM calls.
+```bash
+AI_RATE_LIMIT_PER_MIN=60
+```
+
+### Project init repo scanning safety
+By default, init can only read paths under the server working directory. You can allowlist additional roots:
+```bash
+AI_INIT_ALLOWED_ROOTS=/home/clawdbot,/mnt/data
+AI_INIT_MAX_FILES=400
+AI_INIT_MAX_FILE_BYTES=64000
+AI_INIT_MAX_TOTAL_BYTES=600000
+```
+
+To allow any path (dangerous on shared machines):
+```bash
+AI_INIT_ALLOW_ANY=1
+```

package/bin/cli.mjs

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+/**
+ * kanbanboard CLI — manage KanbanBoard from anywhere.
+ *
+ * Usage: kanbanboard <command>
+ *
+ * Commands:
+ *   init      Set up ~/.kanbanboard/ with config and empty database
+ *   run       Start the server in the foreground (Ctrl+C to stop)
+ *   start     Start the server in the background (detached)
+ *   stop      Stop a running background server
+ *   restart   Stop + start (background)
+ *   status    Show whether the server is running
+ *   doctor    Check system dependencies and configuration
+ *   paths     Show resolved file paths (debug)
+ *   mcp       Run the MCP server (stdio, for Claude/agent integration)
+ *   version   Print version
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import net from 'node:net';
+import readline from 'node:readline';
+import { spawn, execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+import {
+  getHome, isDevelopment, getPackageRoot,
+  loadEnv, ensureDirectories, printPathSummary,
+  getDataDir, getDbPath, getRuntimeDir, getEnvPath,
+  getMcpJsonPath, getPidFile, getLogFile, getPublicDir,
+  getServerScript, getQueueLogPath,
+} from '../lib/paths.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+const command = (process.argv[2] || '').toLowerCase();
+
+switch (command) {
+  case 'init':
+    await cmdInit();
+    break;
+  case 'run':
+    await cmdRun();
+    break;
+  case 'start':
+    await cmdStart();
+    break;
+  case 'stop':
+    await cmdStop();
+    break;
+  case 'restart':
+    await cmdStop();
+    await sleep(1000);
+    await cmdStart();
+    break;
+  case 'status':
+    cmdStatus();
+    break;
+  case 'doctor':
+    await cmdDoctor();
+    break;
+  case 'paths':
+    printPathSummary();
+    break;
+  case 'mcp':
+    await cmdMcp();
+    break;
+  case 'version':
+  case '--version':
+  case '-v':
+    console.log(`kanbanboard v${pkg.version}`);
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case '':
+    printHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+}
+
+// ── Helpers ──
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+function ask(question, defaultVal = '') {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    const suffix = defaultVal ? ` [${defaultVal}]` : '';
+    rl.question(`${question}${suffix}: `, answer => {
+      rl.close();
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+function readPid() {
+  try {
+    const pid = parseInt(fs.readFileSync(getPidFile(), 'utf8').trim(), 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch { return null; }
+}
+
+function isProcessRunning(pid) {
+  if (process.platform === 'win32') {
+    try {
+      const out = execSync(`tasklist /FI "PID eq ${pid}" /NH`, {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+      });
+      return out.includes(String(pid));
+    } catch { return false; }
+  }
+  // Unix: signal 0
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function printHelp() {
+  console.log(`
+kanbanboard v${pkg.version} — AI-powered Kanban Dashboard
+
+Usage: kanbanboard <command>
+
+Commands:
+  init      Set up ~/.kanbanboard/ with config and empty database
+  run       Start the server in the foreground (Ctrl+C to stop)
+  start     Start the server in the background (detached)
+  stop      Stop a running background server
+  restart   Stop + start (background)
+  status    Show whether the server is running
+  doctor    Check system dependencies and configuration
+  paths     Show resolved file paths (debug)
+  mcp       Run the MCP server (stdio, for Claude/agent integration)
+  version   Print version
+
+Environment:
+  KANBANBOARD_HOME   Override the config directory (default: ~/.kanbanboard/)
+  PORT               Server port (default: 3000)
+  HOST               Server bind address (default: 127.0.0.1)
+`);
+}
+
+// ── Commands ──
+
+async function cmdInit() {
+  const home = getHome();
+  console.log(`\nKanbanBoard Init`);
+  console.log(`================`);
+  console.log(`Config directory: ${home}\n`);
+
+  // 1. Create directories
+  ensureDirectories();
+  console.log(`[ok] Created data directory: ${getDataDir()}`);
+  console.log(`[ok] Created runtime directory: ${getRuntimeDir()}`);
+
+  // 2. Create .env if it doesn't exist
+  const envPath = getEnvPath();
+  if (fs.existsSync(envPath)) {
+    console.log(`[skip] .env already exists at ${envPath}`);
+  } else {
+    console.log(`\n--- LLM Configuration (optional, press Enter to skip) ---`);
+    const llmEnabled = await ask('Enable LLM features? (1/0)', '0');
+    const llmBaseUrl = await ask('LLM base URL (OpenAI-compatible)');
+    const llmApiKey = await ask('LLM API key');
+    const llmModel = await ask('LLM model name', 'openrouter/google/gemini-3-pro-preview');
+
+    let envContent = `# KanbanBoard Configuration\n`;
+    envContent += `# See .env.example for all available options\n\n`;
+    envContent += `# Server\n`;
+    envContent += `PORT=3000\n`;
+    envContent += `HOST=127.0.0.1\n\n`;
+    envContent += `# LLM (OpenAI-compatible API)\n`;
+    envContent += `LLM_ENABLED=${llmEnabled || '0'}\n`;
+    if (llmBaseUrl) envContent += `LLM_BASE_URL=${llmBaseUrl}\n`;
+    if (llmApiKey) envContent += `LLM_API_KEY=${llmApiKey}\n`;
+    if (llmModel) envContent += `LLM_MODEL=${llmModel}\n`;
+    envContent += `\n# AI API protection (set a key to require X-API-Key header)\n`;
+    envContent += `# AI_API_KEY=\n`;
+    envContent += `# AI_INIT_ALLOW_ANY=1\n`;
+
+    fs.writeFileSync(envPath, envContent, 'utf8');
+    console.log(`\n[ok] Created .env at ${envPath}`);
+  }
+
+  // 3. Initialize database
+  console.log(`\nInitializing database...`);
+  await loadEnv();
+  const { migrate } = await import('../db.mjs');
+  migrate();
+  console.log(`[ok] Database initialized at ${getDbPath()}`);
+
+  console.log(`\n--- Setup Complete ---`);
+  console.log(`Run 'kanbanboard doctor' to verify your environment.`);
+  console.log(`Run 'kanbanboard run' to start the server.\n`);
+}
+
+async function cmdRun() {
+  ensureDirectories();
+  await loadEnv();
+  await import('../server.mjs');
+}
+
+async function cmdStart() {
+  const existing = readPid();
+  if (existing && isProcessRunning(existing)) {
+    console.log(`Server already running (PID ${existing}). Use 'restart' to bounce.`);
+    return;
+  }
+  if (existing) try { fs.unlinkSync(getPidFile()); } catch {}
+
+  ensureDirectories();
+
+  const logFile = getLogFile();
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(logFile, 'a');
+
+  // Spawn the CLI itself with 'run' so loadEnv + paths are set up
+  const child = spawn(process.execPath, [__filename, 'run'], {
+    detached: true,
+    stdio: ['ignore', out, err],
+    env: { ...process.env, KANBANBOARD_HOME: getHome() },
+  });
+
+  child.unref();
+  fs.writeFileSync(getPidFile(), String(child.pid), 'utf8');
+  console.log(`Server started (PID ${child.pid}). Logs: ${logFile}`);
+}
+
+async function cmdStop() {
+  const pid = readPid();
+  if (!pid) {
+    console.log('Server is not running (no PID file).');
+    return false;
+  }
+  if (!isProcessRunning(pid)) {
+    console.log(`PID ${pid} is not running. Cleaning stale PID file.`);
+    try { fs.unlinkSync(getPidFile()); } catch {}
+    return false;
+  }
+  try {
+    if (process.platform === 'win32') {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'pipe' });
+    } else {
+      process.kill(pid, 'SIGTERM');
+    }
+    console.log(`Stopped server (PID ${pid}).`);
+  } catch (e) {
+    console.error(`Failed to stop PID ${pid}: ${e.message}`);
+    return false;
+  }
+  try { fs.unlinkSync(getPidFile()); } catch {}
+  return true;
+}
+
+function cmdStatus() {
+  const pid = readPid();
+  if (!pid) {
+    console.log('Server is NOT running (no PID file).');
+    return;
+  }
+  if (isProcessRunning(pid)) {
+    console.log(`Server is RUNNING (PID ${pid}).`);
+  } else {
+    console.log(`Server is NOT running (stale PID ${pid}). Cleaning up.`);
+    try { fs.unlinkSync(getPidFile()); } catch {}
+  }
+}
+
+async function cmdMcp() {
+  await loadEnv();
+  await import('../kanban-mcp-server.mjs');
+}
+
+async function cmdDoctor() {
+  console.log(`\nKanbanBoard Doctor`);
+  console.log(`==================\n`);
+
+  let issues = 0;
+
+  // 1. Mode and paths
+  console.log(`Mode: ${isDevelopment() ? 'development (repo)' : 'installed'}`);
+  console.log(`Home: ${getHome()}\n`);
+
+  // 2. Node.js version
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  if (major >= 18) {
+    console.log(`[ok]   Node.js ${nodeVersion} (>= 18 required)`);
+  } else {
+    console.log(`[FAIL] Node.js ${nodeVersion} -- version 18+ required`);
+    issues++;
+  }
+
+  // 3. Data directory
+  if (fs.existsSync(getDataDir())) {
+    console.log(`[ok]   Data directory exists: ${getDataDir()}`);
+  } else {
+    console.log(`[FAIL] Data directory missing: ${getDataDir()}`);
+    console.log(`       Run 'kanbanboard init' to create it.`);
+    issues++;
+  }
+
+  // 4. Database
+  if (fs.existsSync(getDbPath())) {
+    console.log(`[ok]   Database exists: ${getDbPath()}`);
+    try {
+      const { default: Database } = await import('better-sqlite3');
+      const testDb = new Database(getDbPath(), { readonly: true });
+      const ver = testDb.pragma('user_version', { simple: true });
+      testDb.close();
+      console.log(`[ok]   Database schema version: ${ver}`);
+    } catch (e) {
+      console.log(`[WARN] Database may be corrupted: ${e.message}`);
+      issues++;
+    }
+  } else {
+    console.log(`[WARN] Database not found: ${getDbPath()}`);
+    console.log(`       It will be created on first server start.`);
+  }
+
+  // 5. .env file
+  if (fs.existsSync(getEnvPath())) {
+    console.log(`[ok]   .env file exists: ${getEnvPath()}`);
+  } else {
+    console.log(`[WARN] .env file not found: ${getEnvPath()}`);
+    console.log(`       AI features will be disabled without configuration.`);
+  }
+
+  // 6. LLM configuration
+  await loadEnv();
+  const llmEnabled = process.env.LLM_ENABLED;
+  const llmBaseUrl = process.env.LLM_BASE_URL;
+  const llmApiKey = process.env.LLM_API_KEY;
+  if (llmEnabled === '1' || llmEnabled === 'true') {
+    console.log(`[ok]   LLM enabled`);
+    if (llmBaseUrl) {
+      console.log(`[ok]   LLM base URL: ${llmBaseUrl}`);
+      // Try to reach it
+      try {
+        const url = new URL(llmBaseUrl);
+        const mod = url.protocol === 'https:' ? await import('node:https') : await import('node:http');
+        await new Promise((resolve, reject) => {
+          const req = mod.default.get(url, { timeout: 5000 }, res => {
+            res.resume();
+            resolve();
+          });
+          req.on('error', reject);
+          req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+        });
+        console.log(`[ok]   LLM base URL is reachable`);
+      } catch (e) {
+        console.log(`[WARN] LLM base URL not reachable: ${e.message}`);
+      }
+    } else {
+      console.log(`[FAIL] LLM enabled but LLM_BASE_URL not set`);
+      issues++;
+    }
+    if (llmApiKey) {
+      console.log(`[ok]   LLM API key is set (${llmApiKey.slice(0, 8)}...)`);
+    } else {
+      console.log(`[WARN] LLM_API_KEY not set -- some providers require it`);
+    }
+  } else {
+    console.log(`[info] LLM disabled (set LLM_ENABLED=1 to enable)`);
+  }
+
+  // 7. CLI tools
+  console.log('');
+  for (const [name, desc] of [
+    ['claude', 'Claude Code CLI (Anthropic)'],
+    ['codex', 'Codex CLI (OpenAI)'],
+    ['gemini', 'Gemini CLI (Google)'],
+  ]) {
+    try {
+      const versionCmd = name === 'gemini' ? `${name} --version` : `${name} --version`;
+      const version = execSync(versionCmd, {
+        encoding: 'utf8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim().split('\n')[0];
+      console.log(`[ok]   ${desc}: ${version}`);
+    } catch {
+      console.log(`[info] ${desc}: not found in PATH`);
+    }
+  }
+
+  // 8. Port availability
+  console.log('');
+  const port = Number(process.env.PORT || 3000);
+  try {
+    await new Promise((resolve, reject) => {
+      const server = net.createServer();
+      server.once('error', (e) => {
+        if (e.code === 'EADDRINUSE') reject(new Error(`Port ${port} in use`));
+        else reject(e);
+      });
+      server.once('listening', () => { server.close(); resolve(); });
+      server.listen(port, '127.0.0.1');
+    });
+    console.log(`[ok]   Port ${port} is available`);
+  } catch (e) {
+    console.log(`[WARN] ${e.message} -- the server may already be running`);
+  }
+
+  // 9. Chrome (for MCP agent DevTools)
+  let chromeFound = false;
+  if (process.platform === 'win32') {
+    for (const envVar of ['ProgramFiles', 'ProgramFiles(x86)', 'LocalAppData']) {
+      const base = process.env[envVar];
+      if (base) {
+        const candidate = path.join(base, 'Google', 'Chrome', 'Application', 'chrome.exe');
+        if (fs.existsSync(candidate)) { chromeFound = true; break; }
+      }
+    }
+  } else if (process.platform === 'darwin') {
+    chromeFound = fs.existsSync('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome');
+  } else {
+    try {
+      execSync('which google-chrome || which chromium', { stdio: 'pipe' });
+      chromeFound = true;
+    } catch {}
+  }
+  if (chromeFound) {
+    console.log(`[ok]   Chrome browser found (for agent MCP DevTools)`);
+  } else {
+    console.log(`[info] Chrome browser not found (optional, for agent MCP)`);
+  }
+
+  // Summary
+  console.log(`\n${issues === 0 ? 'All checks passed!' : `${issues} issue(s) found.`}\n`);
+  process.exit(issues > 0 ? 1 : 0);
+}

package/cron-sync.mjs

@@ -0,0 +1,9 @@
+/**
+ * Placeholder for the cron sync agent.
+ *
+ * This repo currently ships the Kanban UI + API, but does not include the
+ * Gateway cron integration client. If you intend to run a sync worker,
+ * implement your cron tooling here (or add a local ./lib/cron-tool-shim.mjs).
+ */
+
+// Intentionally empty.