@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/files/workspace-files-session.d.ts

@@ -0,0 +1,43 @@
+import type pino from "pino";
+import { type FileTransferFrame } from "@bytetrue/byspace-protocol/binary-frames/index";
+import type { FileDownloadTokenRequest, FileExplorerRequest, FileUploadRequest, 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;
+    byspaceHome: string;
+    logger: pino.Logger;
+}
+/**
+ * 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;
+    constructor(options: WorkspaceFilesSessionOptions);
+    handleFileExplorerRequest(request: FileExplorerRequest): 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/node_modules/@bytetrue/byspace-server/dist/server/server/session/files/workspace-files-session.js

@@ -0,0 +1,218 @@
+import { getErrorMessage } from "@bytetrue/byspace-protocol/error-utils";
+import { encodeFileTransferFrame, FileTransferOpcode, } from "@bytetrue/byspace-protocol/binary-frames/index";
+import { FileUploadStore } from "../../file-upload/index.js";
+import { getDownloadableFileInfo, listDirectoryEntries, readExplorerFile, readExplorerFileBytes, } from "../../file-explorer/service.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.host = options.host;
+        this.downloadTokenStore = options.downloadTokenStore;
+        this.logger = options.logger;
+        this.fileUploads = new FileUploadStore({ byspaceHome: options.byspaceHome });
+    }
+    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,
+                },
+            });
+        }
+    }
+    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/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/dist/server/server/session/git-mutation/git-mutation-service.js

@@ -0,0 +1,71 @@
+import { getErrorMessage } from "@bytetrue/byspace-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

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/project-config/project-config-session.d.ts

@@ -0,0 +1,34 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { ProjectRegistry } from "../../workspace-registry.js";
+export interface ProjectConfigSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+export interface ProjectConfigSessionOptions {
+    host: ProjectConfigSessionHost;
+    projectRegistry: Pick<ProjectRegistry, "list">;
+    logger: pino.Logger;
+}
+/**
+ * A client's read/write surface for a project's on-disk byspace.json. Resolves the
+ * request's repoRoot against the known (non-archived) project roots — accepting a
+ * trailing slash or a symlink via realpath — then reads or writes the config
+ * substrate and emits the matching response. Reaches no state beyond the injected
+ * project registry and the outbound channel.
+ */
+export declare class ProjectConfigSession {
+    private readonly host;
+    private readonly projectRegistry;
+    private readonly logger;
+    constructor(options: ProjectConfigSessionOptions);
+    handleReadProjectConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "read_project_config_request";
+    }>): Promise<void>;
+    handleWriteProjectConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "write_project_config_request";
+    }>): Promise<void>;
+    private emitProjectConfigReadFailure;
+    private emitProjectConfigWriteFailure;
+    private resolveKnownProjectRoot;
+}
+//# sourceMappingURL=project-config-session.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/project-config/project-config-session.js

