@getpaseo/server 0.1.95 → 0.1.97-beta.1

package/dist/server/server/agent/agent-metadata-generator.js

@@ -1,112 +0,0 @@
-import { z } from "zod";
-import { StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent-response-loop.js";
-import { resolveStructuredGenerationProviders, } from "./structured-generation-providers.js";
-import { MAX_AUTO_AGENT_TITLE_CHARS } from "@getpaseo/protocol/agent-title-limits";
-import { buildMetadataPrompt } from "../../utils/build-metadata-prompt.js";
-function hasExplicitTitle(title) {
-    return Boolean(title && title.trim().length > 0);
-}
-function normalizeAutoTitle(title) {
-    const normalized = title.trim();
-    if (!normalized) {
-        return null;
-    }
-    return normalized.slice(0, MAX_AUTO_AGENT_TITLE_CHARS).trim() || null;
-}
-export async function determineAgentMetadataNeeds(options) {
-    const prompt = options.initialPrompt?.trim();
-    if (!prompt) {
-        return { prompt: null, needsTitle: false };
-    }
-    const needsTitle = !hasExplicitTitle(options.explicitTitle);
-    return {
-        prompt,
-        needsTitle,
-    };
-}
-function buildMetadataSchema(needs) {
-    if (!needs.needsTitle) {
-        return null;
-    }
-    const shape = {};
-    if (needs.needsTitle) {
-        shape.title = z.string().min(1).max(MAX_AUTO_AGENT_TITLE_CHARS);
-    }
-    return z.object(shape);
-}
-async function buildPrompt(needs, options) {
-    const beforeLines = ["Generate metadata for a coding agent based on the user prompt."];
-    if (needs.needsTitle) {
-        beforeLines.push(`Title: short descriptive label (<= ${MAX_AUTO_AGENT_TITLE_CHARS} chars).`);
-    }
-    return buildMetadataPrompt({
-        cwd: options.cwd,
-        workspaceGitService: options.workspaceGitService,
-        configKey: "agentTitle",
-        before: beforeLines.join("\n"),
-        after: "Return JSON only with a single field 'title'.",
-        trailing: `User prompt:\n${needs.prompt ?? ""}`,
-    });
-}
-export async function generateAndApplyAgentMetadata(options) {
-    const needs = await determineAgentMetadataNeeds(options);
-    if (!needs.prompt) {
-        return;
-    }
-    const schema = buildMetadataSchema(needs);
-    if (!schema) {
-        return;
-    }
-    const generator = options.deps?.generateStructuredAgentResponseWithFallback ??
-        generateStructuredAgentResponseWithFallback;
-    let result;
-    try {
-        const providers = options.providerSnapshotManager
-            ? await resolveStructuredGenerationProviders({
-                cwd: options.cwd,
-                providerSnapshotManager: options.providerSnapshotManager,
-                daemonConfig: options.daemonConfig,
-                currentSelection: options.currentSelection,
-            })
-            : [];
-        result = await generator({
-            manager: options.agentManager,
-            cwd: options.cwd,
-            prompt: await buildPrompt(needs, {
-                cwd: options.cwd,
-                workspaceGitService: options.workspaceGitService,
-            }),
-            schema,
-            schemaName: "AgentMetadata",
-            maxRetries: 2,
-            providers,
-            persistSession: false,
-            logger: options.logger,
-            agentConfigOverrides: {
-                title: "Agent metadata generator",
-                internal: true,
-            },
-        });
-    }
-    catch (error) {
-        const attempts = error instanceof StructuredAgentFallbackError ? error.attempts : undefined;
-        options.logger.error({ err: error, agentId: options.agentId, attempts }, error instanceof StructuredAgentResponseError || error instanceof StructuredAgentFallbackError
-            ? "Structured metadata generation failed"
-            : "Agent metadata generation failed");
-        return;
-    }
-    if (needs.needsTitle && typeof result.title === "string") {
-        const normalizedTitle = normalizeAutoTitle(result.title);
-        if (normalizedTitle) {
-            await options.agentManager.setGeneratedTitle(options.agentId, normalizedTitle);
-        }
-    }
-}
-export function scheduleAgentMetadataGeneration(options) {
-    queueMicrotask(() => {
-        void generateAndApplyAgentMetadata(options).catch((error) => {
-            options.logger.error({ err: error, agentId: options.agentId }, "Agent metadata generation crashed");
-        });
-    });
-}
-//# sourceMappingURL=agent-metadata-generator.js.map

package/dist/server/server/paseo-worktree-archive-service.d.ts

@@ -1,41 +0,0 @@
-import type { Logger } from "pino";
-import type { AgentManager } from "./agent/agent-manager.js";
-import type { AgentStorage } from "./agent/agent-storage.js";
-import type { WorkspaceGitService } from "./workspace-git-service.js";
-import type { GitHubService } from "../services/github-service.js";
-import type { TerminalManager } from "../terminal/terminal-manager.js";
-export interface ArchivePaseoWorktreeDependencies {
-    paseoHome?: string;
-    worktreesRoot?: string;
-    github: GitHubService;
-    workspaceGitService: Pick<WorkspaceGitService, "getSnapshot">;
-    agentManager: Pick<AgentManager, "listAgents" | "archiveAgent" | "archiveSnapshot">;
-    agentStorage: Pick<AgentStorage, "list">;
-    archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
-    emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
-    markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
-    clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
-    isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
-    killTerminalsUnderPath: (rootPath: string) => Promise<void>;
-    sessionLogger?: Logger;
-}
-export interface KillTerminalsUnderPathDependencies {
-    isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
-    killTrackedTerminal: (terminalId: string, options?: {
-        emitExit: boolean;
-    }) => void;
-    detachTerminalStream?: (terminalId: string, options: {
-        emitExit: boolean;
-    }) => void;
-    sessionLogger: Logger;
-    terminalManager: TerminalManager | null;
-}
-export declare function archivePaseoWorktree(dependencies: ArchivePaseoWorktreeDependencies, options: {
-    targetPath: string;
-    repoRoot: string | null;
-    worktreesRoot?: string;
-    worktreesBaseRoot?: string;
-    requestId: string;
-}): Promise<string[]>;
-export declare function killTerminalsUnderPath(dependencies: KillTerminalsUnderPathDependencies, rootPath: string): Promise<void>;
-//# sourceMappingURL=paseo-worktree-archive-service.d.ts.map

package/dist/server/server/paseo-worktree-archive-service.js

@@ -1,144 +0,0 @@
-import { normalizeWorkspaceId as normalizePersistedWorkspaceId } from "./workspace-registry-model.js";
-import { deletePaseoWorktree, resolvePaseoWorktreeRootForCwd, WorktreeTeardownError, } from "../utils/worktree.js";
-export async function archivePaseoWorktree(dependencies, options) {
-    let targetPath = options.targetPath;
-    const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(targetPath, {
-        paseoHome: dependencies.paseoHome,
-        worktreesRoot: options.worktreesBaseRoot ?? dependencies.worktreesRoot,
-    });
-    if (resolvedWorktree) {
-        targetPath = resolvedWorktree.worktreePath;
-    }
-    const archivedAgents = new Set();
-    const affectedWorkspaceCwds = new Set([targetPath]);
-    const affectedWorkspaceIds = new Set([normalizePersistedWorkspaceId(targetPath)]);
-    const liveAgents = dependencies.agentManager
-        .listAgents()
-        .filter((agent) => dependencies.isPathWithinRoot(targetPath, agent.cwd));
-    for (const agent of liveAgents) {
-        archivedAgents.add(agent.id);
-        affectedWorkspaceCwds.add(agent.cwd);
-        affectedWorkspaceIds.add(normalizePersistedWorkspaceId(agent.cwd));
-    }
-    let storedRecords = [];
-    try {
-        storedRecords = await dependencies.agentStorage.list();
-    }
-    catch (error) {
-        dependencies.sessionLogger?.warn({ err: error, targetPath }, "Failed to list stored agents during worktree archive; continuing");
-    }
-    const liveAgentIds = new Set(liveAgents.map((agent) => agent.id));
-    const matchingStoredRecords = storedRecords.filter((record) => dependencies.isPathWithinRoot(targetPath, record.cwd));
-    for (const record of matchingStoredRecords) {
-        archivedAgents.add(record.id);
-        affectedWorkspaceCwds.add(record.cwd);
-        affectedWorkspaceIds.add(normalizePersistedWorkspaceId(record.cwd));
-    }
-    const affectedWorkspaceIdList = Array.from(affectedWorkspaceIds);
-    dependencies.markWorkspaceArchiving(affectedWorkspaceIdList, new Date().toISOString());
-    try {
-        await dependencies.emitWorkspaceUpdatesForWorkspaceIds(affectedWorkspaceIdList);
-        const archivedAt = new Date().toISOString();
-        const archiveResults = await Promise.allSettled([
-            ...liveAgents.map((agent) => dependencies.agentManager.archiveAgent(agent.id)),
-            ...matchingStoredRecords
-                .filter((record) => !liveAgentIds.has(record.id) && !record.archivedAt)
-                .map((record) => dependencies.agentManager.archiveSnapshot(record.id, archivedAt)),
-            dependencies.killTerminalsUnderPath(targetPath),
-        ]);
-        for (const result of archiveResults) {
-            if (result.status === "rejected") {
-                dependencies.sessionLogger?.warn({ err: result.reason, targetPath }, "Worktree archive teardown step failed; continuing");
-            }
-        }
-        let teardownError = null;
-        try {
-            await deletePaseoWorktree({
-                cwd: options.repoRoot,
-                worktreePath: targetPath,
-                worktreesRoot: options.worktreesRoot,
-                paseoHome: dependencies.paseoHome,
-                worktreesBaseRoot: options.worktreesBaseRoot ?? dependencies.worktreesRoot,
-            });
-        }
-        catch (error) {
-            if (error instanceof WorktreeTeardownError) {
-                teardownError = error;
-                dependencies.sessionLogger?.warn({ err: error, targetPath }, "Worktree teardown failed during archive; archiving workspace record anyway");
-            }
-            else {
-                throw error;
-            }
-        }
-        if (!teardownError && options.repoRoot) {
-            try {
-                await dependencies.workspaceGitService.getSnapshot(options.repoRoot, {
-                    force: true,
-                    reason: "archive-worktree",
-                });
-            }
-            catch (error) {
-                dependencies.sessionLogger?.warn({ err: error, cwd: options.repoRoot }, "Failed to force-refresh workspace git snapshot after archiving worktree");
-            }
-        }
-        for (const cwd of affectedWorkspaceCwds) {
-            dependencies.github.invalidate({ cwd });
-        }
-        await Promise.all(affectedWorkspaceIdList.map(async (workspaceId) => {
-            try {
-                await dependencies.archiveWorkspaceRecord(workspaceId);
-            }
-            catch (error) {
-                dependencies.sessionLogger?.warn({ err: error, workspaceId }, teardownError
-                    ? "Failed to archive workspace record after teardown failed"
-                    : "Failed to archive workspace record; worktree FS already removed");
-            }
-        }));
-        if (teardownError) {
-            throw teardownError;
-        }
-    }
-    finally {
-        dependencies.clearWorkspaceArchiving(affectedWorkspaceIdList);
-        await dependencies.emitWorkspaceUpdatesForWorkspaceIds(affectedWorkspaceIdList);
-    }
-    return Array.from(archivedAgents);
-}
-export async function killTerminalsUnderPath(dependencies, rootPath) {
-    const terminalManager = dependencies.terminalManager;
-    if (!terminalManager) {
-        return;
-    }
-    const terminalIds = [];
-    const relevantCwds = [...terminalManager.listDirectories()].filter((terminalCwd) => dependencies.isPathWithinRoot(rootPath, terminalCwd));
-    const terminalLists = await Promise.all(relevantCwds.map(async (terminalCwd) => {
-        try {
-            return await terminalManager.getTerminals(terminalCwd);
-        }
-        catch (error) {
-            dependencies.sessionLogger.warn({ err: error, cwd: terminalCwd }, "Failed to enumerate worktree terminals during archive");
-            return [];
-        }
-    }));
-    for (const terminals of terminalLists) {
-        for (const terminal of terminals) {
-            terminalIds.push(terminal.id);
-        }
-    }
-    if (terminalIds.length === 0) {
-        return;
-    }
-    await Promise.allSettled(terminalIds.map(async (terminalId) => {
-        try {
-            dependencies.detachTerminalStream?.(terminalId, { emitExit: true });
-            await terminalManager.killTerminalAndWait(terminalId, {
-                gracefulTimeoutMs: 2000,
-                forceTimeoutMs: 1500,
-            });
-        }
-        catch (error) {
-            dependencies.sessionLogger.warn({ err: error, terminalId }, "Terminal kill escalation failed during archive; proceeding anyway");
-        }
-    }));
-}
-//# sourceMappingURL=paseo-worktree-archive-service.js.map