@zhanguym/chatroom 1.0.0 → 1.1.0-beta.0

package/dist/plugins/agent/runtime-config.js

@@ -0,0 +1,60 @@
+import { ChatRoomError } from "#core/errors/chatroom-error";
+export function emptyAgentSessionConfig() {
+    return {
+        model: null,
+        reasoningEffort: null,
+        reasoningSummary: null,
+        serviceTier: null,
+        approvalPolicy: null,
+        approvalsReviewer: null,
+        permissionMode: null,
+    };
+}
+export function copyAgentSessionConfig(config) {
+    return {
+        model: config.model,
+        reasoningEffort: config.reasoningEffort,
+        reasoningSummary: config.reasoningSummary,
+        serviceTier: config.serviceTier,
+        approvalPolicy: config.approvalPolicy,
+        approvalsReviewer: config.approvalsReviewer,
+        permissionMode: config.permissionMode,
+    };
+}
+export function approvalPolicySupported(value, setting) {
+    if (value === null)
+        return false;
+    if (typeof value === "string")
+        return setting.options.some((option) => option.id === value);
+    if (!setting.options.some((option) => option.id === "granular"))
+        return false;
+    const granular = value.granular;
+    return (typeof granular.sandbox_approval === "boolean" &&
+        typeof granular.rules === "boolean" &&
+        typeof granular.skill_approval === "boolean" &&
+        typeof granular.request_permissions === "boolean" &&
+        typeof granular.mcp_elicitations === "boolean");
+}
+export function validateReviewTarget(target) {
+    if (!target || typeof target !== "object")
+        throw new ChatRoomError("INVALID_INPUT", "Invalid review target");
+    switch (target.type) {
+        case "uncommittedChanges":
+            return;
+        case "baseBranch":
+            if (typeof target.branch === "string" && target.branch.trim())
+                return;
+            break;
+        case "commit":
+            if (typeof target.sha === "string" &&
+                target.sha.trim() &&
+                (target.title === null || typeof target.title === "string"))
+                return;
+            break;
+        case "custom":
+            if (typeof target.instructions === "string" && target.instructions.trim())
+                return;
+            break;
+    }
+    throw new ChatRoomError("INVALID_INPUT", "Invalid review target");
+}

package/dist/plugins/agent/runtime-files.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderItem } from "./provider.js";
+import type { AgentStore } from "./store.js";
+import type { AgentHistory, AgentSession, AgentTurnInput } from "./types.js";
+export declare function sessionAttachmentPrefix(sessionId: string): string;
+export declare function cleanupSessionFiles(store: AgentStore, history: AgentHistory): Promise<void>;
+export declare function cleanupOrphanAttachments(store: AgentStore, maxAgeMs: number): Promise<void>;
+export declare function prepareProviderItem(session: AgentSession, item: ProviderItem): Promise<ProviderItem>;
+export declare function validateAttachments(session: AgentSession, attachments: AgentTurnInput["attachments"]): Promise<AgentTurnInput["attachments"]>;

