@pasko70/pibo 1.1.0 → 1.2.0

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

@@ -0,0 +1,75 @@
+import { readPiboBasePrompt, savePiboCustomBasePrompt, setPiboBasePromptMode } from "../../core/base-prompt.js";
+import { readPiboCompactionPrompt, savePiboCustomCompactionPrompt, setPiboCompactionPromptMode } from "../../core/compaction-prompt.js";
+import { loadPiboUserSettings, sanitizeShortcutSettings, sanitizeTimezone, updatePiboUserSettings } 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";
+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}/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 === "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);
+    return patch;
+}

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

@@ -0,0 +1,94 @@
+import { createHash } from "node:crypto";
+import { patchTraceViewWithEvent } from "../../shared/trace-engine.js";
+export const DEFAULT_TRACE_EVENTS_PAGE_SIZE = 2_000;
+export const MAX_TRACE_EVENTS_PER_REQUEST = 50_000;
+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,
+        firstEventSequence,
+        lastEventSequence,
+        nextBeforeSequence: firstEventSequence,
+        hasOlderEvents: firstEventSequence !== undefined ? firstEventSequence > 1 : false,
+    };
+}
+export function setTraceCache(cache, key, trace, maxEntries) {
+    if (trace.rawEvents.length > 0)
+        return;
+    cache.delete(key);
+    cache.set(key, trace);
+    while (cache.size > maxEntries) {
+        const oldestKey = cache.keys().next().value;
+        if (typeof oldestKey !== "string")
+            break;
+        cache.delete(oldestKey);
+    }
+}

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

