@pasko70/pibo 1.9.9 → 1.9.10

package/dist/apps/chat/trace.js

@@ -0,0 +1,572 @@
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseSessionEntries, SessionManager } from "@earendil-works/pi-coding-agent";
+import { buildTraceViewFromEvents } from "../../shared/trace-engine.js";
+import { isChatWebSessionArchived } from "./session-metadata.js";
+import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
+export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromEntries, } from "../../shared/trace-engine.js";
+export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = 2 * 1024 * 1024;
+export const TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES = 512 * 1024;
+export const TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES = 16 * 1024 * 1024;
+export async function loadPiSessionMetadata(session, cwd = process.cwd()) {
+    const piSession = await findPiSession(session, cwd);
+    return metadataFromPiSession(piSession);
+}
+export async function loadPiSessionFastMetadata(session, cwd = process.cwd()) {
+    const piSession = findPiSessionDirectFast(session.piSessionId, cwd)
+        ?? findPiSessionDirect(session.piSessionId, cwd, { fast: true });
+    return metadataFromPiSession(piSession);
+}
+function metadataFromPiSession(piSession) {
+    if (!piSession)
+        return {};
+    let sessionSize;
+    let sessionMtimeMs;
+    try {
+        const stats = statSync(piSession.path);
+        sessionSize = stats.size;
+        sessionMtimeMs = stats.mtimeMs;
+    }
+    catch {
+        // The session list can contain a file that was removed before trace rendering.
+    }
+    return {
+        sessionPath: piSession.path,
+        sessionSize,
+        sessionMtimeMs,
+        name: piSession.name,
+        firstMessage: piSession.firstMessage,
+        modified: piSession.modified,
+    };
+}
+export async function buildSessionNodes(sessions, indexItems, cwd = process.cwd(), unreadCounts = new Map(), options = {}) {
+    const indexByKey = new Map(indexItems.map((item) => [item.piboSessionId, item]));
+    const nodes = new Map();
+    const piSessionsByCwd = new Map();
+    for (const session of sessions) {
+        let metadata = {};
+        if (!session.title && !options.skipPiMetadataFallback) {
+            const sessionCwd = session.workspace ?? cwd;
+            let piSessions = piSessionsByCwd.get(sessionCwd);
+            if (!piSessions) {
+                piSessions = listPiSessions(sessionCwd);
+                piSessionsByCwd.set(sessionCwd, piSessions);
+            }
+            metadata = metadataFromPiSession((await piSessions).find((piSession) => piSession.id === session.piSessionId));
+        }
+        const indexed = indexByKey.get(session.id);
+        nodes.set(session.id, {
+            piboSessionId: session.id,
+            piSessionId: session.piSessionId,
+            parentId: session.parentId,
+            originId: session.originId,
+            profile: session.profile,
+            activeModel: session.activeModel,
+            subagentName: stringValue(session.metadata?.subagentName),
+            workflowSessionKind: workflowSessionKindFromMetadata(session.metadata),
+            title: createSessionTitle(session, metadata),
+            subtitle: session.id,
+            archived: isChatWebSessionArchived(session),
+            status: sessionNodeStatus(indexed?.status),
+            lastActivityAt: indexed?.lastActivityAt ?? indexed?.createdAt ?? session.createdAt,
+            unreadCount: unreadCounts.get(session.id) || undefined,
+            derivedSessions: [],
+            children: [],
+        });
+    }
+    const roots = [];
+    for (const node of nodes.values()) {
+        const parent = node.parentId ? nodes.get(node.parentId) : undefined;
+        if (parent) {
+            parent.children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    for (const node of nodes.values()) {
+        if (!node.originId)
+            continue;
+        const origin = nodes.get(node.originId);
+        if (!origin)
+            continue;
+        origin.derivedSessions.push({
+            piboSessionId: node.piboSessionId,
+            profile: node.profile,
+            subagentName: node.subagentName,
+            workflowSessionKind: node.workflowSessionKind,
+            title: node.title,
+            status: node.status,
+            lastActivityAt: node.lastActivityAt,
+        });
+    }
+    const sortNodes = (items) => {
+        items.sort((left, right) => (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? ""));
+        for (const item of items) {
+            item.derivedSessions.sort((left, right) => (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? ""));
+            sortNodes(item.children);
+        }
+    };
+    sortNodes(roots);
+    return roots;
+}
+function sessionNodeStatus(indexedStatus) {
+    return indexedStatus ?? "idle";
+}
+export async function buildTraceView(input) {
+    const metadata = input.metadata ?? (await loadPiSessionMetadata(input.session, input.session.workspace ?? input.cwd));
+    const allEntries = input.transcriptEntries ?? (metadata.sessionPath ? readEntries(metadata.sessionPath) : []);
+    const sessionStatus = input.status ?? "idle";
+    const view = buildTraceViewFromEvents({
+        session: {
+            id: input.session.id,
+            piSessionId: input.session.piSessionId,
+            title: createSessionTitle(input.session, metadata),
+        },
+        events: input.events,
+        transcriptEntries: allEntries,
+        sessions: input.sessions.map((s) => ({
+            id: s.id,
+            parentId: s.parentId ?? null,
+            originId: s.originId ?? null,
+            updatedAt: s.updatedAt,
+            title: s.title ?? null,
+            metadata: s.metadata,
+        })),
+        status: sessionStatus,
+        latestStreamId: input.latestStreamId,
+        includeRawEvents: input.includeRawEvents,
+        rawEventsLimit: input.rawEventsLimit,
+    });
+    if (input.transcriptOrderOffset && input.transcriptOrderOffset > 0) {
+        offsetTranscriptTraceOrder(view.nodes, input.transcriptOrderOffset);
+    }
+    annotateForkableUserMessageNodes(view.nodes, allEntries);
+    return {
+        ...view,
+        version: createTraceViewVersion({
+            session: input.session,
+            sessions: input.sessions,
+            events: input.events,
+            status: sessionStatus,
+            metadata,
+            latestStreamId: input.latestStreamId,
+        }),
+    };
+}
+export async function loadPiSessionTailEntries(session, cwd = process.cwd(), maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
+    const metadata = await loadPiSessionMetadata(session, cwd);
+    if (!metadata.sessionPath)
+        return { metadata, entries: [] };
+    return { metadata, entries: readTailEntries(metadata.sessionPath, maxBytes) };
+}
+export function createTraceViewVersion(input) {
+    const relevantSessions = input.sessions
+        .map((session) => ({
+        id: session.id,
+        parentId: session.parentId ?? null,
+        originId: session.originId ?? null,
+        updatedAt: session.updatedAt,
+        title: session.title ?? null,
+    }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    const eventTail = input.events.at(-1);
+    return createHash("sha1")
+        .update(JSON.stringify({
+        session: {
+            id: input.session.id,
+            piSessionId: input.session.piSessionId,
+            profile: input.session.profile,
+            title: input.session.title ?? null,
+            updatedAt: input.session.updatedAt,
+        },
+        metadata: {
+            sessionPath: input.metadata?.sessionPath ?? null,
+            sessionSize: input.metadata?.sessionSize ?? null,
+            sessionMtimeMs: input.metadata?.sessionMtimeMs ?? null,
+            name: input.metadata?.name ?? null,
+            firstMessage: input.metadata?.firstMessage ?? null,
+            modified: input.metadata?.modified ?? null,
+        },
+        status: input.status ?? "idle",
+        events: {
+            lastSequence: eventTail?.eventSequence ?? null,
+            lastCreatedAt: eventTail?.createdAt ?? null,
+            latestStreamId: input.latestStreamId ?? null,
+        },
+        sessions: relevantSessions,
+    }))
+        .digest("hex");
+}
+const PI_SESSION_LIST_CACHE_TTL_MS = 5_000;
+const PI_SESSION_DIRECT_CACHE_TTL_MS = 5_000;
+const PI_SESSION_FAST_HEAD_BYTES = 64 * 1024;
+const piSessionListCache = new Map();
+const piSessionDirectCache = new Map();
+export async function listPiSessions(cwd = process.cwd()) {
+    const now = Date.now();
+    const cached = piSessionListCache.get(cwd);
+    if (cached && cached.expiresAt > now)
+        return cached.promise;
+    const promise = SessionManager.list(cwd).then((sessions) => sessions.map((session) => ({
+        path: session.path,
+        id: session.id,
+        cwd: session.cwd,
+        name: session.name,
+        parentSessionPath: session.parentSessionPath,
+        created: session.created.toISOString(),
+        modified: session.modified.toISOString(),
+        messageCount: session.messageCount,
+        firstMessage: session.firstMessage,
+    })));
+    piSessionListCache.set(cwd, { expiresAt: now + PI_SESSION_LIST_CACHE_TTL_MS, promise });
+    promise.catch(() => {
+        if (piSessionListCache.get(cwd)?.promise === promise)
+            piSessionListCache.delete(cwd);
+    });
+    return promise;
+}
+function createSessionTitle(session, metadata) {
+    const candidate = session.title || metadata.name || metadata.firstMessage || session.id;
+    return truncateTitle(candidate);
+}
+function truncateTitle(title, maxLength = 56) {
+    const normalized = title.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized || "Untitled Session";
+    return `${normalized.slice(0, maxLength - 1)}…`;
+}
+async function findPiSession(piboSession, cwd) {
+    return (findPiSessionDirect(piboSession.piSessionId, cwd) ??
+        (await listPiSessions(cwd)).find((session) => session.id === piboSession.piSessionId));
+}
+function findPiSessionDirectFast(piSessionId, cwd) {
+    const cacheKey = `${cwd}\0${piSessionId}`;
+    const cached = piSessionDirectCache.get(cacheKey);
+    if (!cached || cached.expiresAt <= Date.now())
+        return undefined;
+    try {
+        const stats = statSync(cached.path);
+        if (stats.size === cached.size && stats.mtimeMs === cached.mtimeMs)
+            return cached.item;
+    }
+    catch {
+        piSessionDirectCache.delete(cacheKey);
+    }
+    return undefined;
+}
+function setPiSessionDirectFastCache(piSessionId, cwd, item, stats) {
+    piSessionDirectCache.set(`${cwd}\0${piSessionId}`, {
+        expiresAt: Date.now() + PI_SESSION_DIRECT_CACHE_TTL_MS,
+        path: item.path,
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+        item,
+    });
+}
+function findPiSessionDirect(piSessionId, cwd, options = {}) {
+    const sessionDir = defaultPiSessionDir(cwd);
+    if (!existsSync(sessionDir))
+        return undefined;
+    try {
+        const file = readdirSync(sessionDir).find((candidate) => candidate.endsWith(`_${piSessionId}.jsonl`));
+        if (!file)
+            return undefined;
+        const sessionPath = join(sessionDir, file);
+        const stats = statSync(sessionPath);
+        const entries = options.fast
+            ? readHeadEntries(sessionPath, stats.size, PI_SESSION_FAST_HEAD_BYTES)
+            : parseSessionEntries(readFileSync(sessionPath, "utf8"));
+        const header = entries.find((entry) => entry.type === "session");
+        if (header?.id !== piSessionId)
+            return undefined;
+        let name;
+        let firstMessage = "";
+        let messageCount = 0;
+        for (const entry of entries) {
+            if (entry.type === "session_info")
+                name = stringValue(entry.name)?.trim() || undefined;
+            if (entry.type !== "message")
+                continue;
+            messageCount++;
+            if (firstMessage || messageRole(entry) !== "user")
+                continue;
+            firstMessage = extractMessageText(messageContent(entry));
+        }
+        const item = {
+            path: sessionPath,
+            id: piSessionId,
+            cwd: stringValue(header.cwd) ?? cwd,
+            name,
+            parentSessionPath: stringValue(header.parentSession),
+            created: stringValue(header.timestamp) ?? stats.birthtime.toISOString(),
+            modified: options.fast
+                ? stats.mtime.toISOString()
+                : sessionModifiedIso(entries.filter((entry) => entry.type !== "session"), stringValue(header.timestamp), stats.mtime),
+            messageCount,
+            firstMessage: firstMessage || "(no messages)",
+        };
+        if (options.fast)
+            setPiSessionDirectFastCache(piSessionId, cwd, item, stats);
+        return item;
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultPiSessionDir(cwd) {
+    const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+    const safePath = `--${cwd.replace(/^[\\/]/, "").replace(/[\\/:]/g, "-")}--`;
+    return join(agentDir, "sessions", safePath);
+}
+function sessionModifiedIso(entries, headerTimestamp, statsMtime) {
+    let lastActivityTime;
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        const timestamp = entry.message.timestamp;
+        if (typeof timestamp === "number") {
+            lastActivityTime = Math.max(lastActivityTime ?? 0, timestamp);
+            continue;
+        }
+        const entryTime = new Date(entry.timestamp).getTime();
+        if (!Number.isNaN(entryTime))
+            lastActivityTime = Math.max(lastActivityTime ?? 0, entryTime);
+    }
+    if (lastActivityTime)
+        return new Date(lastActivityTime).toISOString();
+    const headerTime = headerTimestamp ? new Date(headerTimestamp).getTime() : NaN;
+    return !Number.isNaN(headerTime) ? new Date(headerTime).toISOString() : statsMtime.toISOString();
+}
+function readEntries(path) {
+    if (!existsSync(path))
+        return [];
+    const content = readFileSync(path, "utf8");
+    return parseSessionEntries(content).filter((entry) => entry.type !== "session");
+}
+function readHeadEntries(path, fileSize, maxBytes) {
+    const length = Math.max(1, Math.min(maxBytes, fileSize));
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(path, "r");
+    try {
+        const bytesRead = readSync(fd, buffer, 0, length, 0);
+        let content = buffer.subarray(0, bytesRead).toString("utf8");
+        if (bytesRead < fileSize && !content.endsWith("\n")) {
+            const lastNewline = content.lastIndexOf("\n");
+            if (lastNewline >= 0)
+                content = content.slice(0, lastNewline + 1);
+        }
+        if (!content.trim())
+            return [];
+        return parseSessionEntries(content.endsWith("\n") ? content : `${content}\n`);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function readTailEntries(path, maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
+    if (!existsSync(path))
+        return [];
+    const stats = statSync(path);
+    if (stats.size <= maxBytes)
+        return readEntries(path);
+    const length = Math.max(1, Math.min(maxBytes, stats.size));
+    const start = stats.size - length;
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(path, "r");
+    try {
+        const bytesRead = readSync(fd, buffer, 0, length, start);
+        let content = buffer.subarray(0, bytesRead).toString("utf8");
+        const firstNewline = content.indexOf("\n");
+        if (start > 0 && firstNewline >= 0)
+            content = content.slice(firstNewline + 1);
+        return parseSessionEntries(content).filter((entry) => entry.type !== "session");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function readTranscriptHistoryPage(path, input = {}) {
+    if (!existsSync(path))
+        return { entries: [], hasOlder: false, scannedBytes: 0, startByte: 0, endByte: 0 };
+    const stats = statSync(path);
+    const fileSize = Math.max(0, stats.size);
+    const initialEnd = input.beforeByte === undefined
+        ? fileSize
+        : Math.max(0, Math.min(input.beforeByte, fileSize));
+    const limit = Math.max(1, Math.min(input.limit ?? 50, 500));
+    const pageBytes = Math.max(1024, Math.min(input.pageBytes ?? TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES, TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES));
+    const maxScanBytes = Math.max(pageBytes, Math.min(input.maxScanBytes ?? TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES, 32 * 1024 * 1024));
+    const beforeTime = input.beforeTimestamp ? Date.parse(input.beforeTimestamp) : undefined;
+    const entries = [];
+    let cursorEnd = initialEnd;
+    let scannedBytes = 0;
+    let nextBeforeByte;
+    while (cursorEnd > 0 && entries.length < limit && scannedBytes < maxScanBytes) {
+        const chunkStart = Math.max(0, cursorEnd - pageBytes);
+        const chunk = readUtf8Range(path, chunkStart, cursorEnd);
+        scannedBytes += cursorEnd - chunkStart;
+        const records = transcriptLineRecords(chunk, chunkStart, cursorEnd);
+        for (let index = records.length - 1; index >= 0; index -= 1) {
+            const record = records[index];
+            const parsed = parseTranscriptLine(record.text);
+            for (let entryIndex = parsed.length - 1; entryIndex >= 0; entryIndex -= 1) {
+                const entry = parsed[entryIndex];
+                if (beforeTime !== undefined && entryTimestampMs(entry) >= beforeTime)
+                    continue;
+                entries.push({ entry, startByte: record.startByte });
+                if (entries.length >= limit) {
+                    nextBeforeByte = record.startByte;
+                    break;
+                }
+            }
+            if (entries.length >= limit)
+                break;
+        }
+        cursorEnd = chunkStart;
+    }
+    if (nextBeforeByte === undefined)
+        nextBeforeByte = cursorEnd > 0 ? cursorEnd : undefined;
+    return {
+        entries: entries.reverse().map((item) => item.entry),
+        nextBeforeByte,
+        hasOlder: nextBeforeByte !== undefined && nextBeforeByte > 0,
+        scannedBytes,
+        startByte: nextBeforeByte ?? 0,
+        endByte: initialEnd,
+    };
+}
+function readUtf8Range(path, start, end) {
+    const length = Math.max(0, end - start);
+    if (length === 0)
+        return "";
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(path, "r");
+    try {
+        const bytesRead = readSync(fd, buffer, 0, length, start);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function transcriptLineRecords(content, startByte, endByte) {
+    let text = content;
+    let byteOffset = startByte;
+    if (startByte > 0) {
+        const firstNewline = text.indexOf("\n");
+        if (firstNewline < 0)
+            return [];
+        const skipped = text.slice(0, firstNewline + 1);
+        byteOffset += Buffer.byteLength(skipped, "utf8");
+        text = text.slice(firstNewline + 1);
+    }
+    if (endByte > startByte && text && !text.endsWith("\n")) {
+        const lastNewline = text.lastIndexOf("\n");
+        if (lastNewline >= 0)
+            text = text.slice(0, lastNewline + 1);
+    }
+    const records = [];
+    const segments = text.match(/[^\n]*(?:\n|$)/g) ?? [];
+    for (const segment of segments) {
+        if (!segment)
+            continue;
+        const lineStart = byteOffset;
+        byteOffset += Buffer.byteLength(segment, "utf8");
+        const line = segment.replace(/\r?\n$/, "");
+        if (line.trim())
+            records.push({ text: line, startByte: lineStart });
+    }
+    return records;
+}
+function parseTranscriptLine(line) {
+    try {
+        return parseSessionEntries(`${line}\n`).filter((entry) => entry.type !== "session");
+    }
+    catch {
+        return [];
+    }
+}
+function entryTimestampMs(entry) {
+    const timestamp = entry.timestamp;
+    if (typeof timestamp !== "string")
+        return Number.POSITIVE_INFINITY;
+    const parsed = Date.parse(timestamp);
+    return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
+}
+function offsetTranscriptTraceOrder(nodes, offset) {
+    for (const node of nodes) {
+        if (node.source === "transcript" && node.orderKey) {
+            const transcriptIndex = node.orderKey.transcriptIndex;
+            node.orderKey = {
+                ...node.orderKey,
+                turnSeq: node.orderKey.turnSeq + offset,
+                transcriptIndex: transcriptIndex === undefined ? undefined : transcriptIndex + offset,
+            };
+        }
+        offsetTranscriptTraceOrder(node.children, offset);
+    }
+}
+function annotateForkableUserMessageNodes(nodes, entries) {
+    const candidates = userMessageForkCandidates(entries);
+    if (!candidates.length)
+        return;
+    const used = new Set();
+    for (const node of flattenTraceNodesForForkAnnotation(nodes)) {
+        if (node.type !== "user.message" || node.entryId)
+            continue;
+        const text = stringValue(node.output) ?? stringValue(node.summary) ?? "";
+        const candidate = candidates.find((item) => !used.has(item.entryId) && item.text === text);
+        if (!candidate)
+            continue;
+        node.entryId = candidate.entryId;
+        used.add(candidate.entryId);
+    }
+}
+function flattenTraceNodesForForkAnnotation(nodes) {
+    const flattened = [];
+    const visit = (items) => {
+        for (const item of items) {
+            flattened.push(item);
+            visit(item.children);
+        }
+    };
+    visit(nodes);
+    return flattened;
+}
+function userMessageForkCandidates(entries) {
+    const candidates = [];
+    for (const entry of entries) {
+        if (entry.type !== "message" || messageRole(entry) !== "user")
+            continue;
+        const text = extractMessageText(messageContent(entry));
+        if (text)
+            candidates.push({ entryId: entry.id, text });
+    }
+    return candidates;
+}
+function messageRole(entry) {
+    return entry.type === "message" ? entry.message.role : undefined;
+}
+function messageContent(entry) {
+    return entry.type === "message" ? entry.message.content : undefined;
+}
+function extractMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object")
+            return "";
+        const typed = part;
+        return typed.type === "text" && typeof typed.text === "string" ? typed.text : "";
+    })
+        .join("");
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/apps/chat/types/event-store.js

@@ -0,0 +1 @@
+export {};

package/dist/apps/chat/types/read-model.js

@@ -0,0 +1 @@
+export {};

package/dist/apps/chat/types/rooms.js

@@ -0,0 +1,36 @@
+export const CHAT_ROOM_ID_METADATA_KEY = "chatRoomId";
+const CHAT_ROOM_ARCHIVED_AT_METADATA_KEY = "chatRoomArchivedAt";
+const CHAT_ROOM_WORKSPACE_METADATA_KEY = "workspace";
+export function chatRoomIdFromMetadata(metadata) {
+    const value = metadata?.[CHAT_ROOM_ID_METADATA_KEY];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function withChatRoomId(metadata, roomId) {
+    return { ...(metadata ?? {}), [CHAT_ROOM_ID_METADATA_KEY]: roomId };
+}
+export function isDefaultPiboRoom(room) {
+    return room.metadata.default === true;
+}
+export function isPiboRoomArchived(room) {
+    return typeof room.metadata[CHAT_ROOM_ARCHIVED_AT_METADATA_KEY] === "string";
+}
+export function roomWorkspaceFromMetadata(metadata) {
+    const value = metadata?.[CHAT_ROOM_WORKSPACE_METADATA_KEY];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function withPiboRoomArchived(metadata, archived) {
+    const next = { ...(metadata ?? {}) };
+    if (archived)
+        next[CHAT_ROOM_ARCHIVED_AT_METADATA_KEY] = new Date().toISOString();
+    else
+        delete next[CHAT_ROOM_ARCHIVED_AT_METADATA_KEY];
+    return next;
+}
+export function withPiboRoomWorkspace(metadata, workspace) {
+    const next = { ...(metadata ?? {}) };
+    if (workspace)
+        next[CHAT_ROOM_WORKSPACE_METADATA_KEY] = workspace;
+    else
+        delete next[CHAT_ROOM_WORKSPACE_METADATA_KEY];
+    return next;
+}