@theronap/cortex-mcp 0.9.29 → 0.9.31

package/lib/server.mjs

@@ -517,6 +517,187 @@ export async function runServer(version) {
     },
   )
 
+  server.registerTool(
+    'set_page_privacy',
+    {
+      title: 'Change who can see a wiki page',
+      description: 'Re-tier a wiki page you own or may edit: "accessible" (anyone in the org), "scoped" (owner + their management chain), or "confidential" (owner only, plus explicit grants). Demoting a PROJECT page also demotes its evidence records (demote-only; each record\'s owner is notified and can revert). Promotions never touch records. If the target tier already has a page, you\'ll be asked to merge via author first, then re-run with absorb=true. Org admins may demote any page, never promote.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().describe('the exact page name'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).describe('the new visibility tier'),
+        source_tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('when the node has multiple tier variants: which one to move'),
+        absorb: z.boolean().optional().describe('after merging your content into an existing target-tier page via author: true removes your now-absorbed source variant'),
+      },
+    },
+    async ({ kind, name, tier, source_tier, absorb }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-privacy`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind, name, tier, ...(source_tier ? { source_tier } : {}), ...(absorb ? { absorb: true } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not set page privacy: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) {
+        // 409s carry the collision protocol (merge instruction, both variants when readable) —
+        // surface the server's structured message verbatim so the agent can follow it.
+        if (out?.error) {
+          const extra = out.collision === 'readable' && out.blocking
+            ? `\nYour ${out.source?.tier} page: ${out.source?.summary ?? out.source?.title}\nExisting ${out.blocking.tier} page: ${out.blocking.summary ?? out.blocking.title}`
+            : ''
+          return { content: [{ type: 'text', text: `Could not set page privacy: ${out.error}${extra}` }] }
+        }
+        const d = classify(res.status, res.headers.get('content-type'), '', res.headers.get('x-vercel-id'))
+        return { content: [{ type: 'text', text: `Could not set page privacy: ${d.message}` }] }
+      }
+      const g = out.live_grants?.length
+        ? ` Grants still active for: ${out.live_grants.map((x) => x.grantee_name ?? x.grantee_user_id).join(', ')}.`
+        : ''
+      return { content: [{ type: 'text', text: `Done — "${out.moved.title}" moved ${out.moved.from} → ${out.moved.to}.${out.ownership_taken ? ' (You took ownership of this previously owner-less page.)' : ''} ${out.note}${g}` }] }
+    },
+  )
+
+  server.registerTool(
+    'grant_page_access',
+    {
+      title: 'Grant or revoke a specific person\'s access to your page',
+      description: 'Share one of YOUR non-accessible wiki pages with a specific org member (or take that access back). A grant lets exactly that person read the page even though its tier would hide it — the escape hatch for "confidential, but Dana needs it". Owner-only. Grants survive re-tiering: revoke them when they should end.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().describe('the exact page name'),
+        grantee: z.string().describe('the org member\'s display name or email (must resolve uniquely — use email if ambiguous)'),
+        action: z.enum(['grant', 'revoke']).describe('grant or revoke'),
+        tier: z.enum(['scoped', 'confidential']).optional().describe('which variant (default: the most restrictive one)'),
+      },
+    },
+    async ({ kind, name, grantee, action, tier }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-grants`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ kind, name, grantee, action, ...(tier ? { tier } : {}) }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not ${action}: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not ${action}: ${out?.error ?? res.status}` }] }
+      const verb = { granted: 'now has access to', already_granted: 'already had access to', revoked: 'no longer has access to', not_granted: 'had no grant on' }[out.action]
+      return { content: [{ type: 'text', text: `Done — ${out.grantee} ${verb} the ${out.tier} page.` }] }
+    },
+  )
+
+  server.registerTool(
+    'list_page_grants',
+    {
+      title: 'List who has granted access to your page',
+      description: 'Show every explicit access grant on YOUR page\'s tier variants (owner-only). Use after re-tiering a page — grants survive tier changes and keep granting until revoked.',
+      inputSchema: {
+        kind: z.enum(['project', 'person', 'org', 'user']).describe('the page kind'),
+        name: z.string().describe('the exact page name'),
+      },
+    },
+    async ({ kind, name }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-grants?kind=${encodeURIComponent(kind)}&name=${encodeURIComponent(name)}`, {
+          headers: { Authorization: `Bearer ${TOKEN}` },
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list grants: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not list grants: ${out?.error ?? res.status}` }] }
+      if (!out.grants?.length) return { content: [{ type: 'text', text: 'No grants on this page.' }] }
+      const lines = out.grants.map((g) => `- ${g.grantee_name ?? g.grantee_user_id} → ${g.tier} variant (since ${String(g.created_at).slice(0, 10)})`)
+      return { content: [{ type: 'text', text: `Grants (${out.grants.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'my_retier_notices',
+    {
+      title: 'Records of yours that a page demotion re-tiered',
+      description: 'When someone demotes a project page, its evidence records follow (demote-only) — including yours. This lists those notices (newest first) and marks them seen. To undo one, call set_record_privacy with the record_id and its previous tier (shown as from_privacy).',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/retier-notices`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list notices: ${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 notices: ${d.message}` }] }
+      }
+      const { notices } = await res.json()
+      if (!notices?.length) return { content: [{ type: 'text', text: 'No re-tier notices.' }] }
+      const lines = notices.map((n) =>
+        `- record ${n.record_id} ("${n.record_title ?? 'untitled'}") ${n.from_privacy} → ${n.to_privacy} — ${n.demoted_by_name ?? 'someone'} demoted the ${n.node_name ?? n.node_kind} page. Revert: set_record_privacy(record_id, "${n.from_privacy}").`)
+      return { content: [{ type: 'text', text: `Your re-tiered records (${notices.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'page_merge_requests',
+    {
+      title: 'Merge requests on pages you own',
+      description: 'Someone tried to move their page into a tier slot your page occupies (they only saw "slot occupied"). Review pending requests here; read their variant, merge anything worth keeping into your page via author, then decide with decide_page_merge.',
+      inputSchema: {},
+    },
+    async () => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-merge-requests`, { headers: { Authorization: `Bearer ${TOKEN}` } })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not list merge requests: ${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 merge requests: ${d.message}` }] }
+      }
+      const { requests } = await res.json()
+      if (!requests?.length) return { content: [{ type: 'text', text: 'No pending page merge requests.' }] }
+      const lines = requests.map((q) =>
+        `- [${q.id}] ${q.requester_name ?? 'someone'} wants their ${q.kind} page merged into your ${q.requested_tier} "${q.page_title}". Merge via author first, then decide_page_merge.`)
+      return { content: [{ type: 'text', text: `Pending page merge requests (${requests.length}):\n${lines.join('\n')}` }] }
+    },
+  )
+
+  server.registerTool(
+    'decide_page_merge',
+    {
+      title: 'Approve or deny a page merge request',
+      description: 'Decide a pending page merge request you own. IMPORTANT: approve only AFTER you have merged whatever of the requester\'s content you want into your page (via author) — approving DELETES their variant of the node. Deny closes the request and nothing moves.',
+      inputSchema: {
+        id: z.string().describe('the request id from page_merge_requests'),
+        decision: z.enum(['approve', 'deny']).describe('approve = their variant is removed (merge first!); deny = nothing moves'),
+      },
+    },
+    async ({ id, decision }) => {
+      let res
+      try {
+        res = await fetchCortex(`${BASE}/api/brain/page-merge-requests`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ id, decision }),
+        })
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Could not decide: ${e.message}` }] }
+      }
+      const out = await res.json().catch(() => null)
+      if (!res.ok) return { content: [{ type: 'text', text: `Could not decide: ${out?.error ?? res.status}` }] }
+      return { content: [{ type: 'text', text: out.decision === 'denied' ? 'Denied — nothing moved.' : `Approved — removed variant(s): ${out.removed_variants.join(', ') || 'none remained'}. ${out.note}` }] }
+    },
+  )
+
   // ── File requests: ask the owner for a record's FULL original (lives on their machine) ──
   const fail = (verb, res) => async () =>
     ({ content: [{ type: 'text', text: `Could not ${verb}: ${classify(res.status, res.headers.get('content-type'), await res.text(), res.headers.get('x-vercel-id')).message}` }] })
