@wix/ditto-codegen-public 1.0.441 → 1.0.442

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;
@@ -16508,11 +16537,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 +23791,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 +23837,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 +24244,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 +24633,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 +24731,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 +24781,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 +24848,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.442",
   "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": "19c7b1e106b5b7a1aa3bc62b9fc8ebae4ce01f8641d5971c6e7138c3"
 }