pixifact-cli 0.7.0 → 0.9.0

package/editor/assets/init-CzHI7RKj.js

@@ -0,0 +1 @@
+import{n as e,r as t,t as n,u as r}from"./index-BUZ_WtnT.js";r.add(n,t),r.add(e);

package/editor/assets/webworkerAll-D-3iZ4fC.js

@@ -0,0 +1 @@
+import"./index-BUZ_WtnT.js";import"./init-CzHI7RKj.js";

package/editor/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Pixifact Editor</title>
-    <script type="module" crossorigin src="/assets/index-DoPhYWF1.js"></script>
+    <script type="module" crossorigin src="/assets/index-BUZ_WtnT.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D3t5XxiB.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixifact-cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Pixifact Scene 自动化 CLI。",
   "packageManager": "bun@1.3.13",
   "type": "module",
@@ -32,7 +32,7 @@
     "start": "bun src/pixifact-cli.ts"
   },
   "dependencies": {
-    "pixifact": "^0.7.0",
+    "pixifact": "^0.9.0",
     "vite": "^8.0.10"
   }
 }

package/src/automation.ts

@@ -33,7 +33,6 @@ interface ToolInput {
     projectRoot?: unknown;
     scenePath?: unknown;
     node?: unknown;
-    name?: unknown;
 }
 
 type CompilerSceneValidationSuccess = ReturnType<typeof validateCompilerSceneFile> & { ok: true };
