@tomflow/proflow-platform-cli 0.1.42 → 0.1.44

package/dist/deployment/adapter.d.ts

@@ -6,7 +6,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-cli";
-            readonly moduleVersion: "0.1.42";
+            readonly moduleVersion: "0.1.44";
         };
         observedEffects: never[];
     }>;
@@ -16,7 +16,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-cli";
-            readonly moduleVersion: "0.1.42";
+            readonly moduleVersion: "0.1.44";
         };
         observedEffects: never[];
     }>;
@@ -26,7 +26,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-cli";
-            moduleVersion: "0.1.42";
+            moduleVersion: "0.1.44";
             data: {
                 readonly setupStatus: "READY";
                 readonly runtimeStatus: "NOT_APPLICABLE";
@@ -40,7 +40,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-cli";
-            readonly moduleVersion: "0.1.42";
+            readonly moduleVersion: "0.1.44";
         };
         observedEffects: never[];
     }>;
@@ -50,7 +50,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-cli";
-            moduleVersion: "0.1.42";
+            moduleVersion: "0.1.44";
             data: {
                 docs: string;
             };
@@ -63,7 +63,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-cli";
-            readonly moduleVersion: "0.1.42";
+            readonly moduleVersion: "0.1.44";
         };
         observedEffects: never[];
     }>;
@@ -73,7 +73,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-cli";
-            readonly moduleVersion: "0.1.42";
+            readonly moduleVersion: "0.1.44";
         };
         observedEffects: never[];
     }>;

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "platform-cli";
     readonly packageName: "@tomflow/proflow-platform-cli";
-    readonly moduleVersion: "0.1.42";
+    readonly moduleVersion: "0.1.44";
     readonly kind: "cli";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "platform-cli",
     packageName: "@tomflow/proflow-platform-cli",
-    moduleVersion: "0.1.42",
+    moduleVersion: "0.1.44",
     kind: "cli",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

package/dist/src/cli.js

