claude-telegram-bot 0.3.23 → 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/ctb.mjs

@@ -151,8 +151,8 @@ async function main() {
 
 async function summarizeSession(sid, lang) {
   const langInstruction = lang && lang.startsWith("ko")
-    ? "---ctb:start--- 마커 이후에 이 터미널 세션에서 한 작업을 한국어로 짧은 구문(10단어 이내)으로 요약해줘. 마크다운 없이 텍스트만. 마커 이후 중요한 작업이 없으면 정확히 이렇게만 답해: SKIP"
-    : "After the ---ctb:start--- marker in this conversation, what was accomplished in this terminal session? One short phrase, 10 words max, plain text. If nothing significant after the marker, reply: SKIP";
+    ? "방금 로컬 터미널 코딩 세션이 끝났어. 이 대화에서 가장 최근에 나눈 내용(이 메시지 직전까지)을 바탕으로, 그 세션에서 무엇을 했는지 한국어로 짧은 구문(10단어 이내)으로 요약해줘. 마크다운 없이 텍스트만. 중요한 작업이 없었으면 정확히 이렇게만 답해: SKIP"
+    : "A local terminal coding session just ended. Based on the most recent exchanges in this conversation (just before this message), summarize in one short phrase (10 words max) what was accomplished. Plain text only. If nothing significant was done, reply exactly: SKIP";
   return new Promise((resolve) => {
     const child = spawn("claude", [
       "--resume", sid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-telegram-bot",
-  "version": "0.3.23",
+  "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": {