appback-remoteagent 0.15.7 → 0.17.0

package/.env.example

@@ -18,6 +18,8 @@ TELEGRAM_RECOVERY_CHECK_INTERVAL_MS=60000
 ARTIFACT_CLEANUP_ENABLED=true
 ARTIFACT_RETENTION_DAYS=30
 ARTIFACT_CLEANUP_INTERVAL_MS=86400000
+WORKSPACE_CLEANUP_ENABLED=true
+WORKSPACE_CLEANUP_INTERVAL_MS=86400000
 REMOTEAGENT_WATCHDOG_ENABLED=true
 REMOTEAGENT_WATCHDOG_INTERVAL_MS=300000
 REMOTEAGENT_WATCHDOG_CPU_PERCENT=90

package/README.md

@@ -123,6 +123,9 @@ Current command surface implemented in `src/bot.ts`:
 | `/batch done` | Alias for `/batch send` |
 | `/batch cancel` | Discards the current batch |
 | `/batch status` | Shows current batch state |
+| `/queue` | Lists instructions waiting behind the active session work |
+| `/queue remove <id>` | Removes one waiting instruction by its `Q001`-style id |
+| `/queue del` | Removes the most recently queued instruction |
 
 Multi-bot polling is tiered by recent activity and active provider work. See [docs/BOT_POLLING_POLICY.md](./docs/BOT_POLLING_POLICY.md).
 
