@xfey/tutti 0.1.53 → 0.1.54

package/dist/artifacts/index.d.ts

@@ -1,6 +1,6 @@
-export { ARTIFACT_MANIFEST_PATH, ARTIFACT_PREVIEW_BASE_PATH, buildArtifactPreviewUrl, readArtifactDeclaration, readArtifactProjection, type ArtifactDeclaration, type DeclaredArtifactRuntime, type ReadArtifactDeclarationOptions, } from "./manifest.js";
+export { readLiveArtifactDeclaration, type LiveArtifactDeclaration, } from "./live-manifest.js";
 export { validateCandidateArtifact, type ArtifactValidationDiagnostic, type ArtifactValidationDiagnosticSource, type ArtifactValidationReasonCode, type CandidateArtifactValidationFailure, type CandidateArtifactValidationResult, type ValidateCandidateArtifactOptions, } from "./candidate-validator.js";
-export { parseArtifactManifestContract, type ArtifactContractError, type ArtifactContractResult, type ValidatedArtifactContract, type ValidatedArtifactRuntime, } from "./manifest-contract.js";
-export { ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, isArtifactPreviewHttpMethod, type ArtifactPreviewCommandResult, type ArtifactPreviewHeartbeatResult, type ArtifactPreviewHttpMethod, type ArtifactPreviewManagerOptions, type ArtifactPreviewProcessPlan, type ArtifactPreviewStartResult, type ArtifactPreviewStopResult, type ArtifactServerPreviewResponse, } from "./preview-runtime.js";
+export { ARTIFACT_MANIFEST_PATH, parseArtifactManifestContract, type ArtifactContractError, type ArtifactContractResult, type ValidatedArtifactContract, type ValidatedArtifactRuntime, } from "./manifest-contract.js";
+export { ARTIFACT_PREVIEW_BASE_PATH, ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, isArtifactPreviewHttpMethod, type ArtifactPreviewLeaseOptions, type ArtifactPreviewHttpMethod, type ArtifactPreviewManagerOptions, type ArtifactPreviewProcessPlan, type ArtifactServerPreviewResponse, } from "./preview-runtime.js";
 export { ARTIFACT_PREVIEW_CSP, readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, type ArtifactStaticPreviewFile, type ReadArtifactStaticPreviewOptions, } from "./static-preview.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/artifacts/index.js

@@ -1,6 +1,6 @@
-export { ARTIFACT_MANIFEST_PATH, ARTIFACT_PREVIEW_BASE_PATH, buildArtifactPreviewUrl, readArtifactDeclaration, readArtifactProjection, } from "./manifest.js";
+export { readLiveArtifactDeclaration, } from "./live-manifest.js";
 export { validateCandidateArtifact, } from "./candidate-validator.js";
-export { parseArtifactManifestContract, } from "./manifest-contract.js";
-export { ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, isArtifactPreviewHttpMethod, } from "./preview-runtime.js";
+export { ARTIFACT_MANIFEST_PATH, parseArtifactManifestContract, } from "./manifest-contract.js";
+export { ARTIFACT_PREVIEW_BASE_PATH, ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, isArtifactPreviewHttpMethod, } from "./preview-runtime.js";
 export { ARTIFACT_PREVIEW_CSP, readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, } from "./static-preview.js";
 //# sourceMappingURL=index.js.map

package/dist/artifacts/live-manifest.d.ts

@@ -0,0 +1,23 @@
+import type { ArtifactManifest, ArtifactProjection } from "@tutti/shared/schemas/api";
+import { type ValidatedArtifactRuntime } from "./manifest-contract.js";
+type ArtifactInvalidProjection = Extract<ArtifactProjection, {
+    status: "invalid";
+}>;
+export type LiveArtifactDeclaration = {
+    status: "not_declared";
+    projection: Extract<ArtifactProjection, {
+        status: "not_declared";
+    }>;
+} | {
+    status: "invalid";
+    projection: ArtifactInvalidProjection;
+} | {
+    status: "declared";
+    manifest: ArtifactManifest;
+    runtime: ValidatedArtifactRuntime;
+};
+export declare function readLiveArtifactDeclaration(options: {
+    workspaceRoot: string;
+}): LiveArtifactDeclaration;
+export {};
+//# sourceMappingURL=live-manifest.d.ts.map

package/dist/artifacts/live-manifest.js

