@telepat/snoopy 0.1.13 → 0.1.14

package/dist/src/mcp/helpers.js

@@ -0,0 +1,433 @@
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { getDb } from '../services/db/sqlite.js';
+import { JobsRepository } from '../services/db/repositories/jobsRepo.js';
+import { RunsRepository } from '../services/db/repositories/runsRepo.js';
+import { ScanItemsRepository } from '../services/db/repositories/scanItemsRepo.js';
+import { SettingsRepository } from '../services/db/repositories/settingsRepo.js';
+import { AnalyticsService } from '../services/analytics/analyticsService.js';
+import { extractErrorEntries, readRunLog } from '../services/logging/logReader.js';
+import { getOpenRouterApiKey, isKeytarAvailable } from '../services/security/secretStore.js';
+import { getStartupStatus } from '../services/startup/index.js';
+import { isDaemonRunning, ensureDaemonRunning, requestDaemonReload } from '../services/daemonControl.js';
+import { ensureAppDirs } from '../utils/paths.js';
+const require = createRequire(import.meta.url);
+export function getSnoopyVersion() {
+    for (const rel of ['../../../package.json', '../../package.json']) {
+        try {
+            const pkg = require(rel);
+            if (pkg.name === '@telepat/snoopy')
+                return pkg.version ?? '0.0.0';
+        }
+        catch { /* try next depth */ }
+    }
+    return '0.0.0';
+}
+function formatToolError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+    return {
+        content: [{ type: 'text', text: message }],
+        isError: true,
+    };
+}
+function formatToolResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        structuredContent: data,
+    };
+}
+export { formatToolError, formatToolResult };
+export async function buildDoctorReport() {
+    const paths = ensureAppDirs();
+    const db = getDb();
+    let dbOk = false;
+    let dbDetails = `DB file: ${paths.dbPath}`;
+    try {
+        db.prepare('SELECT 1').get();
+        dbOk = true;
+        dbDetails = `DB reachable at ${paths.dbPath}`;
+    }
+    catch (error) {
+        dbDetails = `DB error: ${String(error)}`;
+    }
+    const jobsRepo = new JobsRepository();
+    const runsRepo = new RunsRepository();
+    const jobs = jobsRepo.list();
+    const enabledJobs = jobs.filter((j) => j.enabled).length;
+    const apiKey = await getOpenRouterApiKey();
+    const keytarAvailable = await isKeytarAvailable();
+    const startup = getStartupStatus();
+    const daemon = isDaemonRunning();
+    const recentProblemRuns = runsRepo
+        .latestWithJobNames(20)
+        .filter((run) => {
+        const timestamp = Date.parse(run.createdAt);
+        return !Number.isNaN(timestamp) && timestamp >= Date.now() - 24 * 60 * 60 * 1000;
+    })
+        .map((run) => {
+        const logContent = readRunLog(run.logFilePath);
+        const errorEntries = extractErrorEntries(logContent ?? '');
+        return { run, errorEntries };
+    })
+        .filter(({ run, errorEntries }) => run.status === 'failed' || errorEntries.length > 0);
+    return {
+        platform: process.platform,
+        nodeVersion: process.version,
+        database: { ok: dbOk, details: dbDetails },
+        openRouterApiKey: { configured: Boolean(apiKey), keytarAvailable },
+        jobs: { total: jobs.length, enabled: enabledJobs },
+        daemon: { running: daemon.running, pid: daemon.pid },
+        startup: { enabled: startup.enabled, method: startup.method, detail: startup.detail },
+        recentErrors: recentProblemRuns.map(({ run, errorEntries }) => ({
+            runId: run.id,
+            jobName: run.jobName ?? run.jobId,
+            status: run.status,
+            message: run.message,
+            errorCount: errorEntries.length,
+            latestError: errorEntries.length > 0 ? errorEntries[errorEntries.length - 1]?.split('\n')[0] : null,
+        })),
+    };
+}
+export function buildDaemonStatusReport() {
+    const status = isDaemonRunning();
+    return {
+        running: status.running,
+        pid: status.pid,
+    };
+}
+export function startDaemonReport() {
+    const result = ensureDaemonRunning();
+    return {
+        started: result.started,
+        pid: result.pid,
+    };
+}
+export function stopDaemonReport() {
+    const status = isDaemonRunning();
+    if (!status.running || !status.pid) {
+        return { stopped: false, message: 'Daemon is not running' };
+    }
+    try {
+        process.kill(status.pid, 'SIGTERM');
+        return { stopped: true, pid: status.pid };
+    }
+    catch (error) {
+        return { stopped: false, pid: status.pid, error: String(error) };
+    }
+}
+export function reloadDaemonReport() {
+    const result = requestDaemonReload();
+    return {
+        reloaded: result.reloaded,
+        pid: result.pid,
+    };
+}
+export function listJobsReport() {
+    const jobsRepo = new JobsRepository();
+    const jobs = jobsRepo.list();
+    return {
+        count: jobs.length,
+        jobs: jobs.map((j) => ({
+            id: j.id,
+            slug: j.slug,
+            name: j.name,
+            enabled: j.enabled,
+            subreddits: j.subreddits,
+            scheduleCron: j.scheduleCron,
+            monitorComments: j.monitorComments,
+        })),
+    };
+}
+export function listJobRunsReport(jobRef, limit) {
+    const runsRepo = new RunsRepository();
+    const boundedLimit = limit ?? 20;
+    if (jobRef) {
+        const jobsRepo = new JobsRepository();
+        const job = jobsRepo.getByRef(jobRef);
+        if (!job) {
+            throw new Error(`Job not found: ${jobRef}`);
+        }
+        const runs = runsRepo.listByJob(job.id, boundedLimit);
+        return {
+            job: { id: job.id, slug: job.slug, name: job.name },
+            count: runs.length,
+            runs: runs.map((r) => ({
+                id: r.id,
+                status: r.status,
+                message: r.message,
+                startedAt: r.startedAt,
+                finishedAt: r.finishedAt,
+                itemsDiscovered: r.itemsDiscovered,
+                itemsNew: r.itemsNew,
+                itemsQualified: r.itemsQualified,
+                promptTokens: r.promptTokens,
+                completionTokens: r.completionTokens,
+                estimatedCostUsd: r.estimatedCostUsd,
+            })),
+        };
+    }
+    const runs = runsRepo.latestWithJobNames(boundedLimit);
+    return {
+        count: runs.length,
+        runs: runs.map((r) => ({
+            id: r.id,
+            jobId: r.jobId,
+            jobName: r.jobName,
+            status: r.status,
+            message: r.message,
+            createdAt: r.createdAt,
+            itemsDiscovered: r.itemsDiscovered,
+            itemsNew: r.itemsNew,
+            itemsQualified: r.itemsQualified,
+        })),
+    };
+}
+export function addJobReport(input) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.create({
+        name: input.name,
+        description: input.description ?? '',
+        subreddits: input.subreddits,
+        qualificationPrompt: input.qualificationPrompt,
+        scheduleCron: input.scheduleCron,
+        enabled: input.enabled,
+        monitorComments: input.monitorComments,
+    });
+    return {
+        id: job.id,
+        slug: job.slug,
+        name: job.name,
+        enabled: job.enabled,
+        subreddits: job.subreddits,
+        scheduleCron: job.scheduleCron,
+    };
+}
+export function deleteJobReport(jobRef) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.removeByRef(jobRef);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    return { deleted: true, id: job.id, slug: job.slug, name: job.name };
+}
+export function enableJobReport(jobRef) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.setEnabledByRef(jobRef, true);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    return { id: job.id, slug: job.slug, name: job.name, enabled: job.enabled };
+}
+export function disableJobReport(jobRef) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.setEnabledByRef(jobRef, false);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    return { id: job.id, slug: job.slug, name: job.name, enabled: job.enabled };
+}
+export function runJobReport(jobRef, limit) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.getByRef(jobRef);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    const args = ['job', 'run', jobRef];
+    if (limit) {
+        args.push('--limit', String(limit));
+    }
+    const result = spawnSync(process.execPath, [process.argv[1], ...args], {
+        encoding: 'utf8',
+        timeout: 120_000,
+    });
+    return {
+        job: { id: job.id, slug: job.slug, name: job.name },
+        exitCode: result.status,
+        stdout: result.stdout?.slice(0, 4000) ?? '',
+        stderr: result.stderr?.slice(0, 2000) ?? '',
+    };
+}
+export function analyticsReport(jobRef, days) {
+    const analyticsService = new AnalyticsService();
+    const boundedDays = days ?? 30;
+    if (jobRef) {
+        const jobsRepo = new JobsRepository();
+        const job = jobsRepo.getByRef(jobRef);
+        if (!job) {
+            throw new Error(`Job not found: ${jobRef}`);
+        }
+        return analyticsService.getJobAnalytics(job.id, { days: boundedDays });
+    }
+    return analyticsService.getGlobalAnalytics({ days: boundedDays });
+}
+export function exportReport(jobRef, format, lastRun, limit) {
+    const jobsRepo = new JobsRepository();
+    const scanItemsRepo = new ScanItemsRepository();
+    const runsRepo = new RunsRepository();
+    const boundedLimit = limit ?? 100;
+    const jobs = jobRef
+        ? (() => {
+            const job = jobsRepo.getByRef(jobRef);
+            if (!job)
+                throw new Error(`Job not found: ${jobRef}`);
+            return [job];
+        })()
+        : jobsRepo.list();
+    const results = [];
+    for (const job of jobs) {
+        const latestRunId = lastRun ? runsRepo.listByJob(job.id, 1)[0]?.id ?? null : null;
+        if (lastRun && !latestRunId)
+            continue;
+        const items = latestRunId
+            ? scanItemsRepo.listQualifiedByJobRun(job.id, latestRunId, boundedLimit)
+            : scanItemsRepo.listQualifiedByJob(job.id, boundedLimit);
+        results.push({
+            jobId: job.id,
+            jobSlug: job.slug,
+            jobName: job.name,
+            rowCount: items.length,
+            items,
+        });
+    }
+    return { format: format ?? 'json', jobs: results, totalRows: results.reduce((s, r) => s + r.rowCount, 0) };
+}
+export function consumeReport(jobRef, limit, dryRun) {
+    const jobsRepo = new JobsRepository();
+    const scanItemsRepo = new ScanItemsRepository();
+    let jobId;
+    if (jobRef) {
+        const job = jobsRepo.getByRef(jobRef);
+        if (!job)
+            throw new Error(`Job not found: ${jobRef}`);
+        jobId = job.id;
+    }
+    const rows = scanItemsRepo.listUnconsumedQualified(jobId, limit);
+    if (dryRun) {
+        return { dryRun: true, count: rows.length, items: rows };
+    }
+    const consumedCount = scanItemsRepo.markConsumed(rows.map((r) => r.id));
+    return { consumed: consumedCount, items: rows };
+}
+export function errorsReport(jobRef, hours) {
+    const jobsRepo = new JobsRepository();
+    const runsRepo = new RunsRepository();
+    const boundedHours = hours ?? 24;
+    const job = jobsRepo.getByRef(jobRef);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    const cutoff = Date.now() - boundedHours * 60 * 60 * 1000;
+    const recentRuns = runsRepo.listByJob(job.id, 100).filter((run) => {
+        const ts = Date.parse(run.createdAt);
+        return !Number.isNaN(ts) && ts >= cutoff;
+    });
+    const errorRuns = recentRuns
+        .map((run) => {
+        const logContent = readRunLog(run.logFilePath);
+        const errorEntries = extractErrorEntries(logContent ?? '');
+        return { run, errorEntries, hasErrors: run.status === 'failed' || errorEntries.length > 0 };
+    })
+        .filter((entry) => entry.hasErrors);
+    return {
+        job: { id: job.id, slug: job.slug, name: job.name },
+        hours: boundedHours,
+        errorCount: errorRuns.length,
+        errors: errorRuns.map(({ run, errorEntries }) => ({
+            runId: run.id,
+            status: run.status,
+            message: run.message,
+            createdAt: run.createdAt,
+            errorEntries: errorEntries.map((e) => e.split('\n')[0]),
+        })),
+    };
+}
+export function logsReport(runId) {
+    const runsRepo = new RunsRepository();
+    const run = runsRepo.getById(runId);
+    if (!run) {
+        throw new Error(`Run not found: ${runId}`);
+    }
+    const logContent = readRunLog(run.logFilePath);
+    return {
+        runId: run.id,
+        jobId: run.jobId,
+        jobName: run.jobName,
+        status: run.status,
+        logPath: run.logFilePath,
+        logLength: logContent?.length ?? 0,
+        log: logContent?.slice(0, 10_000) ?? null,
+    };
+}
+export async function settingsGetReport() {
+    const settingsRepo = new SettingsRepository();
+    const appSettings = settingsRepo.getAppSettings();
+    const apiKey = await getOpenRouterApiKey();
+    const redditState = await settingsRepo.getRedditCredentialState();
+    return {
+        model: appSettings.model,
+        temperature: appSettings.modelSettings.temperature,
+        maxTokens: appSettings.modelSettings.maxTokens,
+        topP: appSettings.modelSettings.topP,
+        cronIntervalMinutes: appSettings.cronIntervalMinutes,
+        jobTimeoutMs: appSettings.jobTimeoutMs,
+        notificationsEnabled: appSettings.notificationsEnabled,
+        openRouterApiKeyConfigured: Boolean(apiKey),
+        reddit: {
+            appName: redditState.appName,
+            clientId: redditState.clientId,
+            hasClientSecret: redditState.hasClientSecret,
+        },
+    };
+}
+export function settingsSetReport(key, value) {
+    const settingsRepo = new SettingsRepository();
+    const appSettings = settingsRepo.getAppSettings();
+    switch (key) {
+        case 'model':
+            appSettings.model = value;
+            break;
+        case 'temperature': {
+            const parsed = Number(value);
+            if (Number.isNaN(parsed) || parsed < 0 || parsed > 2)
+                throw new Error('temperature must be 0.0-2.0');
+            appSettings.modelSettings.temperature = parsed;
+            break;
+        }
+        case 'maxTokens': {
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed < 1)
+                throw new Error('maxTokens must be a positive integer');
+            appSettings.modelSettings.maxTokens = parsed;
+            break;
+        }
+        case 'topP': {
+            const parsed = Number(value);
+            if (Number.isNaN(parsed) || parsed < 0 || parsed > 1)
+                throw new Error('topP must be 0.0-1.0');
+            appSettings.modelSettings.topP = parsed;
+            break;
+        }
+        case 'cronIntervalMinutes': {
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed < 1)
+                throw new Error('cronIntervalMinutes must be a positive integer');
+            appSettings.cronIntervalMinutes = parsed;
+            break;
+        }
+        case 'jobTimeoutMs': {
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed < 0)
+                throw new Error('jobTimeoutMs must be a non-negative integer');
+            appSettings.jobTimeoutMs = parsed;
+            break;
+        }
+        case 'notificationsEnabled':
+            appSettings.notificationsEnabled = value === 'true';
+            break;
+        default:
+            throw new Error(`Unknown setting: ${key}`);
+    }
+    settingsRepo.setAppSettings(appSettings);
+    return { updated: key, value, settings: appSettings };
+}
+//# sourceMappingURL=helpers.js.map

