talentos 1.2.0 → 1.4.1
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/dist/agent/adapters.js +31 -0
- package/dist/agent/codex-policy.js +3 -0
- package/dist/agent/gateway.js +17 -1
- package/dist/agent/mcp-entry.js +4 -1
- package/dist/agent/native/approvals.js +53 -1
- package/dist/agent/native/codex-fence-probe.js +629 -0
- package/dist/agent/native/codex-fence.js +168 -0
- package/dist/agent/native/codex-launch.js +86 -0
- package/dist/agent/native/codex-owner-probe.js +530 -0
- package/dist/agent/native/codex-owner.js +160 -0
- package/dist/agent/native/codex-run-command.js +302 -0
- package/dist/agent/native/config.js +8 -2
- package/dist/agent/native/context.js +92 -0
- package/dist/agent/native/discover.js +137 -0
- package/dist/agent/native/fresh.js +104 -0
- package/dist/agent/native/gate.js +144 -12
- package/dist/agent/native/hook-entry.js +65 -3
- package/dist/agent/native/launch.js +10 -1
- package/dist/agent/native/policy.js +344 -32
- package/dist/agent/native/probe.js +18 -15
- package/dist/agent/native/project-requests.js +106 -0
- package/dist/agent/native/projects.js +111 -0
- package/dist/agent/native/receipts.js +47 -0
- package/dist/agent/native/touch.js +153 -0
- package/dist/agent/native/workspace.js +20 -5
- package/dist/agent/serve.js +105 -6
- package/dist/agent-service.js +14 -1
- package/dist/args.js +1 -0
- package/dist/commands/agent-native.js +41 -7
- package/dist/commands/agent.js +5 -1
- package/dist/gateway-install.js +15 -0
- package/dist/mcp-proxy.js +25 -2
- package/package.json +1 -1
|
@@ -0,0 +1,530 @@
|
|
|
1
|
+
import { spawn } from "node:child_process";
|
|
2
|
+
import { createHash } from "node:crypto";
|
|
3
|
+
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
|
|
4
|
+
import { createServer } from "node:http";
|
|
5
|
+
import { tmpdir } from "node:os";
|
|
6
|
+
import { join } from "node:path";
|
|
7
|
+
import { probeResponse } from "../codex-probe.js";
|
|
8
|
+
import { codexHookArgs, trustHookArgs } from "./codex-owner.js";
|
|
9
|
+
// The behavioural proof Codex owner-native would rest on (#10987, R13's musts).
|
|
10
|
+
// A real `codex` runs against a loopback Responses API that scripts one tool
|
|
11
|
+
// call per cell, with our PreToolUse hook installed and trusted by hash exactly
|
|
12
|
+
// as a job would, in an isolated CODEX_HOME. Every cell is "the call was seen by
|
|
13
|
+
// the hook AND its refusal held" (or, for the bypass classes, "the effect never
|
|
14
|
+
// happened"). Anything not proven is a failure: a Codex version that fails any
|
|
15
|
+
// cell stays room-only. Opt-in test: TALENTOS_TEST_CODEX.
|
|
16
|
+
export const CODEX_PROBE_REVISION = 2;
|
|
17
|
+
const RUN_MS = 25_000;
|
|
18
|
+
const MCP_NAME = /probe_mcp/u;
|
|
19
|
+
export const CODEX_CELLS = [
|
|
20
|
+
"trust",
|
|
21
|
+
"bash",
|
|
22
|
+
"bash_sandboxed",
|
|
23
|
+
"stdin",
|
|
24
|
+
"proc_fd",
|
|
25
|
+
"apply_patch",
|
|
26
|
+
"view_image",
|
|
27
|
+
"mcp_tool",
|
|
28
|
+
"mcp_resource",
|
|
29
|
+
"subagent",
|
|
30
|
+
"exec_js",
|
|
31
|
+
"owner_trust_untouched",
|
|
32
|
+
"repo_hooks_ignored",
|
|
33
|
+
];
|
|
34
|
+
// The hook our probe installs: records every call, allows only the opening
|
|
35
|
+
// `sh` of the stdin cell (and the one command a cell names in PROBE_ALLOW),
|
|
36
|
+
// refuses everything else.
|
|
37
|
+
const HOOK = `#!/usr/bin/env node
|
|
38
|
+
let raw = "";
|
|
39
|
+
process.stdin.on("data", (c) => (raw += c));
|
|
40
|
+
process.stdin.on("end", () => {
|
|
41
|
+
const call = JSON.parse(raw);
|
|
42
|
+
require("node:fs").appendFileSync(process.env.PROBE_RECORDS, raw.replace(/\\n/g, " ") + "\\n");
|
|
43
|
+
const open =
|
|
44
|
+
(call.tool_name === "Bash" && call.tool_input?.command === "sh") ||
|
|
45
|
+
(call.tool_name === "Bash" && process.env.PROBE_ALLOW && call.tool_input?.command === process.env.PROBE_ALLOW) ||
|
|
46
|
+
call.tool_name === "collaborationspawn_agent";
|
|
47
|
+
process.stdout.write(JSON.stringify({ hookSpecificOutput: {
|
|
48
|
+
hookEventName: "PreToolUse",
|
|
49
|
+
permissionDecision: open ? "allow" : "deny",
|
|
50
|
+
permissionDecisionReason: "probe",
|
|
51
|
+
} }));
|
|
52
|
+
});
|
|
53
|
+
`;
|
|
54
|
+
function message(text) {
|
|
55
|
+
return {
|
|
56
|
+
type: "message",
|
|
57
|
+
id: "answer",
|
|
58
|
+
role: "assistant",
|
|
59
|
+
status: "completed",
|
|
60
|
+
content: [{ type: "output_text", text, annotations: [] }],
|
|
61
|
+
};
|
|
62
|
+
}
|
|
63
|
+
// The subagent cell's parent: spawn, wait for the child, finish.
|
|
64
|
+
function parentStep(turn) {
|
|
65
|
+
if (turn === 1) {
|
|
66
|
+
return {
|
|
67
|
+
type: "function_call",
|
|
68
|
+
id: "spawn",
|
|
69
|
+
call_id: "spawn",
|
|
70
|
+
name: "spawn_agent",
|
|
71
|
+
namespace: "collaboration",
|
|
72
|
+
arguments: JSON.stringify({
|
|
73
|
+
message: "child task",
|
|
74
|
+
task_name: "probe_child",
|
|
75
|
+
}),
|
|
76
|
+
status: "completed",
|
|
77
|
+
};
|
|
78
|
+
}
|
|
79
|
+
if (turn === 2) {
|
|
80
|
+
return {
|
|
81
|
+
type: "function_call",
|
|
82
|
+
id: "wait",
|
|
83
|
+
call_id: "wait",
|
|
84
|
+
name: "wait_agent",
|
|
85
|
+
namespace: "collaboration",
|
|
86
|
+
arguments: JSON.stringify({ timeout_ms: 15_000 }),
|
|
87
|
+
status: "completed",
|
|
88
|
+
};
|
|
89
|
+
}
|
|
90
|
+
return message("done");
|
|
91
|
+
}
|
|
92
|
+
/**
|
|
93
|
+
* A Python script (argv[1] is the line to type) that walks up to the nearest
|
|
94
|
+
* `codex` ancestor and types the line into every pipe or pty master open in
|
|
95
|
+
* that process tree but its own, two ways: reopening `/proc/<pid>/fd/<n>`
|
|
96
|
+
* (non-blocking, so a pipe with no reader is skipped) and taking the fd itself
|
|
97
|
+
* with `pidfd_getfd` (434/438 on x86_64 and arm64). Writes what it reached to
|
|
98
|
+
* argv[2], the proof that it ran.
|
|
99
|
+
*/
|
|
100
|
+
export const INJECTOR = `import ctypes, os, sys
|
|
101
|
+
line = sys.argv[1].encode() + b"\\n"
|
|
102
|
+
libc = ctypes.CDLL(None, use_errno=True)
|
|
103
|
+
def stat(pid):
|
|
104
|
+
try:
|
|
105
|
+
text = open("/proc/%d/stat" % pid).read()
|
|
106
|
+
except OSError:
|
|
107
|
+
return None
|
|
108
|
+
close = text.rindex(")")
|
|
109
|
+
return text[text.index("(") + 1:close], int(text[close + 2:].split()[1])
|
|
110
|
+
def tree():
|
|
111
|
+
root, at = None, os.getpid()
|
|
112
|
+
while at > 1 and root is None:
|
|
113
|
+
info = stat(at)
|
|
114
|
+
if info is None:
|
|
115
|
+
break
|
|
116
|
+
if info[0].startswith("codex"):
|
|
117
|
+
root = at
|
|
118
|
+
at = info[1]
|
|
119
|
+
if root is None:
|
|
120
|
+
return []
|
|
121
|
+
out = []
|
|
122
|
+
for name in os.listdir("/proc"):
|
|
123
|
+
if not name.isdigit() or int(name) == os.getpid():
|
|
124
|
+
continue
|
|
125
|
+
at = int(name)
|
|
126
|
+
while at > 1 and at != root:
|
|
127
|
+
info = stat(at)
|
|
128
|
+
at = info[1] if info else 1
|
|
129
|
+
if at == root:
|
|
130
|
+
out.append(int(name))
|
|
131
|
+
return out
|
|
132
|
+
reopened = taken = 0
|
|
133
|
+
for pid in tree():
|
|
134
|
+
# Codex's own pipes carry its internal protocols; its pty masters are
|
|
135
|
+
# the session channel. Other processes: every pipe.
|
|
136
|
+
own = (stat(pid) or ("",))[0].startswith("codex")
|
|
137
|
+
try:
|
|
138
|
+
fds = os.listdir("/proc/%d/fd" % pid)
|
|
139
|
+
except OSError:
|
|
140
|
+
continue
|
|
141
|
+
pidfd = libc.syscall(434, pid, 0)
|
|
142
|
+
for fd in fds:
|
|
143
|
+
try:
|
|
144
|
+
target = os.readlink("/proc/%d/fd/%s" % (pid, fd))
|
|
145
|
+
except OSError:
|
|
146
|
+
continue
|
|
147
|
+
if not ("ptmx" in target or (target.startswith("pipe:") and not own)):
|
|
148
|
+
continue
|
|
149
|
+
if target.startswith("pipe:"):
|
|
150
|
+
try:
|
|
151
|
+
out = os.open("/proc/%d/fd/%s" % (pid, fd), os.O_WRONLY | os.O_NONBLOCK)
|
|
152
|
+
os.write(out, line)
|
|
153
|
+
os.close(out)
|
|
154
|
+
reopened += 1
|
|
155
|
+
except OSError:
|
|
156
|
+
pass
|
|
157
|
+
if pidfd >= 0:
|
|
158
|
+
got = libc.syscall(438, pidfd, int(fd), 0)
|
|
159
|
+
if got >= 0:
|
|
160
|
+
try:
|
|
161
|
+
os.set_blocking(got, False)
|
|
162
|
+
os.write(got, line)
|
|
163
|
+
taken += 1
|
|
164
|
+
except OSError:
|
|
165
|
+
pass
|
|
166
|
+
os.close(got)
|
|
167
|
+
import time
|
|
168
|
+
time.sleep(1)
|
|
169
|
+
open(sys.argv[2], "w").write("reopened %d taken %d" % (reopened, taken))
|
|
170
|
+
`;
|
|
171
|
+
async function runCell(binary, root, options, signal) {
|
|
172
|
+
const home = mkdtempSync(join(root, "home-"));
|
|
173
|
+
const work = mkdtempSync(join(root, "work-"));
|
|
174
|
+
const records = join(root, `records-${createHash("sha1").update(home).digest("hex")}`);
|
|
175
|
+
writeFileSync(records, "");
|
|
176
|
+
const hook = join(root, "hook.js");
|
|
177
|
+
writeFileSync(hook, HOOK, { mode: 0o700 });
|
|
178
|
+
if (options.ownerConfig) {
|
|
179
|
+
writeFileSync(join(home, "config.toml"), options.ownerConfig);
|
|
180
|
+
}
|
|
181
|
+
if (options.repoConfig) {
|
|
182
|
+
mkdirSync(join(work, ".codex"), { recursive: true });
|
|
183
|
+
writeFileSync(join(work, ".codex", "config.toml"), options.repoConfig);
|
|
184
|
+
}
|
|
185
|
+
let canaryHits = 0;
|
|
186
|
+
let turn = 0;
|
|
187
|
+
let canaryUrl = "";
|
|
188
|
+
const scriptText = () => typeof options.script === "function"
|
|
189
|
+
? options.script(canaryUrl, work)
|
|
190
|
+
: options.script;
|
|
191
|
+
const server = createServer(async (request, response) => {
|
|
192
|
+
let raw = "";
|
|
193
|
+
for await (const chunk of request) {
|
|
194
|
+
raw += chunk.toString();
|
|
195
|
+
}
|
|
196
|
+
if (request.url?.startsWith("/canary")) {
|
|
197
|
+
canaryHits += 1;
|
|
198
|
+
response.end("canary");
|
|
199
|
+
return;
|
|
200
|
+
}
|
|
201
|
+
const body = JSON.parse(raw);
|
|
202
|
+
const input = (body.input ?? []);
|
|
203
|
+
const answered = input.some((item) => String(item.type).endsWith("_output"));
|
|
204
|
+
const last = input.at(-1);
|
|
205
|
+
if (options.child) {
|
|
206
|
+
// A parent that spawns a subagent and WAITS for it, so the child's call
|
|
207
|
+
// is made before the run ends; the child's own turn is scripted too.
|
|
208
|
+
if (last?.type === "agent_message" && !answered) {
|
|
209
|
+
probeResponse(response, options.child());
|
|
210
|
+
return;
|
|
211
|
+
}
|
|
212
|
+
if (last?.type === "custom_tool_call_output") {
|
|
213
|
+
probeResponse(response, message("child done"));
|
|
214
|
+
return;
|
|
215
|
+
}
|
|
216
|
+
turn += 1;
|
|
217
|
+
probeResponse(response, parentStep(turn));
|
|
218
|
+
return;
|
|
219
|
+
}
|
|
220
|
+
turn += 1;
|
|
221
|
+
probeResponse(response, turn === 1 && !answered
|
|
222
|
+
? {
|
|
223
|
+
type: "custom_tool_call",
|
|
224
|
+
id: "call",
|
|
225
|
+
call_id: "call",
|
|
226
|
+
name: "exec",
|
|
227
|
+
input: scriptText(),
|
|
228
|
+
status: "completed",
|
|
229
|
+
}
|
|
230
|
+
: message("done"));
|
|
231
|
+
});
|
|
232
|
+
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
233
|
+
const address = server.address();
|
|
234
|
+
if (!address || typeof address === "string") {
|
|
235
|
+
throw new Error("Missing probe port");
|
|
236
|
+
}
|
|
237
|
+
canaryUrl = `http://127.0.0.1:${address.port}/canary`;
|
|
238
|
+
const env = {
|
|
239
|
+
CODEX_HOME: home,
|
|
240
|
+
HOME: home,
|
|
241
|
+
PATH: process.env.PATH,
|
|
242
|
+
...(options.allow ? { PROBE_ALLOW: options.allow } : {}),
|
|
243
|
+
PROBE_RECORDS: records,
|
|
244
|
+
TALENTOS_PROBE_KEY: "loopback-only",
|
|
245
|
+
};
|
|
246
|
+
try {
|
|
247
|
+
const hookArgs = codexHookArgs(hook);
|
|
248
|
+
const trust = options.trusted === false
|
|
249
|
+
? []
|
|
250
|
+
: await trustHookArgs({
|
|
251
|
+
binary,
|
|
252
|
+
command: hook,
|
|
253
|
+
cwd: work,
|
|
254
|
+
env,
|
|
255
|
+
signal,
|
|
256
|
+
});
|
|
257
|
+
const args = [
|
|
258
|
+
"-c",
|
|
259
|
+
'model_provider="talentos_probe"',
|
|
260
|
+
"-c",
|
|
261
|
+
'model_providers.talentos_probe.name="Loopback"',
|
|
262
|
+
"-c",
|
|
263
|
+
`model_providers.talentos_probe.base_url="http://127.0.0.1:${address.port}/v1"`,
|
|
264
|
+
"-c",
|
|
265
|
+
'model_providers.talentos_probe.wire_api="responses"',
|
|
266
|
+
"-c",
|
|
267
|
+
'model_providers.talentos_probe.env_key="TALENTOS_PROBE_KEY"',
|
|
268
|
+
"-c",
|
|
269
|
+
`sandbox_mode="${options.sandbox ?? "danger-full-access"}"`,
|
|
270
|
+
// /tmp is writable under workspace-write by default; the probe root
|
|
271
|
+
// lives there, so keep it out for the sandbox control to mean anything.
|
|
272
|
+
"-c",
|
|
273
|
+
"sandbox_workspace_write.exclude_slash_tmp=true",
|
|
274
|
+
"-c",
|
|
275
|
+
"sandbox_workspace_write.exclude_tmpdir_env_var=true",
|
|
276
|
+
"-c",
|
|
277
|
+
`approval_policy="${options.approval ?? "never"}"`,
|
|
278
|
+
...hookArgs,
|
|
279
|
+
...trust,
|
|
280
|
+
...(options.extraArgs ?? []),
|
|
281
|
+
"exec",
|
|
282
|
+
"--json",
|
|
283
|
+
"--skip-git-repo-check",
|
|
284
|
+
"probe",
|
|
285
|
+
];
|
|
286
|
+
const child = spawn(binary, args, {
|
|
287
|
+
cwd: work,
|
|
288
|
+
env,
|
|
289
|
+
stdio: ["ignore", "ignore", "ignore"],
|
|
290
|
+
});
|
|
291
|
+
const stop = () => child.kill("SIGKILL");
|
|
292
|
+
signal.addEventListener("abort", stop, { once: true });
|
|
293
|
+
const timer = setTimeout(stop, RUN_MS);
|
|
294
|
+
await new Promise((resolve) => child.once("close", resolve));
|
|
295
|
+
clearTimeout(timer);
|
|
296
|
+
signal.removeEventListener("abort", stop);
|
|
297
|
+
}
|
|
298
|
+
finally {
|
|
299
|
+
server.closeAllConnections();
|
|
300
|
+
await new Promise((resolve) => server.close(() => resolve()));
|
|
301
|
+
}
|
|
302
|
+
const records_ = readFileSync(records, "utf8")
|
|
303
|
+
.split("\n")
|
|
304
|
+
.filter(Boolean)
|
|
305
|
+
.map((line) => JSON.parse(line));
|
|
306
|
+
return { canaryHits, home, records: records_, work };
|
|
307
|
+
}
|
|
308
|
+
const seen = (run, tool) => run.records.filter((record) => record.tool_name === tool);
|
|
309
|
+
/**
|
|
310
|
+
* Proves, on the real binary, every class of call our hook has to see. A
|
|
311
|
+
* failing cell makes this Codex version room-only. Never run per job.
|
|
312
|
+
*/
|
|
313
|
+
export async function probeCodexOwnerNative(binary, version, signal = AbortSignal.timeout(180_000)) {
|
|
314
|
+
const root = mkdtempSync(join(tmpdir(), "talentos-codex-owner-"));
|
|
315
|
+
const marker = (name) => join(root, `marker-${name}`);
|
|
316
|
+
const cells = Object.fromEntries(CODEX_CELLS.map((cell) => [cell, "fail"]));
|
|
317
|
+
const cell = async (name, check) => {
|
|
318
|
+
try {
|
|
319
|
+
cells[name] = (await check()) ? "pass" : "fail";
|
|
320
|
+
}
|
|
321
|
+
catch {
|
|
322
|
+
cells[name] = "fail";
|
|
323
|
+
}
|
|
324
|
+
};
|
|
325
|
+
// A script is code-mode JavaScript: it can only reach the outside through
|
|
326
|
+
// nested tools, which is what makes the hook sufficient.
|
|
327
|
+
const js = (body) => body;
|
|
328
|
+
try {
|
|
329
|
+
// Trust: our hook runs with no bypass flag, and without its hash it does
|
|
330
|
+
// NOT run (the fail-open a launcher must never leave open).
|
|
331
|
+
await cell("trust", async () => {
|
|
332
|
+
const script = js(`await tools.exec_command({cmd: ${JSON.stringify(`echo x > ${marker("trust-a")}`)}});`);
|
|
333
|
+
const trusted = await runCell(binary, root, { script }, signal);
|
|
334
|
+
const held = seen(trusted, "Bash").length === 1 && !existsSync(marker("trust-a"));
|
|
335
|
+
// Control: with no trust the hook is silently skipped and the command runs.
|
|
336
|
+
const untrusted = await runCell(binary, root, { script, trusted: false }, signal);
|
|
337
|
+
return (held && untrusted.records.length === 0 && existsSync(marker("trust-a")));
|
|
338
|
+
});
|
|
339
|
+
await cell("bash", async () => {
|
|
340
|
+
for (const approval of ["never", "on-request"]) {
|
|
341
|
+
const file = marker(`bash-${approval}`);
|
|
342
|
+
const run = await runCell(binary, root, {
|
|
343
|
+
approval,
|
|
344
|
+
script: js(`await tools.exec_command({cmd: ${JSON.stringify(`echo x > ${file}`)}});`),
|
|
345
|
+
}, signal);
|
|
346
|
+
if (seen(run, "Bash").length !== 1 || existsSync(file)) {
|
|
347
|
+
return false;
|
|
348
|
+
}
|
|
349
|
+
}
|
|
350
|
+
return true;
|
|
351
|
+
});
|
|
352
|
+
// The same deny under Codex's own OS sandbox (bubblewrap on Linux,
|
|
353
|
+
// Seatbelt on macOS): a sandbox is a backstop, never a reason to skip the
|
|
354
|
+
// hook. A host where the sandbox cannot start fails this cell.
|
|
355
|
+
await cell("bash_sandboxed", async () => {
|
|
356
|
+
for (const sandbox of ["workspace-write", "read-only"]) {
|
|
357
|
+
for (const approval of ["never", "on-request"]) {
|
|
358
|
+
const name = `sandboxed-${sandbox}-${approval}`;
|
|
359
|
+
const run = await runCell(binary, root, {
|
|
360
|
+
approval,
|
|
361
|
+
sandbox,
|
|
362
|
+
script: (_canary, work) => js(`await tools.exec_command({cmd: ${JSON.stringify(`echo x > ${join(work, name)}`)}});`),
|
|
363
|
+
}, signal);
|
|
364
|
+
if (seen(run, "Bash").length !== 1 ||
|
|
365
|
+
existsSync(join(run.work, name))) {
|
|
366
|
+
return false;
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
}
|
|
370
|
+
// Control: the sandbox really runs here (an allowed write inside the
|
|
371
|
+
// workspace lands, one outside it does not).
|
|
372
|
+
const inside = "sandbox-control";
|
|
373
|
+
const outside = marker("sandbox-outside");
|
|
374
|
+
const command = `echo x > ${inside}; echo x > ${outside}`;
|
|
375
|
+
const run = await runCell(binary, root, {
|
|
376
|
+
allow: command,
|
|
377
|
+
sandbox: "workspace-write",
|
|
378
|
+
script: js(`await tools.exec_command({cmd: ${JSON.stringify(command)}});`),
|
|
379
|
+
}, signal);
|
|
380
|
+
return existsSync(join(run.work, inside)) && !existsSync(outside);
|
|
381
|
+
});
|
|
382
|
+
// R13 (1): an open exec session driven through write_stdin. The first `sh`
|
|
383
|
+
// is allowed; what the model then types into it must never run.
|
|
384
|
+
await cell("stdin", async () => {
|
|
385
|
+
const file = marker("stdin");
|
|
386
|
+
await runCell(binary, root, {
|
|
387
|
+
script: js(`const r = await tools.exec_command({cmd: "sh", tty: true, yield_time_ms: 300});
|
|
388
|
+
if (r.session_id !== undefined) { await tools.write_stdin({session_id: r.session_id, chars: ${JSON.stringify(`echo x > ${file}\n`)}, yield_time_ms: 800}); }`),
|
|
389
|
+
}, signal);
|
|
390
|
+
return !existsSync(file);
|
|
391
|
+
});
|
|
392
|
+
// The ancestor-fd channel: a same-user child of an approved command takes
|
|
393
|
+
// the open session's input from the Codex process tree, by reopening
|
|
394
|
+
// /proc/<pid>/fd/* or with pidfd_getfd, and types a command into it. That
|
|
395
|
+
// command runs with no hook call. macOS has neither (the cell passes
|
|
396
|
+
// there because the channel does not exist); without python3 it fails.
|
|
397
|
+
await cell("proc_fd", async () => {
|
|
398
|
+
const file = marker("procfd");
|
|
399
|
+
const injector = join(root, "inject.py");
|
|
400
|
+
writeFileSync(injector, INJECTOR);
|
|
401
|
+
const ran = marker("procfd-ran");
|
|
402
|
+
const command = `python3 -I ${injector} ${JSON.stringify(`echo x > ${file}`)} ${ran}`;
|
|
403
|
+
const run = await runCell(binary, root, {
|
|
404
|
+
allow: command,
|
|
405
|
+
script: js(`await tools.exec_command({cmd: "sh", yield_time_ms: 300});
|
|
406
|
+
await tools.exec_command({cmd: "sh", tty: true, yield_time_ms: 300});
|
|
407
|
+
await tools.exec_command({cmd: ${JSON.stringify(command)}, yield_time_ms: 3000});`),
|
|
408
|
+
}, signal);
|
|
409
|
+
return (existsSync(ran) &&
|
|
410
|
+
!existsSync(file) &&
|
|
411
|
+
seen(run, "Bash").some((call) => call.tool_input?.command === command));
|
|
412
|
+
});
|
|
413
|
+
// R13 (2): the hook sees every path of a patch, renames and deletes too.
|
|
414
|
+
await cell("apply_patch", async () => {
|
|
415
|
+
const dir = join(root, "patch");
|
|
416
|
+
mkdirSync(dir, { recursive: true });
|
|
417
|
+
writeFileSync(join(dir, "old.txt"), "a\n");
|
|
418
|
+
writeFileSync(join(dir, "gone.txt"), "x");
|
|
419
|
+
const patch = `*** Begin Patch\n*** Add File: ${dir}/new.txt\n+hello\n*** Update File: ${dir}/old.txt\n*** Move to: ${dir}/moved.txt\n@@\n-a\n+b\n*** Delete File: ${dir}/gone.txt\n*** End Patch`;
|
|
420
|
+
const run = await runCell(binary, root, { script: js(`await tools.apply_patch(${JSON.stringify(patch)});`) }, signal);
|
|
421
|
+
const [call] = seen(run, "apply_patch");
|
|
422
|
+
const text = String(call?.tool_input?.command ?? "");
|
|
423
|
+
return ([
|
|
424
|
+
`${dir}/new.txt`,
|
|
425
|
+
`${dir}/old.txt`,
|
|
426
|
+
`${dir}/moved.txt`,
|
|
427
|
+
`${dir}/gone.txt`,
|
|
428
|
+
].every((path) => text.includes(path)) &&
|
|
429
|
+
!existsSync(join(dir, "new.txt")) &&
|
|
430
|
+
!existsSync(join(dir, "moved.txt")) &&
|
|
431
|
+
existsSync(join(dir, "gone.txt")));
|
|
432
|
+
});
|
|
433
|
+
await cell("view_image", async () => {
|
|
434
|
+
const run = await runCell(binary, root, {
|
|
435
|
+
script: js(`await tools.view_image({path: ${JSON.stringify(join(root, "x.png"))}});`),
|
|
436
|
+
}, signal);
|
|
437
|
+
return seen(run, "view_image").length === 1;
|
|
438
|
+
});
|
|
439
|
+
await cell("mcp_resource", async () => {
|
|
440
|
+
const run = await runCell(binary, root, {
|
|
441
|
+
script: js(`await tools.read_mcp_resource({server: "probe", uri: "file:///etc/hosts"});`),
|
|
442
|
+
}, signal);
|
|
443
|
+
return seen(run, "read_mcp_resource").length === 1;
|
|
444
|
+
});
|
|
445
|
+
await cell("mcp_tool", async () => {
|
|
446
|
+
const file = marker("mcp");
|
|
447
|
+
const server = join(root, "mcp.mjs");
|
|
448
|
+
writeFileSync(server, `import {Server} from ${JSON.stringify(import.meta.resolve("@modelcontextprotocol/sdk/server/index.js"))};
|
|
449
|
+
import {StdioServerTransport} from ${JSON.stringify(import.meta.resolve("@modelcontextprotocol/sdk/server/stdio.js"))};
|
|
450
|
+
import {ListToolsRequestSchema,CallToolRequestSchema} from ${JSON.stringify(import.meta.resolve("@modelcontextprotocol/sdk/types.js"))};
|
|
451
|
+
import {writeFileSync} from "node:fs";
|
|
452
|
+
const s=new Server({name:"probe_mcp",version:"1"},{capabilities:{tools:{}}});
|
|
453
|
+
s.setRequestHandler(ListToolsRequestSchema,async()=>({tools:[{name:"mark",description:"mark",inputSchema:{type:"object",properties:{}}}]}));
|
|
454
|
+
s.setRequestHandler(CallToolRequestSchema,async()=>{writeFileSync(${JSON.stringify(file)},"1");return {content:[{type:"text",text:"ok"}]};});
|
|
455
|
+
await s.connect(new StdioServerTransport());`);
|
|
456
|
+
const run = await runCell(binary, root, {
|
|
457
|
+
extraArgs: [
|
|
458
|
+
"-c",
|
|
459
|
+
`mcp_servers.probe_mcp.command=${JSON.stringify(process.execPath)}`,
|
|
460
|
+
"-c",
|
|
461
|
+
`mcp_servers.probe_mcp.args=${JSON.stringify([server])}`,
|
|
462
|
+
],
|
|
463
|
+
script: js("await tools.mcp__probe_mcp__mark({});"),
|
|
464
|
+
}, signal);
|
|
465
|
+
return (run.records.some((record) => MCP_NAME.test(String(record.tool_name))) &&
|
|
466
|
+
!existsSync(file));
|
|
467
|
+
});
|
|
468
|
+
// A subagent's calls are hooked and refused too (they carry an agent_id).
|
|
469
|
+
await cell("subagent", async () => {
|
|
470
|
+
const file = marker("subagent");
|
|
471
|
+
const run = await runCell(binary, root, {
|
|
472
|
+
child: () => ({
|
|
473
|
+
type: "custom_tool_call",
|
|
474
|
+
id: "child",
|
|
475
|
+
call_id: "child",
|
|
476
|
+
name: "exec",
|
|
477
|
+
input: `await tools.exec_command({cmd: ${JSON.stringify(`echo x > ${file}`)}});`,
|
|
478
|
+
status: "completed",
|
|
479
|
+
}),
|
|
480
|
+
script: "",
|
|
481
|
+
}, signal);
|
|
482
|
+
return (run.records.some((record) => record.tool_name === "Bash" && record.agent_id) && !existsSync(file));
|
|
483
|
+
});
|
|
484
|
+
// Rooms lead: the code-mode JavaScript has no file system or network of its
|
|
485
|
+
// own. If it can reach either without a nested tool, the hook cannot see it.
|
|
486
|
+
await cell("exec_js", async () => {
|
|
487
|
+
const file = marker("execjs");
|
|
488
|
+
const run = await runCell(binary, root, {
|
|
489
|
+
script: (canary) => js(`const tries = [
|
|
490
|
+
async () => fetch(${JSON.stringify(canary)}),
|
|
491
|
+
async () => (await import("node:fs")).writeFileSync(${JSON.stringify(file)}, "1"),
|
|
492
|
+
async () => require("fs").writeFileSync(${JSON.stringify(file)}, "1"),
|
|
493
|
+
async () => process.env.PATH,
|
|
494
|
+
async () => Deno.writeTextFileSync(${JSON.stringify(file)}, "1"),
|
|
495
|
+
async () => new XMLHttpRequest(),
|
|
496
|
+
];
|
|
497
|
+
for (const t of tries) { try { await t(); } catch (e) {} }`),
|
|
498
|
+
}, signal);
|
|
499
|
+
return run.canaryHits === 0 && !existsSync(file);
|
|
500
|
+
});
|
|
501
|
+
// R13 (3): the owner's own trust state is byte-identical after a job.
|
|
502
|
+
await cell("owner_trust_untouched", async () => {
|
|
503
|
+
const config = `[hooks.state."owner:hook:0"]\ntrusted_hash = "sha256:owner"\n`;
|
|
504
|
+
const run = await runCell(binary, root, {
|
|
505
|
+
ownerConfig: config,
|
|
506
|
+
script: js(`await tools.exec_command({cmd: "true"});`),
|
|
507
|
+
}, signal);
|
|
508
|
+
return (readFileSync(join(run.home, "config.toml"), "utf8") === config &&
|
|
509
|
+
!existsSync(join(run.home, "hooks.json")));
|
|
510
|
+
});
|
|
511
|
+
// R13 (3): a hook that lives in the workspace is never trusted or loaded
|
|
512
|
+
// through our job.
|
|
513
|
+
await cell("repo_hooks_ignored", async () => {
|
|
514
|
+
const file = marker("repohook");
|
|
515
|
+
const run = await runCell(binary, root, {
|
|
516
|
+
repoConfig: `[[hooks.PreToolUse]]\nmatcher = "*"\n[[hooks.PreToolUse.hooks]]\ntype = "command"\ncommand = ${JSON.stringify(`sh -c 'echo x > ${file}'`)}\n`,
|
|
517
|
+
script: js(`await tools.exec_command({cmd: "true"});`),
|
|
518
|
+
}, signal);
|
|
519
|
+
return !existsSync(file) && seen(run, "Bash").length === 1;
|
|
520
|
+
});
|
|
521
|
+
}
|
|
522
|
+
finally {
|
|
523
|
+
rmSync(root, { force: true, recursive: true });
|
|
524
|
+
}
|
|
525
|
+
return {
|
|
526
|
+
cells,
|
|
527
|
+
safe: CODEX_CELLS.every((name) => cells[name] === "pass"),
|
|
528
|
+
version,
|
|
529
|
+
};
|
|
530
|
+
}
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
import { execFile, spawn } from "node:child_process";
|
|
2
|
+
import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
|
|
3
|
+
import { join } from "node:path";
|
|
4
|
+
import { promisify } from "node:util";
|
|
5
|
+
// Codex owner-native, PR 1 (#10987): what we know about running the owner's own
|
|
6
|
+
// Codex behind our PreToolUse hook, and the checks that keep a Codex that cannot
|
|
7
|
+
// be fenced out of owner jobs. Nothing here launches an owner job: the findings
|
|
8
|
+
// (docs/features/agent-access/README.md) say why Codex 0.162.1 stays room-only.
|
|
9
|
+
const exec = promisify(execFile);
|
|
10
|
+
const APP_SERVER_MS = 20_000;
|
|
11
|
+
const VERSION = /(\d+\.\d+\.\d+)/u;
|
|
12
|
+
const FEATURE_LINE = /^(\S+)\s+\S+(?:\s+\S+)*?\s+(true|false)\s*$/u;
|
|
13
|
+
/** `-c` arguments that add our command as a PreToolUse hook for one run. */
|
|
14
|
+
export function codexHookArgs(command) {
|
|
15
|
+
return [
|
|
16
|
+
"-c",
|
|
17
|
+
`hooks.PreToolUse=[{matcher="*",hooks=[{type="command",command=${JSON.stringify(command)},timeout=900}]}]`,
|
|
18
|
+
];
|
|
19
|
+
}
|
|
20
|
+
/**
|
|
21
|
+
* An inline hook is UNTRUSTED by default and Codex then silently does not run
|
|
22
|
+
* it: the command just executes (fail open). `hooks/list` on the app server
|
|
23
|
+
* reports each hook's key and current hash; passing `hooks.state` with that
|
|
24
|
+
* hash trusts exactly our hook for this run, persists nothing and needs no
|
|
25
|
+
* `--dangerously-bypass-hook-trust`. Throws unless our hook is listed once.
|
|
26
|
+
*/
|
|
27
|
+
export async function trustHookArgs(input) {
|
|
28
|
+
const list = await appServerRequest({
|
|
29
|
+
args: ["app-server", ...codexHookArgs(input.command)],
|
|
30
|
+
binary: input.binary,
|
|
31
|
+
cwd: input.cwd,
|
|
32
|
+
env: input.env,
|
|
33
|
+
method: "hooks/list",
|
|
34
|
+
params: { cwds: [input.cwd] },
|
|
35
|
+
signal: input.signal,
|
|
36
|
+
});
|
|
37
|
+
const ours = (list.data ?? [])
|
|
38
|
+
.flatMap((entry) => entry.hooks ?? [])
|
|
39
|
+
.filter((hook) => hook.source === "sessionFlags" &&
|
|
40
|
+
hook.eventName === "preToolUse" &&
|
|
41
|
+
hook.command === input.command);
|
|
42
|
+
const [hook] = ours;
|
|
43
|
+
if (ours.length !== 1 || !hook?.key || !hook.currentHash) {
|
|
44
|
+
throw new Error("Our hook was not listed exactly once.");
|
|
45
|
+
}
|
|
46
|
+
return [
|
|
47
|
+
"-c",
|
|
48
|
+
`hooks.state={${JSON.stringify(hook.key)}={trusted_hash=${JSON.stringify(hook.currentHash)}}}`,
|
|
49
|
+
];
|
|
50
|
+
}
|
|
51
|
+
async function appServerRequest(input) {
|
|
52
|
+
const child = spawn(input.binary, input.args, {
|
|
53
|
+
cwd: input.cwd,
|
|
54
|
+
env: input.env,
|
|
55
|
+
stdio: ["pipe", "pipe", "ignore"],
|
|
56
|
+
});
|
|
57
|
+
try {
|
|
58
|
+
return await new Promise((resolve, reject) => {
|
|
59
|
+
const timer = setTimeout(() => reject(new Error("app-server timed out")), APP_SERVER_MS);
|
|
60
|
+
const stop = () => reject(new Error("aborted"));
|
|
61
|
+
input.signal?.addEventListener("abort", stop, { once: true });
|
|
62
|
+
let buffer = "";
|
|
63
|
+
child.once("error", reject);
|
|
64
|
+
child.stdout.setEncoding("utf8");
|
|
65
|
+
child.stdout.on("data", (chunk) => {
|
|
66
|
+
buffer += chunk;
|
|
67
|
+
for (let end = buffer.indexOf("\n"); end >= 0; end = buffer.indexOf("\n")) {
|
|
68
|
+
const line = buffer.slice(0, end);
|
|
69
|
+
buffer = buffer.slice(end + 1);
|
|
70
|
+
try {
|
|
71
|
+
const message = JSON.parse(line);
|
|
72
|
+
if (message.id === 1) {
|
|
73
|
+
child.stdin.write(`${JSON.stringify({ method: "initialized" })}\n`);
|
|
74
|
+
child.stdin.write(`${JSON.stringify({ id: 2, method: input.method, params: input.params })}\n`);
|
|
75
|
+
}
|
|
76
|
+
else if (message.id === 2) {
|
|
77
|
+
clearTimeout(timer);
|
|
78
|
+
if (message.result === undefined) {
|
|
79
|
+
reject(new Error("app-server request failed"));
|
|
80
|
+
}
|
|
81
|
+
else {
|
|
82
|
+
resolve(message.result);
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
catch {
|
|
87
|
+
// Notifications and log lines are not responses.
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
});
|
|
91
|
+
child.stdin.write(`${JSON.stringify({ id: 1, method: "initialize", params: { clientInfo: { name: "talentos", version: "0" } } })}\n`);
|
|
92
|
+
});
|
|
93
|
+
}
|
|
94
|
+
finally {
|
|
95
|
+
child.kill();
|
|
96
|
+
}
|
|
97
|
+
}
|
|
98
|
+
/** The Codex version, or undefined when the binary does not answer. */
|
|
99
|
+
export async function codexVersion(binary, env) {
|
|
100
|
+
try {
|
|
101
|
+
const { stdout } = await exec(binary, ["--version"], {
|
|
102
|
+
env,
|
|
103
|
+
timeout: 10_000,
|
|
104
|
+
});
|
|
105
|
+
return VERSION.exec(stdout)?.[1];
|
|
106
|
+
}
|
|
107
|
+
catch {
|
|
108
|
+
return;
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
/**
|
|
112
|
+
* Static reasons this owner's Codex cannot run our hook at all: hooks turned
|
|
113
|
+
* off in the effective config, or a binary that does not answer. Checked at
|
|
114
|
+
* every owner job (not cached), like the Claude disqualifier.
|
|
115
|
+
*/
|
|
116
|
+
export async function codexDisqualifier(binary, env) {
|
|
117
|
+
try {
|
|
118
|
+
const { stdout } = await exec(binary, ["features", "list"], {
|
|
119
|
+
env,
|
|
120
|
+
timeout: 15_000,
|
|
121
|
+
});
|
|
122
|
+
const hooks = stdout
|
|
123
|
+
.split("\n")
|
|
124
|
+
.map((line) => FEATURE_LINE.exec(line.trim()))
|
|
125
|
+
.find((match) => match?.[1] === "hooks");
|
|
126
|
+
if (hooks?.[2] !== "true") {
|
|
127
|
+
return "Codex hooks are turned off in this Codex's configuration.";
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
catch {
|
|
131
|
+
return "Codex did not report its features.";
|
|
132
|
+
}
|
|
133
|
+
return;
|
|
134
|
+
}
|
|
135
|
+
// Owner-level context that reaches Codex with no tool call: user AGENTS.md,
|
|
136
|
+
// skills, memories, MCP servers, profiles, notify and shell environment rules
|
|
137
|
+
// (R13). In a room with other people a job that starts with any of it loaded
|
|
138
|
+
// cannot be called untouched. Fail closed: unreadable or unknown = present.
|
|
139
|
+
const CONFIG_CONTEXT = /^\s*(?:\[(?:mcp_servers|profiles|hooks|plugins|marketplaces|shell_environment_policy|skills)\b|(?:notify|profile|model_instructions_file|developer_instructions|instructions|compact_prompt|experimental_instructions_file)\s*=)/mu;
|
|
140
|
+
const CONTEXT_FILES = ["AGENTS.md", "AGENTS.override.md", "hooks.json"];
|
|
141
|
+
const CONTEXT_DIRS = ["skills", "memories", "prompts", "rules", "plugins"];
|
|
142
|
+
export function codexOwnerContextPresent(codexHome) {
|
|
143
|
+
try {
|
|
144
|
+
if (CONTEXT_FILES.some((name) => existsSync(join(codexHome, name)))) {
|
|
145
|
+
return true;
|
|
146
|
+
}
|
|
147
|
+
for (const name of CONTEXT_DIRS) {
|
|
148
|
+
const dir = join(codexHome, name);
|
|
149
|
+
if (existsSync(dir) &&
|
|
150
|
+
(!statSync(dir).isDirectory() || readdirSync(dir).length > 0)) {
|
|
151
|
+
return true;
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
const config = join(codexHome, "config.toml");
|
|
155
|
+
return (existsSync(config) && CONFIG_CONTEXT.test(readFileSync(config, "utf8")));
|
|
156
|
+
}
|
|
157
|
+
catch {
|
|
158
|
+
return true;
|
|
159
|
+
}
|
|
160
|
+
}
|