@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/checkout/git-metadata-generator.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { AgentManager } from "../../agent/agent-manager.js";
+import type { ProviderSnapshotManager } from "../../agent/provider-snapshot-manager.js";
+import { type ResolveStructuredGenerationProvidersOptions, type StructuredGenerationDaemonConfig } from "../../agent/structured-generation-providers.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+export interface PullRequestText {
+    title: string;
+    body: string;
+}
+/**
+ * Generates a workspace's commit message and pull-request text from its git diff
+ * via the agent LLM. The checkout subsystem is the only consumer; it owns the
+ * commit/PR commands and asks this for the wording when the user left it blank.
+ */
+export interface GitMetadataGenerator {
+    generateCommitMessage(cwd: string): Promise<string>;
+    generatePullRequestText(cwd: string, baseRef?: string): Promise<PullRequestText>;
+}
+/**
+ * The LLM boundary, injected so the generator's prompt-building and fallback
+ * behaviour is unit-testable with a fake. Production wires
+ * createAgentStructuredTextGeneration (resolve providers → run structured
+ * generation); a failed generation throws StructuredAgent*Error, which the
+ * generator catches and turns into the product fallback text.
+ */
+export interface StructuredTextGeneration {
+    generate<T>(request: StructuredTextGenerationRequest<T>): Promise<T>;
+}
+export interface StructuredTextGenerationRequest<T> {
+    cwd: string;
+    prompt: string;
+    schema: z.ZodType<T>;
+    schemaName: string;
+    agentTitle: string;
+}
+type GitMetadataDiffSource = Pick<WorkspaceGitService, "getCheckoutDiff" | "resolveRepoRoot">;
+export declare function createGitMetadataGenerator(deps: {
+    workspaceGitService: GitMetadataDiffSource;
+    generation: StructuredTextGeneration;
+}): GitMetadataGenerator;
+/**
+ * Production StructuredTextGeneration: resolve the structured-generation providers
+ * for the cwd, then run the agent with a 2-retry fallback as an internal,
+ * non-persisted session.
+ */
+export declare function createAgentStructuredTextGeneration(deps: {
+    agentManager: AgentManager;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    readDaemonConfig: () => StructuredGenerationDaemonConfig;
+    getFocusedSelection: (cwd: string) => ResolveStructuredGenerationProvidersOptions["currentSelection"];
+}): StructuredTextGeneration;
+export {};
+//# sourceMappingURL=git-metadata-generator.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/checkout/git-metadata-generator.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "../../agent/agent-response-loop.js";
+import { resolveStructuredGenerationProviders, } from "../../agent/structured-generation-providers.js";
+import { buildMetadataPrompt, } from "../../../utils/build-metadata-prompt.js";
+const COMMIT_MESSAGE_SCHEMA = z.object({
+    message: z
+        .string()
+        .min(1)
+        .max(72)
+        .describe("Concise git commit message, imperative mood, no trailing period."),
+});
+const PULL_REQUEST_SCHEMA = z.object({
+    title: z.string().min(1).max(72),
+    body: z.string().min(1),
+});
+const COMMIT_MESSAGE_FALLBACK = "Update files";
+const PULL_REQUEST_FALLBACK = {
+    title: "Update changes",
+    body: "Automated PR generated by BySpace.",
+};
+const MAX_COMMIT_PATCH_CHARS = 120000;
+const MAX_PULL_REQUEST_PATCH_CHARS = 200000;
+export function createGitMetadataGenerator(deps) {
+    const { workspaceGitService, generation } = deps;
+    async function buildPromptForDiff(input) {
+        const diff = await workspaceGitService.getCheckoutDiff(input.cwd, input.diffOptions);
+        const fileList = renderFileList(diff.structured);
+        const patch = truncatePatch(diff.diff, input.maxPatchChars);
+        return buildMetadataPrompt({
+            cwd: input.cwd,
+            workspaceGitService,
+            contract: input.contract,
+            styles: [{ configKey: input.styleConfigKey, default: input.styleDefault }],
+            after: [
+                input.jsonFieldsHint,
+                "",
+                fileList,
+                "",
+                patch.length > 0 ? patch : "(No diff available)",
+            ].join("\n"),
+        });
+    }
+    return {
+        async generateCommitMessage(cwd) {
+            const prompt = await buildPromptForDiff({
+                cwd,
+                diffOptions: { mode: "uncommitted", includeStructured: true },
+                maxPatchChars: MAX_COMMIT_PATCH_CHARS,
+                contract: "Write a concise git commit message for the changes below.",
+                styleConfigKey: "commitMessage",
+                styleDefault: "Concise, imperative mood, no trailing period.",
+                jsonFieldsHint: "Return JSON only with a single field 'message'.",
+            });
+            try {
+                const result = await generation.generate({
+                    cwd,
+                    prompt,
+                    schema: COMMIT_MESSAGE_SCHEMA,
+                    schemaName: "CommitMessage",
+                    agentTitle: "Commit generator",
+                });
+                return result.message;
+            }
+            catch (error) {
+                if (isStructuredGenerationFailure(error)) {
+                    return COMMIT_MESSAGE_FALLBACK;
+                }
+                throw error;
+            }
+        },
+        async generatePullRequestText(cwd, baseRef) {
+            const prompt = await buildPromptForDiff({
+                cwd,
+                diffOptions: { mode: "base", baseRef, includeStructured: true },
+                maxPatchChars: MAX_PULL_REQUEST_PATCH_CHARS,
+                contract: "Write a pull request title and body for the changes below.",
+                styleConfigKey: "pullRequest",
+                styleDefault: "Clear, descriptive title; body explaining what changed and why.",
+                jsonFieldsHint: "Return JSON only with fields 'title' and 'body'.",
+            });
+            try {
+                return await generation.generate({
+                    cwd,
+                    prompt,
+                    schema: PULL_REQUEST_SCHEMA,
+                    schemaName: "PullRequest",
+                    agentTitle: "PR generator",
+                });
+            }
+            catch (error) {
+                if (isStructuredGenerationFailure(error)) {
+                    return PULL_REQUEST_FALLBACK;
+                }
+                throw error;
+            }
+        },
+    };
+}
+/**
+ * Production StructuredTextGeneration: resolve the structured-generation providers
+ * for the cwd, then run the agent with a 2-retry fallback as an internal,
+ * non-persisted session.
+ */
+export function createAgentStructuredTextGeneration(deps) {
+    return {
+        async generate({ cwd, prompt, schema, schemaName, agentTitle }) {
+            const providers = await resolveStructuredGenerationProviders({
+                cwd,
+                providerSnapshotManager: deps.providerSnapshotManager,
+                daemonConfig: deps.readDaemonConfig(),
+                currentSelection: deps.getFocusedSelection(cwd),
+            });
+            return generateStructuredAgentResponseWithFallback({
+                manager: deps.agentManager,
+                cwd,
+                prompt,
+                schema,
+                schemaName,
+                maxRetries: 2,
+                providers,
+                persistSession: false,
+                agentConfigOverrides: {
+                    title: agentTitle,
+                    internal: true,
+                },
+            });
+        },
+    };
+}
+function renderFileList(structured) {
+    if (!structured || structured.length === 0) {
+        return "Files changed: (unknown)";
+    }
+    return [
+        "Files changed:",
+        ...structured.map((file) => {
+            const changeType = diffChangeTypeFor(file);
+            const status = file.status && file.status !== "ok" ? ` [${file.status}]` : "";
+            return `${changeType}\t${file.path}\t(+${file.additions} -${file.deletions})${status}`;
+        }),
+    ].join("\n");
+}
+function truncatePatch(patch, maxPatchChars) {
+    if (patch.length <= maxPatchChars) {
+        return patch;
+    }
+    return `${patch.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`;
+}
+function diffChangeTypeFor(file) {
+    if (file.isNew)
+        return "A";
+    if (file.isDeleted)
+        return "D";
+    return "M";
+}
+function isStructuredGenerationFailure(error) {
+    return (error instanceof StructuredAgentResponseError || error instanceof StructuredAgentFallbackError);
+}
+//# sourceMappingURL=git-metadata-generator.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/daemon/daemon-self-update-session-controller.d.ts