@@ -0,0 +1,115 @@
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { ARTIFACT_MANIFEST_PATH, MAX_ARTIFACT_MANIFEST_BYTES, parseArtifactManifestContract, } from "./manifest-contract.js";
+function truncateMessage(message) {
+    const normalized = message.replace(/\s+/gu, " ").trim();
+    return normalized.length <= 220 ? normalized : `${normalized.slice(0, 217)}...`;
+}
+function invalidArtifact(code, message) {
+    return {
+        status: "invalid",
+        projection: {
+            status: "invalid",
+            error: {
+                code,
+                message: truncateMessage(message),
+            },
+        },
+    };
+}
+function isContainedPath(root, target) {
+    const relativePath = relative(root, target);
+    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+function requireContainedPath(options) {
+    try {
+        const target = realpathSync.native(resolve(options.workspaceRealPath, options.repoPath));
+        const stat = lstatSync(target);
+        const expectedKind = options.kind === "file" ? stat.isFile() : stat.isDirectory();
+        if (!isContainedPath(options.workspaceRealPath, target) || !expectedKind) {
+            return invalidArtifact("invalid_path", `${options.label} is not a contained ${options.kind}`);
+        }
+        return null;
+    }
+    catch {
+        return invalidArtifact("not_found", `${options.label} does not exist`);
+    }
+}
+export function readLiveArtifactDeclaration(options) {
+    let workspaceRealPath;
+    try {
+        workspaceRealPath = realpathSync.native(options.workspaceRoot);
+    }
+    catch {
+        return invalidArtifact("workspace_unavailable", "Project workspace is unavailable");
+    }
+    const manifestPath = join(workspaceRealPath, ARTIFACT_MANIFEST_PATH);
+    let manifestStat;
+    try {
+        manifestStat = lstatSync(manifestPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {
+                status: "not_declared",
+                projection: { status: "not_declared" },
+            };
+        }
+        return invalidArtifact("manifest_unavailable", "Artifact manifest cannot be read");
+    }
+    if (!manifestStat.isFile()) {
+        return invalidArtifact("invalid_manifest", "Artifact manifest path is not a regular file");
+    }
+    if (manifestStat.size > MAX_ARTIFACT_MANIFEST_BYTES) {
+        return invalidArtifact("too_large", "Artifact manifest is too large");
+    }
+    let manifestContent;
+    try {
+        manifestContent = readFileSync(manifestPath);
+    }
+    catch {
+        return invalidArtifact("manifest_unavailable", "Artifact manifest cannot be read");
+    }
+    const parsed = parseArtifactManifestContract(manifestContent);
+    if (!parsed.ok) {
+        return invalidArtifact(parsed.error.code, parsed.error.message);
+    }
+    const runtime = parsed.declaration.runtime;
+    if (runtime.kind === "static") {
+        const rootError = requireContainedPath({
+            workspaceRealPath,
+            repoPath: runtime.root_path,
+            kind: "directory",
+            label: "Static artifact root",
+        });
+        if (rootError !== null) {
+            return rootError;
+        }
+        const entryError = requireContainedPath({
+            workspaceRealPath,
+            repoPath: runtime.entry_repo_path,
+            kind: "file",
+            label: "Static artifact entry",
+        });
+        if (entryError !== null) {
+            return entryError;
+        }
+    }
+    else {
+        const cwdError = requireContainedPath({
+            workspaceRealPath,
+            repoPath: runtime.cwd_path,
+            kind: "directory",
+            label: "Server artifact cwd",
+        });
+        if (cwdError !== null) {
+            return cwdError;
+        }
+    }
+    return {
+        status: "declared",
+        manifest: parsed.declaration.manifest,
+        runtime,
+    };
+}
+//# sourceMappingURL=live-manifest.js.map

package/dist/artifacts/preview-runtime.d.ts

@@ -1,21 +1,7 @@
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
-import type { ArtifactProjection, GetArtifactsResponse, HeartbeatArtifactPreviewDisposition, StartArtifactPreviewDisposition, StopArtifactPreviewDisposition } from "@tutti/shared/schemas/api";
+import type { GetArtifactsResponse } from "@tutti/shared/schemas/api";
 import { type ArtifactPreviewProcessPlan, type ArtifactProcessRuntime } from "./process-boundary.js";
-export type ArtifactPreviewCommandResult = {
-    artifact: ArtifactProjection;
-};
-export type ArtifactPreviewStartResult = {
-    disposition: StartArtifactPreviewDisposition;
-    result: ArtifactPreviewCommandResult;
-};
-export type ArtifactPreviewHeartbeatResult = {
-    disposition: HeartbeatArtifactPreviewDisposition;
-    result: ArtifactPreviewCommandResult;
-};
-export type ArtifactPreviewStopResult = {
-    disposition: StopArtifactPreviewDisposition;
-    result: ArtifactPreviewCommandResult;
-};
+import { type ArtifactStaticPreviewFile } from "./static-preview.js";
 export type ArtifactServerPreviewResponse = {
     status_code: number;
     headers: Record<string, string>;
@@ -23,7 +9,6 @@ export type ArtifactServerPreviewResponse = {
 };
 export type ArtifactPreviewHttpMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
 export type ArtifactPreviewManagerOptions = {
-    now?: () => Date;
     baseEnv?: NodeJS.ProcessEnv;
     spawnProcess?: (plan: ArtifactPreviewProcessPlan) => ChildProcessWithoutNullStreams;
     terminateProcess?: (child: ChildProcessWithoutNullStreams) => Promise<void>;
@@ -43,11 +28,15 @@ export type ArtifactPreviewManagerOptions = {
     responseBodyLimitBytes?: number;
     idleStopTtlMs?: number;
 };
+export type ArtifactPreviewLeaseOptions = {
+    viewerId: string;
+    workspaceRoot: string;
+};
 export declare const ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES: number;
 export declare const ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES: number;
+export declare const ARTIFACT_PREVIEW_BASE_PATH: "/artifacts/preview";
 export declare function isArtifactPreviewHttpMethod(method: string): method is ArtifactPreviewHttpMethod;
 export declare class ArtifactPreviewManager {
-    private readonly now;
     private readonly baseEnv;
     private readonly spawnProcess;
     private readonly terminateProcess;
@@ -67,25 +56,26 @@ export declare class ArtifactPreviewManager {
     private readonly responseBodyLimitBytes;
     private readonly idleStopTtlMs;
     private readonly pendingTasks;
+    private readonly leases;
+    private leaseSweepTimer;
     private state;
-    private nextInstanceSequence;
+    private declaration;
+    private lastProjection;
+    private workspaceUpdating;
+    private nextGenerationSequence;
     constructor(options?: ArtifactPreviewManagerOptions);
-    readProjection(options: {
-        workspaceRoot: string;
+    readProjection(options?: {
+        workspaceRoot?: string;
         previewBasePath?: string;
     }): GetArtifactsResponse;
-    start(options: {
+    initializeWorkspace(options: {
         workspaceRoot: string;
-        previewBasePath?: string;
-    }): ArtifactPreviewStartResult;
-    heartbeat(options: {
+    }): void;
+    renewLease(options: ArtifactPreviewLeaseOptions): void;
+    beginWorkspaceUpdate(): void;
+    settleWorkspaceUpdate(options: {
         workspaceRoot: string;
-        previewBasePath?: string;
-    }): ArtifactPreviewHeartbeatResult;
-    stop(options: {
-        workspaceRoot: string;
-        previewBasePath?: string;
-    }): ArtifactPreviewStopResult;
+    }): void;
     fetchServerPreview(options: {
         workspaceRoot: string;
         path: string | undefined;
@@ -94,22 +84,30 @@ export declare class ArtifactPreviewManager {
         headers?: Record<string, string | undefined>;
         body?: Buffer;
     }): Promise<ArtifactServerPreviewResponse>;
-    sweepIdle(): void;
+    readStaticPreview(options: {
+        workspaceRoot: string;
+        path: string | undefined;
+        query?: string;
+    }): ArtifactStaticPreviewFile;
     stopAll(): Promise<void>;
+    private currentProjection;
+    private ensurePreview;
+    private refreshDeclaration;
+    private applyDeclaration;
+    private createIdleState;
     private startProcess;
     private launchProcess;
     private attachProcessListeners;
     private waitUntilReady;
     private probeReadyEntry;
-    private recordHeartbeat;
-    private scheduleIdleSweep;
-    private stopStaleRuntime;
+    private pruneExpiredLeases;
+    private scheduleLeaseSweep;
     private stopCurrentProcess;
     private failState;
     private disposeStateProcess;
     private cleanupStateRuntime;
     private trackTask;
-    private nextInstanceId;
+    private nextGeneration;
 }
 export type { ArtifactPreviewProcessPlan } from "./process-boundary.js";
 export declare const ARTIFACT_PREVIEW_DEFAULT_BASE_PATH: "/artifacts/preview";