claude-telegram-bot 0.2.6 → 0.2.7

package/README.ko.md

@@ -2,6 +2,10 @@
 
 **한국어** · [English](./README.md)
 
+[![npm version](https://img.shields.io/npm/v/claude-telegram-bot.svg)](https://www.npmjs.com/package/claude-telegram-bot)
+[![npm downloads](https://img.shields.io/npm/dm/claude-telegram-bot.svg)](https://www.npmjs.com/package/claude-telegram-bot)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 텔레그램으로 메시지를 보내면, 집이나 서버에 켜둔 Claude Code가 작업하고 결과를 다시 텔레그램으로 돌려주는 봇입니다.
 
 ```

package/README.md

@@ -2,6 +2,10 @@
 
 [한국어](./README.ko.md) · **English**
 
+[![npm version](https://img.shields.io/npm/v/claude-telegram-bot.svg)](https://www.npmjs.com/package/claude-telegram-bot)
+[![npm downloads](https://img.shields.io/npm/dm/claude-telegram-bot.svg)](https://www.npmjs.com/package/claude-telegram-bot)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 **A zero-dependency, single-file, daemonized Claude Code bot — no Bun, no Python, no open session.**
 
 A tiny bridge that takes your Telegram messages, runs `claude -p` (Claude Code headless mode)

package/bot.mjs

@@ -14,7 +14,7 @@
 // 자동 판별하고, cfg.lang 을 주면 그 언어로 고정함. 콘솔/CLI 출력은 영어 단일.
 
 import { basename, dirname, join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 
 import dns from "node:dns";
 import { fileURLToPath } from "node:url";
@@ -134,6 +134,7 @@ const STR = {
       `\nWorking dir: ${cfg.projectDir}\nPermission mode: ${cfg.permissionMode}`,
     newSession: "🆕 Started a new conversation (previous context cleared).",
     busy: "⏳ A previous task is still running. Please try again when it finishes.",
+    localBusy: "💻 A local `ctb claude` session is active. Send a message when it's done.",
     needChatId: (id) => `Add this chat ID to "allowedChatId" in config.json:\n${id}`,
     cronEmpty:
       "No scheduled tasks yet.\nAdd one in plain language, e.g. `/cron add summarize open issues every weekday at 9am`.",
@@ -189,6 +190,7 @@ const STR = {
       `\n작업 폴더: ${cfg.projectDir}\n권한 모드: ${cfg.permissionMode}`,
     newSession: "🆕 새 대화를 시작합니다 (이전 맥락 초기화).",
     busy: "⏳ 이전 작업이 아직 진행 중입니다. 끝나면 다시 보내주세요.",
+    localBusy: "💻 로컬 `ctb claude` 세션이 활성화되어 있습니다. 종료 후 메시지를 보내주세요.",
     needChatId: (id) => `이 채팅 ID를 config.json 의 allowedChatId 에 넣으세요:\n${id}`,
     cronEmpty:
       "등록된 예약 작업이 없습니다.\n`/cron add 매일 아침 9시에 …` 처럼 자연어로 추가해 보세요.",
@@ -237,7 +239,7 @@ const t = (l, key, ...a) => {
 };
 
 // /model 에서 보여줄 추천 별칭(claude CLI 가 별칭·전체 모델 ID 모두 허용).
-const MODEL_SUGGESTIONS = ["opus", "sonnet", "haiku"];
+const MODEL_SUGGESTIONS = ["fable", "opus", "sonnet", "haiku"];
 
 // /(슬래시) 자동완성 메뉴용 명령 목록 (언어별). setMyCommands 로 등록.
 const COMMANDS = {
@@ -261,6 +263,23 @@ const COMMANDS = {
   ],
 };
 
+// ── 로컬 세션 lock ────────────────────────────────────────────────────────
+// ctb claude 실행 시 .claude-bot/local.lock (PID) 을 생성하고 종료 시 삭제.
+// 봇은 claude 실행 전 이 파일을 확인해 동시 실행을 방지한다.
+// PID 가 이미 종료된 경우(stale lock) 자동 제거 후 진행.
+const LOCAL_LOCK_PATH = join(BOT_DIR, "local.lock");
+function checkLocalLock() {
+  if (!existsSync(LOCAL_LOCK_PATH)) return false;
+  try {
+    const pid = parseInt(readFileSync(LOCAL_LOCK_PATH, "utf8"), 10);
+    process.kill(pid, 0); // throws if process is dead
+    return true; // lock is valid
+  } catch {
+    try { unlinkSync(LOCAL_LOCK_PATH); } catch {} // stale — remove
+    return false;
+  }
+}
+
 // ── 상태 (세션 이어가기용) ────────────────────────────────────────────────
 function loadState() {
   // 새 경로(.claude-bot/) 우선, 없으면 구버전 루트 경로로 폴백(이주 실패 시 안전망).
@@ -395,7 +414,7 @@ function runClaude(prompt, sessionId, opts = {}) {
       "This reply is delivered over Telegram. Be concise — short paragraphs and lists, no filler intro/summary, avoid large tables. Reply in the user's language.";
     // opts.modelHint: 현재 모델을 주입 → 답변 끝에 상위 모델 권유 제안(판단은 Claude 본인)
     const modelHint = opts.modelHint
-      ? `Current model: ${model || "claude (default)"}. Model tiers (low→high): haiku → sonnet → opus. If this question seems to require more capability than the current model, append one short line at the very end of your reply: 💡 \`/model sonnet\` (or \`/model opus\`) for a stronger answer. Omit the suggestion for simple questions.`
+      ? `Current model: ${model || "claude (default)"}. Model tiers (low→high): haiku → sonnet → opus → fable. If this question seems to require more capability than the current model, append one short line at the very end of your reply: 💡 \`/model sonnet\` (or \`/model opus\`, \`/model fable\`) for a stronger answer. Omit the suggestion for simple questions.`
       : null;
     // 페르소나(cfg.persona) + 간결 지침 + 모델 힌트를 함께 주입 → 멀티 봇(역할별) 운영용
     const appendSys = [cfg.persona, brevity, modelHint].filter(Boolean).join("\n\n");
@@ -502,7 +521,7 @@ let schedule = buildSchedule();
 // 예약 작업은 사용자 대화 맥락을 오염시키지 않도록 항상 새 세션으로 독립 실행하고,
 // 결과를 allowedChatId 로 보낸다. busy 락을 공유해 사용자 요청과 직렬화됨.
 async function runScheduled(job) {
-  if (busy) {
+  if (busy || checkLocalLock()) {
     console.warn(`Skipped scheduled job (busy): ${job.cron} — ${String(job.prompt).slice(0, 40)}`);
     return;
   }
@@ -769,6 +788,10 @@ async function handle(msg) {
     await send(chatId, t(l, "busy"));
     return;
   }
+  if (checkLocalLock()) {
+    await send(chatId, t(l, "localBusy"));
+    return;
+  }
   busy = true;
   await tg("sendChatAction", { chat_id: chatId, action: "typing" });
   const started = Date.now();

package/ctb.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+// ctb — short-form CLI for claude-telegram-bot
+//
+// ctb [config.json] [...claude args]   Run Claude, resuming the shared Telegram session
+// ctb bot [config.json]                Start the Telegram bot daemon (delegates to bot.mjs)
+// ctb init [dir]                       Create a config.json template
+// ctb --help | --version
+//
+// config.json is optional. A bare name like "planner.json" resolves relative to the
+// package directory (where bot configs typically live alongside bot.mjs).
+// Absolute or explicitly relative paths (/ or ./) resolve as-is.
+//
+// While Claude runs, .claude-bot/local.lock (PID) is created so the bot defers
+// incoming Telegram messages until the local session ends.
+
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const a = args[0];
+
+const VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(join(HERE, "package.json"), "utf8")).version;
+  } catch {
+    return "?";
+  }
+})();
+
+function runBot(botArgs) {
+  const child = spawn(process.execPath, [join(HERE, "bot.mjs"), ...botArgs], {
+    stdio: "inherit",
+  });
+  child.on("close", (code) => process.exit(code ?? 0));
+}
+
+function resolveConfig(arg) {
+  if (!arg) return process.env.BOT_CONFIG || join(HERE, "config.json");
+  // Absolute or explicitly relative path → use as-is
+  if (arg.startsWith("/") || arg.startsWith("./") || arg.startsWith("../"))
+    return arg;
+  // Bare name (e.g. "planner.json") → relative to package dir
+  return join(HERE, arg);
+}
+
+function main() {
+  if (a === "-h" || a === "--help") {
+    console.log(
+      `ctb v${VERSION} — claude-telegram-bot short CLI\n\n` +
+      `Usage:\n` +
+      `  ctb [config.json] [...args]   Resume Telegram session and run Claude\n` +
+      `  ctb bot [config.json]         Start the Telegram bot daemon\n` +
+      `  ctb init [dir]                Create a config.json template\n` +
+      `  ctb --help | --version\n\n` +
+      `config.json defaults to $BOT_CONFIG or the package's own config.json.\n` +
+      `A bare name like "planner.json" resolves relative to the package directory.\n\n` +
+      `Examples:\n` +
+      `  ctb                           Interactive Claude, continuing the Telegram session\n` +
+      `  ctb -p "what did we do?"      Headless Claude with session context\n` +
+      `  ctb planner.json              Resume planner persona session interactively\n` +
+      `  ctb planner.json -p "..."     Headless with planner session\n` +
+      `  ctb bot                       Start the bot with default config\n` +
+      `  ctb bot planner.json          Start the bot with planner config`,
+    );
+    process.exit(0);
+  }
+
+  if (a === "-v" || a === "--version") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  if (a === "init") {
+    runBot(args);
+    return;
+  }
+
+  if (a === "bot") {
+    runBot(args.slice(1));
+    return;
+  }
+
+  // Run Claude, resuming the bot's session
+  const looksLikeConfig = a && a.endsWith(".json");
+  const configPath = resolveConfig(looksLikeConfig ? a : undefined);
+  const claudeArgs = looksLikeConfig ? args.slice(1) : args;
+
+  const dataDir = dirname(configPath);
+  const botDir = join(dataDir, ".claude-bot");
+  const stateBase = basename(configPath, ".json");
+  const stateFile = stateBase === "config" ? "state.json" : `${stateBase}.state.json`;
+  const statePath = join(botDir, stateFile);
+  const lockPath = join(botDir, "local.lock");
+
+  mkdirSync(botDir, { recursive: true });
+  writeFileSync(lockPath, String(process.pid));
+  const cleanup = () => { try { unlinkSync(lockPath); } catch {} };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => { cleanup(); process.exit(130); });
+  process.on("SIGTERM", () => { cleanup(); process.exit(143); });
+
+  let sessionId;
+  try {
+    sessionId = JSON.parse(readFileSync(statePath, "utf8")).sessionId;
+  } catch {}
+
+  const finalArgs = sessionId ? ["--resume", sessionId, ...claudeArgs] : claudeArgs;
+  if (sessionId) process.stderr.write(`Resuming session: ${sessionId}\n`);
+
+  const child = spawn("claude", finalArgs, { stdio: "inherit" });
+  child.on("close", (code) => process.exit(code ?? 0));
+}
+
+main();

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "claude-telegram-bot",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "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": {
-    "claude-telegram-bot": "bot.mjs"
+    "claude-telegram-bot": "bot.mjs",
+    "ctb": "ctb.mjs"
+  },
+  "exports": {
+    "./session.mjs": "./session.mjs"
   },
   "files": [
     "bot.mjs",
+    "ctb.mjs",
+    "session.mjs",
     "config.example.json",
     "com.claudebot.example.plist"
   ],

package/session.mjs

@@ -0,0 +1,129 @@
+// Standalone Claude session manager — zero-dependency (Node 18+ built-ins only).
+// Maintains conversational context across calls by persisting --resume session IDs.
+//
+// Usage:
+//   import { createSession } from 'claude-telegram-bot/session.mjs'
+//
+//   const session = createSession({ projectDir: '/my/project' })
+//   const r1 = await session.run('리팩토링 계획 세워줘')
+//   const r2 = await session.run('그걸 실제로 실행해줘')  // r1 컨텍스트 유지
+//   session.reset()                                       // 세션 초기화
+//
+// statePath defaults to <projectDir>/.claude-bot/session.json.
+// To share state with a running bot, pass the bot's state path explicitly:
+//   statePath: '/path/to/bot-config-dir/.claude-bot/state.json'
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { spawn } from 'node:child_process'
+
+function loadState(statePath) {
+  try {
+    return JSON.parse(readFileSync(statePath, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function saveState(statePath, state) {
+  try {
+    mkdirSync(dirname(statePath), { recursive: true })
+    writeFileSync(statePath, JSON.stringify(state, null, 2))
+  } catch (e) {
+    console.error('Failed to save session state:', e.message)
+  }
+}
+
+function _runClaude(prompt, sessionId, opts) {
+  return new Promise((resolve) => {
+    const {
+      projectDir = process.cwd(),
+      permissionMode = 'acceptEdits',
+      model,
+      claudeBin = 'claude',
+      appendSystemPrompt,
+      env = {},
+    } = opts
+
+    const args = [
+      '-p', prompt,
+      '--output-format', 'json',
+      '--permission-mode', permissionMode,
+    ]
+    if (model) args.push('--model', model)
+    if (appendSystemPrompt) args.push('--append-system-prompt', appendSystemPrompt)
+    if (sessionId) args.push('--resume', sessionId)
+
+    const child = spawn(claudeBin, args, {
+      cwd: projectDir,
+      env: { ...process.env, ...env },
+    })
+
+    let out = '', err = ''
+    child.stdout.on('data', (d) => { out += d })
+    child.stderr.on('data', (d) => { err += d })
+    child.on('error', (e) => resolve({ ok: false, text: `Failed to start claude: ${e.message}` }))
+    child.on('close', (code) => {
+      try {
+        const j = JSON.parse(out)
+        resolve({
+          ok: !j.is_error,
+          text: j.result ?? '(empty response)',
+          sessionId: j.session_id,
+          cost: j.total_cost_usd,
+        })
+      } catch {
+        resolve({
+          ok: false,
+          text: `Execution error (exit ${code}):\n${(err || out || 'no output').slice(0, 3500)}`,
+        })
+      }
+    })
+  })
+}
+
+/**
+ * Create a stateful Claude session.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.projectDir]        Working directory for claude (default: process.cwd())
+ * @param {string} [opts.statePath]         Where to persist the session ID (default: <projectDir>/.claude-bot/session.json; bot uses <configDir>/.claude-bot/state.json)
+ * @param {string} [opts.permissionMode]    Claude permission mode (default: 'acceptEdits')
+ * @param {string} [opts.model]             Model override (e.g. 'sonnet', 'opus')
+ * @param {string} [opts.claudeBin]         Path to the claude CLI (default: 'claude')
+ * @param {string} [opts.appendSystemPrompt] Extra system prompt to append
+ * @param {object} [opts.env]               Extra environment variables
+ * @returns {{ run(prompt: string): Promise<{ok, text, sessionId, cost}>, reset(): void, getSessionId(): string|undefined }}
+ */
+export function createSession(opts = {}) {
+  const projectDir = opts.projectDir ?? process.cwd()
+  const statePath = opts.statePath ?? join(projectDir, '.claude-bot', 'session.json')
+  const claudeOpts = {
+    projectDir,
+    permissionMode: opts.permissionMode ?? 'acceptEdits',
+    model: opts.model,
+    claudeBin: opts.claudeBin ?? 'claude',
+    appendSystemPrompt: opts.appendSystemPrompt,
+    env: opts.env ?? {},
+  }
+
+  let state = loadState(statePath)
+
+  return {
+    async run(prompt) {
+      const res = await _runClaude(prompt, state.sessionId, claudeOpts)
+      if (res.sessionId) {
+        state.sessionId = res.sessionId
+        saveState(statePath, state)
+      }
+      return res
+    },
+    reset() {
+      state.sessionId = undefined
+      saveState(statePath, state)
+    },
+    getSessionId() {
+      return state.sessionId
+    },
+  }
+}