@adrive/mcp-server 0.3.0 → 0.4.0

package/dist/api-client.d.ts

@@ -233,5 +233,44 @@ export declare class ApiClient {
         run_id: string;
         created_at: number;
     }>;
+    sandboxClone(workspaceId: string, body: {
+        url: string;
+        branch?: string;
+        depth?: number;
+    }): Promise<{
+        workspace_id: string;
+        repo_url?: string;
+        branch?: string;
+        head_sha?: string;
+        last_active_at?: number;
+    }>;
+    sandboxExec(workspaceId: string, body: {
+        cmd: string;
+        cwd?: string;
+        timeout_ms?: number;
+    }): Promise<{
+        exit_code: number;
+        stdout: string;
+        stderr: string;
+        duration_ms: number;
+        truncated: boolean;
+    }>;
+    sandboxRead(workspaceId: string, path: string): Promise<{
+        content: string;
+        size: number;
+        truncated: boolean;
+    }>;
+    sandboxCommit(workspaceId: string, body: {
+        message: string;
+        author?: {
+            name: string;
+            email: string;
+        };
+    }): Promise<{
+        commit_sha: string;
+        branch: string;
+        files_changed: number;
+        artifact_path: string;
+    }>;
 }
 export {};

package/dist/api-client.js

@@ -195,4 +195,18 @@ export class ApiClient {
     async logRun(body) {
         return this.request('POST', '/runs', body);
     }
+    // --- Sandbox (Wave 5 Stream D) ---
+    async sandboxClone(workspaceId, body) {
+        return this.request('POST', `/workspaces/${workspaceId}/sandbox/clone`, body);
+    }
+    async sandboxExec(workspaceId, body) {
+        return this.request('POST', `/workspaces/${workspaceId}/sandbox/exec`, body);
+    }
+    async sandboxRead(workspaceId, path) {
+        const cleaned = path.startsWith('/') ? path : `/${path}`;
+        return this.request('GET', `/workspaces/${workspaceId}/sandbox/files${cleaned}`);
+    }
+    async sandboxCommit(workspaceId, body) {
+        return this.request('POST', `/workspaces/${workspaceId}/sandbox/commit`, body);
+    }
 }

package/dist/index.js

@@ -18,6 +18,10 @@ import { driveSearchSchema, driveSearch } from './tools/drive-search.js';
 import { driveRecallSchema, driveRecall } from './tools/drive-recall.js';
 import { driveLogRunSchema, driveLogRun } from './tools/drive-log-run.js';
 import { driveContextSchema, driveContext } from './tools/drive-context.js';
+import { driveSandboxCloneSchema, driveSandboxClone } from './tools/drive-sandbox-clone.js';
+import { driveSandboxExecSchema, driveSandboxExec } from './tools/drive-sandbox-exec.js';
+import { driveSandboxReadSchema, driveSandboxRead } from './tools/drive-sandbox-read.js';
+import { driveSandboxCommitSchema, driveSandboxCommit } from './tools/drive-sandbox-commit.js';
 const BASE_URL = process.env.AGENTDRIVE_API_URL || 'https://app.agentdrive.sh';
 const API_KEY = process.env.AGENTDRIVE_API_KEY;
 const AGENT_PLATFORM = process.env.AGENTDRIVE_AGENT_PLATFORM || 'claude-code';
@@ -34,8 +38,8 @@ const client = new ApiClient({
 });
 const server = new McpServer({
     name: 'agentdrive',
-    version: '0.3.0',
-    description: 'AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, and cross-platform memory.',
+    version: '0.4.0',
+    description: 'AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, cross-platform memory, and per-workspace Linux sandbox with git worktree.',
 });
 server.tool('drive_write', 'Write a markdown file to a workspace. Creates or updates the file with automatic versioning.', driveWriteSchema, (args) => driveWrite(client, args));
 server.tool('drive_read', 'Read a file\'s content from a workspace.', driveReadSchema, (args) => driveRead(client, args));
