@myagentroam/node 0.9.128 → 0.9.129

package/dist/connector.js

@@ -1334,7 +1334,7 @@ export class NodeConnector {
                     session.workspaceId !== task.workspaceId ||
                     session.runner !== task.runner)
                     throw new Error('SCHEDULE_SESSION_NOT_FOUND');
-                const configuration = this.nativeSessionProjectionService.resumedConfiguration(session);
+                const configuredSession = this.nativeSessionProjectionService.ensureResumedConfiguration(session);
                 return this.scheduledRunAuthorization.authorize({
                     taskId: task.id,
                     revision: task.revision,
@@ -1343,7 +1343,7 @@ export class NodeConnector {
                     workspaceId: task.workspaceId,
                     ownerUserId: task.ownerUserId,
                     runner: task.runner,
-                    model: configuration.model
+                    model: configuredSession.model
                 });
             },
             submit: async (task, occurrenceId, context) => {

package/dist/service/native-session-projection-service.js

@@ -98,31 +98,33 @@ export class NativeSessionProjectionService {
             externalSessionId: direct.externalSessionId,
             nativeControl: 'EXTERNAL',
             cwd: direct.cwd,
+            ...(direct.model === null ? {} : { model: direct.model }),
+            ...(direct.effort === null ? {} : { effort: direct.effort }),
+            ...(direct.access === null ? {} : { access: direct.access }),
             ...(direct.runnerTitle === null ? {} : { title: direct.runnerTitle }),
             ...(direct.customTitle === null ? {} : { customTitle: direct.customTitle })
         });
     }
     resumedConfiguration(session) {
         const workspace = this.options.database()?.getWorkspace(session.workspaceId);
-        const current = {
-            runner: session.runner,
-            model: session.model,
-            effort: session.effort,
-            access: session.access
-        };
-        if (typeof current.model === 'string' &&
-            typeof current.effort === 'string' &&
-            typeof current.access === 'string')
-            return session.runner === 'mar-agent'
-                ? { ...current, access: 'full-access' }
-                : current;
         const saved = this.options
             .database()
             ?.getRunnerDefaults()
             .find((value) => value.runner === session.runner);
-        if (saved !== undefined)
-            return session.runner === 'mar-agent' ? { ...saved, access: 'full-access' } : saved;
-        return this.options.runners.require(session.runner).defaultConfiguration(workspace);
+        const fallback = saved ?? this.options.runners.require(session.runner).defaultConfiguration(workspace);
+        const configuration = {
+            runner: session.runner,
+            model: typeof session.model === 'string' && session.model.trim().length > 0
+                ? session.model
+                : fallback.model,
+            effort: typeof session.effort === 'string' ? session.effort : fallback.effort,
+            access: typeof session.access === 'string' && session.access.trim().length > 0
+                ? session.access
+                : fallback.access
+        };
+        return session.runner === 'mar-agent'
+            ? { ...configuration, access: 'full-access' }
+            : configuration;
     }
     ensureResumedConfiguration(session) {
         const configuration = this.resumedConfiguration(session);

package/dist/service/scheduled-session-recurrence.js

@@ -1,14 +1,21 @@
 export function parseScheduledCron(cron) {
-    const fields = cron.trim().split(/\s+/);
-    if (fields.length !== 5 || fields[2] !== '*' || fields[3] !== '*')
-        throw new Error('SCHEDULE_CRON_INVALID');
-    const minute = boundedInteger(fields[0], 0, 59);
-    if (fields[1] === '*' && fields[4] === '*')
-        return { kind: 'HOURLY', minute };
-    const hour = boundedInteger(fields[1], 0, 23);
-    if (fields[4] === '*')
-        return { kind: 'DAILY', minute, hour };
-    return { kind: 'WEEKLY', minute, hour, weekday: boundedInteger(fields[4], 0, 6) };
+    const parsed = parseCronExpression(cron);
+    if (parsed.dayOfMonthWildcard &&
+        parsed.monthWildcard &&
+        /^\d+$/.test(parsed.fields[0] ?? '') &&
+        (parsed.fields[1] === '*' || /^\d+$/.test(parsed.fields[1] ?? '')) &&
+        (parsed.fields[4] === '*' || /^\d+$/.test(parsed.fields[4] ?? ''))) {
+        const minute = exactInteger(parsed.fields[0], 0, 59);
+        const hour = parsed.fields[1] === '*' ? undefined : exactInteger(parsed.fields[1], 0, 23);
+        const weekdayValue = parsed.fields[4] === '*' ? undefined : exactInteger(parsed.fields[4], 0, 7);
+        if (hour === undefined && weekdayValue === undefined)
+            return { kind: 'HOURLY', minute };
+        if (hour !== undefined && weekdayValue === undefined)
+            return { kind: 'DAILY', minute, hour };
+        if (hour !== undefined && weekdayValue !== undefined)
+            return { kind: 'WEEKLY', minute, hour, weekday: weekdayValue === 7 ? 0 : weekdayValue };
+    }
+    return { kind: 'CRON', expression: parsed.expression };
 }
 export function assertScheduleTimezone(timezone) {
     if (timezone.length < 1 || timezone.length > 128)
@@ -21,7 +28,7 @@ export function assertScheduleTimezone(timezone) {
     }
 }
 export function nextScheduledAt(cron, timezone, after) {
-    const cadence = parseScheduledCron(cron);
+    const schedule = parseCronExpression(cron);
     assertScheduleTimezone(timezone);
     if (!Number.isSafeInteger(after) || after < 0)
         throw new Error('SCHEDULE_TIME_INVALID');
@@ -37,17 +44,81 @@ export function nextScheduledAt(cron, timezone, after) {
     });
     const previousKey = localKey(formatter, after);
     let candidate = Math.floor(after / 60_000) * 60_000 + 60_000;
-    for (let index = 0; index < 8 * 24 * 60 + 120; index++, candidate += 60_000) {
+    for (let index = 0; index < 8 * 366 * 24 * 60; index++, candidate += 60_000) {
         const local = localParts(formatter, candidate);
-        if (local.minute === cadence.minute &&
-            (cadence.kind === 'HOURLY' || local.hour === cadence.hour) &&
-            (cadence.kind !== 'WEEKLY' || local.weekday === cadence.weekday) &&
-            local.key !== previousKey)
+        if (matches(schedule, local) && local.key !== previousKey)
             return candidate;
     }
     throw new Error('SCHEDULE_NEXT_TIME_UNAVAILABLE');
 }
-function boundedInteger(value, min, max) {
+function parseCronExpression(cron) {
+    const expression = cron.trim();
+    const fields = expression.split(/\s+/);
+    if (expression.length === 0 ||
+        expression.length > 64 ||
+        fields.length !== 5 ||
+        fields.some((field) => field.length === 0))
+        throw new Error('SCHEDULE_CRON_INVALID');
+    const minute = parseField(fields[0] ?? '', 0, 59);
+    const hour = parseField(fields[1] ?? '', 0, 23);
+    const dayOfMonth = parseField(fields[2] ?? '', 1, 31);
+    const month = parseField(fields[3] ?? '', 1, 12);
+    const dayOfWeek = parseField(fields[4] ?? '', 0, 7, (value) => (value === 7 ? 0 : value));
+    return {
+        expression,
+        fields,
+        minute: minute.values,
+        hour: hour.values,
+        dayOfMonth: dayOfMonth.values,
+        month: month.values,
+        dayOfWeek: dayOfWeek.values,
+        dayOfMonthWildcard: minuteWildcard(dayOfMonth.values, 1, 31),
+        monthWildcard: minuteWildcard(month.values, 1, 12),
+        dayOfWeekWildcard: minuteWildcard(dayOfWeek.values, 0, 6)
+    };
+}
+function parseField(field, min, max, normalize = (value) => value) {
+    if (field.includes('?'))
+        throw new Error('SCHEDULE_CRON_INVALID');
+    const values = new Set();
+    for (const segment of field.split(',')) {
+        if (segment.length === 0)
+            throw new Error('SCHEDULE_CRON_INVALID');
+        const parts = segment.split('/');
+        if (parts.length > 2 || parts.some((part) => part.length === 0))
+            throw new Error('SCHEDULE_CRON_INVALID');
+        const base = parts[0] ?? '';
+        const step = parts[1] === undefined ? 1 : exactInteger(parts[1], 1, max - min + 1);
+        let start;
+        let end;
+        if (base === '*') {
+            start = min;
+            end = max;
+        }
+        else if (/^\d+-\d+$/.test(base)) {
+            const range = base.split('-');
+            start = exactInteger(range[0], min, max);
+            end = exactInteger(range[1], min, max);
+            if (start > end)
+                throw new Error('SCHEDULE_CRON_INVALID');
+        }
+        else if (parts.length === 1 && /^\d+$/.test(base)) {
+            start = exactInteger(base, min, max);
+            end = start;
+        }
+        else {
+            throw new Error('SCHEDULE_CRON_INVALID');
+        }
+        if (parts[1] !== undefined && start === end)
+            throw new Error('SCHEDULE_CRON_INVALID');
+        for (let value = start; value <= end; value += step)
+            values.add(normalize(value));
+    }
+    if (values.size === 0)
+        throw new Error('SCHEDULE_CRON_INVALID');
+    return { values };
+}
+function exactInteger(value, min, max) {
     if (value === undefined || !/^(0|[1-9][0-9]*)$/.test(value))
         throw new Error('SCHEDULE_CRON_INVALID');
     const number = Number(value);
@@ -55,18 +126,41 @@ function boundedInteger(value, min, max) {
         throw new Error('SCHEDULE_CRON_INVALID');
     return number;
 }
+function minuteWildcard(values, min, max) {
+    return values.size === max - min + 1;
+}
 function localParts(formatter, time) {
     const fields = Object.fromEntries(formatter.formatToParts(time).map((part) => [part.type, part.value]));
     const hour = Number(fields['hour']);
     const minute = Number(fields['minute']);
+    const day = Number(fields['day']);
+    const month = Number(fields['month']);
     const weekday = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(fields['weekday'] ?? '');
     return {
         hour,
         minute,
+        day,
+        month,
         weekday,
         key: `${fields['year']}-${fields['month']}-${fields['day']}T${fields['hour']}:${fields['minute']}`
     };
 }
+function matches(schedule, local) {
+    if (!schedule.minute.has(local.minute) ||
+        !schedule.hour.has(local.hour) ||
+        !schedule.month.has(local.month))
+        return false;
+    const dayOfMonthMatches = schedule.dayOfMonth.has(local.day);
+    const dayOfWeekMatches = schedule.dayOfWeek.has(local.weekday);
+    const dayMatches = schedule.dayOfMonthWildcard && schedule.dayOfWeekWildcard
+        ? true
+        : schedule.dayOfMonthWildcard
+            ? dayOfWeekMatches
+            : schedule.dayOfWeekWildcard
+                ? dayOfMonthMatches
+                : dayOfMonthMatches || dayOfWeekMatches;
+    return dayMatches;
+}
 function localKey(formatter, time) {
     return localParts(formatter, time).key;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.128",
+  "version": "0.9.129",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.128",
-    "@myagentroam/protocol": "0.9.128",
-    "@myagentroam/code-navigation": "0.9.128"
+    "@myagentroam/agent": "0.9.129",
+    "@myagentroam/protocol": "0.9.129",
+    "@myagentroam/code-navigation": "0.9.129"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"