claude-telegram-bot 0.3.24 → 0.3.27

package/bot.mjs

@@ -135,6 +135,7 @@ const STR = {
       "• Just send a message and Claude works in the project.\n" +
       "• /new — reset conversation context (new session)\n" +
       "• /compact — compress context to free up space (keeps the session)\n" +
+      "• /ollama — toggle Ollama chat mode (bypass Claude, use local LLM)\n" +
       "• /stop — stop the current task · /stop --reset to also roll back the session\n" +
       "• /cron — list tasks · /cron add <natural language> to add · /cron rm <id> to remove\n" +
       "• /remember <text> — save to persistent memory (survives /new)\n" +
@@ -151,6 +152,8 @@ const STR = {
     compactNoSession: "No active session to compact. Just send a message to start one.",
     testFallbackDisabled: "⚠️ Ollama fallback is not enabled. Set `\"ollamaFallback\": true` in config.json.",
     testFallbackFail: (m) => `⚠️ Ollama test failed: ${m}`,
+    ollamaOn: "🌙 Ollama mode on. Messages will now go to Ollama. Your Claude session is preserved.",
+    ollamaOff: "✅ Ollama mode off. Back to Claude.",
     busy: "⏳ A previous task is still running. Please try again when it finishes.",
     queued: (n) => `⏳ Queued (#${n}). Will run when the current task finishes.`,
     stopOk: "🛑 Task stopped.",
@@ -204,11 +207,11 @@ const STR = {
     remembered: "💾 Saved to memory.",
     rememberUsage: "Usage: /remember <text to remember>",
     memoryUsage: "Usage: /memory · /memory clear",
-    reserveHint: "\n\nTo retry when the limit resets, send `/reserve` (or `/reserve <different message>`).",
-    reserveOk: (time) => `⏰ Retry scheduled for ${time}. Cancel with /reserve rm.`,
-    reserveRm: "🚫 Scheduled retry canceled.",
+    rateLimitQueued: (n, time) => `⏳ Queued (#${n}). Will retry at ${time}. /reserve rm to cancel.`,
+    reserveStatus: (n, time) => `⏳ ${n} message(s) queued. Retrying at ${time}. /reserve rm to cancel.`,
+    reserveAuto: (time) => `⏰ Auto-retry scheduled for ${time}. Cancel with /reserve rm.`,
+    reserveRm: "🚫 Queue cleared. No retry scheduled.",
     reserveNone: "No retry is scheduled.",
-    reserveNoLimit: "No recent usage limit error. Send a message first.",
     contextTooLong: "⚠️ Prompt is too long. Use `/compact` to compress context, or `/new` to start fresh.",
   },
   ko: {
@@ -217,6 +220,7 @@ const STR = {
       "• 그냥 메시지를 보내면 Claude가 프로젝트에서 작업합니다.\n" +
       "• /new — 대화 맥락 초기화 (새 세션)\n" +
       "• /compact — 컨텍스트 압축 (세션 유지, 공간 확보)\n" +
+      "• /ollama — Ollama 채팅 모드 토글 (Claude 우회, 로컬 LLM 사용)\n" +
       "• /stop — 진행 중인 작업 중단 · /stop --reset 으로 세션도 되돌리기\n" +
       "• /cron — 예약 작업 보기 · /cron add <자연어>로 추가 · /cron rm <번호>로 삭제\n" +
       "• /remember <내용> — 퍼시스턴트 메모리에 저장 (/new 로 초기화해도 유지)\n" +
@@ -280,17 +284,19 @@ const STR = {
     remembered: "💾 메모리에 저장했습니다.",
     rememberUsage: "사용법: /remember <기억할 내용>",
     memoryUsage: "사용법: /memory · /memory clear",
-    reserveHint: "\n\n리셋 후 재시도하려면 `/reserve` (또는 `/reserve <다른 메시지>`)를 입력하세요.",
-    reserveOk: (time) => `⏰ ${time}에 재시도 예약됨. 취소: /reserve rm`,
-    reserveRm: "🚫 예약된 재시도를 취소했습니다.",
+    rateLimitQueued: (n, time) => `⏳ 대기열에 추가됨 (${n}번째). ${time}에 자동 재시도. 취소: /reserve rm`,
+    reserveStatus: (n, time) => `⏳ 대기 중인 메시지 ${n}개. ${time}에 재시도 예약됨. 취소: /reserve rm`,
+    reserveAuto: (time) => `⏰ ${time}에 자동 재시도 예약됨. 취소: /reserve rm`,
+    reserveRm: "🚫 대기열을 비웠습니다. 예약 취소됨.",
     reserveNone: "예약된 재시도가 없습니다.",
-    reserveNoLimit: "최근 한도 초과 에러가 없습니다. 먼저 메시지를 보내주세요.",
     compactOk: "🗜️ 컨텍스트를 압축했습니다. 대화가 요약본으로 이어집니다.",
     compactFail: (m) => `⚠️ compact 실패: ${m}`,
     compactNoSession: "압축할 활성 세션이 없습니다. 메시지를 보내 세션을 시작하세요.",
     contextTooLong: "⚠️ 프롬프트가 너무 깁니다. `/compact` 로 컨텍스트를 압축하거나 `/new` 로 새 세션을 시작하세요.",
     testFallbackDisabled: "⚠️ Ollama 폴백이 비활성화 상태입니다. config.json에 `\"ollamaFallback\": true` 를 추가하세요.",
     testFallbackFail: (m) => `⚠️ Ollama 테스트 실패: ${m}`,
+    ollamaOn: "🌙 Ollama 모드 켜짐. 이제 메시지는 Ollama로 처리됩니다. Claude 세션은 유지됩니다.",
+    ollamaOff: "✅ Ollama 모드 꺼짐. 다시 Claude로 처리합니다.",
   },
 };
 const t = (l, key, ...a) => {
@@ -306,6 +312,7 @@ const COMMANDS = {
   en: [
     { command: "new", description: "Reset context (new session)" },
     { command: "compact", description: "Compress context to free up space (keeps session)" },
+    { command: "ollama", description: "Toggle Ollama chat mode (bypass Claude, use local LLM)" },
     { command: "stop", description: "Stop the current task (--reset to roll back session)" },
     { command: "remember", description: "Save to persistent memory (survives /new)" },
     { command: "memory", description: "View or clear persistent memory" },
@@ -320,6 +327,7 @@ const COMMANDS = {
   ko: [
     { command: "new", description: "대화 맥락 초기화 (새 세션)" },
     { command: "compact", description: "컨텍스트 압축 (세션 유지, 공간 확보)" },
+    { command: "ollama", description: "Ollama 채팅 모드 토글 (Claude 우회, 로컬 LLM)" },
     { command: "stop", description: "작업 중단 (--reset 으로 세션 되돌리기)" },
     { command: "remember", description: "퍼시스턴트 메모리에 저장 (/new 후에도 유지)" },
     { command: "memory", description: "메모리 보기·삭제" },
@@ -527,8 +535,8 @@ function parseResetTime(raw) {
   if (inMin) return new Date(Date.now() + parseInt(inMin[1]) * 60000);
   const inHour = raw.match(/in (\d+)\s*hour/i);
   if (inHour) return new Date(Date.now() + parseInt(inHour[1]) * 3600000);
-  // "resets at HH:MM" or "available at HH:MM"
-  const atTime = raw.match(/(?:resets?|reset|available|retry)\s+at\s+(\d{1,2}):(\d{2})(?:\s*(AM|PM))?/i);
+  // "resets at HH:MM" / "resets HH:MM" / "available at HH:MM"
+  const atTime = raw.match(/(?:resets?|available|retry)(?:\s+at)?\s+(\d{1,2}):(\d{2})\s*(AM|PM)?/i);
   if (atTime) {
     let h = parseInt(atTime[1]);
     const m = parseInt(atTime[2]);
@@ -544,7 +552,7 @@ function isFallbackError(raw, code) {
   const t = (raw || "").toLowerCase();
   return t.includes("credit") || t.includes("balance") || t.includes("billing") || t.includes("payment")
     || t.includes("rate_limit") || t.includes("rate limit") || t.includes("too many requests") || code === 429
-    || t.includes("usage limit") || t.includes("monthly limit")
+    || t.includes("usage limit") || t.includes("monthly limit") || t.includes("session limit")
     || t.includes("overloaded") || code === 529;
 }
 
@@ -553,7 +561,7 @@ function classifyClaudeError(raw, code) {
   if (t.includes("credit") || t.includes("balance") || t.includes("billing") || t.includes("payment"))
     return "💳 API 크레딧이 부족합니다. console.anthropic.com 에서 충전해주세요.";
   if (t.includes("rate_limit") || t.includes("rate limit") || t.includes("too many requests") || code === 429
-      || t.includes("usage limit") || t.includes("monthly limit"))
+      || t.includes("usage limit") || t.includes("monthly limit") || t.includes("session limit"))
     return "⏱️ 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.";
   if (t.includes("overloaded") || code === 529)
     return "🔄 Claude 서버가 일시적으로 과부하 상태입니다. 잠시 후 다시 시도해주세요.";
@@ -626,20 +634,25 @@ function runClaude(prompt, sessionId, opts = {}) {
 }
 
 // ── Ollama 폴백 실행 ──────────────────────────────────────────────────────
-async function runOllama(prompt, lang = "en") {
-  const header = lang === "ko"
+async function runOllama(prompt, lang = "en", opts = {}) {
+  const header = opts.noHeader ? "" : (lang === "ko"
     ? "🌙 Claude가 잠시 쉬고 있어요. 제가 대신 도와드릴게요. (세션은 이어지지 않아요)\n\n"
-    : "🌙 Claude is resting right now. I'll help in the meantime. (Session won't continue)\n\n";
+    : "🌙 Claude is resting right now. I'll help in the meantime. (Session won't continue)\n\n");
   const model = cfg.ollamaModel || "phi3:mini";
-  const r = await fetch("http://localhost:11434/api/generate", {
+  const brevity = "This reply is delivered over Telegram. Be concise — short paragraphs and lists, no filler intro/summary. Reply in the user's language.";
+  const systemParts = [cfg.persona, brevity].filter(Boolean);
+  const messages = [];
+  if (systemParts.length) messages.push({ role: "system", content: systemParts.join("\n\n") });
+  messages.push({ role: "user", content: prompt });
+  const r = await fetch("http://localhost:11434/api/chat", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ model, prompt, stream: false }),
+    body: JSON.stringify({ model, messages, stream: false }),
     signal: AbortSignal.timeout(60_000),
   });
   if (!r.ok) return { ok: false, text: `Ollama HTTP ${r.status}` };
   const j = await r.json();
-  const text = (j.response || "").trim();
+  const text = (j.message?.content || "").trim();
   return text ? { ok: true, text: header + text } : { ok: false, text: "no response" };
 }
 
@@ -923,8 +936,8 @@ let currentChild = null;    // 실행 중인 claude child process (/stop 용)
 let currentTyping = null;   // 타이핑 인터벌 (/stop 시 정리용)
 let prevSessionId;          // /stop --reset 복원 대상
 let stopping = false;       // /stop 처리 중 오류 메시지 억제 플래그
-let rateLimitState = null;  // 마지막 레이트 리밋 { prompt, resetAt } — /reserve 용
-let pendingRetry = null;    // /reserve 로 예약된 재시도 { timer, resetAt }
+let rateLimitUntil = null;  // 레이트 리밋 활성 시 리셋 Date — 이 시간까지 메시지를 큐에 쌓음
+let rateLimitTimer = null;  // 리셋 시간에 큐를 드레인하는 타이머
 
 async function handle(msg) {
   const chatId = msg.chat?.id;
@@ -944,6 +957,14 @@ async function handle(msg) {
     return;
   }
 
+  // 레이트리밋 활성 중: 일반 메시지는 큐에 추가, 명령어는 통과
+  if (rateLimitUntil && Date.now() < rateLimitUntil && !text.startsWith("/")) {
+    msgQueue.push({ msg, receivedAt: Date.now() });
+    const timeStr = rateLimitUntil.toLocaleTimeString(l === "ko" ? "ko-KR" : "en-US", { hour: "2-digit", minute: "2-digit" });
+    await send(chatId, t(l, "rateLimitQueued", msgQueue.length, timeStr));
+    return;
+  }
+
   // 명령어
   if (text === "/start" || text === "/help") {
     await send(chatId, t(l, "help"));
@@ -1027,6 +1048,13 @@ async function handle(msg) {
     }
     return;
   }
+  if (text === "/ollama") {
+    if (!cfg.ollamaFallback) { await send(chatId, t(l, "testFallbackDisabled")); return; }
+    state.ollamaMode = !state.ollamaMode;
+    saveState(state);
+    await send(chatId, t(l, state.ollamaMode ? "ollamaOn" : "ollamaOff"));
+    return;
+  }
   if (text === "/testfallback") {
     if (!cfg.ollamaFallback) { await send(chatId, t(l, "testFallbackDisabled")); return; }
     await send(chatId, "🧪 Ollama 연결 테스트 중…");
@@ -1083,27 +1111,16 @@ async function handle(msg) {
   if (text === "/reserve" || text.startsWith("/reserve ")) {
     const arg = text.slice(8).trim();
     if (arg === "rm") {
-      if (!pendingRetry) { await send(chatId, t(l, "reserveNone")); return; }
-      clearTimeout(pendingRetry.timer); pendingRetry = null;
+      if (!rateLimitUntil && !rateLimitTimer) { await send(chatId, t(l, "reserveNone")); return; }
+      if (rateLimitTimer) { clearTimeout(rateLimitTimer); rateLimitTimer = null; }
+      rateLimitUntil = null;
+      msgQueue.length = 0;
       await send(chatId, t(l, "reserveRm"));
       return;
     }
-    if (!rateLimitState) { await send(chatId, t(l, "reserveNoLimit")); return; }
-    const { resetAt } = rateLimitState;
-    const reservePrompt = arg || rateLimitState.prompt;
-    if (pendingRetry) clearTimeout(pendingRetry.timer);
-    const capturedPrompt = reservePrompt;
-    const capturedMsg = msg;
-    const delay = Math.max(resetAt - Date.now(), 1000);
-    pendingRetry = {
-      resetAt,
-      timer: setTimeout(() => {
-        pendingRetry = null;
-        handle({ ...capturedMsg, text: capturedPrompt, caption: undefined });
-      }, delay),
-    };
-    const timeStr = resetAt.toLocaleTimeString(l === "ko" ? "ko-KR" : "en-US", { hour: "2-digit", minute: "2-digit" });
-    await send(chatId, t(l, "reserveOk", timeStr));
+    if (!rateLimitUntil) { await send(chatId, t(l, "reserveNone")); return; }
+    const timeStr = rateLimitUntil.toLocaleTimeString(l === "ko" ? "ko-KR" : "en-US", { hour: "2-digit", minute: "2-digit" });
+    await send(chatId, t(l, "reserveStatus", msgQueue.length, timeStr));
     return;
   }
 
@@ -1152,6 +1169,16 @@ async function handle(msg) {
     }
     const meta = buildMsgMeta(msg);
     if (meta) prompt = prompt ? `${meta}\n\n${prompt}` : meta;
+    if (state.ollamaMode) {
+      try {
+        const oRes = await runOllama(prompt, l, { noHeader: true });
+        if (oRes.ok) await send(chatId, oRes.text);
+        else await send(chatId, t(l, "testFallbackFail", oRes.text));
+      } catch (e) {
+        await send(chatId, t(l, "testFallbackFail", e.message));
+      }
+      return;
+    }
     prevSessionId = state.sessionId; // /stop --reset 복원 대상 저장
     const res = await runClaude(prompt, state.sessionId, { modelHint: true, trackChild: true, injectMemory: true });
     if (res.sessionId) {
@@ -1160,9 +1187,6 @@ async function handle(msg) {
     }
     const secs = Math.round((Date.now() - started) / 1000);
     if (!res.ok) {
-      // 레이트 리밋이고 리셋 시간을 알면 /reserve 힌트 추가
-      const hint = res.resetAt ? t(l, "reserveHint") : "";
-      rateLimitState = res.resetAt ? { prompt, resetAt: res.resetAt } : null;
       // Ollama 폴백: 레이트리밋·크레딧 에러이고 ollamaFallback 켜져 있으면 Ollama로 재시도
       if (cfg.ollamaFallback && res.canFallback && !stopping) {
         try {
@@ -1170,10 +1194,23 @@ async function handle(msg) {
           if (oRes.ok) { await send(chatId, oRes.text); return; }
         } catch {}
       }
-      const errMsg = res.text === "contextTooLong" ? t(l, "contextTooLong") : `⚠️ ${res.text}${hint}`;
+      // 리셋 시간을 알면 현재 메시지를 큐 앞에 다시 넣고 타이머 설정
+      let autoRetryMsg = "";
+      if (res.resetAt && !stopping) {
+        msgQueue.unshift({ msg, receivedAt: Date.now() });
+        rateLimitUntil = res.resetAt;
+        if (rateLimitTimer) clearTimeout(rateLimitTimer);
+        rateLimitTimer = setTimeout(() => {
+          rateLimitTimer = null;
+          rateLimitUntil = null;
+          if (msgQueue.length > 0) handle(drainQueue());
+        }, Math.max(res.resetAt - Date.now(), 1000));
+        const timeStr = res.resetAt.toLocaleTimeString(l === "ko" ? "ko-KR" : "en-US", { hour: "2-digit", minute: "2-digit" });
+        autoRetryMsg = "\n\n" + t(l, "reserveAuto", timeStr);
+      }
+      const errMsg = res.text === "contextTooLong" ? t(l, "contextTooLong") : `⚠️ ${res.text}${autoRetryMsg}`;
       if (!stopping) await send(chatId, errMsg);
     } else {
-      rateLimitState = null;
       const footer = `\n\n— ${secs}s${res.cost ? ` · $${res.cost.toFixed(4)}` : ""}`;
       if (!stopping) await send(chatId, res.text + footer);
     }
@@ -1184,7 +1221,7 @@ async function handle(msg) {
     currentTyping = null;
     stopping = false;
     busy = false;
-    if (msgQueue.length > 0) setImmediate(() => handle(drainQueue()));
+    if (msgQueue.length > 0 && !rateLimitUntil) setImmediate(() => handle(drainQueue()));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-telegram-bot",
-  "version": "0.3.24",
+  "version": "0.3.27",
   "description": "Drive Claude Code from Telegram — messages run headless `claude -p` in a project dir and replies come back to the chat. Zero dependencies.",
   "type": "module",
   "bin": {