@telepat/snoopy 0.1.10 → 0.1.11

package/README.md

@@ -126,6 +126,9 @@ snoopy job run --limit 5
 snoopy job run <jobRef> --limit 5
 ```
 
+If another run is already active for the same job, Snoopy marks the new attempt as `skipped` with an `already active` message.
+Duplicate candidates matching an existing scan item are treated as already scanned and do not fail the run.
+
 If `<jobRef>` is omitted for `job run`, `job enable`, `job disable`, `job delete`, `start`, `stop`, `errors`, or `results`, Snoopy shows your job list and lets you pick with up/down arrows and Enter.
 
 4. View run history:

package/dist/src/services/db/repositories/runsRepo.d.ts

@@ -1,3 +1,7 @@
+export declare class ActiveRunConflictError extends Error {
+    readonly jobId: string;
+    constructor(jobId: string);
+}
 export interface RunStats {
     itemsDiscovered: number;
     itemsNew: number;

package/dist/src/services/db/repositories/runsRepo.js

@@ -1,5 +1,13 @@
 import crypto from 'node:crypto';
 import { getDb } from '../sqlite.js';
+export class ActiveRunConflictError extends Error {
+    jobId;
+    constructor(jobId) {
+        super(`A run is already active for job ${jobId}.`);
+        this.name = 'ActiveRunConflictError';
+        this.jobId = jobId;
+    }
+}
 export class RunsRepository {
     db = getDb();
     runSelectWithJob = `SELECT
