openxiangda 1.0.264 → 2.0.0-alpha.2

package/lib/git-remote-identity.js

@@ -1,89 +0,0 @@
-const crypto = require('crypto');
-
-function legacyRemoteIdentity(value) {
-  const remote = String(value || '').trim();
-  try {
-    const url = new URL(remote);
-    url.username = '';
-    url.password = '';
-    url.search = '';
-    url.hash = '';
-    return url.toString();
-  } catch {
-    return remote
-      .replace(/^[^@/]+@([^:]+):/, '$1:')
-      .replace(/[?#].*$/, '');
-  }
-}
-
-function toggleDotGit(value) {
-  const normalized = String(value || '').replace(/\/+$/, '');
-  return /\.git$/i.test(normalized)
-    ? normalized.replace(/\.git$/i, '')
-    : `${normalized}.git`;
-}
-
-function canonicalRemoteIdentity(value) {
-  const legacy = legacyRemoteIdentity(value).replace(/\/+$/, '');
-  try {
-    const url = new URL(legacy);
-    const host = url.hostname.toLowerCase();
-    const port = url.port ? `:${url.port}` : '';
-    const pathname = url.pathname
-      .replace(/^\/+|\/+$/g, '')
-      .replace(/\.git$/i, '');
-    return `${host}${port}/${pathname}`.replace(/\/+$/, '');
-  } catch {
-    return legacy
-      .replace(/^([^:]+):/, '$1/')
-      .replace(/\.git$/i, '')
-      .replace(/\/+$/, '');
-  }
-}
-
-function remoteIdentityVariants(value) {
-  const legacy = legacyRemoteIdentity(value).replace(/\/+$/, '');
-  return Array.from(
-    new Set(
-      [
-        legacy,
-        toggleDotGit(legacy),
-        canonicalRemoteIdentity(legacy),
-      ].filter(Boolean)
-    )
-  );
-}
-
-function sha256(value) {
-  return `sha256:${crypto
-    .createHash('sha256')
-    .update(String(value))
-    .digest('hex')}`;
-}
-
-function remoteRepositoryHashes(value) {
-  return remoteIdentityVariants(value).map(identity =>
-    sha256(`remote:${identity}`)
-  );
-}
-
-function remoteUrlHashes(value) {
-  return remoteIdentityVariants(value).map(sha256);
-}
-
-function identitiesIntersect(left, right) {
-  const leftSet = new Set(
-    (Array.isArray(left) ? left : [left]).filter(Boolean)
-  );
-  return (Array.isArray(right) ? right : [right]).some(value =>
-    leftSet.has(value)
-  );
-}
-
-module.exports = {
-  identitiesIntersect,
-  legacyRemoteIdentity,
-  remoteIdentityVariants,
-  remoteRepositoryHashes,
-  remoteUrlHashes,
-};

package/lib/http.js

@@ -1,196 +0,0 @@
-const { formatFetchError, maskText } = require('./utils');
-
-const DEFAULT_REQUEST_TIMEOUT_MS = normalizeTimeoutMs(
-  process.env.OPENXIANGDA_REQUEST_TIMEOUT_MS,
-  120000
-);
-const DEFAULT_CONNECT_TIMEOUT_MS = normalizeTimeoutMs(
-  process.env.OPENXIANGDA_CONNECT_TIMEOUT_MS,
-  30000
-);
-
-configureFetchDispatcher(DEFAULT_CONNECT_TIMEOUT_MS);
-
-async function requestJson(baseUrl, apiPath, options = {}) {
-  if (typeof fetch !== 'function') {
-    throw new Error('当前 Node.js 版本不支持 fetch，请使用 Node.js 18 或更高版本');
-  }
-
-  const url = `${baseUrl.replace(/\/+$/, '')}${apiPath}`;
-  const timeoutMs = normalizeTimeoutMs(options.timeoutMs, DEFAULT_REQUEST_TIMEOUT_MS);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  const headers = {
-    accept: 'application/json',
-    ...(options.headers || {}),
-  };
-  if (options.body !== undefined) {
-    headers['content-type'] = 'application/json';
-  }
-  if (options.accessToken) {
-    headers.authorization = `Bearer ${options.accessToken}`;
-  }
-
-  let response;
-  try {
-    response = await fetch(url, {
-      method: options.method || 'GET',
-      headers,
-      body:
-        options.body === undefined ? undefined : JSON.stringify(options.body),
-      signal: controller.signal,
-    });
-  } catch (error) {
-    if (isAbortError(error)) {
-      throw new Error(maskText(`HTTP request timed out after ${timeoutMs}ms: ${apiPath}`));
-    }
-    throw new Error(formatFetchError(error, apiPath));
-  } finally {
-    clearTimeout(timer);
-  }
-
-  const text = await response.text();
-  let payload = null;
-  if (text) {
-    try {
-      payload = JSON.parse(text);
-    } catch {
-      payload = { message: text };
-    }
-  }
-
-  if (!response.ok) {
-    const message = payload?.message || response.statusText || 'request failed';
-    const error = new Error(maskText(`HTTP ${response.status}: ${message}`));
-    error.status = response.status;
-    error.payload = payload;
-    error.code = payload?.errorCode || payload?.code;
-    error.data = payload?.data;
-    throw error;
-  }
-
-  return payload;
-}
-
-function normalizeTimeoutMs(value, fallback) {
-  const parsed = Number(value);
-  if (Number.isFinite(parsed) && parsed > 0) return parsed;
-  return fallback;
-}
-
-function isAbortError(error) {
-  return (
-    error?.name === 'AbortError' ||
-    String(error?.message || '').toLowerCase().includes('aborted')
-  );
-}
-
-module.exports = {
-  requestJson,
-};
-
-function configureFetchDispatcher(timeoutMs) {
-  try {
-    // Node fetch uses undici internally but does not honor proxy environment
-    // variables by itself. Keep NO_PROXY-aware routing while extending the
-    // connect timeout for private and high-latency deployments.
-    const { Agent, ProxyAgent, setGlobalDispatcher } = require('undici');
-    const connect = { timeout: timeoutMs };
-    const directAgent = new Agent({ connect });
-    const httpProxyUrl = readProxyUrl('HTTP_PROXY');
-    const httpsProxyUrl = readProxyUrl('HTTPS_PROXY') || httpProxyUrl;
-    const allProxyUrl = readProxyUrl('ALL_PROXY');
-    const httpProxyAgent = createProxyAgent(
-      ProxyAgent,
-      httpProxyUrl || allProxyUrl,
-      connect
-    );
-    const httpsProxyAgent = createProxyAgent(
-      ProxyAgent,
-      httpsProxyUrl || allProxyUrl,
-      connect
-    );
-
-    setGlobalDispatcher({
-      dispatch(options, handler) {
-        const origin = new URL(String(options.origin));
-        if (shouldBypassProxy(origin)) {
-          return directAgent.dispatch(options, handler);
-        }
-        const proxyAgent =
-          origin.protocol === 'https:' ? httpsProxyAgent : httpProxyAgent;
-        return (proxyAgent || directAgent).dispatch(options, handler);
-      },
-      close() {
-        return closeDispatchers([
-          directAgent,
-          httpProxyAgent,
-          httpsProxyAgent,
-        ]);
-      },
-      destroy(error) {
-        return destroyDispatchers(
-          [directAgent, httpProxyAgent, httpsProxyAgent],
-          error
-        );
-      },
-    });
-  } catch {
-    // Keep working on runtimes where undici is not directly importable.
-  }
-}
-
-function readProxyUrl(name) {
-  const value = process.env[name] || process.env[name.toLowerCase()];
-  return String(value || '').trim();
-}
-
-function createProxyAgent(ProxyAgent, uri, connect) {
-  if (!uri) return null;
-  return new ProxyAgent({ uri, connect });
-}
-
-function shouldBypassProxy(origin) {
-  const noProxy = readProxyUrl('NO_PROXY');
-  if (!noProxy) return false;
-  const hostname = origin.hostname.replace(/^\[|\]$/g, '').toLowerCase();
-  const port = origin.port || (origin.protocol === 'https:' ? '443' : '80');
-
-  return noProxy.split(',').some(rawEntry => {
-    const entry = rawEntry.trim().toLowerCase();
-    if (!entry) return false;
-    if (entry === '*') return true;
-
-    const normalized = entry.replace(/^https?:\/\//, '');
-    const separator = normalized.lastIndexOf(':');
-    const hasSinglePortSeparator =
-      separator > -1 && normalized.indexOf(':') === separator;
-    const entryHost = (hasSinglePortSeparator
-      ? normalized.slice(0, separator)
-      : normalized
-    ).replace(/^\[|\]$/g, '');
-    const entryPort = hasSinglePortSeparator
-      ? normalized.slice(separator + 1)
-      : '';
-    if (entryPort && entryPort !== port) return false;
-
-    const suffix = entryHost.replace(/^\*?\./, '');
-    return hostname === suffix || hostname.endsWith(`.${suffix}`);
-  });
-}
-
-async function closeDispatchers(dispatchers) {
-  await Promise.all(
-    uniqueDispatchers(dispatchers).map(dispatcher => dispatcher.close())
-  );
-}
-
-async function destroyDispatchers(dispatchers, error) {
-  await Promise.all(
-    uniqueDispatchers(dispatchers).map(dispatcher => dispatcher.destroy(error))
-  );
-}
-
-function uniqueDispatchers(dispatchers) {
-  return [...new Set(dispatchers.filter(Boolean))];
-}

package/lib/integration-bundle.js

@@ -1,225 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const TASK_RESULT_SCHEMA_VERSION = 'openxiangda_task_result_v2';
-const LEGACY_TASK_RESULT_SCHEMA_VERSION = 'openxiangda_task_result_v1';
-const INTEGRATION_BUNDLE_SCHEMA_VERSION = 'openxiangda_integration_bundle_v1';
-
-function runGit(cwd, args, options = {}) {
-  const result = spawnSync('git', args, {
-    cwd,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  if (result.status !== 0 && !options.allowFailure) {
-    const error = new Error(
-      String(result.stderr || result.stdout || `git ${args.join(' ')} failed`).trim()
-    );
-    error.code = 'INTEGRATION_GIT_FAILED';
-    throw error;
-  }
-  return {
-    ok: result.status === 0,
-    stdout: String(result.stdout || '').trim(),
-    stderr: String(result.stderr || '').trim(),
-  };
-}
-
-function gitCommonStateDir(cwd) {
-  const root = runGit(cwd, ['rev-parse', '--show-toplevel']).stdout;
-  const common = runGit(cwd, ['rev-parse', '--git-common-dir']).stdout;
-  const commonDir = path.isAbsolute(common) ? common : path.resolve(root, common);
-  return path.join(commonDir, 'openxiangda');
-}
-
-function taskResultFile(cwd, changeId) {
-  return path.join(
-    gitCommonStateDir(cwd),
-    'task-results',
-    `${normalizeChangeId(changeId)}.json`
-  );
-}
-
-function normalizeChangeId(value) {
-  const changeId = String(value || '').trim();
-  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(changeId)) {
-    const error = new Error(`INTEGRATION_CHANGE_ID_INVALID: ${value || '(empty)'}`);
-    error.code = 'INTEGRATION_CHANGE_ID_INVALID';
-    throw error;
-  }
-  return changeId.toLowerCase();
-}
-
-function recordIntegrationTaskResult(options = {}) {
-  const cwd = path.resolve(options.cwd || process.cwd());
-  const changeId = normalizeChangeId(options.changeId);
-  const dirty = runGit(cwd, ['status', '--porcelain']).stdout;
-  if (dirty) {
-    const error = new Error(
-      'INTEGRATION_TASK_RESULT_DIRTY: 请先提交该任务的实现、测试和 SDD 记录，再生成 task result'
-    );
-    error.code = 'INTEGRATION_TASK_RESULT_DIRTY';
-    throw error;
-  }
-  const commit = runGit(cwd, ['rev-parse', 'HEAD']).stdout;
-  const treeHash = runGit(cwd, ['rev-parse', 'HEAD^{tree}']).stdout;
-  const branch = runGit(cwd, ['branch', '--show-current']).stdout;
-  if (!branch) {
-    const error = new Error(
-      'INTEGRATION_TASK_BRANCH_REQUIRED: detached HEAD 不能生成可合并任务结果'
-    );
-    error.code = 'INTEGRATION_TASK_BRANCH_REQUIRED';
-    throw error;
-  }
-  const result = {
-    schemaVersion: TASK_RESULT_SCHEMA_VERSION,
-    changeId,
-    commit,
-    treeHash,
-    branch,
-    ...(options.sourceBase?.baseCommit && options.sourceBase?.treeHash
-      ? {
-          sourceBase: {
-            repo: options.sourceBase.repo,
-            baseCommit: options.sourceBase.baseCommit,
-            treeHash: options.sourceBase.treeHash,
-          },
-          baseRevision: options.sourceBase.baseCommit,
-        }
-      : {}),
-    targets: options.targets || {},
-    changedFiles: Array.from(
-      new Set((options.changedFiles || []).map(String).filter(Boolean))
-    ).sort(),
-    recordedAt: new Date().toISOString(),
-  };
-  const file = taskResultFile(cwd, changeId);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(result, null, 2)}\n`, {
-    mode: 0o600,
-  });
-  return { ...result, file };
-}
-
-function readIntegrationTaskResult(cwd, changeId) {
-  const file = taskResultFile(cwd, changeId);
-  if (!fs.existsSync(file)) return null;
-  try {
-    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return [
-      TASK_RESULT_SCHEMA_VERSION,
-      LEGACY_TASK_RESULT_SCHEMA_VERSION,
-    ].includes(value?.schemaVersion)
-      ? { ...value, file }
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-function commitIsAncestor(cwd, commit, descendant = 'HEAD') {
-  return runGit(
-    cwd,
-    ['merge-base', '--is-ancestor', String(commit), String(descendant)],
-    { allowFailure: true }
-  ).ok;
-}
-
-function collectIntegrationTaskResults(options = {}) {
-  const cwd = path.resolve(options.cwd || process.cwd());
-  const changeIds = Array.from(
-    new Set((options.changeIds || []).map(normalizeChangeId))
-  ).sort();
-  const results = changeIds.map(changeId => {
-    const result = readIntegrationTaskResult(cwd, changeId);
-    if (!result) {
-      const error = new Error(
-        `INTEGRATION_TASK_RESULT_REQUIRED: ${changeId} 缺少 task result；请在任务提交后运行 openxiangda sdd ready ${changeId}`
-      );
-      error.code = 'INTEGRATION_TASK_RESULT_REQUIRED';
-      error.changeId = changeId;
-      throw error;
-    }
-    if (!commitIsAncestor(cwd, result.commit, 'HEAD')) {
-      const error = new Error(
-        `INTEGRATION_TASK_COMMIT_NOT_MERGED: ${changeId}@${String(result.commit).slice(0, 12)} 尚未合并到当前主线 HEAD`
-      );
-      error.code = 'INTEGRATION_TASK_COMMIT_NOT_MERGED';
-      error.changeId = changeId;
-      error.commit = result.commit;
-      throw error;
-    }
-    return result;
-  });
-  return {
-    schemaVersion: INTEGRATION_BUNDLE_SCHEMA_VERSION,
-    requiredChanges: changeIds,
-    requiredCommits: results.map(result => ({
-      changeId: result.changeId,
-      commit: result.commit,
-      treeHash: result.treeHash,
-      sourceBranch: result.branch,
-      ...(result.sourceBase?.baseCommit && result.sourceBase?.treeHash
-        ? {
-            sourceBase: result.sourceBase,
-            baseRevision:
-              result.baseRevision || result.sourceBase.baseCommit,
-          }
-        : {}),
-    })),
-    verifiedAgainst: runGit(cwd, ['rev-parse', 'HEAD']).stdout,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-function inspectIntegrationBundleCommits(integration, options = {}) {
-  const cwd = path.resolve(options.cwd || process.cwd());
-  const required = Array.isArray(integration?.requiredCommits)
-    ? integration.requiredCommits
-    : [];
-  return {
-    schemaVersion:
-      integration?.schemaVersion || INTEGRATION_BUNDLE_SCHEMA_VERSION,
-    valid: required.length > 0,
-    requiredCommits: required.map(item => ({
-      ...item,
-      mergedIntoHead: commitIsAncestor(cwd, item.commit, 'HEAD'),
-    })),
-    checkedHead: runGit(cwd, ['rev-parse', 'HEAD']).stdout,
-    checkedAt: new Date().toISOString(),
-  };
-}
-
-function assertIntegrationBundleCommits(integration, options = {}) {
-  const inspection = inspectIntegrationBundleCommits(integration, options);
-  if (!inspection.valid) {
-    const error = new Error(
-      'INTEGRATION_BUNDLE_REQUIRED: mainline bundle 缺少 requiredCommits，禁止发布可能遗漏任务的主线'
-    );
-    error.code = 'INTEGRATION_BUNDLE_REQUIRED';
-    throw error;
-  }
-  const missing = inspection.requiredCommits.filter(item => !item.mergedIntoHead);
-  if (missing.length > 0) {
-    const error = new Error(
-      `INTEGRATION_TASK_COMMIT_NOT_MERGED: ${missing
-        .map(item => `${item.changeId}@${String(item.commit).slice(0, 12)}`)
-        .join(', ')} 尚未合并到当前主线 HEAD`
-    );
-    error.code = 'INTEGRATION_TASK_COMMIT_NOT_MERGED';
-    error.missing = missing;
-    throw error;
-  }
-  return inspection;
-}
-
-module.exports = {
-  INTEGRATION_BUNDLE_SCHEMA_VERSION,
-  TASK_RESULT_SCHEMA_VERSION,
-  assertIntegrationBundleCommits,
-  collectIntegrationTaskResults,
-  inspectIntegrationBundleCommits,
-  readIntegrationTaskResult,
-  recordIntegrationTaskResult,
-};

package/lib/js-code-build.js

@@ -1,175 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const JS_CODE_SOURCE_KINDS = new Set(['js-code-nodes', 'automations', 'functions']);
-const CANONICAL_BUILD_SCRIPT = path.join(
-  __dirname,
-  '..',
-  'templates',
-  'openxiangda-react-spa',
-  'scripts',
-  'build-js-code.mjs'
-);
-
-function normalizeJsCodeBuildTargets(targets = []) {
-  const normalized = [];
-  const seen = new Set();
-  for (const target of targets) {
-    const sourceKind = String(target?.sourceKind || target?.kind || '').trim();
-    const scriptCode = String(target?.scriptCode || target?.code || '').trim();
-    if (!JS_CODE_SOURCE_KINDS.has(sourceKind)) {
-      throw new Error(`unsupported JS_CODE source: ${sourceKind || '<empty>'}`);
-    }
-    if (
-      !scriptCode ||
-      scriptCode === '.' ||
-      scriptCode === '..' ||
-      scriptCode.includes('/') ||
-      scriptCode.includes('\\')
-    ) {
-      throw new Error(`invalid JS_CODE script code: ${scriptCode || '<empty>'}`);
-    }
-    const key = `${sourceKind}:${scriptCode}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    normalized.push({ sourceKind, scriptCode });
-  }
-  return normalized;
-}
-
-function buildJsCodeBatchArgs(targets, options = {}) {
-  const normalized = normalizeJsCodeBuildTargets(targets);
-  if (normalized.length === 0) {
-    throw new Error('JS_CODE batch build requires at least one target');
-  }
-  const specs = normalized.map(target => `${target.sourceKind}:${target.scriptCode}`);
-  return [
-    'build-js-code',
-    '--scripts',
-    specs.join(','),
-    ...(options.force ? ['--force'] : []),
-  ];
-}
-
-function readWorkspacePackage(workspaceRoot) {
-  try {
-    return JSON.parse(
-      fs.readFileSync(path.join(workspaceRoot, 'package.json'), 'utf8')
-    );
-  } catch {
-    return null;
-  }
-}
-
-function isStandardWorkspaceJsCodeBuilder(workspaceRoot) {
-  const command = String(
-    readWorkspacePackage(workspaceRoot)?.scripts?.['build-js-code'] || ''
-  ).trim().replace(/\\/g, '/');
-  if (!command) return true;
-  // Only bypass the exact template-shaped command. Extra flags, command
-  // chaining, or wrappers may be meaningful custom preprocessing and must keep
-  // using the workspace builder.
-  const matched = command.match(
-    /^(?:node\s+)?((?:\.\/)?scripts\/build-js-code\.(?:mjs|cjs|js))$/
-  );
-  if (!matched) return false;
-  try {
-    const source = fs.readFileSync(path.resolve(workspaceRoot, matched[1]), 'utf8');
-    return [
-      'tsconfig.js-code-nodes.json',
-      'sourceKinds',
-      'buildScript',
-    ].every(marker => source.includes(marker)) &&
-      (source.includes('resolveBuildTargets') ||
-        source.includes('resolveBuildSelection'));
-  } catch {
-    return false;
-  }
-}
-
-function findWorkspaceTargetEntry(workspaceRoot, target) {
-  const base = path.join(
-    workspaceRoot,
-    'src',
-    target.sourceKind,
-    target.scriptCode,
-    'index'
-  );
-  return ['.ts', '.tsx']
-    .map(extension => `${base}${extension}`)
-    .find(filePath => fs.existsSync(filePath));
-}
-
-function canUseCanonicalJsCodeBuilder(workspaceRoot, targets, options = {}) {
-  if (
-    options.forceCanonical !== true &&
-    (options.preferWorkspaceBuilder ||
-      process.env.OPENXIANGDA_USE_WORKSPACE_JS_CODE_BUILDER === '1')
-  ) {
-    return false;
-  }
-  if (
-    !fs.existsSync(CANONICAL_BUILD_SCRIPT) ||
-    !fs.existsSync(path.join(workspaceRoot, 'tsconfig.js-code-nodes.json')) ||
-    (options.forceCanonical !== true &&
-      !isStandardWorkspaceJsCodeBuilder(workspaceRoot))
-  ) {
-    return false;
-  }
-  return targets.every(target => findWorkspaceTargetEntry(workspaceRoot, target));
-}
-
-function resolveWorkspaceJsCodeBuildCommand(workspaceRoot, targets, options = {}) {
-  const normalized = normalizeJsCodeBuildTargets(targets);
-  const packageArgs = buildJsCodeBatchArgs(normalized, options);
-  if (canUseCanonicalJsCodeBuilder(workspaceRoot, normalized, options)) {
-    return {
-      mode: 'canonical-scoped',
-      command: options.nodeBinary || process.execPath,
-      args: [CANONICAL_BUILD_SCRIPT, ...packageArgs.slice(1)],
-      env: {
-        OPENXIANGDA_WORKSPACE_ROOT: path.resolve(workspaceRoot),
-      },
-    };
-  }
-  return {
-    mode: 'workspace-script',
-    command: options.packageManager || 'pnpm',
-    args: packageArgs,
-    env: {},
-  };
-}
-
-function runWorkspaceJsCodeBuildBatch(workspaceRoot, targets, options = {}) {
-  const resolved = resolveWorkspaceJsCodeBuildCommand(
-    workspaceRoot,
-    targets,
-    options
-  );
-  const spawnOptions = {
-    cwd: workspaceRoot,
-    encoding: 'utf8',
-    ...options.spawnOptions,
-  };
-  if (resolved.mode === 'canonical-scoped') {
-    spawnOptions.env = {
-      ...process.env,
-      ...(options.spawnOptions?.env || {}),
-      ...resolved.env,
-    };
-  }
-  const result = spawnSync(resolved.command, resolved.args, spawnOptions);
-  Object.defineProperty(result, 'openxiangdaBuildMode', {
-    value: resolved.mode,
-    enumerable: false,
-  });
-  return result;
-}
-
-module.exports = {
-  buildJsCodeBatchArgs,
-  normalizeJsCodeBuildTargets,
-  resolveWorkspaceJsCodeBuildCommand,
-  runWorkspaceJsCodeBuildBatch,
-};