@coze-arch/cli 0.0.36-alpha.fde2b5 → 0.0.36

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

@@ -1,319 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,43 +0,0 @@
-
-
-
-
-
-
-
-
-
-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

@@ -1,23 +0,0 @@
-{
-  "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

@@ -1,96 +0,0 @@
-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/deploy/package-project.js

@@ -1,220 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Create the source tar.gz consumed by CreateDeployHistoryV2.
- *
- * Keep this implementation behaviorally aligned with package-project.py, which
- * remains in this directory as the Python reference/backup implementation.
- */
-
-'use strict';
-
-const {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  statSync,
-} = require('node:fs');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const TOML = require('@iarna/toml');
-const tar = require('tar');
-
-const EXCLUDED_PARTS = new Set([
-  '.codegraph',
-  '.next',
-  '.venv',
-  '__pycache__',
-  'node_modules',
-  'site-packages',
-]);
-const LOCAL_METADATA_FILES = new Set([
-  '.coze-deploy-upload.json',
-  '.host.json',
-]);
-const UPLOAD_SESSION_TEMP_PREFIX = '.coze-deploy-upload-';
-const REPRODUCIBLE_ARCHIVE_MTIME = new Date(0);
-
-const parseArguments = argv => {
-  const positional = [];
-  let pages = false;
-  for (const argument of argv) {
-    if (argument === '--pages') {
-      pages = true;
-    } else if (argument.startsWith('-')) {
-      throw new Error(`Unknown argument: ${argument}`);
-    } else {
-      positional.push(argument);
-    }
-  }
-  if (positional.length !== 2) {
-    throw new Error(
-      'Usage: package-project.js <source_dir> <output_path> [--pages]',
-    );
-  }
-  return {
-    sourceDir: path.resolve(positional[0]),
-    outputPath: path.resolve(positional[1]),
-    pages,
-  };
-};
-
-const buildCommandEnv = () => {
-  const env = { ...process.env };
-  const cliBinDir = path.resolve(__dirname, '..', '..', 'node_modules', '.bin');
-  env.PATH = env.PATH
-    ? `${cliBinDir}${path.delimiter}${env.PATH}`
-    : cliBinDir;
-  return env;
-};
-
-const readCozeConfig = sourceDir => {
-  const cozePath = path.join(sourceDir, '.coze');
-  if (!existsSync(cozePath)) {
-    return {};
-  }
-  return TOML.parse(readFileSync(cozePath, 'utf8'));
-};
-
-const readCommand = (config, section, key) => {
-  const command = config[section]?.[key];
-  if (command === undefined) {
-    return undefined;
-  }
-  if (
-    !Array.isArray(command) ||
-    !command.every(part => typeof part === 'string' && part.length > 0)
-  ) {
-    throw new Error(`.coze ${section}.${key} must be a string array`);
-  }
-  return command;
-};
-
-const runCommand = (command, sourceDir, env) => {
-  const result = spawnSync(command[0], command.slice(1), {
-    cwd: sourceDir,
-    env,
-    stdio: 'inherit',
-  });
-  if (result.error) {
-    throw result.error;
-  }
-  if (result.status !== 0) {
-    throw new Error(
-      `Command ${command.join(' ')} exited with code ${String(result.status)}`,
-    );
-  }
-};
-
-const runPackCommand = sourceDir => {
-  const command = readCommand(readCozeConfig(sourceDir), 'dev', 'pack');
-  if (command) {
-    process.stderr.write(`[package] Running dev.pack: ${command.join(' ')}\n`);
-    runCommand(command, sourceDir, buildCommandEnv());
-  }
-};
-
-const hasIndexHtml = directory =>
-  existsSync(path.join(directory, 'index.html')) &&
-  statSync(path.join(directory, 'index.html')).isFile();
-
-const preparePagesOutput = sourceDir => {
-  if (hasIndexHtml(sourceDir)) {
-    process.stderr.write(`[package] Pages static source: ${sourceDir}\n`);
-    return sourceDir;
-  }
-
-  const cozePath = path.join(sourceDir, '.coze');
-  if (!existsSync(cozePath)) {
-    throw new Error(
-      'Pages source contains neither index.html nor a .coze file. ' +
-        'Add index.html or configure a Next.js build in .coze.',
-    );
-  }
-
-  const config = readCozeConfig(sourceDir);
-  const template = config.project?.template;
-  if (typeof template !== 'string' || template.trim().toLowerCase() !== 'nextjs') {
-    throw new Error(
-      'Pages source contains no index.html; .coze project.template must be "nextjs"',
-    );
-  }
-  if (!readCommand(config, 'deploy', 'build')) {
-    throw new Error(
-      'Pages source contains no index.html; .coze deploy.build is required',
-    );
-  }
-  process.stderr.write(`[package] Pages Next.js source: ${sourceDir}\n`);
-  return sourceDir;
-};
-
-const shouldInclude = (archivePath, excludeCozeFile = false) => {
-  const parts = archivePath.split(/[\\/]/u);
-  if (
-    parts.some(
-      part =>
-        LOCAL_METADATA_FILES.has(part) ||
-        (part.startsWith(UPLOAD_SESSION_TEMP_PREFIX) && part.endsWith('.tmp')),
-    )
-  ) {
-    return false;
-  }
-  if (parts.includes('.env')) {
-    return false;
-  }
-  if (excludeCozeFile && parts.includes('.coze')) {
-    return false;
-  }
-  if (parts.some(part => part.startsWith('.git'))) {
-    return false;
-  }
-  return !parts.some(part => EXCLUDED_PARTS.has(part));
-};
-
-const createTarGzWithoutRoot = async (sourceDir, outputPath, excludeCozeFile = false) => {
-  if (!existsSync(sourceDir) || !statSync(sourceDir).isDirectory()) {
-    throw new Error(`source directory does not exist: ${sourceDir}`);
-  }
-  mkdirSync(path.dirname(outputPath), { recursive: true });
-  process.stderr.write(`[package] Creating archive from: ${sourceDir}\n`);
-  const resolvedOutputPath = path.resolve(outputPath);
-  const entries = readdirSync(sourceDir)
-    .filter(entry =>
-      entry !== '.codegraph' &&
-      path.resolve(sourceDir, entry) !== resolvedOutputPath,
-    )
-    .sort();
-  await tar.create(
-    {
-      cwd: sourceDir,
-      file: outputPath,
-      filter: archivePath => shouldInclude(archivePath, excludeCozeFile),
-      gzip: true,
-      mtime: REPRODUCIBLE_ARCHIVE_MTIME,
-      portable: true,
-    },
-    entries,
-  );
-  const size = statSync(outputPath).size;
-  if (size <= 0) {
-    throw new Error('source archive is empty');
-  }
-  process.stderr.write(`[package] Archive ready: ${String(size)} bytes\n`);
-  return size;
-};
-
-const main = async () => {
-  const { sourceDir, outputPath, pages } = parseArguments(process.argv.slice(2));
-  const packageDir = pages
-    ? preparePagesOutput(sourceDir)
-    : (runPackCommand(sourceDir), sourceDir);
-  const size = await createTarGzWithoutRoot(packageDir, outputPath, pages);
-  process.stdout.write(`${String(size)}\n`);
-};
-
-main().catch(error => {
-  process.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);
-  process.exitCode = 1;
-});