claudeck 1.0.0

package/server/routes/tips.js

@@ -0,0 +1,135 @@
+import { Router } from "express";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const router = Router();
+
+// Cache for tips.json
+let tipsData = null;
+
+function loadTips() {
+  if (!tipsData) {
+    const filePath = join(__dirname, "../../public/data/tips.json");
+    tipsData = JSON.parse(readFileSync(filePath, "utf-8"));
+  }
+  return tipsData;
+}
+
+// GET /api/tips — serve tips data
+router.get("/", (req, res) => {
+  try {
+    res.json(loadTips());
+  } catch (err) {
+    res.status(500).json({ error: "Failed to load tips" });
+  }
+});
+
+// RSS proxy cache: url -> { data, timestamp }
+const rssCache = new Map();
+const RSS_CACHE_TTL = 15 * 60 * 1000; // 15 minutes
+
+function stripHtml(str) {
+  return str
+    .replace(/<[^>]*>/g, " ")
+    .replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&")
+    .replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&#8212;/g, "—")
+    .replace(/&#\d+;/g, "")
+    .replace(/<[^>]*>/g, "")  // strip any decoded tags
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+// Simple regex-based XML parser — handles RSS 2.0 (<item>) and Atom (<entry>)
+function parseRssXml(xml) {
+  const items = [];
+
+  // Helper to extract tag content (CDATA or plain)
+  const getTag = (block, tag) => {
+    const m = block.match(new RegExp(`<${tag}[^>]*><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>`, "i"))
+      || block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"));
+    return m ? m[1].trim() : "";
+  };
+
+  // Helper to extract Atom <link href="..."/>
+  const getAtomLink = (block) => {
+    const m = block.match(/<link[^>]*href="([^"]*)"[^>]*rel="alternate"/i)
+      || block.match(/<link[^>]*rel="alternate"[^>]*href="([^"]*)"/i)
+      || block.match(/<link[^>]*href="([^"]*)"/i);
+    return m ? m[1].trim() : "";
+  };
+
+  // Try RSS 2.0 first (<item>)
+  const itemRegex = /<item>([\s\S]*?)<\/item>/gi;
+  let match;
+  while ((match = itemRegex.exec(xml)) !== null && items.length < 20) {
+    const block = match[1];
+    items.push({
+      title: stripHtml(getTag(block, "title")),
+      link: getTag(block, "link"),
+      pubDate: getTag(block, "pubDate"),
+      description: stripHtml(getTag(block, "description")).slice(0, 200),
+    });
+  }
+
+  // Fall back to Atom (<entry>) if no RSS items found
+  if (items.length === 0) {
+    const entryRegex = /<entry>([\s\S]*?)<\/entry>/gi;
+    while ((match = entryRegex.exec(xml)) !== null && items.length < 20) {
+      const block = match[1];
+      const desc = getTag(block, "summary") || getTag(block, "content");
+      items.push({
+        title: stripHtml(getTag(block, "title")),
+        link: getAtomLink(block) || getTag(block, "link"),
+        pubDate: getTag(block, "published") || getTag(block, "updated"),
+        description: stripHtml(desc).slice(0, 200),
+      });
+    }
+  }
+
+  return items;
+}
+
+// GET /api/tips/rss?url=<encoded> — proxy RSS feed
+router.get("/rss", async (req, res) => {
+  const { url } = req.query;
+  if (!url) return res.status(400).json({ error: "url parameter required" });
+
+  // Check cache
+  const cached = rssCache.get(url);
+  if (cached && Date.now() - cached.timestamp < RSS_CACHE_TTL) {
+    return res.json({ items: cached.data });
+  }
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 8000);
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": "claudeck/1.0" },
+    });
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      return res.status(502).json({ error: `Feed returned ${response.status}` });
+    }
+
+    const xml = await response.text();
+    const items = parseRssXml(xml);
+
+    // Cache the result
+    rssCache.set(url, { data: items, timestamp: Date.now() });
+
+    res.json({ items });
+  } catch (err) {
+    if (err.name === "AbortError") {
+      return res.status(504).json({ error: "Feed request timed out" });
+    }
+    res.status(502).json({ error: "Failed to fetch feed" });
+  }
+});
+
+export default router;

package/server/routes/workflows.js

