openxiangda-devkit-core 2.0.0-alpha.12

package/dist/application-services.js

@@ -0,0 +1,660 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { SCHEMA_VERSIONS, canonicalJson, } from "openxiangda-contracts";
+import { compileApplicationSources, compileAppPackage, sha256Bytes, validateAppConfig, } from "openxiangda-compiler";
+import { OpenXiangdaControlPlaneClient, } from "./control-plane-client.js";
+import { loadSession } from "./session.js";
+import { OPENXIANGDA_TOOLCHAIN_VERSION } from "./version.js";
+import { git, loadWorkspace, } from "./workspace-loader.js";
+export class OpenXiangdaApplicationServices {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async workspaceContext(root) {
+        const workspace = await this.workspace(root);
+        return this.ok("workspace.context", workspace.context.workspace, workspace.context);
+    }
+    async contractDescribe(root) {
+        const workspace = await this.workspace(root);
+        const sources = compileApplicationSources(workspace.config);
+        return this.ok("contract.describe", workspace.context.workspace, {
+            configDigest: sources.config.digest,
+            contractDigest: sources.contracts.digest,
+            contract: sources.contracts.value,
+            counts: {
+                backendSecrets: sources.config.value.backendSecrets.length,
+                dataResources: sources.config.value.dataResources.length,
+                eventSubscriptions: sources.config.value.eventSubscriptions.length,
+                timerSubscriptions: sources.config.value.timerSubscriptions?.length || 0,
+                workflowDefinitions: sources.config.value.workflowDefinitions.length,
+                workflowBindings: sources.config.value.workflowBindings.length,
+                workflowProviders: sources.config.value.workflowProviders?.length || 0,
+            },
+        });
+    }
+    async platformCapabilities(root) {
+        const workspace = await this.workspace(root);
+        const capabilities = await (await this.client(workspace.root)).capabilities();
+        return this.ok("platform.capabilities", workspace.context.workspace, capabilities);
+    }
+    async provisionApplication(root) {
+        const workspace = await this.workspace(root);
+        const application = await (await this.client(workspace.root)).provisionApplication({
+            appCode: workspace.config.app.code,
+            name: workspace.config.app.name,
+        });
+        return this.ok("app.provision", workspace.context.workspace, application, [
+            { code: "check", label: "检查应用", command: "openxiangda check" },
+        ]);
+    }
+    async oauthClients(root) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).oauthClients(workspace.config.app.code);
+        return this.ok("oauth.client.list", workspace.context.workspace, data);
+    }
+    async runtimeOAuthCredentialStatus(root, environmentKey) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).runtimeOAuthCredentialStatus(workspace.config.app.code, environmentKey);
+        return this.ok("oauth.runtime.status", workspace.context.workspace, data);
+    }
+    async rotateRuntimeOAuthCredential(root, input) {
+        const workspace = await this.workspace(root);
+        const client = await this.client(workspace.root);
+        const status = await client.runtimeOAuthCredentialStatus(workspace.config.app.code, input.environmentKey);
+        if (!status.configured || !status.client) {
+            throw new Error("OAUTH2_RUNTIME_CLIENT_NOT_PROVISIONED");
+        }
+        const rotation = await client.stageRuntimeOAuthCredentialRotation(workspace.config.app.code, input.environmentKey, {
+            expectedCredentialVersion: status.client.credentialVersion,
+            ...(input.gracePeriodSeconds === undefined
+                ? {}
+                : { gracePeriodSeconds: input.gracePeriodSeconds }),
+            idempotencyKey: input.idempotencyKey,
+        });
+        const head = await client.environmentHead(workspace.config.app.code, input.environmentKey);
+        if (!head.activeAppVersionId) {
+            throw new Error("OAUTH2_RUNTIME_ROTATION_ACTIVE_VERSION_REQUIRED");
+        }
+        const deployment = await client.promote({
+            appCode: workspace.config.app.code,
+            appVersionId: head.activeAppVersionId,
+            ...(head.environmentId
+                ? { environmentId: head.environmentId }
+                : { environmentKind: head.environmentKind }),
+            idempotencyKey: `oauth-runtime-rotation:${input.idempotencyKey}`,
+            requestId: input.idempotencyKey,
+        });
+        return this.ok("oauth.runtime.rotate", workspace.context.workspace, {
+            rotation,
+            deployment,
+            next: {
+                command: `openxiangda status ${deployment.id}`,
+                credentialActivatesDuringDeployment: true,
+            },
+        });
+    }
+    async createOAuthClient(root, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).createOAuthClient(workspace.config.app.code, input);
+        return this.ok("oauth.client.create", workspace.context.workspace, data);
+    }
+    async updateOAuthClient(root, clientId, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).updateOAuthClient(workspace.config.app.code, clientId, input);
+        return this.ok("oauth.client.update", workspace.context.workspace, data);
+    }
+    async rotateOAuthClientSecret(root, clientId, gracePeriodSeconds = 600) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).rotateOAuthClientSecret(workspace.config.app.code, clientId, gracePeriodSeconds);
+        return this.ok("oauth.client.rotate", workspace.context.workspace, data);
+    }
+    async revokeOAuthClient(root, clientId) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).revokeOAuthClient(workspace.config.app.code, clientId);
+        return this.ok("oauth.client.revoke", workspace.context.workspace, data);
+    }
+    async oauthAuditEvents(root, input = {}) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).oauthAuditEvents(workspace.config.app.code, input);
+        return this.ok("oauth.audit.list", workspace.context.workspace, data);
+    }
+    async applicationSecrets(root, environmentKey) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).applicationSecrets(workspace.config.app.code, environmentKey);
+        return this.ok("secret.list", workspace.context.workspace, data);
+    }
+    async createApplicationSecret(root, environmentKey, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).createApplicationSecret(workspace.config.app.code, environmentKey, input);
+        return this.ok("secret.create", workspace.context.workspace, data);
+    }
+    async updateApplicationSecret(root, environmentKey, name, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).updateApplicationSecret(workspace.config.app.code, environmentKey, name, input);
+        return this.ok("secret.update", workspace.context.workspace, data);
+    }
+    async rotateApplicationSecret(root, environmentKey, name, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).rotateApplicationSecret(workspace.config.app.code, environmentKey, name, input);
+        return this.ok("secret.rotate", workspace.context.workspace, data);
+    }
+    async deleteApplicationSecret(root, environmentKey, name, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).deleteApplicationSecret(workspace.config.app.code, environmentKey, name, input);
+        return this.ok("secret.delete", workspace.context.workspace, data);
+    }
+    async applicationSecretAuditEvents(root, environmentKey, name, limit = 100) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).applicationSecretAuditEvents(workspace.config.app.code, environmentKey, name, limit);
+        return this.ok("secret.audit.list", workspace.context.workspace, data);
+    }
+    async eventSubscriptions(root) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).eventSubscriptions(workspace.config.app.code);
+        return this.ok("event.subscription.list", workspace.context.workspace, data);
+    }
+    async setEventSubscriptionStatus(root, subscriptionId, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).setEventSubscriptionStatus(workspace.config.app.code, subscriptionId, input);
+        return this.ok("event.subscription.status", workspace.context.workspace, data);
+    }
+    async rotateEventSubscriptionSecret(root, subscriptionId, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).rotateEventSubscriptionSecret(workspace.config.app.code, subscriptionId, input);
+        return this.ok("event.subscription.rotate", workspace.context.workspace, data);
+    }
+    async eventDeliveries(root, limit = 100) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).eventDeliveries(workspace.config.app.code, limit);
+        return this.ok("event.delivery.list", workspace.context.workspace, data);
+    }
+    async replayEventDelivery(root, deliveryId, idempotencyKey) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).replayEventDelivery(workspace.config.app.code, deliveryId, idempotencyKey);
+        return this.ok("event.delivery.replay", workspace.context.workspace, data);
+    }
+    async timerSubscriptions(root) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).timerSubscriptions(workspace.config.app.code);
+        return this.ok("event.timer.list", workspace.context.workspace, data);
+    }
+    async setTimerSubscriptionStatus(root, timerId, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).setTimerSubscriptionStatus(workspace.config.app.code, timerId, input);
+        return this.ok("event.timer.status", workspace.context.workspace, data);
+    }
+    async workflowAssigneeProviders(root, environmentKey) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).workflowAssigneeProviders(workspace.config.app.code, environmentKey);
+        return this.ok("workflow.provider.list", workspace.context.workspace, data);
+    }
+    async rotateWorkflowAssigneeProviderSecret(root, providerCode, input) {
+        const workspace = await this.workspace(root);
+        const data = await (await this.client(workspace.root)).rotateWorkflowAssigneeProviderSecret(workspace.config.app.code, providerCode, input);
+        return this.ok("workflow.provider.rotate", workspace.context.workspace, data);
+    }
+    async linkApplication(root, input) {
+        const workspace = await this.workspace(root);
+        const path = join(workspace.root, ".openxiangda", "link.json");
+        mkdirSync(dirname(path), { recursive: true });
+        const value = {
+            schemaVersion: 2,
+            appCode: workspace.config.app.code,
+            baseUrl: input.baseUrl.replace(/\/+$/, ""),
+            environments: input.environments || [],
+        };
+        writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+        return this.ok("app.link", workspace.context.workspace, { path, ...value });
+    }
+    async generate(input = {}) {
+        const workspace = await this.workspace(input.root);
+        const sources = compileApplicationSources(workspace.config);
+        const output = join(workspace.root, "packages/contracts/src/generated.ts");
+        const current = existsSync(output) ? readFileSync(output, "utf8") : "";
+        const changed = current !== sources.contracts.typescript;
+        const diagnostics = [];
+        if (input.check && changed) {
+            diagnostics.push(this.diagnostic("GENERATED_CONTRACTS_OUTDATED", "生成契约与应用声明不一致", relative(workspace.root, output), "运行 openxiangda generate 并提交生成结果"));
+        }
+        else if (changed) {
+            mkdirSync(dirname(output), { recursive: true });
+            writeFileSync(output, sources.contracts.typescript, "utf8");
+        }
+        return this.result("generate", workspace.context.workspace, {
+            output,
+            changed,
+            contractDigest: sources.contracts.digest,
+        }, diagnostics, changed && input.check
+            ? [
+                {
+                    code: "generate",
+                    label: "更新生成契约",
+                    command: "openxiangda generate",
+                },
+            ]
+            : []);
+    }
+    async check(root) {
+        const workspace = await this.workspace(root);
+        const diagnostics = [
+            ...validateAppConfig(workspace.config),
+            ...this.versionTrainDiagnostics(workspace),
+        ];
+        const generated = await this.generate({
+            root: workspace.root,
+            check: true,
+        });
+        diagnostics.push(...generated.diagnostics);
+        const command = this.runPackageScript(workspace.root, "check");
+        if (!command.ok) {
+            diagnostics.push(this.diagnostic("WORKSPACE_CHECK_FAILED", "工作区 check 脚本失败", "package.json#scripts.check", "修复类型、契约或静态检查错误后重试", { output: command.output }));
+        }
+        return this.result("check", workspace.context.workspace, { stages: [{ name: "workspace", ...command }] }, diagnostics);
+    }
+    async test(root) {
+        const workspace = await this.workspace(root);
+        const command = this.runPackageScript(workspace.root, "test");
+        const diagnostics = command.ok
+            ? []
+            : [
+                this.diagnostic("WORKSPACE_TEST_FAILED", "工作区测试失败", "package.json#scripts.test", "修复失败测试后重试", { output: command.output }),
+            ];
+        return this.result("test", workspace.context.workspace, command, diagnostics);
+    }
+    async build(input = {}) {
+        const sealed = await this.buildSealed(input);
+        if (!sealed.data)
+            return sealed;
+        return {
+            ...sealed,
+            data: {
+                package: sealed.data.package,
+                ...(sealed.data.outputDirectory
+                    ? { outputDirectory: sealed.data.outputDirectory }
+                    : {}),
+            },
+        };
+    }
+    async buildSealed(input = {}) {
+        const workspace = await this.workspace(input.root);
+        const diagnostics = [];
+        await this.generate({ root: workspace.root });
+        if (!input.skipWorkspaceBuild) {
+            const command = this.runPackageScript(workspace.root, "build");
+            if (!command.ok) {
+                diagnostics.push(this.diagnostic("WORKSPACE_BUILD_FAILED", "前后端生产构建失败", "package.json#scripts.build", "修复构建错误后重试", { output: command.output }));
+                return this.result("build", workspace.context.workspace, undefined, diagnostics);
+            }
+        }
+        const backendImage = String(input.backendImage || process.env.OPENXIANGDA_BACKEND_IMAGE || "").trim();
+        if (!backendImage) {
+            diagnostics.push(this.diagnostic("BACKEND_IMAGE_REQUIRED", "当前应用包含 NestJS 后端，密封 AppPackage 时必须提供不可变 OCI image", "backend.image", "通过 --backend-image <registry/repository@sha256:digest> 或 OPENXIANGDA_BACKEND_IMAGE 提供"));
+            return this.result("build", workspace.context.workspace, undefined, diagnostics);
+        }
+        if (!/@sha256:[a-f0-9]{64}$/i.test(backendImage)) {
+            diagnostics.push(this.diagnostic("BACKEND_IMAGE_NOT_IMMUTABLE", "后端镜像必须使用不可变 sha256 digest，不能使用可变 tag", "backend.image", "将镜像引用改为 <registry/repository@sha256:64位摘要>"));
+            return this.result("build", workspace.context.workspace, undefined, diagnostics);
+        }
+        const sources = compileApplicationSources(workspace.config);
+        const frontendContent = this.directoryBundle(join(workspace.root, workspace.config.frontend.root, "dist"));
+        const frontendDigest = sha256Bytes(frontendContent);
+        const backendContent = canonicalJson({ image: backendImage });
+        const backendDigest = sha256Bytes(backendContent);
+        const artifacts = [
+            {
+                kind: "frontend",
+                digest: frontendDigest,
+                mediaType: "application/vnd.openxiangda.frontend-bundle.v2+json",
+                size: Buffer.byteLength(frontendContent),
+                entrypoint: "index.html",
+            },
+            {
+                kind: "backend",
+                digest: backendDigest,
+                mediaType: "application/vnd.oci.image.manifest.v1+json",
+                size: Buffer.byteLength(backendContent),
+                metadata: {
+                    imageDigest: backendImage,
+                    port: 3000,
+                },
+            },
+            sources.config.artifact,
+            sources.contracts.artifact,
+        ];
+        const revision = workspace.context.workspace.revision || "0".repeat(40);
+        const packageVersion = String(workspace.packageJson.version || "0.0.0");
+        const compiled = compileAppPackage({
+            config: workspace.config,
+            version: `${packageVersion}-${revision.slice(0, 12)}`,
+            createdAt: git(workspace.root, ["show", "-s", "--format=%cI", "HEAD"]) ||
+                new Date(0).toISOString(),
+            source: {
+                repository: workspace.context.workspace.repository || `local:${workspace.root}`,
+                commit: revision,
+                dirty: workspace.context.workspace.dirty === true,
+            },
+            toolchainVersion: this.toolchainVersion,
+            artifacts,
+            manifests: {
+                frontend: frontendDigest,
+                backend: backendDigest,
+                config: sources.config.digest,
+                dataContract: sources.contracts.digest,
+            },
+            minimumPlatformVersion: "2.0.0-alpha.1",
+            metadata: {
+                runtimeProfile: workspace.config.backend.runMode || "shared",
+            },
+        });
+        const artifactContent = {
+            [frontendDigest]: frontendContent,
+            [backendDigest]: backendContent,
+            [sources.config.digest]: sources.config.content,
+            [sources.contracts.digest]: sources.contracts.content,
+        };
+        let outputDirectory;
+        if (input.write !== false) {
+            outputDirectory = join(workspace.root, ".openxiangda", "build");
+            mkdirSync(join(outputDirectory, "artifacts"), { recursive: true });
+            writeFileSync(join(outputDirectory, "app-package.json"), `${JSON.stringify(compiled.manifest, null, 2)}\n`, "utf8");
+            for (const [digest, content] of Object.entries(artifactContent)) {
+                writeFileSync(join(outputDirectory, "artifacts", digest), content, "utf8");
+            }
+        }
+        return this.result("build", workspace.context.workspace, {
+            package: compiled,
+            artifactContent,
+            ...(outputDirectory ? { outputDirectory } : {}),
+        }, diagnostics, [
+            {
+                code: "deploy",
+                label: "部署到预发",
+                command: "openxiangda deploy preproduction",
+            },
+        ]);
+    }
+    async deploymentPlan(input) {
+        const built = await this.build({ ...input, write: false });
+        if (!built.ok || !built.data)
+            return built;
+        return {
+            ...built,
+            operation: "deployment.plan",
+            data: {
+                environment: input.environment,
+                packageDigest: built.data.package.digest,
+                appCode: built.data.package.manifest.appCode,
+                artifacts: built.data.package.manifest.artifacts,
+                requiredCapabilities: built.data.package.manifest.compatibility.requiredCapabilities,
+            },
+        };
+    }
+    async deploy(input) {
+        const workspace = await this.workspace(input.root);
+        if (input.environment === "production" &&
+            workspace.context.workspace.dirty) {
+            return this.result("deploy", workspace.context.workspace, undefined, [
+                this.diagnostic("PRODUCTION_SOURCE_DIRTY", "生产部署只接受 clean Git commit", "git", "提交并推送全部变更后重新构建同一 AppVersion"),
+            ]);
+        }
+        const built = await this.buildSealed({ ...input, root: workspace.root });
+        if (!built.ok || !built.data)
+            return built;
+        const client = await this.client(workspace.root);
+        const deployment = await (await import("./deployment.js")).submitAppPackage({
+            client,
+            compiledPackage: built.data.package,
+            artifactContent: built.data.artifactContent,
+            environmentKind: input.environment,
+            ...(input.environmentId ? { environmentId: input.environmentId } : {}),
+            idempotencyKey: input.idempotencyKey ||
+                `deploy:${built.data.package.digest}:${input.environment}`,
+            ...(input.requestId ? { requestId: input.requestId } : {}),
+        });
+        return this.ok("deploy", workspace.context.workspace, deployment, [
+            {
+                code: "status",
+                label: "查看部署状态",
+                command: `openxiangda status ${deployment.id}`,
+            },
+        ]);
+    }
+    async deploymentStatus(root, deploymentId) {
+        const workspace = await this.workspace(root);
+        const client = await this.client(workspace.root);
+        const data = deploymentId
+            ? await client.deployment(workspace.config.app.code, deploymentId)
+            : await client.deployments(workspace.config.app.code, 20);
+        return this.ok("status", workspace.context.workspace, data);
+    }
+    async deploymentLogs(root, deploymentId) {
+        const status = await this.deploymentStatus(root, deploymentId);
+        const run = status.data;
+        return {
+            ...status,
+            operation: "logs",
+            data: {
+                deploymentId,
+                status: run.status,
+                stage: run.stage,
+                checkpoints: run.checkpoints,
+                failure: run.failure,
+                traceId: run.result?.traceId,
+            },
+        };
+    }
+    async retry(root, deploymentId) {
+        const workspace = await this.workspace(root);
+        const deployment = await (await this.client(workspace.root)).retryDeployment(workspace.config.app.code, deploymentId);
+        return this.ok("retry", workspace.context.workspace, deployment);
+    }
+    async cancel(root, deploymentId) {
+        const workspace = await this.workspace(root);
+        const deployment = await (await this.client(workspace.root)).cancelDeployment(workspace.config.app.code, deploymentId);
+        return this.ok("cancel", workspace.context.workspace, deployment);
+    }
+    async promote(root, deploymentId, environment) {
+        const workspace = await this.workspace(root);
+        const client = await this.client(workspace.root);
+        const source = await client.deployment(workspace.config.app.code, deploymentId);
+        const appVersionId = String(source.result?.applicationVersionId || "");
+        if (!appVersionId)
+            throw new Error("DEPLOYMENT_APP_VERSION_NOT_AVAILABLE");
+        const deployment = await client.promote({
+            appCode: workspace.config.app.code,
+            appVersionId,
+            environmentKind: environment,
+            idempotencyKey: `promote:${source.packageDigest}:${environment}`,
+        });
+        return this.ok("promote", workspace.context.workspace, deployment);
+    }
+    async rollback(root, environment, appVersionId) {
+        const workspace = await this.workspace(root);
+        const deployment = await (await this.client(workspace.root)).rollback({
+            appCode: workspace.config.app.code,
+            appVersionId,
+            environmentKind: environment,
+            idempotencyKey: `rollback:${appVersionId}:${environment}`,
+        });
+        return this.ok("rollback", workspace.context.workspace, deployment);
+    }
+    async doctor(root) {
+        const workspace = await this.workspace(root);
+        const commands = ["git", "node", "pnpm", "docker"].map((command) => {
+            const result = spawnSync(command, ["--version"], { encoding: "utf8" });
+            return {
+                command,
+                ok: result.status === 0,
+                version: String(result.stdout || result.stderr || "").trim(),
+            };
+        });
+        let platform;
+        try {
+            platform = (await (await this.client(workspace.root)).capabilities());
+        }
+        catch (error) {
+            platform = { ok: false, message: error.message };
+        }
+        const diagnostics = commands
+            .filter((item) => !item.ok && item.command !== "docker")
+            .map((item) => this.diagnostic("TOOLCHAIN_COMMAND_MISSING", `缺少必需命令: ${item.command}`, item.command));
+        return this.result("doctor", workspace.context.workspace, { commands, platform }, diagnostics);
+    }
+    async dev(root) {
+        const workspace = await this.workspace(root);
+        return await new Promise((resolve) => {
+            const child = spawn("pnpm", ["run", "dev"], {
+                cwd: workspace.root,
+                stdio: "inherit",
+            });
+            child.on("exit", (code) => resolve(this.result("dev", workspace.context.workspace, { exitCode: code ?? 1 }, code === 0
+                ? []
+                : [
+                    this.diagnostic("DEV_PROCESS_FAILED", "开发进程异常退出", "dev"),
+                ])));
+        });
+    }
+    async workspace(root) {
+        return await loadWorkspace(root, this.toolchainVersion);
+    }
+    async client(root) {
+        if (this.options.client)
+            return this.options.client;
+        if (this.options.clientOptions) {
+            return new OpenXiangdaControlPlaneClient(this.options.clientOptions);
+        }
+        const session = await loadSession();
+        if (!session)
+            throw new Error("OPENXIANGDA_AUTH_REQUIRED");
+        let baseUrl = session.baseUrl;
+        if (root && session.savedAt !== "environment") {
+            const linkPath = join(root, ".openxiangda", "link.json");
+            if (existsSync(linkPath)) {
+                const link = JSON.parse(readFileSync(linkPath, "utf8"));
+                if (link.baseUrl)
+                    baseUrl = String(link.baseUrl).replace(/\/+$/, "");
+            }
+        }
+        return new OpenXiangdaControlPlaneClient({
+            baseUrl,
+            token: session.token,
+        });
+    }
+    get toolchainVersion() {
+        return this.options.toolchainVersion || OPENXIANGDA_TOOLCHAIN_VERSION;
+    }
+    runPackageScript(root, script) {
+        const result = spawnSync("pnpm", ["run", script], {
+            cwd: root,
+            encoding: "utf8",
+            env: process.env,
+        });
+        return {
+            ok: result.status === 0,
+            exitCode: result.status ?? 1,
+            output: `${result.stdout || ""}${result.stderr || ""}`.trim(),
+        };
+    }
+    directoryBundle(root) {
+        if (!existsSync(root) || !statSync(root).isDirectory()) {
+            throw Object.assign(new Error(`前端构建目录不存在: ${root}`), {
+                code: "FRONTEND_DIST_NOT_FOUND",
+            });
+        }
+        const files = [];
+        const visit = (directory) => {
+            for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+                const path = join(directory, entry.name);
+                if (entry.isDirectory())
+                    visit(path);
+                else if (entry.isFile()) {
+                    const content = readFileSync(path);
+                    files.push({
+                        path: relative(root, path).replaceAll("\\", "/"),
+                        sha256: sha256Bytes(content),
+                        content: content.toString("base64"),
+                    });
+                }
+            }
+        };
+        visit(root);
+        return canonicalJson({ schemaVersion: 2, files });
+    }
+    versionTrainDiagnostics(workspace) {
+        const versions = new Map();
+        const packageFiles = [];
+        const visit = (directory) => {
+            for (const entry of readdirSync(directory, { withFileTypes: true })) {
+                if (["node_modules", "dist", "coverage", ".git", ".openxiangda"].includes(entry.name)) {
+                    continue;
+                }
+                const path = join(directory, entry.name);
+                if (entry.isDirectory())
+                    visit(path);
+                else if (entry.isFile() && entry.name === "package.json")
+                    packageFiles.push(path);
+            }
+        };
+        visit(workspace.root);
+        for (const packageFile of packageFiles) {
+            const packageJson = JSON.parse(readFileSync(packageFile, "utf8"));
+            for (const section of [
+                "dependencies",
+                "devDependencies",
+                "peerDependencies",
+            ]) {
+                const dependencies = packageJson[section];
+                if (!dependencies || typeof dependencies !== "object")
+                    continue;
+                for (const [name, version] of Object.entries(dependencies)) {
+                    if (!name.startsWith("openxiangda-"))
+                        continue;
+                    const normalized = String(version).replace(/^workspace:/, "");
+                    const locations = versions.get(normalized) || [];
+                    locations.push(relative(workspace.root, packageFile).replaceAll("\\", "/"));
+                    versions.set(normalized, locations);
+                }
+            }
+        }
+        if (versions.size <= 1)
+            return [];
+        return [
+            this.diagnostic("TOOLCHAIN_VERSION_TRAIN_MISMATCH", `openxiangda-* 依赖不属于同一固定版本列车: ${[...versions.keys()].join(", ")}`, "package.json", "将全部工作区包的 openxiangda-* 依赖升级到同一版本", { versions: Object.fromEntries(versions) }),
+        ];
+    }
+    diagnostic(code, message, path, remediation, details) {
+        return {
+            schemaVersion: SCHEMA_VERSIONS.diagnostic,
+            code,
+            severity: "error",
+            message,
+            path,
+            retryable: false,
+            ...(remediation ? { remediation } : {}),
+            ...(details ? { details } : {}),
+        };
+    }
+    ok(operation, workspace, data, nextActions = []) {
+        return {
+            ok: true,
+            operation,
+            workspace,
+            data,
+            diagnostics: [],
+            nextActions,
+        };
+    }
+    result(operation, workspace, data, diagnostics, nextActions = []) {
+        return {
+            ok: diagnostics.every((item) => item.severity !== "error"),
+            operation,
+            workspace,
+            ...(data === undefined ? {} : { data }),
+            diagnostics,
+            nextActions,
+        };
+    }
+}
+//# sourceMappingURL=application-services.js.map