opencode-claw 0.2.2 → 0.2.5

package/dist/channels/router.js

@@ -31,11 +31,13 @@ function parseCommand(text) {
         return { name: trimmed.slice(1).toLowerCase(), args: "" };
     return { name: trimmed.slice(1, space).toLowerCase(), args: trimmed.slice(space + 1).trim() };
 }
+const PAGE_SIZE = 10;
 const HELP_TEXT = `Available commands:
 /new [title] — Create a new session
 /switch <id> — Switch to an existing session
-/sessions — List your sessions
+/sessions [page] — List your sessions (paginated)
 /current — Show current session
+/status — Show current agent run status
 /fork — Fork current session into a new one
 /cancel — Abort the currently running agent
 /help — Show this help`;
@@ -43,9 +45,8 @@ const HELP_TEXT = `Available commands:
 function peerKey(channel, peerId) {
     return `${channel}:${peerId}`;
 }
-async function handleCommand(cmd, msg, deps, activeStreams) {
+async function handleCommand(cmd, msg, deps, activeStreams, activeStreamsMeta) {
     const key = buildSessionKey(msg.channel, msg.peerId, msg.threadId);
-    const prefix = `${msg.channel}:${msg.peerId}`;
     switch (cmd.name) {
         case "new": {
             const id = await deps.sessions.newSession(key, cmd.args || undefined);
@@ -58,15 +59,21 @@ async function handleCommand(cmd, msg, deps, activeStreams) {
             return `Switched to session: ${cmd.args}`;
         }
         case "sessions": {
-            const list = await deps.sessions.listSessions(prefix);
+            const list = await deps.sessions.listSessions(key);
             if (list.length === 0)
                 return "No sessions found.";
-            return list
-                .map((s) => {
+            const page = Math.max(1, Number.parseInt(cmd.args) || 1);
+            const totalPages = Math.ceil(list.length / PAGE_SIZE);
+            const clamped = Math.min(page, totalPages);
+            const slice = list.slice((clamped - 1) * PAGE_SIZE, clamped * PAGE_SIZE);
+            const lines = slice.map((s) => {
                 const marker = s.active ? " (active)" : "";
                 return `• ${s.id} — ${s.title}${marker}`;
-            })
-                .join("\n");
+            });
+            if (totalPages > 1) {
+                lines.push(`\nPage ${clamped}/${totalPages}${clamped < totalPages ? ` — use /sessions ${clamped + 1} for next` : ""}`);
+            }
+            return lines.join("\n");
         }
         case "current": {
             const id = deps.sessions.currentSession(key);
@@ -97,6 +104,19 @@ async function handleCommand(cmd, msg, deps, activeStreams) {
             deps.logger.info("router: session aborted by user", { sessionId, aborted });
             return aborted ? "Agent aborted." : "Abort request sent (agent may already be done).";
         }
+        case "status": {
+            const pk = peerKey(msg.channel, msg.peerId);
+            const sessionId = activeStreams.get(pk);
+            if (!sessionId)
+                return "No agent is currently running.";
+            const meta = activeStreamsMeta.get(pk);
+            const elapsedSec = meta ? Math.floor((Date.now() - meta.startedAt) / 1000) : 0;
+            const mins = Math.floor(elapsedSec / 60);
+            const secs = elapsedSec % 60;
+            const elapsed = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+            const tool = meta?.lastTool ? ` — last tool: ${humanizeToolName(meta.lastTool)}` : "";
+            return `⏳ Agent is running (${elapsed} elapsed${tool})`;
+        }
         case "help": {
             return HELP_TEXT;
         }
@@ -111,7 +131,7 @@ function humanizeToolName(raw) {
         return raw;
     return raw.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
-async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
+async function routeMessage(msg, deps, activeStreams, activeStreamsMeta, pendingQuestions) {
     const adapter = deps.adapters.get(msg.channel);
     if (!adapter) {
         deps.logger.warn("router: no adapter for channel", { channel: msg.channel });
@@ -132,7 +152,7 @@ async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     // Command interception
     const cmd = parseCommand(msg.text);
     if (cmd) {
-        const reply = await handleCommand(cmd, msg, deps, activeStreams);
+        const reply = await handleCommand(cmd, msg, deps, activeStreams, activeStreamsMeta);
         await adapter.send(msg.peerId, { text: reply, replyToId: msg.replyToId });
         return;
     }
@@ -142,6 +162,7 @@ async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     deps.logger.debug("router: prompting session", { sessionId, channel: msg.channel });
     const pk = peerKey(msg.channel, msg.peerId);
     activeStreams.set(pk, sessionId);
+    activeStreamsMeta.set(pk, { startedAt: Date.now(), lastTool: undefined });
     // Start typing indicator
     if (adapter.sendTyping) {
         await adapter.sendTyping(msg.peerId).catch(() => { });
@@ -180,10 +201,15 @@ async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     }
     const progress = progressEnabled
         ? {
-            onToolRunning: (_tool, title) => adapter.send(msg.peerId, {
-                text: `🔧 ${humanizeToolName(title)}...`,
-                replyToId: msg.replyToId,
-            }),
+            onToolRunning: (_tool, title) => {
+                const meta = activeStreamsMeta.get(pk);
+                if (meta)
+                    meta.lastTool = title;
+                return adapter.send(msg.peerId, {
+                    text: `🔧 ${humanizeToolName(title)}...`,
+                    replyToId: msg.replyToId,
+                });
+            },
             onHeartbeat: async () => {
                 if (adapter.sendTyping) {
                     await adapter.sendTyping(msg.peerId).catch(() => { });
@@ -220,6 +246,7 @@ async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
     }
     finally {
         activeStreams.delete(pk);
+        activeStreamsMeta.delete(pk);
         pendingQuestions.delete(pk);
         if (adapter.stopTyping) {
             await adapter.stopTyping(msg.peerId).catch(() => { });
@@ -235,6 +262,8 @@ async function routeMessage(msg, deps, activeStreams, pendingQuestions) {
 export function createRouter(deps) {
     // Tracks which sessionId is currently streaming for each channel:peerId pair
     const activeStreams = new Map();
+    // Tracks timing + last tool for each active stream
+    const activeStreamsMeta = new Map();
     // Tracks pending question resolvers — when agent asks a question, user's next message resolves it
     const pendingQuestions = new Map();
     async function handler(msg) {
@@ -248,7 +277,7 @@ export function createRouter(deps) {
                 pending.resolve(msg.text);
                 return;
             }
-            await routeMessage(msg, deps, activeStreams, pendingQuestions);
+            await routeMessage(msg, deps, activeStreams, activeStreamsMeta, pendingQuestions);
         }
         catch (err) {
             deps.logger.error("router: unhandled error", {

package/dist/sessions/manager.d.ts

@@ -13,7 +13,7 @@ export declare function createSessionManager(client: OpencodeClient, config: Ses
     resolveSession: (key: string, title?: string) => Promise<string>;
     switchSession: (key: string, targetId: string) => Promise<void>;
     newSession: (key: string, title?: string) => Promise<string>;
-    listSessions: (channelPeerPrefix: string) => Promise<SessionInfo[]>;
+    listSessions: (key: string) => Promise<SessionInfo[]>;
     currentSession: (key: string) => string | undefined;
     persist: () => Promise<void>;
 };

package/dist/sessions/manager.js

@@ -39,20 +39,17 @@ export function createSessionManager(client, config, map, logger) {
         logger.info("sessions: created and switched to new session", { key, id: session.data.id });
         return session.data.id;
     }
-    async function listSessions(channelPeerPrefix) {
+    async function listSessions(key) {
         const all = await client.session.list();
         const sessions = all.data ?? [];
-        const entries = [...map.entries()].filter(([key]) => key.includes(channelPeerPrefix));
-        return entries.map(([key, id]) => {
-            const session = sessions.find((s) => s.id === id);
-            return {
-                id,
-                key,
-                title: session?.title ?? "(deleted)",
-                active: map.get(key) === id,
-                createdAt: session?.time.created,
-            };
-        });
+        const activeId = map.get(key);
+        return sessions.map((s) => ({
+            id: s.id,
+            key: [...map.entries()].find(([, id]) => id === s.id)?.[0] ?? "(external)",
+            title: s.title ?? s.id,
+            active: s.id === activeId,
+            createdAt: s.time.created,
+        }));
     }
     function currentSession(key) {
         return map.get(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claw",
-  "version": "0.2.2",
+  "version": "0.2.5",
   "description": "Wrap OpenCode with persistent memory, messaging channels, and cron jobs",
   "license": "MIT",
   "type": "module",