yidaconnector 2026.6.11

package/scripts/e2e-real/runner.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const BIN = path.join(ROOT, 'bin', 'yida.js');
+const DEFAULT_REGISTRY_DIR = path.join(ROOT, 'project', '.cache', 'e2e-real');
+const DEFAULT_FIELDS_FILE = path.join(__dirname, 'fixtures', 'form-fields.json');
+const DEFAULT_PAGE_SOURCE = path.join(ROOT, 'project', 'pages', 'src', 'demo-compat-smoke.oyd.jsx');
+
+function nowStamp(date = new Date()) {
+  return date.toISOString().replace(/[-:T.Z]/g, '').slice(0, 14);
+}
+
+function getConfig(env = process.env, date = new Date()) {
+  const prefix = env.YIDACONNECTOR_E2E_PREFIX || `OY_E2E_${nowStamp(date)}`;
+  return {
+    enabled: env.YIDACONNECTOR_E2E === '1',
+    missing: env.YIDACONNECTOR_E2E === '1' ? [] : ['YIDACONNECTOR_E2E=1'],
+    prefix,
+    appName: env.YIDACONNECTOR_E2E_APP_NAME || `${prefix}_App`,
+    formName: env.YIDACONNECTOR_E2E_FORM_NAME || `${prefix}_Form`,
+    pageName: env.YIDACONNECTOR_E2E_PAGE_NAME || `${prefix}_Page`,
+    fieldsFile: env.YIDACONNECTOR_E2E_FIELDS_FILE || DEFAULT_FIELDS_FILE,
+    pageSource: env.YIDACONNECTOR_E2E_PAGE_SOURCE || DEFAULT_PAGE_SOURCE,
+    registryDir: env.YIDACONNECTOR_E2E_REGISTRY_DIR || DEFAULT_REGISTRY_DIR,
+    baseUrl: env.YIDACONNECTOR_E2E_BASE_URL,
+    cookiesBase64: env.YIDACONNECTOR_E2E_COOKIES_BASE64,
+    corpId: env.YIDACONNECTOR_E2E_CORP_ID,
+    skipPublish: env.YIDACONNECTOR_E2E_SKIP_PUBLISH === '1',
+  };
+}
+
+function ensureEnabled(config) {
+  if (!config.enabled) {
+    console.log(`Skipping real E2E; missing: ${config.missing.join(', ')}`);
+    return false;
+  }
+  return true;
+}
+
+function decodeCookieData(config) {
+  if (!config.cookiesBase64) {return null;}
+  const raw = Buffer.from(config.cookiesBase64, 'base64').toString('utf8');
+  const parsed = JSON.parse(raw);
+  const cookieData = Array.isArray(parsed) ? { cookies: parsed } : parsed;
+  if (!Array.isArray(cookieData.cookies) || cookieData.cookies.length === 0) {
+    throw new Error('YIDACONNECTOR_E2E_COOKIES_BASE64 must decode to a cookie array or an object with cookies');
+  }
+  cookieData.base_url = config.baseUrl || cookieData.base_url || 'https://www.aliwork.com';
+  return cookieData;
+}
+
+function writeCookieCache(cookieData) {
+  if (!cookieData) {return;}
+  const cacheDir = path.join(ROOT, 'project', '.cache');
+  fs.mkdirSync(cacheDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(cacheDir, 'cookies-public.json'),
+    JSON.stringify(cookieData, null, 2),
+    'utf8'
+  );
+}
+
+function createRegistry(config) {
+  fs.mkdirSync(config.registryDir, { recursive: true });
+  const registry = {
+    runId: config.prefix,
+    startedAt: new Date().toISOString(),
+    status: 'running',
+    targetCorpId: config.corpId || null,
+    resources: [],
+    commands: [],
+  };
+  const registryPath = path.join(config.registryDir, `${config.prefix}.json`);
+  writeRegistry(registryPath, registry);
+  return { registry, registryPath };
+}
+
+function writeRegistry(registryPath, registry) {
+  fs.mkdirSync(path.dirname(registryPath), { recursive: true });
+  fs.writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+}
+
+function addResource(registry, registryPath, resource) {
+  registry.resources.push({
+    createdAt: new Date().toISOString(),
+    ...resource,
+  });
+  writeRegistry(registryPath, registry);
+}
+
+function extractJsonObjects(output) {
+  const text = output || '';
+  const results = [];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] !== '{') {continue;}
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let cursor = index; cursor < text.length; cursor += 1) {
+      const char = text[cursor];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === '\\') {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+      } else if (char === '{') {
+        depth += 1;
+      } else if (char === '}') {
+        depth -= 1;
+        if (depth === 0) {
+          const candidate = text.slice(index, cursor + 1);
+          try {
+            results.push(JSON.parse(candidate));
+          } catch {
+            // Keep scanning; CLI output may contain braces in non-JSON text.
+          }
+          index = cursor;
+          break;
+        }
+      }
+    }
+  }
+  return results;
+}
+
+function parseLastJson(output) {
+  const parsed = extractJsonObjects(output);
+  return parsed.length > 0 ? parsed[parsed.length - 1] : null;
+}
+
+function runCli(args, env = process.env) {
+  console.log(`Running: yidaconnector ${args.join(' ')}`);
+  const result = spawnSync(process.execPath, [BIN, ...args], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    env: {
+      ...env,
+      YIDACONNECTOR_LANG: 'zh',
+      CI: '1',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 120000,
+  });
+  const stdout = result.stdout || '';
+  const stderr = result.stderr || '';
+  if (result.status !== 0) {
+    const details = (stderr.trim() || stdout.trim()).slice(0, 1600);
+    throw new Error(`Command failed: yidaconnector ${args.join(' ')}\n${details}`);
+  }
+  return {
+    stdout,
+    stderr,
+    json: parseLastJson(stdout),
+  };
+}
+
+function requireSuccess(stepName, commandResult) {
+  if (!commandResult.json) {
+    throw new Error(`${stepName} did not emit a JSON result`);
+  }
+  if (commandResult.json.success === false || commandResult.json.status === 'error') {
+    throw new Error(`${stepName} failed: ${JSON.stringify(commandResult.json)}`);
+  }
+  return commandResult.json;
+}
+
+function run(options = {}) {
+  const env = options.env || process.env;
+  const config = options.config || getConfig(env);
+  const executeCli = options.runCli || runCli;
+  const persistCookieCache = options.writeCookieCache || writeCookieCache;
+  const registryFactory = options.createRegistry || createRegistry;
+  const persistRegistry = options.writeRegistry || writeRegistry;
+  const trackResource = options.addResource || addResource;
+
+  if (!ensureEnabled(config)) {
+    return { skipped: true, missing: config.missing };
+  }
+
+  if (!fs.existsSync(config.fieldsFile)) {
+    throw new Error(`E2E fields file not found: ${config.fieldsFile}`);
+  }
+  if (!config.skipPublish && !fs.existsSync(config.pageSource)) {
+    throw new Error(`E2E page source not found: ${config.pageSource}`);
+  }
+
+  persistCookieCache(decodeCookieData(config));
+  const { registry, registryPath } = registryFactory(config);
+
+  function runStep(name, args) {
+    const commandResult = executeCli([...args, '--quiet'], env);
+    registry.commands.push({ name, args, completedAt: new Date().toISOString() });
+    persistRegistry(registryPath, registry);
+    return commandResult;
+  }
+
+  try {
+    requireSuccess('login check', runStep('login', ['login', '--check-only', '--json']));
+    if (config.corpId) {
+      runStep('org-switch', ['org', 'switch', '--corp-id', config.corpId]);
+    }
+    runStep('app-list', ['app-list', '--size', '1']);
+
+    const app = requireSuccess('create app', runStep('create-app', [
+      'create-app',
+      config.appName,
+      '--desc',
+      'YidaConnector real E2E disposable app',
+      '--no-open',
+    ]));
+    trackResource(registry, registryPath, { type: 'app', appType: app.appType, name: config.appName, url: app.url });
+
+    const form = requireSuccess('create form', runStep('create-form', [
+      'create-form',
+      'create',
+      app.appType,
+      config.formName,
+      config.fieldsFile,
+      '--no-open',
+    ]));
+    trackResource(registry, registryPath, { type: 'form', appType: app.appType, formUuid: form.formUuid, name: config.formName, url: form.url });
+
+    requireSuccess('get schema', runStep('get-schema', ['get-schema', app.appType, form.formUuid, '--json']));
+    requireSuccess('query data', runStep('query-data', ['data', 'query', 'form', app.appType, form.formUuid, '--size', '1']));
+
+    if (!config.skipPublish) {
+      const page = requireSuccess('create page', runStep('create-page', [
+        'create-page',
+        app.appType,
+        config.pageName,
+        '--mode',
+        'dashboard',
+        '--no-open',
+      ]));
+      trackResource(registry, registryPath, { type: 'page', appType: app.appType, pageId: page.pageId, name: config.pageName, url: page.url });
+      requireSuccess('publish page', runStep('publish', [
+        'publish',
+        config.pageSource,
+        app.appType,
+        page.pageId,
+        '--health-check',
+        '--no-open',
+      ]));
+    }
+
+    registry.status = 'passed';
+    registry.finishedAt = new Date().toISOString();
+    persistRegistry(registryPath, registry);
+    console.log(`Real E2E passed. Registry: ${registryPath}`);
+    return { skipped: false, registryPath, registry };
+  } catch (error) {
+    registry.status = 'failed';
+    registry.finishedAt = new Date().toISOString();
+    registry.error = error.message;
+    persistRegistry(registryPath, registry);
+    throw error;
+  }
+}
+
+if (require.main === module) {
+  try {
+    run();
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  addResource,
+  createRegistry,
+  decodeCookieData,
+  extractJsonObjects,
+  getConfig,
+  parseLastJson,
+  run,
+  runCli,
+  writeRegistry,
+  writeCookieCache,
+};

package/scripts/e2e-real/skill-coverage.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SKILLS_DIR = path.join(ROOT, 'yida-skills', 'skills');
+
+const SKILL_COVERAGE = {
+  'large-file-write': { level: 'offline', tests: ['write fixture generation uses fs APIs in runner tests'] },
+  'sls-log-workbench': { level: 'offline-unit', tests: ['skill metadata and packaging validation'], reason: 'internal support-only SLS tooling is guarded by passphrase and corp whitelist; shared real E2E must not query production logs' },
+  'yida-app': { level: 'real-e2e', stages: ['app', 'form', 'page', 'data', 'report', 'dashboard'] },
+  'yida-app-permission': { level: 'offline-unit', tests: ['tests/app-permission.test.js'], reason: 'app admin mutations affect real application access; shared real E2E only validates safe read paths' },
+  'yida-basic-info': { level: 'offline-unit', tests: ['tests/basic-info.test.js'], reason: 'basic-info reads org admin metadata and can update domains; unit coverage avoids mutating shared real org settings' },
+  'yida-business-rule': { level: 'opt-in', reason: 'business association rules mutate form event configuration; validate in a dedicated real-form/UI stage before adding to deterministic shared E2E' },
+  'yida-chart': { level: 'real-e2e', stages: ['report', 'dashboard'], tests: ['report chart config generation'] },
+  'yida-connector': { level: 'offline', stages: ['connector-local'], commands: ['connector gen-template', 'connector parse-api'] },
+  'yida-connector-safe-actions': { level: 'offline', stages: ['connector-local'], commands: ['connector parse-api', 'connector test --action <operationId>'], reason: 'skill documents conservative HTTP connector action generation and repair workflow; shared E2E should validate local parsing without mutating tenant connectors' },
+  'yida-corp-efficiency': { level: 'offline-unit', tests: ['tests/corp-efficiency.test.js'], reason: 'enterprise efficiency queries and notify mutations are not safe for shared real org E2E' },
+  'yida-corp-manager': { level: 'offline-unit', tests: ['tests/corp-manager.test.js'], reason: 'enterprise admin mutations are not safe for shared real org E2E' },
+  'yida-create-app': { level: 'real-e2e', stages: ['app'], commands: ['create-app'] },
+  'yida-create-form-page': { level: 'real-e2e', stages: ['form'], commands: ['create-form create', 'create-form update', 'create-form add-option'] },
+  'yida-create-page': { level: 'real-e2e', stages: ['page', 'dashboard'], commands: ['create-page --mode dashboard'] },
+  'yida-create-process': { level: 'opt-in-real-e2e', stages: ['process'], commands: ['create-process --formUuid'], reason: 'process stage mutates workflow definitions and is excluded from default full E2E unless explicitly requested' },
+  'yida-custom-page': { level: 'real-e2e', stages: ['page'], commands: ['check-page', 'build-page', 'compile', 'publish'] },
+  'yida-dashboard': { level: 'real-e2e', stages: ['dashboard'], commands: ['create-page --mode dashboard', 'publish dashboard skill page'] },
+  'yida-data-source-connectors': { level: 'offline-unit', tests: ['skill metadata and packaging validation'], reason: 'skill defines a page Schema/dataSource authoring guardrail; real connector execution mutates tenant-specific connector/data source configuration and should be validated in dedicated page publish scenarios' },
+  'yida-data-management': { level: 'real-e2e', stages: ['data', 'task'], commands: ['data create/query/update form', 'data query tasks'] },
+  'yida-db-seq-fix': { level: 'offline-unit', tests: ['tests/db-seq-fix.test.js'], reason: 'PostgreSQL admin repair is not safe for shared real org E2E' },
+  'yida-density': { level: 'offline-unit', tests: ['sample/check-page coverage'], reason: 'visual density template is validated through page build/lint rather than real data mutation' },
+  'yida-export-conversation': { level: 'offline-unit', tests: ['conversation exporter unit coverage'], reason: 'depends on local conversation artifacts, not Yida API' },
+  'yida-flash-note-to-prd': { level: 'opt-in', stages: ['ai'], commands: ['flash-to-prd'], reason: 'remote AI service can timeout; excluded from deterministic default full run' },
+  'yida-form-detail': { level: 'offline-unit', reason: 'form detail styling skill has no standalone CLI command yet' },
+  'yida-form-permission': { level: 'real-e2e', stages: ['permission'], commands: ['get-permission'] },
+  'yida-formula': { level: 'offline', stages: ['offline'], commands: ['formula evaluate'] },
+  'yida-formula-evaluate': { level: 'offline', stages: ['offline'], commands: ['formula evaluate --json'] },
+  'yida-get-schema': { level: 'real-e2e', stages: ['form'], commands: ['get-schema', 'get-schema --all', 'get-schema --field'] },
+  'yida-i18n': { level: 'offline-unit', tests: ['tests/i18n-management.test.js'], reason: 'multilingual management writes app language config and copy entries; shared real E2E should only run read-only overview on dedicated intl apps' },
+  'yida-integration': { level: 'opt-in', reason: 'creates backend automation flows; should run in a separate integration stage with cleanup/audit controls' },
+  'yida-agent-center': { level: 'offline-unit', tests: ['tests/agent-center.test.js'], reason: 'process delegation mutates real user-agent relationships; shared real E2E must avoid changing organization delegation settings' },
+  'yida-login': { level: 'real-e2e', stages: ['auth'], commands: ['login --check-only --json'] },
+  'yida-logout': { level: 'offline-unit', tests: ['login/auth unit coverage'], reason: 'real logout would destroy the shared E2E session' },
+  'yida-nav-group': { level: 'offline-unit', tests: ['tests/nav-group.test.js'], reason: 'navigation grouping mutates app sidebar order; unit coverage validates payloads and tree operations until a dedicated cleanup-safe nav stage exists' },
+  'yida-page-config': { level: 'real-e2e', stages: ['share'], commands: ['get-page-config', 'verify-short-url', 'save-share-config'] },
+  'yida-ppt': { level: 'deprecated', reason: 'skill is deprecated in favor of yida-ppt-slider' },
+  'yida-ppt-slider': { level: 'offline-unit', reason: 'presentation-style custom page skill should be validated by page generation/check-page fixtures' },
+  'yida-process-rule': { level: 'opt-in-real-e2e', stages: ['process'], commands: ['configure-process'], reason: 'process stage publishes workflow rules on the disposable E2E form and is excluded from default full E2E unless explicitly requested' },
+  'yida-publish-page': { level: 'real-e2e', stages: ['page', 'dashboard'], commands: ['publish --health-check'] },
+  'yida-report': { level: 'real-e2e', stages: ['report'], commands: ['create-report', 'append-chart'] },
+  'yida-table-form': { level: 'offline-unit', reason: 'table-form custom page template should be validated with check-page fixture before real publish stage is added' },
+  'yida-voc': { level: 'offline-unit', reason: 'VOC formatting skill is local text transformation, not Yida API mutation' },
+};
+
+function listSkillNames(skillsDir = SKILLS_DIR) {
+  return fs.readdirSync(skillsDir)
+    .filter((name) => fs.statSync(path.join(skillsDir, name)).isDirectory())
+    .sort();
+}
+
+function validateSkillCoverage(options = {}) {
+  const skillsDir = options.skillsDir || SKILLS_DIR;
+  const coverage = options.coverage || SKILL_COVERAGE;
+  const skillNames = options.skillNames || listSkillNames(skillsDir);
+  const missing = skillNames.filter((name) => !coverage[name]);
+  const extra = Object.keys(coverage).filter((name) => !skillNames.includes(name)).sort();
+  const invalid = Object.entries(coverage)
+    .filter(([, entry]) => !entry || !entry.level)
+    .map(([name]) => name);
+
+  return {
+    ok: missing.length === 0 && extra.length === 0 && invalid.length === 0,
+    checked: skillNames.length,
+    missing,
+    extra,
+    invalid,
+    coverage,
+  };
+}
+
+function run(options = {}) {
+  const result = validateSkillCoverage(options);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`Skill E2E coverage: checked ${result.checked} skills`);
+    for (const name of Object.keys(result.coverage).sort()) {
+      const entry = result.coverage[name];
+      console.log(`- ${name}: ${entry.level}`);
+    }
+  }
+
+  if (!result.ok) {
+    if (!options.json) {
+      if (result.missing.length) {console.error(`Missing coverage: ${result.missing.join(', ')}`);}
+      if (result.extra.length) {console.error(`Coverage entries without skill: ${result.extra.join(', ')}`);}
+      if (result.invalid.length) {console.error(`Invalid coverage entries: ${result.invalid.join(', ')}`);}
+    }
+    process.exit(1);
+  }
+
+  return result;
+}
+
+if (require.main === module) {
+  run({ json: process.argv.includes('--json') });
+}
+
+module.exports = {
+  SKILL_COVERAGE,
+  listSkillNames,
+  run,
+  validateSkillCoverage,
+};

