@adrive/mcp-server 0.3.0

package/dist/api-client.js

@@ -0,0 +1,198 @@
+// MAX_PAGES caps total to prevent unbounded loops; pass cursor explicitly if more needed.
+export async function listAllPages(fetchPage, maxPages = 10) {
+    const all = [];
+    let cursor = null;
+    for (let i = 0; i < maxPages; i++) {
+        const page = await fetchPage(cursor);
+        all.push(...page.items);
+        if (!page.cursor)
+            return all;
+        cursor = page.cursor;
+    }
+    return all;
+}
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    agentPlatform;
+    agentRole;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.apiKey = config.apiKey;
+        this.agentPlatform = config.agentPlatform ?? 'claude-code';
+        this.agentRole = config.agentRole ?? '';
+    }
+    headers() {
+        return {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            'X-Agent-Platform': this.agentPlatform,
+            'X-Agent-Role': this.agentRole,
+        };
+    }
+    async rawFetch(path, init) {
+        const url = `${this.baseUrl}/v1${path}`;
+        return fetch(url, {
+            ...init,
+            headers: { ...this.headers(), ...init.headers },
+        });
+    }
+    async request(method, path, body) {
+        const res = await this.rawFetch(path, {
+            method,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json();
+        if (!res.ok || !json.success) {
+            throw new Error(json.error || `API request failed: ${res.status}`);
+        }
+        return json.data;
+    }
+    async requestPage(method, path, body) {
+        const res = await this.rawFetch(path, {
+            method,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json();
+        if (!res.ok || !json.success) {
+            throw new Error(json.error || `API request failed: ${res.status}`);
+        }
+        return { items: (json.data ?? []), cursor: json.cursor ?? null };
+    }
+    async createWorkspace(name) {
+        return this.request('POST', '/workspaces', { name });
+    }
+    async writeFile(workspaceId, path, content, message) {
+        return this.request('POST', `/workspaces/${workspaceId}/files`, { path, content, message });
+    }
+    async readFile(workspaceId, fileId) {
+        return this.request('GET', `/workspaces/${workspaceId}/files/${fileId}?content=true`);
+    }
+    async listFilesPage(workspaceId, prefix, cursor) {
+        const params = new URLSearchParams();
+        if (prefix)
+            params.set('prefix', prefix);
+        if (cursor)
+            params.set('cursor', cursor);
+        const query = params.toString() ? `?${params.toString()}` : '';
+        return this.requestPage('GET', `/workspaces/${workspaceId}/files${query}`);
+    }
+    async listAllFiles(workspaceId, prefix, maxPages = 10) {
+        return listAllPages((cursor) => this.listFilesPage(workspaceId, prefix, cursor), maxPages);
+    }
+    async deleteFile(workspaceId, fileId) {
+        return this.request('DELETE', `/workspaces/${workspaceId}/files/${fileId}`);
+    }
+    async getVersionsPage(workspaceId, fileId, cursor) {
+        const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : '';
+        return this.requestPage('GET', `/workspaces/${workspaceId}/files/${fileId}/versions${query}`);
+    }
+    async getAllVersions(workspaceId, fileId, maxPages = 10) {
+        return listAllPages((cursor) => this.getVersionsPage(workspaceId, fileId, cursor), maxPages);
+    }
+    async createShareLink(workspaceId, permission, fileId, expiresIn, maxUses, email) {
+        return this.request('POST', `/workspaces/${workspaceId}/share`, {
+            permission,
+            file_id: fileId,
+            expires_in: expiresIn,
+            max_uses: maxUses,
+            email,
+        });
+    }
+    async addComment(workspaceId, fileId, body, authorName, lineStart, lineEnd) {
+        return this.request('POST', `/workspaces/${workspaceId}/files/${fileId}/comments`, {
+            body, author_name: authorName,
+            line_start: lineStart, line_end: lineEnd,
+        });
+    }
+    async getCommentsPage(workspaceId, fileId, cursor) {
+        const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : '';
+        return this.requestPage('GET', `/workspaces/${workspaceId}/files/${fileId}/comments${query}`);
+    }
+    async getAllComments(workspaceId, fileId, maxPages = 10) {
+        return listAllPages((cursor) => this.getCommentsPage(workspaceId, fileId, cursor), maxPages);
+    }
+    async getActivityPage(workspaceId, cursor) {
+        const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : '';
+        return this.requestPage('GET', `/workspaces/${workspaceId}/activity${query}`);
+    }
+    async getAllActivity(workspaceId, maxPages = 10) {
+        return listAllPages((cursor) => this.getActivityPage(workspaceId, cursor), maxPages);
+    }
+    async assignRole(workspaceId, email, permission) {
+        return this.request('POST', `/workspaces/${workspaceId}/roles`, { email, permission });
+    }
+    async getRolesPage(workspaceId, cursor) {
+        const query = cursor ? `?cursor=${encodeURIComponent(cursor)}` : '';
+        return this.requestPage('GET', `/workspaces/${workspaceId}/roles${query}`);
+    }
+    async getAllRoles(workspaceId, maxPages = 10) {
+        return listAllPages((cursor) => this.getRolesPage(workspaceId, cursor), maxPages);
+    }
+    async removeRole(workspaceId, email) {
+        return this.request('DELETE', `/workspaces/${workspaceId}/roles/${encodeURIComponent(email)}`);
+    }
+    async inviteMember(email, role = 'member') {
+        return this.request('POST', '/org/invite', { email, role });
+    }
+    async getOrg(maxPages = 10) {
+        // Org returns agents + members each with its own cursor; loop both to exhaustion.
+        const first = await this.fetchOrgPage(undefined, undefined);
+        const agents = [...first.agents];
+        const members = [...first.members];
+        let agentsCursor = first.agents_cursor ?? undefined;
+        let membersCursor = first.members_cursor ?? undefined;
+        for (let i = 1; i < maxPages && agentsCursor; i++) {
+            const page = await this.fetchOrgPage(agentsCursor, undefined);
+            agents.push(...page.agents);
+            agentsCursor = page.agents_cursor ?? undefined;
+        }
+        for (let i = 1; i < maxPages && membersCursor; i++) {
+            const page = await this.fetchOrgPage(undefined, membersCursor);
+            members.push(...page.members);
+            membersCursor = page.members_cursor ?? undefined;
+        }
+        return {
+            ...first.org,
+            agents,
+            members,
+            usage: first.usage,
+            quota: first.quota,
+        };
+    }
+    async fetchOrgPage(agentsCursor, membersCursor) {
+        const params = new URLSearchParams();
+        if (agentsCursor)
+            params.set('agents_cursor', agentsCursor);
+        if (membersCursor)
+            params.set('members_cursor', membersCursor);
+        const query = params.toString() ? `?${params.toString()}` : '';
+        const res = await this.rawFetch(`/org${query}`, { method: 'GET' });
+        const json = await res.json();
+        if (!res.ok || !json.success || !json.data) {
+            throw new Error(json.error || `API request failed: ${res.status}`);
+        }
+        const { agents, members, usage, quota, ...org } = json.data;
+        return {
+            org,
+            agents,
+            members,
+            usage,
+            quota,
+            agents_cursor: json.agents_cursor ?? null,
+            members_cursor: json.members_cursor ?? null,
+        };
+    }
+    async getBillingPlan() {
+        return this.request('GET', '/billing/plan');
+    }
+    async search(body) {
+        return this.request('POST', '/search', body);
+    }
+    async context(body) {
+        return this.request('POST', '/context', body);
+    }
+    async logRun(body) {
+        return this.request('POST', '/runs', body);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ApiClient } from './api-client.js';
+import { driveWriteSchema, driveWrite } from './tools/drive-write.js';
+import { driveReadSchema, driveRead } from './tools/drive-read.js';
+import { driveListSchema, driveList } from './tools/drive-list.js';
+import { driveShareSchema, driveShare } from './tools/drive-share.js';
+import { driveCommentSchema, driveComment } from './tools/drive-comment.js';
+import { driveFeedbackSchema, driveFeedback } from './tools/drive-feedback.js';
+import { driveActivitySchema, driveActivity } from './tools/drive-activity.js';
+import { driveInviteSchema, driveInvite } from './tools/drive-invite.js';
+import { driveRolesSchema, driveRoles } from './tools/drive-roles.js';
+import { driveOrgSchema, driveOrg } from './tools/drive-org.js';
+import { driveDeleteSchema, driveDelete } from './tools/drive-delete.js';
+import { driveVersionsSchema, driveVersions } from './tools/drive-versions.js';
+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';
+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';
+const AGENT_ROLE = process.env.AGENTDRIVE_AGENT_ROLE || '';
+if (!API_KEY) {
+    console.error('AGENTDRIVE_API_KEY environment variable is required');
+    process.exit(1);
+}
+const client = new ApiClient({
+    baseUrl: BASE_URL,
+    apiKey: API_KEY,
+    agentPlatform: AGENT_PLATFORM,
+    agentRole: AGENT_ROLE,
+});
+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.',
+});
+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));
+server.tool('drive_list', 'List files in a workspace, optionally filtered by path prefix.', driveListSchema, (args) => driveList(client, args));
+server.tool('drive_share', 'Generate a share link for a workspace or specific file. Optionally email-gate the link so only a specific person can access it. Humans open this link to view, comment, or edit files.', driveShareSchema, (args) => driveShare(client, args));
+server.tool('drive_comment', 'Add a comment to a file.', driveCommentSchema, (args) => driveComment(client, args));
+server.tool('drive_feedback', 'Read human comments on a file. Use this to check if humans have left feedback.', driveFeedbackSchema, (args) => driveFeedback(client, args));
+server.tool('drive_activity', 'Get recent activity in a workspace (file writes, comments, shares).', driveActivitySchema, (args) => driveActivity(client, args));
+server.tool('drive_invite', 'Invite a human to your organization by email. They will receive a verification code to join.', driveInviteSchema, (args) => driveInvite(client, args));
+server.tool('drive_roles', 'Manage per-workspace role delegation. Assign, list, or remove access for specific emails (view/comment/edit).', driveRolesSchema, (args) => driveRoles(client, args));
+server.tool('drive_org', 'View your organization details: agents, members, plan, and usage.', driveOrgSchema, (args) => driveOrg(client, args));
+server.tool('drive_delete', 'Delete a file from a workspace.', driveDeleteSchema, (args) => driveDelete(client, args));
+server.tool('drive_versions', 'View version history for a file in a workspace.', driveVersionsSchema, (args) => driveVersions(client, args));
+server.tool('drive_search', "Semantic search across your org's artifacts in AgentDrive. Returns the top-N most relevant files. Use this BEFORE writing similar artifacts to avoid duplication and surface prior context.", driveSearchSchema, (args) => driveSearch(client, args));
+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));
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/dist/tools/drive-activity.d.ts

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

