openxiangda 1.0.49 → 1.0.51

package/lib/cli.js

@@ -59,6 +59,7 @@ async function main(argv) {
   if (command === 'permission') return permission(rest);
   if (command === 'settings') return settings(rest);
   if (command === 'resource') return resource(rest);
+  if (command === 'runtime') return runtime(rest);
   if (command === 'inspect') return inspect(rest);
   if (command === 'skill') return skill(rest);
   if (command === 'feedback') return feedback(rest);
@@ -78,12 +79,12 @@ Usage:
   openxiangda platform use <name>
   openxiangda auth status|refresh|logout [--profile name]
   openxiangda env [--profile name]
-  openxiangda workspace init [dir] [--name package-name] [--install] [--profile name --app-type APP_XXX]
-  openxiangda workspace init [dir] --profile <name> --app-name <app-name> [--install]
+  openxiangda workspace init [dir] [--name package-name] [--runtime legacy|react-spa] [--install] [--profile name --app-type APP_XXX]
+  openxiangda workspace init [dir] --profile <name> --app-name <app-name> [--runtime legacy|react-spa] [--install]
   openxiangda workspace bind --profile <name> --app-type <APP_XXX>
   openxiangda workspace publish --profile <name> [--changed [--since ref]|--form code|--page code|--only list] [--dry-run] [--force] [--resources|--skip-resources] [--prune]
   openxiangda app list [--profile name] [--json]
-  openxiangda app create <name> [--profile name] [--description text]
+  openxiangda app create <name> [--profile name] [--runtime legacy|react-spa] [--description text]
   openxiangda app snapshot <APP_XXX> [--profile name] [--json]
   openxiangda form list [--profile name] [--json]
   openxiangda form create <formCode> [--name text] [--type receipt]  # low-level shell only
@@ -113,6 +114,9 @@ Usage:
   openxiangda permission form-group-list|form-group-create|form-group-bind
   openxiangda settings get|save|indexes|indexes-save|data-management|data-management-save|public-access
   openxiangda resource validate|plan|publish|pull [--profile name] [--json]
+  openxiangda runtime deploy [--profile name] [--dist dist] [--build-id id] [--no-build] [--no-activate] [--json]
+  openxiangda runtime releases [--profile name] [--json]
+  openxiangda runtime activate <releaseId> [--profile name] [--json]
   openxiangda inspect app|form|workflow|automation|permissions
   openxiangda feedback preview|submit --summary <text> [--type bug] [--severity medium] [--profile name] [--yes]
   openxiangda skill install [--agent codex|claude|qoder|dual] [--dest <skills-dir>] [--force] [--dry-run] [--json]
@@ -1040,11 +1044,13 @@ async function workspace(args) {
       assertCanInitializeWorkspace({
         dir: positional[0],
         force: flags.force,
+        runtime: flags.runtime || flags.template,
       });
       const data = await createPlatformApp(config, profileName, {
         name: flags['app-name'],
         description: flags.description || '',
         iconfontCss: flags['iconfont-css'] || '',
+        runtimeMode: normalizeWorkspaceRuntimeFlag(flags.runtime || flags.template),
       });
       appType = extractCreatedAppType(data);
       if (!appType) {
@@ -1064,6 +1070,7 @@ async function workspace(args) {
       force: flags.force,
       profile: profileName,
       appType,
+      runtime: flags.runtime || flags.template,
     });
     if (createdApp) {
       result.createdApp = createdApp;
@@ -1167,6 +1174,7 @@ async function app(args) {
       name,
       description: flags.description || '',
       iconfontCss: flags['iconfont-css'] || '',
+      runtimeMode: normalizeWorkspaceRuntimeFlag(flags.runtime || flags.template),
     });
     if (flags.json) return writeJson(data);
     print(JSON.stringify(data, null, 2));
@@ -1194,10 +1202,16 @@ async function createPlatformApp(config, profileName, payload) {
       name: payload.name,
       description: payload.description || '',
       iconfontCss: payload.iconfontCss || '',
+      ...(payload.runtimeMode ? { runtimeMode: payload.runtimeMode } : {}),
+      ...(payload.runtimeSettings ? { runtimeSettings: payload.runtimeSettings } : {}),
     },
   });
 }
 