package/scripts/generate-command-docs.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { COMMAND_GROUPS } = require('../lib/core/command-manifest');
+const en = require('../lib/core/locales/en');
+
+const ROOT = path.resolve(__dirname, '..');
+const README_FILE = path.join(ROOT, 'README.md');
+const START = '<!-- YIDACONNECTOR_COMMANDS_START -->';
+const END = '<!-- YIDACONNECTOR_COMMANDS_END -->';
+
+function getByPath(object, keyPath) {
+  return String(keyPath || '').split('.').reduce((current, key) => {
+    if (!current || typeof current !== 'object') {
+      return undefined;
+    }
+    return current[key];
+  }, object);
+}
+
+function translate(key) {
+  return getByPath(en, key) || key;
+}
+
+function escapeTableCell(value) {
+  return String(value || '')
+    .replace(/\|/g, '\\|')
+    .replace(/\n/g, '<br>');
+}
+
+function commandRow(entry) {
+  return `| \`yidaconnector ${escapeTableCell(entry.usage)}\` | ${escapeTableCell(translate(entry.descriptionKey))} |`;
+}
+
+function renderGroup(group) {
+  const commands = group.commands.filter(entry => !entry.hidden);
+  if (commands.length === 0) {
+    return '';
+  }
+
+  return [
+    `### ${translate(group.titleKey)}`,
+    '',
+    '| Command | Description |',
+    '|---------|-------------|',
+    ...commands.map(commandRow),
+    '',
+  ].join('\n');
+}
+
+function renderCommandDocs() {
+  return [
+    START,
+    '<!-- This section is generated by `npm run docs:commands`. Do not edit command rows by hand. -->',
+    '',
+    ...COMMAND_GROUPS.map(renderGroup).filter(Boolean),
+    END,
+  ].join('\n');
+}
+
+function replaceGeneratedBlock(readme, generated) {
+  const startIndex = readme.indexOf(START);
+  const endIndex = readme.indexOf(END);
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    return readme.slice(0, startIndex) + generated + readme.slice(endIndex + END.length);
+  }
+
+  const anchor = 'Run `yidaconnector --help` or `yidaconnector <command> --help` for detailed usage.\n';
+  const anchorIndex = readme.indexOf(anchor);
+  if (anchorIndex === -1) {
+    throw new Error('README CLI reference anchor not found');
+  }
+
+  const insertIndex = anchorIndex + anchor.length;
+  return `${readme.slice(0, insertIndex)}\n${generated}\n${readme.slice(insertIndex)}`;
+}
+
+function run() {
+  const args = process.argv.slice(2);
+  const checkOnly = args.includes('--check');
+  const printOnly = args.includes('--print');
+  const generated = renderCommandDocs();
+
+  if (printOnly) {
+    process.stdout.write(generated + '\n');
+    return;
+  }
+
+  const current = fs.readFileSync(README_FILE, 'utf8');
+  const next = replaceGeneratedBlock(current, generated);
+
+  if (checkOnly) {
+    if (next !== current) {
+      console.error('README command docs are out of date. Run `npm run docs:commands`.');
+      process.exit(1);
+    }
+    console.log('README command docs OK');
+    return;
+  }
+
+  fs.writeFileSync(README_FILE, next);
+  console.log('Updated README command docs');
+}
+
+run();

