@agent-wire/terminal 1.7.5 → 1.7.6

package/dist/mcp-server.js

@@ -21,7 +21,7 @@ import {
 // migration window.
 loadDeviceRecord, saveDeviceRecord, deleteDeviceRecord, loadAuthPending, saveAuthPending, deleteAuthPending, getStableDeviceFingerprint, hasAnyLocalIdentityForEmail, acquireIdentityLock, releaseIdentityLock, } from './identity.js';
 import { acquireLock, releaseLock, isWorkerRunning } from './lockfile.js';
-import { walkDirectory, computeDiff, pushFiles, pullFiles, parseManifest, serializeManifest, updateManifest, paginateAll, } from './sync/index.js';
+import { walkDirectory, computeDiff, pushFiles, pullFiles, parseManifest, serializeManifest, updateManifest, paginateAll, generatePreviewJson, } from './sync/index.js';
 import { WIRE_HELP_POINTER } from './help-pointer.js';
 import { pullLocalSubscriptions } from './local-pull.js';
 const SURFACE_REFRESH_TTL_MS = 60_000;
@@ -1591,9 +1591,21 @@ export async function startMcpServer(options) {
         }
     });
     // ── Tool: wire_corpora (split from wire_discover — corpus browser) ──
-    server.tool('wire_corpora', 'Browse source corpora. List all corpora, or list documents within a specific corpus. Filter by visibility. FREE.', {
+    server.tool('wire_corpora', 'Browse or create source corpora. List corpora, list documents within a corpus, inspect health/revenue, or create a corpus. FREE except writes require approval.', {
+        action: z.enum(['list', 'documents', 'create', 'health', 'revenue', 'bulk_ingest']).optional().describe('Action to perform. Defaults to documents when slug is present, otherwise list.'),
         slug: z.string().optional().describe('Corpus slug to browse. Omit to list all corpora.'),
+        title: z.string().optional().describe('Corpus title for create.'),
+        description: z.string().optional().describe('Corpus description for create.'),
+        material_class: z.string().optional().describe('Corpus material class for create.'),
         visibility: z.enum(['public', 'private', 'all']).optional().describe('Filter by visibility (default: public)'),
+        themes: z.array(z.string()).optional().describe('Optional corpus themes for create.'),
+        default_author_share: z.number().optional().describe('Default author revenue share for create.'),
+        default_steward_share: z.number().optional().describe('Default steward revenue share for create.'),
+        split_justification: z.string().optional().describe('Revenue split justification for create.'),
+        provenance_note: z.string().optional().describe('Provenance note for create.'),
+        manifest: z.record(z.unknown()).optional().describe('Optional corpus manifest for create.'),
+        days: z.number().optional().describe('Revenue lookback days for revenue action.'),
+        documents: z.array(z.record(z.unknown())).optional().describe('Documents for bulk_ingest action.'),
         limit: z.number().optional().describe('Max results'),
         offset: z.number().optional().describe('Pagination offset'),
     }, async (params) => {
@@ -1602,13 +1614,54 @@ export async function startMcpServer(options) {
             return { content: [gate], isError: true };
         try {
             let result;
-            if (params.slug) {
-                result = await api.getCorpusDocuments(params.slug, params.limit, params.offset);
-            }
-            else {
-                result = await api.listCorpora();
+            const action = params.action ?? (params.slug ? 'documents' : 'list');
+            switch (action) {
+                case 'list':
+                    result = await api.listCorpora();
+                    break;
+                case 'documents':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for documents action' }], isError: true };
+                    result = await api.getCorpusDocuments(params.slug, params.limit, params.offset);
+                    break;
+                case 'create':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for create action' }], isError: true };
+                    if (!params.title)
+                        return { content: [{ type: 'text', text: 'Error: title is required for create action' }], isError: true };
+                    result = await api.createCorpus({
+                        slug: params.slug,
+                        title: params.title,
+                        description: params.description,
+                        material_class: params.material_class,
+                        visibility: params.visibility === 'all' ? undefined : params.visibility,
+                        themes: params.themes,
+                        default_author_share: params.default_author_share,
+                        default_steward_share: params.default_steward_share,
+                        split_justification: params.split_justification,
+                        provenance_note: params.provenance_note,
+                        manifest: params.manifest,
+                    });
+                    break;
+                case 'health':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for health action' }], isError: true };
+                    result = await api.getCorpusHealth(params.slug);
+                    break;
+                case 'revenue':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for revenue action' }], isError: true };
+                    result = await api.getCorpusRevenue(params.slug, params.days);
+                    break;
+                case 'bulk_ingest':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for bulk_ingest action' }], isError: true };
+                    if (!params.documents)
+                        return { content: [{ type: 'text', text: 'Error: documents is required for bulk_ingest action' }], isError: true };
+                    result = await api.bulkIngestDocuments(params.slug, params.documents);
+                    break;
             }
-            const shaped = shapeCorpora(result, params.slug);
+            const shaped = action === 'list' || action === 'documents' ? shapeCorpora(result, action === 'documents' ? params.slug : undefined) : result;
             return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
         }
         catch (err) {
@@ -1783,6 +1836,7 @@ export async function startMcpServer(options) {
         action: z.enum(['diff', 'push', 'pull', 'preview']).describe('Sync action to perform'),
         publish: z.boolean().optional().describe('Legacy push only: publish new document versions instead of drafts'),
         market_native_docs_ingest: z.enum(['off', 'auto', 'all']).optional().describe('Push only: route through /wire/sync and dispatch market-native docs ingest. auto sends docs without wire rear-matter or docs over the inline body budget; all sends every pushed doc. Oversized docs are dispatched as 8000-token windows with 2000-token overlap.'),
+        include_content: z.boolean().optional().describe('Diff/preview only: include full local file bodies. Defaults false; previews normally return hash + sizeBytes only.'),
     }, async (params) => {
         const gate = await requireConfirmed();
         if (gate)
@@ -1791,6 +1845,7 @@ export async function startMcpServer(options) {
             const { dir, corpus, action } = params;
             const publish = params.publish ?? false;
             const marketNativeDocsIngest = (params.market_native_docs_ingest ?? 'off');
+            const includeContent = params.include_content === true;
             // ── Path traversal protection ──
             if (!isAbsolute(dir)) {
                 return { content: [{ type: 'text', text: 'Error: dir must be an absolute path' }], isError: true };
@@ -1828,7 +1883,7 @@ export async function startMcpServer(options) {
             const remoteDocs = await paginateAll(async (page, pageSize) => {
                 const offset = (page - 1) * pageSize;
                 const result = await api.getCorpusDocuments(corpus, pageSize, offset);
-                return result.documents || [];
+                return result.documents || result.items || [];
             });
             // 4. Compute diff
             const diff = await computeDiff(localFiles, remoteDocs, manifest);
@@ -1843,11 +1898,15 @@ export async function startMcpServer(options) {
                     conflicts: diff.conflicts.length,
                 };
                 const output = {
+                    ...generatePreviewJson({
+                        corpus_slug: corpus,
+                        local_dir: dir,
+                        diff,
+                        summary,
+                    }, { includeContent }),
                     corpus_slug: corpus,
                     local_dir: dir,
                     action,
-                    diff,
-                    summary,
                 };
                 return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
             }
@@ -2200,7 +2259,7 @@ export async function startMcpServer(options) {
     server.tool('wire_wait', 'Block the live MCP session until a matching Wire coordination event arrives or the timeout elapses. Layer 1 uses SSE + cursor replay; durable wire_watch is not included.', {
         triggers: z.array(z.string()).max(20).optional().describe('Event triggers to wait for, e.g. message.unread, task.assigned, task.moved, board.changed, circle.message. Supports prefix wildcards such as message.*. Omit to wait on any message.*, task.*, board.*, or circle.* event addressable to you.'),
         filters: z.record(z.unknown()).optional().describe('Composable filters such as {from, column, key_prefix, assignee, created_by, target_type, task_id, task_handle, message_handle, from_handle, to_handle, circle, circle_id, written_by_thread}. Agent filters accept "me", agent UUID, or pseudo-ID when available. Handle filters match the corresponding event payload field exactly.'),
-        timeout_seconds: z.number().int().min(0).max(1800).optional().describe('Maximum seconds to block. Defaults to 30; max 1800. Use 0 for immediate replay/query behavior.'),
+        timeout_seconds: z.number().int().min(-1).max(86400).optional().describe('Maximum seconds to block. Defaults to 30; max 86400 (24h). Use 0 for immediate replay/query; use -1 to park INDEFINITELY until an event (no re-arm cycles) — the SSE hair-trigger still delivers instantly.'),
         cursor: z.string().optional().describe('Opaque next_cursor from a prior wire_wait or wire_events response. Legacy integer id cursors are accepted. If omitted, wait starts at the current high-water mark.'),
         limit: z.number().int().min(1).max(200).optional().describe('Maximum events to return when triggered. Defaults to 50.'),
     }, async (params) => {
@@ -2289,6 +2348,7 @@ export async function startMcpServer(options) {
         action: z.enum(['supersede', 'propose', 'accept', 'reject']).describe('supersede = direct supersession authorized by target scope, propose = propose supersession (5-credit deposit), accept = approve a proposal, reject = deny a proposal'),
         target_id: z.string().describe('Target contribution UUID (the one being superseded for supersede/propose, or the proposal UUID for accept/reject)'),
         contribution_id: z.string().optional().describe('Your replacement contribution UUID (required for supersede and propose)'),
+        allow_type_change: z.boolean().optional().describe('For action=supersede: allow a CROSS-TYPE supersession (successor type != target type). Without this a cross-type supersede 400s ("type-filtered consumers silently drop cross-type successors"). Pass true only when the type change is deliberate.'),
     }, async (params) => {
         const gate = await requireConfirmed();
         if (gate)
@@ -2312,7 +2372,7 @@ export async function startMcpServer(options) {
                     if (!params.contribution_id) {
                         return { content: [{ type: 'text', text: 'contribution_id is required for supersede' }], isError: true };
                     }
-                    result = await api.executeSupersession(params.target_id, params.contribution_id);
+                    result = await api.executeSupersession(params.target_id, params.contribution_id, params.allow_type_change);
                     break;
                 default:
                     return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };