@phren/cli 0.3.53 → 0.3.54
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/bridge/account-add.d.ts +7 -0
- package/dist/bridge/account-add.js +39 -0
- package/dist/bridge/claude-accounts.js +1 -1
- package/dist/bridge/client.js +1 -1
- package/dist/bridge/command.js +2 -0
- package/dist/bridge/computers.js +3 -2
- package/dist/bridge/conductor-role.d.ts +162 -2
- package/dist/bridge/conductor-role.js +56 -23
- package/dist/bridge/conductor-succession.d.ts +100 -0
- package/dist/bridge/conductor-succession.js +649 -0
- package/dist/bridge/continuation-launch.d.ts +54 -0
- package/dist/bridge/continuation-launch.js +106 -0
- package/dist/bridge/dispatch-command.js +11 -4
- package/dist/bridge/dispatch-hosts.d.ts +3 -0
- package/dist/bridge/dispatch-hosts.js +6 -1
- package/dist/bridge/dispatch-returns.d.ts +21 -3
- package/dist/bridge/dispatch-returns.js +169 -39
- package/dist/bridge/dispatch.d.ts +11 -0
- package/dist/bridge/dispatch.js +70 -5
- package/dist/bridge/hand-off-queue.d.ts +3 -0
- package/dist/bridge/hand-off-queue.js +8 -0
- package/dist/bridge/hand-off.d.ts +13 -0
- package/dist/bridge/hand-off.js +20 -1
- package/dist/bridge/install.js +0 -6
- package/dist/bridge/launch-brief.d.ts +2 -0
- package/dist/bridge/launch-brief.js +19 -8
- package/dist/bridge/move-computers.d.ts +47 -0
- package/dist/bridge/move-computers.js +118 -0
- package/dist/bridge/peer-handoff.d.ts +5 -0
- package/dist/bridge/peer-handoff.js +52 -0
- package/dist/bridge/request-origin.d.ts +6 -0
- package/dist/bridge/request-origin.js +20 -0
- package/dist/bridge/scoped-gateway.d.ts +2 -1
- package/dist/bridge/scoped-gateway.js +16 -3
- package/dist/bridge/server-launch.d.ts +2 -0
- package/dist/bridge/server-launch.js +2 -0
- package/dist/bridge/server-routes.d.ts +6 -0
- package/dist/bridge/server-routes.js +228 -15
- package/dist/bridge/server.js +39 -12
- package/dist/bridge/session-move.d.ts +28 -1
- package/dist/bridge/session-move.js +266 -25
- package/dist/bridge/terminal-herdr.js +14 -0
- package/dist/bridge/terminal-tmux.js +1 -0
- package/dist/bridge/terminal.d.ts +2 -0
- package/dist/bridge/terminal.js +6 -0
- package/dist/bridge/worker-relocation.d.ts +5 -0
- package/dist/bridge/worker-relocation.js +33 -0
- package/dist/bridge-hook.mjs +16154 -14087
- package/dist/modules/registry.js +8 -8
- package/dist/tools/dispatch.js +2 -1
- package/package.json +1 -1
package/dist/bridge/install.js
CHANGED
|
@@ -53,12 +53,6 @@ export function upgradeKeys(text) {
|
|
|
53
53
|
let changed = 0;
|
|
54
54
|
const result = text.split(/(?<=\n)/).map(line => {
|
|
55
55
|
const parsed = keyOptions(line);
|
|
56
|
-
if (parsed && parsed.options[0] === "restrict" && /^\s+ssh-ed25519 [A-Za-z0-9+/=]+ phren-computer:[A-Za-z0-9_.-]+\s*$/.test(parsed.rest)
|
|
57
|
-
&& parsed.options.includes(forcedCommand)) {
|
|
58
|
-
changed++;
|
|
59
|
-
return parsed.options.filter(option => option !== "pty" && option.toLowerCase() !== "port-forwarding" && !option.toLowerCase().startsWith("permitopen="))
|
|
60
|
-
.map(option => option === forcedCommand ? peerForcedCommand : option).join(",") + parsed.rest;
|
|
61
|
-
}
|
|
62
56
|
if (!parsed || parsed.options[0] !== "restrict" || !/^\s+ssh-ed25519 [A-Za-z0-9+/=]+ phren-(?:iphone|android)\s*$/.test(parsed.rest))
|
|
63
57
|
return line;
|
|
64
58
|
const old = /^command="(?:\/usr\/bin\/false|python3 ~\/\.local\/share\/phren\/chat-progress\.py|sh ~\/\.local\/share\/phren\/bridge\/dispatch)"$/;
|
|
@@ -41,6 +41,8 @@ export declare function launchesWithBrief(kind: string): boolean;
|
|
|
41
41
|
* Undefined for an id this computer wrote no label for (older dispatches).
|
|
42
42
|
*/
|
|
43
43
|
export declare function briefLabel(id: string): Promise<string | undefined>;
|
|
44
|
+
/** Moves occupy the launch namespace as well as their own move ledger. */
|
|
45
|
+
export declare function assertUnusedLaunchId(id: string): Promise<void>;
|
|
44
46
|
/**
|
|
45
47
|
* Writes the brief (0600, in a 0700 folder of its own) and returns its path.
|
|
46
48
|
* A `label` is written beside it, inside the same folder, so it is published
|
|
@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
|
|
|
2
2
|
import { lstat, mkdir, readdir, readFile, rename, rm, stat } from "node:fs/promises";
|
|
3
3
|
import path from "node:path";
|
|
4
4
|
import { z } from "zod";
|
|
5
|
-
import { atomic, bridgeRoot, targetSchema } from "./protocol.js";
|
|
5
|
+
import { atomic, BridgeError, bridgeRoot, targetSchema } from "./protocol.js";
|
|
6
6
|
/**
|
|
7
7
|
* A worker's first prompt carried by its launch instead of typed into a
|
|
8
8
|
* starting pane. The brief is written to a private file on the computer that
|
|
@@ -85,6 +85,14 @@ export async function briefLabel(id) {
|
|
|
85
85
|
return undefined;
|
|
86
86
|
}
|
|
87
87
|
}
|
|
88
|
+
/** Moves occupy the launch namespace as well as their own move ledger. */
|
|
89
|
+
export async function assertUnusedLaunchId(id) {
|
|
90
|
+
briefId.parse(id);
|
|
91
|
+
const entries = await Promise.all([briefDirectory(id), path.join(bridgeRoot(), "dispatches", `${id}.json`)].map(file => lstat(file).catch(error => { if (error.code !== "ENOENT")
|
|
92
|
+
throw error; return undefined; })));
|
|
93
|
+
if (entries.some(Boolean))
|
|
94
|
+
throw new BridgeError(409, "This move id already belongs to an existing dispatch or brief.");
|
|
95
|
+
}
|
|
88
96
|
/**
|
|
89
97
|
* Writes the brief (0600, in a 0700 folder of its own) and returns its path.
|
|
90
98
|
* A `label` is written beside it, inside the same folder, so it is published
|
|
@@ -96,7 +104,6 @@ export async function briefLabel(id) {
|
|
|
96
104
|
*/
|
|
97
105
|
export async function writeLaunchBrief(brief, now = Date.now(), label) {
|
|
98
106
|
await mkdir(briefRoot(), { recursive: true, mode: 0o700 });
|
|
99
|
-
await prune(now);
|
|
100
107
|
const directory = briefDirectory(brief.id);
|
|
101
108
|
const file = path.join(directory, "brief.md");
|
|
102
109
|
const text = brief.text.endsWith("\n") ? brief.text : `${brief.text}\n`;
|
|
@@ -106,11 +113,15 @@ export async function writeLaunchBrief(brief, now = Date.now(), label) {
|
|
|
106
113
|
if (named)
|
|
107
114
|
await atomic(path.join(folder, LABEL_FILE), named);
|
|
108
115
|
};
|
|
109
|
-
//
|
|
110
|
-
|
|
111
|
-
await
|
|
116
|
+
// A retry may reuse identical bytes; it must never replace another launch.
|
|
117
|
+
const existing = async () => {
|
|
118
|
+
if (await readFile(file, "utf8").catch(() => undefined) !== text)
|
|
119
|
+
throw new BridgeError(409, "This brief id already belongs to another launch.");
|
|
112
120
|
return file;
|
|
113
|
-
}
|
|
121
|
+
};
|
|
122
|
+
if (await stat(directory).catch(() => undefined))
|
|
123
|
+
return existing();
|
|
124
|
+
await prune(now);
|
|
114
125
|
const staging = path.join(bridgeRoot(), "briefs-staging");
|
|
115
126
|
await mkdir(staging, { recursive: true, mode: 0o700 });
|
|
116
127
|
const draft = path.join(staging, `${brief.id}.${randomUUID()}`);
|
|
@@ -121,10 +132,10 @@ export async function writeLaunchBrief(brief, now = Date.now(), label) {
|
|
|
121
132
|
}
|
|
122
133
|
catch (error) {
|
|
123
134
|
await rm(draft, { recursive: true, force: true }).catch(() => undefined);
|
|
124
|
-
// Another writer published the same id first:
|
|
135
|
+
// Another writer published the same id first: only identical retries are safe.
|
|
125
136
|
if (!(await stat(path.join(directory, "brief.md")).catch(() => undefined)))
|
|
126
137
|
throw error;
|
|
127
|
-
|
|
138
|
+
return existing();
|
|
128
139
|
}
|
|
129
140
|
return file;
|
|
130
141
|
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
import { type moveToSchema } from "./dispatch.js";
|
|
3
|
+
type MoveTo = z.infer<typeof moveToSchema>;
|
|
4
|
+
import { type DispatchHost } from "./dispatch-hosts.js";
|
|
5
|
+
import { type Json } from "./protocol.js";
|
|
6
|
+
declare const availability: z.ZodObject<{
|
|
7
|
+
computerId: z.ZodOptional<z.ZodString>;
|
|
8
|
+
hasCheckout: z.ZodBoolean;
|
|
9
|
+
harnesses: z.ZodArray<z.ZodObject<{
|
|
10
|
+
source: z.ZodEnum<{
|
|
11
|
+
claude: "claude";
|
|
12
|
+
codex: "codex";
|
|
13
|
+
copilot: "copilot";
|
|
14
|
+
opencode: "opencode";
|
|
15
|
+
}>;
|
|
16
|
+
usable: z.ZodBoolean;
|
|
17
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
18
|
+
accounts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
19
|
+
id: z.ZodString;
|
|
20
|
+
label: z.ZodString;
|
|
21
|
+
usable: z.ZodBoolean;
|
|
22
|
+
signedIn: z.ZodBoolean;
|
|
23
|
+
email: z.ZodOptional<z.ZodString>;
|
|
24
|
+
plan: z.ZodOptional<z.ZodString>;
|
|
25
|
+
current: z.ZodDefault<z.ZodBoolean>;
|
|
26
|
+
fiveHourResetsAt: z.ZodOptional<z.ZodString>;
|
|
27
|
+
weekResetsAt: z.ZodOptional<z.ZodString>;
|
|
28
|
+
fiveHourLeft: z.ZodOptional<z.ZodNumber>;
|
|
29
|
+
weekLeft: z.ZodOptional<z.ZodNumber>;
|
|
30
|
+
resetsAt: z.ZodOptional<z.ZodString>;
|
|
31
|
+
}, z.core.$strip>>>;
|
|
32
|
+
}, z.core.$strip>>;
|
|
33
|
+
}, z.core.$strip>;
|
|
34
|
+
export type MoveAvailability = z.infer<typeof availability>;
|
|
35
|
+
export declare function localMoveAvailability(project: unknown, usage: () => Promise<Json>, conductor?: boolean): Promise<MoveAvailability>;
|
|
36
|
+
/** Exact verified names only; self also accepts the name health displays. */
|
|
37
|
+
export declare function movePeer(computer: string | undefined, self?: string): Promise<DispatchHost | undefined>;
|
|
38
|
+
export declare function peerMoveAvailability(peer: DispatchHost, project: string, conductor?: boolean): Promise<MoveAvailability>;
|
|
39
|
+
export declare function checkMovePeer(peer: DispatchHost, project: string, to: MoveTo, conductor?: boolean): Promise<{
|
|
40
|
+
account?: string;
|
|
41
|
+
accountChoice?: string;
|
|
42
|
+
computerId?: string;
|
|
43
|
+
}>;
|
|
44
|
+
export declare function moveComputers(project: unknown, self: string, local: () => Promise<MoveAvailability>, currentAccount?: string, conductor?: boolean): Promise<Json>;
|
|
45
|
+
/** Re-read enrollment before every request that may transmit a brief. */
|
|
46
|
+
export declare function currentMovePeer(captured: DispatchHost): Promise<DispatchHost>;
|
|
47
|
+
export {};
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
// Continuation destinations expose login labels and quota, never auth material.
|
|
2
|
+
import { z } from "zod";
|
|
3
|
+
import { dispatchProjectDirectory, PEER_COPILOT_REASON, projectName } from "./dispatch.js";
|
|
4
|
+
import { chooseAccount } from "./account-choice.js";
|
|
5
|
+
import { harnessInventoryWithin } from "./harnesses.js";
|
|
6
|
+
import { peerHost, isLocalComputer } from "./dispatch-hosts.js";
|
|
7
|
+
import { hookPeers, optionalHookPeers } from "./peers.js";
|
|
8
|
+
import { BridgeError } from "./protocol.js";
|
|
9
|
+
const account = z.object({ id: z.string().max(64), label: z.string().max(200), usable: z.boolean(), signedIn: z.boolean(), email: z.string().optional(), plan: z.string().optional(), current: z.boolean().default(false),
|
|
10
|
+
fiveHourResetsAt: z.string().optional(), weekResetsAt: z.string().optional(),
|
|
11
|
+
fiveHourLeft: z.number().min(0).max(100).optional(), weekLeft: z.number().min(0).max(100).optional(), resetsAt: z.string().optional() });
|
|
12
|
+
const availability = z.object({ computerId: z.string().uuid().optional(), hasCheckout: z.boolean(), harnesses: z.array(z.object({
|
|
13
|
+
source: z.enum(["claude", "codex", "opencode", "copilot"]), usable: z.boolean(), reason: z.string().optional(), accounts: z.array(account).optional(),
|
|
14
|
+
})) });
|
|
15
|
+
export async function localMoveAvailability(project, usage, conductor = false) {
|
|
16
|
+
const name = project === null || project === undefined || project === "" ? undefined : projectName.parse(project);
|
|
17
|
+
const [checkout, found, limits] = await Promise.all([
|
|
18
|
+
conductor ? Promise.resolve(true) : name ? dispatchProjectDirectory(name).then(() => true, () => false) : Promise.resolve(false),
|
|
19
|
+
harnessInventoryWithin(2_500),
|
|
20
|
+
usage().catch(() => ({})),
|
|
21
|
+
]);
|
|
22
|
+
const { claudeMoveAccounts } = await import("./hand-off.js");
|
|
23
|
+
const rooms = claudeMoveAccounts(limits);
|
|
24
|
+
const { claudeHomes, claudeAccountRef, claudeAccountEmail, claudeAccountSubscription } = await import("./claude-accounts.js");
|
|
25
|
+
const discovered = found?.harnesses ?? [];
|
|
26
|
+
const claude = discovered.find(row => row.source === "claude");
|
|
27
|
+
const accounts = [...claude?.accounts ?? []];
|
|
28
|
+
for (const home of claudeHomes())
|
|
29
|
+
if (!accounts.some(login => login.id === home.id)) {
|
|
30
|
+
const ref = claudeAccountRef(home), email = claudeAccountEmail(home), subscription = claudeAccountSubscription(home);
|
|
31
|
+
accounts.push({ ...ref, usable: false, signedIn: false, ...(email ? { email } : {}), ...(subscription?.plan ? { plan: subscription.plan } : {}) });
|
|
32
|
+
}
|
|
33
|
+
const inventory = claude ? discovered.map(row => row.source === "claude" ? { ...row, accounts } : row) : [...discovered, { source: "claude", installed: false, usable: false, accounts }];
|
|
34
|
+
return availability.parse({ hasCheckout: checkout, harnesses: inventory.filter(row => row.source !== "phren").map(row => ({
|
|
35
|
+
source: row.source, usable: row.usable, ...(row.accounts ? { accounts: row.accounts.map(login => {
|
|
36
|
+
const room = row.source === "claude" ? rooms.find(item => item.id === login.id) : undefined;
|
|
37
|
+
return { ...room, id: login.id, label: login.label ?? login.id, usable: login.usable && room?.fiveHourLeft !== 0 && room?.weekLeft !== 0, signedIn: login.signedIn, ...(login.email ? { email: login.email } : {}), ...(login.plan ? { plan: login.plan } : {}) };
|
|
38
|
+
}) } : {}),
|
|
39
|
+
})) });
|
|
40
|
+
}
|
|
41
|
+
/** Exact verified names only; self also accepts the name health displays. */
|
|
42
|
+
export async function movePeer(computer, self) {
|
|
43
|
+
if (computer === undefined || computer === self)
|
|
44
|
+
return undefined;
|
|
45
|
+
const peers = await hookPeers().catch(error => {
|
|
46
|
+
if (error instanceof BridgeError && error.details?.hooksYaml === "missing")
|
|
47
|
+
return [];
|
|
48
|
+
throw error;
|
|
49
|
+
});
|
|
50
|
+
const peer = peers.find(row => row.name === computer);
|
|
51
|
+
if (peer)
|
|
52
|
+
return peerHost(peer);
|
|
53
|
+
if (isLocalComputer(computer))
|
|
54
|
+
return undefined;
|
|
55
|
+
throw new BridgeError(404, "Unknown computer. Add its verified connection to hooks.yaml.");
|
|
56
|
+
}
|
|
57
|
+
export async function peerMoveAvailability(peer, project, conductor = false) {
|
|
58
|
+
try {
|
|
59
|
+
return availability.parse(await peer.request(`/v1/sessions/move/availability?project=${encodeURIComponent(project)}${conductor ? "&conductor=1" : ""}`, undefined, 10_000));
|
|
60
|
+
}
|
|
61
|
+
catch {
|
|
62
|
+
throw new BridgeError(409, `Computer ${peer.name} is offline or cannot report continuation availability.`);
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
function chosenLogin(accounts) {
|
|
66
|
+
return chooseAccount(accounts.map(login => ({ account: login.id, usable: login.usable,
|
|
67
|
+
exhausted: login.fiveHourLeft === 0 || login.weekLeft === 0,
|
|
68
|
+
fiveHour: { leftPercent: login.fiveHourLeft }, week: { leftPercent: login.weekLeft },
|
|
69
|
+
}))).choice;
|
|
70
|
+
}
|
|
71
|
+
export async function checkMovePeer(peer, project, to, conductor = false) {
|
|
72
|
+
if (to.harness === "copilot")
|
|
73
|
+
throw new BridgeError(409, PEER_COPILOT_REASON);
|
|
74
|
+
const facts = await peerMoveAvailability(peer, project, conductor);
|
|
75
|
+
if (!facts.hasCheckout)
|
|
76
|
+
throw new BridgeError(409, `Computer ${peer.name} has no checkout of ${project}.`);
|
|
77
|
+
const harness = facts.harnesses.find(row => row.source === to.harness);
|
|
78
|
+
const choice = to.harness === "claude" && !to.account && harness?.accounts ? chosenLogin(harness.accounts) : undefined;
|
|
79
|
+
const login = harness?.accounts?.find(row => row.id === (to.account ?? choice?.account ?? "default"));
|
|
80
|
+
if (!harness?.usable || (harness.accounts && !login?.usable) || login?.fiveHourLeft === 0 || login?.weekLeft === 0) {
|
|
81
|
+
throw new BridgeError(409, `The harness or account is not usable on ${peer.name}.`);
|
|
82
|
+
}
|
|
83
|
+
if (!facts.computerId)
|
|
84
|
+
throw new BridgeError(409, `Update ${peer.name}'s Hook to verify its continuation identity.`);
|
|
85
|
+
return { ...(facts.computerId ? { computerId: facts.computerId } : {}), ...(choice ? { account: choice.account, accountChoice: choice.reason } : {}) };
|
|
86
|
+
}
|
|
87
|
+
export async function moveComputers(project, self, local, currentAccount, conductor = false) {
|
|
88
|
+
const name = project === null || project === undefined || project === "" ? "" : projectName.parse(project);
|
|
89
|
+
const { peers } = await optionalHookPeers();
|
|
90
|
+
const here = await local();
|
|
91
|
+
const publicFacts = (facts, remote = false) => ({ ...(facts.computerId ? { computerId: facts.computerId } : {}), hasCheckout: facts.hasCheckout, harnesses: facts.harnesses.map(row => ({
|
|
92
|
+
source: row.source, usable: remote && row.source === "copilot" ? false : row.usable,
|
|
93
|
+
...(remote && row.source === "copilot" ? { reason: PEER_COPILOT_REASON } : {}),
|
|
94
|
+
...(row.source === "claude" && row.accounts ? { selectedAccount: chosenLogin(row.accounts)?.account } : {}), ...(row.accounts ? { accounts: row.accounts.map(({ signedIn: _signedIn, ...login }) => ({ ...login, current: !remote && row.source === "claude" && login.id === currentAccount })) } : {}),
|
|
95
|
+
})) });
|
|
96
|
+
const computers = await Promise.all(peers.map(async (peer) => {
|
|
97
|
+
try {
|
|
98
|
+
return { name: peer.name, self: false, online: true, ...publicFacts(await peerMoveAvailability(peerHost(peer), name, conductor), true) };
|
|
99
|
+
}
|
|
100
|
+
catch {
|
|
101
|
+
return { name: peer.name, self: false, online: false, hasCheckout: false, harnesses: [] };
|
|
102
|
+
}
|
|
103
|
+
}));
|
|
104
|
+
return { computers: [{ name: self, self: true, online: true, ...publicFacts(here) }, ...computers],
|
|
105
|
+
localClaudeLogins: here.harnesses.find(row => row.source === "claude")?.accounts?.filter(login => login.signedIn).length ?? 0 };
|
|
106
|
+
}
|
|
107
|
+
/** Re-read enrollment before every request that may transmit a brief. */
|
|
108
|
+
export async function currentMovePeer(captured) {
|
|
109
|
+
const current = await movePeer(captured.name).catch(() => undefined);
|
|
110
|
+
if (!current || !current.fingerprint || current.fingerprint !== captured.fingerprint)
|
|
111
|
+
throw new BridgeError(409, "The destination enrollment was revoked or changed; no brief was sent.");
|
|
112
|
+
return { ...current, request: async (route, data, timeout) => {
|
|
113
|
+
const enrolled = await movePeer(captured.name).catch(() => undefined);
|
|
114
|
+
if (!enrolled || enrolled.fingerprint !== captured.fingerprint)
|
|
115
|
+
throw new BridgeError(409, "The destination enrollment was revoked or changed; no brief was sent.");
|
|
116
|
+
return enrolled.request(route, data, timeout);
|
|
117
|
+
} };
|
|
118
|
+
}
|
|
@@ -0,0 +1,5 @@
|
|
|
1
|
+
/** Only human/agent prose is redacted. Opaque protocol fields (tokens, paths,
|
|
2
|
+
* capabilities, identities and grants) must retain their exact values. */
|
|
3
|
+
export declare function redactPeerHandoff(input: string): string;
|
|
4
|
+
/** Conductor operation envelopes contain prose beside opaque routing data. */
|
|
5
|
+
export declare function redactPeerPayload<T>(data: T): T;
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
/** Only human/agent prose is redacted. Opaque protocol fields (tokens, paths,
|
|
2
|
+
* capabilities, identities and grants) must retain their exact values. */
|
|
3
|
+
export function redactPeerHandoff(input) {
|
|
4
|
+
const value = String.raw `(?:\[redacted\]|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s]+)`;
|
|
5
|
+
let text = input.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "")
|
|
6
|
+
.replace(/(?<![\w.+-])([a-z][a-z0-9+.-]*:\/\/)[^/\s?#]+@/gi, "$1[redacted]@")
|
|
7
|
+
.replace(/(\b(?:Authorization|Cookie|Set-Cookie|X-API-Key)[\t ]*:[\t ]*)[^\r\n]*/gi, "$1[redacted]")
|
|
8
|
+
.replace(new RegExp(String.raw `(\bBearer[\t ]+)${value}`, "gi"), "$1[redacted]")
|
|
9
|
+
.replace(/\b(?:mysql|curl)\b[^\r\n]*/gi, line => {
|
|
10
|
+
if (/\bmysql\b/i.test(line))
|
|
11
|
+
line = line.replace(/([\t ]-p)(?![\t ]|$)[^\s]+/g, "$1[redacted]");
|
|
12
|
+
if (/\bcurl\b/i.test(line))
|
|
13
|
+
line = line.replace(new RegExp(String.raw `([\t ](?:-u|--user)[\t ]+)${value}`, "g"), "$1[redacted]");
|
|
14
|
+
return line;
|
|
15
|
+
});
|
|
16
|
+
// Consume each identifier once, then inspect its name. Requiring a genuine
|
|
17
|
+
// token boundary prevents restarting a greedy search at each dot in a path.
|
|
18
|
+
const keys = /(?<![\w.-])(?:"([\w.-]+)"|'([\w.-]+)'|([\w.-]+))([\t ]*(?:[:=][\t ]*|[\t ]+))/g;
|
|
19
|
+
const secretName = /pass|pwd|token|secret|api[-_]?key|auth|bearer|credential/i;
|
|
20
|
+
const values = new RegExp(value, "y");
|
|
21
|
+
const parts = [];
|
|
22
|
+
let copied = 0;
|
|
23
|
+
for (let match; (match = keys.exec(text));) {
|
|
24
|
+
const name = match[1] ?? match[2] ?? match[3];
|
|
25
|
+
const cleanName = name.replace(/^--/, "");
|
|
26
|
+
if (!secretName.test(cleanName) || /^(?:author|authority)$/i.test(cleanName) || !name.startsWith("--") && !/[:=]/.test(match[4]) && cleanName.toLowerCase() !== "bearer")
|
|
27
|
+
continue;
|
|
28
|
+
const start = keys.lastIndex;
|
|
29
|
+
values.lastIndex = start;
|
|
30
|
+
let found = values.exec(text);
|
|
31
|
+
if (found?.[0] === "-p") {
|
|
32
|
+
values.lastIndex = start + 2 + (/^[\t ]*/.exec(text.slice(start + 2))?.[0].length ?? 0);
|
|
33
|
+
found = values.exec(text);
|
|
34
|
+
}
|
|
35
|
+
if (!found && text[start] !== "\n" && text[start] !== "\r" && start !== text.length)
|
|
36
|
+
continue;
|
|
37
|
+
const end = found ? values.lastIndex : start;
|
|
38
|
+
parts.push(text.slice(copied, start), "[redacted]");
|
|
39
|
+
copied = end;
|
|
40
|
+
keys.lastIndex = end;
|
|
41
|
+
}
|
|
42
|
+
parts.push(text.slice(copied));
|
|
43
|
+
text = parts.join("");
|
|
44
|
+
// Recognizable credential formats are excised, never inferred from the
|
|
45
|
+
// length/base64 shape of ordinary paths or used to refuse a continuation.
|
|
46
|
+
return text.replace(/-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----[\s\S]*?(?:-----END (?:[A-Z0-9 ]+ )?PRIVATE KEY-----|$)|\b(?:AKIA[0-9A-Z]{16}|gh[pousr]_[A-Za-z0-9]{36}|github_pat_[A-Za-z0-9_]{22,}|AIza[0-9A-Za-z_-]{35}|sk-ant-api\d{2}-[\w-]{10,}|sk-proj-[\w-]{30,}|[sp]k_live_[A-Za-z0-9]{24,}|npm_[A-Za-z0-9]{36}|xox[bp]-[0-9]+-[A-Za-z0-9-]+)|(?<![\w-])eyJ[\w-]+\.[\w-]+\.[\w-]+|https:\/\/hooks\.slack\.com\/services\/T\w+\/B\w+\/\w+/g, "[redacted]");
|
|
47
|
+
}
|
|
48
|
+
const proseFields = new Set(["text", "prompt", "reply", "error", "message", "notice", "reason", "description", "title", "label", "question", "request"]);
|
|
49
|
+
/** Conductor operation envelopes contain prose beside opaque routing data. */
|
|
50
|
+
export function redactPeerPayload(data) {
|
|
51
|
+
return JSON.parse(JSON.stringify(data, (key, value) => typeof value === "string" && proseFields.has(key) ? redactPeerHandoff(value) : value));
|
|
52
|
+
}
|
|
@@ -4,3 +4,9 @@ import type { Json } from "./protocol.js";
|
|
|
4
4
|
* peer origin. Peer keys are forced through the peer scope, which rebuilds
|
|
5
5
|
* the request with its own origin header; MCP calls carry an agent origin. */
|
|
6
6
|
export declare function ownerRequest(request: Pick<IncomingMessage, "headers">, data: Json): boolean;
|
|
7
|
+
export interface PeerIdentity {
|
|
8
|
+
name?: string;
|
|
9
|
+
id?: string;
|
|
10
|
+
fingerprint: string;
|
|
11
|
+
}
|
|
12
|
+
export declare function requestPeer(request: Pick<IncomingMessage, "headers">): PeerIdentity | undefined;
|
|
@@ -4,3 +4,23 @@
|
|
|
4
4
|
export function ownerRequest(request, data) {
|
|
5
5
|
return request.headers?.["x-phren-origin"] === undefined && data.origin === undefined;
|
|
6
6
|
}
|
|
7
|
+
export function requestPeer(request) {
|
|
8
|
+
if (request.headers?.["x-phren-origin"] !== "peer")
|
|
9
|
+
return undefined;
|
|
10
|
+
const encoded = request.headers?.["x-phren-peer"];
|
|
11
|
+
if (typeof encoded !== "string")
|
|
12
|
+
return undefined;
|
|
13
|
+
try {
|
|
14
|
+
const value = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
|
|
15
|
+
if (!/^[a-f0-9]{64}$/.test(value.fingerprint) || value.id !== undefined && !/^[a-f0-9-]{36}$/i.test(value.id))
|
|
16
|
+
return undefined;
|
|
17
|
+
if (value.name !== undefined && (typeof value.name !== "string" || !/^[A-Za-z0-9_.-]{1,253}$/.test(value.name)))
|
|
18
|
+
return undefined;
|
|
19
|
+
if (value.name === undefined && value.id === undefined)
|
|
20
|
+
return undefined;
|
|
21
|
+
return { ...(value.name ? { name: value.name } : {}), ...(value.id ? { id: value.id } : {}), fingerprint: value.fingerprint };
|
|
22
|
+
}
|
|
23
|
+
catch {
|
|
24
|
+
return undefined;
|
|
25
|
+
}
|
|
26
|
+
}
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { type PeerIdentity } from "./request-origin.js";
|
|
1
2
|
import type { Readable, Writable } from "node:stream";
|
|
2
3
|
export declare const GATEWAY_SCOPES: readonly ["gitboy-read", "gitboy-write"];
|
|
3
4
|
export type GatewayScope = typeof GATEWAY_SCOPES[number];
|
|
@@ -18,7 +19,7 @@ export type Admission = {
|
|
|
18
19
|
export declare function admitScopedRequest(scope: GatewayScope, rawHead: string, rest?: Buffer): Admission;
|
|
19
20
|
/** A computer key's forced scope rebuilds the HTTP envelope. Client headers
|
|
20
21
|
* cannot impersonate the owner gateway, and peer keys cannot open terminals. */
|
|
21
|
-
export declare function admitPeerRequest(rawHead: string, rest?: Buffer): Admission;
|
|
22
|
+
export declare function admitPeerRequest(rawHead: string, rest?: Buffer, identity?: PeerIdentity): Admission;
|
|
22
23
|
export interface ScopedIO {
|
|
23
24
|
input: Readable;
|
|
24
25
|
output: Writable;
|
|
@@ -1,3 +1,5 @@
|
|
|
1
|
+
import { hookPeers } from "./peers.js";
|
|
2
|
+
import { peerFingerprint } from "./dispatch-hosts.js";
|
|
1
3
|
import { connect } from "node:net";
|
|
2
4
|
import { BridgeError } from "./protocol.js";
|
|
3
5
|
import { findingWriteSchema, taskCompleteSchema, isBranchName, isRepoPath, isSearchText, MAX_FILE_PATHS, MAX_FINDING_BODY, PROJECT_NAME, } from "./gitboy-contract.js";
|
|
@@ -167,7 +169,7 @@ export function admitScopedRequest(scope, rawHead, rest = Buffer.alloc(0)) {
|
|
|
167
169
|
}
|
|
168
170
|
/** A computer key's forced scope rebuilds the HTTP envelope. Client headers
|
|
169
171
|
* cannot impersonate the owner gateway, and peer keys cannot open terminals. */
|
|
170
|
-
export function admitPeerRequest(rawHead, rest = Buffer.alloc(0)) {
|
|
172
|
+
export function admitPeerRequest(rawHead, rest = Buffer.alloc(0), identity) {
|
|
171
173
|
const head = parseHead(rawHead);
|
|
172
174
|
if ("ok" in head)
|
|
173
175
|
return head;
|
|
@@ -179,7 +181,7 @@ export function admitPeerRequest(rawHead, rest = Buffer.alloc(0)) {
|
|
|
179
181
|
return refuse(415, "Send Content-Type: application/json.");
|
|
180
182
|
const body = rest.toString("utf8");
|
|
181
183
|
const target = head.path + (head.query === null ? "" : `?${head.query}`);
|
|
182
|
-
return { ok: true, request: `${head.method} ${target} HTTP/1.1\r\nHost: phren.local\r\nX-Phren-Origin: peer\r\
|
|
184
|
+
return { ok: true, request: `${head.method} ${target} HTTP/1.1\r\nHost: phren.local\r\nX-Phren-Origin: peer\r\n${identity ? `X-Phren-Peer: ${Buffer.from(JSON.stringify(identity)).toString("base64url")}\r\n` : ""}Connection: close\r\nContent-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}` };
|
|
183
185
|
}
|
|
184
186
|
const REASONS = { 400: "Bad Request", 403: "Forbidden", 408: "Request Timeout", 413: "Content Too Large", 415: "Unsupported Media Type", 503: "Service Unavailable" };
|
|
185
187
|
function httpResponse(status, error) {
|
|
@@ -232,12 +234,23 @@ function readRequest(scope, input) {
|
|
|
232
234
|
* reads a normal response.
|
|
233
235
|
*/
|
|
234
236
|
export async function scopedDispatch(scope, command, io) {
|
|
237
|
+
let identity;
|
|
238
|
+
if (scope.startsWith("peer:")) {
|
|
239
|
+
const peer = (await hookPeers().catch(() => [])).find(peer => peer.name === scope.slice(5));
|
|
240
|
+
// The forced-command enrollment binds this client key to the reverse
|
|
241
|
+
// host-key + OS account pin. The Hook verifies its stable computer ID
|
|
242
|
+
// over that pin when authorizing a move. Do not probe here: two gateways
|
|
243
|
+
// probing one another's /health would recursively open SSH sessions.
|
|
244
|
+
if (peer)
|
|
245
|
+
identity = { name: peer.name, fingerprint: peerFingerprint(peer) };
|
|
246
|
+
scope = "peer";
|
|
247
|
+
}
|
|
235
248
|
if (scope !== "peer" && !isGatewayScope(scope))
|
|
236
249
|
throw new BridgeError(403, "Unknown key scope.");
|
|
237
250
|
if (command !== SCOPED_COMMAND)
|
|
238
251
|
throw new BridgeError(403, `This SSH key only permits \`${SCOPED_COMMAND}\` with ${scope === "peer" ? "Hook API requests" : DESCRIBE[scope]}.`);
|
|
239
252
|
const read = await readRequest(scope, io.input);
|
|
240
|
-
const admission = "head" in read ? (scope === "peer" ? admitPeerRequest(read.head, read.rest) : admitScopedRequest(scope, read.head, read.rest)) : refuse(read.status, read.error);
|
|
253
|
+
const admission = "head" in read ? (scope === "peer" ? admitPeerRequest(read.head, read.rest, identity) : admitScopedRequest(scope, read.head, read.rest)) : refuse(read.status, read.error);
|
|
241
254
|
if (!admission.ok) {
|
|
242
255
|
await new Promise(done => io.output.write(httpResponse(admission.status, admission.error), () => done()));
|
|
243
256
|
return;
|
|
@@ -42,6 +42,8 @@ type InventoryReader = () => Promise<HarnessInventory>;
|
|
|
42
42
|
/** Only for tests: what this computer can launch. Without one, `PHREN_LAUNCH_CHECK=off` skips the early availability check. */
|
|
43
43
|
export declare function setLaunchInventory(reader: InventoryReader | undefined): void;
|
|
44
44
|
export interface LaunchOptions {
|
|
45
|
+
/** Persist a newly created pane before starting or prompting its harness. */
|
|
46
|
+
onPlaced?: (paneTarget: Json) => Promise<void>;
|
|
45
47
|
canary?: boolean;
|
|
46
48
|
/** `data.cwd` is a folder the Hook resolved itself (a dispatched or
|
|
47
49
|
* scheduled project's source folder), so it may be marked trusted for the
|
|
@@ -172,6 +172,7 @@ export async function localConductor(known) {
|
|
|
172
172
|
/** Refuses a second conductor in this computer's set: a live one here on
|
|
173
173
|
* another pane, or on any member. Members that could not say come back as `unchecked`. */
|
|
174
174
|
async function requireNoConductor(server, before, except) {
|
|
175
|
+
(await import("./conductor-role.js")).assertRoleMutable(await readRoleState());
|
|
175
176
|
const existing = await localConductor({ server, snapshot: before });
|
|
176
177
|
if (existing && !(except && existing.server === server && existing.target?.pane === except)) {
|
|
177
178
|
throw new BridgeError(409, "A conductor is already running on this computer. Stop it first.", { target: existing.target });
|
|
@@ -520,6 +521,7 @@ async function startSession(server, data, options) {
|
|
|
520
521
|
if (!created)
|
|
521
522
|
throw new BridgeError(409, `${terminalName(server)} created "${label}" but its pane did not appear. Check ${terminalName(server)} on the computer.`);
|
|
522
523
|
const place = { workspace: created.workspaceId, tab: created.tabId, pane: created.paneId };
|
|
524
|
+
await options.onPlaced?.({ server, ...place, source: kind });
|
|
523
525
|
const structuredLaunch = structured ? await codexServers.launch({ server, ...place }, { cwd, ...(model ? { model } : {}),
|
|
524
526
|
...(data.effort === undefined ? {} : { effort }), env: { ...(terminalProvider().paneEnv?.(server, place) ?? {}), ...(env ?? {}) },
|
|
525
527
|
...(brief ? { dispatchId: brief.id } : {}), startThread: !!brief, ...(permissionMode ? { remoteArgs: codexModeFlags(permissionMode) } : {}) }).catch(error => {
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import type { ConductorSuccessionService } from "./conductor-succession.js";
|
|
1
2
|
import type { StorePulls } from "./store-pull.js";
|
|
2
3
|
import type { GitboyWebhooks } from "./gitboy-webhooks.js";
|
|
3
4
|
import { type SessionMover } from "./session-move.js";
|
|
@@ -61,6 +62,7 @@ export interface RouteContext {
|
|
|
61
62
|
handOffs?: HandOffQueue;
|
|
62
63
|
inbox?: OwnerInbox;
|
|
63
64
|
mover?: SessionMover;
|
|
65
|
+
succession?: ConductorSuccessionService;
|
|
64
66
|
agentHooks: AgentHooks;
|
|
65
67
|
journal: ActivityJournal;
|
|
66
68
|
tabActivity: TabActivityStore;
|
|
@@ -140,6 +142,10 @@ export declare const capabilities: {
|
|
|
140
142
|
sessionMove: boolean;
|
|
141
143
|
moveNewChat: boolean;
|
|
142
144
|
moveConductor: boolean;
|
|
145
|
+
moveToComputer: boolean;
|
|
146
|
+
moveConductorToComputer: boolean;
|
|
147
|
+
claudeAccountAdd: boolean;
|
|
148
|
+
workerRelocation: number;
|
|
143
149
|
projectMemory: boolean;
|
|
144
150
|
fileWrite: boolean;
|
|
145
151
|
fileSearch: boolean;
|