package/scripts/nightly-smoke.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const BIN = path.join(ROOT, 'bin', 'yida.js');
+const BASE_REQUIRED_ENV = [
+  'YIDACONNECTOR_SMOKE_COOKIES_BASE64',
+  'YIDACONNECTOR_SMOKE_APP_TYPE',
+];
+
+function getSmokeConfig(env = process.env) {
+  const missing = BASE_REQUIRED_ENV.filter((name) => !env[name]);
+  const hasFormSmoke = Boolean(env.YIDACONNECTOR_SMOKE_FORM_UUID);
+  const hasPageSmoke = Boolean(env.YIDACONNECTOR_SMOKE_PAGE_UUID);
+  if (!hasFormSmoke && !hasPageSmoke) {
+    missing.push('YIDACONNECTOR_SMOKE_FORM_UUID or YIDACONNECTOR_SMOKE_PAGE_UUID');
+  }
+  if (env.YIDACONNECTOR_SMOKE_PAGE_SOURCE && !hasPageSmoke) {
+    missing.push('YIDACONNECTOR_SMOKE_PAGE_UUID');
+  }
+  return {
+    missing,
+    appType: env.YIDACONNECTOR_SMOKE_APP_TYPE,
+    formUuid: env.YIDACONNECTOR_SMOKE_FORM_UUID,
+    pageUuid: env.YIDACONNECTOR_SMOKE_PAGE_UUID,
+    pageSource: env.YIDACONNECTOR_SMOKE_PAGE_SOURCE,
+  };
+}
+
+function hasRequiredConfig(env = process.env) {
+  const { missing } = getSmokeConfig(env);
+  if (missing.length > 0) {
+    console.log(`Skipping real-environment smoke; missing: ${missing.join(', ')}`);
+    return false;
+  }
+  return true;
+}
+
+function decodeCookieData(env = process.env) {
+  const raw = Buffer.from(env.YIDACONNECTOR_SMOKE_COOKIES_BASE64, 'base64').toString('utf8');
+  const parsed = JSON.parse(raw);
+  const cookieData = Array.isArray(parsed) ? { cookies: parsed } : parsed;
+  if (!Array.isArray(cookieData.cookies) || cookieData.cookies.length === 0) {
+    throw new Error('YIDACONNECTOR_SMOKE_COOKIES_BASE64 must decode to a cookie array or an object with cookies');
+  }
+  cookieData.base_url = env.YIDACONNECTOR_SMOKE_BASE_URL || cookieData.base_url || 'https://www.aliwork.com';
+  return cookieData;
+}
+
+function writeCookieCache(cookieData) {
+  const cacheDir = path.join(ROOT, 'project', '.cache');
+  fs.mkdirSync(cacheDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(cacheDir, 'cookies-public.json'),
+    JSON.stringify(cookieData, null, 2),
+    'utf8'
+  );
+}
+
+function runCli(args, env = process.env) {
+  console.log(`Running: yidaconnector ${args.join(' ')}`);
+  const result = spawnSync(process.execPath, [BIN, ...args], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    env: {
+      ...env,
+      YIDACONNECTOR_LANG: 'zh',
+      CI: '1',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 60000,
+  });
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    const stdout = (result.stdout || '').trim();
+    const details = (stderr || stdout).slice(0, 1000);
+    throw new Error(`Command failed: yidaconnector ${args.join(' ')}\n${details}`);
+  }
+  const outputLength = (result.stdout || '').trim().length;
+  console.log(`OK: yidaconnector ${args[0]} (${outputLength} stdout chars)`);
+}
+
+function run(options = {}) {
+  const env = options.env || process.env;
+  const executeCli = options.runCli || runCli;
+  const persistCookieCache = options.writeCookieCache || writeCookieCache;
+  if (!hasRequiredConfig(env)) {
+    return;
+  }
+
+  const config = getSmokeConfig(env);
+  const cookieData = decodeCookieData(env);
+  persistCookieCache(cookieData);
+
+  executeCli(['login', '--check-only'], env);
+  executeCli(['app-list', '--size', '1'], env);
+
+  if (config.pageUuid) {
+    executeCli(['get-schema', config.appType, config.pageUuid], env);
+    if (config.pageSource) {
+      executeCli(['publish', config.pageSource, config.appType, config.pageUuid, '--health-check', '--no-open'], env);
+    }
+  }
+
+  if (config.formUuid) {
+    executeCli(['get-schema', config.appType, config.formUuid], env);
+    executeCli(['data', 'query', 'form', config.appType, config.formUuid, '--size', '1'], env);
+  }
+
+  console.log('Nightly real-environment smoke passed');
+}
+
+if (require.main === module) {
+  try {
+    run();
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  decodeCookieData,
+  getSmokeConfig,
+  hasRequiredConfig,
+  run,
+  runCli,
+  writeCookieCache,
+};