@llblab/pi-telegram 0.51.3 → 0.51.5

package/lib/commands.ts

@@ -2440,6 +2440,19 @@ export interface TelegramSessionActionAssemblyDeps {
   };
   getProfileName: () => string | undefined;
   ownsPersistence: () => boolean;
+  /**
+   * Registered-follower port. A follower cannot persist leader-owned state, so
+   * its Workspace Thread intent is published and claimed by the leader over
+   * authenticated generation-fenced bus RPC.
+   */
+  follower?: {
+    instanceId: string;
+    isRegisteredFor: (target: { chatId: number; threadId?: number }) => boolean;
+    requestSessionReplacement: (
+      operation: "publish" | "settle",
+      intent: TelegramSessionReplacementIntent,
+    ) => Promise<boolean>;
+  };
   sendResult: (
     target: { chatId: number; threadId?: number },
     html: string,
@@ -2478,7 +2491,13 @@ export function createTelegramSessionActionAssembly(
     sendUserMessage: deps.sendUserMessage,
     notifyResult(target, result) { return sendTerminalResult(target, result); },
     async prepareReplacement(ctx, updateId, target) {
-      await deps.store.load();
+      const follower = !deps.ownsPersistence() && typeof target.threadId === "number" &&
+          deps.follower?.isRegisteredFor(target)
+        ? deps.follower
+        : undefined;
+      // Follower memory is not authority; reread the leader-published snapshot.
+      if (follower && deps.store.refresh) await deps.store.refresh();
+      else await deps.store.load();
       const sessionId = ctx.sessionManager.getSessionId();
       const binding = typeof target.threadId === "number"
         ? deps.store.getWorkspaceBindingByTarget(target)
@@ -2488,7 +2507,7 @@ export function createTelegramSessionActionAssembly(
         throw new Error("Telegram session replacement binding is unavailable.");
       }
       const createdAtMs = now();
-      if (!await deps.store.commitSessionReplacementIntent({
+      const intent: TelegramSessionReplacementIntent = {
         continuity: binding ? "workspace-thread" : "classic-chat",
         cwd: binding?.cwd ?? ctx.cwd,
         profileName: deps.getProfileName() ?? "default",
@@ -2501,7 +2520,11 @@ export function createTelegramSessionActionAssembly(
           ? { threadName: binding.manualThreadName ?? binding.threadName } : {}),
         createdAtMs,
         expiresAtMs: createdAtMs + deps.handoffTtlMs,
-      }, deps.ownsPersistence)) {
+        ...(follower ? { sourceInstanceId: follower.instanceId } : {}),
+      };
+      if (!await (follower
+        ? follower.requestSessionReplacement("publish", intent)
+        : deps.store.commitSessionReplacementIntent(intent, deps.ownsPersistence))) {
         throw new Error("Telegram session replacement intent was not persisted.");
       }
     },
@@ -2514,11 +2537,20 @@ export function createTelegramSessionActionAssembly(
       return {
         async getIntent() { await deps.store.refresh?.(); return deps.store.getSessionReplacementIntent(); },
         hasSuccessorContinuity(intent) {
-          return intent.continuity === "classic-chat" ||
-            deps.store.getWorkspaceBindingByTarget(intent.target, sessionId)?.cwd === intent.cwd;
+          if (intent.continuity === "classic-chat") return true;
+          if (deps.store.getWorkspaceBindingByTarget(intent.target, sessionId)?.cwd !==
+              intent.cwd) return false;
+          // A follower successor claims only after its own re-registration is live.
+          return intent.sourceInstanceId === undefined || deps.ownsPersistence() ||
+            deps.follower?.isRegisteredFor(intent.target) === true;
         },
         editSuccess(intent) { return deps.sendResult(intent.target, "<b>🆕 New session started.</b>"); },
-        clearIntent(intent) { return deps.store.removeSessionReplacementIntent(intent, deps.ownsPersistence); },
+        async clearIntent(intent) {
+          if (intent.sourceInstanceId === undefined || deps.ownsPersistence()) {
+            return deps.store.removeSessionReplacementIntent(intent, deps.ownsPersistence);
+          }
+          return await deps.follower?.requestSessionReplacement("settle", intent) ?? false;
+        },
         profileName: deps.getProfileName() ?? "default",
         cwd: ctx.cwd,
         sessionId,

package/lib/extension.ts

@@ -65,6 +65,7 @@ const telegramBusProtocolIdentity =
     Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME,
     Bus.TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE,
     Bus.TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT,
+    Bus.TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT,
   ]);
 
 // --- Extension Runtime ---
@@ -244,6 +245,20 @@ export default function (pi: Pi.ExtensionAPI) {
     store: threadStore,
     getProfileName: configStore.getActiveProfileName,
     ownsPersistence: lockRuntime.owns,
+    follower: {
+      instanceId: telegramInstanceId,
+      isRegisteredFor(target) {
+        const registered = telegramBusFollowerRegistrationState.getTarget();
+        return telegramBusFollowerRegistrationState.isRegistered() &&
+          registered?.chatId === target.chatId &&
+          registered.threadId === target.threadId;
+      },
+      async requestSessionReplacement(operation, intent) {
+        const request = telegramBusFollowerRegistration.requestSessionReplacement;
+        if (!request) return false;
+        return await request(operation, intent);
+      },
+    },
     async sendResult(target, html) {
       const delivery = await Delivery.sendTelegramView(
         { text: html, parseMode: "html", replyMarkup: { inline_keyboard: [] } },

package/lib/locks.ts

@@ -1515,7 +1515,12 @@ export function createTelegramLockedPollingRuntime<
             ctx,
             state.lock,
           );
-          if (!isCurrent() || !restored) return;
+          if (!isCurrent()) return;
+          if (!restored) {
+            deps.recordRuntimeEvent?.("lock", "Telegram follower auto-connect did not restore this session.",
+              { phase: "follower-auto-connect-unavailable" });
+            return;
+          }
           deps.onTransportAvailabilityChanged?.();
           deps.updateStatus(ctx);
           deps.recordRuntimeEvent?.(

package/lib/polling.ts

@@ -1180,8 +1180,16 @@ export function createTelegramThreadAwarePollingPorts<TContext, TOwner>(
     ctx: TContext,
     owner: TOwner,
   ): Promise<boolean | undefined> => {
-    if (!(await refreshFollowerState())) return undefined;
-    if (!deps.hasRememberedWorkspaceBinding?.(ctx)) return undefined;
+    if (!(await refreshFollowerState())) {
+      deps.recordEvent("bus", "Telegram follower auto-connect skipped: Threaded Mode is not enabled.",
+        { phase: "follower-auto-connect-skip", reason: "thread-mode-unavailable" });
+      return undefined;
+    }
+    if (!deps.hasRememberedWorkspaceBinding?.(ctx)) {
+      deps.recordEvent("bus", "Telegram follower auto-connect skipped: no binding for this session.",
+        { phase: "follower-auto-connect-skip", reason: "session-binding-unavailable" });
+      return undefined;
+    }
     return deps.restoreFollowerWithLeader?.(ctx, owner);
   };
   return {

package/lib/skills.ts

@@ -4,26 +4,62 @@
  * Owns source-checkout skill contribution; installed packages use their manifest
  */
 
-import { extname } from "node:path";
+import { existsSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import type { ExtensionAPI } from "./pi.ts";
+import { resolveAgentDir } from "./paths.ts";
 
 const TELEGRAM_SKILLS_MODULE_PATH = fileURLToPath(import.meta.url);
 
-export const TELEGRAM_SKILLS_PATH = fileURLToPath(
-  new URL("../skills", import.meta.url),
+export function getTelegramExtensionPackageRoot(modulePath: string): string {
+  let current = dirname(modulePath);
+  while (true) {
+    if (existsSync(join(current, "package.json"))) {
+      const parent = dirname(current);
+      if (basename(current) === "dist" && existsSync(join(parent, "package.json"))) {
+        return parent;
+      }
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return dirname(modulePath);
+    current = parent;
+  }
+}
+
+export interface TelegramRawExtensionCheckoutOptions {
+  agentDir?: string;
+  cwd?: string;
+}
+
+export function isRawTelegramExtensionCheckout(
+  modulePath: string,
+  options: TelegramRawExtensionCheckoutOptions = {},
+): boolean {
+  const packageRoot = resolve(getTelegramExtensionPackageRoot(modulePath));
+  const agentDir = resolve(options.agentDir ?? resolveAgentDir());
+  const cwd = resolve(options.cwd ?? process.cwd());
+  return dirname(packageRoot) === join(agentDir, "extensions") ||
+    dirname(packageRoot) === join(cwd, ".pi", "extensions");
+}
+
+export const TELEGRAM_SKILLS_PATH = join(
+  getTelegramExtensionPackageRoot(TELEGRAM_SKILLS_MODULE_PATH),
+  "skills",
 );
 
 export function registerTelegramSkillDiscovery(
   pi: Pick<ExtensionAPI, "on">,
   modulePath = TELEGRAM_SKILLS_MODULE_PATH,
+  options: TelegramRawExtensionCheckoutOptions = {},
 ): boolean {
-  // A raw source extension has no package manifest owner. Compiled npm/git
-  // packages do, so contributing again would bypass their resource filters.
-  if (extname(modulePath) !== ".ts") return false;
+  // Pi auto-discovers extension entrypoints but not their manifest Skills.
+  // Manifest-loaded packages own Skills and filters through `pi.skills`.
+  if (!isRawTelegramExtensionCheckout(modulePath, options)) return false;
   pi.on("resources_discover", () => ({
-    skillPaths: [TELEGRAM_SKILLS_PATH],
+    skillPaths: [join(getTelegramExtensionPackageRoot(modulePath), "skills")],
   }));
   return true;
 }

package/lib/threads.ts

@@ -371,6 +371,12 @@ export interface TelegramSessionReplacementIntent {
   threadName?: string;
   createdAtMs: number;
   expiresAtMs: number;
+  /**
+   * Present only when the leader published the intent for a registered
+   * follower. Successor re-key and settlement must come from this exact
+   * follower runtime or its authenticated same-process session handoff.
+   */
+  sourceInstanceId?: string;
 }
 
 export interface TelegramTopicTargetFile {
@@ -1329,7 +1335,7 @@ function cloneSessionReplacementIntent(
   return { ...intent, target: { ...intent.target } };
 }
 
-function normalizeSessionReplacementIntent(
+export function normalizeTelegramSessionReplacementIntent(
   value: unknown,
 ): TelegramSessionReplacementIntent | undefined {
   if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
@@ -1346,7 +1352,10 @@ function normalizeSessionReplacementIntent(
     typeof record.messageId !== "number" || !Number.isSafeInteger(record.messageId) ||
     typeof record.createdAtMs !== "number" || !Number.isSafeInteger(record.createdAtMs) ||
     typeof record.expiresAtMs !== "number" || !Number.isSafeInteger(record.expiresAtMs) ||
-    record.expiresAtMs <= record.createdAtMs
+    record.expiresAtMs <= record.createdAtMs ||
+    (record.sourceInstanceId !== undefined &&
+      (typeof record.sourceInstanceId !== "string" || !record.sourceInstanceId ||
+        record.sourceInstanceId.length > 256))
   ) return undefined;
   const continuity = record.continuity === "workspace-thread" ||
       record.continuity === "classic-chat"
@@ -1370,6 +1379,8 @@ function normalizeSessionReplacementIntent(
     ...(typeof record.threadName === "string" ? { threadName: record.threadName } : {}),
     createdAtMs: record.createdAtMs,
     expiresAtMs: record.expiresAtMs,
+    ...(typeof record.sourceInstanceId === "string"
+      ? { sourceInstanceId: record.sourceInstanceId } : {}),
   };
 }
 
@@ -1680,7 +1691,7 @@ function parseTopicTargetFile(value: unknown): TelegramTopicTargetFile {
           return normalized ? [normalized] : [];
         })
       : [],
-    sessionReplacement: normalizeSessionReplacementIntent(file.sessionReplacement),
+    sessionReplacement: normalizeTelegramSessionReplacementIntent(file.sessionReplacement),
     reservations: Array.isArray(file.reservations)
       ? file.reservations.flatMap((reservation) => {
           const normalized = normalizeReservation(reservation);
@@ -2510,7 +2521,7 @@ export function createTelegramTopicTargetStore(
         : undefined;
     },
     async commitSessionReplacementIntent(intent, isCurrent) {
-      const next = normalizeSessionReplacementIntent(intent);
+      const next = normalizeTelegramSessionReplacementIntent(intent);
       if (!next || !isCurrent()) return false;
       await loadFromDisk();
       if (!isCurrent()) return false;
@@ -2925,7 +2936,10 @@ export function createTelegramTopicTargetStore(
         replacement.expiresAtMs > getNowMs() &&
         replacement.profileName === (getTelegramProfile() ?? "default") &&
         replacement.cwd === normalizedCwd &&
-        replacement.sourceSessionId !== normalizedSessionId
+        replacement.sourceSessionId !== normalizedSessionId &&
+        (replacement.sourceInstanceId === undefined ||
+          replacement.sourceInstanceId === instanceId ||
+          replacement.sourceInstanceId === previousInstanceId)
       ) {
         const sourceEntry = Array.from(workspaceBindings.entries()).find(([, binding]) =>
           binding.cwd === normalizedCwd &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.51.3",
+  "version": "0.51.5",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -31,12 +31,13 @@
     "test:verbose": "node --experimental-strip-types --test --test-reporter=spec tests/*.test.ts",
     "typecheck": "tsc --noEmit",
     "build": "node scripts/build-dist.mjs",
+    "build:check": "node scripts/build-dist.mjs --check",
     "prepack": "npm run build",
     "check": "node -e \"await import('./dist/pi-telegram/index.js'); console.log('pi-telegram: extension import ok')\"",
     "audit": "npm audit --omit=peer",
     "audit:host": "npm audit",
     "pack:check": "npm pack --dry-run",
-    "validate": "npm run build && npm run typecheck && npm test && npm run audit && npm run check && npm run pack:check"
+    "validate": "npm run build:check && npm run typecheck && npm test && npm run audit && npm run check && npm run pack:check"
   },
   "files": [
     "index.ts",
@@ -102,15 +103,9 @@
     "extensions": [
       "./dist/pi-telegram/index.js"
     ],
-    "sourceExtensions": [
-      "./index.ts"
-    ],
     "skills": [
       "./dist/skills"
     ],
-    "sourceSkills": [
-      "./skills"
-    ],
     "image": "https://raw.githubusercontent.com/llblab/pi-telegram/main/screenshot.png"
   },
   "peerDependencies": {

package/scripts/build-dist.mjs

@@ -1,44 +1,115 @@
 #!/usr/bin/env node
 
 /**
- * Builds the distributive JavaScript, declarations, Pi entrypoint, and Skills.
- * Usage: node scripts/build-dist.mjs
- *
- * The build replaces `dist`, compiles with `tsconfig.build.json`, then copies
- * package-owned runtime assets. It does not publish, pack, or modify sources.
+ * Builds or verifies the distributive JavaScript, declarations, Pi entrypoint,
+ * Skills, and runtime assets without exposing a partial tree.
  */
 
 import { spawnSync } from "node:child_process";
-import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join, relative } from "node:path";
+
+const DIST_DIR = "dist";
+const checkOnly = process.argv.includes("--check");
 
 function run(command, args) {
   const result = spawnSync(command, args, { stdio: "inherit" });
   if (result.error) throw result.error;
-  if (result.status !== 0) process.exit(result.status ?? 1);
+  if (result.status !== 0) {
+    throw new Error(`${command} exited with status ${result.status ?? "unknown"}.`);
+  }
+}
+
+function listFiles(root, current = root) {
+  return readdirSync(current, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(current, entry.name);
+    return entry.isDirectory() ? listFiles(root, path) : [relative(root, path)];
+  }).sort();
+}
+
+function normalizeTextFiles(root) {
+  const textSuffixes = [".js", ".ts", ".mjs", ".json", ".md"];
+  for (const path of listFiles(root)) {
+    if (!textSuffixes.some((suffix) => path.endsWith(suffix))) continue;
+    const absolutePath = join(root, path);
+    const source = readFileSync(absolutePath, "utf8");
+    const normalized = source.replace(/\r\n?/g, "\n");
+    if (normalized !== source) writeFileSync(absolutePath, normalized, "utf8");
+  }
+}
+
+function assertTreesEqual(expectedRoot, actualRoot) {
+  if (!existsSync(expectedRoot)) {
+    throw new Error(`${expectedRoot} is missing; run npm run build.`);
+  }
+  const expectedFiles = listFiles(expectedRoot);
+  const actualFiles = listFiles(actualRoot);
+  if (JSON.stringify(expectedFiles) !== JSON.stringify(actualFiles)) {
+    throw new Error("dist file inventory is stale; run npm run build.");
+  }
+  for (const path of expectedFiles) {
+    if (!readFileSync(join(expectedRoot, path)).equals(readFileSync(join(actualRoot, path)))) {
+      throw new Error(`dist/${path} is stale; run npm run build.`);
+    }
+  }
+}
+
+function replaceDist(candidate) {
+  const backup = `.dist-backup-${process.pid}-${Date.now()}`;
+  const hadDist = existsSync(DIST_DIR);
+  if (hadDist) renameSync(DIST_DIR, backup);
+  try {
+    renameSync(candidate, DIST_DIR);
+    if (hadDist) rmSync(backup, { recursive: true, force: true });
+  } catch (error) {
+    if (hadDist && existsSync(backup) && !existsSync(DIST_DIR)) {
+      renameSync(backup, DIST_DIR);
+    }
+    throw error;
+  }
 }
 
-rmSync("dist", { recursive: true, force: true });
-mkdirSync("dist", { recursive: true });
-
-run(process.execPath, [
-  join("node_modules", "typescript", "bin", "tsc"),
-  "-p",
-  "tsconfig.build.json",
-]);
-
-mkdirSync(join("dist", "pi-telegram"), { recursive: true });
-writeFileSync(
-  join("dist", "pi-telegram", "index.js"),
-  'export { default } from "../index.js";\n',
-  "utf8",
-);
-
-cpSync("skills", join("dist", "skills"), { recursive: true });
-cpSync("package.json", join("dist", "package.json"));
-cpSync(
-  join("lib", "generative-app-worker.mjs"),
-  join("dist", "lib", "generative-app-worker.mjs"),
-);
-
-run(process.execPath, ["--check", join("dist", "pi-telegram", "index.js")]);
+const candidate = mkdtempSync(join(process.cwd(), ".dist-build-"));
+try {
+  run(process.execPath, [
+    join("node_modules", "typescript", "bin", "tsc"),
+    "-p",
+    "tsconfig.build.json",
+    "--outDir",
+    candidate,
+  ]);
+
+  mkdirSync(join(candidate, "pi-telegram"), { recursive: true });
+  writeFileSync(
+    join(candidate, "pi-telegram", "index.js"),
+    'export { default } from "../index.js";\n',
+    "utf8",
+  );
+  normalizeTextFiles(candidate);
+  cpSync("skills", join(candidate, "skills"), { recursive: true });
+  cpSync("package.json", join(candidate, "package.json"));
+  cpSync(
+    join("lib", "generative-app-worker.mjs"),
+    join(candidate, "lib", "generative-app-worker.mjs"),
+  );
+  run(process.execPath, ["--check", join(candidate, "pi-telegram", "index.js")]);
+
+  if (checkOnly) {
+    assertTreesEqual(DIST_DIR, candidate);
+    console.log("pi-telegram: dist is current");
+  } else {
+    replaceDist(candidate);
+  }
+} finally {
+  rmSync(candidate, { recursive: true, force: true });
+}