@@ -41,16 +49,25 @@ export class RunsRepository {
     }
     startRun(jobId, logFilePath) {
         const id = crypto.randomUUID();
-        this.db
-            .prepare(`INSERT INTO job_runs (
-          id,
-          job_id,
-          status,
-          started_at,
-          created_at,
-          log_file_path
-        ) VALUES (?, ?, 'running', datetime('now'), datetime('now'), ?)`)
-            .run(id, jobId, logFilePath ?? null);
+        try {
+            this.db
+                .prepare(`INSERT INTO job_runs (
+            id,
+            job_id,
+            status,
+            started_at,
+            created_at,
+            log_file_path
+          ) VALUES (?, ?, 'running', datetime('now'), datetime('now'), ?)`)
+                .run(id, jobId, logFilePath ?? null);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('idx_job_runs_active_job') || message.includes('UNIQUE constraint failed: job_runs.job_id')) {
+                throw new ActiveRunConflictError(jobId);
+            }
+            throw error;
+        }
         return id;
     }
     completeRun(runId, stats) {

package/dist/src/services/db/repositories/scanItemsRepo.d.ts

@@ -87,12 +87,18 @@ export interface AnalyticsByJobRow extends AnalyticsTotalsRow {
     jobName: string;
     jobSlug: string;
 }
+export interface CreateScanItemResult {
+    id: string;
+    inserted: boolean;
+}
 interface AnalyticsFilter {
     jobId?: string;
     days: number;
 }
 export declare class ScanItemsRepository {
     private readonly db;
+    private isDedupConflict;
+    private findExistingScanItemId;
     private mapScanItemRows;
     private buildFilterClause;
     private toAnalyticsTotalsRow;
@@ -107,6 +113,7 @@ export declare class ScanItemsRepository {
     listAnalyticsBySubreddit(filter: AnalyticsFilter): AnalyticsBySubredditRow[];
     listAnalyticsByJob(days: number): AnalyticsByJobRow[];
     existsComment(jobId: string, postId: string, commentId: string): boolean;
+    createWithStatus(item: NewScanItem): CreateScanItemResult;
     create(item: NewScanItem): string;
     listCommentThreadNodes(scanItemId: string): CommentThreadNodeRow[];
 }

package/dist/src/services/db/repositories/scanItemsRepo.js

@@ -2,6 +2,29 @@ import crypto from 'node:crypto';
 import { getDb } from '../sqlite.js';
 export class ScanItemsRepository {
     db = getDb();
+    isDedupConflict(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return message.includes('idx_scan_items_dedup');
+    }
+    findExistingScanItemId(jobId, postId, commentId) {
+        const query = commentId === null
+            ? `SELECT id
+         FROM scan_items
+         WHERE job_id = ?
+           AND reddit_post_id = ?
+           AND reddit_comment_id IS NULL
+         LIMIT 1`
+            : `SELECT id
+         FROM scan_items
+         WHERE job_id = ?
+           AND reddit_post_id = ?
+           AND reddit_comment_id = ?
+         LIMIT 1`;
+        const row = commentId === null
+            ? this.db.prepare(query).get(jobId, postId)
+            : this.db.prepare(query).get(jobId, postId, commentId);
+        return row?.id ?? null;
+    }
     mapScanItemRows(rows) {
         return rows.map((row) => ({
             ...row,
@@ -260,11 +283,11 @@ export class ScanItemsRepository {
             .get(jobId, postId, commentId);
         return Boolean(row);
     }
-    create(item) {
+    createWithStatus(item) {
         const id = crypto.randomUUID();
         const createInTransaction = this.db.transaction((newId, newItem) => {
-            this.db
-                .prepare(`INSERT INTO scan_items (
+            const insertResult = this.db
+                .prepare(`INSERT OR IGNORE INTO scan_items (
             id,
             job_id,
             run_id,
@@ -288,6 +311,13 @@ export class ScanItemsRepository {
             created_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
                 .run(newId, newItem.jobId, newItem.runId, newItem.type, newItem.redditPostId, newItem.redditCommentId, newItem.subreddit, newItem.author, newItem.title, newItem.body, newItem.url, newItem.redditPostedAt, newItem.qualified ? 1 : 0, newItem.viewed ? 1 : 0, newItem.validated ? 1 : 0, newItem.processed ? 1 : 0, newItem.promptTokens ?? 0, newItem.completionTokens ?? 0, newItem.estimatedCostUsd ?? null, newItem.qualificationReason);
+            if (insertResult.changes === 0) {
+                const existingId = this.findExistingScanItemId(newItem.jobId, newItem.redditPostId, newItem.redditCommentId);
+                return {
+                    id: existingId ?? newId,
+                    inserted: false
+                };
+            }
             for (const node of newItem.commentThreadNodes ?? []) {
                 this.db
                     .prepare(`INSERT INTO comment_thread_nodes (
@@ -303,9 +333,27 @@ export class ScanItemsRepository {
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
                     .run(crypto.randomUUID(), newId, node.redditCommentId, node.parentRedditCommentId, node.author, node.body, node.depth, node.isTarget ? 1 : 0);
             }
+            return {
+                id: newId,
+                inserted: true
+            };
         });
-        createInTransaction(id, item);
-        return id;
+        try {
+            return createInTransaction(id, item);
+        }
+        catch (error) {
+            if (!this.isDedupConflict(error)) {
+                throw error;
+            }
+            const existingId = this.findExistingScanItemId(item.jobId, item.redditPostId, item.redditCommentId);
+            return {
+                id: existingId ?? id,
+                inserted: false
+            };
+        }
+    }
+    create(item) {
+        return this.createWithStatus(item).id;
     }
     listCommentThreadNodes(scanItemId) {
         const rows = this.db

package/dist/src/services/db/sqlite.js

@@ -109,6 +109,7 @@ export function getDb() {
         // Column already exists.
     }
     db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_slug ON jobs(slug)');
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_job_runs_active_job ON job_runs(job_id) WHERE status = 'running'");
     db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_scan_items_dedup ON scan_items(job_id, reddit_post_id, COALESCE(reddit_comment_id, ''))");
     db.exec('CREATE INDEX IF NOT EXISTS idx_scan_items_job_qualified_posted ON scan_items(job_id, qualified, reddit_posted_at DESC, created_at DESC)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_scan_items_job_created ON scan_items(job_id, created_at DESC)');

package/dist/src/services/scheduler/jobRunner.d.ts

@@ -11,7 +11,7 @@ export type JobRunProgressEvent = {
     maxNewItems?: number;
 } | {
     type: 'run_skipped';
-    reason: 'missing_api_key';
+    reason: 'missing_api_key' | 'already_running';
     message: string;
 } | {
     type: 'subreddit_fetched';

package/dist/src/services/scheduler/jobRunner.js

@@ -1,5 +1,5 @@
 import { SettingsRepository } from '../db/repositories/settingsRepo.js';
-import { RunsRepository } from '../db/repositories/runsRepo.js';
+import { ActiveRunConflictError, RunsRepository } from '../db/repositories/runsRepo.js';
 import { ScanItemsRepository } from '../db/repositories/scanItemsRepo.js';
 import { getOpenRouterApiKey } from '../security/secretStore.js';
 import { logger } from '../../utils/logger.js';
@@ -86,7 +86,20 @@ export class JobRunner {
         const appSettings = this.settingsRepo.getAppSettings();
         const model = appSettings.model;
         const modelSettings = appSettings.modelSettings;
-        const runId = this.runsRepo.startRun(job.id);
+        let runId;
+        try {
+            runId = this.runsRepo.startRun(job.id);
+        }
+        catch (error) {
+            if (error instanceof ActiveRunConflictError) {
+                const message = `Skipped job ${job.name} (${job.id}): another run is already active.`;
+                this.runsRepo.addRun(job.id, 'skipped', message);
+                this.emit(options, { type: 'run_skipped', reason: 'already_running', message });
+                logger.warn(message);
+                return;
+            }
+            throw error;
+        }
         const runLogger = createRunLogger(runId);
         this.runsRepo.setLogFilePath(runId, runLogger.getLogFilePath());
         const redditTraceHooks = {
@@ -174,7 +187,7 @@ export class JobRunner {
                         postBody: post.body
                     });
                     runLogger.info(JSON.stringify({ event: 'post_qualify_result', postId: post.id, result }, null, 2));
-                    this.scanItemsRepo.create({
+                    const postInsert = this.scanItemsRepo.createWithStatus({
                         jobId: job.id,
                         runId,
                         type: 'post',
@@ -192,24 +205,36 @@ export class JobRunner {
                         estimatedCostUsd: this.estimateCost(result.promptTokens, result.completionTokens),
                         qualificationReason: result.reason
                     });
-                    runStats.itemsNew += 1;
-                    if (result.qualified) {
-                        runStats.itemsQualified += 1;
+                    if (!postInsert.inserted) {
+                        this.emit(options, {
+                            type: 'post_scanned',
+                            postId: post.id,
+                            subreddit: post.subreddit,
+                            status: 'existing',
+                            itemsNew: runStats.itemsNew,
+                            itemsQualified: runStats.itemsQualified
+                        });
+                    }
+                    else {
+                        runStats.itemsNew += 1;
+                        if (result.qualified) {
+                            runStats.itemsQualified += 1;
+                        }
+                        this.accumulateTokens(runStats, result);
+                        this.emit(options, {
+                            type: 'post_scanned',
+                            postId: post.id,
+                            subreddit: post.subreddit,
+                            status: 'new',
+                            title: post.title,
+                            bodySnippet: toSnippet(post.body),
+                            postUrl: post.url,
+                            qualified: result.qualified,
+                            qualificationReason: result.reason,
+                            itemsNew: runStats.itemsNew,
+                            itemsQualified: runStats.itemsQualified
+                        });
                     }
-                    this.accumulateTokens(runStats, result);
-                    this.emit(options, {
-                        type: 'post_scanned',
-                        postId: post.id,
-                        subreddit: post.subreddit,
-                        status: 'new',
-                        title: post.title,
-                        bodySnippet: toSnippet(post.body),
-                        postUrl: post.url,
-                        qualified: result.qualified,
-                        qualificationReason: result.reason,
-                        itemsNew: runStats.itemsNew,
-                        itemsQualified: runStats.itemsQualified
-                    });
                 }
                 else {
                     this.emit(options, {
@@ -319,7 +344,7 @@ export class JobRunner {
                             author,
                             result
                         }, null, 2));
-                        this.scanItemsRepo.create({
+                        const commentInsert = this.scanItemsRepo.createWithStatus({
                             jobId: job.id,
                             runId,
                             type: 'comment',
@@ -345,25 +370,38 @@ export class JobRunner {
                                 isTarget: index === thread.length - 1
                             }))
                         });
-                        runStats.itemsNew += 1;
-                        if (result.qualified) {
-                            runStats.itemsQualified += 1;
+                        if (!commentInsert.inserted) {
+                            this.emit(options, {
+                                type: 'comment_scanned',
+                                postId: post.id,
+                                commentId: lastComment.id,
+                                author,
+                                status: 'existing',
+                                itemsNew: runStats.itemsNew,
+                                itemsQualified: runStats.itemsQualified
+                            });
+                        }
+                        else {
+                            runStats.itemsNew += 1;
+                            if (result.qualified) {
+                                runStats.itemsQualified += 1;
+                            }
+                            this.accumulateTokens(runStats, result);
+                            this.emit(options, {
+                                type: 'comment_scanned',
+                                postId: post.id,
+                                commentId: lastComment.id,
+                                author,
+                                status: 'new',
+                                commentSnippet: toSnippet(lastComment.body),
+                                postUrl: post.url,
+                                commentUrl: buildCommentUrl(post.url, lastComment),
+                                qualified: result.qualified,
+                                qualificationReason: result.reason,
+                                itemsNew: runStats.itemsNew,
+                                itemsQualified: runStats.itemsQualified
+                            });
                         }
-                        this.accumulateTokens(runStats, result);
-                        this.emit(options, {
-                            type: 'comment_scanned',
-                            postId: post.id,
-                            commentId: lastComment.id,
-                            author,
-                            status: 'new',
-                            commentSnippet: toSnippet(lastComment.body),
-                            postUrl: post.url,
-                            commentUrl: buildCommentUrl(post.url, lastComment),
-                            qualified: result.qualified,
-                            qualificationReason: result.reason,
-                            itemsNew: runStats.itemsNew,
-                            itemsQualified: runStats.itemsQualified
-                        });
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telepat/snoopy",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Snoopy CLI for Reddit conversation monitoring jobs.",
   "type": "module",
   "main": "dist/src/index.js",