dsh-supermesh 0.0.0-stage → 0.0.0

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.
@@ -0,0 +1,4688 @@
1
+ import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
2
+ import process from "node:process";
3
+ import { randomUUID } from "node:crypto";
4
+ import { DatabaseSync } from "node:sqlite";
5
+ import { NodeSqliteDialect } from "@fileshed/kysely-node-sqlite";
6
+ import { Kysely } from "kysely";
7
+ import { Migrator } from "kysely/migration";
8
+ import { Model } from "kysely-model";
9
+ import { execFile, spawn } from "node:child_process";
10
+ import { createRouteDispatcher, proxyEnvironmentForChild } from "@deepseek-ai/dsh-http-proxy";
11
+ import { credentialRef } from "@deepseek-ai/dsh-credentials";
12
+ import { getServerContext, getServerOptions } from "dsh-h3/utils";
13
+ import { defineWebServer } from "dsh-h3";
14
+ import { HTTPError, defineHandler, getQuery, getRouterParam, readBody } from "h3";
15
+ import { createStorage } from "unstorage";
16
+ import fs from "unstorage/drivers/fs";
17
+ import { homedir } from "node:os";
18
+ import { ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
19
+ import { access, lstat, mkdir, mkdtemp, realpath, rename, rm, writeFile } from "node:fs/promises";
20
+ import { Session, SessionId } from "@deepseek-ai/dsh-session";
21
+ import { realpathNormalize } from "@deepseek-ai/dsh-workspace";
22
+ import { StringDecoder } from "node:string_decoder";
23
+ import { promisify, stripVTControlCharacters } from "node:util";
24
+ import { fetch } from "undici";
25
+ // src/database/migrations.ts
26
+ /**
27
+ * 由 `pnpm run prisma:migrate` 从 `prisma/migrations` 搬运,不要手改。
28
+ *
29
+ * 一个键就是一个 Prisma 迁移目录,值是它 `migration.sql` 的全文。
30
+ */
31
+ const migrations = {
32
+ "20261113135519": `
33
+ -- CreateTable
34
+ CREATE TABLE "channel" (
35
+ "id" TEXT NOT NULL PRIMARY KEY,
36
+ "name" TEXT NOT NULL,
37
+ "enabled" BOOLEAN NOT NULL DEFAULT false,
38
+ "host" TEXT,
39
+ "createdAt" TEXT NOT NULL
40
+ );
41
+
42
+ -- CreateTable
43
+ CREATE TABLE "channel_account" (
44
+ "id" TEXT NOT NULL PRIMARY KEY,
45
+ "channelId" TEXT NOT NULL,
46
+ "role" TEXT NOT NULL,
47
+ "name" TEXT NOT NULL,
48
+ "avatar" TEXT,
49
+ "status" TEXT NOT NULL DEFAULT 'offline',
50
+ "createdAt" TEXT NOT NULL,
51
+ CONSTRAINT "channel_account_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE CASCADE ON UPDATE CASCADE
52
+ );
53
+
54
+ -- CreateTable
55
+ CREATE TABLE "ci_watch" (
56
+ "id" TEXT NOT NULL PRIMARY KEY,
57
+ "channelId" TEXT NOT NULL,
58
+ "kind" TEXT NOT NULL,
59
+ "ref" TEXT NOT NULL,
60
+ "fingerprint" TEXT NOT NULL,
61
+ "revision" INTEGER NOT NULL DEFAULT 0,
62
+ "head" TEXT,
63
+ "updatedAt" TEXT NOT NULL,
64
+ CONSTRAINT "ci_watch_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE CASCADE ON UPDATE CASCADE
65
+ );
66
+
67
+ -- CreateTable
68
+ CREATE TABLE "source_state" (
69
+ "channelId" TEXT NOT NULL,
70
+ "name" TEXT NOT NULL,
71
+ "value" TEXT NOT NULL,
72
+ "updatedAt" TEXT NOT NULL,
73
+
74
+ PRIMARY KEY ("channelId", "name"),
75
+ CONSTRAINT "source_state_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE CASCADE ON UPDATE CASCADE
76
+ );
77
+
78
+ -- CreateTable
79
+ CREATE TABLE "inbox" (
80
+ "id" TEXT NOT NULL PRIMARY KEY,
81
+ "seq" BIGINT NOT NULL,
82
+ "type" TEXT NOT NULL,
83
+ "projectId" TEXT,
84
+ "supervisorId" TEXT,
85
+ "origin" TEXT NOT NULL,
86
+ "status" TEXT NOT NULL DEFAULT 'pending',
87
+ "kind" TEXT NOT NULL,
88
+ "title" TEXT,
89
+ "message" TEXT NOT NULL,
90
+ "createdAt" TEXT NOT NULL,
91
+ "doneAt" TEXT,
92
+ "deliveryAttempts" INTEGER NOT NULL DEFAULT 0,
93
+ "deliveryError" TEXT,
94
+ "nextRetryAt" TEXT,
95
+ "readAt" TEXT,
96
+ "escalations" INTEGER NOT NULL DEFAULT 0,
97
+ "lastEscalatedAt" TEXT,
98
+ "answer" TEXT,
99
+ "answeredBy" TEXT,
100
+ "answeredAt" TEXT,
101
+ "triggerId" TEXT,
102
+ "threadId" TEXT,
103
+ "ticketId" TEXT,
104
+ "workerId" TEXT,
105
+ CONSTRAINT "inbox_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "project" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
106
+ CONSTRAINT "inbox_supervisorId_fkey" FOREIGN KEY ("supervisorId") REFERENCES "supervisor" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
107
+ CONSTRAINT "inbox_triggerId_fkey" FOREIGN KEY ("triggerId") REFERENCES "trigger" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
108
+ CONSTRAINT "inbox_threadId_fkey" FOREIGN KEY ("threadId") REFERENCES "thread" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
109
+ CONSTRAINT "inbox_ticketId_fkey" FOREIGN KEY ("ticketId") REFERENCES "ticket" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
110
+ CONSTRAINT "inbox_workerId_fkey" FOREIGN KEY ("workerId") REFERENCES "worker" ("id") ON DELETE SET NULL ON UPDATE CASCADE
111
+ );
112
+
113
+ -- CreateTable
114
+ CREATE TABLE "project" (
115
+ "id" TEXT NOT NULL PRIMARY KEY,
116
+ "channelId" TEXT NOT NULL,
117
+ "name" TEXT NOT NULL,
118
+ "workspaceId" TEXT NOT NULL,
119
+ "directory" TEXT NOT NULL,
120
+ "orchestratorSessionId" TEXT,
121
+ "createdAt" TEXT NOT NULL,
122
+ "updatedAt" TEXT NOT NULL,
123
+ CONSTRAINT "project_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
124
+ );
125
+
126
+ -- CreateTable
127
+ CREATE TABLE "setting" (
128
+ "id" TEXT NOT NULL PRIMARY KEY,
129
+ "maxWorkers" INTEGER NOT NULL DEFAULT 4,
130
+ "backgroundLimitMinutes" INTEGER NOT NULL DEFAULT 30,
131
+ "autoMerge" BOOLEAN NOT NULL DEFAULT false,
132
+ "autoMergeMaxLines" INTEGER NOT NULL DEFAULT 200,
133
+ "deliveryMaxAttempts" INTEGER NOT NULL DEFAULT 3,
134
+ "deliveryRetryCeilingSeconds" INTEGER NOT NULL DEFAULT 60,
135
+ "updatedAt" TEXT NOT NULL
136
+ );
137
+
138
+ -- CreateTable
139
+ CREATE TABLE "supervisor" (
140
+ "id" TEXT NOT NULL PRIMARY KEY,
141
+ "sessionId" TEXT,
142
+ "title" TEXT NOT NULL,
143
+ "reason" TEXT NOT NULL,
144
+ "status" TEXT NOT NULL DEFAULT 'active',
145
+ "createdAt" TEXT NOT NULL,
146
+ "closedAt" TEXT
147
+ );
148
+
149
+ -- CreateTable
150
+ CREATE TABLE "supervisor_ticket" (
151
+ "supervisorId" TEXT NOT NULL,
152
+ "ticketId" TEXT NOT NULL,
153
+ "createdAt" TEXT NOT NULL,
154
+
155
+ PRIMARY KEY ("supervisorId", "ticketId"),
156
+ CONSTRAINT "supervisor_ticket_supervisorId_fkey" FOREIGN KEY ("supervisorId") REFERENCES "supervisor" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
157
+ CONSTRAINT "supervisor_ticket_ticketId_fkey" FOREIGN KEY ("ticketId") REFERENCES "ticket" ("id") ON DELETE CASCADE ON UPDATE CASCADE
158
+ );
159
+
160
+ -- CreateTable
161
+ CREATE TABLE "thread" (
162
+ "id" TEXT NOT NULL PRIMARY KEY,
163
+ "channelId" TEXT NOT NULL,
164
+ "projectId" TEXT,
165
+ "refId" TEXT NOT NULL,
166
+ "kind" TEXT NOT NULL,
167
+ "title" TEXT NOT NULL,
168
+ "url" TEXT,
169
+ "createdAt" TEXT NOT NULL,
170
+ "updatedAt" TEXT NOT NULL,
171
+ "triage" TEXT NOT NULL DEFAULT 'pending',
172
+ "triagedAt" TEXT,
173
+ CONSTRAINT "thread_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE RESTRICT ON UPDATE CASCADE,
174
+ CONSTRAINT "thread_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "project" ("id") ON DELETE SET NULL ON UPDATE CASCADE
175
+ );
176
+
177
+ -- CreateTable
178
+ CREATE TABLE "trigger" (
179
+ "id" TEXT NOT NULL PRIMARY KEY,
180
+ "channelId" TEXT NOT NULL,
181
+ "threadId" TEXT NOT NULL,
182
+ "kind" TEXT NOT NULL,
183
+ "actorName" TEXT,
184
+ "human" BOOLEAN NOT NULL DEFAULT true,
185
+ "mentioned" BOOLEAN NOT NULL DEFAULT false,
186
+ "text" TEXT NOT NULL,
187
+ "url" TEXT,
188
+ "at" TEXT NOT NULL,
189
+ "ref" TEXT,
190
+ CONSTRAINT "trigger_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE RESTRICT ON UPDATE CASCADE,
191
+ CONSTRAINT "trigger_threadId_fkey" FOREIGN KEY ("threadId") REFERENCES "thread" ("id") ON DELETE CASCADE ON UPDATE CASCADE
192
+ );
193
+
194
+ -- CreateTable
195
+ CREATE TABLE "ticket" (
196
+ "id" TEXT NOT NULL PRIMARY KEY,
197
+ "projectId" TEXT NOT NULL,
198
+ "channelId" TEXT NOT NULL,
199
+ "title" TEXT NOT NULL,
200
+ "description" TEXT,
201
+ "status" TEXT NOT NULL,
202
+ "createdAt" TEXT NOT NULL,
203
+ "updatedAt" TEXT NOT NULL,
204
+ "startedAt" TEXT,
205
+ "endedAt" TEXT,
206
+ "prUrl" TEXT,
207
+ "prState" TEXT,
208
+ "ciState" TEXT,
209
+ "paused" BOOLEAN NOT NULL DEFAULT false,
210
+ "prepareError" TEXT,
211
+ CONSTRAINT "ticket_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "project" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
212
+ CONSTRAINT "ticket_channelId_fkey" FOREIGN KEY ("channelId") REFERENCES "channel" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
213
+ );
214
+
215
+ -- CreateTable
216
+ CREATE TABLE "ticket_thread" (
217
+ "ticketId" TEXT NOT NULL,
218
+ "threadId" TEXT NOT NULL,
219
+ "createdAt" TEXT NOT NULL,
220
+
221
+ PRIMARY KEY ("ticketId", "threadId"),
222
+ CONSTRAINT "ticket_thread_ticketId_fkey" FOREIGN KEY ("ticketId") REFERENCES "ticket" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
223
+ CONSTRAINT "ticket_thread_threadId_fkey" FOREIGN KEY ("threadId") REFERENCES "thread" ("id") ON DELETE CASCADE ON UPDATE CASCADE
224
+ );
225
+
226
+ -- CreateTable
227
+ CREATE TABLE "ticket_link" (
228
+ "ticketId" TEXT NOT NULL,
229
+ "relatedId" TEXT NOT NULL,
230
+ "kind" TEXT NOT NULL,
231
+ "createdAt" TEXT NOT NULL,
232
+
233
+ PRIMARY KEY ("ticketId", "relatedId", "kind"),
234
+ CONSTRAINT "ticket_link_ticketId_fkey" FOREIGN KEY ("ticketId") REFERENCES "ticket" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
235
+ CONSTRAINT "ticket_link_relatedId_fkey" FOREIGN KEY ("relatedId") REFERENCES "ticket" ("id") ON DELETE CASCADE ON UPDATE CASCADE
236
+ );
237
+
238
+ -- CreateTable
239
+ CREATE TABLE "worker" (
240
+ "id" TEXT NOT NULL PRIMARY KEY,
241
+ "ticketId" TEXT NOT NULL,
242
+ "status" TEXT NOT NULL,
243
+ "createdAt" TEXT NOT NULL,
244
+ "startedAt" TEXT,
245
+ "endedAt" TEXT,
246
+ "title" TEXT,
247
+ "endedReason" TEXT,
248
+ "branch" TEXT,
249
+ "worktree" TEXT,
250
+ "reportState" TEXT,
251
+ "report" TEXT,
252
+ "reportAt" TEXT,
253
+ "backgroundUntil" TEXT,
254
+ "recoveryNote" TEXT,
255
+ CONSTRAINT "worker_ticketId_fkey" FOREIGN KEY ("ticketId") REFERENCES "ticket" ("id") ON DELETE CASCADE ON UPDATE CASCADE
256
+ );
257
+
258
+ -- CreateIndex
259
+ CREATE INDEX "channel_account_channelId_role_idx" ON "channel_account"("channelId", "role");
260
+
261
+ -- CreateIndex
262
+ CREATE UNIQUE INDEX "channel_account_channelId_role_name_key" ON "channel_account"("channelId", "role", "name");
263
+
264
+ -- CreateIndex
265
+ CREATE UNIQUE INDEX "ci_watch_channelId_kind_ref_key" ON "ci_watch"("channelId", "kind", "ref");
266
+
267
+ -- CreateIndex
268
+ CREATE INDEX "source_state_updatedAt_idx" ON "source_state"("updatedAt");
269
+
270
+ -- CreateIndex
271
+ CREATE INDEX "inbox_type_projectId_status_idx" ON "inbox"("type", "projectId", "status");
272
+
273
+ -- CreateIndex
274
+ CREATE INDEX "inbox_type_status_createdAt_idx" ON "inbox"("type", "status", "createdAt");
275
+
276
+ -- CreateIndex
277
+ CREATE INDEX "inbox_status_createdAt_idx" ON "inbox"("status", "createdAt");
278
+
279
+ -- CreateIndex
280
+ CREATE INDEX "inbox_ticketId_seq_idx" ON "inbox"("ticketId", "seq");
281
+
282
+ -- CreateIndex
283
+ CREATE INDEX "inbox_status_nextRetryAt_idx" ON "inbox"("status", "nextRetryAt");
284
+
285
+ -- CreateIndex
286
+ CREATE UNIQUE INDEX "project_workspaceId_key" ON "project"("workspaceId");
287
+
288
+ -- CreateIndex
289
+ CREATE UNIQUE INDEX "project_channelId_name_key" ON "project"("channelId", "name");
290
+
291
+ -- CreateIndex
292
+ CREATE INDEX "supervisor_status_idx" ON "supervisor"("status");
293
+
294
+ -- CreateIndex
295
+ CREATE INDEX "supervisor_ticket_ticketId_idx" ON "supervisor_ticket"("ticketId");
296
+
297
+ -- CreateIndex
298
+ CREATE INDEX "thread_updatedAt_idx" ON "thread"("updatedAt");
299
+
300
+ -- CreateIndex
301
+ CREATE INDEX "thread_projectId_idx" ON "thread"("projectId");
302
+
303
+ -- CreateIndex
304
+ CREATE INDEX "thread_triage_idx" ON "thread"("triage");
305
+
306
+ -- CreateIndex
307
+ CREATE UNIQUE INDEX "thread_channelId_refId_key" ON "thread"("channelId", "refId");
308
+
309
+ -- CreateIndex
310
+ CREATE INDEX "trigger_threadId_at_idx" ON "trigger"("threadId", "at");
311
+
312
+ -- CreateIndex
313
+ CREATE INDEX "trigger_channelId_at_idx" ON "trigger"("channelId", "at");
314
+
315
+ -- CreateIndex
316
+ CREATE INDEX "trigger_at_idx" ON "trigger"("at");
317
+
318
+ -- CreateIndex
319
+ CREATE INDEX "trigger_ref_idx" ON "trigger"("ref");
320
+
321
+ -- CreateIndex
322
+ CREATE INDEX "ticket_projectId_status_idx" ON "ticket"("projectId", "status");
323
+
324
+ -- CreateIndex
325
+ CREATE INDEX "ticket_status_updatedAt_idx" ON "ticket"("status", "updatedAt");
326
+
327
+ -- CreateIndex
328
+ CREATE INDEX "ticket_thread_ticketId_createdAt_idx" ON "ticket_thread"("ticketId", "createdAt");
329
+
330
+ -- CreateIndex
331
+ CREATE INDEX "ticket_thread_threadId_idx" ON "ticket_thread"("threadId");
332
+
333
+ -- CreateIndex
334
+ CREATE INDEX "ticket_link_relatedId_idx" ON "ticket_link"("relatedId");
335
+
336
+ -- CreateIndex
337
+ CREATE INDEX "worker_ticketId_createdAt_idx" ON "worker"("ticketId", "createdAt");
338
+
339
+ -- CreateIndex
340
+ CREATE INDEX "worker_status_idx" ON "worker"("status");
341
+ `,
342
+ "20261117170000_project_workspace": `
343
+ -- RedefineTables
344
+ PRAGMA defer_foreign_keys=ON;
345
+ PRAGMA foreign_keys=OFF;
346
+ CREATE TABLE "new_project" (
347
+ "id" TEXT NOT NULL PRIMARY KEY,
348
+ "name" TEXT NOT NULL,
349
+ "workspaceId" TEXT NOT NULL,
350
+ "directory" TEXT NOT NULL,
351
+ "remoteUrl" TEXT,
352
+ "enabled" BOOLEAN NOT NULL DEFAULT true,
353
+ "orchestratorSessionId" TEXT,
354
+ "createdAt" TEXT NOT NULL,
355
+ "updatedAt" TEXT NOT NULL
356
+ );
357
+ INSERT INTO "new_project" ("createdAt", "directory", "id", "name", "orchestratorSessionId", "updatedAt", "workspaceId") SELECT "createdAt", "directory", "id", "name", "orchestratorSessionId", "updatedAt", "workspaceId" FROM "project";
358
+ DROP TABLE "project";
359
+ ALTER TABLE "new_project" RENAME TO "project";
360
+ CREATE UNIQUE INDEX "project_workspaceId_key" ON "project"("workspaceId");
361
+ PRAGMA foreign_keys=ON;
362
+ PRAGMA defer_foreign_keys=OFF;
363
+ `
364
+ };
365
+ // src/database/models/channel.ts
366
+ var Channel = class extends Model {
367
+ constructor(db) {
368
+ super(db, "channel", "id");
369
+ }
370
+ async saveConfiguration(id, name, host, enabled, metadata, account, hostChanged = false) {
371
+ const now = (/* @__PURE__ */ new Date()).toISOString();
372
+ await this.db.transaction().execute(async (trx) => {
373
+ const previous = await trx.selectFrom("channel").selectAll().where("id", "=", id).executeTakeFirst();
374
+ const activation = await trx.selectFrom("source_state").select("name").where("channelId", "=", id).where("name", "=", "activation").executeTakeFirst();
375
+ await trx.insertInto("channel").values({
376
+ id,
377
+ name,
378
+ host,
379
+ enabled: enabled ? 1 : 0,
380
+ createdAt: now
381
+ }).onConflict((oc) => oc.column("id").doUpdateSet({
382
+ name,
383
+ host,
384
+ enabled: enabled ? 1 : 0
385
+ })).execute();
386
+ if (enabled && (!previous?.enabled || hostChanged || !activation)) {
387
+ const observedAt = previous?.enabled && !hostChanged ? previous.createdAt : now;
388
+ await trx.insertInto("source_state").values({
389
+ channelId: id,
390
+ name: "activation",
391
+ value: JSON.stringify(observedAt),
392
+ updatedAt: now
393
+ }).onConflict((oc) => oc.columns(["channelId", "name"]).doUpdateSet({
394
+ value: JSON.stringify(observedAt),
395
+ updatedAt: now
396
+ })).execute();
397
+ }
398
+ await trx.insertInto("source_state").values({
399
+ channelId: id,
400
+ name: "configuration",
401
+ value: JSON.stringify(metadata),
402
+ updatedAt: now
403
+ }).onConflict((oc) => oc.columns(["channelId", "name"]).doUpdateSet({
404
+ value: JSON.stringify(metadata),
405
+ updatedAt: now
406
+ })).execute();
407
+ if (account) {
408
+ await trx.deleteFrom("channel_account").where("channelId", "=", id).where("role", "=", "bot").execute();
409
+ await trx.insertInto("channel_account").values({
410
+ id: `${id}:bot`,
411
+ channelId: id,
412
+ role: "bot",
413
+ name: account.name,
414
+ avatar: account.avatar,
415
+ status: "online",
416
+ createdAt: now
417
+ }).execute();
418
+ }
419
+ });
420
+ }
421
+ async removeCredentials(id) {
422
+ await this.db.transaction().execute(async (trx) => {
423
+ await trx.updateTable("channel").set({ enabled: 0 }).where("id", "=", id).execute();
424
+ await trx.deleteFrom("channel_account").where("channelId", "=", id).where("role", "=", "bot").execute();
425
+ await trx.updateTable("channel_account").set({ status: "offline" }).where("channelId", "=", id).where("role", "=", "admin").execute();
426
+ });
427
+ }
428
+ async findEnabled() {
429
+ return this.db.selectFrom("channel").selectAll().where("enabled", "=", 1).orderBy("id").execute();
430
+ }
431
+ async setEnabled(id, enabled) {
432
+ await this.db.updateTable("channel").set({ enabled: enabled ? 1 : 0 }).where("id", "=", id).execute();
433
+ }
434
+ async findById(id) {
435
+ return this.db.selectFrom("channel").selectAll().where("id", "=", id).executeTakeFirst();
436
+ }
437
+ async listAll() {
438
+ return this.db.selectFrom("channel").selectAll().orderBy("id").execute();
439
+ }
440
+ };
441
+ // src/database/models/channel-account.ts
442
+ var ChannelAccount = class extends Model {
443
+ constructor(db) {
444
+ super(db, "channel_account", "id");
445
+ }
446
+ async findByChannel(channelId) {
447
+ return this.db.selectFrom("channel_account").selectAll().where("channelId", "=", channelId).orderBy("role").orderBy("name").execute();
448
+ }
449
+ async findByRole(channelId, role) {
450
+ return this.db.selectFrom("channel_account").selectAll().where("channelId", "=", channelId).where("role", "=", role).orderBy("name").execute();
451
+ }
452
+ async findByName(channelId, role, name) {
453
+ return this.db.selectFrom("channel_account").selectAll().where("channelId", "=", channelId).where("role", "=", role).where("name", "=", name).executeTakeFirst();
454
+ }
455
+ async setStatus(id, status) {
456
+ await this.db.updateTable("channel_account").set({ status }).where("id", "=", id).execute();
457
+ }
458
+ async findById(id) {
459
+ return this.db.selectFrom("channel_account").selectAll().where("id", "=", id).executeTakeFirst();
460
+ }
461
+ async listAll() {
462
+ return this.db.selectFrom("channel_account").selectAll().orderBy("id").execute();
463
+ }
464
+ };
465
+ // src/database/models/ci-watch.ts
466
+ var CiWatch = class CiWatch extends Model {
467
+ constructor(db) {
468
+ super(db, "ci_watch", "id");
469
+ }
470
+ async findTarget(channelId, kind, ref) {
471
+ return this.db.selectFrom("ci_watch").selectAll().where("channelId", "=", channelId).where("kind", "=", kind).where("ref", "=", ref).executeTakeFirst();
472
+ }
473
+ async listByChannel(channelId) {
474
+ return this.db.selectFrom("ci_watch").selectAll().where("channelId", "=", channelId).orderBy("ref").execute();
475
+ }
476
+ async rotate(id, fingerprint, updatedAt, head = null) {
477
+ await this.db.updateTable("ci_watch").set((eb) => ({
478
+ fingerprint,
479
+ head,
480
+ updatedAt,
481
+ revision: eb("revision", "+", 1)
482
+ })).where("id", "=", id).execute();
483
+ }
484
+ async recordRevision(value) {
485
+ return this.db.transaction().execute(async (trx) => {
486
+ const model = new CiWatch(trx);
487
+ const previous = await model.findTarget(value.channelId, value.kind, value.ref);
488
+ if (!previous) {
489
+ await model.create({
490
+ ...value,
491
+ revision: 0
492
+ });
493
+ return {
494
+ row: await model.findTarget(value.channelId, value.kind, value.ref),
495
+ changed: true
496
+ };
497
+ }
498
+ const changed = previous.fingerprint !== value.fingerprint || previous.head !== (value.head ?? null);
499
+ if (changed) await model.rotate(previous.id, value.fingerprint, value.updatedAt, value.head ?? null);
500
+ return {
501
+ row: await model.findTarget(value.channelId, value.kind, value.ref),
502
+ changed
503
+ };
504
+ });
505
+ }
506
+ };
507
+ // src/database/models/inbox.ts
508
+ var Inbox = class Inbox extends Model {
509
+ constructor(db) {
510
+ super(db, "inbox", "id");
511
+ }
512
+ async nextSeq() {
513
+ const row = await this.db.selectFrom("inbox").select(this.db.fn.max("seq").as("max")).executeTakeFirst();
514
+ return Number(row?.max ?? 0) + 1;
515
+ }
516
+ async listPending(type, projectId) {
517
+ const query = this.db.selectFrom("inbox").selectAll().where("type", "=", type).where("status", "=", "pending");
518
+ return (projectId === void 0 ? query : query.where("projectId", "=", projectId)).orderBy("seq").execute();
519
+ }
520
+ async countPending(type, projectId) {
521
+ const query = this.db.selectFrom("inbox").select(this.db.fn.countAll().as("count")).where("type", "=", type).where("status", "=", "pending");
522
+ const row = await (projectId === void 0 ? query : query.where("projectId", "=", projectId)).executeTakeFirst();
523
+ return Number(row?.count ?? 0);
524
+ }
525
+ async listPendingAsk() {
526
+ return this.db.selectFrom("inbox").selectAll().where("type", "=", "user").where("kind", "=", "ask").where("status", "=", "pending").orderBy("createdAt").execute();
527
+ }
528
+ async markRead(ids, readAt) {
529
+ if (ids.length === 0) return;
530
+ await this.db.updateTable("inbox").set({ readAt }).where("id", "in", ids).execute();
531
+ }
532
+ async markDone(id, doneAt) {
533
+ await this.db.updateTable("inbox").set({
534
+ status: "done",
535
+ doneAt
536
+ }).where("id", "=", id).execute();
537
+ }
538
+ async answer(id, answer, answeredBy, answeredAt) {
539
+ await this.db.updateTable("inbox").set({
540
+ answer,
541
+ answeredBy,
542
+ answeredAt,
543
+ status: "done",
544
+ doneAt: answeredAt
545
+ }).where("id", "=", id).execute();
546
+ }
547
+ async recordDeliveryFailure(id, deliveryError, nextRetryAt) {
548
+ await this.db.updateTable("inbox").set((eb) => ({
549
+ deliveryAttempts: eb("deliveryAttempts", "+", 1),
550
+ deliveryError,
551
+ nextRetryAt
552
+ })).where("id", "=", id).execute();
553
+ }
554
+ async resetDelivery(id) {
555
+ await this.db.updateTable("inbox").set({
556
+ deliveryAttempts: 0,
557
+ deliveryError: null,
558
+ nextRetryAt: null
559
+ }).where("id", "=", id).execute();
560
+ }
561
+ async markStalled(id, deliveryError) {
562
+ await this.db.updateTable("inbox").set({
563
+ status: "stalled",
564
+ deliveryError,
565
+ nextRetryAt: null
566
+ }).where("id", "=", id).execute();
567
+ }
568
+ async listRetryable(now) {
569
+ return this.db.selectFrom("inbox").selectAll().where("status", "=", "pending").where("nextRetryAt", "is not", null).where("nextRetryAt", "<=", now).orderBy("nextRetryAt").execute();
570
+ }
571
+ async escalate(id, lastEscalatedAt) {
572
+ await this.db.updateTable("inbox").set((eb) => ({
573
+ escalations: eb("escalations", "+", 1),
574
+ lastEscalatedAt
575
+ })).where("id", "=", id).execute();
576
+ }
577
+ async reassign(id, type, refs = {}) {
578
+ await this.db.updateTable("inbox").set({
579
+ type,
580
+ ...refs
581
+ }).where("id", "=", id).execute();
582
+ }
583
+ async findById(id) {
584
+ return this.db.selectFrom("inbox").selectAll().where("id", "=", id).executeTakeFirst();
585
+ }
586
+ async listRecent(limit = 100) {
587
+ return this.db.selectFrom("inbox").selectAll().orderBy("createdAt", "desc").orderBy("id").limit(Math.max(1, Math.min(1e3, limit))).execute();
588
+ }
589
+ /** 一条话题上所有已入队的对外消息,用于判断「这次事件是不是已经有人说过了」。 */
590
+ async listByThread(threadId) {
591
+ return this.db.selectFrom("inbox").selectAll().where("threadId", "=", threadId).where("type", "=", "user").execute();
592
+ }
593
+ async enqueue(value) {
594
+ if (![
595
+ "user",
596
+ "main",
597
+ "project",
598
+ "supervisor"
599
+ ].includes(value.type)) throw new Error("invalid_inbox_recipient");
600
+ const insert = async (trx) => {
601
+ const model = new Inbox(trx);
602
+ if (value.id) {
603
+ const existing = await model.findById(value.id);
604
+ if (existing) return existing;
605
+ }
606
+ const id = value.id ?? randomUUID();
607
+ await model.create({
608
+ id,
609
+ seq: await model.nextSeq(),
610
+ status: "pending",
611
+ createdAt: (/* @__PURE__ */ new Date()).toISOString(),
612
+ projectId: null,
613
+ supervisorId: null,
614
+ title: null,
615
+ doneAt: null,
616
+ deliveryError: null,
617
+ nextRetryAt: null,
618
+ readAt: null,
619
+ lastEscalatedAt: null,
620
+ answer: null,
621
+ answeredBy: null,
622
+ answeredAt: null,
623
+ triggerId: null,
624
+ threadId: null,
625
+ ticketId: null,
626
+ workerId: null,
627
+ ...value
628
+ });
629
+ return await model.findById(id);
630
+ };
631
+ return this.db.isTransaction ? insert(this.db) : this.db.transaction().execute(insert);
632
+ }
633
+ async listByTicket(ticketId) {
634
+ return this.db.selectFrom("inbox").selectAll().where("ticketId", "=", ticketId).orderBy("createdAt").orderBy("seq").execute();
635
+ }
636
+ async listScoped(scope, includeChannel = false) {
637
+ if (![
638
+ "main",
639
+ "project",
640
+ "supervisor"
641
+ ].includes(scope.type)) throw new Error("invalid_inbox_recipient");
642
+ let query = this.db.selectFrom("inbox").selectAll().where("type", "=", scope.type).where("status", "in", ["pending", "stalled"]);
643
+ if (!includeChannel) query = query.where("origin", "!=", "channel");
644
+ if (scope.type === "project") query = query.where("projectId", "=", scope.projectId);
645
+ if (scope.type === "supervisor") query = query.where("supervisorId", "=", scope.supervisorId);
646
+ return query.orderBy("createdAt").orderBy("seq").execute();
647
+ }
648
+ owns(row, scope, includeChannel = false) {
649
+ return [
650
+ "main",
651
+ "project",
652
+ "supervisor"
653
+ ].includes(scope.type) && (includeChannel || row.origin !== "channel") && row.type === scope.type && (scope.type !== "project" || row.projectId === scope.projectId) && (scope.type !== "supervisor" || row.supervisorId === scope.supervisorId);
654
+ }
655
+ async completeScoped(ids, scope, now, includeChannel = false) {
656
+ if (!ids.length) return 0;
657
+ return this.db.transaction().execute(async (trx) => {
658
+ const model = new Inbox(trx);
659
+ const rows = await trx.selectFrom("inbox").selectAll().where("id", "in", [...new Set(ids)]).execute();
660
+ if (rows.length !== new Set(ids).size || rows.some((row) => !model.owns(row, scope, includeChannel))) throw new Error("收件箱不存在或不属于当前身份");
661
+ if (rows.some((row) => row.kind === "ask" && row.status !== "done")) throw new Error("answer_required");
662
+ const result = await trx.updateTable("inbox").set({
663
+ status: "done",
664
+ doneAt: now
665
+ }).where("id", "in", ids).where("status", "in", ["pending", "stalled"]).executeTakeFirst();
666
+ return Number(result.numUpdatedRows);
667
+ });
668
+ }
669
+ async answerScoped(id, text, scope, now) {
670
+ return this.db.transaction().execute(async (trx) => {
671
+ const model = new Inbox(trx);
672
+ const row = await model.findById(id);
673
+ if (!row || !model.owns(row, scope) || row.kind !== "ask" || row.status === "done") throw new Error("只能回答指向当前身份的 pending ask");
674
+ await model.answer(id, text, scope.type, now);
675
+ return row;
676
+ });
677
+ }
678
+ async escalateScoped(id, scope, now) {
679
+ return this.db.transaction().execute(async (trx) => {
680
+ const model = new Inbox(trx);
681
+ const row = await model.findById(id);
682
+ if (!row || !model.owns(row, scope) || row.kind !== "ask" || row.status === "done") throw new Error("只能升级指向当前身份的 pending ask");
683
+ if (scope.type === "main") throw new Error("主编排应通过 ask_user 询问人,不能自动升级");
684
+ const supervisor = scope.type === "project" && row.ticketId ? await trx.selectFrom("supervisor_ticket").innerJoin("supervisor", "supervisor.id", "supervisor_ticket.supervisorId").select("supervisor.id").where("ticketId", "=", row.ticketId).where("supervisor.status", "=", "active").orderBy("supervisor.createdAt").executeTakeFirst() : void 0;
685
+ await trx.updateTable("inbox").set((eb) => ({
686
+ type: supervisor ? "supervisor" : "main",
687
+ supervisorId: supervisor?.id ?? (row.origin === "supervisor" ? row.supervisorId : null),
688
+ escalations: eb("escalations", "+", 1),
689
+ lastEscalatedAt: now,
690
+ readAt: null
691
+ })).where("id", "=", id).execute();
692
+ return await model.findById(id);
693
+ });
694
+ }
695
+ async answerByUser(id, answer, answeredAt) {
696
+ return this.db.updateTable("inbox").set({
697
+ answer,
698
+ answeredBy: "user",
699
+ answeredAt,
700
+ status: "done",
701
+ doneAt: answeredAt
702
+ }).where("id", "=", id).where("type", "=", "user").where("kind", "=", "ask").where("status", "=", "pending").returningAll().executeTakeFirst();
703
+ }
704
+ async enqueueAnswer(row) {
705
+ if (!row.answer || !row.answeredBy || row.answeredBy === "user" || row.origin !== "main" && row.origin !== "project" && row.origin !== "supervisor") return;
706
+ await this.enqueue({
707
+ id: `supermesh:answer:${row.id}`,
708
+ type: row.origin,
709
+ origin: row.answeredBy,
710
+ kind: "notice",
711
+ title: row.title,
712
+ message: row.answer,
713
+ projectId: row.projectId,
714
+ supervisorId: row.supervisorId,
715
+ ticketId: row.ticketId,
716
+ workerId: row.workerId,
717
+ threadId: row.threadId,
718
+ triggerId: row.triggerId
719
+ });
720
+ }
721
+ async listAnswered() {
722
+ return this.db.selectFrom("inbox").selectAll().where("kind", "=", "ask").where("status", "=", "done").where("answer", "is not", null).orderBy("seq").execute();
723
+ }
724
+ async returnPendingTicket(ticketId, reason, now) {
725
+ await this.db.updateTable("inbox").set({
726
+ status: "stalled",
727
+ deliveryError: reason,
728
+ nextRetryAt: null,
729
+ doneAt: now
730
+ }).where("ticketId", "=", ticketId).where("status", "=", "pending").execute();
731
+ }
732
+ async listDelivery() {
733
+ return this.db.selectFrom("inbox").selectAll().where("type", "in", [
734
+ "main",
735
+ "project",
736
+ "supervisor"
737
+ ]).where("status", "in", ["pending", "stalled"]).orderBy("seq").execute();
738
+ }
739
+ async listOutgoing() {
740
+ return this.db.selectFrom("inbox").selectAll().where("type", "=", "user").where("triggerId", "is not", null).where("kind", "in", ["notice", "ask"]).where("status", "in", ["pending", "stalled"]).orderBy("seq").execute();
741
+ }
742
+ async enqueueAsk(value) {
743
+ return this.db.transaction().execute(async (trx) => {
744
+ let query = trx.selectFrom("inbox").selectAll().where("kind", "=", "ask").where("status", "=", "pending").where("origin", "=", value.origin);
745
+ if (value.workerId) query = query.where("workerId", "=", value.workerId);
746
+ else if (value.origin === "project" && value.ticketId) query = query.where("projectId", value.projectId ? "=" : "is", value.projectId ?? null).where("ticketId", "=", value.ticketId);
747
+ else query = query.where("projectId", value.projectId ? "=" : "is", value.projectId ?? null).where("supervisorId", value.supervisorId ? "=" : "is", value.supervisorId ?? null).where("triggerId", value.triggerId ? "=" : "is", value.triggerId ?? null).where("message", "=", value.message);
748
+ const pending = await query.executeTakeFirst();
749
+ if (pending) {
750
+ if (pending.message !== value.message) throw new Error(`当前工作线已有 pending ask:${pending.id}`);
751
+ return pending;
752
+ }
753
+ return new Inbox(trx).enqueue({
754
+ ...value,
755
+ kind: "ask"
756
+ });
757
+ });
758
+ }
759
+ };
760
+ // src/database/models/project.ts
761
+ var Project = class extends Model {
762
+ constructor(db) {
763
+ super(db, "project", "id");
764
+ }
765
+ async findByWorkspace(workspaceId) {
766
+ return this.db.selectFrom("project").selectAll().where("workspaceId", "=", workspaceId).executeTakeFirst();
767
+ }
768
+ async setOrchestrator(id, orchestratorSessionId, updatedAt) {
769
+ await this.db.updateTable("project").set({
770
+ orchestratorSessionId,
771
+ updatedAt
772
+ }).where("id", "=", id).execute();
773
+ }
774
+ async findById(id) {
775
+ return this.db.selectFrom("project").selectAll().where("id", "=", id).executeTakeFirst();
776
+ }
777
+ async listAll() {
778
+ return this.db.selectFrom("project").selectAll().orderBy("id").execute();
779
+ }
780
+ async findBySession(sessionId) {
781
+ const rows = await this.db.selectFrom("project").selectAll().where("orchestratorSessionId", "=", sessionId).limit(2).execute();
782
+ if (rows.length > 1) throw new Error("session_binding_conflict");
783
+ return rows[0];
784
+ }
785
+ async findByRemote(remoteUrl) {
786
+ return this.db.selectFrom("project").selectAll().where("remoteUrl", "=", remoteUrl).executeTakeFirst();
787
+ }
788
+ async setEnabled(id, enabled, updatedAt) {
789
+ let query = this.db.updateTable("project").set({
790
+ enabled: enabled ? 1 : 0,
791
+ updatedAt
792
+ }).where("id", "=", id);
793
+ if (enabled) query = query.where("remoteUrl", "is not", null).where("remoteUrl", "!=", "");
794
+ return query.returningAll().executeTakeFirst();
795
+ }
796
+ async disableUnavailable(workspaceIds, updatedAt) {
797
+ let query = this.db.updateTable("project").set({
798
+ enabled: 0,
799
+ updatedAt
800
+ }).where("enabled", "=", 1);
801
+ if (workspaceIds.length) query = query.where("workspaceId", "not in", workspaceIds);
802
+ await query.execute();
803
+ }
804
+ async upsertWorkspace(value, updatedAt) {
805
+ const hasRemote = Boolean(value.remoteUrl?.trim());
806
+ return this.db.insertInto("project").values({
807
+ ...value,
808
+ enabled: hasRemote ? 1 : 0,
809
+ orchestratorSessionId: null,
810
+ createdAt: updatedAt,
811
+ updatedAt
812
+ }).onConflict((oc) => oc.column("workspaceId").doUpdateSet({
813
+ name: value.name,
814
+ directory: value.directory,
815
+ remoteUrl: value.remoteUrl,
816
+ ...!hasRemote ? { enabled: 0 } : {},
817
+ updatedAt
818
+ })).returningAll().executeTakeFirstOrThrow();
819
+ }
820
+ };
821
+ // src/database/models/source-state.ts
822
+ /**
823
+ * 渠道读到哪了:每个需要增量读取的目标一行。
824
+ *
825
+ * 主键是 `(channelId, name)`,所以不套 `Model` —— 它的按主键操作
826
+ * 只接受单个值,用在这里会误删同渠道的其它游标。
827
+ */
828
+ var SourceState = class {
829
+ db;
830
+ constructor(db) {
831
+ this.db = db;
832
+ }
833
+ /** 读一个游标;没读过时为空。 */
834
+ async find(channelId, name) {
835
+ return this.db.selectFrom("source_state").selectAll().where("channelId", "=", channelId).where("name", "=", name).executeTakeFirst();
836
+ }
837
+ /** 某渠道的全部游标。 */
838
+ async listByChannel(channelId) {
839
+ return this.db.selectFrom("source_state").selectAll().where("channelId", "=", channelId).orderBy("name").execute();
840
+ }
841
+ /** 推进游标;不存在则插入。 */
842
+ async set(channelId, name, value, updatedAt) {
843
+ await this.db.insertInto("source_state").values({
844
+ channelId,
845
+ name,
846
+ value,
847
+ updatedAt
848
+ }).onConflict((oc) => oc.columns(["channelId", "name"]).doUpdateSet({
849
+ value,
850
+ updatedAt
851
+ })).execute();
852
+ }
853
+ /** 删一个游标,例如话题已不再会被读取。 */
854
+ async remove(channelId, name) {
855
+ await this.db.deleteFrom("source_state").where("channelId", "=", channelId).where("name", "=", name).execute();
856
+ }
857
+ };
858
+ // src/database/models/supervisor.ts
859
+ var Supervisor = class extends Model {
860
+ constructor(db) {
861
+ super(db, "supervisor", "id");
862
+ }
863
+ async listActive() {
864
+ return this.db.selectFrom("supervisor").selectAll().where("status", "=", "active").orderBy("createdAt").execute();
865
+ }
866
+ async listByStatus(status) {
867
+ return this.db.selectFrom("supervisor").selectAll().where("status", "=", status).orderBy("createdAt").execute();
868
+ }
869
+ async attachSession(id, sessionId) {
870
+ await this.db.updateTable("supervisor").set({ sessionId }).where("id", "=", id).execute();
871
+ }
872
+ async close(id, closedAt) {
873
+ await this.db.updateTable("supervisor").set({
874
+ status: "closed",
875
+ closedAt
876
+ }).where("id", "=", id).execute();
877
+ }
878
+ async findById(id) {
879
+ return this.db.selectFrom("supervisor").selectAll().where("id", "=", id).executeTakeFirst();
880
+ }
881
+ async findBySession(sessionId) {
882
+ const rows = await this.db.selectFrom("supervisor").selectAll().where("sessionId", "=", sessionId).limit(2).execute();
883
+ if (rows.length > 1) throw new Error("session_binding_conflict");
884
+ return rows[0];
885
+ }
886
+ };
887
+ // src/database/models/supervisor-ticket.ts
888
+ var SupervisorTicket = class {
889
+ db;
890
+ constructor(db) {
891
+ this.db = db;
892
+ }
893
+ async listBySupervisor(supervisorId) {
894
+ return this.db.selectFrom("supervisor_ticket").selectAll().where("supervisorId", "=", supervisorId).orderBy("createdAt").execute();
895
+ }
896
+ async listByTicket(ticketId) {
897
+ return this.db.selectFrom("supervisor_ticket").selectAll().where("ticketId", "=", ticketId).execute();
898
+ }
899
+ async link(supervisorId, ticketId, createdAt) {
900
+ await this.db.insertInto("supervisor_ticket").values({
901
+ supervisorId,
902
+ ticketId,
903
+ createdAt
904
+ }).onConflict((oc) => oc.columns(["supervisorId", "ticketId"]).doNothing()).execute();
905
+ }
906
+ async unlink(supervisorId, ticketId) {
907
+ await this.db.deleteFrom("supervisor_ticket").where("supervisorId", "=", supervisorId).where("ticketId", "=", ticketId).execute();
908
+ }
909
+ async listAll() {
910
+ return this.db.selectFrom("supervisor_ticket").selectAll().orderBy("createdAt").execute();
911
+ }
912
+ };
913
+ // src/database/models/thread.ts
914
+ var Thread = class extends Model {
915
+ constructor(db) {
916
+ super(db, "thread", "id");
917
+ }
918
+ async findByRef(channelId, refId) {
919
+ return this.db.selectFrom("thread").selectAll().where("channelId", "=", channelId).where("refId", "=", refId).executeTakeFirst();
920
+ }
921
+ async listRecent(limit = 50) {
922
+ return this.db.selectFrom("thread").selectAll().orderBy("updatedAt", "desc").limit(limit).execute();
923
+ }
924
+ async touch(id, updatedAt) {
925
+ await this.db.updateTable("thread").set({ updatedAt }).where("id", "=", id).execute();
926
+ }
927
+ async claim(id, projectId, triagedAt) {
928
+ await this.db.updateTable("thread").set({
929
+ projectId,
930
+ triage: "claimed",
931
+ triagedAt
932
+ }).where("id", "=", id).execute();
933
+ }
934
+ async ignore(id, triagedAt) {
935
+ await this.db.updateTable("thread").set({
936
+ triage: "ignored",
937
+ triagedAt
938
+ }).where("id", "=", id).execute();
939
+ }
940
+ async findById(id) {
941
+ return this.db.selectFrom("thread").selectAll().where("id", "=", id).executeTakeFirst();
942
+ }
943
+ async record(value) {
944
+ await this.db.insertInto("thread").values(value).onConflict((oc) => oc.column("id").doUpdateSet({
945
+ title: value.title,
946
+ url: value.url,
947
+ updatedAt: value.updatedAt
948
+ })).execute();
949
+ return await this.findById(value.id);
950
+ }
951
+ async listByChannel(channelId) {
952
+ return this.db.selectFrom("thread").selectAll().where("channelId", "=", channelId).orderBy("id").execute();
953
+ }
954
+ };
955
+ // src/database/models/ticket.ts
956
+ const CLOSED_STATUS = ["done", "cancelled"];
957
+ const closedName = (threadId) => `thread_closed:${threadId}`;
958
+ let creation = Promise.resolve();
959
+ var Ticket = class Ticket extends Model {
960
+ constructor(db) {
961
+ super(db, "ticket", "id");
962
+ }
963
+ async listByProject(projectId, status) {
964
+ const query = this.db.selectFrom("ticket").selectAll().where("projectId", "=", projectId);
965
+ return (status ? query.where("status", "=", status) : query).orderBy("updatedAt", "desc").execute();
966
+ }
967
+ async listOpen() {
968
+ return this.db.selectFrom("ticket").selectAll().where("status", "not in", [...CLOSED_STATUS]).orderBy("updatedAt", "desc").execute();
969
+ }
970
+ async countRunning() {
971
+ const row = await this.db.selectFrom("ticket").select(this.db.fn.countAll().as("count")).where("status", "=", "running").executeTakeFirst();
972
+ return Number(row?.count ?? 0);
973
+ }
974
+ async listDispatchable() {
975
+ return this.db.selectFrom("ticket").selectAll().where("status", "in", ["waiting", "queued"]).where("paused", "=", 0).orderBy("createdAt").execute();
976
+ }
977
+ async start(id, startedAt, updatedAt) {
978
+ await this.db.updateTable("ticket").set({
979
+ status: "running",
980
+ startedAt,
981
+ updatedAt
982
+ }).where("id", "=", id).where("status", "not in", ["done", "cancelled"]).where((eb) => eb.or([eb("prState", "is", null), eb("prState", "not in", ["merged", "closed"])])).execute();
983
+ }
984
+ async finish(id, status, endedAt, updatedAt) {
985
+ await this.db.transaction().execute(async (trx) => {
986
+ await trx.updateTable("ticket").set({
987
+ status,
988
+ endedAt,
989
+ updatedAt,
990
+ prepareError: null
991
+ }).where("id", "=", id).execute();
992
+ await trx.updateTable("inbox").set({
993
+ status: "done",
994
+ doneAt: endedAt
995
+ }).where("ticketId", "=", id).where("kind", "=", "ask").where("status", "in", ["pending", "stalled"]).execute();
996
+ });
997
+ }
998
+ async setPullRequest(id, prUrl, prState, ciState) {
999
+ await this.db.updateTable("ticket").set({
1000
+ prUrl,
1001
+ prState,
1002
+ ciState
1003
+ }).where("id", "=", id).execute();
1004
+ }
1005
+ async setPaused(id, paused, updatedAt) {
1006
+ await this.db.updateTable("ticket").set({
1007
+ paused: paused ? 1 : 0,
1008
+ updatedAt
1009
+ }).where("id", "=", id).execute();
1010
+ }
1011
+ async setPrepareError(id, prepareError, updatedAt) {
1012
+ await this.db.updateTable("ticket").set({
1013
+ prepareError,
1014
+ updatedAt
1015
+ }).where("id", "=", id).execute();
1016
+ }
1017
+ async save(id, patch) {
1018
+ await this.db.updateTable("ticket").set(patch).where("id", "=", id).execute();
1019
+ }
1020
+ async findById(id) {
1021
+ return this.db.selectFrom("ticket").selectAll().where("id", "=", id).executeTakeFirst();
1022
+ }
1023
+ async listRecent(limit = 100) {
1024
+ return this.db.selectFrom("ticket").selectAll().orderBy("createdAt", "desc").orderBy("id").limit(Math.max(1, Math.min(1e3, limit))).execute();
1025
+ }
1026
+ findManyQuery() {
1027
+ return this.db.selectFrom("ticket").selectAll().orderBy("createdAt", "desc").orderBy("id");
1028
+ }
1029
+ async findManyPage(page = 1, pageSize = 8) {
1030
+ const size = Math.max(1, Math.min(100, pageSize));
1031
+ const offset = (Math.max(1, page) - 1) * size;
1032
+ const base = this.findManyQuery();
1033
+ const [counted, data] = await Promise.all([base.clearSelect().select(this.db.fn.count("ticket.id").as("count")).executeTakeFirst(), base.limit(size).offset(offset).execute()]);
1034
+ return {
1035
+ data,
1036
+ total: Number(counted?.count ?? 0)
1037
+ };
1038
+ }
1039
+ /** 全量票,供统计类接口使用;不受分页上限影响。 */
1040
+ async listAll() {
1041
+ return this.findManyQuery().execute();
1042
+ }
1043
+ async listFiltered(filters = {}) {
1044
+ let query = this.db.selectFrom("ticket").selectAll("ticket").select((eb) => eb.exists(eb.selectFrom("inbox").select("id").whereRef("inbox.ticketId", "=", "ticket.id").where("kind", "=", "ask").where("inbox.status", "=", "pending")).as("attention"));
1045
+ if (filters.projectId) query = query.where("ticket.projectId", "=", filters.projectId);
1046
+ if (filters.status) query = query.where("ticket.status", "=", filters.status);
1047
+ else query = query.where("ticket.status", "not in", ["done", "cancelled"]);
1048
+ if (filters.attentionOnly) query = query.where((eb) => eb.exists(eb.selectFrom("inbox").select("id").whereRef("inbox.ticketId", "=", "ticket.id").where("kind", "=", "ask").where("inbox.status", "=", "pending")));
1049
+ if (filters.supervisorId) query = query.where((eb) => eb.exists(eb.selectFrom("supervisor_ticket").select("ticketId").whereRef("supervisor_ticket.ticketId", "=", "ticket.id").where("supervisorId", "=", filters.supervisorId)));
1050
+ return query.orderBy("ticket.createdAt").orderBy("ticket.id").execute();
1051
+ }
1052
+ async createWithThreads(projectId, title, threadIds, description) {
1053
+ if (!threadIds.length) throw new Error("至少需要一条来源话题");
1054
+ const operation = creation.then(() => this.db.transaction().execute(async (trx) => {
1055
+ if (!await trx.selectFrom("project").selectAll().where("id", "=", projectId).executeTakeFirst()) throw new Error("项目不存在");
1056
+ const ids = [...new Set(threadIds)];
1057
+ const threads = await trx.selectFrom("thread").selectAll().where("id", "in", ids).execute();
1058
+ if (threads.length !== ids.length) throw new Error("来源话题不存在");
1059
+ const duplicate = await trx.selectFrom("ticket_thread").innerJoin("ticket", "ticket.id", "ticket_thread.ticketId").select("ticket_thread.ticketId").where("ticket_thread.threadId", "in", ids).where("ticket.projectId", "=", projectId).executeTakeFirst();
1060
+ if (duplicate) throw new Error(`来源话题已关联工单:${duplicate.ticketId}`);
1061
+ const now = (/* @__PURE__ */ new Date()).toISOString();
1062
+ let sequence = (await trx.selectFrom("ticket").select("id").execute()).reduce((max, row) => {
1063
+ const match = /^T-(\d+)$/.exec(row.id);
1064
+ return match ? Math.max(max, Number(match[1])) : max;
1065
+ }, 0);
1066
+ let id = `T-${String(sequence + 1).padStart(3, "0")}`;
1067
+ while (await trx.selectFrom("ticket").select("id").where("id", "=", id).executeTakeFirst()) {
1068
+ sequence++;
1069
+ id = `T-${String(sequence + 1).padStart(3, "0")}`;
1070
+ }
1071
+ const row = {
1072
+ id,
1073
+ projectId,
1074
+ channelId: threads.find((row) => row.id === ids[0]).channelId,
1075
+ title,
1076
+ description: description ?? null,
1077
+ status: "waiting",
1078
+ createdAt: now,
1079
+ updatedAt: now,
1080
+ startedAt: null,
1081
+ endedAt: null,
1082
+ prUrl: null,
1083
+ prState: null,
1084
+ ciState: null,
1085
+ prepareError: null
1086
+ };
1087
+ await trx.insertInto("ticket").values(row).execute();
1088
+ await trx.updateTable("thread").set({
1089
+ projectId,
1090
+ triage: "claimed",
1091
+ triagedAt: now
1092
+ }).where("id", "in", ids).where("triage", "=", "pending").execute();
1093
+ for (const [index, threadId] of ids.entries()) await trx.insertInto("ticket_thread").values({
1094
+ ticketId: id,
1095
+ threadId,
1096
+ createdAt: new Date(Date.parse(now) + index).toISOString()
1097
+ }).execute();
1098
+ return await new Ticket(trx).findById(id);
1099
+ }));
1100
+ creation = operation.catch(() => void 0);
1101
+ return operation;
1102
+ }
1103
+ async requireOpen(id, projectId) {
1104
+ const row = await this.findById(id);
1105
+ if (!row || projectId !== void 0 && row.projectId !== projectId) throw new Error("工单不存在或不属于当前项目");
1106
+ if (row.status === "done" || row.status === "cancelled") throw new Error("工单已结束");
1107
+ return row;
1108
+ }
1109
+ async reopen(id, updatedAt) {
1110
+ const result = await this.db.updateTable("ticket").set({
1111
+ status: "waiting",
1112
+ endedAt: null,
1113
+ updatedAt
1114
+ }).where("id", "=", id).where("status", "in", ["done", "cancelled"]).executeTakeFirst();
1115
+ return Number(result.numUpdatedRows ?? 0) > 0;
1116
+ }
1117
+ async closeThread(threadId, outcome, at, branch) {
1118
+ const thread = await this.db.selectFrom("thread").selectAll().where("id", "=", threadId).executeTakeFirst();
1119
+ if (!thread?.url || thread.kind !== "pull") return [];
1120
+ await this.threadClosed(thread, outcome, at);
1121
+ const ended = [];
1122
+ for (const { ticketId } of await this.db.selectFrom("ticket_thread").select("ticketId").where("threadId", "=", threadId).orderBy("createdAt").execute()) {
1123
+ const row = await this.findById(ticketId);
1124
+ if (!row || CLOSED_STATUS.includes(row.status)) continue;
1125
+ const owns = row.prUrl === thread.url || row.prUrl === null && !!branch && (await this.latestWorker(ticketId))?.branch === branch;
1126
+ if (!owns && row.prUrl) continue;
1127
+ if (owns) await this.setPullRequest(ticketId, thread.url, outcome, row.ciState);
1128
+ const ticket = await this.findById(ticketId);
1129
+ const closed = await this.followsDone(ticket);
1130
+ if (!closed || await this.unfinished(ticketId, at)) continue;
1131
+ await this.end(ticket, closed.outcome, closed.at);
1132
+ ended.push(ticketId);
1133
+ }
1134
+ return ended;
1135
+ }
1136
+ async endOnReport(ticketId, at) {
1137
+ const ticket = await this.findById(ticketId);
1138
+ if (!ticket || CLOSED_STATUS.includes(ticket.status)) return false;
1139
+ const closed = await this.followsDone(ticket);
1140
+ if (!closed) return false;
1141
+ await this.end(ticket, closed.outcome, at);
1142
+ return true;
1143
+ }
1144
+ async end(ticket, outcome, at) {
1145
+ await this.finish(ticket.id, "done", at, (/* @__PURE__ */ new Date()).toISOString());
1146
+ const message = `${ticket.id} 的变更请求已${outcome === "merged" ? "合并" : "关闭"}:${ticket.prUrl ?? ticket.id}`;
1147
+ for (const type of ["project", "main"]) await new Inbox(this.db).enqueue({
1148
+ id: `supermesh:${outcome}:${ticket.id}:${type}`,
1149
+ type,
1150
+ origin: "system",
1151
+ kind: "notice",
1152
+ projectId: ticket.projectId,
1153
+ ticketId: ticket.id,
1154
+ title: outcome === "merged" ? "PR merged" : "PR closed",
1155
+ message
1156
+ });
1157
+ }
1158
+ async threadClosed(thread, outcome, at) {
1159
+ const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
1160
+ const value = JSON.stringify({
1161
+ at,
1162
+ outcome
1163
+ });
1164
+ await this.db.insertInto("source_state").values({
1165
+ channelId: thread.channelId,
1166
+ name: closedName(thread.id),
1167
+ value,
1168
+ updatedAt
1169
+ }).onConflict((oc) => oc.columns(["channelId", "name"]).doUpdateSet({
1170
+ value,
1171
+ updatedAt
1172
+ })).execute();
1173
+ }
1174
+ async followsDone(ticket) {
1175
+ const threads = await this.pullThreads(ticket.id);
1176
+ const own = threads.filter((thread) => thread.url === ticket.prUrl);
1177
+ const counted = own.length ? own : threads;
1178
+ if (!counted.length) return void 0;
1179
+ const closes = [];
1180
+ for (const thread of counted) {
1181
+ const closed = await this.threadClosedAt(thread);
1182
+ if (!closed) return void 0;
1183
+ closes.push(closed);
1184
+ }
1185
+ return closes.sort((left, right) => left.at.localeCompare(right.at)).at(-1);
1186
+ }
1187
+ async threadClosedAt(thread) {
1188
+ const row = await this.db.selectFrom("source_state").select("value").where("channelId", "=", thread.channelId).where("name", "=", closedName(thread.id)).executeTakeFirst();
1189
+ return row ? JSON.parse(row.value) : void 0;
1190
+ }
1191
+ async pullThreads(ticketId) {
1192
+ return this.db.selectFrom("ticket_thread").innerJoin("thread", "thread.id", "ticket_thread.threadId").selectAll("thread").where("ticket_thread.ticketId", "=", ticketId).where("thread.kind", "=", "pull").orderBy("ticket_thread.createdAt").execute();
1193
+ }
1194
+ async unfinished(ticketId, at) {
1195
+ const worker = await this.latestWorker(ticketId);
1196
+ if (!worker || !((worker.startedAt ?? worker.createdAt) > at)) return false;
1197
+ return !["ready", "dropped"].includes(worker.reportState ?? "");
1198
+ }
1199
+ async latestWorker(ticketId) {
1200
+ return this.db.selectFrom("worker").selectAll().where("ticketId", "=", ticketId).orderBy("createdAt", "desc").orderBy("id", "desc").executeTakeFirst();
1201
+ }
1202
+ async setPausedIfOpen(id, paused, updatedAt) {
1203
+ return this.db.updateTable("ticket").set({
1204
+ paused: paused ? 1 : 0,
1205
+ updatedAt
1206
+ }).where("id", "=", id).where("status", "not in", ["done", "cancelled"]).returningAll().executeTakeFirst();
1207
+ }
1208
+ };
1209
+ // src/database/models/ticket-link.ts
1210
+ var TicketLink = class {
1211
+ db;
1212
+ constructor(db) {
1213
+ this.db = db;
1214
+ }
1215
+ async listByTicket(ticketId) {
1216
+ return this.db.selectFrom("ticket_link").selectAll().where("ticketId", "=", ticketId).orderBy("kind").orderBy("relatedId").execute();
1217
+ }
1218
+ async listByRelated(relatedId) {
1219
+ return this.db.selectFrom("ticket_link").selectAll().where("relatedId", "=", relatedId).orderBy("kind").orderBy("ticketId").execute();
1220
+ }
1221
+ async listDependsOn(ticketId) {
1222
+ return this.db.selectFrom("ticket_link").selectAll().where("ticketId", "=", ticketId).where("kind", "=", "depends").execute();
1223
+ }
1224
+ async listDependents(relatedId) {
1225
+ return this.db.selectFrom("ticket_link").selectAll().where("relatedId", "=", relatedId).where("kind", "=", "depends").execute();
1226
+ }
1227
+ async link(ticketId, relatedId, kind, createdAt) {
1228
+ await this.db.insertInto("ticket_link").values({
1229
+ ticketId,
1230
+ relatedId,
1231
+ kind,
1232
+ createdAt
1233
+ }).onConflict((oc) => oc.columns([
1234
+ "ticketId",
1235
+ "relatedId",
1236
+ "kind"
1237
+ ]).doNothing()).execute();
1238
+ }
1239
+ async unlink(ticketId, relatedId, kind) {
1240
+ await this.db.deleteFrom("ticket_link").where("ticketId", "=", ticketId).where("relatedId", "=", relatedId).where("kind", "=", kind).execute();
1241
+ }
1242
+ async listAll() {
1243
+ return this.db.selectFrom("ticket_link").selectAll().orderBy("createdAt").execute();
1244
+ }
1245
+ };
1246
+ // src/database/models/ticket-thread.ts
1247
+ var TicketThread = class {
1248
+ db;
1249
+ constructor(db) {
1250
+ this.db = db;
1251
+ }
1252
+ async listByTicket(ticketId) {
1253
+ return this.db.selectFrom("ticket_thread").selectAll().where("ticketId", "=", ticketId).orderBy("createdAt").execute();
1254
+ }
1255
+ async listByThread(threadId) {
1256
+ return this.db.selectFrom("ticket_thread").selectAll().where("threadId", "=", threadId).orderBy("createdAt").execute();
1257
+ }
1258
+ async listTicketIds(threadId) {
1259
+ return (await this.db.selectFrom("ticket_thread").select("ticketId").where("threadId", "=", threadId).orderBy("createdAt").execute()).map((row) => row.ticketId);
1260
+ }
1261
+ async link(ticketId, threadId, createdAt) {
1262
+ const result = await this.db.insertInto("ticket_thread").values({
1263
+ ticketId,
1264
+ threadId,
1265
+ createdAt
1266
+ }).onConflict((oc) => oc.columns(["ticketId", "threadId"]).doNothing()).executeTakeFirst();
1267
+ return Number(result.numInsertedOrUpdatedRows) > 0;
1268
+ }
1269
+ async unlink(ticketId, threadId) {
1270
+ await this.db.deleteFrom("ticket_thread").where("ticketId", "=", ticketId).where("threadId", "=", threadId).execute();
1271
+ }
1272
+ async listAll() {
1273
+ return this.db.selectFrom("ticket_thread").selectAll().orderBy("createdAt").execute();
1274
+ }
1275
+ };
1276
+ // src/database/models/trigger.ts
1277
+ var Trigger = class extends Model {
1278
+ constructor(db) {
1279
+ super(db, "trigger", "id");
1280
+ }
1281
+ async listByThread(threadId, limit = 50) {
1282
+ return this.db.selectFrom("trigger").selectAll().where("threadId", "=", threadId).orderBy("at", "desc").orderBy("id", "desc").limit(limit).execute();
1283
+ }
1284
+ async lastByThread(threadId) {
1285
+ return this.db.selectFrom("trigger").selectAll().where("threadId", "=", threadId).orderBy("at", "desc").orderBy("id", "desc").executeTakeFirst();
1286
+ }
1287
+ async listByChannelSince(channelId, since) {
1288
+ return this.db.selectFrom("trigger").selectAll().where("channelId", "=", channelId).where("at", ">", since).orderBy("at").execute();
1289
+ }
1290
+ async listByRef(channelId, ref) {
1291
+ return this.db.selectFrom("trigger").selectAll().where("channelId", "=", channelId).where("ref", "=", ref).orderBy("at", "desc").execute();
1292
+ }
1293
+ async exists(id) {
1294
+ return await this.db.selectFrom("trigger").select("id").where("id", "=", id).executeTakeFirst() !== void 0;
1295
+ }
1296
+ async findById(id) {
1297
+ return this.db.selectFrom("trigger").selectAll().where("id", "=", id).executeTakeFirst();
1298
+ }
1299
+ async findLatestByThread(threadId) {
1300
+ return this.db.selectFrom("trigger").selectAll().where("threadId", "=", threadId).orderBy("at", "desc").orderBy("id", "desc").executeTakeFirst();
1301
+ }
1302
+ async listRecent(limit = 100) {
1303
+ return this.db.selectFrom("trigger").selectAll().orderBy("at", "desc").orderBy("id").limit(Math.max(1, Math.min(1e3, limit))).execute();
1304
+ }
1305
+ async ingest(value) {
1306
+ await this.db.insertInto("trigger").values(value).onConflict((oc) => oc.column("id").doNothing()).execute();
1307
+ return await this.findById(value.id);
1308
+ }
1309
+ };
1310
+ // src/database/models/worker.ts
1311
+ var Worker = class Worker extends Model {
1312
+ constructor(db) {
1313
+ super(db, "worker", "id");
1314
+ }
1315
+ async listByTicket(ticketId) {
1316
+ return this.db.selectFrom("worker").selectAll().where("ticketId", "=", ticketId).orderBy("createdAt").execute();
1317
+ }
1318
+ async listRunning() {
1319
+ return this.db.selectFrom("worker").selectAll().where("status", "=", "running").orderBy("startedAt").execute();
1320
+ }
1321
+ async findRunningByBranch(branch) {
1322
+ return this.db.selectFrom("worker").selectAll().where("branch", "=", branch).where("status", "=", "running").executeTakeFirst();
1323
+ }
1324
+ async findByBranch(branch) {
1325
+ return this.db.selectFrom("worker").selectAll().where("branch", "=", branch).orderBy("createdAt", "desc").orderBy("id", "desc").executeTakeFirst();
1326
+ }
1327
+ async start(id, startedAt) {
1328
+ await this.db.updateTable("worker").set((eb) => ({
1329
+ status: "running",
1330
+ startedAt: eb.fn.coalesce("startedAt", eb.val(startedAt))
1331
+ })).where("id", "=", id).execute();
1332
+ }
1333
+ async end(id, endedReason, endedAt) {
1334
+ await this.db.updateTable("worker").set({
1335
+ status: "ended",
1336
+ endedReason,
1337
+ endedAt
1338
+ }).where("id", "=", id).execute();
1339
+ }
1340
+ async setReport(id, reportState, report, reportAt) {
1341
+ await this.db.updateTable("worker").set({
1342
+ reportState,
1343
+ report,
1344
+ reportAt
1345
+ }).where("id", "=", id).execute();
1346
+ }
1347
+ async setBackgroundUntil(id, backgroundUntil) {
1348
+ await this.db.updateTable("worker").set({ backgroundUntil }).where("id", "=", id).execute();
1349
+ }
1350
+ async setRecoveryNote(id, recoveryNote) {
1351
+ await this.db.updateTable("worker").set({ recoveryNote }).where("id", "=", id).execute();
1352
+ }
1353
+ async findById(id) {
1354
+ return this.db.selectFrom("worker").selectAll().where("id", "=", id).executeTakeFirst();
1355
+ }
1356
+ async listRecent(limit = 100) {
1357
+ return this.db.selectFrom("worker").selectAll().orderBy("createdAt", "desc").orderBy("id").limit(Math.max(1, Math.min(1e3, limit))).execute();
1358
+ }
1359
+ async listQueued() {
1360
+ return this.db.selectFrom("worker").selectAll().where("status", "=", "queued").orderBy("createdAt").execute();
1361
+ }
1362
+ /**
1363
+ * 把票放进派工队列。`fresh` 为真时新建一个 worker 记录(沿用原分支与 worktree),
1364
+ * 用于旧会话已被归档、无法再激活的情形 —— 那时复用同一个 id 只会一直失败。
1365
+ */
1366
+ async queue(ticketId, projectId, branch, fresh = false) {
1367
+ if (branch && branch.split("/").at(-1) !== ticketId) throw new Error("分支末段必须是任务号");
1368
+ return this.db.transaction().execute(async (trx) => {
1369
+ const ticket = await trx.selectFrom("ticket").selectAll().where("id", "=", ticketId).where("projectId", "=", projectId).executeTakeFirst();
1370
+ if (!ticket || ticket.status === "done" || ticket.status === "cancelled") throw new Error("工单不存在、已结束或不属于当前项目");
1371
+ if (ticket.paused) throw new Error("工单已暂停");
1372
+ if (!(await trx.selectFrom("project").selectAll().where("id", "=", projectId).executeTakeFirst())?.enabled) throw new Error("项目未启用");
1373
+ const depends = await trx.selectFrom("ticket_link").select("relatedId").where("ticketId", "=", ticketId).where("kind", "=", "depends").execute();
1374
+ for (const link of depends) {
1375
+ const related = await trx.selectFrom("ticket").select(["id", "status"]).where("id", "=", link.relatedId).executeTakeFirst();
1376
+ if (related && related.status !== "done" && related.status !== "cancelled") throw new Error(`依赖的 ${related.id} 还没完成`);
1377
+ }
1378
+ const existing = await trx.selectFrom("worker").selectAll().where("ticketId", "=", ticketId).where("status", "!=", "ended").executeTakeFirst();
1379
+ if (existing) return existing;
1380
+ const previous = await trx.selectFrom("worker").selectAll().where("ticketId", "=", ticketId).orderBy("createdAt", "desc").orderBy("id", "desc").executeTakeFirst();
1381
+ const now = (/* @__PURE__ */ new Date()).toISOString();
1382
+ if (previous && !fresh) {
1383
+ await trx.updateTable("worker").set({
1384
+ status: "queued",
1385
+ startedAt: null,
1386
+ endedAt: null,
1387
+ endedReason: null,
1388
+ reportState: null,
1389
+ report: null,
1390
+ reportAt: null,
1391
+ backgroundUntil: null,
1392
+ recoveryNote: null,
1393
+ branch: branch ?? previous.branch
1394
+ }).where("id", "=", previous.id).execute();
1395
+ await trx.updateTable("ticket").set({
1396
+ status: "queued",
1397
+ updatedAt: now
1398
+ }).where("id", "=", ticketId).execute();
1399
+ return await new Worker(trx).findById(previous.id);
1400
+ }
1401
+ const id = randomUUID();
1402
+ await trx.insertInto("worker").values({
1403
+ id,
1404
+ ticketId,
1405
+ status: "queued",
1406
+ createdAt: now,
1407
+ startedAt: null,
1408
+ endedAt: null,
1409
+ title: ticket.title,
1410
+ endedReason: null,
1411
+ branch: branch ?? previous?.branch ?? `dsh/${ticketId}`,
1412
+ worktree: previous?.worktree ?? null,
1413
+ reportState: null,
1414
+ report: null,
1415
+ reportAt: null,
1416
+ backgroundUntil: null,
1417
+ recoveryNote: null
1418
+ }).execute();
1419
+ await trx.updateTable("ticket").set({
1420
+ status: "queued",
1421
+ updatedAt: now
1422
+ }).where("id", "=", ticketId).execute();
1423
+ return await new Worker(trx).findById(id);
1424
+ });
1425
+ }
1426
+ async requeue(id) {
1427
+ await this.db.updateTable("worker").set({
1428
+ status: "queued",
1429
+ startedAt: null,
1430
+ endedAt: null,
1431
+ endedReason: null,
1432
+ reportState: null,
1433
+ report: null,
1434
+ reportAt: null,
1435
+ backgroundUntil: null
1436
+ }).where("id", "=", id).execute();
1437
+ }
1438
+ async reportProgress(id, reportState, report) {
1439
+ return this.db.transaction().execute(async (trx) => {
1440
+ const worker = await new Worker(trx).findById(id);
1441
+ if (!worker || worker.status === "ended") throw new Error("Worker 已结束或不存在");
1442
+ const ticket = await trx.selectFrom("ticket").selectAll().where("id", "=", worker.ticketId).executeTakeFirst();
1443
+ if (!ticket || ticket.status === "done" || ticket.status === "cancelled") throw new Error("工单已结束或不存在");
1444
+ const now = (/* @__PURE__ */ new Date()).toISOString();
1445
+ await new Worker(trx).setReport(id, reportState, report, now);
1446
+ const message = await new Inbox(trx).enqueue({
1447
+ type: "project",
1448
+ projectId: ticket.projectId,
1449
+ origin: "worker",
1450
+ kind: "ticket",
1451
+ ticketId: ticket.id,
1452
+ workerId: id,
1453
+ title: reportState,
1454
+ message: report
1455
+ });
1456
+ if (reportState === "ready") await new Ticket(trx).endOnReport(ticket.id, now);
1457
+ return message;
1458
+ });
1459
+ }
1460
+ };
1461
+ // src/database/utils/migration.ts
1462
+ /**
1463
+ * 把 SQL 文本包成 Kysely 迁移。
1464
+ *
1465
+ * 两个坑都在这里绕开:
1466
+ * 1. Kysely 的 SQLite 适配器用 `prepare()` 执行,多语句**不报错、只跑第一条**,
1467
+ * 所以改用 `DatabaseSync.exec()`,让 SQLite 自己解析整段脚本。
1468
+ * 2. 适配器的 `supportsTransactionalDdl` 为 false,迁移不会被自动包进事务,
1469
+ * 所以这里手动 BEGIN/COMMIT,一个迁移文件要么整篇生效、要么整篇回滚。
1470
+ *
1471
+ * 没有用 `kysely-migrate-sql`:它 0.2.0 从 `kysely` 根导入 `Migrator`,
1472
+ * 而 Kysely 0.29 起该导出只在 `kysely/migration`,模块加载即抛
1473
+ * `SyntaxError: does not provide an export named 'Migrator'`。
1474
+ */
1475
+ var MigrationProvider = class {
1476
+ database;
1477
+ migrations;
1478
+ /**
1479
+ * @param database - 执行迁移的连接;必须与实际使用的同一个实例。
1480
+ * @param migrations - 迁移名到 SQL 全文的映射,按名字排序执行。
1481
+ */
1482
+ constructor(database, migrations) {
1483
+ this.database = database;
1484
+ this.migrations = migrations;
1485
+ }
1486
+ async getMigrations() {
1487
+ return Object.fromEntries(Object.entries(this.migrations).map(([name, sql]) => [name, { up: async () => {
1488
+ const foreignKeys = this.database.prepare("PRAGMA foreign_keys").get()?.foreign_keys;
1489
+ this.database.exec("PRAGMA foreign_keys=OFF");
1490
+ this.database.exec("BEGIN");
1491
+ try {
1492
+ this.database.exec(sql);
1493
+ if (this.database.prepare("PRAGMA foreign_key_check").all().length) throw new Error(`Migration violates foreign key constraints: ${name}`);
1494
+ this.database.exec("COMMIT");
1495
+ } catch (error) {
1496
+ this.database.exec("ROLLBACK");
1497
+ throw error;
1498
+ } finally {
1499
+ this.database.exec(foreignKeys ? "PRAGMA foreign_keys=ON" : "PRAGMA foreign_keys=OFF");
1500
+ }
1501
+ } }]));
1502
+ }
1503
+ };
1504
+ // src/database/index.ts
1505
+ const worker$1 = process.env.VITEST_POOL_ID ?? process.env.VITEST_WORKER_ID;
1506
+ const file = worker$1 ? `data.worker-${worker$1}.db` : "data.db";
1507
+ const database = new DatabaseSync(file);
1508
+ const connection = new Kysely({ dialect: new NodeSqliteDialect({ database }) });
1509
+ const db = Object.assign(connection, {
1510
+ channel: new Channel(connection),
1511
+ channelAccount: new ChannelAccount(connection),
1512
+ ciWatch: new CiWatch(connection),
1513
+ inbox: new Inbox(connection),
1514
+ project: new Project(connection),
1515
+ sourceState: new SourceState(connection),
1516
+ supervisor: new Supervisor(connection),
1517
+ supervisorTicket: new SupervisorTicket(connection),
1518
+ thread: new Thread(connection),
1519
+ ticket: new Ticket(connection),
1520
+ ticketLink: new TicketLink(connection),
1521
+ ticketThread: new TicketThread(connection),
1522
+ trigger: new Trigger(connection),
1523
+ worker: new Worker(connection)
1524
+ });
1525
+ const { error } = await new Migrator({
1526
+ db,
1527
+ provider: new MigrationProvider(database, migrations)
1528
+ }).migrateToLatest();
1529
+ if (error) throw error;
1530
+ // src/channel/_shared/proxy.ts
1531
+ async function channelProxyEnvironment(url, inherited) {
1532
+ const env = { ...inherited };
1533
+ const overlay = proxyEnvironmentForChild();
1534
+ const explicit = Object.entries(inherited).some(([name, value]) => /^(?:https?|all)_proxy$/i.test(name) && Boolean(value?.trim()));
1535
+ for (const [name, value] of Object.entries(overlay)) if (value === void 0) delete env[name];
1536
+ else env[name] = value;
1537
+ if (process.platform !== "win32" || explicit || Object.keys(overlay).length) return env;
1538
+ const settings = await new Promise((resolve) => {
1539
+ execFile("reg.exe", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"], {
1540
+ windowsHide: true,
1541
+ timeout: 3e3,
1542
+ maxBuffer: 65536
1543
+ }, (error, stdout) => resolve(error ? "" : stdout));
1544
+ });
1545
+ if (!/^\s*ProxyEnable\s+REG_DWORD\s+0x0*1\s*$/im.test(settings)) return env;
1546
+ if ((/^\s*ProxyOverride\s+REG_SZ\s+(\S.*)$/im.exec(settings)?.[1].trim())?.split(";").some((pattern) => bypasses(url.hostname, pattern.trim()))) return env;
1547
+ const raw = /^\s*ProxyServer\s+REG_SZ\s+(\S.*)$/im.exec(settings)?.[1].trim();
1548
+ if (!raw) return env;
1549
+ const selected = raw.includes("=") ? raw.split(";").map((part) => part.trim()).find((part) => part.toLowerCase().startsWith(`${url.protocol.slice(0, -1)}=`))?.slice(url.protocol.length) : raw;
1550
+ if (!selected) return env;
1551
+ try {
1552
+ const proxy = new URL(selected.includes("://") ? selected : `http://${selected}`);
1553
+ if (!["http:", "https:"].includes(proxy.protocol) || !proxy.hostname || proxy.pathname !== "/" || proxy.search || proxy.hash) return env;
1554
+ env.HTTP_PROXY = proxy.href;
1555
+ env.HTTPS_PROXY = proxy.href;
1556
+ delete env.http_proxy;
1557
+ delete env.https_proxy;
1558
+ } catch {}
1559
+ return env;
1560
+ }
1561
+ function bypasses(hostname, pattern) {
1562
+ if (!pattern) return false;
1563
+ if (pattern.toLowerCase() === "<local>") return !hostname.includes(".") && !hostname.includes(":");
1564
+ const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replaceAll("*", ".*");
1565
+ return new RegExp(`^${escaped}$`, "i").test(hostname);
1566
+ }
1567
+ // src/server/routes/agent.model.catalog.get.ts
1568
+ var agent_model_catalog_get_default = defineHandler(async () => {
1569
+ return getServerContext(server).sessionController.modelCatalog();
1570
+ });
1571
+ const DSH_PLUGIN_HOME = `${process.env.DSH_HOME ?? join(homedir(), ".dsh")}/.supermesh`;
1572
+ // src/storage/index.ts
1573
+ const storage = createStorage({ driver: fs({
1574
+ atomic: true,
1575
+ base: DSH_PLUGIN_HOME
1576
+ }) });
1577
+ // src/utils/service.ts
1578
+ function defineService(service) {
1579
+ return service;
1580
+ }
1581
+ // src/service/setting.ts
1582
+ const defaults = {
1583
+ models: {
1584
+ main: null,
1585
+ manager: null,
1586
+ project: null,
1587
+ worker: null,
1588
+ supervisor: null
1589
+ },
1590
+ administrators: [],
1591
+ maxWorkers: 10,
1592
+ backgroundLimitMinutes: 30,
1593
+ autoMerge: false,
1594
+ autoMergeMaxLines: 200,
1595
+ autoArchiveWorkers: false,
1596
+ deliveryMaxAttempts: 3,
1597
+ deliveryRetryCeilingSeconds: 60,
1598
+ updatedAt: ""
1599
+ };
1600
+ const limits = {
1601
+ maxWorkers: [1, 16],
1602
+ backgroundLimitMinutes: [1, 1440],
1603
+ autoMergeMaxLines: [1, 1e4],
1604
+ deliveryMaxAttempts: [1, 20],
1605
+ deliveryRetryCeilingSeconds: [2, 3600]
1606
+ };
1607
+ const roles$1 = [
1608
+ "main",
1609
+ "manager",
1610
+ "project",
1611
+ "worker",
1612
+ "supervisor"
1613
+ ];
1614
+ let writing$2 = Promise.resolve();
1615
+ const setting = defineService({
1616
+ async load() {
1617
+ const value = await storage.getItem("setting.json");
1618
+ if (value === null) return {
1619
+ ...defaults,
1620
+ administrators: []
1621
+ };
1622
+ if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid_stored_settings");
1623
+ const { updatedAt, ...patch } = value;
1624
+ if (updatedAt !== void 0 && typeof updatedAt !== "string" || !valid(patch, true)) throw new Error("invalid_stored_settings");
1625
+ return {
1626
+ ...defaults,
1627
+ ...patch,
1628
+ administrators: normalizeAdministrators(patch.administrators ?? []),
1629
+ models: normalizeModels(patch.models),
1630
+ ...updatedAt === void 0 ? {} : { updatedAt }
1631
+ };
1632
+ },
1633
+ save(patch) {
1634
+ if (!valid(patch)) return Promise.reject(/* @__PURE__ */ new TypeError("invalid_config"));
1635
+ const updates = {
1636
+ ...patch,
1637
+ ...patch.administrators === void 0 ? {} : { administrators: normalizeAdministrators(patch.administrators) },
1638
+ ...patch.models === void 0 ? {} : { models: normalizeModels(patch.models) }
1639
+ };
1640
+ const operation = writing$2.then(async () => {
1641
+ const next = {
1642
+ ...await setting.load(),
1643
+ ...updates,
1644
+ updatedAt: (/* @__PURE__ */ new Date()).toISOString()
1645
+ };
1646
+ await storage.setItem("setting.json", next);
1647
+ return next;
1648
+ });
1649
+ writing$2 = operation.then(() => void 0, () => void 0);
1650
+ return operation;
1651
+ }
1652
+ });
1653
+ function valid(value, allowEmpty = false) {
1654
+ if (!value || typeof value !== "object" || Array.isArray(value)) return false;
1655
+ const entries = Object.entries(value);
1656
+ if (!allowEmpty && entries.length === 0) return false;
1657
+ return entries.every(([key, entry]) => {
1658
+ if (key === "administrators") return Array.isArray(entry) && entry.length <= 100 && entry.every((name) => typeof name === "string" && /^[a-z0-9][\w.-]{0,254}$/i.test(name.trim()));
1659
+ if (key === "autoMerge" || key === "autoArchiveWorkers") return typeof entry === "boolean";
1660
+ if (key === "models") return validModels(entry);
1661
+ if (!Object.hasOwn(limits, key)) return false;
1662
+ const [min, max] = limits[key];
1663
+ return typeof entry === "number" && Number.isInteger(entry) && entry >= min && entry <= max;
1664
+ });
1665
+ }
1666
+ function validModels(value) {
1667
+ if (!value || typeof value !== "object" || Array.isArray(value)) return false;
1668
+ const entries = Object.entries(value);
1669
+ return entries.length > 0 && entries.every(([role, model]) => roles$1.includes(role) && validModel(model));
1670
+ }
1671
+ function validModel(value) {
1672
+ if (value === null) return true;
1673
+ if (!value || typeof value !== "object" || Array.isArray(value)) return false;
1674
+ const { provider, model, reasoningEffort } = value;
1675
+ return Object.keys(value).every((key) => key === "provider" || key === "model" || key === "reasoningEffort") && typeof provider === "string" && provider.trim().length > 0 && typeof model === "string" && model.trim().length > 0 && (reasoningEffort === void 0 || typeof reasoningEffort === "string" && reasoningEffort.trim().length > 0);
1676
+ }
1677
+ function normalizeModels(value) {
1678
+ const source = value ?? {};
1679
+ return Object.fromEntries(roles$1.map((role) => {
1680
+ const model = source[role];
1681
+ return [role, model ? {
1682
+ provider: model.provider,
1683
+ model: model.model,
1684
+ ...model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {}
1685
+ } : null];
1686
+ }));
1687
+ }
1688
+ function normalizeAdministrators(names) {
1689
+ const unique = /* @__PURE__ */ new Map();
1690
+ for (const entry of names) {
1691
+ const name = entry.trim();
1692
+ if (!unique.has(name.toLowerCase())) unique.set(name.toLowerCase(), name);
1693
+ }
1694
+ return [...unique.values()];
1695
+ }
1696
+ // src/server/routes/agent.model.get.ts
1697
+ var agent_model_get_default = defineHandler(async () => (await setting.load()).models);
1698
+ // src/service/role-model.ts
1699
+ const roleModel = defineService({
1700
+ async resolve(model) {
1701
+ const value = await getServerContext(server).llm.resolveCallConfig({
1702
+ provider: model.provider,
1703
+ model: model.model,
1704
+ ...model.reasoningEffort ? { reasoningEffort: ReasoningEffortId(model.reasoningEffort) } : {}
1705
+ });
1706
+ return {
1707
+ provider: value.provider,
1708
+ model: value.model,
1709
+ ...value.reasoningEffort ? { reasoningEffort: value.reasoningEffort } : {}
1710
+ };
1711
+ },
1712
+ async initialize(agent, model) {
1713
+ if (!model) return;
1714
+ if (agent.session.requestHeader() || agent.session.snapshotEvents().some((event) => event.type === "model/selection")) return;
1715
+ const ctx = getServerContext(server);
1716
+ const selected = await roleModel.resolve(model);
1717
+ agent.session.append("model/selection", selected);
1718
+ let initial = true;
1719
+ let assembled;
1720
+ agent.ctx.effect(() => {
1721
+ const disposers = [
1722
+ agent.ctx.on("system-prompt/assemble", async (_assembly, _context, next) => {
1723
+ const selection = initial ? selected : void 0;
1724
+ const result = await next();
1725
+ assembled = selection;
1726
+ return selection ? {
1727
+ ...result,
1728
+ variables: {
1729
+ ...result.variables,
1730
+ provider: selection.provider,
1731
+ model: selection.model
1732
+ }
1733
+ } : result;
1734
+ }, { prepend: true }),
1735
+ agent.ctx.on("agent/request", async (_payload, next) => {
1736
+ const result = await next();
1737
+ if (!assembled) return result;
1738
+ const { reasoningEffort: _inherited, ...rest } = result;
1739
+ return {
1740
+ ...rest,
1741
+ ...assembled
1742
+ };
1743
+ }, { prepend: true }),
1744
+ ctx.on("session/event", (session, event) => {
1745
+ if (session === agent.session && (event.type === "request/header" || event.type === "model/selection")) initial = false;
1746
+ })
1747
+ ];
1748
+ return () => disposers.forEach((dispose) => dispose());
1749
+ });
1750
+ await ctx.sessionPersistence.flush();
1751
+ }
1752
+ });
1753
+ // src/server/routes/agent.model.patch.ts
1754
+ const roles = [
1755
+ "main",
1756
+ "manager",
1757
+ "project",
1758
+ "worker",
1759
+ "supervisor"
1760
+ ];
1761
+ var agent_model_patch_default = defineHandler(async (event) => {
1762
+ const body = await readBody(event);
1763
+ if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => ![
1764
+ "role",
1765
+ "provider",
1766
+ "model",
1767
+ "reasoningEffort"
1768
+ ].includes(key)) || !roles.includes(body.role) || typeof body.provider !== "string" || typeof body.model !== "string" || body.reasoningEffort !== void 0 && typeof body.reasoningEffort !== "string") throw new HTTPError({
1769
+ status: 400,
1770
+ message: "invalid_agent_model"
1771
+ });
1772
+ const provider = body.provider.trim();
1773
+ const name = body.model.trim();
1774
+ const effort = body.reasoningEffort?.trim() ?? "";
1775
+ if ((provider || name || effort) && !(provider && name)) throw new HTTPError({
1776
+ status: 400,
1777
+ message: "invalid_agent_model"
1778
+ });
1779
+ const entry = provider && name ? {
1780
+ provider,
1781
+ model: name,
1782
+ ...effort ? { reasoningEffort: effort } : {}
1783
+ } : null;
1784
+ if (entry) try {
1785
+ await roleModel.resolve(entry);
1786
+ } catch (error) {
1787
+ throw new HTTPError({
1788
+ status: 400,
1789
+ message: `unresolved_agent_model: ${error instanceof Error ? error.message : String(error)}`
1790
+ });
1791
+ }
1792
+ const models = {
1793
+ ...(await setting.load()).models,
1794
+ [body.role]: entry
1795
+ };
1796
+ return (await setting.save({ models })).models;
1797
+ });
1798
+ // src/runtime/singlet.ts
1799
+ const pending = /* @__PURE__ */ new Map();
1800
+ /** 超过这个时长还占着 key 的,视为卡死:不再复用它的 Promise,改为重新执行。 */
1801
+ const STALE_MS = 12e4;
1802
+ function resolveKey(keyOrGen, args) {
1803
+ return typeof keyOrGen === "function" ? keyOrGen(...args) : keyOrGen;
1804
+ }
1805
+ /**
1806
+ * 【单飞原语】同一 key 正在执行时复用同一个 Promise,不排队、不阻塞调用方。
1807
+ *
1808
+ * 超过 `STALE_MS` 仍未结束的记录判定为卡死并让位:新调用重新执行,
1809
+ * 而不是继续等一个可能永不 settle 的 Promise。原任务之后才结束时,
1810
+ * 它的 settle 不会误删新记录(按记录身份比对)。
1811
+ *
1812
+ * @param keyOrGen 静态 key 或按入参生成 key 的函数
1813
+ * @param fn 需要单飞保护的异步函数
1814
+ *
1815
+ * @example
1816
+ * export const worker = defineService({
1817
+ * reconcile: singlet('worker:slots', async () => {
1818
+ * await db.worker.listRunning()
1819
+ * }),
1820
+ * process: singlet(id => `worker:process:${id}`, async (id: string) => {
1821
+ * await runFor(id)
1822
+ * }),
1823
+ * })
1824
+ */
1825
+ function singlet(keyOrGen, fn) {
1826
+ return ((...args) => {
1827
+ const key = resolveKey(keyOrGen, args);
1828
+ const current = pending.get(key);
1829
+ if (current && Date.now() - current.startedAt < 12e4) return current.promise;
1830
+ const task = Promise.resolve().then(() => fn(...args));
1831
+ const record = {
1832
+ promise: task,
1833
+ startedAt: Date.now(),
1834
+ key
1835
+ };
1836
+ pending.set(key, record);
1837
+ const settle = () => {
1838
+ if (pending.get(key) === record) pending.delete(key);
1839
+ };
1840
+ task.then(settle, settle);
1841
+ return task;
1842
+ });
1843
+ }
1844
+ /** 立即执行一次,等价于 `singlet(key, fn)(...args)`,省掉尾随的调用括号。 */
1845
+ singlet.immediate = function immediate(keyOrGen, fn, ...args) {
1846
+ return singlet(keyOrGen, fn)(...args);
1847
+ };
1848
+ singlet.busy = function busy(key) {
1849
+ return key === void 0 ? pending.size > 0 : pending.has(key);
1850
+ };
1851
+ singlet.keys = function keys() {
1852
+ return [...pending.keys()];
1853
+ };
1854
+ /** 卡住超过 `STALE_MS` 的 key 与已运行时长,用于排查采集或投递停摆。 */
1855
+ singlet.stale = function stale() {
1856
+ const now = Date.now();
1857
+ return [...pending.values()].map((record) => ({
1858
+ key: record.key,
1859
+ runningMs: now - record.startedAt
1860
+ })).filter((record) => record.runningMs >= STALE_MS);
1861
+ };
1862
+ singlet.drain = async function drain() {
1863
+ while (pending.size) await Promise.allSettled([...pending.values()].map((record) => record.promise));
1864
+ };
1865
+ // src/service/session.ts
1866
+ const presets$1 = {
1867
+ main: "orchestrator",
1868
+ project: "manager",
1869
+ supervisor: "supervisor",
1870
+ worker: "worker"
1871
+ };
1872
+ const registered = /* @__PURE__ */ new Set();
1873
+ let controller$2 = new AbortController();
1874
+ let stopped$3 = false;
1875
+ const session = defineService({
1876
+ register(id) {
1877
+ registered.add(id);
1878
+ return () => {
1879
+ registered.delete(id);
1880
+ };
1881
+ },
1882
+ async attach(agent) {
1883
+ const ctx = getServerContext(server);
1884
+ const preset = ctx.agentPresets.composedPreset(agent.ctx);
1885
+ if (!preset || !registered.has(preset) || agent.session.header.origin === "subagent" || agent.session.header.parentSession || ctx.workspaceRegistry.archivedSessionIds.includes(agent.session.id)) return null;
1886
+ const role = Object.keys(presets$1).find((role) => presets$1[role] === preset);
1887
+ if (!role) return null;
1888
+ if (role === "main") {
1889
+ const current = await session.findMain();
1890
+ if (current && current !== agent.session.id) throw new Error("ambiguous_main_session");
1891
+ }
1892
+ await bindWorkspace(agent.session.id, agent.session.header.cwd);
1893
+ if (role === "main") await storage.setItem("orchestrator.id", agent.session.id);
1894
+ return role;
1895
+ },
1896
+ start() {
1897
+ if (singlet.busy("session:workspace")) throw new Error("session_busy");
1898
+ controller$2 = new AbortController();
1899
+ stopped$3 = false;
1900
+ return async () => {
1901
+ stopped$3 = true;
1902
+ controller$2.abort(/* @__PURE__ */ new Error("session_stopped"));
1903
+ await Promise.allSettled([singlet.drain()]);
1904
+ };
1905
+ },
1906
+ async resolve(id) {
1907
+ const ctx = getServerContext(server);
1908
+ const sid = SessionId(id);
1909
+ if (ctx.workspaceRegistry.archivedSessionIds.includes(sid)) return null;
1910
+ let header;
1911
+ let preset;
1912
+ try {
1913
+ const snapshot = await ctx.sessionQuery.readSession(sid);
1914
+ header = snapshot.session;
1915
+ preset = ctx.agentPresets.presetForSession(Session.create(sid, snapshot.events, snapshot.session));
1916
+ } catch (error) {
1917
+ if (error instanceof Error && "code" in error && error.code === "SESSION_QUERY_SESSION_NOT_FOUND") return null;
1918
+ throw error;
1919
+ }
1920
+ if (!preset || !registered.has(preset) || header.origin === "subagent" || header.parentSession) return null;
1921
+ const [worker, project, supervisor] = await Promise.all([
1922
+ db.worker.findById(id),
1923
+ db.project.findBySession(id),
1924
+ db.supervisor.findBySession(id)
1925
+ ]);
1926
+ if ([
1927
+ worker,
1928
+ project,
1929
+ supervisor
1930
+ ].filter(Boolean).length > 1) throw new Error("session_binding_conflict");
1931
+ if (worker) {
1932
+ const agent = ctx.agents.get(sid);
1933
+ if (preset !== presets$1.worker || !agent || ctx.agentPresets.composedPreset(agent.ctx) !== presets$1.worker) return null;
1934
+ const ticket = await db.ticket.findById(worker.ticketId);
1935
+ return ticket ? {
1936
+ role: "worker",
1937
+ projectId: ticket.projectId,
1938
+ ticketId: ticket.id,
1939
+ workerId: worker.id
1940
+ } : null;
1941
+ }
1942
+ if (project) return preset === presets$1.project ? {
1943
+ role: "project",
1944
+ projectId: project.id
1945
+ } : null;
1946
+ if (supervisor) return preset === presets$1.supervisor && supervisor.status === "active" ? {
1947
+ role: "supervisor",
1948
+ supervisorId: supervisor.id
1949
+ } : null;
1950
+ return preset === presets$1.main && await storage.getItem("orchestrator.id") === id ? { role: "main" } : null;
1951
+ },
1952
+ async findMain() {
1953
+ const id = await storage.getItem("orchestrator.id");
1954
+ return id && (await session.resolve(id))?.role === "main" ? id : null;
1955
+ },
1956
+ create: singlet((role, options) => `session:create:${role}:${role === "worker" ? options.sessionId : role === "project" ? options.projectId : role === "supervisor" ? options.supervisorId : "main"}`, async (role, options) => {
1957
+ if (stopped$3) throw new Error("runtime_stopping");
1958
+ const ctx = getServerContext(server);
1959
+ const project = options.projectId ? await db.project.findById(options.projectId) : void 0;
1960
+ const supervisor = options.supervisorId ? await db.supervisor.findById(options.supervisorId) : void 0;
1961
+ if (role === "project" && !project) throw new Error("project_not_found");
1962
+ if (role === "supervisor" && (!supervisor || supervisor.status !== "active")) throw new Error("supervisor_not_active");
1963
+ if (role === "main") {
1964
+ const existing = await session.findMain();
1965
+ if (existing) {
1966
+ await bindWorkspace(existing);
1967
+ await ctx.workspaceRegistry.pinSession(SessionId(existing)).catch(() => void 0);
1968
+ return existing;
1969
+ }
1970
+ }
1971
+ if (role === "project" && project?.orchestratorSessionId) {
1972
+ const identity = await session.resolve(project.orchestratorSessionId);
1973
+ if (identity?.role === "project" && identity.projectId === project.id) {
1974
+ await bindWorkspace(project.orchestratorSessionId);
1975
+ return project.orchestratorSessionId;
1976
+ }
1977
+ if (identity) throw new Error("session_binding_conflict");
1978
+ }
1979
+ if (role === "supervisor" && supervisor?.sessionId) {
1980
+ const identity = await session.resolve(supervisor.sessionId);
1981
+ if (identity?.role === "supervisor" && identity.supervisorId === supervisor.id) {
1982
+ await bindWorkspace(supervisor.sessionId);
1983
+ return supervisor.sessionId;
1984
+ }
1985
+ if (identity) throw new Error("session_binding_conflict");
1986
+ }
1987
+ const requestedId = options.sessionId ?? randomUUID();
1988
+ if (role === "worker") {
1989
+ const worker = await db.worker.findById(requestedId);
1990
+ if (!worker || worker.ticketId !== options.ticketId || worker.status === "ended") throw new Error("worker_binding_required");
1991
+ if (!options.directory) throw new Error("worker_directory_required");
1992
+ }
1993
+ const location = role === "worker" ? { cwd: options.directory } : { workspaceId: (await session.workspace()).id };
1994
+ const id = (await ctx.sessionController.create({
1995
+ sessionId: SessionId(requestedId),
1996
+ ...location,
1997
+ agentPreset: presets$1[role]
1998
+ })).sessionId;
1999
+ if (id !== requestedId) throw new Error("session_identity_conflict");
2000
+ if (role === "main") await storage.setItem("orchestrator.id", id);
2001
+ if (project && role === "project") await db.project.setOrchestrator(project.id, id, (/* @__PURE__ */ new Date()).toISOString());
2002
+ if (supervisor && role === "supervisor") await db.supervisor.attachSession(supervisor.id, id);
2003
+ const title = role === "main" ? "[路由] 主编排" : role === "project" ? `[路由] ${project.name}` : role === "supervisor" ? `[协调] ${supervisor.title}` : void 0;
2004
+ if (title) await ctx.sessionController.rename({
2005
+ sessionId: id,
2006
+ title
2007
+ });
2008
+ if (role === "main") await ctx.workspaceRegistry.pinSession(SessionId(id)).catch(() => void 0);
2009
+ if (role !== "worker") await inbox.notify(await resolveAgent(id), true);
2010
+ if (options.prompt) await session.send(id, options.prompt);
2011
+ return id;
2012
+ }),
2013
+ send: singlet((id, text, _mode, requestId = "") => `session:send:${id}:${requestId}:${text.length}:${text.slice(0, 64)}`, async (id, text, mode = "queue", requestId = randomUUID()) => {
2014
+ if (!text.trim()) throw new Error("empty_message");
2015
+ if (stopped$3) throw new Error("runtime_stopping");
2016
+ const identity = await session.resolve(id);
2017
+ if (!identity) {
2018
+ const worker = await db.worker.findById(id);
2019
+ throw new Error(worker ? worker.status === "ended" ? "worker_ended" : "worker_not_live_or_archived" : "unknown_session");
2020
+ }
2021
+ if (identity.workerId && (await db.worker.findById(id))?.status === "ended") throw new Error("worker_ended");
2022
+ const ctx = getServerContext(server);
2023
+ if (mode === "interrupt") await session.cancel(id, true);
2024
+ const admitted = await ctx.sessionController.prompt({
2025
+ sessionId: SessionId(id),
2026
+ requestId,
2027
+ mode: mode === "interrupt" ? "steer" : "queue",
2028
+ content: [{
2029
+ type: "text",
2030
+ text
2031
+ }]
2032
+ }, controller$2.signal);
2033
+ if (admitted && typeof admitted === "object" && "ok" in admitted && admitted.ok === false) throw new Error(`prompt_rejected: ${String(admitted.error ?? "unknown")}`);
2034
+ }),
2035
+ async cancel(id, keepInbox = false) {
2036
+ (await resolveAgent(id)).cancel({
2037
+ kind: "hook",
2038
+ reason: "supermesh_cancel"
2039
+ }, { keepInbox });
2040
+ },
2041
+ async rename(id, title) {
2042
+ if (!await session.resolve(id)) throw new Error("unknown_session");
2043
+ await getServerContext(server).sessionController.rename({
2044
+ sessionId: SessionId(id),
2045
+ title
2046
+ });
2047
+ },
2048
+ async view(id, offset = 0, limit = 12e3) {
2049
+ if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 5e4) throw new Error("invalid_page");
2050
+ if (!await session.resolve(id)) throw new Error("unknown_session");
2051
+ const { events } = await getServerContext(server).sessionQuery.readSession(SessionId(id));
2052
+ const text = events.flatMap((event) => {
2053
+ if (event.type !== "user/message" && event.type !== "assistant/message") return [];
2054
+ return (event.type === "assistant/message" ? event.data.message : event.data).content.flatMap((part) => part.type === "text" ? [part.text] : []);
2055
+ }).join(String.fromCharCode(10, 10));
2056
+ const end = Math.min(text.length, offset + limit);
2057
+ return {
2058
+ text: text.slice(offset, end),
2059
+ next_offset: end < text.length ? end : null
2060
+ };
2061
+ },
2062
+ workspace: singlet("session:workspace", async () => {
2063
+ await mkdir(DSH_PLUGIN_HOME, { recursive: true });
2064
+ return getServerContext(server).workspaceRegistry.create(DSH_PLUGIN_HOME, "代理工作区");
2065
+ }),
2066
+ activate: (id) => resolveAgent(id),
2067
+ async lookup(id) {
2068
+ if (!await session.resolve(id)) return null;
2069
+ return getServerContext(server).agents.get(SessionId(id)) ?? null;
2070
+ },
2071
+ async history(id) {
2072
+ return getServerContext(server).sessionQuery.readSession(SessionId(id));
2073
+ },
2074
+ async lastActivity(id) {
2075
+ try {
2076
+ const { events } = await getServerContext(server).sessionQuery.readSession(SessionId(id));
2077
+ let latest = 0;
2078
+ for (const event of events) {
2079
+ const time = Number(event.time ?? 0);
2080
+ if (time > latest) latest = time;
2081
+ }
2082
+ return latest || null;
2083
+ } catch {
2084
+ return null;
2085
+ }
2086
+ },
2087
+ async receipts(id) {
2088
+ const { events } = await getServerContext(server).sessionQuery.readSession(SessionId(id));
2089
+ const receipts = [];
2090
+ let pending = [];
2091
+ for (const event of events) {
2092
+ if (event.type === "turn/start") pending = [];
2093
+ if (event.type === "user/message" && "rpcId" in event.data.source && typeof event.data.source.rpcId === "string") pending.push(event.data.source.rpcId);
2094
+ if (event.type === "turn/end" && event.data.reason.kind === "completed") {
2095
+ receipts.push(...pending.map((requestId) => ({
2096
+ requestId,
2097
+ consumedAt: new Date(event.time).toISOString()
2098
+ })));
2099
+ pending = [];
2100
+ }
2101
+ }
2102
+ return receipts;
2103
+ },
2104
+ async activity(id) {
2105
+ const ctx = getServerContext(server);
2106
+ const activities = await ctx.waterfall("workspace/session-activity", { sessionId: SessionId(id) }, () => Promise.resolve([]));
2107
+ const state = await ctx.sessionController.state({ sessionId: SessionId(id) }, controller$2.signal);
2108
+ return {
2109
+ running: state.running,
2110
+ background: activities.some((item) => String(item.kind) !== "turn"),
2111
+ queued: Boolean(state.queue?.length)
2112
+ };
2113
+ },
2114
+ async stop(id) {
2115
+ const ctx = getServerContext(server);
2116
+ await ctx.parallel("workspace/session-stop", { sessionId: SessionId(id) });
2117
+ const result = await ctx.sessionController.resolveAgent(SessionId(id));
2118
+ if ("agent" in result) {
2119
+ result.agent.cancel({
2120
+ kind: "hook",
2121
+ reason: "supermesh_stop"
2122
+ }, { keepInbox: true });
2123
+ await result.agent.whenIdle();
2124
+ }
2125
+ if ((await session.activity(id)).background) throw new Error("background_stop_pending");
2126
+ }
2127
+ });
2128
+ async function bindWorkspace(id, cwd) {
2129
+ const ctx = getServerContext(server);
2130
+ const sid = SessionId(id);
2131
+ const directory = cwd ?? (await ctx.sessionQuery.readSession(sid)).session.cwd;
2132
+ if (!directory) return;
2133
+ const actual = await realpathNormalize(directory).catch(() => void 0);
2134
+ if (!actual) return;
2135
+ for (const workspace of [await session.workspace(), ...ctx.workspaceRegistry.list()]) {
2136
+ if (workspace.sessionIds.includes(sid)) return;
2137
+ if (workspace.path !== actual) continue;
2138
+ await workspace.attachSession(sid).catch(() => void 0);
2139
+ return;
2140
+ }
2141
+ await (await ctx.workspaceRegistry.create(actual, basename(actual)).catch(() => void 0))?.attachSession(sid).catch(() => void 0);
2142
+ }
2143
+ async function resolveAgent(id) {
2144
+ if (!await session.resolve(id)) throw new Error("unknown_session");
2145
+ const result = await getServerContext(server).sessionController.resolveAgent(SessionId(id));
2146
+ if ("error" in result) throw result.error;
2147
+ return result.agent;
2148
+ }
2149
+ // src/service/inbox.ts
2150
+ const deliveredAnswers = /* @__PURE__ */ new Set();
2151
+ let stopped$2 = false;
2152
+ const inbox = defineService({
2153
+ notify: singlet((agent) => `inbox:notify:${agent.session.id}`, async (agent, restore = false) => {
2154
+ if (agent.status !== "idle" && !restore) return;
2155
+ const mailbox = await inbox.peek(agent.session.id);
2156
+ if (!mailbox) return;
2157
+ const revision = mailbox.messages.map((message) => [message.id, message.escalations]).sort().map((parts) => parts.join(":")).join("|");
2158
+ if (!revision && !restore) return;
2159
+ const { events } = await session.history(agent.session.id);
2160
+ if ([...agent.inbox.nextTurn, ...agent.inbox.nextStep].some((message) => message.source.kind === (restore ? "supermesh-mailbox-context" : "supermesh-mailbox") && message.source.revision === revision)) return;
2161
+ if (events.some((event) => (event.type === "user/message" ? [event.data] : event.type === "agent/inbox/spliced" ? event.data.inserted : []).some((message) => message.source.kind === (restore ? "supermesh-mailbox-context" : "supermesh-mailbox") && message.source.revision === revision))) return;
2162
+ const text = `你有${mailbox.pendingCount}个未处理邮件。用 read_mailbox 读取邮件和项目上下文,处理完成后显式完成邮件。`;
2163
+ const message = createUserMessage({
2164
+ content: [{
2165
+ type: "text",
2166
+ text
2167
+ }],
2168
+ source: {
2169
+ kind: restore ? "supermesh-mailbox-context" : "supermesh-mailbox",
2170
+ form: "notice",
2171
+ summary: text,
2172
+ revision
2173
+ }
2174
+ });
2175
+ if (stopped$2 || !await session.resolve(agent.session.id)) return;
2176
+ if (restore) agent.inject(message);
2177
+ else if (agent.status === "idle") agent.followup(message);
2178
+ }),
2179
+ async peek(id, includeChannel = false) {
2180
+ const identity = await session.resolve(id);
2181
+ if (!identity) return null;
2182
+ const scope = scopeOf(identity);
2183
+ if (!scope) return null;
2184
+ const messages = await db.inbox.listScoped(scope, includeChannel);
2185
+ const projects = (await db.project.listAll()).filter((project) => project.enabled && (identity.role === "main" || project.id === identity.projectId)).map(({ id, name, directory, remoteUrl }) => ({
2186
+ id,
2187
+ name,
2188
+ directory,
2189
+ remoteUrl
2190
+ }));
2191
+ return {
2192
+ sessionId: id,
2193
+ role: scope.type,
2194
+ projects,
2195
+ pendingCount: messages.length,
2196
+ messages
2197
+ };
2198
+ },
2199
+ async read(id, includeChannel = false, ids) {
2200
+ const mailbox = await inbox.peek(id, includeChannel);
2201
+ if (!mailbox) throw new Error("unknown_session");
2202
+ const now = (/* @__PURE__ */ new Date()).toISOString();
2203
+ const selected = ids?.length ? mailbox.messages.filter((message) => ids.includes(message.id)) : mailbox.messages;
2204
+ await db.inbox.markRead(selected.filter((message) => !message.readAt).map((message) => message.id), now);
2205
+ if (!ids?.length) return mailbox;
2206
+ const missing = ids.filter((id) => !mailbox.messages.some((message) => message.id === id));
2207
+ return {
2208
+ ...mailbox,
2209
+ messages: selected,
2210
+ missing
2211
+ };
2212
+ },
2213
+ async complete(id, ids, includeChannel = false) {
2214
+ const identity = await session.resolve(id);
2215
+ if (!identity) throw new Error("unknown_session");
2216
+ const scope = scopeOf(identity);
2217
+ if (!scope) throw new Error("unknown_session");
2218
+ return db.inbox.completeScoped(ids, scope, (/* @__PURE__ */ new Date()).toISOString(), includeChannel);
2219
+ },
2220
+ start() {
2221
+ if (singlet.busy("inbox:delivery") || singlet.busy("inbox:answers")) throw new Error("inbox_busy");
2222
+ stopped$2 = false;
2223
+ deliveredAnswers.clear();
2224
+ return async () => {
2225
+ stopped$2 = true;
2226
+ await Promise.allSettled([singlet.drain()]);
2227
+ deliveredAnswers.clear();
2228
+ };
2229
+ },
2230
+ deliver: singlet("inbox:delivery", async () => {
2231
+ const settings = await setting.load();
2232
+ const blocked = /* @__PURE__ */ new Set();
2233
+ const notified = /* @__PURE__ */ new Set();
2234
+ const receipts = /* @__PURE__ */ new Map();
2235
+ for (const message of await db.inbox.listDelivery()) {
2236
+ if (stopped$2) break;
2237
+ const key = [
2238
+ message.type,
2239
+ message.projectId,
2240
+ message.supervisorId,
2241
+ message.ticketId
2242
+ ].join(":");
2243
+ if (message.ticketId && (await db.ticket.findById(message.ticketId))?.paused) continue;
2244
+ if (message.type === "project" && message.projectId && !(await db.project.findById(message.projectId))?.enabled) continue;
2245
+ if (message.type === "supervisor" && message.supervisorId && (await db.supervisor.findById(message.supervisorId))?.status !== "active") continue;
2246
+ if (message.origin === "channel") {
2247
+ if (blocked.has(key) || message.readAt) continue;
2248
+ blocked.add(key);
2249
+ } else if (notified.has(key)) continue;
2250
+ if (message.status === "stalled" || message.nextRetryAt && message.nextRetryAt > (/* @__PURE__ */ new Date()).toISOString()) continue;
2251
+ try {
2252
+ const id = await recipient(message);
2253
+ if (!id) throw new Error("recipient_session_unavailable");
2254
+ if (message.origin !== "channel") {
2255
+ const agent = await session.activate(id);
2256
+ if (stopped$2) break;
2257
+ if (agent.status === "idle") await inbox.notify(agent);
2258
+ notified.add(key);
2259
+ await db.inbox.resetDelivery(message.id);
2260
+ continue;
2261
+ }
2262
+ let consumed = receipts.get(id);
2263
+ if (!consumed) {
2264
+ consumed = await session.receipts(id);
2265
+ receipts.set(id, consumed);
2266
+ }
2267
+ const requestId = `supermesh:inbox:${message.id}:${message.escalations}`;
2268
+ const receipt = consumed.find((item) => item.requestId === requestId);
2269
+ if (receipt) {
2270
+ await db.inbox.markRead([message.id], receipt.consumedAt);
2271
+ blocked.delete(key);
2272
+ continue;
2273
+ }
2274
+ if ((await session.activity(id)).running || stopped$2) continue;
2275
+ await session.send(id, [
2276
+ message.title ?? "",
2277
+ `[Inbox ${message.id}]`,
2278
+ message.triggerId ? `triggerId: ${message.triggerId}` : "",
2279
+ message.threadId ? `threadId: ${message.threadId}` : "",
2280
+ message.message
2281
+ ].filter(Boolean).join(String.fromCharCode(10)), "queue", requestId);
2282
+ await db.inbox.resetDelivery(message.id);
2283
+ blocked.delete(key);
2284
+ } catch (error) {
2285
+ if (stopped$2) break;
2286
+ const reason = error instanceof Error ? error.message : String(error);
2287
+ const attempts = message.deliveryAttempts + 1;
2288
+ const delay = Math.min(2 ** Math.min(attempts, 20), settings.deliveryRetryCeilingSeconds) * 1e3;
2289
+ await db.inbox.recordDeliveryFailure(message.id, reason, new Date(Date.now() + delay).toISOString());
2290
+ if (attempts >= settings.deliveryMaxAttempts) await db.inbox.markStalled(message.id, reason);
2291
+ }
2292
+ }
2293
+ }),
2294
+ deliverAnswers: singlet("inbox:answers", async () => {
2295
+ for (const message of await db.inbox.listAnswered()) {
2296
+ if (stopped$2) break;
2297
+ if (!message.answer || message.nextRetryAt && message.nextRetryAt > (/* @__PURE__ */ new Date()).toISOString()) continue;
2298
+ try {
2299
+ if (message.answeredBy !== "user" && message.origin !== "worker") {
2300
+ await db.inbox.enqueueAnswer(message);
2301
+ continue;
2302
+ }
2303
+ let id = null;
2304
+ if (message.origin === "worker") {
2305
+ const worker = message.workerId ? await db.worker.findById(message.workerId) : void 0;
2306
+ if (!worker) throw new Error("worker_not_found");
2307
+ if (worker.status === "ended") throw new Error("worker_ended");
2308
+ id = worker.id;
2309
+ } else if (message.origin === "project" && message.projectId) {
2310
+ const project = await db.project.findById(message.projectId);
2311
+ if (project?.enabled) id = project.orchestratorSessionId;
2312
+ } else if (message.origin === "supervisor" && message.supervisorId) {
2313
+ const supervisor = await db.supervisor.findById(message.supervisorId);
2314
+ if (supervisor?.status === "active") id = supervisor.sessionId;
2315
+ } else if (message.origin === "main") id = await session.findMain();
2316
+ if (!id || deliveredAnswers.has(`${message.id}:${id}`) || stopped$2) continue;
2317
+ if (message.ticketId && (await db.ticket.findById(message.ticketId))?.paused) continue;
2318
+ await session.send(id, `[Answer ${message.id}] ${message.answer}`, "reply", `supermesh:answer:${message.id}`);
2319
+ deliveredAnswers.add(`${message.id}:${id}`);
2320
+ await db.inbox.resetDelivery(message.id);
2321
+ } catch (error) {
2322
+ if (stopped$2) break;
2323
+ const reason = error instanceof Error ? error.message : String(error);
2324
+ const settings = await setting.load();
2325
+ const delays = Math.min(2 ** Math.min(message.deliveryAttempts + 1, 20), settings.deliveryRetryCeilingSeconds) * 1e3;
2326
+ await db.inbox.recordDeliveryFailure(message.id, reason, new Date(Date.now() + delays).toISOString());
2327
+ if (message.deliveryAttempts + 1 >= settings.deliveryMaxAttempts) await db.inbox.markStalled(message.id, reason);
2328
+ }
2329
+ }
2330
+ })
2331
+ });
2332
+ async function recipient(message) {
2333
+ if (message.type === "main") return session.create("main", {});
2334
+ if (message.type === "project" && message.projectId) return session.create("project", { projectId: message.projectId });
2335
+ if (message.type === "supervisor" && message.supervisorId) return session.create("supervisor", { supervisorId: message.supervisorId });
2336
+ throw new Error("invalid_inbox_recipient");
2337
+ }
2338
+ function scopeOf(identity) {
2339
+ if (identity.role === "main") return { type: "main" };
2340
+ if (identity.role === "project" && identity.projectId) return {
2341
+ type: "project",
2342
+ projectId: identity.projectId
2343
+ };
2344
+ if (identity.role === "supervisor" && identity.supervisorId) return {
2345
+ type: "supervisor",
2346
+ supervisorId: identity.supervisorId
2347
+ };
2348
+ return null;
2349
+ }
2350
+ // src/server/routes/ask.[id].answer.post.ts
2351
+ var ask__id__answer_post_default = defineHandler(async (event) => {
2352
+ const id = getRouterParam(event, "id", { decode: true });
2353
+ const body = await readBody(event);
2354
+ if (!id?.trim() || !body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => key !== "answer") || typeof body.answer !== "string" || !body.answer.trim()) throw new HTTPError({
2355
+ status: 400,
2356
+ message: "answer_required"
2357
+ });
2358
+ const current = await db.inbox.findById(id);
2359
+ if (!current) throw new HTTPError({
2360
+ status: 404,
2361
+ message: "not_found"
2362
+ });
2363
+ if (current.type !== "user" || current.kind !== "ask") throw new HTTPError({
2364
+ status: 403,
2365
+ message: "scope_denied"
2366
+ });
2367
+ if (![
2368
+ "worker",
2369
+ "project",
2370
+ "supervisor",
2371
+ "main"
2372
+ ].includes(current.origin)) throw new HTTPError({
2373
+ status: 409,
2374
+ message: "unsupported_reply_target"
2375
+ });
2376
+ const answer = await db.inbox.answerByUser(id, body.answer.trim(), (/* @__PURE__ */ new Date()).toISOString());
2377
+ if (!answer) throw new HTTPError({
2378
+ status: 409,
2379
+ message: "already_answered"
2380
+ });
2381
+ await inbox.deliverAnswers();
2382
+ return answer;
2383
+ });
2384
+ // src/service/shell.ts
2385
+ const directory = join(DSH_PLUGIN_HOME, "cli");
2386
+ const bin = join(directory, "bin");
2387
+ const gitconfig = join(directory, "gitconfig");
2388
+ const removed = [
2389
+ "GH_TOKEN",
2390
+ "GITHUB_TOKEN",
2391
+ "GH_ENTERPRISE_TOKEN",
2392
+ "GITHUB_ENTERPRISE_TOKEN",
2393
+ "GITLAB_TOKEN",
2394
+ "GLAB_TOKEN",
2395
+ "OAUTH_TOKEN",
2396
+ "CI_JOB_TOKEN",
2397
+ "GIT_DIR",
2398
+ "GIT_WORK_TREE",
2399
+ "GIT_INDEX_FILE",
2400
+ "GIT_PREFIX",
2401
+ "GIT_COMMON_DIR",
2402
+ "GIT_OBJECT_DIRECTORY",
2403
+ "GIT_ALTERNATE_OBJECT_DIRECTORIES",
2404
+ "GIT_NAMESPACE",
2405
+ "GIT_CONFIG_COUNT",
2406
+ "GIT_CONFIG_PARAMETERS",
2407
+ "GIT_AUTHOR_NAME",
2408
+ "GIT_AUTHOR_EMAIL",
2409
+ "GIT_COMMITTER_NAME",
2410
+ "GIT_COMMITTER_EMAIL",
2411
+ "SSH_ASKPASS"
2412
+ ];
2413
+ let restore;
2414
+ let writing$1 = Promise.resolve();
2415
+ let basePath = "";
2416
+ const shell = defineService({
2417
+ async start() {
2418
+ if (restore) throw new Error("shell_already_started");
2419
+ basePath = (process.env.PATH ?? "").split(delimiter).filter((path) => resolve(path).toLowerCase() !== resolve(bin).toLowerCase()).join(delimiter);
2420
+ await refresh();
2421
+ const values = {
2422
+ ...Object.fromEntries(removed.map((key) => [key, void 0])),
2423
+ PATH: [bin, basePath].join(delimiter),
2424
+ GIT_CONFIG_GLOBAL: gitconfig,
2425
+ GIT_CONFIG_NOSYSTEM: "1",
2426
+ GIT_ASKPASS: "",
2427
+ GIT_TERMINAL_PROMPT: "0"
2428
+ };
2429
+ const previous = Object.fromEntries(Object.keys(values).map((key) => [key, process.env[key]]));
2430
+ const apply = (entries) => {
2431
+ for (const [key, value] of Object.entries(entries)) if (value === void 0) delete process.env[key];
2432
+ else process.env[key] = value;
2433
+ };
2434
+ apply(values);
2435
+ restore = () => apply(previous);
2436
+ return async () => {
2437
+ const release = restore;
2438
+ restore = void 0;
2439
+ release?.();
2440
+ await writing$1;
2441
+ };
2442
+ },
2443
+ commandEnvironment() {
2444
+ return {
2445
+ ...process.env,
2446
+ ...restore ? { PATH: basePath } : {}
2447
+ };
2448
+ },
2449
+ refresh() {
2450
+ if (!restore) return Promise.resolve();
2451
+ const next = writing$1.then(refresh);
2452
+ writing$1 = next.catch(() => void 0);
2453
+ return next;
2454
+ }
2455
+ });
2456
+ async function refresh() {
2457
+ const [github, gitlab, views, projects] = await Promise.all([
2458
+ channel.connection("github"),
2459
+ channel.connection("gitlab"),
2460
+ channel.list(),
2461
+ db.project.listAll()
2462
+ ]);
2463
+ await Promise.all([
2464
+ bin,
2465
+ join(directory, "gh"),
2466
+ join(directory, "glab")
2467
+ ].map((path) => mkdir(path, {
2468
+ recursive: true,
2469
+ mode: 448
2470
+ })));
2471
+ const gitlabHost = new URL(gitlab.host ?? "https://gitlab.com").host;
2472
+ const bot = (kind) => views.find((view) => view.id === kind)?.accounts.find((account) => account.role === "bot")?.name ?? "";
2473
+ await own(join(directory, "gh", "hosts.yml"), JSON.stringify(github.enabled && github.token ? { "github.com": {
2474
+ oauth_token: github.token,
2475
+ user: bot("github"),
2476
+ git_protocol: "https"
2477
+ } } : {}));
2478
+ await own(join(directory, "glab", "config.yml"), JSON.stringify({
2479
+ git_protocol: "https",
2480
+ hosts: gitlab.enabled && gitlab.token ? { [gitlabHost]: {
2481
+ token: gitlab.token,
2482
+ user: bot("gitlab"),
2483
+ api_protocol: "https",
2484
+ git_protocol: "https"
2485
+ } } : {}
2486
+ }));
2487
+ for (const cli of ["gh", "glab"]) {
2488
+ const executable = await nativeCli(cli);
2489
+ const configKey = cli === "gh" ? "GH_CONFIG_DIR" : "GLAB_CONFIG_DIR";
2490
+ const hostKey = cli === "gh" ? "GH_HOST" : "GITLAB_HOST";
2491
+ const host = cli === "gh" ? "github.com" : gitlabHost;
2492
+ const shellPath = shellPathOf(basePath);
2493
+ const keyringKeys = cli === "glab" ? ["GLAB_USE_KEYRING"] : [];
2494
+ await own(join(bin, cli), [
2495
+ "#!/bin/sh",
2496
+ `unset ${removed.filter((key) => /TOKEN/.test(key)).join(" ")}`,
2497
+ `export PATH=${quote(shellPath)}`,
2498
+ `export ${configKey}=${quote(join(directory, cli).replaceAll("\\", "/"))}`,
2499
+ `export ${hostKey}=${quote(host)}`,
2500
+ ...keyringKeys.map((key) => `export ${key}=false`),
2501
+ executable ? `exec ${quote(executable.replaceAll("\\", "/"))} "$@"` : `echo '${cli} is not installed' >&2; exit 127`,
2502
+ ""
2503
+ ].join("\n"), 448);
2504
+ const cmd = (value) => value.replaceAll("%", "%%");
2505
+ await own(join(bin, `${cli}.cmd`), [
2506
+ "@echo off",
2507
+ "setlocal",
2508
+ ...removed.filter((key) => /TOKEN/.test(key)).map((key) => `set "${key}="`),
2509
+ `set "PATH=${cmd(basePath)}"`,
2510
+ `set "${configKey}=${cmd(join(directory, cli))}"`,
2511
+ `set "${hostKey}=${host}"`,
2512
+ ...keyringKeys.map((key) => `set "${key}=false"`),
2513
+ executable ? `"${cmd(executable)}" %*` : `echo ${cli} is not installed 1>&2 & exit /b 127`,
2514
+ "exit /b %errorlevel%",
2515
+ ""
2516
+ ].join("\r\n"), 448);
2517
+ }
2518
+ const nativeGh = await nativeCli("gh");
2519
+ const escaping = [
2520
+ "GH_CONFIG_DIR",
2521
+ "GH_HOST",
2522
+ ...removed.filter((key) => /TOKEN/.test(key))
2523
+ ];
2524
+ await own(join(bin, "gh-default"), [
2525
+ "#!/bin/sh",
2526
+ `unset ${escaping.join(" ")}`,
2527
+ `export PATH=${quote(shellPathOf(basePath))}`,
2528
+ nativeGh ? `exec ${quote(nativeGh.replaceAll("\\", "/"))} "$@"` : "echo gh is not installed >&2; exit 127",
2529
+ ""
2530
+ ].join("\n"), 448);
2531
+ await own(join(bin, "gh-default.cmd"), [
2532
+ "@echo off",
2533
+ "setlocal",
2534
+ ...escaping.map((key) => `set "${key}="`),
2535
+ `set "PATH=${basePath.replaceAll("%", "%%")}"`,
2536
+ nativeGh ? `"${nativeGh.replaceAll("%", "%%")}" %*` : "echo gh is not installed 1>&2 & exit /b 127",
2537
+ "exit /b %errorlevel%",
2538
+ ""
2539
+ ].join("\r\n"), 448);
2540
+ const gitQuote = (value) => JSON.stringify(value);
2541
+ const cliPath = (cli) => quote(join(bin, cli).replaceAll("\\", "/"));
2542
+ const lines = [
2543
+ "[user]",
2544
+ " useConfigOnly = true",
2545
+ "[credential]",
2546
+ " helper =",
2547
+ "[credential \"https://github.com\"]",
2548
+ `\thelper = ${gitQuote(`!${cliPath("gh")} auth git-credential`)}`,
2549
+ `[credential "https://${gitlabHost}"]`,
2550
+ `\thelper = ${gitQuote(`!f() { if test "$1" = get; then token=$( ${cliPath("glab")} config get token --host ${quote(gitlabHost)} ) || exit; test -n "$token" || exit; printf 'username=oauth2\\npassword=%s\\n' "$token"; fi; }; f`)}`,
2551
+ "[url \"https://github.com/\"]",
2552
+ " insteadOf = git@github.com:",
2553
+ " insteadOf = ssh://git@github.com/",
2554
+ `[url "https://${gitlabHost}/"]`,
2555
+ `\tinsteadOf = git@${gitlabHost}:`,
2556
+ `\tinsteadOf = ssh://git@${gitlabHost}/`,
2557
+ "[filter \"lfs\"]",
2558
+ " clean = git-lfs clean -- %f",
2559
+ " smudge = git-lfs smudge -- %f",
2560
+ " process = git-lfs filter-process",
2561
+ " required = true"
2562
+ ];
2563
+ for (const project of projects) {
2564
+ if (!project.remoteUrl) continue;
2565
+ const metadata = views.find((view) => view.id === (/github\.com[:/]/i.test(project.remoteUrl) ? "github" : "gitlab"));
2566
+ if (!metadata?.commitName || !metadata.commitEmail) continue;
2567
+ const identity = join(directory, `${project.id}.gitconfig`);
2568
+ await own(identity, `[user]\n\tname = ${gitQuote(metadata.commitName)}\n\temail = ${gitQuote(metadata.commitEmail)}\n`);
2569
+ const repositoryGitdir = join(project.directory, ".git").replaceAll("\\", "/");
2570
+ for (const pattern of [repositoryGitdir, `${repositoryGitdir}/`]) lines.push(`[includeIf ${gitQuote(`gitdir/i:${pattern}`)}]`, `\tpath = ${gitQuote(identity)}`);
2571
+ }
2572
+ await own(gitconfig, `${lines.join("\n")}\n`);
2573
+ }
2574
+ function shellPathOf(value) {
2575
+ if (process.platform !== "win32") return value;
2576
+ return value.split(delimiter).map((path) => path.replaceAll("\\", "/").replace(/^([a-z]):/i, (_, drive) => `/${drive.toLowerCase()}`)).join(":");
2577
+ }
2578
+ async function nativeCli(cli) {
2579
+ for (const folder of basePath.split(delimiter)) {
2580
+ if (!folder) continue;
2581
+ const executable = join(folder, process.platform === "win32" ? `${cli}.exe` : cli);
2582
+ try {
2583
+ await access(executable);
2584
+ return executable;
2585
+ } catch (error) {
2586
+ if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
2587
+ }
2588
+ }
2589
+ }
2590
+ async function own(path, content, mode = 384) {
2591
+ const temporary = `${path}.${process.pid}.tmp`;
2592
+ await writeFile(temporary, content, { mode });
2593
+ await rename(temporary, path);
2594
+ }
2595
+ function quote(value) {
2596
+ return `'${value.replaceAll("'", "'\\''")}'`;
2597
+ }
2598
+ // src/service/devops.ts
2599
+ const authentications = /* @__PURE__ */ new Map();
2600
+ const active = /* @__PURE__ */ new Map();
2601
+ const lifetime = 6e5;
2602
+ const devops = defineService({
2603
+ async start(channelId, host) {
2604
+ if (channelId !== "github" && channelId !== "gitlab") throw new TypeError("channel_unsupported");
2605
+ const origin = host !== void 0 ? site(channelId, host) : channelId === "github" ? "https://github.com" : void 0;
2606
+ const pending = active.get(channelId);
2607
+ if (pending) {
2608
+ if (origin && pending.origin && origin !== pending.origin) throw new Error("channel_auth_in_progress");
2609
+ return snapshot(pending);
2610
+ }
2611
+ prune();
2612
+ const task = {
2613
+ view: {
2614
+ id: randomUUID(),
2615
+ channelId,
2616
+ status: "pending",
2617
+ output: channelId === "github" ? "Waiting for GitHub authorization." : "Waiting for GitLab device authorization (GitLab 17.9+)."
2618
+ },
2619
+ origin,
2620
+ controller: new AbortController(),
2621
+ done: Promise.resolve()
2622
+ };
2623
+ const dispose = getServerContext(server).effect(() => () => cancel(task), "supermesh:devops");
2624
+ authentications.set(task.view.id, task);
2625
+ active.set(channelId, task);
2626
+ task.done = Promise.resolve().then(() => authenticate(task)).finally(() => {
2627
+ active.delete(channelId);
2628
+ task.finishedAt = Date.now();
2629
+ });
2630
+ task.done.then(() => dispose());
2631
+ return snapshot(task);
2632
+ },
2633
+ lookup(channelId, authenticationId) {
2634
+ prune();
2635
+ const task = authentications.get(authenticationId);
2636
+ return task?.view.channelId === channelId ? snapshot(task) : null;
2637
+ },
2638
+ async cancel(channelId) {
2639
+ if (channelId !== "github" && channelId !== "gitlab") throw new TypeError("channel_unsupported");
2640
+ const pending = active.get(channelId);
2641
+ if (pending) await cancel(pending);
2642
+ },
2643
+ async cleanup() {
2644
+ await Promise.all([...active.values()].map(cancel));
2645
+ },
2646
+ save(kind, patch) {
2647
+ return channel.serialize(() => save(kind, patch)).then(async (view) => {
2648
+ const { shell } = await import("./shell-6EeRyaxQ.js");
2649
+ await shell.refresh();
2650
+ return view;
2651
+ });
2652
+ },
2653
+ removeCredentials(kind) {
2654
+ return channel.serialize(() => removeCredentials(kind)).then(async (view) => {
2655
+ const { shell } = await import("./shell-6EeRyaxQ.js");
2656
+ await shell.refresh();
2657
+ return view;
2658
+ });
2659
+ }
2660
+ });
2661
+ async function removeCredentials(kind) {
2662
+ if (kind !== "github" && kind !== "gitlab") throw new TypeError("channel_unsupported");
2663
+ const previous = await channel.clearCredential(kind);
2664
+ try {
2665
+ await db.channel.removeCredentials(kind);
2666
+ } catch {
2667
+ if (previous) await channel.storeCredential(kind, previous);
2668
+ throw new Error("channel_credentials_delete_failed");
2669
+ }
2670
+ return (await channel.list()).find((item) => item.kind === kind);
2671
+ }
2672
+ async function save(kind, patch) {
2673
+ if (kind !== "github" && kind !== "gitlab") throw new TypeError("channel_unsupported");
2674
+ if (!patch || typeof patch !== "object" || Array.isArray(patch) || Object.keys(patch).some((key) => ![
2675
+ "host",
2676
+ "enabled",
2677
+ "commitName",
2678
+ "commitEmail",
2679
+ "token"
2680
+ ].includes(key)) || patch.enabled !== void 0 && typeof patch.enabled !== "boolean" || [
2681
+ "host",
2682
+ "commitName",
2683
+ "commitEmail",
2684
+ "token"
2685
+ ].some((key) => patch[key] !== void 0 && typeof patch[key] !== "string")) throw new TypeError("invalid_channel_config");
2686
+ if (patch.token !== void 0 && (!patch.token.trim() || patch.token.length > 8192 || /[\r\n]/.test(patch.token))) throw new TypeError("invalid_channel_token");
2687
+ if ((patch.commitName?.length ?? 0) > 200 || (patch.commitEmail?.length ?? 0) > 254 || /[\r\n]/.test((patch.commitName ?? "") + (patch.commitEmail ?? "")) || patch.commitEmail && !/^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/.test(patch.commitEmail.trim())) throw new TypeError("invalid_commit_identity");
2688
+ const current = (await channel.list()).find((item) => item.kind === kind);
2689
+ let url;
2690
+ try {
2691
+ url = new URL(patch.host ?? current.host ?? (kind === "github" ? "https://github.com" : "https://gitlab.com"));
2692
+ } catch {
2693
+ throw new TypeError("invalid_channel_host");
2694
+ }
2695
+ if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || url.pathname !== "/" || kind === "github" && url.origin !== "https://github.com") throw new TypeError("invalid_channel_host");
2696
+ const hostChanged = kind === "gitlab" && url.origin !== new URL(current.host ?? "https://gitlab.com").origin;
2697
+ const token = patch.token?.trim();
2698
+ let account;
2699
+ if (hostChanged && (current.hasCredential || current.accounts.length > 0) && !token) throw new TypeError("channel_account_required");
2700
+ if (token) account = await verify(kind, url, token);
2701
+ const enabled = patch.enabled ?? (Boolean(account) || current.enabled);
2702
+ if (enabled && !account && !current.accounts.some((account) => account.role === "bot" && account.status === "online")) throw new TypeError("channel_account_required");
2703
+ const previous = token ? await channel.storeCredential(kind, token) : void 0;
2704
+ try {
2705
+ await db.channel.saveConfiguration(kind, current.name, kind === "gitlab" ? url.origin : null, enabled, {
2706
+ commitName: patch.commitName?.trim() ?? current.commitName,
2707
+ commitEmail: patch.commitEmail?.trim() ?? current.commitEmail
2708
+ }, account, ...hostChanged ? [true] : []);
2709
+ } catch {
2710
+ if (token) {
2711
+ if (previous) await channel.storeCredential(kind, previous);
2712
+ else await channel.clearCredential(kind);
2713
+ }
2714
+ throw new Error("channel_save_failed");
2715
+ }
2716
+ return (await channel.list()).find((item) => item.kind === kind);
2717
+ }
2718
+ async function verify(kind, url, token) {
2719
+ const endpoint = kind === "github" ? "https://api.github.com/user" : `${url.origin}/api/v4/user`;
2720
+ const env = await channelProxyEnvironment(new URL(endpoint), process.env);
2721
+ const dispatcher = await createRouteDispatcher({ get: (name) => env[name] === void 0 ? void 0 : { value: env[name] } }, { allowH2: false });
2722
+ try {
2723
+ let response;
2724
+ try {
2725
+ response = await fetch(endpoint, {
2726
+ dispatcher,
2727
+ headers: {
2728
+ authorization: `Bearer ${token}`,
2729
+ accept: kind === "github" ? "application/vnd.github+json" : "application/json"
2730
+ },
2731
+ signal: AbortSignal.timeout(15e3),
2732
+ redirect: "error"
2733
+ });
2734
+ } catch {
2735
+ throw new Error("channel_verification_failed");
2736
+ }
2737
+ if (!response.ok) {
2738
+ await response.body?.cancel();
2739
+ throw new Error("channel_auth_failed");
2740
+ }
2741
+ let identity;
2742
+ try {
2743
+ identity = await response.json();
2744
+ } catch {
2745
+ throw new Error("channel_auth_failed");
2746
+ }
2747
+ if (!identity || typeof identity !== "object" || Array.isArray(identity)) throw new Error("channel_auth_failed");
2748
+ const user = identity;
2749
+ const login = kind === "github" ? user.login : user.username ?? user.name;
2750
+ if (typeof login !== "string" || !login.trim() || login.length > 200 || /[\r\n]/.test(login)) throw new Error("channel_auth_failed");
2751
+ return {
2752
+ name: login.trim(),
2753
+ avatar: null
2754
+ };
2755
+ } finally {
2756
+ await dispatcher.close();
2757
+ }
2758
+ }
2759
+ function snapshot(task) {
2760
+ return {
2761
+ ...task.view,
2762
+ ...task.view.account ? { account: { ...task.view.account } } : {}
2763
+ };
2764
+ }
2765
+ function prune() {
2766
+ for (const [id, task] of authentications) if (task.finishedAt && (Date.now() - task.finishedAt > lifetime || authentications.size >= 32)) authentications.delete(id);
2767
+ }
2768
+ async function cancel(task) {
2769
+ if (!task.finishedAt) task.controller.abort();
2770
+ await task.done;
2771
+ }
2772
+ async function authenticate(task) {
2773
+ const directory = join(DSH_PLUGIN_HOME, `${task.view.channelId}-auth`, task.view.id);
2774
+ let env = Object.fromEntries(Object.entries(shell.commandEnvironment()).filter(([key]) => key === "GITLAB_CLIENT_ID" || !/^(?:GH_|GITHUB_|GLAB_|GITLAB_|OAUTH_TOKEN$|CI_JOB_TOKEN$|GL_HOST$|BROWSER$|API_PROTOCOL$|SKIP_TLS_VERIFY$|NO_PROMPT$|PROMPT_DISABLED$)/i.test(key)));
2775
+ env.GH_CONFIG_DIR = directory;
2776
+ env.GLAB_CONFIG_DIR = directory;
2777
+ env.GH_HOST = "github.com";
2778
+ env.GH_BROWSER = `"${process.execPath.replaceAll("\\", "/")}" -e "process.exit(0)"`;
2779
+ env.ELECTRON_RUN_AS_NODE = "1";
2780
+ env.GLAB_BROWSER = env.GH_BROWSER;
2781
+ env.GLAB_CHECK_UPDATE = "false";
2782
+ env.GLAB_SKIP_TLS_VERIFY = "false";
2783
+ env.GLAB_API_PROTOCOL = "https";
2784
+ env.GLAB_USE_KEYRING = "false";
2785
+ env.GH_PAGER = "cat";
2786
+ env.NO_COLOR = "1";
2787
+ const timeout = setTimeout(() => task.controller.abort(), lifetime);
2788
+ timeout.unref();
2789
+ try {
2790
+ task.controller.signal.throwIfAborted();
2791
+ await mkdir(directory, {
2792
+ recursive: true,
2793
+ mode: 448
2794
+ });
2795
+ if (!task.origin) task.origin = site(task.view.channelId, (await channel.list()).find((item) => item.id === task.view.channelId)?.host ?? "https://gitlab.com");
2796
+ env = await channelProxyEnvironment(new URL(task.origin), env);
2797
+ const hostname = new URL(task.origin).host;
2798
+ const args = task.view.channelId === "github" ? [
2799
+ "auth",
2800
+ "login",
2801
+ "--hostname",
2802
+ hostname,
2803
+ "--git-protocol",
2804
+ "https",
2805
+ "--web",
2806
+ "--insecure-storage"
2807
+ ] : [
2808
+ "auth",
2809
+ "login",
2810
+ "--hostname",
2811
+ hostname,
2812
+ "--git-protocol",
2813
+ "https",
2814
+ "--api-protocol",
2815
+ "https",
2816
+ "--device",
2817
+ "--insecure-storage"
2818
+ ];
2819
+ if (task.view.channelId === "gitlab") throw new TypeError("channel_gitlab_token_only");
2820
+ await command(task, args, env, true);
2821
+ task.controller.signal.throwIfAborted();
2822
+ const token = (await command(task, task.view.channelId === "github" ? [
2823
+ "auth",
2824
+ "token",
2825
+ "--hostname",
2826
+ hostname
2827
+ ] : [
2828
+ "config",
2829
+ "get",
2830
+ "token",
2831
+ "--host",
2832
+ hostname
2833
+ ], env, false)).trim();
2834
+ if (!token || token.length > 8192 || /[\r\n]/.test(token)) throw new Error("channel_auth_token_failed");
2835
+ task.controller.signal.throwIfAborted();
2836
+ const account = (await devops.save(task.view.channelId, {
2837
+ token,
2838
+ ...task.view.channelId === "gitlab" ? { host: task.origin } : {}
2839
+ })).accounts.find((account) => account.role === "bot");
2840
+ if (!account) throw new Error("channel_auth_verification_failed");
2841
+ task.view.account = { login: account.name };
2842
+ task.view.status = "succeeded";
2843
+ } catch (error) {
2844
+ task.view.status = "failed";
2845
+ const missing = error instanceof Error && error.code === "ENOENT";
2846
+ task.view.error = task.controller.signal.aborted ? "channel_auth_cancelled" : missing ? task.view.channelId === "github" ? "gh_missing" : "glab_missing" : task.networkTimeout ? "channel_auth_network_timeout" : "channel_auth_failed";
2847
+ publish(task.view, missing ? `Required CLI is not installed: ${task.view.channelId === "github" ? "gh" : "glab"}.` : task.controller.signal.aborted ? "Authentication cancelled." : task.networkTimeout ? `连接授权服务器超时,尚未完成登录。${env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy ? "CLI已继承代理配置(宿主或Windows已启用配置),请检查代理连通性及绕过规则。" : "CLI未收到HTTP(S)代理配置,当前使用直连;请检查宿主或Windows系统代理设置。"}终端可登录不代表宿主子进程使用相同网络路径。` : "Authentication failed. Review the CLI output above.");
2848
+ } finally {
2849
+ clearTimeout(timeout);
2850
+ try {
2851
+ await rm(directory, {
2852
+ recursive: true,
2853
+ force: true
2854
+ });
2855
+ } catch {
2856
+ if (task.view.status !== "succeeded") task.view.status = "failed";
2857
+ task.view.error = "channel_auth_cleanup_failed";
2858
+ }
2859
+ }
2860
+ }
2861
+ function command(task, args, env, login) {
2862
+ return new Promise((resolve, reject) => {
2863
+ task.controller.signal.throwIfAborted();
2864
+ const child = spawn(task.view.channelId === "github" ? "gh" : "glab", args, {
2865
+ env,
2866
+ cwd: env.GH_CONFIG_DIR,
2867
+ windowsHide: true,
2868
+ stdio: [
2869
+ "pipe",
2870
+ "pipe",
2871
+ "pipe"
2872
+ ],
2873
+ signal: task.controller.signal
2874
+ });
2875
+ let output = "";
2876
+ const stdout = lines(task);
2877
+ const stderr = lines(task);
2878
+ let failure;
2879
+ let force;
2880
+ const abort = () => {
2881
+ force = setTimeout(() => child.kill("SIGKILL"), 1e3);
2882
+ force.unref();
2883
+ };
2884
+ task.controller.signal.addEventListener("abort", abort, { once: true });
2885
+ child.on("error", (error) => {
2886
+ failure = error;
2887
+ });
2888
+ child.stdin.on("error", () => {});
2889
+ child.stdout.on("data", (chunk) => {
2890
+ if (login) stdout.write(chunk);
2891
+ else {
2892
+ output = (output + chunk.toString("utf8")).slice(0, 8193);
2893
+ if (output.length > 8192) {
2894
+ failure = /* @__PURE__ */ new Error("channel_auth_output_limit");
2895
+ task.controller.abort();
2896
+ }
2897
+ }
2898
+ });
2899
+ child.stderr.on("data", (chunk) => {
2900
+ if (login) stderr.write(chunk);
2901
+ });
2902
+ child.once("close", (code) => {
2903
+ clearTimeout(force);
2904
+ task.controller.signal.removeEventListener("abort", abort);
2905
+ if (login) {
2906
+ stdout.end();
2907
+ stderr.end();
2908
+ }
2909
+ if (failure || code !== 0 || task.controller.signal.aborted) {
2910
+ if (login && code !== 0 && !task.controller.signal.aborted && !failure) publish(task.view, `CLI exited with status ${code ?? "unknown"}.`);
2911
+ reject(failure ?? /* @__PURE__ */ new Error("channel_auth_process_failed"));
2912
+ } else resolve(output);
2913
+ });
2914
+ child.stdin.end(login ? "\n" : void 0);
2915
+ });
2916
+ }
2917
+ function authorize$1(task, raw) {
2918
+ const view = task.view;
2919
+ const text = stripVTControlCharacters(raw);
2920
+ const code = /(?:one[- ]time|device|user) code[:\s]+([A-Z0-9]{4}-[A-Z0-9]{4})\b/i.exec(text);
2921
+ if (code) view.userCode = code[1].toUpperCase();
2922
+ for (const match of text.matchAll(/https:\/\/[^\s'"<>]+/gi)) try {
2923
+ const url = new URL(match[0]);
2924
+ const allowed = view.channelId === "github" ? ["/login/device"] : ["/oauth/device", "/-/oauth/device"];
2925
+ if (url.origin === task.origin && !url.username && !url.password && !url.search && !url.hash && allowed.includes(url.pathname)) view.verificationUri = url.href;
2926
+ } catch {}
2927
+ publish(view, text);
2928
+ }
2929
+ function site(channelId, host) {
2930
+ try {
2931
+ const url = new URL(host);
2932
+ if (url.protocol === "https:" && !url.username && !url.password && !url.search && !url.hash && url.pathname === "/" && (channelId !== "github" || url.origin === "https://github.com")) return url.origin;
2933
+ } catch {}
2934
+ throw new TypeError("invalid_channel_host");
2935
+ }
2936
+ function publish(view, line) {
2937
+ view.output = [view.output, line].filter(Boolean).join("\n").slice(-1024);
2938
+ }
2939
+ function lines(task) {
2940
+ const decoder = new StringDecoder("utf8");
2941
+ let pending = "";
2942
+ let discarded = false;
2943
+ const complete = () => {
2944
+ const text = [...stripVTControlCharacters(pending)].filter((char) => char.charCodeAt(0) >= 32 || char === " ").join("").trim();
2945
+ if (!discarded && /(?:dial tcp|connectex|connection|connect|i\/o|TLS handshake|request|context deadline).*(?:timed? out|timeout|deadline exceeded)|(?:timed? out|timeout).*(?:connect|request)/i.test(text)) task.networkTimeout = true;
2946
+ if (!discarded && text && !/token|password|authorization|secret|gh[pousr]_|github_pat_|glpat[-_]|Bearer\s|\b[\w=-]{40,}\b/i.test(text)) authorize$1(task, text.replace(/https?:\/\/[^\s'"<>]+/gi, (raw) => {
2947
+ try {
2948
+ const url = new URL(raw);
2949
+ const paths = task.view.channelId === "github" ? [
2950
+ "/login/device",
2951
+ "/login/device/code",
2952
+ "/login/oauth/access_token"
2953
+ ] : [
2954
+ "/oauth/device",
2955
+ "/-/oauth/device",
2956
+ "/oauth/device/code",
2957
+ "/oauth/token"
2958
+ ];
2959
+ if (url.origin === task.origin && !url.username && !url.password && paths.includes(url.pathname)) return `${url.origin}${url.pathname}`;
2960
+ } catch {}
2961
+ return "[URL omitted]";
2962
+ }));
2963
+ pending = "";
2964
+ discarded = false;
2965
+ };
2966
+ return {
2967
+ write(chunk) {
2968
+ const parts = decoder.write(chunk).split("\n");
2969
+ for (let index = 0; index < parts.length; index++) {
2970
+ if (!discarded) {
2971
+ if (pending.length + parts[index].length > 4096) {
2972
+ pending = "";
2973
+ discarded = true;
2974
+ } else pending += parts[index];
2975
+ }
2976
+ if (index < parts.length - 1) complete();
2977
+ }
2978
+ },
2979
+ end() {
2980
+ pending += decoder.end();
2981
+ complete();
2982
+ }
2983
+ };
2984
+ }
2985
+ // src/server/routes/channel.[id].authentication.[authenticationId].get.ts
2986
+ var channel__id__authentication__authenticationId__get_default = defineHandler((event) => {
2987
+ const id = getRouterParam(event, "id");
2988
+ const authenticationId = getRouterParam(event, "authenticationId");
2989
+ if (!id || !authenticationId) throw new HTTPError({
2990
+ status: 400,
2991
+ message: "invalid_authentication"
2992
+ });
2993
+ const authentication = devops.lookup(id, authenticationId);
2994
+ if (!authentication) throw new HTTPError({
2995
+ status: 404,
2996
+ message: "channel_auth_not_found"
2997
+ });
2998
+ return authentication;
2999
+ });
3000
+ // src/server/routes/channel.[id].authentication.post.ts
3001
+ var channel__id__authentication_post_default = defineHandler(async (event) => {
3002
+ const id = getRouterParam(event, "id");
3003
+ if (!id) throw new HTTPError({
3004
+ status: 400,
3005
+ message: "invalid_channel"
3006
+ });
3007
+ const body = await readBody(event);
3008
+ if (body !== void 0 && (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => key !== "host") || body.host !== void 0 && typeof body.host !== "string")) throw new HTTPError({
3009
+ status: 400,
3010
+ message: "invalid_authentication"
3011
+ });
3012
+ try {
3013
+ return await devops.start(id, body?.host);
3014
+ } catch (error) {
3015
+ const message = error instanceof Error ? error.message : "";
3016
+ if (message === "channel_unsupported" || message === "invalid_channel_host") throw new HTTPError({
3017
+ status: 400,
3018
+ message
3019
+ });
3020
+ if (message === "channel_auth_in_progress") throw new HTTPError({
3021
+ status: 409,
3022
+ message
3023
+ });
3024
+ throw new HTTPError({
3025
+ status: 503,
3026
+ message: "channel_auth_unavailable"
3027
+ });
3028
+ }
3029
+ });
3030
+ // src/server/routes/channel.[id].configuration.put.ts
3031
+ var channel__id__configuration_put_default = defineHandler(async (event) => {
3032
+ const id = getRouterParam(event, "id");
3033
+ const body = await readBody(event);
3034
+ if (!id || !body) throw new HTTPError({
3035
+ status: 400,
3036
+ message: "invalid_channel_config"
3037
+ });
3038
+ try {
3039
+ return { channel: await devops.save(id, body) };
3040
+ } catch (error) {
3041
+ const message = error instanceof Error && [
3042
+ "channel_unsupported",
3043
+ "invalid_channel_config",
3044
+ "invalid_channel_token",
3045
+ "invalid_commit_identity",
3046
+ "invalid_channel_host",
3047
+ "invalid_expected_account",
3048
+ "channel_identity_mismatch",
3049
+ "channel_account_required",
3050
+ "channel_auth_failed",
3051
+ "channel_verification_failed"
3052
+ ].includes(error.message) ? error.message : "channel_save_failed";
3053
+ throw new HTTPError({
3054
+ status: error instanceof TypeError ? 400 : message === "channel_auth_failed" ? 422 : 502,
3055
+ message
3056
+ });
3057
+ }
3058
+ });
3059
+ // src/server/routes/channel.[id].credential.delete.ts
3060
+ var channel__id__credential_delete_default = defineHandler(async (event) => {
3061
+ const id = getRouterParam(event, "id");
3062
+ if (!id) throw new HTTPError({
3063
+ status: 400,
3064
+ message: "channel_unsupported"
3065
+ });
3066
+ try {
3067
+ await devops.cancel(id);
3068
+ return { channel: await devops.removeCredentials(id) };
3069
+ } catch (error) {
3070
+ const unsupported = error instanceof TypeError && error.message === "channel_unsupported";
3071
+ throw new HTTPError({
3072
+ status: unsupported ? 400 : 502,
3073
+ message: unsupported ? "channel_unsupported" : "channel_credentials_delete_failed"
3074
+ });
3075
+ }
3076
+ });
3077
+ // src/server/routes/channel.get.ts
3078
+ var channel_get_default = defineHandler(async () => channel.list());
3079
+ // src/server/routes/delivery.get.ts
3080
+ var delivery_get_default = defineHandler(async () => db.inbox.listRecent());
3081
+ // src/server/routes/edge.get.ts
3082
+ var edge_get_default = defineHandler(async () => {
3083
+ const [runningWorkers, queuedWorkers, links, openTickets] = await Promise.all([
3084
+ db.worker.listRunning(),
3085
+ db.worker.listQueued(),
3086
+ db.ticketLink.listAll(),
3087
+ db.ticket.listOpen()
3088
+ ]);
3089
+ const activeWorkers = [...new Map([...queuedWorkers, ...runningWorkers].map((worker) => [worker.id, worker])).values()];
3090
+ const runningTicketIds = new Set(runningWorkers.map((worker) => worker.ticketId));
3091
+ const ticketMap = new Map(openTickets.map((ticket) => [ticket.id, ticket]));
3092
+ for (const ticket of await Promise.all([...new Set(activeWorkers.map((worker) => worker.ticketId))].filter((id) => !ticketMap.has(id)).map((id) => db.ticket.findById(id)))) if (ticket) ticketMap.set(ticket.id, ticket);
3093
+ return [
3094
+ ...[...new Set([...ticketMap.values()].map((ticket) => ticket.projectId))].map((projectId) => ({
3095
+ source: "orchestrator",
3096
+ target: `project:${projectId}`,
3097
+ kind: "flow"
3098
+ })),
3099
+ ...[...ticketMap.values()].map((ticket) => ({
3100
+ source: `project:${ticket.projectId}`,
3101
+ target: `ticket:${ticket.id}`,
3102
+ kind: "flow"
3103
+ })),
3104
+ ...activeWorkers.filter((worker) => runningTicketIds.has(worker.ticketId) || ticketMap.has(worker.ticketId)).map((worker) => ({
3105
+ source: `ticket:${worker.ticketId}`,
3106
+ target: `worker:${worker.id}`,
3107
+ kind: "flow"
3108
+ })),
3109
+ ...links.map((link) => ({
3110
+ source: `ticket:${link.ticketId}`,
3111
+ target: `ticket:${link.relatedId}`,
3112
+ kind: link.kind === "depends" ? "dependency" : "association"
3113
+ }))
3114
+ ];
3115
+ });
3116
+ // src/server/routes/group.get.ts
3117
+ var group_get_default = defineHandler(async () => {
3118
+ const [supervisors, scopes, runningWorkers, queuedWorkers, openTickets] = await Promise.all([
3119
+ db.supervisor.listActive(),
3120
+ db.supervisorTicket.listAll(),
3121
+ db.worker.listRunning(),
3122
+ db.worker.listQueued(),
3123
+ db.ticket.listOpen()
3124
+ ]);
3125
+ const activeWorkers = [...new Map([...queuedWorkers, ...runningWorkers].map((worker) => [worker.id, worker])).values()];
3126
+ const runningTicketIds = new Set(runningWorkers.map((worker) => worker.ticketId));
3127
+ const ticketMap = new Map(openTickets.map((ticket) => [ticket.id, ticket]));
3128
+ for (const ticket of await Promise.all([...new Set(activeWorkers.map((worker) => worker.ticketId))].filter((id) => !ticketMap.has(id)).map((id) => db.ticket.findById(id)))) if (ticket) ticketMap.set(ticket.id, ticket);
3129
+ const current = [...ticketMap.values()].filter((ticket) => ![
3130
+ "closed",
3131
+ "done",
3132
+ "cancelled"
3133
+ ].includes(ticket.status) || runningTicketIds.has(ticket.id));
3134
+ return supervisors.map((supervisor) => ({
3135
+ id: `supervisor:${supervisor.id}`,
3136
+ label: supervisor.title,
3137
+ sessionId: supervisor.sessionId,
3138
+ nodeIds: [...new Set(scopes.filter((scope) => scope.supervisorId === supervisor.id).flatMap((scope) => {
3139
+ const ticket = current.find((item) => item.id === scope.ticketId);
3140
+ return ticket ? [`project:${ticket.projectId}`] : [];
3141
+ }))]
3142
+ })).filter((group) => group.nodeIds.length);
3143
+ });
3144
+ // src/server/routes/message.get.ts
3145
+ var message_get_default = defineHandler(async () => db.inbox.listRecent());
3146
+ // src/utils/repository.ts
3147
+ function parseGitRemote(value) {
3148
+ const invalid = () => /* @__PURE__ */ new Error("invalid_repository_remote");
3149
+ if (typeof value !== "string" || !value || value !== value.trim() || /[\s\\%]/.test(value)) throw invalid();
3150
+ const scp = /^git@([^/:]+):(.+)$/.exec(value);
3151
+ let url;
3152
+ try {
3153
+ url = new URL(scp ? `ssh://git@${scp[1]}/${scp[2]}` : value);
3154
+ } catch {
3155
+ throw invalid();
3156
+ }
3157
+ if (!["https:", "ssh:"].includes(url.protocol) || !url.hostname || url.password || url.search || url.hash || (url.protocol === "https:" ? Boolean(url.username) : url.username !== "git" || Boolean(url.port))) throw invalid();
3158
+ const segments = (scp ? scp[2] : value.slice(value.indexOf("://") + 3).replace(/^[^/]+\//, "")).replace(/\/$/, "").replace(/\.git$/, "").split("/");
3159
+ if (segments.length < 2 || !segments.every((segment) => /^\w[\w.-]*$/.test(segment) && !segment.endsWith(".") && !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment))) throw invalid();
3160
+ const owner = segments.slice(0, -1).join("/");
3161
+ const name = segments.at(-1);
3162
+ const webUrl = `https://${url.host}/${segments.join("/")}`;
3163
+ return {
3164
+ host: url.host,
3165
+ owner,
3166
+ name,
3167
+ remoteUrl: url.protocol === "https:" ? `${webUrl}.git` : `git@${url.hostname}:${segments.join("/")}.git`,
3168
+ webUrl
3169
+ };
3170
+ }
3171
+ function parseRepositoryRemote(value, gitlabHost = "https://gitlab.com") {
3172
+ const invalid = () => /* @__PURE__ */ new Error("invalid_repository_remote");
3173
+ let configured;
3174
+ try {
3175
+ configured = new URL(gitlabHost);
3176
+ } catch {
3177
+ throw invalid();
3178
+ }
3179
+ if (configured.protocol !== "https:" || configured.username || configured.password || configured.pathname !== "/" || configured.search || configured.hash) throw invalid();
3180
+ const remote = parseGitRemote(value);
3181
+ const platform = remote.host === "github.com" ? "github" : remote.host === configured.host ? "gitlab" : null;
3182
+ if (!platform || platform === "github" && remote.owner.includes("/")) throw invalid();
3183
+ return {
3184
+ ...remote,
3185
+ platform,
3186
+ defaultName: `${platform}/${remote.name}`
3187
+ };
3188
+ }
3189
+ // src/service/worktree.ts
3190
+ const execute = promisify(execFile);
3191
+ let controller$1 = new AbortController();
3192
+ const worktree = defineService({
3193
+ start() {
3194
+ if (singlet.busy()) throw new Error("worktree_busy");
3195
+ controller$1 = new AbortController();
3196
+ return async () => {
3197
+ controller$1.abort(/* @__PURE__ */ new Error("worktree_stopped"));
3198
+ await Promise.allSettled([singlet.drain()]);
3199
+ };
3200
+ },
3201
+ peek: singlet((directory) => `worktree:peek:${resolve(directory)}`, async (directory) => {
3202
+ const root = await realpath(directory);
3203
+ let gitRoot;
3204
+ try {
3205
+ gitRoot = await git(root, ["rev-parse", "--show-toplevel"]);
3206
+ } catch (error) {
3207
+ if (error instanceof Error && "code" in error && error.code === 128 && "stderr" in error && typeof error.stderr === "string" && error.stderr.includes("not a git repository")) return null;
3208
+ throw error;
3209
+ }
3210
+ if (!samePath$1(gitRoot, root)) return null;
3211
+ return {
3212
+ directory: root,
3213
+ remoteUrl: (await git(root, ["remote"])).split(String.fromCharCode(10)).includes("origin") ? await git(root, [
3214
+ "config",
3215
+ "--get",
3216
+ "remote.origin.url"
3217
+ ]) : null
3218
+ };
3219
+ }),
3220
+ clone: singlet((remoteUrl, target) => `worktree:clone:${process.platform === "win32" ? resolve(target).toLowerCase() : resolve(target)}:${remoteUrl}`, async (remoteUrl, target, gitlabHost, signal) => {
3221
+ signal?.throwIfAborted();
3222
+ const repository = parseRepositoryRemote(remoteUrl, gitlabHost);
3223
+ const result = await (async () => {
3224
+ if (!isAbsolute(target)) throw new Error("invalid_repository_path");
3225
+ const existing = await existingRepository(target, repository.webUrl, gitlabHost);
3226
+ if (existing) return existing;
3227
+ await mkdir(dirname(target), { recursive: true });
3228
+ if (!samePath$1(await realpath(dirname(target)), dirname(target))) throw new Error("repository_path_conflict");
3229
+ const temporary = await mkdtemp(join(dirname(target), ".supermesh-clone-"));
3230
+ try {
3231
+ await git(temporary, [
3232
+ "-c",
3233
+ "http.followRedirects=false",
3234
+ "-c",
3235
+ "protocol.file.allow=never",
3236
+ "clone",
3237
+ "--",
3238
+ repository.remoteUrl,
3239
+ temporary
3240
+ ], signal, 12e4);
3241
+ const facts = await worktree.peek(temporary);
3242
+ if (!facts?.remoteUrl || parseRepositoryRemote(facts.remoteUrl, gitlabHost).webUrl !== repository.webUrl) throw new Error("repository_remote_mismatch");
3243
+ signal?.throwIfAborted();
3244
+ controller$1.signal.throwIfAborted();
3245
+ const raced = await existingRepository(target, repository.webUrl, gitlabHost);
3246
+ if (raced) return raced;
3247
+ await rename(temporary, target);
3248
+ return {
3249
+ directory: await realpath(target),
3250
+ remoteUrl: repository.remoteUrl
3251
+ };
3252
+ } finally {
3253
+ await rm(temporary, {
3254
+ recursive: true,
3255
+ force: true
3256
+ });
3257
+ }
3258
+ })();
3259
+ if (parseRepositoryRemote(result.remoteUrl, gitlabHost).webUrl !== repository.webUrl) throw new Error("repository_path_conflict");
3260
+ return result;
3261
+ }),
3262
+ async create(agent, ticketId) {
3263
+ if (!/^[a-z0-9][\w-]*$/i.test(ticketId)) throw new Error("invalid_worktree_identity");
3264
+ const branch = `dsh/${ticketId}`;
3265
+ const ctx = getServerContext(server);
3266
+ if (!ctx.worktrees) throw new Error("worktrees_unavailable");
3267
+ const created = await ctx.worktrees.create(agent, {
3268
+ name: branch,
3269
+ from: "HEAD"
3270
+ });
3271
+ if (created.branch !== branch) throw new Error("worktree_branch_conflict");
3272
+ return {
3273
+ branch: created.branch,
3274
+ worktree: created.path,
3275
+ baseCommit: created.baseCommit,
3276
+ repositoryRoot: created.repositoryRoot
3277
+ };
3278
+ },
3279
+ verify: singlet((_directory, target) => `worktree:verify:${resolve(target)}`, async (directory, target, branch) => {
3280
+ const root = await realpath(directory);
3281
+ const actual = await realpath(target);
3282
+ if (samePath$1(root, actual) || !samePath$1(target, actual)) throw new Error("worktree_path_conflict");
3283
+ const registered = (await git(root, [
3284
+ "worktree",
3285
+ "list",
3286
+ "--porcelain",
3287
+ "-z"
3288
+ ])).split("\0\0").map((entry) => entry.split("\0")).find((fields) => fields.some((field) => field.startsWith("worktree ") && samePath$1(field.slice(9), actual)));
3289
+ if (!registered || registered.some((field) => field === "locked" || field.startsWith("locked "))) throw new Error("worktree_registration_conflict");
3290
+ if (!samePath$1(resolve(root, await git(root, ["rev-parse", "--git-common-dir"])), resolve(actual, await git(actual, ["rev-parse", "--git-common-dir"]))) || await git(actual, ["branch", "--show-current"]) !== branch) throw new Error("worktree_branch_conflict");
3291
+ })
3292
+ });
3293
+ async function existingRepository(target, webUrl, gitlabHost) {
3294
+ try {
3295
+ const entry = await lstat(target);
3296
+ if (!entry.isDirectory() || entry.isSymbolicLink() || !samePath$1(target, await realpath(target))) throw new Error("repository_path_conflict");
3297
+ } catch (error) {
3298
+ if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
3299
+ throw error;
3300
+ }
3301
+ const facts = await worktree.peek(target);
3302
+ if (!facts?.remoteUrl) throw new Error("repository_path_conflict");
3303
+ let remote;
3304
+ try {
3305
+ remote = parseRepositoryRemote(facts.remoteUrl, gitlabHost);
3306
+ } catch {
3307
+ throw new Error("repository_path_conflict");
3308
+ }
3309
+ if (remote.webUrl !== webUrl) throw new Error("repository_path_conflict");
3310
+ return {
3311
+ directory: facts.directory,
3312
+ remoteUrl: remote.remoteUrl
3313
+ };
3314
+ }
3315
+ async function git(cwd, args, signal, timeout = 15e3) {
3316
+ const operationSignal = signal ? AbortSignal.any([controller$1.signal, signal]) : controller$1.signal;
3317
+ operationSignal.throwIfAborted();
3318
+ return (await execute("git", args, {
3319
+ cwd,
3320
+ signal: operationSignal,
3321
+ timeout,
3322
+ maxBuffer: 4194304,
3323
+ windowsHide: true,
3324
+ env: {
3325
+ ...process.env,
3326
+ LC_ALL: "C",
3327
+ GIT_TERMINAL_PROMPT: "0",
3328
+ GCM_INTERACTIVE: "never",
3329
+ GIT_SSH_COMMAND: "ssh -oBatchMode=yes -oStrictHostKeyChecking=yes -oConnectTimeout=15"
3330
+ }
3331
+ })).stdout.trim();
3332
+ }
3333
+ function samePath$1(left, right) {
3334
+ return process.platform === "win32" ? resolve(left).toLowerCase() === resolve(right).toLowerCase() : resolve(left) === resolve(right);
3335
+ }
3336
+ // src/service/project.ts
3337
+ let syncing;
3338
+ let controller = new AbortController();
3339
+ let stopped$1 = false;
3340
+ const repositories = /* @__PURE__ */ new Map();
3341
+ const project = defineService({
3342
+ start() {
3343
+ if (repositories.size || syncing) throw new Error("project_busy");
3344
+ controller = new AbortController();
3345
+ stopped$1 = false;
3346
+ return async () => {
3347
+ stopped$1 = true;
3348
+ controller.abort(/* @__PURE__ */ new Error("project_stopped"));
3349
+ await Promise.allSettled([...repositories.values(), ...syncing ? [syncing] : []]);
3350
+ };
3351
+ },
3352
+ async list() {
3353
+ const rows = await db.project.listAll();
3354
+ const workspaces = getServerContext(server).workspaceRegistry.list();
3355
+ return Promise.all(rows.map(async (current) => {
3356
+ const workspace = workspaces.find((workspace) => workspace.id === current.workspaceId);
3357
+ const facts = workspace && await workspace.status() === "ok" ? await repositoryFacts(workspace.path) : null;
3358
+ return {
3359
+ ...current,
3360
+ available: Boolean(facts?.remoteUrl && samePath(facts.directory, current.directory) && facts.remoteUrl === current.remoteUrl)
3361
+ };
3362
+ }));
3363
+ },
3364
+ addRepository(remoteUrl, name, signal) {
3365
+ return addRepository(remoteUrl, name, signal);
3366
+ },
3367
+ async open(id, signal) {
3368
+ const current = await db.project.findById(id);
3369
+ if (!current) throw new Error("project_not_found");
3370
+ const ctx = getServerContext(server);
3371
+ if (!ctx.sessionController.canOpenWorkspacePath()) throw new Error("native_open_unavailable");
3372
+ return ctx.sessionController.openWorkspacePath({ path: current.directory }, signal);
3373
+ },
3374
+ sync() {
3375
+ if (stopped$1) return Promise.reject(/* @__PURE__ */ new Error("project_stopped"));
3376
+ return queueSync();
3377
+ }
3378
+ });
3379
+ async function addRepository(remoteUrl, name, requestSignal) {
3380
+ if (stopped$1) throw new Error("project_stopped");
3381
+ const signal = requestSignal ? AbortSignal.any([controller.signal, requestSignal]) : controller.signal;
3382
+ const remote = parseGitRemote(remoteUrl);
3383
+ const platform = remote.host === "github.com" ? "github" : remote.host;
3384
+ if (name !== void 0 && (typeof name !== "string" || !name.trim() || name.trim().length > 200 || [...name].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127))) throw new Error("invalid_workspace_name");
3385
+ const active = repositories.get(remote.webUrl);
3386
+ if (active) return active;
3387
+ const task = (async () => {
3388
+ signal?.throwIfAborted();
3389
+ const registry = getServerContext(server).workspaceRegistry;
3390
+ let directory;
3391
+ for (const workspace of registry.list()) {
3392
+ if (await workspace.status() !== "ok") continue;
3393
+ const facts = await repositoryFacts(workspace.path);
3394
+ if (facts?.remoteUrl === remote.webUrl) {
3395
+ directory = facts.directory;
3396
+ break;
3397
+ }
3398
+ }
3399
+ if (!directory) {
3400
+ const target = join(DSH_PLUGIN_HOME, "repositories", platform, remote.host.replace(":", "_"), remote.owner, remote.name);
3401
+ try {
3402
+ directory = (await worktree.clone(remote.remoteUrl, resolve(target), void 0, signal)).directory;
3403
+ } catch (error) {
3404
+ if (signal?.aborted || error instanceof Error && error.name === "AbortError") throw new Error("repository_clone_cancelled");
3405
+ if (error instanceof Error && [
3406
+ "repository_path_conflict",
3407
+ "repository_remote_mismatch",
3408
+ "worktree_stopped"
3409
+ ].includes(error.message)) throw error;
3410
+ if (error instanceof Error && "killed" in error && error.killed) throw new Error("repository_clone_timeout");
3411
+ throw new Error("repository_clone_failed");
3412
+ }
3413
+ }
3414
+ signal.throwIfAborted();
3415
+ if (parseGitRemote(remoteUrl).webUrl !== remote.webUrl || (await repositoryFacts(directory))?.remoteUrl !== remote.webUrl) throw new Error("repository_remote_mismatch");
3416
+ signal.throwIfAborted();
3417
+ const workspace = await registry.create(directory, name?.trim() ?? `${platform}/${remote.name}`);
3418
+ await queueSync();
3419
+ const current = await db.project.findByWorkspace(workspace.id);
3420
+ if (!current) throw new Error("repository_registration_failed");
3421
+ return {
3422
+ project: current,
3423
+ workspaceId: workspace.id
3424
+ };
3425
+ })().finally(() => repositories.delete(remote.webUrl));
3426
+ repositories.set(remote.webUrl, task);
3427
+ return task;
3428
+ }
3429
+ function queueSync() {
3430
+ const task = (syncing ? syncing.then(synchronize, synchronize) : synchronize()).finally(() => {
3431
+ if (syncing === task) syncing = void 0;
3432
+ });
3433
+ syncing = task;
3434
+ return task;
3435
+ }
3436
+ async function synchronize() {
3437
+ const registry = getServerContext(server).workspaceRegistry;
3438
+ const available = [];
3439
+ const now = (/* @__PURE__ */ new Date()).toISOString();
3440
+ for (const workspace of registry.list()) {
3441
+ if (await workspace.status() !== "ok") continue;
3442
+ const facts = await repositoryFacts(workspace.path);
3443
+ if (!facts) continue;
3444
+ const current = await db.project.findByWorkspace(workspace.id);
3445
+ if (!current && !facts.remoteUrl) continue;
3446
+ if (facts.remoteUrl) available.push(workspace.id);
3447
+ await db.project.upsertWorkspace({
3448
+ id: current?.id ?? workspace.id,
3449
+ workspaceId: workspace.id,
3450
+ name: workspace.title,
3451
+ directory: facts.directory,
3452
+ remoteUrl: facts.remoteUrl
3453
+ }, now);
3454
+ }
3455
+ await db.project.disableUnavailable(available, now);
3456
+ return db.project.listAll();
3457
+ }
3458
+ async function repositoryFacts(directory) {
3459
+ let facts;
3460
+ try {
3461
+ facts = await worktree.peek(directory);
3462
+ } catch (error) {
3463
+ if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
3464
+ throw error;
3465
+ }
3466
+ if (!facts?.remoteUrl) return facts;
3467
+ try {
3468
+ return {
3469
+ ...facts,
3470
+ remoteUrl: parseGitRemote(facts.remoteUrl).webUrl
3471
+ };
3472
+ } catch {
3473
+ return {
3474
+ ...facts,
3475
+ remoteUrl: null
3476
+ };
3477
+ }
3478
+ }
3479
+ function samePath(left, right) {
3480
+ return process.platform === "win32" ? resolve(left).toLowerCase() === resolve(right).toLowerCase() : resolve(left) === resolve(right);
3481
+ }
3482
+ // src/server/routes/node.get.ts
3483
+ var node_get_default = defineHandler(async () => {
3484
+ const [projects, runningWorkers, queuedWorkers, openTickets, channelCatalog] = await Promise.all([
3485
+ project.list(),
3486
+ db.worker.listRunning(),
3487
+ db.worker.listQueued(),
3488
+ db.ticket.listOpen(),
3489
+ channel.list()
3490
+ ]);
3491
+ async function activity(id, role, projectId) {
3492
+ if (!id) return {
3493
+ sessionId: null,
3494
+ status: "not_created"
3495
+ };
3496
+ const identity = await session.resolve(id);
3497
+ if (identity?.role !== role || role === "project" && identity.projectId !== projectId) return {
3498
+ sessionId: null,
3499
+ status: "not_created"
3500
+ };
3501
+ const state = await session.activity(id);
3502
+ return {
3503
+ sessionId: id,
3504
+ status: state.running ? "running" : state.background ? "background" : state.queued ? "queued" : "idle"
3505
+ };
3506
+ }
3507
+ const mainBinding = await activity(await session.findMain(), "main");
3508
+ const projectBindings = await Promise.all(projects.map(async (item) => ({
3509
+ id: item.id,
3510
+ ...await activity(item.orchestratorSessionId ?? null, "project", item.id)
3511
+ })));
3512
+ const projectSessions = new Map(projectBindings.map((item) => [item.id, item]));
3513
+ const activeWorkers = [...new Map([...queuedWorkers, ...runningWorkers].map((worker) => [worker.id, worker])).values()];
3514
+ const runningTicketIds = new Set(runningWorkers.map((worker) => worker.ticketId));
3515
+ const ticketMap = new Map(openTickets.map((ticket) => [ticket.id, ticket]));
3516
+ for (const ticket of await Promise.all([...new Set(activeWorkers.map((worker) => worker.ticketId))].filter((id) => !ticketMap.has(id)).map((id) => db.ticket.findById(id)))) if (ticket) ticketMap.set(ticket.id, ticket);
3517
+ const currentTickets = [...ticketMap.values()].filter((ticket) => ![
3518
+ "closed",
3519
+ "done",
3520
+ "cancelled"
3521
+ ].includes(ticket.status) || runningTicketIds.has(ticket.id));
3522
+ const currentTicketIds = new Set(currentTickets.map((ticket) => ticket.id));
3523
+ const currentWorkers = activeWorkers.filter((worker) => currentTicketIds.has(worker.ticketId) && (worker.status === "running" || ![
3524
+ "closed",
3525
+ "done",
3526
+ "cancelled"
3527
+ ].includes(ticketMap.get(worker.ticketId).status)));
3528
+ const currentProjects = projects.filter((item) => [
3529
+ "running",
3530
+ "background",
3531
+ "queued"
3532
+ ].includes(projectSessions.get(item.id).status) || currentTickets.some((ticket) => ticket.projectId === item.id));
3533
+ const hasRuntime = currentTickets.length > 0 || currentProjects.length > 0 || [
3534
+ "running",
3535
+ "background",
3536
+ "queued"
3537
+ ].includes(mainBinding.status);
3538
+ const channels = channelCatalog.filter((item) => item.configured && item.supported && currentTickets.some((ticket) => ticket.channelId === item.id));
3539
+ return [
3540
+ ...channels.length ? [{
3541
+ id: "channel",
3542
+ kind: "channel",
3543
+ label: channels.map((item) => item.name).join(" · "),
3544
+ status: "configured",
3545
+ projectId: null,
3546
+ ticketId: null,
3547
+ sessionId: null
3548
+ }] : [],
3549
+ ...hasRuntime ? [{
3550
+ id: "orchestrator",
3551
+ kind: "orchestrator",
3552
+ label: mainBinding.sessionId ?? "",
3553
+ status: mainBinding.status,
3554
+ projectId: null,
3555
+ ticketId: null,
3556
+ sessionId: mainBinding.sessionId
3557
+ }] : [],
3558
+ ...currentProjects.map((item) => ({
3559
+ id: `project:${item.id}`,
3560
+ kind: "project",
3561
+ label: item.name,
3562
+ status: projectSessions.get(item.id).status,
3563
+ projectId: item.id,
3564
+ ticketId: null,
3565
+ sessionId: projectSessions.get(item.id).sessionId
3566
+ })),
3567
+ ...currentTickets.map((ticket) => ({
3568
+ id: `ticket:${ticket.id}`,
3569
+ kind: "ticket",
3570
+ label: ticket.title,
3571
+ status: ticket.paused ? "paused" : ticket.prepareError ? "error" : ticket.status,
3572
+ projectId: ticket.projectId,
3573
+ ticketId: ticket.id,
3574
+ sessionId: null
3575
+ })),
3576
+ ...currentWorkers.map((worker) => ({
3577
+ id: `worker:${worker.id}`,
3578
+ kind: "worker",
3579
+ label: worker.title,
3580
+ status: worker.status,
3581
+ projectId: ticketMap.get(worker.ticketId).projectId,
3582
+ ticketId: worker.ticketId,
3583
+ sessionId: worker.status === "running" ? worker.id : null
3584
+ }))
3585
+ ];
3586
+ });
3587
+ // src/server/routes/pending.get.ts
3588
+ var pending_get_default = defineHandler(async () => {
3589
+ const [pending, openTickets] = await Promise.all([db.inbox.listPending("user"), db.ticket.listOpen()]);
3590
+ return pending.filter((message) => !message.ticketId || openTickets.some((ticket) => ticket.id === message.ticketId));
3591
+ });
3592
+ // src/server/routes/project.[id].opening.post.ts
3593
+ var project__id__opening_post_default = defineHandler(async (event) => {
3594
+ const id = getRouterParam(event, "id", { decode: true });
3595
+ if (!id?.trim()) throw new HTTPError({
3596
+ status: 400,
3597
+ message: "project_id_required"
3598
+ });
3599
+ try {
3600
+ return await project.open(id, event.req.signal);
3601
+ } catch (error) {
3602
+ const message = error instanceof Error ? error.message : "repository_open_failed";
3603
+ throw new HTTPError({
3604
+ status: message === "project_not_found" ? 404 : message === "native_open_unavailable" ? 503 : 502,
3605
+ message
3606
+ });
3607
+ }
3608
+ });
3609
+ // src/server/routes/project.[id].patch.ts
3610
+ var project__id__patch_default = defineHandler(async (event) => {
3611
+ const id = getRouterParam(event, "id", { decode: true });
3612
+ const body = await readBody(event);
3613
+ if (!id?.trim() || !body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => key !== "enabled") || typeof body.enabled !== "boolean") throw new HTTPError({
3614
+ status: 400,
3615
+ message: "invalid_enabled"
3616
+ });
3617
+ const current = await db.project.findById(id);
3618
+ if (!current) throw new HTTPError({
3619
+ status: 404,
3620
+ message: "not_found"
3621
+ });
3622
+ if (body.enabled && !current.remoteUrl?.trim()) throw new HTTPError({
3623
+ status: 409,
3624
+ message: "repository_identity_unverified"
3625
+ });
3626
+ const project = await db.project.setEnabled(id, body.enabled, (/* @__PURE__ */ new Date()).toISOString());
3627
+ if (!project) throw new HTTPError({
3628
+ status: 409,
3629
+ message: "project_unavailable"
3630
+ });
3631
+ return project;
3632
+ });
3633
+ // src/server/routes/project.[id].session.put.ts
3634
+ var project__id__session_put_default = defineHandler(async (event) => {
3635
+ const id = getRouterParam(event, "id", { decode: true });
3636
+ if (!id?.trim()) throw new HTTPError({
3637
+ status: 400,
3638
+ message: "project_id_required"
3639
+ });
3640
+ try {
3641
+ return { sessionId: await session.create("project", { projectId: id }) };
3642
+ } catch (error) {
3643
+ const message = error instanceof Error ? error.message : "session_open_failed";
3644
+ throw new HTTPError({
3645
+ status: message === "project_not_found" ? 404 : message === "session_binding_conflict" ? 409 : message === "runtime_stopping" ? 503 : 502,
3646
+ message
3647
+ });
3648
+ }
3649
+ });
3650
+ // src/server/routes/project.get.ts
3651
+ var project_get_default = defineHandler(async () => {
3652
+ const projects = await project.list();
3653
+ return Promise.all(projects.map(async (item) => {
3654
+ const id = item.orchestratorSessionId ?? null;
3655
+ let status = "not_created";
3656
+ let sessionId = null;
3657
+ if (id) {
3658
+ const identity = await session.resolve(id);
3659
+ if (identity?.role === "project" && identity.projectId === item.id) {
3660
+ const activity = await session.activity(id);
3661
+ status = activity.running ? "running" : activity.background ? "background" : activity.queued ? "queued" : "idle";
3662
+ sessionId = id;
3663
+ }
3664
+ }
3665
+ return {
3666
+ ...item,
3667
+ session: {
3668
+ sessionId,
3669
+ status
3670
+ }
3671
+ };
3672
+ }));
3673
+ });
3674
+ // src/server/routes/project.post.ts
3675
+ var project_post_default = defineHandler(async () => project.sync());
3676
+ // src/server/routes/project.repository.post.ts
3677
+ var project_repository_post_default = defineHandler(async (event) => {
3678
+ const body = await readBody(event);
3679
+ if (!body || typeof body.remoteUrl !== "string" || body.name !== void 0 && typeof body.name !== "string") throw new HTTPError({
3680
+ status: 400,
3681
+ message: "invalid_repository_request"
3682
+ });
3683
+ try {
3684
+ return await project.addRepository(body.remoteUrl, body.name, event.req.signal);
3685
+ } catch (error) {
3686
+ const reason = error instanceof Error ? error.message : "";
3687
+ const invalid = ["invalid_repository_remote", "invalid_workspace_name"].includes(reason);
3688
+ const conflict = ["repository_path_conflict", "repository_remote_mismatch"].includes(reason);
3689
+ const cancelled = reason === "repository_clone_cancelled";
3690
+ const message = invalid || conflict || cancelled || [
3691
+ "repository_clone_timeout",
3692
+ "repository_clone_failed",
3693
+ "repository_registration_failed"
3694
+ ].includes(reason) ? reason : "repository_registration_failed";
3695
+ throw new HTTPError({
3696
+ status: invalid ? 400 : conflict ? 409 : cancelled ? 408 : message === "repository_clone_timeout" ? 504 : 502,
3697
+ message
3698
+ });
3699
+ }
3700
+ });
3701
+ // src/server/routes/scope.get.ts
3702
+ var scope_get_default = defineHandler(async () => db.supervisorTicket.listAll());
3703
+ // src/server/routes/session.[id].context.get.ts
3704
+ var session__id__context_get_default = defineHandler(async (event) => {
3705
+ const id = getRouterParam(event, "id", { decode: true });
3706
+ if (!id?.trim()) throw new HTTPError({
3707
+ status: 400,
3708
+ message: "invalid_session"
3709
+ });
3710
+ const identity = await session.resolve(id);
3711
+ if (!identity) throw new HTTPError({
3712
+ status: 404,
3713
+ message: "unknown_session"
3714
+ });
3715
+ const context = await session.view(id, 0, 12e3);
3716
+ return {
3717
+ sessionId: id,
3718
+ role: identity.role,
3719
+ pendingCount: (await inbox.peek(id)).pendingCount,
3720
+ ...context
3721
+ };
3722
+ });
3723
+ // src/server/routes/session.[id].mailbox.[messageId].patch.ts
3724
+ var session__id__mailbox__messageId__patch_default = defineHandler(async (event) => {
3725
+ const body = await readBody(event);
3726
+ if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => key !== "status") || body.status !== "done") throw new HTTPError({
3727
+ status: 400,
3728
+ message: "invalid_mail_patch"
3729
+ });
3730
+ const id = getRouterParam(event, "id", { decode: true });
3731
+ const messageId = getRouterParam(event, "messageId", { decode: true });
3732
+ if (!id?.trim() || !messageId?.trim()) throw new HTTPError({
3733
+ status: 400,
3734
+ message: "invalid_parameters"
3735
+ });
3736
+ const mailbox = await inbox.peek(id);
3737
+ if (!mailbox) throw new HTTPError({
3738
+ status: 404,
3739
+ message: "unknown_session"
3740
+ });
3741
+ const message = mailbox.messages.find((message) => message.id === messageId);
3742
+ if (!message) throw new HTTPError({
3743
+ status: 403,
3744
+ message: "scope_denied"
3745
+ });
3746
+ if (message.kind === "ask") throw new HTTPError({
3747
+ status: 409,
3748
+ message: "answer_required"
3749
+ });
3750
+ return { completed: await inbox.complete(id, [messageId]) };
3751
+ });
3752
+ // src/server/routes/session.[id].mailbox.get.ts
3753
+ var session__id__mailbox_get_default = defineHandler(async (event) => {
3754
+ const id = getRouterParam(event, "id", { decode: true });
3755
+ if (!id?.trim()) throw new HTTPError({
3756
+ status: 400,
3757
+ message: "invalid_session"
3758
+ });
3759
+ return { mailbox: await inbox.peek(id) };
3760
+ });
3761
+ // src/server/routes/session.open.post.ts
3762
+ var session_open_post_default = defineHandler(async () => {
3763
+ try {
3764
+ return { sessionId: await session.create("main", {}) };
3765
+ } catch (error) {
3766
+ const message = error instanceof Error ? error.message : "session_open_failed";
3767
+ throw new HTTPError({
3768
+ status: message === "ambiguous_main_session" ? 409 : message === "runtime_stopping" ? 503 : 502,
3769
+ message
3770
+ });
3771
+ }
3772
+ });
3773
+ // src/server/routes/session.role.get.ts
3774
+ var session_role_get_default = defineHandler(async () => {
3775
+ const [mainSessionId, projects, supervisors, workers] = await Promise.all([
3776
+ storage.getItem("orchestrator.id"),
3777
+ db.project.listAll(),
3778
+ db.supervisor.listByStatus("active"),
3779
+ db.worker.listRecent()
3780
+ ]);
3781
+ return { sessions: [
3782
+ ...mainSessionId ? [{
3783
+ sessionId: mainSessionId,
3784
+ role: "main"
3785
+ }] : [],
3786
+ ...projects.flatMap((project) => project.orchestratorSessionId ? [{
3787
+ sessionId: project.orchestratorSessionId,
3788
+ role: "project"
3789
+ }] : []),
3790
+ ...supervisors.flatMap((supervisor) => supervisor.sessionId ? [{
3791
+ sessionId: supervisor.sessionId,
3792
+ role: "supervisor"
3793
+ }] : []),
3794
+ ...workers.map((worker) => ({
3795
+ sessionId: worker.id,
3796
+ role: "worker"
3797
+ }))
3798
+ ] };
3799
+ });
3800
+ // src/server/routes/setting.get.ts
3801
+ var setting_get_default = defineHandler(async () => setting.load());
3802
+ // src/server/routes/setting.patch.ts
3803
+ var setting_patch_default = defineHandler(async (event) => {
3804
+ const body = await readBody(event);
3805
+ if (!body) throw new HTTPError({
3806
+ status: 400,
3807
+ message: "invalid_config"
3808
+ });
3809
+ try {
3810
+ return await setting.save(body);
3811
+ } catch (error) {
3812
+ if (error instanceof TypeError && error.message === "invalid_config") throw new HTTPError({
3813
+ status: 400,
3814
+ message: "invalid_config"
3815
+ });
3816
+ throw error;
3817
+ }
3818
+ });
3819
+ // src/server/routes/status.get.ts
3820
+ var status_get_default = defineHandler(async () => {
3821
+ const [projects, runningWorkers, queuedWorkers, messages, mainSessionId] = await Promise.all([
3822
+ project.list(),
3823
+ db.worker.listRunning(),
3824
+ db.worker.listQueued(),
3825
+ db.inbox.listRecent(),
3826
+ session.findMain()
3827
+ ]);
3828
+ const bindings = [...mainSessionId ? [{ sessionId: mainSessionId }] : [], ...projects.flatMap((item) => item.orchestratorSessionId ? [{ sessionId: item.orchestratorSessionId }] : [])];
3829
+ const activities = await Promise.all(bindings.map(async (binding) => await session.resolve(binding.sessionId) ? await session.activity(binding.sessionId) : {
3830
+ running: false,
3831
+ background: false,
3832
+ queued: false
3833
+ }));
3834
+ const failed = messages.find((message) => message.status === "stalled" || message.status === "pending" && message.deliveryError);
3835
+ const active = activities.some((activity) => activity.running || activity.background);
3836
+ const queued = queuedWorkers.length > 0 || activities.some((activity) => activity.queued);
3837
+ return {
3838
+ state: failed ? "delivery_failed" : runningWorkers.length || active ? "running" : queued ? "queued" : "idle",
3839
+ reason: failed?.deliveryError ?? null
3840
+ };
3841
+ });
3842
+ // src/server/routes/subscription.get.ts
3843
+ var subscription_get_default = defineHandler(async () => db.ticketThread.listAll());
3844
+ // src/server/routes/supervisor.get.ts
3845
+ var supervisor_get_default = defineHandler(async () => db.supervisor.listActive());
3846
+ // src/server/routes/thread.get.ts
3847
+ var thread_get_default = defineHandler(async () => db.thread.listRecent(1e3));
3848
+ // src/server/routes/ticket.[id].get.ts
3849
+ var ticket__id__get_default = defineHandler(async (event) => {
3850
+ const id = getRouterParam(event, "id", { decode: true });
3851
+ if (!id?.trim()) throw new HTTPError({
3852
+ status: 400,
3853
+ message: "invalid_ticket"
3854
+ });
3855
+ const ticket = await db.ticket.findById(id);
3856
+ if (!ticket) throw new HTTPError({
3857
+ status: 404,
3858
+ message: "not_found"
3859
+ });
3860
+ const [project, executions, outgoing, incoming, subscriptions, inbox] = await Promise.all([
3861
+ db.project.findById(ticket.projectId),
3862
+ db.worker.listByTicket(id),
3863
+ db.ticketLink.listByTicket(id),
3864
+ db.ticketLink.listByRelated(id),
3865
+ db.ticketThread.listByTicket(id),
3866
+ db.inbox.listByTicket(id)
3867
+ ]);
3868
+ const topics = (await Promise.all(subscriptions.map((link) => db.thread.findById(link.threadId)))).filter((topic) => topic !== void 0);
3869
+ const triggers = (await Promise.all(topics.map((topic) => db.trigger.listByThread(topic.id)))).flat();
3870
+ const dependencies = [...outgoing, ...incoming.filter((link) => !outgoing.some((other) => other.ticketId === link.ticketId && other.relatedId === link.relatedId && other.kind === link.kind))];
3871
+ return {
3872
+ ticket,
3873
+ project: project ?? null,
3874
+ executions,
3875
+ dependencies,
3876
+ subscriptions,
3877
+ topics,
3878
+ triggers,
3879
+ inbox
3880
+ };
3881
+ });
3882
+ // src/service/archive.ts
3883
+ const archive = defineService({ async session(id) {
3884
+ if (!(await setting.load()).autoArchiveWorkers) return false;
3885
+ const ctx = getServerContext(server);
3886
+ await session.stop(id).catch(() => void 0);
3887
+ for (let attempt = 0; attempt < 3; attempt++) try {
3888
+ await ctx.workspaceRegistry.archiveSession(id, { stopActivity: true });
3889
+ return true;
3890
+ } catch (error) {
3891
+ if (attempt === 2) {
3892
+ ctx.logger.warn("supermesh: archiving session %s failed: %s", id, error instanceof Error ? error.message : String(error));
3893
+ return false;
3894
+ }
3895
+ await new Promise((resolve) => setTimeout(resolve, 500));
3896
+ }
3897
+ return false;
3898
+ } });
3899
+ // src/service/worker.ts
3900
+ const eventQueues = /* @__PURE__ */ new Map();
3901
+ let stopped = false;
3902
+ let observing = false;
3903
+ const worker = defineService({
3904
+ start() {
3905
+ if (singlet.busy("worker:slots") || eventQueues.size) throw new Error("worker_busy");
3906
+ stopped = false;
3907
+ observing = true;
3908
+ return async () => {
3909
+ stopped = true;
3910
+ observing = false;
3911
+ while (singlet.keys().some((key) => key.startsWith("worker:")) || eventQueues.size) await Promise.allSettled([singlet.drain(), ...[...eventQueues.values()]]);
3912
+ };
3913
+ },
3914
+ reconcile: singlet("worker:slots", async () => {
3915
+ const settings = await setting.load();
3916
+ for (const worker of await db.worker.listRunning()) {
3917
+ if (stopped) break;
3918
+ const ticket = await db.ticket.findById(worker.ticketId);
3919
+ if (!ticket || ticket.status === "done" || ticket.status === "cancelled") continue;
3920
+ if (ticket.prState === "merged" || ticket.prState === "closed") {
3921
+ const now = (/* @__PURE__ */ new Date()).toISOString();
3922
+ await db.worker.end(worker.id, "stopped", now);
3923
+ await finishTicket(ticket.id, "done", now, now);
3924
+ await releaseDependents(ticket.id);
3925
+ continue;
3926
+ }
3927
+ const activity = await session.activity(worker.id).catch(() => null);
3928
+ if (activity && (activity.running || activity.background || activity.queued)) continue;
3929
+ const started = worker.startedAt ? Date.parse(worker.startedAt) : NaN;
3930
+ if (Number.isFinite(started) && Date.now() - started < 12e4) continue;
3931
+ const last = await session.lastActivity(worker.id);
3932
+ if (last && Date.now() - last < 12e4) continue;
3933
+ const now = (/* @__PURE__ */ new Date()).toISOString();
3934
+ await db.worker.end(worker.id, worker.reportState === "ready" ? "completed" : "stopped", now);
3935
+ await db.ticket.update(ticket.id, {
3936
+ status: worker.reportState === "ready" ? "review" : "waiting",
3937
+ updatedAt: now
3938
+ });
3939
+ }
3940
+ for (const waiting of await db.ticket.listFiltered({ status: "waiting" })) {
3941
+ if (stopped) break;
3942
+ if (waiting.paused || waiting.prepareError) continue;
3943
+ if (await blockedByDependency(waiting.id)) continue;
3944
+ if (!(await db.ticketLink.listDependsOn(waiting.id)).length) continue;
3945
+ if ((await db.worker.listByTicket(waiting.id)).some((worker) => worker.status !== "ended")) continue;
3946
+ await db.ticket.update(waiting.id, {
3947
+ status: "queued",
3948
+ updatedAt: (/* @__PURE__ */ new Date()).toISOString()
3949
+ });
3950
+ await db.worker.queue(waiting.id, waiting.projectId).catch(() => void 0);
3951
+ }
3952
+ let running = (await db.worker.listRunning()).length;
3953
+ const queueable = [...await db.worker.listQueued()];
3954
+ for (const waiting of await db.ticket.listFiltered({ status: "waiting" })) {
3955
+ if (waiting.paused || waiting.prepareError) continue;
3956
+ if (waiting.prState === "merged" || waiting.prState === "closed") continue;
3957
+ if (await blockedByDependency(waiting.id)) continue;
3958
+ if ((await db.worker.listByTicket(waiting.id)).some((worker) => worker.status !== "ended")) continue;
3959
+ await db.worker.queue(waiting.id, waiting.projectId).catch(() => void 0);
3960
+ }
3961
+ for (const worker of [...queueable, ...await db.worker.listQueued()]) {
3962
+ if (stopped || running >= settings.maxWorkers) break;
3963
+ const ticket = await db.ticket.findById(worker.ticketId);
3964
+ if (!ticket || ticket.status === "done" || ticket.status === "cancelled") {
3965
+ await db.worker.end(worker.id, "stopped", (/* @__PURE__ */ new Date()).toISOString());
3966
+ continue;
3967
+ }
3968
+ if (ticket.prState === "merged" || ticket.prState === "closed") {
3969
+ const now = (/* @__PURE__ */ new Date()).toISOString();
3970
+ await db.worker.end(worker.id, "stopped", now);
3971
+ await finishTicket(ticket.id, "done", now, now);
3972
+ await releaseDependents(ticket.id);
3973
+ continue;
3974
+ }
3975
+ if (ticket.paused) continue;
3976
+ if (await blockedByDependency(ticket.id)) continue;
3977
+ if ((await db.inbox.listByTicket(ticket.id)).some((message) => message.kind === "ask" && message.status === "pending" && message.workerId === worker.id)) continue;
3978
+ const project = await db.project.findById(ticket.projectId);
3979
+ if (!project) {
3980
+ await db.ticket.setPrepareError(ticket.id, "project_not_found", (/* @__PURE__ */ new Date()).toISOString());
3981
+ continue;
3982
+ }
3983
+ if (!project.enabled) continue;
3984
+ let started = false;
3985
+ try {
3986
+ const branch = `dsh/${ticket.id}`;
3987
+ let directory = worker.worktree;
3988
+ if (await session.resolve(worker.id).then(Boolean).catch(() => false)) {
3989
+ if (directory && worker.branch === branch) await worktree.verify(project.directory, directory, branch);
3990
+ directory = directory ?? project.directory;
3991
+ await session.activate(worker.id);
3992
+ } else {
3993
+ await session.create("worker", {
3994
+ sessionId: worker.id,
3995
+ ticketId: ticket.id,
3996
+ projectId: project.id,
3997
+ directory: project.directory
3998
+ });
3999
+ if (stopped) throw new Error("worker_stopped");
4000
+ if (directory && worker.branch === branch) await worktree.verify(project.directory, directory, branch);
4001
+ else {
4002
+ const created = await worktree.create(await session.activate(worker.id), ticket.id);
4003
+ directory = created.worktree;
4004
+ await db.worker.update(worker.id, {
4005
+ branch: created.branch,
4006
+ worktree: directory
4007
+ });
4008
+ }
4009
+ }
4010
+ if (!directory) throw new Error("worker_directory_required");
4011
+ if (stopped) throw new Error("worker_stopped");
4012
+ const threads = await db.ticketThread.listByTicket(ticket.id);
4013
+ const sources = await Promise.all(threads.map(async (thread) => {
4014
+ const latest = await db.trigger.findLatestByThread(thread.threadId);
4015
+ return latest ? `${thread.threadId}(trigger ${latest.id})` : thread.threadId;
4016
+ }));
4017
+ const prompt = [
4018
+ `${ticket.id}: ${ticket.title}`,
4019
+ ticket.description ?? "",
4020
+ `执行配置:${JSON.stringify({
4021
+ autoMerge: settings.autoMerge,
4022
+ autoMergeMaxLines: settings.autoMergeMaxLines
4023
+ })}`,
4024
+ "来源话题:",
4025
+ ...sources,
4026
+ worker.recoveryNote ?? ""
4027
+ ].filter(Boolean).join(String.fromCharCode(10));
4028
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4029
+ await db.worker.start(worker.id, now);
4030
+ await db.ticket.start(ticket.id, now, now);
4031
+ running++;
4032
+ started = true;
4033
+ await session.send(worker.id, prompt, "queue", `supermesh:worker:${worker.id}`);
4034
+ await db.ticket.setPrepareError(ticket.id, null, now);
4035
+ } catch (error) {
4036
+ const reason = error instanceof Error ? error.message : String(error);
4037
+ if (reason === "unknown_session" || reason === "session_identity_conflict") {
4038
+ await db.worker.end(worker.id, "stopped", (/* @__PURE__ */ new Date()).toISOString());
4039
+ await db.worker.queue(ticket.id, ticket.projectId, worker.branch ?? void 0, true).catch(() => void 0);
4040
+ await db.ticket.setPrepareError(ticket.id, null, (/* @__PURE__ */ new Date()).toISOString());
4041
+ if (stopped) break;
4042
+ continue;
4043
+ }
4044
+ await db.ticket.setPrepareError(ticket.id, reason, (/* @__PURE__ */ new Date()).toISOString());
4045
+ if (stopped) break;
4046
+ if (started) {
4047
+ await session.stop(worker.id);
4048
+ await db.worker.end(worker.id, "failed", (/* @__PURE__ */ new Date()).toISOString());
4049
+ const latest = await db.ticket.findById(ticket.id);
4050
+ if (latest && latest.prState === "merged" && latest.status !== "done") await finishTicket(latest.id, "done", (/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString());
4051
+ else if (!latest || latest.status !== "done" && latest.status !== "cancelled") await db.ticket.update(ticket.id, {
4052
+ status: "waiting",
4053
+ updatedAt: (/* @__PURE__ */ new Date()).toISOString()
4054
+ });
4055
+ running--;
4056
+ }
4057
+ }
4058
+ }
4059
+ }),
4060
+ reconcileBackground: singlet("worker:background", async () => {
4061
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4062
+ for (const worker of await db.worker.listRunning()) {
4063
+ if (stopped) break;
4064
+ if (!worker.backgroundUntil) continue;
4065
+ const activity = await session.activity(worker.id);
4066
+ const expired = worker.backgroundUntil <= now;
4067
+ if (!expired && (activity.running || activity.background || activity.queued)) continue;
4068
+ if (expired) await session.stop(worker.id);
4069
+ await finish(worker, expired ? "stopped" : void 0);
4070
+ }
4071
+ }),
4072
+ cancel: singlet((ticketId) => `worker:cancel:${ticketId}`, async (ticketId) => {
4073
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4074
+ for (const current of await db.worker.listByTicket(ticketId)) {
4075
+ if (current.status === "ended") continue;
4076
+ await session.stop(current.id).catch(() => void 0);
4077
+ await db.worker.end(current.id, "stopped", now);
4078
+ }
4079
+ }),
4080
+ rescue: singlet("worker:rescue", async () => {
4081
+ for (const ticket of await db.ticket.listOpen()) {
4082
+ if (stopped) break;
4083
+ if (ticket.status !== "waiting") continue;
4084
+ if ((await db.worker.listByTicket(ticket.id)).some((worker) => worker.status !== "ended")) continue;
4085
+ if (!(await db.project.findById(ticket.projectId))?.enabled) continue;
4086
+ if (ticket.prState === "merged" || ticket.prState === "closed") {
4087
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4088
+ await finishTicket(ticket.id, "done", now, now);
4089
+ await releaseDependents(ticket.id);
4090
+ continue;
4091
+ }
4092
+ if (ticket.paused) continue;
4093
+ if (ticket.prepareError) await db.ticket.setPrepareError(ticket.id, null, (/* @__PURE__ */ new Date()).toISOString());
4094
+ await db.worker.queue(ticket.id, ticket.projectId);
4095
+ }
4096
+ }),
4097
+ recover: singlet("worker:recovery", async () => {
4098
+ for (const worker of await db.worker.listRunning()) {
4099
+ if (stopped) break;
4100
+ const ticket = await db.ticket.findById(worker.ticketId);
4101
+ if (!ticket) continue;
4102
+ if (ticket.status === "done" || ticket.status === "cancelled") {
4103
+ if (await session.resolve(worker.id)) await session.stop(worker.id);
4104
+ await db.worker.end(worker.id, "stopped", (/* @__PURE__ */ new Date()).toISOString());
4105
+ continue;
4106
+ }
4107
+ if (ticket.paused) continue;
4108
+ try {
4109
+ const project = await db.project.findById(ticket.projectId);
4110
+ if (project && !project.enabled) continue;
4111
+ if (ticket.prState === "merged") {
4112
+ await db.worker.end(worker.id, "stopped", (/* @__PURE__ */ new Date()).toISOString());
4113
+ await finishTicket(ticket.id, "done", (/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString());
4114
+ await releaseDependents(ticket.id);
4115
+ continue;
4116
+ }
4117
+ if (!project || !worker.worktree || !worker.branch) {
4118
+ await db.worker.requeue(worker.id);
4119
+ continue;
4120
+ }
4121
+ await worktree.verify(project.directory, worker.worktree, worker.branch);
4122
+ if (!await session.resolve(worker.id)) {
4123
+ await db.worker.requeue(worker.id);
4124
+ continue;
4125
+ }
4126
+ const activity = await session.activity(worker.id);
4127
+ if (activity.background && !worker.backgroundUntil) {
4128
+ const settings = await setting.load();
4129
+ await db.worker.setBackgroundUntil(worker.id, new Date(Date.now() + Math.min(30, settings.backgroundLimitMinutes) * 6e4).toISOString());
4130
+ }
4131
+ if (activity.running || activity.background || activity.queued) continue;
4132
+ const note = "运行已恢复。先检查目录、git 历史与渠道的当前事实,再决定是否重做外部动作;不要重复开 PR 或发布评论。";
4133
+ await db.worker.setRecoveryNote(worker.id, note);
4134
+ if (!(await db.inbox.listByTicket(ticket.id)).some((message) => message.kind === "ask" && message.status === "pending" && message.workerId === worker.id)) await session.send(worker.id, note, "queue", `supermesh:recovery:${randomUUID()}`);
4135
+ } catch (error) {
4136
+ if (stopped) break;
4137
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4138
+ const latest = await db.ticket.findById(ticket.id);
4139
+ if (latest && (latest.status === "done" || latest.status === "cancelled" || latest.prState === "merged")) {
4140
+ if (latest.prState === "merged" && latest.status !== "done") await finishTicket(latest.id, "done", now, now);
4141
+ await db.worker.end(worker.id, "stopped", now);
4142
+ continue;
4143
+ }
4144
+ await db.ticket.setPrepareError(ticket.id, error instanceof Error ? error.message : String(error), now);
4145
+ await db.ticket.update(ticket.id, {
4146
+ status: "waiting",
4147
+ updatedAt: now
4148
+ });
4149
+ await db.worker.end(worker.id, "failed", now);
4150
+ }
4151
+ }
4152
+ }),
4153
+ observe: singlet((source) => `worker:event:${source.id}`, async (source, event) => {
4154
+ if (!observing || stopped || event.type !== "turn/end") return;
4155
+ const previous = eventQueues.get(source.id) ?? Promise.resolve();
4156
+ const action = () => stopped ? Promise.resolve() : (async () => {
4157
+ const identity = await session.resolve(source.id);
4158
+ if (!identity || identity.role !== "worker" || !identity.workerId) return;
4159
+ const current = await db.worker.findById(identity.workerId);
4160
+ if (!current || current.status !== "running") return;
4161
+ const activity = await session.activity(current.id);
4162
+ if (activity.background) {
4163
+ const settings = await setting.load();
4164
+ if (!current.backgroundUntil) await db.worker.setBackgroundUntil(current.id, new Date(Date.now() + Math.min(30, settings.backgroundLimitMinutes) * 6e4).toISOString());
4165
+ return;
4166
+ }
4167
+ if (activity.queued) return;
4168
+ await finish(current, event.data.reason.kind === "error" ? "failed" : event.data.reason.kind === "aborted" ? "stopped" : void 0);
4169
+ })();
4170
+ const current = previous.then(action, action).finally(() => {
4171
+ if (eventQueues.get(source.id) === current) eventQueues.delete(source.id);
4172
+ });
4173
+ eventQueues.set(source.id, current);
4174
+ return current;
4175
+ })
4176
+ });
4177
+ async function finish(current, reason) {
4178
+ const asks = (await db.inbox.listByTicket(current.ticketId)).filter((message) => message.kind === "ask" && message.workerId === current.id);
4179
+ if (!reason) {
4180
+ if (asks.some((message) => message.status === "pending")) {
4181
+ await deferWhileWaiting(current);
4182
+ return;
4183
+ }
4184
+ const answered = asks.filter((message) => message.answer);
4185
+ if (answered.length) {
4186
+ const receipts = await session.receipts(current.id);
4187
+ if (answered.some((message) => !receipts.some((receipt) => receipt.requestId === `supermesh:answer:${message.id}`))) {
4188
+ await deferWhileWaiting(current);
4189
+ return;
4190
+ }
4191
+ }
4192
+ }
4193
+ if (stopped) return;
4194
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4195
+ await db.worker.setBackgroundUntil(current.id, null);
4196
+ await db.worker.end(current.id, reason ?? (current.reportState === "failed" ? "failed" : "completed"), now);
4197
+ const ticket = await db.ticket.findById(current.ticketId);
4198
+ if (ticket && ticket.status !== "done" && ticket.status !== "cancelled") {
4199
+ if (ticket.prState === "merged" || ticket.prState === "closed") await finishTicket(ticket.id, "done", now, now);
4200
+ else if (!reason && current.reportState === "dropped") await finishTicket(ticket.id, "done", now, now);
4201
+ else await db.ticket.update(ticket.id, {
4202
+ status: !reason && current.reportState === "ready" ? "review" : "waiting",
4203
+ updatedAt: now
4204
+ });
4205
+ }
4206
+ const ended = await db.ticket.findById(current.ticketId);
4207
+ if (!reason && current.reportState !== "failed" && ended && (ended.status === "done" || ended.status === "cancelled")) await archiveWorker(current.id);
4208
+ if (ended && (ended.status === "done" || ended.status === "cancelled")) await releaseDependents(ended.id);
4209
+ }
4210
+ async function blockedByDependency(ticketId) {
4211
+ const links = await db.ticketLink.listDependsOn(ticketId);
4212
+ if (!links.length) return false;
4213
+ for (const link of links) {
4214
+ const related = await db.ticket.findById(link.relatedId);
4215
+ if (!related || related.status === "done" || related.status === "cancelled") continue;
4216
+ return true;
4217
+ }
4218
+ return false;
4219
+ }
4220
+ /**
4221
+ * 票进终态时通知它所属的 supervisor。
4222
+ * 不要求两票之间有 depends —— 跨项目协调里 supervisor 往往靠「这张做完了」才能派下一张,
4223
+ * 漏掉这条通知,整条链路就停在原地,票却不报错。
4224
+ */
4225
+ /** 结单并通知相关方:所有终态路径都必须经过这里,否则 supervisor 收不到「这张做完了」。 */
4226
+ async function finishTicket(id, status, endedAt, updatedAt) {
4227
+ await db.ticket.finish(id, status, endedAt, updatedAt);
4228
+ await notifySupervisor(id);
4229
+ }
4230
+ async function notifySupervisor(ticketId) {
4231
+ const ticket = await db.ticket.findById(ticketId);
4232
+ if (!ticket || ticket.status !== "done" && ticket.status !== "cancelled") return;
4233
+ for (const link of await db.supervisorTicket.listByTicket(ticketId)) {
4234
+ const supervisor = await db.supervisor.findById(link.supervisorId);
4235
+ if (!supervisor || supervisor.status !== "active") continue;
4236
+ await db.inbox.enqueue({
4237
+ id: `supervisor:${link.supervisorId}:ticket:${ticketId}:${ticket.status}`,
4238
+ type: "supervisor",
4239
+ origin: "system",
4240
+ kind: "notice",
4241
+ supervisorId: link.supervisorId,
4242
+ message: `${ticketId} ${ticket.status === "done" ? "已完成" : "已取消"}:${ticket.title}`,
4243
+ title: ticket.title
4244
+ }).catch(() => void 0);
4245
+ }
4246
+ }
4247
+ async function releaseDependents(relatedId) {
4248
+ for (const link of await db.ticketLink.listDependents(relatedId)) {
4249
+ const ticket = await db.ticket.findById(link.ticketId);
4250
+ if (!ticket || ticket.status !== "waiting" || ticket.paused) continue;
4251
+ if (await blockedByDependency(ticket.id)) continue;
4252
+ if ((await db.worker.listByTicket(ticket.id)).some((worker) => worker.status !== "ended")) continue;
4253
+ await db.ticket.update(ticket.id, {
4254
+ status: "queued",
4255
+ updatedAt: (/* @__PURE__ */ new Date()).toISOString()
4256
+ });
4257
+ await db.worker.queue(ticket.id, ticket.projectId).catch(() => void 0);
4258
+ }
4259
+ }
4260
+ async function deferWhileWaiting(current) {
4261
+ const ticket = await db.ticket.findById(current.ticketId);
4262
+ if (!ticket || ticket.status === "done" || ticket.status === "cancelled") return;
4263
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4264
+ await db.worker.end(current.id, "completed", now);
4265
+ if (ticket.prState === "merged") {
4266
+ await finishTicket(ticket.id, "done", now, now);
4267
+ return;
4268
+ }
4269
+ await db.ticket.update(ticket.id, {
4270
+ status: "waiting",
4271
+ updatedAt: now
4272
+ });
4273
+ }
4274
+ async function archiveWorker(id) {
4275
+ await archive.session(id);
4276
+ }
4277
+ // src/server/routes/ticket.[id].patch.ts
4278
+ var ticket__id__patch_default = defineHandler(async (event) => {
4279
+ const id = getRouterParam(event, "id", { decode: true });
4280
+ const body = await readBody(event);
4281
+ const allowed = [
4282
+ "reason",
4283
+ "paused",
4284
+ "status"
4285
+ ];
4286
+ const validShape = body && typeof body === "object" && !Array.isArray(body) && Object.keys(body).every((key) => allowed.includes(key)) && (body.paused === void 0 || typeof body.paused === "boolean") && (body.status === void 0 || body.status === "cancelled") && (body.reason === void 0 || typeof body.reason === "string" && body.reason.trim().length > 0) && (body.paused !== void 0 || body.status !== void 0);
4287
+ if (!id?.trim() || !validShape) throw new HTTPError({
4288
+ status: 400,
4289
+ message: "invalid_ticket_patch"
4290
+ });
4291
+ const ticket = await db.ticket.findById(id);
4292
+ if (!ticket) throw new HTTPError({
4293
+ status: 404,
4294
+ message: "not_found"
4295
+ });
4296
+ if (ticket.status === "done" || ticket.status === "cancelled") throw new HTTPError({
4297
+ status: 409,
4298
+ message: "ticket_closed"
4299
+ });
4300
+ const now = (/* @__PURE__ */ new Date()).toISOString();
4301
+ if (body.status === "cancelled") {
4302
+ await worker.cancel(id);
4303
+ await db.ticket.finish(id, "cancelled", now, now);
4304
+ return await db.ticket.findById(id);
4305
+ }
4306
+ const updated = await db.ticket.setPausedIfOpen(id, body.paused, now);
4307
+ if (!updated) throw new HTTPError({
4308
+ status: 409,
4309
+ message: "ticket_closed"
4310
+ });
4311
+ return updated;
4312
+ });
4313
+ // src/server/routes/ticket.count.get.ts
4314
+ /** 任务卡片的统计:全量计数,不受分页与列表取数上限影响。 */
4315
+ var ticket_count_get_default = defineHandler(async () => {
4316
+ const rows = await db.ticket.listAll();
4317
+ const since = Date.now() - 864e5;
4318
+ let added = 0;
4319
+ let inProgress = 0;
4320
+ let completed = 0;
4321
+ let blocked = 0;
4322
+ for (const ticket of rows) {
4323
+ if (Date.parse(ticket.createdAt) >= since) added++;
4324
+ const closed = ticket.status === "done" || ticket.status === "cancelled";
4325
+ if (ticket.status === "done") completed++;
4326
+ else if (!closed && (ticket.paused || ticket.prepareError)) blocked++;
4327
+ else if (!closed && !ticket.paused && !ticket.prepareError && [
4328
+ "running",
4329
+ "queued",
4330
+ "review"
4331
+ ].includes(ticket.status)) inProgress++;
4332
+ }
4333
+ return {
4334
+ all: rows.length,
4335
+ added,
4336
+ inProgress,
4337
+ completed,
4338
+ blocked
4339
+ };
4340
+ });
4341
+ // src/server/routes/ticket.current.get.ts
4342
+ var ticket_current_get_default = defineHandler(async () => {
4343
+ const [runningWorkers, queuedWorkers, openTickets] = await Promise.all([
4344
+ db.worker.listRunning(),
4345
+ db.worker.listQueued(),
4346
+ db.ticket.listOpen()
4347
+ ]);
4348
+ const runningTicketIds = new Set(runningWorkers.map((worker) => worker.ticketId));
4349
+ const activeWorkers = [...new Map([...queuedWorkers, ...runningWorkers].map((worker) => [worker.id, worker])).values()];
4350
+ const ticketMap = new Map(openTickets.map((ticket) => [ticket.id, ticket]));
4351
+ for (const ticket of await Promise.all([...new Set(activeWorkers.map((worker) => worker.ticketId))].filter((id) => !ticketMap.has(id)).map((id) => db.ticket.findById(id)))) if (ticket) ticketMap.set(ticket.id, ticket);
4352
+ return [...ticketMap.values()].filter((ticket) => ![
4353
+ "closed",
4354
+ "done",
4355
+ "cancelled"
4356
+ ].includes(ticket.status) || runningTicketIds.has(ticket.id));
4357
+ });
4358
+ // src/server/routes/ticket.get.ts
4359
+ var ticket_get_default = defineHandler(async (event) => {
4360
+ const query = getQuery(event);
4361
+ const page = Math.max(1, Number(query.page) || 1);
4362
+ const pageSize = Math.max(1, Math.min(100, Number(query.pageSize) || 8));
4363
+ return {
4364
+ ...await db.ticket.findManyPage(page, pageSize),
4365
+ page,
4366
+ pageSize
4367
+ };
4368
+ });
4369
+ // src/service/topic.ts
4370
+ /** 一条触发按投递事实推出的状态:有受阻就是受阻,有排队就是排队。 */
4371
+ function eventStatus(event) {
4372
+ if (event.deliveries.some((item) => item.status === "stalled")) return "stalled";
4373
+ if (event.deliveries.some((item) => item.status === "pending")) return "pending";
4374
+ return event.deliveries.length ? "done" : "not-delivered";
4375
+ }
4376
+ function matchEvent(event, filters, thread, projectName) {
4377
+ const query = (filters.query ?? "").trim().toLocaleLowerCase();
4378
+ if (filters.channel && filters.channel !== "all" && event.channel !== filters.channel) return false;
4379
+ if (filters.kind && filters.kind !== "all" && event.kind !== filters.kind) return false;
4380
+ if (filters.mentionedOnly && !event.mentioned) return false;
4381
+ if (filters.status && filters.status !== "all") {
4382
+ if (eventStatus(event) !== filters.status) return false;
4383
+ }
4384
+ if (query) {
4385
+ if (![
4386
+ event.id,
4387
+ event.actor,
4388
+ event.channel,
4389
+ thread.refId,
4390
+ projectName,
4391
+ event.ref,
4392
+ thread.title,
4393
+ event.text,
4394
+ ...event.tickets
4395
+ ].filter(Boolean).join(" ").toLocaleLowerCase().includes(query)) return false;
4396
+ }
4397
+ return true;
4398
+ }
4399
+ const topic = defineService({
4400
+ async page(filters, page = 1, pageSize = 5) {
4401
+ const size = Math.max(1, Math.min(100, pageSize));
4402
+ const rows = await collect(filters);
4403
+ const offset = (Math.max(1, page) - 1) * size;
4404
+ return {
4405
+ data: rows.slice(offset, offset + size),
4406
+ total: rows.length,
4407
+ page: Math.max(1, page),
4408
+ pageSize: size
4409
+ };
4410
+ },
4411
+ /** 统计卡片用:按话题去重的全量计数,与分页和当前页数据无关。 */
4412
+ async count(filters) {
4413
+ const rows = await collect({
4414
+ ...filters,
4415
+ status: void 0
4416
+ });
4417
+ const counts = {
4418
+ all: rows.length,
4419
+ pending: 0,
4420
+ done: 0,
4421
+ stalled: 0
4422
+ };
4423
+ for (const row of rows) {
4424
+ const status = eventStatus(row.latest);
4425
+ if (status === "pending") counts.pending++;
4426
+ else if (status === "done") counts.done++;
4427
+ else if (status === "stalled") counts.stalled++;
4428
+ }
4429
+ return counts;
4430
+ }
4431
+ });
4432
+ /** 按筛选条件装配全量话题行(未分页),page 与 count 共用。 */
4433
+ async function collect(filters) {
4434
+ const [triggers, threads, projects, subscriptions, deliveries] = await Promise.all([
4435
+ db.trigger.listRecent(1e3),
4436
+ db.thread.listRecent(1e3),
4437
+ db.project.listAll(),
4438
+ db.ticketThread.listAll(),
4439
+ db.inbox.listRecent()
4440
+ ]);
4441
+ const threadById = new Map(threads.map((item) => [item.id, item]));
4442
+ const projectById = new Map(projects.map((item) => [item.id, item]));
4443
+ const grouped = /* @__PURE__ */ new Map();
4444
+ for (const item of triggers) {
4445
+ const thread = threadById.get(item.threadId);
4446
+ if (!thread) continue;
4447
+ const event = {
4448
+ id: item.id,
4449
+ channel: item.channelId,
4450
+ kind: item.kind,
4451
+ actor: item.actorName ?? "",
4452
+ human: Boolean(item.human),
4453
+ mentioned: Boolean(item.mentioned),
4454
+ text: item.text,
4455
+ at: item.at,
4456
+ ref: item.ref ?? void 0,
4457
+ url: item.url ?? void 0,
4458
+ thread: {
4459
+ id: thread.id,
4460
+ kind: thread.kind,
4461
+ ref: thread.refId,
4462
+ title: thread.title,
4463
+ triage: thread.triage,
4464
+ project: thread.projectId ? projectById.get(thread.projectId)?.name : void 0,
4465
+ url: thread.url ?? void 0
4466
+ },
4467
+ tickets: subscriptions.filter((link) => link.threadId === thread.id).map((link) => link.ticketId),
4468
+ deliveries: deliveries.filter((message) => message.triggerId === item.id).map((message) => ({
4469
+ target: message.type,
4470
+ project: message.projectId ? projectById.get(message.projectId)?.name : void 0,
4471
+ status: message.status,
4472
+ read: Boolean(message.readAt),
4473
+ attempts: message.deliveryAttempts,
4474
+ error: message.deliveryError ?? void 0
4475
+ }))
4476
+ };
4477
+ if (!matchEvent(event, filters, thread, projectById.get(thread.projectId ?? "")?.name)) continue;
4478
+ const events = grouped.get(thread.id) ?? [];
4479
+ events.push(event);
4480
+ grouped.set(thread.id, events);
4481
+ }
4482
+ const rows = [...grouped.values()].map((events) => {
4483
+ events.sort((a, b) => Date.parse(b.at) - Date.parse(a.at) || b.id.localeCompare(a.id));
4484
+ return {
4485
+ latest: events[0],
4486
+ events
4487
+ };
4488
+ });
4489
+ rows.sort((a, b) => Date.parse(b.latest.at) - Date.parse(a.latest.at) || b.latest.id.localeCompare(a.latest.id));
4490
+ return rows;
4491
+ }
4492
+ // src/server/routes/topic.count.get.ts
4493
+ var topic_count_get_default = defineHandler(async (event) => {
4494
+ const query = getQuery(event);
4495
+ return topic.count({
4496
+ query: query.query || void 0,
4497
+ channel: query.channel || void 0,
4498
+ kind: query.kind,
4499
+ mentionedOnly: query.mentionedOnly === "true"
4500
+ });
4501
+ });
4502
+ // src/server/routes/topic.get.ts
4503
+ var topic_get_default = defineHandler(async (event) => {
4504
+ const query = getQuery(event);
4505
+ const page = Math.max(1, Number(query.page) || 1);
4506
+ const pageSize = Math.max(1, Math.min(100, Number(query.pageSize) || 5));
4507
+ return topic.page({
4508
+ query: query.query,
4509
+ channel: query.channel,
4510
+ status: query.status,
4511
+ kind: query.kind,
4512
+ mentionedOnly: query.mentionedOnly === "true"
4513
+ }, page, pageSize);
4514
+ });
4515
+ // src/server/routes/trigger.get.ts
4516
+ var trigger_get_default = defineHandler(async () => db.trigger.listRecent());
4517
+ // src/server/routes/worker.get.ts
4518
+ var worker_get_default = defineHandler(async () => {
4519
+ const [running, queued] = await Promise.all([db.worker.listRunning(), db.worker.listQueued()]);
4520
+ return [...new Map([...queued, ...running].map((worker) => [worker.id, worker])).values()];
4521
+ });
4522
+ // src/server/index.ts
4523
+ const authorize = defineHandler(async (event) => {
4524
+ const options = getServerOptions(event);
4525
+ event.res.headers.set("cache-control", "no-store");
4526
+ const origin = event.req.headers.get("origin");
4527
+ const host = event.req.headers.get("host");
4528
+ if (origin && origin !== options.origin || host && host !== new URL(options.origin).host) throw new HTTPError({
4529
+ status: 403,
4530
+ message: "origin_denied"
4531
+ });
4532
+ if (!options.owner || !await options.owner(event)) throw new HTTPError({
4533
+ status: 401,
4534
+ message: "owner_required"
4535
+ });
4536
+ });
4537
+ const server = defineWebServer((app) => {
4538
+ app.use(authorize);
4539
+ app.get("/api/supermesh/project", project_get_default);
4540
+ app.post("/api/supermesh/project", project_post_default);
4541
+ app.patch("/api/supermesh/project/:id", project__id__patch_default);
4542
+ app.put("/api/supermesh/project/:id/session", project__id__session_put_default);
4543
+ app.post("/api/supermesh/project/:id/opening", project__id__opening_post_default);
4544
+ app.post("/api/supermesh/repository", project_repository_post_default);
4545
+ app.get("/api/supermesh/ticket", ticket_get_default);
4546
+ app.get("/api/supermesh/ticket/count", ticket_count_get_default);
4547
+ app.get("/api/supermesh/ticket/current", ticket_current_get_default);
4548
+ app.get("/api/supermesh/ticket/:id", ticket__id__get_default);
4549
+ app.patch("/api/supermesh/ticket/:id", ticket__id__patch_default);
4550
+ app.post("/api/supermesh/ask/:id/answer", ask__id__answer_post_default);
4551
+ app.get("/api/supermesh/worker", worker_get_default);
4552
+ app.get("/api/supermesh/supervisor", supervisor_get_default);
4553
+ app.get("/api/supermesh/scope", scope_get_default);
4554
+ app.get("/api/supermesh/node", node_get_default);
4555
+ app.get("/api/supermesh/edge", edge_get_default);
4556
+ app.get("/api/supermesh/group", group_get_default);
4557
+ app.get("/api/supermesh/status", status_get_default);
4558
+ app.get("/api/supermesh/message", message_get_default);
4559
+ app.get("/api/supermesh/pending", pending_get_default);
4560
+ app.get("/api/supermesh/delivery", delivery_get_default);
4561
+ app.get("/api/supermesh/thread", thread_get_default);
4562
+ app.get("/api/supermesh/trigger", trigger_get_default);
4563
+ app.get("/api/supermesh/topic", topic_get_default);
4564
+ app.get("/api/supermesh/topic/count", topic_count_get_default);
4565
+ app.get("/api/supermesh/subscription", subscription_get_default);
4566
+ app.get("/api/supermesh/channel", channel_get_default);
4567
+ app.put("/api/supermesh/channel/:id/configuration", channel__id__configuration_put_default);
4568
+ app.delete("/api/supermesh/channel/:id/credential", channel__id__credential_delete_default);
4569
+ app.post("/api/supermesh/channel/:id/authentication", channel__id__authentication_post_default);
4570
+ app.get("/api/supermesh/channel/:id/authentication/:authenticationId", channel__id__authentication__authenticationId__get_default);
4571
+ app.get("/api/supermesh/setting", setting_get_default);
4572
+ app.patch("/api/supermesh/setting", setting_patch_default);
4573
+ app.get("/api/supermesh/agent/model", agent_model_get_default);
4574
+ app.patch("/api/supermesh/agent/model", agent_model_patch_default);
4575
+ app.get("/api/supermesh/agent/model/catalog", agent_model_catalog_get_default);
4576
+ app.put("/api/supermesh/session/main", session_open_post_default);
4577
+ app.get("/api/supermesh/session/role", session_role_get_default);
4578
+ app.get("/api/supermesh/session/:id/context", session__id__context_get_default);
4579
+ app.get("/api/supermesh/session/:id/mailbox", session__id__mailbox_get_default);
4580
+ app.patch("/api/supermesh/session/:id/mailbox/:messageId", session__id__mailbox__messageId__patch_default);
4581
+ });
4582
+ // src/service/channel.ts
4583
+ const presets = [
4584
+ {
4585
+ id: "github",
4586
+ name: "GitHub"
4587
+ },
4588
+ {
4589
+ id: "gitlab",
4590
+ name: "GitLab"
4591
+ },
4592
+ {
4593
+ id: "feishu",
4594
+ name: "飞书"
4595
+ }
4596
+ ];
4597
+ let writing = Promise.resolve();
4598
+ const channel = defineService({
4599
+ async list() {
4600
+ const [rows, accounts] = await Promise.all([db.channel.listAll(), db.channelAccount.listAll()]);
4601
+ return Promise.all(presets.map(async (preset) => {
4602
+ const row = rows.find((row) => row.id === preset.id);
4603
+ const members = accounts.filter((account) => account.channelId === preset.id).map(({ id, channelId, role, name, avatar, status, createdAt }) => ({
4604
+ id,
4605
+ channelId,
4606
+ role,
4607
+ name,
4608
+ avatar,
4609
+ status,
4610
+ createdAt
4611
+ }));
4612
+ const supported = preset.id !== "feishu";
4613
+ const hasCredential = preset.id !== "feishu" && Boolean((await credentials().resolve(ref(preset.id)))?.value?.trim() || (await credentials().resolve(legacyRef(preset.id)))?.value?.trim());
4614
+ const enabled = supported && Boolean(row?.enabled);
4615
+ const stored = await db.sourceState.find(preset.id, "configuration");
4616
+ const configured = hasCredential || members.length > 0 || Boolean(stored);
4617
+ const metadata = readMetadata(stored?.value);
4618
+ return {
4619
+ id: preset.id,
4620
+ kind: preset.id,
4621
+ name: row?.name ?? preset.name,
4622
+ host: row?.host ?? (preset.id === "gitlab" ? "https://gitlab.com" : null),
4623
+ enabled,
4624
+ createdAt: row?.createdAt ?? "",
4625
+ accounts: members,
4626
+ configured,
4627
+ supported,
4628
+ hasCredential,
4629
+ status: !supported ? "unsupported" : !configured ? "unconfigured" : !enabled ? "disabled" : members.some((account) => account.role === "bot" && account.status === "online") ? "online" : "offline",
4630
+ ...metadata
4631
+ };
4632
+ }));
4633
+ },
4634
+ serialize(action) {
4635
+ const operation = writing.then(action);
4636
+ writing = operation.then(() => void 0, () => void 0);
4637
+ return operation;
4638
+ },
4639
+ connection(kind) {
4640
+ return channel.serialize(async () => {
4641
+ const row = await db.channel.findById(kind);
4642
+ const token = kind === "feishu" ? void 0 : await channel.resolveCredential(kind);
4643
+ return Object.freeze({
4644
+ host: row?.host ?? (kind === "gitlab" ? "https://gitlab.com" : null),
4645
+ token,
4646
+ enabled: kind !== "feishu" && Boolean(row?.enabled)
4647
+ });
4648
+ });
4649
+ },
4650
+ async resolveCredential(kind) {
4651
+ if (kind === "feishu") return void 0;
4652
+ const stored = await credentials().resolve(ref(kind));
4653
+ if (stored?.value?.trim()) return stored.value;
4654
+ return (await credentials().resolve(legacyRef(kind)))?.value;
4655
+ },
4656
+ async storeCredential(kind, token) {
4657
+ const previous = await credentials().resolve(ref(kind));
4658
+ await credentials().set(ref(kind), token);
4659
+ return previous?.value;
4660
+ },
4661
+ async clearCredential(kind) {
4662
+ const previous = await credentials().resolve(ref(kind));
4663
+ await credentials().unset(ref(kind));
4664
+ return previous?.value;
4665
+ }
4666
+ });
4667
+ function credentials() {
4668
+ return getServerContext(server).credentials;
4669
+ }
4670
+ function ref(kind) {
4671
+ return credentialRef(kind === "github" ? "SUPERMESH_GITHUB_TOKEN" : "SUPERMESH_GITLAB_TOKEN");
4672
+ }
4673
+ function legacyRef(kind) {
4674
+ return credentialRef(kind === "github" ? "NEXUS_GITHUB_TOKEN" : "NEXUS_GITLAB_TOKEN");
4675
+ }
4676
+ function readMetadata(raw) {
4677
+ if (!raw) return {
4678
+ commitName: "",
4679
+ commitEmail: ""
4680
+ };
4681
+ const value = JSON.parse(raw);
4682
+ if (!value || typeof value !== "object" || !("commitName" in value) || !("commitEmail" in value) || typeof value.commitName !== "string" || typeof value.commitEmail !== "string") throw new Error("invalid_channel_metadata");
4683
+ return {
4684
+ commitName: value.commitName,
4685
+ commitEmail: value.commitEmail
4686
+ };
4687
+ }
4688
+ export { project as a, shell as c, singlet as d, setting as f, db as g, channelProxyEnvironment as h, archive as i, inbox as l, DSH_PLUGIN_HOME as m, server as n, worktree as o, defineService as p, worker as r, devops as s, channel as t, session as u };