@selfagency/beans-mcp 0.1.1 → 0.1.3

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selfagency/beans-mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "MCP (Model Context Protocol) server for Beans issue tracker",
   "keywords": [
     "beans",
@@ -15,7 +15,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/selfagency/beans-mcp.git"
+    "url": "git+https://github.com/selfagency/beans-mcp.git"
   },
   "license": "MIT",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selfagency/beans-mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "MCP (Model Context Protocol) server for Beans issue tracker",
   "author": {
@@ -14,7 +14,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/selfagency/beans-mcp.git"
+    "url": "git+https://github.com/selfagency/beans-mcp.git"
   },
   "keywords": [
     "beans",
@@ -36,7 +36,7 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "beans-mcp": "./dist/beans-mcp-server.cjs"
+    "beans-mcp": "dist/beans-mcp-server.cjs"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",

package/src/server/BeansMcpServer.ts

@@ -10,6 +10,10 @@ import {
   MAX_TITLE_LENGTH,
 } from '../types';
 import { makeTextAndStructured } from '../utils';
+// Log package version on startup to help diagnose runtime package mismatches
+// Note: resolveJsonModule is enabled in tsconfig, so we can import package.json safely.
+// Always log to stderr to avoid interfering with MCP stdio transport on stdout.
+import pkgJson from '../../package.json' assert { type: 'json' };
 import type { BackendInterface } from './backend';
 
 export { sortBeans };
@@ -97,6 +101,7 @@ export function updateHandler(backend: BackendInterface) {
     clearParent?: boolean;
     blocking?: string[];
     blockedBy?: string[];
+    body?: string;
   }) =>
     makeTextAndStructured({
       bean: await backend.update(input.beanId, {
@@ -107,6 +112,7 @@ export function updateHandler(backend: BackendInterface) {
         clearParent: input.clearParent,
         blocking: input.blocking,
         blockedBy: input.blockedBy,
+        body: input.body,
       }),
     });
 }
@@ -293,6 +299,7 @@ function registerTools(server: McpServer, backend: BackendInterface): void {
         clearParent: z.boolean().optional(),
         blocking: z.array(z.string().max(MAX_ID_LENGTH)).optional(),
         blockedBy: z.array(z.string().max(MAX_ID_LENGTH)).optional(),
+        body: z.string().max(MAX_DESCRIPTION_LENGTH).optional(),
       }),
       annotations: {
         readOnlyHint: false,
@@ -574,6 +581,18 @@ export async function startBeansMcpServer(
   process.env.BEANS_VSCODE_MCP_PORT = String(port);
   process.env.BEANS_MCP_PORT = String(port);
 
+  // Emit a single-line startup banner with package version and key settings.
+  try {
+    const version = (pkgJson as { version?: string }).version ?? '0.0.0-dev';
+    const workspaceLabel = workspaceExplicit ? workspaceRoot : '(auto from roots)';
+    // stderr only – stdout is reserved for JSON-RPC traffic
+    console.error(
+      `[beans-mcp] v${version} starting (port=${port}, workspace=${workspaceLabel}, cli=${cliPath}, logDir=${logDir})`,
+    );
+  } catch {
+    // Best-effort only; never fail startup on logging
+  }
+
   // Use a mutable delegate so we can hot-swap the workspace after roots discovery
   // without re-registering the MCP tools.
   const mutable = new MutableBackend(new BeansCliBackend(workspaceRoot, cliPath, logDir));
@@ -595,6 +614,10 @@ export async function startBeansMcpServer(
     const rootPath = await resolver(server);
     if (rootPath) {
       mutable.setInner(new BeansCliBackend(rootPath, cliPath));
+      // Log the resolved workspace for traceability (stderr to avoid stdout noise)
+      try {
+        console.error(`[beans-mcp] workspace resolved from roots: ${rootPath}`);
+      } catch {}
     }
   }
 }

package/src/server/backend.ts

@@ -35,6 +35,7 @@ export interface BackendInterface {
       clearParent?: boolean;
       blocking?: string[];
       blockedBy?: string[];
+      body?: string;
     },
   ): Promise<BeanRecord>;
   delete(beanId: string): Promise<Record<string, unknown>>;
