vellum 0.2.13 → 0.2.14

package/src/__tests__/scheduler-recurrence.test.ts

@@ -156,7 +156,7 @@ describe('scheduler RRULE execution', () => {
     expect(runs.length).toBeGreaterThanOrEqual(1);
   });
 
-  test('ended RRULE (UNTIL in past) is not repeatedly claimed', async () => {
+  test('expired RRULE fires one final due run then is disabled', async () => {
     const endedExpr = buildEndedRrule();
 
     // Insert directly via raw SQL because createSchedule would throw when
@@ -167,7 +167,7 @@ describe('scheduler RRULE execution', () => {
     getRawDb().run(
       `INSERT INTO cron_jobs (id, name, enabled, cron_expression, schedule_syntax, timezone, message, next_run_at, last_run_at, last_status, retry_count, created_by, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [id, 'Ended RRULE', 1, endedExpr, 'rrule', null, 'Should not fire', now - 1000, null, null, 0, 'agent', now, now],
+      [id, 'Ended RRULE', 1, endedExpr, 'rrule', null, 'Final expired run', now - 1000, null, null, 0, 'agent', now, now],
     );
 
     const processedMessages: string[] = [];
@@ -175,16 +175,35 @@ describe('scheduler RRULE execution', () => {
       processedMessages.push(message);
     };
 
-    const scheduler = startScheduler(processMessage, () => {}, () => {});
+    // First tick: the expired schedule should fire its final due run
+    const scheduler1 = startScheduler(processMessage, () => {}, () => {});
     await new Promise(resolve => setTimeout(resolve, 500));
-    scheduler.stop();
+    scheduler1.stop();
 
-    // The ended RRULE should NOT have fired
-    expect(processedMessages).not.toContain('Should not fire');
+    // The message IS delivered once
+    expect(processedMessages).toContain('Final expired run');
 
-    // No runs should have been created
+    // One run record IS created with status 'ok'
     const runs = getScheduleRuns(id);
-    expect(runs.length).toBe(0);
+    expect(runs.length).toBe(1);
+    expect(runs[0].status).toBe('ok');
+
+    // After firing, the schedule is disabled with nextRunAt=0
+    const afterSchedule = getSchedule(id);
+    expect(afterSchedule).not.toBeNull();
+    expect(afterSchedule!.enabled).toBe(false);
+    expect(afterSchedule!.nextRunAt).toBe(0);
+
+    // Second tick: the disabled schedule must NOT fire again
+    processedMessages.length = 0;
+    const scheduler2 = startScheduler(processMessage, () => {}, () => {});
+    await new Promise(resolve => setTimeout(resolve, 500));
+    scheduler2.stop();
+
+    expect(processedMessages).not.toContain('Final expired run');
+    // No additional runs
+    const runsAfter = getScheduleRuns(id);
+    expect(runsAfter.length).toBe(1);
   });
 
   test('existing cron schedule behavior is unchanged', async () => {
@@ -299,6 +318,88 @@ describe('scheduler RRULE execution', () => {
     expect(runs[0].status).toBe('ok');
   });
 
+  test('EXRULE schedule skips excluded occurrence and advances to next valid date', async () => {
+    // RRULE: every minute from a known dtstart
+    // EXRULE: every 2nd minute from the same dtstart (excludes offsets 0, 2, 4, ...)
+    //
+    // DTSTART is set to 59 minutes ago (floored to minute) so the first
+    // occurrence after "now" without EXRULE would be at offset 60 (even).
+    // With EXRULE active, offset 60 is excluded and the scheduler must
+    // advance to offset 61 (odd). Using 59 minutes (not 60) is critical:
+    // at 60 minutes the first post-now occurrence is offset 61 (odd), which
+    // would pass the parity check even if EXRULE were completely ignored.
+    //
+    // We mock Date.now() so the scheduler's internal clock matches the test
+    // baseline exactly, making the test fully deterministic regardless of
+    // when it runs.
+    const realNow = new Date();
+    const frozenNow = new Date(realNow);
+    frozenNow.setUTCSeconds(30);
+    frozenNow.setUTCMilliseconds(0);
+
+    const originalDateNow = Date.now;
+    Date.now = () => frozenNow.getTime();
+
+    try {
+      const pad = (n: number) => String(n).padStart(2, '0');
+      const pastDate = new Date(frozenNow.getTime() - 59 * 60_000);
+      pastDate.setUTCSeconds(0);
+      pastDate.setUTCMilliseconds(0);
+      const ds = `${pastDate.getUTCFullYear()}${pad(pastDate.getUTCMonth() + 1)}${pad(pastDate.getUTCDate())}T${pad(pastDate.getUTCHours())}${pad(pastDate.getUTCMinutes())}00Z`;
+
+      const expression = `DTSTART:${ds}\nRRULE:FREQ=MINUTELY;INTERVAL=1\nEXRULE:FREQ=MINUTELY;INTERVAL=2`;
+
+      // Compute what the next occurrence would be WITHOUT EXRULE — this should
+      // be at an even offset that EXRULE must exclude.
+      const withoutExrule = `DTSTART:${ds}\nRRULE:FREQ=MINUTELY;INTERVAL=1`;
+      const { computeNextRunAt } = await import('../schedule/recurrence-engine.js');
+      const nextWithoutExrule = computeNextRunAt(
+        { syntax: 'rrule', expression: withoutExrule },
+        frozenNow.getTime(),
+      );
+      const offsetWithout = Math.round((nextWithoutExrule - pastDate.getTime()) / 60_000);
+      // Sanity: the without-EXRULE occurrence must be even (would be excluded)
+      expect(offsetWithout % 2).toBe(0);
+
+      const schedule = createSchedule({
+        name: 'EXRULE scheduler test',
+        cronExpression: expression,
+        message: 'EXRULE scheduler fire',
+        syntax: 'rrule',
+        expression,
+      });
+
+      forceScheduleDue(schedule.id);
+
+      const processedMessages: string[] = [];
+      const processMessage = async (_conversationId: string, message: string) => {
+        processedMessages.push(message);
+      };
+
+      const scheduler = startScheduler(processMessage, () => {}, () => {});
+      await new Promise(resolve => setTimeout(resolve, 500));
+      scheduler.stop();
+
+      // The schedule should have fired
+      expect(processedMessages).toContain('EXRULE scheduler fire');
+
+      const after = getSchedule(schedule.id);
+      expect(after).not.toBeNull();
+      expect(after!.lastRunAt).not.toBeNull();
+      expect(after!.nextRunAt).toBeGreaterThan(frozenNow.getTime() - 5000);
+
+      // nextRunAt must NOT equal the without-EXRULE occurrence (which is excluded)
+      expect(after!.nextRunAt).not.toBe(nextWithoutExrule);
+
+      // nextRunAt must land on an odd-minute offset from dtstart
+      const dtstartMs = pastDate.getTime();
+      const minuteOffset = Math.round((after!.nextRunAt - dtstartMs) / 60_000);
+      expect(minuteOffset % 2).toBe(1);
+    } finally {
+      Date.now = originalDateNow;
+    }
+  });
+
   test('RRULE schedule advances nextRunAt after firing', async () => {
     const rruleExpr = buildEveryMinuteRrule();
     const schedule = createSchedule({
@@ -322,8 +423,8 @@ describe('scheduler RRULE execution', () => {
     expect(after).not.toBeNull();
     // nextRunAt must have moved forward from the forced-due value
     expect(after!.nextRunAt).toBeGreaterThan(forcedDueAt);
-    // It should be at or near the original computed value (within a few seconds tolerance)
-    expect(Math.abs(after!.nextRunAt - originalNextRunAt)).toBeLessThan(5000);
+    // After claiming, MINUTELY recurrence advances nextRunAt by ~60s, so allow up to 65s tolerance
+    expect(Math.abs(after!.nextRunAt - originalNextRunAt)).toBeLessThan(65000);
     expect(after!.lastRunAt).not.toBeNull();
   });
 });

package/src/__tests__/secret-allowlist.test.ts

@@ -13,6 +13,7 @@ mock.module('../util/logger.js', () => ({
 }));
 
 mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
   getDataDir: () => testDir,
 }));
 
@@ -22,7 +23,7 @@ import { scanText } from '../security/secret-scanner.js';
 describe('secret-allowlist', () => {
   beforeEach(() => {
     testDir = join(tmpdir(), `vellum-allowlist-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(testDir, { recursive: true });
+    mkdirSync(join(testDir, 'protected'), { recursive: true });
     resetAllowlist();
   });
 
@@ -45,7 +46,7 @@ describe('secret-allowlist', () => {
   // -----------------------------------------------------------------------
   test('[experimental] suppresses exact values', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: ['my-test-api-key-12345'] }),
     );
     expect(isAllowlisted('my-test-api-key-12345')).toBe(true);
@@ -54,7 +55,7 @@ describe('secret-allowlist', () => {
 
   test('[experimental] exact values are case-sensitive', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: ['MyTestKey'] }),
     );
     expect(isAllowlisted('MyTestKey')).toBe(true);
@@ -66,7 +67,7 @@ describe('secret-allowlist', () => {
   // -----------------------------------------------------------------------
   test('[experimental] suppresses values matching a prefix', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ prefixes: ['my-internal-'] }),
     );
     expect(isAllowlisted('my-internal-key-abc123')).toBe(true);
@@ -78,7 +79,7 @@ describe('secret-allowlist', () => {
   // -----------------------------------------------------------------------
   test('[experimental] suppresses values matching a regex pattern', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ patterns: ['^ci-test-[a-z0-9]+$'] }),
     );
     expect(isAllowlisted('ci-test-abc123')).toBe(true);
@@ -87,7 +88,7 @@ describe('secret-allowlist', () => {
 
   test('[experimental] invalid regex is skipped without crashing', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ patterns: ['[invalid', '^valid$'] }),
     );
     loadAllowlist();
@@ -102,7 +103,7 @@ describe('secret-allowlist', () => {
   // -----------------------------------------------------------------------
   test('[experimental] combines values, prefixes, and patterns', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({
         values: ['exact-match-value'],
         prefixes: ['test-prefix-'],
@@ -119,7 +120,7 @@ describe('secret-allowlist', () => {
   // Malformed file
   // -----------------------------------------------------------------------
   test('handles malformed JSON gracefully', () => {
-    writeFileSync(join(testDir, 'secret-allowlist.json'), 'not json{{{');
+    writeFileSync(join(testDir, 'protected', 'secret-allowlist.json'), 'not json{{{');
     loadAllowlist();
     // Should not throw, just log warning
     expect(isAllowlisted('anything')).toBe(false);
@@ -127,7 +128,7 @@ describe('secret-allowlist', () => {
 
   test('handles non-array fields gracefully', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: 'not-an-array', prefixes: 42 }),
     );
     loadAllowlist();
@@ -140,7 +141,7 @@ describe('secret-allowlist', () => {
   test('[experimental] allowlisted values are suppressed by scanText', () => {
     const awsKey = 'AKIAIOSFODNN7REALKEY';
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: [awsKey] }),
     );
     resetAllowlist();
@@ -152,7 +153,7 @@ describe('secret-allowlist', () => {
 
   test('non-allowlisted values are still detected by scanText', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: ['AKIAIOSFODNN7OTHERKE'] }),
     );
     resetAllowlist();
@@ -164,7 +165,7 @@ describe('secret-allowlist', () => {
 
   test('[experimental] prefix allowlist suppresses pattern matches', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ prefixes: ['ghp_AAAA'] }),
     );
     resetAllowlist();
@@ -184,7 +185,7 @@ describe('secret-allowlist', () => {
 
     // Create the file — but fileChecked is cached, so it won't be seen
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: ['test-key'] }),
     );
     expect(isAllowlisted('test-key')).toBe(false);
@@ -196,13 +197,13 @@ describe('secret-allowlist', () => {
 
   test('[experimental] retries loading when file was malformed on first call', () => {
     // First call with malformed JSON
-    writeFileSync(join(testDir, 'secret-allowlist.json'), 'not json{{{');
+    writeFileSync(join(testDir, 'protected', 'secret-allowlist.json'), 'not json{{{');
     loadAllowlist();
     expect(isAllowlisted('test-key')).toBe(false);
 
     // Fix the file
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: ['test-key'] }),
     );
 
@@ -215,7 +216,7 @@ describe('secret-allowlist', () => {
   // -----------------------------------------------------------------------
   test('[experimental] resetAllowlist clears cached state', () => {
     writeFileSync(
-      join(testDir, 'secret-allowlist.json'),
+      join(testDir, 'protected', 'secret-allowlist.json'),
       JSON.stringify({ values: ['test-value'] }),
     );
     loadAllowlist();
@@ -223,7 +224,7 @@ describe('secret-allowlist', () => {
 
     // Reset and remove file — should no longer be allowlisted
     resetAllowlist();
-    rmSync(join(testDir, 'secret-allowlist.json'));
+    rmSync(join(testDir, 'protected', 'secret-allowlist.json'));
     expect(isAllowlisted('test-value')).toBe(false);
   });
 });

package/src/__tests__/secret-ingress-handler.test.ts

@@ -12,6 +12,8 @@ const mockConfig = {
 mock.module('../config/loader.js', () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
+  loadRawConfig: () => ({ secretDetection: { ...mockConfig.secretDetection } }),
+  saveRawConfig: () => {},
   invalidateConfigCache: () => {},
 }));
 
@@ -19,6 +21,7 @@ mock.module('../util/logger.js', () => ({
   getLogger: () => new Proxy({} as Record<string, unknown>, {
     get: () => () => {},
   }),
+  isDebug: () => false,
 }));
 
 const { checkIngressForSecrets } = await import('../security/secret-ingress.js');
@@ -27,6 +30,7 @@ const { checkIngressForSecrets } = await import('../security/secret-ingress.js')
 // These are well-known fake AWS/GitHub patterns used across the test suite.
 const AWS_KEY = ['AKIA', 'IOSFODNN7', 'REALKEY'].join('');
 const GH_TOKEN = ['ghp_', 'ABCDEFghijklMN01234567', '89abcdefghijkl'].join('');
+const TG_TOKEN = ['123456789', ':', 'ABCDefGHIJklmnopQRSTuvwxyz012345678'].join('');
 
 describe('secret ingress handler', () => {
   beforeEach(() => {
@@ -84,6 +88,13 @@ describe('secret ingress handler', () => {
     expect(result.detectedTypes.length).toBeGreaterThanOrEqual(2);
   });
 
+  test('blocks message containing a Telegram bot token', () => {
+    const result = checkIngressForSecrets(`Here is my bot token: ${TG_TOKEN}`);
+    expect(result.blocked).toBe(true);
+    expect(result.detectedTypes).toContain('Telegram Bot Token');
+    expect(result.userNotice).not.toContain(TG_TOKEN);
+  });
+
   test('empty content passes through', () => {
     const result = checkIngressForSecrets('');
     expect(result.blocked).toBe(false);

package/src/__tests__/secret-scanner.test.ts

@@ -130,6 +130,49 @@ describe('Slack tokens', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Telegram
+// ---------------------------------------------------------------------------
+describe('Telegram bot tokens', () => {
+  // Build test token at runtime to avoid tripping pre-commit secret hook
+  const BOT_TOKEN = ['123456789', ':', 'ABCDefGHIJklmnopQRSTuvwxyz012345678'].join('');
+
+  test('detects Telegram bot token', () => {
+    expectMatch(`token=${BOT_TOKEN}`, 'Telegram Bot Token');
+  });
+
+  test('detects bot token in surrounding text', () => {
+    expectMatch(`My bot token is ${BOT_TOKEN} please save it`, 'Telegram Bot Token');
+  });
+
+  test('detects bot token ending with hyphen', () => {
+    // ~1.5% of valid tokens end with '-'; trailing \b would miss these
+    const tokenEndingHyphen = ['123456789', ':', 'ABCDefGHIJklmnopQRSTuvwxyz01234567-'].join('');
+    expectMatch(`token=${tokenEndingHyphen}`, 'Telegram Bot Token');
+  });
+
+  test('does not flag short numeric:alpha strings', () => {
+    // Too few digits in bot ID (only 5)
+    const matches = scanText('12345:ABCDefGHIJklmnopQRSTuvwxyz012345678');
+    const telegram = matches.filter((m) => m.type === 'Telegram Bot Token');
+    expect(telegram).toHaveLength(0);
+  });
+
+  test('does not flag token with wrong secret length', () => {
+    // Secret part is only 10 chars (needs 35)
+    const matches = scanText('123456789:ABCDefGHIJ');
+    const telegram = matches.filter((m) => m.type === 'Telegram Bot Token');
+    expect(telegram).toHaveLength(0);
+  });
+
+  test('does not flag token with too-long secret part', () => {
+    // Secret part is 40 chars (needs exactly 35)
+    const matches = scanText('123456789:ABCDefGHIJklmnopQRSTuvwxyz0123456789AB');
+    const telegram = matches.filter((m) => m.type === 'Telegram Bot Token');
+    expect(telegram).toHaveLength(0);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Anthropic
 // ---------------------------------------------------------------------------