package/dist/tools/drive-activity.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export const driveActivitySchema = {
+    workspace_id: z.string().describe('Workspace ID'),
+};
+export async function driveActivity(client, args) {
+    const events = await client.getAllActivity(args.workspace_id);
+    if (events.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'No recent activity.' }],
+        };
+    }
+    const formatted = events.map(e => {
+        const path = e.target_path ? ` → ${e.target_path}` : '';
+        return `[${e.actor_type}] ${e.actor_id}: ${e.action}${path} — ${e.created_at}`;
+    }).join('\n');
+    return {
+        content: [{
+                type: 'text',
+                text: `Recent activity (${events.length}):\n${formatted}`,
+            }],
+    };
+}

package/dist/tools/drive-comment.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveCommentSchema: {
+    workspace_id: z.ZodString;
+    file_id: z.ZodString;
+    body: z.ZodString;
+    line_start: z.ZodOptional<z.ZodNumber>;
+    line_end: z.ZodOptional<z.ZodNumber>;
+};
+export declare function driveComment(client: ApiClient, args: {
+    workspace_id: string;
+    file_id: string;
+    body: string;
+    line_start?: number;
+    line_end?: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-comment.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const driveCommentSchema = {
+    workspace_id: z.string().describe('Workspace ID'),
+    file_id: z.string().describe('File ID to comment on'),
+    body: z.string().describe('Comment text'),
+    line_start: z.number().optional().describe('Start line number (optional)'),
+    line_end: z.number().optional().describe('End line number (optional)'),
+};
+export async function driveComment(client, args) {
+    const comment = await client.addComment(args.workspace_id, args.file_id, args.body, undefined, args.line_start, args.line_end);
+    return {
+        content: [{
+                type: 'text',
+                text: `Comment added (id: ${comment.id})`,
+            }],
+    };
+}

package/dist/tools/drive-context.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveContextSchema: {
+    task: z.ZodString;
+    workspace_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    include_facts: z.ZodOptional<z.ZodBoolean>;
+};
+export declare function driveContext(client: ApiClient, args: {
+    task: string;
+    workspace_id?: string;
+    limit?: number;
+    include_facts?: boolean;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-context.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export const driveContextSchema = {
+    task: z.string().min(1).max(2000).describe('What you are about to do — used to rank prior artifacts by relevance'),
+    workspace_id: z.string().optional().describe('Scope to a single workspace; omit for org-wide context'),
+    limit: z.number().int().positive().max(20).optional().describe('Max artifacts to return (default 5, max 20)'),
+    include_facts: z.boolean().optional().describe('Include extracted facts alongside artifacts (v1.5+)'),
+};
+export async function driveContext(client, args) {
+    const { artifacts } = await client.context({
+        task: args.task,
+        workspace_id: args.workspace_id,
+        limit: args.limit ?? 5,
+        include_facts: args.include_facts ?? false,
+    });
+    if (artifacts.length === 0) {
+        return { content: [{ type: 'text', text: 'No prior context found.' }] };
+    }
+    const now = Date.now();
+    return {
+        content: [{
+                type: 'text',
+                text: artifacts.map((a) => formatArtifact(a, now)).join('\n\n---\n\n'),
+            }],
+    };
+}
+function formatArtifact(a, now) {
+    const snippet = truncate(a.snippet ?? '', 500);
+    const rel = relativeTime(now - a.created_at);
+    return `${a.path} (by ${a.agent_id}@${a.agent_platform}, ${rel})\n${snippet}`;
+}
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return s.slice(0, n - 1) + '...';
+}
+function relativeTime(ms) {
+    if (ms < 0)
+        return 'just now';
+    const sec = Math.floor(ms / 1000);
+    if (sec < 60)
+        return `${sec}s ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const day = Math.floor(hr / 24);
+    if (day < 30)
+        return `${day}d ago`;
+    const mo = Math.floor(day / 30);
+    if (mo < 12)
+        return `${mo}mo ago`;
+    const yr = Math.floor(mo / 12);
+    return `${yr}y ago`;
+}

package/dist/tools/drive-delete.d.ts

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

package/dist/tools/drive-delete.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const driveDeleteSchema = {
+    workspace_id: z.string().describe('Workspace ID'),
+    file_id: z.string().describe('File ID to delete'),
+};
+export async function driveDelete(client, args) {
+    const result = await client.deleteFile(args.workspace_id, args.file_id);
+    return { content: [{ type: 'text', text: `Deleted file ${args.file_id} from workspace ${args.workspace_id}` }] };
+}

package/dist/tools/drive-feedback.d.ts

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

package/dist/tools/drive-feedback.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const driveFeedbackSchema = {
+    workspace_id: z.string().describe('Workspace ID'),
+    file_id: z.string().describe('File ID to read comments from'),
+};
+export async function driveFeedback(client, args) {
+    const comments = await client.getAllComments(args.workspace_id, args.file_id);
+    if (comments.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'No comments on this file.' }],
+        };
+    }
+    const formatted = comments.map(c => {
+        const author = c.author_name || c.author_id;
+        const lines = c.line_start
+            ? ` (lines ${c.line_start}${c.line_end ? `-${c.line_end}` : ''})`
+            : '';
+        return `[${c.author_type}] ${author}${lines} — ${c.created_at}:\n${c.body}`;
+    }).join('\n\n---\n\n');
+    return {
+        content: [{
+                type: 'text',
+                text: `Comments (${comments.length}):\n\n${formatted}`,
+            }],
+    };
+}

package/dist/tools/drive-invite.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveInviteSchema: {
+    email: z.ZodString;
+    role: z.ZodDefault<z.ZodEnum<["owner", "admin", "member"]>>;
+};
+export declare function driveInvite(client: ApiClient, args: {
+    email: string;
+    role: 'owner' | 'admin' | 'member';
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-invite.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const driveInviteSchema = {
+    email: z.string().describe('Email address of the human to invite to your organization'),
+    role: z.enum(['owner', 'admin', 'member']).default('member').describe('Role in the organization (default: member)'),
+};
+export async function driveInvite(client, args) {
+    const member = await client.inviteMember(args.email, args.role);
+    return {
+        content: [{
+                type: 'text',
+                text: `Invited ${args.email} as ${args.role}. They'll receive an email with a verification code to join the organization.`,
+            }],
+    };
+}