@@ -11,6 +11,7 @@ import { observeWorkspaceInstalledVersion, preflightWorkspacePackageManager, rem
 import { cleanOwnedPnpmPolicy, observeMinimumReleaseAgeExclude, recordPnpmPolicyOwnership, } from "./install/pnpm-policy.js";
 import { installModulesThin, observeDocs, observeStatuses, setupModulesThin, startModulesThin, stopModulesThin, uninstallModulesThin, } from "./lifecycle/index.js";
 import { ensureWorkspaceStateIsGitIgnored } from "./persistence/git-isolation.js";
+import { clearStartOwner, registerStartOwner, requestStartOwnerStop, } from "./persistence/start-owner.js";
 import { ensureWorkspaceMetadata } from "./persistence/workspace-metadata.js";
 import { reportProgress } from "./progress.js";
 import { discoverRegistryModules, PRO_FLOW_PACKAGE_PREFIX, } from "./registry/index.js";
@@ -1148,15 +1149,71 @@ export function renderHumanResult(result, options = {}) {
         return `${theme.success("✓ 已经卸载")}${result.workspaceRoot ? `\n${theme.muted("Workspace")}  ${result.workspaceRoot}` : ""}`;
     return `${result.status === "SUCCEEDED" ? theme.success("✓") : theme.failure("✕")} ${labels[result.command] ?? result.command}${result.status === "SUCCEEDED" ? "成功" : "未完成"}${result.workspaceRoot ? `\n${theme.muted("Workspace")}  ${result.workspaceRoot}` : ""}`;
 }
+function ownsStartedRuntime(result) {
+    if (result.command !== "start" || !isRecord(result.data))
+        return false;
+    const results = Array.isArray(result.data.results)
+        ? result.data.results.filter(isRecord)
+        : [];
+    return results.some((item) => item.command === "start" &&
+        Array.isArray(item.observedEffects) &&
+        item.observedEffects.length > 0 &&
+        isRecord(item.result) &&
+        item.result.status === "SUCCEEDED");
+}
 if (import.meta.main) {
     const argv = process.argv.slice(2);
     const reporter = createTerminalProgressReporter();
+    let parsedForOwner;
+    let ownerRoot;
+    try {
+        parsedForOwner = parseArgs(argv);
+        if (parsedForOwner.command === "start" || parsedForOwner.command === "stop")
+            ownerRoot = await canonicalWorkspace(process.cwd(), parsedForOwner.workspace);
+    }
+    catch {
+        // runCli owns normal usage/workspace error rendering.
+    }
+    if (parsedForOwner?.command === "stop" && ownerRoot) {
+        reportProgress(reporter, {
+            command: "stop",
+            phase: "owner",
+            status: "STARTED",
+            message: "正在请求当前平台运行进程停止",
+        });
+        const requested = await requestStartOwnerStop(ownerRoot);
+        reportProgress(reporter, {
+            command: "stop",
+            phase: "owner",
+            status: requested === "TIMEOUT" ? "WARNING" : "SUCCEEDED",
+            message: requested === "STOPPED"
+                ? "平台运行进程已停止"
+                : "未发现需要接管的前台运行进程",
+        });
+    }
     const result = await runCli(argv, {
         onProgress: reporter,
         ...(process.stdin.isTTY && process.stdout.isTTY
             ? { setupInteraction: createClackSetupInteraction() }
             : {}),
     });
+    if (parsedForOwner?.command === "start" &&
+        ownerRoot &&
+        result.status === "SUCCEEDED" &&
+        ownsStartedRuntime(result)) {
+        await registerStartOwner(ownerRoot);
+        let stopping = false;
+        const gracefulStop = async () => {
+            if (stopping)
+                return;
+            stopping = true;
+            const stopped = await runCli(["stop", "--workspace", ownerRoot]);
+            await clearStartOwner(ownerRoot);
+            process.exit(stopped.status === "SUCCEEDED" ? 0 : 1);
+        };
+        process.once("SIGTERM", () => void gracefulStop());
+        process.once("SIGINT", () => void gracefulStop());
+    }
     reporter.close();
     const color = process.stdout.isTTY === true &&
         process.env.NO_COLOR === undefined &&

package/dist/src/lifecycle/thin.js

@@ -222,27 +222,85 @@ export async function setupModulesThin(catalog, modules, workspaceRoot, target,
         .map((moduleRef) => byRef.get(moduleRef))
         .filter((module) => module !== undefined);
     let completed = true;
-    for (const [index, module] of modulesInOrder.entries()) {
-        reportProgress(reporter, {
-            command: "setup",
-            phase: "setup",
-            kind: "detail",
-            retention: "REPLACE",
-            current: index + 1,
-            total: modulesInOrder.length,
-            moduleRef: module.moduleRef,
-            status: "STARTED",
-            message: module.moduleRef,
-        });
-        const status = await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot));
-        if (!succeeded(status.result)) {
-            results.push(status);
-            completed = false;
-            break;
+    const temporaryRuntimeRefs = [];
+    const temporaryRuntimeSet = new Set();
+    const dependencyClosure = (moduleRef) => {
+        const closure = new Set();
+        const visit = (ref) => {
+            for (const dependency of dependenciesByRef.get(ref) ?? []) {
+                if (closure.has(dependency))
+                    continue;
+                closure.add(dependency);
+                visit(dependency);
+            }
+        };
+        visit(moduleRef);
+        return closure;
+    };
+    const ensureSetupRuntimeDependencies = async (module) => {
+        if (module.kind !== "agent-package")
+            return true;
+        const closure = dependencyClosure(module.moduleRef);
+        for (const dependencyRef of graph.order) {
+            if (!closure.has(dependencyRef))
+                continue;
+            const dependency = byRef.get(dependencyRef);
+            if (dependency?.kind !== "service")
+                continue;
+            const status = await dispatchModuleCommand(catalog, dependency, "status", context(workspaceRoot));
+            if (!succeeded(status.result)) {
+                blockers.push({
+                    moduleRef: dependencyRef,
+                    setupStatus: "FAILED",
+                    reason: status.result.error?.message ?? "临时运行依赖状态检查失败",
+                });
+                completed = false;
+                return false;
+            }
+            const observed = moduleStatusObservationSchema.parse(status.result.data);
+            if (observed.setupStatus !== "READY") {
+                const issue = observed.issues?.find((item) => item.scope === "SETUP");
+                blockers.push({
+                    moduleRef: dependencyRef,
+                    setupStatus: observed.setupStatus,
+                    ...(issue
+                        ? { reason: issue.message, nextCommand: issue.nextCommand }
+                        : {}),
+                });
+                completed = false;
+                return false;
+            }
+            if (observed.runtimeStatus === "RUNNING" ||
+                observed.runtimeStatus === "NOT_APPLICABLE")
+                continue;
+            if (observed.runtimeStatus !== "STOPPED") {
+                blockers.push({
+                    moduleRef: dependencyRef,
+                    setupStatus: "FAILED",
+                    reason: `临时运行依赖 ${dependencyRef} 处于 ${observed.runtimeStatus}`,
+                });
+                completed = false;
+                return false;
+            }
+            const started = await dispatchModuleCommand(catalog, dependency, "start", context(workspaceRoot));
+            if (!succeeded(started.result)) {
+                blockers.push({
+                    moduleRef: dependencyRef,
+                    setupStatus: "FAILED",
+                    reason: started.result.error?.message ?? `临时启动 ${dependencyRef} 失败`,
+                });
+                completed = false;
+                return false;
+            }
+            if (!temporaryRuntimeSet.has(dependencyRef)) {
+                temporaryRuntimeSet.add(dependencyRef);
+                temporaryRuntimeRefs.push(dependencyRef);
+            }
         }
-        const observed = moduleStatusObservationSchema.parse(status.result.data);
-        if (observed.setupStatus === "READY" && target === undefined) {
-            skipped.push({ moduleRef: module.moduleRef, reason: "READY" });
+        return true;
+    };
+    try {
+        for (const [index, module] of modulesInOrder.entries()) {
             reportProgress(reporter, {
                 command: "setup",
                 phase: "setup",
@@ -251,53 +309,93 @@ export async function setupModulesThin(catalog, modules, workspaceRoot, target,
                 current: index + 1,
                 total: modulesInOrder.length,
                 moduleRef: module.moduleRef,
-                status: "SKIPPED",
+                status: "STARTED",
                 message: module.moduleRef,
             });
-            continue;
-        }
-        await beforeSetup?.(module.moduleRef);
-        const setup = await dispatchModuleCommand(catalog, module, "setup", context(workspaceRoot, target?.input));
-        results.push(setup);
-        reportProgress(reporter, {
-            command: "setup",
-            phase: "setup",
-            kind: "detail",
-            retention: "REPLACE",
-            current: index + 1,
-            total: modulesInOrder.length,
-            moduleRef: module.moduleRef,
-            status: succeeded(setup.result)
-                ? "SUCCEEDED"
-                : setup.result.status === "ACTION_REQUIRED"
-                    ? "ACTION_REQUIRED"
-                    : "FAILED",
-            message: module.moduleRef,
-        });
-        if (!succeeded(setup.result)) {
-            completed = false;
-        }
-        const reconciled = await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot));
-        if (!succeeded(reconciled.result)) {
-            results.push(reconciled);
-            completed = false;
-        }
-        else {
-            const reconciledStatus = moduleStatusObservationSchema.parse(reconciled.result.data);
-            if (reconciledStatus.setupStatus !== "READY") {
-                const issue = reconciledStatus.issues?.find((item) => item.scope === "SETUP");
-                blockers.push({
+            const status = await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot));
+            if (!succeeded(status.result)) {
+                results.push(status);
+                completed = false;
+                break;
+            }
+            const observed = moduleStatusObservationSchema.parse(status.result.data);
+            if (observed.setupStatus === "READY" && target === undefined) {
+                skipped.push({ moduleRef: module.moduleRef, reason: "READY" });
+                reportProgress(reporter, {
+                    command: "setup",
+                    phase: "setup",
+                    kind: "detail",
+                    retention: "REPLACE",
+                    current: index + 1,
+                    total: modulesInOrder.length,
                     moduleRef: module.moduleRef,
-                    setupStatus: reconciledStatus.setupStatus,
-                    ...(issue === undefined
-                        ? {}
-                        : { reason: issue.message, nextCommand: issue.nextCommand }),
+                    status: "SKIPPED",
+                    message: module.moduleRef,
                 });
+                continue;
+            }
+            if (!(await ensureSetupRuntimeDependencies(module)))
+                break;
+            await beforeSetup?.(module.moduleRef);
+            const setup = await dispatchModuleCommand(catalog, module, "setup", context(workspaceRoot, target?.input));
+            results.push(setup);
+            reportProgress(reporter, {
+                command: "setup",
+                phase: "setup",
+                kind: "detail",
+                retention: "REPLACE",
+                current: index + 1,
+                total: modulesInOrder.length,
+                moduleRef: module.moduleRef,
+                status: succeeded(setup.result)
+                    ? "SUCCEEDED"
+                    : setup.result.status === "ACTION_REQUIRED"
+                        ? "ACTION_REQUIRED"
+                        : "FAILED",
+                message: module.moduleRef,
+            });
+            if (!succeeded(setup.result)) {
                 completed = false;
             }
+            const reconciled = await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot));
+            if (!succeeded(reconciled.result)) {
+                results.push(reconciled);
+                completed = false;
+            }
+            else {
+                const reconciledStatus = moduleStatusObservationSchema.parse(reconciled.result.data);
+                if (reconciledStatus.setupStatus !== "READY") {
+                    const issue = reconciledStatus.issues?.find((item) => item.scope === "SETUP");
+                    blockers.push({
+                        moduleRef: module.moduleRef,
+                        setupStatus: reconciledStatus.setupStatus,
+                        ...(issue === undefined
+                            ? {}
+                            : { reason: issue.message, nextCommand: issue.nextCommand }),
+                    });
+                    completed = false;
+                }
+            }
+            if (!succeeded(setup.result) || blockers.length > 0)
+                break;
+        }
+    }
+    finally {
+        for (const dependencyRef of [...temporaryRuntimeRefs].reverse()) {
+            const dependency = byRef.get(dependencyRef);
+            if (!dependency)
+                continue;
+            const stopped = await dispatchModuleCommand(catalog, dependency, "stop", context(workspaceRoot));
+            if (!succeeded(stopped.result)) {
+                completed = false;
+                blockers.push({
+                    moduleRef: dependencyRef,
+                    setupStatus: "FAILED",
+                    reason: stopped.result.error?.message ??
+                        `临时运行依赖 ${dependencyRef} 清理失败`,
+                });
+            }
         }
-        if (!succeeded(setup.result) || blockers.length > 0)
-            break;
     }
     return {
         phase: "setup",

package/dist/src/persistence/start-owner.d.ts

@@ -0,0 +1,3 @@
+export declare function registerStartOwner(root: string): Promise<void>;
+export declare function clearStartOwner(root: string, pid?: number): Promise<void>;
+export declare function requestStartOwnerStop(root: string): Promise<"ABSENT" | "STOPPED" | "UNVERIFIED" | "TIMEOUT">;

package/dist/src/persistence/start-owner.js

@@ -0,0 +1,118 @@
+import { execFile } from "node:child_process";
+import { readFile, realpath, rm } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { atomicWrite } from "../paths.js";
+const CONTRACT = "proflow.platform-start-owner.v1";
+const ownerFile = (root) => join(root, ".proflow", "runtime", "platform-cli", "start-owner.json");
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function commandLine(pid) {
+    return new Promise((resolveCommand) => {
+        execFile("ps", ["-p", String(pid), "-o", "command="], { timeout: 2_000, encoding: "utf8" }, (error, stdout) => resolveCommand(error ? undefined : String(stdout).trim()));
+    });
+}
+function parseRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const item = value;
+    if (item.contract !== CONTRACT ||
+        typeof item.pid !== "number" ||
+        !Number.isInteger(item.pid) ||
+        item.pid <= 0 ||
+        typeof item.workspaceRoot !== "string" ||
+        typeof item.processCwd !== "string" ||
+        typeof item.argv1 !== "string" ||
+        typeof item.entrypointRealpath !== "string" ||
+        typeof item.startedAt !== "string" ||
+        Number.isNaN(Date.parse(item.startedAt)))
+        return undefined;
+    return item;
+}
+async function readOwner(root) {
+    try {
+        return parseRecord(JSON.parse(await readFile(ownerFile(root), "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function ownerMatchesProcess(record) {
+    if (!processAlive(record.pid))
+        return false;
+    let observedEntrypoint;
+    try {
+        observedEntrypoint = await realpath(record.argv1);
+    }
+    catch {
+        return false;
+    }
+    if (observedEntrypoint !== record.entrypointRealpath)
+        return false;
+    const observed = await commandLine(record.pid);
+    if (!observed)
+        return false;
+    const relativeArgv = relative(record.processCwd, record.argv1);
+    const entrypointMatches = [
+        record.argv1,
+        relativeArgv,
+        `./${relativeArgv}`,
+    ].some((candidate) => candidate.length > 0 && observed.includes(candidate));
+    return entrypointMatches && /(?:^|\s)start(?:\s|$)/.test(observed);
+}
+async function waitForExit(pid, timeoutMs = 60_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!processAlive(pid))
+            return true;
+        await new Promise((resolveWait) => setTimeout(resolveWait, 100));
+    }
+    return !processAlive(pid);
+}
+export async function registerStartOwner(root) {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        throw new Error("platform start entrypoint is unavailable");
+    const record = {
+        contract: CONTRACT,
+        pid: process.pid,
+        workspaceRoot: root,
+        processCwd: process.cwd(),
+        argv1,
+        entrypointRealpath: await realpath(argv1),
+        startedAt: new Date().toISOString(),
+    };
+    await atomicWrite(ownerFile(root), `${JSON.stringify(record, null, 2)}\n`);
+}
+export async function clearStartOwner(root, pid = process.pid) {
+    const current = await readOwner(root);
+    if (current?.pid !== pid)
+        return;
+    await rm(ownerFile(root), { force: true });
+}
+export async function requestStartOwnerStop(root) {
+    const record = await readOwner(root);
+    if (!record)
+        return "ABSENT";
+    if (record.workspaceRoot !== root || !(await ownerMatchesProcess(record))) {
+        if (!processAlive(record.pid))
+            await rm(ownerFile(root), { force: true });
+        return "UNVERIFIED";
+    }
+    try {
+        process.kill(record.pid, "SIGTERM");
+    }
+    catch {
+        return "UNVERIFIED";
+    }
+    if (!(await waitForExit(record.pid)))
+        return "TIMEOUT";
+    await rm(ownerFile(root), { force: true });
+    return "STOPPED";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-cli",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -28,8 +28,8 @@
     "@tomflow/proflow-module-contract": "^0.1.13"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.13",
-    "@tomflow/proflow-module-template": "^0.1.10"
+    "@tomflow/proflow-module-template": "^0.1.10",
+    "@tomflow/proflow-deployment-conformance": "^0.1.13"
   },
   "description": "Thin Platform CLI for Module discovery, documentation, package synchronization and lifecycle orchestration.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-cli",
 	"packageName": "@tomflow/proflow-platform-cli",
-	"moduleVersion": "0.1.42",
+	"moduleVersion": "0.1.44",
 	"kind": "cli",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",

package/CHANGELOG.md

@@ -1,85 +0,0 @@
-# @tomflow/proflow-platform-cli
-
-## 0.1.42
-
-### Patch Changes
-
-- Repack the Deployment Closeout release from freshly rebuilt artifacts and enforce build + publishability before every canonical publish.
-
-## 0.1.41
-
-### Patch Changes
-
-- Harden Deployment Closeout: fail closed on partial installs and package-manager conflicts, normalize Git workspace isolation, make Dev Tunnel status fast and resumable without fabricating login failures, and align Browser Extension setup/conformance behavior.
-
-## 0.1.40
-
-### Patch Changes
-
-- Ignore governed non-Module tool packages during Registry module discovery so Fresh install remains fixed at 23 active modules.
-
-## 0.1.39
-
-### Patch Changes
-
-- Add professional setup orchestration, Provider FAST/THINK input, recoverable managed Dev Tunnel provisioning, Browser installation guidance, and precise status diagnostics.
-
-## 0.1.38
-
-### Patch Changes
-
-- Retire the obsolete Carrier package and Browser standalone management CLI, make Platform setup/status preserve owner and dependency semantics, and enforce read-only status observation across the final Real-3 deployment closeout.
-
-## 0.1.37
-
-### Patch Changes
-
-- Ship the Phase 3 browser, tunnel, model automation, platform readiness, and documentation closure as one verifiable platform snapshot.
-
-## 0.1.36
-
-### Patch Changes
-
-- Distinguish dependency blocking from verified failure, expose Module-owned status diagnostics, remove automatic docs paging, consolidate start checks, add contextual help, and clarify uninstall output.
-
-## 0.1.35
-
-### Patch Changes
-
-- Render retryable package-manager warnings as warnings instead of failed subprocess events.
-
-## 0.1.34
-
-### Patch Changes
-
-- Upgrade the ProFlow terminal experience, stream Registry and package-manager progress, publish structured Chinese Module documentation, and provide numbered package-owned Setup assistants.
-
-## 0.1.33
-
-### Patch Changes
-
-- Keep lifecycle summary totals mutually exclusive when a no-effect external runtime is skipped.
-
-## 0.1.32
-
-### Patch Changes
-
-- Report successful lifecycle calls with no owned stop effect as skipped instead of claiming an external runtime was stopped.
-
-## 0.1.31
-
-### Patch Changes
-
-- Make every setup command directly runnable from a workspace and render setup failures without Node stack traces.
-
-## 0.1.30
-
-### Patch Changes
-
-- Use a stable progress marker in non-interactive logs instead of a frozen spinner frame.
-
-## 0.1.29
-
-### Patch Changes
-
-- Improve terminal progress and localized status output, publish readable Chinese module docs, and add guided setup assistants for external resources.