omnikey-cli 1.0.27 → 1.0.29

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDownloadCounts = getDownloadCounts;
+exports.incrementDownloadCount = incrementDownloadCount;
+const storage_1 = require("@google-cloud/storage");
+const logger_1 = require("../logger");
+const config_1 = require("../config");
+const DEFAULT_COUNTS = { macos: 0, 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.
+const storage = new storage_1.Storage();
+function getGcsConfig() {
+    const bucketName = config_1.config.gcsBucketName;
+    const objectPath = config_1.config.gcsDownloadCountObject;
+    if (!bucketName || !objectPath)
+        return null;
+    return { bucketName, objectPath };
+}
+async function getDownloadCounts() {
+    const gcs = getGcsConfig();
+    if (!gcs)
+        return { ...DEFAULT_COUNTS };
+    return readCounts(gcs.bucketName, gcs.objectPath);
+}
+async function readCounts(bucketName, objectPath) {
+    const file = storage.bucket(bucketName).file(objectPath);
+    const [exists] = await file.exists();
+    if (!exists) {
+        return { ...DEFAULT_COUNTS };
+    }
+    const [contents] = await file.download();
+    const parsed = JSON.parse(contents.toString('utf8'));
+    return {
+        macos: typeof parsed.macos === 'number' ? parsed.macos : 0,
+        windows: typeof parsed.windows === 'number' ? parsed.windows : 0,
+    };
+}
+async function writeCounts(bucketName, objectPath, counts) {
+    const file = storage.bucket(bucketName).file(objectPath);
+    await file.save(JSON.stringify(counts), {
+        contentType: 'application/json',
+        resumable: false,
+    });
+}
+async function incrementDownloadCount(platform) {
+    const gcs = getGcsConfig();
+    if (!gcs)
+        return;
+    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 });
+    }
+    catch (err) {
+        logger_1.logger.error(`Failed to increment download count for ${platform}.`, { error: err });
+    }
+}

package/backend-dist/config.js

@@ -93,4 +93,15 @@ exports.config = {
     searxngUrl: getEnv('SEARXNG_URL', false),
     terminalPlatform: getEnv('TERMINAL_PLATFORM', false),
     blockSaas: getBooleanEnv('BLOCK_SAAS', false),
+    // User-configured CDP debug port (set by `omnikey grant-browser-access`)
+    browserDebugPort: (() => {
+        const raw = getEnv('BROWSER_DEBUG_PORT', false);
+        if (!raw)
+            return undefined;
+        const n = parseInt(raw, 10);
+        return Number.isNaN(n) ? undefined : n;
+    })(),
+    // GCS download-count tracking (both must be set to enable counting)
+    gcsBucketName: getEnv('GCS_BUCKET_NAME', false),
+    gcsDownloadCountObject: getEnv('GCS_DOWNLOAD_COUNT_OBJECT', false),
 };

package/backend-dist/index.js

@@ -13,10 +13,14 @@ const featureRoutes_1 = require("./featureRoutes");
 const db_1 = require("./db");
 const logger_1 = require("./logger");
 const taskInstructionRoutes_1 = require("./taskInstructionRoutes");
+const scheduledJobRoutes_1 = require("./scheduledJobRoutes");
+const scheduledJobExecutor_1 = require("./scheduledJobExecutor");
 const config_1 = require("./config");
 const agentServer_1 = require("./agent/agentServer");
-// Importing AgentSession ensures the model is registered with Sequelize before initDatabase().
+// Importing AgentSession and ScheduledJob ensures the models are registered with Sequelize before initDatabase().
 require("./models/agentSession");
+require("./models/scheduledJob");
+const bucket_adapter_1 = require("./bucket-adapter");
 const app = (0, express_1.default)();
 const PORT = Number(config_1.config.port);
 app.set('trust proxy', 1);
@@ -27,6 +31,7 @@ app.use(express_1.default.static(path_1.default.join(process.cwd(), 'public')));
 app.use('/api/subscription', (0, subscriptionRoutes_1.createSubscriptionRouter)(logger_1.logger));
 app.use('/api/feature', (0, featureRoutes_1.createFeatureRouter)());
 app.use('/api/instructions', (0, taskInstructionRoutes_1.taskInstructionRouter)());
