@chrysb/alphaclaw 0.1.25 → 0.2.0

package/lib/server/telegram-api.js

@@ -0,0 +1,65 @@
+const kTelegramApiBase = "https://api.telegram.org";
+
+const createTelegramApi = (getToken) => {
+  const call = async (method, params = {}) => {
+    const token = typeof getToken === "function" ? getToken() : getToken;
+    if (!token) throw new Error("TELEGRAM_BOT_TOKEN is not set");
+    const url = `${kTelegramApiBase}/bot${token}/${method}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+    });
+    const data = await res.json();
+    if (!data.ok) {
+      const err = new Error(data.description || `Telegram API error: ${method}`);
+      err.telegramErrorCode = data.error_code;
+      throw err;
+    }
+    return data.result;
+  };
+
+  const getMe = () => call("getMe");
+
+  const getChat = (chatId) => call("getChat", { chat_id: chatId });
+
+  const getChatMember = (chatId, userId) =>
+    call("getChatMember", { chat_id: chatId, user_id: userId });
+
+  const getChatAdministrators = (chatId) =>
+    call("getChatAdministrators", { chat_id: chatId });
+
+  const createForumTopic = (chatId, name, opts = {}) =>
+    call("createForumTopic", {
+      chat_id: chatId,
+      name,
+      ...(opts.iconColor != null && { icon_color: opts.iconColor }),
+      ...(opts.iconCustomEmojiId && { icon_custom_emoji_id: opts.iconCustomEmojiId }),
+    });
+
+  const deleteForumTopic = (chatId, messageThreadId) =>
+    call("deleteForumTopic", {
+      chat_id: chatId,
+      message_thread_id: messageThreadId,
+    });
+
+  const editForumTopic = (chatId, messageThreadId, opts = {}) =>
+    call("editForumTopic", {
+      chat_id: chatId,
+      message_thread_id: messageThreadId,
+      ...(opts.name && { name: opts.name }),
+      ...(opts.iconCustomEmojiId && { icon_custom_emoji_id: opts.iconCustomEmojiId }),
+    });
+
+  return {
+    getMe,
+    getChat,
+    getChatMember,
+    getChatAdministrators,
+    createForumTopic,
+    deleteForumTopic,
+    editForumTopic,
+  };
+};
+
+module.exports = { createTelegramApi };

package/lib/server/telegram-workspace.js

@@ -0,0 +1,82 @@
+const kTelegramTopicConcurrencyMultiplier = 3;
+const kAgentConcurrencyFloor = 8;
+const kSubagentConcurrencyFloor = 4;
+
+const syncConfigForTelegram = ({
+  fs,
+  openclawDir,
+  topicRegistry,
+  groupId,
+  requireMention = false,
+  resolvedUserId = "",
+}) => {
+  const configPath = `${openclawDir}/openclaw.json`;
+  const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+
+  // Remove legacy root keys from older setup flow.
+  delete cfg.sessions;
+  delete cfg.groups;
+  delete cfg.groupAllowFrom;
+
+  if (!cfg.channels) cfg.channels = {};
+  if (!cfg.channels.telegram) cfg.channels.telegram = {};
+  if (!cfg.channels.telegram.groups) cfg.channels.telegram.groups = {};
+  const existingGroupConfig = cfg.channels.telegram.groups[groupId] || {};
+  cfg.channels.telegram.groups[groupId] = {
+    ...existingGroupConfig,
+    requireMention,
+  };
+
+  const registryTopics = topicRegistry.getGroup(groupId)?.topics || {};
+  const promptTopics = {};
+  for (const [threadId, topic] of Object.entries(registryTopics)) {
+    const systemPrompt = String(topic?.systemInstructions || "").trim();
+    if (!systemPrompt) continue;
+    promptTopics[threadId] = { systemPrompt };
+  }
+  if (Object.keys(promptTopics).length > 0) {
+    cfg.channels.telegram.groups[groupId].topics = promptTopics;
+  } else {
+    delete cfg.channels.telegram.groups[groupId].topics;
+  }
+
+  cfg.channels.telegram.groupPolicy = "allowlist";
+  if (!Array.isArray(cfg.channels.telegram.groupAllowFrom)) {
+    cfg.channels.telegram.groupAllowFrom = [];
+  }
+  if (
+    resolvedUserId
+    && !cfg.channels.telegram.groupAllowFrom.includes(String(resolvedUserId))
+  ) {
+    cfg.channels.telegram.groupAllowFrom.push(String(resolvedUserId));
+  }
+
+  // Persist thread sessions and keep concurrency in schema-valid agent defaults.
+  if (!cfg.session) cfg.session = {};
+  if (!cfg.session.resetByType) cfg.session.resetByType = {};
+  cfg.session.resetByType.thread = { mode: "idle", idleMinutes: 525600 };
+
+  const totalTopics = topicRegistry.getTotalTopicCount();
+  const maxConcurrent = Math.max(
+    totalTopics * kTelegramTopicConcurrencyMultiplier,
+    kAgentConcurrencyFloor,
+  );
+  if (!cfg.agents) cfg.agents = {};
+  if (!cfg.agents.defaults) cfg.agents.defaults = {};
+  cfg.agents.defaults.maxConcurrent = maxConcurrent;
+  if (!cfg.agents.defaults.subagents) cfg.agents.defaults.subagents = {};
+  cfg.agents.defaults.subagents.maxConcurrent = Math.max(
+    maxConcurrent - 2,
+    kSubagentConcurrencyFloor,
+  );
+
+  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+
+  return {
+    totalTopics,
+    maxConcurrent: cfg.agents.defaults.maxConcurrent,
+    subagentMaxConcurrent: cfg.agents.defaults.subagents.maxConcurrent,
+  };
+};
+
+module.exports = { syncConfigForTelegram };

package/lib/server/topic-registry.js

@@ -0,0 +1,152 @@
+const fs = require("fs");
+const { WORKSPACE_DIR } = require("./constants");
+
+const kRegistryPath = `${WORKSPACE_DIR}/topic-registry.json`;
+
+const readRegistry = () => {
+  try {
+    return JSON.parse(fs.readFileSync(kRegistryPath, "utf8"));
+  } catch {
+    return { groups: {} };
+  }
+};
+
+const writeRegistry = (registry) => {
+  fs.mkdirSync(WORKSPACE_DIR, { recursive: true });
+  fs.writeFileSync(kRegistryPath, JSON.stringify(registry, null, 2));
+};
+
+const getGroup = (groupId) => {
+  const registry = readRegistry();
+  return registry.groups[groupId] || null;
+};
+
+const setGroup = (groupId, groupData) => {
+  const registry = readRegistry();
+  const existingGroup = registry.groups[groupId] || {
+    name: groupId,
+    topics: {},
+  };
+  registry.groups[groupId] = {
+    ...existingGroup,
+    ...groupData,
+    topics: existingGroup.topics || {},
+  };
+  writeRegistry(registry);
+  return registry;
+};
+
+const addTopic = (groupId, threadId, topicData) => {
+  const registry = readRegistry();
+  if (!registry.groups[groupId]) {
+    registry.groups[groupId] = { name: groupId, topics: {} };
+  }
+  if (
+    !registry.groups[groupId].topics ||
+    typeof registry.groups[groupId].topics !== "object"
+  ) {
+    registry.groups[groupId].topics = {};
+  }
+  registry.groups[groupId].topics[String(threadId)] = topicData;
+  writeRegistry(registry);
+  return registry;
+};
+
+const updateTopic = (groupId, threadId, topicData) => {
+  const registry = readRegistry();
+  if (!registry.groups[groupId]) {
+    registry.groups[groupId] = { name: groupId, topics: {} };
+  }
+  if (
+    !registry.groups[groupId].topics ||
+    typeof registry.groups[groupId].topics !== "object"
+  ) {
+    registry.groups[groupId].topics = {};
+  }
+  const existing = registry.groups[groupId].topics[String(threadId)] || {};
+  registry.groups[groupId].topics[String(threadId)] = {
+    ...existing,
+    ...topicData,
+  };
+  writeRegistry(registry);
+  return registry;
+};
+
+const removeTopic = (groupId, threadId) => {
+  const registry = readRegistry();
+  if (registry.groups[groupId]?.topics) {
+    delete registry.groups[groupId].topics[String(threadId)];
+  }
+  writeRegistry(registry);
+  return registry;
+};
+
+const getTotalTopicCount = () => {
+  const registry = readRegistry();
+  let count = 0;
+  for (const group of Object.values(registry.groups)) {
+    count += Object.keys(group.topics || {}).length;
+  }
+  return count;
+};
+
+// Render the topic registry as a markdown section for TOOLS.md
+const renderTopicRegistryMarkdown = ({ includeSyncGuidance = false } = {}) => {
+  const registry = readRegistry();
+  const rows = [];
+  for (const [groupId, group] of Object.entries(registry.groups)) {
+    for (const [threadId, topic] of Object.entries(group.topics || {})) {
+      rows.push({
+        groupName: group.name || groupId,
+        groupId,
+        topicName: topic.name,
+        threadId,
+      });
+    }
+  }
+  if (rows.length === 0 && !includeSyncGuidance) return "";
+
+  const lines = [
+    "",
+    "## Topic Registry",
+    "",
+    "When sending messages to group topics, use these thread IDs:",
+    "",
+    "| Group | Topic | Thread ID |",
+    "| ----- | ----- | --------- |",
+  ];
+  for (const r of rows) {
+    lines.push(
+      `| ${r.groupName} (${r.groupId}) | ${r.topicName} | ${r.threadId} |`,
+    );
+  }
+  if (includeSyncGuidance) {
+    lines.push(
+      "",
+      "### Sync Rules",
+      "",
+      "When Telegram workspace is enabled, keep topic mappings in sync with real Telegram activity:",
+      "",
+      "- If a message arrives in an unregistered Telegram topic, ask the user to name it for addition to the registry.",
+      '- When adding a topic (new or missing) run `alphaclaw telegram topic add --thread <threadId> --name "<topicName>"` immediately, no confirmation needed.',
+      "- Never edit `hooks/bootstrap/TOOLS.md` directly for topic changes",
+      "",
+    );
+  } else {
+    lines.push("");
+  }
+  return lines.join("\n");
+};
+
+module.exports = {
+  kRegistryPath,
+  readRegistry,
+  writeRegistry,
+  getGroup,
+  setGroup,
+  addTopic,
+  updateTopic,
+  removeTopic,
+  getTotalTopicCount,
+  renderTopicRegistryMarkdown,
+};

package/lib/server.js

@@ -36,6 +36,7 @@ const { createLoginThrottle } = require("./server/login-throttle");
 const { createOpenclawVersionService } = require("./server/openclaw-version");
 const { createAlphaclawVersionService } = require("./server/alphaclaw-version");
 const { syncBootstrapPromptFiles } = require("./server/onboarding/workspace");
+const { createTelegramApi } = require("./server/telegram-api");
 
 const { registerAuthRoutes } = require("./server/routes/auth");
 const { registerPageRoutes } = require("./server/routes/pages");
@@ -46,6 +47,7 @@ const { registerPairingRoutes } = require("./server/routes/pairings");
 const { registerCodexRoutes } = require("./server/routes/codex");
 const { registerGoogleRoutes } = require("./server/routes/google");
 const { registerProxyRoutes } = require("./server/routes/proxy");
+const { registerTelegramRoutes } = require("./server/routes/telegram");
 
 const { PORT, GATEWAY_URL, kTrustProxyHops, SETUP_API_PREFIXES } = constants;
 
@@ -146,6 +148,10 @@ registerGoogleRoutes({
   getApiEnableUrl,
   constants,
 });
+const telegramApi = createTelegramApi(() => process.env.TELEGRAM_BOT_TOKEN);
+const doSyncPromptFiles = () =>
+  syncBootstrapPromptFiles({ fs, workspaceDir: constants.WORKSPACE_DIR });
+registerTelegramRoutes({ app, telegramApi, syncPromptFiles: doSyncPromptFiles });
 registerProxyRoutes({ app, proxy, SETUP_API_PREFIXES, requireAuth });
 
 const server = http.createServer(app);
@@ -170,7 +176,7 @@ server.on("upgrade", (req, socket, head) => {
 
 server.listen(PORT, "0.0.0.0", () => {
   console.log(`[alphaclaw] Express listening on :${PORT}`);
-  syncBootstrapPromptFiles({ fs, workspaceDir: constants.WORKSPACE_DIR });
+  doSyncPromptFiles();
   if (isOnboarded()) {
     reloadEnv();
     syncChannelConfig(readEnvFile());

package/lib/setup/core-prompts/TOOLS.md

@@ -25,7 +25,7 @@ Google Workspace is connected via the **General** tab (`{{SETUP_UI_URL}}#general
 **Commit and push after every set of changes.** Your entire .openclaw directory (config, cron, workspace) is version controlled. This is how your work survives container restarts.
 
 ```bash
-cd /data/.openclaw && git add -A && git commit -m "description" && git push
+alphaclaw git-sync --message "description"
 ```
 
 Never force push. Always pull before pushing if there might be remote changes.

package/lib/setup/env.template

@@ -11,6 +11,9 @@ GEMINI_API_KEY=
 GITHUB_TOKEN=
 GITHUB_WORKSPACE_REPO=
 
+# --- Setup UI auth (required) ---
+SETUP_PASSWORD=
+
 # --- Channels (at least one required) ---
 TELEGRAM_BOT_TOKEN=
 DISCORD_BOT_TOKEN=

package/lib/setup/hourly-git-sync.sh

@@ -4,6 +4,14 @@ set -euo pipefail
 REPO="$(cd "$(dirname "$0")" && pwd)"
 cd "$REPO"
 
+# Load persisted env vars when running under cron's minimal environment.
+if [[ -f "$REPO/.env" ]]; then
+  set -a
+  # shellcheck disable=SC1091
+  source "$REPO/.env"
+  set +a
+fi
+
 # Drop cron scheduler runtime-only churn when it is metadata/timestamp-only.
 maybe_restore_if_runtime_only() {
   local file="$1"
@@ -73,14 +81,5 @@ NODE
 maybe_restore_if_runtime_only "cron/jobs.json"
 maybe_restore_if_runtime_only "crons.json"
 
-# Stage everything else.
-git add -A
-
-# Nothing to commit? done.
-if git diff --cached --quiet; then
-  exit 0
-fi
-
 msg="Auto-commit hourly sync $(date -u +'%Y-%m-%dT%H:%M:%SZ')"
-git commit -m "$msg"
-git push
+alphaclaw git-sync -m "$msg"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.1.25",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },