granclaw 0.0.1-beta.9 → 0.0.1-beta.91

package/dist/backend/agent/browser-bin.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBrowserProvider = registerBrowserProvider;
+exports._resetBrowserProvidersForTests = _resetBrowserProvidersForTests;
+exports.buildArgv = buildArgv;
+exports.resolveBrowserBinary = resolveBrowserBinary;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const stealth_js_1 = require("../browser/stealth.js");
+const providers = [];
+function registerBrowserProvider(provider) {
+    providers.push(provider);
+}
+function _resetBrowserProvidersForTests() {
+    providers.length = 0;
+}
+function buildArgv(res, command, args) {
+    return [...res.preCommandArgs, command, ...args, ...res.postCommandArgs];
+}
+async function resolveBrowserBinary(agentId, workspaceDir) {
+    for (const provider of providers) {
+        const resolution = await provider(agentId, workspaceDir);
+        if (resolution)
+            return resolution;
+    }
+    const cdpFile = `/tmp/granclaw-cdp-${agentId}.url`;
+    if (fs_1.default.existsSync(cdpFile)) {
+        try {
+            const wsUrl = fs_1.default.readFileSync(cdpFile, 'utf8').trim();
+            const port = new URL(wsUrl.replace('ws://', 'http://')).port;
+            if (port) {
+                return {
+                    bin: process.env.AGENT_BROWSER_BIN ?? 'agent-browser',
+                    preCommandArgs: ['--cdp', port, '--session', agentId],
+                    postCommandArgs: [],
+                    env: {},
+                    isRemote: false,
+                    recordingSupported: true,
+                };
+            }
+        }
+        catch { }
+    }
+    const bin = process.env.AGENT_BROWSER_BIN ?? 'agent-browser';
+    const profileDir = path_1.default.join(workspaceDir, '.browser-profile');
+    const preCommandArgs = ['--session', agentId];
+    if (fs_1.default.existsSync(profileDir)) {
+        preCommandArgs.push('--profile', profileDir);
+    }
+    preCommandArgs.push(...(0, stealth_js_1.stealthArgv)());
+    return {
+        bin,
+        preCommandArgs,
+        postCommandArgs: [],
+        env: {},
+        isRemote: false,
+        recordingSupported: true,
+    };
+}

package/dist/backend/agent/channel-broadcast.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS_OPEN = void 0;
+exports.broadcastToClients = broadcastToClients;
+exports.getOrCreateChannelSet = getOrCreateChannelSet;
+exports.WS_OPEN = 1;
+function broadcastToClients(clients, data) {
+    const json = JSON.stringify(data);
+    let sent = 0;
+    for (const ws of clients) {
+        if (ws.readyState === exports.WS_OPEN) {
+            ws.send(json);
+            sent++;
+        }
+    }
+    return sent;
+}
+function getOrCreateChannelSet(map, channelId) {
+    let set = map.get(channelId);
+    if (!set) {
+        set = new Set();
+        map.set(channelId, set);
+    }
+    return set;
+}

