1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
import type { BrowserClient } from "../client";
import { discoverEndpoint } from "../cdp/discovery";
import { currentCdpTarget } from "../cdp/current-target";
import { describeCdpTarget } from "../cdp/endpoint";
import { type Result, err, ok } from "../util/result";
import { type BrowserProfile, listProfiles } from "./list";
import { browserNameForUserDataDir, userDataDirCandidates } from "./paths";
import { clearPin, type ProfilePin, readPin, writePin } from "./store";
// `ctx.ui.select` resolves to undefined both on Escape and in non-interactive modes, so "no answer" must mean "change nothing".
const CLEAR_SELECTION_LABEL = "— Clear selection (use whichever window is focused) —";
type ProfileChoice =
| { readonly kind: "profile"; readonly profile: BrowserProfile }
| { readonly kind: "clear" }
| { readonly kind: "cancelled" };
const disambiguate = (profiles: ReadonlyArray<BrowserProfile>): ReadonlyArray<string> => {
const counts = new Map<string, number>();
for (const p of profiles) counts.set(p.label, (counts.get(p.label) ?? 0) + 1);
return profiles.map((p) => ((counts.get(p.label) ?? 0) > 1 ? `${p.label} [${p.dir}]` : p.label));
};
const promptForProfile = async (
ctx: ExtensionContext,
profiles: ReadonlyArray<BrowserProfile>,
currentPin: ProfilePin | null,
title = "Select browser profile",
): Promise<ProfileChoice> => {
if (!ctx.hasUI || profiles.length === 0) return { kind: "cancelled" };
const labels = disambiguate(profiles);
const rows = labels.map((label, i) => {
const isPinned = currentPin?.profileDir === profiles[i]?.dir;
return isPinned ? `✓ ${label}` : ` ${label}`;
});
const options = [...rows, CLEAR_SELECTION_LABEL];
const answer = await ctx.ui.select(title, options);
if (answer === undefined) return { kind: "cancelled" };
if (answer === CLEAR_SELECTION_LABEL) return { kind: "clear" };
const index = options.indexOf(answer);
const profile = index >= 0 ? profiles[index] : undefined;
if (!profile) return { kind: "cancelled" };
return { kind: "profile", profile };
};
const pinFor = (userDataDir: string, profile: BrowserProfile): ProfilePin => ({
userDataDir,
profileDir: profile.dir,
label: profile.label,
savedAt: new Date().toISOString(),
});
const resolveUserDataDir = async (client: BrowserClient): Promise<Result<string, string>> => {
const connected = client.userDataDir();
if (connected) return ok(connected);
const endpoint = await discoverEndpoint();
if (endpoint.success && endpoint.data.userDataDir) return ok(endpoint.data.userDataDir);
// A remote browser has no user-data-dir on THIS disk. Falling through to the
// local candidates below would enumerate whatever Chromium browsers happen to
// be installed here and offer their profiles for a browser on another host —
// profiles the harness is not connected to and cannot open a window in. Worse,
// pinning one sends seedProfileWindow() off to launch a local browser whose
// sentinel page can never appear over this connection.
const target = await currentCdpTarget();
if (target.kind === "remote") {
return err(
`Profile selection needs a browser on this machine, but the harness is driving ${describeCdpTarget(target)}. ` +
"Choosing a profile works by launching the browser with --profile-directory, which only reaches a local browser. " +
"Run /browser-target local to drive this machine's browser, then /browser-profile.",
);
}
const withProfiles: string[] = [];
for (const dir of userDataDirCandidates()) {
if ((await listProfiles(dir)).length > 0) withProfiles.push(dir);
}
const only = withProfiles[0];
if (withProfiles.length === 1 && only !== undefined) return ok(only);
if (withProfiles.length === 0) {
return err("No browser profiles found on this machine. Open Chrome, Brave, or Edge and try again.");
}
return err(
`Found profiles for more than one browser (${withProfiles.map(browserNameForUserDataDir).join(", ")}). ` +
"Open the browser you want the agent to use, then run /browser-profile again.",
);
};
const loadProfiles = async (
client: BrowserClient,
): Promise<Result<{ userDataDir: string; profiles: ReadonlyArray<BrowserProfile> }, string>> => {
const dir = await resolveUserDataDir(client);
if (!dir.success) return dir;
const profiles = await listProfiles(dir.data);
if (profiles.length === 0) {
return err(`No profiles found in ${dir.data}. If the browser was just installed, open it once and retry.`);
}
return ok({ userDataDir: dir.data, profiles });
};
const applyToLiveSession = async (client: BrowserClient): Promise<Result<void, string>> => {
if (!client.status().alive) return ok(undefined);
await client.closeOwnedTabs();
await client.stop();
const started = await client.start();
if (!started.success) return err(started.error.message);
return ok(undefined);
};
export function registerProfileCommand(pi: ExtensionAPI, client: BrowserClient): void {
pi.registerCommand("browser-profile", {
description: "Choose which browser profile the agent uses",
handler: async (_args, ctx) => {
const loaded = await loadProfiles(client);
if (!loaded.success) {
ctx.ui.notify(loaded.error, "error");
return;
}
if (!ctx.hasUI) {
ctx.ui.notify("Profile selection needs an interactive terminal.", "warning");
return;
}
const currentPin = client.profilePin() ?? (await readPin());
const choice = await promptForProfile(ctx, loaded.data.profiles, currentPin);
if (choice.kind === "cancelled") {
ctx.ui.notify("Profile unchanged.", "info");
return;
}
if (choice.kind === "clear") {
const cleared = await clearPin();
if (!cleared.success) {
ctx.ui.notify(cleared.error, "error");
return;
}
client.setProfilePin(null);
ctx.ui.notify(
"Profile selection cleared. New windows will open in whichever browser profile is focused.",
"info",
);
return;
}
const pin = pinFor(loaded.data.userDataDir, choice.profile);
const saved = await writePin(pin);
if (!saved.success) {
ctx.ui.notify(saved.error, "error");
return;
}
client.setProfilePin(pin);
const applied = await applyToLiveSession(client);
if (!applied.success) {
ctx.ui.notify(
`Saved ${pin.label}, but switching the open session failed: ${applied.error}`,
"warning",
);
return;
}
ctx.ui.notify(`Browser profile: ${pin.label} ✓\nSaved — this profile is used until you change it.`, "info");
},
});
}
export const promptForProfileIfUnset = async (
client: BrowserClient,
ctx: ExtensionContext | undefined,
): Promise<string | undefined> => {
if (client.profilePin()) return undefined;
const stored = await readPin();
if (stored) {
client.setProfilePin(stored);
return undefined;
}
// Never prompt for a remote browser. Profile selection cannot act on one (see
// resolveUserDataDir), so asking would be a blocking question with no useful
// answer — and every cancelled prompt stores nothing, so it would come back
// every session. Silence is correct here: the browser keeps its own default
// profile, and /browser-status already reports which browser is being driven.
if ((await currentCdpTarget()).kind === "remote") return undefined;
if (!ctx?.hasUI) {
return "No browser profile selected — using whichever window is focused. Run /browser-profile to pin one.";
}
const loaded = await loadProfiles(client);
if (!loaded.success) return loaded.error;
const choice = await promptForProfile(
ctx,
loaded.data.profiles,
null,
"Select the browser profile the agent should use",
);
if (choice.kind !== "profile") {
return "No browser profile selected — using whichever window is focused. Run /browser-profile to pin one.";
}
const pin = pinFor(loaded.data.userDataDir, choice.profile);
const saved = await writePin(pin);
if (!saved.success) return saved.error;
client.setProfilePin(pin);
return `Browser profile: ${pin.label}`;
};
|
