@ziggs-ai/ziggs-mcp 0.1.1 → 0.1.3

package/README.md

@@ -29,6 +29,12 @@ Full walkthrough: [`examples/claude-code.md`](examples/claude-code.md)
 | Send message | `ziggs_send_message` |
 | Propose + respond | `ziggs_propose_agreement`, `ziggs_respond_to_agreement` |
 
+Automated verify (same MCP path as `claude mcp add` + `npx`):
+
+```bash
+ZIGGS_OPERATOR_KEY=<agent-scoped> node scripts/smoke-ziggs-mcp-z430-e2e.mjs
+```
+
 ---
 
 ## Cursor (local dev / monorepo)
@@ -89,6 +95,16 @@ ZIGGS_OPERATOR_KEY_A=... ZIGGS_AGENT_ID_A=... \
 ZIGGS_OPERATOR_KEY_B=... ZIGGS_AGENT_ID_B=... \
 ZIGGS_SMOKE_CHAT_ID=... \
   node scripts/smoke-ziggs-mcp-context.mjs
+
+# ZIG-433 tools-only (npx trust tools after publish)
+ZIGGS_OPERATOR_KEY=<agent-scoped> node scripts/smoke-ziggs-mcp-z433-e2e.mjs --tools-only
+
+# ZIG-433 full two-org (delegate → approval → from-now read → revoke)
+ZIGGS_OPERATOR_KEY_A=... ZIGGS_AGENT_ID_A=... \
+ZIGGS_OPERATOR_KEY_B=... ZIGGS_AGENT_ID_B=... \
+ZIGGS_APPROVER_OPERATOR_KEY=... ZIGGS_APPROVER_USER_ID=... \
+ZIGGS_SMOKE_CHAT_ID=... \
+  node scripts/smoke-ziggs-mcp-z433-e2e.mjs
 ```
 
 ---
@@ -101,6 +117,11 @@ ZIGGS_SMOKE_CHAT_ID=... \
 | `ziggs_read_context` | `GET /context/read/:type` |
 | `ziggs_record_artifact` | `POST /artifacts` |
 | `ziggs_list_artifacts` | `GET /artifacts` |
+| `ziggs_search_agents` | Agent search (ZIG-433) |
+| `ziggs_list_my_grants` | `GET /context/grants` |
+| `ziggs_issue_grant` | Chat admission or `POST /context/grants` |
+| `ziggs_delegate_grant` | `POST /context/grants/:id/delegate` |
+| `ziggs_revoke_grant` | `DELETE /context/grants/:id` |
 | `ziggs_smoke_impersonation` | Smoke step 1 |
 | `ziggs_get_scope` | `GET /scope?via=` |
 | `ziggs_list_my_agreements` | `GET /agreements?scope=mine` |
@@ -131,6 +152,10 @@ Logs must use **stderr** only (stdio MCP transport).
 2. Tag `ziggs-mcp-v*` → CI publishes `@ziggs-ai/ziggs-mcp`.
 
 ```bash
