pi-telegram-plus 0.0.1

package/lib/commands/tg-config.ts

@@ -0,0 +1,128 @@
+import type { CommandRegistry, TgConfigDeps } from "./register.ts";
+import type { TelegramConfig, TelegramMessageMode, TelegramRenderLevel } from "../types.ts";
+import { RENDER_LEVELS, MODE_VALUES } from "../types.ts";
+
+const KEY_LABELS: Record<string, string> = {
+  tool: "🔧 Tool rendering",
+  thinking: "💭 Thinking rendering",
+  mode: "📨 Message mode",
+  retry: "🔄 Retry count",
+};
+
+export function registerTgConfigCommands(
+  registry: CommandRegistry,
+  deps: TgConfigDeps,
+): void {
+  registry.registerCommand("tg-config", {
+    description: "Configure Telegram message rendering and mode",
+    handler: async (args, ctx) => {
+      const ui = ctx.ui;
+      const parts = args.trim().split(/\s+/);
+
+      // Direct-set mode: /tg-config <key> <value>
+      if (parts.length >= 2 && parts[0]) {
+        const key = parts[0];
+        const value = parts[1];
+        const config = deps.getConfig();
+
+        if (key === "tool" || key === "thinking") {
+          if (!(RENDER_LEVELS as readonly string[]).includes(value)) {
+            ui.notify("Invalid. Use: /tg-config <tool|thinking> <hidden|brief|full>", "error");
+            return;
+          }
+          const next = key === "tool"
+            ? { ...config, tool: value as TelegramRenderLevel }
+            : { ...config, thinking: value as TelegramRenderLevel };
+          deps.setConfig(next);
+          await deps.persistConfig(next);
+          ui.notify(`${key} set to ${value}`, "info");
+          return;
+        } else if (key === "mode") {
+          if (!(MODE_VALUES as readonly string[]).includes(value)) {
+            ui.notify("Invalid. Use: /tg-config mode <queue|steer>", "error");
+            return;
+          }
+          const next = { ...config, messageMode: value as TelegramMessageMode };
+          deps.setConfig(next);
+          await deps.persistConfig(next);
+          ui.notify(`mode set to ${value}`, "info");
+          return;
+        } else if (key === "retry") {
+          const n = parseInt(value, 10);
+          if (!Number.isInteger(n) || n < 0 || n > 10) {
+            ui.notify("Invalid. Use: /tg-config retry <0-10>", "error");
+            return;
+          }
+          const next = { ...config, retryCount: n };
+          deps.setConfig(next);
+          await deps.persistConfig(next);
+          ui.notify(`retryCount set to ${n}`, "info");
+          return;
+        } else {
+          ui.notify("Invalid key. Use: tool, thinking, mode, or retry", "error");
+          return;
+        }
+      }
+
+      // Interactive mode
+      const config = deps.getConfig();
+      const currentTool = config.tool ?? "brief";
+      const currentThinking = config.thinking ?? "brief";
+      const currentMode = config.messageMode ?? "steer";
+      const currentRetry = config.retryCount ?? 3;
+
+      const choice = await ui.select("⚙️ Telegram Config", [
+        `${KEY_LABELS.tool}: ${currentTool}`,
+        `${KEY_LABELS.thinking}: ${currentThinking}`,
+        `${KEY_LABELS.mode}: ${currentMode}`,
+        `${KEY_LABELS.retry}: ${currentRetry}`,
+      ]);
+      if (!choice) return;
+
+      let selectedKey: string;
+      let current: string;
+
+      if (choice.startsWith(KEY_LABELS.tool)) {
+        selectedKey = "tool";
+        current = currentTool;
+      } else if (choice.startsWith(KEY_LABELS.thinking)) {
+        selectedKey = "thinking";
+        current = currentThinking;
+      } else if (choice.startsWith(KEY_LABELS.mode)) {
+        selectedKey = "mode";
+        current = currentMode;
+      } else if (choice.startsWith(KEY_LABELS.retry)) {
+        // Retry count is a number, not a select from list
+        const input = await ui.input("Retry count (0-10)", `Current: ${currentRetry}`);
+        if (!input) return;
+        const n = parseInt(input, 10);
+        if (!Number.isInteger(n) || n < 0 || n > 10) {
+          ui.notify("Must be a number 0-10", "error");
+          return;
+        }
+        const next = { ...config, retryCount: n };
+        deps.setConfig(next);
+        await deps.persistConfig(next);
+        ui.notify(`${KEY_LABELS.retry} set to ${n}`, "info");
+        return;
+      } else {
+        return;
+      }
+
+      const values = selectedKey === "mode" ? [...MODE_VALUES] : [...RENDER_LEVELS];
+      const labels = values.map((v) => (v === current ? `● ${v}` : `  ${v}`));
+
+      const valueChoice = await ui.select(KEY_LABELS[selectedKey], labels);
+      if (!valueChoice) return;
+
+      const idx = labels.indexOf(valueChoice);
+      if (idx < 0 || idx >= values.length) return;
+      const selectedValue = values[idx];
+
+      const next = { ...config, [selectedKey === "mode" ? "messageMode" : selectedKey]: selectedValue };
+      deps.setConfig(next);
+      await deps.persistConfig(next);
+      ui.notify(`${KEY_LABELS[selectedKey]} set to ${selectedValue}`, "info");
+    },
+  });
+}