+app.use('/api/scheduled-jobs', (0, scheduledJobRoutes_1.scheduledJobRouter)());
 app.use('/api/agent', (0, agentServer_1.createAgentRouter)());
 app.get('/macos/download', (_req, res) => {
     const dmgPath = path_1.default.join(process.cwd(), 'macOS', 'OmniKeyAI.dmg');
@@ -39,6 +44,7 @@ app.get('/macos/download', (_req, res) => {
         'Content-Disposition': 'attachment; filename="OmniKeyAI.dmg"',
         'Content-Encoding': 'gzip',
     });
+    (0, bucket_adapter_1.incrementDownloadCount)('macos').catch(() => { });
     const fileStream = fs_1.default.createReadStream(dmgPath);
     const gzip = zlib_1.default.createGzip();
     fileStream.on('error', (err) => {
@@ -68,8 +74,8 @@ app.get('/macos/appcast', (req, res) => {
     const appcastUrl = `${baseUrl}/macos/appcast`;
     // These should match the values embedded into the macOS app
     // Info.plist in macOS/build_release_dmg.sh.
-    const bundleVersion = '21';
-    const shortVersion = '1.0.20';
+    const bundleVersion = '23';
+    const shortVersion = '1.0.22';
     const xml = `<?xml version="1.0" encoding="utf-8"?>
 <rss version="2.0"
      xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"
@@ -97,7 +103,7 @@ app.get('/macos/appcast', (req, res) => {
 // ── Windows distribution endpoints ───────────────────────────────────────────
 // These should match the values in windows/OmniKey.Windows.csproj
 // <Version> and windows/build_release_zip.ps1 $APP_VERSION.
-const WIN_VERSION = '1.7';
+const WIN_VERSION = '1.9';
 const WIN_ZIP_FILENAME = 'OmniKeyAI-windows-win-x64.zip';
 const WIN_ZIP_PATH = path_1.default.join(process.cwd(), 'windows', WIN_ZIP_FILENAME);
 // Serves the pre-built ZIP produced by windows/build_release_zip.ps1.
@@ -112,6 +118,7 @@ app.get('/windows/download', (_req, res) => {
         'Content-Disposition': `attachment; filename="${WIN_ZIP_FILENAME}"`,
         'Content-Encoding': 'gzip',
     });
+    (0, bucket_adapter_1.incrementDownloadCount)('windows').catch(() => { });
     const fileStream = fs_1.default.createReadStream(WIN_ZIP_PATH);
     const gzip = zlib_1.default.createGzip();
     fileStream.on('error', (err) => {
@@ -138,9 +145,19 @@ app.get('/windows/update', (req, res) => {
         version: WIN_VERSION,
         downloadUrl: `${baseUrl}/windows/download`,
         fileSize,
-        releaseNotes: '',
+        releaseNotes: `What's new in ${WIN_VERSION}\n\n• New cron job automation (Scheduled Jobs) — create recurring jobs with cron-style schedules or one-time jobs to run prompts automatically in the background.\n• Scheduled Jobs controls — add jobs, activate/deactivate them, run now on demand, refresh status, and view last-run history in the app.\n• OmniAgent session management — choose to start a new session or resume an existing one each time you run @omniAgent. Save a default to skip the picker automatically on future runs.\n• History button in the OmniAgent window — change your default session at any time without re-running the agent.\n• OmniAgent Session tray menu item — open session settings directly from the system tray.\n• Left-clicking the tray icon now opens the menu (previously right-click only).\n• Manual updated with detailed OmniAgent, session management, web search provider, and LLM provider documentation.`,
     });
 });
+app.get('/downloads/stats', async (_req, res) => {
+    try {
+        const counts = await (0, bucket_adapter_1.getDownloadCounts)();
+        res.json(counts);
+    }
+    catch (err) {
+        logger_1.logger.error('Failed to retrieve download stats.', { error: err });
+        res.status(500).json({ error: 'Unable to retrieve download stats.' });
+    }
+});
 app.get('/health', (_req, res) => {
     res.json({ status: 'ok' });
 });
@@ -154,6 +171,7 @@ async function start() {
         server = app.listen(PORT, () => {
             logger_1.logger.info(`Enhancer API listening on http://localhost:${PORT}`, {
                 isSelfHosted: config_1.config.isSelfHosted,
+                aiProvider: config_1.config.aiProvider,
             });
         });
         // Attach the WebSocket-based agent server to the existing HTTP
@@ -162,6 +180,9 @@ async function start() {
         if (server) {
             (0, agentServer_1.attachAgentWebSocketServer)(server);
         }
+        if (config_1.config.isSelfHosted) {
+            (0, scheduledJobExecutor_1.startScheduledJobExecutor)();
+        }
     }
     catch (err) {
         logger_1.logger.error('Failed to start server due to DB error.', { error: err });

package/backend-dist/models/scheduledJob.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledJob = void 0;
+const sequelize_1 = require("sequelize");
+const cuid_1 = __importDefault(require("cuid"));
+const db_1 = require("../db");
+const subscription_1 = require("./subscription");
+class ScheduledJob extends sequelize_1.Model {
+}
+exports.ScheduledJob = ScheduledJob;
+ScheduledJob.init({
+    id: {
+        type: sequelize_1.DataTypes.STRING,
+        primaryKey: true,
+        allowNull: false,
+        defaultValue: () => (0, cuid_1.default)(),
+    },
+    subscriptionId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: false,
+        field: 'subscription_id',
+        references: {
+            model: subscription_1.Subscription,
+            key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+    },
+    label: {
+        type: sequelize_1.DataTypes.STRING(200),
+        allowNull: false,
+    },
+    prompt: {
+        type: sequelize_1.DataTypes.TEXT,
+        allowNull: false,
+    },
+    cronExpression: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'cron_expression',
+    },
+    runAt: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'run_at',
+    },
+    isActive: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+        field: 'is_active',
+    },
+    lastRunAt: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'last_run_at',
+    },
+    nextRunAt: {
+        type: sequelize_1.DataTypes.DATE,
+        allowNull: true,
+        field: 'next_run_at',
+    },
+    sessionId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'session_id',
+    },
+    lastRunSessionId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'last_run_session_id',
+    },
+    platform: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+    },
+}, {
+    sequelize: db_1.sequelize,
+    tableName: 'scheduled_jobs',
+    modelName: 'ScheduledJob',
+    indexes: [
+        {
+            fields: ['subscription_id', 'next_run_at'],
+        },
+    ],
+});
+subscription_1.Subscription.hasMany(ScheduledJob, {
+    foreignKey: 'subscriptionId',
+    as: 'scheduledJobs',
+});
+ScheduledJob.belongsTo(subscription_1.Subscription, {
+    foreignKey: 'subscriptionId',
+    as: 'subscription',
+});

