@alisio/server 0.1.0-alpha.5 → 0.1.0-alpha.7

package/dist/auth/view-token.d.ts

@@ -0,0 +1,16 @@
+/** Default lifetime of a view link (renewable with another `POST /api/artifacts/:aid/view`). */
+export declare const VIEW_TOKEN_TTL_MS: number;
+/** A token for `artifactId` valid until `expiresAt` (epoch ms). */
+export declare function signViewToken(secret: string, artifactId: string, expiresAt: number): string;
+export type ViewTokenCheck = {
+    ok: true;
+    artifactId: string;
+    expiresAt: number;
+} | {
+    ok: false;
+    reason: "malformed" | "signature" | "expired";
+};
+/** Verifies a token's signature (constant time) and expiry. */
+export declare function verifyViewToken(secret: string, token: string, now?: number): ViewTokenCheck;
+/** A request path with the view token replaced, for logs (tokens are never logged). */
+export declare const redactViewPath: (pathname: string) => string;

package/dist/auth/view-token.js

@@ -0,0 +1,36 @@
+/**
+ * Signed view tokens of the isolated artifact viewer (spec §14.2): `base64url(artifactId ·
+ * expiresAt · HMAC-SHA256(secret, artifactId‖expiresAt))`. A token names one artifact, expires
+ * after a short time and is useless with any other secret (a fresh one per server process).
+ */
+import { createHmac } from "node:crypto";
+import { safeEqual } from "./token.js";
+/** Default lifetime of a view link (renewable with another `POST /api/artifacts/:aid/view`). */
+export const VIEW_TOKEN_TTL_MS = 10 * 60_000;
+const ID = /^[A-Za-z0-9_-]{1,64}$/;
+const mac = (secret, artifactId, expiresAt) => createHmac("sha256", secret).update(`${artifactId}\n${expiresAt}`).digest("base64url");
+/** A token for `artifactId` valid until `expiresAt` (epoch ms). */
+export function signViewToken(secret, artifactId, expiresAt) {
+    if (!ID.test(artifactId))
+        throw new Error("Invalid artifact id");
+    return Buffer.from(`${artifactId}.${expiresAt}.${mac(secret, artifactId, expiresAt)}`, "utf8").toString("base64url");
+}
+/** Verifies a token's signature (constant time) and expiry. */
+export function verifyViewToken(secret, token, now = Date.now()) {
+    if (!/^[A-Za-z0-9_-]{1,512}$/.test(token))
+        return { ok: false, reason: "malformed" };
+    const parts = Buffer.from(token, "base64url").toString("utf8").split(".");
+    if (parts.length !== 3)
+        return { ok: false, reason: "malformed" };
+    const [artifactId = "", expires = "", signature = ""] = parts;
+    const expiresAt = Number(expires);
+    if (!ID.test(artifactId) || !/^\d{1,16}$/.test(expires) || !Number.isSafeInteger(expiresAt))
+        return { ok: false, reason: "malformed" };
+    if (!safeEqual(signature, mac(secret, artifactId, expiresAt)))
+        return { ok: false, reason: "signature" };
+    if (now >= expiresAt)
+        return { ok: false, reason: "expired" };
+    return { ok: true, artifactId, expiresAt };
+}
+/** A request path with the view token replaced, for logs (tokens are never logged). */
+export const redactViewPath = (pathname) => pathname.replace(/^\/artifact-view\/[^/]*/, "/artifact-view/[token]");

package/dist/bridges/approval-bridge.js

@@ -40,6 +40,10 @@ export class ApprovalBridge {
             effect: request.effect,
             ...(request.label ? { label: request.label } : {}),
             input: pretty(request.input),
+            ...(request.capability ? { capability: request.capability } : {}),
+            ...(request.preview !== undefined ? { preview: request.preview } : {}),
+            ...(request.runtime ? { runtime: request.runtime } : {}),
+            ...(request.install ? { install: request.install } : {}),
         }, request.signal);
     };
     /** Passed as `AppOptions.approveExternalDirectory` for every workspace app. */

package/dist/host/presets.js