package/lib/config.ts

@@ -0,0 +1,171 @@
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, relative, resolve } from "node:path";
+import type { ResolvedTelegramConfig, TelegramConfig, TelegramConfigStore, TelegramWorkspaceConfig } from "./types.ts";
+
+export function getAgentDir(): string {
+  return process.env.PI_CODING_AGENT_DIR
+    ? resolve(process.env.PI_CODING_AGENT_DIR)
+    : join(homedir(), ".pi", "agent");
+}
+
+export function getTelegramConfigPath(): string {
+  return join(getAgentDir(), "tg.json");
+}
+
+function emptyStore(): TelegramConfigStore {
+  return { version: 2, global: {}, workspaces: [] };
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function withTelegramConfigLock<T>(run: () => Promise<T>): Promise<T> {
+  await mkdir(getAgentDir(), { recursive: true });
+  const lockPath = join(getAgentDir(), "tg.json.lock");
+  const started = Date.now();
+  while (true) {
+    try {
+      await mkdir(lockPath, { mode: 0o700 });
+      break;
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "EEXIST") throw error;
+      const age = Date.now() - (await stat(lockPath).then((s) => s.mtimeMs).catch(() => Date.now()));
+      if (age > 30_000 || Date.now() - started > 10_000) {
+        await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+        continue;
+      }
+      await sleep(50);
+    }
+  }
+  try {
+    return await run();
+  } finally {
+    await rmdir(lockPath).catch(() => undefined);
+  }
+}
+
+function assertV2Store(value: unknown): TelegramConfigStore {
+  if (!value || typeof value !== "object" || (value as { version?: unknown }).version !== 2) {
+    throw new Error("Unsupported Telegram config format. Please recreate ~/.pi/agent/tg.json as version 2 or run /tg-setup.");
+  }
+  const store = value as TelegramConfigStore;
+  return {
+    version: 2,
+    global: store.global ?? {},
+    workspaces: Array.isArray(store.workspaces) ? store.workspaces : [],
+  };
+}
+
+export async function readTelegramConfigStore(): Promise<TelegramConfigStore> {
+  const path = getTelegramConfigPath();
+  if (!existsSync(path)) return emptyStore();
+  return assertV2Store(JSON.parse(await readFile(path, "utf8")));
+}
+
+export async function writeTelegramConfigStore(store: TelegramConfigStore): Promise<void> {
+  await mkdir(getAgentDir(), { recursive: true });
+  const path = getTelegramConfigPath();
+  const normalized: TelegramConfigStore = {
+    version: 2,
+    global: store.global ?? {},
+    workspaces: store.workspaces ?? [],
+  };
+  await writeFile(path, JSON.stringify(normalized, null, 2) + "\n", { mode: 0o600 });
+  await chmod(path, 0o600).catch(() => undefined);
+}
+
+function normalizePath(path: string): string {
+  return resolve(path);
+}
+
+function isPathInsideOrEqual(child: string, parent: string): boolean {
+  const rel = relative(parent, child);
+  return rel === "" || (!!rel && !rel.startsWith("..") && !rel.startsWith("/"));
+}
+
+export function resolveTelegramConfigStore(store: TelegramConfigStore, cwd: string): ResolvedTelegramConfig {
+  const normalizedCwd = normalizePath(cwd);
+  const workspaces = store.workspaces ?? [];
+  const match = workspaces
+    .map((workspace) => ({ ...workspace, path: normalizePath(workspace.path) }))
+    .filter((workspace) => isPathInsideOrEqual(normalizedCwd, workspace.path))
+    .sort((a, b) => b.path.length - a.path.length)[0];
+
+  if (match) {
+    return { store, scope: "workspace", workspacePath: match.path, config: match.config ?? {} };
+  }
+  return { store, scope: "global", config: store.global ?? {} };
+}
+
+export async function readResolvedTelegramConfig(cwd: string): Promise<ResolvedTelegramConfig> {
+  return resolveTelegramConfigStore(await readTelegramConfigStore(), cwd);
+}
+
+function mergeTelegramConfigForWrite(existing: TelegramConfig | undefined, incoming: TelegramConfig): TelegramConfig {
+  const next = { ...(incoming ?? {}) };
+  const existingOffset = existing?.lastUpdateId;
+  const incomingOffset = incoming.lastUpdateId;
+  if (typeof existingOffset === "number" || typeof incomingOffset === "number") {
+    next.lastUpdateId = Math.max(
+      typeof existingOffset === "number" ? existingOffset : -1,
+      typeof incomingOffset === "number" ? incomingOffset : -1,
+    );
+  }
+  return next;
+}
+
+export async function writeResolvedTelegramConfig(resolved: ResolvedTelegramConfig, config: TelegramConfig): Promise<ResolvedTelegramConfig> {
+  return await withTelegramConfigLock(async () => {
+    // Re-read the store while holding the lock. Multiple pi instances / workspace
+    // bots can persist polling offsets and active chats concurrently; writing the
+    // stale session_start snapshot would overwrite other bots' newer workspace config.
+    // Preserve lastUpdateId monotonically so stale async handlers cannot regress
+    // the durable Telegram offset after polling has advanced it.
+    const store = await readTelegramConfigStore();
+    if (resolved.scope === "workspace" && resolved.workspacePath) {
+      const workspacePath = normalizePath(resolved.workspacePath);
+      const workspaces = store.workspaces ?? [];
+      const index = workspaces.findIndex((workspace) => normalizePath(workspace.path) === workspacePath);
+      const existing = index >= 0 ? workspaces[index].config : undefined;
+      const nextConfig = mergeTelegramConfigForWrite(existing, config);
+      if (index >= 0) workspaces[index] = { path: workspacePath, config: nextConfig };
+      else workspaces.push({ path: workspacePath, config: nextConfig });
+      store.workspaces = workspaces;
+    } else {
+      store.global = mergeTelegramConfigForWrite(store.global, config);
+    }
+    await writeTelegramConfigStore(store);
+    return resolveTelegramConfigStore(store, resolved.workspacePath ?? process.cwd());
+  });
+}
+
+export async function bindWorkspaceTelegramConfig(cwd: string, config: TelegramConfig): Promise<ResolvedTelegramConfig> {
+  return await withTelegramConfigLock(async () => {
+    const store = await readTelegramConfigStore();
+    const workspacePath = normalizePath(cwd);
+    const workspaces = store.workspaces ?? [];
+    const index = workspaces.findIndex((workspace) => normalizePath(workspace.path) === workspacePath);
+    const entry: TelegramWorkspaceConfig = { path: workspacePath, config };
+    if (index >= 0) workspaces[index] = entry;
+    else workspaces.push(entry);
+    workspaces.sort((a, b) => normalizePath(a.path).localeCompare(normalizePath(b.path)));
+    store.workspaces = workspaces;
+    await writeTelegramConfigStore(store);
+    return resolveTelegramConfigStore(store, workspacePath);
+  });
+}
+
+export async function unbindWorkspaceTelegramConfig(cwd: string): Promise<ResolvedTelegramConfig> {
+  return await withTelegramConfigLock(async () => {
+    const store = await readTelegramConfigStore();
+    const current = resolveTelegramConfigStore(store, cwd);
+    if (current.scope === "workspace" && current.workspacePath) {
+      const workspacePath = normalizePath(current.workspacePath);
+      store.workspaces = (store.workspaces ?? []).filter((workspace) => normalizePath(workspace.path) !== workspacePath);
+      await writeTelegramConfigStore(store);
+    }
+    return resolveTelegramConfigStore(store, cwd);
+  });
+}