@@ -53,6 +57,10 @@ server.tool('drive_search', "Semantic search across your org's artifacts in Agen
 server.tool('drive_recall', 'Recall persistent facts and preferences your agents have written. In v1 this returns semantic search results across artifacts; v1.5 will narrow to auto-extracted facts (preferences, decisions, key entities).', driveRecallSchema, (args) => driveRecall(client, args));
 server.tool('drive_log_run', "Log an agent run to AgentDrive's provenance store. Captures task, status, referenced/produced artifacts, and cross-platform identity (which agent on which tool). Used for retrospective context retrieval and team-wide audit.", driveLogRunSchema, (args) => driveLogRun(client, args));
 server.tool('drive_context', 'Auto-pull the most relevant artifacts from prior agent sessions for the task you are about to do. Combines semantic relevance with recency. Call this at the START of any non-trivial task to ground the agent in prior context — replaces manual copy-paste of artifacts between sessions.', driveContextSchema, (args) => driveContext(client, args));
+server.tool('drive_sandbox_clone', 'Clone a git repo into a per-workspace Linux sandbox. The sandbox persists across MCP sessions for the workspace. Use this to set up a real dev environment your other agents can also drive.', driveSandboxCloneSchema, (args) => driveSandboxClone(client, args));
+server.tool('drive_sandbox_exec', 'Run a shell command inside the per-workspace Linux sandbox. Captures stdout/stderr (64KB cap), exit code, and duration. Use for `npm install`, running tests, file ops — any real dev workflow.', driveSandboxExecSchema, (args) => driveSandboxExec(client, args));
+server.tool('drive_sandbox_read', 'Read a file from the per-workspace sandbox filesystem (e.g., generated build artifacts, test output, log files).', driveSandboxReadSchema, (args) => driveSandboxRead(client, args));
+server.tool('drive_sandbox_commit', 'Stage + commit the current sandbox worktree. The commit surfaces as an AgentDrive artifact at commits/<sha>.json with cross-agent provenance — other agents on other platforms can see who shipped what.', driveSandboxCommitSchema, (args) => driveSandboxCommit(client, args));
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/drive-sandbox-clone.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveSandboxCloneSchema: {
+    workspace_id: z.ZodString;
+    url: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    depth: z.ZodOptional<z.ZodNumber>;
+};
+export declare function driveSandboxClone(client: ApiClient, args: {
+    workspace_id: string;
+    url: string;
+    branch?: string;
+    depth?: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-sandbox-clone.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export const driveSandboxCloneSchema = {
+    workspace_id: z.string().describe('Workspace to clone into. The sandbox persists across MCP sessions per workspace.'),
+    url: z.string().url().describe('Git repository URL to clone'),
+    branch: z.string().optional().describe('Branch to check out (default: repo default)'),
+    depth: z.number().int().positive().max(50).optional().describe('Shallow clone depth (default: full clone)'),
+};
+export async function driveSandboxClone(client, args) {
+    const state = await client.sandboxClone(args.workspace_id, {
+        url: args.url,
+        branch: args.branch,
+        depth: args.depth,
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: `Cloned ${state.repo_url}${state.branch ? '@' + state.branch : ''} into workspace ${state.workspace_id}.`,
+            }],
+    };
+}

package/dist/tools/drive-sandbox-commit.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveSandboxCommitSchema: {
+    workspace_id: z.ZodString;
+    message: z.ZodString;
+    author_name: z.ZodOptional<z.ZodString>;
+    author_email: z.ZodOptional<z.ZodString>;
+};
+export declare function driveSandboxCommit(client: ApiClient, args: {
+    workspace_id: string;
+    message: string;
+    author_name?: string;
+    author_email?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-sandbox-commit.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const driveSandboxCommitSchema = {
+    workspace_id: z.string().describe('Workspace whose sandbox to commit'),
+    message: z.string().min(1).max(500).describe('Commit message'),
+    author_name: z.string().optional().describe('Override git author name (default: agent identity)'),
+    author_email: z.string().email().optional().describe('Override git author email (default: agent identity)'),
+};
+export async function driveSandboxCommit(client, args) {
+    const author = args.author_name && args.author_email
+        ? { name: args.author_name, email: args.author_email }
+        : undefined;
+    const result = await client.sandboxCommit(args.workspace_id, {
+        message: args.message,
+        author,
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: `Committed ${result.commit_sha.slice(0, 8)} on ${result.branch} ` +
+                    `(${result.files_changed} file${result.files_changed === 1 ? '' : 's'} changed). ` +
+                    `Surfaced as AgentDrive artifact at ${result.artifact_path}.`,
+            }],
+    };
+}

package/dist/tools/drive-sandbox-exec.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveSandboxExecSchema: {
+    workspace_id: z.ZodString;
+    cmd: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+};
+export declare function driveSandboxExec(client: ApiClient, args: {
+    workspace_id: string;
+    cmd: string;
+    cwd?: string;
+    timeout_ms?: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-sandbox-exec.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const driveSandboxExecSchema = {
+    workspace_id: z.string().describe('Workspace whose sandbox to run in'),
+    cmd: z.string().min(1).max(2048).describe('Shell command to run inside the per-workspace Linux sandbox'),
+    cwd: z.string().optional().describe('Working directory (default: workspace root)'),
+    timeout_ms: z.number().int().positive().max(60_000).optional().describe('Max runtime in ms (default 30000, hard cap 60000)'),
+};
+export async function driveSandboxExec(client, args) {
+    const result = await client.sandboxExec(args.workspace_id, {
+        cmd: args.cmd,
+        cwd: args.cwd,
+        timeout_ms: args.timeout_ms,
+    });
+    const header = `exit=${result.exit_code} duration=${result.duration_ms}ms${result.truncated ? ' [output truncated to 64KB]' : ''}`;
+    const stdoutBlock = result.stdout ? `\n--- stdout ---\n${result.stdout}` : '';
+    const stderrBlock = result.stderr ? `\n--- stderr ---\n${result.stderr}` : '';
+    return {
+        content: [{
+                type: 'text',
+                text: `${header}${stdoutBlock}${stderrBlock}`,
+            }],
+    };
+}

package/dist/tools/drive-sandbox-read.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveSandboxReadSchema: {
+    workspace_id: z.ZodString;
+    path: z.ZodString;
+};
+export declare function driveSandboxRead(client: ApiClient, args: {
+    workspace_id: string;
+    path: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-sandbox-read.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const driveSandboxReadSchema = {
+    workspace_id: z.string().describe('Workspace whose sandbox to read from'),
+    path: z.string().describe('Path inside the sandbox (e.g., src/index.ts or /tmp/build.log)'),
+};
+export async function driveSandboxRead(client, args) {
+    const file = await client.sandboxRead(args.workspace_id, args.path);
+    const note = file.truncated ? `\n\n[content truncated; total ${file.size} bytes]` : '';
+    return {
+        content: [{
+                type: 'text',
+                text: `${args.path} (${file.size} bytes)\n\n${file.content}${note}`,
+            }],
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adrive/mcp-server",
-  "version": "0.3.0",
-  "description": "MCP server for AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, and cross-platform memory.",
+  "version": "0.4.0",
+  "description": "MCP server for AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, cross-platform memory, and per-workspace agent sandboxing.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {