@metagptx/deepflow-suite-cli 0.2.10 → 0.3.0

package/bundle/skills/df-task/skill_test.go

@@ -1,201 +0,0 @@
-package skill
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/deepflow/deepflow-task/internal/authz"
-	"github.com/deepflow/deepflow-task/internal/model"
-	"github.com/deepflow/deepflow-task/internal/validate"
-)
-
-func readFile(t *testing.T, path string) string {
-	t.Helper()
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return string(data)
-}
-
-func TestSkillHasFrontmatter(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	if !strings.HasPrefix(content, "---\n") {
-		t.Fatal("SKILL.md must start with YAML frontmatter")
-	}
-	frontmatter, _, found := strings.Cut(strings.TrimPrefix(content, "---\n"), "\n---")
-	if !found {
-		t.Fatal("frontmatter is not closed")
-	}
-	for _, key := range []string{"name:", "description:"} {
-		if !strings.Contains(frontmatter, key) {
-			t.Errorf("frontmatter is missing %s", key)
-		}
-	}
-	if !strings.Contains(frontmatter, "name: df-task") {
-		t.Errorf("frontmatter name must be df-task, got %q", frontmatter)
-	}
-}
-
-func TestSkillReferenceDocumentsEveryFactType(t *testing.T) {
-	// **十六种全要，不是只要智能体写得了的那九种。** 这份 reference 的作用是让智能体
-	// 读日志时认得每一条事实 —— 只遍历两个 Run 身份的可写集合，把「## 外部输入」
-	// 或「## 推进器写的」整张表删掉照样全绿，而 `external_result` 与 `invocation_ended`
-	// 是三条触发事实里的两条，认不出它们，读日志就读漏了最关键的两种。
-	reference := readFile(t, filepath.Join("references", "fact-types.md"))
-	for _, factType := range model.FactTypes() {
-		if !strings.Contains(reference, string(factType)) {
-			t.Errorf("references/fact-types.md 没有记 %s", factType)
-		}
-	}
-	// 「一共十六种」这个数字也要钉住。不钉的话，将来加第十六种类型时 Task 10 的
-	// `len(payloadSchemas) != len(model.FactTypes())` 会红，而这份文档会悄悄过期。
-	// **两个条件要各给自己的报错。** 合成一句 `if A || B` 的话，「有人把文档里那句话
-	// 删了而类型数还是 15」这一路会红出「文档写的是十六种，而 FactTypes() 有 15 种」
-	// —— 一句不含任何矛盾的话，看的人不知道该改文档还是改代码。而这一路恰好是最
-	// 常见的那一路：改文档比加第十六种类型常见得多。
-	if len(model.FactTypes()) != 16 {
-		t.Errorf("model.FactTypes() 有 %d 种，而 fact-types.md 与本断言都按十六种写的 —— 加了新类型要同时改这两处", len(model.FactTypes()))
-	}
-	if !strings.Contains(reference, "一共十六种事实") {
-		t.Error("fact-types.md 里找不到「一共十六种事实」这句 —— 这个数字是文档过期的唯一机械信号，不要删")
-	}
-}
-
-func TestSkillCommandTablesMatchTheAuthorizationMatrix(t *testing.T) {
-	// 两个方向都要验。只验「不该出现的没出现」，那么往调度一节里插一行
-	// `--type run_outcome` 照样全绿，而任务 Run 读到它就会去写，然后拿一个 403；
-	// 只验「该出现的出现了」，那么删掉一整行命令也照样全绿，而 Agent 在 Run 里
-	// 只有这份文档可读 —— 少一行，那条事实它就永远不会写。
-	content := readFile(t, "SKILL.md")
-	sections := map[model.ActorKind]string{
-		model.ActorTaskRun:      "## 任务 Run 可以写什么",
-		model.ActorSchedulerRun: "## 调度 Run 可以写什么",
-	}
-	for kind, heading := range sections {
-		// strings.Cut 返回三个值：before、after、found。这里要的是标题**之后**那段，
-		// 所以第一个返回值丢掉 —— 接成两个变量编译就过不去。
-		_, afterHeading, found := strings.Cut(content, heading)
-		if !found {
-			t.Fatalf("SKILL.md is missing the %q section", heading)
-		}
-		// 截到下一个 `## ` 为止。两节各自只谈自己那个身份，所以「职责边界」一节里
-		// 那句「写一条 summary 或 help_requested 说明情况」不会被算进调度一节。
-		section, _, _ := strings.Cut(afterHeading, "\n## ")
-		for _, factType := range model.FactTypes() {
-			// 正向只认表格那一列的形状 `| ` + 类型名 + `` ` ``。用裸的 Contains 会被
-			// 同一节的正文喂饱 —— 「`run_outcome` 只是你的主张」「读日志时你看到的是
-			// `dispatch_intent`」这些句子里都有类型名，于是删掉对应那行命令照样全绿，
-			// 而 Agent 在 Run 里只有这份文档可读，少一行那条事实它就永远不会写。
-			inTable := strings.Contains(section, "| `"+string(factType)+"`")
-			// 反向要宽：正文里出现一个写不了的类型，同样会把 Agent 带去拿 403。
-			mentioned := strings.Contains(section, string(factType))
-			switch {
-			case authz.CanWrite(kind, factType) && !inTable:
-				t.Errorf("%s 的命令表里没有 %s，而这个身份写得了它", heading, factType)
-			case !authz.CanWrite(kind, factType) && mentioned:
-				t.Errorf("%s 一节提了 %s，而这个身份写它会拿 403", heading, factType)
-			}
-		}
-	}
-	// 上面那两节里没有推进器的身份，所以唤起生命周期靠这一条兜：整份文档里都不许
-	// 出现「让 Agent 用 append 写它」的样子。
-	for _, factType := range authz.WritableBy(model.ActorDriver) {
-		if strings.Contains(content, string(factType)+" --file") {
-			t.Errorf("SKILL.md shows an agent writing %s; only the driver writes the invocation lifecycle", factType)
-		}
-	}
-}
-
-func TestSkillStatesTheEnvironmentContract(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	// DF_TASK_ID 和 DF_RUN_ID 也在这份清单里：SKILL.md 的示例命令用了它们，
-	// 而它们由 runtime 注入、不由本服务定义。示例里出现却没说明来源，
-	// Agent 就会以为要自己编一个。
-	for _, needle := range []string{"DF_TASK_BASE_URL", "DF_TASK_ACTOR_KIND", "DF_TASK_ACTOR_ID", "DF_TASK_ID", "DF_RUN_ID", "--json"} {
-		if !strings.Contains(content, needle) {
-			t.Errorf("SKILL.md does not mention %s", needle)
-		}
-	}
-}
-
-// 推进器拉起的 Run 里没有人可问。环境门禁若在 Run 内也要求询问，调度 Agent
-// 每一轮都会停下不读事实，而推进器照常记下执行结束——多轮执行就此静默断掉。
-func TestSkillResolvesTheRunEnvironmentWithoutAsking(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	for _, needle := range []string{"### Run 内的目标环境", "`DF_TASK_BASE_URL` 由部署注入", "不根据同名 Service DNS 猜成 dev", "不询问"} {
-		if !strings.Contains(content, needle) {
-			t.Errorf("SKILL.md does not state %q", needle)
-		}
-	}
-}
-
-func TestSkillStatesFactsAreAppendOnly(t *testing.T) {
-	content := readFile(t, "SKILL.md")
-	if !strings.Contains(content, "只追加") {
-		t.Fatal("SKILL.md must state that facts are append-only")
-	}
-}
-
-func TestPayloadExamplesPassServerValidation(t *testing.T) {
-	entries, err := os.ReadDir(filepath.Join("assets", "payload-examples"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(entries) == 0 {
-		t.Fatal("there must be at least one payload example")
-	}
-	checked := 0
-	for _, entry := range entries {
-		// 只看 .json。这台机器上到处都是 .DS_Store，不过滤的话它会被当成
-		// 一个叫 ".DS_Store" 的事实类型，测试在一个与代码无关的原因上变红。
-		if !strings.HasSuffix(entry.Name(), ".json") {
-			continue
-		}
-		checked++
-		name := strings.TrimSuffix(entry.Name(), ".json")
-		factType := model.FactType(name)
-		if !model.KnownFactType(factType) {
-			t.Errorf("%s is not a fact type", entry.Name())
-			continue
-		}
-		raw := readFile(t, filepath.Join("assets", "payload-examples", entry.Name()))
-		if !json.Valid([]byte(raw)) {
-			t.Errorf("%s is not valid JSON", entry.Name())
-			continue
-		}
-		if err := validate.Payload(factType, []byte(raw)); err != nil {
-			t.Errorf("%s would be rejected by the server: %v", entry.Name(), err)
-		}
-	}
-	if checked == 0 {
-		t.Fatal("the directory has entries but none of them is a .json example")
-	}
-}
-
-func TestEveryHandWrittenPayloadHasAnExample(t *testing.T) {
-	// 凡是 SKILL.md 让智能体自己写 payload 的事实类型，都要有一份能抄的样例。
-	// 语法糖那三种（dispatch / wait / handoff）的字段由 CLI 填，不需要样例。
-	// **这里两个身份都要走。** 只走任务 Run 的话，调度 Run 那两种手写类型就露在外面：
-	// `adjudication` 的 `subject` 是全服务唯一一个数字字段，没样例的调度智能体会写成
-	// 字符串然后吃一个 422；而日志只追加，它既改不了那条，也没有别的地方能学对。
-	sugar := map[model.FactType]bool{
-		model.FactDispatchIntent: true,
-		model.FactWaitingReason:  true,
-		model.FactHandoffToHuman: true,
-	}
-	for _, kind := range []model.ActorKind{model.ActorTaskRun, model.ActorSchedulerRun} {
-		for _, factType := range authz.WritableBy(kind) {
-			if sugar[factType] {
-				continue
-			}
-			path := filepath.Join("assets", "payload-examples", string(factType)+".json")
-			if _, err := os.Stat(path); err != nil {
-				t.Errorf("%s 缺样例，而 %s 要手写这份 payload：%v", factType, kind, err)
-			}
-		}
-	}
-}

package/bundle/skills/df-workbench/manifest.yaml

@@ -1,5 +0,0 @@
-id: df-workbench
-version: 1.0.0
-provides:
-  skill: df-workbench
-  cli: df-workbench

package/scripts/build-runtime-packages.mjs

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { readFile } from "node:fs/promises";
-
-import {
-  buildRuntimePackages,
-  verifyRuntimePackage,
-} from "../src/runtime-build.mjs";
-import { supportedRuntimePlatforms } from "../src/runtime-package.mjs";
-
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const workspaceRoot = path.resolve(packageRoot, "../..");
-
-function option(argv, name, fallback) {
-  const index = argv.indexOf(name);
-  return index === -1 ? fallback : argv[index + 1];
-}
-
-const argv = process.argv.slice(2);
-const outputRoot = path.resolve(option(argv, "--output", path.join(packageRoot, "platform-packages")));
-const version = option(argv, "--version", JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8")).version);
-const check = argv.includes("--check");
-
-if (check) {
-  for (const target of supportedRuntimePlatforms()) {
-    await verifyRuntimePackage({
-      packageRoot: path.join(outputRoot, target.package.replace(/^@[^/]+\//, "")),
-      target,
-      expectedVersion: version,
-    });
-  }
-  console.log(JSON.stringify({ ok: true, outputRoot, version, packages: supportedRuntimePlatforms().map((target) => target.package) }, null, 2));
-} else {
-  const result = await buildRuntimePackages({ workspaceRoot, outputRoot, version });
-  console.log(JSON.stringify({ ok: true, outputRoot, version, packages: result.packages }, null, 2));
-}

package/skills/deepflow-suite/SKILL.md

@@ -1,81 +0,0 @@
----
-name: deepflow-suite
-description: DeepFlow 统一入口。常规任务默认使用 df-workbench；只有用户明确要求或 Workbench 事实无法解释阻塞时，才按顺序检查 Task、Task Driver、Agent Control 和 Agent Runtime。
----
-
-# DeepFlow Suite
-
-这是 DeepFlow 的统一用户和开发者入口。它开放完整的 DeepFlow 能力，但不默认调用整条链路：普通任务先走 `df-workbench`，只有确实需要解释推进、Agent 或 Runtime 问题时才升级到其他项目 CLI。
-
-## 依赖
-
-本 Skill 依赖以下项目级 Skill 和 CLI：
-
-- `df-workbench`：用户身份、工作区、Workbench 配置和任务事实；
-- `df-task`：Task 原始事实和事实落库核对；
-- `df-taskdriver`：任务推进和唤起兑现诊断；
-- `df-agentctrl`：Agent 定义、版本和可分配目录；
-- `df-agentrt`：Session、Invocation、transcript 和运行现场。
-- `df-agentrt-repo`：在 Runtime 会话中发现和追加代码仓库。
-
-这些依赖由 `deepflow-suite` 安装器统一安装。不要因为某个依赖缺失就自行复制 Skill、克隆仓库或切换安装源。
-
-## 环境门禁
-
-用户没有明确说 `local`、本地、`dev`、开发环境或 `prod`、生产环境时，先询问：
-
-```text
-请指定目标环境：local（本地）、dev（开发环境）还是 prod（生产环境）？
-```
-
-环境一旦选定，本轮所有 Workbench、Task、Driver、Agent Control 和 Runtime 请求保持在同一环境。连接失败不能静默切换环境。
-
-`prod` 当前指国内生产 `prod-cn`。各服务的地址和访问方式以对应服务 Skill 为准；先选择环境，再显式设置该服务的地址变量或参数，CLI 不会根据环境名自动选址。普通任务先设置 `DF_WORKBENCH_BASE_URL` 并走 Workbench；开发者只在需要时使用其他服务入口。Run 内使用服务 Skill 规定的部署注入上下文，不根据重复的 Service DNS 或业务项目目标环境切换流程服务。
-
-## 默认路由
-
-### 普通任务
-
-创建任务、继续对话、查看任务和读取可见进度，只调用 `df-workbench`：
-
-```bash
-df-workbench me --json
-df-workbench config --json
-df-workbench task create --message '<用户原始请求>' --json
-df-workbench task send <task-id> --message '<补充内容>' --json
-df-workbench task get <task-id> --json
-df-workbench task facts <task-id> --json
-```
-
-不要在普通用户入口直接调用 `df-task` 写接口，不要伪造 `DF_TASK_ACTOR_*`，不要自行创建 Run 或选择执行 Agent。
-
-### 深度排障
-
-用户询问“任务为什么卡住”“为什么没有执行”“查看 Session/Invocation”“检查 Driver/Agent/Runtime”时，按以下顺序只读检查：
-
-```text
-df-workbench
-  → df-task
-  → df-taskdriver
-  → df-agentctrl
-  → df-agentrt
-```
-
-前一步事实不足以解释问题时，才进入下一步。不要把某个服务可达描述成整条链路成功，也不要把未知状态描述成完成或失败。
-
-## 写操作安全
-
-- 普通排障优先只读；
-- 取消、释放 Session、修复孤儿执行、启停或回退 Agent 前必须获得明确确认；
-- 不直接修改 Task 事实；
-- 不因诊断失败而重建 Session、Invocation 或切换环境；
-- 所有服务请求保持在用户选定的环境。
-
-## 输出边界
-
-回复时区分：
-
-1. 已由事实确认的结果；
-2. Driver、Agent Control 或 Runtime 返回的诊断；
-3. 仍无法确认的未知状态；
-4. 需要用户或服务维护者采取的下一步。

package/skills/deepflow-suite/manifest.yaml

@@ -1,20 +0,0 @@
-id: deepflow-suite
-version: 0.2.9
-kind: composite-skill
-requires:
-  skills:
-    - df-workbench
-    - df-task
-    - df-taskdriver
-    - df-agentctrl
-    - df-agentrt
-    - df-agentrt-repo
-  cli:
-    - df-workbench
-    - df-task
-    - df-taskdriver
-    - df-agentctrl
-    - df-agentrt
-resolution:
-  managed_by: deepflow-suite
-  install_missing_dependencies: false

package/src/cli-launcher.mjs

@@ -1,71 +0,0 @@
-import { createRequire } from "node:module";
-import { readFile } from "node:fs/promises";
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { verifyRuntimePackage } from "./runtime-build.mjs";
-import {
-  runtimeBinaryFileName,
-  runtimeBinaryNames,
-  runtimePackageForPlatform,
-} from "./runtime-package.mjs";
-
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-function defaultPackageRoot() {
-  return PACKAGE_ROOT;
-}
-
-function packageTarget(platform, arch) {
-  const packageName = runtimePackageForPlatform(platform, arch);
-  if (!packageName) throw new Error(`unsupported DeepFlow CLI platform: ${platform}/${arch}`);
-  return { platform, arch, package: packageName };
-}
-
-export function resolveInstalledPackageRoot(packageRoot, packageName) {
-  const require = createRequire(path.join(packageRoot, "package.json"));
-  try {
-    return path.dirname(require.resolve(`${packageName}/package.json`, { paths: [packageRoot] }));
-  } catch {
-    throw new Error(`optional runtime package ${packageName} is not installed; reinstall without --omit=optional`);
-  }
-}
-
-function runProcess(command, args, env = process.env) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { env, stdio: "inherit" });
-    child.once("error", reject);
-    child.once("close", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
-  });
-}
-
-export async function runRuntimeCli(name, argv = [], options = {}) {
-  if (!runtimeBinaryNames().includes(name)) throw new Error(`unsupported runtime CLI: ${name}`);
-  const packageRoot = options.packageRoot ?? defaultPackageRoot();
-  const platform = options.platform ?? process.platform;
-  const arch = options.arch ?? process.arch;
-  const target = packageTarget(platform, arch);
-  const runtimeRoot = resolveInstalledPackageRoot(packageRoot, target.package);
-  const packageJson = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
-  const release = await verifyRuntimePackage({
-    packageRoot: runtimeRoot,
-    target,
-    expectedVersion: packageJson.version,
-  });
-  const binary = release.binaries.find((entry) => entry.name === name);
-  const binaryPath = path.join(runtimeRoot, binary.path);
-  return runProcess(binaryPath, argv, options.env ?? process.env);
-}
-
-export async function runWorkbench(argv = [], options = {}) {
-  const packageRoot = options.packageRoot ?? defaultPackageRoot();
-  const entry = path.join(packageRoot, "runtime", "df-workbench.mjs");
-  return runProcess(process.execPath, [entry, ...argv], options.env ?? process.env);
-}
-
-export function runtimeLauncherTarget(platform = process.platform, arch = process.arch) {
-  return packageTarget(platform, arch);
-}
-
-export { runtimeBinaryFileName };

package/src/runtime-build.mjs

@@ -1,193 +0,0 @@
-import { access, chmod, lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { execFile as execFileCallback } from "node:child_process";
-import os from "node:os";
-import path from "node:path";
-import { promisify } from "node:util";
-
-import {
-  runtimeBinaryFileName,
-  runtimeBinaryNames,
-  runtimePackageForPlatform,
-  supportedRuntimePlatforms,
-} from "./runtime-package.mjs";
-
-const execFile = promisify(execFileCallback);
-const SOURCE_PROJECTS = Object.freeze({
-  "df-task": { project: "deepflow-task", target: "./cmd/df-task" },
-  "df-taskdriver": { project: "deepflow-task-driver", target: "./cmd/df-taskdriver" },
-  "df-agentctrl": { project: "deepflow-agent-ctrl", target: "./cmd/df-agentctrl" },
-  "df-agentrt": { project: "deepflow-agent-runtime", target: "./cmd/df-agentrt-cli" },
-});
-
-function packageDirectoryName(packageName) {
-  return packageName.replace(/^@[^/]+\//, "");
-}
-
-function validateTarget(target) {
-  const expectedPackage = runtimePackageForPlatform(target.platform, target.arch);
-  if (!expectedPackage || target.package !== expectedPackage) {
-    throw new Error(`runtime package name does not match target ${target.platform}/${target.arch}`);
-  }
-}
-
-async function sha256(filePath) {
-  const contents = await readFile(filePath);
-  return {
-    size: contents.byteLength,
-    sha256: createHash("sha256").update(contents).digest("hex"),
-  };
-}
-
-async function verifyRegularFile(filePath) {
-  const stats = await lstat(filePath);
-  if (!stats.isFile()) throw new Error(`runtime binary is not a regular file: ${filePath}`);
-  await access(filePath);
-  return stats;
-}
-
-export async function verifyRuntimePackage({ packageRoot, target, expectedVersion }) {
-  validateTarget(target);
-  const packageJson = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
-  if (packageJson.name !== target.package) throw new Error(`runtime package name must be ${target.package}`);
-  if (packageJson.version !== expectedVersion) throw new Error(`runtime package version ${packageJson.version} does not match ${expectedVersion}`);
-  if (JSON.stringify(packageJson.os) !== JSON.stringify([target.platform])) {
-    throw new Error(`runtime package OS must be ${target.platform}`);
-  }
-  if (JSON.stringify(packageJson.cpu) !== JSON.stringify([target.arch])) {
-    throw new Error(`runtime package CPU must be ${target.arch}`);
-  }
-  const release = JSON.parse(await readFile(path.join(packageRoot, "deepflow-runtime-release.json"), "utf8"));
-  if (release.schemaVersion !== 1 || release.distribution !== "deepflow-suite" || release.package !== target.package) {
-    throw new Error("invalid DeepFlow runtime release metadata");
-  }
-  if (release.version !== expectedVersion || release.platform !== target.platform || release.arch !== target.arch) {
-    throw new Error("runtime release metadata does not match package target");
-  }
-  if (!Array.isArray(release.binaries) || release.binaries.length !== runtimeBinaryNames().length) {
-    throw new Error("runtime release must contain exactly four CLI binaries");
-  }
-  const expectedNames = runtimeBinaryNames().sort();
-  const actualNames = release.binaries.map((binary) => binary?.name).sort();
-  if (JSON.stringify(expectedNames) !== JSON.stringify(actualNames)) {
-    throw new Error("runtime release contains an unexpected CLI binary");
-  }
-  for (const binary of release.binaries) {
-    const expectedPath = path.posix.join("bin", runtimeBinaryFileName(binary.name, target.platform));
-    if (binary.path !== expectedPath || !Number.isSafeInteger(binary.size) || binary.size < 1
-      || !/^[a-f0-9]{64}$/.test(binary.sha256)) {
-      throw new Error(`invalid runtime binary metadata: ${binary.name}`);
-    }
-    const binaryPath = path.join(packageRoot, binary.path);
-    const stats = await verifyRegularFile(binaryPath);
-    const digest = await sha256(binaryPath);
-    if (digest.size !== binary.size || digest.sha256 !== binary.sha256) {
-      throw new Error(`runtime binary hash does not match release metadata: ${binary.name}`);
-    }
-    if (target.platform !== "win32" && (stats.mode & 0o111) === 0) {
-      throw new Error(`runtime binary is not executable: ${binary.name}`);
-    }
-  }
-  return release;
-}
-
-async function buildGoBinary({ workspaceRoot, source, outputPath, target }) {
-  const projectRoot = path.join(workspaceRoot, source.project);
-  await execFile("go", ["build", "-trimpath", "-ldflags=-s -w", "-o", outputPath, source.target], {
-    cwd: projectRoot,
-    env: {
-      ...process.env,
-      CGO_ENABLED: "0",
-      GOOS: target.platform === "win32" ? "windows" : target.platform,
-      GOARCH: target.arch === "x64" ? "amd64" : target.arch,
-    },
-  });
-}
-
-function packageJsonForTarget(target, version) {
-  return {
-    name: target.package,
-    version,
-    description: `DeepFlow Suite CLI runtime binaries for ${target.platform}/${target.arch}.`,
-    license: "UNLICENSED",
-    files: ["bin/", "deepflow-runtime-release.json", "README.md"],
-    os: [target.platform],
-    cpu: [target.arch],
-  };
-}
-
-async function buildOnePackage({ workspaceRoot, outputRoot, version, target, buildBinary }) {
-  validateTarget(target);
-  const packageRoot = path.join(outputRoot, packageDirectoryName(target.package));
-  const stagingRoot = await mkdtemp(path.join(outputRoot, `.${packageDirectoryName(target.package)}.tmp-`));
-  try {
-    await mkdir(path.join(stagingRoot, "bin"), { recursive: true });
-    const binaries = [];
-    for (const name of runtimeBinaryNames()) {
-      const fileName = runtimeBinaryFileName(name, target.platform);
-      const relativePath = path.posix.join("bin", fileName);
-      const outputPath = path.join(stagingRoot, "bin", fileName);
-      const source = SOURCE_PROJECTS[name];
-      await buildBinary({ name, outputPath, source, target, workspaceRoot });
-      if (target.platform !== "win32") await chmod(outputPath, 0o755);
-      const digest = await sha256(outputPath);
-      binaries.push({ name, path: relativePath, ...digest });
-    }
-
-    const release = {
-      schemaVersion: 1,
-      distribution: "deepflow-suite",
-      package: target.package,
-      version,
-      platform: target.platform,
-      arch: target.arch,
-      binaries,
-    };
-    await writeFile(path.join(stagingRoot, "package.json"), `${JSON.stringify(packageJsonForTarget(target, version), null, 2)}\n`);
-    await writeFile(path.join(stagingRoot, "deepflow-runtime-release.json"), `${JSON.stringify(release, null, 2)}\n`);
-    await writeFile(
-      path.join(stagingRoot, "README.md"),
-      `# ${target.package}\n\nPlatform runtime binaries for DeepFlow Suite ${version} (${target.platform}/${target.arch}).\n`,
-    );
-    await rm(packageRoot, { recursive: true, force: true });
-    await rename(stagingRoot, packageRoot);
-    return { package: target.package, directory: packageRoot, release };
-  } catch (error) {
-    await rm(stagingRoot, { recursive: true, force: true });
-    throw error;
-  }
-}
-
-export async function buildRuntimePackages({
-  workspaceRoot,
-  outputRoot,
-  version,
-  targets = supportedRuntimePlatforms(),
-  buildBinary = buildGoBinary,
-}) {
-  if (!workspaceRoot) throw new Error("runtime build workspace root is required");
-  if (!outputRoot) throw new Error("runtime build output root is required");
-  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
-    throw new Error("runtime package version must be a semantic version");
-  }
-  await mkdir(outputRoot, { recursive: true });
-  const results = [];
-  for (const target of targets) {
-    results.push(await buildOnePackage({ workspaceRoot, outputRoot, version, target, buildBinary }));
-  }
-  return { packages: results.map((result) => result.package), results };
-}
-
-export function runtimeSourceProjects() {
-  return structuredClone(SOURCE_PROJECTS);
-}
-
-export function hostRuntimeTarget() {
-  return { platform: process.platform, arch: process.arch, package: runtimePackageForPlatform(process.platform, process.arch) };
-}
-
-export async function buildHostRuntimePackage(options) {
-  const target = hostRuntimeTarget();
-  if (!target.package) throw new Error(`unsupported runtime platform: ${os.platform()}/${os.arch()}`);
-  return buildRuntimePackages({ ...options, targets: [target] });
-}

package/src/runtime-package.mjs

@@ -1,31 +0,0 @@
-const RUNTIME_BINARY_NAMES = Object.freeze([
-  "df-task",
-  "df-taskdriver",
-  "df-agentctrl",
-  "df-agentrt",
-]);
-
-const RUNTIME_TARGETS = Object.freeze([
-  Object.freeze({ platform: "darwin", arch: "arm64", package: "@metagptx/deepflow-suite-cli-darwin-arm64" }),
-  Object.freeze({ platform: "darwin", arch: "x64", package: "@metagptx/deepflow-suite-cli-darwin-x64" }),
-  Object.freeze({ platform: "linux", arch: "arm64", package: "@metagptx/deepflow-suite-cli-linux-arm64" }),
-  Object.freeze({ platform: "linux", arch: "x64", package: "@metagptx/deepflow-suite-cli-linux-x64" }),
-  Object.freeze({ platform: "win32", arch: "x64", package: "@metagptx/deepflow-suite-cli-win32-x64" }),
-]);
-
-export function supportedRuntimePlatforms() {
-  return RUNTIME_TARGETS.map((target) => ({ ...target }));
-}
-
-export function runtimePackageForPlatform(platform, arch) {
-  return RUNTIME_TARGETS.find((target) => target.platform === platform && target.arch === arch)?.package ?? null;
-}
-
-export function runtimeBinaryNames() {
-  return [...RUNTIME_BINARY_NAMES];
-}
-
-export function runtimeBinaryFileName(name, platform) {
-  if (!RUNTIME_BINARY_NAMES.includes(name)) throw new Error(`unsupported runtime CLI: ${name}`);
-  return platform === "win32" ? `${name}.exe` : name;
-}