@yeaft/webchat-agent 1.0.566 → 1.0.568

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.566",
+  "version": "1.0.568",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/work-center/attachments.js

@@ -392,6 +392,34 @@ function resolveAttachmentPath(root, workItemId, attachment) {
   return { filePath: actualPath, size: stat.size, itemDirectory: itemRoot };
 }
 
+/** Copy verified bytes into a new owner directory; never share source paths. */
+export function cloneWorkItemAttachments(workItem, workItemId, options = {}) {
+  if (!workItem.attachments?.length) return [];
+  const state = openAttachmentDirectory(options.root, workItem.id);
+  try {
+    const files = workItem.attachments.map(attachment => {
+      const storageName = attachment.storageName;
+      if (typeof storageName !== 'string' || !/^[A-Za-z0-9_-]+(?:\.[a-z0-9]{1,10})?$/.test(storageName)) {
+        throw new Error('WorkItem attachment metadata is invalid');
+      }
+      assertDescriptorMatchesPath(state.rootDescriptor, state.attachmentRoot, 'WorkItem attachment root');
+      assertDescriptorMatchesPath(state.itemDescriptor, state.itemDirectory, 'WorkItem attachment owner directory');
+      const fd = openSync(`/proc/self/fd/${state.itemDescriptor}/${storageName}`, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+      try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile()) throw new Error('WorkItem attachment is not a regular file');
+        assertWorkItemAttachmentSize(stat.size);
+        const buffer = readFileSync(fd);
+        if (buffer.length !== Number(attachment.size) || digest(buffer) !== attachment.sha256) {
+          throw new Error('WorkItem attachment changed after creation');
+        }
+        return { name: attachment.name, mimeType: attachment.mimeType, data: buffer.toString('base64') };
+      } finally { closeSync(fd); }
+    });
+    return persistWorkItemAttachments(files, { root: options.root, workItemId });
+  } finally { closeDirectoryState(state); }
+}
+
 export function readWorkItemAttachment(workItem, attachmentId, options = {}) {
   const attachment = Array.isArray(workItem?.attachments)
     ? workItem.attachments.find(item => item?.id === attachmentId)

package/yeaft/work-center/bridge.js

@@ -21,7 +21,7 @@ let serviceFactory = null;
 let featureEnabled = false;
 
 const BROWSER_DETAIL_OPS = new Set([
-  'get', 'create', 'update', 'start', 'cancel', 'resume', 'extend_budget', 'post_work_item_message', 'action_input', 'retry_action', 'guide', 'retry',
+  'get', 'create', 'update', 'update_schedule', 'start', 'cancel', 'resume', 'extend_budget', 'post_work_item_message', 'action_input', 'retry_action', 'guide', 'retry',
 ]);
 const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_requests', 'get_action_request']);
 // `files` is an internal server-to-Agent field. The browser relay rejects any
@@ -29,7 +29,7 @@ const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_req
 const BROWSER_FILE_FIELDS = Object.freeze({
   create: [
     'title', 'titleSource', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'deliveryTarget', 'deliveryInstructions',
-    'reuseMemory', 'files', 'start',
+    'reuseMemory', 'files', 'start', 'scheduledFor', 'scheduleEnabled', 'recurrence',
   ],
   post_work_item_message: [
     'id', 'clientMessageId', 'text', 'target', 'revision', 'planRevision', 'ledgerRevision',
@@ -96,6 +96,7 @@ async function getSettingsRuntime() {
     defaultWorkDir: ctx.CONFIG?.workDir || process.cwd(),
     workItemAttachments: Array.isArray(ctx.agentCapabilities)
       && ctx.agentCapabilities.includes('work_item_attachments'),
+    recurringSchedules: true,
     defaultStageInstructions: defaultWorkCenterStageInstructions(),
   };
 }

package/yeaft/work-center/controller.js

@@ -164,8 +164,8 @@ export class WorkflowController {
     return detail;
   }
 
-  startScheduled(id, scheduledAt) {
-    return this.store.startWorkItemAtomic(id, workItem => {
+  startScheduled(id, scheduledAt, cloneAttachments = null) {
+    return this.store.dispatchScheduledWorkItem(id, scheduledAt, workItem => {
       const action = initialActionFor(workItem);
       if (workItem.reuseMemory === false) return action;
       const context = this.store.getReusableContext(workItem.workDir, workItem.id);
@@ -174,7 +174,7 @@ export class WorkflowController {
         context,
         instruction: actionInstruction(action, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
       };
-    }, { scheduledAt });
+    }, cloneAttachments);
   }
 
   update(id, patch) {

package/yeaft/work-center/durable-model.js

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { withTransaction } from './transaction.js';
 
-export const WORK_CENTER_SCHEMA_VERSION = 41;
+export const WORK_CENTER_SCHEMA_VERSION = 42;
 
 const MIGRATIONS = [
   ['23-conversation-stream', migrateConversationStream],
@@ -22,6 +23,7 @@ const MIGRATIONS = [
   ['39-action-creation-source', migrateActionCreationSource],
   ['40-work-item-schedules', migrateWorkItemSchedules],
   ['41-delivery-instructions', migrateDeliveryInstructions],
+  ['42-recurring-schedules', migrateRecurringSchedules],
 ];
 
 const MIGRATION_ALIASES = new Map([
@@ -83,15 +85,7 @@ function runMigration(db, now, name, migration) {
     db.prepare(`INSERT INTO schema_migrations(name, checksum, applied_at)
       VALUES (?, ?, ?)`).run(name, checksum, now);
   };
-  if (db.isTransaction) return apply();
-  db.exec('BEGIN IMMEDIATE');
-  try {
-    apply();
-    db.exec('COMMIT');
-  } catch (error) {
-    try { db.exec('ROLLBACK'); } catch {}
-    throw error;
-  }
+  return withTransaction(db, apply);
 }
 
 export function migrateDurableWorkCenterModel(db, now = Date.now(), sourceSchemaVersion = 22) {
@@ -568,6 +562,20 @@ function migrateActionClosureAndOutputs(db) {
   `);
 }
 
+function migrateRecurringSchedules(db) {
+  for (const [column, definition] of [
+    ['schedule_recurrence', 'TEXT'],
+    ['schedule_run_count', 'INTEGER NOT NULL DEFAULT 0'],
+    ['schedule_last_work_item_id', 'TEXT'],
+    ['source_schedule_id', 'TEXT'],
+    ['scheduled_occurrence_at', 'INTEGER'],
+  ]) {
+    if (!hasColumn(db, 'work_items', column)) db.exec(`ALTER TABLE work_items ADD COLUMN ${column} ${definition}`);
+  }
+  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_work_items_schedule_occurrence
+    ON work_items(source_schedule_id, scheduled_occurrence_at) WHERE source_schedule_id IS NOT NULL`);
+}
+
 function migrateWorkItemSchedules(db) {
   for (const [column, definition] of [
     ['schedule_status', 'TEXT'],

package/yeaft/work-center/projection.js

@@ -27,6 +27,24 @@ const MAX_HISTORICAL_BRIEF_CHARS = 256;
 const MAX_CURRENT_BRIEF_BYTES = 8 * 1024;
 export const MAX_WORK_ITEM_BROWSER_DTO_BYTES = 512 * 1024;
 
+function projectSchedule(schedule) {
+  if (!schedule) return null;
+  return {
+    status: schedule.status,
+    scheduledFor: schedule.scheduledFor ?? null,
+    triggeredAt: schedule.triggeredAt ?? null,
+    recurrence: schedule.recurrence || null,
+    runCount: count(schedule.runCount),
+    lastWorkItemId: schedule.lastWorkItemId || null,
+    // Do not forward caller-provided diagnostic text, stack, paths or metadata.
+    lastError: schedule.lastError ? {
+      code: 'schedule_dispatch_failed',
+      message: 'Scheduled execution could not start. The plan will retry automatically; check its configuration and attachments.',
+      at: count(schedule.lastError.at),
+    } : null,
+  };
+}
+
 function jsonByteLength(value) {
   return Buffer.byteLength(JSON.stringify(value), 'utf8');
 }
@@ -1094,7 +1112,9 @@ export function projectWorkItemDetail(detail, options = {}) {
     executionControl: detail.executionControl,
     executionStats: combinedExecutionStats(detail),
     reuseMemory: detail.reuseMemory !== false,
-    schedule: detail.schedule || null,
+    schedule: projectSchedule(detail.schedule),
+    sourceScheduleId: detail.sourceScheduleId || null,
+    scheduledOccurrenceAt: detail.scheduledOccurrenceAt ?? null,
     deliveryTarget: ['response', 'workspace_files', 'pull_request', 'merge'].includes(detail.deliveryTarget)
       ? detail.deliveryTarget : null,
     deliveryInstructions: truncateUtf8(detail.deliveryInstructions || '', 2 * 1024),
@@ -1206,7 +1226,9 @@ export function projectWorkItemSummary(detail) {
       executionStats: combinedExecutionStats(detail),
       executionControl: detail.executionControl,
       origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
-      schedule: detail.schedule || null,
+      schedule: projectSchedule(detail.schedule),
+      sourceScheduleId: detail.sourceScheduleId || null,
+      scheduledOccurrenceAt: detail.scheduledOccurrenceAt ?? null,
       linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
       attachmentCount: Array.isArray(detail.attachments) ? detail.attachments.length : 0,
       createdAt: detail.createdAt,
@@ -1247,7 +1269,9 @@ export function projectWorkItemSummary(detail) {
     currentAction: projectCurrentActionSummary(action, projectedAction),
     actionStats: projectActionStats(detail, null),
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
-    schedule: detail.schedule || null,
+    schedule: projectSchedule(detail.schedule),
+    sourceScheduleId: detail.sourceScheduleId || null,
+    scheduledOccurrenceAt: detail.scheduledOccurrenceAt ?? null,
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
     attachmentCount: Array.isArray(detail.attachments) ? detail.attachments.length : 0,
     createdAt: detail.createdAt,

package/yeaft/work-center/recurrence.js

@@ -0,0 +1,103 @@
+// Calendar computation is pure and independent of dispatch / Agent local timezone.
+// Keep arithmetic and Intl in a bounded, supported date range (1970–2099).
+export const MAX_SCHEDULE_TIMESTAMP = Date.UTC(2100, 0, 1) - 1;
+const DAY = 86_400_000;
+
+export function validateScheduleTimestamp(value, name = 'scheduledFor') {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_SCHEDULE_TIMESTAMP) {
+    throw new Error(`${name} must be epoch milliseconds between 1970 and 2099`);
+  }
+  return value;
+}
+
+export function normalizeRecurrence(value) {
+  if (value == null) return null;
+  if (typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid recurrence');
+  const allowed = ['frequency', 'timeZone', 'time', 'weekdays', 'dayOfMonth', 'endsAt', 'maxRuns'];
+  if (Object.keys(value).some(key => !allowed.includes(key))) throw new Error('Unknown recurrence field');
+  if (!['daily', 'weekdays', 'weekly', 'monthly'].includes(value.frequency)) throw new Error('Invalid recurrence frequency');
+  if (typeof value.timeZone !== 'string' || value.timeZone.length > 100 || /^[+-]/.test(value.timeZone)) throw new Error('Invalid recurrence timeZone');
+  try { new Intl.DateTimeFormat('en', { timeZone: value.timeZone }); } catch { throw new Error('Invalid recurrence timeZone'); }
+  if (typeof value.time !== 'string' || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value.time)) throw new Error('Invalid recurrence time');
+  if (value.weekdays !== undefined && (!Array.isArray(value.weekdays) || value.weekdays.length > 7
+      || value.weekdays.some(day => !Number.isInteger(day) || day < 0 || day > 6)
+      || new Set(value.weekdays).size !== value.weekdays.length)) throw new Error('Invalid recurrence weekdays');
+  if (value.frequency === 'weekly' && !value.weekdays?.length) throw new Error('Weekly recurrence requires weekdays');
+  if (value.dayOfMonth !== undefined && (!Number.isInteger(value.dayOfMonth) || value.dayOfMonth < 1 || value.dayOfMonth > 31)) throw new Error('Invalid recurrence dayOfMonth');
+  if (value.frequency === 'monthly' && value.dayOfMonth === undefined) throw new Error('Monthly recurrence requires dayOfMonth');
+  if (value.endsAt != null) validateScheduleTimestamp(value.endsAt, 'endsAt');
+  if (value.maxRuns != null && (!Number.isInteger(value.maxRuns) || value.maxRuns < 1 || value.maxRuns > 1000)) throw new Error('Invalid recurrence maxRuns');
+  return { frequency: value.frequency, timeZone: value.timeZone, time: value.time,
+    ...(value.weekdays !== undefined ? { weekdays: [...value.weekdays].sort() } : {}),
+    ...(value.dayOfMonth !== undefined ? { dayOfMonth: value.dayOfMonth } : {}),
+    endsAt: value.endsAt ?? null, maxRuns: value.maxRuns ?? null };
+}
+
+function calendar(recurrence) {
+  const formatter = new Intl.DateTimeFormat('en-GB', { timeZone: recurrence.timeZone,
+    year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23' });
+  const parts = timestamp => Object.fromEntries(formatter.formatToParts(timestamp)
+    .filter(part => part.type !== 'literal').map(part => [part.type, Number(part.value)]));
+  const localEpoch = timestamp => {
+    const p = parts(timestamp);
+    return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  };
+  return { parts, localEpoch };
+}
+
+// Resolve a wall time by trying nearby UTC offsets. Gaps have no matching instant;
+// folds select the earlier instant, so a local date can never execute twice.
+function wallInstant(date, recurrence, localEpoch) {
+  const [hour, minute] = recurrence.time.split(':').map(Number);
+  const wall = date + hour * 3_600_000 + minute * 60_000;
+  const candidates = new Set();
+  for (let hours = -36; hours <= 36; hours += 6) {
+    const probe = wall + hours * 3_600_000;
+    const candidate = wall - (localEpoch(probe) - probe);
+    if (localEpoch(candidate) === wall) candidates.add(candidate);
+  }
+  return candidates.size ? Math.min(...candidates) : null;
+}
+
+function matchesDate(date, recurrence) {
+  const d = new Date(date);
+  const weekday = d.getUTCDay();
+  if (recurrence.frequency === 'weekdays') return weekday > 0 && weekday < 6;
+  if (recurrence.frequency === 'weekly') return recurrence.weekdays.includes(weekday);
+  if (recurrence.frequency === 'monthly') {
+    const last = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0)).getUTCDate();
+    return d.getUTCDate() === Math.min(recurrence.dayOfMonth, last);
+  }
+  return true;
+}
+
+function findOccurrence(recurrence, timestamp, direction) {
+  validateScheduleTimestamp(timestamp);
+  const { parts, localEpoch } = calendar(recurrence);
+  const p = parts(timestamp);
+  const date = Date.UTC(p.year, p.month - 1, p.day);
+  // Monthly schedules need at most 62 days even around a skipped civil date.
+  // A hard bound also protects dispatch from malformed persisted data.
+  for (let day = 0; day < 370; day++) {
+    const candidateDate = date + day * direction * DAY;
+    if (!matchesDate(candidateDate, recurrence)) continue;
+    const candidate = wallInstant(candidateDate, recurrence, localEpoch);
+    if (candidate == null || candidate < 0 || candidate > MAX_SCHEDULE_TIMESTAMP) continue;
+    if (direction > 0 ? candidate > timestamp : candidate <= timestamp) return candidate;
+  }
+  return null;
+}
+
+export function nextOccurrence(recurrence, after) {
+  return findOccurrence(recurrence, after, 1);
+}
+
+export function latestOccurrence(recurrence, at) {
+  return findOccurrence(recurrence, at, -1);
+}
+
+export function initialOccurrence(recurrence, scheduledFor) {
+  validateScheduleTimestamp(scheduledFor);
+  if (!recurrence || latestOccurrence(recurrence, scheduledFor) === scheduledFor) return scheduledFor;
+  return nextOccurrence(recurrence, scheduledFor);
+}

package/yeaft/work-center/resource-control.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { withTransaction } from './transaction.js';
 import { LLMAdapter } from '../llm/adapter.js';
 import { normalizeTokenUsage } from '../llm/usage-accounting.js';
 
@@ -88,10 +89,7 @@ export class WorkCenterResourceControl {
   }
 
   atomic(fn) {
-    if (this.db.isTransaction) return fn();
-    this.db.exec('BEGIN IMMEDIATE');
-    try { const result = fn(); this.db.exec('COMMIT'); return result; }
-    catch (error) { this.db.exec('ROLLBACK'); throw error; }
+    return withTransaction(this.db, fn);
   }
 
   ensure(id) {

package/yeaft/work-center/service.js

@@ -1,3 +1,4 @@
+import { normalizeRecurrence, validateScheduleTimestamp } from './recurrence.js';
 import { realpathSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -6,6 +7,7 @@ import { WorkflowController } from './controller.js';
 import { WorkItemWatcher } from './watcher.js';
 import {
   appendWorkItemAttachments,
+  cloneWorkItemAttachments,
   persistWorkItemAttachments,
   readWorkItemAttachment,
   removeWorkItemAttachmentFiles,
@@ -114,6 +116,7 @@ export class WorkCenterService {
         ...(await this.runtimeInfoProvider()),
         defaultStageInstructions: defaultWorkCenterStageInstructions(),
         workItemTypes: listWorkItemTypeTemplates(settings),
+        recurringSchedules: true,
       };
     };
     this.ownerBootId = options.ownerBootId || randomUUID();
@@ -255,10 +258,14 @@ export class WorkCenterService {
             workItemId,
           });
           const scheduledFor = payload.scheduledFor == null || payload.scheduledFor === ''
-            ? null : Number(payload.scheduledFor);
+            ? null : payload.scheduledFor;
           if (scheduledFor != null && (!Number.isSafeInteger(scheduledFor) || scheduledFor <= this.now())) {
             throw new Error('scheduledFor must be in the future');
           }
+          if (scheduledFor != null) validateScheduleTimestamp(scheduledFor);
+          if (payload.scheduleEnabled !== undefined && typeof payload.scheduleEnabled !== 'boolean') throw new Error('scheduleEnabled must be a boolean');
+          const recurrence = normalizeRecurrence(payload.recurrence);
+          if (recurrence && scheduledFor == null) throw new Error('recurrence requires scheduledFor');
           const shouldStart = scheduledFor == null
             && (payload.start === undefined ? settings.startImmediately : payload.start !== false);
           const goal = requiredString(payload.goal, 'goal');
@@ -308,6 +315,7 @@ export class WorkCenterService {
             schedule: scheduledFor == null ? null : {
               status: payload.scheduleEnabled === false ? 'paused' : 'scheduled',
               scheduledFor,
+              recurrence,
             },
             start: false,
           });
@@ -745,8 +753,27 @@ export class WorkCenterService {
   #scanSchedules() {
     const now = this.now();
     for (const id of this.store.listDueScheduledWorkItemIds(now)) {
-      const detail = this.controller.startScheduled(id, now);
-      if (detail) this.#emit({ type: 'work_item.schedule_triggered', workItem: detail });
+      const createdAttachmentOwners = [];
+      try {
+        const before = this.store.getWorkItem(id);
+        const detail = this.controller.startScheduled(id, now, (source, occurrenceId) => {
+          const attachments = cloneWorkItemAttachments(source, occurrenceId, { root: this.attachmentRoot });
+          createdAttachmentOwners.push(occurrenceId);
+          return attachments;
+        });
+        const source = this.store.getWorkItemDetail(id);
+        if (detail) this.#emit({ type: 'work_item.schedule_triggered', workItem: source });
+        else if (source && source.revision !== before?.revision) {
+          this.#emit({ type: 'work_item.schedule_advanced', workItem: source });
+        }
+        if (detail && detail.id !== id) this.#emit({ type: 'work_item.created', workItem: detail });
+      } catch {
+        for (const owner of createdAttachmentOwners) {
+          if (!this.store.getWorkItem(owner)) removeWorkItemAttachments(this.attachmentRoot, owner);
+        }
+        const workItem = this.store.recordScheduleFailure(id);
+        if (workItem) this.#emit({ type: 'work_item.schedule_failed', workItem });
+      }
     }
   }