@guanlin4924/devflow-pi 0.1.97 → 0.1.99

package/plugins/devflow-quality/runtime/playwright/runner.spec.mjs

@@ -227,6 +227,7 @@ var API_ACTIONS = new Set(["request"]);
 var BUILTIN_VARIABLES = new Set(["execution_id", "namespace"]);
 var VAR_REF = /\$\{([^}]*)\}/g;
 var VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var SECRET_HEADERS = new Set(["authorization", "proxy-authorization", "cookie", "x-api-key", "x-auth-token"]);
 var FRAGILE_CSS = [
   /el-table_\d+(?:_column_\d+)?/,
   /:nth-(?:last-)?(?:child|of-type)\(/,
@@ -245,6 +246,15 @@ function collectRefs(value, out = new Set) {
   }
   return out;
 }
+function unterminatedRefs(value, at, issues) {
+  if (typeof value === "string") {
+    if (value.replace(VAR_REF, "").includes("${"))
+      issues.push({ path: at, message: "unterminated variable reference" });
+  } else if (value && typeof value === "object") {
+    for (const [key, child] of Object.entries(value))
+      unterminatedRefs(child, `${at}/${key}`, issues);
+  }
+}
 function validateDsl(dsl, schema) {
   const issues = new SchemaValidator(schema).validate(dsl);
   if (issues.length)
@@ -261,6 +271,7 @@ function semanticIssues(dsl) {
   const ids = new Set;
   const screenshotNames = new Set;
   const defined = new Set([...BUILTIN_VARIABLES, ...Object.keys(dsl.variables)]);
+  const sensitive = new Set(Object.entries(dsl.variables).filter(([, variable]) => variable.secret !== undefined || variable.sensitive === true).map(([name]) => name));
   for (const name of Object.keys(dsl.variables)) {
     if (BUILTIN_VARIABLES.has(name))
       issues.push({ path: `/variables/${name}`, message: "shadows a built-in variable" });
@@ -270,6 +281,7 @@ function semanticIssues(dsl) {
     if (refs.size)
       issues.push({ path: `/variables/${name}`, message: "variable values must be literals" });
   }
+  unterminatedRefs(dsl.data.namespace, "/data/namespace", issues);
   for (const ref of collectRefs(dsl.data.namespace)) {
     if (ref !== "execution_id")
       issues.push({ path: "/data/namespace", message: `namespace may only reference \${execution_id}, got \${${ref}}` });
@@ -283,6 +295,8 @@ function semanticIssues(dsl) {
       const allowed = step.driver === "api" ? API_ACTIONS : UI_ACTIONS;
       if (!allowed.has(step.action))
         issues.push({ path: `${at}/action`, message: `unknown action ${step.action}` });
+      const payload = Object.fromEntries(Object.entries(step).filter(([key]) => !["id", "driver", "action", "covers", "extract", "assertions", "retry"].includes(key)));
+      unterminatedRefs(payload, at, issues);
       for (const ref of collectRefs(step)) {
         if (!VAR_NAME.test(ref))
           issues.push({ path: at, message: `malformed variable reference \${${ref}}` });
@@ -298,6 +312,7 @@ function semanticIssues(dsl) {
       if (step.driver === "api") {
         const assertions = step.assertions ?? [];
         assertions.forEach((a, i) => {
+          unterminatedRefs(a.value, `${at}/assertions/${i}/value`, issues);
           const needsValue = a.op !== "exists" && a.op !== "not_exists";
           if (needsValue && !("value" in a))
             issues.push({ path: `${at}/assertions/${i}`, message: `op ${a.op} requires value` });
@@ -308,11 +323,21 @@ function semanticIssues(dsl) {
         if (step.retry && (method === "POST" || method === "PATCH") && step.idempotent !== true) {
           issues.push({ path: `${at}/retry`, message: `${method} retry requires idempotent=true` });
         }
-        for (const name of Object.keys(step.extract ?? {})) {
-          if (BUILTIN_VARIABLES.has(name) || name in dsl.variables) {
-            issues.push({ path: `${at}/extract/${name}`, message: "extract may not overwrite a declared or built-in variable" });
+        for (const [header, value] of Object.entries(step.headers ?? {})) {
+          if (!SECRET_HEADERS.has(header.toLowerCase()))
+            continue;
+          const refs = collectRefs(value);
+          if (!refs.size || [...refs].some((name) => !sensitive.has(name))) {
+            issues.push({ path: `${at}/headers/${header}`, message: "must be built only from secret or sensitive variables" });
+          }
+        }
+        for (const [name, spec] of Object.entries(step.extract ?? {})) {
+          if (defined.has(name)) {
+            issues.push({ path: `${at}/extract/${name}`, message: "extract may not overwrite an existing variable" });
           }
           defined.add(name);
+          if (spec.sensitive === true || spec.header !== undefined && spec.sensitive !== false)
+            sensitive.add(name);
         }
       } else if (step.target && typeof step.target === "object") {
         semanticTargetIssues(step.target, `${at}/target`, issues, step.action);
@@ -769,6 +794,17 @@ async function executeApi(step, ctx) {
   return details;
 }
 
+// plugins/devflow-quality/runtime/playwright/src/text-match.ts
+function normalizeText(value, normalizeWhitespace, caseSensitive) {
+  let out = normalizeWhitespace ? value.replace(/\s+/g, " ").trim() : value;
+  if (!caseSensitive)
+    out = out.toLowerCase();
+  return out;
+}
+function textMatches(actual, expected, match) {
+  return match === "exact" ? actual === expected : actual.includes(expected);
+}
+
 // plugins/devflow-quality/runtime/playwright/src/ui.ts
 import path from "node:path";
 import fs from "node:fs";
@@ -995,15 +1031,6 @@ function resolveNavigationUrl(raw, ctx) {
     throw new StepFailure("blocked", "invalid_url", `goto url must be absolute or start with '/': ${ctx.redactor.text(url)}`);
   }
 }
-function normalizeText(value, normalizeWhitespace, caseSensitive) {
-  let out = normalizeWhitespace ? value.replace(/\s+/g, " ").trim() : value;
-  if (!caseSensitive)
-    out = out.toLowerCase();
-  return out;
-}
-function textMatches(actual, expected, match) {
-  return match === "exact" ? actual === expected : actual.includes(expected);
-}
 async function executeUi(step, ctx) {
   const page = ctx.page;
   const defaultTimeout = step.action === "goto" ? DEFAULT_NAVIGATION_TIMEOUT_MS : DEFAULT_UI_TIMEOUT_MS;
@@ -1477,8 +1504,8 @@ async function executeRun(page, runtimeDir) {
   } catch {
     return outcome({ status: "invalid", error_code: "dsl_not_json", dsl_sha256: dslSha, started_at: startedAt }, redactor);
   }
-  const allSteps = [...dsl?.data?.setup ?? [], ...dsl?.steps ?? [], ...dsl?.data?.cleanup ?? []];
-  const unknown = Array.isArray(allSteps) && allSteps.some((s) => {
+  const allSteps = [dsl?.data?.setup, dsl?.steps, dsl?.data?.cleanup].flatMap((steps) => Array.isArray(steps) ? steps : []);
+  const unknown = allSteps.some((s) => {
     const set = s?.driver === "api" ? API_ACTIONS : s?.driver === "ui" ? UI_ACTIONS : null;
     return !set || !set.has(s?.action);
   });

package/plugins/devflow-quality/runtime/playwright/runtime-manifest.json

@@ -3,10 +3,10 @@
   "runtime_version": "0.1.0",
   "playwright_version": "1.63.0",
   "files": {
-    "runner.spec.mjs": "abf0c5c9aff43b4f233de4c44db0946001c970758ef63ab861fad1d125c1a6fc",
+    "runner.spec.mjs": "25910031e9d9b413843a19c2ac5496b2109546e40283bb68dd9aa2ac9b97b743",
     "playwright.config.mjs": "301c0b97e229f83e6934994718b11b93a1da5d46ec606cfd11a8292e9d622b02",
     "reporter.mjs": "5c91d68c50a93603f583cf82345d427bcd9ce9a7cfb78fd6d0989abddbd55275",
-    "explore-host.mjs": "0973ff6be3b4a3cdd332b90cc6c09ebe96b4ea98bc1e1273be6c09b9bf79efd9",
+    "explore-host.mjs": "686474bcbe9af1151849e4e25266d60e01e8a49162511c49e071c5ec60a65979",
     "devflow-test-dsl-v1.schema.json": "df07e55507697a70df214ae820403b530b04aeb04a12d0aa85715bf5e528e194"
   }
 }

package/plugins/devflow-quality/skills/workflow-generate-mainflow-cases/SKILL.md

@@ -10,6 +10,8 @@ description: "Use after code review, as the binding-phase prerequisite of run-ac
 ## Hard Rules
 
 - `devflow_explore` 只能辅助回归设计或本步骤的 DSL 绑定；它产生的视图、断言和 draft 都不是验收证据。只能消费经人工检查的草稿，仍须运行本技能的编译、目录校验、独立审查和 `execution_plan` 审批流程。
+- 草稿到执行只有一条路径：①人工检查草稿并处理 `review_items`；②回归流程先由 `regression-test-design` 冻结 TC（生成 `tests.json`，将草稿 `tc_id` 替换为冻结编号）；③本 `regression-dsl` 步骤运行 `compile_dsl.py <草稿或 case-descriptions 路径>`（没有 `--draft` 参数），通过校验后提交 `execution_plan` 批准；④由 `run-acceptance-tests` 执行。草稿不能直接执行，也不能用内置浏览器重放代替验收执行。冻结 TC 若提示需要激活合同，应通过 `/devflow control` →“启动当前可执行步骤”进入。
+- DSL 的 `screenshot` 步骤可以留存截图，截图只供用户在本地查看。
 - 探索草稿中的 secret 变量只能保持 `${KEY}` 引用，禁止读取、回填或输出凭据值；页面中的个人信息也不能被当作通用 oracle。
 
 - MUST NOT hardcode `platform-backend` or `platform-frontend`.

package/plugins/devflow-quality/skills/workflow-regression-test-design/SKILL.md

@@ -15,6 +15,8 @@ description: "Use from an idle project to derive a user-confirmed, frozen regres
 
 需要补充当前页面行为时，可在已批准的测试环境中调用 `devflow_explore`（start/observe/act/assert/draft）。探索只用于发现和录制草稿，不是验收证据；密码、密钥和凭据值不得写入描述、日志或草稿。草稿必须由后续 `workflow-generate-mainflow-cases` 编译、校验并经用户批准后才能执行。
 
+草稿到执行的唯一合法路径是：①人工检查草稿并处理 `review_items`；②在回归流程的 `regression-test-design` 中冻结 TC（生成 `tests.json`，并将草稿中的 `tc_id` 替换为冻结后的编号）；③在 `regression-dsl` 步骤使用 `compile_dsl.py <草稿或 case-descriptions 路径>` 编译（没有 `--draft` 参数），通过校验后提交 `execution_plan` 批准；④由 `run-acceptance-tests` 执行。草稿不能直接执行，也不能用内置浏览器重放代替验收执行。冻结 TC 若提示需要激活合同，应通过 `/devflow control` →“启动当前可执行步骤”进入。
+
 1. 读取 `devflow_requirement_graph(action="inspect")` 和 `.devflow/planning/code-index/`，确认当前功能、代码索引 revision、入口、接口、数据流和调用关系。
 2. 阅读实际前端与后端源码、路由/控制器、服务、权限规则、数据访问和已有测试；代码只能用于发现真实功能点与可执行入口，不能把实现细节直接当作预期。
 3. 阅读 `.devflow/planning/test-environments/*.json` 中的环境声明；需要登录或测试 token 时，只记录 `secret_env` 的变量名和所需前置，不读取或输出值。
@@ -67,3 +69,4 @@ description: "Use from an idle project to derive a user-confirmed, frozen regres
 - 不读取或使用 agent 交付自述、`SUMMARY.md` 或 git diff 来决定测试范围。
 - 不写入 `acceptance-results.json`，不生成人工通过结果，不确认执行计划或环境批准。
 - 不向模型上下文、文档或日志输出测试凭据值。
+- DSL 的 `screenshot` 步骤可以留存截图，截图只供用户在本地查看。

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.97";
+export const PRODUCT_VERSION = "0.1.99";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";
 

package/src/mcp/core.ts

@@ -45,33 +45,32 @@ export const runPython: CoreRunner = async (script, args, cwd, stdin, timeoutMs
   const timeoutPromise = new Promise<"timeout">(resolve => {
     timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
   });
-  const exitPromise = child.exited.then(exitCode => ({ exitCode }));
-  const winner = await Promise.race([exitPromise, timeoutPromise]);
-  if (winner === "timeout") {
-    timedOut = true;
-    terminateProcessGroup(child.pid, "SIGTERM");
-    try { child.kill("SIGTERM"); } catch { /* already exited */ }
-    await new Promise(resolve => setTimeout(resolve, TERMINATION_GRACE_MS));
-    terminateProcessGroup(child.pid, "SIGKILL");
-    try { child.kill("SIGKILL"); } catch { /* already exited */ }
+  // The parent can exit while descendants still hold its output pipes open.
+  // Keep the deadline active until both exit and output collection complete.
+  const completion = Promise.all([child.exited, stdoutPromise, stderrPromise])
+    .then(([exitCode, stdout, stderr]) => ({ exitCode, stdout, stderr }));
+  try {
+    const winner = await Promise.race([completion, timeoutPromise]);
+    if (winner === "timeout") {
+      timedOut = true;
+      terminateProcessGroup(child.pid, "SIGTERM");
+      try { child.kill("SIGTERM"); } catch { /* already exited */ }
+      await new Promise(resolve => setTimeout(resolve, TERMINATION_GRACE_MS));
+      terminateProcessGroup(child.pid, "SIGKILL");
+      try { child.kill("SIGKILL"); } catch { /* already exited */ }
+      return {
+        exitCode: null,
+        stdout: await settleText(stdoutPromise, 100),
+        stderr: await settleText(stderrPromise, 100),
+        timedOut,
+      };
+    }
+
+    return { ...winner, timedOut };
+  } finally {
     if (progressTimer !== undefined) clearInterval(progressTimer);
     clearTimeout(timeoutHandle);
-    return {
-      exitCode: null,
-      stdout: await settleText(stdoutPromise, 100),
-      stderr: await settleText(stderrPromise, 100),
-      timedOut,
-    };
   }
-
-  if (progressTimer !== undefined) clearInterval(progressTimer);
-  clearTimeout(timeoutHandle);
-  return {
-    exitCode: winner.exitCode,
-    stdout: await stdoutPromise,
-    stderr: await stderrPromise,
-    timedOut,
-  };
 };
 
 export async function invokeCore(

package/src/mcp/server.ts

@@ -114,20 +114,19 @@ export async function createMcpServer(options: McpServerOptions) {
       if (tool === "run_feature" && running) throw new McpError("mcp_busy", "another run_feature is in progress");
 
       if (tool === "run_feature") {
-        const bindingFile = path.join(auth.project, ".devflow/planning/features", String(feature), "acceptance-test-bindings.json");
-        let bindings: unknown;
-        try {
-          bindings = JSON.parse(await readFile(bindingFile, "utf8"));
-        } catch {
-          throw new McpError("mcp_input_invalid", "acceptance-test-bindings.json is missing or invalid");
-        }
-        const profiles = collectEnvironmentProfiles(bindings);
-        if ([...profiles].some(profile => !auth.grant.environment_profiles.includes(profile))) {
-          throw new McpError("mcp_environment_not_allowed", "environment profile is not authorized");
-        }
-
         running = true;
         try {
+          const bindingFile = path.join(auth.project, ".devflow/planning/features", String(feature), "acceptance-test-bindings.json");
+          let bindings: unknown;
+          try {
+            bindings = JSON.parse(await readFile(bindingFile, "utf8"));
+          } catch {
+            throw new McpError("mcp_input_invalid", "acceptance-test-bindings.json is missing or invalid");
+          }
+          const profiles = collectEnvironmentProfiles(bindings);
+          if ([...profiles].some(profile => !auth.grant.environment_profiles.includes(profile))) {
+            throw new McpError("mcp_environment_not_allowed", "environment profile is not authorized");
+          }
           const runResult = await invokeCore(
             runner,
             "run",

package/src/project-context.ts

@@ -138,6 +138,10 @@ export async function assertPlanningBoundary(root: string): Promise<string> {
 }
 
 export async function loadProjectContext(root: string): Promise<ProjectContext> {
+  return readProjectContext(root, false);
+}
+
+async function readProjectContext(root: string, registerWorkspace: boolean): Promise<ProjectContext> {
   const canonicalRoot = await canonicalDirectory(root);
   const manifestPath = projectLayout(canonicalRoot).manifestPath;
   const manifestValue = JSON.parse(await readFile(manifestPath, "utf8")) as Record<string, unknown>;
@@ -150,6 +154,10 @@ export async function loadProjectContext(root: string): Promise<ProjectContext>
   const manifest = validateManifest(manifestValue, manifestPath);
   await mkdir(projectLayout(canonicalRoot).planningRoot, { recursive: true });
   const planningRoot = await assertPlanningBoundary(canonicalRoot);
+  if (registerWorkspace) {
+    const store = await InitializationStore.open({ root: canonicalRoot, manifest });
+    try { await store.registerWorkspace(); } finally { store.close(); }
+  }
   if (!(await exists(projectControlDatabasePath(manifest.projectId)))) throw new Error("Project initialization database is not registered; run explicit project initialization first");
   return attachInitializationStore({ root: canonicalRoot, manifestPath, manifest, planningRoot });
 }
@@ -198,7 +206,7 @@ export async function initializeProject(root: string): Promise<{ context: Projec
   await mkdir(devflowDir, { recursive: true });
   await assertPlanningBoundary(canonicalRoot);
   if (await exists(manifestPath)) {
-    const context = await loadProjectContext(canonicalRoot);
+    const context = await readProjectContext(canonicalRoot, true);
     await ensureTestRuntimeLayout(canonicalRoot, context.planningRoot);
     return { context, created: false };
   }

package/src/project-initializer.ts

@@ -42,7 +42,7 @@ function source(file: SourceFile, kind: FactKind, objectKey: string, value: Reco
   return { kind, objectKey, repository: file.repository, value, evidenceLevel: "observed", sourcePath: file.path, sourceLine: line, sourceFingerprint: file.contentHash, extractor, confidence: "heuristic" };
 }
 
-async function walk(repository: string, repositoryRoot: string, includes: string[], excludes: string[], diagnostics: ScanDiagnostic[], relative = ""): Promise<SourceFile[]> {
+async function walk(repository: string, repositoryRoot: string, includes: string[], excludes: string[], diagnostics: ScanDiagnostic[], maxFileSize: number, relative = ""): Promise<SourceFile[]> {
   const directory = path.join(repositoryRoot, relative);
   let entries;
   try { entries = await readdir(directory, { withFileTypes: true }); }
@@ -54,11 +54,11 @@ async function walk(repository: string, repositoryRoot: string, includes: string
     const child = path.join(relative, entry.name);
     const normalized = child.replaceAll("\\", "/");
     if (excludes.some(pattern => globMatches(normalized, pattern) || globMatches(`${normalized}/`, pattern))) { if (diagnostics.length < 1000) diagnostics.push({ repository, path: normalized, reason: "excluded" }); continue; }
-    if (entry.isDirectory()) { result.push(...await walk(repository, repositoryRoot, includes, excludes, diagnostics, child)); continue; }
+    if (entry.isDirectory()) { result.push(...await walk(repository, repositoryRoot, includes, excludes, diagnostics, maxFileSize, child)); continue; }
     if (!entry.isFile()) continue;
     if (includes.length && !includes.some(pattern => globMatches(normalized, pattern))) continue;
     const absolute = path.join(repositoryRoot, child); const info = await stat(absolute);
-    if (info.size > 2 * 1024 * 1024) { diagnostics.push({ repository, path: normalized, reason: "too_large" }); continue; }
+    if (info.size > maxFileSize) { diagnostics.push({ repository, path: normalized, reason: "too_large" }); continue; }
     let bytes: Buffer;
     try { bytes = await readFile(absolute); }
     catch (error) { diagnostics.push({ repository, path: normalized, reason: "unreadable", message: error instanceof Error ? error.message : String(error) }); continue; }
@@ -84,7 +84,7 @@ async function scan(context: ProjectContext, config: ScanConfigInput): Promise<{
     const root = path.resolve(context.root, repository.relativePath);
     if (!path.isAbsolute(repository.relativePath) && root !== context.root && !root.startsWith(`${context.root}${path.sep}`)) throw new Error(`Repository escapes project root: ${repository.relativePath}`);
     repositoryVersions.push({ repository: repository.name, revision: await gitRevision(root) });
-    all.push(...await walk(repository.name, root, includes, excludes, diagnostics));
+    all.push(...await walk(repository.name, root, includes, excludes, diagnostics, config.maxFileSize ?? 2 * 1024 * 1024));
   }
   return { files: all.sort((a, b) => `${a.repository}/${a.path}`.localeCompare(`${b.repository}/${b.path}`)), diagnostics, repositoryVersions };
 }

package/src/session-rollover.ts

@@ -0,0 +1,10 @@
+/** The current prepared revision differs from the immutable handoff's source revision after recovery. */
+export function preparedRolloverRevision(state: Record<string, unknown>): number | undefined {
+  const rollover = state.rollover as Record<string, unknown> | undefined;
+  if (rollover?.status !== "prepared") return undefined;
+  const revision = rollover.prepared_state_revision ?? (
+    typeof rollover.expected_state_revision === "number" ? rollover.expected_state_revision + 1 : undefined
+  );
+  return typeof revision === "number" && Number.isSafeInteger(revision) && revision === state.revision
+    ? revision : undefined;
+}