opencode-feishu-plugin 0.1.4 → 0.2.1

package/README.en.md

@@ -242,7 +242,7 @@ Besides sessions created from Feishu, you can **load any past OpenCode session v
   [▶️ Enter topic] [▶️ New topic] [⬅️ Prev] [➡️ Next] [➕ New session]
 ```
 
-- Data source is `ctx.session.list()` (**all** OpenCode sessions, sorted by `time.updated` desc), not just the plugin's mapping table; if unavailable it falls back to the mapping list and logs a `warn`.
+- Data source, in order: `ctx.session.list()` (usually **not exposed** in the V2 plugin runtime) → **local HTTP `GET /api/session`** (same machine, returns **all** sessions including ones created in the TUI/Web) → the plugin's mapping table. Entering an external session also binds a mapping for it so approvals/notifications keep working.
 - Each row shows: title (truncated), short id, relative time, `💬 topic-bound` (this session already has a topic mapping), `📍 <directory tail>`.
 - **Paging**: 8 per page by default (`sessionPageSize`, clamped 5–20); the bottom buttons flip pages (`{cmd:"list", page:N}`).
 - **"➕ New session"** opens the setup form card (same as `/new` `/form`) instead of creating a session directly.
@@ -358,9 +358,9 @@ The threshold is `staleExecutionMs` (default 5 minutes, clamped to 1–60 minute
 
 When the agent calls the `question` tool (or any form interaction), OpenCode creates a pending form that blocks execution. The plugin relays it as a Feishu card:
 
-- tap an option for single-choice fields; multi-field forms submit automatically once every field is filled;
-- for free-text fields, tap "✍️ reply directly" and send the answer as a message in the **same topic**;
-- the card resolves after submit/cancel.
+- **Two equivalent ways to answer**: tap an option button, or just **send text in the topic** (no need to tap "✍️ reply directly" first). Text is matched intelligently — option label/value are matched to their value, booleans accept 是/否 & yes/no & 1/0, numbers are parsed, multiselect splits on commas, anything else counts as a **manual answer**;
+- multi-field forms can be answered with a mix of taps and a text reply; they submit automatically once every field is filled;
+- **the card is recalled once answered/cancelled**; if it is past Feishu's recall window, it degrades to a "submitted/cancelled" result card instead.
 
 Without this relay, any clarifying question would stall the Feishu session forever and every later message would queue behind it — a common cause of "stuck sessions".
 
@@ -400,6 +400,28 @@ Without this relay, any clarifying question would stall the Feishu session forev
 | `topicStatusInTitle` | boolean | `false` | Add a status emoji prefix to the root card title (e.g. `🟡 session name`). Off by default: the topic name shows in the sidebar, and flipping it would be noisy |
 | `topicStatusThrottleMs` | number | `1000` | Min root-card status refresh interval (clamped 500–10000); patched only when the kind changes |
 | `cardMaxTables` | number | `4` | Max markdown tables kept per card (clamped 1–5); tables beyond it are degraded **cumulatively per card** into fenced code blocks (no content lost) to avoid Feishu 400 `code=230099` |
+| `keepalive` | boolean | `true` | **Location keep-alive**: periodically emits activity so OpenCode does not evict the idle Location after 60 minutes (which unloads the plugin and closes the Feishu long connection) |
+| `keepaliveIntervalMs` | number | `1200000` | Keep-alive interval (default 20 min, clamped 5–45); must stay well below OpenCode's hardcoded 60-minute TTL |
+
+### Location keep-alive (on by default)
+
+OpenCode **evicts idle Locations**, which unloads plugins and closes the Feishu long connection:
+
+| Mechanism | Where | Trigger | Effect |
+|---|---|---|---|
+| LayerMap `idleTimeToLive` | `packages/core/src/location-services.ts` (hardcoded `60 minutes`) | no **session-scoped request** for 60 min | Location services destroyed (silently) |
+| `@opencode/LocationActivity` | hardcoded 60 min as well | no **durable event carrying the location** for 60 min | interrupts active sessions, then `invalidate(location)`; logs `location services evicted` |
+
+Both dispose the plugin (closing the Feishu WS). **After that, no request means no recovery — the bot stays silent permanently** (see issues [#51343](https://github.com/anomalyco/opencode/issues/51343), [#48691](https://github.com/anomalyco/opencode/issues/48691), [#51828](https://github.com/anomalyco/opencode/issues/51828); the TTL has no config knob).
+
+The plugin ships two built-in layers (both on by default, **no external script required**):
+
+1. **Gateway keep-alive** (every 20 min, `keepaliveIntervalMs`): ① a session-scoped `GET /api/session/{id}` → `locations.get()` renews the LayerMap entry, and **re-creates the Location** if it was evicted; ② create + GET + delete a probe session → renews `LocationActivity` (via the `session.created` event).
+2. **Process-wide gateway watchdog** (same interval, exactly one timer per process): every Location's plugin instance registers it, and it performs a session-scoped GET against the gateway Location. Result:
+   - if the gateway instance was evicted, it is revived automatically as long as **any other Location** still has a loaded instance (e.g. you have a TUI/Web open in another project);
+   - after a **service restart**, the first use of any Location starts the watchdog, which fires an immediate probe after ~3s and brings the gateway back up.
+
+> Still recommended (optional, not required): a cron / systemd timer doing one session-scoped GET every 15–30 minutes, covering the extreme case where the opencode process is down and nothing is used for a long time. See `scripts/keepalive-feishu.sh`. Set `keepalive: false` to disable all keep-alive.
 
 ---
 
@@ -451,6 +473,7 @@ otherwise (per session preset) → ask ─────────────
 | No plugin logs | Plugin stderr is discarded in service mode; set `logFile: true` and read `<configDir>/plugins/feishu.log` |
 | Main chat replies with a hint card | Expected: the main chat is management-only. Use `/new` and work inside a topic; set `threadRouting: false` to revert |
 | Session looks stuck and messages only queue | The watchdog auto-interrupts it after `staleExecutionMs` (default 5 min) and cancels the queue, then sends a notice card; you can also tap the card's "⏹ force stop" or send `/stop` |
+| **Bot goes completely silent after ~1 hour idle** (no "long connection started" in the log) | OpenCode evicted the idle Location (hardcoded 60-min TTL). The built-in keep-alive is on by default; if it still happens (service restart / long sleep / keep-alive disabled), one session-scoped request re-creates it: `opencode api get /api/session/{id}`, or set up the external cron described under "Location keep-alive" |
 | Switched `/model` but older messages still show the old model | Expected: a switch only affects **subsequent** replies; history keeps each message's model. The receipt / run-card footer / `/current` all show the read-back truth |
 
 ---

package/README.md

@@ -161,6 +161,7 @@ opencode mcp list        # 顺带确认服务健康
 
 ![/sessions 会话列表卡：翻页、进入/再开、新建会话](image/sessions.png)
 
+- **数据源**：优先插件原生 `ctx.session.list()`（V2 运行时通常未暴露）→ **本机 HTTP `GET /api/session`**（与 opencode 同机，列出**全量**会话，含 TUI / Web 里开的）→ `SessionMap` 回退（仅机器人自己的会话）。进入外部会话时会补一条映射，审批 / 失败通知照常。
 - 每条显示标题 / 短 id / 相对时间 / 是否已绑话题 / 目录，当前会话标「← 当前」；已绑话题的按钮显示「▶️ 再开」，其余为「▶️ 进入」；底部可翻页 + 「➕ 新建会话」。
 - **「▶️ 进入话题」**：在主聊天流发一张恢复卡（含会话摘要），**直接回复这张卡**即续聊该历史会话。
 - `/resume [序号]` 跳过列表直达，同一套「发恢复卡 → 回复即续聊」流程。
@@ -210,7 +211,12 @@ opencode mcp list        # 顺带确认服务健康
 
 ### 表单 / 提问（`question` 工具）
 
-agent 调 `question` 等 form 类交互时，插件把它转成飞书卡片：单选题直接点选项，多字段逐项点选，自由文本点「✍️ 直接回复答案」后在话题里发一条消息。**没有这层转发，agent 一反问飞书会话就会永久卡住**——这也是会话卡死的常见原因。
+agent 调 `question` 等 form 类交互时，插件把它转成飞书卡片：
+
+- **两种作答方式等价**：直接点选项按钮，或**直接在话题里发文字**（无需先点「✍️ 直接回复答案」）。文本会智能匹配——命中选项 label/value 用选项值，`boolean` 认「是/否、yes/no、1/0」，`number`/`integer` 转数值，多选按顿号/逗号拆分，其余视为**手动输入**。
+- 多字段表单可以混合作答：点几个按钮 + 补一条文字，填满即自动提交。
+- **作答 / 取消后卡片会被撤回**（不再残留待填卡）；若超出飞书撤回时限，降级为「已提交 / 已取消」结果卡。
+- **没有这层转发，agent 一反问飞书会话就会永久卡住**——这也是会话卡死的常见原因。
 
 ### 卡片内容守卫（表格超限降级）
 
@@ -255,6 +261,8 @@ agent 调 `question` 等 form 类交互时，插件把它转成飞书卡片：
 | `topicStatusInTitle` | boolean | `false` | 是否在根卡标题加状态 emoji 前缀 |
 | `topicStatusThrottleMs` | number | `1000` | 根卡状态刷新最小间隔（500–10000） |
 | `cardMaxTables` | number | `4` | 单卡最多保留的 markdown 表格数（1–5）；超出按整卡累计降级为围栏代码块，避免飞书 400 `code=230099` |
+| `keepalive` | boolean | `true` | **位置保活**：周期性向 opencode 发一次活动，阻止 60 分钟空闲回收 location（会关掉飞书长连接、机器人失联） |
+| `keepaliveIntervalMs` | number | `1200000` | 保活间隔（默认 20 分钟，夹取 5–45）；必须显著小于 opencode 硬编码的 60 分钟 TTL |
 
 ---
 
@@ -274,6 +282,27 @@ permission.evaluate (插件 hook)               permission.asked (事件流)
 - **三重单人边界**：可用范围「仅本人」+ 不申请群权限 + 代码层 open_id 白名单。
 - **`always` 语义**：仅当请求带 `save[]` 时才持久化，否则等价于「允许一次」。
 
+### 位置保活（防空闲失联，默认开启）
+
+opencode 会**回收空闲的 location**，这会连带卸载插件、关闭飞书长连接：
+
+| 机制 | 位置 | 触发条件 | 表现 |
+|---|---|---|---|
+| LayerMap `idleTimeToLive` | `packages/core/src/location-services.ts`（硬编码 `60 minutes`） | 60 分钟内无**会话级请求** | location 服务被销毁（静默） |
+| `@opencode/LocationActivity` | 同为硬编码 60 分钟 | 60 分钟内无**带 location 的 durable 事件** | 先 interrupt 活动会话，再 `invalidate(location)`，日志 `location services evicted` |
+
+两者都会让插件被 dispose（飞书长连接关闭）。**此后若该 location 再无请求，插件不会自行恢复 → 机器人永久沉默**（官方 issue：[#51343](https://github.com/anomalyco/opencode/issues/51343)、[#51891→#48691](https://github.com/anomalyco/opencode/issues/48691)、[#51828](https://github.com/anomalyco/opencode/issues/51828)；TTL 无配置项）。
+
+插件内置两道防线（都是默认开启，**无需任何外部脚本**）：
+
+1. **网关保活**（每 20 分钟，`keepaliveIntervalMs`）：① 会话级 `GET /api/session/{id}` → `locations.get()` 续期 LayerMap，若已被回收则**重建 location**；② 创建 + GET + 删除一个探针会话 → 续期 `LocationActivity`（`session.created` 事件）。
+2. **进程级网关看门狗**（同样每 20 分钟，每进程仅一个定时器）：**任意** location 的插件实例都会登记，周期性对网关 location 做会话级 GET。效果：
+   - 网关实例即使已被回收，只要进程里还有**别的** location 存活（例如你在别的项目里开了 TUI/Web），网关会被自动救活；
+   - **服务重启后**，你第一次使用任意 location 时看门狗即启动（并在约 3 秒后立即探测一次），网关随之上线；
+   - 首次探测带 3 秒延迟，重启后恢复很快。
+
+> 仍建议（可选，非必需）：用 cron / systemd timer 每 15–30 分钟做一次「会话级 GET」，覆盖「opencode 进程整个挂掉且长时间无人使用」的极端场景。仓库提供 `scripts/keepalive-feishu.sh` 一键脚本；`keepalive: false` 可关闭全部保活。
+
 ---
 
 ## 六、故障排查
@@ -291,6 +320,7 @@ permission.evaluate (插件 hook)               permission.asked (事件流)
 | 卡片内容被截断 | 飞书卡片上限约 30KB，超长会话丢弃卡片上最旧块（完整内容仍在会话里） |
 | 建会话后没看到话题 | 表单卡会改写为「✅ 已创建 · …」并附手动创建话题指引 |
 | 会话像卡死、发消息只排队 | 看门狗默认 5 分钟后自动中断；也可点「⏹ 强制停止」或发 `/stop` |
+| **空闲约 1 小时后机器人完全失联**（日志无「长连接已启动」） | opencode 回收了空闲 location（60 分钟硬编码 TTL）。内置保活默认开启；若仍发生（服务重启 / 长休眠 / 保活被关），用 `opencode api get /api/session/{id}` 任一本地会话即可唤起，或按上方「位置保活」配置外部 cron |
 | 看不到插件日志 | 服务模式下 stderr 被丢弃，设 `logFile: true` |
 | 切了 `/model` 但历史还是旧模型 | 预期行为：切换只影响后续回复，历史消息保留各自当时的模型 |
 

package/dist/index.js

@@ -144024,6 +144024,12 @@ function resolveConfig2(raw, env = process.env, deps = {}) {
   const topicStatusInTitle = asBoolean(merged.topicStatusInTitle, false);
   const topicStatusThrottleMs = clamp4(asNumber(merged.topicStatusThrottleMs, 1e3), 500, 1e4);
   const cardMaxTables = clamp4(asNumber(merged.cardMaxTables, 4), 1, 5);
+  const keepalive = asBoolean(merged.keepalive, true);
+  const keepaliveIntervalMs = clamp4(
+    asNumber(merged.keepaliveIntervalMs, 20 * 60 * 1e3),
+    5 * 60 * 1e3,
+    45 * 60 * 1e3
+  );
   const domain = merged.domain === "lark" ? "lark" : "feishu";
   const logFile = resolveLogFile(merged.logFile, env, deps);
   const gatewayLocation = normalizeGatewayLocation(asString(merged.gatewayLocation));
@@ -144071,7 +144077,9 @@ function resolveConfig2(raw, env = process.env, deps = {}) {
     topicStatus,
     topicStatusInTitle,
     topicStatusThrottleMs,
-    cardMaxTables
+    cardMaxTables,
+    keepalive,
+    keepaliveIntervalMs
   };
 }
 function loadConfigFile(env, deps, warnings) {
@@ -145125,10 +145133,18 @@ function createFeishuSender(client, log2, options2 = {}) {
       }
     },
     async deleteMessage(messageId) {
-      if (!messageId) return;
+      if (!messageId) return { ok: false, error: "missing messageId" };
       try {
-        await client.im.message.delete({ path: { message_id: messageId } });
-      } catch {
+        const res = await client.im.message.delete({ path: { message_id: messageId } });
+        if (res?.code && res.code !== 0) {
+          log2.debug("\u64A4\u56DE\u6D88\u606F\u5931\u8D25", { messageId, code: res.code, msg: res.msg });
+          return { ok: false, error: `code=${res.code} msg=${res.msg ?? ""}` };
+        }
+        return { ok: true };
+      } catch (err2) {
+        const error = describeLarkError(err2);
+        log2.debug("\u64A4\u56DE\u6D88\u606F\u5F02\u5E38", { messageId, error });
+        return { ok: false, error };
       }
     }
   };
@@ -145304,6 +145320,25 @@ var SessionMap = class {
     await this.persist(chatId, record2);
     await this.safeSet(`${SESSION_KEY_PREFIX}${sessionID}`, serializeSession(link2));
   }
+  /**
+   * 为**外部来源**的会话（TUI/Web，无飞书映射）补一条会话索引（P7.5）。
+   *
+   * `/ls` 列出 opencode 全量会话后，用户「进入话题」的会话需要审批投递、
+   * 跨 location 路由（`dir`）与失败通知的目标。已存在则只补缺失字段，
+   * **不覆盖** perm/gateMode/model 等既有元数据。
+   */
+  async ensureSessionLink(sessionID, input) {
+    if (!sessionID || !input.chatId) return;
+    const existing = await this.resolveBySession(sessionID);
+    const link2 = {
+      ...existing,
+      chatId: input.chatId,
+      openId: input.openId,
+      ...input.directory ? { dir: input.directory } : {}
+    };
+    this.remember(sessionID, link2);
+    await this.safeSet(`${SESSION_KEY_PREFIX}${sessionID}`, serializeSession(link2));
+  }
   /** 切换当前会话；会话不属于该 chat 时返回 false。 */
   async setActive(chatId, sessionID) {
     const record2 = await this.loadChat(chatId);
@@ -146813,7 +146848,7 @@ var FormRelay = class {
       return false;
     }
     const field = pending.form.fields.find((f) => f.key === fieldKey);
-    pending.answers[fieldKey] = coerceText(field?.type, text);
+    pending.answers[fieldKey] = coerceAnswer(field, text);
     pending.awaitingField = void 0;
     this.awaiting.delete(sessionID);
     if (isComplete(pending.form, pending.answers)) {
@@ -146837,7 +146872,7 @@ var FormRelay = class {
     }
     this.awaiting.delete(sessionID ?? pending.sessionID);
     this.forms.delete(id2);
-    void this.patch(pending, buildFormResolvedCard(pending.form, pending.answers, "answered"));
+    void this.finish(pending, "answered");
   }
   /** 处理 `form.cancelled`。 */
   onCancelled(data) {
@@ -146847,7 +146882,7 @@ var FormRelay = class {
     if (!pending) return;
     this.awaiting.delete(sessionID ?? pending.sessionID);
     this.forms.delete(id2);
-    void this.patch(pending, buildFormResolvedCard(pending.form, pending.answers, "cancelled"));
+    void this.finish(pending, "cancelled");
   }
   dispose() {
     this.disposed = true;
@@ -146868,6 +146903,13 @@ var FormRelay = class {
         error: errorMessage(err2)
       });
       pending.settled = false;
+      const missing2 = pending.form.fields.find(
+        (f) => f.hidden !== true && pending.answers[f.key] === void 0
+      );
+      if (missing2) {
+        pending.awaitingField = missing2.key;
+        this.awaiting.set(pending.sessionID, pending.form.id);
+      }
       this.forms.set(pending.form.id, pending);
       await this.patch(
         pending,
@@ -146876,7 +146918,20 @@ var FormRelay = class {
       return;
     }
     this.forms.delete(pending.form.id);
-    await this.patch(pending, buildFormResolvedCard(pending.form, pending.answers, "answered"));
+    await this.finish(pending, "answered");
+  }
+  /**
+   * 表单收敛：**优先撤回卡片**（作答/取消后不再残留待填卡），撤回失败（超时限/无权限）
+   * 才降级 patch 成结果卡，避免卡片永久停在待填态。
+   */
+  async finish(pending, outcome) {
+    if (this.disposed) return;
+    const res = await this.deps.sender.deleteMessage(pending.messageId);
+    if (res.ok) {
+      this.deps.log.debug("\u8868\u5355\u5361\u5DF2\u64A4\u56DE", { formID: pending.form.id, outcome });
+      return;
+    }
+    await this.patch(pending, buildFormResolvedCard(pending.form, pending.answers, outcome));
   }
   async patch(pending, card) {
     if (this.disposed) return;
@@ -146890,17 +146945,47 @@ function isFormValue(value3) {
   if (typeof value3 === "string" || typeof value3 === "number" || typeof value3 === "boolean") return true;
   return Array.isArray(value3) && value3.every((x) => typeof x === "string");
 }
-function coerceText(type, text) {
+function coerceAnswer(field, text) {
   const trimmed = text.trim();
-  if (type === "number") {
-    const n = Number(trimmed);
-    return Number.isFinite(n) ? n : text;
-  }
-  if (type === "integer") {
-    const n = Number.parseInt(trimmed, 10);
-    return Number.isFinite(n) && String(n) === trimmed ? n : text;
+  if (!field) return trimmed;
+  switch (field.type) {
+    case "number": {
+      const n = Number(trimmed);
+      return trimmed !== "" && Number.isFinite(n) ? n : trimmed;
+    }
+    case "integer": {
+      const n = Number.parseInt(trimmed, 10);
+      return Number.isFinite(n) && String(n) === trimmed ? n : trimmed;
+    }
+    case "boolean": {
+      const parsed = parseBooleanText(trimmed);
+      return parsed === void 0 ? trimmed : parsed;
+    }
+    case "multiselect": {
+      const parts = trimmed.split(/[、,，;；\n]+/).map((s) => s.trim()).filter(Boolean);
+      if (parts.length === 0) return trimmed;
+      return parts.map((p) => matchOption(field, p) ?? p);
+    }
+    default:
+      return matchOption(field, trimmed) ?? trimmed;
   }
-  return text;
+}
+function matchOption(field, text) {
+  if (!field.options?.length) return void 0;
+  const trimmed = text.trim();
+  const lower = trimmed.toLowerCase();
+  const hit = field.options.find(
+    (o) => o.value === trimmed || o.label.trim() === trimmed || o.label.trim().toLowerCase() === lower
+  );
+  return hit?.value;
+}
+var TRUE_WORDS = /* @__PURE__ */ new Set(["\u662F", "\u5BF9", "\u597D", "\u53EF\u4EE5", "\u5141\u8BB8", "\u786E\u8BA4", "\u540C\u610F", "yes", "y", "true", "1"]);
+var FALSE_WORDS = /* @__PURE__ */ new Set(["\u5426", "\u4E0D", "\u4E0D\u884C", "\u62D2\u7EDD", "\u53D6\u6D88", "\u4E0D\u8981", "no", "n", "false", "0"]);
+function parseBooleanText(text) {
+  const lower = text.trim().toLowerCase();
+  if (TRUE_WORDS.has(lower)) return true;
+  if (FALSE_WORDS.has(lower)) return false;
+  return void 0;
 }
 function serviceStatePath(env = process.env) {
   const base2 = env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state");
@@ -146960,6 +147045,173 @@ async function replyFormOverHttp(input, deps) {
   }
 }
 
+// src/session/session-list-http.ts
+async function listSessionsOverHttp(input, deps) {
+  const discover = deps.discover ?? (() => discoverLocalService());
+  const doFetch = deps.fetchImpl ?? fetch;
+  const service3 = await discover();
+  if (!service3) {
+    deps.log.debug("\u672A\u53D1\u73B0\u672C\u673A opencode \u670D\u52A1\uFF0CHTTP \u4F1A\u8BDD\u5217\u8868\u8DF3\u8FC7");
+    return void 0;
+  }
+  const params = new URLSearchParams();
+  params.set("limit", String(input.limit ?? 200));
+  params.set("order", input.order ?? "desc");
+  if (input.rootsOnly ?? true) params.set("parentID", "null");
+  try {
+    const response2 = await doFetch(`${service3.url}/api/session?${params.toString()}`, {
+      method: "GET",
+      headers: { ...authHeaders(service3) },
+      signal: AbortSignal.timeout(deps.timeoutMs ?? 8e3)
+    });
+    if (!response2.ok) {
+      deps.log.debug("HTTP \u4F1A\u8BDD\u5217\u8868\u5931\u8D25", { status: response2.status });
+      return void 0;
+    }
+    return await response2.json();
+  } catch (err2) {
+    deps.log.debug("HTTP \u4F1A\u8BDD\u5217\u8868\u5F02\u5E38", { error: errorMessage(err2) });
+    return void 0;
+  }
+}
+
+// src/session/keepalive.ts
+var KEEPALIVE_SESSION_TITLE = "__opencode_feishu_keepalive__";
+async function touchLocationOverHttp(directory, deps) {
+  const discover = deps.discover ?? (() => discoverLocalService());
+  const doFetch = deps.fetchImpl ?? fetch;
+  const service3 = await discover();
+  if (!service3) {
+    deps.log.debug("\u4FDD\u6D3B\u8DF3\u8FC7\uFF1A\u672A\u53D1\u73B0\u672C\u673A opencode \u670D\u52A1");
+    return false;
+  }
+  const headers = {
+    "content-type": "application/json",
+    ...authHeaders(service3)
+  };
+  const timeout3 = deps.timeoutMs ?? 8e3;
+  const signal = () => AbortSignal.timeout(timeout3);
+  let touched = false;
+  try {
+    const params = new URLSearchParams({ limit: "1", parentID: "null" });
+    if (directory) params.set("directory", directory);
+    const listRes = await doFetch(`${service3.url}/api/session?${params.toString()}`, {
+      method: "GET",
+      headers,
+      signal: signal()
+    });
+    if (listRes.ok) {
+      const list = await listRes.json().catch(() => void 0);
+      const target = list?.data?.[0]?.id;
+      if (target) {
+        const getRes = await doFetch(`${service3.url}/api/session/${encodeURIComponent(target)}`, {
+          method: "GET",
+          headers,
+          signal: signal()
+        });
+        touched = getRes.ok;
+      }
+    }
+  } catch (err2) {
+    deps.log.debug("\u4FDD\u6D3B\u4F1A\u8BDD\u7EA7\u7EED\u671F\u5931\u8D25", { directory, error: errorMessage(err2) });
+  }
+  let sessionID;
+  try {
+    const response2 = await doFetch(`${service3.url}/api/session`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        title: KEEPALIVE_SESSION_TITLE,
+        ...directory ? { location: { directory } } : {}
+      }),
+      signal: signal()
+    });
+    if (response2.ok) {
+      const body = await response2.json().catch(() => void 0);
+      sessionID = body?.data?.id;
+      touched = true;
+    } else {
+      deps.log.debug("\u4FDD\u6D3B\u63A2\u9488\u521B\u5EFA\u5931\u8D25", { status: response2.status, directory });
+    }
+  } catch (err2) {
+    deps.log.debug("\u4FDD\u6D3B\u63A2\u9488\u521B\u5EFA\u5F02\u5E38", { directory, error: errorMessage(err2) });
+  }
+  if (sessionID) {
+    try {
+      const getRes = await doFetch(`${service3.url}/api/session/${encodeURIComponent(sessionID)}`, {
+        method: "GET",
+        headers,
+        signal: signal()
+      });
+      touched = touched || getRes.ok;
+    } catch {
+    }
+    try {
+      await doFetch(`${service3.url}/api/session/${encodeURIComponent(sessionID)}`, {
+        method: "DELETE",
+        headers,
+        signal: signal()
+      });
+    } catch {
+    }
+  }
+  if (touched) deps.log.debug("\u4FDD\u6D3B\u5FC3\u8DF3\u5DF2\u53D1\u9001", { directory, probe: sessionID ?? "(none)" });
+  return touched;
+}
+var WATCHDOG_SLOT = /* @__PURE__ */ Symbol.for("opencode-feishu-v2/gateway-watchdog");
+function ensureGatewayWatchdog(input) {
+  const g = globalThis;
+  const existing = g[WATCHDOG_SLOT];
+  if (existing) {
+    if (input.authoritative && existing.target !== input.directory) {
+      existing.target = input.directory;
+      input.log.debug("\u7F51\u5173\u770B\u95E8\u72D7\u76EE\u6807\u66F4\u65B0\u4E3A\u7F51\u5173 location", { directory: input.directory });
+    }
+    return false;
+  }
+  const setIntervalImpl = input.setIntervalImpl ?? setInterval;
+  input.clearIntervalImpl ?? clearInterval;
+  const setTimeoutImpl = input.setTimeoutImpl ?? setTimeout;
+  input.clearTimeoutImpl ?? clearTimeout;
+  const probe = input.probe ?? ((dir) => touchLocationOverHttp(dir, { log: input.log }));
+  const slot = {
+    target: input.directory,
+    timer: void 0,
+    initial: void 0
+  };
+  const run2 = () => {
+    void probe(slot.target).catch((err2) => {
+      input.log.debug("\u7F51\u5173\u770B\u95E8\u72D7\u63A2\u6D4B\u5F02\u5E38", { error: errorMessage(err2) });
+    });
+  };
+  const delay3 = input.immediateDelayMs ?? 3e3;
+  if (delay3 > 0) slot.initial = setTimeoutImpl(run2, delay3);
+  slot.timer = setIntervalImpl(run2, input.intervalMs);
+  slot.timer.unref?.();
+  slot.initial?.unref?.();
+  g[WATCHDOG_SLOT] = slot;
+  input.log.info("\u7F51\u5173\u770B\u95E8\u72D7\u5DF2\u542F\u52A8\uFF08\u8FDB\u7A0B\u7EA7\uFF09", {
+    directory: input.directory,
+    intervalMs: input.intervalMs
+  });
+  return true;
+}
+function startKeepalive(deps) {
+  const setIntervalImpl = deps.setIntervalImpl ?? setInterval;
+  const clearIntervalImpl = deps.clearIntervalImpl ?? clearInterval;
+  const touch = deps.touch ?? ((dir) => touchLocationOverHttp(dir, { log: deps.log }));
+  const timer = setIntervalImpl(() => {
+    void touch(deps.directory).catch((err2) => {
+      deps.log.debug("\u4FDD\u6D3B\u5FC3\u8DF3\u5F02\u5E38", { error: errorMessage(err2) });
+    });
+  }, deps.intervalMs);
+  timer.unref?.();
+  deps.log.info("\u4F4D\u7F6E\u4FDD\u6D3B\u5DF2\u542F\u52A8", { directory: deps.directory, intervalMs: deps.intervalMs });
+  return () => {
+    clearIntervalImpl(timer);
+  };
+}
+
 // src/feishu/commands.ts
 var ALIASES = {
   new: "new",
@@ -149452,28 +149704,53 @@ async function cmdSessions(ctx, message, page = 0) {
   }
 }
 async function loadSessionEntries(ctx, chatId) {
-  if (ctx.deps.listAllSessions) {
-    try {
-      const raw = await ctx.deps.listAllSessions();
-      const normalized = normalizeSessionList(raw);
-      if (normalized) {
-        ctx.deps.log.info("\u5217\u51FA\u5168\u90E8\u4F1A\u8BDD", { count: normalized.length, source: "session.list" });
-        return normalized;
-      }
-      ctx.deps.log.warn("session.list \u8FD4\u56DE\u5F62\u72B6\u65E0\u6CD5\u8BC6\u522B\uFF0C\u56DE\u9000 SessionMap \u5217\u8868", { chatId });
-    } catch (err2) {
-      ctx.deps.log.warn("session.list \u8C03\u7528\u5931\u8D25\uFF0C\u56DE\u9000 SessionMap \u5217\u8868", {
-        chatId,
-        error: errorMessage(err2)
-      });
-    }
-  } else {
-    ctx.deps.log.warn("\u8FD0\u884C\u65F6\u672A\u66B4\u9732 session.list\uFF0C\u56DE\u9000 SessionMap \u5217\u8868", { chatId });
-  }
+  const viaApi = await loadViaSessionListApi(ctx, chatId);
+  if (viaApi) return viaApi;
+  const viaHttp = await loadViaHttp(ctx, chatId);
+  if (viaHttp) return viaHttp;
   const fallback = fallbackEntries(await ctx.deps.sessionMap.listSessions(chatId));
   ctx.deps.log.warn("\u4F1A\u8BDD\u5217\u8868\u56DE\u9000\u5230 SessionMap", { chatId, count: fallback.length });
   return fallback;
 }
+async function loadViaSessionListApi(ctx, chatId) {
+  if (!ctx.deps.listAllSessions) {
+    ctx.deps.log.warn("\u8FD0\u884C\u65F6\u672A\u66B4\u9732 session.list\uFF0C\u5C1D\u8BD5 HTTP \u515C\u5E95", { chatId });
+    return void 0;
+  }
+  try {
+    const raw = await ctx.deps.listAllSessions();
+    const normalized = normalizeSessionList(raw);
+    if (normalized) {
+      ctx.deps.log.info("\u5217\u51FA\u5168\u90E8\u4F1A\u8BDD", { count: normalized.length, source: "session.list" });
+      return normalized;
+    }
+    ctx.deps.log.warn("session.list \u8FD4\u56DE\u5F62\u72B6\u65E0\u6CD5\u8BC6\u522B\uFF0C\u5C1D\u8BD5 HTTP \u515C\u5E95", { chatId });
+  } catch (err2) {
+    ctx.deps.log.warn("session.list \u8C03\u7528\u5931\u8D25\uFF0C\u5C1D\u8BD5 HTTP \u515C\u5E95", {
+      chatId,
+      error: errorMessage(err2)
+    });
+  }
+  return void 0;
+}
+async function loadViaHttp(ctx, chatId) {
+  if (!ctx.deps.listAllSessionsHttp) return void 0;
+  try {
+    const raw = await ctx.deps.listAllSessionsHttp();
+    const normalized = normalizeSessionList(raw);
+    if (normalized) {
+      ctx.deps.log.info("\u5217\u51FA\u5168\u90E8\u4F1A\u8BDD", { count: normalized.length, source: "http" });
+      return normalized;
+    }
+    ctx.deps.log.warn("HTTP \u4F1A\u8BDD\u5217\u8868\u5F62\u72B6\u65E0\u6CD5\u8BC6\u522B\uFF0C\u56DE\u9000 SessionMap \u5217\u8868", { chatId });
+  } catch (err2) {
+    ctx.deps.log.warn("HTTP \u4F1A\u8BDD\u5217\u8868\u8C03\u7528\u5931\u8D25\uFF0C\u56DE\u9000 SessionMap \u5217\u8868", {
+      chatId,
+      error: errorMessage(err2)
+    });
+  }
+  return void 0;
+}
 async function buildListCard(ctx, chatId, entries3, page, activeID) {
   const pageSize = ctx.sessionPageSize;
   const pageCount = Math.max(1, Math.ceil(entries3.length / pageSize));
@@ -149510,6 +149787,13 @@ async function enterSessionThread(ctx, input) {
   const info = input.info;
   const link2 = await ctx.deps.sessionMap.resolveBySession(sessionID);
   const dir = info?.directory ?? link2?.dir;
+  if (!link2) {
+    await ctx.deps.sessionMap.ensureSessionLink(sessionID, {
+      chatId,
+      openId: operatorOpenId,
+      ...dir ? { directory: dir } : {}
+    });
+  }
   const showSummary = (ctx.deps.resumeSummary ?? true) && Boolean(ctx.deps.summarizeSession);
   const onLimit = (report) => {
     ctx.deps.log.warn("\u4F1A\u8BDD\u6062\u590D\u5361\u5185\u5BB9\u8D85\u9650\uFF0C\u5DF2\u964D\u7EA7", { sessionID, ...report });
@@ -150680,24 +150964,37 @@ var index_default = plugin_exports.define({
       hasAppSecret: hasSecret(config.appSecret)
     });
     const here = ctx.location?.directory;
+    let startedWatchdog = false;
+    if (config.keepalive) {
+      const watchdogTarget = config.gatewayLocation ?? here;
+      if (watchdogTarget) {
+        startedWatchdog = ensureGatewayWatchdog({
+          log: log2,
+          directory: watchdogTarget,
+          intervalMs: config.keepaliveIntervalMs
+        });
+      }
+    }
     if (config.gatewayLocation) {
       const matched = Boolean(here) && isUnder(here, config.gatewayLocation);
+      const keepSink = matched || startedWatchdog;
       trackGatewayLocationSeen({
         here: here ?? "(unknown)",
         expected: config.gatewayLocation,
         matched,
         warn: (message) => log2.warn(message),
-        ...matched ? {} : { onSettled: () => logSink?.close() }
+        ...keepSink ? {} : { onSettled: () => logSink?.close() }
       });
       if (!matched) {
         log2.debug("\u8DF3\u8FC7\u975E\u7F51\u5173 location", { here, expected: config.gatewayLocation });
+        if (!keepSink) logSink?.close();
         return async () => {
         };
       }
     }
     if (!acquireProcessGuard()) {
       log2.debug("\u68C0\u6D4B\u5230\u540C\u8FDB\u7A0B\u91CD\u590D setup\uFF0C\u8DF3\u8FC7\u542F\u52A8\uFF08\u4EC5\u9996\u4E2A\u5B9E\u4F8B\u751F\u6548\uFF09");
-      logSink?.close();
+      if (!startedWatchdog) logSink?.close();
       return async () => {
       };
     }
@@ -151009,6 +151306,9 @@ async function start(ctx, config, log2, logSink) {
     sessionPageSize: config.sessionPageSize,
     threadRouting: config.threadRouting,
     listAllSessions: listAllSessionsRaw,
+    // `ctx.session.list` 在 V2 运行时未暴露 → 本机 HTTP `GET /api/session`
+    // 兜底列出全量会话（含 TUI/Web 来源）。
+    listAllSessionsHttp: () => listSessionsOverHttp({}, { log: log2 }),
     getSessionInfo: getSessionInfoRaw,
     resumeSummary: config.resumeSummary,
     resumeSummaryTimeoutMs: config.resumeSummaryTimeoutMs,
@@ -151245,6 +151545,22 @@ async function start(ctx, config, log2, logSink) {
     const res = link2.replyMessageId ? await sender.replyCard(link2.replyMessageId, card) : await sender.sendCard(link2.chatId, card);
     if (!res.ok) log2.warn("\u5361\u6B7B\u63D0\u793A\u5361\u53D1\u9001\u5931\u8D25", { sessionID, error: res.error ?? "unknown" });
   }
+  const here = ctx.location?.directory;
+  const keepaliveDirectory = here ?? config.gatewayLocation;
+  if (config.keepalive && keepaliveDirectory) {
+    ensureGatewayWatchdog({
+      log: log2,
+      directory: keepaliveDirectory,
+      intervalMs: config.keepaliveIntervalMs,
+      authoritative: true,
+      immediateDelayMs: 0
+    });
+  }
+  const stopKeepalive = config.keepalive && keepaliveDirectory ? startKeepalive({
+    log: log2,
+    directory: keepaliveDirectory,
+    intervalMs: config.keepaliveIntervalMs
+  }) : void 0;
   log2.info("\u98DE\u4E66\u63D2\u4EF6\u5DF2\u5C31\u7EEA");
   let cleanedUp = false;
   return async () => {
@@ -151253,6 +151569,7 @@ async function start(ctx, config, log2, logSink) {
     log2.info("\u98DE\u4E66\u63D2\u4EF6\u5378\u8F7D\u4E2D");
     abort.abort();
     stopWatchdog();
+    stopKeepalive?.();
     await subscription.catch(() => void 0);
     runs.dispose();
     executions.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-feishu-plugin",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "Feishu/Lark plugin for OpenCode V2 — single-user topics as sessions, in-card permission approvals, streaming cards. Minimal permissions, no public endpoint.",
   "type": "module",
   "main": "index.js",