larkway 0.3.31 → 0.3.32

package/dist/main.js

@@ -118306,6 +118306,84 @@ function renderPrompt(input) {
   ].join("\n");
 }
 
+// src/lark/rosterResolver.ts
+import { execFile as execFile2 } from "node:child_process";
+function parseBotRoster(stdout) {
+  const roster = /* @__PURE__ */ new Map();
+  let json2;
+  try {
+    json2 = JSON.parse(stdout);
+  } catch {
+    return roster;
+  }
+  const items = json2?.data?.items;
+  if (!Array.isArray(items)) return roster;
+  for (const item of items) {
+    if (typeof item !== "object" || item === null) continue;
+    const record = item;
+    const name = record["bot_name"];
+    const id = record["bot_id"];
+    if (typeof name === "string" && name && typeof id === "string" && id) {
+      roster.set(name, id);
+    }
+  }
+  return roster;
+}
+function remapPeersToLiveRoster(peers, liveRoster) {
+  const remapped = [];
+  const unresolved = [];
+  const out = peers.map((peer) => {
+    const liveId = liveRoster.get(peer.name);
+    if (!liveId) {
+      unresolved.push(peer.name);
+      return peer;
+    }
+    if (liveId !== peer.id) {
+      remapped.push(peer.name);
+      return { ...peer, id: liveId };
+    }
+    return peer;
+  });
+  return { peers: out, remapped, unresolved };
+}
+async function resolveChatBotRoster(chatId, opts = {}) {
+  const cli = opts.larkCliPath ?? "lark-cli";
+  const args = ["im", "chat.members", "bots", "--chat-id", chatId, "--as", "bot"];
+  if (opts.profile) args.push("--profile", opts.profile);
+  const exec = opts.exec ?? defaultExec(opts.timeoutMs ?? 1e4);
+  try {
+    const stdout = await exec(cli, args);
+    const roster = parseBotRoster(stdout);
+    return roster.size > 0 ? roster : null;
+  } catch {
+    return null;
+  }
+}
+function defaultExec(timeoutMs) {
+  return (cmd, args) => new Promise((resolve2, reject) => {
+    execFile2(cmd, args, { timeout: timeoutMs, maxBuffer: 1024 * 1024 }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve2(stdout);
+    });
+  });
+}
+function createCachedRosterResolver(opts) {
+  const ttlMs = opts.ttlMs ?? 5 * 60 * 1e3;
+  const now = opts.now ?? (() => Date.now());
+  const cache = /* @__PURE__ */ new Map();
+  return async (chatId) => {
+    const hit = cache.get(chatId);
+    if (hit && now() - hit.at < ttlMs) return hit.roster;
+    const roster = await resolveChatBotRoster(chatId, {
+      profile: opts.profile,
+      larkCliPath: opts.larkCliPath,
+      exec: opts.exec
+    });
+    cache.set(chatId, { roster, at: now() });
+    return roster;
+  };
+}
+
 // src/agent/runner.ts
 var _registry = /* @__PURE__ */ new Map();
 function registerRunner(backend, factory) {
@@ -120132,7 +120210,7 @@ async function ensureNodeModules(worktreePath) {
   if (await pathExists(modulesMarker)) return;
   const start = Date.now();
   try {
-    await execFile2(
+    await execFile3(
       "pnpm",
       ["install", "--offline", "--frozen-lockfile"],
       { cwd: monorepDir, timeoutMs: 18e4 }
@@ -120146,7 +120224,7 @@ async function ensureNodeModules(worktreePath) {
       `[bridge.handler] --offline install failed (will fall back to network): ${offlineErr.message.slice(0, 200)}`
     );
   }
-  await execFile2(
+  await execFile3(
     "pnpm",
     ["install", "--frozen-lockfile"],
     { cwd: monorepDir, timeoutMs: 6e5 }
@@ -120155,7 +120233,7 @@ async function ensureNodeModules(worktreePath) {
     `[bridge.handler] pnpm install (network) ok (${((Date.now() - start) / 1e3).toFixed(1)}s) in ${monorepDir}`
   );
 }
-function execFile2(cmd, args, opts) {
+function execFile3(cmd, args, opts) {
   return new Promise((resolve2, reject) => {
     const child = child_process.spawn(cmd, args, {
       cwd: opts.cwd,
@@ -120223,9 +120301,30 @@ async function createOnlyPostFallback(opts) {
 var BridgeHandler = class {
   deps;
   closed = false;
+  /**
+   * In-flight per-turn completion promises. run() dispatches handleOne
+   * fire-and-forget (thread-serialized), so run() returning does NOT mean the
+   * turn finished. Each entry resolves only when its handleOne AND all trailing
+   * work (terminal render + ledger writes, incl. the failure-path fallback that
+   * runs after the early settle) have completed. {@link whenAllTurnsSettled}
+   * awaits these — the real turn boundary tests must sync assertions/cleanup on.
+   */
+  inFlightTurns = /* @__PURE__ */ new Set();
   constructor(deps) {
     this.deps = deps;
   }
+  /**
+   * Resolves when every dispatched turn has fully completed (handleOne returned
+   * and its trailing render/ledger I/O drained). Test-facing sync point; a bridge
+   * that keeps receiving events would keep finding work, so callers use this
+   * after the event source is exhausted (e.g. right after `await run()` in a
+   * single-message test).
+   */
+  async whenAllTurnsSettled() {
+    while (this.inFlightTurns.size > 0) {
+      await Promise.all([...this.inFlightTurns]);
+    }
+  }
   runtimeWarnings() {
     return (this.deps.runtimeRequirements ?? []).filter(
       (req) => !req.ok && (req.severity === "required" || req.kind === "secret")
@@ -120276,7 +120375,9 @@ var BridgeHandler = class {
       }).finally(() => {
         release();
         if (threadQueues.get(key) === next) threadQueues.delete(key);
+        this.inFlightTurns.delete(next);
       });
+      this.inFlightTurns.add(next);
       threadQueues.set(key, next);
     }
   }
@@ -120659,6 +120760,34 @@ var BridgeHandler = class {
         while (true) {
           attempt++;
           const currentIsNewThread = currentExisting === void 0;
+          let effectivePeers = this.deps.peers;
+          if (effectivePeers?.length && this.deps.resolveLiveRoster) {
+            try {
+              const liveRoster = await this.deps.resolveLiveRoster(parsed.chatId);
+              if (liveRoster) {
+                const { peers: remappedPeers, remapped, unresolved } = remapPeersToLiveRoster(
+                  effectivePeers,
+                  liveRoster
+                );
+                effectivePeers = remappedPeers;
+                if (remapped.length > 0 || unresolved.length > 0) {
+                  await recordEvent({
+                    status: "running",
+                    appendPath: "peer roster",
+                    reason: `live-roster resolve: remapped [${remapped.join(", ") || "none"}] to same-app-scope open_id; unresolved (kept static config id, may not be deliverable) [${unresolved.join(", ") || "none"}].`
+                  });
+                }
+              } else {
+                await recordEvent({
+                  status: "running",
+                  appendPath: "peer roster",
+                  reason: "live-roster resolve returned nothing; kept static <peer-bots> open_ids (may be cross-app-scope / undeliverable)."
+                });
+              }
+            } catch (err) {
+              console.warn("[bridge.handler] live-roster resolve failed (using static peers):", err);
+            }
+          }
           const prompt = renderPrompt({
             parsed,
             isNewThread: currentIsNewThread,
@@ -120680,7 +120809,7 @@ var BridgeHandler = class {
               readOnly: conventions.readOnly,
               gitlabTokenEnvName: conventions.gitlabTokenEnvName
             },
-            peers: this.deps.peers,
+            peers: effectivePeers,
             turn_taking_limit: this.deps.botConfig?.turn_taking_limit,
             botName: this.deps.botConfig?.name,
             backend: this.deps.botConfig?.backend,
@@ -126297,6 +126426,9 @@ async function runV2Mode({
       gitlabToken: effectiveGitlabToken,
       agentMemory: bot.agent_memory,
       larkCliProfile,
+      // PRB-6/§11.3: resolve peer @ targets to same-app-scope open_ids from the
+      // live chat roster (per-chat cached), only when this bot actually has peers.
+      resolveLiveRoster: resolvedPeers.length > 0 ? createCachedRosterResolver({ profile: larkCliProfile }) : void 0,
       runtimeRequirements: runtimeRequirementsForBots([bot]),
       recordRuntimeEvent: async (patch) => {
         await upsertRuntimeEvent(larkwayHome(), bot.id, patch);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkway",
-  "version": "0.3.31",
+  "version": "0.3.32",
   "description": "Thin bridge: Feishu thread to local Claude Code CLI",
   "license": "MIT",
   "author": "Chuck Wu (chuckwu0)",