appback-remoteagent 0.22.3 → 0.23.0

package/README.md

@@ -329,6 +329,13 @@ remoteagent-start
 
 The command validates the BotFather token and shows a one-time Telegram `/start` link. Open that link from the account that will own the installation; RemoteAgent detects the sender's numeric user ID and stores it as the owner automatically. The token is entered through a hidden prompt, and the owner ID does not need to be looked up or typed manually.
 
+Remove a configured bot by username or numeric Bot ID, then restart the runtime:
+
+```bash
+remoteagent bot remove @example_bot
+sudo systemctl restart remoteagent
+```
+
 To move installation-wide `/secret` values to another PC, export and import a password-encrypted bundle:
 
 ```bash

package/dist/cli.js

@@ -3,7 +3,7 @@ import { randomBytes } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { fetchTelegramBotIdentity, registerTelegramBot, readConfiguredOwnerId, waitForTelegramOwner, } from "./services/cli-config-service.js";
+import { fetchTelegramBotIdentity, registerTelegramBot, removeTelegramBot, readConfiguredOwnerId, waitForTelegramOwner, } from "./services/cli-config-service.js";
 import { exportSecrets, importSecrets } from "./services/secret-transfer-service.js";
 async function main() {
     const args = process.argv.slice(2);
@@ -21,6 +21,10 @@ async function main() {
         await addBot(dataDir, args.slice(2));
         return;
     }
+    if (group === "bot" && action === "remove") {
+        await removeBot(dataDir, args.slice(2));
+        return;
+    }
     if (group === "secret" && action === "export") {
         await exportSecretCommand(dataDir, args.slice(2));
         return;
@@ -76,6 +80,25 @@ async function addBot(dataDir, args) {
         "  # systemd runtime: sudo systemctl restart remoteagent",
     ].join("\n"));
 }
+async function removeBot(dataDir, args) {
+    if (args.some((arg) => arg.startsWith("--"))) {
+        throw new Error(`Unknown bot remove option: ${args.find((arg) => arg.startsWith("--"))}`);
+    }
+    const selector = args.shift();
+    if (!selector || args.length > 0) {
+        throw new Error("Usage: remoteagent bot remove <username|id>");
+    }
+    const result = await removeTelegramBot({ dataDir, selector });
+    const label = result.username ? `@${result.username}` : `bot ${result.id}`;
+    console.log([
+        `Removed ${label} (${result.id}).`,
+        `Configured bots: ${result.botCount}`,
+        `Configuration: ${result.envPath}`,
+        "Start or restart RemoteAgent to apply it:",
+        "  remoteagent-start",
+        "  # systemd runtime: sudo systemctl restart remoteagent",
+    ].join("\n"));
+}
 async function exportSecretCommand(dataDir, args) {
     const passphraseFile = takeOption(args, "--passphrase-file");
     if (args.some((arg) => arg.startsWith("--"))) {
@@ -197,6 +220,7 @@ Usage:
   remoteagent                         Start the foreground runtime
   remoteagent bot add [token] [--owner <telegram-user-id>]
   remoteagent bot add --token-file <file> --owner <telegram-user-id>
+  remoteagent bot remove <username|id>
   remoteagent secret export [file] [--passphrase-file <file>]
   remoteagent secret import <file> [--replace] [--passphrase-file <file>]
 

package/dist/config.js

@@ -33,14 +33,13 @@ function readTelegramBotTokens() {
     return [readRequired("TELEGRAM_BOT_TOKEN")];
 }
 function readTelegramBotUsernames() {
-    const raw = process.env.TELEGRAM_BOT_USERNAMES?.trim();
-    if (!raw) {
+    const raw = process.env.TELEGRAM_BOT_USERNAMES;
+    if (raw === undefined || raw === "") {
         return [];
     }
     return raw
-        .split(/[\r\n,]+/)
-        .map((value) => value.trim())
-        .filter(Boolean);
+        .split(",")
+        .map((value) => value.trim());
 }
 function readOptional(name) {
     const value = process.env[name]?.trim();

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

@@ -437,7 +437,9 @@ export class BotManagementService {
             : singleTokenLine
                 ? [singleTokenLine.slice("TELEGRAM_BOT_TOKEN=".length).trim()].filter(Boolean)
                 : [];
-        const configuredUsernames = usernameLine ? this.parseCsv(usernameLine.slice("TELEGRAM_BOT_USERNAMES=".length)) : [];
+        const configuredUsernames = usernameLine
+            ? usernameLine.slice("TELEGRAM_BOT_USERNAMES=".length).split(",").map((value) => value.trim())
+            : [];
         const usernames = await this.normalizeUsernamesFromTelegram(tokens, configuredUsernames);
         return {
             lines,

package/dist/services/cli-config-service.js

@@ -18,7 +18,7 @@ export async function registerTelegramBot(options) {
     });
     const values = parseEnv(original);
     const configuredTokens = parseCsv(values.get("TELEGRAM_BOT_TOKENS") || values.get("TELEGRAM_BOT_TOKEN") || "");
-    const configuredUsernames = parseCsv(values.get("TELEGRAM_BOT_USERNAMES") || "");
+    const configuredUsernames = parseCsvSlots(values.get("TELEGRAM_BOT_USERNAMES") || "");
     const validIndexes = configuredTokens
         .map((configuredToken, index) => isBotToken(configuredToken) ? index : -1)
         .filter((index) => index >= 0);
@@ -54,6 +54,51 @@ export async function registerTelegramBot(options) {
         botCount: tokens.length,
     };
 }
+export async function removeTelegramBot(options) {
+    const selector = options.selector.trim().replace(/^@/, "").toLowerCase();
+    if (!selector) {
+        throw new Error("Usage: remoteagent bot remove <username|id>");
+    }
+    const envPath = path.join(options.dataDir, ".env");
+    const original = await fs.readFile(envPath, "utf8").catch((error) => {
+        if (error.code === "ENOENT") {
+            throw new Error(`RemoteAgent configuration was not found: ${envPath}`);
+        }
+        throw error;
+    });
+    const values = parseEnv(original);
+    const configuredTokens = parseCsv(values.get("TELEGRAM_BOT_TOKENS") || values.get("TELEGRAM_BOT_TOKEN") || "");
+    const configuredUsernames = parseCsvSlots(values.get("TELEGRAM_BOT_USERNAMES") || "");
+    const validIndexes = configuredTokens
+        .map((token, index) => isBotToken(token) ? index : -1)
+        .filter((index) => index >= 0);
+    const tokens = validIndexes.map((index) => configuredTokens[index]);
+    const usernames = validIndexes.map((index) => configuredUsernames[index] || "");
+    const targetIndex = tokens.findIndex((token, index) => token.slice(0, token.indexOf(":")) === selector
+        || usernames[index]?.toLowerCase() === selector);
+    if (targetIndex < 0) {
+        throw new Error(`Telegram bot was not found: ${options.selector.trim()}`);
+    }
+    if (tokens.length <= 1) {
+        throw new Error("Cannot remove the last configured bot.");
+    }
+    const removedToken = tokens[targetIndex];
+    const removedUsername = usernames[targetIndex] || undefined;
+    const remainingTokens = tokens.filter((_, index) => index !== targetIndex);
+    const remainingUsernames = usernames.filter((_, index) => index !== targetIndex);
+    const next = upsertEnv(original, {
+        TELEGRAM_BOT_TOKEN: remainingTokens[0],
+        TELEGRAM_BOT_TOKENS: remainingTokens.join(","),
+        TELEGRAM_BOT_USERNAMES: remainingUsernames.join(","),
+    });
+    await atomicWrite(envPath, next, 0o600);
+    return {
+        id: Number(removedToken.slice(0, removedToken.indexOf(":"))),
+        username: removedUsername,
+        envPath,
+        botCount: remainingTokens.length,
+    };
+}
 export async function readConfiguredOwnerId(dataDir) {
     const envPath = path.join(dataDir, ".env");
     const text = await fs.readFile(envPath, "utf8").catch((error) => {
@@ -200,6 +245,9 @@ function parseCsv(value) {
         .map((item) => item.trim())
         .filter(Boolean);
 }
+function parseCsvSlots(value) {
+    return value.split(",").map((item) => item.trim());
+}
 function parseEnv(text) {
     const result = new Map();
     for (const line of text.split(/\r?\n/)) {

package/docs/CLI_BOOTSTRAP_AND_SECRET_MIGRATION.md

@@ -22,6 +22,22 @@ chmod 600 /secure/path/telegram-token
 remoteagent bot add --token-file /secure/path/telegram-token --owner 123456789
 ```
 