@@ -182,6 +185,8 @@ Telegram attachments are written into the local runtime under `~/.remoteagent/up
 
 Attachments can be inspected with `/artifacts list` and cleaned manually with `/artifacts cleanup <days>`. RemoteAgent also runs periodic artifact cleanup when `ARTIFACT_CLEANUP_ENABLED=true`; by default it keeps 30 days and also removes old unindexed files under `uploads/telegram`.
 
+Managed workspaces are cleaned separately. RemoteAgent periodically removes only orphan workspace directories that are no longer referenced by `state.json` when `WORKSPACE_CLEANUP_ENABLED=true`. Use `/cleanup` to clear the current session workspace; RemoteAgent keeps the session todo/state/history under `~/.remoteagent/managed/sessions/<session>` and refuses non-RemoteAgent-managed workspaces.
+
 Current supported attachment classes:
 
 - photos

package/dist/bot.js

@@ -9,6 +9,7 @@ import { config } from "./config.js";
 import { ProviderSetupService } from "./services/provider-setup-service.js";
 import { RemoteShellService } from "./services/remote-shell-service.js";
 import { AgentMemoryService } from "./services/agent-memory-service.js";
+import { WorkspaceCleanupService } from "./services/workspace-cleanup-service.js";
 import { deleteTelegramCommandMenu, setTelegramCommandMenu } from "./telegram-command-menu.js";
 const execFileAsync = promisify(execFile);
 const HELP_TEXT = [
@@ -23,14 +24,18 @@ const HELP_TEXT = [
     "/attach codex <thread_id>",
     "/attach claude <session_id>",
     "/model [name]",
+    "/queue [remove <id>|del]",
     "/stop",
     "/sandbox codex <read-only|workspace-write|danger-full-access>",
     "/status",
     "/option [retry <count>|timeout <seconds>|intent <count>|command-menu <on|off|refresh>]",
     "/state [clear|note <text>]",
     "/artifacts list|cleanup <days>",
+    "/cleanup",
     "/secret set|list|remove",
     "/docs pin|find|list|remove|reinforce",
+    "/macro set|list|remove|<alias|number>",
+    "/매크로 set|list|remove|<alias|number>",
     "/보강 <count>",
     "/bots",
     "/bot add <token>",
@@ -76,14 +81,17 @@ const RECOGNIZED_COMMANDS = new Set([
     "batch",
     "attach",
     "model",
+    "queue",
     "stop",
     "sandbox",
     "status",
     "option",
     "state",
     "artifacts",
+    "cleanup",
     "secret",
     "docs",
+    "macro",
     "bots",
     "bot",
     "install",
@@ -92,7 +100,10 @@ const RECOGNIZED_COMMANDS = new Set([
 ]);
 const TELEGRAM_STALE_UPDATE_GRACE_SECONDS = 10;
 const TELEGRAM_PROCESS_STARTED_AT_SECONDS = Math.floor(Date.now() / 1000);
-const activeWorkLoopKeys = new Set();
+const workLoopTails = new Map();
+const workLoopGenerations = new Map();
+const queuedWorkLoops = new Map();
+let nextQueuedWorkSequence = 1;
 const REPORT_CONTINUE_PROMPT = [
     "Continue the same task now.",
     "Do more concrete work before replying again.",
@@ -177,6 +188,7 @@ export function createBot(token, bridge, botManagement, botInfo) {
     const autoContinue = new AutoContinueController(path.join(config.dataDir, "stop-gates.json"));
     const shellService = new RemoteShellService(config.commandTimeoutMs);
     const memoryService = new AgentMemoryService(config.dataDir);
+    const workspaceCleanupService = new WorkspaceCleanupService(config.dataDir, config.workspaceRoot);
     const sourceBotToken = token;
     const setupService = new ProviderSetupService(config.setupCommandTimeoutMs, (provider) => bridge.listAvailableProviders().includes(provider), {
         codex: config.codexInstallCommand,
@@ -196,6 +208,7 @@ export function createBot(token, bridge, botManagement, botInfo) {
         if (!previous) {
             return;
         }
+        cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
         autoContinue.requestSessionStop(previous.session.sessionId);
         messageBatcher.cancelPending(botId, chatId);
         messageBatcher.cancelManual(botId, chatId);
@@ -350,6 +363,7 @@ ${bridge.formatStatus(mapping)}`);
         const mapping = await bridge.switchSession(botId, chatId, sessionId);
         if (previous && previous.session.sessionId !== mapping.session.sessionId) {
             autoContinue.requestSessionStop(previous.session.sessionId);
+            cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
             messageBatcher.cancelPending(botId, chatId);
             messageBatcher.cancelManual(botId, chatId);
             await bridge.stopSessionRun(previous.session.sessionId, botId, chatId, "Chat switched to another session; previous session execution was stopped.");
@@ -443,16 +457,47 @@ ${bridge.formatStatus(mapping)}`);
         const mapping = await bridge.setModel(botId, chatId, model);
         await reply(ctx, `Set ${mapping.session.mode} model to ${model}.\n\n${bridge.formatStatus(mapping)}`);
     });
+    bot.command("queue", async (ctx) => {
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const mapping = await bridge.status(botId, chatId);
+        const activeKey = workLoopKey(botId, chatId, mapping?.session.sessionId);
+        const { args, rest } = parseCommand(ctx.message?.text, 2);
+        const action = args[0]?.toLowerCase();
+        const selector = args[1];
+        if (rest?.trim() || (action && action !== "list" && action !== "remove" && action !== "rm" && action !== "del")) {
+            await reply(ctx, "Usage: `/queue`, `/queue remove <id>`, or `/queue del`", { parse_mode: "Markdown" });
+            return;
+        }
+        if (!action || action === "list") {
+            await reply(ctx, formatQueuedWorkLoops(activeKey, mapping?.session.publicId));
+            return;
+        }
+        if ((action === "remove" || action === "rm") && !selector) {
+            await reply(ctx, "Usage: `/queue remove <id>`", { parse_mode: "Markdown" });
+            return;
+        }
+        const removed = removeQueuedWorkLoop(activeKey, selector);
+        if (!removed) {
+            const target = selector ? normalizeQueueId(selector) : "the latest queued instruction";
+            await reply(ctx, `Queued instruction was not found: ${target}`);
+            return;
+        }
+        await bridge.logSystem(botId, chatId, `Removed queued instruction ${removed.id} for ${activeKey}.`);
+        await reply(ctx, `Removed queued instruction ${removed.id} from ${removed.publicSessionId ?? "this session"}.\n`
+            + `Remaining queued instructions: ${listQueuedWorkLoops(activeKey).length}`);
+    });
     bot.command("stop", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
         const mapping = await bridge.status(botId, chatId);
         const sessionId = mapping?.session.sessionId;
         autoContinue.requestStop(botId, chatId, sessionId);
+        const queuedWorkCount = cancelQueuedWorkLoops(botId, chatId, sessionId);
         const pendingBatch = messageBatcher.cancelPending(botId, chatId);
         const manualBatch = messageBatcher.cancelManual(botId, chatId);
         if (!autoContinue.beginStop(botId, chatId, sessionId)) {
-            const batchCount = pendingBatch.count + manualBatch.count;
+            const batchCount = queuedWorkCount + pendingBatch.count + manualBatch.count;
             if (batchCount > 0) {
                 await bridge.logSystem(botId, chatId, `Duplicate stop discarded ${batchCount} queued message(s).`);
             }
@@ -461,7 +506,7 @@ ${bridge.formatStatus(mapping)}`);
         try {
             const result = await bridge.stopActiveRun(botId, chatId);
             await bridge.logSystem(botId, chatId, "Stop requested for auto-continue.");
-            const batchCount = pendingBatch.count + manualBatch.count;
+            const batchCount = queuedWorkCount + pendingBatch.count + manualBatch.count;
             await reply(ctx, result.stopped
                 ? `Stop requested. Active work for ${result.sessionPublicId ?? "this session"} was interrupted, further automatic continuation will stop, and ${batchCount} queued message(s) were discarded.`
                 : `Stop requested. No active provider process was running, but further automatic continuation will stop, and ${batchCount} queued message(s) were discarded.`);
@@ -620,6 +665,19 @@ ${bridge.formatStatus(mapping)}`);
         }
         await reply(ctx, "Usage: `/artifacts list` or `/artifacts cleanup <days>`", { parse_mode: "Markdown" });
     });
+    bot.command("cleanup", async (ctx) => {
+        await ensureOwnerControlAccess(ctx);
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const mapping = await bridge.status(botId, chatId);
+        if (!mapping) {
+            await reply(ctx, "No paired session for this chat yet.");
+            return;
+        }
+        const result = await workspaceCleanupService.cleanupSessionWorkspace(mapping.session);
+        await bridge.logSystem(botId, chatId, `Workspace cleanup requested for ${mapping.session.publicId}.`);
+        await reply(ctx, result);
+    });
     bot.command("secret", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const { args, rest } = parseCommand(ctx.message?.text, 2);
@@ -700,6 +758,40 @@ ${bridge.formatStatus(mapping)}`);
         }
         await reply(ctx, "Usage: `/docs list`, `/docs find <keyword>`, `/docs pin <keyword> <path>`, `/docs remove <keyword>`, or `/docs reinforce <1-10>`", { parse_mode: "Markdown" });
     });