@@ -0,0 +1,32 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import { type DaemonSelfUpdater } from "./daemon-self-updater.js";
+interface DaemonSelfUpdateRestartIntent {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason: string;
+}
+export interface DaemonSelfUpdateSessionControllerOptions {
+    clientId: string;
+    daemonVersion: string | null;
+    emit: (msg: SessionOutboundMessage) => void;
+    emitLifecycleIntent: (intent: DaemonSelfUpdateRestartIntent) => void;
+    sessionLogger: pino.Logger;
+    updater?: Pick<DaemonSelfUpdater, "update">;
+}
+export declare class DaemonSelfUpdateSessionController {
+    private readonly clientId;
+    private readonly daemonVersion;
+    private readonly emit;
+    private readonly emitLifecycleIntent;
+    private readonly sessionLogger;
+    private readonly updater;
+    constructor(options: DaemonSelfUpdateSessionControllerOptions);
+    dispatch(msg: SessionInboundMessage): Promise<void> | undefined;
+    private handleDaemonUpdateRequest;
+    private emitProgress;
+    private emitResponse;
+}
+export {};
+//# sourceMappingURL=daemon-self-update-session-controller.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/daemon/daemon-self-update-session-controller.js

@@ -0,0 +1,88 @@
+import { daemonSelfUpdater, DaemonSelfUpdateInProgressError, } from "./daemon-self-updater.js";
+import { getErrorMessage } from "@bytetrue/byspace-protocol/error-utils";
+const DAEMON_SELF_UPDATE_MESSAGE_TYPES = new Set([
+    "daemon.update.request",
+]);
+function isDaemonSelfUpdateMessage(msg) {
+    return DAEMON_SELF_UPDATE_MESSAGE_TYPES.has(msg.type);
+}
+export class DaemonSelfUpdateSessionController {
+    constructor(options) {
+        this.clientId = options.clientId;
+        this.daemonVersion = options.daemonVersion;
+        this.emit = options.emit;
+        this.emitLifecycleIntent = options.emitLifecycleIntent;
+        this.sessionLogger = options.sessionLogger;
+        this.updater = options.updater ?? daemonSelfUpdater;
+    }
+    dispatch(msg) {
+        if (!isDaemonSelfUpdateMessage(msg)) {
+            return undefined;
+        }
+        return this.handleDaemonUpdateRequest(msg);
+    }
+    async handleDaemonUpdateRequest(msg) {
+        const previousVersion = this.daemonVersion;
+        try {
+            const result = await this.updater.update({
+                daemonVersion: previousVersion,
+                onProgress: (phase) => this.emitProgress(msg.requestId, phase),
+                logger: this.sessionLogger,
+            });
+            this.emitResponse({
+                requestId: msg.requestId,
+                success: result.success,
+                error: result.error,
+                previousVersion,
+                newVersion: result.newVersion,
+            });
+            if (!result.success) {
+                return;
+            }
+            this.emitLifecycleIntent({
+                type: "restart",
+                clientId: this.clientId,
+                requestId: msg.requestId,
+                reason: "daemon_update",
+            });
+        }
+        catch (error) {
+            if (error instanceof DaemonSelfUpdateInProgressError) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId: msg.requestId,
+                        requestType: "daemon.update.request",
+                        error: error.message,
+                        code: "already_updating",
+                    },
+                });
+                return;
+            }
+            this.sessionLogger.error({ err: error }, "Daemon update failed with exception");
+            this.emitResponse({
+                requestId: msg.requestId,
+                success: false,
+                error: getErrorMessage(error),
+                previousVersion,
+                newVersion: null,
+            });
+        }
+    }
+    emitProgress(requestId, phase) {
+        this.emit({
+            type: "daemon.update.progress",
+            payload: {
+                requestId,
+                phase,
+            },
+        });
+    }
+    emitResponse(payload) {
+        this.emit({
+            type: "daemon.update.response",
+            payload,
+        });
+    }
+}
+//# sourceMappingURL=daemon-self-update-session-controller.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/daemon/daemon-self-updater.d.ts

