appback-remoteagent 0.15.7 → 0.17.0

package/scripts/selftest-telegram-update.mjs

@@ -62,18 +62,41 @@ process.env.TELEGRAM_EMPTY_RESPONSE_RETRIES = "0";
 process.env.TELEGRAM_RETRYABLE_ERROR_RETRIES = "0";
 process.env.LOCAL_UI_ENABLED = "false";
 
-const [{ createBot }, { BridgeService }, { BotManagementService }, { FileStore }, { AgentMemoryService }] = await Promise.all([
+const [
+  { createBot },
+  { BridgeService },
+  { BotManagementService },
+  { FileStore },
+  { AgentMemoryService },
+  { WorkspaceCleanupService },
+  { buildFallbackBotInfo },
+] = await Promise.all([
   import(path.join(root, "dist", "bot.js")),
   import(path.join(root, "dist", "services", "bridge-service.js")),
   import(path.join(root, "dist", "services", "bot-management-service.js")),
   import(path.join(root, "dist", "store", "file-store.js")),
   import(path.join(root, "dist", "services", "agent-memory-service.js")),
+  import(path.join(root, "dist", "services", "workspace-cleanup-service.js")),
+  import(path.join(root, "dist", "telegram-bot-identity.js")),
 ]);
 
+const persistedBotIdentity = buildFallbackBotInfo(
+  "8966593034:test-token",
+  0,
+  "@appbackadmin_bot",
+);
+if (persistedBotIdentity.username !== "appbackadmin_bot") {
+  throw new Error(`Configured bot username was not preserved during getMe fallback: ${persistedBotIdentity.username}`);
+}
+
 const providerCalls = [];
 let providerMode = "success";
 let untaggedIntentCalls = 0;
 let missingEvidenceCalls = 0;
+let queueHoldStartedResolve;
+let queueHoldReleaseResolve;
+let queueHoldStartedPromise = Promise.resolve();
+let queueHoldReleasePromise = Promise.resolve();
 const provider = {
   async send(request) {
     providerCalls.push(request);
@@ -104,6 +127,17 @@ const provider = {
           : "REPORT:result\n수정 완료했습니다.\n\n근거:\n- 변경 파일: `src/example.ts`\n- 검증: `npm run check` 통과",
       };
     }
+    if (providerMode === "queue-hold") {
+      queueHoldStartedResolve?.();
+      await queueHoldReleasePromise;
+      return {
+        provider: "codex",
+        sessionId: request.sessionId || "mock-thread",
+        publicSessionId: request.publicSessionId,
+        cwd: request.cwd,
+        output: "REPORT:result\nactive queue test completed",
+      };
+    }
     return {
       provider: "codex",
       sessionId: request.sessionId || "mock-thread",
@@ -161,6 +195,34 @@ async function send(text) {
   await injectedBot.handleUpdates([update(text)]);
 }
 
+async function readTelegramCalls() {
+  return (await fs.readFile(telegramCalls, "utf8"))
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [method, chatId, textB64 = ""] = line.split("\t");
+      return {
+        method,
+        chat_id: chatId,
+        text: Buffer.from(textB64, "base64").toString("utf8"),
+      };
+    });
+}
+
+async function waitForTelegramCall(predicate, timeoutMs = 3000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const calls = await readTelegramCalls();
+    const match = [...calls].reverse().find(predicate);
+    if (match) {
+      return match;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  throw new Error("Timed out waiting for Telegram self-test call.");
+}
+
 await send("/start codex");
 await send("/option retry 6");
 await send("/option timeout 600");
@@ -188,6 +250,59 @@ if (!/^TELEGRAM_UNTAGGED_INTENT_RETRIES=4$/m.test(envText)) {
   throw new Error(`Option command did not persist untagged intent retry limit to .env: ${envText}`);
 }
 
+const sessionWorkspace = session.workspace;
+await fs.mkdir(path.join(sessionWorkspace, "node_modules", "left-pad"), { recursive: true });
+await fs.mkdir(path.join(sessionWorkspace, "src"), { recursive: true });
+await fs.writeFile(path.join(sessionWorkspace, "node_modules", "left-pad", "index.js"), "module.exports = 1;\n", "utf8");
+await fs.writeFile(path.join(sessionWorkspace, "src", "keep.ts"), "export const keep = true;\n", "utf8");
+await fs.writeFile(path.join(sessionWorkspace, "debug.log"), "temporary log\n", "utf8");
+await fs.writeFile(path.join(sessionWorkspace, "TODO.md"), "- keep cleanup notes\n", "utf8");
+await send("/cleanup");
+await fs.access(path.join(sessionWorkspace, "TODO.md"));
+if (await pathExists(path.join(sessionWorkspace, "node_modules"))) {
+  throw new Error("/cleanup did not remove node_modules");
+}
+if (await pathExists(path.join(sessionWorkspace, "debug.log"))) {
+  throw new Error("/cleanup did not remove log file");
+}
+if (await pathExists(path.join(sessionWorkspace, "src"))) {
+  throw new Error("/cleanup did not remove regular workspace contents");
+}
+
+const orphanWorkspace = path.join(workspaceRoot, "orphan123");
+const referencedWorkspace = sessionWorkspace;
+await fs.mkdir(orphanWorkspace, { recursive: true });
+await fs.writeFile(path.join(orphanWorkspace, "artifact.tmp"), "orphan\n", "utf8");
+const workspaceCleanup = new WorkspaceCleanupService(dataDir, workspaceRoot);
+const orphanResult = await workspaceCleanup.cleanupOrphanWorkspaces();
+if (!/removed=1/.test(orphanResult)) {
+  throw new Error(`Expected one orphan workspace removal, got: ${orphanResult}`);
+}
+if (await pathExists(orphanWorkspace)) {
+  throw new Error("Orphan workspace was not removed");
+}
+if (!(await pathExists(referencedWorkspace))) {
+  throw new Error("Referenced workspace was removed unexpectedly");
+}
+
+const missingStateDataDir = path.join(tmp, "missing-state-data");
+const missingStateWorkspaceRoot = path.join(tmp, "missing-state-workspaces");
+const shouldRemain = path.join(missingStateWorkspaceRoot, "should-remain");
+await fs.mkdir(shouldRemain, { recursive: true });
+const missingStateCleanup = new WorkspaceCleanupService(missingStateDataDir, missingStateWorkspaceRoot);
+let refusedMissingState = false;
+try {
+  await missingStateCleanup.cleanupOrphanWorkspaces();
+} catch {
+  refusedMissingState = true;
+}
+if (!refusedMissingState) {
+  throw new Error("Workspace cleanup should refuse to run when state.json is missing");
+}
+if (!(await pathExists(shouldRemain))) {
+  throw new Error("Workspace cleanup removed a workspace when state.json was missing");
+}
+
 const memory = new AgentMemoryService(dataDir);
 const developmentSession = {
   ...session,
@@ -258,6 +373,9 @@ if (!calls.some((call) => call.method === "sendMessage" && /Set provider executi
 if (!calls.some((call) => call.method === "sendMessage" && /Set untagged intent retry limit to 4/.test(call.text))) {
   throw new Error(`Did not see option intent acknowledgement. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
+if (!calls.some((call) => call.method === "sendMessage" && /Workspace cleanup finished for S001/.test(call.text))) {
+  throw new Error(`Did not see workspace cleanup acknowledgement. Calls: ${JSON.stringify(calls, null, 2)}`);
+}
 if (calls.some((call) => /미완료 TODO|\/task|새 작업으로 접수/.test(call.text))) {
   throw new Error(`Task gate language leaked to Telegram replies. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
@@ -333,13 +451,70 @@ const evidenceCalls = (await fs.readFile(telegramCalls, "utf8"))
 if (missingEvidenceCalls !== 2) {
   throw new Error(`Expected missing evidence result to be retried once, got ${missingEvidenceCalls}`);
 }
-if (!evidenceCalls.some((call) => /변경 파일: `src\/example\.ts`/.test(call.text) && /`npm run check` 통과/.test(call.text))) {
+if (!evidenceCalls.some((call) =>
+  /변경 파일: (?:`|<code>)src\/example\.ts(?:`|<\/code>)/.test(call.text)
+  && /(?:`|<code>)npm run check(?:`|<\/code>) 통과/.test(call.text)
+)) {
   throw new Error(`Did not see recovered result with concrete evidence. Calls: ${JSON.stringify(evidenceCalls, null, 2)}`);
 }
 if (evidenceCalls.some((call) => call.method === "sendMessage" && /^수정 완료했습니다\.$/.test(call.text.trim()))) {
   throw new Error(`Evidence-free completion leaked as final Telegram message. Calls: ${JSON.stringify(evidenceCalls, null, 2)}`);
 }
 
+const queueProviderCallsBefore = providerCalls.length;
+providerMode = "queue-hold";
+queueHoldStartedPromise = new Promise((resolve) => {
+  queueHoldStartedResolve = resolve;
+});
+queueHoldReleasePromise = new Promise((resolve) => {
+  queueHoldReleaseResolve = resolve;
+});
+
+await send("/batch start");
+await send("active queue regression test");
+const activeQueueSend = send("/batch send");
+await queueHoldStartedPromise;
+
+await send("/batch start");
+await send("first queued instruction");
+const firstQueuedSend = send("/batch send");
+const firstQueueNotice = await waitForTelegramCall((call) => /Queued instruction Q\d+/.test(call.text));
+const firstQueueId = firstQueueNotice.text.match(/Queued instruction (Q\d+)/)?.[1];
+if (!firstQueueId) {
+  throw new Error(`First queued instruction did not receive an id: ${firstQueueNotice.text}`);
+}
+
+await send("/batch start");
+await send("second queued instruction");
+const secondQueuedSend = send("/batch send");
+const secondQueueNotice = await waitForTelegramCall((call) => {
+  const queueId = call.text.match(/Queued instruction (Q\d+)/)?.[1];
+  return Boolean(queueId && queueId !== firstQueueId);
+});
+const secondQueueId = secondQueueNotice.text.match(/Queued instruction (Q\d+)/)?.[1];
+if (!secondQueueId) {
+  throw new Error(`Second queued instruction did not receive an id: ${secondQueueNotice.text}`);
+}
+
+await send("/queue");
+const queueListCall = await waitForTelegramCall((call) =>
+  call.text.includes(firstQueueId) && call.text.includes(secondQueueId)
+);
+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 waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${firstQueueId}`));
+await send("/queue del");
+await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${secondQueueId}`));
+
+queueHoldReleaseResolve?.();
+await Promise.all([activeQueueSend, firstQueuedSend, secondQueuedSend]);
+if (providerCalls.length !== queueProviderCallsBefore + 1) {
+  throw new Error(`Removed queued instructions reached the provider: ${providerCalls.length - queueProviderCallsBefore} calls`);
+}
+
 console.log(JSON.stringify({
   ok: true,
   dataDir,
@@ -352,8 +527,14 @@ console.log(JSON.stringify({
   providerCalls: providerCalls.length,
   untaggedIntentCalls,
   missingEvidenceCalls,
+  queueRemoveById: firstQueueId,
+  queueRemoveLatest: secondQueueId,
   timeoutFinalMessage: true,
   telegramSendMessages: evidenceCalls.filter((call) => call.method === "sendMessage").length,
 }, null, 2));
 
 process.exit(0);
+
+async function pathExists(target) {
+  return fs.access(target).then(() => true, () => false);
+}