-git tag api-client-v0.1.5 && git push origin api-client-v0.1.5
-git tag ziggs-mcp-v0.1.0 && git push origin ziggs-mcp-v0.1.0
+git tag api-client-v0.1.8 && git push origin api-client-v0.1.8
+git tag ziggs-mcp-v0.1.3 && git push origin ziggs-mcp-v0.1.3
 ```
+
+CI publishes on tag push. Push **api-client tag first**, then ziggs-mcp.
+
+npm `--provenance` is not used: npm only supports provenance when the GitHub source repo is **public** (agentplus is private → 422).

package/dist/tools.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { getAgreement, getMyAgreements, listMyChats, openConversation, proposeDirectTo, respondToAgreement, ScopeClient, MessagesClient, sendChatMessage, ContextDiscoveryClient, ContextReadClient, ArtifactsClient, getBackendUrl, } from '@ziggs-ai/api-client';
+import { registerTrustTools } from './trustTools.js';
 function textResult(data) {
     return {
         content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
@@ -303,4 +304,5 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
+    registerTrustTools(server, creds);
 }

package/dist/trustTools.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Creds } from '@ziggs-ai/api-client';
+/** ZIG-433 — agent search + context grant management through MCP. */
+export declare function registerTrustTools(server: McpServer, creds: Creds): void;

package/dist/trustTools.js

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import { AgentSearchClient, ContextGrantsClient, addChatMember, } from '@ziggs-ai/api-client';
+function textResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+}
+function toolError(message) {
+    return {
+        content: [{ type: 'text', text: message }],
+        isError: true,
+    };
+}
+const grantScopeKindSchema = z.enum(['chat', 'agreement', 'org']);
+const contextTemporalSchema = z.enum(['from-now', 'from-start']);
+/** ZIG-433 — agent search + context grant management through MCP. */
+export function registerTrustTools(server, creds) {
+    server.tool('ziggs_search_agents', 'Search published agents by query (AgentSearchClient). Use returned agentId in grant/issue tools — do not guess ids.', {
+        query: z.string().describe('Natural language or keyword search'),
+        limit: z.number().optional().describe('Max results (default server-side)'),
+        minScore: z.number().optional().describe('Minimum match score filter'),
+    }, async ({ query, limit, minScore }) => {
+        try {
+            const client = new AgentSearchClient(creds.operatorKey, creds.agentId);
+            const result = await client.searchAgents(query, { limit, minScore });
+            if (!result.success) {
+                return toolError(result.error ?? result.message ?? 'search failed');
+            }
+            return textResult({
+                count: result.agents?.length ?? 0,
+                agents: result.agents ?? [],
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_list_my_grants', 'List context grants held by the delegate agent (GET /context/grants). Returns grantId, scope, temporal, watermarkAt, expiresAt — no content.', {
+        holderId: z
+            .string()
+            .optional()
+            .describe('Admin only: list grants for another agent id'),
+    }, async ({ holderId }) => {
+        try {
+            const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
+            const grants = await client.listGrants(holderId);
+            return textResult({ count: grants.length, grants });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_issue_grant', 'Issue bounded context access. Chat scope: admits agent via POST /chats/:id/members (agent-invite → pending_approval until humans consent). Agreement/org scope: POST /context/grants (requires context:admin on operator key). Defaults: from-now, narrow scope.', {
+        holderId: z.string().describe('Bare agent id receiving the grant'),
+        scopeKind: grantScopeKindSchema,
+        scopeId: z.string().describe('chatId, agreementId, or orgId'),
+        temporal: contextTemporalSchema
+            .optional()
+            .describe('from-now (default) or from-start (approval-gated on chat)'),
+        expiresAt: z
+            .string()
+            .optional()
+            .nullable()
+            .describe('ISO-8601 expiry; omit for platform default TTL'),
+    }, async ({ holderId, scopeKind, scopeId, temporal, expiresAt }) => {
+        const resolvedTemporal = temporal ?? 'from-now';
+        try {
+            if (scopeKind === 'chat') {
+                const result = await addChatMember({
+                    chatId: scopeId,
+                    memberId: holderId,
+                    memberType: 'agent',
+                    temporal: resolvedTemporal,
+                }, creds);
+                if ('status' in result && result.status === 'pending') {
+                    return textResult({
+                        status: 'pending_approval',
+                        message: 'Human approval required before the grant is issued (ZIG-426). Surface this to the user — do not treat as success.',
+                        scope: { kind: 'chat', id: scopeId },
+                        holderId,
+                        temporal: resolvedTemporal,
+                        pendingAdmission: result.pendingAdmission,
+                    });
+                }
+                return textResult({
+                    status: 'granted',
+                    scope: { kind: 'chat', id: scopeId },
+                    holderId,
+                    temporal: resolvedTemporal,
+                    bounds: {
+                        temporal: resolvedTemporal,
+                        note: 'from-now: readable content starts at grant watermark; from-start requires unanimous approval',
+                    },
+                    chat: 'chat' in result ? result.chat : undefined,
+                });
+            }
+            const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
+            const grant = await client.issueGrant({
+                holderId,
+                scope: { kind: scopeKind, id: scopeId },
+                temporal: resolvedTemporal,
+                expiresAt,
+            });
+            return textResult({
+                status: 'granted',
+                grant,
+                bounds: {
+                    temporal: grant.temporal,
+                    watermarkAt: grant.watermarkAt,
+                    expiresAt: grant.expiresAt,
+                },
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_delegate_grant', 'Delegate a narrower child grant from one you hold (POST /context/grants/:id/delegate). Delegation only narrows scope/expiry/temporal — never broadens.', {
+        parentGrantId: z.string(),
+        holderId: z.string().describe('Agent receiving the delegated grant'),
+        scopeKind: grantScopeKindSchema,
+        scopeId: z.string(),
+        temporal: contextTemporalSchema.describe('from-now or from-start (must be same-or-narrower)'),
+        expiresAt: z.string().optional().nullable(),
+        watermarkAt: z
+            .string()
+            .optional()
+            .describe('from-now watermark ISO-8601 (optional; server may default)'),
+    }, async ({ parentGrantId, holderId, scopeKind, scopeId, temporal, expiresAt, watermarkAt, }) => {
+        try {
+            const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
+            const grant = await client.delegateGrant(parentGrantId, {
+                holderId,
+                scope: { kind: scopeKind, id: scopeId },
+                temporal,
+                expiresAt,
+                watermarkAt,
+            });
+            return textResult({
+                status: 'delegated',
+                parentGrantId,
+                grant,
+                bounds: {
+                    temporal: grant.temporal,
+                    watermarkAt: grant.watermarkAt,
+                    expiresAt: grant.expiresAt,
+                },
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_revoke_grant', 'Revoke a context grant and its descendants (DELETE /context/grants/:id). Requires context:admin on the operator key.', {
+        grantId: z.string(),
+    }, async ({ grantId }) => {
+        try {
+            const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
+            const result = await client.revokeGrant(grantId);
+            return textResult({ grantId, ...result });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+}

package/examples/claude-code.md

@@ -37,7 +37,14 @@ Ask Claude to call tools in order:
 2. `ziggs_send_message` (chat you belong to)
 3. `ziggs_propose_agreement` + `ziggs_respond_to_agreement` (optional)
 
-Paste the session transcript in the PR when verifying ZIG-430.
+Paste the session transcript in the PR when verifying ZIG-430, or run:
+
+```bash
+cd agentplus
+ZIGGS_OPERATOR_KEY=<agent-scoped> node scripts/smoke-ziggs-mcp-z430-e2e.mjs
+```
+
+(Same MCP stdio path as `claude mcp add` + `npx -y @ziggs-ai/ziggs-mcp`.)
 
 ## Fleet key alternative
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/ziggs-mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "MCP server for Claude Code, Cursor, and other MCP hosts — act as your Ziggs delegate agent",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "^0.1.6",
+    "@ziggs-ai/api-client": "^0.1.8",
     "dotenv": "^16.6.1",
     "zod": "^3.24.2"
   },