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
|
import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
import type { BrowserClient } from "../client";
import { discoverEndpoint } from "../cdp/discovery";
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);
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;
}
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}`;
};
|
