@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/session-tools/extract.ts

@@ -0,0 +1,137 @@
+import path from 'path'
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { runStructuredExtraction } from '../structured-extract'
+import type { ToolBuildContext } from './context'
+import { safePath } from './context'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+
+function resolveSessionForExtraction(bctx: ToolBuildContext) {
+  const session = bctx.resolveCurrentSession?.()
+  if (!session) throw new Error('extract requires an active session context.')
+  return session
+}
+
+async function executeExtractAction(args: Record<string, unknown>, bctx: ToolBuildContext) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'extract_structured').trim().toLowerCase()
+
+  try {
+    if (action === 'status') {
+      const session = resolveSessionForExtraction(bctx)
+      return JSON.stringify({
+        provider: session.provider || null,
+        model: session.model || null,
+        source: 'session',
+        supports: ['extract_structured', 'summarize'],
+      })
+    }
+
+    const session = resolveSessionForExtraction(bctx)
+    const filePath = typeof normalized.filePath === 'string' && normalized.filePath.trim()
+      ? (path.isAbsolute(normalized.filePath) ? path.resolve(normalized.filePath) : safePath(bctx.cwd, normalized.filePath))
+      : typeof normalized.path === 'string' && normalized.path.trim()
+        ? (path.isAbsolute(normalized.path) ? path.resolve(normalized.path) : safePath(bctx.cwd, normalized.path))
+        : null
+    const schema = action === 'summarize' ? undefined : normalized.schema
+    const instruction = typeof normalized.instruction === 'string'
+      ? normalized.instruction
+      : action === 'summarize'
+        ? (typeof normalized.prompt === 'string' ? normalized.prompt : 'Summarize the input and extract the main entities and key points.')
+        : typeof normalized.prompt === 'string'
+          ? normalized.prompt
+          : 'Extract the requested structured data.'
+    const result = await runStructuredExtraction({
+      session,
+      text: typeof normalized.text === 'string' ? normalized.text : typeof normalized.content === 'string' ? normalized.content : null,
+      filePath,
+      instruction,
+      schema,
+      preferOcr: normalized.preferOcr === true,
+      maxChars: typeof normalized.maxChars === 'number' ? Math.max(5_000, normalized.maxChars) : undefined,
+    })
+
+    return JSON.stringify({
+      object: result.object,
+      validationErrors: result.validationErrors,
+      provider: result.provider,
+      model: result.model,
+      source: {
+        kind: result.source.kind,
+        filePath: result.source.filePath || null,
+        method: result.source.artifact?.method || null,
+        fileName: result.source.artifact?.fileName || null,
+      },
+      raw: normalized.includeRaw === true ? result.raw : undefined,
+    })
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const ExtractPlugin: Plugin = {
+  name: 'Extract',
+  enabledByDefault: false,
+  description: 'Run schema-driven structured extraction over text or local files using the current session model.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can turn unstructured text or documents into validated JSON with `extract`, using the current session provider/model and a caller-supplied schema.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'extract',
+      description: 'Structured extraction tool. Actions: extract_structured, summarize, status.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['extract_structured', 'summarize', 'status'] },
+          text: { type: 'string' },
+          content: { type: 'string' },
+          filePath: { type: 'string' },
+          schema: {},
+          instruction: { type: 'string' },
+          prompt: { type: 'string' },
+          maxChars: { type: 'number' },
+          preferOcr: { type: 'boolean' },
+          includeRaw: { type: 'boolean' },
+        },
+        required: ['action'],
+      },
+      execute: async (args, context) => {
+        const syntheticBuildContext = {
+          cwd: context.session.cwd || process.cwd(),
+          ctx: { sessionId: context.session.id, agentId: context.session.agentId || null },
+          hasPlugin: () => true,
+          hasTool: () => true,
+          cleanupFns: [],
+          commandTimeoutMs: 0,
+          claudeTimeoutMs: 0,
+          cliProcessTimeoutMs: 0,
+          persistDelegateResumeId: () => undefined,
+          readStoredDelegateResumeId: () => null,
+          resolveCurrentSession: () => context.session,
+          activePlugins: context.session.plugins || [],
+        } as ToolBuildContext
+        return executeExtractAction(args, syntheticBuildContext)
+      },
+    },
+  ],
+}
+
+getPluginManager().registerBuiltin('extract', ExtractPlugin)
+
+export function buildExtractTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('extract')) return []
+  return [
+    tool(
+      async (args) => executeExtractAction(args, bctx),
+      {
+        name: 'extract',
+        description: ExtractPlugin.tools![0].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+  ]
+}

package/src/lib/server/session-tools/file-normalize.test.ts

@@ -0,0 +1,93 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { executeFileAction, normalizeFileArgs } from './file'
+
+describe('normalizeFileArgs', () => {
+  it('infers write from top-level filename and text', () => {
+    const out = normalizeFileArgs({ filename: 'note.txt', text: 'hello' })
+    assert.equal(out.action, 'write')
+    assert.equal(out.filePath, 'note.txt')
+    assert.equal(out.content, 'hello')
+  })
+
+  it('accepts top-level name and body aliases', () => {
+    const out = normalizeFileArgs({ name: 'note.txt', body: 'hello' })
+    assert.equal(out.action, 'write')
+    assert.equal(out.filePath, 'note.txt')
+    assert.equal(out.content, 'hello')
+  })
+
+  it('infers read from filename when action is omitted', () => {
+    const out = normalizeFileArgs({ filename: 'note.txt' })
+    assert.equal(out.action, 'read')
+    assert.equal(out.filePath, 'note.txt')
+  })
+
+  it('infers read from lowercase filepath alias when action is omitted', () => {
+    const out = normalizeFileArgs({ filepath: 'note.txt' })
+    assert.equal(out.action, 'read')
+    assert.equal(out.filePath, 'note.txt')
+  })
+
+  it('infers list from directory aliases', () => {
+    const out = normalizeFileArgs({ directory: 'docs' })
+    assert.equal(out.action, 'list')
+    assert.equal(out.dirPath, 'docs')
+  })
+
+  it('infers write from bulk file entries with text content', () => {
+    const out = normalizeFileArgs({
+      files: [
+        { filename: 'a.txt', text: 'alpha' },
+      ],
+    })
+    assert.equal(out.action, 'write')
+    assert.deepEqual(out.files, [{ filename: 'a.txt', text: 'alpha' }])
+  })
+
+  it('normalizes legacy write wrapper payloads', () => {
+    const out = normalizeFileArgs({
+      input: JSON.stringify({
+        write: {
+          filename: 'legacy.txt',
+          content: 'legacy body',
+        },
+      }),
+    })
+
+    assert.equal(out.action, 'write')
+    assert.equal(out.filePath, 'legacy.txt')
+    assert.equal(out.content, 'legacy body')
+  })
+
+  it('preserves nested write.files arrays from natural model payloads', () => {
+    const out = normalizeFileArgs({
+      input: JSON.stringify({
+        write: {
+          files: [
+            { name: 'report.md', content: '# report' },
+          ],
+        },
+      }),
+    })
+
+    assert.equal(out.action, 'write')
+    assert.deepEqual(out.files, [{ name: 'report.md', content: '# report' }])
+  })
+
+  it('treats trailing-slash write targets as directory creation', async () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'file-write-dir-'))
+    const out = await executeFileAction({
+      action: 'write',
+      path: 'weather_update/',
+      content: 'placeholder',
+    }, { cwd })
+
+    assert.equal(out, 'Created directory weather_update/')
+    assert.equal(fs.statSync(path.join(cwd, 'weather_update')).isDirectory(), true)
+    fs.rmSync(cwd, { recursive: true, force: true })
+  })
+})

