@tangle-network/agent-app 0.47.15 → 0.47.16

package/dist/web/file-export.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Workspace exports exclude runtime configuration and hidden credential stores.
+ * OpenCode's provider marks these non-hidden configs as runtime-only; old
+ * persisted copies still need the same boundary when files leave the workspace.
+ */
+export declare function isWorkspaceFileExportable(path: string): boolean;

package/dist/web/index.d.ts

@@ -81,3 +81,4 @@ export declare function addSecurityHeaders(response: Response, opts?: SecurityHe
  * @param what - noun for the error message (e.g. 'media url', 'src').
  */
 export declare function assertMediaUrl(url: string, what?: string): void;
+export { isWorkspaceFileExportable } from './file-export';

package/dist/web/index.js

@@ -15,7 +15,10 @@ import {
   requireString,
   serializeCookie,
   withFreeRouteLimit
-} from "../chunk-F7VH4G5C.js";
+} from "../chunk-3YUI7WNW.js";
+import {
+  isWorkspaceFileExportable
+} from "../chunk-TXD5HXLE.js";
 export {
   FREE_ROUTE_BUDGETS,
   FreeRouteLimitError,
@@ -28,6 +31,7 @@ export {
   clearCookieHeader,
   extractRequestContext,
   freeRouteLimitResponse,
+  isWorkspaceFileExportable,
   parseJsonObjectBody,
   readCookieValue,
   requireString,

package/dist/web-react/api-access-panel.d.ts

@@ -0,0 +1,33 @@
+export interface ApiAccessKey {
+    id: string;
+    name: string;
+    scopes: string[];
+    expiresAt: string | Date | null;
+}
+export interface ApiAccessScope {
+    scope: string;
+    label: string;
+    description: string;
+}
+export interface ApiAccessPanelProps {
+    keys: readonly ApiAccessKey[];
+    access: readonly ApiAccessScope[];
+    defaultScopes: readonly string[];
+    baseUrl: string;
+    expiryDays?: readonly number[];
+    defaultExpiryDays?: number;
+    accountHref?: string;
+    description?: string;
+    limitsDescription?: string;
+    onCreate: (input: {
+        name: string;
+        scopes: string[];
+        expiresAt: string;
+    }) => Promise<{
+        id: string;
+        key: string;
+    }>;
+    onRevoke: (id: string) => Promise<void>;
+    onChanged: () => void;
+}
+export declare function ApiAccessPanel({ keys, access, defaultScopes, baseUrl, accountHref, description, limitsDescription, expiryDays, defaultExpiryDays, onCreate, onRevoke, onChanged }: ApiAccessPanelProps): import("react").JSX.Element;

package/dist/web-react/index.d.ts

@@ -273,3 +273,4 @@ export declare function useThinkingSeconds(active: boolean): number;
  * label/meta row becomes a hover-revealed meta lane under each row.
  */
 export declare function ChatMessages({ messages, messageSize, chrome, models, renderMarkdown, renderExtras, durableCards, userLabel, agentLabel, loading, approval, onToolCallClick, toolRenderers, error, onRetry, renderEmpty, emptyState, header, resolveAttachmentUrl, workProductCards, }: ChatMessagesProps): import("react").JSX.Element;
+export * from './api-access-panel';

package/dist/web-react/index.js

@@ -1,5 +1,6 @@
 import {
   AgentActivityPanel,
+  ApiAccessPanel,
   ChatEmptyState,
   ChatMessages,
   CommandPalette,
@@ -127,7 +128,7 @@ import {
   withoutRecordGridCreated,
   withoutRecordGridRemoved,
   withoutRecordGridUpdate
-} from "../chunk-TTYJIMTR.js";
+} from "../chunk-H6R3VYAZ.js";
 import {
   SessionHistoryPanel,
   formatSessionTimestamp,
@@ -170,7 +171,7 @@ import {
   renamePastedImages,
   useComposerAttachments,
   useDictation
-} from "../chunk-FMEL7VJR.js";
+} from "../chunk-TNWQA5XJ.js";
 import "../chunk-L7MB2LLM.js";
 import {
   DEFAULT_EFFORT_LEVELS,
@@ -194,10 +195,10 @@ import {
   tabTerminalConnectionId,
   useSandboxTerminalConnection
 } from "../chunk-BATKJP3P.js";
-import "../chunk-HZVVO6VR.js";
+import "../chunk-FQYAJYPW.js";
 import {
   ATTACHMENT_ACCEPT
-} from "../chunk-SUO2R2ET.js";
+} from "../chunk-NU7QSZBR.js";
 import "../chunk-MCYJON3F.js";
 import "../chunk-OU3VTK3I.js";
 import {
@@ -207,7 +208,7 @@ import {
   isChatAttachmentPart,
   mentionInputToPart,
   mentionPartsFromMessageParts
-} from "../chunk-IRYULX3R.js";
+} from "../chunk-4PZE7XAM.js";
 import "../chunk-ZVEEWGDK.js";
 import {
   DISPATCH_MAX_MEDIA_PARTS,
@@ -220,7 +221,8 @@ import {
   fileMentionsToParts,
   mediaTypeForMentionPath,
   mentionKindForPath
-} from "../chunk-DXHUQ5NO.js";
+} from "../chunk-X47R2IVO.js";
+import "../chunk-TXD5HXLE.js";
 import {
   attachmentPartKey
 } from "../chunk-ZMMIQOFI.js";
@@ -254,6 +256,7 @@ export {
   ATTACHMENT_ACCEPT,
   AgentActivityPanel,
   AgentSessionControls,
+  ApiAccessPanel,
   ChatComposer,
   ChatEmptyState,
   ChatMessages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.47.15",
+  "version": "0.47.16",
   "packageManager": "pnpm@11.24.0",
   "description": "Build agent applications with typed chat, tools, sandboxes, integrations, billing, and evaluation.",
   "keywords": [

package/dist/DesignCanvas-JRBCAWHW.js

@@ -1,10 +0,0 @@
-import {
-  DesignCanvas
-} from "./chunk-7LJYCHXK.js";
-import "./chunk-X5DQ5QOP.js";
-import "./chunk-DRB77FYL.js";
-import "./chunk-F7VH4G5C.js";
-export {
-  DesignCanvas
-};
-//# sourceMappingURL=DesignCanvas-JRBCAWHW.js.map

package/dist/DesignCanvasEditor-J2OLS22G.js

@@ -1,13 +0,0 @@
-import {
-  DesignCanvasEditor
-} from "./chunk-33BN7P57.js";
-import "./chunk-7LJYCHXK.js";
-import "./chunk-Q2QKEV6J.js";
-import "./chunk-OYTMILRK.js";
-import "./chunk-X5DQ5QOP.js";
-import "./chunk-DRB77FYL.js";
-import "./chunk-F7VH4G5C.js";
-export {
-  DesignCanvasEditor
-};
-//# sourceMappingURL=DesignCanvasEditor-J2OLS22G.js.map

package/dist/chunk-DXHUQ5NO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/chat-routes/wire.ts"],"sourcesContent":["import type { ReasoningEffort } from '@tangle-network/agent-interface'\n\n/**\n * Wire contract between the chat client (composer + `streamChatTurn`) and the\n * assembled server vertical (`createChatTurnRoutes`). Runtime-import-free on\n * purpose: `/web-react` re-exports these types into browser bundles, so nothing\n * here may reach a Node builtin or an engine package.\n *\n * The client part shape permits an absolute file path until the server converts\n * it to the URL required by the sandbox SDK. It is derived here, not imported,\n * so the client bundle never touches the SDK.\n */\n\nexport interface ChatTurnTextPartInput {\n  type: 'text'\n  text: string\n}\n\n/** A non-text prompt part the upload route hands back and the client echoes\n *  on send. `url` carries an inline `data:` URI for small files; `path` is a\n *  sandbox workspace reference for large ones (the >1 MiB gateway body cap\n *  makes the two-step upload mandatory). */\nexport interface ChatTurnFilePartInput {\n  type: 'image' | 'file'\n  filename?: string\n  mediaType?: string\n  url?: string\n  path?: string\n}\n\n/** Resolve input as either a text part or a file part of a chat turn */\nexport type ChatTurnPartInput = ChatTurnTextPartInput | ChatTurnFilePartInput\n\n/** A chat turn's automatic sentinel plus the canonical agent reasoning levels. */\nexport type ChatReasoningEffort = 'auto' | ReasoningEffort\n\n// ── producer stream vocabulary ───────────────────────────────────────────────\n\n/** Represent a text event produced by a source with a fixed type and associated text content */\nexport interface ProducerTextEvent {\n  type: 'text'\n  text: string\n}\n\n/** Define an event representing reasoning output with a fixed type and associated text */\nexport interface ProducerReasoningEvent {\n  type: 'reasoning'\n  text: string\n}\n\n/** Represent an event triggered by a producer tool call with its identifier, name, and arguments */\nexport interface ProducerToolCallEvent {\n  type: 'tool_call'\n  call: {\n    toolCallId: string\n    toolName: string\n    args: Record<string, unknown>\n  }\n}\n\n/** Describe the structure of an event representing the result of a producer tool call */\nexport interface ProducerToolResultEvent {\n  type: 'tool_result'\n  toolCallId: string\n  toolName: string\n  outcome: {\n    ok: boolean\n    result?: unknown\n    message?: string\n  }\n}\n\n/** Describe cumulative provider usage reported by a producer. */\nexport interface ProducerUsageEvent {\n  type: 'usage'\n  usage: {\n    promptTokens: number\n    completionTokens: number\n    reasoningTokens?: number\n    toolTokens?: number\n    toolCallCount?: number\n    providerCostUsd?: number\n    /** Present only when the provider enforced the complete execution budget. */\n    budgetEnforced?: boolean\n  }\n}\n\n/** Define the structure for a producer notice event with type, id, kind, and text fields */\nexport interface ProducerNoticeEvent {\n  type: 'notice'\n  id: string\n  /** Kept inline with `/interactions`' `NoticeKind` so this file stays import-free. */\n  noticeKind: 'warning' | 'auto-declined'\n  text: string\n}\n\n/** Represent an error event emitted by a producer containing message, code, and optional details */\nexport interface ProducerErrorEvent {\n  type: 'error'\n  data: {\n    message: string\n    code?: string\n    details?: Record<string, unknown>\n  }\n}\n\n/** Stable raw lifecycle/interaction/plan/route events forwarded unchanged. */\nexport type ProducerPassthroughEventType =\n  | 'turn'\n  | 'metadata'\n  | 'interaction'\n  | 'interaction.cancel'\n  | 'plan.submitted'\n  | 'done'\n  | 'warning'\n  | 'session.run.started'\n  | 'session.run.completed'\n  | 'session.run.failed'\n  | 'turn_status'\n\n/** Define an event carrying passthrough data with flexible properties for producer communication */\nexport interface ProducerPassthroughEvent {\n  type: ProducerPassthroughEventType\n  data?: Record<string, unknown>\n  /** Route markers and raw passthroughs may carry `turnId`, `status`, `seq`, etc. */\n  [key: string]: unknown\n}\n\n/** Represent events emitted by a producer during its operation for processing and handling */\nexport type ProducerWireEvent =\n  | ProducerTextEvent\n  | ProducerReasoningEvent\n  | ProducerToolCallEvent\n  | ProducerToolResultEvent\n  | ProducerUsageEvent\n  | ProducerNoticeEvent\n  | ProducerErrorEvent\n  | ProducerPassthroughEvent\n\n/** The image/file split an attachment is rendered and persisted under — the\n *  same discriminant as {@link ChatMentionKind}, but a distinct name because an\n *  attachment carries content the product uploaded (`ChatAttachmentInput`)\n *  while a mention points at a file the box already has. Defined HERE (the\n *  import-free layer) so `ChatAttachmentInput` can reference it and the client\n *  composer imports it without pulling the persisted-part vocabulary;\n *  `/chat-store`'s parts module re-exports it alongside the attachment helpers. */\nexport type ChatAttachmentKind = 'image' | 'file'\n\n/** `POST` turn-body entry describing a file already uploaded to the product's\n *  store (vault/object-store) — distinct from an inline {@link\n *  ChatTurnFilePartInput} (which carries bytes) and from a {@link FileMention}\n *  (a sandbox path the box already holds). The route resolves this field with\n *  {@link resolveChatAttachments}: every path is re-validated and every size is\n *  re-derived from the stored body, so nothing here is trusted as sent. */\nexport interface ChatAttachmentInput {\n  path: string\n  name: string\n  size: number\n  mediaType: string\n  kind: ChatAttachmentKind\n}\n\n/** POST body for the turn route. `content` may be empty when `parts` carry the\n *  message (an image-only send). Product routing fields (workspaceId etc.) ride\n *  alongside and are read by the product's `authorize` seam. */\nexport interface ChatTurnRequestPayload {\n  threadId: string\n  content?: string\n  /** Non-text parts from the upload route, echoed back verbatim. */\n  parts?: ChatTurnFilePartInput[]\n  /** `@`-picked file mentions for this turn — path references into the\n   *  workspace sandbox, NOT uploads, so they travel in their own field rather\n   *  than as `parts` entries. A product whose `parts` field is already spoken\n   *  for (an attachment sentinel) can still send mentions, and mentions\n   *  persist as their own `ChatMentionPart`s so a retry rebuilds them. The\n   *  route validates this field with {@link parseFileMentions} and replaces it\n   *  on the payload with the validated, deduped list. */\n  mentions?: FileMention[]\n  /** Files uploaded to the product's store ahead of the turn — path\n   *  references, NOT inline bytes (those ride `parts`). Validated and\n   *  size-re-derived by {@link resolveChatAttachments} into persistable\n   *  attachment parts; a product whose `parts` field is spoken for by inline\n   *  uploads still sends store-backed files here. */\n  attachments?: ChatAttachmentInput[]\n  model?: string\n  effort?: ChatReasoningEffort\n  harness?: string\n  /** Client-generated idempotency key for the logical turn (retry-safe). */\n  turnId?: string\n  [key: string]: unknown\n}\n\n/** `fetch` init for the turn route — the one place the client wire shape is\n *  serialized, so composer glue and products never drift from the server's\n *  parser. */\nexport function chatTurnRequestInit(payload: ChatTurnRequestPayload): RequestInit {\n  return {\n    method: 'POST',\n    headers: { 'Content-Type': 'application/json' },\n    body: JSON.stringify(payload),\n  }\n}\n\n// ── inline-part byte budget ─────────────────────────────────────────────────\n//\n// The sandbox gateway caps request bodies at 1 MiB; a turn body whose inline\n// `data:` parts exceed it dies at the gateway with an opaque 413. Enforce the\n// budget at the route boundary instead, with headroom for the JSON envelope\n// (same fail-loud-at-the-choke-point style as /sandbox's provision-payload and\n// env-size gates).\n\n/** Define the maximum byte size allowed for inline parts in data processing */\nexport const INLINE_PARTS_MAX_BYTES = 950_000\n\n// ── dispatch (parts[]) budget vocabulary ────────────────────────────────────\n//\n// The default caps `buildDispatchParts` sizes an attachment/mention dispatch\n// against — the sidecar/proxy limits an assembled `parts` array crosses, one\n// step past `INLINE_PARTS_MAX_BYTES` (which gates the raw turn BODY). Grouped\n// here, in the import-free layer, so the numbers are one overridable\n// vocabulary the client can read and a product can tune per call rather than\n// constants buried in the server module. NOTE: these model sidecar/proxy caps,\n// not a product's MIME accept-list or vault bucketing — those are DOMAIN\n// values the product supplies, never defaulted here.\n\n/** Hard cap on the whole `/prompt` request body as it crosses the sandbox\n *  proxy — smaller in practice than a raw-file write cap because a dispatch\n *  carries several inline parts plus the flattened history in one request. */\nexport const DISPATCH_REQUEST_MAX_BYTES = 1024 * 1024\n\n/** Bytes reserved off the top of {@link DISPATCH_REQUEST_MAX_BYTES} for the\n *  JSON structure around the parts array (keys, delimiters, per-part\n *  `type`/`filename`/`mediaType` fields) that {@link base64WireLen} does not\n *  account for — keeps the inline budget off the exact proxy cap where one\n *  stray byte trips the 413. */\nexport const DISPATCH_STRUCTURAL_RESERVE_BYTES = 64 * 1024\n\n/** Sidecar's hard cap on the `parts` array of one prompt request — a dispatch\n *  must never assemble more parts than this or the whole turn 400s. */\nexport const DISPATCH_MAX_PARTS = 64\n\n/** Product-side cap on media parts per dispatch (current turn + carried\n *  history), well under {@link DISPATCH_MAX_PARTS}. History trimming that keeps\n *  a transcript's native media under this is a PRODUCT concern (the pointer\n *  block keeps trimmed media reachable); `buildDispatchParts` enforces only the\n *  total {@link DISPATCH_MAX_PARTS} cap. */\nexport const DISPATCH_MAX_MEDIA_PARTS = 24\n\n/** Size a base64-encoded string occupies on the wire given the raw\n *  (pre-encoding) byte length: base64 packs 3 raw bytes into 4 output\n *  characters, rounded up to the next multiple of 4. */\nexport function base64WireLen(byteLen: number): number {\n  return Math.ceil(byteLen / 3) * 4\n}\n\n/**\n * Render a raw byte count as a human-readable size (`512B`, `3KB`, `12MB\n * 500KB`). Ported EXACTLY from gtm-agent's `attachment-limits.ts` — byte-\n * identical implementation, not a reinterpretation — so `resolve-attachments`'s\n * and `promote-file-part`'s error strings match gtm's wording verbatim. Lives\n * in the import-free wire layer (not `resolve-attachments.ts` alone) because\n * BOTH the aggregate-cap message here and the per-file oversize message in\n * `promote-file-part.ts` need it; a browser composer wanting the same\n * formatting for a client-side pre-check can also import it with no engine\n * pulled in.\n */\nexport function formatBytes(bytes: number): string {\n  if (bytes < 1024) return `${bytes}B`\n  if (bytes >= 1024 * 1024) {\n    const megabytes = Math.floor(bytes / (1024 * 1024))\n    const remainder = bytes % (1024 * 1024)\n    return remainder === 0 ? `${megabytes}MB` : `${megabytes}MB ${formatBytes(remainder)}`\n  }\n  return `${Math.round(bytes / 1024)}KB`\n}\n\n/** Represent errors for invalid chat turn inputs with status and code properties */\nexport class ChatTurnInputError extends Error {\n  constructor(message: string, readonly status = 400, readonly code = 'INVALID_CHAT_TURN') {\n    super(message)\n    this.name = 'ChatTurnInputError'\n  }\n}\n\nfunction partByteSize(part: ChatTurnPartInput): number {\n  let bytes = 0\n  if (part.type === 'text') return part.text.length\n  if (part.url) bytes += part.url.length\n  if (part.path) bytes += part.path.length\n  return bytes\n}\n\n/** Calculate the total byte size of an array of chat turn parts */\nexport function promptPartsByteSize(parts: ChatTurnPartInput[]): number {\n  return parts.reduce((total, part) => total + partByteSize(part), 0)\n}\n\n/** Throws `ChatTurnInputError` (413) when the parts' inline payload would blow\n *  the gateway cap. Path-ref parts are tiny by construction and always pass. */\nexport function assertPromptPartsWithinCap(\n  parts: ChatTurnPartInput[],\n  maxBytes = INLINE_PARTS_MAX_BYTES,\n): void {\n  const total = promptPartsByteSize(parts)\n  if (total <= maxBytes) return\n  const largest = [...parts].sort((a, b) => partByteSize(b) - partByteSize(a))[0]\n  const largestName = largest && largest.type !== 'text' ? largest.filename ?? largest.path ?? largest.type : 'text'\n  throw new ChatTurnInputError(\n    `Inline prompt parts total ${total}B, over the ${maxBytes}B budget (largest: ${largestName}, ${largest ? partByteSize(largest) : 0}B). ` +\n      'Upload large files through the upload route so they travel as sandbox path references.',\n    413,\n    'PROMPT_PARTS_TOO_LARGE',\n  )\n}\n\n// ── file mentions ────────────────────────────────────────────────────────\n//\n// A file mention (`@`-picked in the composer, sandbox-ui#184) is a path\n// reference into the workspace sandbox — no byte upload. These helpers turn\n// a resolved mention list into wire parts and the prompt pointer block that\n// tells the agent where to read them from.\n\n/** A file mention resolved from the composer's `@`-picker: the\n *  workspace-relative path plus enough metadata to build a prompt part and\n *  pointer text. `path` is the canonical identity — the mention pill's\n *  `MentionItem.id` for the file kind (`/web-react`'s `useFileMentions`). */\nexport interface FileMention {\n  path: string\n  name: string\n  size?: number\n}\n\nconst MENTION_IMAGE_MEDIA_TYPES: ReadonlyMap<string, string> = new Map([\n  ['.png', 'image/png'],\n  ['.jpg', 'image/jpeg'],\n  ['.jpeg', 'image/jpeg'],\n  ['.gif', 'image/gif'],\n  ['.webp', 'image/webp'],\n  ['.svg', 'image/svg+xml'],\n  ['.bmp', 'image/bmp'],\n  ['.heic', 'image/heic'],\n  ['.heif', 'image/heif'],\n  ['.avif', 'image/avif'],\n])\n\nfunction extensionOf(path: string): string {\n  const base = path.split('/').filter(Boolean).pop() ?? path\n  const dot = base.lastIndexOf('.')\n  return dot > 0 ? base.slice(dot).toLowerCase() : ''\n}\n\n/** The `image/*` mime for a mention path by extension, or `undefined` for\n *  anything not in the known image set (dispatched as `type: 'file'`). */\nexport function mediaTypeForMentionPath(path: string): string | undefined {\n  return MENTION_IMAGE_MEDIA_TYPES.get(extensionOf(path))\n}\n\n/** The image/file split a mention is rendered and persisted under — the\n *  composer pill's icon, the dispatched part's `type`, and\n *  `ChatMentionPart.mentionKind` are all this one value. */\nexport type ChatMentionKind = 'image' | 'file'\n\n/** `image` when the path's extension is in the known image set (the same table\n *  {@link mediaTypeForMentionPath} reads), `file` otherwise. Exported so a\n *  client that needs only the discriminant — a pill icon, a persisted part's\n *  `mentionKind` — never re-declares the extension table; two frozen copies of\n *  one mime table is how one gains a format and the other doesn't. */\nexport function mentionKindForPath(path: string): ChatMentionKind {\n  return mediaTypeForMentionPath(path) ? 'image' : 'file'\n}\n\n/** Define options to resolve mention paths when converting file mentions to parts */\nexport interface FileMentionsToPartsOptions {\n  /** Resolve a mention's workspace-relative path to the absolute path the\n   *  dispatched part should carry (e.g. a host prefixing the in-box vault\n   *  root). Default: identity — the path travels unchanged. */\n  resolvePath?: (path: string) => string\n}\n\n/** Maps resolved file mentions to path-only `ChatTurnFilePartInput`s —\n *  `image` vs `file` by extension, and always a `path`, never a `url` (the\n *  url/path XOR invariant: a mention is a sandbox path reference, never\n *  inline bytes). */\nexport function fileMentionsToParts(\n  mentions: readonly FileMention[],\n  opts: FileMentionsToPartsOptions = {},\n): ChatTurnFilePartInput[] {\n  const resolvePath = opts.resolvePath ?? ((path: string) => path)\n  return mentions.map((mention) => {\n    const mediaType = mediaTypeForMentionPath(mention.path)\n    const part: ChatTurnFilePartInput = {\n      type: mediaType ? 'image' : 'file',\n      filename: mention.name,\n      path: resolvePath(mention.path),\n    }\n    if (mediaType) part.mediaType = mediaType\n    return part\n  })\n}\n\n/** The agent-facing pointer block appended to the dispatched prompt — never\n *  persisted in message `content`. Empty array → `''` so callers can append\n *  unconditionally. This is the sole producer of that text: the current\n *  turn's dispatch and any history projection built from the same mention\n *  list both route through here, so the two can't drift apart. */\nexport function buildMentionPromptBlock(\n  mentions: readonly Pick<FileMention, 'name' | 'path'>[],\n): string {\n  if (mentions.length === 0) return ''\n  const lines = mentions.map((m) => `- ${m.name} (${m.path})`)\n  return `\\n\\nMentioned files — read them from these paths:\\n${lines.join('\\n')}`\n}\n\n// ── mention validation ───────────────────────────────────────────────────\n//\n// This package owns BOTH ends of the mention path contract — it emits paths\n// from `createSandboxFileIndexRoute` and consumes them in `fileMentionsToParts`\n// / `buildMentionPromptBlock` — so the validation belongs here rather than in\n// each app that wires the pair up. A mention names a file that already exists\n// in the sandbox, so validation is a pure path/charset/count check with no\n// I/O: existence is proven later, when the agent reads the path and the turn\n// fails loudly if it is gone.\n\n/** Hard cap on mentions per turn. Bounds the prompt pointer block, the\n *  persisted parts, and whatever media budget a dispatch draws from them. */\nexport const MENTION_MAX_COUNT = 16\n\n/** Longest mention display name accepted — bounds the pointer-block text and\n *  the transcript pill label. */\nconst MAX_MENTION_NAME_LENGTH = 256\n/** Longest mention path accepted. */\nconst MAX_MENTION_PATH_LENGTH = 1024\n\n/** Represent the result of a sandbox mention path check indicating success or failure with an error message */\nexport type SandboxMentionPathCheck =\n  | { succeeded: true }\n  | { succeeded: false; error: string }\n\n/**\n * Validate a workspace-relative sandbox mention path. Rejects traversal (a\n * `..` path segment), absolute paths (leading `/`), backslashes, and null\n * bytes — the four ways a path picked in a client can escape the root the\n * index route scanned.\n *\n * Spaces and unicode are deliberately ALLOWED: in-box filenames are arbitrary,\n * and an ASCII-only charset would silently drop real files from a feature\n * whose whole job is naming them.\n */\nexport function validateSandboxMentionPath(path: unknown): SandboxMentionPathCheck {\n  if (typeof path !== 'string' || path.length === 0) {\n    return { succeeded: false, error: 'mention path must be a non-empty string' }\n  }\n  if (path.length > MAX_MENTION_PATH_LENGTH) {\n    return { succeeded: false, error: `mention path must not exceed ${MAX_MENTION_PATH_LENGTH} characters` }\n  }\n  if (path.includes('\\0')) {\n    return { succeeded: false, error: 'mention path must not contain null bytes' }\n  }\n  if (path.includes('\\\\')) {\n    return { succeeded: false, error: 'mention path must not contain backslashes' }\n  }\n  if (path.startsWith('/')) {\n    return { succeeded: false, error: 'mention path must be workspace-relative, not absolute' }\n  }\n  if (path.split('/').some((segment) => segment === '..')) {\n    return { succeeded: false, error: 'mention path must not contain \"..\" segments' }\n  }\n  return { succeeded: true }\n}\n\nfunction parseFileMention(value: unknown, index: number): FileMention {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    throw new ChatTurnInputError(`mentions[${index}] must be an object`)\n  }\n  const record = value as Record<string, unknown>\n\n  const pathCheck = validateSandboxMentionPath(record.path)\n  if (!pathCheck.succeeded) throw new ChatTurnInputError(`mentions[${index}]: ${pathCheck.error}`)\n\n  const name = record.name\n  if (typeof name !== 'string' || !name.trim()) {\n    throw new ChatTurnInputError(`mentions[${index}].name must be a non-empty string`)\n  }\n  if (name.length > MAX_MENTION_NAME_LENGTH) {\n    throw new ChatTurnInputError(`mentions[${index}].name must not exceed ${MAX_MENTION_NAME_LENGTH} characters`)\n  }\n\n  const size = record.size\n  if (size !== undefined) {\n    if (typeof size !== 'number' || !Number.isFinite(size)) {\n      throw new ChatTurnInputError(`mentions[${index}].size must be a finite number`)\n    }\n    if (size < 0) {\n      throw new ChatTurnInputError(`mentions[${index}].size must not be negative`)\n    }\n  }\n\n  return { path: record.path as string, name, ...(typeof size === 'number' ? { size } : {}) }\n}\n\n/**\n * Validates the untyped `mentions` array off the wire, mirroring\n * {@link parseChatTurnParts}: the typed list, or `ChatTurnInputError` (400)\n * naming the offending entry. Never sanitizes-and-continues — a traversal path\n * is a rejected request, not a trimmed one.\n *\n * A path repeated within one turn is deduped to its first occurrence rather\n * than rejected: mentioning the same file twice is plausible user input, not\n * an attack.\n */\nexport function parseFileMentions(raw: unknown): FileMention[] {\n  if (raw === undefined || raw === null) return []\n  if (!Array.isArray(raw)) throw new ChatTurnInputError('mentions must be an array')\n  if (raw.length > MENTION_MAX_COUNT) {\n    throw new ChatTurnInputError(`mentions must not exceed ${MENTION_MAX_COUNT} entries`)\n  }\n\n  const mentions: FileMention[] = []\n  const seenPaths = new Set<string>()\n  for (let index = 0; index < raw.length; index += 1) {\n    const mention = parseFileMention(raw[index], index)\n    if (seenPaths.has(mention.path)) continue\n    seenPaths.add(mention.path)\n    mentions.push(mention)\n  }\n  return mentions\n}\n\n/** Validates the untyped `parts` array off the wire. Returns the typed parts\n *  or throws `ChatTurnInputError` (400) naming the offending entry. */\nexport function parseChatTurnParts(raw: unknown): ChatTurnFilePartInput[] {\n  if (raw === undefined || raw === null) return []\n  if (!Array.isArray(raw)) throw new ChatTurnInputError('parts must be an array')\n  return raw.map((entry, index) => {\n    const part = entry as Record<string, unknown> | null\n    if (!part || typeof part !== 'object') {\n      throw new ChatTurnInputError(`parts[${index}] must be an object`)\n    }\n    if (part.type !== 'image' && part.type !== 'file') {\n      throw new ChatTurnInputError(`parts[${index}].type must be 'image' or 'file'`)\n    }\n    for (const key of ['filename', 'mediaType', 'url', 'path'] as const) {\n      if (part[key] !== undefined && typeof part[key] !== 'string') {\n        throw new ChatTurnInputError(`parts[${index}].${key} must be a string`)\n      }\n    }\n    if (part.content !== undefined) {\n      throw new ChatTurnInputError(`parts[${index}].content is not supported; provide a url or path`)\n    }\n\n    const url = typeof part.url === 'string' && part.url.length > 0 ? part.url : undefined\n    const path = typeof part.path === 'string' && part.path.length > 0 ? part.path : undefined\n    if (Boolean(url) === Boolean(path)) {\n      throw new ChatTurnInputError(`parts[${index}] requires exactly one url or path`)\n    }\n    if (path && !path.startsWith('/')) {\n      throw new ChatTurnInputError(`parts[${index}].path must be absolute`)\n    }\n\n    const filename = typeof part.filename === 'string' ? part.filename.trim() : undefined\n    if (part.type === 'file' && !filename) {\n      throw new ChatTurnInputError(`parts[${index}].filename is required for file parts`)\n    }\n    return {\n      type: part.type,\n      ...(filename ? { filename } : {}),\n      ...(part.mediaType !== undefined ? { mediaType: part.mediaType as string } : {}),\n      ...(url ? { url } : { path: path! }),\n    }\n  })\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-HZVVO6VR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/chat-routes/file-index.ts"],"sourcesContent":["/**\n * `createSandboxFileIndexRoute` — server side of `@`-file-mentions\n * (companion to sandbox-ui#184's composer mention primitive). Serves a flat,\n * ignore-filtered listing of the workspace sandbox so `useFileMentions`\n * (`/web-react`) can filter it client-side without a round trip per\n * keystroke.\n *\n * Same seam style as `createUploadRoute`: `authorize({ request })` resolves a\n * structural `{ tree(path, opts) }` handle (the shape of the sandbox SDK's\n * `box.fs.tree`) — no SDK import here. `authorize` also carries the\n * cold-box signal: a sandbox that isn't running yet answers `{ status:\n * 'warming' }` directly, never provisions-and-waits inside this route.\n *\n * A box can also be running with its workspace root not yet materialised, which\n * `authorize` cannot see; the route recognises that one signal off `fs.tree`\n * and answers `warming` too, so every consumer gets the retry-and-wait state\n * instead of a 500. Every other `tree()` failure propagates.\n */\n\nimport type { FileMention } from './wire'\n\n/** One entry from a structural `tree()` scan. Mirrors the sandbox SDK's\n *  `FileTreeFile` (`path`, `size`, `mtime`) — `mtime` is unused here so it's\n *  omitted from the structural match. */\nexport interface SandboxTreeFile {\n  path: string\n  size: number\n}\n\n/** Structural match of the sandbox SDK's `box.fs.tree` result shape\n *  (`FileTreeResult`). `stats.truncated` is the only stat this route reads;\n *  the rest ride through unread on the real SDK type. */\nexport interface SandboxTreeResult {\n  root: string\n  files: SandboxTreeFile[]\n  stats: { truncated: boolean }\n}\n\n/** Structural match of the sandbox SDK's `box.fs` tree surface. */\nexport interface SandboxFileTreeSource {\n  tree(path: string, options?: { maxDepth?: number }): Promise<SandboxTreeResult>\n}\n\n/** Describe a ready file index response with workspace-relative entries and truncation status */\nexport interface FileIndexReadyResponse {\n  status: 'ready'\n  /** Workspace-relative entries. Same shape as `FileMention` (`./wire`) so a\n   *  client can hand a response entry straight to `fileMentionsToParts` /\n   *  `buildMentionPromptBlock` without remapping. */\n  files: FileMention[]\n  /** True when either the underlying scan truncated (SDK-side cap) or this\n   *  route's own `maxEntries` cap trimmed the filtered list. The client\n   *  should show \"showing first N files\" rather than imply completeness. */\n  truncated: boolean\n  generatedAt: string\n}\n\n/** Cold-box answer: no provisioning happened, no files were scanned. The\n *  client shows a warming state and retries — this route never blocks on a\n *  box coming up. Two situations produce it: `authorize` reporting a box that\n *  is not running, and a running box whose workspace root does not exist yet\n *  (see `isMissingRootError`). */\nexport interface FileIndexWarmingResponse {\n  status: 'warming'\n}\n\n/** Resolve a response indicating the file index is either ready or warming up */\nexport type FileIndexResponse = FileIndexReadyResponse | FileIndexWarmingResponse\n\n/** Short-TTL cache seam so repeat popover opens in the same session don't\n *  re-scan the workspace. Host-provided (e.g. a KV binding); `key` is\n *  whatever `authorize` returns as `cacheKey` — this route treats it opaquely. */\nexport interface FileIndexCache {\n  get(key: string): Promise<FileIndexReadyResponse | null> | FileIndexReadyResponse | null\n  put(key: string, value: FileIndexReadyResponse, options?: { ttlSeconds?: number }): Promise<void> | void\n}\n\n/** Define authorization details and parameters for indexing a file workspace with optional caching and ignore rules */\nexport type FileIndexAuthorization =\n  | {\n      status: 'ready'\n      /** Structural sandbox `fs` handle, usually `ensureWorkspaceSandbox(...)` → `box.fs`. */\n      fs: SandboxFileTreeSource\n      /** Workspace root to index (e.g. `/home/agent`). */\n      root: string\n      /** Extra ignore segments for this request, merged with the route's\n       *  defaults + `CreateSandboxFileIndexRouteOptions.ignore`. */\n      ignore?: string[]\n      /** Opaque cache key for the optional cache seam. Omit to skip caching\n       *  for this request (e.g. a workspace the host chooses not to cache). */\n      cacheKey?: string\n    }\n  | { status: 'warming' }\n  | { status: 'denied'; response: Response }\n\n/** Define options to authorize and configure sandbox file index route behavior */\nexport interface CreateSandboxFileIndexRouteOptions {\n  /** Authenticate the caller, resolve the sandbox `fs` handle, and signal a\n   *  cold box — never provisions or waits. */\n  authorize(args: { request: Request }): Promise<FileIndexAuthorization>\n  /** Extra ignore segments beyond the route's defaults (node_modules, .git,\n   *  dotfiles/dot-dirs, common build dirs). Matched as exact path-segment\n   *  names, same rule as the defaults. */\n  ignore?: string[]\n  /** Passed to `fs.tree` as `options.maxDepth`. Default 12. */\n  maxDepth?: number\n  /** Hard cap on entries returned after filtering. Default 5000. */\n  maxEntries?: number\n  /** Optional host-provided cache seam. */\n  cache?: FileIndexCache\n  /** Cache TTL in seconds when `cache` is set. Default 20. */\n  cacheTtlSeconds?: number\n}\n\n/** Segment names ignored anywhere in a path, beyond the generic dotfile rule\n *  below. Intentionally small and language/framework-agnostic — callers\n *  extend it via `ignore` for anything domain-specific (e.g. a vault's\n *  `uploads` dir). */\nconst DEFAULT_IGNORE_SEGMENTS = [\n  'node_modules',\n  'dist',\n  'build',\n  'out',\n  'coverage',\n  'target',\n  '__pycache__',\n  'venv',\n]\n\n/** A path segment starting with `.` (`.git`, `.env`, `.next`, `.cache`, …) is\n *  always ignored — this single rule covers most dot-prefixed VCS/tooling\n *  dirs and dotfiles without enumerating them. */\nfunction isIgnored(relPath: string, ignoreSegments: ReadonlySet<string>): boolean {\n  if (!relPath || relPath.startsWith('/') || relPath.includes('\\\\')) return true\n  for (const segment of relPath.split('/')) {\n    if (!segment) continue\n    if (segment.startsWith('.')) return true\n    if (ignoreSegments.has(segment)) return true\n  }\n  return false\n}\n\n/** Strips the tree result's echoed `root` prefix so entries are always\n *  workspace-relative, whichever convention the structural `fs.tree` uses\n *  (root-relative already, or root-prefixed). */\nfunction relativeTo(root: string, path: string): string {\n  const prefix = root.endsWith('/') ? root : `${root}/`\n  if (path.startsWith(prefix)) return path.slice(prefix.length)\n  if (path === root) return ''\n  return path\n}\n\nfunction basename(path: string): string {\n  const segments = path.split('/').filter(Boolean)\n  return segments[segments.length - 1] ?? path\n}\n\n/**\n * A box can answer `running` before it has materialised the workspace root —\n * `authorize` has already committed to `ready` by then, so `fs.tree` is the\n * first thing to notice, and it rejects with the sandbox SDK's\n * `ValidationError` wrapping a box-side `ENOENT … lstat` on the root. That is\n * the SAME \"not usable yet\" state `authorize` collapses onto `warming` for an\n * absent or stopped box, just discovered one step later, so it gets the same\n * answer instead of escaping as a 500.\n *\n * Matched STRUCTURALLY, not with `instanceof`: importing the SDK's error class\n * would make `@tangle-network/sandbox` a hard dependency of a route factory\n * whose entire `fs` seam is structural (`SandboxFileTreeSource`), and would\n * break any host feeding it a non-SDK handle.\n *\n * Deliberately narrow — the error code, `ENOENT`, the ENOENT message text, AND\n * the failing syscall's own operand all have to line up. A permission error, a\n * timeout, an auth failure, or an ENOENT on some other path inside the tree is\n * a real failure and still surfaces.\n *\n * The operand is matched as the quoted `lstat '<root>'` clause rather than by\n * substring, because the root is a PREFIX of everything under it: a plain\n * `includes(root)` would also swallow an ENOENT on `<root>/gone/x.md`, and on\n * a prefix sibling like `/home/agent-old/...`.\n */\nfunction isMissingRootError(err: unknown, root: string): boolean {\n  if (!(err instanceof Error)) return false\n  if ((err as { code?: unknown }).code !== 'VALIDATION_ERROR') return false\n  return (\n    /ENOENT/.test(err.message) &&\n    /no such file or directory/.test(err.message) &&\n    new RegExp(`\\\\blstat '${escapeRegExp(root)}'`).test(err.message)\n  )\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/** Resolve a sandbox file index route with authorization, caching, and configurable depth and entries limits */\nexport function createSandboxFileIndexRoute(\n  options: CreateSandboxFileIndexRouteOptions,\n): (request: Request) => Promise<Response> {\n  const maxDepth = options.maxDepth ?? 12\n  const maxEntries = options.maxEntries ?? 5000\n  const cacheTtlSeconds = options.cacheTtlSeconds ?? 20\n  const staticIgnore = new Set([...DEFAULT_IGNORE_SEGMENTS, ...(options.ignore ?? [])])\n\n  return async function fileIndex(request: Request): Promise<Response> {\n    const auth = await options.authorize({ request })\n    if (auth.status === 'denied') return auth.response\n    if (auth.status === 'warming') {\n      return Response.json({ status: 'warming' } satisfies FileIndexWarmingResponse)\n    }\n\n    const cache = options.cache\n    if (cache && auth.cacheKey) {\n      const cached = await cache.get(auth.cacheKey)\n      if (cached) return Response.json(cached)\n    }\n\n    const ignoreSegments = auth.ignore?.length\n      ? new Set([...staticIgnore, ...auth.ignore])\n      : staticIgnore\n\n    let scan: SandboxTreeResult\n    try {\n      scan = await auth.fs.tree(auth.root, { maxDepth })\n    } catch (err) {\n      if (!isMissingRootError(err, auth.root)) throw err\n      return Response.json({ status: 'warming' } satisfies FileIndexWarmingResponse)\n    }\n    const filtered = scan.files.filter((f) => !isIgnored(relativeTo(auth.root, f.path), ignoreSegments))\n    const truncated = scan.stats.truncated || filtered.length > maxEntries\n    const files: FileMention[] = filtered.slice(0, maxEntries).map((f) => {\n      const path = relativeTo(auth.root, f.path)\n      const entry: FileMention = { path, name: basename(path) }\n      if (typeof f.size === 'number') entry.size = f.size\n      return entry\n    })\n\n    const body: FileIndexReadyResponse = {\n      status: 'ready',\n      files,\n      truncated,\n      generatedAt: new Date().toISOString(),\n    }\n\n    if (cache && auth.cacheKey) await cache.put(auth.cacheKey, body, { ttlSeconds: cacheTtlSeconds })\n\n    return Response.json(body)\n  }\n}\n"],"mappings":"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","names":[]}