appback-remoteagent 0.17.0 → 0.18.0

package/dist/services/agent-memory-service.js

@@ -267,8 +267,7 @@ export class AgentMemoryService {
         return existed;
     }
     async getMacro(aliasOrIndex) {
-        const macros = Object.values(await this.readMacros())
-            .sort((left, right) => left.alias.localeCompare(right.alias, "ko"));
+        const macros = await this.getMacros();
         const trimmed = aliasOrIndex.trim();
         if (/^[0-9]+$/.test(trimmed)) {
             const index = Number.parseInt(trimmed, 10);
@@ -277,9 +276,12 @@ export class AgentMemoryService {
         const normalizedAlias = this.normalizeMacroAlias(trimmed);
         return macros.find((macro) => macro.alias === normalizedAlias);
     }
-    async listMacros() {
-        const macros = Object.values(await this.readMacros())
+    async getMacros() {
+        return Object.values(await this.readMacros())
             .sort((left, right) => left.alias.localeCompare(right.alias, "ko"));
+    }
+    async listMacros() {
+        const macros = await this.getMacros();
         if (macros.length === 0) {
             return "No macros are stored.";
         }

package/dist/services/bot-management-service.js

@@ -31,6 +31,9 @@ export class BotManagementService {
         }
         return this.formatBots(bots, await this.pollingState.list());
     }
+    async listBotChoices() {
+        return (await this.listConfiguredBots()).map(({ id, username }) => ({ id, username }));
+    }
     async formatCurrentBotSummary(currentBotId) {
         const env = await this.readEnvConfig();
         const bots = this.zipBots(env.tokens, env.usernames);

package/dist/services/bridge-service.js

@@ -181,15 +181,12 @@ export class BridgeService {
         }, chatSession.session.workspace);
     }
     async formatModelSelection(botId, chatId) {
-        const chatSession = await this.requireChat(botId, chatId);
-        const provider = chatSession.session.mode;
-        this.ensurePaired(chatSession, provider);
-        const providerSession = chatSession.session[provider];
-        const presets = MODEL_PRESETS[provider] ?? [];
+        const selection = await this.getModelSelection(botId, chatId);
+        const { provider, currentModel, presets } = selection;
         const lines = [
-            `session: ${chatSession.session.publicId}`,
+            `session: ${selection.sessionPublicId}`,
             `mode: ${provider}`,
-            `currentModel: ${providerSession.model ?? this.defaultModelFor(provider)}`,
+            `currentModel: ${currentModel}`,
             "availablePresets:",
             ...presets.map((item, index) => ` ${index + 1}. ${item}`),
             "",
@@ -200,6 +197,18 @@ export class BridgeService {
         }
         return lines.join("\n");
     }
+    async getModelSelection(botId, chatId) {
+        const chatSession = await this.requireChat(botId, chatId);
+        const provider = chatSession.session.mode;
+        this.ensurePaired(chatSession, provider);
+        const providerSession = chatSession.session[provider];
+        return {
+            sessionPublicId: chatSession.session.publicId,
+            provider,
+            currentModel: providerSession.model ?? this.defaultModelFor(provider),
+            presets: [...(MODEL_PRESETS[provider] ?? [])],
+        };
+    }
     async status(botId, chatId) {
         return this.store.getChatSession(botId, chatId);
     }
@@ -284,7 +293,7 @@ export class BridgeService {
         }
         return { stopped, sessionPublicId: session.publicId };
     }
-    async routeMessage(botId, chatId, message) {
+    async routeMessage(botId, chatId, message, onProgress) {
         const chatSession = await this.requireChat(botId, chatId);
         await this.log({
             timestamp: new Date().toISOString(),
@@ -295,7 +304,7 @@ export class BridgeService {
             direction: "in",
             text: message,
         });
-        return this.withSessionLock(chatSession.session.sessionId, () => this.routeSession(chatSession.session, message, "telegram", botId, chatId));
+        return this.withSessionLock(chatSession.session.sessionId, () => this.routeSession(chatSession.session, message, "telegram", botId, chatId, onProgress));
     }
     async routeSessionMessage(sessionId, message) {
         const session = await this.store.getSession(sessionId);
@@ -311,7 +320,7 @@ export class BridgeService {
         });
         return this.withSessionLock(session.sessionId, () => this.routeSession(session, message, "pc-ui"));
     }
-    async routeSessionMessageForChat(sessionId, botId, chatId, message) {
+    async routeSessionMessageForChat(sessionId, botId, chatId, message, onProgress) {
         const session = await this.store.getSession(sessionId);
         if (!session) {
             throw new Error(`Session was not found: ${sessionId}`);
@@ -325,7 +334,7 @@ export class BridgeService {
             direction: "in",
             text: message,
         });
-        return this.withSessionLock(session.sessionId, () => this.routeSession(session, message, "telegram", botId, chatId));
+        return this.withSessionLock(session.sessionId, () => this.routeSession(session, message, "telegram", botId, chatId, onProgress));
     }
     formatStatus(chatSession) {
         if (!chatSession) {
@@ -475,7 +484,7 @@ export class BridgeService {
             }
         }
     }
-    async routeSession(session, message, requestSource, botId, chatId) {
+    async routeSession(session, message, requestSource, botId, chatId, onProgress) {
         const responses = [];
         const providers = this.resolveProviders(session.mode);
         for (const provider of providers) {
@@ -491,6 +500,29 @@ export class BridgeService {
                 message,
                 model: providerSession.model,
                 sandboxMode: providerSession.sandboxMode,
+                onProgress: onProgress
+                    ? async (output) => {
+                        const progressResponse = {
+                            provider,
+                            sessionId: providerSession.sessionId ?? session.sessionId,
+                            publicSessionId: session.publicId,
+                            model: providerSession.model ?? this.defaultModelFor(provider),
+                            cwd: providerSession.cwd,
+                            output,
+                        };
+                        await this.log({
+                            timestamp: new Date().toISOString(),
+                            remoteSessionId: session.sessionId,
+                            botId,
+                            chatId,
+                            provider,
+                            direction: "out",
+                            sessionId: providerSession.sessionId,
+                            text: output,
+                        });
+                        await onProgress(progressResponse);
+                    }
+                    : undefined,
             });
             const updatedProviderSession = {
                 ...providerSession,

package/docs/RELEASING.md

@@ -197,3 +197,48 @@ npm run selftest:telegram
 npm run release:publish
 npm run release:deploy -- 0.17.0 all
 ```
+
+## Release 0.17.1
+
+Date: 2026-08-03
+
+Changes:
+
+- Codex JSON stdout is parsed while the provider process is running.
+- `REPORT:progress` messages are delivered to Telegram immediately without starting another provider turn.
+- A streamed final progress message is deduplicated from the normal post-process response path.
+- Queue instructions are announced in one Telegram message instead of two.
+- Queue notices include inline `/queue remove Qxxx` and `/queue del` buttons that execute the existing queue removal behavior.
+
+Validated:
+
+```bash
+npm run check
+npm run build
+npm run selftest:codex-stream
+npm run selftest:telegram
+npm run release:publish
+npm run release:deploy -- 0.17.1 30
+```
+
+## Release 0.18.0
+
+Date: 2026-08-03
+
+Changes:
+
+- Telegram list and option responses provide inline command controls.
+- Queue notices provide inline remove-latest and remove-by-id controls in one message.
+- Codex progress streaming accepts both normalized CLI `item.completed` events and raw `event_msg`/`response_item` agent-message events.
+- The Codex stream self-test covers every supported progress event shape and keeps final results out of the progress callback.
+
+Validated:
+
+```bash
+npm run check
+npm run build
+npm run selftest:codex-stream
+npm run selftest:telegram
+npm run release:publish
+npm run release:deploy -- 0.18.0 30
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",
@@ -19,6 +19,7 @@
     "start": "node dist/index.js",
     "check": "tsc --noEmit -p tsconfig.json",
     "selftest:telegram": "npm run build && node scripts/selftest-telegram-update.mjs",
+    "selftest:codex-stream": "npm run build && node scripts/selftest-codex-stream.mjs",
     "prepare": "npm run build",
     "prepublishOnly": "node scripts/prepublish-guard.mjs",
     "release:version": "bash scripts/release-version.sh",

package/scripts/selftest-codex-stream.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const root = path.resolve(new URL("..", import.meta.url).pathname);
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "remoteagent-codex-stream-"));
+const fakeCodex = path.join(tmp, "codex");
+
+await fs.writeFile(fakeCodex, `#!/usr/bin/env bash
+set -euo pipefail
+output=""
+while [ "$#" -gt 0 ]; do
+  if [ "$1" = "-o" ]; then
+    output="$2"
+    shift 2
+    continue
+  fi
+  shift
+done
+cat >/dev/null
+printf '%s\\n' '{"type":"thread.started","thread_id":"stream-thread"}'
+printf '%s' '{"type":"item.completed","item":{"type":"agent_message","text":"REPORT:progress\\nphase one"}}'
+printf '\\n'
+sleep 0.05
+printf '%s\\n' '{"type":"event_msg","payload":{"type":"agent_message","message":"REPORT:progress\\nphase two"}}'
+sleep 0.05
+printf '%s\\n' '{"type":"response_item","payload":{"type":"message","content":[{"type":"output_text","text":"REPORT:progress\\nphase three"}]}}'
+sleep 0.05
+printf '%s\\n' '{"type":"item.completed","item":{"type":"agent_message","text":"REPORT:result\\nfinished"}}'
+printf '%s\\n' 'REPORT:result' 'finished' > "$output"
+`, "utf8");
+await fs.chmod(fakeCodex, 0o755);
+
+const { CodexAdapter } = await import(path.join(root, "dist", "adapters", "codex-adapter.js"));
+const adapter = new CodexAdapter(fakeCodex, 5000, "read-only");
+const progress = [];
+let settled = false;
+const responsePromise = adapter.send({
+  chatId: "selftest",
+  remoteSessionId: "remote-session",
+  publicSessionId: "S001",
+  message: "test",
+  cwd: tmp,
+  onProgress: async (output) => {
+    if (settled) {
+      throw new Error("Progress arrived after the provider response settled");
+    }
+    progress.push(output);
+  },
+});
+const response = await responsePromise;
+settled = true;
+
+if (
+  progress.length !== 3
+  || !progress[0]?.includes("phase one")
+  || !progress[1]?.includes("phase two")
+  || !progress[2]?.includes("phase three")
+) {
+  throw new Error(`Unexpected streamed progress: ${JSON.stringify(progress)}`);
+}
+if (progress.some((item) => item.includes("REPORT:result"))) {
+  throw new Error(`Final result leaked through progress callback: ${JSON.stringify(progress)}`);
+}
+if (response.sessionId !== "stream-thread" || response.output !== "REPORT:result\nfinished") {
+  throw new Error(`Unexpected final response: ${JSON.stringify(response)}`);
+}
+
+console.log(JSON.stringify({ ok: true, streamedProgress: progress.length, final: response.output }, null, 2));

package/scripts/selftest-telegram-update.mjs

@@ -21,23 +21,27 @@ set -euo pipefail
 method="unknown"
 text=""
 chat_id=""
+reply_markup=""
 for arg in "$@"; do
   case "$arg" in
     https://api.telegram.org/bot*/sendMessage) method="sendMessage" ;;
     https://api.telegram.org/bot*/editMessageText) method="editMessageText" ;;
     https://api.telegram.org/bot*/deleteMessage) method="deleteMessage" ;;
     https://api.telegram.org/bot*/sendDocument) method="sendDocument" ;;
+    https://api.telegram.org/bot*/answerCallbackQuery) method="answerCallbackQuery" ;;
     chat_id=*) chat_id="\${arg#chat_id=}" ;;
     text=*) text="\${arg#text=}" ;;
+    reply_markup=*) reply_markup="\${arg#reply_markup=}" ;;
   esac
 done
 text_b64="$(printf '%s' "$text" | base64 -w 0)"
-printf '%s\\t%s\\t%s\\n' "$method" "$chat_id" "$text_b64" >> ${JSON.stringify(telegramCalls)}
+reply_markup_b64="$(printf '%s' "$reply_markup" | base64 -w 0)"
+printf '%s\\t%s\\t%s\\t%s\\n' "$method" "$chat_id" "$text_b64" "$reply_markup_b64" >> ${JSON.stringify(telegramCalls)}
 case "$method" in
   sendMessage|editMessageText)
     printf '{"ok":true,"result":{"message_id":1001}}'
     ;;
-  deleteMessage)
+  deleteMessage|answerCallbackQuery)
     printf '{"ok":true,"result":true}'
     ;;
   sendDocument)