+Remove a configured bot by username or numeric Bot ID, then restart the runtime:
+
+```bash
+remoteagent bot remove @example_bot
+sudo systemctl restart remoteagent
+```
+
+```bash
+remoteagent bot remove 123456789
+sudo systemctl restart remoteagent
+```
+
+The command updates `TELEGRAM_BOT_TOKEN`, `TELEGRAM_BOT_TOKENS`, and
+`TELEGRAM_BOT_USERNAMES` together. It does not print bot tokens and refuses to
+remove the final configured bot.
+
 After adding or updating a bot, apply the configuration with the runtime command appropriate to the installation:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.22.3",
+  "version": "0.23.0",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",

package/scripts/selftest-cli.mjs

@@ -7,6 +7,7 @@ import path from "node:path";
 import {
   fetchTelegramBotIdentity,
   registerTelegramBot,
+  removeTelegramBot,
   waitForTelegramOwner,
 } from "../dist/services/cli-config-service.js";
 import { buildProviderEnv, buildRuntimePath } from "../dist/adapters/runtime-env.js";
@@ -14,6 +15,7 @@ import { exportSecrets, importSecrets } from "../dist/services/secret-transfer-s
 
 const root = await fs.mkdtemp(path.join(os.tmpdir(), "remoteagent-cli-selftest-"));
 const sourceDataDir = path.join(root, "source");
