@otto-code/server 0.5.0

package/dist/server/server/session/files/workspace-files-session.d.ts

@@ -0,0 +1,60 @@
+import type pino from "pino";
+import { type FileTransferFrame } from "@otto-code/protocol/binary-frames/index";
+import type { CodeListFilesRequest, CodeOutlineRequest, CodeSymbolsRequest, FileDownloadTokenRequest, FileExplorerRequest, FileReplaceRequest, FileSearchRequest, FileUploadRequest, FileWatchSubscribeRequest, FileWatchUnsubscribeRequest, FileWriteRequest, SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { DownloadTokenStore } from "../../file-download/token-store.js";
+/**
+ * What a workspace file-access request reaches outside its own domain: the
+ * outbound message channel (text + binary). `hasBinaryChannel` gates the
+ * binary file-explorer transfer path the same way the terminal subsystem does
+ * — old clients without a binary channel fall back to inline JSON file content.
+ */
+export interface WorkspaceFilesSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    emitBinary(frame: Uint8Array): void;
+    hasBinaryChannel(): boolean;
+}
+export interface WorkspaceFilesSessionOptions {
+    host: WorkspaceFilesSessionHost;
+    downloadTokenStore: DownloadTokenStore;
+    ottoHome: string;
+    logger: pino.Logger;
+    /** Test hook: tighten the watcher's timing so specs stay fast. */
+    watchOptions?: {
+        pollIntervalMs?: number;
+        debounceMs?: number;
+    };
+}
+/**
+ * A client's workspace file-access surface: browsing directories, reading file
+ * contents (inline JSON or binary frames), receiving uploads, issuing download
+ * tokens, and reading project icons. It owns the upload store and reaches no
+ * workspace-git, registry, or subscription state — file I/O scoped to a cwd is
+ * the whole concern.
+ */
+export declare class WorkspaceFilesSession {
+    private readonly host;
+    private readonly downloadTokenStore;
+    private readonly logger;
+    private readonly fileUploads;
+    private readonly fileWatcher;
+    private readonly symbolIndex;
+    private activeSearchSignal;
+    constructor(options: WorkspaceFilesSessionOptions);
+    dispose(): void;
+    handleFileWatchSubscribeRequest(request: FileWatchSubscribeRequest): Promise<void>;
+    handleFileWatchUnsubscribeRequest(request: FileWatchUnsubscribeRequest): void;
+    handleFileExplorerRequest(request: FileExplorerRequest): Promise<void>;
+    handleFileWriteRequest(request: FileWriteRequest): Promise<void>;
+    handleFileSearchRequest(request: FileSearchRequest): Promise<void>;
+    handleFileReplaceRequest(request: FileReplaceRequest): Promise<void>;
+    handleCodeListFilesRequest(request: CodeListFilesRequest): Promise<void>;
+    handleCodeSymbolsRequest(request: CodeSymbolsRequest): Promise<void>;
+    handleCodeOutlineRequest(request: CodeOutlineRequest): Promise<void>;
+    handleFileUploadRequest(request: FileUploadRequest): void;
+    handleFileTransferFrame(frame: FileTransferFrame): Promise<void>;
+    handleProjectIconRequest(request: Extract<SessionInboundMessage, {
+        type: "project_icon_request";
+    }>): Promise<void>;
+    handleFileDownloadTokenRequest(request: FileDownloadTokenRequest): Promise<void>;
+}
+//# sourceMappingURL=workspace-files-session.d.ts.map

package/dist/server/server/session/files/workspace-files-session.js