@@ -16,6 +16,7 @@ const FLAG = {
     write: "--allow-write",
     process: "--allow-process",
     external: "--allow-external",
+    analysis: "--allow-analysis",
 };
 /**
  * A preset narrowed by the ceiling: an effect the launch flags do not allow degrades to asking
@@ -27,6 +28,9 @@ export function presetInfo(id, ceiling) {
         write: wanted.policy.write && ceiling.policy.write,
         process: wanted.policy.process && ceiling.policy.process,
         external: wanted.policy.external && ceiling.policy.external,
+        // `alisio serve --allow-analysis` pre-allows Python analysis where the preset allows
+        // processes (full-access); elsewhere python_run asks.
+        ...(wanted.policy.process && ceiling.policy.analysis ? { analysis: true } : {}),
     };
     if (ceiling.readOnly && id !== "read-only")
         return {

package/dist/host/run-scheduler.d.ts

@@ -1,4 +1,4 @@
-import type { Attachment } from "@alisio/sdk";
+import type { Attachment, DatasetRef } from "@alisio/sdk";
 import type { Application } from "./workspace-host.ts";
 type RunOptions = NonNullable<Parameters<Application["runner"]["run"]>[3]>;
 /** One prompt accepted by the server: a `runs` row in `queued` until a slot is free. */