@@ -0,0 +1,81 @@
+import { Router } from "express";
+import { readFile, writeFile } from "fs/promises";
+import { configPath } from "../paths.js";
+
+const router = Router();
+
+async function readWorkflows() {
+  try {
+    const data = await readFile(configPath("workflows.json"), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+
+async function writeWorkflows(workflows) {
+  await writeFile(configPath("workflows.json"), JSON.stringify(workflows, null, 2) + "\n");
+}
+
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+router.get("/", async (req, res) => {
+  try {
+    res.json(await readWorkflows());
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.post("/", async (req, res) => {
+  try {
+    const { title, description, steps } = req.body;
+    if (!title || !steps?.length) {
+      return res.status(400).json({ error: "title and steps are required" });
+    }
+    const workflows = await readWorkflows();
+    const id = slugify(title);
+    if (workflows.find((w) => w.id === id)) {
+      return res.status(409).json({ error: `Workflow "${id}" already exists` });
+    }
+    const wf = { id, title, description: description || "", steps };
+    workflows.push(wf);
+    await writeWorkflows(workflows);
+    res.json(wf);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.put("/:id", async (req, res) => {
+  try {
+    const workflows = await readWorkflows();
+    const idx = workflows.findIndex((w) => w.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: "Workflow not found" });
+    const { title, description, steps } = req.body;
+    if (title !== undefined) workflows[idx].title = title;
+    if (description !== undefined) workflows[idx].description = description;
+    if (steps !== undefined) workflows[idx].steps = steps;
+    await writeWorkflows(workflows);
+    res.json(workflows[idx]);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.delete("/:id", async (req, res) => {
+  try {
+    const workflows = await readWorkflows();
+    const idx = workflows.findIndex((w) => w.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: "Workflow not found" });
+    workflows.splice(idx, 1);
+    await writeWorkflows(workflows);
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/summarizer.js

@@ -0,0 +1,55 @@
+import { query } from "@anthropic-ai/claude-code";
+import { execPath } from "process";
+import { getMessagesNoChatId, updateSessionSummary, getSession } from "../db.js";
+
+export async function generateSessionSummary(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) return null;
+
+  const messages = getMessagesNoChatId(sessionId);
+  const conversation = [];
+  for (const msg of messages) {
+    try {
+      const data = JSON.parse(msg.content);
+      if (msg.role === "user" && data.text) {
+        conversation.push(`User: ${data.text.slice(0, 500)}`);
+      } else if (msg.role === "assistant" && data.text) {
+        conversation.push(`Assistant: ${data.text.slice(0, 500)}`);
+      }
+    } catch {
+      // skip unparseable messages
+    }
+  }
+
+  if (conversation.length < 2) return null;
+
+  const transcript = conversation.join("\n").slice(-4000);
+  const prompt = `Summarize this coding session in 1 short sentence (max 120 chars). Focus on what was accomplished or discussed. No quotes, no prefixes like "Summary:". Just the sentence.\n\n${transcript}`;
+
+  let summary = null;
+
+  const q = query({
+    prompt,
+    options: {
+      maxTurns: 1,
+      model: "claude-haiku-4-5-20251001",
+      permissionMode: "bypassPermissions",
+      executable: execPath,
+    },
+  });
+
+  for await (const msg of q) {
+    if (msg.type === "assistant" && msg.message?.content) {
+      for (const block of msg.message.content) {
+        if (block.type === "text" && block.text) {
+          summary = block.text.trim().slice(0, 200);
+        }
+      }
+    }
+  }
+
+  if (summary) {
+    updateSessionSummary(sessionId, summary);
+  }
+  return summary;
+}

package/server/telegram-poller.js

@@ -0,0 +1,205 @@
+/**
+ * Telegram long-poller — listens for callback_query events (Approve/Deny button presses)
+ * and routes them back to the pendingApprovals Map used by the permission system.
+ *
+ * Also sends a WebSocket message to the frontend so the permission modal auto-dismisses
+ * when approval comes from Telegram.
+ */
+import {
+  getRawBotToken,
+  isEnabled,
+  answerCallbackQuery,
+  editMessageText,
+  editMessageReplyMarkup,
+} from "./telegram-sender.js";
+
+let polling = false;
+let pollAbort = null;
+let lastUpdateId = 0;
+
+// Registry: approvalId → { resolve, timer, toolInput, telegramMessageId, ws }
+// Shared reference set by ws-handler via registerApprovalBridge
+let pendingApprovalsRef = null;
+let broadcastToSessionRef = null;
+
+/**
+ * Register the bridge so the poller can resolve pending approvals and notify the frontend.
+ * @param {Map} pendingApprovals - The Map from ws-handler
+ * @param {Function} broadcastToSession - fn(sessionId, payload) to send WS msg to frontend
+ */
+export function registerApprovalBridge(pendingApprovals, broadcastToSession) {
+  pendingApprovalsRef = pendingApprovals;
+  broadcastToSessionRef = broadcastToSession;
+}
+
+/**
+ * Track a Telegram message ID for a given approval so we can edit it later.
+ */
+const approvalMessages = new Map(); // approvalId → { messageId, toolName }
+
+export function trackApprovalMessage(approvalId, messageId, toolName) {
+  approvalMessages.set(approvalId, { messageId, toolName });
+}
+
+export function removeApprovalMessage(approvalId) {
+  const entry = approvalMessages.get(approvalId);
+  approvalMessages.delete(approvalId);
+  return entry;
+}
+
+/**
+ * Mark a Telegram permission message as resolved (from web UI).
+ * Called when the user approves/denies via the web modal.
+ */
+export async function markTelegramMessageResolved(approvalId, behavior) {
+  const entry = removeApprovalMessage(approvalId);
+  if (!entry) return;
+
+  const icon = behavior === "allow" ? "\u{2705}" : "\u{274C}";
+  const label = behavior === "allow" ? "Approved" : "Denied";
+
+  await editMessageText(
+    entry.messageId,
+    `${icon} <b>${label} via Web</b>\n<s>${entry.toolName}</s>`
+  );
+}
+
+// ── Polling loop ──
+
+async function pollOnce() {
+  const token = getRawBotToken();
+  if (!token) return;
+
+  pollAbort = new AbortController();
+
+  try {
+    const res = await fetch(
+      `https://api.telegram.org/bot${token}/getUpdates`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          offset: lastUpdateId + 1,
+          timeout: 30,
+          allowed_updates: ["callback_query"],
+        }),
+        signal: pollAbort.signal,
+      }
+    );
+
+    if (!res.ok) {
+      console.error("Telegram poll error:", res.status, await res.text());
+      return;
+    }
+
+    const data = await res.json();
+    if (!data.ok || !data.result?.length) return;
+
+    for (const update of data.result) {
+      lastUpdateId = Math.max(lastUpdateId, update.update_id);
+      if (update.callback_query) {
+        await handleCallback(update.callback_query);
+      }
+    }
+  } catch (err) {
+    if (err.name === "AbortError") return;
+    console.error("Telegram poll error:", err.message);
+  }
+}
+
+async function handleCallback(cb) {
+  const data = cb.data || "";
+  const [action, approvalId] = data.split(":");
+
+  if (!approvalId || (action !== "approve" && action !== "deny")) {
+    await answerCallbackQuery(cb.id, "Unknown action");
+    return;
+  }
+
+  const behavior = action === "approve" ? "allow" : "deny";
+  const icon = action === "approve" ? "\u{2705}" : "\u{274C}";
+  const label = action === "approve" ? "Approved" : "Denied";
+
+  // Try to resolve the pending approval
+  let resolved = false;
+
+  if (pendingApprovalsRef) {
+    const pending = pendingApprovalsRef.get(approvalId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      pendingApprovalsRef.delete(approvalId);
+
+      if (behavior === "allow") {
+        pending.resolve({ behavior: "allow", updatedInput: pending.toolInput });
+      } else {
+        pending.resolve({ behavior: "deny", message: "Denied via Telegram" });
+      }
+
+      resolved = true;
+
+      // Notify the frontend to dismiss the permission modal
+      if (pending.ws && pending.ws.readyState === 1) {
+        pending.ws.send(JSON.stringify({
+          type: "permission_response_external",
+          id: approvalId,
+          behavior,
+          source: "telegram",
+        }));
+      }
+    }
+  }
+
+  // Update the Telegram message
+  const entry = removeApprovalMessage(approvalId);
+  if (entry) {
+    await editMessageText(
+      entry.messageId,
+      `${icon} <b>${label} via Telegram</b>\n<s>${entry.toolName || "Tool"}</s>`
+    );
+  } else if (cb.message?.message_id) {
+    // Fallback: remove buttons even if we lost track
+    await editMessageReplyMarkup(cb.message.message_id);
+  }
+
+  // Answer the callback to dismiss the loading spinner
+  await answerCallbackQuery(cb.id, resolved ? `${label}!` : "Already resolved");
+}
+
+// ── Lifecycle ──
+
+export function startTelegramPoller() {
+  if (polling) return;
+  if (!isEnabled()) {
+    console.log("Telegram poller: disabled (not configured)");
+    return;
+  }
+
+  polling = true;
+  console.log("Telegram poller: started");
+
+  (async () => {
+    while (polling) {
+      await pollOnce();
+      // Small delay between polls to avoid hammering on errors
+      if (polling) await new Promise((r) => setTimeout(r, 500));
+    }
+  })();
+}
+
+export function stopTelegramPoller() {
+  polling = false;
+  if (pollAbort) {
+    pollAbort.abort();
+    pollAbort = null;
+  }
+  console.log("Telegram poller: stopped");
+}
+
+/**
+ * Restart the poller (e.g., after config change).
+ */
+export function restartTelegramPoller() {
+  stopTelegramPoller();
+  // Small delay to let the old poll abort cleanly
+  setTimeout(() => startTelegramPoller(), 1000);
+}