@llblab/pi-telegram 0.24.6 → 0.24.7

package/lib/sync.ts

@@ -110,11 +110,19 @@ export interface TelegramLeaderHealthRuntime {
 export interface TelegramManualThreadDisconnectDeps<TSyncState> {
   instanceId: string;
   getCurrentThreadRecord: () =>
-    | { target: TelegramTarget; instanceId?: string; owner?: { kind?: string } }
+    | {
+        target: TelegramTarget;
+        instanceId?: string;
+        profileKey?: string;
+        owner?: { kind?: string };
+      }
     | undefined;
   topicTargetStore: Pick<
     TelegramTopicTargetStore,
-    "markOfflineByInstanceId" | "persist"
+    | "markStaleByTarget"
+    | "persist"
+    | "upsertPendingCleanup"
+    | "removePendingCleanup"
   >;
   callApi: <TResponse>(
     method: string,
@@ -175,22 +183,44 @@ export function createTelegramManualThreadDisconnectHandler<
           }
         }
       } else {
-        const stillOwnsLeaderEpoch = () =>
-          !deps.getCurrentLeaderEpoch ||
-          (leaderEpoch !== undefined &&
-            deps.getCurrentLeaderEpoch() === leaderEpoch);
+        const target = currentRecord.target as TelegramTarget & {
+          threadId: number;
+        };
+        const runtimeGeneration = currentRecord.instanceId ?? deps.instanceId;
+        const intent: ThreadReconciler.TelegramThreadCleanupIntent = {
+          id: `cleanup:${deps.instanceId}:${runtimeGeneration}:${target.chatId}:${target.threadId}`,
+          owner: isManualFollower ? "manual-follower" : "leader",
+          instanceId: deps.instanceId,
+          runtimeGeneration,
+          ...(currentRecord.profileKey
+            ? { profileKey: currentRecord.profileKey }
+            : {}),
+          target,
+          requestedAtMs: (deps.getNowMs ?? Date.now)(),
+        };
+        deps.topicTargetStore.upsertPendingCleanup(intent);
+        await deps.topicTargetStore.persist();
         const cleanup = await ThreadReconciler.applyThreadReconciliationPlan(
-          ThreadReconciler.planDisconnectedInstanceThreadCleanup({
-            target: currentRecord.target as TelegramTarget & {
-              threadId: number;
-            },
-            instanceId: deps.instanceId,
-            leaderEpoch,
+          ThreadReconciler.planThreadReconciliation({
+            nowMs: (deps.getNowMs ?? Date.now)(),
+            currentLeaderEpoch: leaderEpoch,
+            records: [],
+            pendingCleanups: [intent],
           }),
           {
             callApi(method, body) {
               return deps.callApi(method, body);
             },
+            markStaleByTarget(targetToMark, syncStatus, lastSyncError) {
+              return deps.topicTargetStore.markStaleByTarget(
+                targetToMark,
+                syncStatus,
+                lastSyncError,
+              );
+            },
+            removeCleanupIntentById(id) {
+              return deps.topicTargetStore.removePendingCleanup(id);
+            },
             persist() {
               return deps.topicTargetStore.persist();
             },
@@ -203,14 +233,6 @@ export function createTelegramManualThreadDisconnectHandler<
             "Telegram thread deletion was not confirmed; inspect /telegram-status --debug and retry /telegram-disconnect.",
           );
         }
-        if (!stillOwnsLeaderEpoch()) return deps.stopPolling();
-        const offlineChanged =
-          deps.topicTargetStore.markOfflineByInstanceId(deps.instanceId) > 0;
-        if (!stillOwnsLeaderEpoch()) return deps.stopPolling();
-        if (offlineChanged) {
-          await deps.topicTargetStore.persist();
-          if (!stillOwnsLeaderEpoch()) return deps.stopPolling();
-        }
       }
       const leaderTarget = deps.getLeaderTarget();
       if (

package/lib/thread-reconciler.ts

@@ -48,6 +48,16 @@ export interface TelegramThreadPendingProvision {
   leaderEpoch?: number | string;
 }
 
+export interface TelegramThreadCleanupIntent {
+  id: string;
+  owner: "leader" | "manual-follower";
+  instanceId: string;
+  runtimeGeneration: string;
+  profileKey?: string;
+  target: ThreadTarget;
+  requestedAtMs: number;
+}
+
 export interface TelegramUnboundThreadMessageObservation {
   target: TelegramTarget & { threadId: number };
   observedAtMs: number;
@@ -130,6 +140,24 @@ export type ThreadReconciliationAction =
       messageId?: number;
       leaderEpoch?: number | string;
     }
+  | {
+      kind: "close-delete-graceful-shutdown-topic";
+      target: TelegramTarget & { threadId: number };
+      reason: "graceful-shutdown";
+      cleanupIntentId: string;
+      instanceId: string;
+      runtimeGeneration: string;
+      leaderEpoch?: number | string;
+    }
+  | {
+      kind: "cancel-superseded-graceful-shutdown-cleanup";
+      target: TelegramTarget & { threadId: number };
+      reason: "replacement-registration";
+      cleanupIntentId: string;
+      instanceId: string;
+      runtimeGeneration: string;
+      leaderEpoch?: number | string;
+    }
   | {
       kind: "close-delete-expired-pending-provision-topic";
       target: TelegramTarget & { threadId: number };
@@ -186,6 +214,7 @@ export interface ThreadReconciliationApplyPorts {
   ) => boolean;
   persist?: () => Promise<void>;
   removePendingProvisionById?: (id: string) => boolean;
+  removeCleanupIntentById?: (id: string) => boolean;
   getCurrentLeaderEpoch?: () => number | string | undefined;
   recordRuntimeEvent?: (
     category: string,
@@ -201,6 +230,7 @@ export interface ThreadReconciliationInput {
   reservations?: readonly ThreadReconciliationReservation[];
   observations?: readonly ThreadReconciliationObservation[];
   pendingProvisions?: readonly TelegramThreadPendingProvision[];
+  pendingCleanups?: readonly TelegramThreadCleanupIntent[];
   unboundMessages?: readonly TelegramUnboundThreadMessageObservation[];
   reservedMessages?: readonly TelegramReservedThreadMessageObservation[];
   proactiveReservationCleanup?: boolean;
@@ -291,6 +321,8 @@ function isCleanupAction(action: ThreadReconciliationAction): boolean {
     action.kind === "close-delete-replaced-follower-topic" ||
     action.kind === "close-delete-previous-leader-topic" ||
     action.kind === "close-delete-disconnected-instance-topic" ||
+    action.kind === "close-delete-graceful-shutdown-topic" ||
+    action.kind === "cancel-superseded-graceful-shutdown-cleanup" ||
     action.kind === "close-delete-expired-pending-provision-topic"
   );
 }
@@ -505,6 +537,26 @@ export async function applyThreadReconciliationPlan(
         shouldPersist;
       continue;
     }
+    if (action.kind === "cancel-superseded-graceful-shutdown-cleanup") {
+      if (shouldSkipForStaleLeaderEpoch(action, ports)) {
+        incompleteActions.push(action);
+        continue;
+      }
+      const changed =
+        ports.removeCleanupIntentById?.(action.cleanupIntentId) ?? false;
+      shouldPersist = changed || shouldPersist;
+      ports.recordRuntimeEvent?.(
+        "telegram",
+        "Cancelled superseded Telegram topic cleanup",
+        {
+          phase: "thread-reconciler-cleanup-superseded",
+          instanceId: action.instanceId,
+          chatId: action.target.chatId,
+          threadId: action.target.threadId,
+        },
+      );
+      continue;
+    }
     if (action.kind === "close-stale-replaced-topic") {
       if (shouldSkipForStaleLeaderEpoch(action, ports)) {
         incompleteActions.push(action);
@@ -558,6 +610,7 @@ export async function applyThreadReconciliationPlan(
       action.kind === "close-delete-replaced-follower-topic" ||
       action.kind === "close-delete-previous-leader-topic" ||
       action.kind === "close-delete-disconnected-instance-topic" ||
+      action.kind === "close-delete-graceful-shutdown-topic" ||
       action.kind === "close-delete-expired-pending-provision-topic"
     ) {
       if (shouldSkipForStaleLeaderEpoch(action, ports)) {
@@ -647,7 +700,9 @@ export async function applyThreadReconciliationPlan(
                   ? "Previous leader Telegram topic deleted"
                   : action.kind === "close-delete-disconnected-instance-topic"
                     ? "Disconnected instance Telegram topic deleted"
-                    : "Expired pending provision Telegram topic deleted",
+                    : action.kind === "close-delete-graceful-shutdown-topic"
+                      ? "Graceful shutdown Telegram topic deleted"
+                      : "Expired pending provision Telegram topic deleted",
         {
           phase:
             action.kind === "close-delete-unbound-topic"
@@ -661,7 +716,10 @@ export async function applyThreadReconciliationPlan(
                       : action.kind ===
                           "close-delete-disconnected-instance-topic"
                         ? "thread-reconciler-disconnected-instance-topic-delete"
-                        : "thread-reconciler-expired-pending-provision-topic-delete",
+                        : action.kind ===
+                            "close-delete-graceful-shutdown-topic"
+                          ? "thread-reconciler-graceful-shutdown-topic-delete"
+                          : "thread-reconciler-expired-pending-provision-topic-delete",
           chatId: action.target.chatId,
           threadId: action.target.threadId,
           ...("messageId" in action ? { messageId: action.messageId } : {}),
@@ -678,6 +736,16 @@ export async function applyThreadReconciliationPlan(
         if (changed) persistFences.push(action);
         shouldPersist = changed || shouldPersist;
       }
+      if (
+        action.kind === "close-delete-graceful-shutdown-topic" &&
+        deleteConfirmed
+      ) {
+        if (shouldSkipForStaleLeaderEpoch(action, ports)) continue;
+        const changed =
+          ports.removeCleanupIntentById?.(action.cleanupIntentId) ?? false;
+        if (changed) persistFences.push(action);
+        shouldPersist = changed || shouldPersist;
+      }
     }
   }
   if (shouldPersist) {
@@ -736,6 +804,36 @@ export function planThreadReconciliation(
   );
 
   const actions: ThreadReconciliationAction[] = [];
+  for (const cleanup of input.pendingCleanups ?? []) {
+    const superseded = input.records.some(
+      (record) =>
+        isCurrentRecord(record) &&
+        targetKey(record.target) === targetKey(cleanup.target) &&
+        record.instanceId !== cleanup.instanceId,
+    );
+    const common = {
+      target: cleanup.target,
+      cleanupIntentId: cleanup.id,
+      instanceId: cleanup.instanceId,
+      runtimeGeneration: cleanup.runtimeGeneration,
+      ...(input.currentLeaderEpoch !== undefined
+        ? { leaderEpoch: input.currentLeaderEpoch }
+        : {}),
+    };
+    if (superseded) {
+      actions.push({
+        ...common,
+        kind: "cancel-superseded-graceful-shutdown-cleanup",
+        reason: "replacement-registration",
+      });
+    } else {
+      actions.push({
+        ...common,
+        kind: "close-delete-graceful-shutdown-topic",
+        reason: "graceful-shutdown",
+      });
+    }
+  }
   for (const provision of input.pendingProvisions ?? []) {
     if (!provision.target) continue;
     if (!isPendingProvisionExpired(provision, input.nowMs)) continue;

package/lib/threads.ts

@@ -92,6 +92,9 @@ export interface TelegramThreadPendingProvision {
   leaderEpoch?: number | string;
 }
 
+export type TelegramThreadCleanupIntent =
+  ThreadReconciler.TelegramThreadCleanupIntent;
+
 type TelegramProvisionRecoveryFile = Record<
   string,
   {
@@ -160,6 +163,7 @@ export interface TelegramTopicTargetFile {
   identities?: TelegramThreadIdentityRecord[];
   reservations?: TelegramThreadReservation[];
   pendingProvisions?: TelegramThreadPendingProvision[];
+  pendingCleanups?: TelegramThreadCleanupIntent[];
   syncObservations?: TelegramTopicSyncObservation[];
 }
 
@@ -229,6 +233,7 @@ export interface TelegramTopicTargetStore {
   ) => { slot?: string; threadName?: string } | undefined;
   listReservations: () => TelegramThreadReservation[];
   listPendingProvisions: () => TelegramThreadPendingProvision[];
+  listPendingCleanups: () => TelegramThreadCleanupIntent[];
   listSyncObservations: () => TelegramTopicSyncObservation[];
   reserveThread: (reservation: TelegramThreadReservation) => void;
   upsertPendingProvision: (provision: TelegramThreadPendingProvision) => void;
@@ -237,6 +242,8 @@ export interface TelegramTopicTargetStore {
     target: TelegramTarget & { threadId: number },
   ) => Promise<boolean>;
   removePendingProvision: (id: string) => boolean;
+  upsertPendingCleanup: (intent: TelegramThreadCleanupIntent) => void;
+  removePendingCleanup: (id: string) => boolean;
   getBotState: () => TelegramBotStateSnapshot;
   setBotState: (state: Partial<TelegramBotStateSnapshot>) => void;
   setStatusSnapshot: (snapshot: {
@@ -876,6 +883,56 @@ function normalizePendingProvision(
   };
 }
 
+function normalizePendingCleanup(
+  value: unknown,
+): TelegramThreadCleanupIntent | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return undefined;
+  const record = value as Record<string, unknown>;
+  const targetValue = record.target;
+  if (
+    !targetValue ||
+    typeof targetValue !== "object" ||
+    Array.isArray(targetValue)
+  ) {
+    return undefined;
+  }
+  const targetRecord = targetValue as Record<string, unknown>;
+  const owner = record.owner;
+  if (owner !== "leader" && owner !== "manual-follower") return undefined;
+  if (typeof record.id !== "string" || record.id.length === 0) return undefined;
+  if (typeof record.instanceId !== "string" || record.instanceId.length === 0)
+    return undefined;
+  if (
+    typeof record.runtimeGeneration !== "string" ||
+    record.runtimeGeneration.length === 0
+  ) {
+    return undefined;
+  }
+  if (
+    typeof targetRecord.chatId !== "number" ||
+    typeof targetRecord.threadId !== "number" ||
+    !Number.isInteger(targetRecord.threadId) ||
+    typeof record.requestedAtMs !== "number"
+  ) {
+    return undefined;
+  }
+  return {
+    id: record.id,
+    owner,
+    instanceId: record.instanceId,
+    runtimeGeneration: record.runtimeGeneration,
+    ...(typeof record.profileKey === "string"
+      ? { profileKey: record.profileKey }
+      : {}),
+    target: {
+      chatId: targetRecord.chatId,
+      threadId: targetRecord.threadId,
+    },
+    requestedAtMs: record.requestedAtMs,
+  };
+}
+
 function normalizeReservation(
   value: unknown,
 ): TelegramThreadReservation | undefined {
@@ -970,6 +1027,12 @@ function parseTopicTargetFile(value: unknown): TelegramTopicTargetFile {
           return normalized ? [normalized] : [];
         })
       : [],
+    pendingCleanups: Array.isArray(file.pendingCleanups)
+      ? file.pendingCleanups.flatMap((intent) => {
+          const normalized = normalizePendingCleanup(intent);
+          return normalized ? [normalized] : [];
+        })
+      : [],
     syncObservations: Array.isArray(file.syncObservations)
       ? file.syncObservations.flatMap((observation) => {
           const normalized = normalizeSyncObservation(observation);
@@ -1084,6 +1147,7 @@ export function createTelegramTopicTargetStore(
   let identities = new Map<string, TelegramThreadIdentityRecord>();
   let reservations: TelegramThreadReservation[] = [];
   let pendingProvisions: TelegramThreadPendingProvision[] = [];
+  let pendingCleanups: TelegramThreadCleanupIntent[] = [];
   let syncObservations: TelegramTopicSyncObservation[] = [];
   let followerRecoveryHints = new Map<
     string,
@@ -1140,6 +1204,7 @@ export function createTelegramTopicTargetStore(
     identities = new Map();
     reservations = [];
     pendingProvisions = [];
+    pendingCleanups = [];
     syncObservations = [];
     followerRecoveryHints = new Map();
     statusSnapshot = {};
@@ -1157,6 +1222,7 @@ export function createTelegramTopicTargetStore(
       identities = new Map();
       reservations = [];
       pendingProvisions = [];
+      pendingCleanups = [];
       syncObservations = [];
       followerRecoveryHints = new Map();
       loaded = true;
@@ -1207,6 +1273,10 @@ export function createTelegramTopicTargetStore(
               : {}),
         };
       });
+    pendingCleanups = (file.pendingCleanups ?? []).map((intent) => ({
+      ...intent,
+      target: { ...intent.target },
+    }));
     syncObservations = (file.syncObservations ?? []).map((observation) => ({
       ...observation,
       target: { ...observation.target },
@@ -1269,6 +1339,10 @@ export function createTelegramTopicTargetStore(
             ...provision,
             ...(provision.target ? { target: { ...provision.target } } : {}),
           })),
+          pendingCleanups: pendingCleanups.map((intent) => ({
+            ...intent,
+            target: { ...intent.target },
+          })),
           syncObservations: syncObservations.map((observation) => ({
             ...observation,
             target: { ...observation.target },
@@ -1355,6 +1429,12 @@ export function createTelegramTopicTargetStore(
           ...(provision.target ? { target: { ...provision.target } } : {}),
         }));
     },
+    listPendingCleanups() {
+      return pendingCleanups.map((intent) => ({
+        ...intent,
+        target: { ...intent.target },
+      }));
+    },
     listSyncObservations() {
       return syncObservations.map((observation) => ({
         ...observation,
@@ -1425,6 +1505,21 @@ export function createTelegramTopicTargetStore(
       if (changed) markDirty();
       return changed;
     },
+    upsertPendingCleanup(intent) {
+      const next = { ...intent, target: { ...intent.target } };
+      pendingCleanups = pendingCleanups.filter(
+        (existing) => existing.id !== next.id,
+      );
+      pendingCleanups.push(next);
+      markDirty();
+    },
+    removePendingCleanup(id) {
+      const before = pendingCleanups.length;
+      pendingCleanups = pendingCleanups.filter((intent) => intent.id !== id);
+      const changed = pendingCleanups.length !== before;
+      if (changed) markDirty();
+      return changed;
+    },
     getBotState() {
       return Object.fromEntries(
         Object.entries(botState).filter(([, value]) => value !== undefined),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.24.6",
+  "version": "0.24.7",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -30,7 +30,8 @@
     "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": "node --experimental-strip-types scripts/audit-dependencies.ts",
+    "audit": "npm audit --omit=peer",
+    "audit:host": "npm audit",
     "pack:check": "npm pack --dry-run",
     "validate": "npm run typecheck && npm test && npm run audit && npm run pack:check"
   },
@@ -74,29 +75,5 @@
   "devDependencies": {
     "@types/node": "latest",
     "typescript": "latest"
-  },
-  "overrides": {
-    "brace-expansion": "5.0.7",
-    "protobufjs": "7.6.5",
-    "undici": "8.5.0",
-    "ws": "8.21.0",
-    "@earendil-works/pi-coding-agent": {
-      "brace-expansion": "5.0.7",
-      "protobufjs": "7.6.5",
-      "undici": "8.5.0",
-      "ws": "8.21.0",
-      "@google/genai": {
-        "protobufjs": "7.6.5",
-        "ws": "8.21.0"
-      },
-      "@earendil-works/pi-ai": {
-        "protobufjs": "7.6.5",
-        "ws": "8.21.0",
-        "@google/genai": {
-          "protobufjs": "7.6.5",
-          "ws": "8.21.0"
-        }
-      }
-    }
   }
 }

package/scripts/audit-dependencies.ts

@@ -1,78 +0,0 @@
-/**
- * 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;
-}