clawgram 2.0.0

package/dist/clawgram-cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_runtime_1 = require("openclaw/plugin-sdk/config-runtime");
+const cli_core_1 = require("./cli-core");
+async function main() {
+    const { snapshot } = await (0, config_runtime_1.readConfigFileSnapshotForWrite)();
+    const exitCode = await (0, cli_core_1.runTelegramUserbotStandaloneCli)(process.argv.slice(2), snapshot.config);
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/cli-core.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTelegramUserbotCliFlags = runTelegramUserbotCliFlags;
+exports.runTelegramUserbotStandaloneCli = runTelegramUserbotStandaloneCli;
+const node_readline_1 = __importDefault(require("node:readline"));
+const telegram_1 = require("telegram");
+const sessions_1 = require("telegram/sessions");
+const config_runtime_1 = require("openclaw/plugin-sdk/config-runtime");
+const constants_1 = require("./constants");
+const update_config_1 = require("./update-config");
+function printRestartNotice() {
+    console.log("");
+    console.log("After applying config changes, restart OpenClaw:");
+    console.log("openclaw gateway restart");
+}
+function createPrompt() {
+    const rl = node_readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (question) => new Promise((resolve) => {
+        rl.question(question, resolve);
+    });
+    return {
+        ask,
+        async askRequired(question) {
+            for (;;) {
+                const answer = (await ask(question)).trim();
+                if (answer) {
+                    return answer;
+                }
+                console.log("Value is required.");
+            }
+        },
+        async askPositiveInteger(question) {
+            for (;;) {
+                const answer = (await ask(question)).trim();
+                if (!/^[1-9]\d*$/.test(answer)) {
+                    console.log("Enter a positive integer.");
+                    continue;
+                }
+                const parsed = Number(answer);
+                if (!Number.isSafeInteger(parsed)) {
+                    console.log("Number is too large.");
+                    continue;
+                }
+                return parsed;
+            }
+        },
+        async askYesNo(question, defaultValue = false) {
+            for (;;) {
+                const answer = (await ask(question)).trim().toLowerCase();
+                if (!answer) {
+                    return defaultValue;
+                }
+                if (["y", "yes", "да", "д"].includes(answer)) {
+                    return true;
+                }
+                if (["n", "no", "нет", "н"].includes(answer)) {
+                    return false;
+                }
+                console.log("Please answer yes or no.");
+            }
+        },
+        close() {
+            rl.close();
+        },
+    };
+}
+function resolveDefaultAccountId(config) {
+    const accounts = config?.channels?.[constants_1.CHANNEL_ID]?.accounts;
+    if (!accounts || typeof accounts !== "object") {
+        return "default";
+    }
+    const firstAccountId = Object.keys(accounts).find((accountId) => accountId.trim());
+    return firstAccountId?.trim() || "default";
+}
+function buildAccountConfigFragment(auth) {
+    return {
+        enabled: true,
+        apiId: auth.apiId,
+        apiHash: auth.apiHash,
+        sessionString: auth.sessionString,
+        allowFrom: ["*"],
+        groups: {
+            "*": {
+                enabled: true,
+                groupPolicy: "mention",
+                allowFrom: ["*"],
+            },
+        },
+    };
+}
+function buildConfigFragment(accountId, auth) {
+    return {
+        channels: {
+            [constants_1.CHANNEL_ID]: {
+                accounts: {
+                    [accountId]: buildAccountConfigFragment(auth),
+                },
+            },
+        },
+    };
+}
+async function runTelegramAuthorization(prompt) {
+    const apiId = await prompt.askPositiveInteger("Please enter your apiId: ");
+    const apiHash = await prompt.askRequired("Please enter your apiHash: ");
+    const client = new telegram_1.TelegramClient(new sessions_1.StringSession(""), apiId, apiHash, {
+        connectionRetries: 5,
+    });
+    try {
+        await client.start({
+            phoneNumber: async () => await prompt.askRequired("Please enter your number: "),
+            password: async () => await prompt.askRequired("Please enter your password: "),
+            phoneCode: async () => await prompt.askRequired("Please enter the code you received: "),
+            onError: (error) => {
+                console.log(error);
+            },
+        });
+        return {
+            apiId,
+            apiHash,
+            sessionString: String(client.session.save()),
+        };
+    }
+    finally {
+        await client.destroy().catch(() => undefined);
+    }
+}
+async function runTelegramUserbotAuth(config) {
+    const prompt = createPrompt();
+    try {
+        console.log("Starting Clawgram authorization...");
+        const auth = await runTelegramAuthorization(prompt);
+        console.log("Telegram authorization completed successfully.");
+        console.log("");
+        console.log("Session string:");
+        console.log(auth.sessionString);
+        console.log("");
+        const defaultAccountId = resolveDefaultAccountId(config);
+        const rawAccountId = await prompt.ask(`Enter account id for config [${defaultAccountId}]: `);
+        const accountId = rawAccountId.trim() || defaultAccountId;
+        const shouldUpdateConfig = await prompt.askYesNo("Update OpenClaw config automatically? [y/N]: ", false);
+        const { snapshot } = await (0, config_runtime_1.readConfigFileSnapshotForWrite)();
+        if (!shouldUpdateConfig) {
+            console.log("");
+            console.log("JSON fragment for manual insertion:");
+            console.log(JSON.stringify(buildConfigFragment(accountId, auth), null, 2));
+            printRestartNotice();
+            return;
+        }
+        if (!snapshot.exists || !snapshot.path) {
+            console.log("");
+            console.log("Automatic config update is unavailable because openclaw.json was not found.");
+            console.log("");
+            console.log("JSON fragment for manual insertion:");
+            console.log(JSON.stringify(buildConfigFragment(accountId, auth), null, 2));
+            printRestartNotice();
+            return;
+        }
+        try {
+            const backupPath = await (0, update_config_1.createConfigBackup)(snapshot.path);
+            await (0, update_config_1.updateConfigFileDirectly)(snapshot.path, accountId, auth);
+            console.log("");
+            console.log(`OpenClaw config updated: ${snapshot.path}`);
+            console.log(`Configured account id: ${accountId}`);
+            if (backupPath) {
+                console.log(`Config backup created: ${backupPath}`);
+            }
+            printRestartNotice();
+            return;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log("");
+            console.log(`Automatic config update failed: ${message}`);
+            if (snapshot.issues.length > 0) {
+                console.log("Current config validation issues:");
+                for (const issue of snapshot.issues) {
+                    console.log(`- ${issue.path || "<root>"}: ${issue.message}`);
+                }
+            }
+            console.log("");
+            console.log("JSON fragment for manual insertion:");
+            console.log(JSON.stringify(buildConfigFragment(accountId, auth), null, 2));
+            printRestartNotice();
+        }
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function runTelegramUserbotCliFlags(config, options) {
+    const enabledFlags = [options.hello, options.auth].filter(Boolean).length;
+    if (enabledFlags === 0) {
+        console.log("Specify one flag: --hello or --auth");
+        return;
+    }
+    if (enabledFlags > 1) {
+        console.log("Use only one flag at a time: --hello or --auth");
+        return;
+    }
+    if (options.hello) {
+        console.log("Hello from clawgram");
+        return;
+    }
+    if (options.auth) {
+        await runTelegramUserbotAuth(config);
+    }
+}
+async function runTelegramUserbotStandaloneCli(argv, config) {
+    const flags = new Set(argv);
+    const hasHelp = flags.has("-h") || flags.has("--help") || flags.has("help");
+    if (argv.length === 0 || hasHelp) {
+        console.log("Usage: clawgram-cli <--hello|--auth>");
+        return 0;
+    }
+    const unsupportedArgs = argv.filter((arg) => !["--hello", "--auth"].includes(arg));
+    if (unsupportedArgs.length > 0) {
+        console.log(`Unknown argument(s): ${unsupportedArgs.join(", ")}`);
+        console.log("Usage: clawgram-cli <--hello|--auth>");
+        return 1;
+    }
+    if (flags.has("--hello") || flags.has("--auth")) {
+        await runTelegramUserbotCliFlags(config, {
+            hello: flags.has("--hello"),
+            auth: flags.has("--auth"),
+        });
+        return 0;
+    }
+    console.log("Specify one flag: --hello or --auth");
+    return 1;
+}

package/dist/cli.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTelegramUserbotCli = registerTelegramUserbotCli;
+exports.getTelegramUserbotCliDescriptors = getTelegramUserbotCliDescriptors;
+const constants_1 = require("./constants");
+const cli_core_1 = require("./cli-core");
+function registerTelegramUserbotCli(program, config) {
+    program
+        .command(constants_1.CLI_COMMAND)
+        .description("Clawgram CLI utilities")
+        .option("--hello", "Print a greeting from the clawgram plugin")
+        .option("--auth", "Authorize a Telegram account for clawgram")
+        .action(async (options) => {
+        await (0, cli_core_1.runTelegramUserbotCliFlags)(config, options);
+    });
+}
+function getTelegramUserbotCliDescriptors() {
+    return [
+        {
+            name: constants_1.CLI_COMMAND,
+            description: "Clawgram CLI utilities",
+            hasSubcommands: false,
+        },
+    ];
+}

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_COMMAND = exports.CHANNEL_ID = void 0;
+const CHANNEL_ID = "clawgram";
+exports.CHANNEL_ID = CHANNEL_ID;
+const CLI_COMMAND = "clawgram";
+exports.CLI_COMMAND = CLI_COMMAND;