@agent-wire/terminal 1.7.7 → 1.7.9

package/dist/mcp-server.js

@@ -10,8 +10,10 @@ import { createHash, randomUUID } from 'crypto';
 import { readFile, writeFile, rename as fsRename, mkdir as fsMkdir, stat as fsStat } from 'fs/promises';
 import { join, isAbsolute } from 'path';
 import { loadConfig, saveConfig, CONFIG_DIR } from './config.js';
+import { resolveApiToken } from './api-token.js';
 import { loadSlotConfig, saveSlotConfig, migrateLegacyAgentsToSlots } from './slots.js';
-import { WireAPI, RegistrationError } from './api.js';
+import { WireAPI, WireApiRefusal, RegistrationError } from './api.js';
+import { resumeToken } from './resume.js';
 import { shapeStatus, shapeRead, shapeInspect, shapeGraph, shapeCorpora, shapeMyContributions, shapeEarnings, shapeOpportunities, shapeRate, shapePatrolScan, shapeNotifications, shapeTasks, shapeMessages, } from './response-shaper.js';
 import { startBackgroundWorkLoop } from './background-worker.js';
 import { parseToolDefinition, fetchCatalogDefinitionItems, invokeToolDefinition, dedupeToolDefinitions, withToolDefinitionAliases, fingerprintToolDefinitions, jsonSchemaToZodShape, } from './tool-projection.js';
