appback-remoteagent 0.20.0 → 0.21.0

package/README.md

@@ -325,7 +325,7 @@ remoteagent bot add
 remoteagent-start
 ```
 
-The command validates the BotFather token, stores the bot configuration, and configures the numeric Telegram owner user ID. Tokens are entered through a hidden prompt by default.
+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.
 
 To move installation-wide `/secret` values to another PC, export and import a password-encrypted bundle:
 

package/dist/cli.js

@@ -1,9 +1,9 @@
 import fs from "node:fs/promises";
+import { randomBytes } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import readline from "node:readline/promises";
-import { registerTelegramBot, readConfiguredOwnerId } from "./services/cli-config-service.js";
+import { fetchTelegramBotIdentity, registerTelegramBot, 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);
@@ -46,9 +46,27 @@ async function addBot(dataDir, args) {
     if (args.length > 0) {
         throw new Error(`Unexpected bot argument: ${args[0]}`);
     }
+    const identity = await fetchTelegramBotIdentity(token);
     const configuredOwner = await readConfiguredOwnerId(dataDir);
-    const ownerId = ownerOption || configuredOwner || await promptVisible("Telegram owner user ID: ");
-    const result = await registerTelegramBot({ dataDir, token, ownerId });
+    let ownerId = ownerOption || configuredOwner;
+    if (!ownerId) {
+        const startPayload = `ra_${randomBytes(8).toString("hex")}`;
+        console.log([
+            `Validated @${identity.username} (${identity.id}).`,
+            "",
+            "Open this Telegram link within 3 minutes to confirm the owner:",
+            `  https://t.me/${identity.username}?start=${startPayload}`,
+            "",
+            "Or send this exact command to the bot:",
+            `  /start ${startPayload}`,
+            "",
+            "Waiting for owner confirmation...",
+        ].join("\n"));
+        const owner = await waitForTelegramOwner(token, startPayload);
+        ownerId = owner.id;
+        console.log(`Detected Telegram owner: ${owner.displayName}${owner.username ? ` (@${owner.username})` : ""} (${owner.id})`);
+    }
+    const result = await registerTelegramBot({ dataDir, token, ownerId, identity });
     console.log([
         `${result.added ? "Registered" : "Updated"} @${result.identity.username} (${result.identity.id}).`,
         `Configured bots: ${result.botCount}`,
@@ -119,18 +137,6 @@ function takeFlag(args, name) {
     args.splice(index, 1);
     return true;
 }
-async function promptVisible(question) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        throw new Error(`${question.trim()} is required as a command option in non-interactive mode.`);
-    }
-    const terminal = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        return (await terminal.question(question)).trim();
-    }
-    finally {
-        terminal.close();
-    }
-}
 async function promptHidden(question) {
     if (!process.stdin.isTTY || !process.stdout.isTTY || !process.stdin.setRawMode) {
         throw new Error("Interactive hidden input requires a TTY. Use the corresponding --*-file option instead.");

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

@@ -1,5 +1,8 @@
+import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
 export async function registerTelegramBot(options) {
     const token = options.token.trim();
     const ownerId = options.ownerId.trim();
@@ -63,30 +66,121 @@ export async function readConfiguredOwnerId(dataDir) {
 }
 export async function fetchTelegramBotIdentity(token) {
     assertBotToken(token);
-    let response;
+    let stdout;
     try {
-        response = await fetch(`https://api.telegram.org/bot${token}/getMe`, {
-            signal: AbortSignal.timeout(20_000),
-        });
+        const result = await execFileAsync("curl", [
+            "-4",
+            "-sS",
+            "--connect-timeout",
+            "10",
+            "--max-time",
+            "20",
+            `https://api.telegram.org/bot${token}/getMe`,
+        ]);
+        stdout = result.stdout;
+        if (result.stderr?.trim()) {
+            console.error(`curl stderr for Telegram getMe: ${result.stderr.trim()}`);
+        }
     }
-    catch {
-        throw new Error("Telegram getMe request failed. Check this machine's network and DNS, then retry.");
+    catch (error) {
+        const detail = error instanceof Error ? error.message.replace(token, "[redacted]") : String(error);
+        throw new Error(`Telegram getMe request failed over IPv4: ${detail}`);
     }
     let payload;
     try {
-        payload = await response.json();
+        payload = JSON.parse(stdout);
     }
     catch {
-        throw new Error(`Telegram getMe returned an invalid response (HTTP ${response.status}).`);
+        throw new Error("Telegram getMe returned an invalid response.");
     }
-    if (!response.ok || !payload.ok || !payload.result?.id || !payload.result.username) {
-        throw new Error(payload.description || `Telegram rejected the supplied bot token (HTTP ${response.status}).`);
+    if (!payload.ok || !payload.result?.id || !payload.result.username) {
+        throw new Error(payload.description || "Telegram rejected the supplied bot token.");
     }
     return {
         id: payload.result.id,
         username: payload.result.username,
     };
 }
+export async function waitForTelegramOwner(token, startPayload, timeoutMs = 180_000) {
+    assertBotToken(token);
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(startPayload)) {
+        throw new Error("Telegram start payload must use 1-64 URL-safe characters.");
+    }
+    const startedAt = Date.now();
+    let offset = await nextTelegramUpdateOffset(token);
+    while (Date.now() - startedAt < timeoutMs) {
+        const remainingMs = timeoutMs - (Date.now() - startedAt);
+        const pollSeconds = Math.max(1, Math.min(15, Math.floor(remainingMs / 1000)));
+        const updates = await getTelegramUpdates(token, offset, pollSeconds);
+        for (const update of updates) {
+            if (typeof update.update_id === "number") {
+                offset = Math.max(offset, update.update_id + 1);
+            }
+            const message = update.message;
+            const sender = message?.from;
+            if (message?.chat?.type !== "private"
+                || sender?.is_bot
+                || typeof sender?.id !== "number"
+                || message.text?.trim() !== `/start ${startPayload}`) {
+                continue;
+            }
+            return {
+                id: String(sender.id),
+                username: sender.username,
+                displayName: [sender.first_name, sender.last_name].filter(Boolean).join(" ") || sender.username || String(sender.id),
+            };
+        }
+    }
+    throw new Error("Timed out waiting for the Telegram owner confirmation. Run the command again and use the new /start link.");
+}
+async function nextTelegramUpdateOffset(token) {
+    const updates = await getTelegramUpdates(token, undefined, 0);
+    return updates.reduce((next, update) => typeof update.update_id === "number" ? Math.max(next, update.update_id + 1) : next, 0);
+}
+async function getTelegramUpdates(token, offset, timeoutSeconds) {
+    const args = [
+        "-4",
+        "-sS",
+        "--get",
+        "--connect-timeout",
+        "10",
+        "--max-time",
+        String(Math.max(20, timeoutSeconds + 10)),
+        "--data-urlencode",
+        `timeout=${timeoutSeconds}`,
+        "--data-urlencode",
+        "limit=100",
+        "--data-urlencode",
+        'allowed_updates=["message"]',
+    ];
+    if (offset !== undefined) {
+        args.push("--data-urlencode", `offset=${offset}`);
+    }
+    args.push(`https://api.telegram.org/bot${token}/getUpdates`);
+    let stdout;
+    try {
+        const result = await execFileAsync("curl", args);
+        stdout = result.stdout;
+        if (result.stderr?.trim()) {
+            console.error(`curl stderr for Telegram getUpdates: ${result.stderr.trim()}`);
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message.replace(token, "[redacted]") : String(error);
+        throw new Error(`Telegram getUpdates request failed over IPv4: ${detail}`);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("Telegram getUpdates returned an invalid response.");
+    }
+    if (!payload.ok || !Array.isArray(payload.result)) {
+        throw new Error(payload.description || "Telegram rejected the getUpdates request.");
+    }
+    return payload.result;
+}
 function assertBotToken(token) {
     if (!isBotToken(token)) {
         throw new Error("Invalid Telegram bot token format.");

package/docs/CLI_BOOTSTRAP_AND_SECRET_MIGRATION.md

@@ -11,9 +11,11 @@ remoteagent bot add
 remoteagent-start
 ```
 
-`remoteagent bot add` asks for the BotFather token without echoing it and then asks for the numeric Telegram owner user ID. It validates the token with Telegram `getMe` before writing `~/.remoteagent/.env`.
+`remoteagent bot add` asks for the BotFather token without echoing it and validates the token with Telegram `getMe`. On the first registration it then prints a one-time Telegram `/start` link and waits up to three minutes. Open that link from the Telegram account that will own the installation; RemoteAgent detects and stores that account's numeric user ID automatically. No manual owner ID lookup or entry is required.
 
-For automation, keep sensitive values out of shell history by using a permission-restricted token file:
+The confirmation update is consumed by the setup command. After `remoteagent-start`, send `/start` to the bot normally to begin using RemoteAgent.
+
+For unattended automation, keep sensitive values out of shell history by using a permission-restricted token file and pass the already verified owner ID explicitly:
 
 ```bash
 chmod 600 /secure/path/telegram-token

package/package.json

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

package/scripts/selftest-cli.mjs

@@ -4,7 +4,11 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { registerTelegramBot } from "../dist/services/cli-config-service.js";
+import {
+  fetchTelegramBotIdentity,
+  registerTelegramBot,
+  waitForTelegramOwner,
+} from "../dist/services/cli-config-service.js";
 import { exportSecrets, importSecrets } from "../dist/services/secret-transfer-service.js";
 
 const root = await fs.mkdtemp(path.join(os.tmpdir(), "remoteagent-cli-selftest-"));
@@ -15,6 +19,50 @@ const selectedBundlePath = path.join(root, "selected-transfer.ra-secrets");
 const passphrase = "correct-horse-battery-staple";
 
 try {
+  const binDir = path.join(root, "bin");
+  const curlArgsPath = path.join(root, "curl-args.txt");
+  const curlUpdateCallsPath = path.join(root, "curl-update-calls.txt");
+  await fs.mkdir(binDir, { recursive: true });
+  await fs.writeFile(path.join(binDir, "curl"), `#!/usr/bin/env bash
+printf '%s\\n' "$@" > ${JSON.stringify(curlArgsPath)}
+if printf '%s\\n' "$@" | grep -q '/getUpdates'; then
+  count=0
+  if [ -f ${JSON.stringify(curlUpdateCallsPath)} ]; then
+    count="$(cat ${JSON.stringify(curlUpdateCallsPath)})"
+  fi
+  count=$((count + 1))
+  printf '%s' "$count" > ${JSON.stringify(curlUpdateCallsPath)}
+  if [ "$count" -eq 1 ]; then
+    printf '{"ok":true,"result":[{"update_id":41,"message":{"text":"/start stale_payload","chat":{"id":777,"type":"private"},"from":{"id":777,"is_bot":false,"username":"stale"}}}]}'
+  else
+    printf '{"ok":true,"result":[{"update_id":42,"message":{"text":"/start ra_selftest","chat":{"id":8202993989,"type":"private"},"from":{"id":8202993989,"is_bot":false,"username":"roy","first_name":"Roy"}}}]}'
+  fi
+else
+  printf '{"ok":true,"result":{"id":100000,"username":"bootstrap_test_bot"}}'
+fi
+`, { mode: 0o755 });
+  const originalPath = process.env.PATH;
+  process.env.PATH = `${binDir}:${originalPath ?? ""}`;
+  const fetchedIdentity = await fetchTelegramBotIdentity("100000:abcdefghijklmnopqrstuvwxyz_123456");
+  assert.deepEqual(fetchedIdentity, { id: 100000, username: "bootstrap_test_bot" });
+  const curlArgs = await fs.readFile(curlArgsPath, "utf8");
+  assert.match(curlArgs, /^-4$/m);
+  assert.match(curlArgs, /\/getMe$/m);
+  const detectedOwner = await waitForTelegramOwner(
+    "100000:abcdefghijklmnopqrstuvwxyz_123456",
+    "ra_selftest",
+    2_000,
+  );
+  assert.deepEqual(detectedOwner, {
+    id: "8202993989",
+    username: "roy",
+    displayName: "Roy",
+  });
+  const ownerCurlArgs = await fs.readFile(curlArgsPath, "utf8");
+  assert.match(ownerCurlArgs, /^-4$/m);
+  assert.match(ownerCurlArgs, /^offset=42$/m);
+  process.env.PATH = originalPath;
+
   await fs.mkdir(sourceDataDir, { recursive: true });
   await fs.writeFile(path.join(sourceDataDir, ".env"), [
     "TELEGRAM_BOT_TOKEN=your-telegram-bot-token",