@pasko70/pibo 1.9.9 → 1.9.10

package/dist/apps/chat/chat-settings-routes.js

@@ -0,0 +1,98 @@
+import { readPiboBasePrompt, savePiboCustomBasePrompt, setPiboBasePromptMode } from "../../core/base-prompt.js";
+import { readPiboCompactionPrompt, savePiboCustomCompactionPrompt, setPiboCompactionPromptMode } from "../../core/compaction-prompt.js";
+import { sanitizeTelemetryRetentionDays, sanitizeTelemetryRetentionSettings } from "../../core/telemetry-retention-settings.js";
+import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, updatePiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
+import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
+import { CHAT_WEB_API_PREFIX } from "./chat-api-routes.js";
+import { normalizeBasePromptMarkdown, normalizeBasePromptMode, normalizeCompactionPromptMarkdown, normalizeCompactionPromptMode, updateChatModelDefaults, } from "./chat-request-normalizers.js";
+import { pruneTelemetryOlderThan } from "./telemetry-retention-service.js";
+export function chatSettingsRoute(pathname, method) {
+    if (pathname === `${CHAT_WEB_API_PREFIX}/model-defaults` && method === "PATCH")
+        return { kind: "model-defaults" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/user-settings` && method === "GET")
+        return { kind: "user-settings", action: "read" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/user-settings` && method === "PATCH")
+        return { kind: "user-settings", action: "update" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/telemetry-retention/prune` && method === "POST")
+        return { kind: "telemetry-retention", action: "prune" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt` && method === "GET")
+        return { kind: "base-prompt", action: "read" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt` && method === "PATCH")
+        return { kind: "base-prompt", action: "set-mode" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/base-prompt/custom` && method === "PUT")
+        return { kind: "base-prompt", action: "save-custom" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/compaction-prompt` && method === "GET")
+        return { kind: "compaction-prompt", action: "read" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/compaction-prompt` && method === "PATCH")
+        return { kind: "compaction-prompt", action: "set-mode" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/compaction-prompt/custom` && method === "PUT")
+        return { kind: "compaction-prompt", action: "save-custom" };
+    return undefined;
+}
+export function chatSettingsRouteRequiresSameOrigin(route) {
+    return route.kind === "model-defaults" || route.action !== "read";
+}
+export function chatSettingsRouteInvalidatesBootstrapCatalog(route) {
+    return route.kind === "model-defaults";
+}
+export async function handleChatSettingsRoute(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const { route, request } = input;
+    if (route.kind === "model-defaults") {
+        const body = await readJsonBody(request);
+        return responseJson({ modelDefaults: updateChatModelDefaults(body, cwd) });
+    }
+    if (route.kind === "user-settings") {
+        if (route.action === "read")
+            return responseJson({ userSettings: loadPiboUserSettings() });
+        const body = await readJsonBody(request);
+        return responseJson({ userSettings: updatePiboUserSettings(userSettingsPatch(body)) });
+    }
+    if (route.kind === "telemetry-retention") {
+        if (!input.dataStore)
+            throw new PiboWebHttpError("Telemetry retention store unavailable", 503);
+        const body = await readJsonBody(request);
+        const days = sanitizeTelemetryRetentionDays(body.days);
+        if (!days)
+            throw new PiboWebHttpError("Invalid telemetry retention days", 400);
+        const result = pruneTelemetryOlderThan({ dataStore: input.dataStore, days, apply: body.dryRun !== true });
+        if (result.applied)
+            updateTelemetryRetentionLastPrunedAt(new Date().toISOString());
+        return responseJson({ telemetryRetention: result });
+    }
+    if (route.kind === "base-prompt") {
+        if (route.action === "read")
+            return responseJson({ basePrompt: await readPiboBasePrompt(cwd) });
+        const body = await readJsonBody(request);
+        if (route.action === "set-mode") {
+            return responseJson({ basePrompt: setPiboBasePromptMode(normalizeBasePromptMode(body.mode), cwd) });
+        }
+        return responseJson({ basePrompt: await savePiboCustomBasePrompt(normalizeBasePromptMarkdown(body.markdown), cwd) });
+    }
+    if (route.action === "read")
+        return responseJson({ compactionPrompt: await readPiboCompactionPrompt(cwd) });
+    const body = await readJsonBody(request);
+    if (route.action === "set-mode") {
+        return responseJson({ compactionPrompt: setPiboCompactionPromptMode(normalizeCompactionPromptMode(body.mode), cwd) });
+    }
+    return responseJson({ compactionPrompt: await savePiboCustomCompactionPrompt(normalizeCompactionPromptMarkdown(body.markdown), cwd) });
+}
+function userSettingsPatch(body) {
+    const patch = {};
+    if (body.timezone !== undefined) {
+        const timezone = sanitizeTimezone(body.timezone);
+        if (!timezone)
+            throw new PiboWebHttpError("Invalid timezone", 400);
+        patch.timezone = timezone;
+    }
+    if (body.shortcuts !== undefined)
+        patch.shortcuts = sanitizeShortcutSettings(body.shortcuts);
+    if (body.telemetryRetention !== undefined) {
+        const current = loadPiboUserSettings().telemetryRetention;
+        patch.telemetryRetention = {
+            ...sanitizeTelemetryRetentionSettings(body.telemetryRetention),
+            ...(current.lastPrunedAt ? { lastPrunedAt: current.lastPrunedAt } : {}),
+        };
+    }
+    return patch;
+}

package/dist/apps/chat/chat-trace-helpers.js

@@ -0,0 +1,139 @@
+import { createHash } from "node:crypto";
+import { patchTraceViewWithEvent } from "../../shared/trace-engine.js";
+export const DEFAULT_TRACE_EVENTS_PAGE_SIZE = 50;
+export const MAX_TRACE_EVENTS_PER_REQUEST = 1000;
+export const TRACE_CACHE_MAX_BYTES = 8 * 1024 * 1024;
+export function etagForVersion(version) {
+    return `"${version}"`;
+}
+export function requestMatchesVersion(request, version) {
+    const header = request.headers.get("if-none-match");
+    if (!header)
+        return false;
+    return header
+        .split(",")
+        .map((value) => value.trim())
+        .some((value) => value === "*" || value === etagForVersion(version) || value === `W/${etagForVersion(version)}`);
+}
+export function traceCacheKey(piboSessionId, version) {
+    return [piboSessionId, version, "structural"].join(":");
+}
+export function withRawTraceTail(trace, rawEvents) {
+    if (rawEvents.length === 0)
+        return trace;
+    return { ...trace, rawEvents };
+}
+export function liveSnapshotVersion(snapshots) {
+    if (snapshots.length === 0)
+        return "";
+    const hash = createHash("sha1");
+    for (const snapshot of snapshots) {
+        hash.update(JSON.stringify(snapshot));
+        hash.update("\n");
+    }
+    return hash.digest("hex").slice(0, 16);
+}
+export function storedLiveSnapshotEvents(input) {
+    const createdAt = input.now ?? new Date().toISOString();
+    return input.snapshots.map((snapshot, index) => ({
+        id: `live-snapshot:${input.piboSessionId}:${index}:${liveSnapshotVersion([snapshot])}`,
+        piboSessionId: input.piboSessionId,
+        eventSequence: input.lastEventSequence + index + 1,
+        eventId: "eventId" in snapshot && typeof snapshot.eventId === "string" ? snapshot.eventId : undefined,
+        type: snapshot.type,
+        createdAt,
+        payload: snapshot,
+    }));
+}
+export function withLiveSnapshots(trace, snapshots, input) {
+    if (snapshots.length === 0)
+        return trace;
+    const events = storedLiveSnapshotEvents({
+        piboSessionId: input.piboSessionId,
+        snapshots,
+        lastEventSequence: input.lastEventSequence,
+    });
+    let next = trace;
+    for (const event of events) {
+        next = patchTraceViewWithEvent(next, event, input.status ?? "running");
+    }
+    return {
+        ...next,
+        version: `${trace.version}:live:${liveSnapshotVersion(snapshots)}`,
+        rawEvents: trace.rawEvents,
+    };
+}
+export function annotateTracePage(trace, events, input) {
+    const sequences = events
+        .map((event) => event.eventSequence)
+        .filter((sequence) => typeof sequence === "number");
+    const firstEventSequence = sequences.length ? Math.min(...sequences) : undefined;
+    const lastEventSequence = sequences.length ? Math.max(...sequences) : undefined;
+    return {
+        ...trace,
+        eventCount: input.lastEventSequence,
+        eventLimit: input.pageSize,
+        pageSize: input.pageSize,
+        beforeSequence: input.beforeSequence,
+        beforeCursor: input.beforeCursor,
+        firstEventSequence,
+        lastEventSequence,
+        nextBeforeSequence: firstEventSequence,
+        nextBeforeCursor: input.nextBeforeCursor ?? (firstEventSequence !== undefined ? String(firstEventSequence) : undefined),
+        hasOlderEvents: input.hasOlderEvents ?? (firstEventSequence !== undefined ? firstEventSequence > 1 : false),
+    };
+}
+export function setTraceCache(cache, key, trace, maxEntries, maxBytes = TRACE_CACHE_MAX_BYTES) {
+    if (trace.rawEvents.length > 0)
+        return;
+    cache.delete(key);
+    cache.set(key, trace);
+    while (cache.size > maxEntries || traceCacheEstimatedBytes(cache) > maxBytes) {
+        const oldestKey = cache.keys().next().value;
+        if (typeof oldestKey !== "string")
+            break;
+        cache.delete(oldestKey);
+    }
+}
+export function traceCacheEstimatedBytes(cache) {
+    let bytes = 0;
+    for (const trace of cache.values())
+        bytes += estimateTraceViewBytes(trace);
+    return bytes;
+}
+export function estimateTraceViewBytes(trace) {
+    let bytes = 512;
+    bytes += byteLength(trace.piboSessionId) + byteLength(trace.piSessionId) + byteLength(trace.title) + byteLength(trace.version);
+    for (const node of flattenEstimateNodes(trace.nodes)) {
+        bytes += 256;
+        bytes += byteLength(node.id) + byteLength(node.parentId) + byteLength(node.title) + byteLength(node.summary);
+        bytes += estimatePayloadBytes(node.input) + estimatePayloadBytes(node.output) + byteLength(node.error);
+    }
+    return bytes;
+}
+function flattenEstimateNodes(nodes) {
+    const result = [];
+    const visit = (items) => {
+        for (const item of items) {
+            result.push(item);
+            visit(item.children);
+        }
+    };
+    visit(nodes);
+    return result;
+}
+function estimatePayloadBytes(value) {
+    if (value === undefined || value === null)
+        return 0;
+    if (typeof value === "string")
+        return byteLength(value);
+    try {
+        return byteLength(JSON.stringify(value));
+    }
+    catch {
+        return byteLength(String(value));
+    }
+}
+function byteLength(value) {
+    return value ? Buffer.byteLength(value, "utf8") : 0;
+}

package/dist/apps/chat/chat-user-skill-routes.js

@@ -0,0 +1,178 @@
+import { normalizeUserSkillScope, normalizeWritableUserSkillScope } from "../../user-skills/manager.js";
+import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
+import { CHAT_WEB_API_PREFIX, userSkillResourceId } from "./chat-api-routes.js";
+import { normalizeUserSkillDescription, normalizeUserSkillEnabled, normalizeUserSkillMarkdown, normalizeUserSkillName, normalizeUserSkillUrl, } from "./chat-request-normalizers.js";
+export function chatUserSkillRoute(pathname, method) {
+    if (pathname === `${CHAT_WEB_API_PREFIX}/user-skills` && method === "GET")
+        return { kind: "user-skills-list" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/user-skills` && method === "POST")
+        return { kind: "user-skills-create" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/user-skills/install` && method === "POST")
+        return { kind: "user-skills-install" };
+    const skillId = userSkillResourceId(pathname);
+    if (skillId && method === "GET")
+        return { kind: "user-skill-read", skillId };
+    if (skillId && method === "PATCH")
+        return { kind: "user-skill-update", skillId };
+    if (skillId && method === "DELETE")
+        return { kind: "user-skill-delete", skillId };
+    return undefined;
+}
+export function chatUserSkillRouteRequiresSameOrigin(route) {
+    return route.kind !== "user-skills-list" && route.kind !== "user-skill-read";
+}
+export function syncChatUserSkills(options) {
+    const { userSkillManager, channelContext, previouslySyncedNames, setSyncedUserSkillNames } = options;
+    const registerSkill = channelContext.registerSkill;
+    const unregisterSkill = channelContext.unregisterSkill;
+    if (!registerSkill || !unregisterSkill)
+        return;
+    const userSkills = userSkillManager.list("all");
+    const catalogSkills = channelContext.getCapabilityCatalog?.().skills ?? [];
+    const catalogSkillByName = new Map(catalogSkills.map((skill) => [skill.name, skill]));
+    const reservedSkillNames = new Set(catalogSkills.filter((skill) => skill.kind !== "user").map((skill) => skill.name));
+    const enabledSkillByName = new Map();
+    for (const skill of userSkills) {
+        if (!skill.enabled || reservedSkillNames.has(skill.name))
+            continue;
+        const existing = enabledSkillByName.get(skill.name);
+        if (!existing || skill.scope === "workspace")
+            enabledSkillByName.set(skill.name, skill);
+    }
+    const enabledNames = new Set(enabledSkillByName.keys());
+    const syncedNames = new Set([
+        ...catalogSkills.filter((skill) => skill.kind === "user").map((skill) => skill.name),
+        ...(previouslySyncedNames ?? []),
+    ]);
+    // Unregister disabled, removed, or now built-in user skills. Avoid removing a
+    // built-in/plugin skill if a promoted user skill has the same name.
+    for (const name of syncedNames) {
+        if (!enabledNames.has(name)) {
+            const catalogSkill = catalogSkillByName.get(name);
+            if (!catalogSkill || catalogSkill.kind === "user")
+                unregisterSkill(name);
+        }
+    }
+    // Register the winning enabled skill per name. Workspace-local skills take
+    // precedence over global user skills with the same name; if the winning path
+    // changes, re-register the user skill so runtime context loads the right body.
+    for (const skill of enabledSkillByName.values()) {
+        const catalogSkill = catalogSkillByName.get(skill.name);
+        if (catalogSkill?.kind === "user" && catalogSkill.path !== skill.path) {
+            unregisterSkill(skill.name);
+            registerSkill({ name: skill.name, path: skill.path, enabled: true, kind: "user" });
+        }
+        else if (!catalogSkill) {
+            registerSkill({ name: skill.name, path: skill.path, enabled: true, kind: "user" });
+        }
+    }
+    setSyncedUserSkillNames(enabledNames);
+}
+function assertUserSkillNameIsAvailable(options) {
+    const { channelContext, name } = options;
+    const conflict = (channelContext.getCapabilityCatalog?.().skills ?? []).find((skill) => (skill.name === name && skill.kind !== "user"));
+    if (conflict) {
+        throw new PiboWebHttpError(`Skill name "${name}" conflicts with an existing registered skill`, 409);
+    }
+}
+function syncAndInvalidate(options) {
+    syncChatUserSkills({
+        userSkillManager: options.userSkillManager,
+        channelContext: options.channelContext,
+        previouslySyncedNames: options.previouslySyncedNames,
+        setSyncedUserSkillNames: options.setSyncedUserSkillNames,
+    });
+    options.invalidateBootstrapCatalogCache();
+}
+function requestScope(request, fallback = "all") {
+    return normalizeUserSkillScope(new URL(request.url).searchParams.get("scope") ?? undefined, fallback);
+}
+function bodyScope(body, fallback = "global") {
+    if (body.scope !== undefined && typeof body.scope !== "string") {
+        throw new PiboWebHttpError("Skill scope must be a string", 400);
+    }
+    try {
+        return normalizeWritableUserSkillScope(body.scope, fallback);
+    }
+    catch (error) {
+        throw new PiboWebHttpError(error instanceof Error ? error.message : String(error), 400);
+    }
+}
+export async function handleChatUserSkillRoute(options) {
+    const { route, request, userSkillManager, channelContext } = options;
+    switch (route.kind) {
+        case "user-skills-list":
+            return responseJson({ skills: userSkillManager.list(requestScope(request)) });
+        case "user-skills-create": {
+            const body = await readJsonBody(request);
+            const scope = bodyScope(body);
+            const name = normalizeUserSkillName(body.name);
+            assertUserSkillNameIsAvailable({ channelContext, name });
+            const skill = userSkillManager.create({
+                name,
+                description: normalizeUserSkillDescription(body.description ?? ""),
+                markdown: normalizeUserSkillMarkdown(body.markdown ?? ""),
+            }, scope);
+            syncAndInvalidate(options);
+            return responseJson({ skill }, { status: 201 });
+        }
+        case "user-skills-install": {
+            const body = await readJsonBody(request);
+            const scope = bodyScope(body);
+            const skill = await userSkillManager.installFromUrl(normalizeUserSkillUrl(body.url), scope);
+            try {
+                assertUserSkillNameIsAvailable({ channelContext, name: skill.name });
+            }
+            catch (error) {
+                userSkillManager.remove(skill.id, scope);
+                throw error;
+            }
+            syncAndInvalidate(options);
+            return responseJson({ skill }, { status: 201 });
+        }
+        case "user-skill-read": {
+            const scope = requestScope(request);
+            const skill = userSkillManager.get(route.skillId, scope);
+            if (!skill)
+                throw new PiboWebHttpError("Skill not found", 404);
+            const markdown = userSkillManager.getSkillMarkdown(skill.id, scope);
+            return responseJson({ skill, markdown });
+        }
+        case "user-skill-update": {
+            const scope = requestScope(request);
+            const existing = userSkillManager.get(route.skillId, scope);
+            if (!existing)
+                throw new PiboWebHttpError("Skill not found", 404);
+            const body = await readJsonBody(request);
+            const input = {};
+            if (body.name !== undefined)
+                input.name = normalizeUserSkillName(body.name);
+            if (body.description !== undefined)
+                input.description = normalizeUserSkillDescription(body.description);
+            if (body.markdown !== undefined)
+                input.markdown = normalizeUserSkillMarkdown(body.markdown);
+            if (body.enabled !== undefined)
+                input.enabled = normalizeUserSkillEnabled(body.enabled);
+            if (Object.keys(input).length === 0) {
+                throw new PiboWebHttpError("No skill update fields provided", 400);
+            }
+            const nextName = input.name ?? existing.name;
+            const nextEnabled = input.enabled ?? existing.enabled;
+            if (nextEnabled) {
+                assertUserSkillNameIsAvailable({ channelContext, name: nextName });
+            }
+            const skill = userSkillManager.update(existing.id, input, scope);
+            syncAndInvalidate(options);
+            return responseJson({ skill });
+        }
+        case "user-skill-delete": {
+            const scope = requestScope(request);
+            const existing = userSkillManager.get(route.skillId, scope);
+            if (!existing)
+                throw new PiboWebHttpError("Skill not found", 404);
+            userSkillManager.remove(existing.id, scope);
+            syncAndInvalidate(options);
+            return responseJson({ removedSkillId: existing.id });
+        }
+    }
+}

package/dist/apps/chat/cron-api.js

@@ -0,0 +1,213 @@
+import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
+import { getPiboCronService } from "../../cron/channel.js";
+import { parseFriendlySchedule } from "../../cron/schedule.js";
+import { isPiboRoomArchived } from "./types/rooms.js";
+const CHAT_WEB_API_PREFIX = "/api/chat";
+function requireSameOriginJsonRequest(request) {
+    const contentType = request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+    if (contentType !== "application/json")
+        throw new PiboWebHttpError("Content-Type must be application/json", 415);
+    const origin = request.headers.get("origin");
+    if (!origin)
+        throw new PiboWebHttpError("Origin header is required", 403);
+    if (origin !== new URL(request.url).origin)
+        throw new PiboWebHttpError("Origin is not allowed", 403);
+}
+function accessDenied(error) {
+    throw new PiboWebHttpError(error instanceof Error ? error.message : "Access denied", 403);
+}
+function normalizeString(value, field, options = {}) {
+    if (value === undefined || value === null) {
+        if (options.required)
+            throw new PiboWebHttpError(`${field} is required`, 400);
+        return undefined;
+    }
+    if (typeof value !== "string")
+        throw new PiboWebHttpError(`${field} must be a string`, 400);
+    const normalized = value.trim();
+    if (!normalized && options.required)
+        throw new PiboWebHttpError(`${field} is required`, 400);
+    if (options.max && normalized.length > options.max)
+        throw new PiboWebHttpError(`${field} is too long`, 400);
+    return normalized || undefined;
+}
+function normalizeEnabled(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new PiboWebHttpError("enabled must be a boolean", 400);
+    return value;
+}
+function normalizeTarget(value, options) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new PiboWebHttpError("target is required", 400);
+    const raw = value;
+    if (raw.kind === "room") {
+        const roomId = normalizeString(raw.roomId, "target.roomId", { required: true });
+        let room;
+        try {
+            room = options.roomService.requireRoom(roomId);
+        }
+        catch (error) {
+            accessDenied(error);
+        }
+        if (isPiboRoomArchived(room))
+            throw new PiboWebHttpError("Archived rooms are read-only", 403);
+        return { kind: "room", roomId };
+    }
+    if (raw.kind === "default-chat") {
+        options.roomService.ensureDefaultRoom({ name: "Shared Chat" });
+        return { kind: "default-chat" };
+    }
+    throw new PiboWebHttpError("target.kind must be room or default-chat", 400);
+}
+function normalizeSchedule(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new PiboWebHttpError("schedule is required", 400);
+    const raw = value;
+    try {
+        if (raw.kind === "at" && typeof raw.at === "string")
+            return { schedule: { kind: "at", at: raw.at } };
+        if (raw.kind === "at" && typeof raw.value === "string")
+            return parseFriendlySchedule({ kind: "at", value: raw.value, tz: typeof raw.tz === "string" ? raw.tz : undefined });
+        if (raw.kind === "every" && typeof raw.everyMs === "number")
+            return { schedule: { kind: "every", everyMs: raw.everyMs, anchorMs: typeof raw.anchorMs === "number" ? raw.anchorMs : Date.now() } };
+        if (raw.kind === "every" && typeof raw.value === "string")
+            return parseFriendlySchedule({ kind: "every", value: raw.value });
+        if (raw.kind === "cron" && typeof raw.expr === "string")
+            return { schedule: { kind: "cron", expr: raw.expr, tz: typeof raw.tz === "string" ? raw.tz : undefined } };
+        if (raw.kind === "in" && typeof raw.value === "string")
+            return parseFriendlySchedule({ kind: "in", value: raw.value });
+        if (raw.kind === "daily" && typeof raw.time === "string")
+            return parseFriendlySchedule({ kind: "daily", time: raw.time, tz: typeof raw.tz === "string" ? raw.tz : undefined });
+        if (raw.kind === "weekly" && typeof raw.time === "string" && (typeof raw.weekdays === "string" || Array.isArray(raw.weekdays)))
+            return parseFriendlySchedule({ kind: "weekly", time: raw.time, weekdays: raw.weekdays, tz: typeof raw.tz === "string" ? raw.tz : undefined });
+        if (raw.kind === "monthly" && typeof raw.time === "string" && typeof raw.dayOfMonth === "number")
+            return parseFriendlySchedule({ kind: "monthly", time: raw.time, dayOfMonth: raw.dayOfMonth, tz: typeof raw.tz === "string" ? raw.tz : undefined });
+    }
+    catch (error) {
+        throw new PiboWebHttpError(error instanceof Error ? error.message : String(error), 400);
+    }
+    throw new PiboWebHttpError("Unsupported schedule", 400);
+}
+function resolveProfile(context, fallback, value) {
+    const requested = normalizeString(value, "profile") ?? fallback;
+    const profile = context.channelContext.getProfiles?.().find((item) => item.name === requested || item.aliases.includes(requested));
+    if (!profile)
+        throw new PiboWebHttpError(`Unknown profile: ${requested}`, 400);
+    return profile.name;
+}
+function jobResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/cron/jobs/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+    if (!parts[0] || parts.length > 2)
+        return undefined;
+    if (parts[1] && parts[1] !== "run")
+        return undefined;
+    return { id: parts[0], child: parts[1] };
+}
+function serializeJob(job) {
+    return job;
+}
+function serializeRun(run) {
+    return run;
+}
+function createPatch(body, options) {
+    const patch = {};
+    const name = normalizeString(body.name, "name", { max: 120 });
+    if (body.name !== undefined && name !== undefined)
+        patch.name = name;
+    if (body.description !== undefined)
+        patch.description = normalizeString(body.description, "description", { max: 500 });
+    const enabled = normalizeEnabled(body.enabled);
+    if (enabled !== undefined)
+        patch.enabled = enabled;
+    if (body.target !== undefined)
+        patch.target = normalizeTarget(body.target, options);
+    if (body.profile !== undefined)
+        patch.profile = resolveProfile(options.context, options.defaultProfile, body.profile);
+    if (body.prompt !== undefined)
+        patch.prompt = normalizeString(body.prompt, "prompt", { required: true, max: 20_000 });
+    if (body.schedule !== undefined) {
+        const normalized = normalizeSchedule(body.schedule);
+        patch.schedule = normalized.schedule;
+        patch.scheduleUi = normalized.scheduleUi;
+    }
+    if (body.deleteAfterRun !== undefined) {
+        if (typeof body.deleteAfterRun !== "boolean")
+            throw new PiboWebHttpError("deleteAfterRun must be a boolean", 400);
+        patch.deleteAfterRun = body.deleteAfterRun;
+    }
+    if (Object.keys(patch).length === 0)
+        throw new PiboWebHttpError("No cron job update fields provided", 400);
+    return patch;
+}
+export async function handleChatCronApiRequest(options) {
+    const { request, cronStore } = options;
+    const url = new URL(request.url);
+    if (!url.pathname.startsWith(`${CHAT_WEB_API_PREFIX}/cron`))
+        return undefined;
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/cron/status` && request.method === "GET") {
+        return responseJson({ status: getPiboCronService()?.status() ?? { enabled: false, ...cronStore.status() } });
+    }
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/cron/jobs` && request.method === "GET") {
+        return responseJson({ jobs: cronStore.listJobs({ includeDisabled: url.searchParams.get("includeDisabled") === "true" }).map(serializeJob) });
+    }
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/cron/jobs` && request.method === "POST") {
+        requireSameOriginJsonRequest(request);
+        const body = await readJsonBody(request);
+        const normalized = normalizeSchedule(body.schedule);
+        const job = cronStore.createJob({
+            name: normalizeString(body.name, "name", { max: 120 }),
+            description: normalizeString(body.description, "description", { max: 500 }),
+            enabled: normalizeEnabled(body.enabled),
+            target: normalizeTarget(body.target, options),
+            profile: resolveProfile(options.context, options.defaultProfile, body.profile),
+            prompt: normalizeString(body.prompt, "prompt", { required: true, max: 20_000 }),
+            schedule: normalized.schedule,
+            scheduleUi: normalized.scheduleUi,
+            deleteAfterRun: body.deleteAfterRun === true,
+        });
+        return responseJson({ job: serializeJob(job) }, { status: 201 });
+    }
+    if (url.pathname === `${CHAT_WEB_API_PREFIX}/cron/runs` && request.method === "GET") {
+        const jobId = url.searchParams.get("jobId") || undefined;
+        const limit = Number(url.searchParams.get("limit") ?? "100");
+        if (jobId && !cronStore.getJob(jobId))
+            throw new PiboWebHttpError("Cron job not found", 404);
+        return responseJson({ runs: cronStore.listRuns({ jobId, limit: Number.isFinite(limit) ? limit : 100 }).map(serializeRun) });
+    }
+    const resource = jobResource(url.pathname);
+    if (!resource)
+        return undefined;
+    if (resource.child === "run" && request.method === "POST") {
+        requireSameOriginJsonRequest(request);
+        const service = getPiboCronService();
+        if (!service)
+            throw new PiboWebHttpError("Cron service is not running", 503);
+        return responseJson({ run: serializeRun(await service.runJobNow(resource.id)) }, { status: 202 });
+    }
+    if (resource.child)
+        return undefined;
+    if (request.method === "GET") {
+        const job = cronStore.getJob(resource.id);
+        if (!job)
+            throw new PiboWebHttpError("Cron job not found", 404);
+        return responseJson({ job: serializeJob(job) });
+    }
+    if (request.method === "PATCH") {
+        requireSameOriginJsonRequest(request);
+        const body = await readJsonBody(request);
+        const job = cronStore.updateJob(resource.id, createPatch(body, options));
+        if (!job)
+            throw new PiboWebHttpError("Cron job not found", 404);
+        return responseJson({ job: serializeJob(job) });
+    }
+    if (request.method === "DELETE") {
+        requireSameOriginJsonRequest(request);
+        return responseJson({ removed: cronStore.removeJob(resource.id) });
+    }
+    return undefined;
+}