codeclaw 0.2.5 → 0.2.7

package/dist/bot-telegram.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { Bot, VERSION, fmtTokens, fmtUptime, fmtBytes, whichSync, listSubdirs, buildPrompt, thinkLabel, parseAllowedChatIds, shellSplit, } from './bot.js';
 import { TelegramChannel } from './channel-telegram.js';
+import { splitText } from './channel-base.js';
 // ---------------------------------------------------------------------------
 // Telegram HTML formatting
 // ---------------------------------------------------------------------------
@@ -657,20 +658,39 @@ export class TelegramBot extends Bot {
             }
         }
         else {
-            let preview = bodyHtml.slice(0, 3200);
-            if (bodyHtml.length > 3200)
-                preview += '\n<i>... (see full response below)</i>';
-            const previewHtml = `${statusHtml}${thinkingHtml}${preview}\n\n${meta}${tokenBlock}`;
+            // Send full content as split plain-text messages instead of a file.
+            // First message: edit placeholder with meta + thinking + beginning of body.
+            const headerHtml = `${statusHtml}${thinkingHtml}`;
+            const footerHtml = `\n\n${meta}${tokenBlock}`;
+            const maxFirst = 3900 - headerHtml.length - footerHtml.length;
+            let firstBody;
+            let remaining;
+            if (maxFirst > 200) {
+                // find a newline-friendly cut in the HTML body
+                let cut = bodyHtml.lastIndexOf('\n', maxFirst);
+                if (cut < maxFirst * 0.3)
+                    cut = maxFirst;
+                firstBody = bodyHtml.slice(0, cut);
+                remaining = bodyHtml.slice(cut);
+            }
+            else {
+                firstBody = '';
+                remaining = bodyHtml;
+            }
+            const firstHtml = `${headerHtml}${firstBody}${footerHtml}`;
             try {
-                await this.channel.editMessage(ctx.chatId, phId, previewHtml, { parseMode: 'HTML', keyboard });
+                await this.channel.editMessage(ctx.chatId, phId, firstHtml, { parseMode: 'HTML', keyboard });
             }
             catch {
-                finalMsgId = await this.channel.send(ctx.chatId, previewHtml, { parseMode: 'HTML', replyTo: ctx.messageId, keyboard });
+                finalMsgId = await this.channel.send(ctx.chatId, firstHtml, { parseMode: 'HTML', replyTo: ctx.messageId, keyboard });
+            }
+            // Send remaining body as continuation messages (split at ~3800 chars)
+            if (remaining.trim()) {
+                const chunks = splitText(remaining, 3800);
+                for (const chunk of chunks) {
+                    await this.channel.send(ctx.chatId, chunk, { parseMode: 'HTML', replyTo: finalMsgId ?? phId });
+                }
             }
-            const thinkingMd = result.thinking
-                ? `> **${thinkLabel(agent)}**\n${result.thinking.split('\n').map(l => `> ${l}`).join('\n')}\n\n---\n\n`
-                : '';
-            await this.channel.sendDocument(ctx.chatId, thinkingMd + result.message, `response_${phId}.md`, { caption: `Full response (${result.message.length} chars)`, replyTo: finalMsgId ?? phId });
         }
         return finalMsgId;
     }

package/dist/bot.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { doStream, getSessions, getUsage, listAgents, } from './code-agent.js';
-export const VERSION = '0.2.5';
+export const VERSION = '0.2.7';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/dist/code-agent.js

