polygram 0.3.4 → 0.3.6

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands and a history skill.",
   "keywords": [
     "telegram",

package/config.example.json

@@ -11,6 +11,14 @@
       "streamReplies": true,
       "streamMinChars": 30,
       "streamThrottleMs": 500,
+      "_comment_pairedChatDefaults": "When a user sends /pair <CODE> from a private chat that isn't in config.chats yet, polygram auto-creates a chat entry using these defaults (merged over top-level `defaults`). Leave out `cwd` at your peril — without it, auto-onboarded DMs have no working directory and pairing will fail.",
+      "pairedChatDefaults": {
+        "agent": "admin",
+        "cwd": "/Users/you/admin-agent",
+        "model": "sonnet",
+        "effort": "medium",
+        "timeout": 600
+      },
       "voice": {
         "enabled": true,
         "provider": "openai",

package/lib/process-manager.js

@@ -173,14 +173,20 @@ class ProcessManager {
         entry.sessionId = event.session_id;
         if (this.onInit) this.onInit(sessionKey, event, entry);
       }
-      if (event.type === 'assistant' && this.onStreamChunk && entry.pending) {
-        const added = extractAssistantText(event);
-        if (added) {
-          entry.streamText = entry.streamText
-            ? `${entry.streamText}\n\n${added}`
-            : added;
-          try { this.onStreamChunk(sessionKey, entry.streamText, entry); }
-          catch (err) { this.logger.error(`[${entry.label}] onStreamChunk: ${err.message}`); }
+      if (event.type === 'assistant' && entry.pending) {
+        // Any assistant step (text block, tool_use, tool_result) counts as
+        // Claude activity — reset the idle timeout so long turns don't
+        // wall-clock out.
+        entry.pending.resetIdleTimer?.();
+        if (this.onStreamChunk) {
+          const added = extractAssistantText(event);
+          if (added) {
+            entry.streamText = entry.streamText
+              ? `${entry.streamText}\n\n${added}`
+              : added;
+            try { this.onStreamChunk(sessionKey, entry.streamText, entry); }
+            catch (err) { this.logger.error(`[${entry.label}] onStreamChunk: ${err.message}`); }
+          }
         }
       }
       if (event.type === 'result' && entry.pending) {
@@ -250,18 +256,27 @@ class ProcessManager {
       entry.pending = { resolve, reject };
       entry.streamText = '';
 
-      const timer = setTimeout(() => {
+      // Idle timeout: counts N seconds of SILENCE from Claude, not total
+      // wall-clock. Long multi-tool turns that produce visible progress
+      // (streaming chunks, tool_use events) should not time out as long as
+      // they're actively working. onStreamChunk resets this below.
+      const arm = () => setTimeout(() => {
         if (entry.pending) {
           entry.pending = null;
           entry.inFlight = false;
-          reject(new Error(`Timeout after ${timeoutMs / 1000}s`));
+          reject(new Error(`Timeout: ${timeoutMs / 1000}s idle with no Claude activity`));
         }
       }, timeoutMs);
+      entry.pending.timer = arm();
+      entry.pending.resetIdleTimer = () => {
+        if (entry.pending?.timer) clearTimeout(entry.pending.timer);
+        if (entry.pending) entry.pending.timer = arm();
+      };
 
       const wrappedResolve = entry.pending.resolve;
       const wrappedReject = entry.pending.reject;
-      entry.pending.resolve = (r) => { clearTimeout(timer); wrappedResolve(r); };
-      entry.pending.reject = (e) => { clearTimeout(timer); wrappedReject(e); };
+      entry.pending.resolve = (r) => { if (entry.pending?.timer) clearTimeout(entry.pending.timer); wrappedResolve(r); };
+      entry.pending.reject = (e) => { if (entry.pending?.timer) clearTimeout(entry.pending.timer); wrappedReject(e); };
 
       try {
         entry.proc.stdin.write(JSON.stringify({
@@ -269,9 +284,9 @@ class ProcessManager {
           message: { role: 'user', content: prompt },
         }) + '\n');
       } catch (err) {
+        if (entry.pending?.timer) clearTimeout(entry.pending.timer);
         entry.pending = null;
         entry.inFlight = false;
-        clearTimeout(timer);
         reject(err);
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc-client.js",
   "bin": {

package/polygram.js

@@ -1271,6 +1271,87 @@ function createBot(token) {
   // not another bot's problem.
   const knownChat = (chatId) => !!config.chats[chatId];
 
+  // Claim a pair code from an unconfigured private chat and persist a new
+  // chat entry so subsequent messages go through the normal flow. Replies
+  // to the user on both success and failure. Returns the new chatConfig on
+  // success, null on any failure.
+  //
+  // The new chat inherits cwd/agent from bot-level pairedChatDefaults if
+  // present, otherwise from the first existing chat the bot owns — on the
+  // reasonable assumption that paired DMs should behave like other DMs for
+  // this bot. Operator can override by setting config.bots.<bot>.pairedChatDefaults.
+  async function onboardPairedChat(ctx, code) {
+    const chatId = ctx.chat.id.toString();
+    const userId = ctx.message.from?.id;
+    const send = (text) => bot.api.sendMessage(chatId, text).catch(() => {});
+
+    if (!userId) {
+      await send('No user id on request.');
+      return null;
+    }
+
+    const res = pairings.claimCode({
+      code, claimer_user_id: userId,
+      chat_id: chatId, bot_name: BOT_NAME,
+    });
+    dbWrite(() => db.logEvent('pair-claim-attempt', {
+      bot: BOT_NAME, user_id: userId, chat_id: chatId,
+      ok: res.ok, reason: res.reason, via: 'auto-onboard',
+    }), 'log pair-claim-attempt');
+
+    if (!res.ok) {
+      const reply = res.reason === 'rate-limited'
+        ? 'Too many attempts. Try again later.'
+        : 'Invalid or expired code.';
+      await send(reply);
+      return null;
+    }
+
+    const paired = config.bot?.pairedChatDefaults || {};
+    const globals = config.defaults || {};
+    const firstChat = Object.values(config.chats)[0] || {};
+    const chatName = paired.name
+      || (ctx.chat.username && `@${ctx.chat.username}`)
+      || ctx.chat.first_name
+      || `User ${userId}`;
+
+    const cwd = paired.cwd || firstChat.cwd;
+    if (!cwd) {
+      dbWrite(() => db.logEvent('auto-onboard-failed', {
+        bot: BOT_NAME, chat_id: chatId, user_id: userId,
+        reason: 'no-cwd',
+      }), 'log auto-onboard-failed');
+      await send('Paired, but no working directory is configured. Ask the operator to set pairedChatDefaults.cwd.');
+      return null;
+    }
+
+    const newChat = {
+      name: chatName,
+      bot: BOT_NAME,
+      agent: paired.agent || firstChat.agent,
+      model: paired.model || globals.model || 'sonnet',
+      effort: paired.effort || globals.effort || 'medium',
+      cwd,
+      timeout: paired.timeout || globals.timeout || 600,
+    };
+    if (paired.requireMention != null) newChat.requireMention = paired.requireMention;
+
+    config.chats[chatId] = newChat;
+    try { saveConfig(); }
+    catch (err) {
+      console.error(`[${BOT_NAME}] saveConfig on auto-onboard failed: ${err.message}`);
+    }
+    dbWrite(() => db.logEvent('chat-auto-created', {
+      bot: BOT_NAME, chat_id: chatId, user_id: userId,
+      source: 'pair-claim', model: newChat.model, effort: newChat.effort,
+    }), 'log chat-auto-created');
+
+    const chatLabel = res.chat_id ? `chat ${res.chat_id}` : `every chat ${BOT_NAME} is in`;
+    const suffix = res.note ? `\n(${res.note})` : '';
+    await send(`Paired. You can use me in ${chatLabel}.${suffix}`);
+    return newChat;
+  }
+
   bot.on('message', async (ctx) => {
     if (!isWellFormedMessage(ctx.message)) {
       dbWrite(() => db.logEvent('malformed-update', {
@@ -1281,7 +1362,25 @@ function createBot(token) {
       return;
     }
     const chatId = ctx.chat.id.toString();
-    const chatConfig = config.chats[chatId];
+    let chatConfig = config.chats[chatId];
+
+    // Auto-onboarding: /pair <CODE> from an unconfigured private chat.
+    // Without this, the !chatConfig drop below would silently eat pair
+    // claims from DMs the operator hasn't pre-listed — defeating the
+    // whole point of pair codes (which exist to grant access without
+    // pre-configuration). Group chats are not auto-onboarded: they must
+    // still be added to config.json by the operator, because adding a
+    // group can affect multiple users.
+    if (!chatConfig && ctx.chat.type === 'private') {
+      const probe = (ctx.message.text || '').trim();
+      const pairMatch = /^\/pair(?:@\S+)?\s+(\S+)\s*$/.exec(probe);
+      if (pairMatch) {
+        chatConfig = await onboardPairedChat(ctx, pairMatch[1]);
+        if (!chatConfig) return;
+        recordInbound(ctx.message);
+        return;
+      }
+    }
     if (!chatConfig) return;
 
     // Record every inbound msg, even unaddressed ones — needed for reply-to