@@ -645,7 +826,7 @@ export async function runServer(version) {
     {
       title: 'Authoring context (call before author)',
       description:
-        'Fetch the scaffolding to author a Cortex wiki node: the canonical NAMESPACE (existing node names — link to these with the EXACT name inside [[ ]]) and the node-type CONNECTION RULES (what kinds of links to look for). ALWAYS call this BEFORE `author` so the page links to real nodes by their established names instead of minting synonyms. Reference a node in the namespace as [[Name]]; if you reference something real that is NOT in the namespace, still write [[Name]] — that is a red-link marking a node worth creating. If the page IS about a specific code repo, also stamp [[repo:owner/name]] (lowercase) once — an identifier join key, not a page link.',
+        'Fetch the scaffolding to author a Cortex wiki node: the canonical NAMESPACE (existing node names — link to these with the EXACT name inside [[ ]]) and the node-type CONNECTION RULES (what kinds of links to look for). ALWAYS call this BEFORE `author` so the page links to real nodes by their established names instead of minting synonyms. Reference a node in the namespace as [[Name]]; if you reference something real that is NOT in the namespace, still write [[Name]] — that is a red-link marking a node worth creating. If the page IS about a specific code repo or chat channel, also stamp it once — [[repo:owner/name]] or [[channel:name]] (lowercase, no #) — identifier join keys, not page links.',
       inputSchema: {
         kind: z.enum(['project', 'person', 'org', 'user']).optional().describe('the node type you are about to author (default project)'),
       },
@@ -688,12 +869,14 @@ export async function runServer(version) {
           heading: z.string().describe('e.g. Overview, Current state, Decisions, Open threads, People'),
           body: z.string().describe('dense markdown WITH inline [[links]] where the prose references another node'),
         })).describe('3-5 sections; the page body'),
-        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('visibility tier (default accessible — the shareable page)'),
+        tier: z.enum(['accessible', 'scoped', 'confidential']).optional().describe('visibility tier. Omit for the safe default: scoped (you + your management chain) on nodes that support it — your user page, projects you own-scope — and accessible elsewhere (person/org pages are the shared wiki). Pass accessible explicitly when the page is meant for the whole org.'),
         base_version: z.string().optional().describe('the `version` hash shown when you read this page (read_page) — REQUIRED when updating an existing page, so a concurrent edit is caught instead of clobbered. Omit only for a brand-new node. If the save returns "stale" or "read first", read_page again and retry with the fresh version.'),
       },
     },
     async ({ kind, name, summary, sections, tier, base_version }) => {
-      const pages = [{ tier: tier ?? 'accessible', summary, base_version, sections: Array.isArray(sections) ? sections : [] }]
+      // No client-side tier default — the server computes the per-kind safe default (page-privacy
+      // T4/D10) so version-pinned installs can't bake a stale policy.
+      const pages = [{ ...(tier ? { tier } : {}), summary, base_version, sections: Array.isArray(sections) ? sections : [] }]
       let res
       try {
         res = await fetchCortex(`${BASE}/api/brain/author`, {

package/package.json

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