@@ -0,0 +1,32 @@
+import { type DaemonInstallOriginRuntime } from "./install-origin.js";
+import { type NpmGlobalBySpaceCli } from "./npm-global-cli.js";
+export type DaemonSelfUpdatePhase = "starting" | "downloading" | "installing" | "complete";
+export interface DaemonSelfUpdateResult {
+    success: boolean;
+    error: string | null;
+    newVersion: string | null;
+}
+export interface DaemonSelfUpdateInput {
+    daemonVersion: string | null;
+    onProgress: (phase: DaemonSelfUpdatePhase) => void;
+    logger: DaemonSelfUpdateLogger;
+}
+export interface DaemonSelfUpdateLogger {
+    error(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+}
+export interface DaemonSelfUpdateRuntime {
+    npm: NpmGlobalBySpaceCli;
+    installOrigin: DaemonInstallOriginRuntime;
+}
+export declare class DaemonSelfUpdateInProgressError extends Error {
+    constructor();
+}
+export declare class DaemonSelfUpdater {
+    private readonly runtime;
+    private inProgress;
+    constructor(runtime?: DaemonSelfUpdateRuntime);
+    update(input: DaemonSelfUpdateInput): Promise<DaemonSelfUpdateResult>;
+}
+export declare const daemonSelfUpdater: DaemonSelfUpdater;
+//# sourceMappingURL=daemon-self-updater.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/session/daemon/daemon-self-updater.js

@@ -0,0 +1,56 @@
+import { getErrorMessage } from "@bytetrue/byspace-protocol/error-utils";
+import { daemonInstallOriginRuntime, validateDaemonInstallOrigin, } from "./install-origin.js";
+import { npmGlobalBySpaceCli } from "./npm-global-cli.js";
+export class DaemonSelfUpdateInProgressError extends Error {
+    constructor() {
+        super("An update is already in progress");
+        this.name = "DaemonSelfUpdateInProgressError";
+    }
+}
+const defaultRuntime = {
+    npm: npmGlobalBySpaceCli,
+    installOrigin: daemonInstallOriginRuntime,
+};
+export class DaemonSelfUpdater {
+    constructor(runtime = defaultRuntime) {
+        this.runtime = runtime;
+        this.inProgress = false;
+    }
+    async update(input) {
+        if (this.inProgress) {
+            throw new DaemonSelfUpdateInProgressError();
+        }
+        this.inProgress = true;
+        try {
+            input.onProgress("starting");
+            const install = await this.runtime.npm.inspect();
+            const unsupportedReason = validateDaemonInstallOrigin(install, input.daemonVersion, this.runtime.installOrigin);
+            if (unsupportedReason) {
+                return { success: false, error: unsupportedReason, newVersion: null };
+            }
+            input.onProgress("downloading");
+            input.onProgress("installing");
+            const result = await this.runtime.npm.installLatest();
+            if (result.exitCode !== 0) {
+                const error = result.stderr.trim() || result.stdout.trim() || `npm exited with code ${result.exitCode}`;
+                input.logger.error({ exitCode: result.exitCode, stderr: result.stderr }, "Daemon self-update failed");
+                return { success: false, error, newVersion: null };
+            }
+            const updatedInstall = await this.runtime.npm.inspect().catch((error) => {
+                input.logger.warn({ err: error }, "Unable to read updated npm package version");
+                return null;
+            });
+            input.onProgress("complete");
+            return { success: true, error: null, newVersion: updatedInstall?.version ?? null };
+        }
+        catch (error) {
+            input.logger.error({ err: error }, "Daemon self-update failed with exception");
+            return { success: false, error: getErrorMessage(error), newVersion: null };
+        }
+        finally {
+            this.inProgress = false;
+        }
+    }
+}
+export const daemonSelfUpdater = new DaemonSelfUpdater();
+//# sourceMappingURL=daemon-self-updater.js.map

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

@@ -0,0 +1,76 @@
+import type pino from "pino";
+import type { ProviderAvailability } from "../../agent/agent-manager.js";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import { type DaemonWebSocketRuntimeDiagnosticSnapshot } from "./diagnostics.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import type { PersistedProjectRecord, PersistedWorkspaceRecord } from "../../workspace-registry.js";
+export interface DaemonRuntimeConfig {
+    listen: string | null;
+    appBaseUrl?: string;
+    relay: {
+        enabled: boolean;
+        endpoint: string;
+        publicEndpoint: string;
+        useTls: boolean;
+        publicUseTls: boolean;
+    } | null;
+}
+export interface DaemonSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    emitLifecycleIntent(intent: {
+        type: "restart";
+        clientId: string;
+        requestId: string;
+        reason: string;
+    }): void;
+}
+export interface DaemonSessionOptions {
+    host: DaemonSessionHost;
+    clientId: string;
+    byspaceHome: string;
+    serverId: string | undefined;
+    daemonVersion: string | undefined;
+    daemonRuntimeConfig: DaemonRuntimeConfig | undefined;
+    listAgents: () => ManagedAgent[];
+    listProjects: () => Promise<PersistedProjectRecord[]>;
+    listWorkspaces: () => Promise<PersistedWorkspaceRecord[]>;
+    listProviderAvailability: () => Promise<ProviderAvailability[]>;
+    getWebSocketRuntimeMetrics?: () => DaemonWebSocketRuntimeDiagnosticSnapshot | null;
+    logger: pino.Logger;
+}
+/**
+ * A client's read surface for the daemon process itself: its runtime status
+ * (pid-lock start time, listen address, relay config, provider availability) and
+ * a fresh local pairing offer for connecting a new client. Owns the `daemon.*`
+ * RPCs. Reaches no state beyond the never-mutated runtime values injected at
+ * construction and the outbound channel.
+ */
+export declare class DaemonSession {
+    private readonly host;
+    private readonly clientId;
+    private readonly byspaceHome;
+    private readonly serverId;
+    private readonly daemonVersion;
+    private readonly daemonRuntimeConfig;
+    private readonly listAgents;
+    private readonly listProjects;
+    private readonly listWorkspaces;
+    private readonly listProviderAvailability;
+    private readonly getWebSocketRuntimeMetrics;
+    private readonly logger;
+    private readonly selfUpdate;
+    constructor(options: DaemonSessionOptions);
+    handleGetStatusRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.get_status.request";
+    }>): Promise<void>;
+    handleGetPairingOfferRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.get_pairing_offer.request";
+    }>): Promise<void>;
+    handleDiagnosticsRequest(msg: Extract<SessionInboundMessage, {
+        type: "diagnostics.request";
+    }>): Promise<void>;
+    handleUpdateRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.update.request";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=daemon-session.d.ts.map

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

