@metagptx/deepflow-suite-cli 0.3.0 → 0.3.1

package/runtime/df-task/read.mjs

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+import { lstat, mkdtemp, open, link, rm } from 'node:fs/promises';
+import path from 'node:path';
+
+// Retain every numeric token verbatim, including values outside JS precision.
+export const decodeRaw = (raw) => JSON.parse(raw, (_key, value, context) => typeof value === 'number' ? JSON.rawJSON(context.source) : value);
+export const encodeRaw = (value) => JSON.stringify(value);
+const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) && !JSON.isRawJSON(value);
+const seq = (value) => {
+  if (!JSON.isRawJSON(value) || !/^-?\d+$/.test(value.rawJSON)) throw Error('invalid facts sequence');
+  const n = BigInt(value.rawJSON);
+  if (n < 0n || n > 9223372036854775807n) throw Error('invalid facts sequence');
+  return n;
+};
+const rawSeq = (n) => JSON.rawJSON(BigInt(n).toString());
+
+export function validateReadOptions(o) {
+  const v = o.values;
+  if ('--fields' in v) {
+    if (!o.json) throw Error('--fields requires --json');
+    const roots = o.command === 'get' ? ['id', 'title', 'description', 'description_version', 'metadata', 'created_at', 'updated_at'] : ['seq', 'type', 'actor_kind', 'actor_id', 'payload', 'idempotency_key', 'created_at'];
+    const paths = v['--fields'].split(',');
+    paths.forEach((field, i) => {
+      const parts = field.split('.');
+      if (!roots.includes(parts[0]) || (parts.length > 1 && !['metadata', 'payload'].includes(parts[0]))) throw Error(`unsupported field path ${JSON.stringify(field)} for ${o.command}`);
+      if (parts.some((part) => !part || part.trim() !== part || /[\[\]*\/\\\t\r\n]/.test(part))) throw Error(`invalid object field path ${JSON.stringify(field)}`);
+      if (paths.slice(0, i).some((earlier) => earlier === field || earlier.startsWith(field + '.') || field.startsWith(earlier + '.'))) throw Error('overlapping field paths');
+    });
+  }
+  const all = '--all' in v;
+  if (all && (!o.json || !v['--output-file']?.trim() || '--fields' in v)) throw Error('--all requires --json and --output-file, and cannot be combined with --fields');
+  for (const flag of ['--output-file', '--max-pages', '--max-bytes']) if (flag in v && !all) throw Error(`${flag} requires --all`);
+  for (const [flag, max] of [['--max-pages', 100], ['--max-bytes', 64 << 20]]) {
+    if (flag in v && (!/^\+?\d+$/.test(v[flag]) || BigInt(v[flag]) < 1n || BigInt(v[flag]) > BigInt(max))) throw Error(`${flag} must be between 1 and ${max}`);
+  }
+}
+
+function projectObject(source, paths) {
+  if (!isObject(source)) throw Error('expected a JSON object for field selection');
+  const selected = Object.create(null), children = new Map();
+  for (const field of paths) {
+    const [root, ...parts] = field.split('.');
+    if (parts.length) { if (!children.has(root)) children.set(root, []); children.get(root).push(parts.join('.')); }
+    else if (Object.hasOwn(source, root)) selected[root] = source[root];
+  }
+  for (const [root, subpaths] of children) {
+    if (!Object.hasOwn(source, root) || !isObject(source[root])) continue;
+    const projected = projectObject(source[root], subpaths);
+    if (Object.keys(projected).length) selected[root] = projected;
+  }
+  return selected;
+}
+export function projectResponse(command, raw, paths) {
+  const data = decodeRaw(raw);
+  if (command === 'get') return encodeRaw(projectObject(data, paths));
+  if (!isObject(data) || !Array.isArray(data.facts)) throw Error('expected facts array');
+  data.facts = data.facts.map((fact) => projectObject(fact, paths));
+  return encodeRaw(data);
+}
+const normalizedID = (id) => typeof id === 'string' ? id.toLowerCase().replace(/^urn:uuid:/, '').replace(/[{}-]/g, '') : '';
+export function validateFactPage(raw, taskID, after) {
+  const page = decodeRaw(raw);
+  if (!isObject(page) || !Array.isArray(page.facts) || !Object.hasOwn(page, 'next_after_seq')) throw Error('invalid facts page identity, facts or cursor');
+  if (!/^[0-9a-f]{32}$/.test(normalizedID(page.task_id)) || normalizedID(page.task_id) !== normalizedID(taskID)) throw Error('facts page task_id does not match query');
+  let last = after;
+  for (const fact of page.facts) {
+    if (!isObject(fact) || typeof fact.type !== 'string' || !fact.type || seq(fact.seq) <= last) throw Error(`facts page is not strictly ordered after ${after}`);
+    last = seq(fact.seq);
+  }
+  if (seq(page.next_after_seq) !== last) throw Error(`facts cursor does not match last seq ${last}`);
+  return { facts: page.facts, next: last };
+}
+export async function readResponse(response, limit = 0) {
+  if (!limit) return response.text();
+  let bytes = 0; const chunks = [];
+  for await (const chunk of response.body) {
+    bytes += chunk.length;
+    if (bytes > limit) throw Object.assign(Error('read byte budget exhausted'), { byteLimit: true });
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+export async function readAllFacts(o, baseURL, request, stdout, stderr) {
+  const output = path.resolve(o.values['--output-file']);
+  let temp;
+  try {
+    try { await lstat(output); throw Error(`output file must not exist: ${output}`); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    temp = await mkdtemp(path.join(path.dirname(output), '.task-facts-'));
+  } catch (error) { stderr.write(error.message + '\n'); return 2; }
+  try {
+    const query = { task_id: o.args[0], base_url: baseURL, after_seq: '0', limit: '200' };
+    for (const flag of ['--after', '--types', '--limit', '--metadata-source', '--metadata-query-key']) if (flag in o.values) query[flag === '--after' ? 'after_seq' : flag.slice(2).replaceAll('-', '_')] = o.values[flag];
+    const manifest = { query, complete: false, stop_reason: 'page_limit', pages: 0, count: 0, next_after_seq: rawSeq(query.after_seq), type_counts: Object.create(null), response_bytes: 0, output_file: output };
+    const facts = [], budget = Number(o.values['--max-bytes'] || (8 << 20));
+    let cursor = BigInt(query.after_seq);
+    for (let i = 0; i < Number(o.values['--max-pages'] || 10); i++) {
+      const remaining = budget - manifest.response_bytes;
+      if (remaining <= 0) { manifest.stop_reason = 'byte_limit'; break; }
+      let raw, page;
+      try { raw = await request({ ...o, values: { ...o.values, '--after': String(cursor) } }, remaining); }
+      catch (error) { manifest.stop_reason = error.byteLimit ? 'byte_limit' : 'request_error'; stderr.write(error.message + '\n'); break; }
+      manifest.response_bytes += Buffer.byteLength(raw);
+      try { page = validateFactPage(raw, o.args[0], cursor); }
+      catch (error) { manifest.stop_reason = 'invalid_page'; stderr.write(error.message + '\n'); break; }
+      manifest.pages++;
+      if (!page.facts.length) { manifest.complete = true; manifest.stop_reason = 'empty_page'; break; }
+      for (const fact of page.facts) {
+        if (!manifest.count) manifest.first_seq = fact.seq;
+        manifest.last_seq = fact.seq;
+        manifest.type_counts[fact.type] = (manifest.type_counts[fact.type] || 0) + 1;
+        manifest.count++;
+      }
+      facts.push(...page.facts); cursor = page.next; manifest.next_after_seq = rawSeq(cursor);
+    }
+    const data = Buffer.from(encodeRaw({ query, facts, complete: manifest.complete, stop_reason: manifest.stop_reason, next_after_seq: manifest.next_after_seq }));
+    const staging = path.join(temp, 'facts.json'), file = await open(staging, 'wx', 0o600);
+    try { await file.writeFile(data); } finally { await file.close(); }
+    await link(staging, output);
+    manifest.file_bytes = data.length; manifest.file_sha256 = createHash('sha256').update(data).digest('hex');
+    stdout.write(encodeRaw(manifest) + '\n');
+    if (!manifest.complete) { stderr.write(`incomplete facts read: ${manifest.stop_reason}; next_after_seq=${cursor}\n`); return 1; }
+    return 0;
+  } catch (error) { stderr.write(error.message + '\n'); return 1; }
+  finally { await rm(temp, { recursive: true, force: true }); }
+}

package/runtime/df-task/release.json

@@ -1 +1 @@
-{"version":"0.3.0","project":"deepflow-task","sourceCommit":"3a8f5c8915cf5df74236eb4da693ac75f4c816a8","sourceDirty":false}
+{"version":"0.3.1","project":"deepflow-task","sourceCommit":"a5b9064298158aad2fef2a67f0baa0a638c89f4b","sourceDirty":false}

package/runtime/df-taskdriver/release.json

@@ -1 +1 @@
-{"version":"0.3.0","project":"deepflow-task-driver","sourceCommit":"ab582505c8d60a99c8d2939c3d58b31803a8a229","sourceDirty":false}
+{"version":"0.3.1","project":"deepflow-task-driver","sourceCommit":"c05efdc13dfd0d7a9043007f7421dbd1ac6daab2","sourceDirty":false}

package/runtime/df-workbench/df-workbench.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { randomUUID, createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { basename } from "node:path";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 
@@ -39,6 +40,7 @@ export function parseArgs(argv, env = process.env) {
     baseUrl: env.DF_WORKBENCH_BASE_URL || DEFAULT_BASE_URL,
     token: env.DF_WORKBENCH_TOKEN || "",
     workspace: env.DF_WORKBENCH_WORKSPACE_ID || "",
+    expectedActor: undefined,
     json: false,
     idempotencyKey: "",
     message: "",
@@ -48,6 +50,8 @@ export function parseArgs(argv, env = process.env) {
     scope: "mine",
     squadId: undefined,
     file: undefined,
+    attachmentIds: [],
+    participantIds: [],
   };
   const positionals = [];
   for (let index = 0; index < argv.length; index += 1) {
@@ -67,6 +71,7 @@ export function parseArgs(argv, env = process.env) {
       [
         "--base-url",
         "--workspace",
+        "--expected-actor",
         "--idempotency-key",
         "--message",
         "--title",
@@ -75,6 +80,11 @@ export function parseArgs(argv, env = process.env) {
         "--scope",
         "--squad-id",
         "--file",
+        "--attachment-id",
+        "--member-id",
+        "--expected-owner",
+        "--owner-id",
+        "--participant-id",
       ].includes(name)
     ) {
       const parsed =
@@ -82,6 +92,11 @@ export function parseArgs(argv, env = process.env) {
       if (inline === undefined) index += 1;
       if (name === "--base-url") options.baseUrl = parsed;
       if (name === "--workspace") options.workspace = parsed;
+      if (name === "--expected-actor") {
+        if (!parsed.trim() || parsed.length > 160 || /[\r\n]/.test(parsed))
+          throw new UsageError("--expected-actor 需要有效的用户 ID。");
+        options.expectedActor = parsed;
+      }
       if (name === "--idempotency-key") options.idempotencyKey = parsed;
       if (name === "--message") options.message = parsed;
       if (name === "--title") options.title = parsed;
@@ -90,6 +105,11 @@ export function parseArgs(argv, env = process.env) {
       if (name === "--scope") options.scope = parsed;
       if (name === "--squad-id") options.squadId = parsed;
       if (name === "--file") options.file = parsed;
+      if (name === "--attachment-id") options.attachmentIds.push(parsed);
+      if (name === "--member-id") options.memberId = parsed;
+      if (name === "--expected-owner") options.expectedOwner = parsed;
+      if (name === "--owner-id") options.ownerId = parsed;
+      if (name === "--participant-id") options.participantIds.push(parsed);
       continue;
     }
     if (argument.startsWith("--"))
@@ -245,6 +265,13 @@ async function currentContext(options) {
     throw new RequestError("Workbench 没有返回当前用户。", {
       code: "identity_missing",
     });
+  if (
+    options.expectedActor !== undefined &&
+    options.expectedActor !== me.user.id
+  )
+    throw new RequestError("Workbench 操作身份已变化；未提交业务请求。", {
+      code: "identity_changed",
+    });
   return { me, workspace, actorId: me.user.id };
 }
 
@@ -423,18 +450,28 @@ function help() {
   df-workbench squad get <squad-id> [--json]
   df-workbench squad create --file <配置.json> [--idempotency-key <key>] [--json]
   df-workbench squad update <squad-id> --file <配置.json> [--idempotency-key <key>] [--json]
-  df-workbench task create --message <消息> [--title <标题>] [--squad-id <squad-id>] [--idempotency-key <key>]
+  df-workbench workspace members [--json]
+  df-workbench task create --message <消息> [--title <标题>] [--squad-id <squad-id>] [--owner-id <user-id>] [--participant-id <user-id>] [--idempotency-key <key>]
+  df-workbench task member-options <task-id>
+  df-workbench task invite <task-id> --member-id <user-id> [--idempotency-key <key>]
+  df-workbench task transfer-owner <task-id> --member-id <user-id> --expected-owner <user-id> [--idempotency-key <key>]
   df-workbench task send <task-id> --message <消息> [--idempotency-key <key>]
+  df-workbench task lookup <DF-number> [--json]
   df-workbench task get <task-id> [--json]
   df-workbench task facts <task-id> [--after <seq>] [--limit <n>] [--json]
   df-workbench task list [--scope <mine|workspace>] [--limit <n>] [--json]
+  df-workbench attachment upload --file <文件> [--idempotency-key <key>] [--json]
+
+task create/send 可重复传入 --attachment-id <id>，每次最多 10 个。
 
 全局配置：
   DF_WORKBENCH_BASE_URL       Workbench 根地址，默认 http://127.0.0.1:8793
   DF_WORKBENCH_TOKEN          OIDC 环境使用的 personal token
   DF_WORKBENCH_WORKSPACE_ID   当前工作区覆盖值
+  Token 获取：公司账号登录 → 个人设置 → 个人 Token
   --base-url <url>             覆盖 Workbench 根地址
   --workspace <id>             覆盖当前工作区
+  --expected-actor <user-id>    固定操作身份；身份变化时停止请求
   --json                      输出机器可读 JSON`;
 }
 
@@ -444,6 +481,11 @@ async function run(options) {
     process.stdout.write(`${help()}\n`);
     return;
   }
+  if ((options.ownerId !== undefined || options.participantIds.length) && !(command === "task" && subject === "create")) throw new UsageError("--owner-id 和 --participant-id 仅用于 task create。");
+  if (options.ownerId !== undefined && !/^[\w-]{1,100}$/.test(options.ownerId)) throw new UsageError("初始负责人 ID 无效。");
+  if ((options.memberId !== undefined && !(command === "task" && ["invite","transfer-owner"].includes(subject))) ||
+      (options.expectedOwner !== undefined && !(command === "task" && subject === "transfer-owner")))
+    throw new UsageError("成员和负责人参数只用于对应的任务成员命令。");
   if (
     options.squadId !== undefined &&
     !(command === "task" && subject === "create")
@@ -453,9 +495,57 @@ async function run(options) {
     );
   if (
     options.file !== undefined &&
-    !(command === "squad" && ["create", "update"].includes(subject))
+    !(command === "squad" && ["create", "update"].includes(subject)) &&
+    !(command === "attachment" && subject === "upload")
   )
-    throw new UsageError("--file 仅用于 squad create/update。");
+    throw new UsageError(
+      "--file 仅用于 squad create/update 或 attachment upload。",
+    );
+  if (
+    options.attachmentIds.length &&
+    !(command === "task" && ["create", "send"].includes(subject))
+  )
+    throw new UsageError("--attachment-id 仅用于 task create/send。");
+  if (
+    options.attachmentIds.length > 10 ||
+    new Set(options.attachmentIds).size !== options.attachmentIds.length ||
+    options.attachmentIds.some((id) => !/^[\w-]{1,100}$/.test(id))
+  )
+    throw new UsageError("附件列表无效，每次最多发送 10 个不同附件。");
+  if (command === "attachment" && subject === "upload") {
+    if (!options.file) throw new UsageError("attachment upload 需要 --file。");
+    const fileInfo = await stat(options.file);
+    if (!fileInfo.isFile() || !fileInfo.size || fileInfo.size > 4 * 1024 * 1024)
+      throw new UsageError("每个附件需为 1 字节至 4 MiB。");
+    const bytes = await readFile(options.file);
+    const filename = basename(options.file);
+    if (!bytes.length || bytes.length > 4 * 1024 * 1024)
+      throw new UsageError("每个附件需为 1 字节至 4 MiB。");
+    if (
+      !filename.trim() ||
+      filename.length > 180 ||
+      /[\x00-\x1f\x7f\\]/.test(filename)
+    )
+      throw new UsageError("附件名称无效。");
+    const context = await currentContext(options);
+    const value = await request(
+      options,
+      "/api/v1/task-attachments",
+      {
+        method: "POST",
+        key: idempotencyKey(options),
+        body: { filename, bytesBase64: bytes.toString("base64") },
+      },
+      context,
+    );
+    writeResult(
+      value,
+      options,
+      (value) =>
+        `已上传附件：${value.attachment?.filename} (${value.attachment?.id})`,
+    );
+    return;
+  }
   if (command === "squad") return squadCommand(options, subject, rest);
   if (command === "health") {
     const value = await request(options, "/healthz");
@@ -482,16 +572,44 @@ async function run(options) {
     );
     return;
   }
+  if (command === "workspace" && subject === "members") {
+    const context = await currentContext(options);
+    const value = await request(options,"/api/v1/members",{},context);
+    if (!Array.isArray(value.members)) throw new RequestError("工作区成员目录回执无效。",{code:"invalid_member_directory"});
+    writeResult(value,options,value => value.members.map(member=>`${member.userId} ${member.name || ""}`).join("\n"));return;
+  }
   if (command !== "task") throw new UsageError(`不支持的命令：${command}`);
+  if (["member-options", "invite", "transfer-owner"].includes(subject)) {
+    const taskId = rest[0];
+    if (!taskId || !/^[\w-]{1,160}$/.test(taskId)) throw new UsageError("需要有效的 Task ID。");
+    const writes = subject !== "member-options";
+    if (writes && !/^[\w-]{1,100}$/.test(options.memberId || "")) throw new UsageError("需要 --member-id 指定有效的 DF 用户 ID。");
+    if (subject === "transfer-owner" && !/^[\w-]{1,100}$/.test(options.expectedOwner || "")) throw new UsageError("需要 --expected-owner 指定当前负责人 ID。");
+    const context = await currentContext(options);
+    const path = subject === "member-options" ? `/api/v1/task-ui/tasks/${encodeURIComponent(taskId)}/property-options`
+      : `/api/v1/tasks/${encodeURIComponent(taskId)}/${subject === "invite" ? "member-invitations" : "owner-transfer"}`;
+    const value = await request(options, path, writes ? {method:"POST", key:idempotencyKey(options), body:subject === "invite"
+      ? {invitee_ids:[options.memberId]} : {new_owner_id:options.memberId,expected_owner_id:options.expectedOwner}} : {}, context);
+    writeResult(value, options, value => JSON.stringify(value));
+    return;
+  }
   if (subject === "create") {
     const body = buildCreateBody(
       options.message,
       options.title,
       options.squadId,
     );
+    if (options.ownerId) {
+      if (![options.ownerId,...options.participantIds].every(id=>/^[\w-]{1,100}$/.test(id))) throw new UsageError("初始负责人和参与人 ID 无效。");
+      body.initial_owner_id=options.ownerId;
+      body.first_message="";
+      body.invitee_ids=[...new Set(options.participantIds)].sort();
+    } else if(options.participantIds.length) throw new UsageError("--participant-id 需要同时指定 --owner-id。");
+    if (options.attachmentIds.length && !options.ownerId)
+      body.attachment_ids = options.attachmentIds;
     const context = await currentContext(options);
     const key = idempotencyKey(options);
-    const value = await request(
+    let value = await request(
       options,
       "/api/v1/tasks",
       {
@@ -514,6 +632,23 @@ async function run(options) {
           idempotencyKey: key,
         },
       );
+    if (options.ownerId) {
+      const task=value?.task,data=task?.metadata?.data;
+      if (!task?.id || data?.workspace_id!==context.workspace || data.owner_id!==options.ownerId || data.created_by!==context.actorId ||
+        ![context.actorId,options.ownerId,...options.participantIds].every(id=>data.members?.includes(id))) throw new RequestError("已创建的任务初始负责人或成员回执不匹配，请保留原幂等键核对，不要重建。",{code:"task_metadata_mismatch",outcome:"unknown",taskId:task?.id,idempotencyKey:key});
+      // Current squad edits must never change a retry of the original message.
+      const agentId=data.initial_message_context?.agentId;
+      if (!agentId) throw new RequestError("任务已创建，但创建时的小队快照没有可接收首条消息的伙伴；请保留原任务与幂等键核对。",{code:"initial_agent_unavailable",outcome:"unknown",taskId:task.id,idempotencyKey:key});
+      const firstKey="initial-message:"+createHash("sha256").update(key).digest("hex");
+      let first;
+      try {
+        first=await request(options,`/api/v1/tasks/${encodeURIComponent(task.id)}/messages`,{method:"POST",key:firstKey,body:{text:messageValue(options.message),agentIds:[agentId],...(options.attachmentIds.length?{attachment_ids:options.attachmentIds}:{})}},context);
+      } catch(error) {
+        throw new RequestError(`任务 ${task.id} 已创建，首条消息回执尚待确认；保留幂等键 ${key} 重试，不换键或重建。`,{code:"initial_message_unconfirmed",outcome:"unknown",taskId:task.id,idempotencyKey:key,causeCode:error.code});
+      }
+      if (!Number.isSafeInteger(first?.fact?.seq) || first.fact.task_id!==task.id) throw new RequestError("初始消息回执不匹配；保留原任务与幂等键重试。",{code:"initial_message_unconfirmed",outcome:"unknown",taskId:task.id,idempotencyKey:key});
+      value={...value,first_fact:first.fact,first_fact_seq:first.fact.seq};
+    }
     writeResult(value, options, taskSummary);
     return;
   }
@@ -525,7 +660,16 @@ async function run(options) {
     const value = await request(
       options,
       `/api/v1/tasks/${encodeURIComponent(taskId)}/messages`,
-      { method: "POST", key, body: { text: messageValue(options.message) } },
+      {
+        method: "POST",
+        key,
+        body: {
+          text: messageValue(options.message),
+          ...(options.attachmentIds.length
+            ? { attachment_ids: options.attachmentIds }
+            : {}),
+        },
+      },
       context,
     );
     writeResult(
@@ -535,6 +679,29 @@ async function run(options) {
     );
     return;
   }
+  if (subject === "lookup") {
+    const number = String(rest[0] || "").toUpperCase();
+    if (!/^DF-\d+$/.test(number)) throw new UsageError("task lookup 需要 DF 编号。");
+    const context = await currentContext(options);
+    for (let page = 0, offset = 0; page < 20; page++) {
+      const result = await request(options, `/api/v1/tasks?${new URLSearchParams({scope:"workspace",limit:"200",offset:String(offset)})}`, {}, context);
+      if (!Array.isArray(result.tasks) || typeof result.hasMore !== "boolean") throw new RequestError("工作区任务分页回执不完整，尚不能判断该编号是否存在。",{code:"task_lookup_incomplete"});
+      const matches = result.tasks.filter(task => task.number === number);
+      if (matches.length > 1) throw new RequestError("工作区中出现重复任务编号，请核实目标。",{code:"task_lookup_ambiguous"});
+      if (matches.length) {
+        const task = matches[0];
+        if (task.access === "overview") throw new RequestError(`${number} 存在，但当前账号尚未加入任务，请先获得参与权限。`,{code:"task_participation_required",status:403});
+        const value = await request(options, `/api/v1/tasks/${encodeURIComponent(task.id)}`, {}, context);
+        if (value.task?.id !== task.id || value.task?.number !== number || value.task?.metadata?.data?.workspace_id !== context.workspace || value.task?.access === "overview")
+          throw new RequestError("DF 编号、工作区或内容权限读回不一致，暂停操作。",{code:"task_lookup_mismatch"});
+        writeResult(value, options, taskSummary);return;
+      }
+      if (!result.hasMore) throw new RequestError(`当前工作区未找到 ${number}，请确认编号。`,{code:"task_not_found",status:404});
+      if (!result.tasks.length) break;
+      offset += result.tasks.length;
+    }
+    throw new RequestError("工作区任务查询尚未完成，请稍后再试；不会新建任务。",{code:"task_lookup_incomplete"});
+  }
   if (subject === "get") {
     const taskId = rest[0];
     if (!taskId) throw new UsageError("task get 需要 Task ID。");

package/runtime/df-workbench/release.json

@@ -1 +1 @@
-{"version":"0.3.0","project":"deepflow-workbench","sourceCommit":"6afd4dec2000e93a971c94d4f18126c10f74a300","sourceDirty":false}
+{"version":"0.3.1","project":"deepflow-workbench","sourceCommit":"b83963f15f4ed187164464dddbfd2ea460f52971","sourceDirty":false}