@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/pagination/sortable-pager.js

@@ -0,0 +1,68 @@
+import { CursorError, decodeCursor, encodeCursor, } from "./cursor.js";
+export class SortablePager {
+    constructor(config) {
+        this.config = config;
+    }
+    normalizeSort(sort) {
+        if (!sort || sort.length === 0) {
+            return [...this.config.defaultSort];
+        }
+        const deduped = [];
+        const seen = new Set();
+        for (const entry of sort) {
+            if (seen.has(entry.key)) {
+                continue;
+            }
+            seen.add(entry.key);
+            deduped.push(entry);
+        }
+        return deduped.length > 0 ? deduped : [...this.config.defaultSort];
+    }
+    compare(left, right, sort) {
+        for (const spec of sort) {
+            const leftValue = this.config.getSortValue(left, spec.key);
+            const rightValue = this.config.getSortValue(right, spec.key);
+            const base = compareValues(leftValue, rightValue);
+            if (base === 0) {
+                continue;
+            }
+            return spec.direction === "asc" ? base : -base;
+        }
+        return this.config.getId(left).localeCompare(this.config.getId(right));
+    }
+    compareWithCursor(item, cursor, sort) {
+        for (const spec of sort) {
+            const leftValue = this.config.getSortValue(item, spec.key);
+            const rightValue = cursor.values[spec.key] ?? null;
+            const base = compareValues(leftValue, rightValue);
+            if (base === 0) {
+                continue;
+            }
+            return spec.direction === "asc" ? base : -base;
+        }
+        return this.config.getId(item).localeCompare(cursor.id);
+    }
+    encode(item, sort) {
+        return encodeCursor(item, sort, this.config.getId, this.config.getSortValue);
+    }
+    decode(token, sort) {
+        return decodeCursor(token, sort, this.config.validKeys, this.config.label);
+    }
+}
+export { CursorError };
+export function compareValues(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    if (left === null) {
+        return -1;
+    }
+    if (right === null) {
+        return 1;
+    }
+    if (typeof left === "number" && typeof right === "number") {
+        return left < right ? -1 : 1;
+    }
+    return String(left).localeCompare(String(right));
+}
+//# sourceMappingURL=sortable-pager.js.map

package/dist/server/server/pairing-offer.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from "pino";
+export interface LocalPairingOffer {
+    relayEnabled: boolean;
+    url: string | null;
+    qr: string | null;
+}
+export declare function generateLocalPairingOffer(args: {
+    paseoHome: string;
+    relayEnabled?: boolean;
+    relayEndpoint?: string;
+    relayPublicEndpoint?: string;
+    relayUseTls?: boolean;
+    relayPublicUseTls?: boolean;
+    appBaseUrl?: string;
+    includeQr?: boolean;
+    logger?: Logger;
+}): Promise<LocalPairingOffer>;
+//# sourceMappingURL=pairing-offer.d.ts.map

package/dist/server/server/pairing-offer.js

@@ -0,0 +1,47 @@
+import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
+import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
+import { renderPairingQr } from "./pairing-qr.js";
+import { getOrCreateServerId } from "./server-id.js";
+export async function generateLocalPairingOffer(args) {
+    const relayEnabled = args.relayEnabled ?? true;
+    if (!relayEnabled) {
+        return {
+            relayEnabled: false,
+            url: null,
+            qr: null,
+        };
+    }
+    const relayEndpoint = args.relayEndpoint ?? "relay.paseo.sh:443";
+    const relayPublicEndpoint = args.relayPublicEndpoint ?? relayEndpoint;
+    const relayUseTls = args.relayUseTls ?? relayEndpoint === "relay.paseo.sh:443";
+    const relayPublicUseTls = args.relayPublicUseTls ?? relayUseTls;
+    const appBaseUrl = args.appBaseUrl ?? "https://app.paseo.sh";
+    const serverId = getOrCreateServerId(args.paseoHome, { logger: args.logger });
+    const daemonKeyPair = await loadOrCreateDaemonKeyPair(args.paseoHome, args.logger);
+    const offer = await createConnectionOfferV2({
+        serverId,
+        daemonPublicKeyB64: daemonKeyPair.publicKeyB64,
+        relay: { endpoint: relayPublicEndpoint, useTls: relayPublicUseTls },
+    });
+    const url = encodeOfferToFragmentUrl({ offer, appBaseUrl });
+    if (args.includeQr === false) {
+        return {
+            relayEnabled: true,
+            url,
+            qr: null,
+        };
+    }
+    let qr = null;
+    try {
+        qr = await renderPairingQr(url);
+    }
+    catch (error) {
+        args.logger?.debug({ error }, "Failed to render pairing QR");
+    }
+    return {
+        relayEnabled: true,
+        url,
+        qr,
+    };
+}
+//# sourceMappingURL=pairing-offer.js.map

