@coze-arch/cli 0.0.35 → 0.0.36-alpha.0a210b

package/lib/__templates__/phaser/src/utils/asset-loader.ts

@@ -0,0 +1,319 @@
+import type Phaser from 'phaser';
+
+import { AUDIOS, IMAGES, IMAGE_SEQUENCES, VIDEOS } from '../assets';
+import type {
+  AssetCollections,
+  AssetSources,
+  ImageSequenceManifest,
+  LoadedAsset,
+} from '../types';
+
+const FRAME_KEY_MARKER = ':frame:';
+const MANIFEST_KEY_SUFFIX = ':manifest';
+
+const getFrameKey = (assetKey: string, frameIndex: number): string =>
+  `${assetKey}${FRAME_KEY_MARKER}${String(frameIndex + 1).padStart(4, '0')}`;
+
+const getManifestKey = (assetKey: string): string =>
+  `${assetKey}${MANIFEST_KEY_SUFFIX}`;
+
+const getFrameSource = (directory: string, frameIndex: number): string =>
+  `${directory}/frame_${String(frameIndex + 1).padStart(4, '0')}.png`;
+
+export const resolveAssetUrl = (source: string): string =>
+  new URL(source, document.baseURI).href;
+
+const isImageSequenceManifest = (
+  value: unknown,
+): value is ImageSequenceManifest => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const manifest = value as Partial<ImageSequenceManifest>;
+  return (
+    manifest.type === 'image_sequence' &&
+    typeof manifest.name === 'string' &&
+    typeof manifest.properties?.fps === 'number' &&
+    typeof manifest.properties.frame_count === 'number' &&
+    manifest.properties.frame_count > 0
+  );
+};
+
+const getImageSequenceManifest = (
+  scene: Phaser.Scene,
+  assetKey: string,
+): ImageSequenceManifest => {
+  const manifest: unknown = scene.cache.json.get(getManifestKey(assetKey));
+  if (!isImageSequenceManifest(manifest)) {
+    throw new Error(`Invalid image sequence manifest: ${assetKey}`);
+  }
+
+  return manifest;
+};
+
+const queueImageSequenceFrames = (
+  scene: Phaser.Scene,
+  assetKey: string,
+  directory: string,
+  manifest: ImageSequenceManifest,
+): void => {
+  Array.from(
+    { length: manifest.properties.frame_count },
+    (_value, frameIndex) => {
+      scene.load.image(
+        getFrameKey(assetKey, frameIndex),
+        resolveAssetUrl(getFrameSource(directory, frameIndex)),
+      );
+    },
+  );
+};
+
+const queueImages = (scene: Phaser.Scene, images: AssetSources): number => {
+  Object.entries(images).forEach(([assetKey, source]) => {
+    scene.load.image(assetKey, resolveAssetUrl(source));
+  });
+  return Object.keys(images).length;
+};
+
+const queueVideos = (scene: Phaser.Scene, videos: AssetSources): number => {
+  Object.entries(videos).forEach(([assetKey, source]) => {
+    scene.load.video(assetKey, resolveAssetUrl(source));
+  });
+  return Object.keys(videos).length;
+};
+
+const queueAudios = (scene: Phaser.Scene, audios: AssetSources): number => {
+  Object.entries(audios).forEach(([assetKey, source]) => {
+    scene.load.audio(assetKey, resolveAssetUrl(source));
+  });
+  return Object.keys(audios).length;
+};
+
+const queueImageSequences = (
+  scene: Phaser.Scene,
+  imageSequences: AssetSources,
+): number => {
+  return Object.entries(imageSequences).reduce(
+    (fileCount, [assetKey, directory]) => {
+      const manifestKey = getManifestKey(assetKey);
+      const cachedManifest: unknown = scene.cache.json.get(manifestKey);
+
+      if (isImageSequenceManifest(cachedManifest)) {
+        queueImageSequenceFrames(
+          scene,
+          assetKey,
+          directory,
+          cachedManifest,
+        );
+        return fileCount + cachedManifest.properties.frame_count;
+      }
+
+      scene.load.once(
+        `filecomplete-json-${manifestKey}`,
+        (_key: string, _type: string, data: unknown) => {
+          if (!isImageSequenceManifest(data)) {
+            throw new Error(`Invalid image sequence manifest: ${assetKey}`);
+          }
+
+          queueImageSequenceFrames(scene, assetKey, directory, data);
+        },
+      );
+
+      scene.load.json(
+        manifestKey,
+        resolveAssetUrl(`${directory}/manifest.json`),
+      );
+      return fileCount + 1;
+    },
+    0,
+  );
+};
+
+export const loadAssets = (
+  scene: Phaser.Scene,
+  collections: AssetCollections,
+): number =>
+  queueImages(scene, collections.images ?? {}) +
+  queueImageSequences(scene, collections.imageSequences ?? {}) +
+  queueVideos(scene, collections.videos ?? {}) +
+  queueAudios(scene, collections.audios ?? {});
+
+export const getImageSequenceRuntimeKeys = (
+  assetKey: string,
+): { texture: string; animation: string } => ({
+  texture: getFrameKey(assetKey, 0),
+  animation: `${assetKey}:animation`,
+});
+
+export const getAssetKeyFromFileKey = (fileKey: string): string =>
+  fileKey.split(FRAME_KEY_MARKER)[0]?.replace(MANIFEST_KEY_SUFFIX, '') ??
+  fileKey;
+
+export const getAssetLabelFromFileKey = (
+  fileKey: string,
+  collections: AssetCollections,
+): string => {
+  const assetKey = getAssetKeyFromFileKey(fileKey);
+
+  if (assetKey in (collections.images ?? {})) {
+    return `图片 ${assetKey}`;
+  }
+  if (assetKey in (collections.imageSequences ?? {})) {
+    return `帧动画 ${assetKey}`;
+  }
+  if (assetKey in (collections.videos ?? {})) {
+    return `视频 ${assetKey}`;
+  }
+  if (assetKey in (collections.audios ?? {})) {
+    return `音频 ${assetKey}`;
+  }
+
+  return assetKey;
+};
+
+export const registerImageSequenceAnimations = (
+  scene: Phaser.Scene,
+  imageSequences: AssetSources,
+): void => {
+  Object.keys(imageSequences).forEach(assetKey => {
+    const manifest = getImageSequenceManifest(scene, assetKey);
+    const animationKey = getImageSequenceRuntimeKeys(assetKey).animation;
+    if (scene.anims.exists(animationKey)) {
+      return;
+    }
+
+    scene.anims.create({
+      key: animationKey,
+      frames: Array.from(
+        { length: manifest.properties.frame_count },
+        (_value, frameIndex) => ({ key: getFrameKey(assetKey, frameIndex) }),
+      ),
+      frameRate: manifest.properties.fps,
+      repeat: -1,
+    });
+  });
+};
+
+const findAsset = (
+  assetKey: string,
+): { collections: AssetCollections; loadedAsset: LoadedAsset } => {
+  const matches: Array<{
+    collections: AssetCollections;
+    loadedAsset: LoadedAsset;
+  }> = [];
+
+  if (Object.hasOwn(IMAGES, assetKey)) {
+    matches.push({
+      collections: { images: { [assetKey]: IMAGES[assetKey] } },
+      loadedAsset: { kind: 'image', key: assetKey },
+    });
+  }
+  if (Object.hasOwn(IMAGE_SEQUENCES, assetKey)) {
+    matches.push({
+      collections: {
+        imageSequences: { [assetKey]: IMAGE_SEQUENCES[assetKey] },
+      },
+      loadedAsset: {
+        kind: 'image-sequence',
+        key: assetKey,
+        ...getImageSequenceRuntimeKeys(assetKey),
+      },
+    });
+  }
+  if (Object.hasOwn(VIDEOS, assetKey)) {
+    matches.push({
+      collections: { videos: { [assetKey]: VIDEOS[assetKey] } },
+      loadedAsset: { kind: 'video', key: assetKey },
+    });
+  }
+  if (Object.hasOwn(AUDIOS, assetKey)) {
+    matches.push({
+      collections: { audios: { [assetKey]: AUDIOS[assetKey] } },
+      loadedAsset: { kind: 'audio', key: assetKey },
+    });
+  }
+
+  if (matches.length === 0) {
+    throw new Error(`Asset not found: ${assetKey}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Duplicate asset key: ${assetKey}`);
+  }
+
+  return matches[0];
+};
+
+const isAssetLoaded = (
+  scene: Phaser.Scene,
+  loadedAsset: LoadedAsset,
+): boolean => {
+  switch (loadedAsset.kind) {
+    case 'image':
+      return scene.textures.exists(loadedAsset.key);
+    case 'image-sequence':
+      return scene.anims.exists(loadedAsset.animation);
+    case 'video':
+      return scene.cache.video.exists(loadedAsset.key);
+    case 'audio':
+      return scene.cache.audio.exists(loadedAsset.key);
+  }
+};
+
+interface LoaderFileLike {
+  key: string;
+}
+
+export const loadAsset = async (
+  scene: Phaser.Scene,
+  assetKey: string,
+): Promise<LoadedAsset> => {
+  const { collections, loadedAsset } = findAsset(assetKey);
+  if (isAssetLoaded(scene, loadedAsset)) {
+    return loadedAsset;
+  }
+
+  return new Promise<LoadedAsset>((resolve, reject) => {
+    const cleanup = (): void => {
+      scene.load.off('complete', onComplete);
+      scene.load.off('loaderror', onLoadError);
+    };
+
+    const onComplete = (): void => {
+      cleanup();
+      try {
+        if (loadedAsset.kind === 'image-sequence') {
+          registerImageSequenceAnimations(
+            scene,
+            collections.imageSequences ?? {},
+          );
+        }
+        resolve(loadedAsset);
+      } catch (error) {
+        reject(error);
+      }
+    };
+
+    const onLoadError = (file: LoaderFileLike): void => {
+      if (getAssetKeyFromFileKey(file.key) !== assetKey) {
+        return;
+      }
+
+      cleanup();
+      reject(new Error(`Failed to load asset: ${assetKey}`));
+    };
+
+    scene.load.once('complete', onComplete);
+    scene.load.on('loaderror', onLoadError);
+
+    try {
+      loadAssets(scene, collections);
+      if (!scene.load.isLoading()) {
+        scene.load.start();
+      }
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+};

package/lib/__templates__/phaser/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './asset-loader';
+export * from './mark-editable';

package/lib/__templates__/phaser/src/utils/mark-editable.ts

@@ -0,0 +1,6 @@
+import type Phaser from 'phaser';
+
+export const markEditable = <T extends Phaser.GameObjects.GameObject>(
+  locator: string,
+  gameObject: T,
+): T => window.PhaserBridge?.markEditable?.(locator, gameObject) ?? gameObject;

package/lib/__templates__/phaser/template.config.js

@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
+
+
+export const paramsSchema = {
+  type: 'object',
+  properties: {
+    appName: {
+      type: 'string',
+      minLength: 1,
+      pattern: '^[a-z0-9-]+$',
+      description:
+        'Application name (lowercase, alphanumeric and hyphens only)',
+    },
+    port: {
+      type: 'number',
+      default: 5000,
+      minimum: 1024,
+      maximum: 65535,
+      description: 'Development and preview server port',
+    },
+  },
+  required: [],
+  additionalProperties: false,
+};
+
+const config = {
+  description:
+    'Phaser（2D 游戏）：`coze-dev init ${COZE_WORKSPACE_PATH} --template phaser`\n' +
+    '- 适用：基于 Phaser 3、Vite 和 TypeScript 的 2D Web 游戏。',
+  paramsSchema,
+  defaultParams: {
+    appName: 'phaser-game',
+    port: 5000,
+  },
+};
+
+export default config;

package/lib/__templates__/phaser/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/lib/__templates__/phaser/vite.config.ts

@@ -0,0 +1,96 @@
+import { cp } from "node:fs/promises";
+import path from "node:path";
+import { defineConfig, type Plugin } from "vite";
+import serveStatic from "serve-static";
+
+const DEV_PHASER_BRIDGE_URL =
+  "https://unpkg.byted-static.com/latest/coze-game/phaser-bridge/dist/index.js";
+
+function injectDevPhaserBridge(): Plugin {
+  return {
+    name: "phaser-dev-bridge",
+    transformIndexHtml() {
+      return [
+        {
+          tag: "script",
+          attrs: { src: DEV_PHASER_BRIDGE_URL },
+          injectTo: "head",
+        },
+      ];
+    },
+  };
+}
+
+function mountDevAssets(directory: string): Plugin {
+  const serveAssets = serveStatic(directory, {
+    cacheControl: false,
+    dotfiles: "allow",
+    fallthrough: false,
+    index: false,
+    redirect: false,
+    setHeaders(response) {
+      response.setHeader("Cache-Control", "no-cache");
+    },
+  });
+
+  return {
+    name: "phaser-dev-assets",
+    configureServer(server) {
+      server.middlewares.use("/assets", (request, response, next) => {
+        const isRead = request.method === "GET" || request.method === "HEAD";
+        if (!isRead || request.url?.includes("?")) {
+          response.statusCode = 404;
+          response.end("Not Found\n");
+          return;
+        }
+        serveAssets(request, response, next);
+      });
+    },
+  };
+}
+
+function copyGameAssets(directory: string): Plugin {
+  return {
+    name: "phaser-build-assets",
+    async writeBundle(outputOptions) {
+      const outputDirectory = path.resolve(
+        import.meta.dirname,
+        outputOptions.dir ?? "dist",
+      );
+
+      await cp(directory, path.join(outputDirectory, "assets"), {
+        recursive: true,
+        force: true,
+        filter(source) {
+          return path.basename(source) !== ".DS_Store";
+        },
+      });
+    },
+  };
+}
+
+export default defineConfig(() => {
+  const isDev = process.env.COZE_PHASER_GAME_ENV === "DEV";
+  const assetsDirectory = path.join(import.meta.dirname, "assets");
+
+  return {
+    resolve: {
+      alias: {
+        "@": path.resolve(import.meta.dirname, "src"),
+      },
+    },
+    server: {
+      // 游戏需用户手动刷新，防止游玩过程中丢失游戏状态
+      hmr: false,
+    },
+    plugins: [
+      copyGameAssets(assetsDirectory),
+      ...(isDev
+        ? [
+            injectDevPhaserBridge(),
+            mountDevAssets(assetsDirectory),
+          ]
+        : []),
+    ],
+  };
+});

package/lib/__templates__/taro/.cozeproj/scripts/dev_run.sh

@@ -8,6 +8,9 @@ cd "${COZE_WORKSPACE_PATH}"
 # PID 文件，用于追踪上一次启动的进程树
 # ---------------------------------------------------------
 PID_FILE="/tmp/coze-dev-run.pid"
+LOG_DIR="/tmp/coze-logs"
+LOG_FILE="${LOG_DIR}/dev.log"
+DEV_PID=""
 
 # ---------------------------------------------------------
 # 工具函数
@@ -89,7 +92,8 @@ cleanup_previous_run() {
 # 2. 安装依赖
 # ---------------------------------------------------------
 echo "📦 Installing dependencies..."
-pnpm install
+PNPM_BIN="$(command -v pnpm)"
+"${PNPM_BIN}" install
 echo "✅ Dependencies installed successfully!"
 
 # ---------------------------------------------------------
@@ -108,11 +112,14 @@ kill_port_if_listening "${SERVER_PORT}"
 # 4. 退出时自动清理子进程（信号 trap）
 # ---------------------------------------------------------
 cleanup_on_exit() {
-    echo "🛑 dev_run.sh exiting, cleaning up child processes..."
-    # 杀掉当前脚本的所有子进程
-    kill -- -$$ 2>/dev/null || true
+    local exit_code=$?
+    trap - EXIT INT TERM HUP
+    if [[ -n "${DEV_PID}" ]] && kill -0 "${DEV_PID}" 2>/dev/null; then
+        echo "🛑 dev_run.sh exiting, cleaning up child processes..."
+        kill_process_tree "${DEV_PID}"
+    fi
     rm -f "${PID_FILE}"
-    exit 0
+    exit "${exit_code}"
 }
 trap cleanup_on_exit EXIT INT TERM HUP
 
@@ -134,17 +141,16 @@ start_service() {
     echo "Starting Taro H5 Dev Server and NestJS Server..."
 
     export PORT=${DEPLOY_RUN_PORT}
-    rm -f /tmp/coze-logs/dev.log
-    mkdir -p /tmp/coze-logs
+    mkdir -p "${LOG_DIR}"
+    : > "${LOG_FILE}"
 
-    # 后台启动并记录 PID
-    pnpm dev 2>&1 | tee /tmp/coze-logs/dev.log &
-    local dev_pid=$!
-    echo "${dev_pid}" > "${PID_FILE}"
-    echo "📝 Dev process started with PID: ${dev_pid} (saved to ${PID_FILE})"
+    # 后台启动以便记录真实 pnpm PID，但脚本持续 wait，保持外层 CLI 生命周期有效。
+    "${PNPM_BIN}" dev > >(tee -a "${LOG_FILE}") 2>&1 &
+    DEV_PID=$!
+    echo "${DEV_PID}" > "${PID_FILE}"
+    echo "📝 Dev process started with PID: ${DEV_PID} (saved to ${PID_FILE})"
 
-    # 前台等待，保证 trap 能正常捕获信号
-    wait "${dev_pid}" || true
+    wait "${DEV_PID}"
 }
 
 echo "Starting HTTP services on port ${DEPLOY_RUN_PORT} (web) and ${SERVER_PORT} (server)..."

package/lib/__templates__/templates.json

@@ -94,6 +94,31 @@
         "additionalProperties": false
       }
     },
+    {
+      "name": "phaser",
+      "description": "Phaser（2D 游戏）：`coze-dev init ${COZE_WORKSPACE_PATH} --template phaser`\n- 适用：基于 Phaser 3、Vite 和 TypeScript 的 2D Web 游戏。",
+      "location": "./phaser",
+      "paramsSchema": {
+        "type": "object",
+        "properties": {
+          "appName": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "^[a-z0-9-]+$",
+            "description": "Application name (lowercase, alphanumeric and hyphens only)"
+          },
+          "port": {
+            "type": "number",
+            "default": 5000,
+            "minimum": 1024,
+            "maximum": 65535,
+            "description": "Development and preview server port"
+          }
+        },
+        "required": [],
+        "additionalProperties": false
+      }
+    },
     {
       "name": "pi-agent",
       "description": "Pi Agent：`coze-dev init ${COZE_WORKSPACE_PATH} --template pi-agent`\n- 适用：基于 pi-agent-core 的 AI Agent 应用\n- 支持飞书、微信等多渠道接入\n- 内置 Dashboard 管理面板\n- 使用 TypeScript + Express + Vite",

package/lib/__templates__/vite/template.config.js

@@ -2,6 +2,7 @@
 import { spawn } from 'child_process';
 import { resolve, join, basename } from 'path';
 import { appendFileSync, openSync, closeSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
 
 
 
@@ -81,7 +82,8 @@ const config = {
       const projectRoot = resolve(outputPath);
 
       // Determine log directory
-      const logDir = process.env.COZE_LOG_DIR || resolve(__dirname, '../.log');
+      const cozeHome = process.env.COZE_HOME || join(homedir(), '.coze');
+      const logDir = process.env.COZE_LOG_DIR || join(cozeHome, 'logs');
       mkdirSync(logDir, { recursive: true });
 
       // Use project name in log file to avoid conflicts