@@ -93,6 +97,7 @@ const providerCalls = [];
 let providerMode = "success";
 let untaggedIntentCalls = 0;
 let missingEvidenceCalls = 0;
+let streamingFinalProgressCalls = 0;
 let queueHoldStartedResolve;
 let queueHoldReleaseResolve;
 let queueHoldStartedPromise = Promise.resolve();
@@ -138,6 +143,38 @@ const provider = {
         output: "REPORT:result\nactive queue test completed",
       };
     }
+    if (providerMode === "streaming-progress") {
+      await request.onProgress?.("REPORT:progress\nstreamed phase one completed");
+      await request.onProgress?.("REPORT:progress\nstreamed phase two completed");
+      return {
+        provider: "codex",
+        sessionId: request.sessionId || "mock-thread",
+        publicSessionId: request.publicSessionId,
+        cwd: request.cwd,
+        output: "REPORT:result\nstreamed provider completed with evidence: `stream-test.log`",
+      };
+    }
+    if (providerMode === "streaming-final-progress") {
+      streamingFinalProgressCalls += 1;
+      if (streamingFinalProgressCalls === 1) {
+        const output = "REPORT:progress\nstreamed final progress completed";
+        await request.onProgress?.(output);
+        return {
+          provider: "codex",
+          sessionId: request.sessionId || "mock-thread",
+          publicSessionId: request.publicSessionId,
+          cwd: request.cwd,
+          output,
+        };
+      }
+      return {
+        provider: "codex",
+        sessionId: request.sessionId || "mock-thread",
+        publicSessionId: request.publicSessionId,
+        cwd: request.cwd,
+        output: "REPORT:result\nstreamed continuation completed with evidence: `stream-final.log`",
+      };
+    }
     return {
       provider: "codex",
       sessionId: request.sessionId || "mock-thread",
@@ -191,21 +228,52 @@ function update(text) {
   };
 }
 
