@theronap/cortex-mcp 0.9.35 → 0.9.37

package/lib/server.mjs

@@ -253,10 +253,28 @@ export async function runServer(version) {
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project; pass person/org for people/teams)'),
         expand: z.boolean().optional().describe('identifier names only: also list recent visible timeline events for this identifier (default: home + count)'),
         history: z.boolean().optional().describe('node names only: return the node\'s TIMELINE (events joined via its [[repo:…]] stamps, reverse-chron, viewer-visible) instead of the page body. The page is the present; this is the history.'),
+        version: z.string().optional().describe('read a HISTORICAL version of this page instead of the current one: a rev_no (e.g. "3") or a content_hash from page_history. Use page_history first to see the versions, then rollback_page to restore one.'),
       },
     },
-    async ({ name, kind, expand, history }) => {
+    async ({ name, kind, expand, history, version }) => {
       const k = kind ?? 'project'
+      // PAGE HISTORY (Part A): a specific version reads one historical body, resolved within this page's
+      // own history. Not for identifier-shaped names (those are join keys, handled below).
+      if (version && !/^[a-z][a-z0-9_-]*:.+/i.test(name)) {
+        try {
+          const qs = new URLSearchParams({ kind: k, key: name, version })
+          const vr = await fetchCortex(`${BASE}/api/brain/page?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+          if (vr.status === 404) return { content: [{ type: 'text', text: `No version "${version}" for "${name}" (or you can't see it). Use page_history "${name}" to list its versions.` }] }
+          if (!vr.ok) {
+            const d = classify(vr.status, vr.headers.get('content-type'), await vr.text(), vr.headers.get('x-vercel-id'))
+            return { content: [{ type: 'text', text: `Could not read version "${version}" of "${name}": ${d.message}` }] }
+          }
+          const v = await vr.json()
+          return { content: [{ type: 'text', text: `# ${name} — historical version (rev ${v.revNo} · ${v.op} · ${String(v.createdAt).slice(0, 10)} · ${v.tier})\nversion: ${v.version}\n\n${v.body}\n\n— This is a HISTORICAL snapshot, not the current page. \`read_page "${name}"\` (no version) shows what's live; \`rollback_page\` restores this one as a new version.` }] }
+        } catch (e) {
+          return { content: [{ type: 'text', text: `Could not read version "${version}" of "${name}": ${e.message}` }] }
+        }
+      }
       // PER-NODE TIMELINE (slice 4): history = the projection over the node's identifier stamps.
       if (history && !/^[a-z][a-z0-9_-]*:.+/i.test(name)) {
         try {
@@ -353,6 +371,74 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'page_history',
+    {
+      title: 'See a wiki page\'s edit history',
+      description: 'Show the VERSION history of an authored wiki page — every prior version, who changed it and when, newest first. This is how you see "what changed on this page and by whom", and it includes privacy changes (re-tiers). Then use `read_page` with a version to view an old body, or `rollback_page` to restore one. (Distinct from read_page\'s `history: true`, which is the raw event timeline via [[repo:…]] stamps.) RLS-scoped: you see history only for pages you may read.',
+      inputSchema: {
+        name: z.string().describe('the canonical node name exactly as written (e.g. "Cortex", "Ben")'),
+        kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project)'),
+        limit: z.number().int().optional().describe('how many recent versions to show (default 20, max 200)'),
+      },
+    },
+    async ({ name, kind, limit }) => {
+      const k = kind ?? 'project'
+      let res
+      try {
+        const qs = new URLSearchParams({ kind: k, key: name, ...(limit ? { limit: String(limit) } : {}) })
+        res = await fetchCortex(`${BASE}/api/brain/page-history?${qs}`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not read history for "${name}": ${e.message}` }] }
+      }
+      if (res.status === 404) return { content: [{ type: 'text', text: `No ${k} named "${name}". Pass kind (person/org) if it isn't a project.` }] }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not read history for "${name}": ${d.message}` }] }
+      }
+      const out = await res.json()
+      const revs = out.revisions ?? []
+      if (!revs.length) return { content: [{ type: 'text', text: `"${name}" (${k}) has no recorded version history yet.` }] }
+      const lines = revs.map((r) => {
+        const who = r.actor_name ? ` · ${r.actor_name}` : ''
+        const why = r.reason ? ` — ${r.reason}` : ''
+        return `- rev ${r.rev_no} · ${String(r.created_at).slice(0, 10)} · ${r.op} · ${r.tier}${who}${why}\n    version: ${r.content_hash}`
+      })
+      return { content: [{ type: 'text', text: `# ${name} — page history (newest first)\n${lines.join('\n')}\n\n— \`read_page "${name}"\` with version:<rev_no|version> to view an old body; \`rollback_page\` to restore one.` }] }
+    },
+  )
+
+  server.registerTool(
+    'rollback_page',
+    {
+      title: 'Roll a wiki page back to a prior version',
+      description: 'Restore a wiki page to an earlier version from its page_history — a forward, non-destructive write (the old versions are kept; a new "rollback" version is recorded). Use this to undo a mistaken or bad edit. You may only roll back a page you are allowed to edit. Find the target version with page_history first.',
+      inputSchema: {
+        name: z.string().describe('the exact page name'),
+        kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('node kind (default project)'),
+        to_version: z.string().describe('which version to restore: a rev_no (e.g. "3") or a content_hash, from page_history'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('which tier variant to roll back, if the node has more than one'),
+        reason: z.string().optional().describe('optional note recorded on the new rollback version (why you rolled back)'),
+      },
+    },
+    async ({ name, kind, to_version, tier, reason }) => {
+      const k = kind ?? 'project'
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/rollback`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind: k, name, to_version, ...(tier ? { tier } : {}), ...(reason ? { reason } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not roll back "${name}": ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not roll back "${name}": ${out?.error ?? res.status}` }] }
+      return { content: [{ type: 'text', text: `Done — "${name}" ${out.note}. \`read_page "${name}"\` to confirm the current content.` }] }
+    },
+  )
+
   server.registerTool(
     'writing_style',
     {
@@ -403,6 +489,59 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'my_brains',
+    {
+      title: 'List your brains + which one writes land in',
+      description: 'List the brains (orgs/workspaces) you belong to and show which one is your ACTIVE WRITE brain — where author/log_session/capture currently land. Reads span all your brains; writes go to the active one. Use this to see your options before set_active_brain, or when a session seems to belong to a different brain than the one you are writing to.',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brains`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list brains: ${e.message}` }] }
+      }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not list brains: ${d.message}` }] }
+      }
+      const { brains, activeIsExplicit } = await res.json()
+      if (!brains?.length) return { content: [{ type: 'text', text: 'You have no brains.' }] }
+      const lines = brains.map((b) => `${b.isActive ? '▶' : ' '} ${b.name}  (${b.role}${b.status !== 'active' ? `, ${b.status}` : ''})  [${b.orgId}]`)
+      const note = activeIsExplicit ? '' : '\n(active brain is the default — you have one brain; set_active_brain once you hold more.)'
+      return { content: [{ type: 'text', text: `Your brains (▶ = writes land here):\n${lines.join('\n')}${note}` }] }
+    },
+  )
+
+  server.registerTool(
+    'set_active_brain',
+    {
+      title: 'Choose the brain your writes go to',
+      description: 'Point your writes (author / log_session / capture) at one of your brains, by its org id (from my_brains). Sticky — it stays until you change it. Pass org_id = null to clear it and fall back to the default. You can only select a brain you are a member of.',
+      inputSchema: { org_id: z.string().nullable().describe('the org id of the brain to write to (from my_brains), or null to clear the pointer') },
+    },
+    async ({ org_id }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brains`, {
+          method: 'PUT',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ orgId: org_id ?? null }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not set active brain: ${e.message}` }] }
+      }
+      if (!res.ok) {
+        const d = classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not set active brain: ${d.message}` }] }
+      }
+      const r = await res.json()
+      return { content: [{ type: 'text', text: r.activeOrgId ? `Writes now land in brain ${r.activeOrgId}.` : 'Cleared your active-brain pointer (writes fall back to your default brain).' }] }
+    },
+  )
+
   server.registerTool(
     'list_records',
     {

package/package.json

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