package/dist/plugins/agent/runtime-files.js

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import { removeFileWithin, resolveReadableFileWithin, writeBytesAtomicWithin, } from "#core/fs/safe-directory";
+import { runtimeErrorMessage } from "./runtime-state.js";
+export function sessionAttachmentPrefix(sessionId) {
+    return ".chatroom/agent-attachments/" + sessionId + "/";
+}
+export async function cleanupSessionFiles(store, history) {
+    const workspaceRoot = history.session.workspaceRoot;
+    const retained = referencedManagedFiles(store, workspaceRoot, history.session.id);
+    const attachmentPrefix = sessionAttachmentPrefix(history.session.id);
+    const attachmentDirectory = path.join(workspaceRoot, attachmentPrefix);
+    try {
+        for (const file of await readdir(attachmentDirectory)) {
+            const filePath = attachmentPrefix + file;
+            if (retained.has(filePath))
+                continue;
+            await removeFileWithin(workspaceRoot, filePath).catch(() => undefined);
+        }
+    }
+    catch {
+        // The session may not have uploaded local attachments.
+    }
+    for (const filePath of sessionArtifactFiles(history)) {
+        if (retained.has(filePath))
+            continue;
+        await removeFileWithin(workspaceRoot, filePath).catch(() => undefined);
+    }
+}
+export async function cleanupOrphanAttachments(store, maxAgeMs) {
+    const now = Date.now();
+    const workspaceRoots = new Set(store.listSessions().map((session) => session.workspaceRoot));
+    for (const workspaceRoot of workspaceRoots) {
+        await removeUnreferencedAttachmentFiles(workspaceRoot, referencedManagedFiles(store, workspaceRoot), now, maxAgeMs);
+    }
+}
+export async function prepareProviderItem(session, item) {
+    if (item.type !== "artifact")
+        return item;
+    try {
+        if (!path.isAbsolute(item.artifact.path)) {
+            return {
+                ...item,
+                artifact: {
+                    ...item.artifact,
+                    path: (await resolveReadableFileWithin(session.workspaceRoot, item.artifact.path)).relative,
+                },
+            };
+        }
+        if (item.artifact.kind !== "image")
+            throw new ChatRoomError("FORBIDDEN", "External Agent artifacts must be imported explicitly");
+        const info = await stat(item.artifact.path);
+        if (!info.isFile())
+            throw new ChatRoomError("INVALID_INPUT", "Agent artifact is not a file");
+        if (info.size > 32 * 1024 * 1024)
+            throw new ChatRoomError("INVALID_INPUT", "Agent artifact is too large");
+        const extension = path.extname(item.artifact.name).slice(0, 16);
+        const target = ".chatroom/agent-artifacts/" + randomUUID() + extension.toLowerCase();
+        const content = await readFile(item.artifact.path);
+        if (content.byteLength > 32 * 1024 * 1024)
+            throw new ChatRoomError("INVALID_INPUT", "Agent artifact is too large");
+        await writeBytesAtomicWithin(session.workspaceRoot, target, content);
+        return {
+            ...item,
+            artifact: {
+                ...item.artifact,
+                path: target,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            type: "notice",
+            level: "warning",
+            text: "Agent artifact could not be imported: " + runtimeErrorMessage(error),
+        };
+    }
+}
+export async function validateAttachments(session, attachments) {
+    return Promise.all(attachments.map(async (attachment) => {
+        const resolved = await resolveReadableFileWithin(session.workspaceRoot, attachment.path);
+        if (resolved.relative.startsWith(".chatroom/agent-attachments/") &&
+            !resolved.relative.startsWith(sessionAttachmentPrefix(session.id)))
+            throw new ChatRoomError("FORBIDDEN", "Agent attachment belongs to another session");
+        return {
+            ...attachment,
+            path: resolved.relative,
+        };
+    }));
+}
+function referencedManagedFiles(store, workspaceRoot, excludedSessionId) {
+    const paths = new Set();
+    for (const session of store.listSessions()) {
+        if (session.id === excludedSessionId)
+            continue;
+        if (session.workspaceRoot !== workspaceRoot)
+            continue;
+        const history = store.history(session.id);
+        if (!history)
+            continue;
+        for (const filePath of managedFilesInHistory(history))
+            paths.add(filePath);
+    }
+    return paths;
+}
+async function removeUnreferencedAttachmentFiles(workspaceRoot, referenced, now, maxAgeMs) {
+    const root = path.join(workspaceRoot, ".chatroom/agent-attachments");
+    let sessions;
+    try {
+        sessions = await readdir(root);
+    }
+    catch {
+        return;
+    }
+    for (const sessionId of sessions) {
+        const dir = path.join(root, sessionId);
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const relative = sessionAttachmentPrefix(sessionId) + file;
+            if (referenced.has(relative))
+                continue;
+            try {
+                const info = await stat(path.join(dir, file));
+                if (info.isFile() && now - info.mtimeMs > maxAgeMs)
+                    await removeFileWithin(workspaceRoot, relative);
+            }
+            catch {
+                // Ignore races with uploads/deletions.
+            }
+        }
+    }
+}
+function managedFilesInHistory(history) {
+    const paths = new Set();
+    for (const entry of history.turns) {
+        for (const item of entry.items) {
+            if (item.type === "user_message") {
+                for (const attachment of item.attachments) {
+                    if (attachment.path.startsWith(".chatroom/agent-attachments/") ||
+                        attachment.path.startsWith(".chatroom/agent-artifacts/"))
+                        paths.add(attachment.path);
+                }
+            }
+            else if (item.type === "artifact" &&
+                item.artifact.path.startsWith(".chatroom/agent-artifacts/")) {
+                paths.add(item.artifact.path);
+            }
+        }
+    }
+    return paths;
+}
+function sessionArtifactFiles(history) {
+    const paths = new Set();
+    for (const entry of history.turns) {
+        for (const item of entry.items) {
+            if (item.type === "artifact" &&
+                item.artifact.path.startsWith(".chatroom/agent-artifacts/"))
+                paths.add(item.artifact.path);
+        }
+    }
+    return paths;
+}

