@wix/agent-skills 1.15.1 → 1.16.0

package/skills/wix-replatform/lib/orchestration-preflight.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const path = require('node:path');
+const { statEnvKeys } = require('./config-env.js');
+
+const SCHEMA_VERSION = 1;
+
+const SOURCE_CONFIG_BY_PLATFORM = {
+  wordpress: ['WP_BASE_URL'],
+  woocommerce: ['WP_BASE_URL'],
+  shopify: ['SHOPIFY_STORE_URL'],
+  // CSV is a file-provided flow: source.csv.env holds only optional
+  // delimiter/encoding/vendor/rewrite hints, so no key is required. The
+  // files_only branch above enforces fileInputPaths instead.
+  csv: [],
+};
+
+function makeCheck(id, label, status, message, details = {}) {
+  return { id, label, status, message, ...details };
+}
+
+async function defaultProbeWixCli() {
+  return { available: false, authState: 'unknown', reason: 'no probe configured' };
+}
+
+function configFileForPlatform(projectDir, platform) {
+  return path.join(projectDir, 'config', `source.${platform}.env`);
+}
+
+async function runPreflight(projectDir, artifacts, options = {}) {
+  const probeWixCli = options.probeWixCli || defaultProbeWixCli;
+  const progress = options.progress || null;
+  const checks = [];
+  const decisions = artifacts.decisions || {};
+  const sourceMode = decisions.sourceMode && decisions.sourceMode.value;
+  const sourcePlatform = decisions.sourcePlatform && decisions.sourcePlatform.value;
+  const deliveryMode = decisions.deliveryMode && decisions.deliveryMode.value;
+  const targetSiteStrategy = decisions.targetSiteStrategy && decisions.targetSiteStrategy.value;
+  const fileInputPaths = decisions.fileInputPaths && decisions.fileInputPaths.value;
+  const credentialRef = decisions.sourceCredentialRef && decisions.sourceCredentialRef.value;
+
+  checks.push(
+    sourceMode
+      ? makeCheck('source_mode', 'Source acquisition mode', 'pass', `sourceMode=${sourceMode}`)
+      : makeCheck('source_mode', 'Source acquisition mode', 'blocked', 'sourceMode decision is missing'),
+  );
+  progress?.progress('Checked source acquisition mode', { phase: 'preflight', step: 'source-mode' });
+
+  if (sourceMode === 'private_data' || sourceMode === 'authenticated_api') {
+    checks.push(
+      credentialRef
+        ? makeCheck('source_credentials', 'Source credential reference', 'pass', 'credential reference present')
+        : makeCheck('source_credentials', 'Source credential reference', 'blocked', 'private/authenticated mode requires sourceCredentialRef'),
+    );
+    progress?.progress('Checked source credential reference', { phase: 'preflight', step: 'source-credentials' });
+  }
+
+  if (sourceMode === 'files_only' || (decisions.includeAdditionalFiles && decisions.includeAdditionalFiles.value === true)) {
+    const files = Array.isArray(fileInputPaths) ? fileInputPaths : [];
+    checks.push(
+      files.length > 0
+        ? makeCheck('file_inputs', 'Input files', 'pass', `${files.length} file input path(s) recorded`)
+        : makeCheck('file_inputs', 'Input files', 'blocked', 'file-based flow requires fileInputPaths'),
+    );
+    progress?.progress('Checked file inputs', { phase: 'preflight', step: 'file-inputs' });
+  }
+
+  checks.push(
+    deliveryMode
+      ? makeCheck('delivery_mode', 'Delivery mode', 'pass', `deliveryMode=${deliveryMode}`)
+      : makeCheck('delivery_mode', 'Delivery mode', 'blocked', 'deliveryMode decision is missing'),
+  );
+  checks.push(
+    targetSiteStrategy
+      ? makeCheck('target_site_strategy', 'Target site strategy', 'pass', `targetSiteStrategy=${targetSiteStrategy}`)
+      : makeCheck('target_site_strategy', 'Target site strategy', 'blocked', 'targetSiteStrategy decision is missing'),
+  );
+  progress?.progress('Checked delivery and target site decisions', { phase: 'preflight', step: 'target-decisions' });
+
+  const wixEnv = await statEnvKeys(path.join(projectDir, 'config', 'wix.env'), ['WIX_SITE_STRATEGY', 'WIX_SITE_ID', 'WIX_AUTH_TOKEN']);
+  checks.push(makeCheck('wix_env', 'Wix config file', wixEnv.exists ? 'pass' : 'blocked', wixEnv.exists ? 'wix.env exists' : 'wix.env is missing', { keyStatus: wixEnv.keys }));
+  progress?.progress('Checked Wix config file', { phase: 'preflight', step: 'wix-env' });
+
+  if (targetSiteStrategy === 'existing_site') {
+    const siteIdStatus = wixEnv.keys.WIX_SITE_ID;
+    checks.push(
+      siteIdStatus === 'present'
+        ? makeCheck('wix_site_id', 'Existing site id', 'pass', 'WIX_SITE_ID present')
+        : makeCheck('wix_site_id', 'Existing site id', 'blocked', `WIX_SITE_ID is ${siteIdStatus}`),
+    );
+    progress?.progress('Checked existing Wix site id', { phase: 'preflight', step: 'wix-site-id' });
+  }
+
+  if (sourcePlatform) {
+    const requiredSourceKeys = SOURCE_CONFIG_BY_PLATFORM[sourcePlatform] || [];
+    if (requiredSourceKeys.length > 0) {
+      const sourceEnv = await statEnvKeys(configFileForPlatform(projectDir, sourcePlatform), requiredSourceKeys);
+      const allGood = Object.values(sourceEnv.keys).every((status) => status === 'present');
+      checks.push(
+        makeCheck(
+          'source_env',
+          'Source config file',
+          allGood ? 'pass' : 'blocked',
+          sourceEnv.exists ? `checked source.${sourcePlatform}.env` : `source.${sourcePlatform}.env is missing`,
+          { keyStatus: sourceEnv.keys },
+        ),
+      );
+      progress?.progress(`Checked source ${sourcePlatform} config file`, { phase: 'preflight', step: 'source-env', entity: sourcePlatform });
+    }
+  }
+
+  progress?.progress('Wix CLI probe started', { phase: 'preflight', step: 'wix-cli' });
+  const wixCli = progress
+    ? await progress.withHeartbeat({ phase: 'preflight', step: 'wix-cli', message: 'Still probing Wix CLI' }, probeWixCli)
+    : await probeWixCli();
+  checks.push(
+    wixCli.available
+      ? makeCheck('wix_cli_available', 'Wix CLI availability', 'pass', 'Wix CLI probe succeeded', { cli: wixCli })
+      : makeCheck('wix_cli_available', 'Wix CLI availability', 'blocked', wixCli.reason || 'Wix CLI probe failed', { cli: wixCli }),
+  );
+  checks.push(
+    wixCli.authState === 'authenticated'
+      ? makeCheck('wix_cli_auth', 'Wix CLI auth state', 'pass', 'Wix CLI is authenticated', { cli: wixCli })
+      : makeCheck('wix_cli_auth', 'Wix CLI auth state', 'blocked', wixCli.reason || 'Wix CLI auth could not be confirmed', { cli: wixCli }),
+  );
+  progress?.progress('Checked Wix CLI availability and auth', { phase: 'preflight', step: 'wix-cli' });
+
+  const blocked = checks.filter((check) => check.status === 'blocked');
+  const failed = checks.filter((check) => check.status === 'failed');
+  const status = failed.length > 0 ? 'failed' : blocked.length > 0 ? 'blocked' : 'pass';
+
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    status,
+    updatedAt: new Date().toISOString(),
+    checks,
+  };
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  runPreflight,
+};

