@getpaseo/server 0.1.99 → 0.1.101

package/dist/server/server/session/checkout/checkout-session.js

@@ -14,16 +14,18 @@ import { expandTilde } from "../../../utils/path.js";
  * merge/pull/push/stash and the GitHub-PR operations).
  *
  * Command operations keep the live diff in sync by calling scheduleDiffRefresh()
- * and refresh the workspace git snapshot through host.notifyGitMutation(); the
+ * and refresh the workspace git snapshot through gitMutation.notifyGitMutation(); the
  * workspace git observer streams branch changes through emitStatusUpdate().
  */
 export class CheckoutSession {
     constructor(options) {
         this.diffSubscriptions = new Map();
         this.host = options.host;
+        this.gitMutation = options.gitMutation;
         this.workspaceGitService = options.workspaceGitService;
         this.github = options.github;
         this.checkoutDiffManager = options.checkoutDiffManager;
+        this.gitMetadataGenerator = options.gitMetadataGenerator;
         this.paseoHome = options.paseoHome;
         this.worktreesRoot = options.worktreesRoot;
         this.logger = options.logger;
@@ -252,7 +254,7 @@ export class CheckoutSession {
     async handleCheckoutSwitchBranchRequest(msg) {
         const { cwd, branch, requestId } = msg;
         try {
-            const checkoutResult = await this.host.checkoutExistingBranch(cwd, branch);
+            const checkoutResult = await this.gitMutation.checkoutExistingBranch(cwd, branch);
             this.scheduleDiffRefresh(cwd);
             // Push a workspace_update immediately so the sidebar/header reflect
             // the new branch name without waiting for the background git watcher.
@@ -300,7 +302,7 @@ export class CheckoutSession {
         }
         try {
             const result = await this.host.renameCurrentBranch(cwd, branch);
-            await this.host.notifyGitMutation(cwd, "rename-branch", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "rename-branch", { invalidateGithub: true });
             this.scheduleDiffRefresh(cwd);
             this.host.handleWorkspaceGitBranchSnapshot(cwd, result.currentBranch);
             // Branch is a git fact derived per-descriptor from each workspace's own
@@ -344,7 +346,7 @@ export class CheckoutSession {
             await execCommand("git", ["stash", "push", "--include-untracked", "-m", message], {
                 cwd,
             });
-            await this.host.notifyGitMutation(cwd, "stash-push");
+            await this.gitMutation.notifyGitMutation(cwd, "stash-push");
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "stash_save_response",
@@ -364,7 +366,7 @@ export class CheckoutSession {
             await execCommand("git", ["stash", "pop", `stash@{${stashIndex}}`], {
                 cwd,
             });
-            await this.host.notifyGitMutation(cwd, "stash-pop");
+            await this.gitMutation.notifyGitMutation(cwd, "stash-pop");
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "stash_pop_response",
@@ -400,7 +402,7 @@ export class CheckoutSession {
         try {
             let message = msg.message?.trim() ?? "";
             if (!message) {
-                message = await this.host.generateCommitMessage(cwd);
+                message = await this.gitMetadataGenerator.generateCommitMessage(cwd);
             }
             if (!message) {
                 throw new Error("Commit message is required");
@@ -409,7 +411,7 @@ export class CheckoutSession {
                 message,
                 addAll: msg.addAll ?? true,
             });
-            await this.host.notifyGitMutation(cwd, "commit-changes");
+            await this.gitMutation.notifyGitMutation(cwd, "commit-changes");
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "checkout_commit_response",
@@ -457,8 +459,8 @@ export class CheckoutSession {
                 mode: msg.strategy === "squash" ? "squash" : "merge",
             }, { paseoHome: this.paseoHome, worktreesRoot: this.worktreesRoot });
             await Promise.all([
-                this.host.notifyGitMutation(mutatedCwd, "merge-to-base", { invalidateGithub: true }),
-                ...(mutatedCwd !== cwd ? [this.host.notifyGitMutation(cwd, "merge-to-base")] : []),
+                this.gitMutation.notifyGitMutation(mutatedCwd, "merge-to-base", { invalidateGithub: true }),
+                ...(mutatedCwd !== cwd ? [this.gitMutation.notifyGitMutation(cwd, "merge-to-base")] : []),
             ]);
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
@@ -496,7 +498,7 @@ export class CheckoutSession {
                 baseRef: msg.baseRef,
                 requireCleanTarget: msg.requireCleanTarget ?? true,
             });
-            await this.host.notifyGitMutation(cwd, "merge-from-base", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "merge-from-base", { invalidateGithub: true });
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "checkout_merge_from_base_response",
@@ -524,7 +526,7 @@ export class CheckoutSession {
         const { cwd, requestId } = msg;
         try {
             await pullCurrentBranch(cwd);
-            await this.host.notifyGitMutation(cwd, "pull", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "pull", { invalidateGithub: true });
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "checkout_pull_response",
@@ -552,7 +554,7 @@ export class CheckoutSession {
         const { cwd, requestId } = msg;
         try {
             await pushCurrentBranch(cwd);
-            await this.host.notifyGitMutation(cwd, "push", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "push", { invalidateGithub: true });
             this.host.emit({
                 type: "checkout_push_response",
                 payload: {
@@ -581,7 +583,7 @@ export class CheckoutSession {
             let title = msg.title?.trim() ?? "";
             let body = msg.body?.trim() ?? "";
             if (!title || !body) {
-                const generated = await this.host.generatePullRequestText(cwd, msg.baseRef);
+                const generated = await this.gitMetadataGenerator.generatePullRequestText(cwd, msg.baseRef);
                 if (!title)
                     title = generated.title;
                 if (!body)
@@ -592,7 +594,7 @@ export class CheckoutSession {
                 body,
                 base: msg.baseRef,
             }, this.github);
-            await this.host.notifyGitMutation(cwd, "create-pr", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "create-pr", { invalidateGithub: true });
             this.host.emit({
                 type: "checkout_pr_create_response",
                 payload: {
@@ -632,7 +634,7 @@ export class CheckoutSession {
                 mergeMethod: msg.mergeMethod,
                 status: pullRequest,
             });
-            await this.host.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
             this.host.emit({
                 type: "checkout_pr_merge_response",
                 payload: {
@@ -695,7 +697,7 @@ export class CheckoutSession {
                     status: pullRequest,
                 });
             }
-            await this.host.notifyGitMutation(cwd, msg.enabled ? "enable-pr-auto-merge" : "disable-pr-auto-merge", {
+            await this.gitMutation.notifyGitMutation(cwd, msg.enabled ? "enable-pr-auto-merge" : "disable-pr-auto-merge", {
                 invalidateGithub: true,
             });
             this.host.emit({

package/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/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 Paseo.",
+};
+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/dist/server/server/session/daemon/daemon-session.d.ts

@@ -1,6 +1,9 @@
 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;
@@ -21,7 +24,11 @@ export interface DaemonSessionOptions {
     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;
 }
 /**
@@ -37,7 +44,11 @@ export declare class DaemonSession {
     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;
     constructor(options: DaemonSessionOptions);
     handleGetStatusRequest(msg: Extract<SessionInboundMessage, {
@@ -46,5 +57,8 @@ export declare class DaemonSession {
     handleGetPairingOfferRequest(msg: Extract<SessionInboundMessage, {
         type: "daemon.get_pairing_offer.request";
     }>): Promise<void>;
+    handleDiagnosticsRequest(msg: Extract<SessionInboundMessage, {
+        type: "diagnostics.request";
+    }>): Promise<void>;
 }
 //# sourceMappingURL=daemon-session.d.ts.map

package/dist/server/server/session/daemon/daemon-session.js

@@ -1,5 +1,6 @@
 import { getPidLockInfo } from "../../pid-lock.js";
 import { generateLocalPairingOffer } from "../../pairing-offer.js";
+import { collectDaemonDiagnostics, } from "./diagnostics.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
@@ -14,7 +15,11 @@ export class DaemonSession {
         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;
     }
     async handleGetStatusRequest(msg) {
@@ -94,5 +99,38 @@ export class DaemonSession {
             });
         }
     }
+    async handleDiagnosticsRequest(msg) {
+        try {
+            const diagnostic = await collectDaemonDiagnostics({
+                paseoHome: this.paseoHome,
+                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: `Paseo diagnostics\n  Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            });
+        }
+    }
 }
 //# sourceMappingURL=daemon-session.js.map

package/dist/server/server/session/daemon/diagnostics.d.ts

@@ -0,0 +1,41 @@
+import type pino from "pino";
+import type { ManagedAgent, ProviderAvailability } from "../../agent/agent-manager.js";
+import type { WebSocketRuntimeDiagnosticSnapshot } from "../../websocket/runtime-metrics.js";
+import type { PersistedProjectRecord, PersistedWorkspaceRecord } from "../../workspace-registry.js";
+import type { DaemonRuntimeConfig } from "./daemon-session.js";
+export interface DaemonDiagnosticsOptions {
+    paseoHome: 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;
+}
+interface DiagnosticWebSocketRuntimeMetrics {
+    terminalDirectorySubscriptionCount: number;
+    terminalSubscriptionCount: number;
+    inflightRequests: number;
+    peakInflightRequests: number;
+    checkoutDiffTargetCount: number;
+    checkoutDiffSubscriptionCount: number;
+    checkoutDiffWatcherCount: number;
+    checkoutDiffFallbackRefreshTargetCount: number;
+}
+interface DiagnosticAgentRuntimeMetrics {
+    total: number;
+    byLifecycle: Record<string, number>;
+    withActiveForegroundTurn: number;
+    timelineStats: {
+        totalItems: number;
+        maxItemsPerAgent: number;
+    };
+}
+export type DaemonWebSocketRuntimeDiagnosticSnapshot = WebSocketRuntimeDiagnosticSnapshot<DiagnosticWebSocketRuntimeMetrics, DiagnosticAgentRuntimeMetrics>;
+export declare function collectDaemonDiagnostics(options: DaemonDiagnosticsOptions): Promise<string>;
+export declare function redactDiagnostic(value: string, options?: Partial<DaemonDiagnosticsOptions>): string;
+export {};
+//# sourceMappingURL=diagnostics.d.ts.map