package/dist/src/mcp/server.d.ts

@@ -0,0 +1 @@
+export declare function startSnoopyMcpServer(): Promise<void>;

package/dist/src/mcp/server.js

@@ -0,0 +1,260 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { snoopyDoctorToolInputSchema, snoopyDaemonStatusToolInputSchema, snoopyDaemonStartToolInputSchema, snoopyDaemonStopToolInputSchema, snoopyDaemonReloadToolInputSchema, snoopyJobListToolInputSchema, snoopyJobRunsToolInputSchema, snoopyJobAddToolInputSchema, snoopyJobDeleteToolInputSchema, snoopyJobEnableToolInputSchema, snoopyJobDisableToolInputSchema, snoopyJobRunToolInputSchema, snoopyAnalyticsToolInputSchema, snoopyExportToolInputSchema, snoopyConsumeToolInputSchema, snoopyErrorsToolInputSchema, snoopyLogsToolInputSchema, snoopySettingsGetToolInputSchema, snoopySettingsSetToolInputSchema, } from './tools.js';
+import { getSnoopyVersion, formatToolError, formatToolResult, buildDoctorReport, buildDaemonStatusReport, startDaemonReport, stopDaemonReport, reloadDaemonReport, listJobsReport, listJobRunsReport, addJobReport, deleteJobReport, enableJobReport, disableJobReport, runJobReport, analyticsReport, exportReport, consumeReport, errorsReport, logsReport, settingsGetReport, settingsSetReport, } from './helpers.js';
+export async function startSnoopyMcpServer() {
+    const version = getSnoopyVersion();
+    const server = new McpServer({ name: 'snoopy', version });
+    // --- snoopy_doctor ---
+    server.registerTool('snoopy_doctor', {
+        title: 'Health Check',
+        description: 'Run full system health check: database, API key, daemon, jobs, startup, recent errors.',
+        inputSchema: snoopyDoctorToolInputSchema,
+    }, async () => {
+        try {
+            const report = await buildDoctorReport();
+            return formatToolResult(report);
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_status ---
+    server.registerTool('snoopy_daemon_status', {
+        title: 'Daemon Status',
+        description: 'Show whether the Snoopy daemon is running and its PID.',
+        inputSchema: snoopyDaemonStatusToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(buildDaemonStatusReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_start ---
+    server.registerTool('snoopy_daemon_start', {
+        title: 'Start Daemon',
+        description: 'Start the Snoopy background daemon.',
+        inputSchema: snoopyDaemonStartToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(startDaemonReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_stop ---
+    server.registerTool('snoopy_daemon_stop', {
+        title: 'Stop Daemon',
+        description: 'Stop the Snoopy background daemon.',
+        inputSchema: snoopyDaemonStopToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(stopDaemonReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_reload ---
+    server.registerTool('snoopy_daemon_reload', {
+        title: 'Reload Daemon',
+        description: 'Hot-reload daemon job schedules without restart.',
+        inputSchema: snoopyDaemonReloadToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(reloadDaemonReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_list ---
+    server.registerTool('snoopy_job_list', {
+        title: 'List Jobs',
+        description: 'List all monitoring jobs with their state, subreddits, and schedule.',
+        inputSchema: snoopyJobListToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(listJobsReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_runs ---
+    server.registerTool('snoopy_job_runs', {
+        title: 'Job Run History',
+        description: 'List recent run history for a job or all jobs.',
+        inputSchema: snoopyJobRunsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(listJobRunsReport(input.jobRef, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_add ---
+    server.registerTool('snoopy_job_add', {
+        title: 'Add Job',
+        description: 'Create a new monitoring job with subreddits and qualification prompt.',
+        inputSchema: snoopyJobAddToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(addJobReport(input));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_delete ---
+    server.registerTool('snoopy_job_delete', {
+        title: 'Delete Job',
+        description: 'Delete a job and all its runs, scan items, and log files.',
+        inputSchema: snoopyJobDeleteToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(deleteJobReport(input.jobRef));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_enable ---
+    server.registerTool('snoopy_job_enable', {
+        title: 'Enable Job',
+        description: 'Enable scheduling for a monitoring job.',
+        inputSchema: snoopyJobEnableToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(enableJobReport(input.jobRef));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_disable ---
+    server.registerTool('snoopy_job_disable', {
+        title: 'Disable Job',
+        description: 'Disable scheduling for a monitoring job.',
+        inputSchema: snoopyJobDisableToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(disableJobReport(input.jobRef));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_run ---
+    server.registerTool('snoopy_job_run', {
+        title: 'Run Job Now',
+        description: 'Trigger an immediate run for a monitoring job.',
+        inputSchema: snoopyJobRunToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(runJobReport(input.jobRef, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_analytics ---
+    server.registerTool('snoopy_analytics', {
+        title: 'Analytics',
+        description: 'Show analytics for all jobs or a single job (tokens, cost, posts, comments).',
+        inputSchema: snoopyAnalyticsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(analyticsReport(input.jobRef, input.days));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_export ---
+    server.registerTool('snoopy_export', {
+        title: 'Export Results',
+        description: 'Export qualified scan items as JSON or CSV for downstream processing.',
+        inputSchema: snoopyExportToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(exportReport(input.jobRef, input.format, input.lastRun, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_consume ---
+    server.registerTool('snoopy_consume', {
+        title: 'Consume Results',
+        description: 'List and mark unconsumed qualified results as consumed.',
+        inputSchema: snoopyConsumeToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(consumeReport(input.jobRef, input.limit, input.dryRun));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_errors ---
+    server.registerTool('snoopy_errors', {
+        title: 'Recent Errors',
+        description: 'Show recent failed or errored runs for a job.',
+        inputSchema: snoopyErrorsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(errorsReport(input.jobRef, input.hours));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_logs ---
+    server.registerTool('snoopy_logs', {
+        title: 'Run Logs',
+        description: 'View the log output for a specific run.',
+        inputSchema: snoopyLogsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(logsReport(input.runId));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_settings_get ---
+    server.registerTool('snoopy_settings_get', {
+        title: 'Get Settings',
+        description: 'Read current Snoopy settings (model, API key status, schedule, notifications).',
+        inputSchema: snoopySettingsGetToolInputSchema,
+    }, async () => {
+        try {
+            const report = await settingsGetReport();
+            return formatToolResult(report);
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_settings_set ---
+    server.registerTool('snoopy_settings_set', {
+        title: 'Update Setting',
+        description: 'Update a single Snoopy setting.',
+        inputSchema: snoopySettingsSetToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(settingsSetReport(input.key, input.value));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+//# sourceMappingURL=server.js.map