package/dist/server/server/pairing-qr.d.ts

@@ -0,0 +1,2 @@
+export declare function renderPairingQr(url: string): Promise<string>;
+//# sourceMappingURL=pairing-qr.d.ts.map

package/dist/server/server/pairing-qr.js

@@ -0,0 +1,15 @@
+import * as QRCode from "qrcode";
+const BLACK_ON_WHITE = "\u001b[47m\u001b[30m";
+const RESET_COLORS = "\u001b[0m";
+export async function renderPairingQr(url) {
+    const utf8Options = {
+        type: "utf8",
+        margin: 4,
+    };
+    const qr = await QRCode.toString(url, utf8Options);
+    return qr
+        .split("\n")
+        .map((line) => `${BLACK_ON_WHITE}${line}${RESET_COLORS}`)
+        .join("\n");
+}
+//# sourceMappingURL=pairing-qr.js.map

package/dist/server/server/paseo-env.d.ts

@@ -0,0 +1,13 @@
+export type PaseoNodeEnv = "development" | "production" | "test";
+export type ProcessEnvRecord = Record<string, string | undefined>;
+export type ExternalProcessEnv = NodeJS.ProcessEnv & Record<string, string>;
+export declare function createPaseoInternalEnv(baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function createExternalProcessEnv(baseEnv: ProcessEnvRecord, ...overlays: ProcessEnvRecord[]): ExternalProcessEnv;
+export declare function createExternalCommandProcessEnv(_command: string, baseEnv: ProcessEnvRecord, ...overlays: ProcessEnvRecord[]): ExternalProcessEnv;
+export declare function buildSelfNodeCommand(args: string[], envOverlay?: ProcessEnvRecord): {
+    command: string;
+    args: string[];
+    env: ExternalProcessEnv;
+};
+export declare function resolvePaseoNodeEnv(env: NodeJS.ProcessEnv): PaseoNodeEnv | undefined;
+//# sourceMappingURL=paseo-env.d.ts.map

package/dist/server/server/paseo-env.js

@@ -0,0 +1,54 @@
+const PASEO_NODE_ENV = "PASEO_NODE_ENV";
+const ELECTRON_RUN_AS_NODE = "ELECTRON_RUN_AS_NODE";
+const RUNTIME_CONTROL_ENV_KEYS = [
+    PASEO_NODE_ENV,
+    "PASEO_DESKTOP_MANAGED",
+    "PASEO_SUPERVISED",
+    ELECTRON_RUN_AS_NODE,
+    "ELECTRON_NO_ATTACH_CONSOLE",
+    "ESBUILD_BINARY_PATH",
+];
+function buildInternalProcessEnv(baseEnv) {
+    return { ...baseEnv };
+}
+function buildExternalProcessEnv(baseEnv, overlays) {
+    const sanitized = Object.assign({}, baseEnv, ...overlays);
+    for (const key of RUNTIME_CONTROL_ENV_KEYS) {
+        delete sanitized[key];
+    }
+    for (const [key, value] of Object.entries(sanitized)) {
+        if (value === undefined) {
+            delete sanitized[key];
+        }
+    }
+    return sanitized;
+}
+export function createPaseoInternalEnv(baseEnv) {
+    return buildInternalProcessEnv(baseEnv);
+}
+export function createExternalProcessEnv(baseEnv, ...overlays) {
+    return buildExternalProcessEnv(baseEnv, overlays);
+}
+export function createExternalCommandProcessEnv(_command, baseEnv, ...overlays) {
+    // Deprecated command parameter: retained while callers migrate to createExternalProcessEnv.
+    return buildExternalProcessEnv(baseEnv, overlays);
+}
+export function buildSelfNodeCommand(args, envOverlay) {
+    const env = buildExternalProcessEnv(process.env, []);
+    Object.assign(env, { [ELECTRON_RUN_AS_NODE]: "1" }, envOverlay);
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined) {
+            delete env[key];
+        }
+    }
+    return {
+        command: process.execPath,
+        args,
+        env,
+    };
+}
+export function resolvePaseoNodeEnv(env) {
+    const value = env[PASEO_NODE_ENV];
+    return value === "development" || value === "production" || value === "test" ? value : undefined;
+}
+//# sourceMappingURL=paseo-env.js.map

