@world-engines/project-host 0.1.0-alpha.0

package/dist/cli.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { execFile, spawn } from "node:child_process";
+import { realpath, readFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { AuthoringBridgeError } from "@world-engines/authoring-bridge";
+import { runWorldengineCli } from "./cli-command.js";
+import { createProjectAuthTransport } from "./project-auth-transport.js";
+import { writeCliPublicError } from "./public-error.js";
+import { createCachedEmbeddingPort } from "./embedding-cache.js";
+import { createLocalAccountEmbeddingPort } from "./local-account-embedding.js";
+import { startLocalAccountModelProxy } from "./account-model-proxy.js";
+import { createPreparedEmbeddingSnapshotReader, persistPreparedFrozenEmbeddingBatch } from "./prepared-embedding-cache.js";
+import { createFrozenReviewEmbeddingBatch, createFrozenReviewLocalArtifactAssembler, createFrozenReviewLocalPipeline, createCompilerReleaseProfileAdmission, createFrozenReviewRecoveryPort, } from "./frozen-review-local-pipeline.js";
+import { createFrozenReviewSourceCapture } from "./frozen-review-source-capture.js";
+import { createHarnessCallbackCapabilities } from "./harness-callback-transport.js";
+import { runProjectHostMcpPipe } from "./mcp-pipe-internal.js";
+import { LocalPreviewRuntime } from "./preview-runtime.js";
+import { createAuthoringBrowserRuntime } from "./authoring-browser-runtime.js";
+import { runProjectGitCli } from "./project-git-cli.js";
+const argv = process.argv.slice(2);
+const execFileAsync = promisify(execFile);
+/** 只有实际使用向量时才解析账户；cache 命中也必须验证登录与账户 identity。 */
+function accountEmbeddingResolver(projectRoot, projectId) {
+    return async () => {
+        const remote = await createLocalAccountEmbeddingPort({ projectRoot, projectId });
+        const cached = await createCachedEmbeddingPort({ projectRoot, embedding: remote, origin: remote.origin });
+        return Object.freeze({
+            ...cached,
+            assertCurrentAccount: remote.assertCurrentAccount,
+            async embed(texts, options) {
+                await remote.assertCurrentAccount(options);
+                const result = await cached.embed(texts, options);
+                await remote.assertCurrentAccount(options);
+                return result;
+            },
+        });
+    };
+}
+async function openSystemBrowser(url) {
+    const invocation = process.platform === "win32"
+        ? { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url] }
+        : process.platform === "darwin"
+            ? { command: "open", args: [url] }
+            : { command: "xdg-open", args: [url] };
+    const child = spawn(invocation.command, invocation.args, { detached: true, stdio: "ignore", windowsHide: true, shell: false });
+    child.once("error", () => undefined);
+    child.unref();
+}
+async function main() {
+    const canonicalRoot = await realpath(resolve(process.cwd()));
+    if (argv[0] === "mcp" && argv[1] === "--pipe" && argv[3] === "--challenge" && argv.length === 5) {
+        return runProjectHostMcpPipe(canonicalRoot, argv[2] ?? "", argv[4] ?? "");
+    }
+    const needsTransport = argv[0] === "upload" || argv[0] === "download" || argv[0] === "review" || argv[0] === "git";
+    const manifest = JSON.parse(await readFile(resolve(canonicalRoot, "worldengine.project.json"), "utf8"));
+    const projectId = String(manifest.project_id ?? "");
+    const transport = needsTransport ? await createProjectAuthTransport(projectId) : undefined;
+    if (argv[0] === "git") {
+        return runProjectGitCli(argv.slice(1), canonicalRoot, transport, {
+            stdout: (text) => process.stdout.write(text),
+        });
+    }
+    const questions = (argv[0] === "upload" || (argv[0] === "tool" && argv[1] === "ask_user")) && process.stdin.isTTY === true
+        ? createInterface({ input: process.stdin, output: process.stderr, terminal: process.stdin.isTTY === true })
+        : undefined;
+    const previewRuntime = new LocalPreviewRuntime();
+    const browserRuntime = createAuthoringBrowserRuntime(canonicalRoot, previewRuntime);
+    try {
+        const stagingRoot = join(canonicalRoot, ".worldengine", "download-staging");
+        const installViewDependencies = async (stagingViewRoot) => {
+            const canonicalStaging = await realpath(stagingViewRoot);
+            if (!canonicalStaging.startsWith(`${stagingRoot}${sep}`) || !canonicalStaging.endsWith(`${sep}incoming${sep}view`))
+                throw new Error("download_staging_view_root_rejected");
+            const npmCli = process.platform === "win32" ? join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js") : undefined;
+            await execFileAsync(npmCli === undefined ? "npm" : process.execPath, [...(npmCli === undefined ? [] : [npmCli]), "ci", "--ignore-scripts", "--no-audit", "--no-fund"], { cwd: canonicalStaging, timeout: 5 * 60_000, windowsHide: true, maxBuffer: 1024 * 1024 });
+        };
+        const command = argv[0] ?? "";
+        const resolveEmbedding = accountEmbeddingResolver(canonicalRoot, projectId);
+        const brokerCallbacks = await createHarnessCallbackCapabilities(projectId);
+        const terminalAskUser = questions === undefined || command !== "tool" || argv[1] !== "ask_user"
+            ? {}
+            : {
+                async ask_user(input) {
+                    const prompt = String(input.prompt ?? "");
+                    const choices = Array.isArray(input.choices) ? input.choices.filter((value) => typeof value === "string") : [];
+                    const label = choices.length === 0 ? `${prompt} ` : `${prompt}\n${choices.map((choice, index) => `${index + 1}. ${choice}`).join("\n")}\n> `;
+                    const raw = (await questions.question(label)).trim();
+                    const indexed = /^\d+$/.test(raw) ? choices[Number(raw) - 1] : undefined;
+                    const answer = indexed ?? raw;
+                    if (answer.length === 0 || (choices.length > 0 && input.allow_freeform !== true && !choices.includes(answer))) {
+                        throw new AuthoringBridgeError("E_VALIDATION_FAILED", "ask_user TTY 回答无效");
+                    }
+                    return { answer, ...(choices.includes(answer) ? { selected_choice: answer } : {}), transport: "terminal" };
+                },
+            };
+        const desktopAuthoringCapabilities = {
+            ...brokerCallbacks,
+            ...browserRuntime.capabilities,
+            ...terminalAskUser,
+            get_prepared_embedding_snapshot: async (request) => {
+                const embedding = await resolveEmbedding();
+                return createPreparedEmbeddingSnapshotReader({
+                    projectRoot: canonicalRoot, projectId, embedding, origin: embedding.origin,
+                })(request);
+            },
+        };
+        const authoringRuntime = {
+            desktopAuthoringCapabilities,
+            resolveEmbedding,
+        };
+        const runtimeForTransport = (activeTransport) => ({
+            transport: activeTransport,
+            recovery: createFrozenReviewRecoveryPort({
+                project_root: canonicalRoot,
+                project_id: projectId,
+                transport: activeTransport,
+            }),
+            pipeline: createFrozenReviewLocalPipeline({
+                project_root: canonicalRoot,
+                project_id: projectId,
+                run_embedding_batch: persistPreparedFrozenEmbeddingBatch({
+                    projectRoot: canonicalRoot,
+                    projectId,
+                    runBatch: async (request) => createFrozenReviewEmbeddingBatch(await resolveEmbedding())(request),
+                }),
+                read_source_ready: createFrozenReviewSourceCapture({
+                    project_root: canonicalRoot,
+                    project_id: projectId,
+                    transport: activeTransport,
+                }),
+                assembler: createFrozenReviewLocalArtifactAssembler({
+                    project_root: canonicalRoot,
+                    project_id: projectId,
+                    transport: activeTransport,
+                }),
+                admit_profile: createCompilerReleaseProfileAdmission(activeTransport, projectId),
+            }),
+        });
+        const reviewRuntime = command === "review" && transport !== undefined
+            ? runtimeForTransport(transport)
+            : transport === undefined ? {} : { transport };
+        return await runWorldengineCli(argv, canonicalRoot, {
+            stdout: (text) => process.stdout.write(text),
+            stderr: (text) => process.stderr.write(text),
+            ...(questions === undefined ? {} : {
+                confirmUploadTarget: async (target) => (await questions.question(`确认目标 ${String(target.client_target_key ?? "unknown")} force_overwrite? [y/N] `)).trim().toLowerCase() === "y",
+            }),
+        }, previewRuntime, { ...(transport === undefined ? {} : { transport }), dependencies: { installViewDependencies } }, transport === undefined ? {} : { transport }, authoringRuntime, reviewRuntime, {
+            openBrowser: openSystemBrowser,
+            startModelProxy: async (server, project) => {
+                if (server.auth === undefined)
+                    throw new AuthoringBridgeError("E_AUTH_REQUIRED", "模型代理需要项目登录模块");
+                return startLocalAccountModelProxy({ projectRoot: project.root, projectId: project.project_id, auth: server.auth });
+            },
+            onServerStarted: (server) => {
+                const closeOnSignal = (exitCode) => {
+                    void browserRuntime.close().finally(() => server.close()).finally(() => { process.exitCode = exitCode; });
+                };
+                process.once("SIGINT", () => closeOnSignal(130));
+                process.once("SIGTERM", () => closeOnSignal(143));
+            },
+            runtimesForTransport: (activeTransport) => ({
+                download: { transport: activeTransport, dependencies: { installViewDependencies } },
+                upload: { transport: activeTransport },
+                review: runtimeForTransport(activeTransport),
+            }),
+        });
+    }
+    finally {
+        questions?.close();
+        if (argv[0] !== "gui")
+            await browserRuntime.close();
+    }
+}
+main().then((code) => {
+    process.exitCode = code;
+}).catch((error) => {
+    writeCliPublicError((text) => process.stderr.write(text), error);
+    process.exitCode = 1;
+});

