@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/plugins/session-socket.d.ts

@@ -0,0 +1,23 @@
+import type { PluginProcessRequest } from "./plugin-process-protocol.js";
+interface PluginProcessSender {
+    send(message: PluginProcessRequest, callback?: (error: Error | null) => void): boolean;
+}
+type SocketEvent = "message" | "close" | "error";
+type SocketListener = (...args: unknown[]) => void;
+export declare class PluginSessionSocket {
+    private readonly child;
+    readyState: number;
+    bufferedAmount: number;
+    private readonly listeners;
+    private readonly onceListeners;
+    constructor(child: PluginProcessSender);
+    send(data: string | Uint8Array | ArrayBuffer, callback?: (error?: Error) => void): void;
+    receive(data: string | Uint8Array, isBinary: boolean): void;
+    close(code?: number, reason?: string): void;
+    peerClosed(): void;
+    on(event: SocketEvent, listener: SocketListener): void;
+    once(event: "close" | "error", listener: SocketListener): void;
+    private emit;
+}
+export {};
+//# sourceMappingURL=session-socket.d.ts.map

package/dist/server/server/plugins/session-socket.js

@@ -0,0 +1,82 @@
+import { Buffer } from "node:buffer";
+function normalizeBinaryFrame(data) {
+    if (data instanceof Uint8Array) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return new Uint8Array(data);
+}
+function frameByteLength(data) {
+    return typeof data === "string" ? Buffer.byteLength(data) : data.byteLength;
+}
+export class PluginSessionSocket {
+    constructor(child) {
+        this.child = child;
+        this.readyState = 1;
+        this.bufferedAmount = 0;
+        this.listeners = new Map();
+        this.onceListeners = new Map();
+    }
+    send(data, callback) {
+        if (this.readyState !== 1) {
+            callback?.(new Error("Plugin session socket is closed"));
+            return;
+        }
+        const frame = typeof data === "string" ? data : normalizeBinaryFrame(data);
+        const byteLength = frameByteLength(frame);
+        this.bufferedAmount += byteLength;
+        try {
+            this.child.send({ type: "paseo_frame", data: frame, isBinary: typeof frame !== "string" }, (error) => {
+                this.bufferedAmount = Math.max(0, this.bufferedAmount - byteLength);
+                callback?.(error ?? undefined);
+            });
+        }
+        catch (error) {
+            this.bufferedAmount = Math.max(0, this.bufferedAmount - byteLength);
+            callback?.(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    receive(data, isBinary) {
+        if (this.readyState !== 1)
+            return;
+        this.emit("message", data, isBinary);
+    }
+    close(code, reason) {
+        if (this.readyState === 3)
+            return;
+        this.readyState = 3;
+        try {
+            this.child.send({ type: "paseo_close" });
+        }
+        catch {
+            // The child has already gone; local session cleanup still has to run.
+        }
+        this.emit("close", code, reason);
+    }
+    peerClosed() {
+        if (this.readyState === 3)
+            return;
+        this.readyState = 3;
+        this.emit("close");
+    }
+    on(event, listener) {
+        const listeners = this.listeners.get(event) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(event, listeners);
+    }
+    once(event, listener) {
+        const listeners = this.onceListeners.get(event) ?? new Set();
+        listeners.add(listener);
+        this.onceListeners.set(event, listeners);
+    }
+    emit(event, ...args) {
+        for (const listener of this.listeners.get(event) ?? [])
+            listener(...args);
+        const once = this.onceListeners.get(event);
+        if (!once)
+            return;
+        this.onceListeners.delete(event);
+        for (const listener of once)
+            listener(...args);
+    }
+}
+//# sourceMappingURL=session-socket.js.map

package/dist/server/server/plugins/settings/index.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { type SettingsDefinition } from "@camerontaylor/paseo-plugin";
+/** One instance per installation. The subprocess lifetime gives writes a single owner. */
+export declare class PluginSettingsStore {
+    private readonly definitions;
+    private queue;
+    private readonly directory;
+    private readonly changed;
+    constructor(directory: string, changed: (id: string) => void);
+    register(definition: SettingsDefinition): {
+        read: {
+            contract: import("@camerontaylor/paseo-plugin").PluginRpcContract<z.ZodObject<{}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"ready">;
+                revision: z.ZodString;
+                values: z.ZodJSONSchema;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"invalid">;
+                revision: z.ZodString;
+                error: z.ZodString;
+            }, z.core.$strip>], "status">>;
+            handle: () => Promise<{
+                status: "ready";
+                revision: string;
+                values: z.core.util.JSONType;
+            } | {
+                status: "invalid";
+                revision: string;
+                error: string;
+            }>;
+        };
+        write: {
+            contract: import("@camerontaylor/paseo-plugin").PluginRpcContract<z.ZodObject<{
+                revision: z.ZodString;
+                values: z.ZodJSONSchema;
+            }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"saved">;
+                revision: z.ZodString;
+                values: z.ZodJSONSchema;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"conflict">;
+                error: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"invalid">;
+                error: z.ZodString;
+            }, z.core.$strip>], "status">>;
+            handle: (input: z.output<z.ZodObject<{
+                revision: z.ZodString;
+                values: z.ZodJSONSchema;
+            }, z.core.$strip>>) => Promise<{
+                status: "saved";
+                revision: string;
+                values: z.core.util.JSONType;
+            } | {
+                status: "conflict";
+                error: string;
+            } | {
+                status: "invalid";
+                error: string;
+            }>;
+        };
+        reset: {
+            contract: import("@camerontaylor/paseo-plugin").PluginRpcContract<z.ZodObject<{
+                revision: z.ZodString;
+            }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"saved">;
+                revision: z.ZodString;
+                values: z.ZodJSONSchema;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"conflict">;
+                error: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"invalid">;
+                error: z.ZodString;
+            }, z.core.$strip>], "status">>;
+            handle: (input: z.output<z.ZodObject<{
+                revision: z.ZodString;
+            }, z.core.$strip>>) => Promise<{
+                status: "saved";
+                revision: string;
+                values: z.core.util.JSONType;
+            } | {
+                status: "conflict";
+                error: string;
+            } | {
+                status: "invalid";
+                error: string;
+            }>;
+        };
+    };
+    private serial;
+    private stored;
+    private read;
+    private write;
+    private persist;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/plugins/settings/index.js