package/dist/tools/drive-list.d.ts

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

package/dist/tools/drive-list.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export const driveListSchema = {
+    workspace_id: z.string().describe('Workspace ID'),
+    prefix: z.string().optional().describe('Path prefix filter (e.g. "notes/")'),
+};
+export async function driveList(client, args) {
+    const files = await client.listAllFiles(args.workspace_id, args.prefix);
+    if (files.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'No files found.' }],
+        };
+    }
+    const listing = files.map(f => `- ${f.path} (v${f.version}, ${f.size} bytes, updated: ${f.updated_at})`).join('\n');
+    return {
+        content: [{
+                type: 'text',
+                text: `Files in workspace:\n${listing}`,
+            }],
+    };
+}

package/dist/tools/drive-log-run.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveLogRunSchema: {
+    task: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<["success", "failure", "partial", "in_progress"]>>;
+    run_id: z.ZodOptional<z.ZodString>;
+    artifacts_referenced: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    artifacts_produced: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare function driveLogRun(client: ApiClient, args: {
+    task: string;
+    status?: 'success' | 'failure' | 'partial' | 'in_progress';
+    run_id?: string;
+    artifacts_referenced?: string[];
+    artifacts_produced?: string[];
+    duration_ms?: number;
+    metadata?: Record<string, unknown>;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-log-run.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export const driveLogRunSchema = {
+    task: z.string().min(1).describe('What the agent did or is doing (free text)'),
+    status: z.enum(['success', 'failure', 'partial', 'in_progress']).optional().describe('Run outcome (default success)'),
+    run_id: z.string().optional().describe('Existing run ID to update; omit to let server allocate'),
+    artifacts_referenced: z.array(z.string()).optional().describe('Paths of artifacts the run read'),
+    artifacts_produced: z.array(z.string()).optional().describe('Paths of artifacts the run wrote'),
+    duration_ms: z.number().int().nonnegative().optional().describe('Wall-clock duration in milliseconds'),
+    metadata: z.record(z.unknown()).optional().describe('Free-form key/value metadata'),
+};
+export async function driveLogRun(client, args) {
+    const result = await client.logRun({
+        task: args.task,
+        status: args.status ?? 'success',
+        run_id: args.run_id,
+        artifacts_referenced: args.artifacts_referenced,
+        artifacts_produced: args.artifacts_produced,
+        duration_ms: args.duration_ms,
+        metadata: args.metadata,
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: `Run logged: ${result.run_id} (${new Date(result.created_at).toISOString()})`,
+            }],
+    };
+}

package/dist/tools/drive-org.d.ts

@@ -0,0 +1,8 @@
+import type { ApiClient } from '../api-client.js';
+export declare const driveOrgSchema: {};
+export declare function driveOrg(client: ApiClient, _args: Record<string, never>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-org.js

@@ -0,0 +1,30 @@
+export const driveOrgSchema = {};
+export async function driveOrg(client, _args) {
+    const org = await client.getOrg();
+    const agentList = org.agents.map(a => `  - ${a.agent_name || a.agent_id}${a.agent_email ? ` (${a.agent_email})` : ''}`).join('\n');
+    const memberList = org.members.map(m => `  - ${m.email} (${m.role})`).join('\n');
+    const text = [
+        `Organization: ${org.name} (${org.id})`,
+        `Plan: ${org.plan}`,
+        '',
+        `Agents (${org.agents.length}/${org.quota.max_agents}):`,
+        agentList || '  (none)',
+        '',
+        `Members (${org.members.length}/${org.quota.max_human_seats}):`,
+        memberList || '  (none)',
+        '',
+        `Usage:`,
+        `  Storage: ${formatBytes(org.usage.storage_bytes)} / ${formatBytes(org.quota.storage_bytes)}`,
+        `  Workspaces: ${org.usage.workspace_count} / ${org.quota.max_workspaces}`,
+    ].join('\n');
+    return { content: [{ type: 'text', text }] };
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}