+function callbackUpdate(data, sourceMessageId = messageId++) {
+  return {
+    update_id: updateId++,
+    callback_query: {
+      id: `callback-${updateId}`,
+      from: { id: 111, is_bot: false, first_name: "Tester", username: "tester" },
+      message: {
+        message_id: sourceMessageId,
+        date: now(),
+        chat: { id: 111222333, type: "private", first_name: "Tester", username: "tester" },
+        text: "queue controls",
+      },
+      chat_instance: "selftest",
+      data,
+    },
+  };
+}
+
 async function send(text) {
   await injectedBot.handleUpdates([update(text)]);
 }
 
+async function click(data) {
+  await injectedBot.handleUpdates([callbackUpdate(data)]);
+}
+
+function findInlineButton(call, label) {
+  if (!call?.reply_markup) {
+    return undefined;
+  }
+  const markup = JSON.parse(call.reply_markup);
+  return markup.inline_keyboard?.flat().find((button) => button.text === label);
+}
+
 async function readTelegramCalls() {
   return (await fs.readFile(telegramCalls, "utf8"))
     .trim()
     .split("\n")
     .filter(Boolean)
     .map((line) => {
-      const [method, chatId, textB64 = ""] = line.split("\t");
+      const [method, chatId, textB64 = "", replyMarkupB64 = ""] = line.split("\t");
       return {
         method,
         chat_id: chatId,
         text: Buffer.from(textB64, "base64").toString("utf8"),
+        reply_markup: Buffer.from(replyMarkupB64, "base64").toString("utf8"),
       };
     });
 }