package/dist/server/server/paseo-home.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePaseoHome(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=paseo-home.d.ts.map

package/dist/server/server/paseo-home.js

@@ -0,0 +1,19 @@
+import os from "node:os";
+import path from "node:path";
+import { ensurePrivateDirectory } from "./private-files.js";
+function expandHomeDir(input) {
+    if (input.startsWith("~/")) {
+        return path.join(os.homedir(), input.slice(2));
+    }
+    if (input === "~") {
+        return os.homedir();
+    }
+    return input;
+}
+export function resolvePaseoHome(env = process.env) {
+    const raw = env.PASEO_HOME ?? "~/.paseo";
+    const resolved = path.resolve(expandHomeDir(raw));
+    ensurePrivateDirectory(resolved);
+    return resolved;
+}
+//# sourceMappingURL=paseo-home.js.map

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

@@ -0,0 +1,45 @@
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import type { PersistedWorkspaceRecord } from "./workspace-registry.js";
+import type { WorkspaceProvisioningService } from "./session/workspace-provisioning/workspace-provisioning-service.js";
+import { type CreateWorktreeCoreDeps, type CreateWorktreeCoreInput } from "./worktree-core.js";
+import { type WorktreeConfig } from "../utils/worktree.js";
+import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
+import type { WorktreeCreationIntent } from "./resolve-worktree-creation-intent.js";
+import type { FirstAgentContext } from "@camerontaylor/paseo-protocol/messages";
+export interface CreatePaseoWorktreeInput extends CreateWorktreeCoreInput {
+    workspaceId?: string;
+    projectId?: string;
+    title?: string;
+}
+export interface CreatePaseoWorktreeResult {
+    worktree: WorktreeConfig;
+    intent: WorktreeCreationIntent;
+    workspace: PersistedWorkspaceRecord;
+    repoRoot: string;
+    created: boolean;
+}
+export type CreatePaseoWorktreeFn = (input: CreatePaseoWorktreeInput, options?: {
+    resolveDefaultBranch?: (repoRoot: string) => Promise<string>;
+}) => Promise<CreatePaseoWorktreeResult>;
+export interface AttemptFirstAgentBranchAutoNameResult {
+    attempted: boolean;
+    renamed: boolean;
+    branchName: string | null;
+}
+export interface CreatePaseoWorktreeDeps extends CreateWorktreeCoreDeps {
+    workspaceGitService: WorkspaceGitService;
+    workspaceProvisioning: Pick<WorkspaceProvisioningService, "createWorkspaceForWorktree">;
+}
+export declare function createPaseoWorktree(input: CreatePaseoWorktreeInput, deps: CreatePaseoWorktreeDeps): Promise<CreatePaseoWorktreeResult>;
+export declare function attemptFirstAgentBranchAutoName(options: {
+    cwd: string;
+    firstAgentContext: FirstAgentContext | undefined;
+    generateBranchNameFromContext: (input: {
+        cwd: string;
+        firstAgentContext: FirstAgentContext;
+    }) => Promise<string | null>;
+    getCurrentBranch?: typeof getCurrentBranch;
+    renameCurrentBranch?: typeof renameCurrentBranch;
+    localBranchExists?: typeof localBranchExists;
+}): Promise<AttemptFirstAgentBranchAutoNameResult>;
+//# sourceMappingURL=paseo-worktree-service.d.ts.map

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

@@ -0,0 +1,191 @@
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { getRealpathAwareRelativePath } from "../utils/path.js";
+import { createWorktreeCore, } from "./worktree-core.js";
+import { mapWorkspaceRelativeCwdToWorktree, rollbackCreatedPaseoWorktree, seedPaseoConfigFile, validateBranchSlug, } from "../utils/worktree.js";
+import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
+import { markPaseoWorktreeFirstAgentBranchAutoNameAttempted, normalizeBaseRefName, readPaseoWorktreeMetadata, writePaseoWorktreeFirstAgentBranchAutoNameMetadata, } from "../utils/worktree-metadata.js";
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
+import { buildAgentBranchNameSeed } from "./agent/prompt-attachments.js";
+import { runWithGitCommandPriority } from "../utils/run-git-command.js";
+export async function createPaseoWorktree(input, deps) {
+    return runWithGitCommandPriority("high", () => createPaseoWorktreeWithPriority(input, deps));
+}
+async function createPaseoWorktreeWithPriority(input, deps) {
+    const workspaceCwdPlan = await planWorkspaceCwdForWorktree(input.cwd, deps.workspaceGitService);
+    const createdWorktree = await createWorktreeCore(input, deps);
+    try {
+        maybeMarkFirstAgentBranchAutoNameEligible({ createdWorktree });
+        const workspaceCwd = mapWorkspaceRelativeCwdToWorktree({
+            relativeWorkspaceCwd: workspaceCwdPlan.relativeWorkspaceCwd,
+            targetWorktreePath: createdWorktree.worktree.worktreePath,
+        });
+        if (!(await isDirectory(workspaceCwd))) {
+            throw new Error(`Selected project directory is missing from the worktree: ${workspaceCwd}`);
+        }
+        if (createdWorktree.created) {
+            await seedPaseoConfigFile({
+                sourceCwd: workspaceCwdPlan.inputCwd,
+                targetCwd: workspaceCwd,
+            });
+        }
+        const workspace = await deps.workspaceProvisioning.createWorkspaceForWorktree({
+            sourceCwd: workspaceCwdPlan.inputCwd,
+            projectId: input.projectId,
+            workspaceId: input.workspaceId,
+            repoRoot: createdWorktree.repoRoot,
+            cwd: workspaceCwd,
+            worktreeRoot: createdWorktree.worktree.worktreePath,
+            branch: createdWorktree.worktree.branchName || null,
+            baseBranch: resolveIntentBaseBranch(createdWorktree.intent),
+            title: input.title?.trim() || resolveFirstAgentPromptTitle(input.firstAgentContext),
+            expectsInitialAgent: Boolean(input.firstAgentContext),
+            ...(createdWorktree.intent.kind === "checkout-change-request" &&
+                createdWorktree.intent.headRepository
+                ? {
+                    untrustedSource: {
+                        kind: "change_request",
+                        forge: createdWorktree.intent.forge,
+                        number: createdWorktree.intent.changeRequestNumber,
+                        headRepository: createdWorktree.intent.headRepository,
+                    },
+                }
+                : {}),
+        });
+        deps.github.invalidate({ cwd: createdWorktree.worktree.worktreePath });
+        return {
+            worktree: createdWorktree.worktree,
+            intent: createdWorktree.intent,
+            workspace,
+            repoRoot: createdWorktree.repoRoot,
+            created: createdWorktree.created,
+        };
+    }
+    catch (error) {
+        if (!createdWorktree.created) {
+            throw error;
+        }
+        return rollbackCreatedPaseoWorktree({
+            cwd: createdWorktree.repoRoot,
+            worktreePath: createdWorktree.worktree.worktreePath,
+            ...(input.runSetup === false ? { teardownCwds: [] } : {}),
+            paseoHome: input.paseoHome,
+            worktreesBaseRoot: input.worktreesRoot,
+        }, error);
+    }
+}
+async function isDirectory(targetPath) {
+    try {
+        return (await stat(targetPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function planWorkspaceCwdForWorktree(inputCwd, workspaceGitService) {
+    const normalizedInputCwd = resolve(inputCwd);
+    const sourceCheckout = await workspaceGitService.getCheckout(normalizedInputCwd);
+    const sourceWorktreePath = sourceCheckout.worktreeRoot ?? normalizedInputCwd;
+    const relativeWorkspaceCwd = getRealpathAwareRelativePath(sourceWorktreePath, normalizedInputCwd);
+    if (relativeWorkspaceCwd === null) {
+        throw new Error(`Workspace cwd is outside its source worktree: ${normalizedInputCwd}`);
+    }
+    return { inputCwd: normalizedInputCwd, relativeWorkspaceCwd };
+}
+export async function attemptFirstAgentBranchAutoName(options) {
+    const firstAgentContext = options.firstAgentContext;
+    if (!firstAgentContext || !buildAgentBranchNameSeed(firstAgentContext)) {
+        return { attempted: false, renamed: false, branchName: null };
+    }
+    let metadata;
+    try {
+        metadata = readPaseoWorktreeMetadata(options.cwd);
+    }
+    catch {
+        return { attempted: false, renamed: false, branchName: null };
+    }
+    if (!metadata ||
+        metadata.version !== 2 ||
+        metadata.firstAgentBranchAutoName?.status !== "pending") {
+        return { attempted: false, renamed: false, branchName: null };
+    }
+    const getCurrentBranchImpl = options.getCurrentBranch ?? getCurrentBranch;
+    const placeholderBranchName = metadata.firstAgentBranchAutoName.placeholderBranchName;
+    if ((await getCurrentBranchImpl(options.cwd)) !== placeholderBranchName) {
+        markPaseoWorktreeFirstAgentBranchAutoNameAttempted(options.cwd);
+        return { attempted: true, renamed: false, branchName: null };
+    }
+    markPaseoWorktreeFirstAgentBranchAutoNameAttempted(options.cwd);
+    const branchName = await options.generateBranchNameFromContext({
+        cwd: options.cwd,
+        firstAgentContext,
+    });
+    if (!branchName) {
+        return { attempted: true, renamed: false, branchName: null };
+    }
+    const validation = validateBranchSlug(branchName);
+    if (!validation.valid || branchName === placeholderBranchName) {
+        return { attempted: true, renamed: false, branchName: null };
+    }
+    if ((await getCurrentBranchImpl(options.cwd)) !== placeholderBranchName) {
+        return { attempted: true, renamed: false, branchName: null };
+    }
+    const localBranchExistsImpl = options.localBranchExists ?? localBranchExists;
+    const targetName = await findAvailableBranchName({
+        cwd: options.cwd,
+        desiredName: branchName,
+        placeholderBranchName,
+        localBranchExists: localBranchExistsImpl,
+    });
+    if (!targetName) {
+        return { attempted: true, renamed: false, branchName: null };
+    }
+    const renameCurrentBranchImpl = options.renameCurrentBranch ?? renameCurrentBranch;
+    const renamedBranch = await renameCurrentBranchImpl(options.cwd, targetName);
+    return {
+        attempted: true,
+        renamed: true,
+        branchName: renamedBranch.currentBranch ?? targetName,
+    };
+}
+const MAX_BRANCH_NAME_SUFFIX_ATTEMPTS = 50;
+async function findAvailableBranchName(options) {
+    const { cwd, desiredName, placeholderBranchName } = options;
+    if (!(await options.localBranchExists(cwd, desiredName))) {
+        return desiredName;
+    }
+    for (let suffix = 2; suffix <= MAX_BRANCH_NAME_SUFFIX_ATTEMPTS; suffix++) {
+        const candidate = `${desiredName}-${suffix}`;
+        if (candidate === placeholderBranchName) {
+            continue;
+        }
+        if (!(await options.localBranchExists(cwd, candidate))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function maybeMarkFirstAgentBranchAutoNameEligible(options) {
+    const { createdWorktree } = options;
+    if (!createdWorktree.created || createdWorktree.intent.kind !== "branch-off") {
+        return;
+    }
+    writePaseoWorktreeFirstAgentBranchAutoNameMetadata(createdWorktree.worktree.worktreePath, {
+        placeholderBranchName: createdWorktree.worktree.branchName,
+    });
+}
+// The base branch is normalized to match worktree.json's baseRefName (origin/
+// stripped). checkout-branch worktrees have no distinct base, so they stay null.
+function resolveIntentBaseBranch(intent) {
+    switch (intent.kind) {
+        case "branch-off":
+            return normalizeBaseRefName(intent.baseBranch);
+        case "checkout-change-request":
+            return normalizeBaseRefName(intent.baseRefName);
+        case "checkout-github-pr":
+            return normalizeBaseRefName(intent.baseRefName);
+        case "checkout-branch":
+            return null;
+    }
+}
+//# sourceMappingURL=paseo-worktree-service.js.map

package/dist/server/server/path-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function assertAbsolutePath(cwd: string): void;
+export declare function expandUserPath(value: string): string;
+export declare function resolvePathFromBase(baseCwd: string, requestedPath: string): string;
+export declare function isSameOrDescendantPath(basePath: string, candidatePath: string): boolean;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/server/server/path-utils.js

@@ -0,0 +1,34 @@
+import { homedir } from "node:os";
+import { isAbsolute, posix, resolve, win32 } from "node:path";
+export function assertAbsolutePath(cwd) {
+    if (!posix.isAbsolute(cwd) && !win32.isAbsolute(cwd)) {
+        throw new Error("cwd must be absolute path");
+    }
+}
+function hasHomePrefix(value) {
+    return value === "~" || value.startsWith("~/");
+}
+export function expandUserPath(value) {
+    const trimmed = value.trim();
+    if (hasHomePrefix(trimmed)) {
+        return resolve(homedir(), trimmed.slice(2));
+    }
+    return resolve(trimmed);
+}
+export function resolvePathFromBase(baseCwd, requestedPath) {
+    const trimmed = requestedPath.trim();
+    if (hasHomePrefix(trimmed) || isAbsolute(trimmed)) {
+        return expandUserPath(trimmed);
+    }
+    return resolve(baseCwd, trimmed);
+}
+export function isSameOrDescendantPath(basePath, candidatePath) {
+    let normalizedBase = basePath.replace(/\\/g, "/").replace(/\/$/, "");
+    let normalizedCandidate = candidatePath.replace(/\\/g, "/").replace(/\/$/, "");
+    if (/^[a-zA-Z]:\//.test(normalizedBase) || /^[a-zA-Z]:\//.test(normalizedCandidate)) {
+        normalizedBase = normalizedBase.toLowerCase();
+        normalizedCandidate = normalizedCandidate.toLowerCase();
+    }
+    return (normalizedCandidate === normalizedBase || normalizedCandidate.startsWith(normalizedBase + "/"));
+}
+//# sourceMappingURL=path-utils.js.map