@tangle-network/create-agent-app 0.46.60 → 0.47.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/create-agent-app",
-  "version": "0.46.60",
+  "version": "0.47.2",
   "description": "Create a tested Tangle agent application with either a tool loop or a complete chat interface.",
   "keywords": [
     "tangle",

package/template-chat/README.md

@@ -51,3 +51,11 @@ Then walk the trail:
 Identity comes from the session, never a request body. Inaccessible threads
 read as 404. No mock agent — missing sandbox credentials fail loud. See
 `AGENTS.md` for the full contract.
+
+## Artifact index
+
+`GET /api/files` lists files under `/home/agent/artifacts` for the signed-in user's workspace.
+The default prompt directs the agent to save user-facing outputs there; other workspace files are not indexed.
+The route returns `ready` with filtered metadata or `warming` when no ready sandbox exists.
+It never provisions or resumes a sandbox, and it does not provide file downloads.
+Hidden files and paths outside the artifact root are excluded.

package/template-chat/prompts/system.md

@@ -9,3 +9,6 @@ Hard rules:
 - Never fabricate a figure (price, identifier, clause, date). Cite a real record or say NOT ON FILE.
 - Route every regulated or client-facing action to a named human for approval; propose, don't execute.
 - State what you did and what evidence backs it. No filler.
+
+Save files created for the user under `/home/agent/artifacts` so they appear in the workspace artifact index.
+Keep credentials, configuration, and private working files outside that directory.

package/template-chat/src/files.ts

@@ -0,0 +1,30 @@
+import { createSandboxFileIndexRoute } from '@tangle-network/agent-app/chat-routes'
+import { peekWorkspaceSandbox } from '@tangle-network/agent-app/sandbox'
+import type { ChatApp } from './chat'
+import type { AppEnv } from './env'
+import { createSandboxShell } from './sandbox'
+
+/** Agent output directory; configuration and other workspace files are excluded. */
+export const ARTIFACT_ROOT = '/home/agent/artifacts'
+
+export function createArtifactIndex(
+  env: AppEnv,
+  app: ChatApp,
+  peek: typeof peekWorkspaceSandbox = peekWorkspaceSandbox,
+) {
+  return createSandboxFileIndexRoute({
+    authorize: async ({ request }) => {
+      const session = await app.auth.getSession(request)
+      if (!session) return { status: 'denied', response: Response.json({ error: 'Unauthorized' }, { status: 401 }) }
+      const userId = session.user.id
+      const requestedWorkspace = new URL(request.url).searchParams.get('workspaceId')
+      if (requestedWorkspace !== null && requestedWorkspace !== userId) {
+        return { status: 'denied', response: Response.json({ error: 'Not found' }, { status: 404 }) }
+      }
+      const found = await peek(createSandboxShell(env), { workspaceId: userId, userId })
+      if (found.status !== 'running') return { status: 'warming' }
+      return { status: 'ready', fs: found.box.fs, root: ARTIFACT_ROOT }
+    },
+    maxEntries: 1000,
+  })
+}

package/template-chat/src/worker.ts

@@ -11,6 +11,7 @@
  *   POST /api/chat                      run one turn (NDJSON stream)
  *   GET  /api/chat/replay/:turnId       replay a buffered turn (?fromSeq=)
  *   GET  /api/chat/running              live turn ids on a thread (?threadId=)
+ *   GET  /api/files                     owned artifact index (no provisioning)
  *   POST /api/chat/upload               multipart upload → prompt parts
  *   GET  /api/chat/interactions         outstanding agent asks (?threadId=)
  *   POST /api/chat/interactions         answer an ask
@@ -18,6 +19,8 @@
  *   POST /v1/agents/:slug/chat/completions  OpenAI-compatible API
  */
 
+import { createArtifactIndex } from './files'
+import type { peekWorkspaceSandbox } from '@tangle-network/agent-app/sandbox'
 import { config } from '../agent.config'
 import { buildChatApp, type ChatApp } from './chat'
 import type { AppEnv } from './env'
@@ -35,6 +38,8 @@ export interface WorkerAssembly {
   ): ReturnType<typeof buildGatewayApp>
   /** Test override. Production follows agent.config.ts. */
   gatewayEnabled?: boolean
+  /** Test seam; production reads existing sandbox state without provisioning. */
+  peekWorkspace?: typeof peekWorkspaceSandbox
 }
 
 function attachThreadUrl(response: Response, request: Request): Response {
@@ -100,6 +105,10 @@ export function createWorker(assembly: WorkerAssembly = defaultAssembly): Export
         return attachThreadUrl(await gateway.fetch(request), request)
       }
 