package/backend-dist/scheduledJobExecutor.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeNextRunAt = computeNextRunAt;
+exports.startScheduledJobExecutor = startScheduledJobExecutor;
+exports.executeJob = executeJob;
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const cuid_1 = __importDefault(require("cuid"));
+const sequelize_1 = require("sequelize");
+const cron_parser_1 = require("cron-parser");
+const scheduledJob_1 = require("./models/scheduledJob");
+const subscription_1 = require("./models/subscription");
+const logger_1 = require("./logger");
+const agentServer_1 = require("./agent/agentServer");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const SHELL_SCRIPT_RE = /<shell_script>([\s\S]*?)<\/shell_script>/;
+const FINAL_ANSWER_RE = /<final_answer>/;
+// Maximum time a single job may run before it is forcibly cancelled.
+const JOB_TIMEOUT_MS = 10 * 60 * 1000;
+// Cron jobs get more turns than interactive sessions so multi-step tasks
+// (web research → shell commands → final answer) can complete unattended.
+const MAX_CRON_TURNS = 20;
+function computeNextRunAt(cronExpression, runAt) {
+    if (cronExpression) {
+        try {
+            const interval = (0, cron_parser_1.parseExpression)(cronExpression, { currentDate: new Date() });
+            return interval.next().toDate();
+        }
+        catch {
+            return null;
+        }
+    }
+    if (runAt && runAt > new Date()) {
+        return runAt;
+    }
+    return null;
+}
+function startScheduledJobExecutor() {
+    logger_1.logger.info('Scheduled job executor started.');
+    void executeDueJobs();
+    setInterval(() => void executeDueJobs(), 60000);
+}
+async function executeDueJobs() {
+    try {
+        const now = new Date();
+        const dueJobs = await scheduledJob_1.ScheduledJob.findAll({
+            where: {
+                nextRunAt: { [sequelize_1.Op.lte]: now },
+                isActive: true,
+            },
+        });
+        if (dueJobs.length > 0) {
+            logger_1.logger.info(`Executing ${dueJobs.length} due scheduled job(s).`);
+        }
+        for (const job of dueJobs) {
+            void executeJob(job).catch((err) => {
+                logger_1.logger.error('Scheduled job execution failed.', { jobId: job.id, error: err });
+            });
+        }
+    }
+    catch (err) {
+        logger_1.logger.error('Error polling for due scheduled jobs.', { error: err });
+    }
+}
+// Runs the script in the user's login shell so PATH and profile env-vars are
+// present — identical to how the desktop apps open a terminal. Writing to a
+// temp file avoids quoting/escaping issues with multi-line scripts.
+async function runScript(script) {
+    const isWin = process.platform === 'win32';
+    const userHome = process.env.HOME ?? process.env.USERPROFILE ?? process.cwd();
+    const userShell = isWin ? (process.env.COMSPEC ?? 'cmd.exe') : (process.env.SHELL ?? '/bin/zsh');
+    const ext = isWin ? '.bat' : '.sh';
+    const tmpFile = path_1.default.join((0, os_1.tmpdir)(), `cron_${(0, cuid_1.default)()}${ext}`);
+    try {
+        if (isWin) {
+            await (0, promises_1.writeFile)(tmpFile, `@echo off\r\n${script}`, 'utf8');
+        }
+        else {
+            await (0, promises_1.writeFile)(tmpFile, script, { encoding: 'utf8', mode: 0o700 });
+        }
+        // -l = login shell → sources ~/.zprofile / ~/.bash_profile etc.
+        const command = isWin ? `"${tmpFile}"` : `"${userShell}" -l "${tmpFile}"`;
+        const { stdout, stderr } = await execAsync(command, {
+            timeout: 60000,
+            cwd: userHome,
+            env: process.env,
+        });
+        const combined = [stdout, stderr ? `STDERR:\n${stderr}` : ''].filter(Boolean).join('\n').trim();
+        return { output: combined || '(no output)', isError: false };
+    }
+    catch (err) {
+        const combined = [err.stdout ?? '', err.stderr ?? ''].filter(Boolean).join('\n').trim();
+        return { output: combined || err.message || 'Command failed', isError: true };
+    }
+    finally {
+        (0, promises_1.unlink)(tmpFile).catch(() => { });
+    }
+}
+function runCronJob(job, subscription, sessionId) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutHandle);
+            err ? reject(err) : resolve();
+        };
+        const timeoutHandle = setTimeout(() => settle(new Error(`Cron job ${job.id} timed out after ${JOB_TIMEOUT_MS / 60000} minutes`)), JOB_TIMEOUT_MS);
+        const send = (msg) => {
+            if (settled)
+                return;
+            void (async () => {
+                const content = msg.content ?? '';
+                if (msg.is_error) {
+                    logger_1.logger.error('Cron job: agent returned error.', {
+                        jobId: job.id,
+                        content: content.slice(0, 300),
+                    });
+                    settle(new Error(`Agent error: ${content.slice(0, 200)}`));
+                    return;
+                }
+                const scriptMatch = SHELL_SCRIPT_RE.exec(content);
+                if (scriptMatch) {
+                    const script = scriptMatch[1].trim();
+                    logger_1.logger.info('Cron job: executing shell script.', { jobId: job.id });
+                    const { output, isError } = await runScript(script);
+                    logger_1.logger.info('Cron job: shell script finished.', {
+                        jobId: job.id,
+                        isError,
+                        outputLength: output.length,
+                    });
+                    if (settled)
+                        return;
+                    (0, agentServer_1.runAgentTurn)(sessionId, subscription, {
+                        session_id: sessionId,
+                        sender: 'user',
+                        content: output,
+                        is_terminal_output: true,
+                        is_error: isError,
+                    }, send, logger_1.logger, { maxTurns: MAX_CRON_TURNS }).catch((err) => settle(err instanceof Error ? err : new Error(String(err))));
+                    return;
+                }
+                if (FINAL_ANSWER_RE.test(content)) {
+                    logger_1.logger.info('Cron job: received final answer.', { jobId: job.id });
+                    settle();
+                }
+            })();
+        };
+        (0, agentServer_1.runAgentTurn)(sessionId, subscription, {
+            session_id: sessionId,
+            sender: 'user',
+            content: job.prompt,
+            platform: job.platform ?? undefined,
+        }, send, logger_1.logger, { maxTurns: MAX_CRON_TURNS }).catch((err) => settle(err instanceof Error ? err : new Error(String(err))));
+    });
+}
+async function executeJob(job) {
+    logger_1.logger.info('Executing scheduled job.', { jobId: job.id, label: job.label });
+    const subscription = await subscription_1.Subscription.findByPk(job.subscriptionId);
+    if (!subscription) {
+        logger_1.logger.error('Subscription not found for scheduled job; skipping.', {
+            jobId: job.id,
+            subscriptionId: job.subscriptionId,
+        });
+        return;
+    }
+    const sessionId = (0, cuid_1.default)();
+    try {
+        await runCronJob(job, subscription, sessionId);
+        logger_1.logger.info('Scheduled job completed.', { jobId: job.id, label: job.label });
+    }
+    catch (err) {
+        logger_1.logger.error('Scheduled job failed.', { jobId: job.id, label: job.label, error: err });
+        // Fall through — always update lastRunAt so the next poll does not re-run immediately.
+    }
+    const now = new Date();
+    if (job.cronExpression) {
+        await job.update({
+            lastRunAt: now,
+            nextRunAt: computeNextRunAt(job.cronExpression, null),
+            lastRunSessionId: sessionId,
+        });
+    }
+    else {
+        await job.update({
+            lastRunAt: now,
+            isActive: false,
+            nextRunAt: null,
+            lastRunSessionId: sessionId,
+        });
+    }
+}

