claudeck 1.0.0

package/server/routes/messages.js

@@ -0,0 +1,36 @@
+import { Router } from "express";
+import { getMessages, getMessagesByChatId, getMessagesNoChatId } from "../../db.js";
+
+const router = Router();
+
+// Get all messages for a session
+router.get("/:id/messages", (req, res) => {
+  try {
+    const messages = getMessages(req.params.id);
+    res.json(messages);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Get messages filtered by chatId
+router.get("/:id/messages/:chatId", (req, res) => {
+  try {
+    const messages = getMessagesByChatId(req.params.id, req.params.chatId);
+    res.json(messages);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Get messages where chat_id IS NULL (single-mode)
+router.get("/:id/messages-single", (req, res) => {
+  try {
+    const messages = getMessagesNoChatId(req.params.id);
+    res.json(messages);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/notifications.js

@@ -0,0 +1,37 @@
+import { Router } from "express";
+import { upsertPushSubscription, deletePushSubscription } from "../../db.js";
+
+const router = Router();
+
+let vapidPublicKey = null;
+
+export function setVapidPublicKey(key) {
+  vapidPublicKey = key;
+}
+
+router.get("/vapid-public-key", (req, res) => {
+  if (!vapidPublicKey) {
+    return res.status(404).json({ error: "Push notifications not configured" });
+  }
+  res.json({ key: vapidPublicKey });
+});
+
+router.post("/subscribe", (req, res) => {
+  const { endpoint, keys } = req.body;
+  if (!endpoint || !keys?.p256dh || !keys?.auth) {
+    return res.status(400).json({ error: "Invalid subscription" });
+  }
+  upsertPushSubscription(endpoint, keys.p256dh, keys.auth);
+  res.json({ ok: true });
+});
+
+router.post("/unsubscribe", (req, res) => {
+  const { endpoint } = req.body;
+  if (!endpoint) {
+    return res.status(400).json({ error: "Missing endpoint" });
+  }
+  deletePushSubscription(endpoint);
+  res.json({ ok: true });
+});
+
+export default router;

package/server/routes/projects.js

@@ -0,0 +1,207 @@
+import { Router } from "express";
+import { readFile, readdir, stat, writeFile } from "fs/promises";
+import { join, resolve, isAbsolute, dirname } from "path";
+import { homedir } from "os";
+import { configPath } from "../paths.js";
+
+const router = Router();
+
+// Load project configs into memory
+let projectConfigs = [];
+export async function loadProjectConfigs() {
+  try {
+    const data = await readFile(configPath("folders.json"), "utf-8");
+    projectConfigs = JSON.parse(data);
+  } catch (err) {
+    console.error("Failed to load project configs:", err.message);
+    projectConfigs = [];
+  }
+}
+loadProjectConfigs();
+
+export function getProjectSystemPrompt(cwd) {
+  const project = projectConfigs.find((p) => p.path === cwd);
+  return project?.systemPrompt || "";
+}
+
+// Serve configured project folders
+router.get("/", async (req, res) => {
+  try {
+    const data = await readFile(configPath("folders.json"), "utf-8");
+    res.json(JSON.parse(data));
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Save/clear system prompt for a project
+router.put("/system-prompt", async (req, res) => {
+  try {
+    const { path: projectPath, systemPrompt } = req.body;
+    if (!projectPath) return res.status(400).json({ error: "path is required" });
+    const filePath = configPath("folders.json");
+    const data = JSON.parse(await readFile(filePath, "utf-8"));
+    const project = data.find((p) => p.path === projectPath);
+    if (!project) return res.status(404).json({ error: "Project not found" });
+    project.systemPrompt = systemPrompt || "";
+    const { writeFile } = await import("fs/promises");
+    await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    await loadProjectConfigs();
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Browse directories on the server filesystem
+router.get("/browse", async (req, res) => {
+  try {
+    const requestedDir = req.query.dir || homedir();
+    const current = resolve(requestedDir);
+
+    // Security: ensure resolved path is valid
+    if (!isAbsolute(current)) {
+      return res.status(400).json({ error: "Invalid path" });
+    }
+
+    const s = await stat(current);
+    if (!s.isDirectory()) {
+      return res.status(400).json({ error: "Not a directory" });
+    }
+
+    const entries = await readdir(current, { withFileTypes: true });
+    const dirs = entries
+      .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .map((e) => ({ name: e.name, path: join(current, e.name) }));
+
+    const parent = current === "/" ? null : dirname(current);
+    res.json({ current, parent, dirs });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Add a new project to folders.json
+router.post("/", async (req, res) => {
+  try {
+    const { name, path: projectPath } = req.body;
+    if (!name || !projectPath) {
+      return res.status(400).json({ error: "name and path are required" });
+    }
+
+    const resolvedPath = resolve(projectPath);
+
+    // Validate path exists and is a directory
+    const s = await stat(resolvedPath);
+    if (!s.isDirectory()) {
+      return res.status(400).json({ error: "Path is not a directory" });
+    }
+
+    const filePath = configPath("folders.json");
+    const data = JSON.parse(await readFile(filePath, "utf-8"));
+
+    // Check for duplicate path
+    if (data.some((p) => p.path === resolvedPath)) {
+      return res.status(409).json({ error: "Project with this path already exists" });
+    }
+
+    data.push({ name, path: resolvedPath });
+    await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    await loadProjectConfigs();
+    res.json({ ok: true, project: { name, path: resolvedPath } });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Remove a project from folders.json
+router.delete("/", async (req, res) => {
+  try {
+    const { path: projectPath } = req.body;
+    if (!projectPath) {
+      return res.status(400).json({ error: "path is required" });
+    }
+
+    const filePath = configPath("folders.json");
+    const data = JSON.parse(await readFile(filePath, "utf-8"));
+    const filtered = data.filter((p) => p.path !== projectPath);
+
+    if (filtered.length === data.length) {
+      return res.status(404).json({ error: "Project not found" });
+    }
+
+    await writeFile(filePath, JSON.stringify(filtered, null, 2) + "\n");
+    await loadProjectConfigs();
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Read project commands from .claude/commands/*.md and .claude/skills/*/SKILL.md
+router.get("/commands", async (req, res) => {
+  const projectPath = req.query.path;
+  if (!projectPath) return res.status(400).json({ error: "path is required" });
+
+  const { readdir, stat } = await import("fs/promises");
+  const commands = [];
+
+  // 1. Read .claude/commands/*.md and .claude/commands/<subfolder>/*.md
+  const commandsDir = join(projectPath, ".claude", "commands");
+  async function readCommandsRecursive(dir, prefix) {
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        const entryPath = join(dir, entry);
+        if (!entryPath.startsWith(commandsDir)) continue;
+        try {
+          const s = await stat(entryPath);
+          if (s.isDirectory()) {
+            await readCommandsRecursive(entryPath, prefix ? `${prefix}:${entry}` : entry);
+          } else if (entry.endsWith(".md")) {
+            const content = await readFile(entryPath, "utf-8");
+            const name = prefix ? `${prefix}:${entry.replace(/\.md$/, "")}` : entry.replace(/\.md$/, "");
+            const titleMatch = content.match(/^#\s+(.+)$/m);
+            const description = titleMatch ? titleMatch[1].trim() : name;
+            commands.push({ command: name, description, prompt: content, source: "command" });
+          }
+        } catch { /* skip unreadable entries */ }
+      }
+    } catch { /* directory doesn't exist or unreadable */ }
+  }
+  await readCommandsRecursive(commandsDir, "");
+
+  // 2. Read .claude/skills/*/SKILL.md
+  const skillsDir = join(projectPath, ".claude", "skills");
+  try {
+    const entries = await readdir(skillsDir);
+    for (const entry of entries) {
+      try {
+        const entryPath = join(skillsDir, entry);
+        const s = await stat(entryPath);
+        if (!s.isDirectory()) continue;
+        const skillFile = join(entryPath, "SKILL.md");
+        const content = await readFile(skillFile, "utf-8");
+        let name = entry;
+        let description = entry;
+        let argumentHint = "";
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (fmMatch) {
+          const fm = fmMatch[1];
+          const nameMatch = fm.match(/^name:\s*(.+)$/m);
+          const descMatch = fm.match(/^description:\s*(.+)$/m);
+          const argMatch = fm.match(/^argument-hint:\s*"?(.+?)"?\s*$/m);
+          if (nameMatch) name = nameMatch[1].trim();
+          if (descMatch) description = descMatch[1].trim();
+          if (argMatch) argumentHint = argMatch[1].trim();
+        }
+        commands.push({ command: name, description, prompt: content, source: "skill", argumentHint });
+      } catch { /* skip unreadable skill dirs */ }
+    }
+  } catch { /* .claude/skills/ doesn't exist */ }
+
+  res.json(commands);
+});
+
+export default router;

package/server/routes/prompts.js

@@ -0,0 +1,53 @@
+import { Router } from "express";
+import { readFile } from "fs/promises";
+import { configPath } from "../paths.js";
+
+const router = Router();
+
+// Serve prompt toolbox
+router.get("/", async (req, res) => {
+  try {
+    const data = await readFile(configPath("prompts.json"), "utf-8");
+    res.json(JSON.parse(data));
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Add a new prompt
+router.post("/", async (req, res) => {
+  try {
+    const { title, description, prompt } = req.body;
+    if (!title || !description || !prompt) {
+      return res.status(400).json({ error: "title, description, and prompt are required" });
+    }
+    const filePath = configPath("prompts.json");
+    const data = JSON.parse(await readFile(filePath, "utf-8"));
+    data.push({ title, description, prompt });
+    const { writeFile } = await import("fs/promises");
+    await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Delete a prompt by index
+router.delete("/:index", async (req, res) => {
+  try {
+    const idx = parseInt(req.params.index, 10);
+    const filePath = configPath("prompts.json");
+    const data = JSON.parse(await readFile(filePath, "utf-8"));
+    if (idx < 0 || idx >= data.length) {
+      return res.status(404).json({ error: "Prompt not found" });
+    }
+    data.splice(idx, 1);
+    const { writeFile } = await import("fs/promises");
+    await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/sessions.js

@@ -0,0 +1,103 @@
+import { Router } from "express";
+import {
+  listSessions,
+  deleteSession as dbDeleteSession,
+  updateSessionTitle,
+  toggleSessionPin,
+  searchSessions,
+} from "../../db.js";
+import { getActiveSessionIds } from "../ws-handler.js";
+import { generateSessionSummary } from "../summarizer.js";
+
+const router = Router();
+
+// sessionIds map is passed in from the parent
+let sessionIds;
+export function setSessionIds(map) {
+  sessionIds = map;
+}
+
+// List sessions (optionally filtered by project_path)
+router.get("/", (req, res) => {
+  try {
+    const projectPath = req.query.project_path || undefined;
+    const sessions = listSessions(20, projectPath);
+    res.json(sessions);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Search sessions
+router.get("/search", (req, res) => {
+  try {
+    const q = req.query.q || "";
+    const projectPath = req.query.project_path || undefined;
+    const sessions = searchSessions(q, 20, projectPath);
+    res.json(sessions);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// List session IDs with active (in-flight) queries
+router.get("/active", (req, res) => {
+  try {
+    res.json({ activeSessionIds: getActiveSessionIds() });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Delete a session
+router.delete("/:id", (req, res) => {
+  try {
+    const id = req.params.id;
+    dbDeleteSession(id);
+    // Clean up sessionIds map entries for this session
+    for (const [key] of sessionIds) {
+      if (key === id || key.startsWith(id + "::")) {
+        sessionIds.delete(key);
+      }
+    }
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Update session title
+router.put("/:id/title", (req, res) => {
+  try {
+    const { title } = req.body;
+    if (typeof title !== "string") {
+      return res.status(400).json({ error: "title is required" });
+    }
+    updateSessionTitle(req.params.id, title.slice(0, 200));
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Toggle session pin
+router.put("/:id/pin", (req, res) => {
+  try {
+    toggleSessionPin(req.params.id);
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Generate/regenerate summary on demand
+router.post("/:id/summary", async (req, res) => {
+  try {
+    const summary = await generateSessionSummary(req.params.id);
+    res.json({ ok: true, summary });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/stats.js

@@ -0,0 +1,143 @@
+import { Router } from "express";
+import { execFile } from "child_process";
+import { join } from "path";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import {
+  getTotalCost, getProjectCost, getSessionCosts, getCostTimeline, getTotalTokens, getProjectTokens,
+  getAnalyticsOverview, getDailyBreakdown, getHourlyActivity, getProjectBreakdown,
+  getTopSessionsByCost, getToolUsage, getToolErrors, getSessionDepth,
+  getMsgLengthDistribution, getTopBashCommands, getTopFiles,
+  getErrorCategories, getErrorTimeline, getErrorsByTool, getRecentErrors,
+  getModelUsage, getCacheEfficiency, getYearlyActivity,
+  getAgentRunsOverview, getAgentRunsSummary, getAgentRunsByType, getAgentRunsDaily, getAgentRunsRecent,
+} from "../../db.js";
+
+const router = Router();
+
+// Account info — cached in memory
+let cachedAccountInfo = null;
+
+// Resolve claude binary — check common locations if not on PATH
+function findClaudeBinary() {
+  const home = homedir();
+  const candidates = [
+    join(home, ".local", "bin", "claude"),           // Linux
+    "/usr/local/bin/claude",                          // macOS Homebrew
+  ];
+  if (process.platform === "win32") {
+    candidates.push(join(home, "AppData", "Local", "Programs", "claude", "claude.exe"));
+    candidates.push(join(home, ".claude", "local", "claude.exe"));
+  }
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  return "claude"; // fallback to PATH
+}
+const claudeBin = findClaudeBinary();
+
+router.get("/account", async (req, res) => {
+  if (cachedAccountInfo) {
+    return res.json(cachedAccountInfo);
+  }
+  try {
+    const data = await new Promise((resolve, reject) => {
+      execFile(claudeBin, ["auth", "status"], { timeout: 10000 }, (err, stdout) => {
+        if (err) return reject(err);
+        try { resolve(JSON.parse(stdout)); } catch (e) { reject(e); }
+      });
+    });
+    cachedAccountInfo = {
+      email: data.email || null,
+      plan: data.subscriptionType || null,
+    };
+  } catch (err) {
+    console.error("Failed to fetch account info:", err.message);
+    cachedAccountInfo = { email: null, plan: null };
+  }
+  res.json(cachedAccountInfo);
+});
+
+// Cost dashboard
+router.get("/dashboard", (req, res) => {
+  try {
+    const projectPath = req.query.project_path || undefined;
+    const sessions = getSessionCosts(projectPath);
+    const timeline = getCostTimeline(projectPath);
+    const totalCost = getTotalCost();
+    const projectCost = projectPath ? getProjectCost(projectPath) : null;
+    const totalTokens = getTotalTokens();
+    const projectTokens = projectPath ? getProjectTokens(projectPath) : null;
+    res.json({ sessions, timeline, totalCost, projectCost, totalTokens, projectTokens });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Analytics dashboard
+router.get("/analytics", (req, res) => {
+  try {
+    const projectPath = req.query.project_path || undefined;
+    res.json({
+      overview: getAnalyticsOverview(projectPath),
+      dailyBreakdown: getDailyBreakdown(projectPath),
+      hourlyActivity: getHourlyActivity(projectPath),
+      projectBreakdown: getProjectBreakdown(),
+      topSessions: getTopSessionsByCost(projectPath),
+      toolUsage: getToolUsage(projectPath),
+      toolErrors: getToolErrors(projectPath),
+      sessionDepth: getSessionDepth(projectPath),
+      msgLength: getMsgLengthDistribution(projectPath),
+      topBashCommands: getTopBashCommands(projectPath),
+      topFiles: getTopFiles(projectPath),
+      errorCategories: getErrorCategories(projectPath),
+      errorTimeline: getErrorTimeline(projectPath),
+      errorsByTool: getErrorsByTool(projectPath),
+      recentErrors: getRecentErrors(projectPath),
+      modelUsage: getModelUsage(projectPath),
+      cacheEfficiency: getCacheEfficiency(projectPath),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Home page data — yearly activity grid + overview
+router.get("/home", (req, res) => {
+  try {
+    const yearlyActivity = getYearlyActivity();
+    const overview = getAnalyticsOverview();
+    res.json({ yearlyActivity, overview });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Agent monitoring dashboard
+router.get("/agent-metrics", (req, res) => {
+  try {
+    res.json({
+      overview: getAgentRunsOverview(),
+      agents: getAgentRunsSummary(),
+      byType: getAgentRunsByType(),
+      daily: getAgentRunsDaily(),
+      recent: getAgentRunsRecent(30),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Stats — total cost (optionally filtered by project_path)
+router.get("/", (req, res) => {
+  try {
+    const projectPath = req.query.project_path;
+    const totalCost = getTotalCost();
+    const projectCost = projectPath ? getProjectCost(projectPath) : null;
+    res.json({ totalCost, projectCost });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/telegram.js

@@ -0,0 +1,71 @@
+import { Router } from "express";
+import { readFile } from "fs/promises";
+import {
+  getTelegramConfig,
+  saveTelegramConfig,
+  sendTelegramNotification,
+} from "../telegram-sender.js";
+import { restartTelegramPoller } from "../telegram-poller.js";
+import { configPath } from "../paths.js";
+
+const router = Router();
+
+// GET /config — return current config (token masked)
+router.get("/config", (req, res) => {
+  res.json(getTelegramConfig());
+});
+
+// PUT /config — save new config
+router.put("/config", async (req, res) => {
+  try {
+    const { enabled, botToken, chatId, afkTimeoutMinutes, notify } = req.body;
+
+    if (typeof enabled !== "boolean") {
+      return res.status(400).json({ error: "enabled must be a boolean" });
+    }
+
+    // If botToken looks masked (starts with ****), keep the old one
+    const configFile = configPath("telegram-config.json");
+
+    let existingToken = "";
+    try {
+      const raw = await readFile(configFile, "utf-8");
+      existingToken = JSON.parse(raw).botToken || "";
+    } catch {}
+
+    const finalToken =
+      botToken && !botToken.startsWith("****") ? botToken : existingToken;
+
+    await saveTelegramConfig({
+      enabled,
+      botToken: finalToken,
+      chatId: chatId || "",
+      afkTimeoutMinutes: afkTimeoutMinutes || 15,
+      notify: notify || {},
+    });
+
+    // Restart poller if config changed
+    restartTelegramPoller();
+
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST /test — send a test message
+router.post("/test", async (req, res) => {
+  try {
+    await sendTelegramNotification(
+      "session",
+      "Claudeck Test",
+      "Telegram notifications are working!",
+      { durationMs: 1234, costUsd: 0.0042, inputTokens: 1500, outputTokens: 800, model: "claude-sonnet-4-6", turns: 3 }
+    );
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;