@otto-code/server 0.5.0

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

@@ -0,0 +1,294 @@
+import { resolve } from "node:path";
+import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
+import { classifyDirectoryForProjectMembership, deriveProjectGroupingName, generateWorkspaceId, } from "./workspace-registry-model.js";
+import { createWorktreeCore, } from "./worktree-core.js";
+import { validateBranchSlug } from "../utils/worktree.js";
+import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
+import { markOttoWorktreeFirstAgentBranchAutoNameAttempted, normalizeBaseRefName, readOttoWorktreeMetadata, writeOttoWorktreeFirstAgentBranchAutoNameMetadata, } from "../utils/worktree-metadata.js";
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
+import { buildAgentBranchNameSeed } from "./agent/prompt-attachments.js";
+export async function createOttoWorktree(input, deps) {
+    const createdWorktree = await createWorktreeCore(input, deps);
+    maybeMarkFirstAgentBranchAutoNameEligible({ createdWorktree });
+    const workspace = await upsertWorkspaceForWorktree({
+        inputCwd: input.cwd,
+        projectId: input.projectId,
+        repoRoot: createdWorktree.repoRoot,
+        worktree: createdWorktree.worktree,
+        baseBranch: resolveIntentBaseBranch(createdWorktree.intent),
+        title: resolveFirstAgentPromptTitle(input.firstAgentContext),
+        deps,
+    });
+    deps.github.invalidate({ cwd: createdWorktree.worktree.worktreePath });
+    return {
+        worktree: createdWorktree.worktree,
+        intent: createdWorktree.intent,
+        workspace,
+        repoRoot: createdWorktree.repoRoot,
+        created: createdWorktree.created,
+    };
+}
+export async function attemptFirstAgentBranchAutoName(options) {
+    const firstAgentContext = options.firstAgentContext;
+    if (!firstAgentContext || !buildAgentBranchNameSeed(firstAgentContext)) {
+        return { attempted: false, renamed: false, branchName: null };
+    }
+    let metadata;
+    try {
+        metadata = readOttoWorktreeMetadata(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) {
+        markOttoWorktreeFirstAgentBranchAutoNameAttempted(options.cwd);
+        return { attempted: true, renamed: false, branchName: null };
+    }
+    markOttoWorktreeFirstAgentBranchAutoNameAttempted(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;
+    }
+    writeOttoWorktreeFirstAgentBranchAutoNameMetadata(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-github-pr":
+            return normalizeBaseRefName(intent.baseRefName);
+        case "checkout-branch":
+            return null;
+    }
+}
+async function upsertWorkspaceForWorktree(options) {
+    const normalizedCwd = resolve(options.worktree.worktreePath);
+    const normalizedInputCwd = resolve(options.inputCwd);
+    const normalizedRepoRoot = resolve(options.repoRoot);
+    // Creation never deduplicates by directory: a worktree directory may back
+    // more than one workspace. We still resolve the source project from the
+    // originating checkout, but always mint a fresh workspace record.
+    const sourceProject = await resolveSourceProjectForWorktree({
+        inputCwd: normalizedInputCwd,
+        projectId: options.projectId,
+        repoRoot: normalizedRepoRoot,
+        existingWorkspace: null,
+        deps: options.deps,
+    });
+    const workspaceId = generateWorkspaceId();
+    const now = new Date().toISOString();
+    await options.deps.projectRegistry.upsert(createPersistedProjectRecord({
+        projectId: sourceProject.projectId,
+        rootPath: sourceProject.rootPath,
+        kind: sourceProject.kind,
+        displayName: sourceProject.displayName,
+        customName: sourceProject.customName,
+        createdAt: sourceProject.createdAt ?? now,
+        updatedAt: now,
+        archivedAt: null,
+    }));
+    const workspace = createPersistedWorkspaceRecord({
+        workspaceId,
+        projectId: sourceProject.projectId,
+        cwd: normalizedCwd,
+        kind: "worktree",
+        displayName: options.worktree.branchName || normalizedCwd,
+        branch: options.worktree.branchName || null,
+        baseBranch: options.baseBranch ?? null,
+        title: options.title ?? null,
+        createdAt: now,
+        updatedAt: now,
+        archivedAt: null,
+    });
+    await options.deps.workspaceRegistry.upsert(workspace);
+    return (await options.deps.workspaceRegistry.get(workspace.workspaceId)) ?? workspace;
+}
+// Always create a NEW workspace record backed by the existing directory `cwd`.
+// Never reuses a same-cwd record: a directory may back any number of
+// workspaces. Used by explicit user creation.
+export async function createLocalCheckoutWorkspace(options, deps) {
+    const normalizedCwd = resolve(options.cwd);
+    const checkout = await deps.workspaceGitService.getCheckout(normalizedCwd);
+    const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
+    const now = new Date().toISOString();
+    const projectRecord = await resolveProjectRecordForMembership({
+        membership,
+        timestamp: now,
+        projectRegistry: deps.projectRegistry,
+    });
+    await deps.projectRegistry.upsert(projectRecord);
+    const trimmedTitle = options.title?.trim();
+    // Persist the live git branch into the dedicated `branch` field so
+    // buildWorkspaceCheckout reports the real branch for directory/local_checkout
+    // workspaces too (it reads workspace.branch). Same source deriveWorkspaceDisplayName
+    // reads. HEAD/detached resolves to null — there is no branch to report.
+    const currentBranch = checkout.currentBranch?.trim() ?? null;
+    const branch = currentBranch && currentBranch.toUpperCase() !== "HEAD" ? currentBranch : null;
+    const workspace = createPersistedWorkspaceRecord({
+        workspaceId: generateWorkspaceId(),
+        projectId: projectRecord.projectId,
+        cwd: normalizedCwd,
+        kind: membership.workspaceKind,
+        displayName: membership.workspaceDisplayName,
+        branch,
+        title: trimmedTitle ? trimmedTitle : null,
+        createdAt: now,
+        updatedAt: now,
+    });
+    await deps.workspaceRegistry.upsert(workspace);
+    return workspace;
+}
+async function resolveProjectRecordForMembership(options) {
+    const rootPath = options.membership.projectRootPath;
+    const projects = await options.projectRegistry.list();
+    const existingProject = projects.find((project) => !project.archivedAt && project.rootPath === rootPath) ??
+        projects.find((project) => project.rootPath === rootPath) ??
+        null;
+    if (!existingProject) {
+        return createPersistedProjectRecord({
+            projectId: options.membership.projectKey,
+            rootPath,
+            kind: options.membership.projectKind,
+            displayName: options.membership.projectName,
+            createdAt: options.timestamp,
+            updatedAt: options.timestamp,
+        });
+    }
+    return {
+        ...existingProject,
+        rootPath,
+        kind: options.membership.projectKind,
+        archivedAt: null,
+        updatedAt: options.timestamp,
+    };
+}
+function sourceProjectFromRecord(record) {
+    return {
+        projectId: record.projectId,
+        rootPath: record.rootPath,
+        kind: "git",
+        displayName: record.displayName,
+        customName: record.customName ?? null,
+        createdAt: record.createdAt ?? null,
+    };
+}
+async function resolveExplicitProjectForWorktree(options) {
+    const project = await options.projectRegistry.get(options.projectId);
+    if (!project || project.archivedAt) {
+        throw new Error(`Project not found for worktree: ${options.projectId}`);
+    }
+    return sourceProjectFromRecord(project);
+}
+async function resolveWorkspaceProjectForWorktree(options) {
+    const sourceProject = await options.projectRegistry.get(options.sourceWorkspace.projectId);
+    return sourceProjectFromRecord({
+        projectId: options.sourceWorkspace.projectId,
+        rootPath: sourceProject?.rootPath ?? options.repoRoot,
+        displayName: sourceProject?.displayName ?? deriveProjectGroupingName(options.sourceWorkspace.projectId),
+        customName: sourceProject?.customName ?? null,
+        createdAt: sourceProject?.createdAt ?? null,
+    });
+}
+async function resolveFallbackProjectForWorktree(options) {
+    const existingFallbackProject = await options.projectRegistry.get(options.repoRoot);
+    return sourceProjectFromRecord({
+        projectId: options.repoRoot,
+        rootPath: existingFallbackProject?.rootPath ?? options.repoRoot,
+        displayName: existingFallbackProject?.displayName ?? deriveProjectGroupingName(options.repoRoot),
+        customName: existingFallbackProject?.customName ?? null,
+        createdAt: existingFallbackProject?.createdAt ?? null,
+    });
+}
+async function resolveSourceProjectForWorktree(options) {
+    if (options.projectId) {
+        return resolveExplicitProjectForWorktree({
+            projectId: options.projectId,
+            projectRegistry: options.deps.projectRegistry,
+        });
+    }
+    const sourceWorkspace = options.existingWorkspace ??
+        (await findWorkspaceForSource({
+            inputCwd: options.inputCwd,
+            repoRoot: options.repoRoot,
+            workspaceRegistry: options.deps.workspaceRegistry,
+        }));
+    if (sourceWorkspace) {
+        return resolveWorkspaceProjectForWorktree({
+            sourceWorkspace,
+            repoRoot: options.repoRoot,
+            projectRegistry: options.deps.projectRegistry,
+        });
+    }
+    return resolveFallbackProjectForWorktree({
+        repoRoot: options.repoRoot,
+        projectRegistry: options.deps.projectRegistry,
+    });
+}
+async function findWorkspaceForSource(options) {
+    const workspaces = await options.workspaceRegistry.list();
+    return (workspaces.find((workspace) => workspace.cwd === options.inputCwd && !workspace.archivedAt) ??
+        workspaces.find((workspace) => workspace.cwd === options.repoRoot && !workspace.archivedAt) ??
+        null);
+}
+//# sourceMappingURL=otto-worktree-service.js.map

package/dist/server/server/package-version.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+interface ResolvePackageVersionParams {
+    moduleUrl?: string;
+    packageName: string;
+}
+export declare const packageJsonSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PackageJson = z.infer<typeof packageJsonSchema>;
+export declare class PackageVersionResolutionError extends Error {
+    constructor(params: {
+        moduleUrl: string;
+        packageName: string;
+    });
+}
+export declare function resolvePackageVersion(params: ResolvePackageVersionParams): string;
+export {};
+//# sourceMappingURL=package-version.d.ts.map

package/dist/server/server/package-version.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+export const packageJsonSchema = z.object({
+    name: z.string().optional(),
+    version: z.string().optional(),
+});
+function parsePackageJson(raw) {
+    const result = packageJsonSchema.safeParse(raw);
+    return result.success ? result.data : null;
+}
+export class PackageVersionResolutionError extends Error {
+    constructor(params) {
+        super(`Unable to resolve ${params.packageName} version from module URL ${params.moduleUrl}.`);
+        this.name = "PackageVersionResolutionError";
+    }
+}
+function readMatchingPackageVersion(packageJsonPath, packageName, moduleUrl) {
+    let packageJson;
+    try {
+        const parsed = parsePackageJson(JSON.parse(readFileSync(packageJsonPath, "utf8")));
+        if (!parsed)
+            return null;
+        packageJson = parsed;
+    }
+    catch {
+        return null;
+    }
+    if (packageJson.name !== packageName) {
+        return null;
+    }
+    if (typeof packageJson.version === "string" && packageJson.version.trim().length > 0) {
+        return packageJson.version.trim();
+    }
+    throw new PackageVersionResolutionError({ moduleUrl, packageName });
+}
+export function resolvePackageVersion(params) {
+    const moduleUrl = params.moduleUrl ?? import.meta.url;
+    let currentDir = path.dirname(fileURLToPath(moduleUrl));
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const version = readMatchingPackageVersion(packageJsonPath, params.packageName, moduleUrl);
+            if (version !== null) {
+                return version;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw new PackageVersionResolutionError({
+        moduleUrl,
+        packageName: params.packageName,
+    });
+}
+//# sourceMappingURL=package-version.js.map

package/dist/server/server/pagination/cursor.d.ts

@@ -0,0 +1,16 @@
+export interface CursorSortEntry<K extends string> {
+    key: K;
+    direction: "asc" | "desc";
+}
+export type CursorSortValue = string | number | null;
+export interface DecodedCursor<K extends string> {
+    sort: CursorSortEntry<K>[];
+    values: Record<string, CursorSortValue>;
+    id: string;
+}
+export declare class CursorError extends Error {
+    constructor(message: string);
+}
+export declare function encodeCursor<E, K extends string>(entry: E, sort: readonly CursorSortEntry<K>[], getId: (entry: E) => string, getValue: (entry: E, key: K) => CursorSortValue): string;
+export declare function decodeCursor<K extends string>(cursor: string, sort: readonly CursorSortEntry<K>[], validKeys: readonly K[], label: string): DecodedCursor<K>;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/server/server/pagination/cursor.js

@@ -0,0 +1,62 @@
+export class CursorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CursorError";
+    }
+}
+export function encodeCursor(entry, sort, getId, getValue) {
+    const values = {};
+    for (const spec of sort) {
+        values[spec.key] = getValue(entry, spec.key);
+    }
+    return Buffer.from(JSON.stringify({ sort, values, id: getId(entry) }), "utf8").toString("base64url");
+}
+export function decodeCursor(cursor, sort, validKeys, label) {
+    const invalid = new CursorError(`Invalid ${label} cursor`);
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    }
+    catch {
+        throw invalid;
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw invalid;
+    }
+    const payload = parsed;
+    if (!Array.isArray(payload.sort) || typeof payload.id !== "string") {
+        throw invalid;
+    }
+    if (!payload.values || typeof payload.values !== "object") {
+        throw invalid;
+    }
+    const cursorSort = parseCursorSort(payload.sort, validKeys, label);
+    if (cursorSort.length !== sort.length ||
+        cursorSort.some((entry, index) => entry.key !== sort[index]?.key || entry.direction !== sort[index]?.direction)) {
+        throw new CursorError(`${label} cursor does not match current sort`);
+    }
+    return {
+        sort: cursorSort,
+        values: payload.values,
+        id: payload.id,
+    };
+}
+function parseCursorSort(raw, validKeys, label) {
+    const result = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object") {
+            throw new CursorError(`Invalid ${label} cursor`);
+        }
+        const { key, direction } = item;
+        if (typeof key !== "string" || typeof direction !== "string") {
+            throw new CursorError(`Invalid ${label} cursor`);
+        }
+        if (!validKeys.includes(key) ||
+            (direction !== "asc" && direction !== "desc")) {
+            throw new CursorError(`Invalid ${label} cursor`);
+        }
+        result.push({ key: key, direction });
+    }
+    return result;
+}
+//# sourceMappingURL=cursor.js.map