package/dist/backend/agent/compaction-retry.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCompactionWithRecovery = runCompactionWithRecovery;
+const TURN_PREFIX_FAILURE_RE = /turn prefix summarization failed/i;
+const AVOID_SPLIT_LADDER = [
+    { strategy: 'avoid-split-50', reservePct: 0.2, keepPct: 0.5 },
+    { strategy: 'avoid-split-70', reservePct: 0.15, keepPct: 0.7 },
+    { strategy: 'avoid-split-90', reservePct: 0.1, keepPct: 0.9 },
+];
+const MINIMAL_KEEP = {
+    strategy: 'minimal-keep',
+    reservePct: 0.5,
+    keepPct: 0.05,
+};
+function toTokens(pct, window, floor = 0) {
+    return Math.max(floor, Math.floor(window * pct));
+}
+function toError(err) {
+    return err instanceof Error ? err : new Error(String(err));
+}
+async function runCompactionWithRecovery(io, modelContextWindow) {
+    const attempts = [];
+    try {
+        await io.compact();
+        attempts.push({ attempt: 1, strategy: 'default' });
+        return { succeeded: true, attempts };
+    }
+    catch (err) {
+        attempts.push({ attempt: 1, strategy: 'default', error: toError(err) });
+    }
+    const lastError = () => attempts[attempts.length - 1]?.error;
+    if (lastError() && TURN_PREFIX_FAILURE_RE.test(lastError().message)) {
+        for (const step of AVOID_SPLIT_LADDER) {
+            try {
+                io.applySettings({
+                    reserveTokens: toTokens(step.reservePct, modelContextWindow),
+                    keepRecentTokens: toTokens(step.keepPct, modelContextWindow),
+                });
+                await io.compact();
+                attempts.push({ attempt: attempts.length + 1, strategy: step.strategy });
+                return { succeeded: true, attempts };
+            }
+            catch (err) {
+                attempts.push({
+                    attempt: attempts.length + 1,
+                    strategy: step.strategy,
+                    error: toError(err),
+                });
+                if (!TURN_PREFIX_FAILURE_RE.test(toError(err).message))
+                    break;
+            }
+        }
+    }
+    try {
+        io.applySettings({
+            reserveTokens: toTokens(MINIMAL_KEEP.reservePct, modelContextWindow),
+            keepRecentTokens: toTokens(MINIMAL_KEEP.keepPct, modelContextWindow, 2_000),
+        });
+        await io.compact();
+        attempts.push({ attempt: attempts.length + 1, strategy: 'minimal-keep' });
+        return { succeeded: true, attempts };
+    }
+    catch (err) {
+        const e = toError(err);
+        attempts.push({ attempt: attempts.length + 1, strategy: 'minimal-keep', error: e });
+        return { succeeded: false, attempts, finalError: e };
+    }
+}

package/dist/backend/agent/context-budget.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planContextBudget = planContextBudget;
+const FIXED_OVERHEAD_TOKENS = 2_000;
+function estimateTokensFromChars(chars) {
+    return Math.ceil(chars / 4);
+}
+function planContextBudget(input) {
+    const { currentTokens, incomingChars, contextWindow, maxOutputTokens } = input;
+    const outputReserve = Math.min(maxOutputTokens, Math.floor(contextWindow * 0.2));
+    const budget = contextWindow - outputReserve - FIXED_OVERHEAD_TOKENS;
+    const incomingTokens = estimateTokensFromChars(incomingChars);
+    const projectedTokens = currentTokens + incomingTokens;
+    if (incomingTokens + FIXED_OVERHEAD_TOKENS + outputReserve >= contextWindow) {
+        return {
+            projectedTokens,
+            budget,
+            action: 'abort',
+            reason: `Incoming message (~${incomingTokens} tok) plus output reservation (${outputReserve}) exceeds the model's ${contextWindow}-token window on its own. Send a shorter message or switch to a larger-context model.`,
+        };
+    }
+    if (projectedTokens <= budget) {
+        return {
+            projectedTokens,
+            budget,
+            action: 'send',
+            reason: `Projected ${projectedTokens} tok ≤ budget ${budget} (window ${contextWindow}, output reserve ${outputReserve}).`,
+        };
+    }
+    return {
+        projectedTokens,
+        budget,
+        action: 'compact',
+        reason: `Projected ${projectedTokens} tok > budget ${budget} (window ${contextWindow}, output reserve ${outputReserve}). Compaction required before send.`,
+    };
+}

package/dist/backend/agent/message-assembly.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleAssistantMessage = assembleAssistantMessage;
+function assembleAssistantMessage(chunks) {
+    let out = '';
+    let textRunHasContent = false;
+    let pendingToolSeparator = false;
+    for (const chunk of chunks) {
+        if (chunk.type === 'text') {
+            if (!chunk.text)
+                continue;
+            if (pendingToolSeparator && textRunHasContent) {
+                out += '\n\n';
+            }
+            out += chunk.text;
+            textRunHasContent = true;
+            pendingToolSeparator = false;
+        }
+        else if (chunk.type === 'tool_call') {
+            if (textRunHasContent)
+                pendingToolSeparator = true;
+        }
+    }
+    return out;
+}

