335 lines
18 KiB
TypeScript
335 lines
18 KiB
TypeScript
import type { AgentBrowserService } from '../api/context';
|
|
import type { CodingConversationService } from './conversation-service';
|
|
import type { CodingConversationRuntime } from './contracts';
|
|
import { OPEN_WORK_PROMPT, type WorkPreviewResult } from '../../shared/coding-work-preview';
|
|
import { codingRecovery } from '../../shared/coding-recovery';
|
|
import type { AgentBrowserSnapshot } from '../../shared/agent-browser';
|
|
import { inspectWorkPresence, type WorkPresence } from './work-presence';
|
|
import { loadWorkEntry, saveWorkEntry } from './work-entry-store';
|
|
import { discoverWorkLaunch, startWorkLaunch, stopWorkLaunch, workLaunchMatches } from './work-launcher';
|
|
import type { WorkEntry, WorkLaunchSpec } from './work-entry-contracts';
|
|
import { createHash } from 'node:crypto';
|
|
|
|
type Project = { id: string; path: string };
|
|
type Attempt = {
|
|
requestId: string;
|
|
conversationId?: string;
|
|
submitted?: boolean;
|
|
runId?: string;
|
|
submittedAt?: number;
|
|
result?: WorkPreviewResult;
|
|
};
|
|
|
|
function sameWorkServer(left: string, right: string): boolean {
|
|
try {
|
|
const a = new URL(left);
|
|
const b = new URL(right);
|
|
const local = (url: URL) => ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
|
|
return local(a) && local(b) && a.protocol === b.protocol && a.port === b.port;
|
|
} catch { return false; }
|
|
}
|
|
|
|
/** Only probe a known loopback work address; never scan ports or follow redirects. */
|
|
export async function workPageResponds(address: string): Promise<boolean> {
|
|
try {
|
|
const url = new URL(address);
|
|
if (!['http:', 'https:'].includes(url.protocol)
|
|
|| !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)
|
|
|| url.username || url.password) return false;
|
|
const response = await fetch(url, { redirect: 'manual', signal: AbortSignal.timeout(2_000) });
|
|
await response.body?.cancel();
|
|
return response.ok;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/** Identity for pages whose launch method is unknown; only bounded local HTML. */
|
|
export async function workPageSignature(address: string): Promise<string | null> {
|
|
try {
|
|
const url = new URL(address);
|
|
if (!['http:', 'https:'].includes(url.protocol) || !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)
|
|
|| url.username || url.password) return null;
|
|
const response = await fetch(url, { redirect: 'manual', signal: AbortSignal.timeout(2_000) });
|
|
if (!response.ok || !response.headers.get('content-type')?.includes('text/html') || !response.body) {
|
|
await response.body?.cancel();
|
|
return null;
|
|
}
|
|
const reader = response.body.getReader();
|
|
const hash = createHash('sha256');
|
|
let bytes = 0;
|
|
try {
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) return hash.digest('hex');
|
|
bytes += value.byteLength;
|
|
if (bytes > 256 * 1024) return null;
|
|
hash.update(value);
|
|
}
|
|
} finally { await reader.cancel().catch(() => undefined); }
|
|
} catch { return null; }
|
|
}
|
|
|
|
export class CodingWorkPreviewService {
|
|
private readonly attempts = new Map<string, Attempt>();
|
|
private readonly flights = new Map<string, Promise<WorkPreviewResult>>();
|
|
private readonly flightHelp = new Map<string, boolean>();
|
|
// Native views are disposable during background sleep; the running project
|
|
// server and its verified address have a separate lifetime.
|
|
private readonly pages = new Map<string, { path: string; url: string }>();
|
|
private readonly pageRevisions = new Map<string, number>();
|
|
private readonly rememberedWrites = new Map<string, Promise<void>>();
|
|
private readonly loaded = new Map<string, WorkEntry | null>();
|
|
|
|
constructor(private readonly deps: {
|
|
browser: Pick<AgentBrowserService, 'getSnapshot' | 'open'>;
|
|
conversations: Pick<CodingConversationService, 'getConversation' | 'listConversations' | 'createConversation' | 'getSnapshot' | 'acceptPrompt'>;
|
|
runtime: Pick<CodingConversationRuntime, 'getDiagnostics'>;
|
|
ensureActive(project: Project): Promise<void>;
|
|
responds?(url: string): Promise<boolean>;
|
|
inspectWork?(projectPath: string): Promise<WorkPresence>;
|
|
entries?: { load: typeof loadWorkEntry; save: typeof saveWorkEntry };
|
|
launcher?: { discover: typeof discoverWorkLaunch; start: typeof startWorkLaunch; matches?: typeof workLaunchMatches; stop?: typeof stopWorkLaunch };
|
|
storedSnapshot?: CodingConversationService['getStoredSnapshot'];
|
|
signature?(url: string): Promise<string | null>;
|
|
}) {}
|
|
|
|
remember(project: Project, snapshot: AgentBrowserSnapshot, launch?: WorkLaunchSpec): Promise<void> {
|
|
if (snapshot.projectId !== project.id || !snapshot.url || !snapshot.browserId
|
|
|| snapshot.state !== 'attached' || snapshot.error) return Promise.resolve();
|
|
this.pages.delete(project.id);
|
|
if (this.pages.size >= 100) this.pages.delete(this.pages.keys().next().value!);
|
|
this.pages.set(project.id, { path: project.path, url: snapshot.url });
|
|
this.pageRevisions.set(project.id, (this.pageRevisions.get(project.id) ?? 0) + 1);
|
|
this.attempts.delete(project.id);
|
|
// A successful manual/Agent open supersedes a slow older startup check.
|
|
this.flights.delete(project.id);
|
|
const previous = this.rememberedWrites.get(project.id);
|
|
const write = (async () => {
|
|
await previous?.catch(() => undefined);
|
|
const recipe = launch ?? await (this.deps.launcher?.discover ?? discoverWorkLaunch)(project.path).catch(() => null);
|
|
const documentHash = await (this.deps.signature ?? workPageSignature)(snapshot.url);
|
|
const entry: WorkEntry = { version: 1, projectId: project.id, projectPath: project.path, url: snapshot.url,
|
|
...(documentHash ? { documentHash } : {}),
|
|
...(recipe ? { launch: recipe } : {}) };
|
|
this.loaded.set(project.id, entry);
|
|
await (this.deps.entries?.save ?? saveWorkEntry)(project, entry);
|
|
})();
|
|
this.rememberedWrites.set(project.id, write);
|
|
// Manual opens remain usable if project metadata temporarily cannot be saved.
|
|
void write.catch(() => undefined);
|
|
return write;
|
|
}
|
|
|
|
async ensure(project: Project, requestId: string, conversationId?: string, allowAssistant = false): Promise<WorkPreviewResult> {
|
|
await this.deps.ensureActive(project);
|
|
// Serialize browser checks as well as prompt submission for each project.
|
|
const existing = this.flights.get(project.id);
|
|
if (existing) {
|
|
if (allowAssistant && !this.flightHelp.get(project.id)) {
|
|
await existing;
|
|
return this.ensure(project, requestId, conversationId, true);
|
|
}
|
|
return existing;
|
|
}
|
|
const flight = this.check(project, requestId, conversationId, allowAssistant).catch((error: unknown) => {
|
|
const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
|
|
? error.code : 'WORK_PREVIEW_START_FAILED';
|
|
if (['PROJECT_NOT_ACTIVE', 'PROJECT_MISMATCH'].includes(code)) throw error;
|
|
const result = { status: 'failed' as const, errorCode: code, message: codingRecovery(code, true).message };
|
|
const attempt = this.attempts.get(project.id);
|
|
if (attempt?.requestId === requestId) attempt.result = result;
|
|
return result;
|
|
});
|
|
this.flights.set(project.id, flight);
|
|
this.flightHelp.set(project.id, allowAssistant);
|
|
try { return await flight; }
|
|
finally { if (this.flights.get(project.id) === flight) { this.flights.delete(project.id); this.flightHelp.delete(project.id); } }
|
|
}
|
|
|
|
private async check(project: Project, requestId: string, conversationId?: string, allowAssistant = false): Promise<WorkPreviewResult> {
|
|
const { browser, conversations } = this.deps;
|
|
const pageRevision = this.pageRevisions.get(project.id) ?? 0;
|
|
const superseded = () => (this.pageRevisions.get(project.id) ?? 0) !== pageRevision;
|
|
await this.rememberedWrites.get(project.id)?.catch(() => undefined);
|
|
if (!this.loaded.has(project.id) || this.loaded.get(project.id)?.projectPath !== project.path) {
|
|
const loaded = await (this.deps.entries?.load ?? loadWorkEntry)(project);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
this.loaded.set(project.id, loaded);
|
|
}
|
|
const saved = this.loaded.get(project.id);
|
|
const snapshot = await browser.getSnapshot(project.path);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
const responds = this.deps.responds ?? workPageResponds;
|
|
const remembered = this.pages.get(project.id);
|
|
const address = snapshot.projectId === project.id && snapshot.url
|
|
? snapshot.url
|
|
: remembered?.path === project.path ? remembered.url : saved?.url;
|
|
const matches = this.deps.launcher?.matches ?? workLaunchMatches;
|
|
const addressMatches = async () => saved?.launch ? await matches(project, saved.launch, address!)
|
|
: saved?.documentHash ? await (this.deps.signature ?? workPageSignature)(address!) === saved.documentHash
|
|
: Boolean(remembered?.path === project.path || (snapshot.projectId === project.id && snapshot.url));
|
|
if (address && await responds(address) && await addressMatches()) {
|
|
await this.deps.ensureActive(project);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
const ready = snapshot.projectId === project.id && snapshot.url === address
|
|
&& snapshot.browserId && snapshot.state === 'attached' && !snapshot.error
|
|
? snapshot
|
|
: await browser.open({ projectId: project.id, projectPath: project.path, url: address, visible: false });
|
|
await this.deps.ensureActive(project);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
await this.remember(project, ready, saved?.launch).catch(() => undefined);
|
|
return { status: 'ready', browser: ready };
|
|
}
|
|
if (this.pages.has(project.id) && this.pages.get(project.id) !== remembered) return this.check(project, requestId, conversationId, allowAssistant);
|
|
this.pages.delete(project.id);
|
|
await this.deps.ensureActive(project);
|
|
let attempt = this.attempts.get(project.id);
|
|
if (attempt?.submitted && attempt.conversationId) {
|
|
const current = await conversations.getSnapshot(attempt.conversationId);
|
|
if (this.pages.has(project.id)) return this.check(project, requestId, conversationId, allowAssistant);
|
|
if (!['idle', 'error'].includes(current.run.status)) {
|
|
return { status: 'starting', conversation: await conversations.getConversation(attempt.conversationId) };
|
|
}
|
|
if (attempt.runId && current.run.runId !== attempt.runId && Date.now() - attempt.submittedAt! < 15_000) {
|
|
return { status: 'starting', conversation: await conversations.getConversation(attempt.conversationId) };
|
|
}
|
|
// The accepted action settled without opening a reachable work page.
|
|
const errorCode = current.run.error?.code;
|
|
attempt.result ??= { status: 'failed', errorCode, message: codingRecovery(errorCode, true).message };
|
|
}
|
|
if (attempt?.result && attempt.requestId === requestId) return attempt.result;
|
|
if (!attempt || attempt.result || attempt.requestId !== requestId) {
|
|
attempt = { requestId, conversationId };
|
|
// Keep only a bounded number of inactive project attempts.
|
|
if (this.attempts.size >= 100) this.attempts.delete(this.attempts.keys().next().value!);
|
|
this.attempts.set(project.id, attempt);
|
|
}
|
|
|
|
const list = await conversations.listConversations(project.id);
|
|
const projectIds = new Set(list.map(({ id }) => id));
|
|
const busy = () => this.deps.runtime.getDiagnostics().workers.some((worker) => (
|
|
projectIds.has(worker.conversationId) && ['starting', 'queued', 'running'].includes(worker.stage)
|
|
));
|
|
if (busy()) return { status: 'waiting' };
|
|
const presence = await (this.deps.inspectWork ?? inspectWorkPresence)(project.path);
|
|
await this.deps.ensureActive(project);
|
|
if (this.pages.has(project.id)) return this.check(project, requestId, conversationId, allowAssistant);
|
|
if (busy()) return { status: 'waiting' };
|
|
if (presence === 'empty') {
|
|
// No cached terminal attempt: the same tab/request can discover newly made work.
|
|
this.attempts.delete(project.id);
|
|
return { status: 'empty' };
|
|
}
|
|
// Upgrade existing projects from successful browser tool receipts, never
|
|
// assistant prose or an arbitrary link, and never start Pi to read them.
|
|
let discoveryError: unknown;
|
|
const launch = saved?.launch ?? await (this.deps.launcher?.discover ?? discoverWorkLaunch)(project.path).catch((error: unknown) => {
|
|
discoveryError = error;
|
|
return null;
|
|
});
|
|
if (!saved && this.deps.storedSnapshot) {
|
|
for (const item of list.slice(0, 20)) {
|
|
const history = await this.deps.storedSnapshot(item.id).catch(() => null);
|
|
await this.deps.ensureActive(project);
|
|
if (!history || history.conversation.projectId !== project.id) continue;
|
|
for (const node of [...history.nodes].reverse()) {
|
|
if (node.kind !== 'tool' || node.status !== 'complete' || node.toolName !== 'agent_browser'
|
|
|| node.details?.schema !== 'agent-browser.v1' || node.details.action !== 'open') continue;
|
|
const text = node.output.filter((block) => block.kind === 'text').map((block) => block.text).join('');
|
|
if (text.length > 16_384) continue;
|
|
let known: AgentBrowserSnapshot;
|
|
try { known = JSON.parse(text); } catch { continue; }
|
|
if (!known || typeof known !== 'object') continue;
|
|
if (known.projectId !== project.id || known.state !== 'attached' || !known.browserId || !known.url
|
|
|| !launch || !(await responds(known.url)) || !(await matches(project, launch, known.url))) continue;
|
|
await this.deps.ensureActive(project);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
const restored = await browser.open({ projectId: project.id, projectPath: project.path, url: known.url, visible: false });
|
|
await this.deps.ensureActive(project);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
await this.remember(project, restored, launch ?? undefined).catch(() => undefined);
|
|
return { status: 'ready', browser: restored };
|
|
}
|
|
}
|
|
}
|
|
if (discoveryError && !allowAssistant) throw discoveryError;
|
|
await this.deps.ensureActive(project);
|
|
if (this.pages.has(project.id)) return this.check(project, requestId, conversationId, allowAssistant);
|
|
if (busy()) return { status: 'waiting' };
|
|
if (launch) {
|
|
try {
|
|
const url = await (this.deps.launcher?.start ?? startWorkLaunch)(project, launch, address);
|
|
const stopUnused = async () => {
|
|
const newer = this.pages.get(project.id);
|
|
if (!newer || !sameWorkServer(newer.url, url)) await (this.deps.launcher?.stop ?? stopWorkLaunch)(project, url);
|
|
};
|
|
if (superseded()) {
|
|
await stopUnused();
|
|
return this.check(project, requestId, conversationId, allowAssistant);
|
|
}
|
|
// Keep the verified server associated with its own project even if the
|
|
// student switches projects while it starts. Only UI attachment is gated.
|
|
const startedEntry: WorkEntry = { version: 1, projectId: project.id, projectPath: project.path, url, launch };
|
|
this.loaded.set(project.id, startedEntry);
|
|
const previousWrite = this.rememberedWrites.get(project.id);
|
|
const startedWrite = (async () => {
|
|
await previousWrite?.catch(() => undefined);
|
|
await (this.deps.entries?.save ?? saveWorkEntry)(project, startedEntry);
|
|
})();
|
|
this.rememberedWrites.set(project.id, startedWrite);
|
|
await startedWrite.catch(() => undefined);
|
|
if (superseded()) {
|
|
await stopUnused();
|
|
return this.check(project, requestId, conversationId, allowAssistant);
|
|
}
|
|
await this.deps.ensureActive(project);
|
|
if (superseded()) {
|
|
await stopUnused();
|
|
return this.check(project, requestId, conversationId, allowAssistant);
|
|
}
|
|
const opened = await browser.open({ projectId: project.id, projectPath: project.path, url, visible: false });
|
|
await this.deps.ensureActive(project);
|
|
if (superseded()) return this.check(project, requestId, conversationId, allowAssistant);
|
|
await this.remember(project, opened, launch).catch(() => undefined);
|
|
return { status: 'ready', browser: opened };
|
|
} catch (error) {
|
|
if (!allowAssistant || (error && typeof error === 'object' && 'code' in error
|
|
&& ['PROJECT_NOT_ACTIVE', 'PROJECT_MISMATCH'].includes(String(error.code)))) throw error;
|
|
// The user chose assistance for a known launch failure. The assistant
|
|
// may inspect it; merely reopening the tab never takes this path.
|
|
}
|
|
}
|
|
if (!allowAssistant) return { status: 'failed', errorCode: 'WORK_PREVIEW_NEEDS_HELP',
|
|
message: codingRecovery('WORK_PREVIEW_NEEDS_HELP', true).message };
|
|
let conversation = attempt.conversationId
|
|
? await conversations.getConversation(attempt.conversationId)
|
|
: list.find((item) => !item.archivedAt);
|
|
await this.deps.ensureActive(project);
|
|
conversation ??= await conversations.createConversation({ projectId: project.id, title: '新对话' });
|
|
attempt.conversationId = conversation.id;
|
|
const current = await conversations.getSnapshot(conversation.id);
|
|
if (this.pages.has(project.id)) return this.check(project, requestId, conversationId, allowAssistant);
|
|
if (!['idle', 'error'].includes(current.run.status)) return { status: 'waiting', conversation };
|
|
await this.deps.ensureActive(project);
|
|
// Mark before dispatch: uncertain acceptance must never cause automatic resubmission.
|
|
attempt.submitted = true;
|
|
attempt.submittedAt = Date.now();
|
|
try {
|
|
const acceptance = await conversations.acceptPrompt({
|
|
conversationId: conversation.id,
|
|
clientRequestId: `work-preview-${attempt.requestId}`,
|
|
mode: 'prompt',
|
|
text: OPEN_WORK_PROMPT,
|
|
});
|
|
attempt.runId = acceptance.runId;
|
|
} catch (error) {
|
|
const errorCode = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
|
|
? error.code : 'CODING_REQUEST_UNCERTAIN';
|
|
attempt.result = { status: 'failed', conversation, errorCode, message: codingRecovery(errorCode, true).message };
|
|
return attempt.result;
|
|
}
|
|
return { status: 'starting', conversation };
|
|
}
|
|
}
|