@@ -576,8 +575,8 @@ export function createPixifactAutomation() {
         createScene(input: unknown) {
             const args = assertRecord(input, 'input') as ToolInput;
             const { root, target } = resolveProjectPath(args.projectRoot, args.scenePath);
-            const sceneName = assertString(args.name, 'name');
             const scenePath = normalizeSceneAssetId(path.relative(root, target));
+            const sceneName = sceneLocalName(scenePath);
             const sourceRootFailure = compilerSceneSourceRootFailure(scenePath);
             if (sourceRootFailure) {
                 return sourceRootFailure;

package/src/editorServer.ts

@@ -36,6 +36,10 @@ interface EditorProjectFile {
     path: string;
 }
 
+interface EditorUiState {
+    assetTreeExpandedDirectories?: string[];
+}
+
 interface BunServer {
     hostname: string;
     port: number;
@@ -163,6 +167,35 @@ function requestPath(url: URL) {
     return url.searchParams.get('path') ?? '';
 }
 
+function editorUiStatePath(projectRoot: string) {
+    return path.join(projectRoot, '.pixifact', 'editor', 'ui-state.json');
+}
+
+function parseEditorUiState(value: unknown): EditorUiState {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Editor UI state must be a JSON object.');
+    }
+    const directories = (value as Record<string, unknown>).assetTreeExpandedDirectories;
+    if (directories === undefined) return {};
+    if (!Array.isArray(directories) || directories.some((directory) => typeof directory !== 'string')) {
+        throw new Error('Editor UI state assetTreeExpandedDirectories must be a string array.');
+    }
+    return { assetTreeExpandedDirectories: directories };
+}
+
+function readEditorUiState(projectRoot: string): EditorUiState {
+    const statePath = editorUiStatePath(projectRoot);
+    if (!fs.existsSync(statePath)) return {};
+    return parseEditorUiState(JSON.parse(fs.readFileSync(statePath, 'utf8')));
+}
+
+function writeEditorUiState(projectRoot: string, state: EditorUiState) {
+    const statePath = editorUiStatePath(projectRoot);
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+    return state;
+}
+
 async function readJsonBody(request: Request) {
     const value = await request.json();
     if (!value || typeof value !== 'object') {
@@ -205,6 +238,17 @@ export function createEditorProjectService(options: EditorProjectServiceOptions)
                     images: files.filter((file) => file.kind === 'image').map((file) => file.path),
                 });
             }
+            if (url.pathname === '/api/editor-ui-state' && request.method === 'GET') {
+                return jsonResponse(readEditorUiState(projectRoot));
+            }
+            if (url.pathname === '/api/editor-ui-state' && request.method === 'PUT') {
+                const body = await readJsonBody(request);
+                const state = parseEditorUiState(body);
+                if (!state.assetTreeExpandedDirectories) {
+                    throw new EditorRequestError(400, 'Editor UI state requires assetTreeExpandedDirectories.');
+                }
+                return jsonResponse(writeEditorUiState(projectRoot, state));
+            }
             if (url.pathname === '/api/scene' && request.method === 'GET') {
                 const scenePath = requestPath(url);
                 if (path.extname(scenePath).toLowerCase() !== '.scene') {
@@ -275,6 +319,9 @@ export function watchEditorProject(projectRoot: string, onProjectFileChanged: (p
     const watcher = fs.watch(projectRoot, { recursive: true }, (_event, fileName) => {
         if (!fileName) return;
         const filePath = String(fileName);
+        if (filePath.split(/[\\/]/).some((segment) => ignoredDirectories.has(segment))) {
+            return;
+        }
         const absolutePath = path.resolve(projectRoot, filePath);
         if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
             return;

package/src/pixifact-cli.ts

@@ -8,7 +8,7 @@ import { CompileSceneError, compileScenes } from 'pixifact/compiler-node';
 import type { SceneValidationDiagnostic } from 'pixifact/compiler';
 import { startEditorServer } from './editorServer';
 import { captureEditorScreenshot, queryEditorContext } from './editorSession';
-import { queryRuntime, queryRuntimeList } from './runtimeSession';
+import { captureRuntimeScreenshot, queryRuntime, queryRuntimeList } from './runtimeSession';
 import type { RuntimeLogLevel, RuntimeRequest } from 'pixifact/runtime-dev';
 import {
     buildPixifactTarget,
@@ -23,6 +23,7 @@ type Automation = ReturnType<typeof createPixifactAutomation>;
 interface CliOptions {
     automation?: Automation;
     captureEditorScreenshot?: typeof captureEditorScreenshot;
+    captureRuntimeScreenshot?: typeof captureRuntimeScreenshot;
     onDevEvent?: (event: PixifactDevEvent) => void;
     readEditorContext?: typeof queryEditorContext;
     listRuntimes?: typeof queryRuntimeList;
@@ -46,6 +47,8 @@ interface ParsedArgs {
     flags: Record<string, string | true>;
 }
 
+const runtimeScreenshotDefaultOutput = '.pixifact/runtime/frame.png';
+
 function parseArgs(argv: string[]): ParsedArgs {
     const positionals: string[] = [];
     const flags: Record<string, string | true> = {};
@@ -274,6 +277,7 @@ async function executeFileCommand(
     captureScreenshot: typeof captureEditorScreenshot = captureEditorScreenshot,
     listRuntimes: typeof queryRuntimeList = queryRuntimeList,
     sendRuntimeRequest: typeof queryRuntime = queryRuntime,
+    captureRuntime: typeof captureRuntimeScreenshot = captureRuntimeScreenshot,
 ) {
     const [area, action] = positionals;
     const projectRoot = projectRootFlag(flags);
@@ -282,6 +286,30 @@ async function executeFileCommand(
         return listRuntimes({ projectRoot });
     }
 
+    if (area === 'runtime' && action === 'screenshot') {
+        assertAllowedFlags(flags, ['output', 'project-root', 'runtime'], 'runtime screenshot');
+        const output = flags.output === undefined
+            ? path.resolve(projectRoot, runtimeScreenshotDefaultOutput)
+            : path.resolve(requireFlag(flags, 'output'));
+        const screenshot = await captureRuntime({
+            projectRoot,
+            runtimeId: optionalFlag(flags, 'runtime'),
+        });
+        if (!screenshot.ok) return screenshot;
+        const capturedAt = new Date().toISOString();
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, screenshot.data);
+        return {
+            ok: true,
+            runtimeId: screenshot.runtimeId,
+            width: screenshot.width,
+            height: screenshot.height,
+            bytes: screenshot.data.byteLength,
+            output,
+            capturedAt,
+        };
+    }
+
     if (area === 'runtime' && action !== undefined) {
         const runtimeId = optionalFlag(flags, 'runtime');
         let request: RuntimeRequest;
@@ -463,10 +491,17 @@ async function executeFileCommand(
     }
 
     if (area === 'scene' && action === 'create') {
+        assertAllowedFlags(flags, ['project-root'], 'scene create');
+        const scenePath = positionals[2];
+        if (!scenePath) {
+            throw new Error('Scene create requires a project-relative .scene path.');
+        }
+        if (positionals[3] !== undefined) {
+            throw new Error('Scene create accepts exactly one scene path.');
+        }
         return automation.createScene({
             projectRoot,
-            scenePath: requireFlag(flags, 'scene'),
-            name: requireFlag(flags, 'name'),
+            scenePath,
         });
     }
 
@@ -525,6 +560,7 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
                     runtimeCommands: [
                         'runtime list',
                         'runtime tree [--output <json-path>] [--runtime <runtime-id>]',
+                        'runtime screenshot [--output <png-path>] [--runtime <runtime-id>]',
                         'runtime node <pixi-uid> [--runtime <runtime-id>]',
                         'runtime state [--runtime <runtime-id>]',
                         'runtime logs [--after <seq>] [--level <level>] [--runtime <runtime-id>]',
@@ -538,12 +574,13 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
                         'editor',
                         'editor context',
                         'editor screenshot --output <png-path>',
-                        'scene create --scene <scene-path> --name <SceneName>',
+                        'scene create <scene-path>',
                         'node inspect --scene <scene-path> --node <locator>',
                     ],
                     nodeLocatorSource: 'scene inspect --scene <scene-path> returns node locator values',
                     defaults: {
                         projectRoot: 'current working directory',
+                        runtimeScreenshotOutput: runtimeScreenshotDefaultOutput,
                     },
                 }),
                 stderr: '',
@@ -561,6 +598,7 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
             options.captureEditorScreenshot,
             options.listRuntimes,
             options.queryRuntime,
+            options.captureRuntimeScreenshot,
         );
         if (isFailedResult(result)) {
             return {

package/src/runtimeSession.ts

@@ -4,6 +4,8 @@ import {
 } from 'pixifact/compiler-node';
 import type { RuntimePageDescriptor, RuntimeRequest } from 'pixifact/runtime-dev';
 
+const pngSignature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+
 interface RuntimeSessionLookupOptions {
     projectRoot: string;
     sessionsRoot?: string;
@@ -131,3 +133,61 @@ export async function queryRuntime(options: RuntimeQueryOptions) {
         }),
     });
 }
+
+export async function captureRuntimeScreenshot(
+    options: RuntimeSessionLookupOptions & { runtimeId?: string },
+): Promise<
+    | { ok: true; runtimeId: string; width: number; height: number; data: Uint8Array }
+    | { ok: false; error: string; [key: string]: unknown }
+> {
+    const active = await activeDescriptor(options);
+    if (!active.ok) return active;
+    const fetcher = options.fetch ?? fetch;
+    const listed = await runtimeHostFetch(active.descriptor, 'list', fetcher);
+    if (listed.ok !== true || !Array.isArray(listed.runtimes)) return listed;
+    const selected = selectRuntime(
+        listed.runtimes as Array<RuntimePageDescriptor & { connectedAt: string }>,
+        options.runtimeId,
+    );
+    if (!selected.ok) return selected;
+
+    let response: Response;
+    try {
+        response = await fetcher(`${active.descriptor.origin}/__pixifact_runtime__/screenshot`, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${active.descriptor.token}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ runtimeId: selected.runtime.runtimeId }),
+        });
+    } catch {
+        return {
+            ok: false,
+            error: 'Pixifact Runtime Vite server is not reachable for this project.',
+        };
+    }
+    if (!response.ok) {
+        return await response.json() as { ok: false; error: string; [key: string]: unknown };
+    }
+
+    const runtimeId = response.headers.get('x-pixifact-runtime');
+    const width = Number(response.headers.get('x-pixifact-width'));
+    const height = Number(response.headers.get('x-pixifact-height'));
+    if (
+        response.headers.get('content-type') !== 'image/png'
+        || runtimeId !== selected.runtime.runtimeId
+        || !Number.isInteger(width)
+        || width <= 0
+        || !Number.isInteger(height)
+        || height <= 0
+    ) {
+        return { ok: false, error: 'Pixifact Runtime Host returned invalid screenshot metadata.' };
+    }
+
+    const data = new Uint8Array(await response.arrayBuffer());
+    if (!Buffer.from(data.subarray(0, pngSignature.length)).equals(pngSignature)) {
+        return { ok: false, error: 'Pixifact Runtime Host did not return PNG screenshot data.' };
+    }
+    return { ok: true, runtimeId, width, height, data };
+}

package/src/viteTarget.ts

@@ -1,4 +1,4 @@
-import { access, readFile, readdir, stat } from 'node:fs/promises';
+import { access, readFile, readdir, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import {
     build,
@@ -55,7 +55,7 @@ export class PixifactTargetError extends Error {
 }
 
 export async function validatePixifactTarget(projectRootInput: string, mode: string) {
-    const projectRoot = path.resolve(projectRootInput);
+    const projectRoot = await realpath(path.resolve(projectRootInput));
     const { platform } = loadPixifactEnv(projectRoot, mode);
     const config = parsePixifactProjectConfig(JSON.parse(await readFile(
         path.join(projectRoot, pixifactProjectConfigFileName),

package/editor/assets/browserAll-DePxC4RK.js

@@ -1 +0,0 @@
-import{a as e,c as t,i as n,l as r,o as i,s as a,u as o}from"./index-DoPhYWF1.js";import"./init-CuKNsO_k.js";o.add(t),o.mixin(r,a),o.add(i),o.add(e),o.mixin(r,n);