package/dist/backend/agent/process.js

@@ -1,20 +1,4 @@
 "use strict";
-/**
- * agent/process.ts
- *
- * Standalone agent process — spawned by the orchestrator, one per agent.
- *
- * Architecture:
- *   WS server  →  receives messages  →  [BB evaluate]  →  enqueue()
- *   Queue worker (poll loop)          →  dequeueNext() → runAgent() → broadcastToChannel chunks
- *
- * WebSocket protocol:
- *   Client → Agent:  { type: 'message', text: string, channelId?: string }
- *   Agent  → Client: { type: 'queued' }
- *                    { type: 'chunk', chunk: StreamChunk }
- *                    { type: 'error', message: string }
- *                    { type: 'blocked', reason: string }
- */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -26,9 +10,11 @@ const path_1 = __importDefault(require("path"));
 const config_js_1 = require("../config.js");
 const agent_db_js_1 = require("../agent-db.js");
 const runner_pi_js_1 = require("./runner-pi.js");
+const channel_broadcast_js_1 = require("./channel-broadcast.js");
 const messages_db_js_1 = require("../messages-db.js");
 const telegram_adapter_js_1 = require("./telegram-adapter.js");
 const browser_sessions_js_1 = require("../browser-sessions.js");
+const message_assembly_js_1 = require("./message-assembly.js");
 const takeover_state_js_1 = require("../takeover-state.js");
 const takeover_timeout_js_1 = require("../takeover-timeout.js");
 const agentId = process.env.AGENT_ID;
@@ -37,7 +23,6 @@ if (!agentId || !port) {
     console.error('[agent/process] AGENT_ID and AGENT_PORT env vars are required');
     process.exit(1);
 }