+    const handleMacroCommand = async (ctx, text) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const parsed = parseMacroCommandText(text, botId);
+        if (parsed.kind === "help") {
+            await reply(ctx, await formatMacroHelp(memoryService));
+            return;
+        }
+        if (parsed.kind === "set") {
+            await ensureOwnerControlAccess(ctx);
+            const macro = await memoryService.setMacro(parsed.alias, parsed.prompt);
+            await reply(ctx, `Saved macro '${macro.alias}'.`);
+            return;
+        }
+        if (parsed.kind === "remove") {
+            await ensureOwnerControlAccess(ctx);
+            const removed = await memoryService.removeMacro(parsed.alias);
+            await reply(ctx, removed ? `Removed macro '${parsed.alias}'.` : `Macro was not found: ${parsed.alias}`);
+            return;
+        }
+        const macro = await memoryService.getMacro(parsed.target);
+        if (!macro) {
+            await reply(ctx, `Macro was not found: ${parsed.target}\n\n${await memoryService.listMacros()}`);
+            return;
+        }
+        await bridge.logSystem(botId, chatId, `Macro executed: ${macro.alias}`);
+        await messageBatcher.enqueue({ botToken: token, telegramChatId: ctx.chat.id }, botId, chatId, macro.prompt);
+    };
+    bot.command("macro", async (ctx) => {
+        await handleMacroCommand(ctx, ctx.message?.text ?? "/macro");
+    });
     bot.command("bots", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const pendingNotice = await botManagement.getPendingOperationNotice();
@@ -825,6 +917,11 @@ ${bridge.formatStatus(mapping)}`);
             await reply(ctx, "Usage: `/보강 <1-10>`", { parse_mode: "Markdown" });
             return;
         }
+        const koreanMacro = parseKoreanMacroCommand(text, botId);
+        if (koreanMacro) {
+            await handleMacroCommand(ctx, text ?? "/매크로");
+            return;
+        }
         if (text && isRecognizedSlashCommand(text, botId)) {
             return;
         }
@@ -1155,22 +1252,70 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
     const currentSession = await bridge.status(botId, chatId);
     const sessionId = currentSession?.session.sessionId;
     const activeKey = workLoopKey(botId, chatId, sessionId);
-    if (activeWorkLoopKeys.has(activeKey)) {
-        const message = [
-            `Session ${currentSession?.session.publicId ?? sessionId ?? `${botId}:${chatId}`} is already running.`,
-            "Send /stop to interrupt the active work, then send the instruction again.",
-        ].join("\n");
-        await bridge.logSystem(botId, chatId, `Rejected overlapping Telegram work loop for ${activeKey}.`);
-        return [message];
-    }
-    activeWorkLoopKeys.add(activeKey);
-    if (currentSession) {
-        await memoryService.recordInstruction(currentSession.session, message);
+    const previousTail = workLoopTails.get(activeKey);
+    const generation = workLoopGenerations.get(activeKey) ?? 0;
+    let release;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    const currentTail = (previousTail ?? Promise.resolve())
+        .catch(() => undefined)
+        .then(() => gate);
+    workLoopTails.set(activeKey, currentTail);
+    let queuedEntry;
+    if (previousTail) {
+        queuedEntry = registerQueuedWorkLoop({
+            activeKey,
+            botId,
+            chatId,
+            sessionId,
+            publicSessionId: currentSession?.session.publicId,
+            message,
+            release,
+        });
+        try {
+            await bridge.logSystem(botId, chatId, `Queued overlapping Telegram work loop ${queuedEntry.id} for ${activeKey}.`);
+            await helpers.reportProgress([
+                `Queued instruction ${queuedEntry.id} for ${currentSession?.session.publicId ?? "this session"}. It will run after the active work finishes.`,
+                `Remove it with \`/queue remove ${queuedEntry.id}\`, or remove the latest queued instruction with \`/queue del\`.`,
+            ]);
+            await previousTail.catch(() => undefined);
+        }
+        catch (error) {
+            queuedWorkLoops.delete(queuedEntry.id);
+            release();
+            if (workLoopTails.get(activeKey) === currentTail) {
+                workLoopTails.delete(activeKey);
+            }
+            throw error;
+        }
+        queuedWorkLoops.delete(queuedEntry.id);
+        if (queuedEntry.canceled || (workLoopGenerations.get(activeKey) ?? 0) !== generation || autoContinue.isStopRequested(botId, chatId, sessionId)) {
+            await bridge.logSystem(botId, chatId, `Discarded queued Telegram work loop ${queuedEntry.id} for ${activeKey}.`);
+            release();
+            if (workLoopTails.get(activeKey) === currentTail) {
+                workLoopTails.delete(activeKey);
+            }
+            throw new SilentTelegramAbort("Queued work was discarded.");
+        }
+    }
+    let managedContext = "";
+    try {
+        if (currentSession) {
+            await memoryService.recordInstruction(currentSession.session, message);
+        }
+        managedContext = currentSession
+            ? await memoryService.formatProviderContext(currentSession.session)
+            : "";
+        autoContinue.clear(botId, chatId, sessionId);
+    }
+    catch (error) {
+        release();
+        if (workLoopTails.get(activeKey) === currentTail) {
+            workLoopTails.delete(activeKey);
+        }
+        throw error;
     }