package/dist/plugins/agent/runtime-state.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderItem } from "./provider.js";
+import type { AgentError, AgentHistory, AgentInputQuestion, AgentInteractionOption, AgentItem } from "./types.js";
+export declare function nextSessionUpdatedAt(current: string): string;
+export declare function materializeProviderItem(turnId: string, providerItemId: string, sequence: number, status: AgentItem["status"], item: ProviderItem, existing?: AgentItem): AgentItem;
+export declare function materializeInteraction(turnId: string, providerItemId: string, sequence: number, interaction: {
+    id: string;
+    kind: "approval" | "input";
+    title: string;
+    description: string | null;
+    questions: AgentInputQuestion[];
+    approvalOptions: AgentInteractionOption[];
+}): AgentItem;
+export declare function applyItemDelta(item: AgentItem, field: "text" | "output", delta: string): AgentItem;
+export declare function buildContinuityDelta(history: AgentHistory, afterTurnId: string | null): string;
+export declare function mergeContinuityContext(existing: string, delta: string): string;
+export declare function runtimeErrorMessage(error: unknown): string;
+export declare function structuredError(error: unknown): AgentError;

package/dist/plugins/agent/runtime-state.js

@@ -0,0 +1,133 @@
+import { randomUUID } from "node:crypto";
+const CONTINUITY_CONTEXT_LIMIT = 64 * 1024;
+export function nextSessionUpdatedAt(current) {
+    const currentMs = Date.parse(current);
+    const nextMs = Math.max(Date.now(), Number.isFinite(currentMs) ? currentMs + 1 : 0);
+    return new Date(nextMs).toISOString();
+}
+export function materializeProviderItem(turnId, providerItemId, sequence, status, item, existing) {
+    const now = new Date().toISOString();
+    return {
+        id: existing?.id ?? "item_" + randomUUID(),
+        turnId,
+        providerItemId,
+        sequence,
+        status,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        ...item,
+    };
+}
+export function materializeInteraction(turnId, providerItemId, sequence, interaction) {
+    const now = new Date().toISOString();
+    return {
+        id: "item_" + randomUUID(),
+        turnId,
+        providerItemId,
+        sequence,
+        status: "waiting",
+        createdAt: now,
+        updatedAt: now,
+        type: "interaction",
+        interaction: {
+            kind: interaction.kind,
+            title: interaction.title,
+            description: interaction.description,
+            questions: interaction.questions,
+            approvalOptions: interaction.approvalOptions,
+            response: null,
+        },
+    };
+}
+export function applyItemDelta(item, field, delta) {
+    const updatedAt = new Date().toISOString();
+    if (field === "text") {
+        if (item.type === "assistant_message" ||
+            item.type === "plan" ||
+            item.type === "reasoning_summary")
+            return { ...item, text: item.text + delta, updatedAt };
+        if (item.type === "notice")
+            return { ...item, text: item.text + delta, updatedAt };
+    }
+    if (field === "output" && item.type === "command")
+        return { ...item, output: item.output + delta, updatedAt };
+    return { ...item, updatedAt };
+}
+export function buildContinuityDelta(history, afterTurnId) {
+    let startIndex = 0;
+    if (afterTurnId) {
+        const index = history.turns.findIndex((entry) => entry.turn.id === afterTurnId);
+        if (index >= 0)
+            startIndex = index + 1;
+    }
+    const lines = [];
+    for (const entry of history.turns.slice(startIndex)) {
+        for (const item of entry.items) {
+            const line = continuityLine(item, entry.turn.source);
+            if (line)
+                lines.push(line);
+        }
+    }
+    return lines.join("\n\n");
+}
+export function mergeContinuityContext(existing, delta) {
+    if (!delta)
+        return existing;
+    let merged = existing ? existing + "\n\n" + delta : delta;
+    if (merged.length > CONTINUITY_CONTEXT_LIMIT)
+        merged =
+            "[Earlier cross-provider context omitted]\n\n" +
+                merged.slice(merged.length - CONTINUITY_CONTEXT_LIMIT);
+    return merged;
+}
+function continuityLine(item, source) {
+    if (item.type === "user_message") {
+        const attachments = item.attachments.length
+            ? "\nAttachments: " +
+                item.attachments
+                    .map((attachment) => `${attachment.name} (${attachment.path})`)
+                    .join(", ")
+            : "";
+        return `User [${item.source ?? source}]: ${item.text}${attachments}`;
+    }
+    if (item.type === "assistant_message")
+        return "Assistant: " + item.text;
+    if (item.type === "plan")
+        return ("Plan: " +
+            item.text +
+            "\n" +
+            item.steps.map((step) => `[${step.status}] ${step.step}`).join("\n"));
+    if (item.type === "command")
+        return ("Command: " +
+            item.command +
+            (item.exitCode === null ? "" : " (exit " + item.exitCode + ")") +
+            (item.output ? "\n" + item.output.slice(-2000) : ""));
+    if (item.type === "file_change")
+        return ("Files changed: " +
+            item.changes.map((change) => change.kind + " " + change.path).join(", "));
+    if (item.type === "tool")
+        return "Tool: " + (item.server ? item.server + "/" : "") + item.name;
+    if (item.type === "artifact")
+        return "Artifact: " + item.artifact.path;
+    if (item.type === "interaction" && item.interaction.response)
+        return ("Interaction: " +
+            item.interaction.title +
+            "\nResponse: " +
+            JSON.stringify(item.interaction.response));
+    if (item.type === "notice" && item.level !== "info")
+        return "Notice: " + item.text;
+    return null;
+}
+export function runtimeErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function structuredError(error) {
+    const details = error && typeof error === "object" ? error : null;
+    return {
+        message: typeof details?.message === "string"
+            ? details.message
+            : runtimeErrorMessage(error),
+        details: typeof details?.details === "string" ? details.details : null,
+        providerData: details?.providerData ?? null,
+    };
+}

