@promptbook/cli 0.114.0-5 → 0.114.0-50

package/apps/agents-server/src/utils/vpsSelfUpdate/vpsSelfUpdateCron.ts

@@ -1,5 +1,6 @@
-import { NotAllowed } from '../../../../../src/errors/NotAllowed';
 import { spaceTrim } from 'spacetrim';
+import { NotAllowed } from '../../../../../src/errors/NotAllowed';
+import { normalizeCronExpression, resolveNextCronRun } from '../cronExpression';
 
 /**
  * Default automatic self-update cron expression: every day at midnight.
@@ -8,63 +9,6 @@ import { spaceTrim } from 'spacetrim';
  */
 export const DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION = '0 0 * * *';
 
-/**
- * Number of fields in a standard minute-based cron expression.
- *
- * @private constant of `vpsSelfUpdate`
- */
-const VPS_SELF_UPDATE_CRON_FIELD_COUNT = 5;
-
-/**
- * Maximum number of minutes scanned while finding the next cron run.
- *
- * Five years keeps leap-day schedules valid while still rejecting impossible expressions.
- *
- * @private constant of `vpsSelfUpdate`
- */
-const VPS_SELF_UPDATE_CRON_LOOKAHEAD_MINUTES = 366 * 24 * 60 * 5;
-
-/**
- * Parsed cron field values.
- *
- * @private type of `vpsSelfUpdateCron`
- */
-type VpsSelfUpdateCronField = {
-    /**
-     * Accepted numeric values for this field.
-     */
-    readonly values: ReadonlySet<number>;
-    /**
-     * Whether the field is the unrestricted `*` wildcard.
-     */
-    readonly isWildcard: boolean;
-};
-
-/**
- * Parsed five-field cron expression.
- *
- * @private type of `vpsSelfUpdateCron`
- */
-type VpsSelfUpdateCronExpression = {
-    readonly minute: VpsSelfUpdateCronField;
-    readonly hour: VpsSelfUpdateCronField;
-    readonly dayOfMonth: VpsSelfUpdateCronField;
-    readonly month: VpsSelfUpdateCronField;
-    readonly dayOfWeek: VpsSelfUpdateCronField;
-};
-
-/**
- * One cron field parser configuration.
- *
- * @private type of `vpsSelfUpdateCron`
- */
-type VpsSelfUpdateCronFieldOptions = {
-    readonly name: string;
-    readonly minimum: number;
-    readonly maximum: number;
-    readonly isSevenAllowedForSunday?: boolean;
-};
-
 /**
  * Normalizes and validates a cron expression accepted by the automatic self-update scheduler.
  *
@@ -74,12 +18,9 @@ type VpsSelfUpdateCronFieldOptions = {
  * @private function of `vpsSelfUpdate`
  */
 export function normalizeVpsSelfUpdateCronExpression(value: string | null | undefined): string {
-    const normalizedExpression = normalizeVpsSelfUpdateCronWhitespace(value || DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION);
-    const cronExpression = parseVpsSelfUpdateCronExpression(normalizedExpression);
-
-    resolveNextVpsSelfUpdateCronRunFromParsedExpression(cronExpression, new Date());
-
-    return normalizedExpression;
+    return resolveWithVpsSelfUpdateCronError(() =>
+        normalizeCronExpression((value || '').trim() || DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION),
+    );
 }
 
 /**
@@ -92,266 +33,32 @@ export function normalizeVpsSelfUpdateCronExpression(value: string | null | unde
  * @private function of `vpsSelfUpdate`
  */
 export function resolveNextVpsSelfUpdateCronRun(cronExpression: string, afterDate = new Date()): Date {
-    return resolveNextVpsSelfUpdateCronRunFromParsedExpression(
-        parseVpsSelfUpdateCronExpression(normalizeVpsSelfUpdateCronWhitespace(cronExpression)),
-        afterDate,
-    );
+    return resolveWithVpsSelfUpdateCronError(() => resolveNextCronRun(cronExpression, afterDate));
 }
 
 /**
- * Collapses cron whitespace without changing field values.
+ * Reports one shared cron failure as a self-update configuration failure.
  *
- * @param value - Raw cron expression.
- * @returns Whitespace-normalized expression.
- */
-function normalizeVpsSelfUpdateCronWhitespace(value: string): string {
-    return value.trim().replace(/\s+/gu, ' ') || DEFAULT_VPS_SELF_UPDATE_CRON_EXPRESSION;
-}
-
-/**
- * Parses a five-field cron expression into numeric field sets.
+ * The automatic self-update cron comes from the VPS configuration rather than from a request, so an
+ * invalid expression is a configuration problem and keeps its own branded error.
+ *
+ * @param resolveCronValue - Operation performed by the shared cron engine.
+ * @returns Value returned by the operation.
  *
- * @param expression - Normalized cron expression.
- * @returns Parsed cron expression.
+ * @private function of `vpsSelfUpdateCron`
  */