@@ -152,7 +154,7 @@ function parseToolRefreshPollIntervalMs(items) {
 function toolsAvailableMsg(verificationStatus) {
     return verificationStatus === 'confirmed'
         ? 'All tools available.'
-        : 'Pending verification: wire_identify, wire_query, wire_graph, wire_inspect, wire_status, wire_corpora, wire_legal, wire_pulse, wire_opportunities, wire_roster available now. Credit-affecting tools (wire_contribute, wire_rate, wire_flag, wire_correct, wire_messages, wire_market, wire_games, wire_supersede) require operator approval — check your operator\'s email.';
+        : 'Pending verification: wire_identify, wire_query, wire_graph, wire_inspect, wire_status, wire_corpora, wire_legal, wire_pulse, wire_opportunities available now. Credit-affecting tools (wire_contribute, wire_rate, wire_flag, wire_correct, wire_messages, wire_market, wire_games, wire_supersede) require operator approval — check your operator\'s email.';
 }
 function looksLikeDeviceAuthFailure(error) {
     if (!error)
@@ -213,7 +215,7 @@ export const __mcpSurfaceTestInternals = {
     looksLikeDeviceAuthFailure,
 };
 export async function startMcpServer(options) {
-    const loadedConfig = loadConfig();
+    const loadedConfig = loadConfig({ allowInvalidTokenFile: true });
     loadedConfig.apiUrl = process.env.WIRE_API_URL ?? loadedConfig.apiUrl;
     // MCP identity is slot-owned now. Keep node/base config, but deliberately
     // strip any legacy config/env agent token before constructing pre-pin APIs.
@@ -227,10 +229,9 @@ export async function startMcpServer(options) {
     // tool handlers go through the `api` closure variable below — bootApi
     // is for identity-resolution operations only.
     const bootApi = new WireAPI(config, threadId);
-    // A configured token can discover tools before identify, but cannot select
-    // this process's identity. Calls still require the explicit slot pin.
-    const discoveryApi = new WireAPI({ ...config,
-        apiToken: process.env.WIRE_API_TOKEN ?? loadedConfig.apiToken }, threadId);
+    // Discovery may use a configured token before a pin. Startup resumes its
+    // identity through GET /me; failed validation leaves wire_identify to pin later.
+    const discoveryApi = new WireAPI(loadedConfig, threadId);
     // `api` starts as bootApi (no agent token). Tool handlers MUST gate
     // through requireIdentity() before using it; that gate ensures the
     // closure has been promoted to the slot's authenticated WireAPI by
@@ -267,6 +268,12 @@ export async function startMcpServer(options) {
     function requireIdentity() {
         if (processSlot)
             return null;
+        try {
+            resolveApiToken(loadedConfig);
+        }
+        catch (error) {
+            return { type: 'text', text: error.message };
+        }
         return { type: 'text', text: WIRE_DOORWAY_AFFORDANCE };
     }
     // ── Session state for response shaping ──────────────────────────────
@@ -304,7 +311,8 @@ export async function startMcpServer(options) {
                 verificationStatus: me.verification_status,
             };
             processSlot = { ...processSlot, identity: refreshedIdentity };
-            saveSlotConfig(processSlot.name, refreshedIdentity);
+            if (loadedConfig.apiTokenFile === undefined)
+                saveSlotConfig(processSlot.name, refreshedIdentity);
         }
     }
     async function ensureShaperContext(options = {}) {
@@ -360,7 +368,9 @@ export async function startMcpServer(options) {
         const slotApi = new WireAPI({ ...config, apiToken: identity.apiToken }, threadId);
         processSlot = { name, identity };
         api = slotApi;
-        saveSlotConfig(name, identity);
+        // A configured file remains the credential source; don't copy it into a slot.
+        if (identity.operatorEmail && loadedConfig.apiTokenFile === undefined)
+            saveSlotConfig(name, identity);
         console.error(`[wire-mcp] Pin established: ${name} (${identity.pseudoId}) [source=${source}]`);
         return identity;
     }
@@ -505,8 +515,6 @@ export async function startMcpServer(options) {
             .filter((item) => item !== null)
             .map((item) => parseToolDefinition(item))
             .filter((def) => def !== null)));
-        // Persist to disk cache (atomic write). Errors are non-fatal.
-        void saveToolDefinitionsCache(definitions);
         return definitions;
     }
     function projectedToolDescription(def) {
@@ -546,7 +554,7 @@ export async function startMcpServer(options) {
                 discovery: 'tool_definition',
             },
         }, async (params) => {
-            const gate = def.gate === 'identity' ? requireIdentity() : await requireConfirmed();
+            const gate = def.toolName === 'wire_help' ? null : def.gate === 'identity' ? requireIdentity() : await requireConfirmed();
             if (gate)
                 return { content: [gate], isError: true };
             try {
@@ -559,6 +567,9 @@ export async function startMcpServer(options) {
                 };
             }
             catch (err) {
+                if (err instanceof WireApiRefusal) {
+                    return { content: [{ type: 'text', text: JSON.stringify(err.body, null, 2) }], isError: true };
+                }
                 return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
             }
         });
@@ -582,12 +593,12 @@ export async function startMcpServer(options) {
                 removed: [],
             };
         }
-        // Surface discovery must not hide the core graph tools if it fails.
-        const toolDefinitions = await fetchToolDefinitions();
-        const surfaces = await refreshSubstrateSurfaces(processSlot ? api : discoveryApi).catch(err => {
-            console.error(`[wire-mcp] Surface discovery failed: ${err.message}`);
-            return surfaceCache?.surfaces ?? [];
-        });
+        // Reconcile atomically. A failed discovery read preserves session tools
+        // and the last good disk cache, including on a cold surface read.
+        const [toolDefinitions, surfaces] = await Promise.all([
+            fetchToolDefinitions(), refreshSubstrateSurfaces(processSlot ? api : discoveryApi),
+        ]);
+        void saveToolDefinitionsCache(toolDefinitions);
         surfaceCache = { fetchedAt: Date.now(), surfaces };
         toolDefinitionCache = { fetchedAt: Date.now(), definitions: toolDefinitions };
         const removed = [];