package/src/lib/server/session-tools/file-send.test.ts

@@ -1,6 +1,9 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import { normalizeSendFilePaths } from './file'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { findRecentSendFileFallbackPaths, normalizeSendFilePaths, resolveSendFileSourcePath } from './file'
 
 describe('normalizeSendFilePaths', () => {
   it('reads top-level filePath', () => {
@@ -8,6 +11,11 @@ describe('normalizeSendFilePaths', () => {
     assert.deepEqual(out, ['foo.png'])
   })
 
+  it('reads top-level lowercase filepath alias', () => {
+    const out = normalizeSendFilePaths({ filepath: 'foo.png' })
+    assert.deepEqual(out, ['foo.png'])
+  })
+
   it('reads nested input.files string array payload', () => {
     const out = normalizeSendFilePaths({
       input: {
@@ -26,6 +34,16 @@ describe('normalizeSendFilePaths', () => {
     assert.deepEqual(out, ['a.png'])
   })
 
+  it('accepts filePaths arrays from natural model tool calls', () => {
+    const out = normalizeSendFilePaths({
+      filePaths: ['a.png', 'b.png'],
+      input: JSON.stringify({
+        filePaths: ['b.png', 'c.png'],
+      }),
+    })
+    assert.deepEqual(out, ['a.png', 'b.png', 'c.png'])
+  })
+
   it('reads files object entries with path/filePath and dedupes', () => {
     const out = normalizeSendFilePaths({
       files: [
@@ -36,4 +54,69 @@ describe('normalizeSendFilePaths', () => {
     })
     assert.deepEqual(out, ['a.png', 'b.png'])
   })
+
+  it('accepts filename/name aliases commonly produced by model tool calls', () => {
+    const out = normalizeSendFilePaths({
+      filename: 'brief.md',
+      input: {
+        files: [{ name: 'fallback.md' }],
+      },
+    })
+    assert.deepEqual(out, ['brief.md', 'fallback.md'])
+  })
+
+  it('accepts fileId aliases commonly produced by model tool calls', () => {
+    const out = normalizeSendFilePaths({
+      input: {
+        fileId: 'brief.md',
+      },
+    })
+    assert.deepEqual(out, ['brief.md'])
+  })
+
+  it('extracts upload URLs from screenshot markdown tool output', () => {
+    const out = normalizeSendFilePaths({
+      filePath: '- [Screenshot of viewport](../../../.swarmclaw/browser-profiles/session/mcp-output/page.png)\n![Screenshot](/api/uploads/screenshot-123.png)',
+    })
+    assert.deepEqual(out, ['/api/uploads/screenshot-123.png', '../../../.swarmclaw/browser-profiles/session/mcp-output/page.png'])
+  })
+
+  it('falls back to a single recent file in the workspace when the payload is empty', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'send-file-'))
+    const recent = path.join(dir, 'brief.md')
+    const stale = path.join(dir, 'notes.txt')
+    fs.writeFileSync(recent, '# brief')
+    fs.writeFileSync(stale, 'old')
+    const oldTime = new Date(Date.now() - 20 * 60 * 1000)
+    fs.utimesSync(stale, oldTime, oldTime)
+
+    const out = findRecentSendFileFallbackPaths(dir)
+    assert.deepEqual(out, ['brief.md'])
+  })
+
+  it('resolves sandbox upload URLs when sending files', async () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'send-file-upload-'))
+    const resolved = resolveSendFileSourcePath(cwd, 'sandbox:/api/uploads/artifact.md')
+    assert.equal(path.basename(resolved), 'artifact.md')
+    assert.match(resolved, /uploads[\/\\]artifact\.md$/)
+    fs.rmSync(cwd, { recursive: true, force: true })
+  })
+
+  it('resolves /workspace aliases against the current session workspace first', () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'send-file-workspace-alias-'))
+    const artifact = path.join(cwd, 'spec.md')
+    fs.writeFileSync(artifact, '# spec')
+
+    const resolved = resolveSendFileSourcePath(cwd, '/workspace/spec.md')
+
+    assert.equal(resolved, artifact)
+    fs.rmSync(cwd, { recursive: true, force: true })
+  })
+
+  it('resolves browser profile screenshot paths back into the agent home directory', () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'send-file-browser-profile-'))
+    const resolved = resolveSendFileSourcePath(cwd, '../../../.swarmclaw/browser-profiles/example/mcp-output/page.png')
+    assert.match(resolved, new RegExp(`\\.swarmclaw[\\\\/]browser-profiles[\\\\/]example[\\\\/]mcp-output[\\\\/]page\\.png$`))
+    fs.rmSync(cwd, { recursive: true, force: true })
+  })
 })