package/dist/desktop-authoring-runtime.d.ts

@@ -0,0 +1,88 @@
+import { type AuthoringBridgeAdapter, type AuthoringToolReceiptV1 } from "@world-engines/authoring-bridge";
+import { type FrozenArtifactEmbeddingRequestEntity, type PreparedNeutralArtifactEmbeddingSnapshot } from "@world-engines/scenario-review-snapshot";
+import { type LadybugEmbeddingPort, type LadybugGraphSnapshot, type LadybugGraphSnapshotRequest } from "./ladybug-runtime.js";
+import type { AuthoringEmbeddingPort } from "./authoring-model-connection.js";
+import type { ScenarioSourceReadback, ScenarioWriteRequest } from "./scenario-writer.js";
+/** ProjectHost 向 runtime 提供的唯一 source capability；不暴露任意文件或 statement。 */
+export interface DesktopAuthoringSourcePort {
+    readSourceReadback(): Promise<ScenarioSourceReadback>;
+    writeScenario(request: ScenarioWriteRequest): Promise<AuthoringToolReceiptV1>;
+}
+export interface DesktopAuthoringCapabilities {
+    readonly ask_user?: (input: Readonly<Record<string, unknown>>) => Promise<unknown> | unknown;
+    readonly preview_inspect?: (input: Readonly<Record<string, unknown>>) => Promise<unknown> | unknown;
+    readonly preview_interact?: (input: Readonly<Record<string, unknown>>) => Promise<unknown> | unknown;
+    /** Desktop model provider 的真实 embedding seam；缺失时 semantic/hybrid recall fail-closed。 */
+    readonly ladybug_embedding_port?: LadybugEmbeddingPort;
+    /** 登录态 embedding 延迟解析；keyword/tools/list/world_apply 不得触发账户登录。 */
+    readonly resolve_ladybug_embedding_port?: () => Promise<AuthoringEmbeddingPort>;
+    /** 只能回读已显式准备的冻结向量；不得在此触发 capture/compile/embed。 */
+    readonly get_prepared_embedding_snapshot?: (request: Readonly<{
+        project_id: string;
+        project_revision: number;
+        source_sha256: string;
+        scope_id?: string;
+        entities: readonly Readonly<{
+            entity_id: string;
+            source_kind: "entity" | "chunk" | "statement" | "edge_assertion";
+            source_text: string;
+            source_text_sha256: string;
+        }>[];
+    }>) => Promise<PreparedAuthoringRecallSnapshot | null>;
+}
+export interface PreparedAuthoringRecallSnapshot {
+    readonly project_id: string;
+    readonly project_revision: number;
+    readonly source_sha256: string;
+    readonly scope_id: string;
+    readonly snapshot: PreparedNeutralArtifactEmbeddingSnapshot;
+}
+export type AuthoringRecallGraph = Readonly<{
+    entities: readonly Readonly<Record<string, unknown>>[];
+    relations: readonly Readonly<Record<string, unknown>>[];
+}>;
+/**
+ * 本地 prepare 与正式 review reader 共用的 corpus 文本 seam。
+ */
+export declare function buildAuthoringRecallCorpus(graph: AuthoringRecallGraph): readonly Readonly<{
+    entity_id: string;
+    source_kind: FrozenArtifactEmbeddingRequestEntity["source_kind"];
+    source_text: string;
+}>[];
+export type GraphProjectionReadback = Readonly<{
+    schema_version: 1;
+    project_revision: number;
+    source_sha256: string;
+    graph: LadybugGraphSnapshot;
+    authoring: Readonly<{
+        metadata: JsonRecord;
+        runtime_definitions: JsonRecord;
+        entities: readonly Entity[];
+        relations: readonly Relation[];
+    }>;
+}>;
+type JsonRecord = Record<string, unknown>;
+type Entity = JsonRecord & {
+    id: string;
+    kind: string;
+    props: JsonRecord;
+};
+type Relation = JsonRecord & {
+    src: string;
+    dst: string;
+    kind: string;
+    props: JsonRecord;
+};
+export declare class DesktopAuthoringRuntime {
+    #private;
+    private readonly root;
+    private readonly port;
+    private readonly capabilities;
+    readonly adapter: AuthoringBridgeAdapter;
+    private constructor();
+    static open(root: string, port: DesktopAuthoringSourcePort, capabilities?: DesktopAuthoringCapabilities): Promise<DesktopAuthoringRuntime>;
+    close(): Promise<void>;
+    /** 固定完整 Node/Edge 读回；派生 graph-only cache 不调用模型，不能成为第二 source authority。 */
+    readGraphProjectionReadback(request?: LadybugGraphSnapshotRequest): Promise<GraphProjectionReadback>;
+}
+export {};