@suwenguang/pi-feishu-bridge 0.0.0-stage → 0.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (52) hide show
  1. package/.pi/extensions/feishu/index.ts +11 -0
  2. package/.pi/feishu/debug.pi.log +81 -0
  3. package/.pi/feishu/state.pi.json +12 -0
  4. package/README.md +210 -2
  5. package/package.json +57 -4
  6. package/src/adapters/pi/PiConversationRuntime.ts +1559 -0
  7. package/src/adapters/pi/index.ts +1169 -0
  8. package/src/adapters/pi/setup.ts +108 -0
  9. package/src/feishu/app-register.ts +50 -0
  10. package/src/feishu/ask.ts +388 -0
  11. package/src/feishu/attachment-processor.ts +198 -0
  12. package/src/feishu/attachments.ts +192 -0
  13. package/src/feishu/bridge-runtime.ts +129 -0
  14. package/src/feishu/bridge-store.ts +92 -0
  15. package/src/feishu/card-action-webhook.ts +141 -0
  16. package/src/feishu/card-actions.ts +241 -0
  17. package/src/feishu/card-builder.ts +277 -0
  18. package/src/feishu/cardkit-stream.ts +483 -0
  19. package/src/feishu/cards.ts +413 -0
  20. package/src/feishu/config.ts +427 -0
  21. package/src/feishu/daemon-spec.ts +43 -0
  22. package/src/feishu/debug.ts +51 -0
  23. package/src/feishu/dedupe-store.ts +150 -0
  24. package/src/feishu/delivery.ts +185 -0
  25. package/src/feishu/gateway-lock.ts +256 -0
  26. package/src/feishu/group-trigger.ts +128 -0
  27. package/src/feishu/image-send.ts +256 -0
  28. package/src/feishu/instance.ts +170 -0
  29. package/src/feishu/instances.ts +148 -0
  30. package/src/feishu/interactive-card.ts +236 -0
  31. package/src/feishu/learn-approval.ts +321 -0
  32. package/src/feishu/live-cards.ts +128 -0
  33. package/src/feishu/message-handler.ts +512 -0
  34. package/src/feishu/messages.ts +356 -0
  35. package/src/feishu/oversize-progress-card.ts +101 -0
  36. package/src/feishu/progress-channel.ts +154 -0
  37. package/src/feishu/progress-note.ts +371 -0
  38. package/src/feishu/prompt-timeout.ts +81 -0
  39. package/src/feishu/reply-card-options.ts +73 -0
  40. package/src/feishu/reply-card.ts +498 -0
  41. package/src/feishu/restart.ts +286 -0
  42. package/src/feishu/retry.ts +102 -0
  43. package/src/feishu/rich-text.ts +387 -0
  44. package/src/feishu/runtime-config.ts +286 -0
  45. package/src/feishu/runtime.ts +110 -0
  46. package/src/feishu/slash-commands.ts +239 -0
  47. package/src/feishu/thinking.ts +24 -0
  48. package/src/feishu/transport.ts +792 -0
  49. package/src/feishu/types.ts +183 -0
  50. package/src/feishu/ui-notify.ts +44 -0
  51. package/src/feishu/user-name.ts +121 -0
  52. package/src/feishu/workspace.ts +42 -0