@@ -0,0 +1,125 @@
+import { realpathSync } from "node:fs";
+import { resolve, sep } from "path";
+import { readBySpaceConfigForEdit, writeBySpaceConfigForEdit, } from "../../../utils/byspace-config-file.js";
+/**
+ * A client's read/write surface for a project's on-disk byspace.json. Resolves the
+ * request's repoRoot against the known (non-archived) project roots — accepting a
+ * trailing slash or a symlink via realpath — then reads or writes the config
+ * substrate and emits the matching response. Reaches no state beyond the injected
+ * project registry and the outbound channel.
+ */
+export class ProjectConfigSession {
+    constructor(options) {
+        this.host = options.host;
+        this.projectRegistry = options.projectRegistry;
+        this.logger = options.logger;
+    }
+    async handleReadProjectConfigRequest(msg) {
+        const repoRoot = await this.resolveKnownProjectRoot(msg.repoRoot);
+        if (!repoRoot) {
+            this.emitProjectConfigReadFailure(msg, { code: "project_not_found" });
+            return;
+        }
+        const result = readBySpaceConfigForEdit(repoRoot);
+        if (!result.ok) {
+            this.logger.warn({ repoRoot, requestId: msg.requestId, outcome: result.error.code }, "Failed to read project config");
+            this.emitProjectConfigReadFailure(msg, result.error, repoRoot);
+            return;
+        }
+        if (result.config === null) {
+            this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "missing_project_config" }, "Project config missing");
+        }
+        this.host.emit({
+            type: "read_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: true,
+                config: result.config,
+                revision: result.revision,
+            },
+        });
+    }
+    async handleWriteProjectConfigRequest(msg) {
+        const repoRoot = await this.resolveKnownProjectRoot(msg.repoRoot);
+        if (!repoRoot) {
+            this.emitProjectConfigWriteFailure(msg, { code: "project_not_found" });
+            return;
+        }
+        this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "write_attempt" }, "Writing project config");
+        const result = writeBySpaceConfigForEdit({
+            repoRoot,
+            config: msg.config,
+            expectedRevision: msg.expectedRevision,
+        });
+        if (!result.ok) {
+            this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: result.error.code }, "Project config write did not complete");
+            this.emitProjectConfigWriteFailure(msg, result.error, repoRoot);
+            return;
+        }
+        this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "written" }, "Project config written");
+        this.host.emit({
+            type: "write_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: true,
+                config: result.config,
+                revision: result.revision,
+            },
+        });
+    }
+    emitProjectConfigReadFailure(msg, error, repoRoot = msg.repoRoot) {
+        this.host.emit({
+            type: "read_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: false,
+                error,
+            },
+        });
+    }
+    emitProjectConfigWriteFailure(msg, error, repoRoot = msg.repoRoot) {
+        this.host.emit({
+            type: "write_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: false,
+                error,
+            },
+        });
+    }
+    async resolveKnownProjectRoot(repoRoot) {
+        const requestedRoot = canonicalizeConfigRoot(repoRoot);
+        const projects = await this.projectRegistry.list();
+        for (const project of projects) {
+            if (project.archivedAt !== null) {
+                continue;
+            }
+            const projectRoot = canonicalizeConfigRoot(project.rootPath);
+            if (requestedRoot === projectRoot) {
+                return projectRoot;
+            }
+        }
+        return null;
+    }
+}
+function canonicalizeConfigRoot(repoRoot) {
+    const resolved = resolve(repoRoot);
+    try {
+        return stripTrailingPathSeparators(realpathSync(resolved));
+    }
+    catch {
+        return stripTrailingPathSeparators(resolved);
+    }
+}
+function stripTrailingPathSeparators(path) {
+    let normalized = path;
+    while (normalized.length > 1 && normalized.endsWith(sep)) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+//# sourceMappingURL=project-config-session.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/provider/provider-catalog-session.d.ts

@@ -0,0 +1,74 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import { type ProviderSnapshotManager } from "../../agent/provider-snapshot-manager.js";
+import type { AgentFeature, AgentSessionConfig } from "../../agent/agent-sdk-types.js";
+import type { ProviderAvailability } from "../../agent/agent-manager.js";
+import type { ProviderUsageService } from "../../../services/quota-fetcher/service.js";
+/**
+ * The collaborators a provider-catalog request reaches that are NOT part of the
+ * provider domain. Two are CLIENT-COMPAT predicates the Session shell owns because
+ * agent-lifecycle shares the visibility gate: both read client state (appVersion /
+ * capabilities) LIVE, mutated post-construction via updateAppVersion /
+ * updateClientCapabilities. The two agent-control reads expose provider availability
+ * and draft features the AgentManager owns.
+ */
+export interface ProviderCatalogSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    isProviderVisibleToClient(provider: string): boolean;
+    supportsCustomModeIcons(): boolean;
+    listProviderAvailability(): Promise<ProviderAvailability[]>;
+    listDraftFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
+}
+export interface ProviderCatalogSessionOptions {
+    host: ProviderCatalogSessionHost;
+    providerSnapshotManager: ProviderSnapshotManager;
+    providerUsageService: ProviderUsageService;
+    logger: pino.Logger;
+}
+/**
+ * A client's provider catalog surface: model / mode / feature listing, the providers
+ * snapshot push + pull, provider diagnostics, and usage. The snapshot PUSH (start) and
+ * every PULL handler gate visibility and downgrade mode icons through the SAME predicates,
+ * so an older client sees one consistent provider set across both paths — the COMPAT
+ * invariant the shell could only enforce by code proximity before this carve.
+ */
+export declare class ProviderCatalogSession {
+    private readonly host;
+    private readonly providerSnapshotManager;
+    private readonly providerUsageService;
+    private readonly logger;
+    private unsubscribeSnapshotEvents;
+    constructor(options: ProviderCatalogSessionOptions);
+    start(): void;
+    dispose(): void;
+    private downgradeModeIconsForClient;
+    private downgradeEntryModesForClient;
+    private emitProviderDisabledResponse;
+    handleListProviderModelsRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_provider_models_request";
+    }>): Promise<void>;
+    handleListProviderModesRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_provider_modes_request";
+    }>): Promise<void>;
+    private getProviderSnapshotEntryForRead;
+    private buildDraftAgentSessionConfig;
+    handleListProviderFeaturesRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_provider_features_request";
+    }>): Promise<void>;
+    handleListAvailableProvidersRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_available_providers_request";
+    }>): Promise<void>;
+    handleGetProvidersSnapshotRequest(msg: Extract<SessionInboundMessage, {
+        type: "get_providers_snapshot_request";
+    }>): Promise<void>;
+    handleRefreshProvidersSnapshotRequest(msg: Extract<SessionInboundMessage, {
+        type: "refresh_providers_snapshot_request";
+    }>): Promise<void>;
+    handleProviderDiagnosticRequest(msg: Extract<SessionInboundMessage, {
+        type: "provider_diagnostic_request";
+    }>): Promise<void>;
+    handleProviderUsageListRequest(msg: Extract<SessionInboundMessage, {
+        type: "provider.usage.list.request";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=provider-catalog-session.d.ts.map