-    const managedContext = currentSession
-        ? await memoryService.formatProviderContext(currentSession.session)
-        : "";
-    autoContinue.clear(botId, chatId, sessionId);
     let prompt = appendManagedContext(appendReportProtocol(message), managedContext);
     const maxTurns = options.maxTurns ?? config.telegramAutoProgressMaxTurns;
     const emptyResponseRetries = config.telegramEmptyResponseRetries;
@@ -1351,7 +1496,10 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
         }
     }
     finally {
-        activeWorkLoopKeys.delete(activeKey);
+        release();
+        if (workLoopTails.get(activeKey) === currentTail) {
+            workLoopTails.delete(activeKey);
+        }
         if (currentSession) {
             if (providerCompleted) {
                 await botManagement.markProviderCompleted(botId, sessionId);
@@ -1365,6 +1513,88 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
 function workLoopKey(botId, chatId, sessionId) {
     return sessionId ? `session:${sessionId}` : `chat:${botId}:${chatId}`;
 }
+function cancelQueuedWorkLoops(botId, chatId, sessionId) {
+    const keys = [workLoopKey(botId, chatId, sessionId)];
+    if (sessionId) {
+        keys.push(workLoopKey(botId, chatId));
+    }
+    const keySet = new Set(keys);
+    let removed = 0;
+    for (const entry of queuedWorkLoops.values()) {
+        if (!keySet.has(entry.activeKey)) {
+            continue;
+        }
+        entry.canceled = true;
+        entry.release();
+        queuedWorkLoops.delete(entry.id);
+        removed += 1;
+    }
+    for (const key of keys) {
+        workLoopGenerations.set(key, (workLoopGenerations.get(key) ?? 0) + 1);
+    }
+    return removed;
+}
+function registerQueuedWorkLoop(input) {
+    const sequence = nextQueuedWorkSequence;
+    nextQueuedWorkSequence += 1;
+    const entry = {
+        id: `Q${String(sequence).padStart(3, "0")}`,
+        sequence,
+        activeKey: input.activeKey,
+        botId: input.botId,
+        chatId: input.chatId,
+        sessionId: input.sessionId,
+        publicSessionId: input.publicSessionId,
+        messagePreview: summarizeQueuedInstruction(input.message),
+        createdAt: new Date().toISOString(),
+        canceled: false,
+        release: input.release,
+    };
+    queuedWorkLoops.set(entry.id, entry);
+    return entry;
+}
+function listQueuedWorkLoops(activeKey) {
+    return [...queuedWorkLoops.values()]
+        .filter((entry) => entry.activeKey === activeKey && !entry.canceled)
+        .sort((left, right) => left.sequence - right.sequence);
+}
+function removeQueuedWorkLoop(activeKey, selector) {
+    const entries = listQueuedWorkLoops(activeKey);
+    const target = selector
+        ? queuedWorkLoops.get(normalizeQueueId(selector))
+        : entries.at(-1);
+    if (!target || target.activeKey !== activeKey || target.canceled) {
+        return undefined;
+    }
+    target.canceled = true;
+    target.release();
+    queuedWorkLoops.delete(target.id);
+    return target;
+}
+function normalizeQueueId(value) {
+    const normalized = value.trim().toUpperCase();
+    if (/^\d+$/.test(normalized)) {
+        return `Q${normalized.padStart(3, "0")}`;
+    }
+    return normalized;
+}
+function summarizeQueuedInstruction(message) {
+    const normalized = message.replace(/\s+/g, " ").trim();
+    return normalized.length > 100 ? `${normalized.slice(0, 97)}...` : normalized;
+}
+function formatQueuedWorkLoops(activeKey, publicSessionId) {
+    const entries = listQueuedWorkLoops(activeKey);
+    if (entries.length === 0) {
+        return `No queued instructions for ${publicSessionId ?? "this chat"}.`;
+    }
+    return [
+        `Queued instructions for ${publicSessionId ?? "this chat"} (${entries.length})`,
+        ...entries.map((entry) => `${entry.id}: ${entry.messagePreview || "(empty instruction)"}`),
+        "",
+        `Remove one: /queue remove ${entries[0].id}`,
+        "Remove latest: /queue del",
+    ].join("\n");
+}
 class SilentTelegramAbort extends Error {
     constructor(message) {
         super(message);
@@ -1711,6 +1941,124 @@ function parseCommand(text, headCount) {
         rest: remaining || undefined,
     };
 }
+function parseMacroCommandText(text, botId) {
+    const body = stripSlashCommand(text, ["macro", "매크로"], botId).trim();
+    if (!body) {
+        return { kind: "help" };
+    }
+    const tokens = tokenizeCommandBody(body);
+    const action = tokens[0]?.toLowerCase();
+    if (action === "list") {
+        return { kind: "help" };
+    }
+    if (action === "set") {
+        const alias = tokens[1]?.trim();
+        const prompt = tokens.length >= 3
+            ? tokens.slice(2).join(" ").trim()
+            : "";
+        if (!alias || !prompt) {
+            throw new Error("Usage: /macro set <alias> <instruction>");
+        }
+        return { kind: "set", alias, prompt };
+    }
+    if (action === "remove" || action === "rm" || action === "delete" || action === "del" || action === "clear") {
+        const alias = tokens[1]?.trim();
+        if (!alias || tokens.length > 2) {
+            throw new Error("Usage: /macro remove <alias>");
+        }
+        return { kind: "remove", alias };
+    }
+    return { kind: "run", target: tokens.length === 1 ? tokens[0] : body };
+}
+function parseKoreanMacroCommand(text, botId) {
+    return Boolean(text && stripSlashCommand(text, ["매크로"], botId) !== text);
+}
+function stripSlashCommand(text, names, botId) {
+    const trimmed = text?.trim() ?? "";
+    for (const name of names) {
+        const escaped = escapeRegExp(name);
+        const username = botId ? `(?:@${escapeRegExp(botId.replace(/^@/, ""))})?` : "(?:@\\w+)?";
+        const pattern = new RegExp(`^/${escaped}${username}(?:\\s+|$)`, "i");
+        if (pattern.test(trimmed)) {
+            return trimmed.replace(pattern, "");
+        }
+    }
+    return trimmed;
+}
+function tokenizeCommandBody(input) {
+    const tokens = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    for (const char of input) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (escaped) {
+        current += "\\";
+    }
+    if (quote) {
+        throw new Error("Unclosed quote in command.");
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function formatMacroHelp(memoryService) {
+    return [
+        "Macro command guide",
+        "",
+        "Commands:",
+        "```text",
+        "/macro",
+        "/macro set 초기설정 너의 역할은 ...",
+        "/macro set '초기설정' '너의 역할은 ...'",
+        "/macro 초기설정",
+        "/macro 1",
+        "/macro remove 초기설정",
+        "/매크로",
+        "/매크로 초기설정",
+        "```",
+        "",
+        "Rules:",
+        "- Macro aliases can use Korean, letters, numbers, dot, underscore, and dash.",
+        "- Numeric-only aliases are reserved for list selection and cannot be registered.",
+        "",
+        await memoryService.listMacros(),
+    ].join("\n");
+}
 function parsePlanReinforcementCount(raw) {
     const value = raw?.trim();
     if (!value) {

package/dist/config.js

@@ -152,6 +152,8 @@ export const config = {
     artifactCleanupEnabled: readBoolean("ARTIFACT_CLEANUP_ENABLED", true),
     artifactRetentionDays: readTimeout("ARTIFACT_RETENTION_DAYS", 30),
     artifactCleanupIntervalMs: readTimeout("ARTIFACT_CLEANUP_INTERVAL_MS", 86_400_000),
+    workspaceCleanupEnabled: readBoolean("WORKSPACE_CLEANUP_ENABLED", true),
+    workspaceCleanupIntervalMs: readTimeout("WORKSPACE_CLEANUP_INTERVAL_MS", 86_400_000),
     dataDir: defaultDataDir,
     defaultMode: readMode("DEFAULT_MODE", "codex"),
     defaultWorkspace: path.resolve(process.env.DEFAULT_WORKSPACE?.trim() || os.homedir()),

package/dist/index.js

@@ -14,11 +14,13 @@ import { BridgeService } from "./services/bridge-service.js";
 import { BotManagementService } from "./services/bot-management-service.js";
 import { LocalUiService } from "./services/local-ui-service.js";
 import { AgentMemoryService } from "./services/agent-memory-service.js";
+import { WorkspaceCleanupService } from "./services/workspace-cleanup-service.js";
 import { BotPollingStateService } from "./services/bot-polling-state-service.js";
 import { ProviderRecoveryService } from "./services/provider-recovery-service.js";
 import { computePolicyPollIntervalMs, computeRecentMessageRanks } from "./services/polling-policy.js";
 import { terminateAllSpawnedExecutions } from "./adapters/windows-shell.js";
 import { setTelegramCommandMenu } from "./telegram-command-menu.js";
+import { buildBotInfoFromIdentity, buildFallbackBotInfo } from "./telegram-bot-identity.js";
 const execFileAsync = promisify(execFile);
 const TELEGRAM_GET_UPDATES_HTTP_TIMEOUT_SECONDS = 30;
 const TELEGRAM_GET_UPDATES_CURL_TIMEOUT_SECONDS = 60;
@@ -56,6 +58,7 @@ async function main() {
     const bridge = new BridgeService(store, adapters, config.defaultWorkspace, config.workspaceRoot, isProviderInstalled, config.defaultMode, config.codexSandboxMode);
     const botManagement = new BotManagementService(config.dataDir, config.botRestartServiceName, config.botRestartHelperPath, botPollingState);
     startArtifactCleanupSchedule(new AgentMemoryService(config.dataDir));
+    startWorkspaceCleanupSchedule(new WorkspaceCleanupService(config.dataDir, config.workspaceRoot));
     if (config.localUiEnabled) {
         const localUi = new LocalUiService(bridge, config.localUiHost, config.localUiPort);
         await localUi.start()
@@ -66,7 +69,7 @@ async function main() {
             console.error("Local UI failed to start:", error);
         });
     }
-    const botInfos = await Promise.all(config.telegramBotTokens.map((token, index) => resolveBotInfo(token, index)));
+    const botInfos = await Promise.all(config.telegramBotTokens.map((token, index) => resolveBotInfo(token, index, config.telegramBotUsernames[index])));
     const bots = config.telegramBotTokens.map((token, index) => createBot(token, bridge, botManagement, botInfos[index]));
     if (config.telegramCommandMenuEnabled) {
         for (const bot of bots) {
@@ -88,6 +91,30 @@ async function main() {
     });
     await startManualPollingScheduler(bots);
 }
+function startWorkspaceCleanupSchedule(workspaceCleanupService) {
+    if (!config.workspaceCleanupEnabled) {
+        console.log("Workspace cleanup schedule is disabled.");
+        return;
+    }
+    const run = async () => {
+        try {
+            const result = await workspaceCleanupService.cleanupOrphanWorkspaces();
+            console.log(`[workspace-cleanup] ${result}`);
+        }
+        catch (error) {
+            console.error("[workspace-cleanup] failed:", error);
+        }
+    };
+    console.log(`Workspace cleanup schedule enabled: interval=${config.workspaceCleanupIntervalMs}ms`);
+    const initial = setTimeout(() => {
+        void run();
+    }, 120_000);
+    initial.unref();
+    const interval = setInterval(() => {
+        void run();
+    }, config.workspaceCleanupIntervalMs);
+    interval.unref();
+}
 function startArtifactCleanupSchedule(memoryService) {
     if (!config.artifactCleanupEnabled) {
         console.log("Artifact cleanup schedule is disabled.");
@@ -458,7 +485,7 @@ class AsyncSemaphore {
         }
     }
 }
-async function resolveBotInfo(token, index) {
+async function resolveBotInfo(token, index, configuredUsername) {
     try {
         const { stdout } = await execFileAsync("curl", [
             "-sS",
@@ -476,32 +503,7 @@ async function resolveBotInfo(token, index) {
     catch (error) {
         console.warn(`Telegram getMe failed for bot ${tokenIdLabel(token)}: ${summarizeTelegramIdentityError(error)}`);
     }
-    return buildFallbackBotInfo(token, index);
-}
-function buildBotInfoFromIdentity(id, username, firstName) {
-    return {
-        id,
-        is_bot: true,
-        first_name: firstName || username,
-        username,
-        can_join_groups: false,
-        can_read_all_group_messages: false,
-        supports_inline_queries: false,
-    };
-}
-function buildFallbackBotInfo(token, index) {
-    const id = Number.parseInt(token.split(":", 1)[0] ?? "", 10);
-    const fallbackUsername = knownBotUsername(id);
-    const username = fallbackUsername || `bot_${Number.isFinite(id) ? id : index + 1}`;
-    return {
-        id: Number.isFinite(id) ? id : index + 1,
-        is_bot: true,
-        first_name: username,
-        username,
-        can_join_groups: false,
-        can_read_all_group_messages: false,
-        supports_inline_queries: false,
-    };
+    return buildFallbackBotInfo(token, index, configuredUsername);
 }
 function tokenIdLabel(token) {
     return token.split(":", 1)[0] || "unknown";
@@ -517,15 +519,6 @@ function summarizeTelegramIdentityError(error) {
         .filter(Boolean)
         .join(" ");
 }
-function knownBotUsername(id) {
-    if (id === 8369496408) {
-        return "codex_remoteagent_bot";
-    }
-    if (id === 8429712341) {
-        return "sqream_bot";
-    }
-    return undefined;
-}
 function commandExists(command) {
     const trimmed = command.trim();
     if (!trimmed) {