@lazyingart/agintiflow 0.20.126 → 0.20.127

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.126",
+  "version": "0.20.127",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/public/app.js

@@ -2061,6 +2061,12 @@ function resetArtifactViewer() {
   artifactViewerBodyEl.innerHTML = `<p class="subtle">${t("artifactViewerEmpty")}</p>`;
 }
 
+function artifactRawUrl(artifactId, { download = false } = {}) {
+  if (!currentSessionId || !artifactId) return "";
+  const base = `/api/sessions/${encodeURIComponent(currentSessionId)}/artifacts/${encodeURIComponent(artifactId)}/raw`;
+  return download ? `${base}?download=1` : base;
+}
+
 function renderArtifactShell() {
   renderArtifactBadge();
   renderArtifactList();
@@ -2075,23 +2081,40 @@ function renderArtifactContent(content) {
   artifactViewerTitleEl.textContent = content.title || item?.title || t("artifactViewerEmptyTitle");
   artifactViewerMetaEl.textContent = [content.path || item?.path, item ? artifactLabel(item) : ""].filter(Boolean).join(" · ");
   artifactViewerKindEl.textContent = content.kind || item?.kind || "";
+  const streamedUrl = content.url || (content.id ? artifactRawUrl(content.id) : "");
+  const downloadUrl = content.downloadUrl || (content.id ? artifactRawUrl(content.id, { download: true }) : "");
+  const renderUrl = content.dataUrl || streamedUrl;
 
-  if (content.dataUrl && (content.kind === "pdf" || content.mime === "application/pdf")) {
+  if (renderUrl && (content.kind === "pdf" || content.mime === "application/pdf")) {
     artifactViewerBodyEl.innerHTML = `
-      <iframe class="artifact-pdf-frame" src="${content.dataUrl}" title="${escapeHtml(content.title || "Artifact PDF")}"></iframe>
+      <iframe class="artifact-pdf-frame" src="${renderUrl}" title="${escapeHtml(content.title || "Artifact PDF")}"></iframe>
     `;
     return;
   }
 
-  if (content.dataUrl) {
+  if (renderUrl && (content.kind === "image" || String(content.mime || "").startsWith("image/"))) {
     artifactViewerBodyEl.innerHTML = `
       <figure class="artifact-image-frame">
-        <img class="artifact-preview-image" src="${content.dataUrl}" alt="${escapeHtml(content.title || "Artifact image")}" />
+        <img class="artifact-preview-image" src="${renderUrl}" alt="${escapeHtml(content.title || "Artifact image")}" />
       </figure>
     `;
     return;
   }
 
+  if ((content.tooLargeForInline || content.binary) && streamedUrl) {
+    artifactViewerBodyEl.innerHTML = `
+      <div class="artifact-large-file">
+        <strong>${escapeHtml(content.preview || "Artifact is available as a streamed file.")}</strong>
+        <p>${escapeHtml(content.path || item?.path || content.title || "Generated artifact")}</p>
+        <div class="artifact-file-actions">
+          <a class="secondary-button" href="${streamedUrl}" target="_blank" rel="noreferrer">Open preview</a>
+          <a class="secondary-button" href="${downloadUrl}" download="${escapeHtml(artifactDownloadName(item, content))}">Download</a>
+        </div>
+      </div>
+    `;
+    return;
+  }
+
   const text = typeof content.text === "string" ? content.text : "";
   if (content.kind === "markdown" || /markdown/i.test(content.mime || "")) {
     artifactViewerBodyEl.innerHTML = `<div class="artifact-markdown markdown-body">${renderMarkdown(text)}</div>`;
@@ -2153,6 +2176,21 @@ async function downloadArtifact(artifactId) {
     const data = await response.json().catch(() => ({}));
     if (!response.ok) throw new Error(data.error || t("artifactDownloadFailed"));
 
+    if ((data.downloadUrl || data.url) && !data.dataUrl && typeof data.text !== "string") {
+      const link = document.createElement("a");
+      link.href = data.downloadUrl || artifactRawUrl(artifactId, { download: true }) || data.url;
+      link.download = artifactDownloadName(item, data);
+      document.body.append(link);
+      link.click();
+      link.remove();
+
+      markArtifactRead(artifactId);
+      renderArtifactBadge();
+      renderArtifactList();
+      artifactStatusEl.textContent = t("artifactDownloadReady");
+      return;
+    }
+
     const blob = data.dataUrl
       ? blobFromDataUrl(data.dataUrl)
       : new Blob([typeof data.text === "string" ? data.text : JSON.stringify(data, null, 2)], {

package/public/styles.css

@@ -1602,6 +1602,29 @@ button.danger {
   background: white;
 }
 
+.artifact-large-file {
+  display: grid;
+  gap: 10px;
+  align-content: start;
+  margin: 0;
+  padding: 18px;
+  border: 1px solid var(--line);
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.artifact-large-file p {
+  margin: 0;
+  color: var(--muted);
+  overflow-wrap: anywhere;
+}
+
+.artifact-file-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
 .artifact-editor {
   min-height: 100%;
   height: 100%;

package/references/agintiflow-aaps-slogan-subtext-v3.md

@@ -14,7 +14,7 @@ AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-a
 
 Project-oriented programming for agentic workflows.
 
-AAPS is a project oriented and prompt-native programming language and visual studio for turning prompts into structured, verifiable pipelines. It connects wet and dry experiments, hardware and software, and human intent with executable agent work through tasks, typed inputs, declared outputs, validation gates, recovery steps, and durable artifacts.
+AAPS is a prompt-native programming language and visual studio for turning prompts into structured, verifiable pipelines. It connects wet and dry experiments, hardware and software, and human intent with executable agent work through tasks, typed inputs, declared outputs, validation gates, recovery steps, and durable artifacts.
 
 ## Shorter Version
 

package/scripts/smoke-canvas-artifacts.js

@@ -1,7 +1,13 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { buildArtifacts, normalizeCanvasPayload, persistCanvasPayloadFile, readArtifactContent } from "../src/artifact-tunnel.js";
+import {
+  buildArtifacts,
+  normalizeCanvasPayload,
+  persistCanvasPayloadFile,
+  readArtifactContent,
+  resolveArtifactFile,
+} from "../src/artifact-tunnel.js";
 import { SessionStore } from "../src/session-store.js";
 
 async function main() {
@@ -54,6 +60,45 @@ async function main() {
   if (!content.ok) throw new Error(content.error || "persisted artifact could not be read");
   if (!String(content.text || "").includes("Durable report")) throw new Error("persisted artifact content mismatch");
 
+  const largeImagePath = path.join(workspace, "large-preview.png");
+  const pngHeader = Buffer.from("89504e470d0a1a0a", "hex");
+  await fs.writeFile(largeImagePath, Buffer.concat([pngHeader, Buffer.alloc(4_200_000)]));
+  const largeNormalized = normalizeCanvasPayload(
+    {
+      title: "Large preview image",
+      kind: "image",
+      path: "large-preview.png",
+      selected: true,
+    },
+    config
+  );
+  if (!largeNormalized.ok) throw new Error(largeNormalized.reason || "large image canvas payload normalization failed");
+  const largePersisted = await persistCanvasPayloadFile(largeNormalized.payload, { config, store });
+  if (!largePersisted.ok) throw new Error(largePersisted.reason || "large image canvas artifact persistence failed");
+  if (!largePersisted.payload.artifactPersisted) throw new Error("large image was not persisted into session artifacts");
+
+  const largeEvents = [
+    {
+      timestamp: new Date().toISOString(),
+      type: "canvas.item",
+      data: {
+        ...largePersisted.payload,
+        commandCwd: workspace,
+      },
+    },
+  ];
+  const { items: largeItems } = buildArtifacts({ sessionId: store.sessionId, events: largeEvents, store });
+  const largeContent = await readArtifactContent(largeItems[0], { store, config });
+  if (!largeContent.ok) throw new Error(largeContent.error || "large artifact metadata could not be read");
+  if (largeContent.dataUrl) throw new Error("large artifact should not be inlined as a data URL");
+  if (!largeContent.url || !largeContent.downloadUrl || !largeContent.tooLargeForInline) {
+    throw new Error("large artifact did not expose streamed preview URLs");
+  }
+  const largeFile = await resolveArtifactFile(largeItems[0], { store, config });
+  if (!largeFile.ok || largeFile.size <= 4_000_000 || largeFile.mime !== "image/png") {
+    throw new Error("large artifact file resolver returned invalid metadata");
+  }
+
   const missing = await persistCanvasPayloadFile({ ...normalized.payload, path: "missing.png" }, { config, store });
   if (missing.ok) throw new Error("missing canvas path should fail persistence");
 

package/scripts/smoke-web-api.js

@@ -350,6 +350,37 @@ try {
     throw new Error("artifact content endpoint did not return renderable content");
   }
 
+  const largeSessionId = "large-artifact-smoke";
+  const largeStore = new SessionStore(paths.globalSessionsDir, largeSessionId, sessionStoreOptions(runtimeDir, largeSessionId));
+  await largeStore.ensure();
+  const largeCanvasDir = path.join(largeStore.artifactsDir, "canvas");
+  await fs.mkdir(largeCanvasDir, { recursive: true });
+  const largeImagePath = path.join(largeCanvasDir, "large-image.png");
+  await fs.writeFile(largeImagePath, Buffer.concat([Buffer.from("89504e470d0a1a0a", "hex"), Buffer.alloc(4_200_000)]));
+  await largeStore.appendEvent("canvas.item", {
+    artifactId: "large-image",
+    title: "Large streamed image",
+    kind: "image",
+    path: "large-image.png",
+    sessionFilePath: largeImagePath,
+    selected: true,
+  });
+  const largeArtifacts = await fetchJson(`/api/sessions/${encodeURIComponent(largeSessionId)}/artifacts`);
+  if (!largeArtifacts.items?.some((item) => item.id === "large-image")) {
+    throw new Error("large artifact endpoint did not list session artifact");
+  }
+  const largeContent = await fetchJson(`/api/sessions/${encodeURIComponent(largeSessionId)}/artifacts/large-image`);
+  if (!largeContent.tooLargeForInline || !largeContent.url || largeContent.dataUrl) {
+    throw new Error("large artifact metadata did not switch to streamed preview");
+  }
+  const rawResponse = await fetch(`${baseUrl}/api/sessions/${encodeURIComponent(largeSessionId)}/artifacts/large-image/raw`);
+  if (!rawResponse.ok) throw new Error(`large artifact raw endpoint failed: ${rawResponse.status}`);
+  if (!/^image\/png\b/i.test(rawResponse.headers.get("content-type") || "")) {
+    throw new Error("large artifact raw endpoint did not preserve image content type");
+  }
+  const rawBytes = await rawResponse.arrayBuffer();
+  if (rawBytes.byteLength <= 4_000_000) throw new Error("large artifact raw endpoint returned truncated content");
+
   const deleted = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}`, {
     method: "DELETE",
   });
@@ -384,6 +415,7 @@ try {
           "/api/workspace/changes",
           "/api/sessions/:id/artifacts",
           "/api/sessions/:id/artifacts/:artifactId",
+          "/api/sessions/:id/artifacts/:artifactId/raw",
           "POST /api/sessions/:id/artifacts/select",
         ],
         provider: run.provider,

package/src/artifact-tunnel.js

@@ -60,6 +60,16 @@ function mimeForPath(filePath) {
   return IMAGE_MIME_BY_EXT.get(ext) || BINARY_RENDER_MIME_BY_EXT.get(ext) || "text/plain; charset=utf-8";
 }
 
+function isRenderableBinaryMime(mime) {
+  return String(mime || "").startsWith("image/") || mime === "application/pdf";
+}
+
+function artifactRawUrl(item, download = false) {
+  if (!item?.sessionId || !item?.id) return "";
+  const base = `/api/sessions/${encodeURIComponent(item.sessionId)}/artifacts/${encodeURIComponent(item.id)}/raw`;
+  return download ? `${base}?download=1` : base;
+}
+
 function safeCanvasFilename(artifactId, filePath) {
   const rawBase = path.basename(String(filePath || "artifact"));
   const safeBase = rawBase
@@ -285,24 +295,13 @@ export function findArtifact(items, artifactId) {
   return items.find((item) => item.id === artifactId) || null;
 }
 
-export async function readArtifactContent(item, { store, config }) {
+export async function resolveArtifactFile(item, { store, config } = {}) {
   if (!item) {
     return { ok: false, error: "Artifact not found." };
   }
 
-  if (item.ref?.type === "inline") {
-    return {
-      ok: true,
-      id: item.id,
-      kind: item.kind,
-      title: item.title,
-      path: item.path || "",
-      mime: item.mime || "text/plain; charset=utf-8",
-      text: redactSensitiveText(String(item.ref.text || "")),
-    };
-  }
-
   if (item.ref?.type === "session-file") {
+    if (!store?.sessionDir) return { ok: false, error: "Artifact session store is unavailable." };
     const absolutePath = path.resolve(item.ref.path);
     if (!isInside(store.sessionDir, absolutePath)) {
       return { ok: false, error: "Artifact path is outside this session." };
@@ -311,32 +310,14 @@ export async function readArtifactContent(item, { store, config }) {
     const stat = await fs.stat(absolutePath).catch(() => null);
     if (!stat?.isFile()) return { ok: false, error: "Artifact file is missing." };
     const mime = mimeForPath(absolutePath);
-    const isBinaryRenderable = mime.startsWith("image/") || mime === "application/pdf";
-    const maxBytes = isBinaryRenderable ? MAX_ARTIFACT_IMAGE_BYTES : MAX_ARTIFACT_TEXT_BYTES;
-    if (stat.size > maxBytes) return { ok: false, error: "Artifact is too large to preview safely." };
-
-    const buffer = await fs.readFile(absolutePath);
-    if (isBinaryRenderable) {
-      return {
-        ok: true,
-        id: item.id,
-        kind: mime === "application/pdf" ? "pdf" : "image",
-        title: item.title,
-        path: item.path || "",
-        mime,
-        dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
-      };
-    }
-
-    if (buffer.includes(0)) return { ok: false, error: "Binary artifact cannot be rendered as text." };
     return {
       ok: true,
-      id: item.id,
-      kind: item.kind,
+      absolutePath,
+      size: stat.size,
+      mime,
+      kind: mime === "application/pdf" ? "pdf" : mime.startsWith("image/") ? "image" : item.kind,
       title: item.title,
       path: item.path || "",
-      mime,
-      text: redactSensitiveText(buffer.toString("utf8")),
     };
   }
 
@@ -350,33 +331,87 @@ export async function readArtifactContent(item, { store, config }) {
     const target = resolveWorkspacePath(itemConfig, item.ref.path);
     const stat = await fs.stat(target.absolutePath).catch(() => null);
     if (!stat?.isFile()) return { ok: false, error: "Workspace file is missing." };
-
     const mime = mimeForPath(target.absolutePath);
-    const isBinaryRenderable = mime.startsWith("image/") || mime === "application/pdf";
+    return {
+      ok: true,
+      absolutePath: target.absolutePath,
+      size: stat.size,
+      mime,
+      kind: mime === "application/pdf" ? "pdf" : mime.startsWith("image/") ? "image" : item.kind,
+      title: item.title,
+      path: item.path || "",
+    };
+  }
+
+  return { ok: false, error: "Artifact has no readable file." };
+}
+
+export async function readArtifactContent(item, { store, config }) {
+  if (!item) {
+    return { ok: false, error: "Artifact not found." };
+  }
+
+  if (item.ref?.type === "inline") {
+    return {
+      ok: true,
+      id: item.id,
+      kind: item.kind,
+      title: item.title,
+      path: item.path || "",
+      mime: item.mime || "text/plain; charset=utf-8",
+      text: redactSensitiveText(String(item.ref.text || "")),
+    };
+  }
+
+  if (item.ref?.type === "session-file" || item.ref?.type === "workspace-file") {
+    const resolved = await resolveArtifactFile(item, { store, config });
+    if (!resolved.ok) return resolved;
+
+    const isBinaryRenderable = isRenderableBinaryMime(resolved.mime);
     const maxBytes = isBinaryRenderable ? MAX_ARTIFACT_IMAGE_BYTES : MAX_ARTIFACT_TEXT_BYTES;
-    if (stat.size > maxBytes) return { ok: false, error: "Workspace file is too large to preview safely." };
+    const url = artifactRawUrl(item);
+    const downloadUrl = artifactRawUrl(item, true);
+    const base = {
+      ok: true,
+      id: item.id,
+      kind: resolved.kind,
+      title: item.title,
+      path: item.path || "",
+      mime: resolved.mime,
+      size: resolved.size,
+      url,
+      downloadUrl,
+    };
+
+    if (resolved.size > maxBytes) {
+      return {
+        ...base,
+        tooLargeForInline: true,
+        preview: isBinaryRenderable
+          ? "Large renderable artifact is available through the streamed artifact endpoint."
+          : "Large artifact is available through the streamed artifact endpoint.",
+      };
+    }
 
-    const buffer = await fs.readFile(target.absolutePath);
+    const buffer = await fs.readFile(resolved.absolutePath);
     if (isBinaryRenderable) {
       return {
-        ok: true,
-        id: item.id,
-        kind: mime === "application/pdf" ? "pdf" : "image",
-        title: item.title,
-        path: item.path || "",
-        mime,
-        dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
+        ...base,
+        dataUrl: `data:${resolved.mime};base64,${buffer.toString("base64")}`,
+      };
+    }
+
+    if (buffer.includes(0)) {
+      return {
+        ...base,
+        binary: true,
+        preview: "Binary artifact is available through the streamed artifact endpoint.",
       };
     }
 
-    if (buffer.includes(0)) return { ok: false, error: "Binary workspace file cannot be rendered as text." };
     return {
-      ok: true,
-      id: item.id,
+      ...base,
       kind: item.kind,
-      title: item.title,
-      path: item.path || "",
-      mime,
       text: redactSensitiveText(buffer.toString("utf8")),
     };
   }

package/web.js

@@ -1,3 +1,4 @@
+import { createReadStream } from "node:fs";
 import fs from "node:fs/promises";
 import express from "express";
 import path from "node:path";
@@ -43,6 +44,7 @@ import {
   countUnreadArtifacts,
   findArtifact,
   readArtifactContent,
+  resolveArtifactFile,
   serializeArtifacts,
 } from "./src/artifact-tunnel.js";
 
@@ -75,6 +77,17 @@ function isSafeSessionId(sessionId) {
   return /^[A-Za-z0-9._:-]+$/.test(String(sessionId || "")) && !String(sessionId || "").includes("..");
 }
 
+function safeDownloadFilename(value) {
+  const basename = path.basename(String(value || "artifact").replace(/\\/g, "/"));
+  return (
+    basename
+      .replace(/[\r\n"\\]+/g, "_")
+      .replace(/^\.+/, "")
+      .replace(/[^A-Za-z0-9._ -]+/g, "-")
+      .slice(0, 120) || "artifact"
+  );
+}
+
 function mapEventLogs(events) {
   return events.map((event) => ({
     at: event.timestamp,
@@ -877,6 +890,39 @@ app.get("/api/sessions/:sessionId/artifacts/:artifactId", async (req, res) => {
   res.json(content);
 });
 
+app.get("/api/sessions/:sessionId/artifacts/:artifactId/raw", async (req, res) => {
+  const bundle = await loadArtifactBundle(req.params.sessionId);
+  if (bundle.error) {
+    res.status(bundle.status || 500).json({ error: bundle.error });
+    return;
+  }
+
+  const artifact = findArtifact(bundle.items, req.params.artifactId);
+  const file = await resolveArtifactFile(artifact, bundle);
+  if (!file.ok) {
+    res.status(artifact ? 400 : 404).json({ error: file.error || "Artifact not found." });
+    return;
+  }
+
+  const filename = safeDownloadFilename(file.path || file.title || file.absolutePath);
+  const disposition = req.query.download === "1" ? "attachment" : "inline";
+  res.setHeader("Content-Type", file.mime || "application/octet-stream");
+  res.setHeader("Content-Length", String(file.size));
+  res.setHeader("Content-Disposition", `${disposition}; filename="${filename}"`);
+  res.setHeader("Cache-Control", "private, max-age=0, no-cache");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+
+  const stream = createReadStream(file.absolutePath);
+  stream.on("error", (error) => {
+    if (!res.headersSent) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    res.destroy(error);
+  });
+  stream.pipe(res);
+});
+
 app.post("/api/sessions/:sessionId/artifacts/select", async (req, res) => {
   const bundle = await loadArtifactBundle(req.params.sessionId);
   if (bundle.error) {