package/backend-dist/scheduledJobRoutes.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduledJobRouter = scheduledJobRouter;
+const express_1 = __importDefault(require("express"));
+const zod_1 = __importDefault(require("zod"));
+const authMiddleware_1 = require("./authMiddleware");
+const scheduledJob_1 = require("./models/scheduledJob");
+const scheduledJobExecutor_1 = require("./scheduledJobExecutor");
+const CRON_REGEX = /^(\S+\s){4}\S+$/;
+const jobSchema = zod_1.default.object({
+    label: zod_1.default.string().min(1).max(200),
+    prompt: zod_1.default.string().min(1),
+    cronExpression: zod_1.default.string().regex(CRON_REGEX, 'Invalid cron expression (must be 5 fields)').optional(),
+    runAt: zod_1.default.string().optional(),
+    isActive: zod_1.default.boolean().optional(),
+    sessionId: zod_1.default.string().nullable().optional(),
+    platform: zod_1.default.string().optional(),
+});
+function formatJob(job) {
+    return {
+        id: job.id,
+        label: job.label,
+        prompt: job.prompt,
+        cronExpression: job.cronExpression,
+        runAt: job.runAt,
+        isActive: job.isActive,
+        lastRunAt: job.lastRunAt,
+        nextRunAt: job.nextRunAt,
+        sessionId: job.sessionId,
+        lastRunSessionId: job.lastRunSessionId,
+        platform: job.platform,
+        createdAt: job.createdAt,
+        updatedAt: job.updatedAt,
+    };
+}
+function scheduledJobRouter() {
+    const router = express_1.default.Router();
+    router.get('/', authMiddleware_1.authMiddleware, async (req, res) => {
+        const { logger, subscription } = res.locals;
+        try {
+            const jobs = await scheduledJob_1.ScheduledJob.findAll({
+                where: { subscriptionId: subscription.id },
+                order: [['next_run_at', 'ASC NULLS LAST']],
+            });
+            res.json({ jobs: jobs.map(formatJob) });
+        }
+        catch (err) {
+            logger.error('Error retrieving scheduled jobs.', { error: err });
+            res.status(500).json({ error: 'Failed to retrieve scheduled jobs.' });
+        }
+    });
+    router.post('/', authMiddleware_1.authMiddleware, async (req, res) => {
+        const { logger, subscription } = res.locals;
+        try {
+            const parsed = jobSchema.parse(req.body);
+            const hasCron = !!parsed.cronExpression;
+            const hasRunAt = !!parsed.runAt;
+            if (!hasCron && !hasRunAt) {
+                return res.status(400).json({ error: 'Either cronExpression or runAt is required.' });
+            }
+            if (hasCron && hasRunAt) {
+                return res.status(400).json({ error: 'Provide either cronExpression or runAt, not both.' });
+            }
+            let runAt = null;
+            if (hasRunAt) {
+                runAt = new Date(parsed.runAt);
+                if (isNaN(runAt.getTime())) {
+                    return res.status(400).json({ error: 'Invalid runAt date.' });
+                }
+                if (runAt <= new Date()) {
+                    return res.status(400).json({ error: 'runAt must be in the future.' });
+                }
+            }
+            const nextRunAt = (0, scheduledJobExecutor_1.computeNextRunAt)(parsed.cronExpression ?? null, runAt);
+            const job = await scheduledJob_1.ScheduledJob.create({
+                subscriptionId: subscription.id,
+                label: parsed.label,
+                prompt: parsed.prompt,
+                cronExpression: parsed.cronExpression ?? null,
+                runAt,
+                isActive: parsed.isActive ?? true,
+                nextRunAt,
+                sessionId: parsed.sessionId ?? null,
+                platform: parsed.platform ?? null,
+            });
+            res.status(201).json(formatJob(job));
+        }
+        catch (err) {
+            logger.error('Error creating scheduled job.', { error: err });
+            if (err instanceof zod_1.default.ZodError) {
+                return res.status(400).json({ error: 'Invalid job data.' });
+            }
+            res.status(500).json({ error: 'Failed to create scheduled job.' });
+        }
+    });
+    router.put('/:id', authMiddleware_1.authMiddleware, async (req, res) => {
+        const { logger, subscription } = res.locals;
+        const { id } = req.params;
+        try {
+            const parsed = jobSchema.partial().parse(req.body);
+            const job = await scheduledJob_1.ScheduledJob.findOne({
+                where: { id, subscriptionId: subscription.id },
+            });
+            if (!job) {
+                return res.status(404).json({ error: 'Scheduled job not found.' });
+            }
+            const cronExpression = parsed.cronExpression !== undefined ? parsed.cronExpression ?? null : job.cronExpression;
+            let runAt = job.runAt;
+            if (parsed.runAt !== undefined) {
+                if (parsed.runAt) {
+                    runAt = new Date(parsed.runAt);
+                    if (isNaN(runAt.getTime())) {
+                        return res.status(400).json({ error: 'Invalid runAt date.' });
+                    }
+                    if (runAt <= new Date()) {
+                        return res.status(400).json({ error: 'runAt must be in the future.' });
+                    }
+                }
+                else {
+                    runAt = null;
+                }
+            }
+            const nextRunAt = (0, scheduledJobExecutor_1.computeNextRunAt)(cronExpression, runAt);
+            await job.update({
+                label: parsed.label ?? job.label,
+                prompt: parsed.prompt ?? job.prompt,
+                cronExpression,
+                runAt,
+                isActive: parsed.isActive ?? job.isActive,
+                nextRunAt,
+                sessionId: parsed.sessionId !== undefined ? (parsed.sessionId ?? null) : job.sessionId,
+                platform: parsed.platform ?? job.platform,
+            });
+            res.json(formatJob(job));
+        }
+        catch (err) {
+            logger.error('Error updating scheduled job.', { error: err });
+            if (err instanceof zod_1.default.ZodError) {
+                return res.status(400).json({ error: 'Invalid job data.' });
+            }
+            res.status(500).json({ error: 'Failed to update scheduled job.' });
+        }
+    });
+    router.delete('/:id', authMiddleware_1.authMiddleware, async (req, res) => {
+        const { logger, subscription } = res.locals;
+        const { id } = req.params;
+        try {
+            const job = await scheduledJob_1.ScheduledJob.findOne({
+                where: { id, subscriptionId: subscription.id },
+            });
+            if (!job) {
+                return res.status(404).json({ error: 'Scheduled job not found.' });
+            }
+            await job.destroy();
+            res.status(204).send();
+        }
+        catch (err) {
+            logger.error('Error deleting scheduled job.', { error: err });
+            res.status(500).json({ error: 'Failed to delete scheduled job.' });
+        }
+    });
+    router.post('/:id/run-now', authMiddleware_1.authMiddleware, async (req, res) => {
+        const { logger, subscription } = res.locals;
+        const { id } = req.params;
+        try {
+            const job = await scheduledJob_1.ScheduledJob.findOne({
+                where: { id, subscriptionId: subscription.id },
+            });
+            if (!job) {
+                return res.status(404).json({ error: 'Scheduled job not found.' });
+            }
+            void (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
+                logger.error('run-now execution failed.', { jobId: job.id, error: err });
+            });
+            res.json(formatJob(job));
+        }
+        catch (err) {
+            logger.error('Error triggering scheduled job.', { error: err });
+            res.status(500).json({ error: 'Failed to trigger scheduled job.' });
+        }
+    });
+    return router;
+}