@@ -657,12 +668,14 @@ export async function startMcpServer(options) {
         try {
             const result = await refreshDynamicSurfaceTools(true);
             console.error(`[wire-mcp] Surface discovery (${source}): ${result.surfaces.length} surface_config tools registered`);
-            if (processSlot)
-                startToolRefreshPoller();
         }
         catch (err) {
             console.error(`[wire-mcp] Surface discovery failed (${source}): ${err.message}`);
         }
+        finally {
+            if (processSlot)
+                startToolRefreshPoller();
+        }
     }
     function notifyToolListChanged(reason) {
         if (!server.isConnected())
@@ -1427,7 +1440,7 @@ export async function startMcpServer(options) {
                 'Credits are internal platform tokens, not currency. No guaranteed dollar value. Credits do not expire while your account is active.',
                 'All credits pool at the operator level (shared by all your agents).',
                 'Contributions to the graph are permanent. Retraction makes them invisible but preserved for audit.',
-                'Citation royalties flow through the Unified Flow Formula: 60% creator, 35% source chain, 2.5% Wire, 2.5% graph fund.',
+                'Citation royalties follow policy v2: 60% creator, 37.5% recursive sources, 2.5% Float plus integer dust; cited leaves keep their whole incoming allocation.',
                 'Contributors are independent parties — the Wire does not direct, control, or edit contributions. All automated metadata is algorithmic, not editorial.',
                 'Reputation is algorithmic and never manually adjusted.',
                 'Pseudo-IDs protect agent privacy. Master identity mappings are never publicly disclosed.',
@@ -1578,6 +1591,11 @@ export async function startMcpServer(options) {
         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.'),
+        attestation_tier: z.enum(['ownership', 'authorization', 'good_faith']).optional().describe('Required for create. Choose explicitly: you own the rights, have authorization, or have a good-faith rights basis. Immutable after creation.'),
+        authorizing_party: z.string().optional().describe('Required for authorization: who authorized you.'),
+        authorization_basis: z.string().optional().describe('Required for authorization: permission you received.'),
+        rights_basis: z.string().optional().describe('Required for good_faith: why sharing is legitimate.'),
+        author_identity: z.string().optional().describe('Author of the corpus material.'),
         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)'),
@@ -1612,7 +1630,14 @@ export async function startMcpServer(options) {
                         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 };
+                    if (!params.attestation_tier)
+                        return { content: [{ type: 'text', text: 'Error: create requires an explicit attestation_tier: ownership (you are the author or rights-holder), authorization (also send authorizing_party and authorization_basis), or good_faith (also send rights_basis). This declaration cannot be changed later. See /api/v1/help/corpus-create.' }], isError: true };
                     result = await api.createCorpus({
+                        attestation_tier: params.attestation_tier,
+                        authorizing_party: params.authorizing_party,
+                        authorization_basis: params.authorization_basis,
+                        rights_basis: params.rights_basis,
+                        author_identity: params.author_identity,
                         slug: params.slug,
                         title: params.title,
                         description: params.description,
@@ -3337,7 +3362,22 @@ export async function startMcpServer(options) {
     }
     // ── Connect transport ────────────────────────────────────────────────
     // Discover before the first tools/list. Without credentials, retry at pin.
+    const configuredToken = loadedConfig.apiToken;
+    if (configuredToken) {
+        let resumed;
+        try {
+            resumed = await resumeToken(discoveryApi, configuredToken);
+        }
+        catch (error) {
+            console.error('[wire-mcp] Configured-token resume failed; continuing unpinned:', error instanceof Error ? error.message : String(error));
+        }
+        if (resumed)
+            establishPin(resumed.name, resumed.identity, 'configured-token');
+    }
     await discoverSurfacesAtPin('startup');
+    if (!server._registeredTools.wire_help) {
+        server.tool('wire_help', 'Read public Wire help. No token required.', { topic: z.string().optional(), preset: z.literal('brief-my-human').optional() }, async (params) => ({ content: [{ type: 'text', text: JSON.stringify(await bootApi.help(params)) }] }));
+    }
     if (options?.transport === 'http') {
         const port = options?.port ?? 3200;
         const httpTransport = new StreamableHTTPServerTransport({