opencode-supertask 0.1.31 → 0.1.32-rc.1

package/dist/worker/index.d.ts

@@ -1,27 +1,4 @@
-interface GatewayConfig {
-    configVersion: 2;
-    worker: {
-        maxConcurrency: number;
-        pollIntervalMs: number;
-        heartbeatIntervalMs: number;
-        taskTimeoutMs: number;
-        shutdownGracePeriodMs: number;
-    };
-    scheduler: {
-        enabled: boolean;
-        checkIntervalMs: number;
-    };
-    watchdog: {
-        heartbeatTimeoutMs: number;
-        checkIntervalMs: number;
-        cleanupIntervalMs: number;
-        retentionDays: number;
-    };
-    dashboard: {
-        enabled: boolean;
-        port: number;
-    };
-}
+import { G as GatewayConfig } from '../config-CCUuD6Az.js';
 
 interface WorkerEngineOptions {
     opencodeBin?: string;

package/dist/worker/index.js

@@ -5359,6 +5359,42 @@ function computeBackoff(retryCount, baseMs = 3e4, maxMs = MAX_BACKOFF_MS) {
   return Math.min(baseMs * Math.pow(2, retryCount - 1), maxMs);
 }
 
+// src/core/task-working-directory.ts
+import { statSync } from "fs";
+import { isAbsolute } from "path";
+var InvalidTaskWorkingDirectoryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidTaskWorkingDirectoryError";
+  }
+};
+function validateTaskWorkingDirectory(cwd) {
+  if (cwd == null) return;
+  if (!cwd.trim()) {
+    throw new InvalidTaskWorkingDirectoryError("\u4EFB\u52A1\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (!isAbsolute(cwd)) {
+    throw new InvalidTaskWorkingDirectoryError(`\u4EFB\u52A1\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${cwd}`);
+  }
+  let stat;
+  try {
+    stat = statSync(cwd);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new InvalidTaskWorkingDirectoryError(`\u4EFB\u52A1\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u8BBF\u95EE\uFF1A${cwd}\uFF08${detail}\uFF09`);
+  }
+  if (!stat.isDirectory()) {
+    throw new InvalidTaskWorkingDirectoryError(`\u4EFB\u52A1\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u662F\u76EE\u5F55\uFF1A${cwd}`);
+  }
+}
+
+// src/core/task-batch.ts
+var TASK_BATCH_TRIM_CHARACTERS = " 	\n\v\f\r\xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF";
+function normalizeTaskBatchId(batchId) {
+  if (batchId == null) return batchId;
+  return batchId.trim() || null;
+}
+
 // src/core/services/task.service.ts
 var { tasks: tasks2, taskRuns: taskRuns2 } = schema_exports;
 var cleanupInvocation = 0;
@@ -5422,34 +5458,75 @@ var TaskService = class {
     return conditions;
   }
   static async add(data) {
-    this.validateNewTask(data);
+    const normalizedData = {
+      ...data,
+      batchId: normalizeTaskBatchId(data.batchId)
+    };
+    this.validateNewTask(normalizedData);
     return db.transaction((tx) => {
-      if (data.dependsOn != null) {
+      if (normalizedData.dependsOn != null) {
         const dependency = tx.select({
           id: tasks2.id,
           cwd: tasks2.cwd,
           status: tasks2.status,
           retryCount: tasks2.retryCount,
           maxRetries: tasks2.maxRetries
-        }).from(tasks2).where(eq(tasks2.id, data.dependsOn)).get();
+        }).from(tasks2).where(eq(tasks2.id, normalizedData.dependsOn)).get();
         if (!dependency) {
-          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${data.dependsOn} \u4E0D\u5B58\u5728`);
+          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${normalizedData.dependsOn} \u4E0D\u5B58\u5728`);
         }
-        if ((dependency.cwd ?? null) !== (data.cwd ?? null)) {
+        if ((dependency.cwd ?? null) !== (normalizedData.cwd ?? null)) {
           throw new Error("dependsOn \u5FC5\u987B\u6307\u5411\u540C\u4E00 cwd \u7684\u4EFB\u52A1");
         }
         const dependencyIsRecoverable = dependency.status === "pending" || dependency.status === "running" || dependency.status === "done" || dependency.status === "failed" && (dependency.retryCount ?? 0) <= (dependency.maxRetries ?? 3);
         if (!dependencyIsRecoverable) {
-          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${data.dependsOn} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`);
+          throw new Error(`dependsOn \u6307\u5411\u7684\u4EFB\u52A1 #${normalizedData.dependsOn} \u5DF2\u8FDB\u5165\u4E0D\u53EF\u6062\u590D\u7EC8\u6001`);
         }
       }
-      return tx.insert(tasks2).values(data).returning().get();
+      return tx.insert(tasks2).values(normalizedData).returning().get();
+    }, { behavior: "immediate" });
+  }
+  static async update(id, data, scope = {}) {
+    if (Object.keys(data).length === 0) throw new Error("\u81F3\u5C11\u63D0\u4F9B\u4E00\u4E2A\u8981\u4FEE\u6539\u7684\u5B57\u6BB5");
+    const normalizedData = data.batchId === void 0 ? data : { ...data, batchId: normalizeTaskBatchId(data.batchId) ?? null };
+    return db.transaction((tx) => {
+      const task = tx.select().from(tasks2).where(and(
+        eq(tasks2.id, id),
+        sql`${tasks2.status} IN ('pending', 'failed', 'dead_letter')`,
+        ...this.buildScopeWhere(scope)
+      )).get();
+      if (!task) return null;
+      this.validateNewTask({
+        name: normalizedData.name ?? task.name,
+        agent: normalizedData.agent ?? task.agent,
+        model: normalizedData.model ?? task.model,
+        prompt: normalizedData.prompt ?? task.prompt,
+        cwd: task.cwd,
+        category: normalizedData.category ?? task.category,
+        importance: normalizedData.importance ?? task.importance,
+        urgency: normalizedData.urgency ?? task.urgency,
+        batchId: normalizedData.batchId === void 0 ? task.batchId : normalizedData.batchId,
+        maxRetries: normalizedData.maxRetries ?? task.maxRetries,
+        retryBackoffMs: normalizedData.retryBackoffMs ?? task.retryBackoffMs,
+        timeoutMs: normalizedData.timeoutMs === void 0 ? task.timeoutMs : normalizedData.timeoutMs,
+        dependsOn: task.dependsOn
+      });
+      const maxRetries = normalizedData.maxRetries ?? task.maxRetries ?? 3;
+      const exhausted = task.status === "failed" && (task.retryCount ?? 0) > maxRetries;
+      return tx.update(tasks2).set({
+        ...normalizedData,
+        ...exhausted ? {
+          status: "dead_letter",
+          retryAfter: null
+        } : {}
+      }).where(eq(tasks2.id, id)).returning().get() ?? null;
     }, { behavior: "immediate" });
   }
   static validateNewTask(data) {
     if (!data.name.trim()) throw new Error("name \u4E0D\u80FD\u4E3A\u7A7A");
     if (!data.agent.trim()) throw new Error("agent \u4E0D\u80FD\u4E3A\u7A7A");
     if (!data.prompt.trim()) throw new Error("prompt \u4E0D\u80FD\u4E3A\u7A7A");
+    validateTaskWorkingDirectory(data.cwd);
     this.validateInteger("importance", data.importance, 1, 5);
     this.validateInteger("urgency", data.urgency, 1, 5);
     this.validateInteger("maxRetries", data.maxRetries, 0, 1e3);
@@ -5470,12 +5547,14 @@ var TaskService = class {
       isNull(tasks2.retryAfter),
       sql`${tasks2.retryAfter} <= ${nowMs}`
     );
-    const hasExcludedBatches = scope.excludedBatchIds && scope.excludedBatchIds.length > 0;
+    const excludedBatchIds = [...new Set((scope.excludedBatchIds ?? []).map((batchId) => normalizeTaskBatchId(batchId)).filter((batchId) => Boolean(batchId)))];
+    const hasExcludedBatches = excludedBatchIds.length > 0;
     let batchFilter;
     if (hasExcludedBatches) {
       batchFilter = or(
         isNull(tasks2.batchId),
-        sql`${tasks2.batchId} NOT IN ${scope.excludedBatchIds}`
+        sql`trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS}) = ''`,
+        sql`trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS}) NOT IN ${excludedBatchIds}`
       );
     }
     const statusConditions = or(
@@ -5509,9 +5588,11 @@ var TaskService = class {
       ),
       or(
         isNull(tasks2.batchId),
+        sql`trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS}) = ''`,
         sql`NOT EXISTS (
                         SELECT 1 FROM tasks AS running_batch_task
-                        WHERE running_batch_task.batch_id = ${tasks2.batchId}
+                        WHERE trim(running_batch_task.batch_id, ${TASK_BATCH_TRIM_CHARACTERS})
+                            = trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS})
                           AND (
                               running_batch_task.status = 'running'
                               OR EXISTS (
@@ -5535,12 +5616,18 @@ var TaskService = class {
     ).limit(1);
     return result[0] ?? null;
   }
-  static async countRunning() {
+  static async countRunning(scope = {}) {
+    const scopeConditions = scope.legacyCwd ? [sql`${tasks2.cwd} IS NULL OR trim(${tasks2.cwd}) = ''`] : this.buildScopeWhere(scope);
+    if (scope.batchId !== void 0) {
+      const batchId = normalizeTaskBatchId(scope.batchId);
+      scopeConditions.push(batchId ? sql`trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS}) = ${batchId}` : sql`0`);
+    }
     return db.transaction((tx) => {
-      const runningTasks = tx.select({ count: sql`count(*)` }).from(tasks2).where(eq(tasks2.status, "running")).get();
+      const runningTasks = tx.select({ count: sql`count(*)` }).from(tasks2).where(and(eq(tasks2.status, "running"), ...scopeConditions)).get();
       const runsWithoutRunningTask = tx.select({ count: sql`count(DISTINCT ${taskRuns2.taskId})` }).from(taskRuns2).innerJoin(tasks2, eq(tasks2.id, taskRuns2.taskId)).where(and(
         eq(taskRuns2.status, "running"),
-        sql`${tasks2.status} <> 'running'`
+        sql`${tasks2.status} <> 'running'`,
+        ...scopeConditions
       )).get();
       return Number(runningTasks?.count ?? 0) + Number(runsWithoutRunningTask?.count ?? 0);
     }, { behavior: "deferred" });
@@ -5873,15 +5960,17 @@ var TaskService = class {
     }).where(and(...conditions, hasViableDependency())).returning().get() ?? null, { behavior: "immediate" });
   }
   static async retryBatch(batchId, scope = {}) {
+    const normalizedBatchId = normalizeTaskBatchId(batchId);
+    if (!normalizedBatchId) return 0;
     const sqlite2 = getSqlite();
     const scopeFilter = scope.cwd === void 0 ? "" : "AND candidate.cwd = ?";
-    const parameters = scope.cwd === void 0 ? [batchId] : [batchId, scope.cwd];
+    const parameters = scope.cwd === void 0 ? [TASK_BATCH_TRIM_CHARACTERS, normalizedBatchId] : [TASK_BATCH_TRIM_CHARACTERS, normalizedBatchId, scope.cwd];
     return db.transaction(() => sqlite2.query(`
             WITH RECURSIVE
             candidate(id, cwd, depends_on) AS MATERIALIZED (
                 SELECT candidate.id, candidate.cwd, candidate.depends_on
                 FROM tasks AS candidate
-                WHERE candidate.batch_id = ?
+                WHERE trim(candidate.batch_id, ?) = ?
                   AND candidate.status IN ('failed', 'dead_letter')
                   ${scopeFilter}
             ),
@@ -5935,16 +6024,28 @@ var TaskService = class {
   static async list(options = {}) {
     let query = db.select().from(tasks2).$dynamic();
     const conditions = [];
-    if (options.status) {
+    if (options.activeExecution) {
+      conditions.push(or(
+        eq(tasks2.status, "running"),
+        sql`EXISTS (
+                    SELECT 1 FROM task_runs AS active_list_run
+                    WHERE active_list_run.task_id = ${tasks2.id}
+                      AND active_list_run.status = 'running'
+                )`
+      ));
+    } else if (options.status) {
       conditions.push(eq(tasks2.status, options.status));
     }
-    if (options.batchId) {
-      conditions.push(eq(tasks2.batchId, options.batchId));
+    if (options.batchId !== void 0) {
+      const batchId = normalizeTaskBatchId(options.batchId);
+      conditions.push(batchId ? sql`trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS}) = ${batchId}` : sql`0`);
     }
     if (options.category) {
       conditions.push(eq(tasks2.category, options.category));
     }
-    if (options.cwd !== void 0) {
+    if (options.legacyCwd) {
+      conditions.push(sql`${tasks2.cwd} IS NULL OR trim(${tasks2.cwd}) = ''`);
+    } else if (options.cwd !== void 0) {
       conditions.push(eq(tasks2.cwd, options.cwd));
     }
     if (conditions.length > 0) {
@@ -5962,9 +6063,12 @@ var TaskService = class {
   static async stats(options = {}) {
     const conditions = [];
     if (options.batchId !== void 0) {
-      conditions.push(eq(tasks2.batchId, options.batchId));
+      const batchId = normalizeTaskBatchId(options.batchId);
+      conditions.push(batchId ? sql`trim(${tasks2.batchId}, ${TASK_BATCH_TRIM_CHARACTERS}) = ${batchId}` : sql`0`);
     }
-    if (options.cwd !== void 0) {
+    if (options.legacyCwd) {
+      conditions.push(sql`${tasks2.cwd} IS NULL OR trim(${tasks2.cwd}) = ''`);
+    } else if (options.cwd !== void 0) {
       conditions.push(eq(tasks2.cwd, options.cwd));
     }
     const whereCondition = conditions.length > 0 ? and(...conditions) : void 0;
@@ -5989,6 +6093,33 @@ var TaskService = class {
     }
     return stats;
   }
+  static async projectSummaries(limit = 100) {
+    this.validateInteger("limit", limit, 1, 1e3);
+    const lastCreatedAt = sql`max(${tasks2.createdAt})`;
+    const lastTaskId = sql`max(${tasks2.id})`;
+    const rows = await db.select({
+      cwd: tasks2.cwd,
+      total: sql`count(*)`,
+      pending: sql`sum(CASE WHEN ${tasks2.status} = 'pending' THEN 1 ELSE 0 END)`,
+      running: sql`sum(CASE WHEN ${tasks2.status} = 'running' OR EXISTS (
+                    SELECT 1 FROM task_runs AS active_project_run
+                    WHERE active_project_run.task_id = ${tasks2.id}
+                      AND active_project_run.status = 'running'
+                ) THEN 1 ELSE 0 END)`,
+      failed: sql`sum(CASE WHEN ${tasks2.status} IN ('failed', 'dead_letter') THEN 1 ELSE 0 END)`,
+      done: sql`sum(CASE WHEN ${tasks2.status} = 'done' THEN 1 ELSE 0 END)`,
+      lastCreatedAt
+    }).from(tasks2).where(sql`${tasks2.cwd} IS NOT NULL AND trim(${tasks2.cwd}) <> ''`).groupBy(tasks2.cwd).orderBy(desc(lastCreatedAt), desc(lastTaskId)).limit(limit);
+    return rows.flatMap((row) => row.cwd === null ? [] : [{
+      cwd: row.cwd,
+      total: Number(row.total),
+      pending: Number(row.pending),
+      running: Number(row.running),
+      failed: Number(row.failed),
+      done: Number(row.done),
+      lastCreatedAt: row.lastCreatedAt === null ? null : Number(row.lastCreatedAt) * 1e3
+    }]);
+  }
   static async delete(id, scope = {}) {
     const conditions = [
       eq(tasks2.id, id),
@@ -6125,11 +6256,15 @@ import { basename, dirname as dirname2, resolve } from "path";
 var TOKEN_GUARDIAN_LAUNCH_PROTOCOL = "gated-v3-token-guardian";
 var LAUNCH_IDENTITY_ARGUMENT = "--supertask-launch-identity";
 var DRAIN_PROOF_MESSAGE_TYPE = "supertask-drained";
+var DRAIN_PROOF_ACK_MESSAGE_TYPE = "supertask-drained-ack";
 var MANAGED_RUN_ENV = "SUPERTASK_MANAGED_RUN";
 var MANAGED_RUN_ENV_VALUE = "1";
 function isLaunchIdentity(value) {
   return value != null && /^gateway-[1-9]\d*:launch:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
 }
+function drainProofAckForIdentity(launchIdentity) {
+  return { type: DRAIN_PROOF_ACK_MESSAGE_TYPE, identity: launchIdentity };
+}
 function isMatchingDrainProof(message, launchIdentity) {
   if (typeof message !== "object" || message == null) return false;
   const candidate = message;
@@ -6627,7 +6762,8 @@ var WorkerEngine = class {
       if (!task) break;
       if (this.stopped) break;
       if (!await TaskService.start(task.id)) continue;
-      if (task.batchId) this.activeBatchIds.add(task.batchId);
+      const batchId = normalizeTaskBatchId(task.batchId);
+      if (batchId) this.activeBatchIds.add(batchId);
       if (this.stopped) {
         await TaskService.resetRunningToPending([task.id]);
         this.releaseBatch(task);
@@ -6658,6 +6794,14 @@ var WorkerEngine = class {
           this.releaseBatch(task);
           continue;
         }
+        try {
+          validateTaskWorkingDirectory(task.cwd);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          await TaskService.failRun(task.id, run.id, message, { setDeadLetter: true });
+          this.releaseBatch(task);
+          continue;
+        }
         await this.spawnTask(task, run.id, launchIdentity);
       } catch (err) {
         this.releaseBatch(task);
@@ -6743,6 +6887,11 @@ var WorkerEngine = class {
     child.on("message", (message) => {
       if (isMatchingDrainProof(message, entry.launchIdentity)) {
         entry.guardianDrained = true;
+        try {
+          child.send(drainProofAckForIdentity(entry.launchIdentity));
+        } catch (error) {
+          this.logError("drain proof acknowledgment failed", error, task.id);
+        }
       }
     });
     let spawnError = null;
@@ -7022,7 +7171,8 @@ ${output}` : ""}` : output;
     );
   }
   releaseBatch(task) {
-    if (task.batchId) this.activeBatchIds.delete(task.batchId);
+    const batchId = normalizeTaskBatchId(task.batchId);
+    if (batchId) this.activeBatchIds.delete(batchId);
   }
   resolveModel(taskModel) {
     if (!taskModel || taskModel === "default") return null;