omnikey-cli 1.0.35 → 1.0.37

package/backend-dist/agent/agentPrompts.js

@@ -17,28 +17,17 @@ ${hasTaskInstructions
 - Default to a \`<shell_script>\` for anything involving the machine, network, files, processes, env vars, or system state — never answer from training data alone.
 - **Read vs write:** For open-ended/ambiguous requests run safe read-only commands first to understand the current state. When the user **explicitly** asks to create, update, delete, configure, or run something — do it directly; no need to ask for confirmation unless the scope is genuinely unclear.
 - **Package installation:** Install any package required to complete the task. Include the install step as its own phase so you can confirm it succeeded before building on it. Prefer project-local or user scope; avoid \`sudo\`/admin unless the user explicitly asks.
-${config_1.config.browserDebugPort !== undefined ? `- **Browser automation:** When the user explicitly asks to interact with a browser (click a button, fill a form, check a page, take a screenshot, etc.), generate \`<shell_script>\` blocks that use Node.js and \`playwright-core\` — one phase at a time (phasing rules below apply).
+${config_1.config.browserDebugPort !== undefined
+        ? `- **Browser automation:** Use browser automation proactively when needed to complete the task.
+  - Do NOT wait for explicit user wording like "use browser" if interaction is obviously required to get the final result.
+  - If \`web_search\` / \`web_fetch\` do not provide enough usable context (blocked pages, incomplete data, client-rendered content, auth walls, dynamic tables, hidden details, repeated low-value fetch results), immediately switch to Playwright-based browser interaction.
+  - Generate \`<shell_script>\` blocks that use Node.js and \`playwright-core\` — one phase at a time (phasing rules below apply).
   - **Phase 1 — ensure deps:** Check and install \`playwright-core\` if missing:
     \`node -e "require('/tmp/playwright-runner/node_modules/playwright-core')" 2>/dev/null || npm install --prefix /tmp/playwright-runner playwright-core --silent\`
-  - **Phase 2 — connect & navigate:** Try CDP first; fall back to the existing debug profile. Reuse an open tab if the URL already matches — never open a duplicate.
-    \`\`\`js
-    const { chromium } = require('/tmp/playwright-runner/node_modules/playwright-core');
-    let browser, page;
-    try {
-      browser = await chromium.connectOverCDP('http://localhost:${config_1.config.browserDebugPort}');
-      const pages = browser.contexts().flatMap(c => c.pages());
-      page = pages.find(p => p.url().startsWith(TARGET_URL)) ?? null;
-      if (page) { await page.bringToFront(); }
-      else { page = await browser.contexts()[0].newPage(); await page.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: 15000 }); }
-    } catch {
-      const ctx = await chromium.launchPersistentContext('${config_1.config.browserDebugUserDataDir}', { executablePath: '${config_1.config.browserDebugExecutable}', headless: false });
-      browser = ctx;
-      page = ctx.pages().find(p => p.url().startsWith(TARGET_URL)) ?? await ctx.newPage();
-      if (!page.url().startsWith(TARGET_URL)) await page.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: 15000 });
-    }
-    \`\`\`
-  - **Phase 3+ — one action per script:** Each subsequent script reconnects the same way, finds the already-open tab, performs exactly one action (click / type / select / screenshot / read text), prints the result, then calls \`browser.disconnect()\` (CDP) or just exits (profile launch — leaves the window open).
-  - Always inline Node.js via a bash heredoc so the script is self-contained. Print structured output to stdout so it returns as \`TERMINAL OUTPUT:\`.` : ''}
+  - **Phase 2 — connect & navigate:** Connect to the running browser via CDP at \`http://localhost:${config_1.config.browserDebugPort}\`. If CDP fails, fall back to launching a persistent context using the debug profile at \`${config_1.config.browserDebugUserDataDir}\` with the executable at \`${config_1.config.browserDebugExecutable}\` (headless: false). Once connected, navigate to any URL required by the task — open any page needed, reusing an existing tab if the URL already matches or creating a new one if not. There is no restriction on which sites or pages you can visit; open whatever is necessary to complete the task.
+  - **Phase 3+ — one action per script:** Each subsequent script reconnects via the same CDP endpoint (\`http://localhost:${config_1.config.browserDebugPort}\`) or profile fallback, finds the already-open tab (or reopens it), performs exactly one action (click, type, select, scroll, screenshot, read text, extract data, fill forms, etc.), prints the result to stdout, then calls \`browser.disconnect()\` (CDP) or exits (profile launch). You may perform any interaction the task requires — reading content, extracting structured data, submitting forms, navigating between pages, or capturing screenshots.
+  - Always inline Node.js via a bash heredoc so the script is self-contained. Print structured output to stdout so it returns as \`TERMINAL OUTPUT:\`.`
+        : ''}
 - Use ${!isWindows ? 'bash (macOS/Linux)' : 'PowerShell'}. Every script must be self-contained and ready to run as-is.
 - Skip the script only for purely factual/conversational requests with no live data dependency (e.g. "what is 2+2").
 