+function normalizeWorkspaceRuntimeFlag(value) {
+  return value === 'react-spa' || value === 'spa' ? 'react-spa' : undefined;
+}
+
 function extractCreatedAppType(data) {
   const candidates = [
     data?.appType,
@@ -2215,11 +2229,14 @@ async function permission(args) {
     const [groupCode] = positional;
     const name = flags.name || positional.slice(1).join(' ') || groupCode;
     if (!groupCode || !name) {
-      fail('用法: openxiangda permission page-group-create <groupCode> --name <text> [--menu-codes <menuCode...>|--page-codes <pageCode...>|--form-codes <formCode...>|--menu-ids <id...>] [--no-runtime-aliases]');
+      fail('用法: openxiangda permission page-group-create <groupCode> --name <text> [--menu-codes <menuCode...>|--route-codes <routeCode...>|--path-patterns <pattern...>|--page-codes <pageCode...>|--form-codes <formCode...>|--menu-ids <id...>] [--no-runtime-aliases]');
     }
     const target = getWorkspaceTarget(config, profileName, flags);
     const roles = splitList(flags.roles);
     const editableTargets = resolvePagePermissionMenuTargets(target.bound, flags);
+    const menuCodes = splitList(flags['menu-codes']);
+    const routeCodes = splitList(flags['route-codes']);
+    const pathPatterns = splitList(flags['path-patterns']);
     const runtimeAliasTargets = flags['no-runtime-aliases']
       ? []
       : resolvePagePermissionRuntimeAliasTargets(target.bound, flags);
@@ -2233,6 +2250,9 @@ async function permission(args) {
           name,
           roles,
           menuFormUuids: editableTargets,
+          menuCodes,
+          routeCodes,
+          pathPatterns,
         },
       }
     );
@@ -2564,8 +2584,8 @@ async function resource(args) {
   const config = loadConfig();
   const profileName = flags.profile || config.currentProfile;
 
-  if (!['validate', 'plan', 'publish', 'pull'].includes(subcommand)) {
-    fail('用法: openxiangda resource validate|plan|publish|pull [--profile name] [--json]');
+  if (!['validate', 'plan', 'publish', 'pull', 'typegen'].includes(subcommand)) {
+    fail('用法: openxiangda resource validate|plan|publish|pull|typegen [--profile name] [--json]');
   }
 
   if (subcommand === 'pull') {
@@ -2577,6 +2597,13 @@ async function resource(args) {
   }
 
   const manifest = loadWorkspaceResources();
+  if (subcommand === 'typegen') {
+    const result = generateResourceTypes(manifest, flags.out || flags.output);
+    if (flags.json) return writeJson(result);
+    print(`已生成资源类型: ${result.filePath}`);
+    return;
+  }
+
   const validation = validateWorkspaceResources(manifest);
   if (subcommand === 'validate') {
     if (flags.json) return writeJson(validation);
@@ -2605,6 +2632,226 @@ async function resource(args) {
   printResourceResult(result);
 }
 
+async function runtime(args) {
+  const [subcommand, ...rest] = args;
+  const { flags, positional } = parseArgs(rest);
+  const config = loadConfig();
+  const profileName = flags.profile || config.currentProfile;
+  const target = getWorkspaceTarget(config, profileName, flags);
+
+  if (subcommand === 'releases' || subcommand === 'list') {
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/runtime/releases`
+    );
+    if (flags.json) return writeJson(data);
+    print(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  if (subcommand === 'activate') {
+    const releaseId = positional[0] || flags['release-id'];
+    if (!releaseId) fail('用法: openxiangda runtime activate <releaseId> [--profile name]');
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/runtime/releases/${encodeURIComponent(releaseId)}/activate`,
+      { method: 'POST' }
+    );
+    saveRuntimeReleaseState(target, data);
+    if (flags.json) return writeJson(data);
+    print(`runtime release 已激活: ${data.id || releaseId} build=${data.buildId || '-'}`);
+    return;
+  }
+
+  if (subcommand === 'deploy') {
+    const buildId = normalizeRuntimeBuildId(flags['build-id'] || createRuntimeBuildId());
+    const distDir = path.resolve(process.cwd(), flags.dist || 'dist');
+    const assetBaseUrl = buildRuntimeAssetBaseUrl(target.appType, buildId);
+    if (!flags['no-build']) {
+      runRuntimeBuild({
+        buildId,
+        appType: target.appType,
+        assetBaseUrl,
+        command: flags['build-command'],
+      });
+    }
+    const files = collectRuntimeDistFiles(distDir, {
+      includeSourceMaps: Boolean(flags['include-sourcemaps']),
+    });
+    const totalBytes = files.reduce((sum, file) => sum + file.size, 0);
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/runtime/releases`,
+      {
+        method: 'POST',
+        body: {
+          buildId,
+          version: flags.version || readWorkspaceVersion(),
+          releaseNotes: flags.notes || flags['release-notes'] || '',
+          activate: !flags['no-activate'],
+          files,
+        },
+      }
+    );
+    saveRuntimeReleaseState(target, data);
+    const result = {
+      appType: target.appType,
+      buildId,
+      release: data,
+      distDir,
+      fileCount: files.length,
+      totalBytes,
+      assetBaseUrl,
+      activated: !flags['no-activate'],
+    };
+    if (flags.json) return writeJson(result);
+    print(
+      [
+        `runtime release 已上传: ${target.appType}`,
+        `build: ${buildId}`,
+        `files: ${files.length} (${formatBytes(totalBytes)})`,
+        `assetBase: ${assetBaseUrl}`,
+        `active: ${result.activated ? 'yes' : 'no'}`,
+      ].join('\n')
+    );
+    return;
+  }
+
+  fail('用法: openxiangda runtime deploy|releases|activate [--profile name]');
+}
+
+function runRuntimeBuild(options) {
+  const command = options.command || defaultRuntimeBuildCommand();
+  print(`构建 React SPA runtime: ${command}`);
+  const result = spawnSync(command, [], {
+    cwd: process.cwd(),
+    shell: true,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      OPENXIANGDA_APP_TYPE: options.appType,
+      APP_TYPE: options.appType,
+      OPENXIANGDA_BUILD_ID: options.buildId,
+      OPENXIANGDA_RUNTIME_ASSET_BASE: options.assetBaseUrl,
+    },
+  });
+  if (result.error) fail(`runtime build 无法启动: ${result.error.message}`);
+  if (result.status !== 0) fail(`runtime build 失败: exit ${result.status}`);
+}
+
+function defaultRuntimeBuildCommand() {
+  if (fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml'))) return 'pnpm build';
+  if (fs.existsSync(path.join(process.cwd(), 'yarn.lock'))) return 'yarn build';
+  return 'npm run build';
+}
+
+function collectRuntimeDistFiles(distDir, options = {}) {
+  if (!fs.existsSync(distDir) || !fs.statSync(distDir).isDirectory()) {
+    fail(`runtime dist 目录不存在: ${distDir}`);
+  }
+  const files = [];
+  walkRuntimeDist(distDir, distDir, files, options);
+  if (!files.some(file => file.path === 'index.html')) {
+    fail(`runtime dist 缺少 index.html: ${distDir}`);
+  }
+  const totalBytes = files.reduce((sum, file) => sum + file.size, 0);
+  if (totalBytes > 25 * 1024 * 1024) {
+    fail(`runtime dist 过大: ${formatBytes(totalBytes)}，当前 JSON 发布通道上限为 25MB`);
+  }
+  return files;
+}
+
+function walkRuntimeDist(rootDir, currentDir, files, options) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolute = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      walkRuntimeDist(rootDir, absolute, files, options);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!options.includeSourceMaps && entry.name.endsWith('.map')) continue;
+    const relative = path.relative(rootDir, absolute).replace(/\\/g, '/');
+    const buffer = fs.readFileSync(absolute);
+    files.push({
+      path: relative,
+      size: buffer.length,
+      sha256: crypto.createHash('sha256').update(buffer).digest('hex'),
+      contentType: inferRuntimeContentType(relative),
+      contentBase64: buffer.toString('base64'),
+    });
+  }
+}
+
+function buildRuntimeAssetBaseUrl(appType, buildId) {
+  return `/service/openxiangda-api/v1/apps/${encodeURIComponent(appType)}/runtime/releases/by-build/${encodeURIComponent(buildId)}/files/`;
+}
+
+function createRuntimeBuildId() {
+  const stamp = new Date()
+    .toISOString()
+    .replace(/[-:.TZ]/g, '')
+    .slice(0, 14);
+  return `${stamp}-${crypto.randomBytes(4).toString('hex')}`;
+}
+
+function normalizeRuntimeBuildId(value) {
+  const normalized = String(value || '').trim().replace(/[^a-zA-Z0-9_.:-]/g, '-');
+  if (!normalized) fail('buildId 不能为空');
+  return normalized.slice(0, 128);
+}
+
+function inferRuntimeContentType(filePath) {
+  const extension = String(filePath || '').split('.').pop().toLowerCase();
+  if (extension === 'html') return 'text/html; charset=utf-8';
+  if (extension === 'js' || extension === 'mjs') return 'application/javascript; charset=utf-8';
+  if (extension === 'css') return 'text/css; charset=utf-8';
+  if (extension === 'json') return 'application/json; charset=utf-8';
+  if (extension === 'svg') return 'image/svg+xml';
+  if (extension === 'png') return 'image/png';
+  if (extension === 'jpg' || extension === 'jpeg') return 'image/jpeg';
+  if (extension === 'webp') return 'image/webp';
+  if (extension === 'woff') return 'font/woff';
+  if (extension === 'woff2') return 'font/woff2';
+  return 'application/octet-stream';
+}
+
+function readWorkspaceVersion() {
+  const packageFile = path.join(process.cwd(), 'package.json');
+  if (!fs.existsSync(packageFile)) return '';
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    return String(pkg.version || '');
+  } catch {
+    return '';
+  }
+}
+
+function saveRuntimeReleaseState(target, release) {
+  target.bound.runtime = {
+    ...(target.bound.runtime || {}),
+    activeReleaseId: release?.id || target.bound.runtime?.activeReleaseId || null,
+    activeBuildId: release?.buildId || target.bound.runtime?.activeBuildId || null,
+    assetBaseUrl: release?.assetBaseUrl || target.bound.runtime?.assetBaseUrl || null,
+    updatedAt: new Date().toISOString(),
+  };
+  target.bound.updatedAt = new Date().toISOString();
+  if (target.state.profiles?.[target.profileName]) {
+    target.state.profiles[target.profileName] = target.bound;
+  }
+  saveProjectState(target.state);
+}
+
+function formatBytes(value) {
+  const bytes = Number(value || 0);
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+}
+
 async function inspect(args) {
   const [subcommand, ...rest] = args;
   const { flags, positional } = parseArgs(rest);
@@ -2705,7 +2952,7 @@ async function commands(args) {
       'permission page-group-list|page-group-create|page-group-bind',
       'permission form-group-list|form-group-create|form-group-bind|form-summary|menu-permissions',
       'settings get|save|indexes|indexes-save|data-management|data-management-save|public-access|public-access-save|public-access-delete',
-      'resource validate|plan|publish|pull',
+      'resource validate|plan|publish|pull|typegen',
       'inspect app|form|workflow|automation|permissions',
       'feedback preview|submit',
       'skill install|status|bootstrap',
@@ -3055,6 +3302,8 @@ function saveMenuResource(target, menuCode, menuId, extra = {}) {
     'routeKey',
     'legacyFormUuid',
     'parentId',
+    'routeCode',
+    'path',
   ];
   saveStateResource(target, 'menus', menuCode, {
     ...pickStateFields(extra, keys),
@@ -3359,6 +3608,57 @@ function validateWorkspaceResources(manifest) {
   };
 }
 
+function generateResourceTypes(manifest, outputFile) {
+  const filePath = path.resolve(outputFile || path.join('src', 'generated', 'openxiangda.gen.ts'));
+  const menus = (manifest.menus || []).map(item => ({
+    code: item.code,
+    routeCode: item.routeCode || null,
+    path: item.path || null,
+  }));
+  const pagePermissionGroups = (manifest.pagePermissionGroups || []).map(item => ({
+    code: item.code,
+    menuCodes: normalizePermissionCodeArray(item.menuCodes),
+    routeCodes: normalizePermissionCodeArray(item.routeCodes),
+    pathPatterns: normalizePermissionCodeArray(item.pathPatterns),
+  }));
+  const routeCodes = unique(
+    [
+      ...menus.map(item => item.routeCode),
+      ...pagePermissionGroups.flatMap(item => item.routeCodes),
+    ].filter(Boolean)
+  );
+  const menuCodes = unique(menus.map(item => item.code).filter(Boolean));
+  const pagePermissionGroupCodes = unique(
+    pagePermissionGroups.map(item => item.code).filter(Boolean)
+  );
+  const content = [
+    '/* eslint-disable */',
+    '// Generated by openxiangda resource typegen. Do not edit manually.',
+    '',
+    `export const menuCodes = ${JSON.stringify(menuCodes, null, 2)} as const`,
+    'export type MenuCode = typeof menuCodes[number]',
+    '',
+    `export const routeCodes = ${JSON.stringify(routeCodes, null, 2)} as const`,
+    'export type RouteCode = typeof routeCodes[number]',
+    '',
+    `export const pagePermissionGroupCodes = ${JSON.stringify(pagePermissionGroupCodes, null, 2)} as const`,
+    'export type PagePermissionGroupCode = typeof pagePermissionGroupCodes[number]',
+    '',
+    `export const runtimeMenus = ${JSON.stringify(menus, null, 2)} as const`,
+    '',
+    `export const pagePermissionGroups = ${JSON.stringify(pagePermissionGroups, null, 2)} as const`,
+    '',
+  ].join('\n');
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+  return {
+    filePath,
+    menuCodes: menuCodes.length,
+    routeCodes: routeCodes.length,
+    pagePermissionGroups: pagePermissionGroupCodes.length,
+  };
+}
+
 function validateResourceItem(kind, item, errors, warnings) {
   const label = resourceLabel(kind, item);
   if (item.__invalid) {
@@ -4259,6 +4559,8 @@ async function publishMenuResources(config, target, menus, result) {
       sortOrder: menuItem.sortOrder,
       icon: menuItem.icon || null,
       isHidden: menuItem.isHidden,
+      routeCode: menuItem.routeCode || null,
+      path: menuItem.path || null,
     };
     const data = existing
       ? await requestWithAuth(
@@ -4281,6 +4583,10 @@ async function publishMenuResources(config, target, menus, result) {
         ...(formUuid ? { formUuid } : {}),
         ...(pageId ? { pageId } : {}),
         ...(menuItem.pageCode ? { pageCode: menuItem.pageCode } : {}),
+        ...(menuItem.routeCode || data.routeCode
+          ? { routeCode: data.routeCode || menuItem.routeCode }
+          : {}),
+        ...(menuItem.path || data.path ? { path: data.path || menuItem.path } : {}),
       });
     }
     result.published.push({ kind: 'menu', code: menuItem.code, action: existing ? 'update' : 'create', id: data?.id });
@@ -4615,6 +4921,9 @@ async function publishPagePermissionGroupResources(config, target, groups, resul
       name: group.name || group.code,
       roles: group.roles || [],
       menuFormUuids: resolvePagePermissionGroupTargets(target.bound, group),
+      menuCodes: normalizePermissionCodeArray(group.menuCodes),
+      routeCodes: normalizePermissionCodeArray(group.routeCodes),
+      pathPatterns: normalizePermissionCodeArray(group.pathPatterns),
     };
     const data = existing
       ? await requestWithAuth(
@@ -5174,6 +5483,9 @@ async function pullResources(config, target) {
       name: group.name,
       roles: group.roles || [],
       ...targets,
+      ...arrayField('menuCodes', group.menuCodes),
+      ...arrayField('routeCodes', group.routeCodes),
+      ...arrayField('pathPatterns', group.pathPatterns),
     });
     written.push(path.relative(process.cwd(), filePath));
   }
@@ -5288,6 +5600,11 @@ function splitPagePermissionTargetsForManifest(values = [], lookups) {
   };
 }
 
+function arrayField(key, value) {
+  const items = normalizePermissionCodeArray(value);
+  return items.length > 0 ? { [key]: items } : {};
+}
+
 function toPulledNotificationTemplate(template, lookups) {
   const formCode = lookups.formCodeByUuid.get(template.formUuid);
   return stripUndefinedValues({
@@ -5666,6 +5983,14 @@ function resolvePagePermissionGroupTargets(bound, group) {
   return unique([...direct, ...fromMenus, ...fromForms, ...fromPages].filter(Boolean));
 }
 
+function normalizePermissionCodeArray(value) {
+  return unique(
+    (Array.isArray(value) ? value : [])
+      .map(item => String(item || '').trim())
+      .filter(Boolean)
+  );
+}
+
 function saveResourceEntry(target, bucket, code, extra = {}) {
   saveStateResource(target, bucket, code, pickStateFields(extra, ['formUuid']), [
     'formUuid',
@@ -5702,7 +6027,9 @@ function menuEquals(bound, desired, existing) {
     optionalScalarEquals(existing.parentId || null, desiredParentId, hasAnyKey(desired, ['parentCode', 'parentId'])) &&
     optionalScalarEquals(existing.sortOrder, desired.sortOrder, desired.sortOrder !== undefined) &&
     optionalScalarEquals(existing.icon || null, desired.icon || null, desired.icon !== undefined) &&
-    optionalScalarEquals(Boolean(existing.isHidden), Boolean(desired.isHidden), desired.isHidden !== undefined)
+    optionalScalarEquals(Boolean(existing.isHidden), Boolean(desired.isHidden), desired.isHidden !== undefined) &&
+    optionalScalarEquals(existing.routeCode || null, desired.routeCode || null, desired.routeCode !== undefined) &&
+    optionalScalarEquals(existing.path || null, desired.path || null, desired.path !== undefined)
   );
 }
 
@@ -5754,7 +6081,10 @@ function pagePermissionGroupEquals(bound, desired, existing) {
     String(existing.name || '') === String(desired.name || desired.code || '') &&
     String(existing.resourceCode || '') === String(desired.code || '') &&
     stringSetEquals(existing.roles || [], desired.roles || []) &&
-    stringSetEquals(existing.menuFormUuids || [], desiredTargets)
+    stringSetEquals(existing.menuFormUuids || [], desiredTargets) &&
+    stringSetEquals(existing.menuCodes || [], normalizePermissionCodeArray(desired.menuCodes)) &&
+    stringSetEquals(existing.routeCodes || [], normalizePermissionCodeArray(desired.routeCodes)) &&
+    stringSetEquals(existing.pathPatterns || [], normalizePermissionCodeArray(desired.pathPatterns))
   );
 }
 

package/lib/workspace-init.js

@@ -4,7 +4,8 @@ const { spawnSync } = require('child_process');
 const { getProfile, loadConfig, saveProjectState } = require('./config');
 
 const ROOT_DIR = path.join(__dirname, '..');
-const TEMPLATE_DIR = path.join(ROOT_DIR, 'templates', 'sy-lowcode-app-workspace');
+const LEGACY_TEMPLATE_DIR = path.join(ROOT_DIR, 'templates', 'sy-lowcode-app-workspace');
+const REACT_SPA_TEMPLATE_DIR = path.join(ROOT_DIR, 'templates', 'openxiangda-react-spa');
 
 function initWorkspace(options = {}) {
   const targetDir = path.resolve(options.dir || process.cwd());
@@ -14,13 +15,16 @@ function initWorkspace(options = {}) {
   const install = Boolean(options.install);
   const profileName = options.profile || null;
   const appType = options.appType || null;
+  const runtime = normalizeRuntime(options.runtime || options.template);
+  const templateDir =
+    runtime === 'react-spa' ? REACT_SPA_TEMPLATE_DIR : LEGACY_TEMPLATE_DIR;
 
   if ((profileName && !appType) || (!profileName && appType)) {
     throw new Error('workspace init 绑定应用时必须同时提供 --profile 和 --app-type');
   }
 
-  ensureCanInitialize(targetDir, force);
-  copyTemplate(TEMPLATE_DIR, targetDir, {
+  ensureCanInitialize(targetDir, force, templateDir);
+  copyTemplate(templateDir, targetDir, {
     __WORKSPACE_PACKAGE_NAME__: packageName,
   });
 
@@ -69,7 +73,8 @@ function initWorkspace(options = {}) {
   return {
     targetDir,
     packageName,
-    templateDir: TEMPLATE_DIR,
+    runtime,
+    templateDir,
     installedDependencies: install,
     bound,
     nextSteps: buildNextSteps(targetDir, install, bound),
@@ -78,13 +83,16 @@ function initWorkspace(options = {}) {
 
 function assertCanInitializeWorkspace(options = {}) {
   const targetDir = path.resolve(options.dir || process.cwd());
-  ensureCanInitialize(targetDir, Boolean(options.force));
+  const runtime = normalizeRuntime(options.runtime || options.template);
+  const templateDir =
+    runtime === 'react-spa' ? REACT_SPA_TEMPLATE_DIR : LEGACY_TEMPLATE_DIR;
+  ensureCanInitialize(targetDir, Boolean(options.force), templateDir);
   return targetDir;
 }
 
-function ensureCanInitialize(targetDir, force) {
-  if (!fs.existsSync(TEMPLATE_DIR)) {
-    throw new Error(`workspace 模板不存在: ${TEMPLATE_DIR}`);
+function ensureCanInitialize(targetDir, force, templateDir) {
+  if (!fs.existsSync(templateDir)) {
+    throw new Error(`workspace 模板不存在: ${templateDir}`);
   }
   if (!fs.existsSync(targetDir)) {
     fs.mkdirSync(targetDir, { recursive: true });
@@ -101,6 +109,10 @@ function ensureCanInitialize(targetDir, force) {
   }
 }
 
+function normalizeRuntime(value) {
+  return value === 'react-spa' || value === 'spa' ? 'react-spa' : 'legacy';
+}
+
 function copyTemplate(sourceDir, targetDir, replacements) {
   for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
     const sourcePath = path.join(sourceDir, entry.name);

package/openxiangda-skills/SKILL.md

@@ -7,7 +7,7 @@ description: Use OpenXiangda for ANY work inside a sy-lowcode-app-workspace or a
 
 OpenXiangda is a lightweight bridge between an AI coding tool and a private low-code platform. No AK/SK. The user provides a platform domain, logs in as a normal platform user, and the CLI calls `/openxiangda-api/v1` with that user's token.
 
-For any user-facing page (form pages, workflow form pages, custom code pages), OpenXiangda must use `sy-lowcode-app-workspace`: source files in `src/`, built into bundles, uploaded to OSS, and registered through `openxiangda workspace publish`. Do not rely on the platform's legacy default schema page.
+OpenXiangda supports two workspace modes. Classic `sy-lowcode-app-workspace` publishes form/page bundles with `openxiangda workspace publish`. Phase 6 `react-spa` workspaces are standard React/Vite apps: publish resources with `openxiangda resource publish`, then publish the frontend dist with `openxiangda runtime deploy`. Do not send React SPA routes through old `isRenderNav`, app-shell, or workbench page parameters.
 
 ## TL;DR — Decision Card
 
@@ -17,7 +17,8 @@ For any user-facing page (form pages, workflow form pages, custom code pages), O
 
 | User says (zh / en) | Skill | First command |
 |---|---|---|
-| 发布 / 上线 / 部署 / publish / deploy / ship / release | `openxiangda-core` | `openxiangda workspace publish --profile <name> --changed --dry-run` |
+| 发布 classic workspace / 上线旧模式 | `openxiangda-core` | `openxiangda workspace publish --profile <name> --changed --dry-run` |
+| 发布 React SPA / Phase 6 runtime | `openxiangda-core` | `openxiangda resource publish --profile <name>` then `openxiangda runtime deploy --profile <name>` |
 | 只发布改动 / 增量 / 单页 / 单表 | `openxiangda-core` | `... --changed` / `--page <code>` / `--form <code>` / `--only pages/a,forms/b` |
 | 创建应用 / 新建 app / scaffold / 初始化工作区 | `openxiangda-app` | `openxiangda workspace init <dir> --profile <name> --app-name "..."` |
 | 绑定已有应用 / bind existing app | `openxiangda-app` | `openxiangda workspace bind --profile <name> --app-type APP_XXX` |
@@ -33,7 +34,7 @@ For any user-facing page (form pages, workflow form pages, custom code pages), O
 
 ### Hard rules — always
 
-- ✅ Publish through `openxiangda workspace publish --profile <name>` (with `--changed` / `--page` / `--form` / `--only` for routine edits).
+- ✅ Publish classic workspaces through `openxiangda workspace publish --profile <name>`; publish React SPA workspaces through `openxiangda resource publish` + `openxiangda runtime deploy`.
 - ✅ User token lives in `~/.openxiangda/profiles.json`; project state in `.openxiangda/state.json` (IDs only).
 - ✅ Each profile (dev / prod / ...) has its own `appType` and resource IDs; never copy a `formUuid` / `pageId` / `workflowId` / `automationId` across profiles.
 - ✅ Run `openxiangda update check --json` at the start of substantial work; if `updateAvailable`, run `openxiangda update install` and `openxiangda skill install --force`.

package/openxiangda-skills/skills/openxiangda-app/SKILL.md

@@ -40,6 +40,32 @@ cd ./my-app-workspace
 pnpm install
 ```
 
+For new Phase 6 React SPA apps, use the standard React application template:
+
+```bash
+openxiangda workspace init ./my-react-app \
+  --profile <name> \
+  --app-name "应用名称" \
+  --runtime react-spa
+cd ./my-react-app
+pnpm install
+pnpm dev
+```
+
+React SPA workspaces use React Router, Tailwind CSS, `OpenXiangdaProvider`
+from `openxiangda/runtime/react`, and resources under `src/resources/`.
+Do not use old `isRenderNav`, app-shell, or workbench page parameters inside
+React SPA routes.
+
+Publish React SPA apps with:
+
+```bash
+openxiangda resource publish --profile <name>
+openxiangda runtime deploy --profile <name>
+```
+
+`runtime deploy` builds and activates the app-level SPA release for `/view/:appType/*`.
+
 Bind to an existing app only when the user explicitly provides `appType` or asks to reuse an existing platform app:
 
 ```bash
@@ -59,6 +85,7 @@ If the user explicitly asks to create an app without initializing a workspace:
 
 ```bash
 openxiangda app create "应用名称" --profile <name>
+openxiangda app create "React应用名称" --profile <name> --runtime react-spa
 openxiangda workspace bind --profile <name> --app-type APP_XXX
 ```
 
@@ -71,6 +98,7 @@ openxiangda workspace bind --profile <name> --app-type APP_XXX
 - Store platform-specific IDs only in `.openxiangda/state.json`.
 - Use logical local codes for forms, pages, workflows, automations, and menus.
 - Before scaffolding a new business app, read `../../references/best-practices.md` and pick an architecture from the initialized `examples/best-practices/` catalog. Do not generate a large single-file app page when a template pattern already covers the scenario.
+- For Phase 6 React SPA apps, use `--runtime react-spa`. The generated app owns routing/layouts/menus with React Router and Tailwind CSS; platform permissions still come from backend runtime bootstrap and route checks.
 - When publishing after app edits, prefer targeted commands (`workspace publish --changed --dry-run`, then `--changed`, `--page`, `--form`, or `--only`). Do not publish all forms/pages just because one page changed.
 - Use `openxiangda app snapshot <APP_XXX> --profile <name> --json` before changing an existing app.