@olares/lares-core 0.15.7 → 0.15.10

package/files/backend-client.js

@@ -0,0 +1,266 @@
+import { HttpError } from "../tools/http.js";
+import { parseFilesPath } from "../drive/files-path.js";
+import { findFilesChild, isDirectoryItem, itemModifiedAt, itemSize } from "../drive/ls.js";
+import { identityFromHeaders, olaresUsername } from "../olares/identity.js";
+
+const MAX_ERROR_BYTES = 256;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+
+function headerValue(headers, name) {
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    return headers.get(name) ?? "";
+  }
+  const raw = headers?.[name] ?? headers?.[name.toLowerCase()];
+  return Array.isArray(raw) ? raw.join(",") : String(raw ?? "");
+}
+
+function hasAuthCookie(cookie) {
+  return cookie.split(";").some((part) => {
+    const [name, ...rest] = part.trim().split("=");
+    return name === "auth_token" && rest.join("=").trim() !== "";
+  });
+}
+
+function explicitToken(headers) {
+  const direct = headerValue(headers, "x-authorization").trim();
+  if (direct) return direct;
+  const authorization = headerValue(headers, "authorization").trim();
+  if (!authorization) return "";
+  return authorization.toLowerCase().startsWith("bearer ")
+    ? authorization.slice(7).trim()
+    : authorization;
+}
+
+export function filesCredentialFromHeaders(headers) {
+  const identity = identityFromHeaders(headers ?? {});
+  const user = olaresUsername(identity.user);
+  const cookie = headerValue(headers, "cookie").trim();
+  const token = explicitToken(headers);
+  const authenticatedCookie = hasAuthCookie(cookie) ? cookie : "";
+  if (!user || (!authenticatedCookie && !token)) {
+    throw new HttpError("files_no_credential", 401, "request carried no Olares Files credential");
+  }
+  return { user, cookie: authenticatedCookie, token };
+}
+
+function filesBaseUrl(template, user) {
+  const source = String(template ?? "").trim().replace(/\/+$/, "");
+  if (!source) {
+    throw new HttpError("files_unavailable", 503, "LARES_FILES_BASE_URL is not configured");
+  }
+  const value = source.replaceAll("{user}", user);
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new HttpError("files_unavailable", 503, "LARES_FILES_BASE_URL is invalid");
+  }
+  if (
+    !["http:", "https:"].includes(parsed.protocol)
+    || parsed.username
+    || parsed.password
+    || parsed.pathname !== "/"
+    || parsed.search
+    || parsed.hash
+  ) {
+    throw new HttpError("files_unavailable", 503, "LARES_FILES_BASE_URL must be an HTTP(S) origin");
+  }
+  return parsed.origin;
+}
+
+function encodeFilesPath(path) {
+  return path.split("/").map((part) => encodeURIComponent(part)).join("/");
+}
+
+async function boundedErrorBody(response) {
+  try {
+    const text = await response.text();
+    return text.trim().slice(0, MAX_ERROR_BYTES);
+  } catch {
+    return "";
+  }
+}
+
+async function checked(response, method, pathname) {
+  if (response.status >= 200 && response.status < 300) return response;
+  if (
+    (response.status >= 300 && response.status < 400)
+    || response.status === 401
+    || response.status === 403
+  ) {
+    await response.body?.cancel().catch(() => {});
+    throw new HttpError("files_unauthenticated", 401, "Olares Files refused the browser credential");
+  }
+  if (response.status === 404) {
+    await response.body?.cancel().catch(() => {});
+    throw new HttpError("file_not_found", 404, "file was not found");
+  }
+  if (response.status === 416) {
+    await response.body?.cancel().catch(() => {});
+    throw new HttpError("range_not_satisfiable", 416, "Files rejected the byte range");
+  }
+  const detail = await boundedErrorBody(response);
+  throw new HttpError(
+    "files_unavailable",
+    502,
+    `${method} ${pathname} failed with ${response.status}${detail ? `: ${detail}` : ""}`,
+  );
+}
+
+async function readAtMost(response, maxBytes) {
+  const reader = response.body?.getReader();
+  if (!reader) return { bytes: Buffer.alloc(0), truncated: false };
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      const remaining = maxBytes - total;
+      if (remaining > 0) chunks.push(chunk.subarray(0, remaining));
+      total += chunk.length;
+      if (total > maxBytes) {
+        truncated = true;
+        await reader.cancel();
+        break;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return { bytes: Buffer.concat(chunks), truncated };
+}
+
+export class FilesRequestClient {
+  constructor({
+    baseUrl,
+    credential,
+    fetchFn = fetch,
+    signal,
+    requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+  }) {
+    this.baseUrl = baseUrl;
+    this.credential = credential;
+    this.fetchFn = fetchFn;
+    this.signal = signal;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+
+  headers(extra = {}) {
+    return {
+      ...(this.credential.cookie ? { cookie: this.credential.cookie } : {}),
+      ...(this.credential.token ? { "x-authorization": this.credential.token } : {}),
+      ...extra,
+    };
+  }
+
+  async fetchRaw(method, pathname, options = {}) {
+    const callerSignal = options.signal ?? this.signal;
+    const timeoutSignal = AbortSignal.timeout(this.requestTimeoutMs);
+    const signal = callerSignal
+      ? AbortSignal.any([callerSignal, timeoutSignal])
+      : timeoutSignal;
+    try {
+      return await this.fetchFn(`${this.baseUrl}${pathname}`, {
+        method,
+        headers: this.headers({ "accept-encoding": "identity", ...options.headers }),
+        redirect: "manual",
+        signal,
+      });
+    } catch (error) {
+      if (error?.name === "AbortError") throw error;
+      throw new HttpError(
+        "files_unavailable",
+        502,
+        `Olares Files request failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  async request(method, pathname, options = {}) {
+    return checked(await this.fetchRaw(method, pathname, options), method, pathname);
+  }
+
+  /**
+   * Metadata for one Files object. The backend's file resource URL can embed
+   * bytes or 500; the supported probe is the parent listing, same as
+   * `olares-cli files download`.
+   */
+  async stat(source) {
+    const path = parseFilesPath(source);
+    const cut = path.lastIndexOf("/");
+    const parent = path.slice(0, cut);
+    const name = path.slice(cut + 1);
+    const response = await this.request("GET", `/api/resources/${encodeFilesPath(parent)}/`);
+    let envelope;
+    try {
+      envelope = await response.json();
+    } catch {
+      throw new HttpError("files_unavailable", 502, "Olares Files listing was not JSON");
+    }
+    const item = findFilesChild(envelope, name);
+    if (!item) throw new HttpError("file_not_found", 404, "file was not found");
+    if (isDirectoryItem(item)) throw new HttpError("path_not_file", 415, "path is not a regular file");
+    return {
+      path,
+      name,
+      size: itemSize(item),
+      modifiedAt: itemModifiedAt(item),
+    };
+  }
+
+  /**
+   * Files raw is GET `?inline=true`. HEAD is not a Files verb; incoming HEAD
+   * still GETs a bounded range so the caller can drop the body.
+   */
+  rawPath(source) {
+    return `/api/raw/${encodeFilesPath(parseFilesPath(source))}?inline=true`;
+  }
+
+  openRaw(source, options = {}) {
+    const range = options.range
+      ?? (options.method === "HEAD" ? "bytes=0-0" : undefined);
+    return this.request("GET", this.rawPath(source), {
+      headers: range ? { range } : {},
+      signal: options.signal,
+    });
+  }
+
+  /**
+   * Files renditions are GET `/api/preview/<path>?size=`. The backend resizes
+   * once and caches the result: `big` fits the image inside 1000x1000, `thumb`
+   * is a 256x256 JPEG. A format it cannot resize comes back as the stored
+   * bytes, so this never fails merely for being asked.
+   */
+  previewPath(source, size) {
+    const path = encodeFilesPath(parseFilesPath(source));
+    return `/api/preview/${path}?size=${encodeURIComponent(size)}`;
+  }
+
+  openPreview(source, options = {}) {
+    return this.request("GET", this.previewPath(source, options.size ?? "big"), {
+      signal: options.signal,
+    });
+  }
+
+  async readRaw(source, maxBytes, options = {}) {
+    const response = await this.openRaw(source, {
+      range: `bytes=0-${maxBytes}`,
+      signal: options.signal,
+    });
+    return readAtMost(response, maxBytes);
+  }
+}
+
+export function filesClientFromRequest(req, options = {}) {
+  const credential = filesCredentialFromHeaders(req?.headers ?? {});
+  const template = options.baseUrl ?? options.env?.LARES_FILES_BASE_URL ?? process.env.LARES_FILES_BASE_URL;
+  return new FilesRequestClient({
+    baseUrl: filesBaseUrl(template, credential.user),
+    credential,
+    fetchFn: options.fetchFn,
+    signal: options.signal,
+  });
+}

package/files/deliverables.js

@@ -1,3 +1,6 @@
+import { isInlineTurnMediaPath } from "./preview-groups.js";
+import { LARES_PUBLISHED_KEY } from "./published-turn-data.js";
+
 /** Same rule as dsh-client-ui-deliverables: only edit/diff call views produce files. */
 export function producedPathsFromView(view) {
   if (!view || !Array.isArray(view.locations)) return [];
@@ -15,7 +18,10 @@ export function producedPathsFromView(view) {
 }
 
 export function producedForClosing(owner) {
-  const produced = owner.turn.data.get("deliverables")?.produced ?? [];
+  const deliverables = owner.turn.data.get("deliverables");
+  const produced = deliverables?.produced ?? [];
+  const presented = deliverables?.presented ?? [];
+  const published = owner.turn.data.get(LARES_PUBLISHED_KEY)?.published ?? [];
   const paths = [];
   const seen = new Set();
   for (const item of produced) {
@@ -23,6 +29,16 @@ export function producedForClosing(owner) {
     seen.add(item.path);
     paths.push(item.path);
   }
+  for (const item of presented) {
+    if (item.seq >= owner.seq || seen.has(item.path)) continue;
+    seen.add(item.path);
+    paths.push(item.path);
+  }
+  for (const item of published) {
+    if (item.seq > owner.seq || seen.has(item.path)) continue;
+    seen.add(item.path);
+    paths.push(item.path);
+  }
   return paths;
 }
 
@@ -30,3 +46,41 @@ export function selectProducedFiles(owner) {
   const paths = producedForClosing(owner);
   return paths.length === 0 ? null : paths;
 }
+
+/**
+ * Playable produced media for the turn-tail preview. Workspace and Files
+ * addresses share that seat so a `drive/…` image is not left as a prose link.
+ */
+export function selectInlineTurnMedia(owner) {
+  const paths = producedForClosing(owner).filter(isInlineTurnMediaPath);
+  return paths.length === 0 ? null : paths;
+}
+
+function listedPaths(files) {
+  if (!Array.isArray(files)) return [];
+  const paths = [];
+  for (const file of files) {
+    const path = typeof file === "string" ? file : file?.path;
+    if (typeof path !== "string") continue;
+    const normalized = path.trim().replace(/\\/g, "/");
+    if (normalized) paths.push(normalized);
+  }
+  return paths;
+}
+
+/**
+ * Playable media a turn published. The web turn tail reads the projection of
+ * these events; a client that only has the session log has to read the events.
+ * media_generate names its files when the call returns, so they are not on the
+ * tool-call arguments.
+ */
+export function turnMediaPathsFromEvent(event) {
+  const data = event?.data;
+  if (event?.type === "deliverables/presented" || (
+    event?.type === "media/generation-settled"
+    && String(data?.status ?? "").toLowerCase() === "completed"
+  )) {
+    return listedPaths(data?.files).filter(isInlineTurnMediaPath);
+  }
+  return [];
+}

package/files/intake.js

@@ -20,69 +20,6 @@ export function splitComposerFiles(files) {
   return { images, documents };
 }
 
-export function documentPasteFiles(clipboardData) {
-  const files = Array.from(clipboardData?.files ?? []);
-  return splitComposerFiles(files).documents.length > 0 ? files : null;
-}
-
-export function composerAttachReady({ phase, pending, addImages, sessionId }) {
-  return phase === "plain"
-    && !pending
-    && typeof addImages === "function"
-    && typeof sessionId === "string";
-}
-
-export function claimComposerBlock(registry, sessionId, reason) {
-  const store = registry.storeFor(sessionId);
-  if (store.getSnapshot() !== undefined) return () => {};
-  const block = { reason };
-  registry.set(sessionId, block);
-  return () => {
-    if (store.getSnapshot() === block) registry.set(sessionId, undefined);
-  };
-}
-
-export const COMPOSER_CARD = "[data-composer-card]";
-
-export function composerPasteInCard(target) {
-  return Boolean(target && typeof target.closest === "function" && target.closest(COMPOSER_CARD));
-}
-
-export function composerDropHasDocuments(files) {
-  return files.length > 0 && splitComposerFiles(files).documents.length > 0;
-}
-
-export function draftImageFailureCode(reason) {
-  return reason instanceof Error ? reason.message : "file_upload_failed";
-}
-
-export function commitComposerImages(ports, files, sessionId) {
-  if (files.length === 0) return;
-  let attachments = [];
-  try {
-    attachments = ports.createDraftImages(files);
-    if (!ports.addImages(attachments.map((attachment) => attachment.id))) {
-      ports.releaseDraftImages(attachments);
-      for (const file of files) ports.reportFailure(sessionId, file, "file_input_blocked");
-    }
-  } catch (reason) {
-    if (attachments.length > 0) ports.releaseDraftImages(attachments);
-    const code = draftImageFailureCode(reason);
-    for (const file of files) ports.reportFailure(sessionId, file, code);
-  }
-}
-
-export function processComposerFiles(ports, incoming) {
-  if (!ports.ready || incoming.length === 0) return;
-  const files = [...incoming];
-  const { images, documents } = splitComposerFiles(files);
-  ports.addImages(images);
-  if (documents.length === 0) return;
-  const { accepted, oversized } = partitionDocumentsBySize(documents, ports.maxBytes);
-  for (const file of oversized) ports.reportFailure(ports.sessionId, file, "file_too_large");
-  return ports.uploadFiles(ports.sessionId, accepted, ports.commit);
-}
-
 export function partitionDocumentsBySize(documents, maxBytes) {
   const accepted = [];
   const oversized = [];

package/files/mention.js

@@ -1,6 +1,4 @@
-const REFERENCE_SOURCE = "reference";
-
-export function mentionOf(path) {
+function mentionOf(path) {
   return /[\s"]/u.test(path) ? `@"${path}"` : `@${path}`;
 }
 
@@ -14,51 +12,3 @@ export function appendDraftMentions(draft, paths) {
   }
   return next;
 }
-
-export function uploadReference(path) {
-  const ref = mentionOf(path);
-  return {
-    source: REFERENCE_SOURCE,
-    ref,
-    label: path.slice(path.lastIndexOf("/") + 1),
-    appearance: "file",
-    clipboardText: ref,
-  };
-}
-
-/**
- * Append one reference per uploaded path at the end of the draft.
- * @returns the paths the input machine refused, in order.
- */
-export function insertUploadReferences(input, paths) {
-  const refused = [];
-  for (const path of paths) {
-    const current = input.state.getSnapshot();
-    if (current.draft !== "" && !/\s$/u.test(current.draft)) input.setDraft(`${current.draft} `);
-    const state = input.state.getSnapshot();
-    const at = state.draft.length;
-    const applied = input.insertReference(uploadReference(path), {
-      start: at,
-      end: at,
-      draftRev: state.draftRev,
-    });
-    if (!applied) refused.push(path);
-  }
-  return refused;
-}
-
-export function commitUploadPaths(input, paths, notifyUnlinked) {
-  if (!input) return;
-  for (const path of insertUploadReferences(input, paths)) {
-    notifyUnlinked(path);
-  }
-}
-
-export function createUploadCommit({ scopeSession, inputFor, unlinkedMessage }) {
-  return (sessionId) => (paths) => {
-    const sessionCtx = scopeSession(sessionId);
-    if (sessionCtx === undefined) return;
-    const input = inputFor(sessionCtx);
-    commitUploadPaths(input, paths, (path) => input.notify("error", unlinkedMessage(path)));
-  };
-}

package/files/preview-groups.js

@@ -1,5 +1,57 @@
+import { posixExtname } from "./filename.js";
+import { isFilesPath } from "../drive/files-path.js";
+
 const MEDIA_KINDS = new Set(["image", "video", "audio", "model3d"]);
 
+/** Extensions that stay as user-facing Produced media after a fetch. */
+const MEDIA_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp",
+  ".mp4", ".webm", ".mov", ".m4v", ".ogv",
+  ".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac",
+  ".glb", ".gltf", ".obj",
+]);
+
+/** Formats TurnMedia can actually play; .gltf/.obj stay official chips. */
+const INLINE_TURN_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp",
+  ".mp4", ".webm", ".mov", ".m4v", ".ogv",
+  ".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac",
+  ".glb",
+]);
+
+function posixPath(path) {
+  return String(path ?? "").replace(/\\/g, "/");
+}
+
+/**
+ * Image / video / audio / 3D destinations are durable deliverables. Other
+ * fetch targets (git APIs, chart YAML, JSON lists, READMEs) are workspace
+ * scratch and must not become Produced chips.
+ */
+export function isMediaDeliverablePath(path) {
+  return MEDIA_EXTENSIONS.has(posixExtname(posixPath(path)).toLowerCase());
+}
+
+/**
+ * Media the turn-tail can play. Workspace and Files addresses use the same
+ * player; a Files path is not a reason to fall back to an in-message link.
+ */
+export function isInlineTurnMediaPath(path) {
+  return INLINE_TURN_EXTENSIONS.has(posixExtname(posixPath(path)).toLowerCase());
+}
+
+/** Default url_fetch / drive_fetch landing zone for non-final research files. */
+export function isDownloadsScratchPath(path) {
+  const normalized = posixPath(path);
+  if (normalized === "downloads" || normalized.startsWith("downloads/")) return true;
+  return /(?:^|\/)downloads(?:\/|$)/.test(normalized);
+}
+
+/**
+ * Produced UI follows live workspace truth: media that still exists previews
+ * inline; missing paths drop out; non-media under downloads/ is scratch even
+ * while the file is briefly on disk.
+ */
 export function partitionPreviews(paths, previews) {
   const media = [];
   const files = [];
@@ -7,15 +59,31 @@ export function partitionPreviews(paths, previews) {
   let loading = false;
   for (const original of paths) {
     if (!previews.has(original)) {
+      if (isInlineTurnMediaPath(original)) {
+        loading = true;
+        continue;
+      }
+      if (isFilesPath(original)) {
+        files.push(original);
+        continue;
+      }
       loading = true;
       continue;
     }
     const preview = previews.get(original);
-    const path = preview?.path ?? original;
+    if (preview === null) {
+      if (isFilesPath(original)) files.push(original);
+      continue;
+    }
+    const path = preview.path ?? original;
     if (seen.has(path)) continue;
     seen.add(path);
-    if (preview !== null && MEDIA_KINDS.has(preview.kind)) media.push(preview);
-    else files.push(path);
+    if (MEDIA_KINDS.has(preview.kind)) {
+      media.push(preview);
+      continue;
+    }
+    if (isDownloadsScratchPath(path) || isDownloadsScratchPath(original)) continue;
+    files.push(path);
   }
   return { media, files, loading };
 }

package/files/preview-local.js

@@ -0,0 +1,69 @@
+import { basename, isAbsolute, resolve } from "node:path";
+import { realpath, stat } from "node:fs/promises";
+import { runtimeSkillsDir } from "../skills/state.js";
+import { HttpError } from "../tools/http.js";
+import { isInsideWorkspace } from "../workspace/path.js";
+
+/**
+ * Disk trees the conversation may preview besides the session workspace.
+ * Skills are what the agent Reads (`/data/lares/skills/…`); they are Lares
+ * app data, not user Drive files, so they stay off `drive/…`.
+ */
+export function localPreviewRoots(env = process.env) {
+  const dataDir = env.LARES_DATA_DIR?.trim() || "/data/lares";
+  return [runtimeSkillsDir(dataDir)];
+}
+
+async function matchingRoot(candidate, roots) {
+  for (const root of roots) {
+    const resolvedRoot = await realpath(root).catch(() => null);
+    if (!resolvedRoot) continue;
+    const resolvedCandidate = await realpath(candidate).catch(() => null);
+    if (resolvedCandidate && isInsideWorkspace(resolvedRoot, resolvedCandidate)) {
+      return resolvedRoot;
+    }
+    const lexical = resolve(candidate);
+    if (
+      isInsideWorkspace(resolvedRoot, lexical)
+      || isInsideWorkspace(root, lexical)
+    ) {
+      return resolvedRoot;
+    }
+  }
+  return null;
+}
+
+/**
+ * Open a file from a Lares-owned local tree. Returns null when the path is
+ * not in one of those trees so the caller can try the session workspace.
+ */
+export async function resolveLocalPreviewFile(requestedPath, options = {}) {
+  if (typeof requestedPath !== "string" || !requestedPath.trim() || requestedPath.includes("\0")) {
+    return null;
+  }
+  if (!isAbsolute(requestedPath)) return null;
+  const roots = options.roots ?? localPreviewRoots(options.env ?? process.env);
+  const candidate = resolve(requestedPath);
+  const root = await matchingRoot(candidate, roots);
+  if (!root) return null;
+  const absolutePath = await realpath(candidate).catch(() => {
+    throw new HttpError("file_not_found", 404, "file was not found");
+  });
+  if (!isInsideWorkspace(root, absolutePath)) {
+    throw new HttpError("path_forbidden", 403, "path leaves the allowed preview tree");
+  }
+  const info = await stat(absolutePath).catch(() => {
+    throw new HttpError("file_not_found", 404, "file was not found");
+  });
+  if (!info.isFile()) throw new HttpError("path_not_file", 415, "path is not a regular file");
+  return {
+    origin: "local",
+    absolutePath,
+    path: requestedPath,
+    name: basename(absolutePath),
+    size: info.size,
+    modifiedAt: info.mtimeMs,
+    device: info.dev,
+    inode: info.ino,
+  };
+}