@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/resolve-workspace-id-for-path.js

@@ -0,0 +1,41 @@
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+// external path→workspace adapter, not ownership.
+//
+// Resolves a raw filesystem path to a single workspace id ONLY at the boundary
+// where a client hands the daemon a bare worktree path with no id:
+// archive-by-path (old client / CLI), auto-archive-after-merge, and the MCP
+// `archive_worktree` tool. It is NEVER used to attribute agent status or place
+// agents under a workspace — those are keyed by `workspaceId`, and git facts
+// derive from a workspace's OWN cwd (id → cwd).
+//
+// Resolution: an exact directory match wins; otherwise the deepest enclosing
+// workspace directory, never the home directory; null when nothing encloses it.
+export function resolveWorkspaceIdForPath(cwd, workspaces) {
+    const workspaceRecords = Array.from(workspaces);
+    const resolvedCwd = resolve(cwd);
+    const exactMatch = workspaceRecords.find((workspace) => resolve(workspace.cwd) === resolvedCwd);
+    if (exactMatch) {
+        return exactMatch.workspaceId;
+    }
+    const userHome = resolve(homedir());
+    let bestMatchLength = 0;
+    let bestMatch = null;
+    for (const workspace of workspaceRecords) {
+        if (workspace.archivedAt)
+            continue;
+        const workspaceCwd = resolve(workspace.cwd);
+        if (workspaceCwd === userHome)
+            continue;
+        const prefix = workspaceCwd.endsWith(sep) ? workspaceCwd : `${workspaceCwd}${sep}`;
+        if (!resolvedCwd.startsWith(prefix)) {
+            continue;
+        }
+        if (workspaceCwd.length > bestMatchLength) {
+            bestMatchLength = workspaceCwd.length;
+            bestMatch = workspace;
+        }
+    }
+    return bestMatch?.workspaceId ?? null;
+}
+//# sourceMappingURL=resolve-workspace-id-for-path.js.map

package/dist/server/server/resolve-worktree-creation-intent.d.ts

@@ -0,0 +1,32 @@
+import type { GitHubService } from "../services/github-service.js";
+import type { WorktreeSource } from "../utils/worktree.js";
+export type WorktreeCreationIntent = WorktreeSource;
+export type ResolveWorktreeCreationIntentInput = {
+    worktreeSlug: string;
+    branchName?: string;
+    refName?: string;
+    action?: "branch-off";
+    githubPrNumber?: undefined;
+} | {
+    worktreeSlug?: string;
+    branchName?: string;
+    refName?: string;
+    action: "checkout";
+    githubPrNumber?: number;
+} | {
+    worktreeSlug?: string;
+    branchName?: string;
+    refName?: string;
+    action?: undefined;
+    githubPrNumber: number;
+};
+export interface ResolveWorktreeCreationIntentDeps {
+    github: GitHubService;
+    resolveDefaultBranch: (repoRoot: string) => Promise<string>;
+}
+export declare class MissingCheckoutTargetError extends Error {
+    readonly action = "checkout";
+    constructor();
+}
+export declare function resolveWorktreeCreationIntent(input: ResolveWorktreeCreationIntentInput, repoRoot: string, deps: ResolveWorktreeCreationIntentDeps): Promise<WorktreeCreationIntent>;
+//# sourceMappingURL=resolve-worktree-creation-intent.d.ts.map

package/dist/server/server/resolve-worktree-creation-intent.js