package/dist/server/server/pagination/sortable-pager.d.ts

@@ -0,0 +1,24 @@
+import { CursorError, type CursorSortValue, type DecodedCursor } from "./cursor.js";
+export interface SortSpec<K extends string> {
+    key: K;
+    direction: "asc" | "desc";
+}
+export interface SortablePagerConfig<TItem, K extends string> {
+    validKeys: readonly K[];
+    defaultSort: readonly SortSpec<K>[];
+    label: string;
+    getId: (item: TItem) => string;
+    getSortValue: (item: TItem, key: K) => CursorSortValue;
+}
+export declare class SortablePager<TItem, K extends string> {
+    private readonly config;
+    constructor(config: SortablePagerConfig<TItem, K>);
+    normalizeSort(sort: readonly SortSpec<K>[] | undefined): SortSpec<K>[];
+    compare(left: TItem, right: TItem, sort: readonly SortSpec<K>[]): number;
+    compareWithCursor(item: TItem, cursor: DecodedCursor<K>, sort: readonly SortSpec<K>[]): number;
+    encode(item: TItem, sort: readonly SortSpec<K>[]): string;
+    decode(token: string, sort: readonly SortSpec<K>[]): DecodedCursor<K>;
+}
+export { CursorError };
+export declare function compareValues(left: CursorSortValue, right: CursorSortValue): number;
+//# sourceMappingURL=sortable-pager.d.ts.map

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: {
+    ottoHome: 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.otto-code.me:443";
+    const relayPublicEndpoint = args.relayPublicEndpoint ?? relayEndpoint;
+    const relayUseTls = args.relayUseTls ?? relayEndpoint === "relay.otto-code.me:443";
+    const relayPublicUseTls = args.relayPublicUseTls ?? relayUseTls;
+    const appBaseUrl = args.appBaseUrl ?? "https://app.otto-code.me";
+    const serverId = getOrCreateServerId(args.ottoHome, { logger: args.logger });
+    const daemonKeyPair = await loadOrCreateDaemonKeyPair(args.ottoHome, 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,7 @@
+import type { Logger } from "pino";
+export declare function renderPairingQr(url: string): Promise<string>;
+export declare function printPairingQrIfEnabled(args: {
+    url: string;
+    logger?: Logger;
+}): Promise<void>;
+//# sourceMappingURL=pairing-qr.d.ts.map

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

@@ -0,0 +1,45 @@
+import * as QRCode from "qrcode";
+function parseBooleanEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "y", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "n", "off"].includes(normalized))
+        return false;
+    return undefined;
+}
+function shouldPrintPairingQr() {
+    const env = parseBooleanEnv(process.env.OTTO_PAIRING_QR);
+    if (env !== undefined)
+        return env;
+    return process.stdout.isTTY ?? false;
+}
+export async function renderPairingQr(url) {
+    const terminalOptions = {
+        type: "terminal",
+        small: true,
+    };
+    const utf8Options = {
+        type: "utf8",
+    };
+    try {
+        return await QRCode.toString(url, terminalOptions);
+    }
+    catch {
+        return await QRCode.toString(url, utf8Options);
+    }
+}
+export async function printPairingQrIfEnabled(args) {
+    if (!shouldPrintPairingQr())
+        return;
+    const qr = await renderPairingQr(args.url);
+    const out = `\nScan to pair:\n${qr}\n${args.url}\n`;
+    try {
+        process.stdout.write(out);
+    }
+    catch (error) {
+        args.logger?.debug({ error }, "Failed to print pairing QR");
+    }
+}
+//# sourceMappingURL=pairing-qr.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