devsh-memory-mcp 0.1.0

package/README.md

@@ -0,0 +1,114 @@
+# devsh-memory-mcp
+
+MCP server for devsh/cmux agent memory - enables Claude Desktop, Cursor, and other MCP clients to access sandbox agent memory.
+
+## Installation
+
+```bash
+npm install -g devsh-memory-mcp
+# or
+npx devsh-memory-mcp
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Use default memory directory (/root/lifecycle/memory)
+devsh-memory-mcp
+
+# Specify custom directory
+devsh-memory-mcp --dir /path/to/memory
+
+# Set agent name for messaging
+devsh-memory-mcp --agent my-agent
+```
+
+### Claude Desktop Configuration
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "devsh-memory": {
+      "command": "npx",
+      "args": ["devsh-memory-mcp"]
+    }
+  }
+}
+```
+
+With custom options:
+
+```json
+{
+  "mcpServers": {
+    "devsh-memory": {
+      "command": "npx",
+      "args": ["devsh-memory-mcp", "--dir", "/path/to/memory", "--agent", "claude-desktop"]
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Read Tools
+
+| Tool | Description |
+|------|-------------|
+| `read_memory` | Read knowledge, tasks, or mailbox memory |
+| `list_daily_logs` | List available daily log dates |
+| `read_daily_log` | Read a specific daily log |
+| `search_memory` | Search across all memory files |
+
+### Messaging Tools
+
+| Tool | Description |
+|------|-------------|
+| `send_message` | Send a message to another agent (or "*" for broadcast) |
+| `get_my_messages` | Get messages addressed to this agent |
+| `mark_read` | Mark a message as read |
+
+### Write Tools
+
+| Tool | Description |
+|------|-------------|
+| `append_daily_log` | Append content to today's daily log |
+| `update_knowledge` | Add an entry to a priority section (P0/P1/P2) |
+| `add_task` | Add a new task to TASKS.json |
+| `update_task` | Update the status of a task |
+
+### Orchestration Tools
+
+| Tool | Description |
+|------|-------------|
+| `read_orchestration` | Read PLAN.json, AGENTS.json, or EVENTS.jsonl |
+| `append_event` | Append an orchestration event to EVENTS.jsonl |
+| `update_plan_task` | Update task status in PLAN.json |
+
+## Memory Directory Structure
+
+```
+/root/lifecycle/memory/
+├── knowledge/
+│   └── MEMORY.md         # Long-term insights (P0/P1/P2 sections)
+├── daily/
+│   └── {date}.md         # Daily session logs
+├── orchestration/
+│   ├── PLAN.json         # Orchestration task plan
+│   ├── AGENTS.json       # Agent registry
+│   └── EVENTS.jsonl      # Orchestration event log
+├── TASKS.json            # Task registry
+└── MAILBOX.json          # Inter-agent messages
+```
+
+## Priority Tiers (MEMORY.md)
+
+- **P0 - Core**: Never expires. Project fundamentals, invariants.
+- **P1 - Active**: 90-day TTL. Ongoing work, current strategies.
+- **P2 - Reference**: 30-day TTL. Temporary findings, debug notes.
+
+Format: `- [YYYY-MM-DD] Your insight here`

package/dist/chunk-PI6DAQTW.js

@@ -0,0 +1,655 @@
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+var DEFAULT_MEMORY_DIR = "/root/lifecycle/memory";
+function createMemoryMcpServer(config) {
+  const memoryDir = config?.memoryDir ?? DEFAULT_MEMORY_DIR;
+  const agentName = config?.agentName ?? process.env.CMUX_AGENT_NAME ?? "external-client";
+  const knowledgeDir = path.join(memoryDir, "knowledge");
+  const dailyDir = path.join(memoryDir, "daily");
+  const orchestrationDir = path.join(memoryDir, "orchestration");
+  const mailboxPath = path.join(memoryDir, "MAILBOX.json");
+  const tasksPath = path.join(memoryDir, "TASKS.json");
+  const planPath = path.join(orchestrationDir, "PLAN.json");
+  const agentsPath = path.join(orchestrationDir, "AGENTS.json");
+  const eventsPath = path.join(orchestrationDir, "EVENTS.jsonl");
+  function readFile(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) return null;
+      return fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  function writeFile(filePath, content) {
+    try {
+      fs.writeFileSync(filePath, content, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function readTasks() {
+    const content = readFile(tasksPath);
+    if (!content) return { version: 1, tasks: [] };
+    try {
+      return JSON.parse(content);
+    } catch {
+      return { version: 1, tasks: [] };
+    }
+  }
+  function writeTasks(tasks) {
+    return writeFile(tasksPath, JSON.stringify(tasks, null, 2));
+  }
+  function generateTaskId() {
+    return "task_" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  }
+  function getTodayDateString() {
+    const iso = (/* @__PURE__ */ new Date()).toISOString();
+    return iso.slice(0, iso.indexOf("T"));
+  }
+  function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+  function readPlan() {
+    const content = readFile(planPath);
+    if (!content) return null;
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  function writePlan(plan) {
+    ensureDir(orchestrationDir);
+    plan.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return writeFile(planPath, JSON.stringify(plan, null, 2));
+  }
+  function appendEvent(event) {
+    ensureDir(orchestrationDir);
+    const line = JSON.stringify(event) + "\n";
+    try {
+      fs.appendFileSync(eventsPath, line, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function readMailbox() {
+    const content = readFile(mailboxPath);
+    if (!content) return { version: 1, messages: [] };
+    try {
+      return JSON.parse(content);
+    } catch {
+      return { version: 1, messages: [] };
+    }
+  }
+  function writeMailbox(mailbox) {
+    return writeFile(mailboxPath, JSON.stringify(mailbox, null, 2));
+  }
+  function generateMessageId() {
+    return "msg_" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
+  }
+  function listDailyLogs() {
+    try {
+      if (!fs.existsSync(dailyDir)) return [];
+      const files = fs.readdirSync(dailyDir);
+      return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")).sort().reverse();
+    } catch {
+      return [];
+    }
+  }
+  function searchMemory(query) {
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    const knowledge = readFile(path.join(knowledgeDir, "MEMORY.md"));
+    if (knowledge?.toLowerCase().includes(lowerQuery)) {
+      const lines = knowledge.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].toLowerCase().includes(lowerQuery)) {
+          results.push({
+            source: "knowledge/MEMORY.md",
+            line: i + 1,
+            content: lines[i].trim()
+          });
+        }
+      }
+    }
+    const tasks = readFile(tasksPath);
+    if (tasks?.toLowerCase().includes(lowerQuery)) {
+      results.push({ source: "TASKS.json", content: "Match found in tasks file" });
+    }
+    const mailbox = readFile(mailboxPath);
+    if (mailbox?.toLowerCase().includes(lowerQuery)) {
+      results.push({ source: "MAILBOX.json", content: "Match found in mailbox file" });
+    }
+    const dailyLogs = listDailyLogs();
+    for (const date of dailyLogs.slice(0, 7)) {
+      const logContent = readFile(path.join(dailyDir, `${date}.md`));
+      if (logContent?.toLowerCase().includes(lowerQuery)) {
+        const lines = logContent.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].toLowerCase().includes(lowerQuery)) {
+            results.push({
+              source: `daily/${date}.md`,
+              line: i + 1,
+              content: lines[i].trim()
+            });
+          }
+        }
+      }
+    }
+    return results;
+  }
+  const server = new Server(
+    {
+      name: "devsh-memory",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "read_memory",
+        description: 'Read a memory file. Type can be "knowledge", "tasks", or "mailbox".',
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["knowledge", "tasks", "mailbox"],
+              description: "The type of memory to read"
+            }
+          },
+          required: ["type"]
+        }
+      },
+      {
+        name: "list_daily_logs",
+        description: "List available daily log dates (newest first).",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "read_daily_log",
+        description: "Read a specific daily log by date (YYYY-MM-DD format).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            date: {
+              type: "string",
+              description: "The date in YYYY-MM-DD format"
+            }
+          },
+          required: ["date"]
+        }
+      },
+      {
+        name: "search_memory",
+        description: "Search across all memory files for a query string.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The search query"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "send_message",
+        description: 'Send a message to another agent on the same task. Use "*" to broadcast to all agents.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            to: {
+              type: "string",
+              description: 'Recipient agent name (e.g., "claude/opus-4.5") or "*" for broadcast'
+            },
+            message: {
+              type: "string",
+              description: "The message content"
+            },
+            type: {
+              type: "string",
+              enum: ["handoff", "request", "status"],
+              description: "Message type: handoff (work transfer), request (ask to do something), status (progress update)"
+            }
+          },
+          required: ["to", "message"]
+        }
+      },
+      {
+        name: "get_my_messages",
+        description: "Get all messages addressed to this agent (including broadcasts). Returns unread messages first.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            includeRead: {
+              type: "boolean",
+              description: "Include messages already marked as read (default: false)"
+            }
+          }
+        }
+      },
+      {
+        name: "mark_read",
+        description: "Mark a message as read by its ID.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            messageId: {
+              type: "string",
+              description: "The message ID to mark as read"
+            }
+          },
+          required: ["messageId"]
+        }
+      },
+      // Write tools
+      {
+        name: "append_daily_log",
+        description: "Append content to today's daily log. Creates the file if it doesn't exist.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "Content to append to the daily log"
+            }
+          },
+          required: ["content"]
+        }
+      },
+      {
+        name: "update_knowledge",
+        description: "Update a specific priority section in the knowledge file (MEMORY.md). Appends a new entry with today's date.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            section: {
+              type: "string",
+              enum: ["P0", "P1", "P2"],
+              description: "Priority section to update (P0=Core, P1=Active, P2=Reference)"
+            },
+            content: {
+              type: "string",
+              description: "Content to add to the section (will be prefixed with today's date)"
+            }
+          },
+          required: ["section", "content"]
+        }
+      },
+      {
+        name: "add_task",
+        description: "Add a new task to the TASKS.json file.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            subject: {
+              type: "string",
+              description: "Brief title for the task"
+            },
+            description: {
+              type: "string",
+              description: "Detailed description of what needs to be done"
+            }
+          },
+          required: ["subject", "description"]
+        }
+      },
+      {
+        name: "update_task",
+        description: "Update the status of an existing task in TASKS.json.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: {
+              type: "string",
+              description: "The ID of the task to update"
+            },
+            status: {
+              type: "string",
+              enum: ["pending", "in_progress", "completed"],
+              description: "New status for the task"
+            }
+          },
+          required: ["taskId", "status"]
+        }
+      },
+      // Orchestration tools
+      {
+        name: "read_orchestration",
+        description: "Read an orchestration file (PLAN.json, AGENTS.json, or EVENTS.jsonl).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["plan", "agents", "events"],
+              description: "Type of orchestration file to read"
+            }
+          },
+          required: ["type"]
+        }
+      },
+      {
+        name: "append_event",
+        description: "Append an orchestration event to EVENTS.jsonl.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            event: {
+              type: "string",
+              description: "Event type (e.g., agent_spawned, agent_completed, message_sent)"
+            },
+            message: {
+              type: "string",
+              description: "Human-readable message describing the event"
+            },
+            agentName: {
+              type: "string",
+              description: "Agent name associated with the event (optional)"
+            },
+            taskRunId: {
+              type: "string",
+              description: "Task run ID associated with the event (optional)"
+            }
+          },
+          required: ["event", "message"]
+        }
+      },
+      {
+        name: "update_plan_task",
+        description: "Update the status of a task in the orchestration PLAN.json.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: {
+              type: "string",
+              description: "The ID of the orchestration task to update"
+            },
+            status: {
+              type: "string",
+              description: "New status (pending, assigned, running, completed, failed, cancelled)"
+            },
+            result: {
+              type: "string",
+              description: "Result message (for completed tasks)"
+            },
+            errorMessage: {
+              type: "string",
+              description: "Error message (for failed tasks)"
+            }
+          },
+          required: ["taskId", "status"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+      case "read_memory": {
+        const type = args.type;
+        let content = null;
+        if (type === "knowledge") {
+          content = readFile(path.join(knowledgeDir, "MEMORY.md"));
+        } else if (type === "tasks") {
+          content = readFile(tasksPath);
+        } else if (type === "mailbox") {
+          content = readFile(mailboxPath);
+        }
+        return {
+          content: [{ type: "text", text: content ?? `No ${type} content found.` }]
+        };
+      }
+      case "list_daily_logs": {
+        const dates = listDailyLogs();
+        return {
+          content: [{ type: "text", text: dates.length > 0 ? dates.join("\n") : "No daily logs found." }]
+        };
+      }
+      case "read_daily_log": {
+        const date = args.date;
+        const content = readFile(path.join(dailyDir, `${date}.md`));
+        return {
+          content: [{ type: "text", text: content ?? `No log found for ${date}.` }]
+        };
+      }
+      case "search_memory": {
+        const query = args.query;
+        const results = searchMemory(query);
+        if (results.length === 0) {
+          return { content: [{ type: "text", text: `No results found for "${query}".` }] };
+        }
+        const formatted = results.map((r) => `[${r.source}${r.line ? `:${r.line}` : ""}] ${r.content}`).join("\n");
+        return { content: [{ type: "text", text: formatted }] };
+      }
+      case "send_message": {
+        const { to, message, type } = args;
+        const mailbox = readMailbox();
+        const newMessage = {
+          id: generateMessageId(),
+          from: agentName,
+          to,
+          type: type ?? "request",
+          message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          read: false
+        };
+        mailbox.messages.push(newMessage);
+        writeMailbox(mailbox);
+        return { content: [{ type: "text", text: `Message sent successfully. ID: ${newMessage.id}` }] };
+      }
+      case "get_my_messages": {
+        const includeRead = args.includeRead ?? false;
+        const mailbox = readMailbox();
+        const myMessages = mailbox.messages.filter(
+          (m) => m.to === agentName || m.to === "*"
+        );
+        const filtered = includeRead ? myMessages : myMessages.filter((m) => !m.read);
+        if (filtered.length === 0) {
+          return { content: [{ type: "text", text: "No messages for you." }] };
+        }
+        const formatted = filtered.map((m) => `[${m.id}] ${m.type ?? "message"} from ${m.from}: ${m.message}`).join("\n\n");
+        return { content: [{ type: "text", text: formatted }] };
+      }
+      case "mark_read": {
+        const messageId = args.messageId;
+        const mailbox = readMailbox();
+        const message = mailbox.messages.find((m) => m.id === messageId);
+        if (!message) {
+          return { content: [{ type: "text", text: `Message ${messageId} not found.` }] };
+        }
+        message.read = true;
+        writeMailbox(mailbox);
+        return { content: [{ type: "text", text: `Message ${messageId} marked as read.` }] };
+      }
+      // Write tool handlers
+      case "append_daily_log": {
+        const { content } = args;
+        const today = getTodayDateString();
+        ensureDir(dailyDir);
+        const logPath = path.join(dailyDir, `${today}.md`);
+        const existing = readFile(logPath) ?? `# Daily Log: ${today}
+
+> Session-specific observations. Temporary notes go here.
+
+---
+`;
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0];
+        const newContent = existing + `
+- [${timestamp}] ${content}`;
+        if (writeFile(logPath, newContent)) {
+          return { content: [{ type: "text", text: `Appended to daily/${today}.md` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to append to daily log` }] };
+      }
+      case "update_knowledge": {
+        const { section, content } = args;
+        ensureDir(knowledgeDir);
+        const knowledgePath = path.join(knowledgeDir, "MEMORY.md");
+        let existing = readFile(knowledgePath);
+        if (!existing) {
+          existing = `# Project Knowledge
+
+> Curated insights organized by priority. Add date tags for TTL tracking.
+
+## P0 - Core (Never Expires)
+<!-- Fundamental project facts, configuration, invariants -->
+
+## P1 - Active (90-day TTL)
+<!-- Ongoing work context, current strategies, recent decisions -->
+
+## P2 - Reference (30-day TTL)
+<!-- Temporary findings, debug notes, one-off context -->
+
+---
+*Priority guide: P0 = permanent truth, P1 = active context, P2 = temporary reference*
+*Format: - [YYYY-MM-DD] Your insight here*
+`;
+        }
+        const today = getTodayDateString();
+        const newEntry = `- [${today}] ${content}`;
+        const sectionHeaders = {
+          P0: "## P0 - Core (Never Expires)",
+          P1: "## P1 - Active (90-day TTL)",
+          P2: "## P2 - Reference (30-day TTL)"
+        };
+        const header = sectionHeaders[section];
+        const headerIndex = existing.indexOf(header);
+        if (headerIndex === -1) {
+          return { content: [{ type: "text", text: `Section ${section} not found in MEMORY.md` }] };
+        }
+        const afterHeader = existing.slice(headerIndex + header.length);
+        const nextSectionMatch = afterHeader.match(/\n## /);
+        const insertPoint = nextSectionMatch ? headerIndex + header.length + (nextSectionMatch.index ?? afterHeader.length) : existing.length;
+        const commentEndMatch = afterHeader.match(/<!--[^>]*-->\n/);
+        const commentEnd = commentEndMatch ? headerIndex + header.length + (commentEndMatch.index ?? 0) + commentEndMatch[0].length : headerIndex + header.length + 1;
+        const actualInsertPoint = Math.min(commentEnd, insertPoint);
+        const updated = existing.slice(0, actualInsertPoint) + newEntry + "\n" + existing.slice(actualInsertPoint);
+        if (writeFile(knowledgePath, updated)) {
+          return { content: [{ type: "text", text: `Added entry to ${section} section in MEMORY.md` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to update MEMORY.md` }] };
+      }
+      case "add_task": {
+        const { subject, description } = args;
+        const tasks = readTasks();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const newTask = {
+          id: generateTaskId(),
+          subject,
+          description,
+          status: "pending",
+          createdAt: now,
+          updatedAt: now
+        };
+        tasks.tasks.push(newTask);
+        if (writeTasks(tasks)) {
+          return { content: [{ type: "text", text: `Task created with ID: ${newTask.id}` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to create task` }] };
+      }
+      case "update_task": {
+        const { taskId, status } = args;
+        const tasks = readTasks();
+        const task = tasks.tasks.find((t) => t.id === taskId);
+        if (!task) {
+          return { content: [{ type: "text", text: `Task ${taskId} not found` }] };
+        }
+        task.status = status;
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (writeTasks(tasks)) {
+          return { content: [{ type: "text", text: `Task ${taskId} updated to status: ${status}` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to update task` }] };
+      }
+      // Orchestration tool handlers
+      case "read_orchestration": {
+        const type = args.type;
+        let content = null;
+        if (type === "plan") {
+          content = readFile(planPath);
+        } else if (type === "agents") {
+          content = readFile(agentsPath);
+        } else if (type === "events") {
+          content = readFile(eventsPath);
+        }
+        return {
+          content: [{ type: "text", text: content ?? `No ${type} file found in orchestration directory.` }]
+        };
+      }
+      case "append_event": {
+        const { event, message, agentName: agentName2, taskRunId } = args;
+        const eventObj = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          event,
+          message
+        };
+        if (agentName2) eventObj.agentName = agentName2;
+        if (taskRunId) eventObj.taskRunId = taskRunId;
+        if (appendEvent(eventObj)) {
+          return { content: [{ type: "text", text: `Event appended to EVENTS.jsonl` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to append event` }] };
+      }
+      case "update_plan_task": {
+        const { taskId, status, result, errorMessage } = args;
+        const plan = readPlan();
+        if (!plan) {
+          return { content: [{ type: "text", text: `No PLAN.json found in orchestration directory` }] };
+        }
+        const task = plan.tasks.find((t) => t.id === taskId);
+        if (!task) {
+          return { content: [{ type: "text", text: `Task ${taskId} not found in PLAN.json` }] };
+        }
+        task.status = status;
+        if (result !== void 0) task.result = result;
+        if (errorMessage !== void 0) task.errorMessage = errorMessage;
+        if (status === "running" && !task.startedAt) {
+          task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (status === "completed" || status === "failed" || status === "cancelled") {
+          task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (writePlan(plan)) {
+          return { content: [{ type: "text", text: `Plan task ${taskId} updated to status: ${status}` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to update plan task` }] };
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+  });
+  return server;
+}
+async function runServer(config) {
+  const server = createMemoryMcpServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  createMemoryMcpServer,
+  runServer
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import {
+  runServer
+} from "./chunk-PI6DAQTW.js";
+
+// src/cli.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--dir" && args[i + 1]) {
+      result.memoryDir = args[i + 1];
+      i++;
+    } else if (args[i] === "--agent" && args[i + 1]) {
+      result.agentName = args[i + 1];
+      i++;
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      console.log(`
+devsh-memory-mcp - MCP server for devsh/cmux agent memory
+
+Usage:
+  devsh-memory-mcp [options]
+
+Options:
+  --dir <path>      Memory directory (default: /root/lifecycle/memory)
+  --agent <name>    Agent name for messaging (default: from CMUX_AGENT_NAME env)
+  --help, -h        Show this help message
+
+Example Claude Desktop config:
+  {
+    "mcpServers": {
+      "devsh-memory": {
+        "command": "npx",
+        "args": ["devsh-memory-mcp", "--dir", "/path/to/memory"]
+      }
+    }
+  }
+`);
+      process.exit(0);
+    }
+  }
+  return result;
+}
+async function main() {
+  const config = parseArgs();
+  console.error(`[devsh-memory-mcp] Starting server...`);
+  if (config.memoryDir) {
+    console.error(`[devsh-memory-mcp] Memory directory: ${config.memoryDir}`);
+  }
+  if (config.agentName) {
+    console.error(`[devsh-memory-mcp] Agent name: ${config.agentName}`);
+  }
+  await runServer(config);
+}
+main().catch((err) => {
+  console.error("[devsh-memory-mcp] Fatal error:", err);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+/**
+ * cmux Memory MCP Server
+ *
+ * Standalone MCP server that exposes cmux agent memory for external clients
+ * like Claude Desktop and Cursor. Can connect to:
+ * - Local sandbox memory directory
+ * - Remote sandbox via SSH/HTTP
+ */
+
+interface MemoryMcpConfig {
+    memoryDir: string;
+    agentName?: string;
+}
+declare function createMemoryMcpServer(config?: Partial<MemoryMcpConfig>): Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            };
+        };
+    };
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            };
+        };
+    };
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        };
+    };
+}>;
+declare function runServer(config?: Partial<MemoryMcpConfig>): Promise<void>;
+
+export { type MemoryMcpConfig, createMemoryMcpServer, runServer };

package/dist/index.js

@@ -0,0 +1,8 @@
+import {
+  createMemoryMcpServer,
+  runServer
+} from "./chunk-PI6DAQTW.js";
+export {
+  createMemoryMcpServer,
+  runServer
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "devsh-memory-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for devsh/cmux agent memory - enables Claude Desktop and external clients to access sandbox memory",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "devsh-memory-mcp": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "devsh",
+    "cmux",
+    "claude",
+    "memory",
+    "agent",
+    "model-context-protocol",
+    "claude-desktop"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/karlorz/cmux.git",
+    "directory": "packages/cmux-memory-mcp"
+  },
+  "homepage": "https://github.com/karlorz/cmux/tree/main/packages/cmux-memory-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/karlorz/cmux/issues"
+  },
+  "author": "cmux team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}