@@ -25,7 +25,7 @@ async function run(cmd, opts, parseLine) {
     const proc = spawn(shellCmd, { cwd: opts.workdir, stdio: ['pipe', 'pipe', 'pipe'], shell: true });
     agentLog(`[spawn] pid=${proc.pid}`);
     try {
-        proc.stdin.write(opts.prompt);
+        proc.stdin.write(opts._stdinOverride ?? opts.prompt);
         proc.stdin.end();
     }
     catch { }
@@ -147,6 +147,49 @@ export function doCodexStream(opts) {
     return run(codexCmd(opts), opts, codexParse);
 }
 // --- claude ---
+const IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
+function mimeForExt(ext) {
+    switch (ext) {
+        case '.jpg':
+        case '.jpeg': return 'image/jpeg';
+        case '.png': return 'image/png';
+        case '.gif': return 'image/gif';
+        case '.webp': return 'image/webp';
+        default: return 'application/octet-stream';
+    }
+}
+/**
+ * Build a stream-json stdin payload that includes images as base64 content
+ * blocks alongside the text prompt.
+ */
+function buildClaudeMultimodalStdin(prompt, attachments) {
+    const content = [];
+    for (const filePath of attachments) {
+        const ext = path.extname(filePath).toLowerCase();
+        if (IMAGE_EXTS.has(ext)) {
+            try {
+                const data = fs.readFileSync(filePath);
+                content.push({
+                    type: 'image',
+                    source: { type: 'base64', media_type: mimeForExt(ext), data: data.toString('base64') },
+                });
+            }
+            catch (e) {
+                agentLog(`[attach] failed to read image ${filePath}: ${e.message}`);
+            }
+        }
+        else {
+            // For non-image files, tell Claude the path so it can Read it
+            content.push({ type: 'text', text: `[Attached file: ${filePath}]` });
+        }
+    }
+    content.push({ type: 'text', text: prompt });
+    const msg = {
+        type: 'user',
+        message: { role: 'user', content },
+    };
+    return JSON.stringify(msg) + '\n';
+}
 function claudeCmd(o) {
     const args = ['claude', '-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
     if (o.claudeModel)
@@ -156,8 +199,8 @@ function claudeCmd(o) {
     if (o.sessionId)
         args.push('--resume', o.sessionId);
     if (o.attachments?.length) {
-        for (const f of o.attachments)
-            args.push('--input-file', f);
+        args.push('--input-format', 'stream-json');
+        o._stdinOverride = buildClaudeMultimodalStdin(o.prompt, o.attachments);
     }
     if (o.claudeExtraArgs?.length)
         args.push(...o.claudeExtraArgs);
@@ -685,6 +728,92 @@ function getCodexUsageFromSessions(home) {
     }
     return null;
 }
+// ---------------------------------------------------------------------------
+// Claude usage from OAuth API (https://api.anthropic.com/api/oauth/usage)
+// ---------------------------------------------------------------------------
+function getClaudeOAuthToken() {
+    try {
+        const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null', {
+            encoding: 'utf-8', timeout: 3000,
+        }).trim();
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return parsed?.claudeAiOauth?.accessToken || null;
+    }
+    catch {
+        return null;
+    }
+}
+function getClaudeUsageFromOAuth() {
+    const token = getClaudeOAuthToken();
+    if (!token)
+        return null;
+    try {
+        const raw = execSync(`curl -s --max-time 5 -H "Authorization: Bearer ${token}" -H "anthropic-beta: oauth-2025-04-20" -H "Content-Type: application/json" "https://api.anthropic.com/api/oauth/usage"`, { encoding: 'utf-8', timeout: 8000 }).trim();
+        if (!raw || raw[0] !== '{')
+            return null;
+        const data = JSON.parse(raw);
+        const capturedAt = new Date().toISOString();
+        const makeWindow = (label, entry) => {
+            if (!entry || typeof entry !== 'object')
+                return null;
+            const usedPercent = roundPercent(entry.utilization);
+            if (usedPercent == null)
+                return null;
+            const remainingPercent = Math.max(0, Math.round((100 - usedPercent) * 10) / 10);
+            const resetAt = typeof entry.resets_at === 'string' ? entry.resets_at : null;
+            let resetAfterSeconds = null;
+            if (resetAt) {
+                const resetAtMs = Date.parse(resetAt);
+                if (Number.isFinite(resetAtMs)) {
+                    resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
+                }
+            }
+            return {
+                label,
+                usedPercent,
+                remainingPercent,
+                resetAt,
+                resetAfterSeconds,
+                status: usedPercent >= 100 ? 'limit_reached' : usedPercent >= 80 ? 'warning' : 'allowed',
+            };
+        };
+        const windows = [];
+        const w5h = makeWindow('5h', data.five_hour);
+        if (w5h)
+            windows.push(w5h);
+        const w7d = makeWindow('7d', data.seven_day);
+        if (w7d)
+            windows.push(w7d);
+        const w7dOpus = makeWindow('7d Opus', data.seven_day_opus);
+        if (w7dOpus)
+            windows.push(w7dOpus);
+        const w7dSonnet = makeWindow('7d Sonnet', data.seven_day_sonnet);
+        if (w7dSonnet)
+            windows.push(w7dSonnet);
+        const wExtra = makeWindow('Extra', data.extra_usage);
+        if (wExtra)
+            windows.push(wExtra);
+        if (!windows.length)
+            return null;
+        const overallStatus = windows.some(w => w.status === 'limit_reached') ? 'limit_reached'
+            : windows.some(w => w.status === 'warning') ? 'warning'
+                : 'allowed';
+        return {
+            ok: true,
+            agent: 'claude',
+            source: 'oauth-api',
+            capturedAt,
+            status: overallStatus,
+            windows,
+            error: null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function getClaudeUsageFromTelemetry(home, model) {
     const telemetryRoot = path.join(home, '.claude', 'telemetry');
     if (!fs.existsSync(telemetryRoot))
@@ -778,6 +907,7 @@ export function getUsage(opts) {
             || getCodexUsageFromSessions(home)
             || emptyUsage('codex', 'No recent Codex usage data found.');
     }
-    return getClaudeUsageFromTelemetry(home, opts.model)
+    return getClaudeUsageFromOAuth()
+        || getClaudeUsageFromTelemetry(home, opts.model)
         || emptyUsage('claude', 'No recent Claude usage data found.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeclaw",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "The best IM-driven remote coding experience. Bridge AI coding agents to any IM.",
   "type": "module",
   "bin": {