@@ -380,6 +448,83 @@ if (calls.some((call) => /미완료 TODO|\/task|새 작업으로 접수/.test(ca
   throw new Error(`Task gate language leaked to Telegram replies. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
 
+await send("/new");
+await send("/list");
+const sessionListCall = await waitForTelegramCall((call) => call.text.includes("Sessions (2/2)"));
+const firstSessionButton = findInlineButton(sessionListCall, `S001 · ${path.basename(session.workspace)}`);
+if (!firstSessionButton?.callback_data?.startsWith("remoteagent:action:")) {
+  throw new Error(`Session switch button is missing: ${sessionListCall.reply_markup}`);
+}
+await click(firstSessionButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Switched this chat to session S001."));
+
+await send("/model");
+const modelListCall = await waitForTelegramCall((call) => call.text.includes("availablePresets:"));
+const modelButton = findInlineButton(modelListCall, "gpt-5.6-terra");
+if (!modelButton?.callback_data) {
+  throw new Error(`Model selection button is missing: ${modelListCall.reply_markup}`);
+}
+await click(modelButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Set codex model to gpt-5.6-terra."));
+const modelState = JSON.parse(await fs.readFile(path.join(dataDir, "state.json"), "utf8"));
+if (modelState.sessions[session.sessionId]?.codex?.model !== "gpt-5.6-terra") {
+  throw new Error("Model button did not update the bound session model");
+}
+
+await send("/option");
+const optionListCall = await waitForTelegramCall((call) => call.text.startsWith("Runtime options"));
+const timeoutButton = findInlineButton(optionListCall, "Timeout");
+if (!timeoutButton?.callback_data) {
+  throw new Error(`Runtime option button is missing: ${optionListCall.reply_markup}`);
+}
+await click(timeoutButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Current provider execution timeout: 600s"));
+
+await send("/sandbox");
+const sandboxListCall = await waitForTelegramCall((call) => call.text.startsWith("Codex sandbox"));
+const readOnlyButton = findInlineButton(sandboxListCall, "read-only");
+const dangerButton = findInlineButton(sandboxListCall, "danger-full-access");
+if (!readOnlyButton?.callback_data || !dangerButton?.callback_data) {
+  throw new Error(`Sandbox selection buttons are missing: ${sandboxListCall.reply_markup}`);
+}
+await click(readOnlyButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Set Codex sandbox to read-only."));
+await click(dangerButton.callback_data);
+const sandboxConfirmCall = await waitForTelegramCall((call) => call.text.includes("Confirm Codex sandbox change"));
+if (!findInlineButton(sandboxConfirmCall, "Confirm danger-full-access")?.callback_data) {
+  throw new Error(`Danger sandbox confirmation button is missing: ${sandboxConfirmCall.reply_markup}`);
+}
+
+await send("/macro set button-test inspect the callback path");
+await send("/batch start");
+await send("/macro");
+const macroListCall = await waitForTelegramCall((call) => call.text.includes("Macros (1)"));
+const macroButton = findInlineButton(macroListCall, "button-test");
+if (!macroButton?.callback_data) {
+  throw new Error(`Macro execution button is missing: ${macroListCall.reply_markup}`);
+}
+await click(macroButton.callback_data);
+await send("/batch send");
+await waitForTelegramCall((call) => call.text.includes("mock provider completed"));
+
+await fs.appendFile(path.join(dataDir, ".env"), [
+  "TELEGRAM_BOT_TOKENS=000000:test-token",
+  "TELEGRAM_BOT_USERNAMES=remoteagent_test_bot",
+  "",
+].join("\n"), "utf8");
+await send("/bots");
+const botsCall = await waitForTelegramCall((call) => call.text.includes("Configured bots (1)"));
+const botLink = findInlineButton(botsCall, "@bot_0");
+const refreshButton = findInlineButton(botsCall, "Refresh");
+if (botLink?.url !== "https://t.me/bot_0" || !refreshButton?.callback_data) {
+  throw new Error(`Bot link or refresh button is missing: ${botsCall.reply_markup}`);
+}
+await click(refreshButton.callback_data);
+const refreshedBotsCalls = (await readTelegramCalls()).filter((call) => call.text.includes("Configured bots (1)"));
+if (refreshedBotsCalls.length < 2) {
+  throw new Error("Bot refresh callback did not render the bot list again");
+}
+
 providerMode = "timeout";
 await send("/batch start");
 await send("timeout regression test");
@@ -461,6 +606,36 @@ if (evidenceCalls.some((call) => call.method === "sendMessage" && /^수정 완
   throw new Error(`Evidence-free completion leaked as final Telegram message. Calls: ${JSON.stringify(evidenceCalls, null, 2)}`);
 }
 
+providerMode = "streaming-progress";
+await send("/batch start");
+await send("streaming progress regression test");
+await send("/batch send");
+
+const streamingCalls = await readTelegramCalls();
+for (const phase of ["streamed phase one completed", "streamed phase two completed"]) {
+  const matches = streamingCalls.filter((call) => call.method === "sendMessage" && call.text.includes(phase));
+  if (matches.length !== 1) {
+    throw new Error(`Expected exactly one streamed Telegram progress message for ${phase}, got ${matches.length}`);
+  }
+}
+if (!streamingCalls.some((call) => call.method === "sendMessage" && call.text.includes("streamed provider completed"))) {
+  throw new Error("Streaming provider final result was not delivered");
+}
+
+providerMode = "streaming-final-progress";
+await send("/batch start");
+await send("streaming final progress deduplication test");
+await send("/batch send");
+const streamingFinalCalls = await readTelegramCalls();
+const streamedFinalProgressMessages = streamingFinalCalls.filter((call) =>
+  call.method === "sendMessage" && call.text.includes("streamed final progress completed")
+);
+if (streamedFinalProgressMessages.length !== 1 || streamingFinalProgressCalls !== 2) {
+  throw new Error(
+    `Final streamed progress was not deduplicated: messages=${streamedFinalProgressMessages.length} providerCalls=${streamingFinalProgressCalls}`,
+  );
+}
+
 const queueProviderCallsBefore = providerCalls.length;
 providerMode = "queue-hold";
 queueHoldStartedPromise = new Promise((resolve) => {
@@ -483,6 +658,16 @@ const firstQueueId = firstQueueNotice.text.match(/Queued instruction (Q\d+)/)?.[
 if (!firstQueueId) {
   throw new Error(`First queued instruction did not receive an id: ${firstQueueNotice.text}`);
 }
+const firstQueueNotices = (await readTelegramCalls()).filter((call) =>
+  call.method === "sendMessage" && call.text.includes(`Queued instruction ${firstQueueId} for`)
+);
+if (firstQueueNotices.length !== 1) {
+  throw new Error(`Queue notice should be one Telegram message, got ${firstQueueNotices.length}`);
+}
+if (!firstQueueNotice.reply_markup.includes(`remoteagent:queue:remove:${firstQueueId}`)
+  || !firstQueueNotice.reply_markup.includes("remoteagent:queue:del")) {
+  throw new Error(`Queue notice buttons are missing: ${firstQueueNotice.reply_markup}`);
+}
 
 await send("/batch start");
 await send("second queued instruction");
@@ -504,9 +689,9 @@ if (!/Queued instructions for S001 \(2\)/.test(queueListCall.text)) {
   throw new Error(`Queue list did not report both entries: ${queueListCall.text}`);
 }
 
-await send(`/queue remove ${firstQueueId}`);
+await click(`remoteagent:queue:remove:${firstQueueId}`);
 await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${firstQueueId}`));
-await send("/queue del");
+await click("remoteagent:queue:del");
 await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${secondQueueId}`));
 
 queueHoldReleaseResolve?.();
@@ -527,6 +712,8 @@ console.log(JSON.stringify({
   providerCalls: providerCalls.length,
   untaggedIntentCalls,
   missingEvidenceCalls,
+  streamingProgress: true,
+  streamingFinalProgressDeduplicated: true,
   queueRemoveById: firstQueueId,
   queueRemoveLatest: secondQueueId,
   timeoutFinalMessage: true,