-function parseVpsSelfUpdateCronExpression(expression: string): VpsSelfUpdateCronExpression {
-    const fields = expression.split(' ');
-    if (fields.length !== VPS_SELF_UPDATE_CRON_FIELD_COUNT) {
+function resolveWithVpsSelfUpdateCronError<TCronValue>(resolveCronValue: () => TCronValue): TCronValue {
+    try {
+        return resolveCronValue();
+    } catch (error) {
         throw new NotAllowed(
-            spaceTrim(`
-                Automatic self-update cron expression \`${expression}\` is invalid.
+            spaceTrim(
+                (block) => `
+                    Automatic self-update cron expression is invalid.
 
-                **Use exactly five fields:** minute hour day-of-month month day-of-week.
-            `),
+                    ${block(error instanceof Error ? error.message : String(error))}
+                `,
+            ),
         );
     }
-
-    return {
-        minute: parseVpsSelfUpdateCronField(fields[0]!, { name: 'minute', minimum: 0, maximum: 59 }),
-        hour: parseVpsSelfUpdateCronField(fields[1]!, { name: 'hour', minimum: 0, maximum: 23 }),
-        dayOfMonth: parseVpsSelfUpdateCronField(fields[2]!, { name: 'day-of-month', minimum: 1, maximum: 31 }),
-        month: parseVpsSelfUpdateCronField(fields[3]!, { name: 'month', minimum: 1, maximum: 12 }),
-        dayOfWeek: parseVpsSelfUpdateCronField(fields[4]!, {
-            name: 'day-of-week',
-            minimum: 0,
-            maximum: 7,
-            isSevenAllowedForSunday: true,
-        }),
-    };
-}
-
-/**
- * Parses one cron field with comma lists, ranges, and step values.
- *
- * @param field - Raw field value.
- * @param options - Numeric bounds and label.
- * @returns Parsed field values.
- */
-function parseVpsSelfUpdateCronField(field: string, options: VpsSelfUpdateCronFieldOptions): VpsSelfUpdateCronField {
-    const values = new Set<number>();
-    const isWildcard = field === '*';
-
-    for (const part of field.split(',')) {
-        if (!part) {
-            throwInvalidVpsSelfUpdateCronField(field, options.name);
-        }
-
-        addVpsSelfUpdateCronFieldPart(values, part, options);
-    }
-
-    if (values.size === 0) {
-        throwInvalidVpsSelfUpdateCronField(field, options.name);
-    }
-
-    return { values, isWildcard };
-}
-
-/**
- * Adds values represented by one comma-separated cron field part.
- *
- * @param values - Mutable field value set.
- * @param part - Field part, for example a wildcard, `1-5`, or a stepped wildcard.
- * @param options - Numeric bounds and label.
- */
-function addVpsSelfUpdateCronFieldPart(
-    values: Set<number>,
-    part: string,
-    options: VpsSelfUpdateCronFieldOptions,
-): void {
-    const stepSplit = part.split('/');
-    if (stepSplit.length > 2) {
-        throwInvalidVpsSelfUpdateCronField(part, options.name);
-    }
-
-    const rangePart = stepSplit[0]!;
-    const step = stepSplit[1] === undefined ? 1 : parseVpsSelfUpdateCronNumber(stepSplit[1], options.name);
-    if (step <= 0) {
-        throwInvalidVpsSelfUpdateCronField(part, options.name);
-    }
-
-    const { start, end } = parseVpsSelfUpdateCronRange(rangePart, options);
-    for (let value = start; value <= end; value += step) {
-        values.add(normalizeVpsSelfUpdateCronFieldValue(value, options));
-    }
-}
-
-/**
- * Parses the range portion of one cron field part.
- *
- * @param rangePart - Range part before optional `/step`.
- * @param options - Numeric bounds and label.
- * @returns Start and end range values.
- */
-function parseVpsSelfUpdateCronRange(
-    rangePart: string,
-    options: VpsSelfUpdateCronFieldOptions,
-): { readonly start: number; readonly end: number } {
-    if (rangePart === '*') {
-        return { start: options.minimum, end: options.maximum };
-    }
-
-    const rangeSplit = rangePart.split('-');
-    if (rangeSplit.length > 2 || rangeSplit.some((value) => value === '')) {
-        throwInvalidVpsSelfUpdateCronField(rangePart, options.name);
-    }
-
-    const start = parseVpsSelfUpdateCronNumber(rangeSplit[0]!, options.name);
-    const end = rangeSplit[1] === undefined ? start : parseVpsSelfUpdateCronNumber(rangeSplit[1], options.name);
-
-    if (start > end) {
-        throwInvalidVpsSelfUpdateCronField(rangePart, options.name);
-    }
-
-    assertVpsSelfUpdateCronFieldValueInRange(start, options);
-    assertVpsSelfUpdateCronFieldValueInRange(end, options);
-
-    return { start, end };
-}
-
-/**
- * Parses one positive cron integer token.
- *
- * @param value - Raw token.
- * @param fieldName - Field name used in validation errors.
- * @returns Parsed integer.
- */
-function parseVpsSelfUpdateCronNumber(value: string, fieldName: string): number {
-    if (!/^\d+$/u.test(value)) {
-        throwInvalidVpsSelfUpdateCronField(value, fieldName);
-    }
-
-    return Number.parseInt(value, 10);
-}
-
-/**
- * Asserts that one parsed cron value is inside the field bounds.
- *
- * @param value - Parsed value.
- * @param options - Numeric bounds and label.
- */
-function assertVpsSelfUpdateCronFieldValueInRange(value: number, options: VpsSelfUpdateCronFieldOptions): void {
-    if (value < options.minimum || value > options.maximum) {
-        throwInvalidVpsSelfUpdateCronField(String(value), options.name);
-    }
-}
-
-/**
- * Normalizes Sunday from `7` to `0` in the day-of-week field.
- *
- * @param value - Parsed field value.
- * @param options - Numeric bounds and label.
- * @returns Normalized value.
- */
-function normalizeVpsSelfUpdateCronFieldValue(value: number, options: VpsSelfUpdateCronFieldOptions): number {
-    if (options.isSevenAllowedForSunday && value === 7) {
-        return 0;
-    }
-
-    return value;
-}
-
-/**
- * Finds the next local server time matching a parsed cron expression.
- *
- * @param cronExpression - Parsed cron expression.
- * @param afterDate - Date after which the next run must happen.
- * @returns Next matching date.
- */
-function resolveNextVpsSelfUpdateCronRunFromParsedExpression(
-    cronExpression: VpsSelfUpdateCronExpression,
-    afterDate: Date,
-): Date {
-    const cursor = new Date(afterDate.getTime());
-    cursor.setSeconds(0, 0);
-    cursor.setMinutes(cursor.getMinutes() + 1);
-
-    for (let index = 0; index < VPS_SELF_UPDATE_CRON_LOOKAHEAD_MINUTES; index++) {
-        if (isVpsSelfUpdateCronDateMatched(cronExpression, cursor)) {
-            return new Date(cursor.getTime());
-        }
-
-        cursor.setMinutes(cursor.getMinutes() + 1);
-    }
-
-    throw new NotAllowed(
-        spaceTrim(`
-            Automatic self-update cron expression cannot be scheduled.
-
-            **Use a cron expression that matches at least one valid date.**
-        `),
-    );
-}
-
-/**
- * Tests whether one date matches a parsed cron expression.
- *
- * @param cronExpression - Parsed cron expression.
- * @param date - Candidate local server date.
- * @returns `true` when the date matches.
- */
-function isVpsSelfUpdateCronDateMatched(cronExpression: VpsSelfUpdateCronExpression, date: Date): boolean {
-    if (!cronExpression.minute.values.has(date.getMinutes())) {
-        return false;
-    }
-
-    if (!cronExpression.hour.values.has(date.getHours())) {
-        return false;
-    }
-
-    if (!cronExpression.month.values.has(date.getMonth() + 1)) {
-        return false;
-    }
-
-    const isDayOfMonthMatched = cronExpression.dayOfMonth.values.has(date.getDate());
-    const isDayOfWeekMatched = cronExpression.dayOfWeek.values.has(date.getDay());
-
-    if (cronExpression.dayOfMonth.isWildcard && cronExpression.dayOfWeek.isWildcard) {
-        return true;
-    }
-
-    if (cronExpression.dayOfMonth.isWildcard) {
-        return isDayOfWeekMatched;
-    }
-
-    if (cronExpression.dayOfWeek.isWildcard) {
-        return isDayOfMonthMatched;
-    }
-
-    return isDayOfMonthMatched || isDayOfWeekMatched;
-}
-
-/**
- * Throws a branded cron validation error for one field.
- *
- * @param value - Invalid field value.
- * @param fieldName - Field name used in the error message.
- */
-function throwInvalidVpsSelfUpdateCronField(value: string, fieldName: string): never {
-    throw new NotAllowed(
-        spaceTrim(`
-            Automatic self-update cron field \`${fieldName}\` contains invalid value \`${value}\`.
-
-            **Use numbers, \`*\`, comma lists, ranges, and step values only.**
-        `),
-    );
 }

package/apps/agents-server/tests/e2e/mockSupabaseServer.cjs

@@ -21,6 +21,36 @@ const REST_PREFIX = '/rest/v1/';
  */
 const OBJECT_ACCEPT_HEADER = 'application/vnd.pgrst.object+json';
 
+/**
+ * Matches PostgREST LIKE patterns, including escaped literals and the `*` alias for `%`.
+ *
+ * @param {unknown} value
+ * @param {string} pattern
+ * @param {boolean} ignoreCase
+ * @returns {boolean}
+ */
+function matchesLikePattern(value, pattern, ignoreCase) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+
+    let expression = '';
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern[index];
+        if (character === '\\' && index + 1 < pattern.length) {
+            expression += pattern[++index].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        } else if (character === '%' || character === '*') {
+            expression += '.*';
+        } else if (character === '_') {
+            expression += '.';
+        } else {
+            expression += character.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+
+    return new RegExp(`^${expression}$`, ignoreCase ? 'is' : 's').test(String(value));
+}
+
 /**
  * In-memory table store used by the mocked Supabase API.
  */
@@ -92,6 +122,20 @@ function getTableRows(tableName) {
     return tables.get(tableName);
 }
 
+/**
+ * Decodes explicitly escaped filter values while preserving literal percent wildcards from URLSearchParams.
+ *
+ * @param {string} rawValue
+ * @returns {string}
+ */
+function decodeFilterValue(rawValue) {
+    try {
+        return decodeURIComponent(rawValue);
+    } catch {
+        return rawValue;
+    }
+}
+
 /**
  * Parses a PostgREST token into a primitive JavaScript value.
  *
@@ -99,7 +143,7 @@ function getTableRows(tableName) {
  * @returns {string | number | boolean | null}
  */
 function parseTokenValue(rawValue) {
-    const decoded = decodeURIComponent(rawValue);
+    const decoded = decodeFilterValue(rawValue);
 
     if (decoded === 'null') {
         return null;
@@ -236,6 +280,15 @@ function matchesRowFilters(row, searchParams) {
             continue;
         }
 
+        if (rawClause.startsWith('like.') || rawClause.startsWith('ilike.')) {
+            const ignoreCase = rawClause.startsWith('ilike.');
+            const pattern = decodeFilterValue(rawClause.slice(ignoreCase ? 'ilike.'.length : 'like.'.length));
+            if (!matchesLikePattern(row[columnName], pattern, ignoreCase)) {
+                return false;
+            }
+            continue;
+        }
+
         if (rawClause.startsWith('is.')) {
             const expectedValue = parseTokenValue(rawClause.slice('is.'.length));
             if (expectedValue === null) {
@@ -378,6 +431,26 @@ async function handleRestRequest(request, response, requestUrl) {
     if (method === 'POST') {
         const body = await parseJsonBody(request);
         const payloadRows = Array.isArray(body) ? body : body ? [body] : [];
+        if (tableName === 'User' || tableName.endsWith('_User')) {
+            // Match the database constraint so concurrent identity creation can retry the existing user.
+            // Validate the whole batch before inserting any rows, as PostgreSQL does for one statement.
+            const usernames = new Set(tableRows.map((row) => row.username));
+            for (const payloadRow of payloadRows) {
+                if (payloadRow.username === undefined || payloadRow.username === null) {
+                    continue;
+                }
+                if (usernames.has(payloadRow.username)) {
+                    sendJson(response, 409, {
+                        code: '23505',
+                        details: `Key (username)=(${payloadRow.username}) already exists.`,
+                        hint: null,
+                        message: `duplicate key value violates unique constraint "${tableName}_username_idx"`,
+                    });
+                    return;
+                }
+                usernames.add(payloadRow.username);
+            }
+        }
         const insertedRows = payloadRows.map((payloadRow) => {
             const nextRow = { ...payloadRow };
 
@@ -506,4 +579,8 @@ function main() {
     process.on('SIGTERM', shutdown);
 }
 
-main();
+module.exports = { createMockSupabaseServer };
+
+if (require.main === module) {
+    main();
+}

package/apps/agents-server/tests/e2e/support/AgentManagementApi.ts

@@ -12,11 +12,11 @@ type CreateTestAgentOptions = {
      */
     readonly label: string;
     /**
-     * Persona sentence inserted into the agent source.
+     * Goal sentence inserted into the agent source.
      *
      * @private internal utility of AgentManagementApi
      */
-    readonly persona: string;
+    readonly goal: string;
     /**
      * Optional rule sentence inserted into the agent source.
      *
@@ -82,7 +82,7 @@ const DEFAULT_RULE = 'Keep replies concise.';
 function buildTestAgentSource(options: CreateTestAgentOptions): string {
     return spaceTrim(`
         ${options.label}
-        PERSONA ${options.persona}
+        GOAL ${options.goal}
         RULE ${options.rule ?? DEFAULT_RULE}
         ${options.initialMessage ? `INITIAL MESSAGE ${options.initialMessage}` : ''}
     `);

package/apps/agents-server/tests/e2e/support/ChatHistoryNavigationSupport.ts

@@ -46,6 +46,10 @@ type DelayNextMatchingRequestOptions = {
      * @private internal utility of ChatHistoryNavigationSupport
      */
     readonly isMatchingUrl: (url: string) => boolean;
+    /**
+     * Buffers the response before pausing, so navigation can cancel the browser request without blocking release.
+     */
+    readonly delayResponse?: boolean;
 };
 
 /**
@@ -236,6 +240,7 @@ async function delayNextMatchingRequest(
         }
 
         hasInterceptedTargetRequest = true;
+        const bufferedResponse = options.delayResponse ? await route.fetch() : undefined;
         markStarted?.();
 
         await new Promise<void>((resolve) => {
@@ -246,8 +251,12 @@ async function delayNextMatchingRequest(
         });
 
         try {
-            await route.continue();
-            await request.response().catch(() => null);
+            if (bufferedResponse) {
+                await route.fulfill({ response: bufferedResponse });
+            } else {
+                await route.continue();
+                await request.response().catch(() => null);
+            }
         } finally {
             markFinished?.();
         }
@@ -294,6 +303,7 @@ async function delayNextUserChatSnapshotRequest(page: Page, agentName: string, c
     return delayNextMatchingRequest(page, {
         method: 'GET',
         isMatchingUrl: (url) => isMatchingUserChatSnapshotRequest(url, agentName, chatId),
+        delayResponse: true,
     });
 }
 

package/apps/agents-server/tests/e2e/support/auth.ts

@@ -62,6 +62,12 @@ export async function loginAsAdmin(page: Page): Promise<void> {
     await page.getByLabel('Password').press('Enter');
     await expect(page.getByLabel('Username')).toBeHidden();
 
+    // Authentication is setup for these tests. Wait for the session and load it without racing the client refresh.
+    await expect
+        .poll(async () => (await page.context().cookies()).some((cookie) => cookie.name === 'sessionToken'))
+        .toBe(true);
+    await page.reload();
+
     const desktopAdminButton = page.getByRole('button', { name: /admin/i });
     if (await desktopAdminButton.isVisible().catch(() => false)) {
         return;

package/esm/apps/agents-server/src/constants/federatedAgentImport.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Metadata key storing the comma-separated federated server URL list.
+ *
+ * @private shared Agents Server constant
+ */
+export declare const FEDERATED_SERVERS_METADATA_KEY: "FEDERATED_SERVERS";
 /**
  * Metadata key storing the delay between retry attempts when importing federated agent books.
  *