package/skills/wix-replatform/lib/orchestration-router.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { validateArtifacts } = require('./orchestration-state.js');
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+async function determineNextStep(projectDir, artifacts) {
+  const validation = validateArtifacts(artifacts);
+  if (!validation.ok) {
+    return {
+      ok: false,
+      nextState: 'failed',
+      nextResource: null,
+      reason: 'invalid_orchestration_artifacts',
+      errors: validation.errors,
+    };
+  }
+
+  const decisions = artifacts.decisions || {};
+  const approvals = artifacts.approvals || {};
+  const sourceUrl = decisions.sourceUrl && decisions.sourceUrl.value;
+  const sourceMode = decisions.sourceMode && decisions.sourceMode.value;
+  const fileInputPaths = decisions.fileInputPaths && decisions.fileInputPaths.value;
+  const hasFileInputs = Array.isArray(fileInputPaths) && fileInputPaths.length > 0;
+  const deliveryMode = decisions.deliveryMode && decisions.deliveryMode.value;
+  const targetSiteStrategy = decisions.targetSiteStrategy && decisions.targetSiteStrategy.value;
+  const preflight = artifacts.preflight || null;
+
+  // A file-provided run (e.g. platform=csv) has no source URL to probe; its
+  // input files stand in for one. URL-based runs are unaffected: they never
+  // carry sourceMode=files_only, so they still fall through to the checks below
+  // in the original order.
+  if (sourceMode === 'files_only') {
+    if (!hasFileInputs) {
+      return { ok: true, nextState: 'awaiting_files', nextResource: null, reason: 'missing_file_inputs' };
+    }
+  } else if (!sourceUrl && !hasFileInputs) {
+    return { ok: true, nextState: 'awaiting_source', nextResource: null, reason: 'missing_source_url' };
+  }
+  if (!sourceMode) {
+    return { ok: true, nextState: 'awaiting_import_scope', nextResource: null, reason: 'missing_source_mode' };
+  }
+  if (!deliveryMode || !targetSiteStrategy) {
+    return { ok: true, nextState: 'awaiting_destination_strategy', nextResource: null, reason: 'missing_destination_strategy' };
+  }
+
+  if (!preflight || !preflight.status || preflight.status === 'not_started') {
+    return { ok: true, nextState: 'preflight_running', nextResource: null, reason: 'preflight_missing' };
+  }
+  if (preflight.status === 'blocked') {
+    return { ok: true, nextState: 'preflight_blocked', nextResource: null, reason: 'preflight_blocked' };
+  }
+  if (preflight.status === 'failed') {
+    return { ok: false, nextState: 'failed', nextResource: null, reason: 'preflight_failed', errors: [] };
+  }
+
+  if (!(await exists(path.join(projectDir, 'source-schema.json')))) {
+    return { ok: true, nextState: 'discovery_running', nextResource: 'resources/rp-discovery/', reason: 'missing_source_schema' };
+  }
+
+  if (!(await exists(path.join(projectDir, 'mapping', 'mapping-plan.json')))) {
+    return { ok: true, nextState: 'mapping_running', nextResource: 'resources/rp-mapper/', reason: 'missing_mapping_plan' };
+  }
+
+  if (approvals.mapping && approvals.mapping.status === 'pending') {
+    return { ok: true, nextState: 'awaiting_mapping_approval', nextResource: null, reason: 'mapping_approval_pending' };
+  }
+
+  if (!(await exists(path.join(projectDir, 'setup', 'setup-plan.json')))) {
+    return { ok: true, nextState: 'setup_discovery_running', nextResource: 'resources/rp-setup-discovery/', reason: 'missing_setup_plan' };
+  }
+
+  if (!(await exists(path.join(projectDir, 'execution', 'execution-manifest.json')))) {
+    return { ok: true, nextState: 'codegen_running', nextResource: 'resources/rp-import-codegen/', reason: 'missing_execution_manifest' };
+  }
+
+  // Sample-preview sub-gate: codegen emits the extractor, runs it in sample
+  // mode, and records the user's validation in preview/preview-result.json.
+  // Routing back into codegen while that is missing or pending is what enforces
+  // the gate — the artifact is stage-local, so no orchestration phase or
+  // schema change is involved. Projects that do not use the gate simply never
+  // create the file and are unaffected.
+  const previewResult = await readJson(path.join(projectDir, 'preview', 'preview-result.json'));
+  if (previewResult && previewResult.status === 'pending') {
+    return { ok: true, nextState: 'codegen_running', nextResource: 'resources/rp-import-codegen/', reason: 'sample_preview_pending' };
+  }
+
+  if (approvals.execution && approvals.execution.status === 'pending') {
+    return { ok: true, nextState: 'awaiting_execution_approval', nextResource: null, reason: 'execution_approval_pending' };
+  }
+
+  if (!(await exists(path.join(projectDir, 'setup', 'setup-verification.json')))) {
+    return { ok: true, nextState: 'executing_setup', nextResource: 'resources/rp-execute-setup/', reason: 'missing_setup_verification' };
+  }
+
+  if (!(await exists(path.join(projectDir, 'execution', 'completion-report.json')))) {
+    return { ok: true, nextState: 'executing_import', nextResource: 'resources/rp-execute-import/', reason: 'missing_completion_report' };
+  }
+
+  return { ok: true, nextState: 'completed', nextResource: null, reason: 'completion_report_present' };
+}
+
+module.exports = {
+  determineNextStep,
+};