@llblab/pi-telegram 0.24.2 → 0.24.4

package/lib/runtime.ts

@@ -455,7 +455,12 @@ export function startTelegramTypingLoop(
   state.typingLoopKey = nextKey;
   const sendTyping = (): void => {
     const activeDeps = state.typingLoopDeps;
-    if (!activeDeps || activeDeps.chatId === undefined || activeDeps.chatId === 0)
+    if (
+      !activeDeps ||
+      activeDeps.chatId === undefined ||
+      activeDeps.chatId === 0 ||
+      state.typingInFlight
+    )
       return;
     const targetChatId = activeDeps.chatId;
     const threadParams = getTelegramTypingLoopThreadParams(activeDeps.target);

package/lib/telegram-api.ts

@@ -333,6 +333,7 @@ interface TelegramApiResponse<T> {
 export interface TelegramApiCallOptions {
   signal?: AbortSignal;
   maxAttempts?: number;
+  retryRateLimit?: boolean;
   retrySafety?: "safe" | "non-idempotent";
   retryBaseDelayMs?: number;
   sleep?: (ms: number) => Promise<void>;
@@ -435,6 +436,9 @@ export interface TelegramBridgeApiRuntimeDeps {
     error: unknown,
     details?: Record<string, unknown>,
   ) => void;
+  now?: () => number;
+  chatActionMinIntervalMs?: number;
+  chatActionMaxGates?: number;
 }
 
 export interface TelegramBridgeApiRuntime {
@@ -995,7 +999,13 @@ async function callTelegramWithRetry<TResponse>(
         ),
       );
     } catch (error) {
-      const retryable = isRetryableTelegramApiError(error);
+      const retryable =
+      isRetryableTelegramApiError(error) &&
+      !(
+        options?.retryRateLimit === false &&
+        error instanceof TelegramApiHttpError &&
+        error.status === 429
+      );
       if (!retrySafe) {
         if (error instanceof TelegramApiHttpError && error.status === 429) {
           if (attempt >= maxAttempts - 1) throw error;
@@ -1321,11 +1331,100 @@ export function createDefaultTelegramBridgeApiRuntime(deps: {
 export function createTelegramBridgeApiRuntime(
   deps: TelegramBridgeApiRuntimeDeps,
 ): TelegramBridgeApiRuntime {
+  const now = deps.now ?? Date.now;
+  const chatActionMinIntervalMs = Math.max(
+    0,
+    deps.chatActionMinIntervalMs ?? 2_000,
+  );
+  const chatActionMaxGates = Math.max(1, deps.chatActionMaxGates ?? 256);
+  const chatActionGates = new Map<
+    string,
+    { inFlight?: Promise<unknown>; notBeforeMs: number }
+  >();
+  const getChatActionKey = (
+    method: string,
+    body: Record<string, unknown>,
+  ): string | undefined => {
+    if (method !== "sendChatAction") return undefined;
+    const chatId = body.chat_id;
+    const action = body.action;
+    if (
+      (typeof chatId !== "number" && typeof chatId !== "string") ||
+      typeof action !== "string"
+    ) {
+      return undefined;
+    }
+    const threadId = body.message_thread_id;
+    return `${String(chatId)}:${
+      typeof threadId === "number" || typeof threadId === "string"
+        ? String(threadId)
+        : "all"
+    }:${action}`;
+  };
   const callRecorded = async <TResponse>(
     method: string,
     body: Record<string, unknown>,
     options?: TelegramApiCallOptions,
   ): Promise<TResponse> => {
+    const chatActionKey = getChatActionKey(method, body);
+    if (chatActionKey) {
+      const nowMs = now();
+      for (const [key, candidate] of chatActionGates) {
+        if (!candidate.inFlight && nowMs >= candidate.notBeforeMs) {
+          chatActionGates.delete(key);
+        }
+      }
+      let gate = chatActionGates.get(chatActionKey);
+      if (!gate) {
+        if (chatActionGates.size >= chatActionMaxGates) return true as TResponse;
+        gate = { notBeforeMs: 0 };
+        chatActionGates.set(chatActionKey, gate);
+      }
+      if (gate.inFlight) return (await gate.inFlight) as TResponse;
+      if (now() < gate.notBeforeMs) return true as TResponse;
+      let request: Promise<TResponse>;
+      request = Promise.resolve()
+        .then(() =>
+          deps.client.call<TResponse>(method, body, {
+            ...options,
+            retryRateLimit: false,
+          }),
+        )
+        .then((result) => {
+          gate.notBeforeMs = now() + chatActionMinIntervalMs;
+          return result;
+        })
+        .catch((error: unknown) => {
+          if (error instanceof TelegramApiHttpError && error.status === 429) {
+            const retryAfterMs = Math.max(
+              chatActionMinIntervalMs,
+              (error.retryAfterSeconds ?? 0) * 1_000,
+            );
+            gate.notBeforeMs = now() + retryAfterMs;
+            deps.recordRuntimeEvent(
+              "api",
+              error,
+              withTelegramTransportDiagnostics(error, {
+                method,
+                rateLimited: true,
+                retryAfterMs,
+              }),
+            );
+            return true as TResponse;
+          }
+          deps.recordRuntimeEvent(
+            "api",
+            error,
+            withTelegramTransportDiagnostics(error, { method }),
+          );
+          throw error;
+        })
+        .finally(() => {
+          if (gate.inFlight === request) gate.inFlight = undefined;
+        });
+      gate.inFlight = request;
+      return request;
+    }
     try {
       return await deps.client.call<TResponse>(method, body, options);
     } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.24.2",
+  "version": "0.24.4",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -30,7 +30,7 @@
     "test": "node --experimental-strip-types --test --test-reporter=dot tests/*.test.ts",
     "test:verbose": "node --experimental-strip-types --test --test-reporter=spec tests/*.test.ts",
     "typecheck": "tsc --noEmit",
-    "audit": "npm audit",
+    "audit": "node --experimental-strip-types scripts/audit-dependencies.ts",
     "pack:check": "npm pack --dry-run",
     "validate": "npm run typecheck && npm test && npm run audit && npm run pack:check"
   },
@@ -43,6 +43,7 @@
     "BACKLOG.md",
     "CHANGELOG.md",
     "docs/",
+    "scripts/",
     "screenshot.png"
   ],
   "exports": {
@@ -75,22 +76,24 @@
     "typescript": "latest"
   },
   "overrides": {
-    "protobufjs": "7.6.4",
+    "brace-expansion": "5.0.7",
+    "protobufjs": "7.6.5",
     "undici": "8.5.0",
     "ws": "8.21.0",
     "@earendil-works/pi-coding-agent": {
-      "protobufjs": "7.6.4",
+      "brace-expansion": "5.0.7",
+      "protobufjs": "7.6.5",
       "undici": "8.5.0",
       "ws": "8.21.0",
       "@google/genai": {
-        "protobufjs": "7.6.4",
+        "protobufjs": "7.6.5",
         "ws": "8.21.0"
       },
       "@earendil-works/pi-ai": {
-        "protobufjs": "7.6.4",
+        "protobufjs": "7.6.5",
         "ws": "8.21.0",
         "@google/genai": {
-          "protobufjs": "7.6.4",
+          "protobufjs": "7.6.5",
           "ws": "8.21.0"
         }
       }

package/scripts/audit-dependencies.ts

@@ -0,0 +1,78 @@
+/**
+ * Dependency audit command adapter
+ * Runs raw npm audit, prints its output, and applies the fail-closed repository policy
+ */
+
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import {
+  evaluateDependencyAudit,
+  type AuditReport,
+} from "./dependency-audit-policy.ts";
+
+function readInstalledPackageVersion(root: string, nodePath: string): string {
+  if (
+    path.isAbsolute(nodePath) ||
+    nodePath.includes("..") ||
+    !nodePath.startsWith("node_modules/")
+  ) {
+    throw new Error(`unsafe installed package path: ${nodePath}`);
+  }
+  const packageJsonPath = path.join(root, nodePath, "package.json");
+  const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+    version?: unknown;
+  };
+  if (typeof parsed.version !== "string") {
+    throw new Error(`installed package has no valid version: ${nodePath}`);
+  }
+  return parsed.version;
+}
+
+function run(): void {
+  const result = spawnSync("npm", ["audit", "--json"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error) throw result.error;
+  if (result.signal || (result.status !== 0 && result.status !== 1)) {
+    throw new Error(
+      `npm audit command failed: status=${String(result.status)} signal=${String(result.signal)}`,
+    );
+  }
+
+  let report: AuditReport;
+  try {
+    report = JSON.parse(result.stdout) as AuditReport;
+  } catch (error) {
+    throw new Error(`could not parse npm audit JSON: ${String(error)}`);
+  }
+  const evaluation = evaluateDependencyAudit(
+    report,
+    (nodePath) => readInstalledPackageVersion(process.cwd(), nodePath),
+  );
+  const expectedStatus = evaluation.vulnerabilityCount === 0 ? 0 : 1;
+  if (result.status !== expectedStatus) {
+    throw new Error(
+      `npm audit exit status mismatch: expected ${expectedStatus}, got ${String(result.status)}`,
+    );
+  }
+  if (evaluation.vulnerabilityCount === 0) {
+    console.log("Dependency audit passed with zero vulnerabilities.");
+    return;
+  }
+  console.warn(
+    `Accepted ${evaluation.vulnerabilityCount} audit graph entries rooted only in approved sources ${evaluation.acceptedAdvisorySources.join(", ")}; exception expires after 2026-08-21 UTC.`,
+  );
+}
+
+try {
+  run();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}

package/scripts/dependency-audit-policy.ts

@@ -0,0 +1,300 @@
+/**
+ * Fail-closed dependency audit policy
+ * Zones: repository validation, dependency security
+ * Validates the exact expiring Pi-shrinkwrap exception and installed package evidence
+ */
+
+const EXCEPTION_EXPIRES_AT = Date.parse("2026-08-22T00:00:00Z");
+
+interface AuditAdvisory {
+  source: number;
+  name: string;
+  url: string;
+  severity: string;
+}
+
+interface AuditVulnerability {
+  name: string;
+  severity: string;
+  via: Array<string | AuditAdvisory>;
+  nodes: string[];
+}
+
+export interface AuditReport {
+  error?: unknown;
+  metadata?: {
+    vulnerabilities?: {
+      info?: number;
+      low?: number;
+      moderate?: number;
+      high?: number;
+      critical?: number;
+      total?: number;
+    };
+  };
+  vulnerabilities?: Record<string, AuditVulnerability>;
+}
+
+interface AllowedAdvisory {
+  source: number;
+  packageName: string;
+  version: string;
+  severity: string;
+  url: string;
+  nodes: readonly string[];
+}
+
+const ALLOWED_ADVISORIES = new Map<number, AllowedAdvisory>([
+  [
+    1123898,
+    {
+      source: 1123898,
+      packageName: "brace-expansion",
+      version: "5.0.6",
+      severity: "high",
+      url: "https://github.com/advisories/GHSA-3jxr-9vmj-r5cp",
+      nodes: [
+        "node_modules/@earendil-works/pi-coding-agent/node_modules/brace-expansion",
+      ],
+    },
+  ],
+  [
+    1123964,
+    {
+      source: 1123964,
+      packageName: "protobufjs",
+      version: "7.6.4",
+      severity: "moderate",
+      url: "https://github.com/advisories/GHSA-j3f2-48v5-ccww",
+      nodes: [
+        "node_modules/@earendil-works/pi-coding-agent/node_modules/protobufjs",
+      ],
+    },
+  ],
+]);
+
+const ALLOWED_GRAPH: Readonly<Record<string, readonly string[]>> = {
+  "brace-expansion": [],
+  protobufjs: [],
+  "@google/genai": ["protobufjs"],
+  "@earendil-works/pi-ai": ["@google/genai"],
+  "@earendil-works/pi-agent-core": ["@earendil-works/pi-ai"],
+  "@earendil-works/pi-coding-agent": [
+    "@earendil-works/pi-agent-core",
+    "@earendil-works/pi-ai",
+  ],
+};
+
+const ALLOWED_GRAPH_SEVERITIES: Readonly<Record<string, string>> = {
+  "brace-expansion": "high",
+  protobufjs: "moderate",
+  "@google/genai": "moderate",
+  "@earendil-works/pi-ai": "moderate",
+  "@earendil-works/pi-agent-core": "moderate",
+  "@earendil-works/pi-coding-agent": "moderate",
+};
+
+const ALLOWED_GRAPH_NODES: Readonly<Record<string, readonly string[]>> = {
+  "brace-expansion": [
+    "node_modules/@earendil-works/pi-coding-agent/node_modules/brace-expansion",
+  ],
+  protobufjs: [
+    "node_modules/@earendil-works/pi-coding-agent/node_modules/protobufjs",
+  ],
+  "@google/genai": [
+    "node_modules/@google/genai",
+    "node_modules/@earendil-works/pi-coding-agent/node_modules/@google/genai",
+  ],
+  "@earendil-works/pi-ai": [
+    "node_modules/@earendil-works/pi-ai",
+    "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-ai",
+  ],
+  "@earendil-works/pi-agent-core": [
+    "node_modules/@earendil-works/pi-agent-core",
+    "node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-agent-core",
+  ],
+  "@earendil-works/pi-coding-agent": [
+    "node_modules/@earendil-works/pi-coding-agent",
+  ],
+};
+
+export interface AuditEvaluation {
+  acceptedAdvisorySources: number[];
+  vulnerabilityCount: number;
+}
+
+function hasExactMembers(actual: readonly string[], expected: readonly string[]): boolean {
+  return (
+    actual.length === expected.length &&
+    new Set(actual).size === actual.length &&
+    expected.every((value) => actual.includes(value))
+  );
+}
+
+export function evaluateDependencyAudit(
+  report: AuditReport,
+  readInstalledVersion: (nodePath: string) => string,
+  nowMs = Date.now(),
+): AuditEvaluation {
+  if (report.error !== undefined) {
+    throw new Error("npm audit returned an error payload");
+  }
+  const vulnerabilities = report.vulnerabilities;
+  if (!vulnerabilities || typeof vulnerabilities !== "object") {
+    throw new Error("npm audit output is missing vulnerabilities");
+  }
+
+  const entries = Object.entries(vulnerabilities);
+  const counts = report.metadata?.vulnerabilities;
+  if (!counts) {
+    throw new Error("npm audit output is missing vulnerability metadata");
+  }
+  const countKeys = [
+    "info",
+    "low",
+    "moderate",
+    "high",
+    "critical",
+    "total",
+  ] as const;
+  for (const key of countKeys) {
+    if (!Number.isInteger(counts[key]) || (counts[key] ?? -1) < 0) {
+      throw new Error(`npm audit metadata has invalid ${key} count`);
+    }
+  }
+  const severityTotal =
+    (counts.info ?? 0) +
+    (counts.low ?? 0) +
+    (counts.moderate ?? 0) +
+    (counts.high ?? 0) +
+    (counts.critical ?? 0);
+  if (severityTotal !== counts.total || counts.total !== entries.length) {
+    throw new Error(
+      `npm audit vulnerability total mismatch: metadata=${String(counts.total)}, severities=${severityTotal}, graph=${entries.length}`,
+    );
+  }
+  if (entries.length === 0) {
+    return { acceptedAdvisorySources: [], vulnerabilityCount: 0 };
+  }
+  if (nowMs >= EXCEPTION_EXPIRES_AT) {
+    throw new Error(
+      "approved dependency audit exception expired at 2026-08-22T00:00:00Z",
+    );
+  }
+
+  const acceptedSources = new Set<number>();
+  for (const [name, vulnerability] of entries) {
+    if (vulnerability.name !== name) {
+      throw new Error(`npm audit graph key/name mismatch for ${name}`);
+    }
+    const allowedParents = ALLOWED_GRAPH[name];
+    const allowedNodes = ALLOWED_GRAPH_NODES[name];
+    const allowedSeverity = ALLOWED_GRAPH_SEVERITIES[name];
+    if (!allowedParents || !allowedNodes || !allowedSeverity) {
+      throw new Error(`unapproved vulnerable package: ${name}`);
+    }
+    if (vulnerability.severity !== allowedSeverity) {
+      throw new Error(
+        `unapproved severity for ${name}: expected ${allowedSeverity}, got ${vulnerability.severity}`,
+      );
+    }
+    if (!Array.isArray(vulnerability.via) || !Array.isArray(vulnerability.nodes)) {
+      throw new Error(`malformed npm audit graph entry for ${name}`);
+    }
+    if (!hasExactMembers(vulnerability.nodes, allowedNodes)) {
+      throw new Error(
+        `audit graph paths differ for ${name}: expected ${allowedNodes.join(",")}, got ${vulnerability.nodes.join(",")}`,
+      );
+    }
+
+    const parentEdges = vulnerability.via.filter(
+      (via): via is string => typeof via === "string",
+    );
+    const advisories = vulnerability.via.filter(
+      (via): via is AuditAdvisory => typeof via !== "string",
+    );
+    if (allowedParents.length > 0) {
+      if (advisories.length > 0 || !hasExactMembers(parentEdges, allowedParents)) {
+        throw new Error(
+          `audit graph edges differ for ${name}: expected ${allowedParents.join(",")}, got ${parentEdges.join(",")}`,
+        );
+      }
+      for (const parent of parentEdges) {
+        if (!vulnerabilities[parent]) {
+          throw new Error(`missing npm audit graph node: ${parent}`);
+        }
+      }
+      continue;
+    }
+    if (parentEdges.length > 0 || advisories.length !== 1) {
+      throw new Error(`audit leaf shape differs for ${name}`);
+    }
+    const advisory = advisories[0];
+    const allowed = ALLOWED_ADVISORIES.get(advisory.source);
+    if (
+      !allowed ||
+      advisory.name !== allowed.packageName ||
+      advisory.url !== allowed.url ||
+      advisory.severity !== allowed.severity ||
+      name !== allowed.packageName ||
+      vulnerability.severity !== allowed.severity
+    ) {
+      throw new Error(
+        `unapproved advisory for ${name}: source=${String(advisory.source)} url=${advisory.url}`,
+      );
+    }
+    acceptedSources.add(advisory.source);
+  }
+
+  const rootsByPackage = new Map<string, Set<number>>();
+  const resolveRoots = (name: string, stack: Set<string>): Set<number> => {
+    const cached = rootsByPackage.get(name);
+    if (cached) return cached;
+    if (stack.has(name)) throw new Error(`cycle in npm audit graph at ${name}`);
+    const vulnerability = vulnerabilities[name];
+    if (!vulnerability) throw new Error(`missing npm audit graph node: ${name}`);
+    const nextStack = new Set(stack).add(name);
+    const roots = new Set<number>();
+    for (const via of vulnerability.via) {
+      if (typeof via === "string") {
+        for (const source of resolveRoots(via, nextStack)) roots.add(source);
+      } else {
+        roots.add(via.source);
+      }
+    }
+    if (roots.size === 0) {
+      throw new Error(`npm audit graph node has no approved advisory root: ${name}`);
+    }
+    rootsByPackage.set(name, roots);
+    return roots;
+  };
+
+  for (const name of Object.keys(vulnerabilities)) resolveRoots(name, new Set());
+
+  for (const source of acceptedSources) {
+    const allowed = ALLOWED_ADVISORIES.get(source);
+    if (!allowed) throw new Error(`missing policy for advisory source ${source}`);
+    const vulnerability = vulnerabilities[allowed.packageName];
+    if (!vulnerability) {
+      throw new Error(`missing leaf package for advisory source ${source}`);
+    }
+    for (const nodePath of vulnerability.nodes) {
+      if (!allowed.nodes.includes(nodePath)) {
+        throw new Error(
+          `unapproved installed path for advisory source ${source}: ${nodePath}`,
+        );
+      }
+      const version = readInstalledVersion(nodePath);
+      if (version !== allowed.version) {
+        throw new Error(
+          `unapproved installed version at ${nodePath}: expected ${allowed.version}, got ${version}`,
+        );
+      }
+    }
+  }
+
+  return {
+    acceptedAdvisorySources: [...acceptedSources].sort((a, b) => a - b),
+    vulnerabilityCount: entries.length,
+  };
+}