@wix/ditto-codegen-public 1.0.441 → 1.0.443

package/dist/out.js

@@ -544,7 +544,15 @@ var require_context = __commonJS({
     var types_1 = require_types_impl();
     var dotenv_1 = __importDefault2(require_main());
     var path_12 = __importDefault2(require("path"));
+    var provisioned = {
+      CODEGEN_JOB_DELIVERY: process.env.CODEGEN_JOB_DELIVERY,
+      CODEGEN_JOB_FETCH_PORT: process.env.CODEGEN_JOB_FETCH_PORT
+    };
     dotenv_1.default.config({ path: path_12.default.join(__dirname, "../.env"), override: true });
+    for (const [key, value] of Object.entries(provisioned)) {
+      if (value?.trim())
+        process.env[key] = value;
+    }
     var HistoryManager = class {
       constructor() {
         this.history = [];
@@ -11032,7 +11040,7 @@ var require_CodeGenService = __commonJS({
   "dist/services/CodeGenService.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CodeGenService = exports2.JobsSortOrder = exports2.TaskKind = exports2.Status = void 0;
+    exports2.CodeGenService = exports2.FETCH_TIMEOUT_MS = exports2.REQUEST_TIMEOUT_MS = exports2.JobsSortOrder = exports2.TaskKind = exports2.Status = void 0;
     exports2.createCodeGenErrorHandler = createCodeGenErrorHandler;
     var http_client_1 = require_index_node();
     var http_1 = require_http_impl();
@@ -11116,6 +11124,14 @@ var require_CodeGenService = __commonJS({
         }
       };
     }
+    exports2.REQUEST_TIMEOUT_MS = 12e4;
+    exports2.FETCH_TIMEOUT_MS = 3e4;
+    function isNotFound(error) {
+      return http_client_1.HttpClient.isHttpError(error) && error.response?.status === 404;
+    }
+    function mapRequest(req, fn) {
+      return typeof req === "function" ? (ctx) => fn(req(ctx)) : fn(req);
+    }
     var CodeGenService = class {
       constructor(projectId, httpClient) {
         this.projectId = projectId;
@@ -11126,15 +11142,16 @@ var require_CodeGenService = __commonJS({
           this.setAccessToken(token);
           return token;
         };
-        this.request = async (req) => {
+        this.request = async (req, timeout) => {
+          const build = () => this.withTimeout(this.withAuth(req), timeout);
           try {
-            return await this.httpClient.request(this.withAuth(req));
+            return await this.httpClient.request(build());
           } catch (err) {
             if (!this.isUnauthorized(err))
               throw err;
             logger_12.logger.warn("[CodeGenService] 401 received, refreshing token and retrying once");
             await this.refreshAccessToken();
-            return await this.httpClient.request(this.withAuth(req));
+            return await this.httpClient.request(build());
           }
         };
         this.fetchPendingJobs = async () => {
@@ -11145,10 +11162,19 @@ var require_CodeGenService = __commonJS({
             paging: { limit: 1 },
             sortOrder: types_1.JobsSortOrder.CREATED_AT_ASC
           } : void 0;
-          const resp = await this.request((0, http_1.listProjectJobs)(filtered ?? { projectId: this.projectId }));
+          const resp = await this.request((0, http_1.listProjectJobs)(filtered ?? { projectId: this.projectId }), exports2.FETCH_TIMEOUT_MS);
           const jobs = resp.data?.jobs ?? [];
           return filtered ? jobs : jobs.filter(this.shouldProcessJob);
         };
+        this.findJob = async (jobId) => {
+          try {
+            return await this.getJob(jobId, exports2.FETCH_TIMEOUT_MS);
+          } catch (error) {
+            if (isNotFound(error))
+              return null;
+            throw error;
+          }
+        };
         this.shouldProcessJob = (job) => {
           if (job.status !== types_1.Status.PENDING)
             return false;
@@ -11279,11 +11305,11 @@ var require_CodeGenService = __commonJS({
             }
           }));
         };
-        this.getJob = async (jobId) => {
+        this.getJob = async (jobId, timeout) => {
           const resp = await this.request((0, http_1.getJob)({
             projectId: this.projectId,
             jobId
-          }));
+          }), timeout);
           return resp.data?.job ?? null;
         };
         this.runContext = (ctx) => ({
@@ -11329,6 +11355,7 @@ var require_CodeGenService = __commonJS({
         const serverUrl = process.env.CODEGEN_SERVER_BASE_URL || "https://manage.wix.com";
         this.httpClient = (0, http_client_1.createHttpClient)({
           baseURL: serverUrl,
+          timeout: exports2.REQUEST_TIMEOUT_MS,
           errorHandler: createCodeGenErrorHandler(() => this.httpClient)
         });
       }
@@ -11346,14 +11373,16 @@ var require_CodeGenService = __commonJS({
         return error.response?.status === 401;
       }
       withAuth(req) {
-        const authHeader = { authorization: `Bearer ${this.accessToken}` };
-        if (typeof req === "function") {
-          return (ctx) => {
-            const r = req(ctx);
-            return { ...r, headers: { ...r.headers ?? {}, ...authHeader } };
-          };
-        }
-        return { ...req, headers: { ...req.headers ?? {}, ...authHeader } };
+        return mapRequest(req, (r) => ({
+          ...r,
+          headers: {
+            ...r.headers ?? {},
+            authorization: `Bearer ${this.accessToken}`
+          }
+        }));
+      }
+      withTimeout(req, timeout) {
+        return timeout === void 0 ? req : mapRequest(req, (r) => ({ ...r, timeout }));
       }
     };
     exports2.CodeGenService = CodeGenService;
@@ -14682,6 +14711,31 @@ For ANY use of a Wix Stores API (products, variants, inventory, collections/cate
   }
 });
 
+// ../codegen-common-logic/dist/rules/vertical-installation.js
+var require_vertical_installation = __commonJS({
+  "../codegen-common-logic/dist/rules/vertical-installation.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VERTICAL_INSTALLATION_RULES = void 0;
+    exports2.VERTICAL_INSTALLATION_RULES = `# Vertical Installation Rules
+
+Code written against a Wix app this site doesn't have compiles, saves, and then does nothing.
+
+For ANY use of a Wix vertical SDK (Stores, eCommerce, Bookings, Restaurants, Pricing Plans, Gift Cards, Blog, Events, Portfolio, Members Area, Forms, Loyalty Program, Donations):
+
+1. **You MUST invoke the \`wix-site-installed-apps\` skill before your FIRST write of any kind** \u2014 not merely before the vertical code itself. The build workflow tells you to write each piece as soon as it is ready, so a dashboard shell written before you reach the vertical part is still work rule 2 will make you undo. Name the apps this request needs, by product name; ask in one call and reuse the answer.
+2. **If any app comes back \`installed: false\`, STOP. Write no code at all** \u2014 not for that app, and not for the rest of the request either. Your reply is **one** short message to the site owner, naming the app and which parts of the request you did not attempt, and nothing else. Write the outcome, never the mechanism: no rule, no skill, no check or verdict, no app id or endpoint, and no sentence announcing that you are stopping \u2014 the user doesn't know what any of that is, and reading it as an error is the likeliest outcome. \\"Wix Events isn't installed on your site, so I couldn't build the upcoming-events page. Install Wix Events from your dashboard, then ask again and I'll build it.\\" \u2014 that shape, once. **If you have already created or modified files in this session, undo those changes before replying \u2014 path by path, naming each file you wrote, never a bulk revert of the working tree (\`git clean\`, \`git checkout .\`, \`git reset --hard\`, or any "discard all changes"), which also destroys work that was there before you** \u2014 a half-built app that saves is worse than either outcome this rule chooses between.
+3. **Do not soften rule 2.** No partial build, no stub, no CMS collection standing in for the app, no "for when they install it" path, and no offering to build the parts that would work. The site owner installs the app, then asks again. **Where the OUTPUT MESSAGE instruction says to build the feature and list installing a dependent app as a "next step", this rule wins** \u2014 for a missing app there is no build, so there is no next step to list against it.
+4. **\`installed: null\`, or the check itself failing: build, and say the app may need installing.** A verdict you can't trust never stops anything. The exception is a \`null\` carrying \`"reason":"not-installable"\` \u2014 the check refuses that name because there is no app behind it to install: build, and name nothing. Some plain \`null\`s are platform features with nothing to install either \u2014 contacts, coupons, automations and triggered emails, login and logged-in-only gating \u2014 so build and name nothing for those too.
+5. **This outranks the plan.** A blueprint summary or extension description naming a missing app was written without knowing the site; rule 2 wins, and your reply says which planned parts you left unbuilt.
+6. **Never install an app** \u2014 it adds pages, a cart, and checkout to the user's live site.
+
+CMS is exempt: \`wix-site-data-collection\` installs it, so CMS work is never blocked and CMS is never named as missing.
+
+Two names answer nothing: **"Wix CMS"** (the published id is a variant nobody can install) and **"Wix eCommerce"** (cart and checkout have no standalone install \u2014 they arrive with a catalog app). The check refuses both, answering \`installed: null\` with \`"reason":"not-installable"\`, so asking is harmless but decides nothing. For an eCommerce feature, gate on the catalog app it needs instead \u2014 Wix Stores, Wix Bookings, or the specific Wix Restaurants app \u2014 and never tell the user to install eCommerce or CMS.`;
+  }
+});
+
 // ../codegen-common-logic/dist/rules/index.js
 var require_rules = __commonJS({
   "../codegen-common-logic/dist/rules/index.js"(exports2) {
@@ -14705,6 +14759,7 @@ var require_rules = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     __exportStar2(require_site_data_layer(), exports2);
     __exportStar2(require_stores_catalog_version(), exports2);
+    __exportStar2(require_vertical_installation(), exports2);
   }
 });
 
@@ -14718,6 +14773,10 @@ var require_site_environment = __commonJS({
     exports2.SITE_ENVIRONMENT_IDENTITY = "You generate code for the user's own live Wix site \u2014 to the user it's just their site, not a separate app they're aware of. Your changes are saved and applied to the site automatically; there is no separate release step.";
     exports2.SITE_CODEGEN_RULES = [
       { filename: "site-data-layer-rules.md", content: rules_1.SITE_DATA_LAYER_RULES },
+      {
+        filename: "vertical-installation-rules.md",
+        content: rules_1.VERTICAL_INSTALLATION_RULES
+      },
       {
         filename: "stores-catalog-version-rules.md",
         content: rules_1.STORES_CATALOG_VERSION_RULES
@@ -16508,11 +16567,13 @@ var require_utils9 = __commonJS({
   "dist/utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.errorStack = void 0;
+    exports2.errorStack = exports2.delay = void 0;
     exports2.serializeError = serializeError;
     exports2.updateAllRunningTasks = updateAllRunningTasks;
     var types_1 = require_types_impl();
     var codeGenerationService_12 = require_codeGenerationService();
+    var delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+    exports2.delay = delay;
     var errorStack = (error) => error instanceof Error ? error.stack ?? error.message : String(error);
     exports2.errorStack = errorStack;
     function serializeError(error) {
@@ -23760,7 +23821,7 @@ var require_skills_installer = __commonJS({
       const nested = discoverSkills((0, path_12.join)(packageRoot, "skills"));
       return nested.length > 0 ? nested : discoverSkills(packageRoot);
     }
-    var delay2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     async function applySkillsOverride(outputPath, log) {
       const skillsOverride = process.env.SKILLS_OVERRIDE_BRANCH;
       if (!skillsOverride) {
@@ -23806,7 +23867,7 @@ var require_skills_installer = __commonJS({
       });
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
-        await delay2(intervalMs);
+        await delay(intervalMs);
         state = inspect(state.candidates);
         if (state.ready) {
           log.info("[Skills] Skills became available", { present: state.present });
@@ -24213,6 +24274,367 @@ var require_plugin_artifacts = __commonJS({
   }
 });
 
+// dist/fetch-scheduler.js
+var require_fetch_scheduler = __commonJS({
+  "dist/fetch-scheduler.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.FetchScheduler = exports2.MAX_AWAITED_JOB_IDS = exports2.MAX_MISSING_JOB_RECHECKS = exports2.ERROR_BACKOFF_MS = exports2.POST_JOB_INTERVAL_MS = exports2.MIN_FETCH_INTERVAL_MS = void 0;
+    var logger_12 = require_logger();
+    var utils_12 = require_utils9();
+    exports2.MIN_FETCH_INTERVAL_MS = 1e3;
+    exports2.POST_JOB_INTERVAL_MS = 3e3;
+    exports2.ERROR_BACKOFF_MS = 5e3;
+    exports2.MAX_MISSING_JOB_RECHECKS = 3;
+    exports2.MAX_AWAITED_JOB_IDS = 4;
+    var FetchScheduler = class {
+      constructor(deps) {
+        this.deps = deps;
+        this.cycle = null;
+        this.checkAgain = false;
+        this.stopped = false;
+        this.nextFetchNotBefore = 0;
+        this.interval = 0;
+        this.awaitedJobIds = /* @__PURE__ */ new Map();
+      }
+      start() {
+        this.stopped = false;
+      }
+      /** A cycle already inside runJob is NOT awaited. A caller that needs exclusivity must
+       *  not start another runner until that cycle settles. */
+      stop() {
+        this.stopped = true;
+      }
+      /** Records the nudge and makes sure a cycle is running. It does not wait for the
+       *  fetch. A caller held on a slow socket times out and reads that as "machine down",
+       *  so retrying is ours to do, not theirs. */
+      nudge(jobId) {
+        if (this.stopped)
+          return;
+        if (jobId) {
+          this.awaitedJobIds.delete(jobId);
+          if (this.awaitedJobIds.size >= exports2.MAX_AWAITED_JOB_IDS) {
+            this.awaitedJobIds.delete(this.awaitedJobIds.keys().next().value);
+          }
+          this.awaitedJobIds.set(jobId, exports2.MAX_MISSING_JOB_RECHECKS);
+        }
+        if (this.cycle) {
+          this.checkAgain = true;
+          return;
+        }
+        this.cycle = this.runUntilIdle().catch((error) => logger_12.logger.error("[JobFetch] Cycle aborted", { error: (0, utils_12.errorStack)(error) }));
+      }
+      async runUntilIdle() {
+        try {
+          do {
+            await this.runSingleJobCycle();
+          } while (this.checkAgain && !this.stopped);
+        } finally {
+          this.cycle = null;
+        }
+      }
+      async runSingleJobCycle() {
+        await this.throttle();
+        if (this.stopped)
+          return;
+        this.checkAgain = false;
+        const due = await this.findRunnableJob();
+        if (!due)
+          return;
+        this.checkAgain = true;
+        if (this.stopped)
+          return;
+        await this.attemptJob(due);
+      }
+      async findRunnableJob() {
+        let jobs;
+        try {
+          jobs = await this.deps.fetchPendingJobs();
+        } catch (error) {
+          this.recordDebt("Fetch failed", error);
+          return null;
+        }
+        this.schedule(exports2.MIN_FETCH_INTERVAL_MS);
+        logger_12.logger.info("[JobFetch] Fetched pending jobs", { count: jobs.length });
+        for (const job of jobs) {
+          if (job.id)
+            this.awaitedJobIds.delete(job.id);
+        }
+        if (jobs.length > 0)
+          return jobs[0];
+        if (this.awaitedJobIds.size === 0)
+          return null;
+        try {
+          return await this.claimNudgedJob();
+        } catch (error) {
+          this.recordDebt("Nudged job lookup failed", error);
+          return null;
+        }
+      }
+      async attemptJob(job) {
+        try {
+          await this.deps.runJob(job);
+          this.schedule(exports2.POST_JOB_INTERVAL_MS);
+        } catch (error) {
+          this.recordDebt("Job run failed", error);
+        }
+      }
+      /** A nudged job the list did not return. Read it by key, which does not wait on the
+       *  index. A key read is still a replica read, so a job the server does not know about
+       *  yet keeps a small budget of re-checks instead of one answer settling it. */
+      async claimNudgedJob() {
+        for (const jobId of [...this.awaitedJobIds.keys()]) {
+          if (this.stopped)
+            return null;
+          const job = await this.deps.findJob(jobId);
+          if (job) {
+            this.awaitedJobIds.delete(jobId);
+            if (this.deps.canRunJob(job))
+              return job;
+            continue;
+          }
+          const rechecksLeft = this.awaitedJobIds.get(jobId);
+          if (rechecksLeft === void 0)
+            continue;
+          if (rechecksLeft > 0) {
+            this.awaitedJobIds.set(jobId, rechecksLeft - 1);
+            this.checkAgain = true;
+          } else {
+            this.awaitedJobIds.delete(jobId);
+            logger_12.logger.warn("[JobFetch] Nudged job does not exist", { jobId });
+          }
+        }
+        return null;
+      }
+      schedule(intervalMs) {
+        this.interval = intervalMs;
+        this.nextFetchNotBefore = Date.now() + intervalMs;
+      }
+      /** Nobody else will retry. We already answered the caller 200. */
+      recordDebt(what, error) {
+        logger_12.logger.error(`[JobFetch] ${what}`, { error: (0, utils_12.errorStack)(error) });
+        this.checkAgain = true;
+        this.schedule(exports2.ERROR_BACKOFF_MS);
+      }
+      async throttle() {
+        const wait = Math.min(this.nextFetchNotBefore - Date.now(), this.interval);
+        if (wait > 0)
+          await (0, utils_12.delay)(wait);
+      }
+    };
+    exports2.FetchScheduler = FetchScheduler;
+  }
+});
+
+// dist/nudge-listener-server.js
+var require_nudge_listener_server = __commonJS({
+  "dist/nudge-listener-server.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.NudgeListenerServer = exports2.BIND_RETRY_DELAY_MS = exports2.BIND_RETRIES = exports2.MAX_LOGGED_PATH_LENGTH = exports2.JOB_ID_PATTERN = exports2.JOB_FETCH_PATH = exports2.JOB_FETCH_PORT = void 0;
+    var node_http_1 = require("node:http");
+    var logger_12 = require_logger();
+    var utils_12 = require_utils9();
+    var fetch_scheduler_1 = require_fetch_scheduler();
+    exports2.JOB_FETCH_PORT = 52402;
+    exports2.JOB_FETCH_PATH = "/_wix/codegen/fetch-jobs";
+    exports2.JOB_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+    exports2.MAX_LOGGED_PATH_LENGTH = 128;
+    exports2.BIND_RETRIES = 5;
+    exports2.BIND_RETRY_DELAY_MS = 300;
+    var NudgeListenerServer = class {
+      constructor(deps, port = exports2.JOB_FETCH_PORT) {
+        this.port = port;
+        this.server = null;
+        this.stopped = false;
+        this.scheduler = new fetch_scheduler_1.FetchScheduler(deps);
+      }
+      async start() {
+        this.stopped = false;
+        this.scheduler.start();
+        await this.listen();
+        if (this.stopped) {
+          await this.stop();
+          throw new Error("Nudge listener was stopped while binding");
+        }
+        logger_12.logger.info("[JobFetch] Endpoint listening", {
+          port: this.boundPort(),
+          path: exports2.JOB_FETCH_PATH
+        });
+        this.scheduler.nudge();
+      }
+      /** Closes the socket and stops the scheduler; a cycle already inside runJob is NOT
+       *  awaited. A caller that needs exclusivity must not start another runner until that
+       *  cycle settles. */
+      async stop() {
+        this.stopped = true;
+        this.scheduler.stop();
+        const server = this.server;
+        if (!server)
+          return;
+        this.server = null;
+        server.removeAllListeners("error");
+        server.on("error", (error) => logger_12.logger.warn("[JobFetch] Endpoint error while closing", {
+          error: (0, utils_12.errorStack)(error)
+        }));
+        server.closeAllConnections();
+        await new Promise((resolve) => server.close(() => resolve()));
+      }
+      boundPort() {
+        const address = this.server?.address();
+        return address && typeof address === "object" ? address.port : null;
+      }
+      /** The agent is restarted in a tight `while true` loop, so a bind can land before
+       *  the previous process has released the port. Falling straight back to poll there
+       *  would strand the machine on the slow path for the whole session. */
+      async listen() {
+        for (let attempt = 0; ; attempt++) {
+          try {
+            return await this.listenOnce();
+          } catch (error) {
+            const inUse = error?.code === "EADDRINUSE" && attempt < exports2.BIND_RETRIES;
+            if (!inUse)
+              throw error;
+            await (0, utils_12.delay)(exports2.BIND_RETRY_DELAY_MS);
+          }
+        }
+      }
+      listenOnce() {
+        return new Promise((resolve, reject) => {
+          const server = (0, node_http_1.createServer)((req, res) => {
+            try {
+              this.handleRequest(req, res);
+            } catch (error) {
+              logger_12.logger.error("[JobFetch] Request handler failed", {
+                error: (0, utils_12.errorStack)(error)
+              });
+              if (res.headersSent)
+                res.destroy();
+              else
+                this.respond(res, 500, { error: "request failed" });
+            }
+          });
+          server.once("error", reject);
+          server.listen(this.port, "0.0.0.0", () => {
+            server.removeListener("error", reject);
+            server.on("error", (error) => {
+              logger_12.logger.error("[JobFetch] Endpoint failed after binding, exiting", {
+                error: (0, utils_12.errorStack)(error)
+              });
+              process.exit(1);
+            });
+            this.server = server;
+            resolve();
+          });
+        });
+      }
+      handleRequest(req, res) {
+        const url = new URL((req.url ?? "").replace(/^\/+/, "/"), "http://localhost");
+        const path = url.pathname.replace(/\/+$/, "");
+        if (req.method !== "GET" || path !== exports2.JOB_FETCH_PATH) {
+          logger_12.logger.warn("[JobFetch] Rejected request", {
+            method: req.method,
+            path: url.pathname.slice(0, exports2.MAX_LOGGED_PATH_LENGTH)
+          });
+          this.respond(res, 404, { error: "not found" });
+          return;
+        }
+        const nudgedId = url.searchParams.get("jobId");
+        const usable = nudgedId === null || exports2.JOB_ID_PATTERN.test(nudgedId);
+        if (!usable) {
+          logger_12.logger.warn("[JobFetch] Nudge carried an unusable jobId", {
+            length: nudgedId.length
+          });
+        }
+        const jobId = usable ? nudgedId ?? void 0 : void 0;
+        this.scheduler.nudge(jobId);
+        logger_12.logger.info("[JobFetch] Nudge accepted", { jobId });
+        this.respond(res, 200, { accepted: true });
+      }
+      respond(res, status, body) {
+        res.writeHead(status, {
+          "Content-Type": "application/json",
+          // A cached response would turn every nudge into a no-op.
+          "Cache-Control": "no-store"
+        });
+        res.end(JSON.stringify(body));
+      }
+    };
+    exports2.NudgeListenerServer = NudgeListenerServer;
+  }
+});
+
+// dist/job-fetching.js
+var require_job_fetching = __commonJS({
+  "dist/job-fetching.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JobDeliveryMode = void 0;
+    exports2.getJobDeliveryMode = getJobDeliveryMode;
+    exports2.getJobFetchPort = getJobFetchPort;
+    exports2.startJobFetching = startJobFetching;
+    var nudge_listener_server_12 = require_nudge_listener_server();
+    var logger_12 = require_logger();
+    var utils_12 = require_utils9();
+    var JobDeliveryMode;
+    (function(JobDeliveryMode2) {
+      JobDeliveryMode2["POLL"] = "poll";
+      JobDeliveryMode2["PUSH"] = "push";
+    })(JobDeliveryMode || (exports2.JobDeliveryMode = JobDeliveryMode = {}));
+    var DEFAULT_MODE = JobDeliveryMode.POLL;
+    function getJobDeliveryMode() {
+      const mode = process.env.CODEGEN_JOB_DELIVERY?.trim().toLowerCase();
+      const supported = Object.values(JobDeliveryMode).find((candidate) => candidate === mode);
+      if (supported)
+        return supported;
+      if (mode) {
+        logger_12.logger.warn("[Startup] Unrecognized CODEGEN_JOB_DELIVERY, using default", {
+          mode,
+          default: DEFAULT_MODE
+        });
+      }
+      return DEFAULT_MODE;
+    }
+    var MIN_PORT = 1;
+    var MAX_PORT = 65535;
+    function getJobFetchPort() {
+      const configured = process.env.CODEGEN_JOB_FETCH_PORT;
+      if (configured === void 0)
+        return nudge_listener_server_12.JOB_FETCH_PORT;
+      const port = /^\s*\d+\s*$/.test(configured) ? Number(configured) : NaN;
+      if (Number.isInteger(port) && port >= MIN_PORT && port <= MAX_PORT)
+        return port;
+      logger_12.logger.warn("[Startup] Unusable CODEGEN_JOB_FETCH_PORT, using default", {
+        port: configured,
+        default: nudge_listener_server_12.JOB_FETCH_PORT
+      });
+      return nudge_listener_server_12.JOB_FETCH_PORT;
+    }
+    async function startJobFetching(deps) {
+      const mode = getJobDeliveryMode();
+      logger_12.logger.info("[Startup] Job delivery mode", { mode });
+      if (mode === JobDeliveryMode.POLL) {
+        return deps.runPollLoop();
+      }
+      try {
+        await deps.nudgeListenerServer.start();
+      } catch (error) {
+        try {
+          await deps.nudgeListenerServer.stop();
+        } catch (stopError) {
+          logger_12.logger.error("[Startup] Closing the half-started listener failed", {
+            error: (0, utils_12.errorStack)(stopError)
+          });
+        }
+        logger_12.logger.error("[Startup] Push delivery unavailable, falling back to poll", {
+          error: (0, utils_12.errorStack)(error)
+        });
+        return deps.runPollLoop();
+      }
+    }
+  }
+});
+
 // dist/index.js
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processJob = processJob;
@@ -24241,61 +24663,67 @@ var subagent_tool_logger_1 = require_subagent_tool_logger();
 var plugin_artifacts_1 = require_plugin_artifacts();
 var config_1 = require_config();
 var environments_1 = require_environments();
-var plugin_host_1 = require_plugin_host();
 var utils_1 = require_utils9();
+var job_fetching_1 = require_job_fetching();
+var nudge_listener_server_1 = require_nudge_listener_server();
+var plugin_host_1 = require_plugin_host();
+var utils_2 = require_utils9();
 var sessionId = process.env.CODEGEN_SESSION_ID || (0, crypto_1.randomUUID)();
 process.env.CODEGEN_SESSION_ID = sessionId;
 (0, logger_1.initLogger)(sessionId);
 var jobCancellationMonitor = new job_cancellation_monitor_1.JobCancellationMonitor(codeGenerationService_1.codeGenerationService);
 var jobTimeoutMonitor = new job_timeout_monitor_1.JobTimeoutMonitor(codeGenerationService_1.codeGenerationService);
-var delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+var POLL_LOG_PREFIX = "[Loop]";
+var PUSH_LOG_PREFIX = "[JobFetch]";
 var ACTIVE_JOB_SLEEP_MS = 1e3;
 var NO_JOBS_SLEEP_MS = 5e3;
 var POST_JOB_SLEEP_MS = 3e3;
+var runPendingJob = async (job, logPrefix) => {
+  const redactAgentData = (payload) => payload?.agentData ? { ...payload, agentData: Object.keys(payload.agentData) } : payload;
+  logger_1.logger.info("Job details", {
+    job: {
+      ...job,
+      tasks: job.tasks?.map((task) => ({
+        ...task,
+        input: redactAgentData(task.input),
+        payload: redactAgentData(task.payload)
+      }))
+    }
+  });
+  if (!job.id) {
+    throw new ditto_codegen_types_1.MissingJobIdError();
+  }
+  const jobId = job.id;
+  logger_1.logger.info(`${logPrefix} Selected job`, { jobId });
+  const freshToken = await codeGenerationService_1.codeGenerationService.refreshAccessToken();
+  (0, config_1.setCurrentAccessToken)(freshToken);
+  await codeGenerationService_1.codeGenerationService.markJobAsRuninng(jobId);
+  await processJob(job);
+  await codeGenerationService_1.codeGenerationService.markJobAsCompleted(jobId);
+  logger_1.logger.info(`${logPrefix} Processed job`, { jobId });
+};
 var alwaysOnLoop = async () => {
   while (true) {
     try {
       if (context_1.ctx.hasActiveJobs()) {
         console.log(`[Loop] Local active job in progress. Sleeping ${ACTIVE_JOB_SLEEP_MS}ms`);
-        await delay(ACTIVE_JOB_SLEEP_MS);
+        await (0, utils_1.delay)(ACTIVE_JOB_SLEEP_MS);
         continue;
       }
       const jobs = await codeGenerationService_1.codeGenerationService.fetchPendingJobs();
       console.log("[Loop] Fetched pending jobs", { count: jobs.length });
       if (jobs.length === 0) {
         console.log("[Loop] No pending jobs, sleeping");
-        await delay(NO_JOBS_SLEEP_MS);
+        await (0, utils_1.delay)(NO_JOBS_SLEEP_MS);
         continue;
       }
-      const job = jobs[0];
-      const redactAgentData = (payload) => payload?.agentData ? { ...payload, agentData: Object.keys(payload.agentData) } : payload;
-      logger_1.logger.info("Job details", {
-        job: {
-          ...job,
-          tasks: job.tasks?.map((task) => ({
-            ...task,
-            input: redactAgentData(task.input),
-            payload: redactAgentData(task.payload)
-          }))
-        }
-      });
-      if (!job.id) {
-        throw new ditto_codegen_types_1.MissingJobIdError();
-      }
-      const jobId = job.id;
-      logger_1.logger.info("[Loop] Selected job", { jobId });
-      const freshToken = await codeGenerationService_1.codeGenerationService.refreshAccessToken();
-      (0, config_1.setCurrentAccessToken)(freshToken);
-      await codeGenerationService_1.codeGenerationService.markJobAsRuninng(jobId);
-      await processJob(job);
-      await codeGenerationService_1.codeGenerationService.markJobAsCompleted(jobId);
-      logger_1.logger.info("[Loop] Processed job", { jobId });
-      await delay(POST_JOB_SLEEP_MS);
+      await runPendingJob(jobs[0], POLL_LOG_PREFIX);
+      await (0, utils_1.delay)(POST_JOB_SLEEP_MS);
     } catch (loopError) {
       logger_1.logger.error("Polling loop encountered an error. Will continue after backoff:", {
         error: loopError instanceof Error ? loopError.message : String(loopError)
       });
-      await delay(NO_JOBS_SLEEP_MS);
+      await (0, utils_1.delay)(NO_JOBS_SLEEP_MS);
     }
     context_1.ctx.resetJobs();
   }
@@ -24333,7 +24761,13 @@ async function main(ctx) {
     metasiteId: ctx.metasiteId
   });
   await initOpenCode();
-  await alwaysOnLoop();
+  const nudgeListenerServer = new nudge_listener_server_1.NudgeListenerServer({
+    fetchPendingJobs: () => codeGenerationService_1.codeGenerationService.fetchPendingJobs(),
+    findJob: (jobId) => codeGenerationService_1.codeGenerationService.findJob(jobId),
+    canRunJob: (job) => codeGenerationService_1.codeGenerationService.shouldProcessJob(job),
+    runJob: (job) => runPendingJob(job, PUSH_LOG_PREFIX)
+  }, (0, job_fetching_1.getJobFetchPort)());
+  await (0, job_fetching_1.startJobFetching)({ runPollLoop: alwaysOnLoop, nudgeListenerServer });
 }
 var getFirstTask = (job) => {
   return job.tasks?.[0];
@@ -24377,7 +24811,7 @@ async function reportPreDispatchFailure(jobId, error) {
   });
   try {
     await codeGenerationService_1.codeGenerationService.markJobAsFailed(jobId, codegenError);
-    await (0, utils_1.updateAllRunningTasks)(jobId, CodeGenService_1.Status.FAILED, codegenError);
+    await (0, utils_2.updateAllRunningTasks)(jobId, CodeGenService_1.Status.FAILED, codegenError);
   } catch (reportError) {
     logger_1.logger.error("[Job] Could not mark the job failed", {
       jobId,
@@ -24444,6 +24878,7 @@ async function processJob(job) {
     } finally {
       jobCancellationMonitor.stop();
       jobTimeoutMonitor.stop();
+      context_1.ctx.resetJobs();
     }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/ditto-codegen-public",
-  "version": "1.0.441",
+  "version": "1.0.443",
   "description": "AI-powered Wix CLI app generator - standalone executable",
   "scripts": {
     "build": "node build.mjs",
@@ -29,5 +29,5 @@
     "esbuild": "^0.27.2",
     "vitest": "^4.0.16"
   },
-  "falconPackageHash": "b04a4f2857569aa9b70fbf2fc57a6b3c7db84e442334799481a9cc6c"
+  "falconPackageHash": "da26fbed4274b90d804fbf1672491b33c4725d7a18de167c461deb2f"
 }