@@ -0,0 +1,121 @@
+export class MissingCheckoutTargetError extends Error {
+    constructor() {
+        super('action "checkout" requires refName or githubPrNumber');
+        this.action = "checkout";
+        this.name = "MissingCheckoutTargetError";
+    }
+}
+export async function resolveWorktreeCreationIntent(input, repoRoot, deps) {
+    if (input.action === "branch-off") {
+        return {
+            kind: "branch-off",
+            baseBranch: input.refName?.trim() || (await resolveDefaultBranch(repoRoot, deps)),
+            branchName: input.branchName ?? input.worktreeSlug,
+        };
+    }
+    if (input.action === "checkout") {
+        if (input.githubPrNumber !== undefined) {
+            return resolveGitHubPrCheckoutIntent({
+                refName: input.refName,
+                githubPrNumber: input.githubPrNumber,
+                repoRoot,
+                deps,
+            });
+        }
+        const branchName = input.refName?.trim();
+        if (branchName) {
+            return {
+                kind: "checkout-branch",
+                branchName,
+            };
+        }
+        throw new MissingCheckoutTargetError();
+    }
+    if (input.githubPrNumber !== undefined) {
+        return resolveGitHubPrCheckoutIntent({
+            refName: input.refName,
+            githubPrNumber: input.githubPrNumber,
+            repoRoot,
+            deps,
+        });
+    }
+    if (input.refName?.trim()) {
+        return {
+            kind: "branch-off",
+            baseBranch: input.refName.trim(),
+            branchName: input.branchName ?? input.worktreeSlug,
+        };
+    }
+    return {
+        kind: "branch-off",
+        baseBranch: await resolveDefaultBranch(repoRoot, deps),
+        branchName: input.branchName ?? input.worktreeSlug,
+    };
+}
+async function resolveGitHubPrCheckoutIntent(params) {
+    const checkoutTarget = await resolveGitHubPrCheckoutTarget(params);
+    const headRef = await resolveGitHubPrHeadRef({
+        refName: params.refName,
+        githubPrNumber: params.githubPrNumber,
+        checkoutTarget,
+        repoRoot: params.repoRoot,
+        deps: params.deps,
+    });
+    const baseRefName = checkoutTarget?.baseRefName?.trim() ||
+        (await resolveDefaultBranch(params.repoRoot, params.deps));
+    const localBranchName = buildGitHubPrLocalBranchName({ headRef, checkoutTarget });
+    const pushRemoteUrl = checkoutTarget?.isCrossRepository
+        ? checkoutTarget.headRepositorySshUrl || checkoutTarget.headRepositoryUrl || undefined
+        : undefined;
+    const trackOriginHead = checkoutTarget ? !checkoutTarget.isCrossRepository : false;
+    return {
+        kind: "checkout-github-pr",
+        githubPrNumber: params.githubPrNumber,
+        headRef,
+        baseRefName,
+        ...(localBranchName !== headRef ? { localBranchName } : {}),
+        ...(pushRemoteUrl ? { pushRemoteUrl } : {}),
+        ...(trackOriginHead ? { trackOriginHead } : {}),
+    };
+}
+async function resolveGitHubPrCheckoutTarget(params) {
+    if (!params.deps.github.getPullRequestCheckoutTarget) {
+        return null;
+    }
+    return params.deps.github.getPullRequestCheckoutTarget({
+        cwd: params.repoRoot,
+        number: params.githubPrNumber,
+    });
+}
+async function resolveDefaultBranch(repoRoot, deps) {
+    const baseBranch = await deps.resolveDefaultBranch(repoRoot);
+    if (!baseBranch) {
+        throw new Error("Unable to resolve repository default branch");
+    }
+    return baseBranch;
+}
+async function resolveGitHubPrHeadRef(params) {
+    const trimmedRefName = params.refName?.trim();
+    if (trimmedRefName) {
+        return trimmedRefName;
+    }
+    const checkoutTargetHeadRef = params.checkoutTarget?.headRefName.trim();
+    if (checkoutTargetHeadRef) {
+        return checkoutTargetHeadRef;
+    }
+    return params.deps.github.getPullRequestHeadRef({
+        cwd: params.repoRoot,
+        number: params.githubPrNumber,
+    });
+}
+function buildGitHubPrLocalBranchName(params) {
+    const owner = params.checkoutTarget?.isCrossRepository
+        ? normalizeGitHubOwnerForBranch(params.checkoutTarget.headOwnerLogin)
+        : null;
+    return owner ? `${owner}/${params.headRef}` : params.headRef;
+}
+function normalizeGitHubOwnerForBranch(owner) {
+    const normalized = owner?.trim().toLowerCase() ?? "";
+    return /^[a-z0-9-]+$/.test(normalized) ? normalized : null;
+}
+//# sourceMappingURL=resolve-worktree-creation-intent.js.map

package/dist/server/server/schedule/cron.d.ts

@@ -0,0 +1,4 @@
+import type { ScheduleCadence } from "@hyperdrive.bot/paseo-protocol/schedule/types";
+export declare function validateScheduleCadence(cadence: ScheduleCadence): void;
+export declare function computeNextRunAt(cadence: ScheduleCadence, after: Date): Date;
+//# sourceMappingURL=cron.d.ts.map

package/dist/server/server/schedule/cron.js

