AutoGineer
Generated banner for Wix Replatform
Generated logo for Wix Replatform

Wix Replatform

WixOfficialPublished by Wix

  • Skill
  • Workflow
  • Automation and integrations
  • MIT
  • Low risk
  • Has scripts
Download ZIP

From the author

Routes RePlatform source-to-Wix migrations to the next required workflow module by inspecting authoritative migration artifacts. Use when starting, resuming, or recovering a migration run.
— the description by Wix

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

wix-replatform acts as a central supervisor for migrating data and content to Wix. It does not perform migration tasks directly but instead inspects migration artifacts to determine the next required stage in the pipeline. By maintaining a deterministic state, it ensures that migrations can be started, resumed, or recovered reliably without duplicating work or creating redundant destination sites. It manages the flow through various phases including discovery, mapping, setup, and import, while enforcing strict validation and approval gates.

What it does

  • Routes migration tasks to appropriate sub-modules based on current project state.
  • Ensures resumability by tracking migration progress through authoritative artifacts.
  • Enforces mandatory approval gates before performing write operations.
  • Dispatches specialized subagents for specific tasks to maintain context boundaries.
  • Validates artifacts at each stage to prevent proceeding with corrupted or stale data.
  • Handles reruns for incremental data updates without re-scaffolding the entire project.

When to use it

  • When initiating a new migration from an external source to a Wix site.
  • When resuming a migration that was interrupted or stopped.
  • When recovering from a failed migration stage by addressing specific errors.
  • When performing incremental imports to sync new or modified records after an initial migration.

Advantages

  • Prevents data duplication by enforcing idempotent write operations.
  • Maintains a clear audit trail through structured telemetry and completion reports.
  • Reduces risk by requiring explicit approvals before critical setup or import steps.
  • Supports both standard interactive flows and automated 1-click execution modes.

Usage examples

“Start a new migration for my project in ./migrations/my-store.”
The agent resolves the project directory, initializes orchestration artifacts, and routes to the project intake module.
“Resume the migration in ./migrations/my-store.”
The agent inspects the existing artifacts, determines the last completed stage, and dispatches the next required module.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/wix/wix-replatform-fya3/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip wix-replatform.zip -d .agents/skills

Documentation by Wix

wix-replatform

wix-replatform is the compact supervisor for a resumable source-to-Wix migration. It selects one internal module for the active stage; it does not carry every stage procedure in its own context.

Always-active contract

  • Resolve the active project under migrations/<project>/ (or REPLATFORM_MIGRATIONS_DIR) before inspecting or creating anything. Only that project's artifacts are authoritative.

  • Preserve EXPECTATIONS.md at that project root. It is the user's free-form record of how they expected the run to behave; initialization creates it once and never overwrites it.

  • Start/resume resources/rp-telemetry/ at the beginning of every run and finalize it at a terminal state. Never hand-write telemetry events.

  • Use orchestration JSON plus validated stage artifacts as resume authority. Logs and chat history are diagnostic context only.

  • Preserve user data: write idempotently, dedupe by source identity, resume rather than restart, and never create a second destination site for a migration.

  • Never print secrets, secret-bearing config contents, tokens, or credentials. Report only key names and present/blank/missing status.

  • Do not declare a migration complete from prose or a single artifact. The deterministic router and aggregate completion artifact own terminal completion.

  • Preserve the owner's cutover handoff: unresolved data, applicable manual setup, missing apps and changed plugin behavior. Reconcile discovery, mapping decisions, setup receipts and final outcomes; imported records alone do not establish working functionality. The producing resources own this guidance and durable completion/handoff artifacts. Use a supported cutover publisher when available; report missing publication integration explicitly rather than claiming the application received local artifacts.

CLI-launched runs and human actions

When a migration is started through replatform, the terminal is deliberately non-interactive: do not use an agent question UI, ask for stdin, or wait for a person in the current agent turn. The runner owns process lifecycle and emits only observed events; it does not replace this skill's router or completion receipts.

When a human choice, review, approval, or manual prerequisite is needed, create a durable request with node skills/wix-replatform/scripts/user-action.js create --project <projectDir> --request-file <request.json>, then end the turn. Put only reviewed artifact paths in the request. The person can later use replatform requests, replatform show, and replatform answer; a resumed agent reads the answered request from orchestration/user-actions/, never from reconstructed chat context.