package/backend-dist/agent/agentServer.js

@@ -171,10 +171,6 @@ async function runToolLoop(initialResult, session, sessionId, send, log, tools,
     return result;
 }
 const aiModel = (0, ai_client_1.getDefaultModel)(config_1.config.aiProvider, 'smart');
-// In-memory cache: sessionId -> live SessionState. Hydrated from DB on first
-// access and written back after each turn so restarts resume correctly.
-const sessionMessages = new Map();
-const MAX_TURNS = 20;
 // ─── DB helpers ───────────────────────────────────────────────────────────────
 async function persistSessionToDB(sessionId, state) {
     try {
@@ -216,22 +212,7 @@ async function enforceSessionCap(subscriptionId, logger) {
     }
 }
 async function getOrCreateSession(sessionId, subscription, platform, log, isCronJob = false) {
-    // 1. Return the live in-memory entry if already loaded this process lifetime.
-    const existing = sessionMessages.get(sessionId);
-    if (existing) {
-        log.debug('Reusing existing agent session (in-memory)', {
-            sessionId,
-            subscriptionId: existing.subscription.id,
-            turns: existing.turns,
-        });
-        return {
-            sessionState: existing,
-            hasStoredPrompt: existing.history
-                .filter((h) => h.role === 'user')
-                .some((h) => typeof h.content === 'string' && h.content.includes('<stored_instructions>')),
-        };
-    }
-    // 2. Try to resume from a persisted DB record.
+    // 1. Try to resume from a persisted DB record.
     try {
         const dbSession = await agentSession_1.AgentSession.findOne({
             where: { id: sessionId, subscriptionId: subscription.id },
@@ -243,7 +224,6 @@ async function getOrCreateSession(sessionId, subscription, platform, log, isCron
                 history,
                 turns: dbSession.turns,
             };
-            sessionMessages.set(sessionId, entry);
             log.info('Resumed agent session from DB', {
                 sessionId,
                 subscriptionId: subscription.id,
@@ -263,7 +243,7 @@ async function getOrCreateSession(sessionId, subscription, platform, log, isCron
             error: err,
         });
     }
-    // 3. Create a brand-new session in-memory and persist it to the DB.
+    // 2. Create a brand-new session and persist it to the DB.
     const prompt = await (0, featureRoutes_1.getPromptForCommand)(log, 'task', subscription).catch((err) => {
         log.error('Failed to get system prompt for new agent session', { error: err });
         return '';
@@ -293,18 +273,39 @@ ${prompt}
         ],
         turns: 0,
     };
-    sessionMessages.set(sessionId, entry);
     // Persist immediately so that GET /sessions picks it up right away.
     try {
-        await agentSession_1.AgentSession.create({
-            id: sessionId,
-            subscriptionId: subscription.id,
-            title: 'New Session',
-            platform: platform ?? null,
-            historyJson: JSON.stringify(entry.history),
-            turns: 0,
-            lastActiveAt: new Date(),
+        const [dbSession, created] = await agentSession_1.AgentSession.findOrCreate({
+            where: { id: sessionId, subscriptionId: subscription.id },
+            defaults: {
+                id: sessionId,
+                subscriptionId: subscription.id,
+                title: 'New Session',
+                platform: platform ?? null,
+                historyJson: JSON.stringify(entry.history),
+                turns: 0,
+                lastActiveAt: new Date(),
+            },
         });
+        if (!created) {
+            const history = JSON.parse(dbSession.historyJson || '[]');
+            const existingEntry = {
+                subscription,
+                history,
+                turns: dbSession.turns,
+            };
+            log.info('Reused existing agent session row from DB during create path', {
+                sessionId,
+                subscriptionId: subscription.id,
+                turns: existingEntry.turns,
+            });
+            return {
+                sessionState: existingEntry,
+                hasStoredPrompt: history
+                    .filter((h) => h.role === 'user')
+                    .some((h) => typeof h.content === 'string' && h.content.includes('<stored_instructions>')),
+            };
+        }
         // Prune oldest sessions after each creation so the cap is always respected.
         void enforceSessionCap(subscription.id, log);
     }
@@ -321,7 +322,7 @@ ${prompt}
         hasStoredPrompt: !!prompt,
     };
 }
-async function runAgentTurn(sessionId, subscription, clientMessage, send, log, options) {
+async function runAgentTurnInternal(sessionId, subscription, clientMessage, send, log, options) {
     const { sessionState: session, hasStoredPrompt } = await getOrCreateSession(sessionId, subscription, clientMessage.platform, log, options?.isCronJob);
     // Count this call as one agent iteration.
     session.turns += 1;
@@ -330,14 +331,6 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
         subscriptionId: subscription.id,
         turn: session.turns,
     });
-    const effectiveMaxTurns = options?.maxTurns ?? MAX_TURNS;
-    // On the final iteration, instruct the LLM to provide a consolidated answer.
-    if (session.turns === effectiveMaxTurns) {
-        (0, utils_1.pushToSessionHistory)(logger_1.logger, session, {
-            role: 'system',
-            content: 'Provide a single, final, concise answer based on the entire conversation so far. Wrap the answer in a <final_answer>...</final_answer> block and do not ask for further input or mention additional shell scripts to run. Do not include any <shell_script> block in this response.',
-        });
-    }
     // Append the client message as user content, marking terminal
     // output and errors in the text so the agent can reason about them.
     let userContent = clientMessage.content || '';
@@ -386,10 +379,7 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
             }
         }
     }
-    // On the final turn we omit tools so the model is forced to emit a
-    // plain text <final_answer> rather than issuing another tool call.
-    const isFinalTurn = session.turns >= effectiveMaxTurns;
-    const tools = isFinalTurn ? undefined : (0, utils_1.buildAvailableTools)();
+    const tools = (0, utils_1.buildAvailableTools)();
     const recordUsage = async (result) => {
         const usage = result.usage;
         if (!usage)
@@ -445,13 +435,12 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
             log.warn('Agent LLM returned empty content; sending generic error to client.');
             const errorMessage = 'The agent returned an empty response. Please try again.';
             await persistSessionToDB(sessionId, session);
-            sessionMessages.delete(sessionId);
             (0, utils_1.sendFinalAnswer)(send, sessionId, errorMessage, true);
             return;
         }
         // If the model requested web tool calls, execute them and get a follow-up
         // response before deciding what to send to the client.
-        if (!isFinalTurn && result.finish_reason === 'tool_calls') {
+        if (result.finish_reason === 'tool_calls') {
             log.info('Running web tool calls to gather information', {
                 sessionId,
                 subscriptionId: subscription.id,
@@ -506,7 +495,10 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
                             'No plain text. No other format.',
                         ].join('\n'),
                 });
-                await runAgentTurn(sessionId, subscription, {
+                // DB-only session state: persist before recursive handoff so the
+                // follow-up turn reads the latest history and turn count.
+                await persistSessionToDB(sessionId, session);
+                await runAgentTurnInternal(sessionId, subscription, {
                     sender: 'agent',
                     session_id: sessionId,
                     content: '',
@@ -515,15 +507,9 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
                 return;
             }
         }
-        // Ensure that a proper <final_answer> block is produced for the
-        // desktop clients once we reach the final turn. If the model did
-        // not emit either a <shell_script> or <final_answer> tag on the
-        // MAX_TURNS turn, we treat this as the final natural-language answer
-        // and wrap it in <final_answer> tags so the client can stop
-        // waiting and paste the result.
         const hasShellScriptTag = content.includes('<shell_script>');
         const hasFinalAnswerTag = content.includes('<final_answer>');
-        if (hasShellScriptTag && !isFinalTurn) {
+        if (hasShellScriptTag) {
             log.info('Completed agent turn. Sending back scripts, waiting for results.', {
                 sessionId,
                 subscriptionId: subscription.id,
@@ -534,6 +520,10 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
                 role: 'assistant',
                 content,
             });
+            // Persist before sending so that if the send callback triggers a new
+            // runAgentTurn immediately (e.g. cron shell-script loop), the DB already
+            // has the updated turn count and history.
+            await persistSessionToDB(sessionId, session);
             send({
                 session_id: sessionId,
                 sender: 'agent',
@@ -543,8 +533,8 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
             });
             return;
         }
-        if (isFinalTurn || hasFinalAnswerTag) {
-            log.info('Finalizing agent session after max turns or final answer tag', {
+        if (hasFinalAnswerTag) {
+            log.info('Finalizing agent session after final answer tag', {
                 sessionId,
                 subscriptionId: subscription.id,
                 turns: session.turns,
@@ -552,7 +542,6 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
             });
             (0, utils_1.pushToSessionHistory)(logger_1.logger, session, { role: 'assistant', content });
             await persistSessionToDB(sessionId, session);
-            sessionMessages.delete(sessionId);
             send({
                 session_id: sessionId,
                 sender: 'agent',
@@ -571,7 +560,6 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
             });
             (0, utils_1.pushToSessionHistory)(log, session, { role: 'assistant', content });
             await persistSessionToDB(sessionId, session);
-            sessionMessages.delete(sessionId);
             send({
                 session_id: sessionId,
                 sender: 'agent',
@@ -583,7 +571,6 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
                 sessionId,
             });
             await persistSessionToDB(sessionId, session);
-            sessionMessages.delete(sessionId);
             (0, utils_1.sendFinalAnswer)(send, sessionId, 'The agent returned an empty response. Please try again.', true);
         }
     }
@@ -591,10 +578,12 @@ async function runAgentTurn(sessionId, subscription, clientMessage, send, log, o
         log.error('Agent LLM call failed', { error: err });
         const errorMessage = 'Agent failed to call language model. Please try again later.';
         await persistSessionToDB(sessionId, session);
-        sessionMessages.delete(sessionId);
         (0, utils_1.sendFinalAnswer)(send, sessionId, errorMessage, true);
     }
 }
+async function runAgentTurn(sessionId, subscription, clientMessage, send, log, options) {
+    await runAgentTurnInternal(sessionId, subscription, clientMessage, send, log, options);
+}
 function attachAgentWebSocketServer(server) {
     const wss = new ws_1.WebSocketServer({ server, path: '/ws/omni-agent' });
     wss.on('connection', (ws, req) => {
@@ -731,8 +720,6 @@ function createAgentRouter() {
                 res.status(404).json({ error: 'Session not found' });
                 return;
             }
-            // Also remove from the in-memory cache if it was loaded.
-            sessionMessages.delete(sessionId);
             res.status(200).json({ deleted: true });
         }
         catch (err) {

package/backend-dist/authMiddleware.js

@@ -10,18 +10,33 @@ const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const logger_1 = require("./logger");
 const config_1 = require("./config");
 const subscription_1 = require("./models/subscription");
+const SELF_HOSTED_SUBSCRIPTION_ID = 'self-hosted-local-subscription';
 async function selfHostedSubscription() {
     try {
-        let subscription = await subscription_1.Subscription.findOne({ where: { isSelfHosted: true } });
-        if (!subscription) {
-            subscription = await subscription_1.Subscription.create({
+        // Reuse any existing self-hosted record (including legacy IDs) first.
+        const existing = await subscription_1.Subscription.findOne({ where: { isSelfHosted: true } });
+        if (existing)
+            return existing;
+        // Use a deterministic primary key so concurrent first-time requests do not
+        // create duplicate rows.
+        const [subscription, created] = await subscription_1.Subscription.findOrCreate({
+            where: { id: SELF_HOSTED_SUBSCRIPTION_ID },
+            defaults: {
+                id: SELF_HOSTED_SUBSCRIPTION_ID,
                 email: 'local-user@omnikey.ai',
                 licenseKey: 'self-hosted',
                 subscriptionStatus: 'active',
                 isSelfHosted: true,
-            });
+            },
+        });
+        if (created) {
             logger_1.logger.info('Created self-hosted subscription record in database.');
         }
+        // Ensure deterministic row remains flagged for self-hosted mode.
+        if (!subscription.isSelfHosted) {
+            subscription.isSelfHosted = true;
+            await subscription.save();
+        }
         return subscription;
     }
     catch (err) {
@@ -31,37 +46,37 @@ async function selfHostedSubscription() {
 }
 async function authMiddleware(req, res, next) {
     const authHeader = req.headers.authorization;
-    logger_1.logger.defaultMeta = { traceId: (0, crypto_1.randomUUID)() };
+    const requestLogger = logger_1.logger.child({ traceId: (0, crypto_1.randomUUID)() });
+    res.locals.logger = requestLogger;
     if (config_1.config.blockSaas) {
-        logger_1.logger.warn('Blocking SaaS access: rejecting request due to BLOCK_SAAS=true');
+        requestLogger.warn('Blocking SaaS access: rejecting request due to BLOCK_SAAS=true');
         return res.status(403).json({ error: 'SaaS access is blocked.' });
     }
     if (config_1.config.isSelfHosted || !config_1.config.jwtSecret) {
-        logger_1.logger.info('Self-hosted mode: skipping auth middleware.');
+        requestLogger.info('Self-hosted mode: skipping auth middleware.');
         if (config_1.config.isSelfHosted) {
             res.locals.subscription = await selfHostedSubscription();
-            res.locals.logger = logger_1.logger;
         }
         return next();
     }
     if (!authHeader) {
-        logger_1.logger.warn('Missing Authorization header on feature route.');
+        requestLogger.warn('Missing Authorization header on feature route.');
         return res.status(401).json({ error: 'Missing bearer token.' });
     }
     const [scheme, token] = authHeader.split(' ');
     if (scheme !== 'Bearer' || !token) {
-        logger_1.logger.warn('Malformed Authorization header on feature route.');
+        requestLogger.warn('Malformed Authorization header on feature route.');
         return res.status(401).json({ error: 'Invalid authorization header.' });
     }
     try {
         const decoded = jsonwebtoken_1.default.verify(token, config_1.config.jwtSecret);
         const subscription = await subscription_1.Subscription.findByPk(decoded.sid);
         if (!subscription) {
-            logger_1.logger.warn('Subscription not found for JWT.', { sid: decoded.sid });
+            requestLogger.warn('Subscription not found for JWT.', { sid: decoded.sid });
             return res.status(403).json({ error: 'Invalid or expired token.' });
         }
         if (subscription.subscriptionStatus == 'expired') {
-            logger_1.logger.warn('Inactive subscription for JWT.', {
+            requestLogger.warn('Inactive subscription for JWT.', {
                 sid: decoded.sid,
                 status: subscription.subscriptionStatus,
             });
@@ -71,19 +86,18 @@ async function authMiddleware(req, res, next) {
         if (subscription.licenseKeyExpiresAt && subscription.licenseKeyExpiresAt <= now) {
             subscription.subscriptionStatus = 'expired';
             await subscription.save();
-            logger_1.logger.info('Subscription key has expired during activation.', {
+            requestLogger.info('Subscription key has expired during activation.', {
                 subscriptionId: subscription.id,
             });
             return res
                 .status(403)
                 .json({ error: 'Subscription has expired.', subscriptionStatus: 'expired' });
         }
-        res.locals.logger = logger_1.logger;
         res.locals.subscription = subscription;
         next();
     }
     catch (err) {
-        logger_1.logger.warn('Invalid or expired JWT on feature route.', { error: err });
+        requestLogger.warn('Invalid or expired JWT on feature route.', { error: err });
         return res.status(403).json({ error: 'Invalid or expired token.' });
     }
 }

package/backend-dist/bucket-adapter/index.js

@@ -3,9 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDownloadCounts = getDownloadCounts;
 exports.incrementDownloadCount = incrementDownloadCount;
 const storage_1 = require("@google-cloud/storage");
+const zod_1 = require("zod");
 const logger_1 = require("../logger");
 const config_1 = require("../config");
 const DEFAULT_COUNTS = { macos: 0, windows: 0 };
+const downloadCountsSchema = zod_1.z.object({
+    macos: zod_1.z.number().nonnegative().optional(),
+    windows: zod_1.z.number().nonnegative().optional(),
+});
+function parseDownloadCounts(raw) {
+    const json = JSON.parse(raw);
+    const parsed = downloadCountsSchema.safeParse(json);
+    if (!parsed.success) {
+        return { ...DEFAULT_COUNTS };
+    }
+    return {
+        macos: parsed.data.macos ?? 0,
+        windows: parsed.data.windows ?? 0,
+    };
+}
 // Initialised once at module load — uses Application Default Credentials when
 // running on Cloud Run (or any GCP environment), and falls back to ADC from
 // the local environment during development.
@@ -30,28 +46,57 @@ async function readCounts(bucketName, objectPath) {
         return { ...DEFAULT_COUNTS };
     }
     const [contents] = await file.download();
-    const parsed = JSON.parse(contents.toString('utf8'));
+    return parseDownloadCounts(contents.toString('utf8'));
+}
+async function readCountsWithGeneration(bucketName, objectPath) {
+    const file = storage.bucket(bucketName).file(objectPath);
+    const [exists] = await file.exists();
+    if (!exists) {
+        return { counts: { ...DEFAULT_COUNTS }, generation: null, exists: false };
+    }
+    const [[metadata], [contents]] = await Promise.all([file.getMetadata(), file.download()]);
+    const counts = parseDownloadCounts(contents.toString('utf8'));
     return {
-        macos: typeof parsed.macos === 'number' ? parsed.macos : 0,
-        windows: typeof parsed.windows === 'number' ? parsed.windows : 0,
+        counts,
+        generation: metadata.generation ?? null,
+        exists: true,
     };
 }
-async function writeCounts(bucketName, objectPath, counts) {
-    const file = storage.bucket(bucketName).file(objectPath);
-    await file.save(JSON.stringify(counts), {
-        contentType: 'application/json',
-        resumable: false,
-    });
+function isGcsPreconditionError(err) {
+    const maybe = err;
+    return (maybe?.code === 412 ||
+        maybe?.message?.includes('conditionNotMet') === true ||
+        maybe?.message?.includes('Precondition Failed') === true);
 }
 async function incrementDownloadCount(platform) {
     const gcs = getGcsConfig();
     if (!gcs)
         return;
+    const file = storage.bucket(gcs.bucketName).file(gcs.objectPath);
+    const MAX_RETRIES = 6;
     try {
-        const counts = await readCounts(gcs.bucketName, gcs.objectPath);
-        counts[platform] += 1;
-        await writeCounts(gcs.bucketName, gcs.objectPath, counts);
-        logger_1.logger.info(`Download count incremented for ${platform}.`, { counts });
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            const { counts, generation, exists } = await readCountsWithGeneration(gcs.bucketName, gcs.objectPath);
+            counts[platform] += 1;
+            try {
+                await file.save(JSON.stringify(counts), {
+                    contentType: 'application/json',
+                    resumable: false,
+                    preconditionOpts: exists
+                        ? { ifGenerationMatch: Number(generation) }
+                        : { ifGenerationMatch: 0 },
+                });
+                logger_1.logger.info(`Download count incremented for ${platform}.`, { counts, attempt });
+                return;
+            }
+            catch (err) {
+                if (isGcsPreconditionError(err) && attempt < MAX_RETRIES) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        logger_1.logger.warn(`Download count increment exhausted retries for ${platform}.`);
     }
     catch (err) {
         logger_1.logger.error(`Failed to increment download count for ${platform}.`, { error: err });

package/backend-dist/scheduledJobExecutor.js

@@ -144,7 +144,7 @@ function runCronJob(job, subscription, sessionId) {
                         content: output,
                         is_terminal_output: true,
                         is_error: isError,
-                    }, send, logger_1.logger, { maxTurns: MAX_CRON_TURNS, isCronJob: true }).catch((err) => settle(err instanceof Error ? err : new Error(String(err))));
+                    }, send, logger_1.logger, { isCronJob: true }).catch((err) => settle(err instanceof Error ? err : new Error(String(err))));
                     return;
                 }
                 if (FINAL_ANSWER_RE.test(content)) {
@@ -158,7 +158,7 @@ function runCronJob(job, subscription, sessionId) {
             sender: 'user',
             content: job.prompt,
             platform: job.platform ?? undefined,
-        }, send, logger_1.logger, { maxTurns: MAX_CRON_TURNS, isCronJob: true }).catch((err) => settle(err instanceof Error ? err : new Error(String(err))));
+        }, send, logger_1.logger, { isCronJob: true }).catch((err) => settle(err instanceof Error ? err : new Error(String(err))));
     });
 }
 async function executeJob(job) {

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.0.35",
+  "version": "1.0.37",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",