@theronap/agnoclast-mcp 0.9.266 → 0.9.268

package/lib/release_gate.mjs

@@ -5,7 +5,7 @@
 // that web/lib/engine/release.test.ts pins to the server's registry.
 
 /** Tools any release flag gates — hidden when the server cannot be asked. Mirror of allGatedTools(). */
-export const GATED_FALLBACK = ['document_diff', 'get_document', 'intake_shadow', 'list_documents', 'my_messages', 'pin_document', 'read_conversation', 'read_document', 'send_message', 'set_manager']
+export const GATED_FALLBACK = ['attach_document', 'document_diff', 'export_page', 'get_document', 'intake_shadow', 'list_documents', 'my_messages', 'pin_document', 'read_conversation', 'read_document', 'send_message', 'set_manager', 'upload_document_version']
 
 export const RELEASE_FETCH_TIMEOUT_MS = 2500
 

package/lib/server.mjs

@@ -7416,6 +7416,101 @@ function renderNudge(payload) {
     },
   )
 
+  // TEXT-FIRST TEST, slice A (2026-10-26): a page rendered as a styled Word doc, in its brain's style.
+  server.registerTool(
+    'export_page',
+    {
+      title: 'Export a page as a styled Word document',
+      description: 'Render a wiki page as a .docx in its brain\'s document style (set by the brain\'s owner or admins in the console) and save it to ~/Downloads/cortex/. Use it when someone needs to SEND or print a page: the page stays the master; the Word file is a copy of it. For PDF, the person uses Export ▸ PDF on the page in Agnoclast.',
+      inputSchema: {
+        page: z.string().describe('the page: its exact title, its `ref:` from read_page, or a document id'),
+        tier: z.string().optional().describe('which copy of a two-copy page (e.g. "scoped"); default the most recently written'),
+      },
+    },
+    async ({ page, tier }) => {
+      const q = new URLSearchParams({ page })
+      if (tier) q.set('tier', tier)
+      let res
+      try { res = await fetchCortex(`${BASE}/api/brain/page/export?${q}`, { headers: { Authorization: `Bearer ${TOKEN}` } }) }
+      catch (e) { return toolError(`Could not export: ${e.message}`) }
+      if (!res.ok) return docFail('export the page', res)
+      const buf = Buffer.from(await res.arrayBuffer())
+      const m = /filename="([^"]+)"/.exec(res.headers.get('content-disposition') ?? '')
+      const name = (m ? m[1] : 'page.docx').replace(/[^\w.\- ]/g, '_')
+      const dir = join(homedir(), 'Downloads', 'cortex')
+      mkdirSync(dir, { recursive: true })
+      const path = join(dir, name)
+      writeFileSync(path, buf)
+      return { content: [{ type: 'text', text: `Saved "${page}" as a styled Word document: ${path} (${Math.round(buf.length / 1024)} KB).` }] }
+    },
+  )
+
+  // UPLOADS (slice 4). The server refuses an assistant unless the person turned on "Let assistants upload
+  // files" in Agnoclast → Settings — a switch only the console can flip. These tools never ask for it.
+  // Bytes go straight to storage on the signed URL the server hands out, then the server reads them back.
+  const uploadStored = async (target, path, extra = {}) => {
+    let st
+    try { st = statSync(path) } catch { return toolError(`No file at ${path}.`) }
+    if (!st.isFile()) return toolError(`${path} is not a file.`)
+    const filename = path.split(/[\\/]/).pop()
+    let res
+    try {
+      res = await fetchCortex(`${BASE}/api/stored-files/uploads`, {
+        method: 'POST', headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...target, ...extra, filename, size: st.size }),
+      })
+    } catch (e) { return toolError(`Could not start the upload: ${e.message}`) }
+    const begin = await res.json().catch(() => null)
+    if (!res.ok) return toolError(`Not uploaded: ${begin?.detail ?? begin?.error ?? res.status}`)
+    let put
+    try {
+      put = await fetch(begin.signedUrl, { method: 'PUT', headers: { 'content-type': begin.contentType ?? 'application/octet-stream', 'x-upsert': 'false' }, body: readFileSync(path) })
+    } catch (e) { return toolError(`Not uploaded: storage could not be reached (${e.message}).`) }
+    if (!put.ok) return toolError(`Not uploaded: storage refused the file (${put.status}).`)
+    let commit
+    try {
+      commit = await fetchCortex(`${BASE}/api/stored-files/uploads/${begin.uploadId}/commit`, { method: 'POST', headers: { Authorization: `Bearer ${TOKEN}` } })
+    } catch (e) { return toolError(`Uploaded but not saved: ${e.message}`) }
+    const c = await commit.json().catch(() => null)
+    if (!commit.ok) return toolError(`Uploaded but not saved: ${c?.detail ?? c?.error ?? commit.status}`)
+    const lines = c.unchanged
+      ? [`"${c.title}" is byte-for-byte identical to its current version (v${c.version}); nothing was added.`]
+      : [`Saved "${c.title}" as version ${c.version} (id ${c.fileId}, ${Math.round(c.sizeBytes / 1024)} KB, sha256 ${c.byteSha256.slice(0, 12)}…)${c.pinned ? ', pinned to its page' : ''}.`]
+    if (!c.unchanged && c.contentUnchanged) lines.push('Its contents read the same as the previous version (only the bytes changed).')
+    if (c.extractStatus && c.extractStatus !== 'ok' && c.extractStatus !== 'unchanged') lines.push(`Not readable as text: ${c.extractNote ?? c.extractStatus}.`)
+    else if (c.extractNote) lines.push(c.extractNote)
+    if (!c.unchanged && c.version > 1 && !c.contentUnchanged) lines.push(`See what changed with document_diff file_id:"${c.fileId}", and update the page if what it says about the file is no longer true.`)
+    return { content: [{ type: 'text', text: lines.join('\n') }] }
+  }
+
+  server.registerTool(
+    'attach_document',
+    {
+      title: 'Store a file on a page',
+      description: 'Keep a local file (Excel, Word, CSV, PDF…) in Agnoclast on a page: it is versioned, readable with read_document, and visible to exactly who can read that page. Needs edit access to the page, and the person must have turned on "Let assistants upload files" in Agnoclast → Settings — if it is off this is refused; tell them, do not work around it. Up to 50 MB. Pass pin:true for the file the page is about.',
+      inputSchema: {
+        page: z.string().describe('the page it lives on: exact title, `ref:` or document id'),
+        path: z.string().describe('absolute path of the local file'),
+        title: z.string().optional().describe('a name for it; default the filename without its extension'),
+        pin: z.boolean().optional().describe('pin it to the top of the page and its timeline'),
+      },
+    },
+    async ({ page, path, title, pin }) => uploadStored({ page }, path, { ...(title ? { title } : {}), ...(pin ? { pin: true } : {}) }),
+  )
+
+  server.registerTool(
+    'upload_document_version',
+    {
+      title: 'Upload a new version of a stored file',
+      description: 'Upload a local file as the NEW VERSION of a file already stored in Agnoclast. Every earlier version is kept. Identical bytes add nothing. Same permission as attach_document: refused unless the person turned on "Let assistants upload files". Afterwards, check document_diff and update the page if it no longer describes the file.',
+      inputSchema: {
+        file_id: z.string().describe('the stored file\'s id'),
+        path: z.string().describe('absolute path of the local file'),
+      },
+    },
+    async ({ file_id, path }) => uploadStored({ fileId: file_id }, path),
+  )
+
   // send_imessage — ask to send a text from the user's own Mac (ADR-0076). It no longer texts from this
   // machine: it creates a request on Agnoclast that waits on /email → Waiting for the user's OK (or their
   // web send rule approves it), and the user's Mac — the desktop app, through Messages — sends it and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theronap/agnoclast-mcp",
-  "version": "0.9.266",
+  "version": "0.9.268",
   "description": "Connect your AI assistant to Cortex — your org's projects, activity, gaps, and directives, scoped to you.",
   "type": "module",
   "bin": {