@aisystemresources/emdee 0.3.0 → 0.3.2

package/README.md

@@ -1,10 +1,10 @@
 # Emdee
 
-Local-first knowledge graph backed by plain markdown. Humans browse it through a Next.js renderer; agents (Claude Code, Claude.ai, Cursor, Codex) read and write the same files through an MCP server. The vault is the source of truth — anything an LLM says traces back to a file you wrote.
+A markdown knowledge graph shared by humans and their AI agents. Files you can edit like Obsidian, a vault you can share like Google Drive, and a live MCP endpoint every agent (Claude Code, Claude.ai, Cursor, Codex) reads and writes to natively. One vault, three surfaces — with the plain markdown you wrote as the only source of truth.
 
 ## Why
 
-LLM agents need a stable, human-readable substrate to read and write their own context over time. Most knowledge-graph tools are either built for humans (Obsidian) or built for agents (vector stores). Emdee is a single substrate for both: the markdown a human edits is the exact bytes an agent reads, with no hidden index, no parallel summaries, no schema gymnastics. Build up a working journal that survives across sessions.
+Every knowledge tool picks two of three: human-friendly, team-shareable, agent-native. Notion is human-friendly and shareable, but its blocks aren't markdown and agents can't natively touch them. Obsidian is human-friendly and agent-touchable (they're just markdown files), but private-by-default — sharing is a paid add-on or a git repo. Google Drive is shareable but not markdown-native. Emdee is all three: the markdown a human edits is the exact bytes an agent reads through MCP and a teammate reads through a share link — no hidden index, no parallel summaries, no schema gymnastics. Build up a working journal that survives across sessions and travels with the people you invite in.
 
 ## Install
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aisystemresources/emdee",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Local-first document management with markdown rendering, knowledge graph, and MCP server.",
   "type": "module",
   "bin": {

package/src/cli/remote-client.ts

@@ -37,6 +37,9 @@ export async function callTool(
     method: "POST",
     headers: {
       "Content-Type": "application/json",
+      // MCP streamable-HTTP transport requires BOTH content types in Accept
+      // or it 406s with "Client must accept both application/json and
+      // text/event-stream". We handle whichever shape the server picks below.
       "Accept": "application/json, text/event-stream",
       Authorization: `Bearer ${creds.access_token}`,
     },
@@ -54,12 +57,33 @@ export async function callTool(
     throw new Error(`remote call failed: ${res.status} ${body}`);
   }
 
-  const body = (await res.json()) as JsonRpcResponse;
+  const body = await parseJsonRpc(res);
   if (body.error) throw new Error(`remote tool error: ${body.error.message}`);
   if (!body.result) throw new Error("remote call returned no result");
   return body.result;
 }
 
+// The MCP streamable-HTTP transport content-negotiates on the request Accept:
+// when the client offers both JSON and SSE (as required — see 406 above),
+// the server may reply with either. JSON we parse directly; SSE arrives as
+// one or more `event: message\ndata: <json>\n\n` frames — for a single
+// tools/call response we take the first `data:` payload.
+async function parseJsonRpc(res: Response): Promise<JsonRpcResponse> {
+  const ct = res.headers.get("content-type") ?? "";
+  if (ct.includes("text/event-stream")) {
+    const text = await res.text();
+    const dataLine = text.split(/\r?\n/).find((l) => l.startsWith("data:"));
+    if (!dataLine) throw new Error(`remote call returned SSE with no data frame: ${text.slice(0, 200)}`);
+    const payload = dataLine.slice("data:".length).trim();
+    try {
+      return JSON.parse(payload) as JsonRpcResponse;
+    } catch (e) {
+      throw new Error(`remote call SSE data frame is not valid JSON: ${(e as Error).message}`);
+    }
+  }
+  return (await res.json()) as JsonRpcResponse;
+}
+
 /**
  * Convenience: unwrap the MCP text envelope back to a string. Tools that
  * return JSON encode it inside `content[0].text`; tools that return plain