omnikey-cli 1.0.28 → 1.0.29

package/backend-dist/index.js

@@ -13,10 +13,13 @@ 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);
@@ -28,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');
@@ -70,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"
@@ -99,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.8';
+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.
@@ -141,7 +145,7 @@ app.get('/windows/update', (req, res) => {
         version: WIN_VERSION,
         downloadUrl: `${baseUrl}/windows/download`,
         fileSize,
-        releaseNotes: `What's new in ${WIN_VERSION}\n\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).`,
+        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) => {
@@ -167,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
@@ -175,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;
+}

package/dist/index.js

@@ -11,6 +11,7 @@ const showLogs_1 = require("./showLogs");
 const showConfig_1 = require("./showConfig");
 const setConfig_1 = require("./setConfig");
 const grantBrowserAccess_1 = require("./grantBrowserAccess");
+const scheduleJob_1 = require("./scheduleJob");
 const program = new commander_1.Command();
 program
     .name('omnikey')
@@ -94,4 +95,23 @@ program
     .action(async () => {
     await (0, grantBrowserAccess_1.reopenBrowserDebugProfile)();
 });
+const scheduleCmd = program
+    .command('schedule')
+    .description('Manage scheduled prompt jobs');
+scheduleCmd
+    .command('add')
+    .description('Add a new scheduled job')
+    .action(async () => { await (0, scheduleJob_1.scheduleAdd)(); });
+scheduleCmd
+    .command('list')
+    .description('List all scheduled jobs')
+    .action(async () => { await (0, scheduleJob_1.scheduleList)(); });
+scheduleCmd
+    .command('remove')
+    .description('Remove a scheduled job')
+    .action(async () => { await (0, scheduleJob_1.scheduleRemove)(); });
+scheduleCmd
+    .command('run-now <id>')
+    .description('Immediately run a scheduled job by ID')
+    .action(async (id) => { await (0, scheduleJob_1.scheduleRunNow)(id); });
 program.parseAsync(process.argv);

package/dist/onboard.js

@@ -14,11 +14,12 @@ const AI_PROVIDERS = [
     { name: 'Google Gemini (gemini-2.5-flash / gemini-2.5-pro)', value: 'gemini' },
 ];
 const SEARCH_PROVIDERS = [
-    { name: 'Skip (DuckDuckGo will be used by default — no key required)', value: 'skip' },
-    { name: 'Serper (Google Search API — serper.dev, 2,500 free/mo)', value: 'serper' },
-    { name: 'Brave Search (brave.com/search/api, 2,000 free/mo)', value: 'brave' },
-    { name: 'Tavily (tavily.com, 1,000 free/mo, optimized for AI)', value: 'tavily' },
-    { name: 'SearXNG (self-hosted, no key needed — provide your instance URL)', value: 'searxng' },
+    { name: 'Skip', value: 'skip' },
+    { name: 'DuckDuckGo', value: 'duckduckgo' },
+    { name: 'Serper', value: 'serper' },
+    { name: 'Brave Search', value: 'brave' },
+    { name: 'Tavily', value: 'tavily' },
+    { name: 'SearXNG', value: 'searxng' },
 ];
 const AI_PROVIDER_KEY_ENV = {
     openai: 'OPENAI_API_KEY',
@@ -59,7 +60,7 @@ async function onboard() {
         {
             type: 'list',
             name: 'provider',
-            message: 'Select a web search provider for the AI agent (enhances research capabilities):',
+            message: 'Select a web search provider for the AI agent. Supported providers: DuckDuckGo, Serper, Brave Search, Tavily, SearXNG:',
             choices: SEARCH_PROVIDERS,
             default: 'skip',
         },