@@ -0,0 +1,518 @@
+import { getErrorMessage } from "@otto-code/protocol/error-utils";
+import { encodeFileTransferFrame, FileTransferOpcode, } from "@otto-code/protocol/binary-frames/index";
+import { FileUploadStore } from "../../file-upload/index.js";
+import { getDownloadableFileInfo, listDirectoryEntries, readExplorerFile, readExplorerFileBytes, writeExplorerFile, } from "../../file-explorer/service.js";
+import { SessionFileWatcher } from "../../file-explorer/file-watcher.js";
+import { replaceInWorkspaceFiles, searchWorkspaceFiles } from "../../file-explorer/file-search.js";
+import { getFileOutline, listWorkspaceFiles, WorkspaceSymbolIndex, } from "../../file-explorer/code-index.js";
+import { getProjectIcon } from "../../../utils/project-icon.js";
+/**
+ * A client's workspace file-access surface: browsing directories, reading file
+ * contents (inline JSON or binary frames), receiving uploads, issuing download
+ * tokens, and reading project icons. It owns the upload store and reaches no
+ * workspace-git, registry, or subscription state — file I/O scoped to a cwd is
+ * the whole concern.
+ */
+export class WorkspaceFilesSession {
+    constructor(options) {
+        this.symbolIndex = new WorkspaceSymbolIndex();
+        this.activeSearchSignal = null;
+        this.host = options.host;
+        this.downloadTokenStore = options.downloadTokenStore;
+        this.logger = options.logger;
+        this.fileUploads = new FileUploadStore({ ottoHome: options.ottoHome });
+        this.fileWatcher = new SessionFileWatcher({
+            logger: options.logger,
+            emitEvent: (event) => {
+                this.host.emit({ type: "file.watch.event", payload: event });
+            },
+            ...options.watchOptions,
+        });
+    }
+    dispose() {
+        this.fileWatcher.dispose();
+    }
+    async handleFileWatchSubscribeRequest(request) {
+        const cwd = request.cwd.trim();
+        const respond = (ok, error) => {
+            this.host.emit({
+                type: "file.watch.subscribe.response",
+                payload: {
+                    cwd: cwd || request.cwd,
+                    path: request.path,
+                    ok,
+                    error,
+                    requestId: request.requestId,
+                },
+            });
+        };
+        if (!cwd) {
+            respond(false, "cwd is required");
+            return;
+        }
+        try {
+            await this.fileWatcher.subscribe({ cwd, path: request.path });
+            respond(true, null);
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: request.path }, `Failed to subscribe file watch for workspace ${cwd}`);
+            respond(false, getErrorMessage(error));
+        }
+    }
+    handleFileWatchUnsubscribeRequest(request) {
+        const cwd = request.cwd.trim();
+        if (cwd) {
+            this.fileWatcher.unsubscribe({ cwd, path: request.path });
+        }
+        this.host.emit({
+            type: "file.watch.unsubscribe.response",
+            payload: {
+                cwd: cwd || request.cwd,
+                path: request.path,
+                ok: Boolean(cwd),
+                error: cwd ? null : "cwd is required",
+                requestId: request.requestId,
+            },
+        });
+    }
+    async handleFileExplorerRequest(request) {
+        const { cwd: workspaceCwd, path: requestedPath = ".", mode, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file_explorer_response",
+                payload: {
+                    cwd: workspaceCwd,
+                    path: requestedPath,
+                    mode,
+                    directory: null,
+                    file: null,
+                    error: "cwd is required",
+                    requestId,
+                },
+            });
+            return;
+        }
+        try {
+            if (mode === "list") {
+                const directory = await listDirectoryEntries({
+                    root: cwd,
+                    relativePath: requestedPath,
+                });
+                this.host.emit({
+                    type: "file_explorer_response",
+                    payload: {
+                        cwd,
+                        path: directory.path,
+                        mode,
+                        directory,
+                        file: null,
+                        error: null,
+                        requestId,
+                    },
+                });
+            }
+            else {
+                if (request.acceptBinary && this.host.hasBinaryChannel()) {
+                    const file = await readExplorerFileBytes({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.host.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileBegin,
+                        requestId,
+                        metadata: {
+                            mime: file.mimeType,
+                            size: file.size,
+                            encoding: file.encoding,
+                            modifiedAt: file.modifiedAt,
+                        },
+                    }));
+                    this.host.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileChunk,
+                        requestId,
+                        payload: file.bytes,
+                    }));
+                    this.host.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileEnd,
+                        requestId,
+                    }));
+                }
+                else {
+                    const file = await readExplorerFile({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.host.emit({
+                        type: "file_explorer_response",
+                        payload: {
+                            cwd,
+                            path: file.path,
+                            mode,
+                            directory: null,
+                            file,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to fulfill file explorer request for workspace ${cwd}`);
+            this.host.emit({
+                type: "file_explorer_response",
+                payload: {
+                    cwd,
+                    path: requestedPath,
+                    mode,
+                    directory: null,
+                    file: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleFileWriteRequest(request) {
+        const { cwd: workspaceCwd, path: requestedPath, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        const emitResult = (result) => {
+            this.host.emit({
+                type: "file.write.response",
+                payload: {
+                    cwd: cwd || workspaceCwd,
+                    path: requestedPath,
+                    result,
+                    requestId,
+                },
+            });
+        };
+        if (!cwd) {
+            emitResult({ status: "error", message: "cwd is required" });
+            return;
+        }
+        try {
+            const outcome = await writeExplorerFile({
+                root: cwd,
+                relativePath: requestedPath,
+                content: request.content,
+                expectedModifiedAt: request.expectedModifiedAt,
+                expectedHash: request.expectedHash,
+                allowCreate: request.allowCreate,
+                eol: request.eol,
+            });
+            if (outcome.status === "ok") {
+                // The file's symbols may have changed; the next lookup rebuilds.
+                this.symbolIndex.invalidate(cwd);
+            }
+            emitResult(outcome);
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to fulfill file write request for workspace ${cwd}`);
+            emitResult({ status: "error", message: getErrorMessage(error) });
+        }
+    }
+    async handleFileSearchRequest(request) {
+        const cwd = request.cwd.trim();
+        const respond = (summary) => {
+            this.host.emit({
+                type: "file.search.response",
+                payload: { cwd: cwd || request.cwd, requestId: request.requestId, ...summary },
+            });
+        };
+        if (!cwd) {
+            respond({ status: "error", error: "cwd is required", fileCount: 0, matchCount: 0 });
+            return;
+        }
+        // One search at a time per session: a new query supersedes the previous
+        // scan mid-flight (the UI issues explicit, press-enter searches).
+        if (this.activeSearchSignal) {
+            this.activeSearchSignal.superseded = true;
+        }
+        const signal = { superseded: false };
+        this.activeSearchSignal = signal;
+        try {
+            const outcome = await searchWorkspaceFiles({
+                root: cwd,
+                query: request.query,
+                caseSensitive: request.caseSensitive,
+                wholeWord: request.wholeWord,
+                regexp: request.regexp,
+                include: request.include,
+                exclude: request.exclude,
+                signal,
+                onFileResult: (result) => {
+                    this.host.emit({
+                        type: "file.search.result",
+                        payload: {
+                            cwd,
+                            searchId: request.requestId,
+                            path: result.path,
+                            hash: result.hash,
+                            matches: result.matches,
+                        },
+                    });
+                },
+            });
+            respond({
+                status: outcome.status,
+                error: null,
+                fileCount: outcome.fileCount,
+                matchCount: outcome.matchCount,
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, query: request.query }, `Failed to run project search for workspace ${cwd}`);
+            respond({ status: "error", error: getErrorMessage(error), fileCount: 0, matchCount: 0 });
+        }
+        finally {
+            if (this.activeSearchSignal === signal) {
+                this.activeSearchSignal = null;
+            }
+        }
+    }
+    async handleFileReplaceRequest(request) {
+        const cwd = request.cwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file.replace.response",
+                payload: {
+                    cwd: request.cwd,
+                    results: [],
+                    error: "cwd is required",
+                    requestId: request.requestId,
+                },
+            });
+            return;
+        }
+        try {
+            const results = await replaceInWorkspaceFiles({
+                root: cwd,
+                replacement: request.replacement,
+                files: request.files,
+            });
+            if (results.some((result) => result.status === "ok")) {
+                this.symbolIndex.invalidate(cwd);
+            }
+            this.host.emit({
+                type: "file.replace.response",
+                payload: { cwd, results, error: null, requestId: request.requestId },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd }, `Failed to run project replace for workspace ${cwd}`);
+            this.host.emit({
+                type: "file.replace.response",
+                payload: { cwd, results: [], error: getErrorMessage(error), requestId: request.requestId },
+            });
+        }
+    }
+    async handleCodeListFilesRequest(request) {
+        const cwd = request.cwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "code.list_files.response",
+                payload: {
+                    cwd: request.cwd,
+                    files: [],
+                    truncated: false,
+                    error: "cwd is required",
+                    requestId: request.requestId,
+                },
+            });
+            return;
+        }
+        try {
+            const { files, truncated } = await listWorkspaceFiles(cwd);
+            this.host.emit({
+                type: "code.list_files.response",
+                payload: { cwd, files, truncated, error: null, requestId: request.requestId },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd }, `Failed to list files for workspace ${cwd}`);
+            this.host.emit({
+                type: "code.list_files.response",
+                payload: {
+                    cwd,
+                    files: [],
+                    truncated: false,
+                    error: getErrorMessage(error),
+                    requestId: request.requestId,
+                },
+            });
+        }
+    }
+    async handleCodeSymbolsRequest(request) {
+        const cwd = request.cwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "code.symbols.response",
+                payload: {
+                    cwd: request.cwd,
+                    name: request.name,
+                    locations: [],
+                    error: "cwd is required",
+                    requestId: request.requestId,
+                },
+            });
+            return;
+        }
+        try {
+            const locations = await this.symbolIndex.findSymbol(cwd, request.name);
+            this.host.emit({
+                type: "code.symbols.response",
+                payload: { cwd, name: request.name, locations, error: null, requestId: request.requestId },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, name: request.name }, `Failed to resolve symbol for workspace ${cwd}`);
+            this.host.emit({
+                type: "code.symbols.response",
+                payload: {
+                    cwd,
+                    name: request.name,
+                    locations: [],
+                    error: getErrorMessage(error),
+                    requestId: request.requestId,
+                },
+            });
+        }
+    }
+    async handleCodeOutlineRequest(request) {
+        const cwd = request.cwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "code.outline.response",
+                payload: {
+                    cwd: request.cwd,
+                    path: request.path,
+                    symbols: [],
+                    error: "cwd is required",
+                    requestId: request.requestId,
+                },
+            });
+            return;
+        }
+        try {
+            const symbols = await getFileOutline(cwd, request.path);
+            this.host.emit({
+                type: "code.outline.response",
+                payload: { cwd, path: request.path, symbols, error: null, requestId: request.requestId },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: request.path }, `Failed to build outline for workspace ${cwd}`);
+            this.host.emit({
+                type: "code.outline.response",
+                payload: {
+                    cwd,
+                    path: request.path,
+                    symbols: [],
+                    error: getErrorMessage(error),
+                    requestId: request.requestId,
+                },
+            });
+        }
+    }
+    handleFileUploadRequest(request) {
+        this.fileUploads.beginUpload(request);
+    }
+    async handleFileTransferFrame(frame) {
+        const response = await this.fileUploads.receiveFrame(frame);
+        if (response) {
+            this.host.emit(response);
+        }
+    }
+    async handleProjectIconRequest(request) {
+        const { cwd, requestId } = request;
+        try {
+            const icon = await getProjectIcon(cwd);
+            this.host.emit({
+                type: "project_icon_response",
+                payload: {
+                    cwd,
+                    icon,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "project_icon_response",
+                payload: {
+                    cwd,
+                    icon: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleFileDownloadTokenRequest(request) {
+        const { cwd: workspaceCwd, path: requestedPath, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd: workspaceCwd,
+                    path: requestedPath,
+                    token: null,
+                    fileName: null,
+                    mimeType: null,
+                    size: null,
+                    error: "cwd is required",
+                    requestId,
+                },
+            });
+            return;
+        }
+        this.logger.debug({ cwd, path: requestedPath }, `Handling file download token request for workspace ${cwd} (${requestedPath})`);
+        try {
+            const info = await getDownloadableFileInfo({
+                root: cwd,
+                relativePath: requestedPath,
+            });
+            const entry = this.downloadTokenStore.issueToken({
+                path: info.path,
+                absolutePath: info.absolutePath,
+                fileName: info.fileName,
+                mimeType: info.mimeType,
+                size: info.size,
+            });
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd,
+                    path: info.path,
+                    token: entry.token,
+                    fileName: entry.fileName,
+                    mimeType: entry.mimeType,
+                    size: entry.size,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to issue download token for workspace ${cwd}`);
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd,
+                    path: requestedPath,
+                    token: null,
+                    fileName: null,
+                    mimeType: null,
+                    size: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+}
+//# sourceMappingURL=workspace-files-session.js.map

package/dist/server/server/session/git-mutation/git-mutation-service.d.ts

@@ -0,0 +1,34 @@
+import type pino from "pino";
+import type { GitHubService } from "../../../services/github-service.js";
+import { type CheckoutExistingBranchResult, type GitMutationRefreshReason } from "../../../utils/checkout-git.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+/**
+ * The git branch / working-tree mutation primitives a client session performs on a
+ * workspace: switch to an existing branch, create a branch from a base, and force a
+ * snapshot refresh (plus optional GitHub cache invalidation) after any mutation.
+ *
+ * CheckoutSession (the branch/commit/merge commands), the worktree session-config
+ * builder, and the auto-naming + worktree-creation paths all funnel their git
+ * mutations through this one module, so the validate-ref → clean-tree → execute →
+ * refresh sequence lives in a single place instead of being smeared across the
+ * session as loose callbacks.
+ */
+export interface GitMutationService {
+    checkoutExistingBranch(cwd: string, branch: string): Promise<CheckoutExistingBranchResult>;
+    createBranchFromBase(params: {
+        cwd: string;
+        baseBranch: string;
+        newBranchName: string;
+    }): Promise<void>;
+    notifyGitMutation(cwd: string, reason: GitMutationRefreshReason, options?: {
+        invalidateGithub?: boolean;
+    }): Promise<void>;
+}
+type GitMutationGitSource = Pick<WorkspaceGitService, "validateBranchRef" | "getSnapshot" | "hasLocalBranch">;
+export declare function createGitMutationService(deps: {
+    workspaceGitService: GitMutationGitSource;
+    github: Pick<GitHubService, "invalidate">;
+    logger: pino.Logger;
+}): GitMutationService;
+export {};
+//# sourceMappingURL=git-mutation-service.d.ts.map

package/dist/server/server/session/git-mutation/git-mutation-service.js

@@ -0,0 +1,71 @@
+import { getErrorMessage } from "@otto-code/protocol/error-utils";
+import { checkoutResolvedBranch, } from "../../../utils/checkout-git.js";
+import { execCommand } from "../../../utils/spawn.js";
+import { assertSafeGitRef as assertWorktreeSafeGitRef } from "../../worktree-session.js";
+export function createGitMutationService(deps) {
+    const { workspaceGitService, github, logger } = deps;
+    function assertSafeGitRef(ref, label) {
+        if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
+            throw new Error(`Invalid ${label}: ${ref}`);
+        }
+        assertWorktreeSafeGitRef(ref, label);
+    }
+    async function isWorkingTreeDirty(cwd) {
+        try {
+            const snapshot = await workspaceGitService.getSnapshot(cwd);
+            return snapshot.git.isDirty === true;
+        }
+        catch (error) {
+            throw new Error(`Unable to inspect git status for ${cwd}: ${getErrorMessage(error)}`, {
+                cause: error,
+            });
+        }
+    }
+    async function ensureCleanWorkingTree(cwd) {
+        const dirty = await isWorkingTreeDirty(cwd);
+        if (dirty) {
+            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
+        }
+    }
+    async function notifyGitMutation(cwd, reason, options) {
+        if (options?.invalidateGithub) {
+            github.invalidate({ cwd });
+        }
+        try {
+            await workspaceGitService.getSnapshot(cwd, { force: true, reason });
+        }
+        catch (error) {
+            logger.warn({ err: error, cwd, reason }, "Failed to force-refresh workspace git snapshot after mutation");
+        }
+    }
+    return {
+        async checkoutExistingBranch(cwd, branch) {
+            assertSafeGitRef(branch, "branch");
+            const resolution = await workspaceGitService.validateBranchRef(cwd, branch);
+            if (resolution.kind === "not-found") {
+                throw new Error(`Branch not found: ${branch}`);
+            }
+            await ensureCleanWorkingTree(cwd);
+            const result = await checkoutResolvedBranch({ cwd, resolution });
+            await notifyGitMutation(cwd, "switch-branch", { invalidateGithub: true });
+            return result;
+        },
+        async createBranchFromBase({ cwd, baseBranch, newBranchName }) {
+            assertSafeGitRef(baseBranch, "base branch");
+            assertSafeGitRef(newBranchName, "new branch");
+            const baseResolution = await workspaceGitService.validateBranchRef(cwd, baseBranch);
+            if (baseResolution.kind === "not-found") {
+                throw new Error(`Base branch not found: ${baseBranch}`);
+            }
+            const exists = await workspaceGitService.hasLocalBranch(cwd, newBranchName);
+            if (exists) {
+                throw new Error(`Branch already exists: ${newBranchName}`);
+            }
+            await ensureCleanWorkingTree(cwd);
+            await execCommand("git", ["checkout", "-b", newBranchName, baseBranch], { cwd });
+            await notifyGitMutation(cwd, "create-branch");
+        },
+        notifyGitMutation,
+    };
+}
+//# sourceMappingURL=git-mutation-service.js.map