Cancellation is not completion. If the runner has recorded cancel_requested, canceled, interrupted or an explicit stop (blocked, transition --status blocked --resume-from '<json>'; routes run_blocked until explicit resume or --status running, never answer --continue), preserve partial/recovery artifacts and let a later explicit replatform resume route recovery. Never create aggregate migration completion from an aborted execution report.

Pipeline

intake → destination → source inputs → preflight → (standard: discovery → mapping → codegen;
quick: adapter preflight → quick plan) → setup discovery → website handoff
→ safety review/approval → setup → import
→ storefront continuation (website only) → aggregate finalization → Migration review

Delivery modes are management (backend only), website (frontend only), and management_and_website (the integrated flow above). Accept user input both as management_and_website and persist the canonical value.

For deliveryMode=management, aggregate finalization requires valid backend import accounting. For deliveryMode=management_and_website, it additionally requires a current website/completion.json with completed screenshot review, no unresolved critical/high gaps, and release evidence. execution/completion-report.json is backend accounting, never website-migration completion by itself.

Route before acting

On every new or resumed turn:

  1. Resolve the project and initialize/load its orchestration artifacts.

  2. Run node skills/wix-replatform/scripts/orchestration-route.js <projectDir>.

  3. Dispatch the nextResource to a Developer subagent instead of loading and following it yourself. Give it the project directory and the resource to run; it follows that resource's contract exactly as written, unchanged. Read back only its result — never its transcript, tool output, or logs.

    • Every dispatch (Developer or QA) is a fresh subagent, never a resumed one; pass only a handoff file and stay within a context budget — follow resources/rp-subagent-dispatch/. Never read state/attempts/write-attempts.ndjson raw; use scripts/write-log-summary.js.

    • A Developer may fan out to sub-subagents only for harmless read-only work with no shared state, and only if the host supports it; writes stay one at a time, as each resource says.

  4. Dispatch a QA subagent to check the Developer's result against that resource's own stated required outputs (its own "artifacts to create or update" or "## Output" section, and any review/gap documents it defines). QA is read-only — it never writes or calls Wix. If something's missing, dispatch a new Developer for the same resource with QA's findings; otherwise the stage is done.

  5. At the end of each pipeline phase (discovery, mapping, setup discovery, import, and so on — see the pipeline above; a phase spans several resource-level stages), dispatch a QA subagent to review that phase's documents as a whole (for example mapping/review/mapping-summary.md and mapping-gaps.json, or execution/completion-report.json) before routing to the next phase. This catches anything a single per-task check could miss. For the import phase specifically, this review must be entity-by-entity against the accepted mapping plan, not a skim of the top-level status string — see rp-execute-import's "Entity-by-entity QA" section. Any run-fixing dispatch mid-phase (a crash fix, a slowness fix, a resumed pass) does not itself satisfy this; run the phase-level QA again once the fix lands, since fixing one entity's defect certifies nothing about its neighbors. Mapping QA also checks exact source coverage, decided operation/path semantics and canonical projections. Codegen QA reads the Developer's independently expected synthetic request evidence and its freshness; it does not execute examples. Semantic defects return to mapper, implementation defects to codegen. One-click tests defer unresolved scope and finish independent work with a typed incomplete result, without questions or repeated redispatch; customer runs retain their existing checkpoints.

  6. Route again after every stage boundary. Stale requests use resources/rp-user-action-recovery/; unreadable request artifacts block until repaired. Never discard pending requests or decide the next stage from memory.