@@ -10,9 +10,19 @@ export interface RunJob {
     text: string;
     correlationId: string;
     /** Built when the run starts, so preset and effort changes while queued apply. */
-    options: () => Omit<RunOptions, "runId" | "correlationId" | "attachments">;
+    options: () => Omit<RunOptions, "runId" | "correlationId" | "attachments" | "datasets">;
     attachments?: Attachment[];
+    /** Datasets attached to the prompt (chips); their summary is already part of `text`. */
+    datasets?: DatasetRef[];
     display?: string;
+    /**
+     * A tool call started from the UI instead of a prompt (`runToolCall`: no model, same gates),
+     * e.g. copying an artifact into the workspace. `text` is ignored for these jobs.
+     */
+    tool?: {
+        name: string;
+        input: Record<string, unknown>;
+    };
 }
 export interface RunSchedulerOptions {
     /** Global semaphore across sessions and workspaces (RF-02, default 4). */

package/dist/host/run-scheduler.js

@@ -36,13 +36,22 @@ export class RunScheduler {
         const { runner, store } = job.app;
         let run;
         try {
-            run = runner.run(job.sessionId, job.text, job.controller.signal, {
-                ...job.options(),
-                runId: job.runId,
-                correlationId: job.correlationId,
-                ...(job.attachments?.length ? { attachments: job.attachments } : {}),
-                ...(job.display ? { display: job.display } : {}),
-            });
+            run = job.tool
+                ? runner.runToolCall(job.sessionId, job.tool.name, job.tool.input, {
+                    ...job.options(),
+                    runId: job.runId,
+                    correlationId: job.correlationId,
+                    signal: job.controller.signal,
+                    ...(job.display ? { display: job.display } : {}),
+                })
+                : runner.run(job.sessionId, job.text, job.controller.signal, {
+                    ...job.options(),
+                    runId: job.runId,
+                    correlationId: job.correlationId,
+                    ...(job.attachments?.length ? { attachments: job.attachments } : {}),
+                    ...(job.datasets?.length ? { datasets: job.datasets } : {}),
+                    ...(job.display ? { display: job.display } : {}),
+                });
         }
         catch (error) {
             run = Promise.reject(error);

package/dist/host/sessions.js

@@ -21,6 +21,7 @@ export class SessionService {
                 write: !readOnly && !!base.allowWrite,
                 process: !readOnly && !!base.allowProcess,
                 external: !readOnly && (!!base.allowExternal || !!base.allowMcp || !!base.allowAgents),
+                ...(!readOnly && base.allowAnalysis ? { analysis: true } : {}),
             },
             approvals: !readOnly,
             readOnly,

package/dist/host/workspace-host.js

@@ -1,6 +1,5 @@
-import { createHash } from "node:crypto";
 import { stat } from "node:fs/promises";
-import { createApplication, findWorkspace, resolveTrust, } from "@alisio/core";
+import { createApplication, findWorkspace, resolveTrust, workspaceKey, } from "@alisio/core";
 import { HttpError } from "../http/errors.js";
 const MISSING_ERRNO = new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"]);
 const missing = (path) => new HttpError("workspace_missing", `Workspace folder not found: ${path}`, { path });
@@ -14,7 +13,7 @@ export async function workspaceExists(path) {
     }
 }
 /** Opaque, stable workspace id: a short sha256 of the canonical path (never a path in URLs). */
-export const workspaceId = (path) => createHash("sha256").update(path).digest("hex").slice(0, 16);
+export const workspaceId = (path) => workspaceKey(path);
 /**
  * One lazily created `Application` per workspace (ADR-06), with LRU eviction of idle apps,
  * a cap on open apps and trust resolved from the shared trust store (granted by the terminal
@@ -90,6 +89,7 @@ export class WorkspaceHost {
                 ...base,
                 trustProject: explicit ? base.trustProject : trusted,
                 cwd: path,
+                approvalSource: "web",
                 ...(this.options.wire?.(id, path) ?? {}),
             });
         }

package/dist/http/errors.js

@@ -28,6 +28,12 @@ export const STATUS = {
     picker_unavailable: 503,
     permission_denied: 403,
     cancelled: 409,
+    artifact_not_found: 404,
+    artifact_too_large: 413,
+    runtime_unavailable: 503,
+    dataset_unsupported: 415,
+    query_rejected: 400,
+    query_timeout: 408,
     internal: 500,
 };
 /** A typed API failure; routes throw it and the server renders it as an `ApiError` body. */

package/dist/http/router.d.ts

@@ -17,7 +17,10 @@ export type RouteResult = {
     body: unknown;
 } | undefined;
 export type RouteHandler = (ctx: RouteContext) => Promise<RouteResult> | RouteResult;
-/** Minimal method + path router with `:param` segments (no regex, no wildcards). */
+/**
+ * Minimal method + path router with `:param` segments and an optional trailing `*` segment that
+ * captures the rest of the path (at least one segment) in `params["*"]`. No regex.
+ */
 export declare class Router {
     private routes;
     add(method: string, path: string, handler: RouteHandler): this;

package/dist/http/router.js

@@ -1,4 +1,7 @@
-/** Minimal method + path router with `:param` segments (no regex, no wildcards). */
+/**
+ * Minimal method + path router with `:param` segments and an optional trailing `*` segment that
+ * captures the rest of the path (at least one segment) in `params["*"]`. No regex.
+ */
 export class Router {
     routes = [];
     add(method, path, handler) {
@@ -38,25 +41,43 @@ export class Router {
         return pathMatched ? "method" : undefined;
     }
 }
+const decode = (segment) => {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return undefined;
+    }
+};
 function matchSegments(pattern, parts) {
-    if (pattern.length !== parts.length)
+    const wildcard = pattern.at(-1) === "*";
+    const fixed = wildcard ? pattern.length - 1 : pattern.length;
+    if (wildcard ? parts.length <= fixed : parts.length !== fixed)
         return undefined;
     const params = {};
-    for (let i = 0; i < pattern.length; i++) {
+    for (let i = 0; i < fixed; i++) {
         const expected = pattern[i];
         const actual = parts[i];
         if (expected.startsWith(":")) {
-            let decoded;
-            try {
-                decoded = decodeURIComponent(actual);
-            }
-            catch {
+            const decoded = decode(actual);
+            if (decoded === undefined)
                 return undefined;
-            }
             params[expected.slice(1)] = decoded;
         }
         else if (expected !== actual)
             return undefined;
     }
+    if (wildcard) {
+        // Each segment is decoded on its own and the rest is joined with "/": confinement of the
+        // resulting path is the handler's job (it may contain "..").
+        const rest = [];
+        for (const part of parts.slice(fixed)) {
+            const decoded = decode(part);
+            if (decoded === undefined)
+                return undefined;
+            rest.push(decoded);
+        }
+        params["*"] = rest.join("/");
+    }
     return params;
 }

package/dist/index.js

@@ -5,8 +5,10 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { dirname, join } from "node:path";
-import { BlobStore, SQLiteStore, stateHome } from "@alisio/core";
+import { AnalysisJobs, ArtifactStore, BlobStore, CapabilityGrants, SQLiteStore, stateHome, } from "@alisio/core";
 import { AuthGuard, isLoopbackHost } from "./auth/guard.js";
+import { newSecret } from "./auth/token.js";
+import { redactViewPath } from "./auth/view-token.js";
 import { ApprovalBridge } from "./bridges/approval-bridge.js";
 import { InteractionBridge } from "./bridges/interaction-bridge.js";
 import { createNativePicker } from "./host/folder-picker.js";
@@ -19,8 +21,12 @@ import { StaticAssets } from "./http/static.js";
 import { createLogger } from "./log.js";
 import { registerAgentDefinitionRoutes } from "./routes/agent-definitions.js";
 import { registerApprovalRoutes } from "./routes/approvals.js";
+import { registerArtifactViewRoutes, VIEW_PREFIX, viewerBaseHeaders, } from "./routes/artifact-view.js";
+import { registerArtifactRoutes } from "./routes/artifacts.js";
 import { registerBlobRoutes } from "./routes/blobs.js";
+import { registerCapabilityRoutes } from "./routes/capabilities.js";
 import { registerCommandRoutes } from "./routes/commands.js";
+import { registerDatasetRoutes } from "./routes/datasets.js";
 import { registerEventRoutes } from "./routes/events.js";
 import { registerFileRoutes } from "./routes/files.js";
 import { registerFolderRoutes } from "./routes/folders.js";
@@ -74,6 +80,15 @@ export async function startServer(options = {}) {
         root: dbPath !== ":memory:" ? join(dirname(dbPath), "blobs") : join(stateHome(), "blobs"),
         db: catalog.db,
     });
+    // Artifacts and capability grants of every workspace (same folders and rows the apps write).
+    const stateRoot = dbPath !== ":memory:" ? dirname(dbPath) : stateHome();
+    const artifacts = new ArtifactStore({ root: stateRoot, db: catalog.db });
+    const grants = new CapabilityGrants({ db: catalog.db, rootOf: (id) => catalog.rootOf(id) });
+    const jobs = new AnalysisJobs({ root: stateRoot, db: catalog.db });
+    // The isolated viewer (§14.2) lives outside /api, on its own router, signed per process.
+    const viewRouter = new Router();
+    const viewSecret = newSecret();
+    registerArtifactViewRoutes(viewRouter, { artifacts, secret: viewSecret });
     // Startup reconciliation (RNF-09): runs and child sessions left queued/running by a dead
     // process become interrupted before any client lists them.
     catalog.interruptRuns();
@@ -140,6 +155,12 @@ export async function startServer(options = {}) {
             onEvent: (event) => {
                 inflight.apply(event);
                 hub.publish(event);
+                // A persisted "allow for this session" grant: other tabs refresh their permissions.
+                if (event.type === "approval_resolved" &&
+                    event.data?.persisted) {
+                    const root = catalog.rootOf(event.sessionId);
+                    hub.toSession(root, { t: "capabilities_changed", sessionId: root });
+                }
             },
             ...(approvals
                 ? { approve: approvals.handler, approveExternalDirectory: approvals.directoryHandler }
@@ -209,6 +230,26 @@ export async function startServer(options = {}) {
     registerSessionViewRoutes(router, { catalog, sessions });
     registerFileRoutes(router, { workspaces, catalog, sessions });
     registerBlobRoutes(router, { blobs });
+    registerArtifactRoutes(router, {
+        artifacts,
+        sessions,
+        scheduler,
+        jobs,
+        stateRoot,
+        viewSecret,
+    });
+    registerDatasetRoutes(router, {
+        sessions,
+        catalog,
+        artifacts,
+        blobs,
+        toSession: (sessionId, frame) => hub.toSession(sessionId, frame),
+    });
+    registerCapabilityRoutes(router, {
+        grants,
+        sessions,
+        toSession: (sessionId, frame) => hub.toSession(sessionId, frame),
+    });
     registerPromptRoutes(router, { sessions, scheduler });
     registerCommandRoutes(router, { sessions, scheduler, workspaces });
     registerSideQuestionRoutes(router, { sessions });
@@ -236,12 +277,32 @@ export async function startServer(options = {}) {
         res.setHeader("X-Request-Id", correlationId);
         const url = new URL(req.url ?? "/", "http://localhost");
         const api = url.pathname === "/api" || url.pathname.startsWith("/api/");
-        securityHeaders(res, assets.csp, api);
+        // View tokens are capabilities: they never reach the logs.
+        const route = redactViewPath(url.pathname);
+        const viewer = url.pathname.startsWith(VIEW_PREFIX);
+        // The viewer replaces the app's headers (it must be framable by the app, and only by it).
+        if (viewer)
+            viewerBaseHeaders(res);
+        else
+            securityHeaders(res, assets.csp, api);
         const method = req.method ?? "GET";
         try {
             if (!guard)
                 throw new HttpError("shutting_down", "Server is not ready");
             guard.checkHost(req);
+            if (viewer) {
+                // No cookie (a sandboxed iframe never sends it) and no Origin check: GET/HEAD only,
+                // authorized by the signed token alone.
+                if (method !== "GET" && method !== "HEAD")
+                    throw new HttpError("not_found", "Not found");
+                if (closing)
+                    throw new HttpError("shutting_down", "Server is shutting down");
+                const matched = viewRouter.match(method, url.pathname);
+                if (!matched || matched === "method")
+                    throw new HttpError("not_found", "Not found");
+                await matched.handler({ req, res, url, params: matched.params, correlationId });
+                return;
+            }
             guard.checkOrigin(req);
             if (!api) {
                 if (method !== "GET" && method !== "HEAD")
@@ -267,7 +328,8 @@ export async function startServer(options = {}) {
                 throw new HttpError("not_found", "Method not supported");
             // Every write is JSON (it forces a CORS preflight) except the raw image upload, which
             // checks its own image content types (also non-safelisted, so also preflighted).
-            const upload = method === "POST" && url.pathname === "/api/blobs";
+            const upload = method === "POST" &&
+                (url.pathname === "/api/blobs" || /^\/api\/sessions\/[^/]+\/datasets$/.test(url.pathname));
             if (!["GET", "HEAD", "OPTIONS"].includes(method) && !upload) {
                 const type = String(req.headers["content-type"] ?? "")
                     .split(";")[0]
@@ -287,7 +349,7 @@ export async function startServer(options = {}) {
             if (status === 500)
                 logger.error("request failed", {
                     correlationId,
-                    route: url.pathname,
+                    route,
                     error: error instanceof Error ? error.message : String(error),
                 });
             if (!res.headersSent)
@@ -298,7 +360,7 @@ export async function startServer(options = {}) {
         finally {
             logger.debug("request", {
                 correlationId,
-                route: `${method} ${url.pathname}`,
+                route: `${method} ${route}`,
                 status: res.statusCode,
                 ms: Date.now() - started,
             });

package/dist/routes/artifact-view.d.ts

@@ -0,0 +1,17 @@
+import type { ServerResponse } from "node:http";
+import { type ArtifactStore } from "@alisio/core";
+import type { Router } from "../http/router.ts";
+/** Path prefix of the viewer route. */
+export declare const VIEW_PREFIX = "/artifact-view/";
+/**
+ * Headers every viewer response starts with (also errors): unframable, inert and uncached. A
+ * successful file response relaxes framing to the app origin with {@link viewerHeaders}.
+ */
+export declare function viewerBaseHeaders(res: ServerResponse): void;
+/** The CSP of an HTML artifact (and its assets) under `origin`/`base` (§14.2). */
+export declare function dashboardCsp(origin: string, base: string): string;
+export declare function registerArtifactViewRoutes(router: Router, ctx: {
+    artifacts: ArtifactStore;
+    secret: string;
+    now?: () => number;
+}): void;

package/dist/routes/artifact-view.js

@@ -0,0 +1,78 @@
+/**
+ * The isolated artifact viewer (spec §14.2): `GET|HEAD /artifact-view/<token>/<path>`, outside
+ * `/api` and without the session cookie (a sandboxed iframe never sends it). The signed token
+ * names one artifact; only files listed in its manifest are served, with headers that replace
+ * the app's: framable by the app origin only, an opaque origin (`sandbox`) and no network.
+ */
+import { createReadStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { viewerContentType } from "@alisio/core";
+import { verifyViewToken } from "../auth/view-token.js";
+import { HttpError } from "../http/errors.js";
+import { viewable } from "./artifacts.js";
+/** Path prefix of the viewer route. */
+export const VIEW_PREFIX = "/artifact-view/";
+/**
+ * Headers every viewer response starts with (also errors): unframable, inert and uncached. A
+ * successful file response relaxes framing to the app origin with {@link viewerHeaders}.
+ */
+export function viewerBaseHeaders(res) {
+    res.setHeader("Content-Security-Policy", "default-src 'none'; frame-ancestors 'none'; sandbox");
+    res.setHeader("X-Frame-Options", "DENY");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader("Cross-Origin-Resource-Policy", "same-origin");
+    res.setHeader("Cache-Control", "private, no-store");
+}
+/** The CSP of an HTML artifact (and its assets) under `origin`/`base` (§14.2). */
+export function dashboardCsp(origin, base) {
+    return [
+        "default-src 'none'",
+        `script-src ${base} 'unsafe-inline'`,
+        `style-src ${base} 'unsafe-inline'`,
+        `img-src ${base} data: blob:`,
+        `font-src ${base} data:`,
+        `media-src ${base} data: blob:`,
+        "connect-src 'none'",
+        "form-action 'none'",
+        "base-uri 'none'",
+        `frame-ancestors ${origin}`,
+        "sandbox allow-scripts allow-downloads",
+    ].join("; ");
+}
+export function registerArtifactViewRoutes(router, ctx) {
+    const handler = async ({ req, res, params }) => {
+        const token = params.token ?? "";
+        const check = verifyViewToken(ctx.secret, token, (ctx.now ?? Date.now)());
+        if (!check.ok)
+            throw new HttpError("permission_denied", check.reason === "expired" ? "This view link expired" : "Invalid view link");
+        const record = ctx.artifacts.get(check.artifactId);
+        if (!record || record.status !== "ready" || !viewable(record))
+            throw new HttpError("artifact_not_found", "Artifact not found");
+        const file = await ctx.artifacts.resolveFile(record, params["*"] ?? "");
+        if (!file)
+            throw new HttpError("artifact_not_found", "File not found in this artifact");
+        // `checkHost` already validated the Host header: it names this server.
+        const origin = `http://${req.headers.host ?? ""}`;
+        const pdf = record.mimeType === "application/pdf" && file.path === (record.entry ?? record.fileName);
+        res.removeHeader("X-Frame-Options");
+        res.setHeader("Content-Security-Policy", 
+        // Chromium's PDF viewer does not load in a sandboxed context (risk R6, decision D9).
+        pdf
+            ? `default-src 'none'; frame-ancestors ${origin}`
+            : dashboardCsp(origin, `${origin}/artifact-view/${token}/`));
+        // The opaque-origin document must be able to load its own files.
+        res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
+        res.writeHead(200, {
+            "Content-Type": pdf ? "application/pdf" : viewerContentType(file.path),
+            "Content-Length": file.bytes,
+        });
+        if (req.method === "HEAD")
+            res.end();
+        else
+            await pipeline(createReadStream(file.abs), res);
+        return undefined;
+    };
+    router.get(`${VIEW_PREFIX}:token/*`, handler);
+    router.add("HEAD", `${VIEW_PREFIX}:token/*`, handler);
+}

package/dist/routes/artifacts.d.ts

@@ -0,0 +1,26 @@
+import { type AnalysisJobs, type ArtifactRecord, type ArtifactStore } from "@alisio/core";
+import type { RunScheduler } from "../host/run-scheduler.ts";
+import type { SessionService } from "../host/sessions.ts";
+import type { Router } from "../http/router.ts";
+/** `attachment; filename="…"; filename*=UTF-8''…` with an ASCII fallback (RFC 6266/5987). */
+export declare function attachmentDisposition(fileName: string): string;
+/**
+ * CSP of files served to the panel on the app origin: inert when opened as a document (opaque
+ * origin, no scripts), harmless for `<img>` and `fetch()` which ignore it.
+ */
+export declare const FILE_CSP = "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; sandbox";
+/** `/artifact-view/<token>/<path>` with every path segment encoded. */
+export declare const viewUrl: (token: string, path: string) => string;
+/** Whether the isolated viewer serves an artifact (HTML dashboards and PDFs). */
+export declare const viewable: (record: Pick<ArtifactRecord, "kind" | "mimeType">) => boolean;
+export declare function registerArtifactRoutes(router: Router, ctx: {
+    artifacts: ArtifactStore;
+    sessions: SessionService;
+    scheduler?: RunScheduler;
+    jobs?: AnalysisJobs;
+    /** State root (job folders of `sources` are relative to it). */
+    stateRoot?: string;
+    /** Per-process secret that signs viewer links. */
+    viewSecret?: string;
+    now?: () => number;
+}): void;