@@ -0,0 +1,286 @@
1
+ /**
2
+ * 飞书里的「无缝重启桥接」:票据 / 结果文件 / worker 拉起 / 重启后回执。
3
+ *
4
+ * 为什么要有 worker(而不是进程内 kill 自己再起):
5
+ * 1. 老进程要在死之前把「重启中」卡片发出去,发送完成才有回执可改;
6
+ * 2. 新进程必须由**老进程之外**的人拉起 —— 老进程一死,没人执行 `startDaemon`;
7
+ * 3. 新进程要等网关锁真正落到自己手上才算接管成功,这个等待只能发生在第三方。
8
+ *
9
+ * 回执由**新进程**补发(不是 worker):新进程本来就有 transport 和 `bridge.pi.json`
10
+ * 里的 chatId,不需要 worker 去读凭据换 token;worker 只做「杀→起→等锁→写结果」。
11
+ */
12
+ import { spawn, spawnSync } from "node:child_process";
13
+ import { closeSync, existsSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
14
+ import { fileURLToPath } from "node:url";
15
+ import { ROOT_DIR, DAEMON_LOG_PATH } from "./config.ts";
16
+ import { daemonSpec } from "./daemon-spec.ts";
17
+ import { buildRestartCard } from "./cards.ts";
18
+ import { debugLog } from "./debug.ts";
19
+ import { gatewayLockPath } from "./gateway-lock.ts";
20
+ import type { FeishuTransport } from "./transport.ts";
21
+
22
+ export const RESTART_TICKET_PATH = `${ROOT_DIR}/restart-ticket.json`;
23
+ export const RESTART_RESULT_PATH = `${ROOT_DIR}/restart-result.json`;
24
+
25
+ /** 票据/结果的保鲜期:超过这个时间的残留一律当垃圾清掉,避免陈旧回执改错卡 */
26
+ export const RESTART_FRESH_MS = 180_000;
27
+
28
+ /** 触发重启的飞书消息上下文(用于回执定位卡片) */
29
+ export type RestartTrigger = {
30
+ messageId: string;
31
+ chatId: string;
32
+ };
33
+
34
+ export type RestartTicket = {
35
+ version: 1;
36
+ oldPid: number;
37
+ /**
38
+ * 老 daemon 的启动壳 pid —— 必须**在退出前**记下:老进程一退,它自己的 ppid 立刻被
39
+ * reparent 成 1,worker 再去查就查不到了(修复前的旧版本漏掉的孤儿 tail 就是这么留下的)。
40
+ */
41
+ launcherPid?: number;
42
+ cwd: string;
43
+ piBin: string;
44
+ args: string[];
45
+ lockPath: string;
46
+ logPath: string;
47
+ resultPath: string;
48
+ startedAt: number;
49
+ commit?: string;
50
+ triggerMessageId?: string;
51
+ chatId?: string;
52
+ cardMessageId?: string;
53
+ };
54
+
55
+ export type RestartResult = {
56
+ version: 1;
57
+ ok: boolean;
58
+ at: number;
59
+ newPid?: number;
60
+ elapsedMs?: number;
61
+ error?: string;
62
+ };
63
+
64
+ function readJson<T>(path: string): T | undefined {
65
+ try {
66
+ if (!existsSync(path)) return undefined;
67
+ return JSON.parse(readFileSync(path, "utf8")) as T;
68
+ } catch {
69
+ return undefined;
70
+ }
71
+ }
72
+
73
+ function writeJsonFile(path: string, value: unknown) {
74
+ try {
75
+ writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
76
+ } catch (error) {
77
+ debugLog("feishu.restart.write_failed", { path, error: error instanceof Error ? error.message : String(error) });
78
+ }
79
+ }
80
+
81
+ export function readRestartTicket(path = RESTART_TICKET_PATH): RestartTicket | undefined {
82
+ const ticket = readJson<RestartTicket>(path);
83
+ return ticket && ticket.version === 1 ? ticket : undefined;
84
+ }
85
+
86
+ export function readRestartResult(path = RESTART_RESULT_PATH): RestartResult | undefined {
87
+ const result = readJson<RestartResult>(path);
88
+ return result && result.version === 1 ? result : undefined;
89
+ }
90
+
91
+ export function clearRestartFiles(ticketPath = RESTART_TICKET_PATH, resultPath = RESTART_RESULT_PATH) {
92
+ for (const path of [ticketPath, resultPath]) {
93
+ try {
94
+ rmSync(path, { force: true });
95
+ } catch {}
96
+ }
97
+ }
98
+
99
+ function isProcessAlive(pid: number | undefined): boolean {
100
+ if (!pid || pid <= 0) return false;
101
+ try {
102
+ process.kill(pid, 0);
103
+ return true;
104
+ } catch {
105
+ return false;
106
+ }
107
+ }
108
+
109
+ /** 当前代码版本,用于回执里告诉用户「重启后到底跑的是哪个 commit」 */
110
+ export function currentCommit(cwd: string): string | undefined {
111
+ try {
112
+ const res = spawnSync("git", ["rev-parse", "--short", "HEAD"], { cwd, encoding: "utf8", timeout: 3000 });
113
+ const sha = res.stdout?.trim();
114
+ if (!sha) return undefined;
115
+ const subject = spawnSync("git", ["log", "-1", "--pretty=%s"], { cwd, encoding: "utf8", timeout: 3000 }).stdout?.trim();
116
+ return subject ? `${sha} ${subject}` : sha;
117
+ } catch {
118
+ return undefined;
119
+ }
120
+ }
121
+
122
+ /** `src/feishu/restart.ts` → `<pkg>/scripts/restart-worker.mjs` */
123
+ export function restartWorkerPath(): string {
124
+ return fileURLToPath(new URL("../../scripts/restart-worker.mjs", import.meta.url));
125
+ }
126
+
127
+ /**
128
+ * 拉起重启 worker(detached,老进程随后自行退出)。
129
+ *
130
+ * worker 用 `process.execPath` 跑,不依赖 PATH 里的 node —— 桥接可能由 nvm 里的
131
+ * pi 拉起,PATH 在 detached 子进程里未必一致。
132
+ */
133
+ export function spawnRestartWorker(ticket: RestartTicket, ticketPath = RESTART_TICKET_PATH): { ok: boolean; error?: string } {
134
+ const worker = restartWorkerPath();
135
+ if (!existsSync(worker)) return { ok: false, error: `重启 worker 不存在:${worker}` };
136
+ let logFd: number | undefined;
137
+ try {
138
+ logFd = openSync(ticket.logPath, "a");
139
+ const child = spawn(process.execPath, [worker, ticketPath], {
140
+ detached: true,
141
+ cwd: ticket.cwd,
142
+ env: { ...process.env, PI_FEISHU_RESTART_WORKER: "1" },
143
+ stdio: ["ignore", logFd, logFd],
144
+ });
145
+ child.unref();
146
+ debugLog("feishu.restart.worker_spawned", { pid: child.pid, ticketPath });
147
+ return { ok: true };
148
+ } catch (error) {
149
+ return { ok: false, error: error instanceof Error ? error.message : String(error) };
150
+ } finally {
151
+ if (typeof logFd === "number") {
152
+ try { closeSync(logFd); } catch {}
153
+ }
154
+ }
155
+ }
156
+
157
+ /** 票据/结果落点(测试可覆盖,避免往真实 agent 目录写垃圾) */
158
+ export type RestartPaths = { ticketPath: string; resultPath: string };
159
+
160
+ const DEFAULT_PATHS: RestartPaths = { ticketPath: RESTART_TICKET_PATH, resultPath: RESTART_RESULT_PATH };
161
+
162
+ export type RequestRestartOptions = {
163
+ transport: FeishuTransport;
164
+ trigger: RestartTrigger;
165
+ extensionPath: string;
166
+ cwd?: string;
167
+ hasActiveRun?: boolean;
168
+ force?: boolean;
169
+ paths?: RestartPaths;
170
+ /** 默认 detach 拉起 scripts/restart-worker.mjs;测试注入桩,避免真起进程 */
171
+ spawnWorker?: (ticket: RestartTicket, ticketPath: string) => { ok: boolean; error?: string };
172
+ };
173
+
174
+ /**
175
+ * 处理 `/restart`:发「重启中」卡片 → 落票据 → 拉 worker。
176
+ *
177
+ * 注意 **顺序**:卡片必须先发出去并且拿到 message_id,票据才可能有回执地址;
178
+ * 反过来先杀进程,用户就只会看到一张永远停在「回复中」的卡。
179
+ */
180
+ export async function requestRestart(options: RequestRestartOptions): Promise<{ ok: boolean; error?: string; cardMessageId?: string }> {
181
+ const cwd = options.cwd ?? process.cwd();
182
+ const paths = options.paths ?? DEFAULT_PATHS;
183
+ const spawnWorker = options.spawnWorker ?? spawnRestartWorker;
184
+ if (options.hasActiveRun && !options.force) {
185
+ return { ok: false, error: "当前还有回复在生成。等它结束再试,或发 `/restart force` 强制中止并重启。" };
186
+ }
187
+ const spec = daemonSpec(options.extensionPath);
188
+ const startedAt = Date.now();
189
+ const commit = currentCommit(cwd);
190
+
191
+ let cardMessageId: string | undefined;
192
+ try {
193
+ cardMessageId = await options.transport.replyCard(
194
+ options.trigger.messageId,
195
+ buildRestartCard({ stage: "restarting", commit, at: startedAt }),
196
+ );
197
+ } catch (error) {
198
+ return { ok: false, error: `重启卡片发送失败:${error instanceof Error ? error.message : String(error)}` };
199
+ }
200
+
201
+ const ticket: RestartTicket = {
202
+ version: 1,
203
+ oldPid: process.pid,
204
+ launcherPid: process.ppid > 1 ? process.ppid : undefined,
205
+ cwd,
206
+ piBin: spec.piBin,
207
+ args: spec.args,
208
+ lockPath: gatewayLockPath(),
209
+ logPath: DAEMON_LOG_PATH,
210
+ resultPath: paths.resultPath,
211
+ startedAt,
212
+ commit,
213
+ triggerMessageId: options.trigger.messageId,
214
+ chatId: options.trigger.chatId,
215
+ cardMessageId,
216
+ };
217
+ writeJsonFile(paths.ticketPath, ticket);
218
+ try {
219
+ rmSync(paths.resultPath, { force: true });
220
+ } catch {}
221
+
222
+ const spawned = spawnWorker(ticket, paths.ticketPath);
223
+ if (!spawned.ok) {
224
+ clearRestartFiles(paths.ticketPath, paths.resultPath);
225
+ if (cardMessageId) {
226
+ await options.transport
227
+ .updateCard(cardMessageId, buildRestartCard({ stage: "failed", error: spawned.error || "worker 启动失败", at: Date.now() }))
228
+ .catch(() => undefined);
229
+ }
230
+ return { ok: false, error: spawned.error };
231
+ }
232
+ return { ok: true, cardMessageId };
233
+ }
234
+
235
+ /**
236
+ * 新进程接管成功后补发回执(也用于兜底:worker 半路死了但新进程起来了)。
237
+ *
238
+ * 判定:结果文件存在且在保鲜期内 → 按结果改卡;只有票据没有结果,且票据里的老 pid
239
+ * 已经死了 → 说明我们就是重启后的新进程,改卡说明「回执缺失」。老 pid 还活着时**不动**
240
+ * 票据:那意味着重启还没发生(worker 卡住),此时把卡改成「已重启」是撒谎。
241
+ */
242
+ export async function ackRestartIfPending(transport: FeishuTransport, paths: RestartPaths = DEFAULT_PATHS): Promise<boolean> {
243
+ const ticket = readRestartTicket(paths.ticketPath);
244
+ const result = readRestartResult(paths.resultPath);
245
+ const now = Date.now();
246
+
247
+ if (result) {
248
+ if (now - result.at > RESTART_FRESH_MS) {
249
+ clearRestartFiles(paths.ticketPath, paths.resultPath);
250
+ return false;
251
+ }
252
+ const cardMessageId = ticket?.cardMessageId;
253
+ clearRestartFiles(paths.ticketPath, paths.resultPath);
254
+ if (!cardMessageId) return false;
255
+ const card = result.ok
256
+ ? buildRestartCard({ stage: "done", commit: ticket?.commit, elapsedMs: result.elapsedMs, newPid: result.newPid, at: result.at })
257
+ : buildRestartCard({ stage: "failed", error: result.error || "未知错误", at: result.at });
258
+ try {
259
+ await transport.updateCard(cardMessageId, card);
260
+ debugLog("feishu.restart.ack_sent", { ok: result.ok, cardMessageId });
261
+ return true;
262
+ } catch (error) {
263
+ debugLog("feishu.restart.ack_failed", { error: error instanceof Error ? error.message : String(error) });
264
+ return false;
265
+ }
266
+ }
267
+
268
+ if (!ticket) return false;
269
+ if (now - ticket.startedAt > RESTART_FRESH_MS) {
270
+ clearRestartFiles(paths.ticketPath, paths.resultPath);
271
+ return false;
272
+ }
273
+ // 老进程还活着 = 重启没真正发生(worker 卡住/老进程没退),别抢先改卡
274
+ // 票据里的 oldPid 等于自己 = 本进程就是发起方,重启尚未发生,更不能改卡
275
+ if (ticket.oldPid === process.pid) return false;
276
+ if (isProcessAlive(ticket.oldPid)) return false;
277
+ const cardMessageId = ticket.cardMessageId;
278
+ clearRestartFiles(paths.ticketPath, paths.resultPath);
279
+ if (!cardMessageId) return false;
280
+ try {
281
+ await transport.updateCard(cardMessageId, buildRestartCard({ stage: "unknown", at: now }));
282
+ return true;
283
+ } catch {
284
+ return false;
285
+ }
286
+ }
@@ -0,0 +1,102 @@
1
+ import { debugLog } from "./debug.ts";
2
+
3
+ export type RetryOptions = {
4
+ maxRetries?: number;
5
+ baseDelayMs?: number;
6
+ label?: string;
7
+ };
8
+
9
+ function sleep(ms: number) {
10
+ return new Promise((resolve) => setTimeout(resolve, ms));
11
+ }
12
+
13
+ export function isRetriableError(error: unknown): boolean {
14
+ if (!error || typeof error !== "object") {
15
+ const msg = String(error || "").toLowerCase();
16
+ return msg.includes("timeout") || msg.includes("econnreset") || msg.includes("socket");
17
+ }
18
+ const err = error as {
19
+ code?: number | string;
20
+ status?: number;
21
+ message?: string;
22
+ response?: { status?: number; data?: { code?: number; msg?: string } };
23
+ cause?: unknown;
24
+ };
25
+ const status = err.status ?? err.response?.status;
26
+ if (typeof status === "number" && (status === 429 || status >= 500)) return true;
27
+
28
+ const code = err.code ?? err.response?.data?.code;
29
+ if (code === 11310 || code === 99991400 || code === 99991429) return true;
30
+ if (typeof code === "string") {
31
+ const c = code.toUpperCase();
32
+ if (["ETIMEDOUT", "ECONNRESET", "EAI_AGAIN", "ENOTFOUND", "EPIPE"].includes(c)) return true;
33
+ }
34
+
35
+ const msg = `${err.message || ""} ${err.response?.data?.msg || ""}`.toLowerCase();
36
+ if (msg.includes("timeout") || msg.includes("rate") || msg.includes("temporarily") || msg.includes("try again")) {
37
+ return true;
38
+ }
39
+ // Node 内置 fetch 的网络层失败统一报 "fetch failed",真实原因在 cause 里;
40
+ // 有 cause 时递归判断 cause,没有 cause 也按可重试处理,避免卡收尾直接放弃。
41
+ if (msg.includes("fetch failed")) {
42
+ return true;
43
+ }
44
+ if (err.cause && err.cause !== error) return isRetriableError(err.cause);
45
+ return false;
46
+ }
47
+
48
+ export type BackoffRetryOptions = {
49
+ /** 每次失败后的等待毫秒数;数组长度 = 允许的重试次数(首次尝试不算) */
50
+ delaysMs: number[];
51
+ /** 判断错误是否值得重试,默认 isRetriableError */
52
+ isRetriable?: (error: unknown) => boolean;
53
+ /** 每次决定重试时回调,便于调用方打日志/改状态 */
54
+ onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
55
+ };
56
+
57
+ /**
58
+ * 按给定延迟序列重试(用于「启动期一次性初始化」这类不该一次失败就放弃的流程)。
59
+ * 延迟序列由调用方给定,便于把总时长控制在网关锁 stale 阈值(30s)以内。
60
+ * 不可重试错误(凭证错、403、999xxxxx)立即抛出,不浪费等待时间。
61
+ */
62
+ export async function withBackoffRetry<T>(fn: () => Promise<T>, options: BackoffRetryOptions): Promise<T> {
63
+ const { delaysMs, isRetriable = isRetriableError, onRetry } = options;
64
+ for (let attempt = 0; ; attempt++) {
65
+ try {
66
+ return await fn();
67
+ } catch (error) {
68
+ if (attempt >= delaysMs.length || !isRetriable(error)) throw error;
69
+ const delayMs = delaysMs[attempt];
70
+ onRetry?.(error, attempt + 1, delayMs);
71
+ await sleep(delayMs);
72
+ }
73
+ }
74
+ }
75
+
76
+ /** 带指数退避的重试;不可重试错误立即抛出 */
77
+ export async function withRetry<T>(fn: () => Promise<T>, options: RetryOptions = {}): Promise<T> {
78
+ const maxRetries = Math.max(0, options.maxRetries ?? 2);
79
+ const baseDelayMs = options.baseDelayMs ?? 300;
80
+ const label = options.label || "feishu.retry";
81
+ let lastError: unknown;
82
+
83
+ for (let attempt = 0; attempt <= maxRetries; attempt++) {
84
+ try {
85
+ return await fn();
86
+ } catch (error) {
87
+ lastError = error;
88
+ const retriable = isRetriableError(error);
89
+ if (!retriable || attempt >= maxRetries) throw error;
90
+ const delay = baseDelayMs * Math.pow(2, attempt);
91
+ debugLog(label, {
92
+ attempt: attempt + 1,
93
+ maxRetries,
94
+ delayMs: delay,
95
+ error: error instanceof Error ? error.message : String(error),
96
+ });
97
+ await sleep(delay);
98
+ }
99
+ }
100
+ throw lastError;
101
+ }
102
+