appback-remoteagent 0.17.0 → 0.18.0

package/README.md

@@ -103,6 +103,8 @@ Current command surface implemented in `src/bot.ts`:
 | `/new` | Creates and binds a new session using the saved default mode in a new managed workspace |
 | `/switch <session>` | Rebinds this chat to an existing RemoteAgent session |
 | `/status` | Shows current session, workspace, provider, and sandbox state |
+| `/model [name]` | Lists selectable provider models or changes the current session model |
+| `/sandbox [codex <mode>]` | Lists Codex sandbox choices or changes the current session sandbox |
 | `/option retry <count>` | Sets the automatic continuation turn limit and persists it to `~/.remoteagent/.env` |
 | `/option timeout <seconds>` | Sets the provider execution timeout and persists it to `~/.remoteagent/.env` |
 | `/option intent <count>` | Sets retries for untagged intent-only provider replies and persists it to `~/.remoteagent/.env` |
@@ -110,6 +112,7 @@ Current command surface implemented in `src/bot.ts`:
 | `/state clear` | Clears the current session ledger without deleting the session |
 | `/state note <text>` | Adds an operator note to the session ledger |
 | `/bots` | Lists the currently configured Telegram bots |
+| `/macro [alias\|number]` | Lists stored macros or runs one against the current session |
 | `/bot add <token>` | Adds a conversation bot, restarts the runtime, and confirms the result after restart |
 | `/bot doctor` | Checks configured Telegram bots and removes bots that Telegram reports as permanently dead |
 | `/bot remove <username\|id>` | Removes a configured Telegram bot, restarts the runtime, and confirms the result after restart |
@@ -127,6 +130,8 @@ Current command surface implemented in `src/bot.ts`:
 | `/queue remove <id>` | Removes one waiting instruction by its `Q001`-style id |
 | `/queue del` | Removes the most recently queued instruction |
 
+Selection-oriented replies include Telegram inline buttons for sessions, models, macros, runtime option details, sandbox modes, queued instructions, and configured bot links. Text commands remain the canonical compatible interface. Callback actions use short-lived opaque IDs bound to the originating chat and user; they do not expose secrets or rely on visible list positions as internal identity. Selecting `danger-full-access` through a button requires a second confirmation.
+
 Multi-bot polling is tiered by recent activity and active provider work. See [docs/BOT_POLLING_POLICY.md](./docs/BOT_POLLING_POLICY.md).
 
 ### 2. Terminal control

package/dist/adapters/codex-adapter.js

@@ -18,7 +18,7 @@ export class CodexAdapter {
         const args = request.sessionId
             ? this.buildResumeArgs(request, outputPath, sandboxMode)
             : this.buildExecArgs(request, outputPath, sandboxMode);
-        const { stdout, stderr, code, timedOut } = await this.runCodex(args, request.cwd, request.remoteSessionId, request.publicSessionId, request.message);
+        const { stdout, stderr, code, timedOut } = await this.runCodex(args, request.cwd, request.remoteSessionId, request.publicSessionId, request.message, request.onProgress);
         try {
             const sessionId = this.extractThreadId(stdout) ?? request.sessionId;
             const output = await this.readOutput(outputPath) || this.extractAgentMessage(stdout);
@@ -102,12 +102,49 @@ export class CodexAdapter {
             args.push("--dangerously-bypass-approvals-and-sandbox");
         }
     }
-    runCodex(args, cwd, remoteSessionId, publicSessionId, input) {
+    runCodex(args, cwd, remoteSessionId, publicSessionId, input, onProgress) {
         return spawnWithPlatformShell(this.codexBin, args, cwd, this.currentTimeoutMs(), input, remoteSessionId, {
             REMOTEAGENT_SESSION_ID: remoteSessionId,
             REMOTEAGENT_PUBLIC_SESSION_ID: publicSessionId ?? "",
             REMOTEAGENT_WORKSPACE: cwd,
-        });
+        }, (line) => this.handleProgressLine(line, onProgress));
+    }
+    async handleProgressLine(line, onProgress) {
+        if (!onProgress || !line.startsWith("{")) {
+            return;
+        }
+        let text;
+        try {
+            text = this.extractEventAgentText(JSON.parse(line));
+        }
+        catch {
+            // Ignore non-JSON stdout and let the normal final-response parser handle it.
+            return;
+        }
+        if (text && /^REPORT:progress(?:\r?\n|$)/i.test(text)) {
+            await onProgress(text);
+        }
+    }
+    extractEventAgentText(event) {
+        if (!event || typeof event !== "object") {
+            return undefined;
+        }
+        const record = event;
+        if (record.type === "item.completed" && record.item?.type === "agent_message") {
+            return record.item.text?.trim();
+        }
+        if (record.type === "event_msg" && record.payload?.type === "agent_message") {
+            return (record.payload.message ?? record.payload.text)?.trim();
+        }
+        if (record.type === "response_item" && record.payload?.type === "message") {
+            const text = record.payload.content
+                ?.filter((item) => item.type === "output_text" && typeof item.text === "string")
+                .map((item) => item.text)
+                .join("\n")
+                .trim();
+            return text || record.payload.text?.trim();
+        }
+        return undefined;
     }
     extractThreadId(stdout) {
         for (const line of stdout.split(/\r?\n/)) {

package/dist/adapters/windows-shell.js

@@ -2,7 +2,7 @@ import process from "node:process";
 import { execFile, spawn } from "node:child_process";
 import { buildProviderEnv } from "./runtime-env.js";
 const activeCommands = new Map();
-export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executionKey, extraEnv) {
+export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executionKey, extraEnv, onStdoutLine) {
     return new Promise((resolve, reject) => {
         const command = process.platform === "win32"
             ? spawn("cmd.exe", ["/d", "/c", "call", bin, ...args], {
@@ -19,13 +19,29 @@ export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executi
         }
         let stdout = "";
         let stderr = "";
+        let stdoutRemainder = "";
+        let stdoutCallbackTail = Promise.resolve();
         let timedOut = false;
         const timer = setTimeout(() => {
             timedOut = true;
             terminateProcessTree(command);
         }, timeoutMs);
         command.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
+            const text = chunk.toString();
+            stdout += text;
+            if (!onStdoutLine) {
+                return;
+            }
+            stdoutRemainder += text;
+            const lines = stdoutRemainder.split(/\r?\n/);
+            stdoutRemainder = lines.pop() ?? "";
+            for (const line of lines) {
+                stdoutCallbackTail = stdoutCallbackTail
+                    .then(() => onStdoutLine(line))
+                    .catch((error) => {
+                    console.warn(`[provider-stream] stdout callback failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
         });
         command.stderr.on("data", (chunk) => {
             stderr += chunk.toString();
@@ -41,11 +57,19 @@ export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executi
             command.stdin.write(input);
         }
         command.stdin.end();
-        command.on("close", (code) => {
+        command.on("close", async (code) => {
             clearTimeout(timer);
             if (executionKey && activeCommands.get(executionKey) === command) {
                 activeCommands.delete(executionKey);
             }
+            if (onStdoutLine && stdoutRemainder) {
+                stdoutCallbackTail = stdoutCallbackTail
+                    .then(() => onStdoutLine(stdoutRemainder))
+                    .catch((error) => {
+                    console.warn(`[provider-stream] stdout callback failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+            await stdoutCallbackTail;
             resolve({ stdout, stderr, code, timedOut });
         });
     });