@@ -0,0 +1,81 @@
+import { parseCronExpression } from "@hyperdrive.bot/paseo-protocol/schedule/cron-expression";
+function startOfNextMinute(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes() + 1, 0, 0));
+}
+function assertValidTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone }).format(new Date(0));
+    }
+    catch {
+        throw new Error(`Invalid cron time zone: ${timeZone}`);
+    }
+}
+function createCronDatePartsReader(timeZone) {
+    if (timeZone === undefined) {
+        return (date) => ({
+            minute: date.getUTCMinutes(),
+            hour: date.getUTCHours(),
+            dayOfMonth: date.getUTCDate(),
+            month: date.getUTCMonth() + 1,
+            dayOfWeek: date.getUTCDay(),
+        });
+    }
+    assertValidTimeZone(timeZone);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+    return (date) => {
+        const values = {};
+        for (const part of formatter.formatToParts(date)) {
+            if (part.type !== "literal") {
+                values[part.type] = part.value;
+            }
+        }
+        const year = Number.parseInt(values.year, 10);
+        const month = Number.parseInt(values.month, 10);
+        const dayOfMonth = Number.parseInt(values.day, 10);
+        return {
+            minute: Number.parseInt(values.minute, 10),
+            hour: Number.parseInt(values.hour, 10),
+            dayOfMonth,
+            month,
+            dayOfWeek: new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay(),
+        };
+    };
+}
+export function validateScheduleCadence(cadence) {
+    if (cadence.type === "cron") {
+        parseCronExpression(cadence.expression);
+        if (cadence.timezone !== undefined) {
+            assertValidTimeZone(cadence.timezone);
+        }
+    }
+}
+export function computeNextRunAt(cadence, after) {
+    if (cadence.type === "every") {
+        return new Date(after.getTime() + cadence.everyMs);
+    }
+    const cron = parseCronExpression(cadence.expression);
+    const readDateParts = createCronDatePartsReader(cadence.timezone);
+    const limit = 366 * 24 * 60;
+    let cursor = startOfNextMinute(after);
+    for (let index = 0; index < limit; index += 1) {
+        const { minute, hour, dayOfMonth, month, dayOfWeek } = readDateParts(cursor);
+        if (cron.minute.matches(minute) &&
+            cron.hour.matches(hour) &&
+            cron.dayOfMonth.matches(dayOfMonth) &&
+            cron.month.matches(month) &&
+            cron.dayOfWeek.matches(dayOfWeek)) {
+            return cursor;
+        }
+        cursor = new Date(cursor.getTime() + 60000);
+    }
+    throw new Error(`Unable to compute next run time for cron expression: ${cadence.expression}`);
+}
+//# sourceMappingURL=cron.js.map

package/dist/server/server/schedule/service.d.ts

@@ -0,0 +1,52 @@
+import type { Logger } from "pino";
+import { AgentManager } from "../agent/agent-manager.js";
+import type { AgentStorage } from "../agent/agent-storage.js";
+import type { ProviderSnapshotManager } from "../agent/provider-snapshot-manager.js";
+import type { CreateScheduleInput, ScheduleExecutionResult, ScheduleRun, StoredSchedule, UpdateScheduleInput } from "@hyperdrive.bot/paseo-protocol/schedule/types";
+export declare class ScheduleTargetGoneError extends Error {
+    constructor(message: string);
+}
+type CreateConfigResolver = Pick<ProviderSnapshotManager, "resolveCreateConfig">;
+export interface ScheduleServiceOptions {
+    paseoHome: string;
+    logger: Logger;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    providerSnapshotManager: CreateConfigResolver;
+    now?: () => Date;
+    runner?: (schedule: StoredSchedule, runId: string) => Promise<ScheduleExecutionResult>;
+}
+export declare class ScheduleService {
+    private readonly store;
+    private readonly logger;
+    private readonly agentManager;
+    private readonly agentStorage;
+    private readonly createConfigResolver;
+    private readonly now;
+    private readonly runner;
+    private readonly runningScheduleIds;
+    private tickTimer;
+    constructor(options: ScheduleServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    create(input: CreateScheduleInput): Promise<StoredSchedule>;
+    createOrReplace(input: CreateScheduleInput): Promise<StoredSchedule>;
+    list(): Promise<StoredSchedule[]>;
+    inspect(id: string): Promise<StoredSchedule>;
+    logs(id: string): Promise<ScheduleRun[]>;
+    pause(id: string): Promise<StoredSchedule>;
+    resume(id: string): Promise<StoredSchedule>;
+    update(input: UpdateScheduleInput): Promise<StoredSchedule>;
+    delete(id: string): Promise<void>;
+    completeForAgent(agentId: string): Promise<number>;
+    runOnce(id: string): Promise<StoredSchedule>;
+    tick(): Promise<void>;
+    private recoverInterruptedRuns;
+    private sweepOrphanedSchedules;
+    private runSchedule;
+    private finishRun;
+    private executeSchedule;
+    private resolveProviderCreateConfig;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map