The router (lib/orchestration-router.js) is the only routing and resume authority. It recomputes the route from decisions, approvals, preflight, run.json status and the phase outputs on every call; run.json.currentState is diagnostic only, never a routing input.

  • A recorded rejection stops the route in every mode, one-click included: execution_approval_rejected is blocked before any setup or import write, and mapping_approval_rejected returns to rp-mapper for a new plan.

  • A gated output that exists but is unusable (source_schema_invalid, mapping_plan_invalid, setup_plan_invalid, setup_requirements_invalid, execution_manifest_invalid) is blocked with errors and the producer as nextResource. Do not re-run the producer automatically; report the errors to the Import Operator and stop.

  • The import routes (missing_completion_report, import_interrupted = a stopped run's aborted report, quick_mode_import_required) carry importProgress. interrupted lists recoveryArtifacts: resume it, never a second import. interruptedReport: "missing": first run scripts/interrupted-completion-report.js.

If an artifact is malformed, partial, stale, or fails its validator, treat its producing stage as incomplete and route to the producer. Do not make parallel replacement artifacts.

A user action whose reviewed artifacts changed after it was created is refused with user_action_stale and stays pending. Create a new request from the current artifacts.

Catching up a finished migration is a rerun, not a new project. When the user asks to pull in records that arrived or changed since the import — "the source kept selling", "these orders are missing", "re-run it" — reuse the same project, destination, mapping, generated importer and crosswalk, and route to rp-execute-import → "Rerunning an import for new and modified records". Do not scaffold a second project or re-approve an unchanged mapping; a mapping or scope change does go back through the existing gates. A rerun's revision conflicts are user decisions even in 1-click mode.

Demand-loaded module map

Router situationDispatch
project, delivery mode, source mode, or grouped intake is unresolvedresources/rp-project-intake/
destination is absent, conflicting, or needs creation/adoptionresources/rp-destination/
source URL/files/config/acquisition mode/credentials are required, including source credentials said to exist already on another siteresources/rp-source-inputs/
deterministic preflight is missing, repaired, or blocked on CLI checksresources/rp-preflight/
quick mode needs platform resolution, endpoint preflight, plan, extraction, or importselected resources/rp-quick-<platform>/
source schema is missingresources/rp-discovery/ and its selected source adapter
mapping is missing or needs reviewresources/rp-mapper/
Wix requirements are missingresources/rp-setup-discovery/
import code/review is missing or staleresources/rp-import-codegen/
setup verification is missingresources/rp-execute-setup/
backend completion report is missingresources/rp-execute-import/
frontend-only work, or integrated website handoff/build/gap loop/release receipt is incompleteresources/rp-website-continuation/
aggregate completion is missingresources/rp-execution-policy/
aggregate completion exists but the local review publication or current recap is missingresources/rp-migration-review/

The resource named by the route is the complete stage contract, dispatched as described in "Route before acting" — the main session itself never loads it directly. Only the dispatched Developer loads source-file, secret, scaffolding, or storefront procedures, and only for the stage that actually needs them; nothing about a stage where they're irrelevant is loaded, by the main session or the Developer.

Interaction policy

Normal mode asks only for a missing required input, a genuinely ambiguous active project, or a mandatory write approval. Ask one question at a time unless a module says otherwise.

When the user says add to expectations: <note> (or an unambiguous natural-language equivalent), append the note to the active project's EXPECTATIONS.md before continuing. Use scripts/expectations-ledger.js so the entry retains the supplied statement plus safe current context (stage/state, relevant project-relative artifacts, and known entity/field labels). Do not treat this as approval or silently change a mapping. Never record secrets, tokens, raw customer data, or raw source records; redact them if supplied and say so.

Before writes, preserve the mandatory execution-plan approval gate. Read-only discovery, mapping, setup verification, code generation, and review happen before it.

Quick management import mode

When managementImportMode=quick, select the platform adapter only after the deterministic source probe identifies a compatible platform. Quick mode is a bounded public-data import: the adapter's versioned quick-mode.json owns its source routes, entity graph, field matrix, and exclusions. Do not run agentic discovery, mapping, or project-specific code generation for the quick backend branch. Still run destination setup, application installation, Catalog-V3 and notification safety checks, execution approval, shared write runtime, crosswalks, and completion accounting. If no adapter qualifies, persist the unsupported-mode result and ask the user to select standard mode; never silently fall back.

Halt only for missing/invalid required input, a manual action with no API, or a systemic failure/data-loss risk. A halt must persist the code, evidence, owner, and exact unblock action; never silently stop.

1-click mode

When explicitly requested by the user, record automationMode=one_click with source=user and apply the following. A missing mode or a one_click value recorded as deterministic_inference/prior_artifact is normal interactive mode and must not skip a checkpoint:

  • collect all still-missing intake values in one grouped request; then do not pause for routine approvals;

  • record mapping and execution approvals as approved, decidedBy=agent; skipping a pause without state is invalid;

  • for CSV/file-only runs, validate and accept the required sample preview as the agent; without explicit user-authored one-click, pause for the normal mapping review, sample preview validation, and execution approval;

  • default to a new isolated site unless an existing destination is explicitly supplied or already pinned, but never default the new site's type (Headless, Studio or Harmony): ask it in the grouped intake; choose website scope deterministically from discovered route families;

  • retry PATH/tool-resolution failures under the operator's compatible interactive login shell; request required browser/network sandbox escalation and retry before calling it blocked;

  • retry the obvious recovery before stopping: aligned shell first for PATH/tool failures, then the required escalation retry for sandboxed browser or network/API failures;

  • continue through the complete selected deliverable. In management_and_website mode that includes frontend build, post-build gap analysis, bounded fix loop, and release receipt; when the user selected facelift at intake, it also includes the separate post-clone facelift review;

  • before yielding, re-route. A 1-click run is only completed with completion/migration-completion.json, or blocked with a typed durable blocker.

Use the operator's compatible local Node/Yarn shell when recovering from a PATH or tool resolution failure. Machine-specific shell paths belong only in local, git-excluded agent instructions.

Repo-local interactive shell contract: a PATH/tool-resolution failure on first attempt may mean the command ran under a plain, non-interactive shell that never sourced the operator's Node/Yarn profile. Resolve the operator's compatible login shell from the local environment or git-excluded agent instructions, verify that it is executable, and retry the exact same command through that shell in interactive login mode so the profile that resolves node/yarn/npx loads. Do not hardcode a machine-specific shell path in this public skill. Only escalate to a durable blocker if the compatible-shell retry itself fails.

Guardrails

  • Never bypass a validator, approval-state update, verified notification mute, or Catalog-V3 gate to make a stage appear finished.

  • website means frontend only; management_and_website means the integrated backend and frontend migration. Never hand the integrated migration destination to the frontend skill or create a second frontend site in that mode.

  • A Studio or Harmony destination (targetSiteType) is created and verified by rp-destination's coordinator and is never published, unpublished or handed to wix-headless-replatform; its website and publication remain operator handoff items.

  • Do not implement a storefront manually when wix-headless-replatform is unavailable; persist a blocker with the exact required runtime capability.

  • In management mode, still generate website/handoff.* after setup discovery so a later storefront can start without repeating backend discovery.

Files

lib/import-interruption.js

'use strict';

// A run that stops still writes what it knows. One wrapper owns an import's
// dispatch and its single completion call. A normal end, a thrown error, a `wix_auth_expired`
// stop and SIGTERM/SIGINT all reach `finalize` exactly once; only a stop passes an
// `interruption`. When finalize cannot run or does not mark the stop, the report is stamped or
// rebuilt from the attempt journal, so cutover never meets a missing report.
const fs = require('node:fs/promises');
const path = require('node:path');
// Loaded on a stop only: a vendored entrypoint must start even where the report's own target
// knowledge is not laid out yet.
const lazy = (name) => () => require(name);
const reportLib = lazy('./completion-report.js');
const localLib = lazy('./local-state.js');

const SIGNAL_EXIT_CODES = { SIGINT: 130, SIGTERM: 143 };
// Long enough for one in-flight batch to settle; a supervisor's SIGKILL usually follows within
// a minute, and the journal fallback covers that case.
const FINALIZE_GRACE_MS = 60000;
const IMPORTED = new Set(['imported']);
const PRESENT = new Set(['skipped_already_imported']);
const FAILED = new Set(['failed_retryable', 'failed_terminal']);

function interruptionFromSignal(signal, at = new Date()) {
  return { kind: 'signal', signal, code: null, at: new Date(at).toISOString() };
}

// Codes only: an error message can echo a record value.
function interruptionFromError(error, at = new Date()) {
  const auth = Boolean(error) && error.interruption === true && error.code === 'wix_auth_expired';
  const code = error && typeof error.code === 'string' && error.code ? error.code : (error && error.name) || null;
  return { kind: auth ? 'wix_auth_expired' : 'error', signal: null, code, at: new Date(at).toISOString() };
}

async function readJson(file) {
  try { return JSON.parse(await fs.readFile(file, 'utf8')); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
}

// Rebuilds per-entity counts from the attempt journal: the latest row per source key, grouped by
// target entity type. Records the run never reached have no row and are not counted; the
// interruption action says so.
function journalCompleteness(rows) {
  const latest = new Map();
  for (const row of rows) if (row && row.sourceStableKey && row.phase !== 'setup') latest.set(`${row.targetEntityType || row.writeSpecId}\0${row.sourceStableKey}`, row);
  const byEntity = new Map();
  for (const row of latest.values()) {
    const entity = row.targetEntityType || row.writeSpecId || 'unknown';
    const counts = byEntity.get(entity) || { entity, subtype: 'all', inScope: 0, attempted: 0, imported: 0, alreadyPresentByCrosswalk: 0, deferred: 0, failed: 0, unresolved: 0, sourceKeys: [] };
    if (row.status === 'skipped_out_of_scope') { byEntity.set(entity, counts); continue; }
    counts.inScope += 1; counts.sourceKeys.push(row.sourceStableKey);
    if (IMPORTED.has(row.status)) { counts.imported += 1; counts.attempted += 1; }
    else if (PRESENT.has(row.status)) counts.alreadyPresentByCrosswalk += 1;
    else if (FAILED.has(row.status)) { counts.failed += 1; counts.attempted += 1; }
    else if (row.status === 'deferred' || row.status === 'skipped_safe_mode_blocked' || row.status === 'skipped_unexpected') counts.deferred += 1;
    // Uncertain writes (started, succeeded_unverified, needs_verification) are left out of every
    // counter here: attachAttemptReasons fills the gap from the same rows, with their target ids.
    else counts.attempted += 1;
    byEntity.set(entity, counts);
  }
  return [...byEntity.values()].sort((a, b) => a.entity.localeCompare(b.entity));
}

async function writeAtomic(file, text) {
  const temp = `${file}.${process.pid}.tmp`;
  await fs.mkdir(path.dirname(file), { recursive: true });
  await fs.writeFile(temp, text);
  await fs.rename(temp, file);
}

async function manifestDigest(projectDir) {
  const manifest = await readJson(path.join(projectDir, 'execution/execution-manifest.json'));
  return manifest && typeof manifest.mappingPlanDigest === 'string' ? manifest.mappingPlanDigest : null;
}


// Makes sure `execution/completion-report.json` records this stop. Three cases:
// - finalize already wrote this run's report with the interruption: nothing to do;
// - finalize wrote this run's report without it (an older generated importer): stamp it;
// - there is no report for this run: rebuild one from the attempt journal.
async function ensureInterruptedCompletionReport(projectDir, { runId = null, interruption, siteId = null, mappingPlanDigest = null } = {}) {
  const normalized = reportLib().normalizeInterruption(interruption);
  const existing = await readJson(path.join(projectDir, reportLib().COMPLETION_REPORT_FILE));
  if (existing && existing.interruption && (!runId || existing.runId === runId)) return { action: 'kept', report: existing };
  if (existing && runId && existing.runId === runId) {
    // Already joined by the writer: stamp in place, never re-join (that would repeat the joined
    // operator actions).
    const stamped = reportLib().stampInterruption(existing, normalized);
    await writeAtomic(path.join(projectDir, reportLib().COMPLETION_REPORT_FILE), `${JSON.stringify(stamped, null, 2)}\n`);
    await writeAtomic(path.join(projectDir, reportLib().COMPLETION_SUMMARY_FILE), reportLib().renderCompletionSummary(stamped));
    return { action: 'stamped', report: stamped };
  }
  const { rows } = await localLib().loadAttemptJournal(projectDir).catch((error) => { if (error.code === 'ENOENT') return { rows: [] }; throw error; });
  const runIds = [...new Set(rows.map((row) => row.runId).filter((id) => typeof id === 'string' && id))];
  const rebuiltRunId = runId || runIds[runIds.length - 1] || 'interrupted-run';
  const completeness = journalCompleteness(rows);
  const lastWriteAt = rows.map((row) => row.ts).filter((ts) => typeof ts === 'string' && !Number.isNaN(Date.parse(ts))).sort().pop() || normalized.at;
  const rebuilt = reportLib().createCompletionReport({
    runId: rebuiltRunId,
    siteId,
    lastWriteAt,
    interruption: { ...normalized, rebuiltFromJournal: true },
    entityCompleteness: runIds.length ? reportLib().attachAttemptReasons(completeness, rows, { runIds }) : completeness,
    stageResiduals: [],
    orderHistoryInScope: completeness.some((row) => /(^|[/:._-])orders?$/i.test(row.entity)),
    warnings: ['Rebuilt from the attempt journal after the import stopped before its completion step; records the run never reached are not counted.'],
  });
  const written = await reportLib().writeCompletionReport(projectDir, rebuilt, { runId: rebuiltRunId, mappingPlanDigest: mappingPlanDigest || await manifestDigest(projectDir) });
  return { action: 'rebuilt', report: written.report };
}

// The cutover-facing artifacts for a stopped run. Best effort: a refusal here (a stale census, an
// unapproved mapping) is the same refusal the router would hit, and it never hides the report.
async function refreshInterruptedHandoff(projectDir, { stderr = process.stderr } = {}) {
  const value = await readJson(path.join(projectDir, reportLib().COMPLETION_REPORT_FILE));
  try {
    if (value && value.managementImportMode !== 'quick') await require('./discovered-set-status.js').buildDiscoveredSetStatus(projectDir);
  } catch (error) {
    stderr.write(`interrupted handoff: discovered-set status not refreshed (${error.code || error.message})\n`);
  }
  const outcome = await require('./website-handoff.js').generatePostExecutionHandoff(projectDir);
  if (!outcome.ok) stderr.write(`interrupted handoff: post-execution handoff refused (${outcome.reason})\n`);
  return outcome;
}

async function recordInterruption(projectDir, options, { stderr = process.stderr } = {}) {
  try {
    const result = await ensureInterruptedCompletionReport(projectDir, options);
    await refreshInterruptedHandoff(projectDir, { stderr });
    return result;
  } catch (error) {
    stderr.write(`interrupted import: completion report not written (${error.code || error.message}); run scripts/interrupted-completion-report.js\n`);
    return { action: 'failed', error };
  }
}

function delay(ms) {
  let timer;
  const promise = new Promise((resolve) => { timer = setTimeout(resolve, ms); });
  return { promise, cancel: () => clearTimeout(timer) };
}

// Awaits `promise` for at most `ms`; a step that hangs past it is reported and abandoned, so the
// whole shutdown stays bounded.
async function bounded(promise, ms, label, stderr) {
  const timer = delay(ms);
  try {
    const outcome = await Promise.race([promise.then(() => 'done', (error) => { stderr.write(`${label} failed (${error.code || error.message})\n`); return 'failed'; }), timer.promise.then(() => 'timeout')]);
    if (outcome === 'timeout') stderr.write(`${label} did not finish within ${ms} ms; the journal is the record\n`);
    return outcome;
  } finally { timer.cancel(); }
}

function latchStop(projectDir, signal) {
  if (!projectDir) return;
  try { require('./wix-auth.js').latchStop(projectDir, signal); } catch (error) {
    // A project that never vendored wix-auth.js has no token-source client to stop.
    if (!(error && error.code === 'MODULE_NOT_FOUND')) throw error;
  }
}

// Runs `dispatch({ stopRequested })`, then `finalize(interruption, result)` at most once.
// - normal end: finalize(null, result), return the result. A stop during finalize, or a finalize
//   that throws, never calls finalize again: the report is stamped or rebuilt instead.
// - dispatch throws: finalize(error interruption), record the stop, rethrow.
// - SIGTERM/SIGINT: latch the project (no new Wix request, no new `started` row), let in-flight
//   writes settle for `graceMs`. If dispatch settled, finalize from memory with what it returned;
//   if not, writes are still outstanding and only the journal is trusted. Record the stop, exit
//   143/130. Every step is bounded by `stepMs`; a second signal exits at once.
// `onInterrupted(interruption)` stamps or rebuilds the report and writes the handoff.
async function runImportWithFinalize({ dispatch, finalize, onInterrupted = async () => {}, projectDir, graceMs = FINALIZE_GRACE_MS, stepMs = FINALIZE_GRACE_MS, proc = process, stderr = process.stderr }) {
  // Without the project there is no latch, and a stopped run would keep starting writes.
  if (typeof projectDir !== 'string' || !projectDir) throw new TypeError('runImportWithFinalize requires projectDir');
  let finalized = false;
  const finalizeOnce = (interruption, result) => {
    if (finalized) return Promise.resolve();
    finalized = true;
    return Promise.resolve().then(() => finalize(interruption, result));
  };
  let signalled = null;
  let resolveSignal;
  const signal = new Promise((resolve) => { resolveSignal = resolve; });
  const handlers = Object.keys(SIGNAL_EXIT_CODES).map((name) => {
    const handler = () => {
      if (signalled) { proc.exit(SIGNAL_EXIT_CODES[name]); return; }
      signalled = interruptionFromSignal(name);
      latchStop(projectDir, name);
      stderr.write(`import stopping on ${name}: no new writes; recording what is known before exit\n`);
      resolveSignal(signalled);
    };
    proc.on(name, handler);
    return [name, handler];
  });
  const settled = { done: false, result: undefined };
  const work = Promise.resolve()
    .then(() => dispatch({ stopRequested: () => Boolean(signalled) }))
    .then((result) => { settled.done = true; settled.result = result; return result; }, (error) => { settled.done = true; throw error; });
  const recordStop = (interruption) => bounded(Promise.resolve().then(() => onInterrupted(interruption)), stepMs, 'recording the stop', stderr);
  const exitOnSignal = async (interruption) => {
    await recordStop(interruption);
    proc.exit(SIGNAL_EXIT_CODES[interruption.signal]);
  };
  try {
    const first = await Promise.race([work.then((result) => ({ result })), signal.then((interruption) => ({ interruption }))]);
    if (!first.interruption) {
      let finalizeError = null;
      const finalizing = finalizeOnce(null, first.result).then(() => 'done', (error) => { finalizeError = error; return 'failed'; });
      const outcome = await Promise.race([finalizing, signal.then(() => 'signal')]);
      if (outcome === 'signal') {
        // Let the running finalizer land first (the writer's latch fence marks its report
        // aborted), so recording the stop keeps or stamps that report instead of racing it.
        await bounded(finalizing, stepMs, 'import finalization after the stop', stderr);
        await exitOnSignal(signalled);
        return undefined;
      }
      if (finalizeError) {
        // Every write finished but no report was written: rebuild it, then fail the run.
        await recordStop(interruptionFromError(finalizeError));
        throw finalizeError;
      }
      return first.result;
    }
    const grace = delay(graceMs);
    await Promise.race([work.catch(() => {}), grace.promise]);
    grace.cancel();
    if (settled.done) await bounded(finalizeOnce(first.interruption, settled.result), stepMs, 'import finalization after the stop', stderr);
    else stderr.write('writes still in flight after the grace period; the report is rebuilt from the attempt journal\n');
    await exitOnSignal(first.interruption);
    return undefined;
  } catch (error) {
    if (finalized) throw error;
    const interruption = interruptionFromError(error);
    await bounded(finalizeOnce(interruption, undefined), stepMs, 'import finalization after the error', stderr);
    await recordStop(interruption);
    throw error;
  } finally {
    for (const [name, handler] of handlers) proc.removeListener(name, handler);
  }
}

module.exports = {
  SIGNAL_EXIT_CODES,
  FINALIZE_GRACE_MS,
  interruptionFromSignal,
  interruptionFromError,
  journalCompleteness,
  ensureInterruptedCompletionReport,
  refreshInterruptedHandoff,
  recordInterruption,
  runImportWithFinalize,
};

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

What our scanner noticed· Low risk

  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Wix
Publisher
Wix (Official)
Source
wix/skills · skills/wix-replatform · commit d168bc2
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Wix.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download wix-replatform.zip