@@ -0,0 +1,148 @@
+import { getPidLockInfo } from "../../pid-lock.js";
+import { generateLocalPairingOffer } from "../../pairing-offer.js";
+import { collectDaemonDiagnostics, } from "./diagnostics.js";
+import { DaemonSelfUpdateSessionController } from "./daemon-self-update-session-controller.js";
+/**
+ * A client's read surface for the daemon process itself: its runtime status
+ * (pid-lock start time, listen address, relay config, provider availability) and
+ * a fresh local pairing offer for connecting a new client. Owns the `daemon.*`
+ * RPCs. Reaches no state beyond the never-mutated runtime values injected at
+ * construction and the outbound channel.
+ */
+export class DaemonSession {
+    constructor(options) {
+        this.host = options.host;
+        this.clientId = options.clientId;
+        this.byspaceHome = options.byspaceHome;
+        this.serverId = options.serverId;
+        this.daemonVersion = options.daemonVersion;
+        this.daemonRuntimeConfig = options.daemonRuntimeConfig;
+        this.listAgents = options.listAgents;
+        this.listProjects = options.listProjects;
+        this.listWorkspaces = options.listWorkspaces;
+        this.listProviderAvailability = options.listProviderAvailability;
+        this.getWebSocketRuntimeMetrics = options.getWebSocketRuntimeMetrics ?? (() => null);
+        this.logger = options.logger;
+        this.selfUpdate = new DaemonSelfUpdateSessionController({
+            clientId: this.clientId,
+            daemonVersion: this.daemonVersion ?? null,
+            emit: (msg) => this.host.emit(msg),
+            emitLifecycleIntent: (intent) => this.host.emitLifecycleIntent(intent),
+            sessionLogger: this.logger,
+        });
+    }
+    async handleGetStatusRequest(msg) {
+        try {
+            const pidInfo = await getPidLockInfo(this.byspaceHome);
+            const providers = (await this.listProviderAvailability()).map((p) => ({
+                provider: p.provider,
+                available: p.available,
+                error: p.error ?? null,
+            }));
+            this.host.emit({
+                type: "daemon.get_status.response",
+                payload: {
+                    requestId: msg.requestId,
+                    serverId: this.serverId ?? "",
+                    version: this.daemonVersion ?? null,
+                    pid: process.pid,
+                    nodePath: process.execPath,
+                    startedAt: pidInfo?.startedAt ?? null,
+                    listen: this.daemonRuntimeConfig?.listen ?? null,
+                    relay: this.daemonRuntimeConfig?.relay ?? null,
+                    providers,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle daemon status request");
+            this.host.emit({
+                type: "daemon.get_status.response",
+                payload: {
+                    requestId: msg.requestId,
+                    serverId: this.serverId ?? "",
+                    version: this.daemonVersion ?? null,
+                    pid: process.pid,
+                    nodePath: process.execPath,
+                    startedAt: null,
+                    listen: null,
+                    relay: null,
+                    providers: [],
+                },
+            });
+        }
+    }
+    async handleGetPairingOfferRequest(msg) {
+        try {
+            const relay = this.daemonRuntimeConfig?.relay;
+            const pairing = await generateLocalPairingOffer({
+                byspaceHome: this.byspaceHome,
+                relayEnabled: relay?.enabled ?? true,
+                relayEndpoint: relay?.endpoint,
+                relayPublicEndpoint: relay?.publicEndpoint,
+                relayUseTls: relay?.useTls,
+                relayPublicUseTls: relay?.publicUseTls,
+                appBaseUrl: this.daemonRuntimeConfig?.appBaseUrl,
+                includeQr: true,
+                logger: this.logger,
+            });
+            this.host.emit({
+                type: "daemon.get_pairing_offer.response",
+                payload: {
+                    requestId: msg.requestId,
+                    url: pairing.url ?? "",
+                    qr: pairing.qr ?? null,
+                    relayEnabled: pairing.relayEnabled,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle daemon pairing offer request");
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: "daemon.get_pairing_offer.request",
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    async handleDiagnosticsRequest(msg) {
+        try {
+            const diagnostic = await collectDaemonDiagnostics({
+                byspaceHome: this.byspaceHome,
+                serverId: this.serverId,
+                daemonVersion: this.daemonVersion,
+                daemonRuntimeConfig: this.daemonRuntimeConfig,
+                listAgents: this.listAgents,
+                listProjects: this.listProjects,
+                listWorkspaces: this.listWorkspaces,
+                listProviderAvailability: this.listProviderAvailability,
+                getWebSocketRuntimeMetrics: this.getWebSocketRuntimeMetrics,
+                logger: this.logger,
+            });
+            this.host.emit({
+                type: "diagnostics.response",
+                payload: {
+                    requestId: msg.requestId,
+                    diagnostic,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle diagnostics request");
+            this.host.emit({
+                type: "diagnostics.response",
+                payload: {
+                    requestId: msg.requestId,
+                    diagnostic: `BySpace diagnostics\n  Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            });
+        }
+    }
+    async handleUpdateRequest(msg) {
+        await this.selfUpdate.dispatch(msg);
+    }
+}
+//# sourceMappingURL=daemon-session.js.map