package/dist/plugins/agent/runtime.d.ts

@@ -0,0 +1,60 @@
+import type { RuntimeEventBus } from "#app/event-bus";
+import type { WorkspaceAccess } from "#app/workspace-access";
+import type { AgentProvider } from "./provider.js";
+import type { AgentStore } from "./store.js";
+import type { AgentSessionConfig, AgentHistory, AgentHistoryUpdate, AgentInteractionResponse, AgentItem, AgentModel, AgentProviderId, AgentProviderStatus, AgentProviderDetails, AgentReviewTarget, AgentSession, AgentTurn, AgentTurnInput, AgentTurnSource, CreateAgentSessionInput } from "./types.js";
+export declare class AgentRuntime {
+    private readonly store;
+    private readonly workspaces;
+    private readonly events;
+    private readonly providerSessions;
+    private readonly activeTurns;
+    private readonly sessionMutations;
+    private readonly deltaInvalidations;
+    private closed;
+    private readonly providers;
+    constructor(store: AgentStore, workspaces: WorkspaceAccess, events: RuntimeEventBus, providers: AgentProvider[]);
+    providerStatuses(): Promise<AgentProviderStatus[]>;
+    providerDetails(providerId: AgentProviderId): Promise<AgentProviderDetails>;
+    models(providerId: AgentProviderId): Promise<AgentModel[]>;
+    listSessions(): AgentSession[];
+    getSession(sessionId: string): AgentSession;
+    history(sessionId: string): AgentHistory;
+    historyUpdate(sessionId: string, turnIds: readonly string[], itemIds: readonly string[]): AgentHistoryUpdate;
+    createSession(input: CreateAgentSessionInput): Promise<AgentSession>;
+    startTurn(sessionId: string, input: AgentTurnInput, source: AgentTurnSource): Promise<AgentTurn>;
+    private startTurnUnlocked;
+    startReview(sessionId: string, target: AgentReviewTarget, source: AgentTurnSource): Promise<AgentTurn>;
+    steer(sessionId: string, input: Pick<AgentTurnInput, "text" | "attachments">, source: AgentTurnSource): Promise<void>;
+    private beginTurn;
+    configureSession(sessionId: string, patch: Partial<AgentSessionConfig>): Promise<AgentSession>;
+    private configureSessionUnlocked;
+    private validateConfig;
+    interrupt(sessionId: string): Promise<void>;
+    respondInteraction(sessionId: string, itemId: string, response: AgentInteractionResponse): Promise<AgentItem>;
+    deleteSession(sessionId: string): Promise<void>;
+    private deleteSessionUnlocked;
+    switchProvider(sessionId: string, targetProvider: AgentProviderId, patch?: Partial<AgentSessionConfig>): Promise<AgentSession>;
+    private switchProviderUnlocked;
+    close(): Promise<void>;
+    private executeTurn;
+    private handleProviderEvent;
+    private finishTurn;
+    private providerSession;
+    private requireProviderState;
+    private updateSessionStatus;
+    private requireProvider;
+    private requireSession;
+    cleanupOrphanAttachments(maxAgeMs?: number): Promise<void>;
+    private withSessionMutation;
+    private validateInputModalities;
+    private scheduleDeltaInvalidation;
+    private flushDeltaInvalidation;
+    private persistItem;
+    private persistPendingSession;
+    private failActiveTurn;
+    private persistPendingItems;
+    private boundCommandOutput;
+    private appendCommandOutput;
+    private invalidateSession;
+}