@@ -0,0 +1,115 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { defineSettings } from "@camerontaylor/paseo-plugin";
+import { settingsRpc } from "@camerontaylor/paseo-plugin";
+const envelopeSchema = z.object({ version: z.number().int().positive(), values: z.json() });
+function message(error) {
+    if (error instanceof z.ZodError)
+        return error.issues.map((issue) => issue.message).join("\n");
+    return error instanceof Error ? error.message : String(error);
+}
+const revisionOf = (raw) => createHash("sha256").update(raw).digest("hex");
+/** One instance per installation. The subprocess lifetime gives writes a single owner. */
+export class PluginSettingsStore {
+    constructor(directory, changed) {
+        this.definitions = new Map();
+        this.queue = Promise.resolve();
+        this.directory = directory;
+        this.changed = changed;
+    }
+    register(definition) {
+        defineSettings(definition);
+        if (this.definitions.has(definition.id))
+            throw new Error(`Duplicate settings: ${definition.id}`);
+        this.definitions.set(definition.id, definition);
+        const rpc = settingsRpc(definition.id);
+        return {
+            read: { contract: rpc.read, handle: () => this.serial(() => this.read(definition)) },
+            write: {
+                contract: rpc.write,
+                handle: (input) => this.serial(() => this.write(definition, input.revision, input.values, "save")),
+            },
+            reset: {
+                contract: rpc.reset,
+                handle: (input) => this.serial(() => this.write(definition, input.revision, {}, "reset")),
+            },
+        };
+    }
+    serial(work) {
+        const pending = this.queue.then(work);
+        this.queue = pending.catch(() => undefined);
+        return pending;
+    }
+    async stored(id) {
+        try {
+            const raw = await readFile(path.join(this.directory, `${id}.json`), "utf8");
+            return { raw, revision: revisionOf(raw) };
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+                return { raw: null, revision: "missing" };
+            throw error;
+        }
+    }
+    async read(definition) {
+        const stored = await this.stored(definition.id);
+        try {
+            const envelope = stored.raw === null ? null : envelopeSchema.parse(JSON.parse(stored.raw));
+            let values = envelope?.values ?? {};
+            if (envelope && envelope.version !== definition.version) {
+                if (envelope.version > definition.version)
+                    throw new Error("Settings were saved by a newer plugin version");
+                if (!definition.migrate)
+                    throw new Error(`Settings version ${envelope.version} requires a migration`);
+                values = await definition.migrate(values, envelope.version);
+            }
+            const parsed = z.json().parse(await definition.schema.parseAsync(values));
+            const revision = envelope && envelope.version !== definition.version
+                ? await this.persist(definition, parsed)
+                : stored.revision;
+            return { status: "ready", values: parsed, revision };
+        }
+        catch (error) {
+            return { status: "invalid", revision: stored.revision, error: message(error) };
+        }
+    }
+    async write(definition, revision, values, intent) {
+        const stored = await this.stored(definition.id);
+        if (stored.revision !== revision)
+            return {
+                status: "conflict",
+                error: "Settings changed on another client. Reload before saving again.",
+            };
+        let parsed;
+        try {
+            if (intent === "save" && stored.raw !== null) {
+                const envelope = envelopeSchema.parse(JSON.parse(stored.raw));
+                if (envelope.version !== definition.version)
+                    throw new Error("Reload or reset settings before saving a different schema version");
+            }
+            parsed = z.json().parse(await definition.schema.parseAsync(values));
+        }
+        catch (error) {
+            return { status: "invalid", error: message(error) };
+        }
+        return { status: "saved", values: parsed, revision: await this.persist(definition, parsed) };
+    }
+    async persist(definition, values) {
+        await mkdir(this.directory, { recursive: true });
+        const target = path.join(this.directory, `${definition.id}.json`);
+        const temporary = `${target}.${randomUUID()}.tmp`;
+        const raw = JSON.stringify({ version: definition.version, values });
+        try {
+            await writeFile(temporary, raw, { mode: 0o600 });
+            await rename(temporary, target);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        this.changed(definition.id);
+        return revisionOf(raw);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/private-files.d.ts

@@ -0,0 +1,6 @@
+export declare const PRIVATE_DIRECTORY_MODE = 448;
+export declare const PRIVATE_FILE_MODE = 384;
+export declare function ensurePrivateDirectory(directoryPath: string): void;
+export declare function ensurePrivateFile(filePath: string): void;
+export declare function writePrivateFileAtomicSync(filePath: string, data: string | NodeJS.ArrayBufferView): void;
+//# sourceMappingURL=private-files.d.ts.map

package/dist/server/server/private-files.js

@@ -0,0 +1,37 @@
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+export const PRIVATE_DIRECTORY_MODE = 0o700;
+export const PRIVATE_FILE_MODE = 0o600;
+function applyPrivateMode(target, mode) {
+    if (process.platform === "win32")
+        return;
+    try {
+        chmodSync(target, mode);
+    }
+    catch {
+        // Permissions are not portable; creation must still work on such filesystems.
+    }
+}
+export function ensurePrivateDirectory(directoryPath) {
+    mkdirSync(directoryPath, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    applyPrivateMode(directoryPath, PRIVATE_DIRECTORY_MODE);
+}
+export function ensurePrivateFile(filePath) {
+    applyPrivateMode(filePath, PRIVATE_FILE_MODE);
+}
+export function writePrivateFileAtomicSync(filePath, data) {
+    ensurePrivateDirectory(path.dirname(filePath));
+    const parent = path.dirname(filePath);
+    const temporary = path.join(parent, `.${path.basename(filePath)}.${process.pid}.${randomUUID()}`);
+    try {
+        writeFileSync(temporary, data, { mode: PRIVATE_FILE_MODE });
+        renameSync(temporary, filePath);
+        ensurePrivateFile(filePath);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+}
+//# sourceMappingURL=private-files.js.map

package/dist/server/server/process-diagnostics.d.ts

@@ -0,0 +1,17 @@
+export interface ProcessMemoryDiagnostics {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+}
+export interface ProcessDiagnostics {
+    pid: number;
+    ppid: number;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
+}
+export declare function getProcessMemoryDiagnostics(): ProcessMemoryDiagnostics;
+export declare function getProcessUptimeSeconds(): number;
+export declare function getProcessDiagnostics(): ProcessDiagnostics;
+//# sourceMappingURL=process-diagnostics.d.ts.map

package/dist/server/server/process-diagnostics.js

@@ -0,0 +1,22 @@
+export function getProcessMemoryDiagnostics() {
+    const memory = process.memoryUsage();
+    return {
+        rss: memory.rss,
+        heapTotal: memory.heapTotal,
+        heapUsed: memory.heapUsed,
+        external: memory.external,
+        arrayBuffers: memory.arrayBuffers,
+    };
+}
+export function getProcessUptimeSeconds() {
+    return Math.round(process.uptime() * 1000) / 1000;
+}
+export function getProcessDiagnostics() {
+    return {
+        pid: process.pid,
+        ppid: process.ppid,
+        uptimeSeconds: getProcessUptimeSeconds(),
+        memory: getProcessMemoryDiagnostics(),
+    };
+}
+//# sourceMappingURL=process-diagnostics.js.map

package/dist/server/server/project-directory-service.d.ts

@@ -0,0 +1,30 @@
+import type { ProjectCreateDirectoryErrorCode } from "@camerontaylor/paseo-protocol/messages";
+import type { PersistedProjectRecord } from "./workspace-registry.js";
+export declare class ProjectDirectoryRequestError extends Error {
+    readonly code: ProjectCreateDirectoryErrorCode;
+    readonly directoryPath: string | null;
+    constructor(code: ProjectCreateDirectoryErrorCode, message: string, directoryPath?: string | null);
+}
+export interface CreateProjectDirectoryInput {
+    parentPath: string;
+    name: string;
+}
+export interface CreateProjectDirectoryResult {
+    directoryPath: string;
+    project: PersistedProjectRecord;
+}
+interface ProjectDirectoryFileSystem {
+    stat(path: string): Promise<{
+        isDirectory(): boolean;
+    }>;
+    mkdir(path: string): Promise<void>;
+    rmdir(path: string): Promise<void>;
+}
+interface CreateProjectDirectoryDependencies {
+    filesystem?: ProjectDirectoryFileSystem;
+    registerProject(directoryPath: string): Promise<PersistedProjectRecord>;
+}
+export declare function createProjectDirectory(input: CreateProjectDirectoryInput, dependencies: CreateProjectDirectoryDependencies): Promise<CreateProjectDirectoryResult>;
+export declare function validateDirectoryName(name: string): void;
+export {};
+//# sourceMappingURL=project-directory-service.d.ts.map

package/dist/server/server/project-directory-service.js

@@ -0,0 +1,120 @@
+import { mkdir, rmdir, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep, win32 } from "node:path";
+import { expandTilde } from "../utils/path.js";
+export class ProjectDirectoryRequestError extends Error {
+    constructor(code, message, directoryPath = null) {
+        super(message);
+        this.code = code;
+        this.directoryPath = directoryPath;
+        this.name = "ProjectDirectoryRequestError";
+    }
+}
+const nodeProjectDirectoryFileSystem = {
+    stat,
+    async mkdir(path) {
+        await mkdir(path);
+    },
+    rmdir,
+};
+export async function createProjectDirectory(input, dependencies) {
+    validateDirectoryName(input.name);
+    const requestedParentPath = input.parentPath.trim();
+    if (!requestedParentPath) {
+        throw new ProjectDirectoryRequestError("parent_directory_not_found", "Parent directory is required");
+    }
+    const parentDirectory = resolve(expandTilde(requestedParentPath));
+    const directoryPath = resolve(parentDirectory, input.name);
+    if (!isPathInside(parentDirectory, directoryPath)) {
+        throw new ProjectDirectoryRequestError("invalid_name", "Directory name must resolve inside the selected parent");
+    }
+    const filesystem = dependencies.filesystem ?? nodeProjectDirectoryFileSystem;
+    await requireExistingParent(filesystem, parentDirectory);
+    try {
+        await filesystem.mkdir(directoryPath);
+    }
+    catch (error) {
+        throw mapCreateDirectoryError(error, directoryPath);
+    }
+    try {
+        const project = await dependencies.registerProject(directoryPath);
+        return { directoryPath, project };
+    }
+    catch (registrationError) {
+        try {
+            await filesystem.rmdir(directoryPath);
+        }
+        catch (rollbackError) {
+            throw new ProjectDirectoryRequestError("registration_failed", `Failed to register project and roll back directory: ${errorMessage(rollbackError)}`, directoryPath);
+        }
+        throw new ProjectDirectoryRequestError("registration_failed", `Failed to register project: ${errorMessage(registrationError)}`, directoryPath);
+    }
+}
+export function validateDirectoryName(name) {
+    if (name.trim().length === 0) {
+        throw new ProjectDirectoryRequestError("invalid_name", "Directory name cannot be empty");
+    }
+    if (name !== name.trim()) {
+        throw new ProjectDirectoryRequestError("invalid_name", "Directory name cannot start or end with whitespace");
+    }
+    if (name === "." || name === "..") {
+        throw new ProjectDirectoryRequestError("invalid_name", "Directory name cannot be . or ..");
+    }
+    if (name.includes("/") || name.includes("\\") || name.includes("\0")) {
+        throw new ProjectDirectoryRequestError("invalid_name", "Directory name must be a single name without path separators");
+    }
+    if (isAbsolute(name) || win32.isAbsolute(name) || /^[A-Za-z]:/.test(name)) {
+        throw new ProjectDirectoryRequestError("invalid_name", "Directory name cannot be an absolute path");
+    }
+}
+async function requireExistingParent(filesystem, parentDirectory) {
+    try {
+        const parent = await filesystem.stat(parentDirectory);
+        if (parent.isDirectory()) {
+            return;
+        }
+        throw new ProjectDirectoryRequestError("parent_directory_not_found", `Parent directory not found: ${parentDirectory}`);
+    }
+    catch (error) {
+        if (error instanceof ProjectDirectoryRequestError) {
+            throw error;
+        }
+        const code = nodeErrorCode(error);
+        if (code === "EACCES" || code === "EPERM") {
+            throw new ProjectDirectoryRequestError("permission_denied", `Permission denied reading parent directory: ${parentDirectory}`);
+        }
+        if (code === "ENOENT" || code === "ENOTDIR") {
+            throw new ProjectDirectoryRequestError("parent_directory_not_found", `Parent directory not found: ${parentDirectory}`);
+        }
+        throw new ProjectDirectoryRequestError("filesystem_error", `Failed to inspect parent directory: ${errorMessage(error)}`);
+    }
+}
+function mapCreateDirectoryError(error, directoryPath) {
+    const code = nodeErrorCode(error);
+    if (code === "EEXIST") {
+        return new ProjectDirectoryRequestError("directory_exists", `Directory already exists: ${directoryPath}`, directoryPath);
+    }
+    if (code === "ENOENT" || code === "ENOTDIR") {
+        return new ProjectDirectoryRequestError("parent_directory_not_found", `Parent directory not found: ${resolve(directoryPath, "..")}`, directoryPath);
+    }
+    if (code === "EACCES" || code === "EPERM" || code === "EROFS") {
+        return new ProjectDirectoryRequestError("permission_denied", `Permission denied creating directory: ${directoryPath}`, directoryPath);
+    }
+    return new ProjectDirectoryRequestError("filesystem_error", `Failed to create directory: ${errorMessage(error)}`, directoryPath);
+}
+function isPathInside(parentDirectory, directoryPath) {
+    const relativePath = relative(parentDirectory, directoryPath);
+    return (relativePath.length > 0 &&
+        relativePath !== ".." &&
+        !relativePath.startsWith(`..${sep}`) &&
+        !isAbsolute(relativePath));
+}
+function nodeErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error)) {
+        return null;
+    }
+    return typeof error.code === "string" ? error.code : null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=project-directory-service.js.map

package/dist/server/server/project-key.d.ts

@@ -0,0 +1,14 @@
+/** Persisted opaque key used to join the same remote across hosts. */
+export declare function deriveProjectKey(input: {
+    rootPath: string;
+    remoteUrl: string | null;
+    worktreeRoot: string | null;
+    mainRepoRoot: string | null;
+    serverId?: string;
+}): string;
+export declare function deriveProjectGroupingDisplayName(input: {
+    rootPath: string;
+    remoteUrl: string | null;
+    worktreeRoot: string | null;
+}): string;
+//# sourceMappingURL=project-key.d.ts.map

package/dist/server/server/project-key.js

@@ -0,0 +1,44 @@
+import { resolve, win32 } from "node:path";
+import { isGitHubHost, parseGitRemoteLocation } from "@camerontaylor/paseo-protocol/git-remote";
+import { getRealpathAwareRelativePath, normalizePathForIdentity } from "../utils/path.js";
+/** Persisted opaque key used to join the same remote across hosts. */
+export function deriveProjectKey(input) {
+    const remote = input.remoteUrl ? parseGitRemoteLocation(input.remoteUrl) : null;
+    const selectedPath = input.worktreeRoot
+        ? getRealpathAwareRelativePath(input.worktreeRoot, input.rootPath) || null
+        : null;
+    if (remote) {
+        const host = remote.port ? `${remote.host}:${remote.port}` : remote.host;
+        const path = isGitHubHost(remote.host) ? remote.path.toLowerCase() : remote.path;
+        const remoteKey = `remote:${host}/${path}`;
+        return selectedPath ? `${remoteKey}#subdir:${selectedPath.replaceAll("\\", "/")}` : remoteKey;
+    }
+    const localPathParts = [
+        selectedPath && input.mainRepoRoot ? input.mainRepoRoot : input.rootPath,
+        selectedPath && input.mainRepoRoot ? selectedPath : "",
+    ];
+    const resolvedLocalPath = localPathParts.some(looksLikeWindowsPath)
+        ? win32.resolve(...localPathParts)
+        : resolve(...localPathParts);
+    const localPath = normalizePathForIdentity(resolvedLocalPath);
+    return input.serverId ? `host:${input.serverId}:${localPath}` : localPath;
+}
+export function deriveProjectGroupingDisplayName(input) {
+    const selectedPath = input.worktreeRoot
+        ? getRealpathAwareRelativePath(input.worktreeRoot, input.rootPath)
+        : null;
+    if (selectedPath)
+        return lastPathSegment(input.rootPath);
+    const remote = input.remoteUrl ? parseGitRemoteLocation(input.remoteUrl) : null;
+    if (!remote)
+        return lastPathSegment(input.rootPath);
+    return remote.path.split("/").filter(Boolean).slice(-2).join("/") || input.rootPath;
+}
+function lastPathSegment(inputPath) {
+    const segments = inputPath.split(/[\\/]/u).filter(Boolean);
+    return segments[segments.length - 1] ?? inputPath;
+}
+function looksLikeWindowsPath(value) {
+    return /^[a-zA-Z]:[\\/]/u.test(value) || /^[/\\]{2}[^/\\]+[/\\][^/\\]+/u.test(value);
+}
+//# sourceMappingURL=project-key.js.map

package/dist/server/server/push/index.d.ts

@@ -0,0 +1,16 @@
+import type pino from "pino";
+import { type PushPayload } from "./push-service.js";
+export type { PushPayload };
+export interface PushNotifications {
+    renew(token: string): void;
+    revoke(token: string): void;
+    send(payload: PushPayload): Promise<void>;
+}
+export type PushNotificationSender = Pick<PushNotifications, "send">;
+export declare function createPushNotifications(options: {
+    logger: pino.Logger;
+    filePath: string;
+    now?: () => number;
+    deliver?: (tokens: string[], payload: PushPayload) => Promise<void>;
+}): PushNotifications;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/push/index.js

@@ -0,0 +1,26 @@
+import { PushService } from "./push-service.js";
+import { PushTokenStore } from "./token-store.js";
+const PUSH_TOKEN_LEASE_MS = 48 * 60 * 60 * 1000;
+export function createPushNotifications(options) {
+    const now = options.now ?? Date.now;
+    const store = new PushTokenStore(options.logger, options.filePath, now, PUSH_TOKEN_LEASE_MS);
+    const service = new PushService(options.logger, (token) => store.revokeToken(token));
+    const deliver = options.deliver ??
+        ((tokens, payload) => service.sendPush(tokens, payload));
+    return {
+        renew(token) {
+            store.renewToken(token);
+        },
+        revoke(token) {
+            store.revokeToken(token);
+        },
+        async send(payload) {
+            const tokens = store.getActiveTokens();
+            options.logger.info({ tokenCount: tokens.length }, "Sending push notification");
+            if (tokens.length === 0)
+                return;
+            await deliver(tokens, payload);
+        },
+    };
+}
+//# sourceMappingURL=index.js.map