openxiangda 1.0.159 → 1.0.161

package/lib/config.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
 const { parse: parseDotenv } = require('dotenv');
@@ -9,6 +10,9 @@ const GLOBAL_ENV_FILE = path.join(CONFIG_DIR, '.env');
 const PROJECT_DIR = '.openxiangda';
 const PROJECT_STATE_FILE = path.join(PROJECT_DIR, 'state.json');
 const LEGACY_PROJECT_CONFIG_FILE = path.join(PROJECT_DIR, 'profiles.json');
+const PROJECT_STATE_LOCK_TIMEOUT_MS = 15_000;
+const PROJECT_STATE_STALE_LOCK_MS = 30_000;
+const projectStateBaselines = new WeakMap();
 
 function emptyConfig() {
   return {
@@ -145,20 +149,281 @@ function getProfile(config, name) {
   return { profileName, profile };
 }
 
-function loadProjectState(cwd = process.cwd()) {
-  return readJson(path.join(cwd, PROJECT_STATE_FILE), {
+function emptyProjectState() {
+  return {
     version: 1,
     profiles: {},
-  });
+  };
+}
+
+function normalizeProjectState(state) {
+  return {
+    version: 1,
+    ...(state || {}),
+    profiles: state?.profiles || {},
+  };
+}
+
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function loadProjectState(cwd = process.cwd()) {
+  const state = normalizeProjectState(
+    readJson(path.join(cwd, PROJECT_STATE_FILE), emptyProjectState())
+  );
+  projectStateBaselines.set(state, cloneJson(state));
+  return state;
 }
 
 function saveProjectState(state, cwd = process.cwd()) {
   const dir = path.join(cwd, PROJECT_DIR);
   fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(
-    path.join(cwd, PROJECT_STATE_FILE),
-    `${JSON.stringify({ version: 1, ...state }, null, 2)}\n`
-  );
+  const stateFile = path.join(cwd, PROJECT_STATE_FILE);
+  const lockFile = `${stateFile}.lock`;
+  const desired = normalizeProjectState(state);
+  const baseline = projectStateBaselines.get(state) || emptyProjectState();
+  const operations = collectProjectStateOperations(baseline, desired);
+  const lockFd = acquireProjectStateLock(lockFile);
+  try {
+    const current = readProjectStateForUpdate(stateFile);
+    const merged = applyProjectStateOperations(current, operations);
+    atomicWriteJson(stateFile, normalizeProjectState(merged));
+    // Keep the caller's own snapshot as its next three-way-merge baseline. Do
+    // not replace it with `merged`: the caller may still hold nested object
+    // references, and unrelated concurrent additions must not look like local
+    // deletions on its next save.
+    projectStateBaselines.set(state, cloneJson(desired));
+    return merged;
+  } finally {
+    releaseProjectStateLock(lockFile, lockFd);
+  }
+}
+
+function isPlainObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function jsonEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return (
+      left.length === right.length &&
+      left.every((value, index) => jsonEqual(value, right[index]))
+    );
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return (
+      leftKeys.length === rightKeys.length &&
+      leftKeys.every(
+        (key, index) => key === rightKeys[index] && jsonEqual(left[key], right[key])
+      )
+    );
+  }
+  return false;
+}
+
+function collectProjectStateOperations(base, desired, pathParts = [], result = []) {
+  if (jsonEqual(base, desired)) return result;
+
+  if (isPlainObject(desired) && (base === undefined || isPlainObject(base))) {
+    const baseObject = isPlainObject(base) ? base : {};
+    const desiredKeys = Object.keys(desired);
+    if (base === undefined && desiredKeys.length === 0) {
+      result.push({ type: 'set', path: pathParts, base, value: {} });
+      return result;
+    }
+    for (const key of new Set([...Object.keys(baseObject), ...desiredKeys])) {
+      const baseHasKey = Object.prototype.hasOwnProperty.call(baseObject, key);
+      const desiredHasKey = Object.prototype.hasOwnProperty.call(desired, key);
+      if (!desiredHasKey) {
+        result.push({
+          type: 'delete',
+          path: [...pathParts, key],
+          base: baseObject[key],
+        });
+      } else {
+        collectProjectStateOperations(
+          baseHasKey ? baseObject[key] : undefined,
+          desired[key],
+          [...pathParts, key],
+          result
+        );
+      }
+    }
+    return result;
+  }
+
+  result.push({ type: 'set', path: pathParts, base, value: cloneJsonValue(desired) });
+  return result;
+}
+
+function cloneJsonValue(value) {
+  return value === undefined ? undefined : cloneJson(value);
+}
+
+function readPathValue(root, pathParts) {
+  let current = root;
+  for (const part of pathParts) {
+    if (!isPlainObject(current) || !Object.prototype.hasOwnProperty.call(current, part)) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+function setPathValue(root, pathParts, value) {
+  if (pathParts.length === 0) return cloneJsonValue(value);
+  let current = root;
+  for (const part of pathParts.slice(0, -1)) {
+    if (!isPlainObject(current[part])) current[part] = {};
+    current = current[part];
+  }
+  current[pathParts[pathParts.length - 1]] = cloneJsonValue(value);
+  return root;
+}
+
+function deletePathValue(root, pathParts) {
+  if (pathParts.length === 0) return emptyProjectState();
+  let current = root;
+  for (const part of pathParts.slice(0, -1)) {
+    if (!isPlainObject(current?.[part])) return root;
+    current = current[part];
+  }
+  delete current[pathParts[pathParts.length - 1]];
+  return root;
+}
+
+function isTimestampPath(pathParts) {
+  return pathParts[pathParts.length - 1] === 'updatedAt';
+}
+
+function applyProjectStateOperations(currentState, operations) {
+  let merged = cloneJson(normalizeProjectState(currentState));
+  for (const operation of operations) {
+    const currentValue = readPathValue(merged, operation.path);
+    const desiredValue = operation.type === 'delete' ? undefined : operation.value;
+    const unchangedSinceLoad = jsonEqual(currentValue, operation.base);
+    const alreadyApplied = jsonEqual(currentValue, desiredValue);
+    if (!unchangedSinceLoad && !alreadyApplied && !isTimestampPath(operation.path)) {
+      const error = new Error(
+        `项目状态并发冲突: ${formatProjectStatePath(operation.path)} 已被其他进程修改，请重新执行当前命令`
+      );
+      error.code = 'OPENXIANGDA_STATE_CONFLICT';
+      error.path = operation.path.join('.');
+      throw error;
+    }
+    merged =
+      operation.type === 'delete'
+        ? deletePathValue(merged, operation.path)
+        : setPathValue(merged, operation.path, operation.value);
+  }
+  return merged;
+}
+
+function formatProjectStatePath(pathParts) {
+  return pathParts.length > 0 ? pathParts.join('.') : '<root>';
+}
+
+function readProjectStateForUpdate(stateFile) {
+  if (!fs.existsSync(stateFile)) return emptyProjectState();
+  try {
+    return normalizeProjectState(JSON.parse(fs.readFileSync(stateFile, 'utf8')));
+  } catch (error) {
+    const wrapped = new Error(`项目状态文件不是有效 JSON，已停止覆盖: ${stateFile}`);
+    wrapped.code = 'OPENXIANGDA_STATE_INVALID';
+    wrapped.cause = error;
+    throw wrapped;
+  }
+}
+
+function acquireProjectStateLock(lockFile) {
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      const fd = fs.openSync(lockFile, 'wx', 0o600);
+      fs.writeFileSync(fd, `${process.pid} ${new Date().toISOString()}\n`);
+      fs.fsyncSync(fd);
+      return fd;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      removeStaleProjectStateLock(lockFile);
+      if (Date.now() - startedAt >= PROJECT_STATE_LOCK_TIMEOUT_MS) {
+        const timeout = new Error(`等待项目状态锁超时: ${lockFile}`);
+        timeout.code = 'OPENXIANGDA_STATE_LOCK_TIMEOUT';
+        throw timeout;
+      }
+      sleepSync(10 + Math.floor(Math.random() * 20));
+    }
+  }
+}
+
+function removeStaleProjectStateLock(lockFile) {
+  try {
+    const stat = fs.statSync(lockFile);
+    if (Date.now() - stat.mtimeMs <= PROJECT_STATE_STALE_LOCK_MS) return;
+    fs.unlinkSync(lockFile);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
+
+function releaseProjectStateLock(lockFile, fd) {
+  try {
+    fs.closeSync(fd);
+  } finally {
+    try {
+      fs.unlinkSync(lockFile);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+function sleepSync(milliseconds) {
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(signal, 0, 0, milliseconds);
+}
+
+function atomicWriteJson(file, value) {
+  const dir = path.dirname(file);
+  const tempFile = `${file}.${process.pid}.${Date.now()}.${crypto
+    .randomBytes(6)
+    .toString('hex')}.tmp`;
+  let fd;
+  try {
+    fd = fs.openSync(tempFile, 'wx', 0o600);
+    fs.writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fd = undefined;
+    fs.renameSync(tempFile, file);
+    fsyncDirectory(dir);
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+    try {
+      fs.unlinkSync(tempFile);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+function fsyncDirectory(dir) {
+  let fd;
+  try {
+    fd = fs.openSync(dir, 'r');
+    fs.fsyncSync(fd);
+  } catch {
+    // Directory fsync is not supported on every platform/filesystem.
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
 }
 
 function loadGlobalEnv() {

package/lib/http.js

@@ -64,6 +64,8 @@ async function requestJson(baseUrl, apiPath, options = {}) {
     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;
   }
 

package/lib/js-code-build.js

@@ -0,0 +1,61 @@
+const { spawnSync } = require('child_process');
+
+const JS_CODE_SOURCE_KINDS = new Set(['js-code-nodes', 'automations', 'functions']);
+
+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 runWorkspaceJsCodeBuildBatch(workspaceRoot, targets, options = {}) {
+  return spawnSync(
+    options.packageManager || 'pnpm',
+    buildJsCodeBatchArgs(targets, options),
+    {
+      cwd: workspaceRoot,
+      encoding: 'utf8',
+      ...options.spawnOptions,
+    }
+  );
+}
+
+module.exports = {
+  buildJsCodeBatchArgs,
+  normalizeJsCodeBuildTargets,
+  runWorkspaceJsCodeBuildBatch,
+};

package/lib/publish-context.js

@@ -0,0 +1,98 @@
+const HEADER_NAMES = Object.freeze({
+  publishLeaseId: 'x-openxiangda-publish-lease-id',
+  changeBaselineId: 'x-openxiangda-change-baseline-id',
+  changeId: 'x-openxiangda-change-id',
+  clientSessionId: 'x-openxiangda-client-session-id',
+});
+
+const ENV_NAMES = Object.freeze({
+  publishLeaseId: 'OPENXIANGDA_PUBLISH_LEASE_ID',
+  changeBaselineId: 'OPENXIANGDA_CHANGE_BASELINE_ID',
+  changeId: 'OPENXIANGDA_CHANGE_ID',
+  clientSessionId: 'OPENXIANGDA_CLIENT_SESSION_ID',
+});
+
+function normalizePublishContext(value, options = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const context = {
+    appType: normalizeOptionalString(value.appType),
+    profileName: normalizeOptionalString(value.profileName || value.profile),
+    publishLeaseId: normalizeOptionalString(
+      value.publishLeaseId || value.leaseId
+    ),
+    changeBaselineId: normalizeOptionalString(
+      value.changeBaselineId || value.baselineId
+    ),
+    changeId: normalizeOptionalString(value.changeId),
+    clientSessionId: normalizeOptionalString(value.clientSessionId),
+  };
+  if (options.requireComplete) assertCompletePublishContext(context);
+  return context;
+}
+
+function assertCompletePublishContext(value) {
+  const context = normalizePublishContext(value) || {};
+  const missing = [];
+  if (!context.publishLeaseId) missing.push('publishLeaseId');
+  if (!context.changeBaselineId) missing.push('changeBaselineId');
+  if (!context.changeId) missing.push('changeId');
+  if (!context.clientSessionId) missing.push('clientSessionId');
+  if (missing.length > 0) {
+    const error = new Error(
+      `发布上下文不完整，缺少 ${missing.join(', ')}；请先执行 openxiangda release begin --change <id>`
+    );
+    error.code = 'PUBLISH_CONTEXT_REQUIRED';
+    error.missing = missing;
+    throw error;
+  }
+  return context;
+}
+
+function buildPublishContextHeaders(value, options = {}) {
+  const context = options.requireComplete
+    ? assertCompletePublishContext(value)
+    : normalizePublishContext(value);
+  if (!context) return {};
+  return compactMappedValues(context, HEADER_NAMES);
+}
+
+function buildPublishContextEnv(value, options = {}) {
+  const context = options.requireComplete
+    ? assertCompletePublishContext(value)
+    : normalizePublishContext(value);
+  if (!context) return {};
+  return compactMappedValues(context, ENV_NAMES);
+}
+
+function readPublishContextEnv(env = process.env) {
+  return normalizePublishContext({
+    publishLeaseId: env?.[ENV_NAMES.publishLeaseId],
+    changeBaselineId: env?.[ENV_NAMES.changeBaselineId],
+    changeId: env?.[ENV_NAMES.changeId],
+    clientSessionId: env?.[ENV_NAMES.clientSessionId],
+  });
+}
+
+function compactMappedValues(context, names) {
+  const entries = [];
+  for (const [field, outputName] of Object.entries(names)) {
+    const value = normalizeOptionalString(context[field]);
+    if (value) entries.push([outputName, value]);
+  }
+  return Object.fromEntries(entries);
+}
+
+function normalizeOptionalString(value) {
+  const text = String(value === undefined || value === null ? '' : value).trim();
+  return text || null;
+}
+
+module.exports = {
+  ENV_NAMES,
+  HEADER_NAMES,
+  assertCompletePublishContext,
+  buildPublishContextEnv,
+  buildPublishContextHeaders,
+  normalizePublishContext,
+  readPublishContextEnv,
+};

package/lib/publish-lease-heartbeat.js

@@ -0,0 +1,182 @@
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
+const DEFAULT_RENEW_WINDOW_MS = 180_000;
+
+class PublishLeaseLostError extends Error {
+  constructor(message, cause) {
+    const detail = String(
+      message || '应用发布租约已丢失，已停止后续写入。'
+    );
+    super(
+      detail.startsWith('PUBLISH_LEASE_LOST:')
+        ? detail
+        : `PUBLISH_LEASE_LOST: ${detail}`
+    );
+    this.name = 'PublishLeaseLostError';
+    this.code = 'PUBLISH_LEASE_LOST';
+    if (cause !== undefined) this.cause = cause;
+  }
+}
+
+class PublishLeaseHeartbeat {
+  constructor(options = {}) {
+    if (typeof options.renew !== 'function') {
+      throw new TypeError('publish lease heartbeat renew 必须是函数');
+    }
+    this.lease = options.lease || null;
+    this.renew = options.renew;
+    this.now = options.now || Date.now;
+    this.intervalMs = normalizePositiveInteger(
+      options.intervalMs,
+      DEFAULT_HEARTBEAT_INTERVAL_MS
+    );
+    this.renewWindowMs = normalizePositiveInteger(
+      options.renewWindowMs,
+      DEFAULT_RENEW_WINDOW_MS
+    );
+    this.setInterval = options.setInterval || global.setInterval;
+    this.clearInterval = options.clearInterval || global.clearInterval;
+    this.onRenew =
+      typeof options.onRenew === 'function' ? options.onRenew : () => {};
+    this.onLost =
+      typeof options.onLost === 'function' ? options.onLost : () => {};
+    this.timer = null;
+    this.inFlight = null;
+    this.lostError = null;
+    this.stopped = false;
+  }
+
+  start() {
+    if (this.stopped || this.timer) return this;
+    this.timer = this.setInterval(() => {
+      void this.tick();
+    }, this.intervalMs);
+    this.timer?.unref?.();
+    return this;
+  }
+
+  setLease(lease) {
+    if (!lease?.leaseId) {
+      throw new TypeError('publish lease heartbeat lease 缺少 leaseId');
+    }
+    if (
+      this.lease?.leaseId &&
+      String(lease.leaseId) !== String(this.lease.leaseId)
+    ) {
+      throw new TypeError('不能把 heartbeat 切换到另一条 publish lease');
+    }
+    this.lease = lease;
+    return this.lease;
+  }
+
+  async tick() {
+    if (this.stopped || this.lostError || !this.shouldRenew()) return this.lease;
+    try {
+      return await this.renewOnce();
+    } catch {
+      return null;
+    }
+  }
+
+  async beforeWrite(options = {}) {
+    this.assertHealthy();
+    if (options.forceRenew || this.shouldRenew()) {
+      await this.renewOnce();
+    }
+    this.assertHealthy();
+    return this.lease;
+  }
+
+  shouldRenew() {
+    const expiresAt = new Date(this.lease?.expiresAt || 0).getTime();
+    if (!Number.isFinite(expiresAt) || expiresAt <= 0) return true;
+    return expiresAt - Number(this.now()) <= this.renewWindowMs;
+  }
+
+  async renewOnce() {
+    this.assertHealthy();
+    if (this.stopped) {
+      throw this.markLost(
+        new Error('publish lease heartbeat 已停止，不能继续续租')
+      );
+    }
+    if (this.inFlight) return await this.inFlight;
+
+    this.inFlight = Promise.resolve()
+      .then(() => this.renew(this.lease))
+      .then(nextLease => {
+        if (!nextLease?.leaseId || !nextLease?.expiresAt) {
+          throw new Error('续租响应缺少 leaseId 或 expiresAt');
+        }
+        if (
+          this.lease?.leaseId &&
+          String(nextLease.leaseId) !== String(this.lease.leaseId)
+        ) {
+          throw new Error('续租响应 leaseId 与当前租约不一致');
+        }
+        this.lease = nextLease;
+        this.onRenew(nextLease);
+        return nextLease;
+      })
+      .catch(error => {
+        throw this.markLost(error);
+      })
+      .finally(() => {
+        this.inFlight = null;
+      });
+    return await this.inFlight;
+  }
+
+  assertHealthy() {
+    if (this.lostError) throw this.lostError;
+  }
+
+  markLost(cause) {
+    if (!this.lostError) {
+      const detail = String(cause?.message || cause || '').trim();
+      this.lostError = new PublishLeaseLostError(
+        detail
+          ? `应用发布租约续期失败，已停止后续写入：${detail}`
+          : undefined,
+        cause
+      );
+      try {
+        this.onLost(this.lostError);
+      } catch {
+        // Observability callbacks must not replace the stable safety error.
+      }
+    }
+    return this.lostError;
+  }
+
+  async stop() {
+    if (this.timer) {
+      this.clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.stopped = true;
+    if (this.inFlight) {
+      try {
+        await this.inFlight;
+      } catch {
+        // The caller can inspect the stable error with assertHealthy().
+      }
+    }
+  }
+}
+
+function normalizePositiveInteger(value, fallback) {
+  const numeric = Number(value);
+  return Number.isSafeInteger(numeric) && numeric > 0 ? numeric : fallback;
+}
+
+function createPublishLeaseHeartbeat(options) {
+  return new PublishLeaseHeartbeat(options);
+}
+
+module.exports = {
+  DEFAULT_HEARTBEAT_INTERVAL_MS,
+  DEFAULT_RENEW_WINDOW_MS,
+  PublishLeaseHeartbeat,
+  PublishLeaseLostError,
+  createPublishLeaseHeartbeat,
+};