@coze-arch/cli 0.0.37 → 0.0.39-alpha.bdff32

package/lib/deploy/package-project.js

@@ -0,0 +1,244 @@
+#!/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;
+});

package/lib/deploy/package-project.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""Create the source tar.gz consumed by CreateDeployHistoryV2.
+
+This is the standalone subset of coze-coding's devbox package.py. It keeps the
+same archive layout and deployment exclusions without importing the devbox
+service runtime (FastAPI, S3FS, project managers, and background tasks).
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+import tarfile
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError as error:  # pragma: no cover - depends on host Python
+    raise RuntimeError("Python 3.11 or newer is required to read .coze") from error
+
+
+EXCLUDED_PARTS = {
+    ".codegraph",
+    ".next",
+    ".venv",
+    "__pycache__",
+    "node_modules",
+    "site-packages",
+}
+UPLOAD_SESSION_FILENAME = ".coze-deploy-upload.json"
+UPLOAD_SESSION_TEMP_PREFIX = ".coze-deploy-upload-"
+HOST_LINK_FILENAME = ".host.json"
+PROJECT_METADATA_FILE_MODE = 0o644
+
+
+def build_command_env():
+    env = os.environ.copy()
+    cli_bin_dir = Path(__file__).resolve().parent.parent / "node_modules" / ".bin"
+    path = env.get("PATH", "")
+    env["PATH"] = f"{cli_bin_dir}{os.pathsep}{path}" if path else str(cli_bin_dir)
+    return env
+
+
+def read_coze_config(source_dir: Path):
+    coze_path = source_dir / ".coze"
+    if not coze_path.is_file():
+        return {}
+    with coze_path.open("rb") as file:
+        return tomllib.load(file)
+
+
+def read_command(config, section: str, key: str):
+    command = (config.get(section) or {}).get(key)
+    if command is None:
+        return None
+    if not isinstance(command, list) or not all(
+        isinstance(part, str) and part for part in command
+    ):
+        raise ValueError(f".coze {section}.{key} must be a string array")
+    return command
+
+
+def read_platform_command(config, section: str, key: str, platform=sys.platform):
+    default_command = read_command(config, section, key)
+    windows_command = (
+        read_command(config, section, f"{key}_win")
+        if platform.startswith("win")
+        else None
+    )
+    if windows_command:
+        return f"{key}_win", windows_command
+    return (key, default_command) if default_command else None
+
+
+def run_pack_command(source_dir: Path):
+    configured_command = read_platform_command(
+        read_coze_config(source_dir), "dev", "pack"
+    )
+    if configured_command:
+        key, command = configured_command
+        print(f"[package] Running dev.{key}: {' '.join(command)}", file=sys.stderr)
+        subprocess.run(command, cwd=source_dir, env=build_command_env(), check=True)
+
+
+def has_index_html(directory: Path):
+    return (directory / "index.html").is_file()
+
+
+def prepare_pages_output(source_dir: Path):
+    if has_index_html(source_dir):
+        print(f"[package] Pages static source: {source_dir}", file=sys.stderr)
+        return source_dir
+
+    coze_path = source_dir / ".coze"
+    if not coze_path.is_file():
+        raise ValueError(
+            "Pages source contains neither index.html nor a .coze file. "
+            "Add index.html or configure a Next.js build in .coze."
+        )
+
+    config = read_coze_config(source_dir)
+    template = (config.get("project") or {}).get("template")
+    if not isinstance(template, str) or template.strip().lower() != "nextjs":
+        raise ValueError(
+            'Pages source contains no index.html; .coze project.template must be "nextjs"'
+        )
+    if not read_command(config, "deploy", "build"):
+        raise ValueError(
+            "Pages source contains no index.html; .coze deploy.build is required"
+        )
+    print(f"[package] Pages Next.js source: {source_dir}", file=sys.stderr)
+    return source_dir
+
+
+def should_exclude(tar_info: tarfile.TarInfo, exclude_coze_file=False):
+    parts = Path(tar_info.name).parts
+
+    # Local deployment metadata is not application source. Including it can change
+    # the package digest on the next CLI invocation and make the resumable PreDeploy
+    # session look like a different artifact.
+    if any(
+        part in {UPLOAD_SESSION_FILENAME, HOST_LINK_FILENAME}
+        or (part.startswith(UPLOAD_SESSION_TEMP_PREFIX) and part.endswith(".tmp"))
+        for part in parts
+    ):
+        return None
+    if ".env" in parts:
+        return None
+    if exclude_coze_file and ".coze" in parts:
+        return None
+    if any(part.startswith(".git") for part in parts):
+        return None
+    if any(part in EXCLUDED_PARTS for part in parts):
+        return None
+    if parts == (".coze",) and tar_info.isfile():
+        tar_info.mode = PROJECT_METADATA_FILE_MODE
+    return tar_info
+
+
+def create_tar_gz_without_root(source_dir: Path, output_path: Path, exclude_coze_file=False):
+    if not source_dir.is_dir():
+        raise ValueError(f"source directory does not exist: {source_dir}")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    print(f"[package] Creating archive from: {source_dir}", file=sys.stderr)
+    with tarfile.open(output_path, "w:gz") as archive:
+        for entry in sorted(os.listdir(source_dir)):
+            if entry == ".codegraph":
+                continue
+            if (source_dir / entry).resolve() == output_path.resolve():
+                continue
+            archive.add(
+                source_dir / entry,
+                arcname=entry,
+                filter=lambda info: should_exclude(info, exclude_coze_file),
+            )
+    if not output_path.is_file() or output_path.stat().st_size <= 0:
+        raise RuntimeError("source archive is empty")
+    print(
+        f"[package] Archive ready: {output_path.stat().st_size} bytes",
+        file=sys.stderr,
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("source_dir")
+    parser.add_argument("output_path")
+    parser.add_argument("--pages", action="store_true")
+    args = parser.parse_args()
+
+    source_dir = Path(args.source_dir).resolve()
+    output_path = Path(args.output_path).resolve()
+    if args.pages:
+        package_dir = prepare_pages_output(source_dir)
+    else:
+        run_pack_command(source_dir)
+        package_dir = source_dir
+    create_tar_gz_without_root(package_dir, output_path, args.pages)
+    print(output_path.stat().st_size)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coze-arch/cli",
-  "version": "0.0.37",
+  "version": "0.0.39-alpha.bdff32",
   "private": false,
   "description": "coze coding devtools cli",
   "license": "MIT",
@@ -12,6 +12,7 @@
   "files": [
     "lib",
     "bin",
+    "docs/deploy.md",
     "lib/**/.npmrc",
     "!**/*.tsbuildinfo",
     "!**/*.map",
@@ -48,7 +49,9 @@
     "fast-glob": "^3.3.3",
     "js-yaml": "^4.2.0",
     "minimist": "^1.2.8",
-    "shelljs": "^0.10.0"
+    "pnpm": "9.0.0",
+    "shelljs": "^0.10.0",
+    "tar": "^7.5.22"
   },
   "devDependencies": {
     "@coze-arch/cli-logger": "workspace:*",