@otto-code/server 0.5.0

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

@@ -0,0 +1,419 @@
+import { randomBytes } from "node:crypto";
+import { readFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { ArtifactStore, assertValidArtifactId } from "./artifact-store.js";
+import { ArtifactWatcher } from "./artifact-watcher.js";
+import { ARTIFACT_SYSTEM_PROMPT } from "./artifact-prompt.js";
+const GENERATION_CANCELLED_MESSAGE = "Generation cancelled";
+// How long a generation may run before we give up, cancel the agent, and mark
+// the artifact as timed out. Local models are slow, so the default is generous;
+// override with OTTO_ARTIFACT_TIMEOUT_MS (milliseconds) to tune without a
+// rebuild. Keep this as the single source of truth — the watcher's timer and
+// the user-facing message both derive from it.
+const DEFAULT_GENERATION_TIMEOUT_MS = 960000;
+const GENERATION_TIMEOUT_MS = parseInt(process.env.OTTO_ARTIFACT_TIMEOUT_MS ?? "", 10) || DEFAULT_GENERATION_TIMEOUT_MS;
+function generationTimedOutMessage() {
+    return `Generation timed out after ${Math.round(GENERATION_TIMEOUT_MS / 1000)} seconds`;
+}
+class ArtifactNotFoundError extends Error {
+    constructor(artifactId) {
+        super(`Artifact "${artifactId}" not found`);
+        this.name = "ArtifactNotFoundError";
+    }
+}
+export class ArtifactService {
+    constructor(options) {
+        // artifactId -> generation agentId, for the lifetime of an active run. Lets
+        // cancel() interrupt the agent even before generationAgentId is persisted.
+        this.runningGenerations = new Map();
+        // artifactId -> path of the prior HTML, set only while a *regeneration* is
+        // in flight (never on a first-ever generation, which has nothing to back
+        // up). Restored on failure/cancel/timeout so a failed regeneration doesn't
+        // destroy an artifact's last successful output; discarded once the new
+        // generation succeeds.
+        this.regenerationBackups = new Map();
+        this.projectCwd = options.projectCwd;
+        this.store = new ArtifactStore(options.projectCwd);
+        this.logger = options.logger.child({ module: "artifact-service" });
+        this.agentManager = options.agentManager;
+        this.providerSnapshotManager = options.providerSnapshotManager;
+        this.broadcastArtifactUpdate = options.broadcastArtifactUpdate;
+        this.watcher = new ArtifactWatcher({
+            store: this.store,
+            logger: this.logger,
+            sendNotification: (metadata) => {
+                this.broadcastArtifactUpdate(metadata);
+            },
+            timeoutMs: GENERATION_TIMEOUT_MS,
+            // The watcher's timer fires here; the service owns the agent, so it does
+            // the real teardown (cancel the run, mark timed out) rather than leaving
+            // a hung/looping generation agent running in the background.
+            onTimeout: (artifactId) => {
+                void this.abortGeneration(artifactId, generationTimedOutMessage()).catch((error) => {
+                    this.logger.error({ err: error, artifactId }, "Failed to abort timed-out generation");
+                });
+            },
+        });
+    }
+    async list(projectId) {
+        return this.store.list(projectId ? { projectId } : undefined);
+    }
+    /** Full record with generation run history, for inspect_artifact. */
+    async inspect(artifactId) {
+        const record = await this.store.inspect(artifactId);
+        if (!record) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        return record;
+    }
+    /** Open a new generation run in "running" state. */
+    async startRun(artifactId, trigger, provider, model) {
+        await this.store.appendRun(artifactId, {
+            id: generateArtifactId(),
+            trigger,
+            status: "running",
+            startedAt: new Date().toISOString(),
+            endedAt: null,
+            agentId: null,
+            provider,
+            model,
+            error: null,
+        });
+    }
+    /** Close out the artifact's in-flight run. No-op if none is running. */
+    async completeRun(artifactId, status, error) {
+        await this.store.patchCurrentRun(artifactId, {
+            status,
+            endedAt: new Date().toISOString(),
+            error: status === "failed" ? (error ?? null) : null,
+        });
+    }
+    /** Watcher success hook, shared by create and regenerate: mark the run
+     * succeeded and drop any regeneration backup (a no-op for first generations). */
+    handleGenerationReady(artifactId) {
+        void this.completeRun(artifactId, "succeeded");
+        void this.discardBackup(artifactId);
+    }
+    async delete(artifactId) {
+        this.watcher.unwatch(artifactId);
+        await this.discardBackup(artifactId);
+        await this.store.delete(artifactId);
+    }
+    stop() {
+        this.watcher.stop();
+    }
+    async star(artifactId, starred) {
+        const existing = await this.store.get(artifactId);
+        if (!existing) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        await this.store.update(artifactId, { starred });
+        const updated = await this.store.get(artifactId);
+        if (!updated) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        return updated;
+    }
+    async getContent(artifactId) {
+        const metadata = await this.store.get(artifactId);
+        if (!metadata) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        try {
+            return await readFile(this.resolveHtmlPath(artifactId), "utf-8");
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                throw new Error(`Artifact HTML not found for "${artifactId}"`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    async create(input) {
+        const artifactId = generateArtifactId();
+        const now = new Date().toISOString();
+        const filePath = this.resolveHtmlPath(artifactId);
+        const metadata = {
+            id: artifactId,
+            name: input.name,
+            description: input.description,
+            projectId: input.projectId ?? "",
+            filePath,
+            kind: "html",
+            status: "generating",
+            starred: false,
+            createdAt: now,
+            updatedAt: now,
+            generationAgentId: null,
+            generationProvider: input.provider,
+            generationModel: input.model ?? null,
+            generationModeId: input.modeId ?? null,
+            generationThinkingOptionId: input.thinkingOptionId ?? null,
+            generationSpinner: input.spinner ?? null,
+            errorMessage: null,
+        };
+        await this.store.create(metadata);
+        await this.startRun(artifactId, "create", metadata.generationProvider, metadata.generationModel);
+        this.watcher.watch(artifactId, filePath, () => this.handleGenerationReady(artifactId));
+        void this.spawnArtifactAgent(artifactId, metadata, input).catch((error) => {
+            this.logger.error({ err: error, artifactId }, "Failed to spawn artifact agent");
+            void this.store.update(artifactId, { status: "error", errorMessage: String(error) });
+            void this.completeRun(artifactId, "failed", String(error));
+        });
+        return metadata;
+    }
+    /**
+     * Edit an artifact's metadata WITHOUT regenerating. Only provided fields are
+     * overwritten. Editing never re-runs the agent — the user regenerates
+     * separately once they're happy with the changes.
+     */
+    async update(input) {
+        const existing = await this.store.get(input.artifactId);
+        if (!existing) {
+            throw new ArtifactNotFoundError(input.artifactId);
+        }
+        await this.store.update(input.artifactId, {
+            ...(input.name !== undefined ? { name: input.name } : {}),
+            ...(input.description !== undefined ? { description: input.description } : {}),
+            ...(input.projectId !== undefined ? { projectId: input.projectId } : {}),
+            ...(input.provider !== undefined ? { generationProvider: input.provider } : {}),
+            ...(input.model !== undefined ? { generationModel: input.model || null } : {}),
+            ...(input.thinkingOptionId !== undefined
+                ? { generationThinkingOptionId: input.thinkingOptionId || null }
+                : {}),
+        });
+        const updated = await this.store.get(input.artifactId);
+        if (!updated) {
+            throw new ArtifactNotFoundError(input.artifactId);
+        }
+        return updated;
+    }
+    /**
+     * Re-run generation for an existing artifact using its stored config. Resets
+     * the artifact to "generating", clears the prior error, and spawns a fresh
+     * agent.
+     */
+    async regenerate(artifactId) {
+        const existing = await this.store.get(artifactId);
+        if (!existing) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        const provider = existing.generationProvider ?? "";
+        if (!provider) {
+            throw new Error(`Artifact "${artifactId}" has no provider to regenerate with`);
+        }
+        const model = existing.generationModel ?? undefined;
+        await this.store.update(artifactId, {
+            status: "generating",
+            errorMessage: null,
+            generationAgentId: null,
+        });
+        const updated = await this.store.get(artifactId);
+        if (!updated) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        // Move the prior HTML out of the way before watching, rather than
+        // deleting it: the watcher marks an artifact "ready" the instant it sees
+        // a valid file at filePath, so leaving the old output in place would flip
+        // status straight back to "ready" with stale content and stop watching
+        // before the new agent writes anything. Keeping it as a backup lets a
+        // failed regeneration restore the last successful version instead of
+        // losing it outright.
+        await this.startRun(artifactId, "regenerate", provider, model ?? null);
+        await this.backupBeforeRegenerate(artifactId, updated.filePath);
+        this.watcher.watch(artifactId, updated.filePath, () => this.handleGenerationReady(artifactId));
+        void this.spawnArtifactAgent(artifactId, updated, {
+            name: updated.name,
+            description: updated.description,
+            projectId: updated.projectId,
+            provider,
+            model,
+            // Re-run with the originally requested mode/effort. The mode is safe to
+            // replay as-is: spawnArtifactAgent only honors it if unattended.
+            modeId: updated.generationModeId ?? undefined,
+            thinkingOptionId: updated.generationThinkingOptionId ?? undefined,
+        }).catch(async (error) => {
+            this.logger.error({ err: error, artifactId }, "Failed to regenerate artifact");
+            await this.restoreBackup(artifactId);
+            void this.store.update(artifactId, { status: "error", errorMessage: String(error) });
+            void this.completeRun(artifactId, "failed", String(error));
+        });
+        return updated;
+    }
+    /**
+     * Cancel an in-progress generation and recover the artifact. Stops the agent
+     * run, stops the watcher (so a partial/late file can't flip status back to
+     * "ready"), and lands the artifact in an error state so it can be regenerated
+     * or deleted.
+     */
+    async cancel(artifactId) {
+        const existing = await this.store.get(artifactId);
+        if (!existing) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        const updated = await this.abortGeneration(artifactId, GENERATION_CANCELLED_MESSAGE);
+        if (!updated) {
+            throw new ArtifactNotFoundError(artifactId);
+        }
+        return updated;
+    }
+    /**
+     * Shared teardown for a generation that must stop early — user cancel or
+     * timeout. Stops the watcher (so a partial/late file can't flip status back
+     * to "ready"), cancels the generation agent so nothing lingers, and lands the
+     * artifact in an error state so it can be regenerated or deleted. Safe to call
+     * when the agent has already finished: cancelAgentRun on a closed agent is
+     * caught and logged. Returns the updated metadata, or null if the artifact
+     * disappeared underneath us.
+     */
+    async abortGeneration(artifactId, errorMessage) {
+        // Stop watching first so an in-flight checkFileReady can't race us to
+        // "ready" after we mark the artifact as errored.
+        this.watcher.unwatch(artifactId);
+        const existing = await this.store.get(artifactId);
+        const agentId = this.runningGenerations.get(artifactId) ?? existing?.generationAgentId;
+        if (agentId) {
+            try {
+                await this.agentManager.cancelAgentRun(agentId);
+            }
+            catch (error) {
+                this.logger.warn({ err: error, artifactId, agentId }, "Failed to cancel generation agent");
+            }
+        }
+        // If this aborted a regeneration (not a first-ever generation), restore
+        // the prior successful output rather than leaving the artifact with none.
+        await this.restoreBackup(artifactId);
+        await this.store.update(artifactId, {
+            status: "error",
+            errorMessage,
+            generationAgentId: null,
+        });
+        await this.completeRun(artifactId, "failed", errorMessage);
+        return this.store.get(artifactId);
+    }
+    /** Move the current HTML aside so a regeneration can't be mistaken for
+     * "ready" by the watcher. No-ops (leaves nothing to restore) when there's
+     * no prior file — a first-ever generation has none. */
+    async backupBeforeRegenerate(artifactId, filePath) {
+        const backupPath = `${filePath}.bak`;
+        try {
+            await rename(filePath, backupPath);
+            this.regenerationBackups.set(artifactId, backupPath);
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+    /** Restore a regeneration's backup after a failed/cancelled/timed-out
+     * attempt. No-op if there's no backup (first-ever generation, or already
+     * consumed). */
+    async restoreBackup(artifactId) {
+        const backupPath = this.regenerationBackups.get(artifactId);
+        if (!backupPath) {
+            return;
+        }
+        this.regenerationBackups.delete(artifactId);
+        try {
+            await rename(backupPath, this.resolveHtmlPath(artifactId));
+        }
+        catch (error) {
+            this.logger.warn({ err: error, artifactId }, "Failed to restore artifact backup after failed regeneration");
+        }
+    }
+    /** Drop a regeneration's backup once the new generation has succeeded. */
+    async discardBackup(artifactId) {
+        const backupPath = this.regenerationBackups.get(artifactId);
+        if (!backupPath) {
+            return;
+        }
+        this.regenerationBackups.delete(artifactId);
+        try {
+            await rm(backupPath, { force: true });
+        }
+        catch (error) {
+            this.logger.warn({ err: error, artifactId }, "Failed to remove stale artifact backup");
+        }
+    }
+    async spawnArtifactAgent(artifactId, metadata, input) {
+        const htmlPath = this.resolveHtmlPath(artifactId);
+        const agentPrompt = `${metadata.description}\n\nWrite the HTML file to: ${htmlPath}`;
+        // Artifacts run unattended: no client is watching to approve tool calls, so
+        // resolve the provider's unattended mode (unless the user picked an explicit
+        // mode that is itself unattended) exactly like the schedule runner does, or
+        // the agent stalls on the first approval prompt and the artifact never
+        // leaves "generating". A non-unattended modeId can leak in from the create
+        // sheet inheriting the user's last-used chat mode preference, so it's only
+        // honored when it actually won't prompt.
+        const requestedModeIsUnattended = input.modeId !== undefined &&
+            (await this.providerSnapshotManager.listModes({
+                provider: input.provider,
+                cwd: this.projectCwd,
+                wait: true,
+            })).some((mode) => mode.id === input.modeId && mode.isUnattended === true);
+        const resolved = requestedModeIsUnattended
+            ? { modeId: input.modeId, featureValues: undefined }
+            : await this.providerSnapshotManager.resolveCreateConfig({
+                provider: input.provider,
+                cwd: this.projectCwd,
+                requestedMode: undefined,
+                featureValues: undefined,
+                parent: null,
+                unattended: true,
+            });
+        const config = {
+            provider: input.provider,
+            model: input.model,
+            modeId: resolved.modeId,
+            thinkingOptionId: input.thinkingOptionId,
+            featureValues: resolved.featureValues,
+            systemPrompt: ARTIFACT_SYSTEM_PROMPT,
+            cwd: this.projectCwd,
+            internal: true,
+            // Keep the agent out of listings/sidebar (internal) but let a client that
+            // opens the generation log watch its stream live (observable). Without
+            // this, the daemon's global subscription drops the agent's stream events
+            // and the log only updates on manual re-fetch (navigate away and back).
+            observable: true,
+            title: metadata.name,
+        };
+        const agent = await this.agentManager.createAgent(config, undefined, {
+            initialPrompt: agentPrompt,
+            initialTitle: metadata.name,
+            // Explicitly no workspace: the generator is an ephemeral internal agent
+            // that must never appear in the sidebar.
+            workspaceId: undefined,
+        });
+        // Register before running so cancel() can interrupt this run immediately.
+        this.runningGenerations.set(artifactId, agent.id);
+        await this.store.update(artifactId, { generationAgentId: agent.id });
+        await this.store.patchCurrentRun(artifactId, { agentId: agent.id });
+        // Creating the agent only spins up the session; the prompt must be run to
+        // actually generate the file. The watcher flips the artifact to "ready"
+        // when the HTML lands. Close (not archive) the ephemeral internal agent
+        // afterward — internal agents are never persisted, matching how other
+        // one-shot internal agents (branch-name/git-metadata generators) tear down.
+        try {
+            await this.agentManager.runAgent(agent.id, agentPrompt);
+        }
+        finally {
+            this.runningGenerations.delete(artifactId);
+            try {
+                await this.agentManager.closeAgent(agent.id);
+            }
+            catch {
+                // Ignore cleanup errors; the run result is what matters.
+            }
+        }
+    }
+    resolveHtmlPath(artifactId) {
+        assertValidArtifactId(artifactId);
+        return join(this.projectCwd, ".otto", "artifacts", `${artifactId}.html`);
+    }
+}
+function generateArtifactId() {
+    return randomBytes(4).toString("hex");
+}
+//# sourceMappingURL=artifact-service.js.map

package/dist/server/server/artifact/artifact-store.d.ts

@@ -0,0 +1,24 @@
+import type { ArtifactMetadata, ArtifactRun, StoredArtifact } from "@otto-code/protocol/artifacts/types";
+export type { ArtifactMetadata };
+export declare function assertValidArtifactId(artifactId: string): void;
+export declare class ArtifactStore {
+    private readonly projectCwd;
+    constructor(projectCwd: string);
+    private artifactsDir;
+    private metadataPath;
+    private htmlPath;
+    private ensureDir;
+    private readStored;
+    get(artifactId: string): Promise<ArtifactMetadata | null>;
+    inspect(artifactId: string): Promise<StoredArtifact | null>;
+    list(options?: {
+        projectId?: string;
+    }): Promise<ArtifactMetadata[]>;
+    create(metadata: ArtifactMetadata): Promise<void>;
+    update(artifactId: string, changes: Partial<ArtifactMetadata>): Promise<void>;
+    appendRun(artifactId: string, run: ArtifactRun): Promise<void>;
+    patchCurrentRun(artifactId: string, patch: Partial<ArtifactRun>): Promise<void>;
+    delete(artifactId: string): Promise<void>;
+    scanAll(projectRoots: string[]): Promise<ArtifactMetadata[]>;
+}
+//# sourceMappingURL=artifact-store.d.ts.map

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

@@ -0,0 +1,168 @@
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { MAX_ARTIFACT_RUNS, StoredArtifactSchema } from "@otto-code/protocol/artifacts/types";
+import { writeJsonFileAtomic } from "../atomic-file.js";
+// Artifact ids are server-generated hex (randomBytes). Anything that reaches a
+// filesystem path must be a single safe segment: reject separators, dots, and
+// null bytes so a client- or agent-supplied id can never traverse out of the
+// artifacts dir (e.g. "../../../../Users/x/secret" would otherwise let delete()
+// unlink arbitrary paired *.json/*.html files, or inspect() read them).
+const ARTIFACT_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+export function assertValidArtifactId(artifactId) {
+    if (!ARTIFACT_ID_PATTERN.test(artifactId)) {
+        throw new Error(`Invalid artifact id: ${JSON.stringify(artifactId)}`);
+    }
+}
+// Drop the run history off a stored record to get the lean metadata that
+// list/get callers (and every broadcast/notification) work with. Keeping runs
+// out of that shape means they never ride the wire on routine updates — only
+// inspect() surfaces them.
+function toMetadata(stored) {
+    const { runs: _runs, ...metadata } = stored;
+    return metadata;
+}
+export class ArtifactStore {
+    constructor(projectCwd) {
+        this.projectCwd = projectCwd;
+    }
+    artifactsDir() {
+        return join(this.projectCwd, ".otto", "artifacts");
+    }
+    metadataPath(artifactId) {
+        assertValidArtifactId(artifactId);
+        return join(this.artifactsDir(), `${artifactId}.json`);
+    }
+    htmlPath(artifactId) {
+        assertValidArtifactId(artifactId);
+        return join(this.artifactsDir(), `${artifactId}.html`);
+    }
+    async ensureDir() {
+        await mkdir(this.artifactsDir(), { recursive: true });
+    }
+    // Read the full on-disk record, run history included. Everything else in the
+    // store layers on top of this: get()/list() strip runs, inspect() keeps them.
+    async readStored(artifactId) {
+        await this.ensureDir();
+        try {
+            const content = await readFile(this.metadataPath(artifactId), "utf-8");
+            return StoredArtifactSchema.parse(JSON.parse(content));
+        }
+        catch (error) {
+            if (isEnoent(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async get(artifactId) {
+        const stored = await this.readStored(artifactId);
+        return stored ? toMetadata(stored) : null;
+    }
+    // Full record with run history, for inspect_artifact. Returns null when the
+    // artifact doesn't exist so callers can raise their own not-found error.
+    async inspect(artifactId) {
+        return this.readStored(artifactId);
+    }
+    async list(options) {
+        await this.ensureDir();
+        const entries = await readdir(this.artifactsDir(), { withFileTypes: true });
+        const results = await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map(async (entry) => {
+            try {
+                const content = await readFile(join(this.artifactsDir(), entry.name), "utf-8");
+                return toMetadata(StoredArtifactSchema.parse(JSON.parse(content)));
+            }
+            catch {
+                return null;
+            }
+        }));
+        const valid = results.filter((m) => m !== null);
+        const sorted = valid.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        if (options?.projectId) {
+            return sorted.filter((m) => m.projectId === options.projectId);
+        }
+        return sorted;
+    }
+    async create(metadata) {
+        await this.ensureDir();
+        const stored = { ...metadata, runs: [] };
+        await writeJsonFileAtomic(this.metadataPath(metadata.id), stored);
+    }
+    async update(artifactId, changes) {
+        await this.ensureDir();
+        const existing = await this.readStored(artifactId);
+        if (!existing) {
+            throw new Error(`Artifact "${artifactId}" not found`);
+        }
+        const updated = {
+            ...existing,
+            ...changes,
+            updatedAt: new Date().toISOString(),
+        };
+        await writeJsonFileAtomic(this.metadataPath(artifactId), updated);
+    }
+    // Append a generation attempt to the run history, oldest entries pruned so the
+    // on-disk log stays bounded. Does not touch updatedAt — the run's own
+    // timestamps carry that, and the accompanying status update bumps it.
+    async appendRun(artifactId, run) {
+        await this.ensureDir();
+        const existing = await this.readStored(artifactId);
+        if (!existing) {
+            throw new Error(`Artifact "${artifactId}" not found`);
+        }
+        const runs = [...existing.runs, run].slice(-MAX_ARTIFACT_RUNS);
+        const updated = { ...existing, runs };
+        await writeJsonFileAtomic(this.metadataPath(artifactId), updated);
+    }
+    // Patch the current (most recent still-"running") run — to stamp its agent id
+    // once known, or to close it out as succeeded/failed. No-ops when there's no
+    // running run, so completion handlers can fire unconditionally.
+    async patchCurrentRun(artifactId, patch) {
+        await this.ensureDir();
+        const existing = await this.readStored(artifactId);
+        if (!existing) {
+            return;
+        }
+        const index = findLastRunningIndex(existing.runs);
+        if (index === -1) {
+            return;
+        }
+        const runs = existing.runs.map((run, i) => (i === index ? { ...run, ...patch } : run));
+        const updated = { ...existing, runs };
+        await writeJsonFileAtomic(this.metadataPath(artifactId), updated);
+    }
+    async delete(artifactId) {
+        await this.ensureDir();
+        await rm(this.metadataPath(artifactId), { force: true });
+        await rm(this.htmlPath(artifactId), { force: true });
+    }
+    async scanAll(projectRoots) {
+        const stores = projectRoots.map((root) => new ArtifactStore(root));
+        const results = await Promise.all(stores.map(async (store) => {
+            try {
+                return await store.list();
+            }
+            catch {
+                return [];
+            }
+        }));
+        return results
+            .flat()
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+}
+function isEnoent(error) {
+    return error.code === "ENOENT";
+}
+// Index of the last run still in flight — the one a success/failure handler
+// should close out. Returns -1 when nothing is running.
+function findLastRunningIndex(runs) {
+    for (let i = runs.length - 1; i >= 0; i--) {
+        if (runs[i].status === "running") {
+            return i;
+        }
+    }
+    return -1;
+}
+//# sourceMappingURL=artifact-store.js.map

package/dist/server/server/artifact/artifact-watcher.d.ts

@@ -0,0 +1,34 @@
+import type { Logger } from "pino";
+import type { ArtifactMetadata } from "@otto-code/protocol/artifacts/types";
+import type { ArtifactStore } from "./artifact-store.js";
+interface ArtifactWatcherOptions {
+    store: ArtifactStore;
+    logger: Logger;
+    sendNotification: (metadata: ArtifactMetadata) => void;
+    timeoutMs: number;
+    onTimeout: (artifactId: string) => void;
+}
+export declare class ArtifactWatcher {
+    private readonly store;
+    private readonly logger;
+    private readonly sendNotification;
+    private readonly timeoutMs;
+    private readonly onTimeout;
+    private readonly activeWatchers;
+    private readonly handles;
+    private batchPollTimer;
+    constructor(options: ArtifactWatcherOptions);
+    watch(artifactId: string, filePath: string, onReady?: () => void): void;
+    unwatch(artifactId: string): void;
+    stop(): void;
+    private cleanupHandle;
+    private startBatchPolling;
+    private stopBatchPolling;
+    private checkFileReady;
+    private writeSanitizedContent;
+    private updateToReady;
+    private handleTimeout;
+    private emitUpdatedNotification;
+}
+export {};
+//# sourceMappingURL=artifact-watcher.d.ts.map