+      if (pathname === '/api/files' && method === 'GET') {
+        return createArtifactIndex(env, app, assembly.peekWorkspace)(request)
+      }
+
       if (pathname.startsWith('/api/auth/')) return app.auth.auth.handler(request)
 
       if (pathname === '/api/chat' && method === 'POST') {

package/template-chat/tests/chat-turn.e2e.test.ts

@@ -21,7 +21,7 @@ import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import Database from 'better-sqlite3'
 import { drizzle } from 'drizzle-orm/better-sqlite3'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 import {
   createSandboxChatProducer,
@@ -46,7 +46,8 @@ import { buildChatApp, type ChatApp } from '../src/chat'
 import type { AppEnv } from '../src/env'
 import { buildGatewayApp } from '../src/gateway'
 import { appSlug } from '../src/sandbox'
-import { createWorker } from '../src/worker'
+import { ARTIFACT_ROOT } from '../src/files'
+import { createWorker, type WorkerAssembly } from '../src/worker'
 
 const BASE = 'http://localhost:8787'
 const MODEL = 'test/model-1'
@@ -126,6 +127,7 @@ interface Harness {
 async function createHarness(
   produce: (args: ChatTurnProduceArgs<void>) => ChatTurnRouteProducer = () =>
     createSandboxChatProducer({ events: feed(RAW_TURN_EVENTS), model: MODEL }),
+  peekWorkspace?: WorkerAssembly['peekWorkspace'],
 ): Promise<Harness> {
   const database = openMigratedDb()
   const pending: Promise<unknown>[] = []
@@ -159,6 +161,7 @@ async function createHarness(
   app.routes.turn = (request) =>
     originalTurn(request, { waitUntil: (p) => void pending.push(p) })
   const worker = createWorker({
+    peekWorkspace,
     buildChatApp: () => app,
     buildGatewayApp: (_env, chatApp, options) => {
       gatewayBuildCount += 1
@@ -234,6 +237,42 @@ async function readGatewayText(response: Response): Promise<string> {
 // ── the gate ────────────────────────────────────────────────────────────────
 
 describe('e2e: fake sandbox producer → streamed turn → persisted transcript', () => {
+  it('indexes only owned artifacts through the real authenticated Worker route', async () => {
+    expect(config.systemPrompt).toContain(ARTIFACT_ROOT)
+    const tree = vi.fn(async () => ({
+      root: '/home/agent/artifacts',
+      files: [
+        { path: '/home/agent/artifacts/report.txt', size: 7 },
+        { path: '/home/agent/artifacts/.env', size: 99 },
+        { path: '/home/agent/private.txt', size: 99 },
+        { path: '../private.txt', size: 99 },
+      ],
+      stats: { truncated: false },
+    }))
+    const peek = vi.fn().mockResolvedValue({ status: 'running', box: { fs: { tree } } })
+    const h = await createHarness(undefined, peek)
+    expect((await h.workerFetch(new Request(`${BASE}/api/files`))).status).toBe(401)
+    expect(peek).not.toHaveBeenCalled()
+    const denied = await h.workerFetch(new Request(`${BASE}/api/files?workspaceId=another-user`, {
+      headers: { cookie: h.cookie },
+    }))
+    expect(denied.status).toBe(404)
+    expect(peek).not.toHaveBeenCalled()
+    const response = await h.workerFetch(new Request(`${BASE}/api/files?root=/home/agent`, {
+      headers: { cookie: h.cookie },
+    }))
+    expect(response.status).toBe(200)
+    expect(await response.json()).toMatchObject({ status: 'ready', files: [{ path: 'report.txt', name: 'report.txt', size: 7 }] })
+    expect(tree).toHaveBeenCalledWith('/home/agent/artifacts', { maxDepth: 12 })
+    const session = await h.app.auth.getSession(new Request(BASE, { headers: { cookie: h.cookie } }))
+    expect(peek).toHaveBeenCalledWith(expect.anything(), { userId: session!.user.id, workspaceId: session!.user.id })
+    peek.mockResolvedValue({ status: 'absent' })
+    tree.mockClear()
+    const cold = await h.workerFetch(new Request(`${BASE}/api/files`, { headers: { cookie: h.cookie } }))
+    expect(await cold.json()).toEqual({ status: 'warming' })
+    expect(tree).not.toHaveBeenCalled()
+  })
+
   it('normalizes path-backed generic files for the sandbox prompt API', () => {
     expect(
       normalizeChatPromptForSandbox([