clawgram 2.0.0

package/dist/update-config.js

@@ -0,0 +1,381 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigBackup = createConfigBackup;
+exports.updateConfigFileDirectly = updateConfigFileDirectly;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const constants_1 = require("./constants");
+function formatBackupTimestamp(date) {
+    const year = String(date.getUTCFullYear());
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+    return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
+function buildConfigBackupPath(configPath) {
+    const dir = node_path_1.default.dirname(configPath);
+    const fileName = node_path_1.default.basename(configPath);
+    const suffix = `${formatBackupTimestamp(new Date())}-clawgram-auth`;
+    return node_path_1.default.join(dir, `${fileName}.bak-${suffix}`);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildAccountPayload(auth) {
+    return {
+        enabled: true,
+        apiId: auth.apiId,
+        apiHash: auth.apiHash,
+        sessionString: auth.sessionString,
+    };
+}
+function buildAccountConfigFragment(auth) {
+    return {
+        ...buildAccountPayload(auth),
+        allowFrom: ["*"],
+        groups: {
+            "*": {
+                enabled: true,
+                groupPolicy: "mention",
+                allowFrom: ["*"],
+            },
+        },
+    };
+}
+function applyAuthToConfig(config, accountId, auth) {
+    const channels = config.channels && typeof config.channels === "object" ? config.channels : {};
+    const channelConfig = channels[constants_1.CHANNEL_ID] && typeof channels[constants_1.CHANNEL_ID] === "object" ? channels[constants_1.CHANNEL_ID] : {};
+    const accounts = channelConfig.accounts && typeof channelConfig.accounts === "object" ? channelConfig.accounts : {};
+    const existingAccount = accounts[accountId] && typeof accounts[accountId] === "object" ? accounts[accountId] : {};
+    return {
+        ...config,
+        channels: {
+            ...channels,
+            [constants_1.CHANNEL_ID]: {
+                ...channelConfig,
+                accounts: {
+                    ...accounts,
+                    [accountId]: {
+                        ...existingAccount,
+                        ...buildAccountPayload(auth),
+                        enabled: existingAccount.enabled ?? true,
+                        allowFrom: existingAccount.allowFrom ?? ["*"],
+                        groups: existingAccount.groups ?? {
+                            "*": {
+                                enabled: true,
+                                groupPolicy: "mention",
+                                allowFrom: ["*"],
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+function detectTextFormat(raw) {
+    const eol = raw.includes("\r\n") ? "\r\n" : "\n";
+    const indentMatch = raw.match(/^[ \t]+(?=(?:\"|')?[A-Za-z0-9_$-]+(?:\"|')?\s*:)/m);
+    return {
+        eol,
+        indentUnit: indentMatch?.[0] || "  ",
+    };
+}
+function getLineStart(raw, index) {
+    const lineStart = raw.lastIndexOf("\n", index - 1);
+    return lineStart === -1 ? 0 : lineStart + 1;
+}
+function getLineIndent(raw, index) {
+    const lineStart = getLineStart(raw, index);
+    let cursor = lineStart;
+    while (cursor < raw.length && (raw[cursor] === " " || raw[cursor] === "\t")) {
+        cursor += 1;
+    }
+    return raw.slice(lineStart, cursor);
+}
+function skipTrivia(raw, start) {
+    let index = start;
+    while (index < raw.length) {
+        const char = raw[index];
+        if (char === " " || char === "\t" || char === "\n" || char === "\r") {
+            index += 1;
+            continue;
+        }
+        if (char === "/" && raw[index + 1] === "/") {
+            index += 2;
+            while (index < raw.length && raw[index] !== "\n") {
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && raw[index + 1] === "*") {
+            index += 2;
+            while (index + 1 < raw.length && !(raw[index] === "*" && raw[index + 1] === "/")) {
+                index += 1;
+            }
+            index = Math.min(index + 2, raw.length);
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function readQuotedString(raw, start) {
+    const quote = raw[start];
+    let index = start + 1;
+    while (index < raw.length) {
+        const char = raw[index];
+        if (char === "\\") {
+            if (index + 1 >= raw.length) {
+                throw new Error("Unterminated escape sequence in config string.");
+            }
+            index += 2;
+            continue;
+        }
+        if (char === quote) {
+            return {
+                value: json5_1.default.parse(raw.slice(start, index + 1)),
+                end: index + 1,
+            };
+        }
+        index += 1;
+    }
+    throw new Error("Unterminated string in config file.");
+}
+function readIdentifier(raw, start) {
+    const first = raw[start];
+    if (!/[A-Za-z_$]/.test(first)) {
+        return null;
+    }
+    let end = start + 1;
+    while (end < raw.length && /[A-Za-z0-9_$-]/.test(raw[end])) {
+        end += 1;
+    }
+    return {
+        value: raw.slice(start, end),
+        end,
+    };
+}
+function scanEnclosedValue(raw, start, openChar, closeChar) {
+    let depth = 1;
+    let index = start + 1;
+    while (index < raw.length) {
+        const char = raw[index];
+        if (char === "\"" || char === "'") {
+            index = readQuotedString(raw, index).end;
+            continue;
+        }
+        if (char === "/" && raw[index + 1] === "/") {
+            index = skipTrivia(raw, index);
+            continue;
+        }
+        if (char === "/" && raw[index + 1] === "*") {
+            index = skipTrivia(raw, index);
+            continue;
+        }
+        if (char === openChar) {
+            depth += 1;
+            index += 1;
+            continue;
+        }
+        if (char === closeChar) {
+            depth -= 1;
+            index += 1;
+            if (depth === 0) {
+                return index;
+            }
+            continue;
+        }
+        if (openChar === "{" && char === "[") {
+            index = scanEnclosedValue(raw, index, "[", "]");
+            continue;
+        }
+        if (openChar === "[" && char === "{") {
+            index = scanEnclosedValue(raw, index, "{", "}");
+            continue;
+        }
+        index += 1;
+    }
+    throw new Error("Unterminated structured value in config file.");
+}
+function scanValue(raw, start) {
+    const char = raw[start];
+    if (char === "{") {
+        return {
+            end: scanEnclosedValue(raw, start, "{", "}"),
+            kind: "object",
+        };
+    }
+    if (char === "[") {
+        return {
+            end: scanEnclosedValue(raw, start, "[", "]"),
+            kind: "array",
+        };
+    }
+    if (char === "\"" || char === "'") {
+        return {
+            end: readQuotedString(raw, start).end,
+            kind: "string",
+        };
+    }
+    let end = start;
+    while (end < raw.length) {
+        const current = raw[end];
+        if (current === "," ||
+            current === "}" ||
+            current === "]" ||
+            current === "\n" ||
+            current === "\r" ||
+            current === "\t" ||
+            current === " " ||
+            (current === "/" && (raw[end + 1] === "/" || raw[end + 1] === "*"))) {
+            break;
+        }
+        end += 1;
+    }
+    return {
+        end,
+        kind: "scalar",
+    };
+}
+function findObjectEnd(raw, objectStart) {
+    return scanEnclosedValue(raw, objectStart, "{", "}");
+}
+function listObjectProperties(raw, objectStart) {
+    const properties = [];
+    const objectEnd = findObjectEnd(raw, objectStart);
+    let cursor = skipTrivia(raw, objectStart + 1);
+    while (cursor < objectEnd) {
+        if (raw[cursor] === "}") {
+            break;
+        }
+        const keyToken = raw[cursor] === "\"" || raw[cursor] === "'"
+            ? readQuotedString(raw, cursor)
+            : readIdentifier(raw, cursor);
+        if (!keyToken) {
+            throw new Error(`Unable to parse config object key near index ${cursor}.`);
+        }
+        const afterKey = skipTrivia(raw, keyToken.end);
+        if (raw[afterKey] !== ":") {
+            throw new Error(`Expected ":" after config key "${keyToken.value}".`);
+        }
+        const valueStart = skipTrivia(raw, afterKey + 1);
+        const scannedValue = scanValue(raw, valueStart);
+        const afterValue = skipTrivia(raw, scannedValue.end);
+        const delimiter = raw[afterValue];
+        if (delimiter !== "," && delimiter !== "}") {
+            throw new Error(`Unexpected token after config key "${keyToken.value}".`);
+        }
+        properties.push({
+            key: keyToken.value,
+            keyStart: cursor,
+            valueStart,
+            valueEnd: scannedValue.end,
+            valueKind: scannedValue.kind,
+            delimiter,
+        });
+        if (delimiter === "}") {
+            break;
+        }
+        cursor = skipTrivia(raw, afterValue + 1);
+    }
+    return properties;
+}
+function findObjectProperty(raw, objectStart, key) {
+    return listObjectProperties(raw, objectStart).find((entry) => entry.key === key) ?? null;
+}
+function formatConfigValue(value, propertyIndent, format) {
+    const serialized = JSON.stringify(value, null, 2);
+    if (serialized === undefined) {
+        throw new Error("Unable to serialize config value.");
+    }
+    return serialized
+        .split("\n")
+        .map((line, index) => {
+        if (index === 0) {
+            return line;
+        }
+        const indentMatch = line.match(/^ +/);
+        const level = indentMatch ? Math.floor(indentMatch[0].length / 2) : 0;
+        return `${propertyIndent}${format.indentUnit.repeat(level)}${line.trimStart()}`;
+    })
+        .join(format.eol);
+}
+function replaceRange(raw, start, end, value) {
+    return `${raw.slice(0, start)}${value}${raw.slice(end)}`;
+}
+function insertObjectProperty(raw, objectStart, key, value, format) {
+    const objectEnd = findObjectEnd(raw, objectStart);
+    const parentIndent = getLineIndent(raw, objectStart);
+    const propertyIndent = `${parentIndent}${format.indentUnit}`;
+    const propertyText = `${JSON.stringify(key)}: ${formatConfigValue(value, propertyIndent, format)}`;
+    const properties = listObjectProperties(raw, objectStart);
+    if (properties.length === 0) {
+        const insertion = `${format.eol}${propertyIndent}${propertyText}${format.eol}${parentIndent}`;
+        return replaceRange(raw, objectEnd, objectEnd, insertion);
+    }
+    let insertAt = objectEnd;
+    while (insertAt > objectStart + 1 && /[ \t\r\n]/.test(raw[insertAt - 1])) {
+        insertAt -= 1;
+    }
+    const separator = properties[properties.length - 1]?.delimiter === "," ? "" : ",";
+    const insertion = `${separator}${format.eol}${propertyIndent}${propertyText}`;
+    return replaceRange(raw, insertAt, insertAt, insertion);
+}
+function replaceObjectPropertyValue(raw, property, value, format) {
+    const propertyIndent = getLineIndent(raw, property.keyStart);
+    const formattedValue = formatConfigValue(value, propertyIndent, format);
+    return replaceRange(raw, property.valueStart, property.valueEnd, formattedValue);
+}
+function buildUpdatedConfigText(raw, accountId, auth) {
+    const parsed = json5_1.default.parse(raw);
+    if (!isPlainObject(parsed)) {
+        throw new Error("OpenClaw config root must be an object.");
+    }
+    const updatedConfig = applyAuthToConfig(parsed, accountId, auth);
+    const updatedChannels = isPlainObject(updatedConfig.channels) ? updatedConfig.channels : {};
+    const format = detectTextFormat(raw);
+    const rootStart = skipTrivia(raw, 0);
+    if (raw[rootStart] !== "{") {
+        throw new Error("OpenClaw config file is not a JSON object.");
+    }
+    const channelsProperty = findObjectProperty(raw, rootStart, "channels");
+    if (!channelsProperty) {
+        return insertObjectProperty(raw, rootStart, "channels", updatedChannels, format);
+    }
+    return replaceObjectPropertyValue(raw, channelsProperty, updatedChannels, format);
+}
+async function writeConfigAtomically(configPath, raw) {
+    const tempPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        await node_fs_1.promises.writeFile(tempPath, raw, "utf8");
+        await node_fs_1.promises.rename(tempPath, configPath);
+    }
+    catch (error) {
+        await node_fs_1.promises.unlink(tempPath).catch(() => undefined);
+        throw error;
+    }
+}
+async function createConfigBackup(configPath) {
+    const raw = await node_fs_1.promises.readFile(configPath, "utf8").catch(() => null);
+    if (raw === null) {
+        return null;
+    }
+    const backupPath = buildConfigBackupPath(configPath);
+    await node_fs_1.promises.writeFile(backupPath, raw, "utf8");
+    return backupPath;
+}
+async function updateConfigFileDirectly(configPath, accountId, auth) {
+    const raw = await node_fs_1.promises.readFile(configPath, "utf8");
+    const nextRaw = buildUpdatedConfigText(raw, accountId, auth);
+    if (nextRaw === raw) {
+        return;
+    }
+    await writeConfigAtomically(configPath, nextRaw);
+}

package/openclaw.plugin.json

@@ -0,0 +1,253 @@
+{
+  "id": "clawgram",
+  "name": "Clawgram",
+  "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
+  "version": "2.0.0",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  },
+  "channels": [
+    "clawgram"
+  ],
+  "channelConfigs": {
+    "clawgram": {
+      "schema": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "enabled": {
+            "type": "boolean"
+          },
+          "allowFrom": {
+            "type": "array",
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "number"
+                }
+              ]
+            }
+          },
+          "groups": {
+            "type": "object",
+            "propertyNames": {
+              "type": "string"
+            },
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": {
+                  "type": "boolean"
+                },
+                "groupPolicy": {
+                  "type": "string",
+                  "enum": [
+                    "open",
+                    "mention"
+                  ],
+                  "default": "mention"
+                },
+                "allowFrom": {
+                  "type": "array",
+                  "items": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "number"
+                      }
+                    ]
+                  }
+                }
+              }
+            }
+          },
+          "accounts": {
+            "type": "object",
+            "propertyNames": {
+              "type": "string"
+            },
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": {
+                  "type": "boolean"
+                },
+                "apiId": {
+                  "anyOf": [
+                    {
+                      "type": "integer",
+                      "exclusiveMinimum": 0,
+                      "maximum": 9007199254740991
+                    },
+                    {
+                      "type": "string",
+                      "pattern": "^[1-9][0-9]*$"
+                    }
+                  ]
+                },
+                "apiHash": {
+                  "type": "string"
+                },
+                "sessionString": {
+                  "type": "string"
+                },
+                "proxy": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "ip": {
+                      "type": "string",
+                      "minLength": 1,
+                      "pattern": "\\S"
+                    },
+                    "port": {
+                      "type": "integer",
+                      "minimum": 1,
+                      "maximum": 65535
+                    },
+                    "socksType": {
+                      "type": "integer",
+                      "enum": [
+                        4,
+                        5
+                      ]
+                    },
+                    "username": {
+                      "type": "string"
+                    },
+                    "password": {
+                      "type": "string"
+                    },
+                    "timeout": {
+                      "type": "number",
+                      "exclusiveMinimum": 0
+                    }
+                  },
+                  "required": [
+                    "ip",
+                    "port",
+                    "socksType"
+                  ]
+                },
+                "allowFrom": {
+                  "type": "array",
+                  "items": {
+                    "anyOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "number"
+                      }
+                    ]
+                  }
+                },
+                "groups": {
+                  "type": "object",
+                  "propertyNames": {
+                    "type": "string"
+                  },
+                  "additionalProperties": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "enabled": {
+                        "type": "boolean"
+                      },
+                      "groupPolicy": {
+                        "type": "string",
+                        "enum": [
+                          "open",
+                          "mention"
+                        ],
+                        "default": "mention"
+                      },
+                      "allowFrom": {
+                        "type": "array",
+                        "items": {
+                          "anyOf": [
+                            {
+                              "type": "string"
+                            },
+                            {
+                              "type": "number"
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  }
+                },
+                "readChats": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "Chat ids the account may read history and membership for. Absent means no restriction; an empty array denies everything."
+                },
+                "joinsJournalPath": {
+                  "type": "string",
+                  "description": "Where joins observed for this account are journalled. Defaults to a per-account file under the OpenClaw state directory."
+                }
+              },
+              "required": [
+                "apiId",
+                "apiHash",
+                "sessionString"
+              ]
+            }
+          }
+        }
+      },
+      "uiHints": {
+        "accounts.*.proxy": {
+          "label": "SOCKS Proxy",
+          "help": "Optional native SOCKS4/SOCKS5 proxy for this account's MTProto connection. GramJS uses raw TCP sockets, so OpenClaw's proxy.proxyUrl does not cover it. This is a SOCKS proxy, not a Telegram MTProxy.",
+          "advanced": true
+        },
+        "accounts.*.proxy.ip": {
+          "label": "Proxy Host",
+          "help": "Proxy hostname or IP address.",
+          "placeholder": "proxy.example.com"
+        },
+        "accounts.*.proxy.port": {
+          "label": "Proxy Port",
+          "help": "Proxy TCP port (1-65535).",
+          "placeholder": "1080"
+        },
+        "accounts.*.proxy.socksType": {
+          "label": "SOCKS Version",
+          "help": "5 for SOCKS5, 4 for SOCKS4.",
+          "placeholder": "5"
+        },
+        "accounts.*.proxy.username": {
+          "label": "Proxy Username",
+          "help": "Optional username for proxies that require authentication."
+        },
+        "accounts.*.proxy.password": {
+          "label": "Proxy Password",
+          "help": "Optional password for proxies that require authentication.",
+          "sensitive": true
+        },
+        "accounts.*.proxy.timeout": {
+          "label": "Proxy Timeout",
+          "help": "Optional proxy connection timeout in seconds (GramJS default: 5).",
+          "placeholder": "10"
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "clawgram",
+  "version": "2.0.0",
+  "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:test": "tsc -p tsconfig.test.json",
+    "test": "npm run build:test && node test/ensure-compiled.mjs && node --test \"dist-test/test/*.test.js\"",
+    "clawgram-cli": "node dist/clawgram-cli.js",
+    "clawgram-cli:hello": "node dist/clawgram-cli.js --hello",
+    "clawgram-cli:auth": "node dist/clawgram-cli.js --auth"
+  },
+  "keywords": [
+    "clawgram",
+    "openclaw",
+    "telegram",
+    "userbot",
+    "mtproto",
+    "gramjs",
+    "plugin",
+    "channel"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "package.json",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "author": "Konstantin Dipezh (d3pre5s)",
+  "contributors": [
+    "eldaruma (original author of telegram-userbot)"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/d3pre5s/clawgram"
+  },
+  "homepage": "https://github.com/d3pre5s/clawgram#readme",
+  "bugs": {
+    "url": "https://github.com/d3pre5s/clawgram/issues"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.5.7",
+      "minGatewayVersion": "2026.5.7"
+    },
+    "build": {
+      "openclawVersion": "2026.5.7",
+      "pluginSdkVersion": "2026.5.7"
+    }
+  },
+  "devDependencies": {
+    "openclaw": "2026.5.7",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.5.7"
+  },
+  "installDependencies": true,
+  "dependencies": {
+    "json5": "^2.2.3",
+    "telegram": "^2.26.22"
+  }
+}