@otto-code/server 0.5.0

package/dist/server/server/artifact/artifact-watcher.js

@@ -0,0 +1,146 @@
+import { readFileSync, watch as fsWatch, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { validateHtmlFile } from "./html-validator.js";
+const BATCH_POLL_INTERVAL_MS = 1000;
+export class ArtifactWatcher {
+    constructor(options) {
+        this.activeWatchers = new Map();
+        this.handles = new Map();
+        this.batchPollTimer = null;
+        this.store = options.store;
+        this.logger = options.logger.child({ module: "artifact-watcher" });
+        this.sendNotification = options.sendNotification;
+        this.timeoutMs = options.timeoutMs;
+        this.onTimeout = options.onTimeout;
+    }
+    watch(artifactId, filePath, onReady) {
+        if (this.handles.has(artifactId)) {
+            return;
+        }
+        const handle = { watcher: null, timeoutTimer: null, onReady: onReady ?? null };
+        this.handles.set(artifactId, handle);
+        const validation = validateHtmlFile(filePath);
+        if (validation.isValid) {
+            this.writeSanitizedContent(filePath, validation.content);
+            this.updateToReady(artifactId);
+            return;
+        }
+        const artifactsDir = dirname(filePath);
+        try {
+            handle.watcher = fsWatch(artifactsDir, { persistent: false }, () => {
+                this.checkFileReady(artifactId, filePath);
+            });
+            this.logger.debug({ artifactId, dir: artifactsDir }, "Started fs.watch on artifacts directory");
+        }
+        catch (error) {
+            this.logger.warn({ error, artifactId }, "Failed to set up fs.watch, relying on polling fallback");
+            handle.watcher = null;
+        }
+        this.activeWatchers.set(artifactId, filePath);
+        this.startBatchPolling();
+        handle.timeoutTimer = setTimeout(() => {
+            this.handleTimeout(artifactId);
+        }, this.timeoutMs);
+        handle.timeoutTimer?.unref?.();
+        this.logger.debug({ artifactId, filePath }, "Watching for artifact file creation");
+    }
+    unwatch(artifactId) {
+        const handle = this.handles.get(artifactId);
+        if (!handle)
+            return;
+        this.activeWatchers.delete(artifactId);
+        if (this.activeWatchers.size === 0) {
+            this.stopBatchPolling();
+        }
+        this.cleanupHandle(handle);
+        this.handles.delete(artifactId);
+        this.logger.debug({ artifactId }, "Stopped watching artifact");
+    }
+    stop() {
+        const count = this.handles.size;
+        this.stopBatchPolling();
+        this.activeWatchers.clear();
+        for (const handle of this.handles.values()) {
+            this.cleanupHandle(handle);
+        }
+        this.handles.clear();
+        if (count > 0) {
+            this.logger.info(`Cleaned up ${count} artifact watchers`);
+        }
+    }
+    cleanupHandle(handle) {
+        handle.watcher?.close();
+        clearTimeout(handle.timeoutTimer ?? undefined);
+    }
+    startBatchPolling() {
+        if (this.batchPollTimer)
+            return;
+        this.logger.debug("Started batch polling timer for artifacts");
+        this.batchPollTimer = setInterval(() => {
+            for (const [artifactId, filePath] of this.activeWatchers.entries()) {
+                this.checkFileReady(artifactId, filePath);
+            }
+        }, BATCH_POLL_INTERVAL_MS);
+        this.batchPollTimer?.unref?.();
+    }
+    stopBatchPolling() {
+        if (this.batchPollTimer) {
+            clearInterval(this.batchPollTimer);
+            this.batchPollTimer = null;
+            this.logger.debug("Stopped batch polling timer");
+        }
+    }
+    async checkFileReady(artifactId, filePath) {
+        const validation = validateHtmlFile(filePath);
+        if (validation.isValid) {
+            this.writeSanitizedContent(filePath, validation.content);
+            await this.updateToReady(artifactId);
+        }
+    }
+    writeSanitizedContent(filePath, content) {
+        try {
+            const original = readFileSync(filePath, "utf-8");
+            if (original !== content) {
+                writeFileSync(filePath, content, "utf-8");
+                this.logger.debug({ filePath }, "Sanitized artifact HTML content");
+            }
+        }
+        catch {
+            // Ignore errors in sanitization - not critical
+        }
+    }
+    async updateToReady(artifactId) {
+        const onReady = this.handles.get(artifactId)?.onReady;
+        this.unwatch(artifactId);
+        try {
+            await this.store.update(artifactId, { status: "ready" });
+            this.logger.info({ artifactId }, "Artifact generation complete - marked as ready");
+            onReady?.();
+            this.emitUpdatedNotification(artifactId);
+        }
+        catch (error) {
+            this.logger.error({ error, artifactId }, "Failed to update artifact status to ready");
+        }
+    }
+    handleTimeout(artifactId) {
+        // Stop the file watch immediately so a late/partial write can't flip the
+        // artifact to "ready" after we've decided it timed out. The service owns
+        // the rest of the teardown: it cancels the generation agent (so nothing
+        // lingers) and marks the artifact as timed out.
+        this.unwatch(artifactId);
+        this.logger.warn({ artifactId }, "Artifact generation timed out");
+        this.onTimeout(artifactId);
+    }
+    async emitUpdatedNotification(artifactId) {
+        try {
+            const metadata = await this.store.get(artifactId);
+            if (!metadata)
+                return;
+            this.sendNotification(metadata);
+        }
+        catch (error) {
+            this.logger.error({ error, artifactId }, "Failed to emit updated notification");
+        }
+    }
+}
+//# sourceMappingURL=artifact-watcher.js.map

package/dist/server/server/artifact/html-validator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Validates that a string contains reasonable HTML content.
+ * Does not perform full parsing - just basic structural checks.
+ */
+export declare function isValidHtmlContent(content: string): boolean;
+/**
+ * Inserts a restrictive Content-Security-Policy meta tag into the document
+ * head so artifact content cannot reach the network no matter which platform
+ * renders it. Idempotent - a document that already has one is left alone.
+ */
+export declare function injectContentSecurityPolicy(content: string): string;
+/**
+ * Sanitizes HTML content by stripping common wrapper artifacts
+ * that models might add (markdown code fences, explanations), and injecting
+ * a restrictive CSP so the artifact cannot make network calls.
+ */
+export declare function sanitizeHtmlContent(content: string): string;
+/**
+ * Validates an HTML file on disk exists and contains valid HTML.
+ * Returns the validated content or null if validation fails.
+ */
+export declare function validateHtmlFile(filePath: string): {
+    content: string;
+    isValid: boolean;
+};
+//# sourceMappingURL=html-validator.d.ts.map

package/dist/server/server/artifact/html-validator.js

@@ -0,0 +1,92 @@
+import { readFileSync, statSync } from "node:fs";
+/**
+ * Validates that a string contains reasonable HTML content.
+ * Does not perform full parsing - just basic structural checks.
+ */
+export function isValidHtmlContent(content) {
+    // Minimum length check (basic HTML needs at least ~50 chars)
+    if (content.length < 50)
+        return false;
+    // Must have HTML structure indicators
+    const hasDoctype = /<!DOCTYPE\s+html/i.test(content);
+    const hasHtmlTag = /<html[^>]*>/i.test(content);
+    const hasBasicTags = /<(head|body)/i.test(content);
+    return (hasDoctype || hasHtmlTag) && (hasBasicTags || content.includes("<"));
+}
+// Artifacts are LLM-generated HTML rendered inline (WebView/iframe/webview guest)
+// on every platform. This CSP is the one hardening layer that reaches all of
+// them regardless of renderer: it blocks the artifact from making any network
+// call (fetch/XHR/WebSocket/beacon) or framing/submitting to anywhere, while
+// still allowing the inline script/style/data-URI assets an artifact needs to
+// render itself. Per-platform WebView/webview sandboxing is defense in depth
+// on top of this, not a substitute for it.
+const ARTIFACT_CSP = "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; " +
+    "img-src data: blob:; font-src data:; connect-src 'none'; frame-src 'none'; " +
+    "object-src 'none'; base-uri 'none'; form-action 'none'";
+/**
+ * Inserts a restrictive Content-Security-Policy meta tag into the document
+ * head so artifact content cannot reach the network no matter which platform
+ * renders it. Idempotent - a document that already has one is left alone.
+ */
+export function injectContentSecurityPolicy(content) {
+    if (/<meta[^>]+http-equiv=["']Content-Security-Policy["']/i.test(content)) {
+        return content;
+    }
+    const cspTag = `<meta http-equiv="Content-Security-Policy" content="${ARTIFACT_CSP}">`;
+    const headOpenMatch = content.match(/<head[^>]*>/i);
+    if (headOpenMatch) {
+        const insertAt = headOpenMatch.index + headOpenMatch[0].length;
+        return content.slice(0, insertAt) + cspTag + content.slice(insertAt);
+    }
+    const htmlOpenMatch = content.match(/<html[^>]*>/i);
+    if (htmlOpenMatch) {
+        const insertAt = htmlOpenMatch.index + htmlOpenMatch[0].length;
+        return content.slice(0, insertAt) + `<head>${cspTag}</head>` + content.slice(insertAt);
+    }
+    return cspTag + content;
+}
+/**
+ * Sanitizes HTML content by stripping common wrapper artifacts
+ * that models might add (markdown code fences, explanations), and injecting
+ * a restrictive CSP so the artifact cannot make network calls.
+ */
+export function sanitizeHtmlContent(content) {
+    // Strip markdown code fences if present
+    let sanitized = content.replace(/^```html\s*\n?/, "");
+    sanitized = sanitized.replace(/^```\s*\n?/, "");
+    sanitized = sanitized.replace(/\n?```\s*$/, "");
+    // Remove any trailing explanations after closing HTML tags
+    const htmlEndMatch = sanitized.match(/(<\/html>)(?:\s|<)/is);
+    if (htmlEndMatch) {
+        // Keep only content up to and including </html>
+        sanitized = sanitized.substring(0, htmlEndMatch.index + "</html>".length);
+    }
+    sanitized = injectContentSecurityPolicy(sanitized.trim());
+    return sanitized.trim();
+}
+/**
+ * Validates an HTML file on disk exists and contains valid HTML.
+ * Returns the validated content or null if validation fails.
+ */
+export function validateHtmlFile(filePath) {
+    try {
+        // Check file exists and has minimum size
+        const stats = statSync(filePath);
+        // Must have non-zero size (minimum ~50 bytes for basic HTML)
+        if (stats.size < 50) {
+            return { content: "", isValid: false };
+        }
+        // Read and validate content
+        const rawContent = readFileSync(filePath, "utf-8");
+        // Sanitize first (remove code fences etc)
+        const sanitized = sanitizeHtmlContent(rawContent);
+        return {
+            content: sanitized,
+            isValid: isValidHtmlContent(sanitized),
+        };
+    }
+    catch {
+        return { content: "", isValid: false };
+    }
+}
+//# sourceMappingURL=html-validator.js.map

package/dist/server/server/atomic-file.d.ts

@@ -0,0 +1,5 @@
+export declare function writeFileAtomic(filePath: string, data: string | NodeJS.ArrayBufferView, options?: {
+    mode?: number;
+}): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;
+//# sourceMappingURL=atomic-file.d.ts.map

package/dist/server/server/atomic-file.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function writeFileAtomic(filePath, data, options) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(tempPath, data, { encoding: "utf8", mode: options?.mode });
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true });
+        throw error;
+    }
+}
+export async function writeJsonFileAtomic(filePath, value) {
+    await writeFileAtomic(filePath, JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=atomic-file.js.map

package/dist/server/server/auth.d.ts

@@ -0,0 +1,38 @@
+import type { RequestHandler } from "express";
+export declare const DAEMON_PASSWORD_BCRYPT_COST = 12;
+export interface DaemonAuthConfig {
+    password?: string;
+}
+export interface BearerAuthRejectContext {
+    path: string;
+    method: string;
+    hasToken: boolean;
+}
+interface BearerValidationInput {
+    password: string | undefined;
+    token: string | null;
+}
+export declare function isBearerTokenValid(input: BearerValidationInput): boolean;
+export declare function isBearerTokenValidAsync(input: BearerValidationInput): Promise<boolean>;
+export declare function isBearerTokenValidSync(input: BearerValidationInput): boolean;
+export declare function hashDaemonPassword(password: string): string;
+export declare function extractHttpBearerToken(value: string | undefined): string | null;
+export declare function extractWsBearerProtocol(value: string | undefined): string | null;
+export declare function extractWsBearerToken(protocol: string | null): string | null;
+export declare function createRequireBearerMiddleware(auth: DaemonAuthConfig | undefined, onReject?: (context: BearerAuthRejectContext) => void): RequestHandler;
+export declare function shouldBypassBearerAuth(method: string, path: string): boolean;
+/**
+ * Authorizes a request to the Agent MCP endpoint (/mcp/agents), which is exempt
+ * from the global daemon-password middleware. Accepts either the per-daemon-run
+ * capability token the daemon injects into its own agents' configs and MCP
+ * client, or a valid daemon-password bearer (so existing password-authenticated
+ * callers keep working). When no daemon password is configured the endpoint is
+ * open, matching the global middleware's behavior.
+ */
+export declare function isAgentMcpRequestAuthorized(input: {
+    password: string | undefined;
+    capabilityToken: string | null;
+    authorizationHeader: string | undefined;
+}): Promise<boolean>;
+export {};
+//# sourceMappingURL=auth.d.ts.map

package/dist/server/server/auth.js

@@ -0,0 +1,143 @@
+import { compare, compareSync, hashSync } from "bcryptjs";
+import { timingSafeEqual } from "node:crypto";
+export const DAEMON_PASSWORD_BCRYPT_COST = 12;
+export function isBearerTokenValid(input) {
+    return isBearerTokenValidSync(input);
+}
+export async function isBearerTokenValidAsync(input) {
+    if (!input.password) {
+        return true;
+    }
+    if (input.token === null) {
+        return false;
+    }
+    return compare(input.token, input.password);
+}
+export function isBearerTokenValidSync(input) {
+    if (!input.password) {
+        return true;
+    }
+    if (input.token === null) {
+        return false;
+    }
+    return compareSync(input.token, input.password);
+}
+export function hashDaemonPassword(password) {
+    return hashSync(password, DAEMON_PASSWORD_BCRYPT_COST);
+}
+export function extractHttpBearerToken(value) {
+    if (!value) {
+        return null;
+    }
+    const [scheme, ...tokenParts] = value.trim().split(/\s+/);
+    if (scheme !== "Bearer" || tokenParts.length !== 1) {
+        return null;
+    }
+    return tokenParts[0] ?? null;
+}
+export function extractWsBearerProtocol(value) {
+    if (!value) {
+        return null;
+    }
+    for (const protocol of value.split(",")) {
+        const trimmed = protocol.trim();
+        const segments = trimmed.split(".");
+        if (segments[0] === "otto" && segments[1] === "bearer" && segments.length >= 3) {
+            return trimmed;
+        }
+    }
+    return null;
+}
+export function extractWsBearerToken(protocol) {
+    if (!protocol) {
+        return null;
+    }
+    const segments = protocol.split(".");
+    if (segments[0] !== "otto" || segments[1] !== "bearer" || segments.length < 3) {
+        return null;
+    }
+    return segments.slice(2).join(".");
+}
+export function createRequireBearerMiddleware(auth, onReject) {
+    const password = auth?.password;
+    return (req, res, next) => {
+        if (!password || shouldBypassBearerAuth(req.method, req.path)) {
+            next();
+            return;
+        }
+        void (async () => {
+            try {
+                const token = extractHttpBearerToken(req.header("authorization"));
+                if (!(await isBearerTokenValidAsync({ password, token }))) {
+                    onReject?.({
+                        path: req.path,
+                        method: req.method,
+                        hasToken: token !== null,
+                    });
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
+                }
+                next();
+            }
+            catch (error) {
+                next(error);
+            }
+        })();
+    };
+}
+// Routes that authenticate via their own capability and therefore must not be
+// gated a second time behind the daemon password.
+const BEARER_AUTH_BYPASS_PATHS = new Set([
+    // Unauthenticated liveness probe.
+    "/api/health",
+    // Guarded by a single-use download token (crypto-random UUID, 60s TTL,
+    // consumed on first use) that is only ever issued over the
+    // already-authenticated WebSocket. The token IS the capability for this
+    // route. Requiring the daemon password on top of it breaks browser and
+    // Electron downloads: those trigger the download via an anchor navigation,
+    // which cannot attach an `Authorization` header. The download endpoint still
+    // rejects requests without a valid token (400/403), so dropping the bearer
+    // here does not make the route unauthenticated.
+    "/api/files/download",
+    // The daemon injects its own agents' Otto MCP connections at this endpoint
+    // (and connects its own per-client MCP client here). Those connections cannot
+    // carry the daemon password — it is only known in plaintext when set via env,
+    // never when set via the app — so the route authenticates them with a
+    // per-daemon-run capability token instead (see isAgentMcpRequestAuthorized).
+    // The token is injected only into local agent configs/sessions and never sent
+    // to remote clients, and the route still rejects callers presenting neither
+    // the token nor a valid daemon password, so dropping the global bearer here
+    // does not make the endpoint unauthenticated.
+    "/mcp/agents",
+]);
+export function shouldBypassBearerAuth(method, path) {
+    if (method === "OPTIONS") {
+        return true;
+    }
+    return BEARER_AUTH_BYPASS_PATHS.has(path);
+}
+/**
+ * Authorizes a request to the Agent MCP endpoint (/mcp/agents), which is exempt
+ * from the global daemon-password middleware. Accepts either the per-daemon-run
+ * capability token the daemon injects into its own agents' configs and MCP
+ * client, or a valid daemon-password bearer (so existing password-authenticated
+ * callers keep working). When no daemon password is configured the endpoint is
+ * open, matching the global middleware's behavior.
+ */
+export async function isAgentMcpRequestAuthorized(input) {
+    if (!input.password) {
+        return true;
+    }
+    const token = extractHttpBearerToken(input.authorizationHeader);
+    if (input.capabilityToken !== null && token !== null) {
+        // Constant-time compare; length-guard first because timingSafeEqual throws
+        // on differing buffer lengths.
+        const provided = Buffer.from(token);
+        const expected = Buffer.from(input.capabilityToken);
+        if (provided.length === expected.length && timingSafeEqual(provided, expected)) {
+            return true;
+        }
+    }
+    return isBearerTokenValidAsync({ password: input.password, token });
+}
+//# sourceMappingURL=auth.js.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.d.ts

@@ -0,0 +1,40 @@
+import type { Logger } from "pino";
+import type { AgentManager } from "../agent/agent-manager.js";
+import type { AgentStorage } from "../agent/agent-storage.js";
+import type { DaemonConfigStore } from "../daemon-config-store.js";
+import { archiveByScope, type ActiveWorkspaceRef, killTerminalsForWorkspace, resolveWorkspaceIdAtPath } from "../workspace-archive-service.js";
+import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitServiceImpl } from "../workspace-git-service.js";
+import type { GitHubService } from "../../services/github-service.js";
+import type { TerminalManager } from "../../terminal/terminal-manager.js";
+import { isOttoOwnedWorktreeCwd } from "../../utils/worktree.js";
+export interface AutoArchiveArchiveOptions {
+    ottoHome: string;
+    ottoWorktreesBaseRoot?: string;
+    daemonConfigStore: DaemonConfigStore;
+    workspaceGitService: WorkspaceGitServiceImpl;
+    github: GitHubService;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    terminalManager: TerminalManager;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
+    archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
+    markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
+    clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
+    emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
+}
+export interface ArchiveIfSafeDependencies {
+    archiveByScope: typeof archiveByScope;
+    resolveWorkspaceIdAtPath: typeof resolveWorkspaceIdAtPath;
+    isOttoOwnedWorktreeCwd: typeof isOttoOwnedWorktreeCwd;
+    killTerminalsForWorkspace: typeof killTerminalsForWorkspace;
+}
+export declare function archiveIfSafe(input: {
+    cwd: string;
+    pullRequest: WorkspaceGitRuntimeSnapshot["github"]["pullRequest"];
+    inFlight: Set<string>;
+    options: AutoArchiveArchiveOptions;
+    log: Logger;
+    deps?: ArchiveIfSafeDependencies;
+}): Promise<void>;
+//# sourceMappingURL=archive-if-safe.d.ts.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -0,0 +1,92 @@
+import { archiveByScope, killTerminalsForWorkspace, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
+import { isOttoOwnedWorktreeCwd } from "../../utils/worktree.js";
+const defaultDependencies = {
+    archiveByScope,
+    resolveWorkspaceIdAtPath,
+    isOttoOwnedWorktreeCwd,
+    killTerminalsForWorkspace,
+};
+export async function archiveIfSafe(input) {
+    const { cwd, pullRequest, inFlight, options, log } = input;
+    const deps = input.deps ?? defaultDependencies;
+    if (!pullRequest?.isMerged) {
+        return;
+    }
+    if (options.daemonConfigStore.get().autoArchiveAfterMerge !== true) {
+        return;
+    }
+    if (inFlight.has(cwd)) {
+        return;
+    }
+    inFlight.add(cwd);
+    try {
+        let snapshot;
+        try {
+            snapshot = await options.workspaceGitService.getSnapshot(cwd, {
+                reason: "auto-archive-on-merge",
+            });
+        }
+        catch (error) {
+            log.warn({ err: error, cwd }, "Failed to read snapshot for auto-archive; skipping");
+            return;
+        }
+        if (!snapshot) {
+            return;
+        }
+        if (snapshot.git.isDirty === true) {
+            return;
+        }
+        if (typeof snapshot.git.aheadOfOrigin === "number" && snapshot.git.aheadOfOrigin > 0) {
+            return;
+        }
+        const ownership = await deps.isOttoOwnedWorktreeCwd(cwd, {
+            ottoHome: options.ottoHome,
+            worktreesRoot: options.ottoWorktreesBaseRoot,
+        });
+        if (!ownership.allowed) {
+            return;
+        }
+        try {
+            const workspaceId = await deps.resolveWorkspaceIdAtPath({
+                findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+                listActiveWorkspaces: options.listActiveWorkspaces,
+            }, cwd);
+            if (!workspaceId) {
+                log.warn({ cwd }, "Auto-archive could not resolve a workspace for cwd; skipping");
+                return;
+            }
+            await deps.archiveByScope({
+                ottoHome: options.ottoHome,
+                ottoWorktreesBaseRoot: options.ottoWorktreesBaseRoot,
+                github: options.github,
+                workspaceGitService: options.workspaceGitService,
+                agentManager: options.agentManager,
+                agentStorage: options.agentStorage,
+                findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+                listActiveWorkspaces: options.listActiveWorkspaces,
+                archiveWorkspaceRecord: options.archiveWorkspaceRecord,
+                emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
+                markWorkspaceArchiving: options.markWorkspaceArchiving,
+                clearWorkspaceArchiving: options.clearWorkspaceArchiving,
+                killTerminalsForWorkspace: (workspaceIdToKill) => deps.killTerminalsForWorkspace({
+                    terminalManager: options.terminalManager,
+                    sessionLogger: log,
+                }, workspaceIdToKill),
+                sessionLogger: log,
+            }, {
+                scope: { kind: "workspace", workspaceId },
+                repoRoot: ownership.repoRoot ?? null,
+                ottoWorktreesBaseRoot: options.ottoWorktreesBaseRoot,
+                requestId: "auto-archive-on-merge",
+            });
+            log.info({ cwd }, "Auto-archived worktree after PR merge");
+        }
+        catch (error) {
+            log.warn({ err: error, cwd }, "Auto-archive after merge failed");
+        }
+    }
+    finally {
+        inFlight.delete(cwd);
+    }
+}
+//# sourceMappingURL=archive-if-safe.js.map

package/dist/server/server/auto-archive-on-merge/index.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from "pino";
+import { type AutoArchiveArchiveOptions } from "./archive-if-safe.js";
+import type { WorkspaceGitSubscription } from "../workspace-git-service.js";
+export interface AutoArchiveOnMergeOptions extends AutoArchiveArchiveOptions {
+    logger: Logger;
+}
+export declare function setupAutoArchiveOnMerge(options: AutoArchiveOnMergeOptions): WorkspaceGitSubscription;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/auto-archive-on-merge/index.js

@@ -0,0 +1,15 @@
+import { archiveIfSafe } from "./archive-if-safe.js";
+export function setupAutoArchiveOnMerge(options) {
+    const log = options.logger.child({ module: "auto-archive-on-merge" });
+    const inFlight = new Set();
+    return options.workspaceGitService.onSnapshotUpdated((snapshot) => {
+        void archiveIfSafe({
+            cwd: snapshot.cwd,
+            pullRequest: snapshot.github.pullRequest,
+            inFlight,
+            options,
+            log,
+        });
+    });
+}
+//# sourceMappingURL=index.js.map