@@ -0,0 +1,149 @@
+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();
+    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 enabledNames = new Set(userSkills
+        .filter((skill) => skill.enabled && !reservedSkillNames.has(skill.name))
+        .map((skill) => skill.name));
+    const syncedNames = previouslySyncedNames ?? new Set();
+    // 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 only newly enabled user skills. Re-registering an already synced
+    // skill would trip the registry duplicate-skill guard and break the web UI.
+    for (const skill of userSkills) {
+        if (skill.enabled && !reservedSkillNames.has(skill.name) && !syncedNames.has(skill.name)) {
+            registerSkill({ name: skill.name, path: skill.path, enabled: true, kind: "user" });
+        }
+    }
+    setSyncedUserSkillNames(enabledNames);
+}
+function assertUserSkillNameIsAvailable(options) {
+    const { userSkillManager, channelContext, name, currentSkillId } = options;
+    const currentSkill = currentSkillId ? userSkillManager.get(currentSkillId) : undefined;
+    const conflict = (channelContext.getCapabilityCatalog?.().skills ?? []).find((skill) => (skill.name === name && (!currentSkill || currentSkill.name !== name)));
+    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();
+}
+export async function handleChatUserSkillRoute(options) {
+    const { route, request, userSkillManager, channelContext } = options;
+    switch (route.kind) {
+        case "user-skills-list":
+            return responseJson({ skills: userSkillManager.list() });
+        case "user-skills-create": {
+            const body = await readJsonBody(request);
+            const name = normalizeUserSkillName(body.name);
+            assertUserSkillNameIsAvailable({ userSkillManager, channelContext, name });
+            const skill = userSkillManager.create({
+                name,
+                description: normalizeUserSkillDescription(body.description ?? ""),
+                markdown: normalizeUserSkillMarkdown(body.markdown ?? ""),
+            });
+            syncAndInvalidate(options);
+            return responseJson({ skill }, { status: 201 });
+        }
+        case "user-skills-install": {
+            const body = await readJsonBody(request);
+            const skill = await userSkillManager.installFromUrl(normalizeUserSkillUrl(body.url));
+            try {
+                assertUserSkillNameIsAvailable({ userSkillManager, channelContext, name: skill.name, currentSkillId: skill.id });
+            }
+            catch (error) {
+                userSkillManager.remove(skill.id);
+                throw error;
+            }
+            syncAndInvalidate(options);
+            return responseJson({ skill }, { status: 201 });
+        }
+        case "user-skill-read": {
+            const skill = userSkillManager.get(route.skillId);
+            if (!skill)
+                throw new PiboWebHttpError("Skill not found", 404);
+            const markdown = userSkillManager.getSkillMarkdown(skill.id);
+            return responseJson({ skill, markdown });
+        }
+        case "user-skill-update": {
+            const existing = userSkillManager.get(route.skillId);
+            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({
+                    userSkillManager,
+                    channelContext,
+                    name: nextName,
+                    currentSkillId: existing.id,
+                });
+            }
+            const skill = userSkillManager.update(existing.id, input);
+            syncAndInvalidate(options);
+            return responseJson({ skill });
+        }
+        case "user-skill-delete": {
+            const existing = userSkillManager.get(route.skillId);
+            if (!existing)
+                throw new PiboWebHttpError("Skill not found", 404);
+            userSkillManager.remove(existing.id);
+            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;
+}

package/dist/apps/chat/data/chat-data-mappers.js

@@ -0,0 +1,74 @@
+import { normalizeSessionErrorDetails } from "../../../core/session-errors.js";
+import { roomWorkspaceFromMetadata } from "../types/rooms.js";
+export function storedPiboEventFromV2Row(row) {
+    const attributes = parseJsonObject(row.attributes_json);
+    const payload = outputPayloadFromV2Row(row, attributes);
+    if (!payload)
+        return undefined;
+    return { id: String(row.stream_id), piboSessionId: row.session_id ?? undefined, eventSequence: row.session_sequence ?? undefined, eventId: row.event_id ?? undefined, streamId: row.stream_id, type: row.type, createdAt: row.created_at, payload };
+}
+export function storedChatEventFromV2Row(row) {
+    const attributes = parseJsonObject(row.attributes_json);
+    return { streamId: row.stream_id, roomId: row.room_id ?? undefined, piboSessionId: row.session_id ?? undefined, eventId: row.event_id ?? `evt_${row.stream_id}`, eventType: row.type, actorType: actorTypeValue(row.actor_type), actorId: row.actor_id ?? undefined, clientTxnId: typeof attributes.clientTxnId === "string" ? attributes.clientTxnId : undefined, createdAt: row.created_at, retentionClass: retentionClassValue(row.retention_class), payload: (outputPayloadFromV2Row(row, attributes) ?? null) };
+}
+function outputPayloadFromV2Row(row, attributes) {
+    const inlinePayload = attributes.inlinePayload;
+    if (inlinePayload && typeof inlinePayload === "object" && !Array.isArray(inlinePayload) && typeof inlinePayload.type === "string")
+        return inlinePayload;
+    const piboSessionId = row.session_id;
+    if (!piboSessionId)
+        return undefined;
+    const base = compactObject({ piboSessionId, eventId: row.event_id ?? undefined });
+    if (row.type === "assistant_message")
+        return { ...base, type: "assistant_message", text: row.preview_text ?? "" };
+    if (row.type === "message_queued")
+        return { ...base, type: "message_queued", text: stringAttribute(attributes, "inlineText") ?? row.preview_text ?? "", source: stringAttribute(attributes, "source") ?? "user", queuedMessages: numberAttribute(attributes, "queuedMessages") ?? 1 };
+    if (row.type === "message_started")
+        return { ...base, type: "message_started", text: row.preview_text ?? "" };
+    if (row.type === "message_finished")
+        return { ...base, type: "message_finished" };
+    if (row.type === "thinking_started")
+        return { ...base, type: "thinking_started" };
+    if (row.type === "thinking_finished")
+        return { ...base, type: "thinking_finished", text: row.preview_text ?? "" };
+    if (row.type === "tool_call")
+        return { ...base, type: "tool_call", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null, argsComplete: booleanAttribute(attributes, "argsComplete") ?? true };
+    if (row.type === "tool_execution_started")
+        return { ...base, type: "tool_execution_started", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null };
+    if (row.type === "tool_execution_updated")
+        return { ...base, type: "tool_execution_updated", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: null, partialResult: inlinePayload ?? null };
+    if (row.type === "tool_execution_finished")
+        return { ...base, type: "tool_execution_finished", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", result: inlinePayload ?? null, isError: booleanAttribute(attributes, "isError") ?? false };
+    if (row.type === "execution_result")
+        return { ...base, type: "execution_result", action: row.preview_text ?? stringAttribute(attributes, "action") ?? "execution", result: inlinePayload ?? null };
+    if (row.type === "session_error") {
+        const error = stringAttribute(attributes, "error") ?? row.preview_text ?? "Error";
+        return { ...base, type: "session_error", error, errorDetails: normalizeSessionErrorDetails(error, isRecord(attributes.errorDetails) ? attributes.errorDetails : undefined) };
+    }
+    if (row.type === "user.message.accepted")
+        return { type: "user.message.accepted", piboSessionId, roomId: row.room_id ?? undefined, text: stringAttribute(attributes, "inlineText") ?? row.preview_text ?? "", clientTxnId: stringAttribute(attributes, "clientTxnId") };
+    return { ...base, type: row.type };
+}
+export function sessionFromRow(row) { return { piboSessionId: row.id, piSessionId: row.pi_session_id ?? row.id, parentId: row.parent_id ?? undefined, profile: row.profile, channel: row.channel, kind: row.kind, createdAt: row.created_at, updatedAt: row.updated_at, lastActivityAt: row.last_activity_at, status: row.status === "running" || row.status === "error" ? row.status : "idle" }; }
+export function roomFromRow(row) { const metadata = parseJsonObject(row.metadata_json); return { id: row.id, name: row.name, topic: row.topic ?? undefined, workspace: row.workspace ?? roomWorkspaceFromMetadata(metadata), type: row.type, parentRoomId: row.parent_room_id ?? undefined, createdAt: row.created_at, updatedAt: row.updated_at, retentionPolicyId: row.retention_policy_id ?? undefined, metadata }; }
+export function parseJsonObject(value) { try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+catch {
+    return {};
+} }
+export function stringAttribute(attributes, key) { const value = attributes[key]; return typeof value === "string" ? value : undefined; }
+function booleanAttribute(attributes, key) { const value = attributes[key]; return typeof value === "boolean" ? value : undefined; }
+function numberAttribute(attributes, key) { const value = attributes[key]; return typeof value === "number" ? value : undefined; }
+function isRecord(value) { return Boolean(value) && typeof value === "object" && !Array.isArray(value); }
+export function nextSessionSequence(store, sessionId) { const row = store.db.prepare("SELECT COALESCE(MAX(session_sequence), 0) + 1 AS next_sequence FROM event_log WHERE session_id = ?").get(sessionId); return row.next_sequence; }
+export function compactObject(value) { return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)); }
+export function previewForPayload(payload) { if (typeof payload === "object" && payload && "text" in payload && typeof payload.text === "string")
+    return payload.text.slice(0, 512); if (typeof payload === "string")
+    return payload.slice(0, 512); return undefined; }
+export function statusFromOutputEvent(event) { if (event.type === "session_error")
+    return "error"; if (event.type === "message_finished")
+    return "idle"; return "running"; }
+function actorTypeValue(value) { return value === "user" || value === "assistant" || value === "system" || value === "agent" ? value : undefined; }
+function retentionClassValue(value) { return value === "live_delta" || value === "chat_message" || value === "audit_event" ? value : "trace_event"; }