@foundation0/api 1.1.1 → 1.1.2

package/mcp/cli.mjs

@@ -32,6 +32,6 @@ try {
     process.exit(1)
   }
 
-  console.error('Failed to launch example-org MCP server', error)
+  console.error('Failed to launch f0-mcp server', error)
   process.exit(1)
 }

package/mcp/cli.ts

@@ -101,6 +101,6 @@ void runExampleMcpServer({
   enableIssues,
   admin,
 }).catch((error) => {
-  console.error('Failed to start example-org MCP server', error)
-  process.exit(1)
-})
+  console.error('Failed to start f0-mcp server', error)
+  process.exit(1)
+})

package/mcp/client.test.ts

@@ -126,4 +126,17 @@ describe('ExampleMcpClient git file guard', () => {
     expect(response.isError).toBe(false)
     expect(response.data).toEqual({ ok: true, body: { result: 'pass-through' } })
   })
+
+  it('keeps plain-text tool responses as data when JSON parsing fails', async () => {
+    stubRequests(() => ({
+      isError: false,
+      content: [{ type: 'text', text: 'not-json' }],
+    }))
+
+    const response = await client.call('projects.listProjects')
+
+    expect(response.isError).toBe(false)
+    expect(response.text).toBe('not-json')
+    expect(response.data).toBe('not-json')
+  })
 })

package/mcp/client.ts

@@ -151,11 +151,19 @@ const decodeFileContent = (content: string, encoding: string): string => {
 }
 
 const extractGitFileContent = (data: unknown): ExtractedGitFileContent | null => {
-  if (!isRecord(data) || !isRecord(data.body)) {
+  const unwrapped = (() => {
+    if (!isRecord(data)) return data
+    if (typeof data.ok === 'boolean' && 'result' in data) {
+      return (data as any).result
+    }
+    return data
+  })()
+
+  if (!isRecord(unwrapped) || !isRecord(unwrapped.body)) {
     return null
   }
 
-  const body = data.body
+  const body = unwrapped.body
   if (typeof body.content !== 'string') {
     return null
   }
@@ -366,7 +374,7 @@ export class ExampleMcpClient {
     return {
       isError: Boolean(response.isError),
       text: parsed.text,
-      data: parsed.parsed,
+      data: parsed.parsed ?? parsed.text,
     }
   }
 
@@ -547,7 +555,7 @@ export class ExampleMcpClient {
     methodArgs: unknown[] = [],
     methodOptions: Record<string, unknown> = {},
   ): Promise<ExampleMcpCallResponse> {
-    const args = { args: methodArgs.map((value) => String(value)), options: methodOptions }
+    const args = { args: methodArgs, options: methodOptions }
     return this.call(path, args)
   }
 }

package/mcp/server.test.ts

@@ -1,4 +1,7 @@
 import { describe, expect, it } from 'bun:test'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
 import { createExampleMcpServer } from './server'
 
 describe('createExampleMcpServer endpoint whitelist', () => {
@@ -115,3 +118,133 @@ describe('createExampleMcpServer endpoint whitelist', () => {
     expect(adminNames).toContain('projects.clearIssues')
   })
 })
+
+describe('createExampleMcpServer request handling', () => {
+  const getToolHandler = (instance: ReturnType<typeof createExampleMcpServer>) => {
+    const handler = (instance.server as any)._requestHandlers?.get('tools/call')
+    if (!handler) {
+      throw new Error('tools/call handler not registered')
+    }
+    return handler as (request: any, extra: any) => Promise<any>
+  }
+
+  it('passes structured args without stringifying', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'f0-mcp-server-test-'))
+    try {
+      await fs.writeFile(path.join(tempDir, 'boot.v0.0.1.md'), '# boot\n', 'utf8')
+      const instance = createExampleMcpServer()
+      const handler = getToolHandler(instance)
+
+      const result = await handler({
+        method: 'tools/call',
+        params: {
+          name: 'agents.resolveTargetFile',
+          arguments: {
+            args: [
+              tempDir,
+              { parts: [], base: 'boot', version: 'v0.0.1', ext: 'md' },
+            ],
+          },
+        },
+      }, {})
+
+      const payload = JSON.parse(result.content?.[0]?.text ?? '{}')
+      expect(payload.ok).toBe(true)
+      expect(payload.result).toBe('boot.v0.0.1.md')
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  it('parses continueOnError from string "false" (fails fast)', async () => {
+    const instance = createExampleMcpServer()
+    const handler = getToolHandler(instance)
+
+    const result = await handler({
+      method: 'tools/call',
+      params: {
+        name: 'batch',
+        arguments: {
+          calls: [
+            { tool: 'projects.usage' },
+            { tool: 'unknown.tool' },
+          ],
+          continueOnError: 'false',
+        },
+      },
+    }, {})
+
+    expect(result.isError).toBe(true)
+    const payload = JSON.parse(result.content?.[0]?.text ?? '{}')
+    expect(payload.ok).toBe(false)
+    expect(payload.error?.message).toContain('Unknown tool')
+  })
+
+  it('parses continueOnError from string "true" (returns per-call errors)', async () => {
+    const instance = createExampleMcpServer()
+    const handler = getToolHandler(instance)
+
+    const result = await handler({
+      method: 'tools/call',
+      params: {
+        name: 'batch',
+        arguments: {
+          calls: [
+            { tool: 'projects.usage' },
+            { tool: 'unknown.tool' },
+          ],
+          continueOnError: 'true',
+          maxConcurrency: 2,
+        },
+      },
+    }, {})
+
+    expect(result.isError).toBe(true)
+    const payload = JSON.parse(result.content?.[0]?.text ?? '{}')
+    expect(payload.ok).toBe(false)
+    expect(payload.error?.message).toContain('batch calls failed')
+    expect(Array.isArray(payload.error?.details?.results)).toBe(true)
+    expect(payload.error.details.results[1].isError).toBe(true)
+  })
+
+  it('accepts unprefixed tool name when toolsPrefix is set', async () => {
+    const instance = createExampleMcpServer({ toolsPrefix: 'api' })
+    const handler = getToolHandler(instance)
+
+    const result = await handler({
+      method: 'tools/call',
+      params: {
+        name: 'projects.usage',
+        arguments: {},
+      },
+    }, {})
+
+    expect(result.isError).toBe(false)
+    const payload = JSON.parse(result.content?.[0]?.text ?? '{}')
+    expect(payload.ok).toBe(true)
+    expect(typeof payload.result).toBe('string')
+    expect(payload.result).toContain('Usage')
+  })
+
+  it('exposes mcp.describeTool for tool discovery', async () => {
+    const instance = createExampleMcpServer({ toolsPrefix: 'api' })
+    const handler = getToolHandler(instance)
+
+    const result = await handler({
+      method: 'tools/call',
+      params: {
+        name: 'mcp.describeTool',
+        arguments: {
+          args: ['projects.usage'],
+        },
+      },
+    }, {})
+
+    expect(result.isError).toBe(false)
+    const payload = JSON.parse(result.content?.[0]?.text ?? '{}')
+    expect(payload.ok).toBe(true)
+    expect(payload.result.name).toBe('api.projects.usage')
+    expect(payload.result.unprefixedName).toBe('projects.usage')
+    expect(payload.result.access).toBe('read')
+  })
+})