@theronap/agnoclast-mcp 0.9.273 → 0.9.275
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/bin/cortex-mcp.mjs +15 -31
- package/lib/confidential_session.mjs +91 -61
- package/lib/diagnose.mjs +9 -1
- package/lib/server.mjs +78 -43
- package/package.json +1 -1
package/bin/cortex-mcp.mjs
CHANGED
|
@@ -58,12 +58,18 @@ if (process.env.CORTEX_SUMMARIZING && CONTEXT_HOOK_COMMANDS.has(cmd)) {
|
|
|
58
58
|
process.exit(0)
|
|
59
59
|
}
|
|
60
60
|
|
|
61
|
-
// ── A confidential
|
|
62
|
-
//
|
|
63
|
-
// Every hook here works on the person's ORDINARY account: capture would file
|
|
64
|
-
// another brain,
|
|
65
|
-
|
|
66
|
-
|
|
61
|
+
// ── A session locked into a confidential brain runs NO ordinary hooks ────────────────────────────────
|
|
62
|
+
// The first time a session uses a confidential brain, its MCP server locks it in and leaves a marker
|
|
63
|
+
// (lib/confidential_session.mjs). Every hook here works on the person's ORDINARY account: capture would file
|
|
64
|
+
// the session's transcript into another brain, hydrate/status would send its prompts there, and the local
|
|
65
|
+
// summarizer runs on whatever AI account this machine has. So each one stands down, silently. Every hook also
|
|
66
|
+
// names the AI account it runs under, so the server refuses one dedicated to a confidential brain.
|
|
67
|
+
if (CONTEXT_HOOK_COMMANDS.has(cmd) || cmd === 'capture' || cmd === 'statusline') {
|
|
68
|
+
const { sessionLockedIn, hookAiAccount } = await import('../lib/confidential_session.mjs')
|
|
69
|
+
const { hookSessionKey } = await import('../lib/session_key.mjs')
|
|
70
|
+
if (sessionLockedIn(hookSessionKey(process.env))) process.exit(0)
|
|
71
|
+
const { setAiAccount } = await import('../lib/diagnose.mjs')
|
|
72
|
+
setAiAccount(hookAiAccount(process.env))
|
|
67
73
|
}
|
|
68
74
|
|
|
69
75
|
// ADR-0020 Stage 2, amended 2026-09-25 — stamp THIS session's identity on the read-only context
|
|
@@ -125,7 +131,6 @@ if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
|
|
|
125
131
|
` hydrate UserPromptSubmit hook — inject query-centered context on the first substantive turn\n` +
|
|
126
132
|
` migrate-key [--dry-run] move the MCP config key to its new name, allow rules first\n` +
|
|
127
133
|
` with-token -- <cmd> run <cmd> with your token in its environment (for cron/launchd wrappers)\n` +
|
|
128
|
-
` confidential "<brain>" [claude|codex] start an agent locked to one confidential brain (approved AI accounts only)\n` +
|
|
129
134
|
` statusline ambient presence line for the Claude Code statusline (local read only)\n` +
|
|
130
135
|
` capture Stop-hook capturer (invoked by Claude Code)\n` +
|
|
131
136
|
` ingest-folder <path> ingest a local markdown folder as your authored records\n` +
|
|
@@ -277,30 +282,9 @@ if (cmd === 'login') {
|
|
|
277
282
|
process.stdout.write(JSON.stringify(res, null, 2) + '\n')
|
|
278
283
|
process.exitCode = res.status === 'aborted' ? 1 : 0
|
|
279
284
|
} else if (cmd === 'confidential') {
|
|
280
|
-
//
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
const agent = agentArg === 'codex' ? 'codex' : agentArg === 'claude' ? 'claude' : null
|
|
284
|
-
if (!brain || !agent) {
|
|
285
|
-
process.stderr.write('Usage: cortex-mcp confidential "<brain name>" [claude|codex] [-- agent args…]\n')
|
|
286
|
-
process.exitCode = 2
|
|
287
|
-
} else {
|
|
288
|
-
const { resolveTokenSource } = await import('../lib/diagnose.mjs')
|
|
289
|
-
const { confidentialLaunch } = await import('../lib/confidential_session.mjs')
|
|
290
|
-
const { token } = resolveTokenSource()
|
|
291
|
-
if (!token) {
|
|
292
|
-
process.stderr.write('cortex-mcp confidential: no Agnoclast token wired on this machine. Run `npx -y @theronap/cortex-mcp login` first.\n')
|
|
293
|
-
process.exitCode = 3
|
|
294
|
-
} else {
|
|
295
|
-
const { spawnSync } = await import('node:child_process')
|
|
296
|
-
const launch = confidentialLaunch({ brain, agent, token })
|
|
297
|
-
const extra = agentArgs[0] === '--' ? agentArgs.slice(1) : agentArgs
|
|
298
|
-
process.stderr.write(`Starting ${agent === 'codex' ? 'Codex' : 'Claude Code'} for the confidential brain "${brain}". Nothing else in Agnoclast is reachable from this session.\n`)
|
|
299
|
-
const r = spawnSync(launch.command, [...launch.args, ...extra], { stdio: 'inherit', windowsHide: true, env: { ...process.env, ...launch.env } })
|
|
300
|
-
if (r.error) process.stderr.write(`cortex-mcp confidential: could not start ${launch.command}: ${r.error.message}\n`)
|
|
301
|
-
process.exitCode = r.status ?? 1
|
|
302
|
-
}
|
|
303
|
-
}
|
|
285
|
+
// Retired 2026-10-28 (0.9.275): a confidential brain opens from an ordinary session, the first time it is used.
|
|
286
|
+
process.stderr.write('cortex-mcp confidential is retired. Start Claude Code or Codex as usual and use the confidential brain by name: the first time a session uses it, the session is locked to it (or, if it used another brain first, locked out of it).\n')
|
|
287
|
+
process.exitCode = 2
|
|
304
288
|
} else if (cmd === 'with-token') {
|
|
305
289
|
// Run a command with the resolved token in its environment. Exists so generated helper scripts
|
|
306
290
|
// (launchd/cron wrappers) never inline their own config parse — those files are frozen on disk and
|
|
@@ -1,10 +1,11 @@
|
|
|
1
|
-
import { readFileSync, mkdirSync, writeFileSync } from 'node:fs'
|
|
1
|
+
import { readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs'
|
|
2
2
|
import { homedir } from 'node:os'
|
|
3
3
|
import { join } from 'node:path'
|
|
4
4
|
import { execFileSync } from 'node:child_process'
|
|
5
|
+
import { createHash } from 'node:crypto'
|
|
5
6
|
|
|
6
|
-
// CONFIDENTIAL BRAINS FROM A CODING AGENT (server: web/lib/engine/confidential_agent.ts
|
|
7
|
-
// 20261027065716; Agnoclast page "Confidential brains — design").
|
|
7
|
+
// CONFIDENTIAL BRAINS FROM A CODING AGENT (server: web/lib/engine/confidential_agent.ts and confidential_lock.ts;
|
|
8
|
+
// migrations 20261027065716 and 20261028201517; Agnoclast page "Confidential brains — design").
|
|
8
9
|
//
|
|
9
10
|
// A confidential brain's data may reach only an AI account its admin approved. This process runs inside the
|
|
10
11
|
// agent, so it is the one place that can see which account that is:
|
|
@@ -12,37 +13,44 @@ import { execFileSync } from 'node:child_process'
|
|
|
12
13
|
// (CLAUDE_CODE_ACCOUNT_UUID / CLAUDE_CODE_ORGANIZATION_UUID — seen on 2026-10-27 in the env of a live
|
|
13
14
|
// cortex-mcp under Claude Code). Unsigned: it stops the accident, not a forger.
|
|
14
15
|
// • Codex keeps an OpenAI-signed id_token in ~/.codex/auth.json. The server verifies the signature.
|
|
15
|
-
//
|
|
16
|
-
//
|
|
17
|
-
//
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
//
|
|
21
|
-
//
|
|
22
|
-
export const CONFIDENTIAL_SESSION_ENV = 'AGNOCLAST_CONFIDENTIAL'
|
|
16
|
+
//
|
|
17
|
+
// THE FIRST-TOUCH LOCK (Theron, 2026-10-28). A session starts the ordinary way, with the ordinary server. The first
|
|
18
|
+
// time a tool names a confidential brain, this process proves the AI account and trades the person's token for a
|
|
19
|
+
// 15-minute token on the person's SEAT; from then on every request goes through the seat, and the server holds
|
|
20
|
+
// the session IN that brain. If the session used any other brain first, the server refuses the seat — it is
|
|
21
|
+
// locked OUT. Once locked in, this process leaves a marker so every hook (capture, context, the local summarizer)
|
|
22
|
+
// stands down for the rest of the session: they work on the person's ordinary account.
|
|
23
23
|
|
|
24
|
-
/**
|
|
25
|
-
|
|
26
|
-
|
|
24
|
+
/**
|
|
25
|
+
* The NEAREST coding agent above this process: 'codex', 'claude', or null. Nearest, because agents nest — a
|
|
26
|
+
* Codex started from a terminal inside Claude Code inherits CLAUDECODE and Claude's account variables, and
|
|
27
|
+
* the agent actually running the model is the one closest to this server. Unix only; anywhere else, null.
|
|
28
|
+
*/
|
|
29
|
+
export function nearestAgent({ pid = process.ppid, exec = execFileSync, platform = process.platform } = {}) {
|
|
30
|
+
if (platform === 'win32') return null
|
|
27
31
|
let cur = pid
|
|
28
32
|
for (let i = 0; i < 16 && cur > 1; i++) {
|
|
29
33
|
let line
|
|
30
|
-
try { line = String(exec('ps', ['-o', 'ppid=,comm=', '-p', String(cur)], { encoding: 'utf8', windowsHide: true })).trim() } catch { return
|
|
34
|
+
try { line = String(exec('ps', ['-o', 'ppid=,comm=', '-p', String(cur)], { encoding: 'utf8', windowsHide: true })).trim() } catch { return null }
|
|
31
35
|
const m = line.match(/^(\d+)\s+(.*)$/)
|
|
32
|
-
if (!m) return
|
|
33
|
-
|
|
36
|
+
if (!m) return null
|
|
37
|
+
const comm = m[2].trim()
|
|
38
|
+
if (/(^|\/)codex[^/]*$/i.test(comm)) return 'codex'
|
|
39
|
+
if (/(^|\/)claude$/.test(comm)) return 'claude' // lower-case: the desktop app's own binary is 'Claude'
|
|
34
40
|
cur = Number(m[1])
|
|
35
41
|
}
|
|
36
|
-
return
|
|
42
|
+
return null
|
|
37
43
|
}
|
|
38
44
|
|
|
39
45
|
/**
|
|
40
46
|
* Which AI account runs this agent, as a proof the server can check — or { refused } saying why there is none.
|
|
41
|
-
*
|
|
42
|
-
*
|
|
47
|
+
* The nearest agent decides (see nearestAgent). Claude Code is also recognised by its environment alone when no
|
|
48
|
+
* agent shows in the process tree, because that environment is set by the process running; a Codex auth file
|
|
49
|
+
* is used only when Codex is the nearest agent, since it can sit on a machine whose agent is something else.
|
|
43
50
|
*/
|
|
44
|
-
export function gatherAgentProof({ env = process.env, readFile = readFileSync, home = homedir(),
|
|
45
|
-
|
|
51
|
+
export function gatherAgentProof({ env = process.env, readFile = readFileSync, home = homedir(), agent = nearestAgent } = {}) {
|
|
52
|
+
const nearest = agent()
|
|
53
|
+
if (env.CLAUDECODE && nearest !== 'codex') {
|
|
46
54
|
if (env.ANTHROPIC_API_KEY || env.CLAUDE_CODE_USE_BEDROCK || env.CLAUDE_CODE_USE_VERTEX || env.ANTHROPIC_AUTH_TOKEN) {
|
|
47
55
|
return { refused: 'Claude Code is running on an API key or a cloud provider, so it cannot say which Claude account runs the model. Sign in with your approved Claude account (/login) and start again.' }
|
|
48
56
|
}
|
|
@@ -52,7 +60,7 @@ export function gatherAgentProof({ env = process.env, readFile = readFileSync, h
|
|
|
52
60
|
}
|
|
53
61
|
return { proof: { kind: 'claude-code', accountUuid, organizationUuid, email: env.CLAUDE_CODE_USER_EMAIL || null } }
|
|
54
62
|
}
|
|
55
|
-
if (
|
|
63
|
+
if (nearest === 'codex') {
|
|
56
64
|
let auth
|
|
57
65
|
try { auth = JSON.parse(readFile(join(env.CODEX_HOME || join(home, '.codex'), 'auth.json'), 'utf8')) } catch {
|
|
58
66
|
return { refused: 'Codex is not signed in on this machine (no ~/.codex/auth.json). Run `codex login` with your approved ChatGPT account.' }
|
|
@@ -82,53 +90,75 @@ export async function requestSeatToken({ base, token, brain, proof, fetchImpl })
|
|
|
82
90
|
if (res.ok && body?.status === 'approved' && typeof body.token === 'string') {
|
|
83
91
|
return { token: body.token, expiresIn: Number(body.expiresIn) || 900, brain: body.brain ?? brain, account: body.account }
|
|
84
92
|
}
|
|
93
|
+
if (body?.status === 'pending' && body.awaiting === 'owner') {
|
|
94
|
+
return { message: `"${body.brain}" approved this AI account (${body.account}) only as DEDICATED to it: once you agree, it can never reach any other brain. To agree, POST { brain, account: "${body.accountId}", decision: "agree" } to /api/brains/confidential/ai-accounts; then try again.` }
|
|
95
|
+
}
|
|
85
96
|
if (body?.status === 'pending') {
|
|
86
|
-
return { message: `"${body.brain}" has not approved this AI account yet: ${body.account}. An owner or admin of the brain approves it (account id ${body.accountId}); then
|
|
97
|
+
return { message: `"${body.brain}" has not approved this AI account yet: ${body.account}. An owner or admin of the brain approves it (account id ${body.accountId}); then try again.` }
|
|
87
98
|
}
|
|
88
|
-
return { message: `"${brain}" did not open: ${body?.error ?? `HTTP ${res.status}`}` }
|
|
99
|
+
return { message: `"${brain}" did not open: ${body?.error ?? body?.message ?? `HTTP ${res.status}`}` }
|
|
89
100
|
}
|
|
90
101
|
|
|
91
|
-
/**
|
|
92
|
-
|
|
93
|
-
|
|
102
|
+
/**
|
|
103
|
+
* The AI account this process runs under, as the server spells it ('anthropic:<org>:<account>' /
|
|
104
|
+
* 'openai:<chatgpt account>:<user>'), or null. Sent as x-cortex-ai-account so the server can refuse an account
|
|
105
|
+
* dedicated to a confidential brain everywhere else. Attested, like the Claude Code proof: it stops accidents.
|
|
106
|
+
*/
|
|
107
|
+
export function aiAccountOf(proof) {
|
|
108
|
+
if (!proof) return null
|
|
109
|
+
if (proof.kind === 'claude-code') return `anthropic:${proof.organizationUuid.toLowerCase()}:${proof.accountUuid.toLowerCase()}`
|
|
110
|
+
try {
|
|
111
|
+
const claims = JSON.parse(Buffer.from(String(proof.idToken).split('.')[1], 'base64url').toString('utf8'))
|
|
112
|
+
const auth = claims['https://api.openai.com/auth'] ?? {}
|
|
113
|
+
return auth.chatgpt_account_id && auth.chatgpt_user_id ? `openai:${auth.chatgpt_account_id}:${auth.chatgpt_user_id}` : null
|
|
114
|
+
} catch { return null }
|
|
94
115
|
}
|
|
95
116
|
|
|
96
117
|
/**
|
|
97
|
-
*
|
|
98
|
-
*
|
|
99
|
-
* Claude Code, --strict-mcp-config; for Codex, the ordinary `cortex` server is switched off for that run.
|
|
118
|
+
* The account a HOOK runs under. Hooks are Claude Code's, so only its environment is read — no process walk on
|
|
119
|
+
* every hook. Null under an API key or a cloud provider, where the login does not say.
|
|
100
120
|
*/
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
const
|
|
104
|
-
|
|
105
|
-
for (const s of sections) {
|
|
106
|
-
const m = s.match(/^\[mcp_servers\.([A-Za-z0-9_-]+)\]/)
|
|
107
|
-
if (m && m[1] !== 'agnoclast_confidential' && /(cortex|agnoclast)-mcp/.test(s)) names.push(m[1])
|
|
108
|
-
}
|
|
109
|
-
return names
|
|
121
|
+
export function hookAiAccount(env = process.env) {
|
|
122
|
+
if (!env.CLAUDECODE || env.ANTHROPIC_API_KEY || env.CLAUDE_CODE_USE_BEDROCK || env.CLAUDE_CODE_USE_VERTEX) return null
|
|
123
|
+
const a = env.CLAUDE_CODE_ACCOUNT_UUID, o = env.CLAUDE_CODE_ORGANIZATION_UUID
|
|
124
|
+
return a && o ? `anthropic:${o.toLowerCase()}:${a.toLowerCase()}` : null
|
|
110
125
|
}
|
|
111
126
|
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
const
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
return {
|
|
127
|
+
/** Ask which confidential brains this person holds a seat in, and the one this AI account is dedicated to. Locks nothing. */
|
|
128
|
+
export async function fetchMyConfidential({ base, token, proof, fetchImpl }) {
|
|
129
|
+
try {
|
|
130
|
+
const res = await fetchImpl(`${base}/api/brains/confidential/mine`, {
|
|
131
|
+
method: 'POST',
|
|
132
|
+
headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
|
|
133
|
+
body: JSON.stringify(proof ? { proof } : {}),
|
|
134
|
+
})
|
|
135
|
+
if (!res.ok) return { brains: [], dedicatedTo: null }
|
|
136
|
+
const body = await res.json()
|
|
137
|
+
return { brains: Array.isArray(body?.brains) ? body.brains : [], dedicatedTo: typeof body?.dedicatedTo === 'string' ? body.dedicatedTo : null }
|
|
138
|
+
} catch {
|
|
139
|
+
return { brains: [], dedicatedTo: null }
|
|
121
140
|
}
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
/** The confidential brain a tool's `brain` argument names (by name or org id, any case), or null. */
|
|
144
|
+
export function confidentialBrainNamed(brains, arg) {
|
|
145
|
+
if (typeof arg !== 'string' || !arg.trim()) return null
|
|
146
|
+
const a = arg.trim().toLowerCase()
|
|
147
|
+
return brains.find((b) => b.orgId?.toLowerCase() === a || b.name?.toLowerCase() === a) ?? null
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
// ── The locked-in marker: how a hook learns its session belongs to a confidential brain ─────────────────────────
|
|
151
|
+
|
|
152
|
+
const markerDir = (home) => join(home, '.cortex', 'confidential-sessions')
|
|
153
|
+
const markerFile = (home, sessionKey) => join(markerDir(home), createHash('sha256').update(String(sessionKey)).digest('hex'))
|
|
154
|
+
|
|
155
|
+
export function markLockedIn(sessionKey, brain, { home = homedir(), write = writeFileSync, mkdir = mkdirSync } = {}) {
|
|
156
|
+
if (!sessionKey) return
|
|
157
|
+
mkdir(markerDir(home), { recursive: true, mode: 0o700 })
|
|
158
|
+
write(markerFile(home, sessionKey), JSON.stringify({ brain, at: new Date().toISOString() }), { mode: 0o600 })
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
/** Is this session locked into a confidential brain? A hook asks this before doing anything. */
|
|
162
|
+
export function sessionLockedIn(sessionKey, { home = homedir(), exists = existsSync } = {}) {
|
|
163
|
+
return !!sessionKey && exists(markerFile(home, sessionKey))
|
|
134
164
|
}
|
package/lib/diagnose.mjs
CHANGED
|
@@ -283,6 +283,12 @@ export function classify(status, contentType, bodyText, requestId) {
|
|
|
283
283
|
let SESSION_KEY = null
|
|
284
284
|
export function setSessionKey(key) { SESSION_KEY = key || null }
|
|
285
285
|
|
|
286
|
+
// THE AI ACCOUNT this process runs under (confidential_session.mjs aiAccountOf/hookAiAccount), sent as
|
|
287
|
+
// x-cortex-ai-account. The server refuses an account dedicated to a confidential brain everywhere else
|
|
288
|
+
// (web/lib/engine/confidential_lock.ts). Null → no header → nothing changes.
|
|
289
|
+
let AI_ACCOUNT = null
|
|
290
|
+
export function setAiAccount(v) { AI_ACCOUNT = v || null }
|
|
291
|
+
|
|
286
292
|
// WHO IS CALLING — an identity INDEPENDENT of the session key, and it must stay independent.
|
|
287
293
|
//
|
|
288
294
|
// The server labels every page revision's `actor_source` from this header. It used to default to
|
|
@@ -429,7 +435,7 @@ async function fetchCortexOnce(url, opts = {}, policy = {}) {
|
|
|
429
435
|
const { timeoutMs: optTimeout, signal: callerSignal, ...rest } = opts
|
|
430
436
|
// x-cortex-tool: the tool this request is for (the running one, else the path map) — the server
|
|
431
437
|
// counts calls per tool for staff usage stats (api_requests). A name only; arguments never travel.
|
|
432
|
-
const baseHeaders = { ...(rest.headers ?? {}), 'x-cortex-client': CLIENT_ID, 'x-cortex-tool': toolForUrl(url) }
|
|
438
|
+
const baseHeaders = { ...(rest.headers ?? {}), 'x-cortex-client': CLIENT_ID, 'x-cortex-tool': toolForUrl(url), ...(AI_ACCOUNT ? { 'x-cortex-ai-account': AI_ACCOUNT } : {}) }
|
|
433
439
|
const fetchOpts = SESSION_KEY
|
|
434
440
|
? { ...rest, headers: { ...baseHeaders, 'x-cortex-session-key': SESSION_KEY } }
|
|
435
441
|
: { ...rest, headers: baseHeaders }
|
|
@@ -539,6 +545,8 @@ const PATH_TOOLS = {
|
|
|
539
545
|
'held': 'held_items', 'held/absorb': 'absorb',
|
|
540
546
|
// Opening a confidential brain from a coding agent (lib/confidential_session.mjs, 2026-10-27).
|
|
541
547
|
'brains/confidential/agent-session': 'confidential_session',
|
|
548
|
+
'brains/confidential/mine': 'confidential_session',
|
|
549
|
+
'brains/confidential/ai-accounts': 'confidential_session',
|
|
542
550
|
}
|
|
543
551
|
|
|
544
552
|
/** PURE. The tool an outage on `url` belongs to: the running tool if known, else a path mapping, else 'other'. */
|
package/lib/server.mjs
CHANGED
|
@@ -6,13 +6,13 @@ import { homedir } from 'os'
|
|
|
6
6
|
import { join } from 'path'
|
|
7
7
|
import { createHash, randomUUID } from 'crypto'
|
|
8
8
|
import { seatChargeRefusal, seatChargeQuestion } from './seat_charge.mjs'
|
|
9
|
-
import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey, setClientVersion, runWithTool, heartbeatPolicy, nextPingFailures, clockMark, sleptBetween, internetReachable } from './diagnose.mjs'
|
|
9
|
+
import { fetchCortex, classify, resolveBase, resolveEnvToken, setSessionKey, setAiAccount, setClientVersion, runWithTool, heartbeatPolicy, nextPingFailures, clockMark, sleptBetween, internetReachable } from './diagnose.mjs'
|
|
10
10
|
import { REPORT_KINDS, REPORT_ISSUE_DESCRIPTION, fileIssue } from './report_issue.mjs'
|
|
11
11
|
import { folderClaimLine } from './folder_claims.mjs'
|
|
12
12
|
import { renderFolderClaimOffers, renderIdentifierResolution, renderUnroutedPathStamps } from './identifier_routes.mjs'
|
|
13
13
|
import { renderDeclines, renderFolderDecisionsApplied, renderFolderQuestions } from './folder_decisions.mjs'
|
|
14
14
|
import { resolveSessionKey, resolveLogSessionId } from './session_key.mjs'
|
|
15
|
-
import {
|
|
15
|
+
import { aiAccountOf, confidentialBrainNamed, fetchMyConfidential, gatherAgentProof, markLockedIn, requestSeatToken } from './confidential_session.mjs'
|
|
16
16
|
import { runSendImessage } from './imessage_send.mjs'
|
|
17
17
|
import { formatGrepHits } from './grep_cli.mjs'
|
|
18
18
|
import { buildProposal, renderProposal, withAskNotice } from './propose_obligation.mjs'
|
|
@@ -257,9 +257,13 @@ export async function gate5StatusFromResponse(res) {
|
|
|
257
257
|
// The Agnoclast MCP server (stdio). Serves the signed-in employee's scoped org
|
|
258
258
|
// context to their AI assistant. CORTEX_TOKEN identifies the user + org.
|
|
259
259
|
|
|
260
|
+
// See the registerTool wrapper in runServer: read tools that take an optional `brain` naming a confidential brain.
|
|
261
|
+
const CONFIDENTIAL_ENTRY_TOOLS = new Set(['grep', 'read_page', 'search_org', 'list_brain_pages', 'list_records', 'project_status', 'my_obligations', 'edit_page', 'my_context'])
|
|
262
|
+
const CONFIDENTIAL_BRAIN_ARG = z.string().optional().describe('ONLY to work in a 🔒 confidential brain that my_brains lists: its name. Using it locks this session to that brain (or is refused if the session already used another brain). Omit it otherwise.')
|
|
263
|
+
|
|
260
264
|
export async function runServer(version) {
|
|
261
|
-
// `let`, not `const`:
|
|
262
|
-
// for a 15-minute SEAT token, renewed below, and every request reads this binding at call time.
|
|
265
|
+
// `let`, not `const`: once this session uses a confidential brain (lib/confidential_session.mjs), the person's
|
|
266
|
+
// token is traded for a 15-minute SEAT token, renewed below, and every request reads this binding at call time.
|
|
263
267
|
let TOKEN = resolveEnvToken().token
|
|
264
268
|
const BASE = resolveBase(process.env.CORTEX_URL)
|
|
265
269
|
|
|
@@ -268,34 +272,6 @@ export async function runServer(version) {
|
|
|
268
272
|
process.exit(1)
|
|
269
273
|
}
|
|
270
274
|
|
|
271
|
-
const confidentialBrain = process.env[CONFIDENTIAL_BRAIN_ENV]
|
|
272
|
-
if (!confidentialBrain && inConfidentialSession()) {
|
|
273
|
-
// The ordinary server, inside a session started for a confidential brain: it must reach nothing else.
|
|
274
|
-
process.stderr.write('cortex-mcp: this session is for a confidential brain, so the ordinary Agnoclast server stays off.\n')
|
|
275
|
-
process.exit(0)
|
|
276
|
-
}
|
|
277
|
-
if (confidentialBrain) {
|
|
278
|
-
// Nothing from this session may reach a local summarizer running on some other AI account.
|
|
279
|
-
process.env.CORTEX_SUMMARIZE_DISABLED = '1'
|
|
280
|
-
const open = async () => {
|
|
281
|
-
const got = gatherAgentProof()
|
|
282
|
-
if (got.refused) return { message: got.refused }
|
|
283
|
-
return requestSeatToken({ base: BASE, token: resolveEnvToken().token, brain: confidentialBrain, proof: got.proof, fetchImpl: fetchCortex })
|
|
284
|
-
}
|
|
285
|
-
const first = await open()
|
|
286
|
-
if (!first.token) return serveConfidentialRefusal(version, first.message)
|
|
287
|
-
TOKEN = first.token
|
|
288
|
-
// Renew a few minutes early, re-proving the account each time: a /login to another account stops the
|
|
289
|
-
// next renewal, and a renewal that fails leaves a token the server refuses, so the session fails closed.
|
|
290
|
-
const every = Math.max(60, first.expiresIn - 180) * 1000
|
|
291
|
-
setInterval(async () => {
|
|
292
|
-
const next = await open().catch((e) => ({ message: String(e?.message ?? e) }))
|
|
293
|
-
if (next.token) { TOKEN = next.token; return }
|
|
294
|
-
TOKEN = 'confidential-session-closed'
|
|
295
|
-
process.stderr.write(`cortex-mcp: confidential session closed — ${next.message}\n`)
|
|
296
|
-
}, every).unref()
|
|
297
|
-
}
|
|
298
|
-
|
|
299
275
|
// Self active-sessions (ADR-0017): one MCP process = one AI session. A stable per-process key + the
|
|
300
276
|
// working dir identify this session; we heartbeat /api/session-ping while alive so the user can see
|
|
301
277
|
// all THEIR sessions via my_sessions. Self-only on the server; best-effort (never breaks serving).
|
|
@@ -315,6 +291,50 @@ export async function runServer(version) {
|
|
|
315
291
|
// resolve THIS session's brain pointer. Must be set BEFORE the first fetchCortex call below —
|
|
316
292
|
// otherwise the opening requests of a session would silently resolve by the account pointer.
|
|
317
293
|
setSessionKey(SESSION_KEY)
|
|
294
|
+
|
|
295
|
+
// ── CONFIDENTIAL BRAINS: THE FIRST-TOUCH LOCK (Theron, 2026-10-28) ─────────────────────────────────────────
|
|
296
|
+
// Only for a person who holds a confidential seat; for everyone else `confidential.brains` is empty and nothing
|
|
297
|
+
// below runs. The first tool call that names a confidential brain opens it: the AI account is proved, the
|
|
298
|
+
// person's token is traded for a seat token, and the server locks the session IN. Anything else used first
|
|
299
|
+
// locks it OUT on the server, which then refuses the seat with a message this passes on. An AI account
|
|
300
|
+
// dedicated to a confidential brain opens it at once, before any tool runs.
|
|
301
|
+
//
|
|
302
|
+
// Asked in parallel with registering tools and awaited (bounded) before the handshake, like the release state.
|
|
303
|
+
// The AI account is only worked out — a walk up the process tree — for someone who holds a seat.
|
|
304
|
+
let confidential = { brains: [], dedicatedTo: null }
|
|
305
|
+
const confidentialP = (async () => {
|
|
306
|
+
const seats = await fetchMyConfidential({ base: BASE, token: TOKEN, proof: null, fetchImpl: fetchCortex })
|
|
307
|
+
if (!seats.brains.length) return seats
|
|
308
|
+
const got = gatherAgentProof()
|
|
309
|
+
setAiAccount(got.proof ? aiAccountOf(got.proof) : null)
|
|
310
|
+
return got.proof ? fetchMyConfidential({ base: BASE, token: TOKEN, proof: got.proof, fetchImpl: fetchCortex }) : seats
|
|
311
|
+
})().catch(() => ({ brains: [], dedicatedTo: null }))
|
|
312
|
+
let lockedInto = null
|
|
313
|
+
async function openConfidential(brainName) {
|
|
314
|
+
if (lockedInto) return lockedInto.toLowerCase() === brainName.toLowerCase() ? null : `This session is locked to the confidential brain "${lockedInto}". Start a new session to use "${brainName}".`
|
|
315
|
+
const mint = async () => {
|
|
316
|
+
const got = gatherAgentProof()
|
|
317
|
+
if (got.refused) return { message: got.refused }
|
|
318
|
+
return requestSeatToken({ base: BASE, token: resolveEnvToken().token, brain: brainName, proof: got.proof, fetchImpl: fetchCortex })
|
|
319
|
+
}
|
|
320
|
+
const first = await mint().catch((e) => ({ message: String(e?.message ?? e) }))
|
|
321
|
+
if (!first.token) return first.message
|
|
322
|
+
TOKEN = first.token
|
|
323
|
+
lockedInto = first.brain
|
|
324
|
+
// Nothing from this session may reach a local summarizer, or a hook on the person's ordinary account.
|
|
325
|
+
process.env.CORTEX_SUMMARIZE_DISABLED = '1'
|
|
326
|
+
try { markLockedIn(SESSION_KEY, lockedInto) } catch (e) { process.stderr.write(`cortex-mcp: could not mark the session confidential: ${e?.message ?? e}\n`) }
|
|
327
|
+
// Renew a few minutes early, re-proving the account each time: a /login to another account stops the next
|
|
328
|
+
// renewal, and a renewal that fails leaves a token the server refuses, so the session fails closed.
|
|
329
|
+
const every = Math.max(60, first.expiresIn - 180) * 1000
|
|
330
|
+
setInterval(async () => {
|
|
331
|
+
const next = await mint().catch((e) => ({ message: String(e?.message ?? e) }))
|
|
332
|
+
if (next.token) { TOKEN = next.token; return }
|
|
333
|
+
TOKEN = 'confidential-session-closed'
|
|
334
|
+
process.stderr.write(`cortex-mcp: confidential session closed — ${next.message}\n`)
|
|
335
|
+
}, every).unref()
|
|
336
|
+
return null
|
|
337
|
+
}
|
|
318
338
|
// Paired with setSessionKey and set at the same moment, but a SEPARATE signal on purpose: the
|
|
319
339
|
// server labels actor_source from this and watches for `mcp` + no session. Tying the two together
|
|
320
340
|
// would make that pair impossible and blind the detector. See actorSourceFrom in auth_cloud.ts.
|
|
@@ -464,8 +484,19 @@ export async function runServer(version) {
|
|
|
464
484
|
// attributed to the tool that hit it rather than guessed from a URL shared by several tools.
|
|
465
485
|
const registerTool = server.registerTool.bind(server)
|
|
466
486
|
server.registerTool = (name, config, handler) => {
|
|
487
|
+
// The tools a session usually STARTS with read across brains and take no `brain`, so a confidential brain could
|
|
488
|
+
// never be opened through them: give them an optional one. The wrapper below reads it; the handler ignores it.
|
|
489
|
+
if (CONFIDENTIAL_ENTRY_TOOLS.has(name) && config?.inputSchema && !config.inputSchema.brain) {
|
|
490
|
+
config = { ...config, inputSchema: { ...config.inputSchema, brain: CONFIDENTIAL_BRAIN_ARG } }
|
|
491
|
+
}
|
|
467
492
|
const takesArgs = !!config?.inputSchema
|
|
468
493
|
const handle = registerTool(name, config, (...args) => runWithTool(name, async () => {
|
|
494
|
+
// A tool naming a confidential brain opens it first (the first-touch lock, above).
|
|
495
|
+
const named = confidential.brains.length && takesArgs ? confidentialBrainNamed(confidential.brains, args[0]?.brain) : null
|
|
496
|
+
if (named) {
|
|
497
|
+
const refused = await openConfidential(named.name)
|
|
498
|
+
if (refused) return { content: [{ type: 'text', text: refused }], isError: true }
|
|
499
|
+
}
|
|
469
500
|
// A LOCKED tool runs nothing: the server's answer says what it would have done and how Regular is
|
|
470
501
|
// reached. "Not locked any more" (the trial started mid-session) → the tool runs as usual; a check that
|
|
471
502
|
// cannot be made → nothing runs (fails closed).
|
|
@@ -4930,7 +4961,14 @@ function renderNudge(payload) {
|
|
|
4930
4961
|
const header = brains.length === 1
|
|
4931
4962
|
? 'Your brain:'
|
|
4932
4963
|
: 'Your brains (reads span all of them; an edit routes to the brain holding the page; creating a NEW page takes an explicit `brain`):'
|
|
4933
|
-
|
|
4964
|
+
// Confidential brains are reached through a seat, so /api/brains never lists them: say they exist and how
|
|
4965
|
+
// they open, so the AI can use one by name.
|
|
4966
|
+
const seats = !lockedInto && confidential.brains.length
|
|
4967
|
+
? `\n\n🔒 Confidential (a session works in one of these ALONE): ${confidential.brains.map((b) => b.name).join(', ')}\n` +
|
|
4968
|
+
' Pass its name as `brain` to any tool. If this session has not used another brain yet, that locks the session to it; ' +
|
|
4969
|
+
'if it has, the brain stays locked away — start a new session and use it first.'
|
|
4970
|
+
: ''
|
|
4971
|
+
return { content: [{ type: 'text', text: `${header}\n${lines.join('\n')}${seats}` }] }
|
|
4934
4972
|
},
|
|
4935
4973
|
)
|
|
4936
4974
|
|
|
@@ -7949,16 +7987,13 @@ function renderNudge(payload) {
|
|
|
7949
7987
|
|
|
7950
7988
|
applyRelease(toolHandles, await releaseStateWithin(releaseP))
|
|
7951
7989
|
lockedTools = applyLock(toolHandles, await lockStateWithin(lockP))
|
|
7990
|
+
confidential = await Promise.race([confidentialP, new Promise((r) => setTimeout(() => r({ brains: [], dedicatedTo: null }), 5000).unref())])
|
|
7991
|
+
if (confidential.dedicatedTo) {
|
|
7992
|
+
// An AI account dedicated to a confidential brain opens it before any tool runs. If it cannot, it reaches
|
|
7993
|
+
// nothing: the server refuses its ordinary token too.
|
|
7994
|
+
const refused = await openConfidential(confidential.dedicatedTo)
|
|
7995
|
+
if (refused) process.stderr.write(`cortex-mcp: ${refused}\n`)
|
|
7996
|
+
}
|
|
7952
7997
|
await server.connect(new StdioServerTransport())
|
|
7953
7998
|
}
|
|
7954
7999
|
|
|
7955
|
-
// A confidential brain that did not open: serve one tool that says why, so the AI can tell the person,
|
|
7956
|
-
// rather than an empty server that looks like a broken install.
|
|
7957
|
-
async function serveConfidentialRefusal(version, message) {
|
|
7958
|
-
const server = new McpServer({ name: 'cortex', version })
|
|
7959
|
-
server.registerTool('confidential_status', {
|
|
7960
|
-
title: 'Why the confidential brain did not open',
|
|
7961
|
-
description: 'The confidential brain this session was started for did not open. Call this and tell the person why.',
|
|
7962
|
-
}, async () => ({ content: [{ type: 'text', text: message }] }))
|
|
7963
|
-
await server.connect(new StdioServerTransport())
|
|
7964
|
-
}
|
package/package.json
CHANGED