+const sparseUsernameDataDir = path.join(root, "sparse-usernames");
 const targetDataDir = path.join(root, "target");
 const bundlePath = path.join(root, "transfer.ra-secrets");
 const selectedBundlePath = path.join(root, "selected-transfer.ra-secrets");
@@ -112,6 +114,55 @@ fi
   assert.doesNotMatch(envText, /your-telegram-bot-token/);
   assert.match(envText, /TELEGRAM_BOT_USERNAMES=first_remoteagent_bot,second_remoteagent_bot/);
 
+  const removedByUsername = await removeTelegramBot({
+    dataDir: sourceDataDir,
+    selector: "@second_remoteagent_bot",
+  });
+  assert.equal(removedByUsername.id, 100002);
+  assert.equal(removedByUsername.username, "second_remoteagent_bot");
+  assert.equal(removedByUsername.botCount, 1);
+  const envAfterUsernameRemoval = await fs.readFile(path.join(sourceDataDir, ".env"), "utf8");
+  assert.match(envAfterUsernameRemoval, /TELEGRAM_BOT_TOKEN=100001:abcdefghijklmnopqrstuvwxyz_123456/);
+  assert.match(envAfterUsernameRemoval, /TELEGRAM_BOT_TOKENS=100001:abcdefghijklmnopqrstuvwxyz_123456/);
+  assert.match(envAfterUsernameRemoval, /TELEGRAM_BOT_USERNAMES=first_remoteagent_bot/);
+  assert.doesNotMatch(envAfterUsernameRemoval, /second_remoteagent_bot/);
+
+  await assert.rejects(
+    removeTelegramBot({ dataDir: sourceDataDir, selector: "100001" }),
+    /Cannot remove the last configured bot/,
+  );
+  await assert.rejects(
+    removeTelegramBot({ dataDir: sourceDataDir, selector: "missing_bot" }),
+    /Telegram bot was not found/,
+  );
+
+  await registerTelegramBot({
+    dataDir: sourceDataDir,
+    token: "100002:abcdefghijklmnopqrstuvwxyz_654321",
+    ownerId: "8202993989",
+    identity: { id: 100002, username: "second_remoteagent_bot" },
+  });
+  const removedById = await removeTelegramBot({ dataDir: sourceDataDir, selector: "100001" });
+  assert.equal(removedById.username, "first_remoteagent_bot");
+  assert.equal(removedById.botCount, 1);
+
+  await fs.mkdir(sparseUsernameDataDir, { recursive: true });
+  await fs.writeFile(path.join(sparseUsernameDataDir, ".env"), [
+    "TELEGRAM_BOT_TOKEN=100001:abcdefghijklmnopqrstuvwxyz_123456",
+    "TELEGRAM_BOT_TOKENS=100001:abcdefghijklmnopqrstuvwxyz_123456,100002:abcdefghijklmnopqrstuvwxyz_654321",
+    "TELEGRAM_BOT_USERNAMES=,second_remoteagent_bot",
+    "TELEGRAM_OWNER_ID=8202993989",
+    "",
+  ].join("\n"), { mode: 0o600 });
+  const removedSparseUsername = await removeTelegramBot({
+    dataDir: sparseUsernameDataDir,
+    selector: "second_remoteagent_bot",
+  });
+  assert.equal(removedSparseUsername.id, 100002);
+  const sparseEnv = await fs.readFile(path.join(sparseUsernameDataDir, ".env"), "utf8");
+  assert.match(sparseEnv, /TELEGRAM_BOT_TOKENS=100001:abcdefghijklmnopqrstuvwxyz_123456/);
+  assert.doesNotMatch(sparseEnv, /100002:abcdefghijklmnopqrstuvwxyz_654321/);
+
   const sourceSecrets = {
     API_TOKEN: {
       key: "API_TOKEN",