@@ -214,6 +215,7 @@ export class BeansCliBackend implements BackendInterface {
       clearParent?: boolean;
       blocking?: string[];
       blockedBy?: string[];
+      body?: string;
     },
   ): Promise<BeanRecord> {
     const updateInput: Record<string, unknown> = {
@@ -236,6 +238,10 @@ export class BeansCliBackend implements BackendInterface {
       updateInput.addBlockedBy = updates.blockedBy;
     }
 
+    if (updates.body !== undefined) {
+      updateInput.body = updates.body;
+    }
+
     const { data, errors } = await this.executeGraphQL<{ updateBean: BeanRecord }>(graphql.UPDATE_BEAN_MUTATION, {
       id: beanId,
       input: updateInput,

package/src/test/handlers.unit.test.ts

@@ -9,6 +9,7 @@ import {
   outputHandler,
   queryHandler,
   reopenHandler,
+  updateHandler,
   viewHandler,
 } from '../server/BeansMcpServer';
 
@@ -75,27 +76,45 @@ describe('Handlers (unit)', () => {
     const backend = makeBackend();
     const res = await initHandler(backend)({ prefix: 'pfx' });
     expect(backend.init).toHaveBeenCalledWith('pfx');
-    expect(res.structuredContent).toBeDefined();
+    const data = JSON.parse(res.content?.[0]?.text ?? '{}');
+    expect(data).toBeDefined();
   });
 
   it('viewHandler returns bean structured content', async () => {
     const backend = makeBackend();
     const res = await viewHandler(backend)({ beanId: 'b1' });
-    expect(res.structuredContent.bean.id).toBe('b1');
+    const data = JSON.parse(res.content?.[0]?.text ?? '{}');
+    expect(data.bean.id).toBe('b1');
   });
 
   it('createHandler delegates to backend.create', async () => {
     const backend = makeBackend();
     const res = await createHandler(backend)({ title: 'T', type: 't' });
     expect(backend.create).toHaveBeenCalled();
-    expect(res.structuredContent.bean.id).toBe('new');
+    const data = JSON.parse(res.content?.[0]?.text ?? '{}');
+    expect(data.bean.id).toBe('new');
   });
 
   it('editHandler delegates to backend.update', async () => {
     const backend = makeBackend();
     const res = await editHandler(backend)({ beanId: 'b1', status: 'todo' });
     expect(backend.update).toHaveBeenCalledWith('b1', { status: 'todo' });
-    expect(res.structuredContent.bean.status).toBe('todo');
+    const data = JSON.parse(res.content?.[0]?.text ?? '{}');
+    expect(data.bean.status).toBe('todo');
+  });
+
+  it('updateHandler delegates body updates to backend.update', async () => {
+    const backend = makeBackend({
+      update: vi.fn(async (id: string, updates: any) => ({
+        ...sampleBean,
+        id,
+        ...updates,
+      })),
+    });
+    const res = await updateHandler(backend)({ beanId: 'b1', body: 'new body text' } as any);
+    expect(backend.update).toHaveBeenCalledWith('b1', expect.objectContaining({ body: 'new body text' }));
+    const data = JSON.parse(res.content?.[0]?.text ?? '{}');
+    expect(data.bean.body).toBe('new body text');
   });
 
   it('reopenHandler throws if current status mismatches', async () => {
@@ -117,7 +136,8 @@ describe('Handlers (unit)', () => {
       targetStatus: 'todo',
     });
     expect(backend.update).toHaveBeenCalled();
-    expect(res.structuredContent.bean.status).toBe('todo');
+    const data = JSON.parse(res.content?.[0]?.text ?? '{}');
+    expect(data.bean.status).toBe('todo');
   });
 
   it('deleteHandler enforces draft/scrapped unless force', async () => {
@@ -168,11 +188,8 @@ describe('Handlers (unit)', () => {
     const _r = await outputHandler(backend)({ operation: 'read', lines: 10 });
     expect(backend.readOutputLog).toHaveBeenCalled();
     const s = await outputHandler(backend)({ operation: 'show' });
-    if ('message' in s.structuredContent) {
-      expect(s.structuredContent.message).toMatch(/When using VS Code UI/);
-    } else {
-      throw new Error('expected message in structuredContent');
-    }
+    const data = JSON.parse(s.content?.[0]?.text ?? '{}');
+    expect(data.message).toMatch(/When using VS Code UI/);
   });
 
   it('queryHandler delegates to handleQueryOperation', async () => {

package/src/test/utils.test.ts

@@ -1,80 +1,81 @@
-import { describe, expect, it } from "vitest";
-import { isPathWithinRoot, makeTextAndStructured } from "../utils";
+import { describe, expect, it } from 'vitest';
+import { isPathWithinRoot, makeTextAndStructured } from '../utils';
 
-describe("isPathWithinRoot", () => {
-  it("should return true for paths within root", () => {
-    const root = "/workspace/.beans";
-    const target = "/workspace/.beans/file.md";
+describe('isPathWithinRoot', () => {
+  it('should return true for paths within root', () => {
+    const root = '/workspace/.beans';
+    const target = '/workspace/.beans/file.md';
     expect(isPathWithinRoot(root, target)).toBe(true);
   });
 
-  it("should return false for paths outside root", () => {
-    const root = "/workspace/.beans";
-    const target = "/workspace/outside.md";
+  it('should return false for paths outside root', () => {
+    const root = '/workspace/.beans';
+    const target = '/workspace/outside.md';
     expect(isPathWithinRoot(root, target)).toBe(false);
   });
 
-  it("should return false for paths with parent traversal", () => {
-    const root = "/workspace/.beans";
-    const target = "/workspace/.beans/../../etc/passwd";
+  it('should return false for paths with parent traversal', () => {
+    const root = '/workspace/.beans';
+    const target = '/workspace/.beans/../../etc/passwd';
     expect(isPathWithinRoot(root, target)).toBe(false);
   });
 
-  it("should handle relative path normalization", () => {
-    const root = "/workspace/.beans/";
-    const target = "/workspace/.beans/subdir/file.md";
+  it('should handle relative path normalization', () => {
+    const root = '/workspace/.beans/';
+    const target = '/workspace/.beans/subdir/file.md';
     expect(isPathWithinRoot(root, target)).toBe(true);
   });
 
-  it("should return false when root and target are the same", () => {
-    const root = "/workspace/.beans";
-    const target = "/workspace/.beans";
+  it('should return false when root and target are the same', () => {
+    const root = '/workspace/.beans';
+    const target = '/workspace/.beans';
     expect(isPathWithinRoot(root, target)).toBe(false);
   });
 
-  it("should handle paths with trailing slashes", () => {
-    const root = "/workspace/.beans/";
-    const target = "/workspace/.beans/file.md";
+  it('should handle paths with trailing slashes', () => {
+    const root = '/workspace/.beans/';
+    const target = '/workspace/.beans/file.md';
     expect(isPathWithinRoot(root, target)).toBe(true);
   });
 });
 
-describe("makeTextAndStructured", () => {
-  it("should create text and structured content from object", () => {
-    const input = { name: "test", value: 42 };
+describe('makeTextAndStructured', () => {
+  it('should serialize object as JSON text', () => {
+    const input = { name: 'test', value: 42 } as const;
     const result = makeTextAndStructured(input);
 
     expect(result.content).toHaveLength(1);
-    expect(result.content[0].type).toBe("text");
-    expect(result.structuredContent).toEqual(input);
+    expect(result.content[0].type).toBe('text');
+    expect(() => JSON.parse(result.content[0].text)).not.toThrow();
+    expect(JSON.parse(result.content[0].text)).toEqual(input);
   });
 
-  it("should serialize content as JSON", () => {
-    const input = { key: "value", nested: { deep: true } };
-    const result = makeTextAndStructured(input);
+  it('should preserve arbitrary fields', () => {
+    const input = { message: 'Operation completed', extra: { ok: true } } as const;
+    const result = makeTextAndStructured(input as any);
+    expect(JSON.parse(result.content[0].text)).toEqual(input);
+  });
 
+  it('should include nested bean objects in JSON text', () => {
+    const input = { bean: { id: 'b1', title: 'My Bean' } } as const;
+    const result = makeTextAndStructured(input as any);
     const parsed = JSON.parse(result.content[0].text);
     expect(parsed).toEqual(input);
   });
 
-  it("should format JSON with proper indentation", () => {
-    const input = { a: 1 };
-    const result = makeTextAndStructured(input);
-
-    expect(result.content[0].text).toContain("\n");
-  });
-
-  it("should handle arrays in structured content", () => {
+  it('should handle arrays in JSON text', () => {
     const input = { items: [1, 2, 3] };
     const result = makeTextAndStructured(input);
-
-    expect(result.structuredContent.items).toEqual([1, 2, 3]);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.items).toEqual([1, 2, 3]);
   });
 
-  it("should handle null and undefined values", () => {
-    const input = { nullValue: null, undefinedValue: undefined };
+  it('should handle null and undefined values', () => {
+    const input = { nullValue: null, undefinedValue: undefined } as any;
     const result = makeTextAndStructured(input);
-
-    expect(result.structuredContent.nullValue).toBeNull();
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.nullValue).toBeNull();
+    // Note: undefined properties are omitted by JSON.stringify
+    expect(Object.prototype.hasOwnProperty.call(parsed, 'undefinedValue')).toBe(false);
   });
 });

package/src/utils.ts

@@ -13,8 +13,8 @@ export function isPathWithinRoot(root: string, target: string): boolean {
 }
 
 export function makeTextAndStructured<T extends Record<string, unknown>>(value: T) {
+  // Return JSON in text content only to avoid duplicate rendering in some clients.
   return {
     content: [{ type: 'text' as const, text: JSON.stringify(value, null, 2) }],
-    structuredContent: value,
   };
 }