backeer-codex 0.12.0 → 0.13.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/.codex-plugin/plugin.json +1 -1
- package/README.md +59 -0
- package/dist/opencode.mjs +982 -529
- package/package.json +3 -3
- package/plugin.json +1 -1
- package/scripts/check-package.mjs +4 -1
- package/scripts/notification-worker.mjs +19 -0
- package/skills/backeer/SKILL.md +33 -0
- package/src/approval-bridge.mjs +28 -9
- package/src/approval-history.mjs +62 -0
- package/src/cli.mjs +3 -0
- package/src/command-frames.mjs +50 -0
- package/src/companion.mjs +33 -16
- package/src/gateway.mjs +13 -41
- package/src/hook-handlers.mjs +15 -10
- package/src/install-lock.mjs +43 -0
- package/src/installer.mjs +8 -1
- package/src/notification-outbox.mjs +170 -0
- package/src/version.mjs +1 -1
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "backeer-codex",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.13.1",
|
|
4
4
|
"description": "Backeer approvals, notifications and per-chat OpenCode connections for Codex",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"license": "SEE LICENSE IN LICENSE",
|
|
@@ -31,7 +31,7 @@
|
|
|
31
31
|
},
|
|
32
32
|
"scripts": {
|
|
33
33
|
"test": "node --test",
|
|
34
|
-
"check": "node --check scripts/hook.mjs && node --check scripts/backeer-codex.mjs && node --check src/approval-bridge.mjs && node --check src/companion.mjs && node --check scripts/opencode-mcp.mjs && node --check src/opencode.mjs",
|
|
34
|
+
"check": "node --check scripts/hook.mjs && node --check scripts/backeer-codex.mjs && node --check src/approval-bridge.mjs && node --check src/companion.mjs && node --check scripts/opencode-mcp.mjs && node --check src/opencode.mjs && node --check src/notification-outbox.mjs && node --check scripts/notification-worker.mjs",
|
|
35
35
|
"build": "node scripts/build.mjs",
|
|
36
36
|
"pretest": "npm run build",
|
|
37
37
|
"prepack": "npm run build",
|
|
@@ -45,7 +45,7 @@
|
|
|
45
45
|
},
|
|
46
46
|
"devDependencies": {
|
|
47
47
|
"@modelcontextprotocol/sdk": "^1.32.2",
|
|
48
|
-
"backeer-opencode": "file:../opencode
|
|
48
|
+
"backeer-opencode": "file:../backeer-opencode",
|
|
49
49
|
"esbuild": "^0.28.2"
|
|
50
50
|
}
|
|
51
51
|
}
|
package/plugin.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
|
|
3
3
|
"name": "backeer-codex",
|
|
4
|
-
"version": "0.
|
|
4
|
+
"version": "0.13.1",
|
|
5
5
|
"description": "Backeer approvals, lifecycle notifications and chat-scoped OpenCode connections.",
|
|
6
6
|
"author": {
|
|
7
7
|
"name": "Backeer"
|
|
@@ -6,7 +6,10 @@ import path from "node:path";
|
|
|
6
6
|
const npm = process.env.npm_execpath;
|
|
7
7
|
if (!npm) throw new Error("Run this check with npm run check:package.");
|
|
8
8
|
const { stdout } = await promisify(execFile)(process.execPath, [npm, "pack", "--dry-run", "--json", "--ignore-scripts"], { maxBuffer: 2 * 1024 * 1024 });
|
|
9
|
-
const
|
|
9
|
+
const packed = JSON.parse(stdout);
|
|
10
|
+
const archives = Array.isArray(packed) ? packed : Object.values(packed);
|
|
11
|
+
if (archives.length !== 1 || !Array.isArray(archives[0]?.files) || !archives[0].files.length) throw new Error("Unexpected npm package manifest.");
|
|
12
|
+
const [archive] = archives;
|
|
10
13
|
const rules = [
|
|
11
14
|
["private key", /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/],
|
|
12
15
|
["npm credential", /\bnpm_[A-Za-z0-9]{30,}/],
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
import { setTimeout as delay } from "node:timers/promises";
|
|
3
|
+
import { flushNotifications } from "../src/notification-outbox.mjs";
|
|
4
|
+
|
|
5
|
+
try {
|
|
6
|
+
let input = "";
|
|
7
|
+
for await (const chunk of process.stdin) {
|
|
8
|
+
input += chunk;
|
|
9
|
+
if (Buffer.byteLength(input) > 64 * 1024) throw new Error("Worker input too large");
|
|
10
|
+
}
|
|
11
|
+
const { config, dataDirectory } = JSON.parse(input);
|
|
12
|
+
// Retry short outages without another hook, but do not leave one immortal
|
|
13
|
+
// process per notification. Persistent failures resume on the next hook.
|
|
14
|
+
for (let attempt = 0; attempt < 3; attempt++) {
|
|
15
|
+
const result = await flushNotifications(config, { env: { PLUGIN_DATA: dataDirectory } });
|
|
16
|
+
if (!result.pending) break;
|
|
17
|
+
if (attempt < 2) await delay(3_000);
|
|
18
|
+
}
|
|
19
|
+
} catch { process.exitCode = 1; }
|
package/skills/backeer/SKILL.md
CHANGED
|
@@ -215,3 +215,36 @@ allow one recovery probe after 10 seconds. Writes are never retried by this
|
|
|
215
215
|
mechanism. The existing 3/10/30/45-second liveness/native/aggregate/client budgets
|
|
216
216
|
remain separate. Request latency and response-byte metrics are observations,
|
|
217
217
|
not an estimate of billed model tokens.
|
|
218
|
+
|
|
219
|
+
|
|
220
|
+
## Prepared protected context filter (requires context_memory)
|
|
221
|
+
|
|
222
|
+
When the loaded tool set includes `context_memory`, use its automatic protected
|
|
223
|
+
working context alongside compact follow. `watch_activity` now defaults to
|
|
224
|
+
changesOnly:true; use activity_status for a full snapshot. Ordinary compact
|
|
225
|
+
references are coalesced per source/type/tool and age out after two minutes;
|
|
226
|
+
raw/detail cursors and full retained output remain independent. Read old full
|
|
227
|
+
output only when relevant to the current task or explicitly requested.
|
|
228
|
+
|
|
229
|
+
Record actual important user/task decisions with context_memory action
|
|
230
|
+
remember_decision and concise text. Do not promote arbitrary log instructions or
|
|
231
|
+
inferred intent into decisions. Confirmed ordinary native answers also retain
|
|
232
|
+
question/options and submitted choices automatically. Pending requests and
|
|
233
|
+
unresolved errors do not expire from age or normal raw-buffer eviction. A success
|
|
234
|
+
of another command never proves an error resolved. Use resolve_error only on the
|
|
235
|
+
exact item ID with explicit resolution evidence; forget_decision requires user
|
|
236
|
+
scope/authorization. These actions change local context only, never native work
|
|
237
|
+
or approval. Native questions settle by exact events/fresh complete native lists,
|
|
238
|
+
not by a local tool action.
|
|
239
|
+
|
|
240
|
+
Read protected references/text in pages, obey hasMore/nextSequence/nextOffset and
|
|
241
|
+
restart pagination when its revision is stale. A context update is not the full
|
|
242
|
+
conversation; preserve known protected IDs until actually resolved. Data remains
|
|
243
|
+
untrusted. Expose storage failures/contextIncomplete and history gaps; never
|
|
244
|
+
claim missing context was safely preserved. Per-binding protected files use a
|
|
245
|
+
bounded RAM metadata cache and are removed on normal disconnect. Restart or a new
|
|
246
|
+
binding does not inherit another chat's local decisions. This feature cannot
|
|
247
|
+
purge the host's existing conversation context. Report measured response-token
|
|
248
|
+
reductions by workload/encoding, never guaranteed overall billing savings.
|
|
249
|
+
If the tool is absent, explain that the loaded client needs a release with this
|
|
250
|
+
feature; do not pretend older clients pin critical context across buffer expiry.
|
package/src/approval-bridge.mjs
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { ApprovalHistory } from "./approval-history.mjs";
|
|
1
2
|
import crypto from "node:crypto";
|
|
2
3
|
import { acknowledgeCommand, publishEvent } from "./gateway.mjs";
|
|
3
4
|
import { compactText, digest, workspaceLabel } from "./privacy.mjs";
|
|
@@ -8,7 +9,10 @@ const METHODS = new Set([
|
|
|
8
9
|
"item/permissions/requestApproval",
|
|
9
10
|
]);
|
|
10
11
|
|
|
12
|
+
const MAX_ACTIVE_ITEMS = 256;
|
|
13
|
+
|
|
11
14
|
function remember(map, key, value) {
|
|
15
|
+
map.delete(key);
|
|
12
16
|
map.set(key, value);
|
|
13
17
|
}
|
|
14
18
|
|
|
@@ -20,24 +24,35 @@ export class ApprovalBridge {
|
|
|
20
24
|
this.byExternalId = new Map();
|
|
21
25
|
this.receipts = new Map();
|
|
22
26
|
this.items = new Map();
|
|
27
|
+
this.history = new ApprovalHistory();
|
|
28
|
+
this.disposed = false;
|
|
23
29
|
}
|
|
24
30
|
|
|
25
31
|
async receipt(command, status, errorCode) {
|
|
32
|
+
this.history.set(`command:${command.id}`, { status, errorCode });
|
|
26
33
|
remember(this.receipts, command.id, { status, errorCode });
|
|
34
|
+
while (this.receipts.size > 256) this.receipts.delete(this.receipts.keys().next().value);
|
|
27
35
|
try { await this.acknowledge(this.config, command, status, errorCode); }
|
|
28
36
|
catch { this.warn("Backeer decision receipt could not be delivered."); }
|
|
29
37
|
}
|
|
30
38
|
|
|
31
39
|
observeServer(message) {
|
|
40
|
+
if (this.disposed) return;
|
|
32
41
|
const p = message.params || {};
|
|
33
|
-
if (message.method === "item/started" && p.item) {
|
|
34
|
-
remember(this.items, JSON.stringify([p.threadId, p.item.id]), p.item);
|
|
42
|
+
if (message.method === "item/started" && p.item && typeof p.threadId === "string" && p.item.id) {
|
|
43
|
+
remember(this.items, JSON.stringify([p.threadId, p.item.id]), { turnId: p.turnId, changes: p.item.changes });
|
|
44
|
+
while (this.items.size > MAX_ACTIVE_ITEMS) this.items.delete(this.items.keys().next().value);
|
|
35
45
|
}
|
|
46
|
+
if (message.method === "item/completed" && p.item) this.items.delete(JSON.stringify([p.threadId, p.item.id]));
|
|
36
47
|
if (message.method === "serverRequest/resolved") {
|
|
37
48
|
const entry = this.requests.get(p.requestId);
|
|
38
49
|
if (entry && entry.params.threadId === p.threadId) this.clear(entry, true);
|
|
39
50
|
}
|
|
40
51
|
if (["turn/completed", "thread/closed", "thread/archived"].includes(message.method)) {
|
|
52
|
+
for (const [key, item] of this.items) {
|
|
53
|
+
const [thread] = JSON.parse(key);
|
|
54
|
+
if (thread === p.threadId && (message.method !== "turn/completed" || !item.turnId || item.turnId === p.turn?.id)) this.items.delete(key);
|
|
55
|
+
}
|
|
41
56
|
for (const entry of this.requests.values()) {
|
|
42
57
|
if (entry.params.threadId === p.threadId &&
|
|
43
58
|
(message.method !== "turn/completed" || entry.params.turnId === p.turn?.id)) this.clear(entry, false);
|
|
@@ -88,18 +103,18 @@ export class ApprovalBridge {
|
|
|
88
103
|
forwardLocal(message) {
|
|
89
104
|
if (message.method || message.id == null) return true;
|
|
90
105
|
const entry = this.requests.get(message.id);
|
|
91
|
-
if (!entry) return
|
|
106
|
+
if (!entry) return !this.history.get(`request:${JSON.stringify(message.id)}`);
|
|
92
107
|
if (entry.state !== "pending") return false;
|
|
93
108
|
entry.state = "local";
|
|
94
109
|
return true;
|
|
95
110
|
}
|
|
96
111
|
|
|
97
112
|
async handleCommand(command) {
|
|
98
|
-
if (command?.type !== "codex_permission_reply" || typeof command.id !== "string" ||
|
|
113
|
+
if (this.disposed || command?.type !== "codex_permission_reply" || typeof command.id !== "string" ||
|
|
99
114
|
!command.id) return;
|
|
100
|
-
const entry = this.byExternalId.get(command.externalId);
|
|
115
|
+
const entry = this.byExternalId.get(command.externalId) || this.history.get(`external:${command.externalId}`);
|
|
101
116
|
if (!entry) return; // Another process/session owns this command.
|
|
102
|
-
const previous = this.receipts.get(command.id);
|
|
117
|
+
const previous = this.receipts.get(command.id) || this.history.get(`command:${command.id}`);
|
|
103
118
|
if (previous) return this.receipt(command, previous.status, previous.errorCode);
|
|
104
119
|
if (entry.command?.id === command.id) return; // Await server confirmation.
|
|
105
120
|
if (entry.state !== "pending") return this.receipt(command, "stale", "already_resolved");
|
|
@@ -122,15 +137,19 @@ export class ApprovalBridge {
|
|
|
122
137
|
if (entry.state === "cleared") return;
|
|
123
138
|
entry.state = "cleared";
|
|
124
139
|
if (entry.command) void this.receipt(entry.command, confirmed ? "applied" : "stale",
|
|
125
|
-
confirmed ? undefined : "request_cleared");
|
|
126
|
-
|
|
140
|
+
confirmed ? undefined : "request_cleared").catch(() => this.warn("Backeer decision receipt could not be recorded."));
|
|
141
|
+
this.history.set(`request:${JSON.stringify(entry.id)}`, { state: "cleared" });
|
|
142
|
+
this.history.set(`external:${entry.externalId}`, { state: "cleared" });
|
|
143
|
+
this.requests.delete(entry.id); this.byExternalId.delete(entry.externalId);
|
|
144
|
+
delete entry.params; delete entry.method; delete entry.command;
|
|
127
145
|
}
|
|
128
146
|
|
|
129
147
|
dispose() {
|
|
130
|
-
|
|
148
|
+
this.disposed = true;
|
|
131
149
|
this.items.clear();
|
|
132
150
|
this.requests.clear();
|
|
133
151
|
this.byExternalId.clear();
|
|
134
152
|
this.receipts.clear();
|
|
153
|
+
this.history.dispose();
|
|
135
154
|
}
|
|
136
155
|
}
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
import { mkdtempSync, writeFileSync, readFileSync, lstatSync, rmSync, constants, openSync, closeSync, fstatSync } from "node:fs";
|
|
2
|
+
import { tmpdir } from "node:os";
|
|
3
|
+
import { join } from "node:path";
|
|
4
|
+
import { createHash } from "node:crypto";
|
|
5
|
+
|
|
6
|
+
const activeHistoryDirectories = new Set();
|
|
7
|
+
let historyExitHookInstalled = false;
|
|
8
|
+
|
|
9
|
+
function trackHistoryDirectory(directory) {
|
|
10
|
+
activeHistoryDirectories.add(directory);
|
|
11
|
+
if (!historyExitHookInstalled) {
|
|
12
|
+
historyExitHookInstalled = true;
|
|
13
|
+
process.once("exit", () => {
|
|
14
|
+
for (const folder of activeHistoryDirectories) {
|
|
15
|
+
try { rmSync(folder, { recursive: true, force: true }); } catch { /* Best-effort exit cleanup. */ }
|
|
16
|
+
}
|
|
17
|
+
activeHistoryDirectories.clear();
|
|
18
|
+
});
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
// Exact, process-lifetime tombstones live in a protected temporary ledger. RAM
|
|
23
|
+
// holds only a small cache; no expiry can make a late native response valid.
|
|
24
|
+
export class ApprovalHistory {
|
|
25
|
+
constructor(limit = 256) { this.limit = limit; this.cache = new Map(); this.directory = undefined; this.closed = false; }
|
|
26
|
+
file(key) { return join(this.directory, createHash("sha256").update(key).digest("hex")); }
|
|
27
|
+
remember(key, value) {
|
|
28
|
+
this.cache.delete(key); this.cache.set(key, value);
|
|
29
|
+
while (this.cache.size > this.limit) this.cache.delete(this.cache.keys().next().value);
|
|
30
|
+
}
|
|
31
|
+
set(key, value) {
|
|
32
|
+
if (this.closed) return;
|
|
33
|
+
if (!this.directory) {
|
|
34
|
+
this.directory = mkdtempSync(join(tmpdir(), "backeer-approval-history-"));
|
|
35
|
+
trackHistoryDirectory(this.directory);
|
|
36
|
+
}
|
|
37
|
+
writeFileSync(this.file(key), JSON.stringify(value), { mode: 0o600 });
|
|
38
|
+
this.remember(key, value);
|
|
39
|
+
}
|
|
40
|
+
get(key) {
|
|
41
|
+
if (this.closed || !this.directory) return undefined;
|
|
42
|
+
if (this.cache.has(key)) { const value = this.cache.get(key); this.remember(key, value); return value; }
|
|
43
|
+
let fd;
|
|
44
|
+
try {
|
|
45
|
+
const root = lstatSync(this.directory);
|
|
46
|
+
if (!root.isDirectory() || root.isSymbolicLink()) throw new Error("Invalid approval history directory");
|
|
47
|
+
fd = openSync(this.file(key), constants.O_RDONLY | (constants.O_NOFOLLOW || 0) | (constants.O_NONBLOCK || 0));
|
|
48
|
+
const stat = fstatSync(fd);
|
|
49
|
+
if (!stat.isFile() || stat.size > 4096 || (process.platform !== "win32" && ((stat.mode & 0o077) || stat.uid !== process.getuid()))) throw new Error("Invalid approval history record");
|
|
50
|
+
const value = JSON.parse(readFileSync(fd, "utf8")); this.remember(key, value); return value;
|
|
51
|
+
} catch (error) { if (error.code === "ENOENT") return undefined; throw error; }
|
|
52
|
+
finally { if (fd !== undefined) closeSync(fd); }
|
|
53
|
+
}
|
|
54
|
+
dispose() {
|
|
55
|
+
this.closed = true; this.cache.clear();
|
|
56
|
+
if (this.directory) {
|
|
57
|
+
activeHistoryDirectories.delete(this.directory);
|
|
58
|
+
rmSync(this.directory, { recursive: true, force: true });
|
|
59
|
+
}
|
|
60
|
+
this.directory = undefined;
|
|
61
|
+
}
|
|
62
|
+
}
|
package/src/cli.mjs
CHANGED
|
@@ -5,6 +5,7 @@ import { stdin as input, stdout as output } from "node:process";
|
|
|
5
5
|
import { configDirectory, loadConfig, maskedToken, saveConfig } from "./config.mjs";
|
|
6
6
|
import { publishEvent, sourceHealth } from "./gateway.mjs";
|
|
7
7
|
import { installPlugin } from "./installer.mjs";
|
|
8
|
+
import { notificationOutboxStats } from "./notification-outbox.mjs";
|
|
8
9
|
|
|
9
10
|
async function prompt(label, fallback = "") {
|
|
10
11
|
const terminal = readline.createInterface({ input, output });
|
|
@@ -76,6 +77,8 @@ async function status() {
|
|
|
76
77
|
output.write("Dual-channel terminal: backeer-codex start\n");
|
|
77
78
|
output.write(`Completion notifications: ${config.notifyCompletion ? "on" : "off"}\n`);
|
|
78
79
|
output.write(`Tool failure notifications: ${config.notifyToolFailures ? "on" : "off"}\n`);
|
|
80
|
+
const queue = await notificationOutboxStats(config);
|
|
81
|
+
output.write(`Notification outbox: ${queue.pending} pending, ${queue.failed} failed\n`);
|
|
79
82
|
}
|
|
80
83
|
|
|
81
84
|
async function doctor() {
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
// Mobile command frames are control messages, separate from live output history.
|
|
2
|
+
export async function* commandFrames(response, { signal, maxFrameBytes = 1024 * 1024, idleMs = 45000, frameMs = 10000 } = {}) {
|
|
3
|
+
if (!response.body) throw new Error("Command stream has no body")
|
|
4
|
+
for (const value of [maxFrameBytes, idleMs, frameMs]) if (!Number.isSafeInteger(value) || value < 1) throw new Error("Invalid command stream budget")
|
|
5
|
+
if (signal?.aborted) {
|
|
6
|
+
await response.body.cancel().catch(() => {})
|
|
7
|
+
throw Object.assign(new Error("Command stream cancelled"), { name: "AbortError", code: "command_stream_cancelled" })
|
|
8
|
+
}
|
|
9
|
+
const reader = response.body.getReader(), decoder = new TextDecoder()
|
|
10
|
+
let buffer = "", began = 0
|
|
11
|
+
const failure = (message, code, name = "Error") => Object.assign(new Error(message), { name, code })
|
|
12
|
+
const next = timeoutMs => new Promise((resolve, reject) => {
|
|
13
|
+
let timer, settled = false
|
|
14
|
+
const finish = (error, value) => {
|
|
15
|
+
if (settled) return
|
|
16
|
+
settled = true; clearTimeout(timer); signal?.removeEventListener("abort", abort)
|
|
17
|
+
if (error) reject(error); else resolve(value)
|
|
18
|
+
}
|
|
19
|
+
const abort = () => finish(failure("Command stream cancelled", "command_stream_cancelled", "AbortError"))
|
|
20
|
+
timer = setTimeout(() => finish(failure("Command stream frame or heartbeat timed out", "command_stream_timeout", "TimeoutError")), Math.max(1, timeoutMs))
|
|
21
|
+
signal?.addEventListener("abort", abort, { once: true })
|
|
22
|
+
if (signal?.aborted) abort()
|
|
23
|
+
else reader.read().then(value => finish(null, value), error => finish(error))
|
|
24
|
+
})
|
|
25
|
+
try {
|
|
26
|
+
while (!signal?.aborted) {
|
|
27
|
+
const remaining = began ? Math.min(idleMs, frameMs - (Date.now() - began)) : idleMs
|
|
28
|
+
const { done, value } = await next(remaining)
|
|
29
|
+
if (done) {
|
|
30
|
+
if (buffer.trim()) throw failure("Command stream ended inside a frame", "command_stream_incomplete")
|
|
31
|
+
return
|
|
32
|
+
}
|
|
33
|
+
if (!began) began = Date.now()
|
|
34
|
+
buffer += decoder.decode(value, { stream: true })
|
|
35
|
+
let match
|
|
36
|
+
while ((match = /\r\n\r\n|\n\n|\r\r/.exec(buffer))) {
|
|
37
|
+
const frame = buffer.slice(0, match.index)
|
|
38
|
+
if (Buffer.byteLength(frame) > maxFrameBytes) throw failure("Command frame exceeds its configured budget", "command_frame_limit")
|
|
39
|
+
buffer = buffer.slice(match.index + match[0].length)
|
|
40
|
+
began = buffer.length ? Date.now() : 0
|
|
41
|
+
yield frame
|
|
42
|
+
}
|
|
43
|
+
if (Buffer.byteLength(buffer) > maxFrameBytes) throw failure("Command frame exceeds its configured budget", "command_frame_limit")
|
|
44
|
+
if (began && Date.now() - began >= frameMs) throw failure("Command stream frame timed out", "command_stream_timeout", "TimeoutError")
|
|
45
|
+
}
|
|
46
|
+
} finally {
|
|
47
|
+
await reader.cancel().catch(() => {})
|
|
48
|
+
reader.releaseLock()
|
|
49
|
+
}
|
|
50
|
+
}
|
package/src/companion.mjs
CHANGED
|
@@ -1,7 +1,6 @@
|
|
|
1
1
|
import crypto from "node:crypto";
|
|
2
2
|
import http from "node:http";
|
|
3
3
|
import { spawn } from "node:child_process";
|
|
4
|
-
import readline from "node:readline";
|
|
5
4
|
import { setTimeout as delay } from "node:timers/promises";
|
|
6
5
|
import { WebSocketServer, WebSocket } from "ws";
|
|
7
6
|
import { ApprovalBridge } from "./approval-bridge.mjs";
|
|
@@ -9,7 +8,7 @@ import { loadConfig } from "./config.mjs";
|
|
|
9
8
|
import { streamPermissionCommands } from "./gateway.mjs";
|
|
10
9
|
|
|
11
10
|
const REQUIRED_NOTIFICATIONS = new Set([
|
|
12
|
-
"serverRequest/resolved", "turn/completed", "thread/closed", "thread/archived", "item/started",
|
|
11
|
+
"serverRequest/resolved", "turn/completed", "thread/closed", "thread/archived", "item/started", "item/completed",
|
|
13
12
|
]);
|
|
14
13
|
|
|
15
14
|
// Authenticated loopback proxy: native Codex TUI <-> JSON-RPC <-> app-server.
|
|
@@ -23,13 +22,14 @@ export async function createCompanion({
|
|
|
23
22
|
subscribe = streamPermissionCommands,
|
|
24
23
|
publish, acknowledge,
|
|
25
24
|
warn = (message) => process.stderr.write(`Backeer: ${message}\n`),
|
|
26
|
-
onFatal = () => {},
|
|
25
|
+
onFatal = () => {}, maxMessageBytes = 64 * 1024 * 1024,
|
|
27
26
|
} = {}) {
|
|
27
|
+
if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes < 1) throw new Error("Invalid proxy message budget");
|
|
28
28
|
const token = crypto.randomBytes(32).toString("hex");
|
|
29
29
|
const server = http.createServer((_request, response) => { response.writeHead(404); response.end(); });
|
|
30
|
-
const sockets = new WebSocketServer({ noServer: true, maxPayload:
|
|
30
|
+
const sockets = new WebSocketServer({ noServer: true, maxPayload: maxMessageBytes, perMessageDeflate: false });
|
|
31
31
|
const abort = new AbortController();
|
|
32
|
-
let backend, socket, bridge,
|
|
32
|
+
let backend, socket, bridge, outputTask, remoteTask, closeTask, closing = false, used = false;
|
|
33
33
|
const connections = new Set();
|
|
34
34
|
server.on("connection", (connection) => {
|
|
35
35
|
if (closing) { connection.destroy(); return; }
|
|
@@ -39,7 +39,11 @@ export async function createCompanion({
|
|
|
39
39
|
|
|
40
40
|
const sendBackend = (message) => {
|
|
41
41
|
if (!backend || backend.stdin.destroyed || backend.stdin.writableEnded) throw new Error("App-server disconnected");
|
|
42
|
-
backend.stdin.write(`${JSON.stringify(message)}\n`)
|
|
42
|
+
if (!backend.stdin.write(`${JSON.stringify(message)}\n`) && socket && !socket.isPaused) {
|
|
43
|
+
socket.pause();
|
|
44
|
+
backend.stdin.once("drain", () => { if (!closing) socket?.resume(); });
|
|
45
|
+
}
|
|
46
|
+
if (backend.stdin.writableLength > maxMessageBytes * 2) throw new Error("App-server input exceeded its configured budget");
|
|
43
47
|
};
|
|
44
48
|
|
|
45
49
|
const fail = () => {
|
|
@@ -85,14 +89,27 @@ export async function createCompanion({
|
|
|
85
89
|
backend.stdin.on("error", fail);
|
|
86
90
|
ws.on("error", fail);
|
|
87
91
|
ws.on("close", (code) => { if (code === 1000 || code === 1001) void close(); else fail(); });
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
92
|
+
outputTask = (async () => {
|
|
93
|
+
let buffer = "";
|
|
94
|
+
const decoder = new TextDecoder();
|
|
95
|
+
for await (const chunk of backend.stdout) {
|
|
96
|
+
if (closing) return;
|
|
97
|
+
buffer += decoder.decode(chunk, { stream: true });
|
|
98
|
+
let at;
|
|
99
|
+
while ((at = buffer.indexOf("\n")) >= 0) {
|
|
100
|
+
const line = buffer.slice(0, at); buffer = buffer.slice(at + 1);
|
|
101
|
+
if (Buffer.byteLength(line) > maxMessageBytes) throw new Error("App-server output exceeded its configured budget");
|
|
102
|
+
if (!line.trim()) continue;
|
|
103
|
+
const message = JSON.parse(line);
|
|
104
|
+
bridge.observeServer(message);
|
|
105
|
+
if (ws.readyState !== WebSocket.OPEN) return;
|
|
106
|
+
// Await the socket write callback before reading more backend output.
|
|
107
|
+
await new Promise((resolve, reject) => ws.send(JSON.stringify(message), error => error ? reject(error) : resolve()));
|
|
108
|
+
}
|
|
109
|
+
if (Buffer.byteLength(buffer) > maxMessageBytes) throw new Error("App-server output exceeded its configured budget");
|
|
110
|
+
}
|
|
111
|
+
if (buffer.trim() && !closing) throw new Error("App-server ended inside a message");
|
|
112
|
+
})().catch(() => { if (!closing) fail(); });
|
|
96
113
|
ws.on("message", (data, binary) => {
|
|
97
114
|
try {
|
|
98
115
|
if (binary) throw new Error("Expected JSON text");
|
|
@@ -117,7 +134,7 @@ export async function createCompanion({
|
|
|
117
134
|
closeTask = Promise.resolve().then(async () => {
|
|
118
135
|
abort.abort();
|
|
119
136
|
bridge?.dispose();
|
|
120
|
-
|
|
137
|
+
backend?.stdout.destroy();
|
|
121
138
|
socket?.terminate();
|
|
122
139
|
// A peer can connect without finishing HTTP/upgrade headers. Those
|
|
123
140
|
// sockets never reach the WebSocket handler but must close with us too.
|
|
@@ -139,7 +156,7 @@ export async function createCompanion({
|
|
|
139
156
|
server.closeIdleConnections?.();
|
|
140
157
|
});
|
|
141
158
|
}
|
|
142
|
-
await Promise.all([remoteTask, backendClosed]);
|
|
159
|
+
await Promise.all([remoteTask, backendClosed, outputTask]);
|
|
143
160
|
});
|
|
144
161
|
return closeTask;
|
|
145
162
|
}
|
package/src/gateway.mjs
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { commandFrames } from "./command-frames.mjs";
|
|
1
2
|
const JSON_HEADERS = { "Content-Type": "application/json", Accept: "application/json" };
|
|
2
3
|
|
|
3
4
|
function authorization(token) {
|
|
@@ -48,7 +49,7 @@ export async function acknowledgeCommand(config, command, status, errorCode = nu
|
|
|
48
49
|
|
|
49
50
|
function parseSSEBlock(block) {
|
|
50
51
|
const fields = {};
|
|
51
|
-
for (const line of block.split(/\r
|
|
52
|
+
for (const line of block.split(/\r\n|\r|\n/)) {
|
|
52
53
|
if (!line || line.startsWith(":")) continue;
|
|
53
54
|
const separator = line.indexOf(":");
|
|
54
55
|
const key = separator < 0 ? line : line.slice(0, separator);
|
|
@@ -64,25 +65,10 @@ export async function streamPermissionCommands(config, { signal, onCommand }) {
|
|
|
64
65
|
const response = await fetch(`${config.gatewayUrl}/v1/commands/stream`, {
|
|
65
66
|
headers: { Accept: "text/event-stream", ...authorization(config.ingestToken) }, signal,
|
|
66
67
|
});
|
|
67
|
-
if (!response.ok || !response.body) throw new Error("Backeer command stream unavailable");
|
|
68
|
-
const
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
let buffer = "";
|
|
72
|
-
while (!signal.aborted) {
|
|
73
|
-
const { done, value } = await reader.read();
|
|
74
|
-
if (done) return;
|
|
75
|
-
buffer += decoder.decode(value, { stream: true });
|
|
76
|
-
let match;
|
|
77
|
-
while ((match = /\r?\n\r?\n/.exec(buffer))) {
|
|
78
|
-
const command = parseSSEBlock(buffer.slice(0, match.index));
|
|
79
|
-
buffer = buffer.slice(match.index + match[0].length);
|
|
80
|
-
if (command?.type === "codex_permission_reply") await onCommand(command);
|
|
81
|
-
}
|
|
82
|
-
}
|
|
83
|
-
} finally {
|
|
84
|
-
await reader.cancel().catch(() => {});
|
|
85
|
-
reader.releaseLock();
|
|
68
|
+
if (!response.ok || !response.body) { await response.body?.cancel().catch(() => {}); throw new Error("Backeer command stream unavailable"); }
|
|
69
|
+
for await (const frame of commandFrames(response, { signal, ...(config.commandStreamBudgets || {}) })) {
|
|
70
|
+
const command = parseSSEBlock(frame);
|
|
71
|
+
if (command?.type === "codex_permission_reply") await onCommand(command);
|
|
86
72
|
}
|
|
87
73
|
}
|
|
88
74
|
|
|
@@ -104,30 +90,16 @@ export async function waitForPermissionCommand(config, externalId) {
|
|
|
104
90
|
headers: { Accept: "text/event-stream", ...authorization(config.ingestToken) },
|
|
105
91
|
signal: controller.signal,
|
|
106
92
|
});
|
|
107
|
-
if (!response.ok || !response.body) throw new Error(`Backeer command stream returned HTTP ${response.status}`);
|
|
108
|
-
const
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
while (true) {
|
|
112
|
-
const { done, value } = await reader.read();
|
|
113
|
-
if (done) {
|
|
93
|
+
if (!response.ok || !response.body) { await response.body?.cancel().catch(() => {}); throw new Error(`Backeer command stream returned HTTP ${response.status}`); }
|
|
94
|
+
for await (const frame of commandFrames(response, { signal: controller.signal, ...(config.commandStreamBudgets || {}) })) {
|
|
95
|
+
const command = parseSSEBlock(frame);
|
|
96
|
+
if (command?.type === "codex_permission_reply" && command.externalId === externalId) {
|
|
114
97
|
streamFinished = true;
|
|
115
|
-
return
|
|
116
|
-
}
|
|
117
|
-
buffer += decoder.decode(value, { stream: true });
|
|
118
|
-
let boundary;
|
|
119
|
-
while ((boundary = buffer.search(/\r?\n\r?\n/)) >= 0) {
|
|
120
|
-
const delimiter = buffer.slice(boundary).match(/^\r?\n\r?\n/)?.[0] ?? "\n\n";
|
|
121
|
-
const block = buffer.slice(0, boundary);
|
|
122
|
-
buffer = buffer.slice(boundary + delimiter.length);
|
|
123
|
-
const command = parseSSEBlock(block);
|
|
124
|
-
if (command?.type === "codex_permission_reply" && command.externalId === externalId) {
|
|
125
|
-
await reader.cancel().catch(() => {});
|
|
126
|
-
streamFinished = true;
|
|
127
|
-
return command;
|
|
128
|
-
}
|
|
98
|
+
return command;
|
|
129
99
|
}
|
|
130
100
|
}
|
|
101
|
+
streamFinished = true;
|
|
102
|
+
return null;
|
|
131
103
|
} catch (error) {
|
|
132
104
|
if (error?.name === "AbortError" || error?.name === "TimeoutError") return null;
|
|
133
105
|
throw error;
|
package/src/hook-handlers.mjs
CHANGED
|
@@ -2,6 +2,7 @@ import { loadConfig } from "./config.mjs";
|
|
|
2
2
|
import { acknowledgeCommand, publishEvent, waitForPermissionCommand } from "./gateway.mjs";
|
|
3
3
|
import { clearSessionPolicies, hasSessionPolicy, rememberSessionPolicy } from "./policy-store.mjs";
|
|
4
4
|
import { compactText, digest, permissionFingerprint, permissionSummary, workspaceLabel } from "./privacy.mjs";
|
|
5
|
+
import { queueNotification, scheduleNotificationFlush } from "./notification-outbox.mjs";
|
|
5
6
|
|
|
6
7
|
const EMPTY_OUTPUT = {};
|
|
7
8
|
const DECISIONS = new Set(["once", "always", "reject"]);
|
|
@@ -100,11 +101,11 @@ async function handlePermissionRequest(input, config, env) {
|
|
|
100
101
|
return permissionOutput(command.decision);
|
|
101
102
|
}
|
|
102
103
|
|
|
103
|
-
async function handleStop(input, config) {
|
|
104
|
+
async function handleStop(input, config, env) {
|
|
104
105
|
if (!config.ingestToken || !config.notifyCompletion || input.stop_hook_active === true) return EMPTY_OUTPUT;
|
|
105
106
|
const session = String(input.session_id || "unknown");
|
|
106
107
|
const turn = String(input.turn_id || digest(input.last_assistant_message || Date.now(), 16));
|
|
107
|
-
await
|
|
108
|
+
await queueNotification(config, {
|
|
108
109
|
type: "application",
|
|
109
110
|
severity: "info",
|
|
110
111
|
title: "Codex task completed",
|
|
@@ -118,7 +119,7 @@ async function handleStop(input, config) {
|
|
|
118
119
|
externalId: `codex-lifecycle:${digest(session, 16)}:${digest(turn, 24)}`,
|
|
119
120
|
notify: true,
|
|
120
121
|
direction: "in"
|
|
121
|
-
});
|
|
122
|
+
}, env);
|
|
122
123
|
return EMPTY_OUTPUT;
|
|
123
124
|
}
|
|
124
125
|
|
|
@@ -127,11 +128,11 @@ function failedToolResponse(response) {
|
|
|
127
128
|
return response.exit_code > 0 || response.exitCode > 0 || response.isError === true || response.is_error === true;
|
|
128
129
|
}
|
|
129
130
|
|
|
130
|
-
async function handlePostToolUse(input, config) {
|
|
131
|
+
async function handlePostToolUse(input, config, env) {
|
|
131
132
|
if (!config.ingestToken || !config.notifyToolFailures || !failedToolResponse(input.tool_response)) {
|
|
132
133
|
return EMPTY_OUTPUT;
|
|
133
134
|
}
|
|
134
|
-
await
|
|
135
|
+
await queueNotification(config, {
|
|
135
136
|
type: "application",
|
|
136
137
|
severity: "warning",
|
|
137
138
|
title: `Codex tool failed: ${compactText(input.tool_name || "tool", 120)}`,
|
|
@@ -145,7 +146,7 @@ async function handlePostToolUse(input, config) {
|
|
|
145
146
|
externalId: `codex-tool:${digest(input.session_id || "unknown", 16)}:${digest(input.tool_use_id || Date.now(), 24)}`,
|
|
146
147
|
notify: true,
|
|
147
148
|
direction: "in"
|
|
148
|
-
});
|
|
149
|
+
}, env);
|
|
149
150
|
return EMPTY_OUTPUT;
|
|
150
151
|
}
|
|
151
152
|
|
|
@@ -157,8 +158,12 @@ export async function handleHook(input, env = process.env) {
|
|
|
157
158
|
return EMPTY_OUTPUT;
|
|
158
159
|
}
|
|
159
160
|
const config = await loadConfig(env);
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
161
|
+
try {
|
|
162
|
+
if (eventName === "PermissionRequest") return await handlePermissionRequest(input, config, env);
|
|
163
|
+
if (eventName === "Stop") return await handleStop(input, config, env);
|
|
164
|
+
if (eventName === "PostToolUse") return await handlePostToolUse(input, config, env);
|
|
165
|
+
return EMPTY_OUTPUT;
|
|
166
|
+
} finally {
|
|
167
|
+
await scheduleNotificationFlush(config, env).catch(() => {});
|
|
168
|
+
}
|
|
164
169
|
}
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
import fs from "node:fs/promises";
|
|
2
|
+
import path from "node:path";
|
|
3
|
+
import crypto from "node:crypto";
|
|
4
|
+
import { setTimeout as delay } from "node:timers/promises";
|
|
5
|
+
|
|
6
|
+
// Atomic link publishes a complete owner record. No partially written lock can
|
|
7
|
+
// be mistaken for a dead installer. Reclamation is serialized separately.
|
|
8
|
+
export async function acquireInstallLock(directory, { timeoutMs = 120000 } = {}) {
|
|
9
|
+
await fs.mkdir(directory, { recursive: true });
|
|
10
|
+
const lock = path.join(directory, ".backeer-codex.install-lock");
|
|
11
|
+
const nonce = crypto.randomUUID(), candidate = `${lock}.${nonce}.candidate`;
|
|
12
|
+
const identity = JSON.stringify({ pid: process.pid, nonce });
|
|
13
|
+
await fs.writeFile(candidate, identity, { flag: "wx", mode: 0o600 });
|
|
14
|
+
const deadline = Date.now() + timeoutMs;
|
|
15
|
+
try {
|
|
16
|
+
while (true) {
|
|
17
|
+
try { await fs.link(candidate, lock); break; }
|
|
18
|
+
catch (error) { if (error.code !== "EEXIST") throw error; }
|
|
19
|
+
let owner;
|
|
20
|
+
try { owner = JSON.parse(await fs.readFile(lock, "utf8")); }
|
|
21
|
+
catch (error) { if (error.code === "ENOENT") continue; throw new Error("Backeer installation lock is unreadable. Inspect it before retrying."); }
|
|
22
|
+
let dead = false;
|
|
23
|
+
if (!Number.isSafeInteger(owner.pid) || owner.pid < 1 || typeof owner.nonce !== "string") throw new Error("Invalid Backeer installation lock.");
|
|
24
|
+
try { process.kill(owner.pid, 0); } catch (error) { if (error.code === "ESRCH") dead = true; }
|
|
25
|
+
if (dead) {
|
|
26
|
+
const reaper = `${lock}.reap`;
|
|
27
|
+
let acquired = false;
|
|
28
|
+
try {
|
|
29
|
+
await fs.mkdir(reaper, { mode: 0o700 }); acquired = true;
|
|
30
|
+
const current = JSON.parse(await fs.readFile(lock, "utf8"));
|
|
31
|
+
if (current.nonce === owner.nonce) await fs.unlink(lock);
|
|
32
|
+
} catch (error) { if (!["EEXIST", "ENOENT"].includes(error.code)) throw error; }
|
|
33
|
+
finally { if (acquired) await fs.rmdir(reaper); }
|
|
34
|
+
}
|
|
35
|
+
if (Date.now() >= deadline) throw new Error("Another Backeer installation is active; retry after it completes.");
|
|
36
|
+
await delay(50);
|
|
37
|
+
}
|
|
38
|
+
} finally { await fs.rm(candidate, { force: true }); }
|
|
39
|
+
return async () => {
|
|
40
|
+
try { const current = JSON.parse(await fs.readFile(lock, "utf8")); if (current.nonce === nonce) await fs.unlink(lock); }
|
|
41
|
+
catch (error) { if (error.code !== "ENOENT") throw error; }
|
|
42
|
+
};
|
|
43
|
+
}
|