-// ── Main ───────────────────────────────────────────────────────────────────────
 function main() {
     const agent = (0, config_js_1.getAgent)(agentId);
     if (!agent) {
@@ -45,21 +30,17 @@ function main() {
         process.exit(1);
     }
     const workspaceDir = path_1.default.resolve(config_js_1.REPO_ROOT, agent.workspaceDir);
-    // Clean up stale 'processing' jobs from previous crashes/restarts
+    (0, runner_pi_js_1.bootstrapWorkspace)(workspaceDir, agentId);
     const cleaned = (0, agent_db_js_1.cleanupStaleJobs)(workspaceDir);
     if (cleaned > 0)
         console.log(`[agent:${agentId}] cleaned up ${cleaned} stale processing jobs`);
-    // ── WebSocket server ───────────────────────────────────────────────────────
     const wss = new ws_1.WebSocketServer({ port });
-    // Map from channelId → set of WS clients subscribed to that channel
     const channelClients = new Map();
     function getChannelClients(channelId) {
-        if (!channelClients.has(channelId))
-            channelClients.set(channelId, new Set());
-        return channelClients.get(channelId);
+        return (0, channel_broadcast_js_1.getOrCreateChannelSet)(channelClients, channelId);
     }
     wss.on('connection', (ws) => {
-        let clientChannelId = 'ui'; // default until client sends a message with channelId
+        let clientChannelId = 'ui';
         console.log(`[agent:${agentId}] client connected`);
         ws.on('message', (raw) => {
             let msg;
@@ -76,8 +57,6 @@ function main() {
                 ws.send(JSON.stringify({ type: 'stopped', killed: stopped }));
             }
             else if (msg.type === 'subscribe' && msg.channelId) {
-                // Subscribe this WS client to a channel without sending a message.
-                // Used by the frontend to receive live chunks from scheduled runs.
                 clientChannelId = msg.channelId;
                 getChannelClients(clientChannelId).add(ws);
             }
@@ -89,7 +68,6 @@ function main() {
             }
         });
         ws.on('close', () => {
-            // Remove from whichever channel set it was in
             for (const [id, set] of channelClients.entries()) {
                 set.delete(ws);
                 if (set.size === 0)
@@ -99,34 +77,24 @@ function main() {
         });
     });
     console.log(`[agent:${agentId}] WS listening on ws://localhost:${port}`);
-    // ── Telegram adapter ───────────────────────────────────────────────────────
-    // Started automatically if TELEGRAM_BOT_TOKEN is set (via Secrets in the UI).
-    // The user adds TELEGRAM_BOT_TOKEN as a secret → orchestrator injects it as
-    // an env var when spawning this process → adapter picks it up here.
     let telegramAdapter = null;
     const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN;
     if (telegramBotToken) {
         telegramAdapter = new telegram_adapter_js_1.TelegramAdapter(agentId, telegramBotToken, workspaceDir);
     }
-    // ── Queue worker ───────────────────────────────────────────────────────────
     function broadcastToChannel(channelId, data) {
-        const json = JSON.stringify(data);
         const targets = channelClients.get(channelId);
         if (!targets)
             return;
-        for (const ws of targets) {
-            if (ws.readyState === ws_1.WebSocket.OPEN)
-                ws.send(json);
-        }
+        (0, channel_broadcast_js_1.broadcastToClients)(targets, data);
     }
-    // Track busy state per channel type so UI chat can run while workflows/schedules execute
     const busyChannels = new Set();
     function channelType(channelId) {
         if (channelId.startsWith('wf-'))
             return 'workflow';
         if (channelId === 'schedule')
             return 'schedule';
-        return channelId; // 'ui', 'telegram:xxx' — each is its own lane
+        return channelId;
     }
     async function processNext() {
         const job = (0, agent_db_js_1.dequeueNext)(workspaceDir, agentId, busyChannels);
@@ -136,41 +104,56 @@ function main() {
         busyChannels.add(lane);
         try {
             const isTelegramJob = telegramAdapter !== null && job.channelId.startsWith('telegram:');
-            // Save the prompt so it's visible in run history immediately
             try {
                 (0, messages_db_js_1.saveMessage)({ id: (0, crypto_1.randomUUID)(), agentId: agentId, channelId: job.channelId, role: 'user', content: job.message });
             }
-            catch { /* non-fatal */ }
-            // Stream chunks directly to channel clients.
-            //
-            // tool_call rows are persisted to the DB the moment they arrive
-            // (not batched at turn end). Reason: if a user leaves the chat view
-            // mid-turn and navigates to /dashboard, ChatPage unmounts and loses
-            // its in-memory streaming state. On return, it refetches history
-            // from the DB — if tool_calls were still buffered in memory, the
-            // user would see an empty chat while the agent was clearly still
-            // working. Persisting as-they-happen makes the live state
-            // refetchable. See regression A (view-switch-state.spec.ts).
-            let fullResponse = '';
+            catch { }
+            const chunkBuffer = [];
             let toolCallCount = 0;
-            // Inject context message if a human takeover was pending
             let messageText = job.message;
             if ((0, takeover_state_js_1.hasTakeover)(agentId)) {
-                (0, takeover_state_js_1.cancelTakeoverTimer)(agentId); // stop 10min timeout — entry stays for runner-pi to restore handle
+                (0, takeover_state_js_1.cancelTakeoverTimer)(agentId);
                 messageText =
                     `[User completed browser interaction]\n` +
                         `User said: "${job.message}"`;
             }
+            if (job.channelId.startsWith('telegram:')) {
+                const proactive = (0, messages_db_js_1.getProactiveMessagesSinceLastUser)(agentId, job.channelId);
+                if (proactive.length > 0) {
+                    const lines = proactive.map((m, i) => {
+                        const ts = new Date(m.createdAt).toISOString().slice(11, 16) + ' UTC';
+                        return `  ${i + 1}. [${ts}] ${m.content}`;
+                    }).join('\n');
+                    messageText =
+                        `[System: since your last Telegram exchange you proactively sent the user these messages ` +
+                            `(they are not in your conversation history but the user received them):\n${lines}\n` +
+                            `]\n\n` +
+                            `User's new reply: ${messageText}`;
+                }
+            }
             await (0, runner_pi_js_1.runAgent)(agent, messageText, (chunk) => {
                 broadcastToChannel(job.channelId, { type: 'chunk', chunk });
                 if (chunk.type === 'text') {
-                    fullResponse += chunk.text;
+                    chunkBuffer.push({ type: 'text', text: chunk.text });
                     if (isTelegramJob) {
                         telegramAdapter.appendChunk(job.channelId, chunk.text);
                     }
                 }
+                if (chunk.type === 'takeover_requested') {
+                    const takeoverUrl = chunk.takeoverUrl;
+                    if (isTelegramJob) {
+                        telegramAdapter.notifyTakeover(job.channelId, takeoverUrl);
+                    }
+                    else {
+                        broadcastToChannel(job.channelId, {
+                            type: 'chunk',
+                            chunk: { type: 'text', text: `\n\n🔗 **Takeover link:** ${takeoverUrl}\n\n` },
+                        });
+                    }
+                }
                 if (chunk.type === 'tool_call') {
                     const tcString = `${chunk.tool}(${JSON.stringify(chunk.input)})`;
+                    chunkBuffer.push({ type: 'tool_call', tool: chunk.tool, input: chunk.input });
                     toolCallCount++;
                     try {
                         (0, messages_db_js_1.saveMessage)({
@@ -181,16 +164,13 @@ function main() {
                             content: tcString,
                         });
                     }
-                    catch { /* non-fatal — WAL/locking can fail under parallel writes */ }
+                    catch { }
                     if (isTelegramJob) {
-                        // Live status update — appears in the user's chat as the
-                        // acknowledgment message gets edited to show progress.
                         void telegramAdapter.appendToolStep(job.channelId, chunk.tool);
                     }
                 }
             }, { channelId: job.channelId });
-            // Persist the final assistant message. tool_call rows were already
-            // saved one-by-one above, so no batch here.
+            const fullResponse = (0, message_assembly_js_1.assembleAssistantMessage)(chunkBuffer);
             try {
                 if (fullResponse) {
                     (0, messages_db_js_1.saveMessage)({
@@ -199,13 +179,12 @@ function main() {
                         channelId: job.channelId,
                         role: 'assistant',
                         content: fullResponse,
-                        createdAt: Date.now() + toolCallCount, // ordered after the last tool_call
+                        createdAt: Date.now() + toolCallCount,
                     });
                 }
             }
-            catch { /* non-fatal */ }
+            catch { }
             (0, agent_db_js_1.markDone)(workspaceDir, job.id);
-            // Arm 10-minute timeout if the agent registered a takeover during this run
             if ((0, takeover_state_js_1.hasTakeover)(agentId)) {
                 const timer = setTimeout(() => {
                     (0, takeover_timeout_js_1.handleTakeoverTimeout)(agentId, workspaceDir).catch((err) => {
@@ -214,14 +193,9 @@ function main() {
                 }, takeover_state_js_1.TAKEOVER_TIMEOUT_MS);
                 (0, takeover_state_js_1.updateTakeoverTimer)(agentId, timer);
             }
-            // Belt-and-suspenders: if the agent left a browser session open (e.g.
-            // forgot to call close), finalize it so recordings don't stay "active"
-            // forever and stream subscribers detach cleanly.
-            // Skip if a human takeover is pending — browser session must stay alive
             if (!(0, takeover_state_js_1.hasTakeover)(agentId)) {
                 (0, browser_sessions_js_1.forceCloseActiveSession)(agentId);
             }
-            // Send the full reply back to Telegram once the turn is complete
             if (isTelegramJob) {
                 await telegramAdapter.flushReply(job.channelId);
             }