@coze-arch/cli 0.0.36-alpha.3ab612 → 0.0.36-alpha.4e6503

package/lib/__templates__/phaser-static/src/utils/asset-loader.js

@@ -1,267 +0,0 @@
-import { AUDIOS, IMAGES, IMAGE_SEQUENCES, VIDEOS } from '../assets.js';
-
-const FRAME_KEY_MARKER = ':frame:';
-const MANIFEST_KEY_SUFFIX = ':manifest';
-
-const getFrameKey = (assetKey, frameIndex) =>
-  assetKey +
-  FRAME_KEY_MARKER +
-  String(frameIndex + 1).padStart(4, '0');
-
-const getManifestKey = assetKey => assetKey + MANIFEST_KEY_SUFFIX;
-
-const getFrameSource = (directory, frameIndex) =>
-  directory + '/frame_' + String(frameIndex + 1).padStart(4, '0') + '.png';
-
-export const resolveAssetUrl = source => new URL(source, document.baseURI).href;
-
-const isImageSequenceManifest = value => {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-
-  return (
-    value.type === 'image_sequence' &&
-    typeof value.name === 'string' &&
-    typeof value.properties?.fps === 'number' &&
-    typeof value.properties.frame_count === 'number' &&
-    value.properties.frame_count > 0
-  );
-};
-
-const getImageSequenceManifest = (scene, assetKey) => {
-  const manifest = scene.cache.json.get(getManifestKey(assetKey));
-  if (!isImageSequenceManifest(manifest)) {
-    throw new Error('Invalid image sequence manifest: ' + assetKey);
-  }
-
-  return manifest;
-};
-
-const queueImageSequenceFrames = (scene, assetKey, directory, manifest) => {
-  Array.from(
-    { length: manifest.properties.frame_count },
-    (_value, frameIndex) => {
-      scene.load.image(
-        getFrameKey(assetKey, frameIndex),
-        resolveAssetUrl(getFrameSource(directory, frameIndex)),
-      );
-    },
-  );
-};
-
-const queueImages = (scene, images) => {
-  Object.entries(images).forEach(([assetKey, source]) => {
-    scene.load.image(assetKey, resolveAssetUrl(source));
-  });
-  return Object.keys(images).length;
-};
-
-const queueVideos = (scene, videos) => {
-  Object.entries(videos).forEach(([assetKey, source]) => {
-    scene.load.video(assetKey, resolveAssetUrl(source));
-  });
-  return Object.keys(videos).length;
-};
-
-const queueAudios = (scene, audios) => {
-  Object.entries(audios).forEach(([assetKey, source]) => {
-    scene.load.audio(assetKey, resolveAssetUrl(source));
-  });
-  return Object.keys(audios).length;
-};
-
-const queueImageSequences = (scene, imageSequences) =>
-  Object.entries(imageSequences).reduce(
-    (fileCount, [assetKey, directory]) => {
-      const manifestKey = getManifestKey(assetKey);
-      const cachedManifest = 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, _type, data) => {
-          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, collections) =>
-  queueImages(scene, collections.images ?? {}) +
-  queueImageSequences(scene, collections.imageSequences ?? {}) +
-  queueVideos(scene, collections.videos ?? {}) +
-  queueAudios(scene, collections.audios ?? {});
-
-export const getImageSequenceRuntimeKeys = assetKey => ({
-  texture: getFrameKey(assetKey, 0),
-  animation: assetKey + ':animation',
-});
-
-export const getAssetKeyFromFileKey = fileKey =>
-  fileKey.split(FRAME_KEY_MARKER)[0]?.replace(MANIFEST_KEY_SUFFIX, '') ??
-  fileKey;
-
-export const getAssetLabelFromFileKey = (fileKey, collections) => {
-  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, imageSequences) => {
-  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 => {
-  const matches = [];
-
-  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, loadedAsset) => {
-  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);
-    default:
-      return false;
-  }
-};
-
-export const loadAsset = async (scene, assetKey) => {
-  const { collections, loadedAsset } = findAsset(assetKey);
-  if (isAssetLoaded(scene, loadedAsset)) {
-    return loadedAsset;
-  }
-
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      scene.load.off('complete', onComplete);
-      scene.load.off('loaderror', onLoadError);
-    };
-
-    const onComplete = () => {
-      cleanup();
-      try {
-        if (loadedAsset.kind === 'image-sequence') {
-          registerImageSequenceAnimations(
-            scene,
-            collections.imageSequences ?? {},
-          );
-        }
-        resolve(loadedAsset);
-      } catch (error) {
-        reject(error);
-      }
-    };
-
-    const onLoadError = file => {
-      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-static/src/utils/index.js

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

package/lib/__templates__/phaser-static/src/utils/mark-editable.js

@@ -1,3 +0,0 @@
-export const markEditable = (locator, gameObject, options) =>
-  window.PhaserBridge?.markEditable?.(locator, gameObject, options) ??
-  gameObject;

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

@@ -1,35 +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)',
-    },
-  },
-  required: [],
-  additionalProperties: false,
-};
-
-const config = {
-  description:
-    'Phaser Static（纯静态 2D 游戏）：coze-dev init ${COZE_WORKSPACE_PATH} --template phaser-static\n' +
-    '- 适用：浏览器原生 JavaScript ESM 的 Phaser 3 游戏。\n' +
-    '- Phaser 与 Phaser Bridge 从 CDN 加载；无需 npm、Vite 或 TypeScript。',
-  paramsSchema,
-  defaultParams: {
-    appName: 'phaser-static-game',
-  },
-};
-
-export default config;

package/lib/deploy/package-project.js

@@ -1,244 +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 PROJECT_METADATA_FILE_MODE = 0o644;
-
-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 readPlatformCommand = (config, section, key) => {
-  const defaultCommand = readCommand(config, section, key);
-  const windowsCommand = process.platform === 'win32'
-    ? readCommand(config, section, `${key}_win`)
-    : undefined;
-
-  if (windowsCommand?.length) {
-    return { command: windowsCommand, key: `${key}_win` };
-  }
-  return defaultCommand?.length ? { command: defaultCommand, key } : undefined;
-};
-
-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 configuredCommand = readPlatformCommand(
-    readCozeConfig(sourceDir),
-    'dev',
-    'pack',
-  );
-  if (configuredCommand) {
-    process.stderr.write(
-      `[package] Running dev.${configuredCommand.key}: ${configuredCommand.command.join(' ')}\n`,
-    );
-    runCommand(configuredCommand.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,
-      onWriteEntry: entry => {
-        if (entry.path === '.coze' && entry.stat?.isFile()) {
-          entry.stat.mode = PROJECT_METADATA_FILE_MODE;
-        }
-      },
-      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;
-});