@undefineds.co/linx 0.3.4 → 0.3.7

package/vendor/pi-web-access/summary-review.ts

@@ -0,0 +1,276 @@
+import { complete, getModel, type Message, type Model } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { QueryResultData } from "./storage.js";
+
+const PREFERRED_SUMMARY_MODELS = [
+	{ provider: "anthropic", id: "claude-haiku-4-5" },
+	{ provider: "openai-codex", id: "gpt-5.3-codex-spark" },
+] as const;
+
+export interface SummaryMeta {
+	model: string | null;
+	durationMs: number;
+	tokenEstimate: number;
+	fallbackUsed: boolean;
+	fallbackReason?: string;
+	edited?: boolean;
+}
+
+export type SummaryGenerationContext = Pick<ExtensionContext, "model" | "modelRegistry">;
+
+function estimateTokens(text: string): number {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return 0;
+	return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+
+function summarizeQueryResult(result: QueryResultData): string {
+	if (result.error) {
+		return `Query: ${result.query}\nStatus: Error\nError: ${result.error}`;
+	}
+
+	const lines = [
+		`Query: ${result.query}`,
+		`Provider: ${result.provider ?? "unknown"}`,
+		`Answer: ${result.answer || "(no answer text returned)"}`,
+	];
+
+	if (result.results.length === 0) {
+		lines.push("Sources: none");
+		return lines.join("\n");
+	}
+
+	lines.push("Sources:");
+	for (let i = 0; i < result.results.length; i++) {
+		const source = result.results[i];
+		lines.push(`${i + 1}. ${source.title} — ${source.url}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function buildSummaryPrompt(results: QueryResultData[], feedback?: string): string {
+	const sections = [
+		"You are writing the final web search summary for a coding assistant.",
+		"Write a concise, factual summary using only the provided search results.",
+		"Requirements:",
+		"- Keep it readable and skimmable.",
+		"- Include key findings and caveats.",
+		"- Do not invent sources or claims.",
+		"- If evidence is weak or conflicting, say so explicitly.",
+		"- End with a short \"Sources\" section listing the most relevant URLs.",
+	];
+
+	if (feedback) {
+		sections.push("- Incorporate the user feedback provided below into the summary.");
+	}
+
+	sections.push("");
+	sections.push("<search_results>");
+
+	for (let i = 0; i < results.length; i++) {
+		sections.push(`\n[Result ${i + 1}]`);
+		sections.push(summarizeQueryResult(results[i]));
+	}
+
+	sections.push("\n</search_results>");
+
+	if (feedback) {
+		sections.push("");
+		sections.push("<user_feedback>");
+		sections.push(feedback);
+		sections.push("</user_feedback>");
+	}
+
+	return sections.join("\n");
+}
+
+function buildDeterministicAnswerPreview(answer: string): string {
+	let text = answer.replace(/\s+/g, " ").trim();
+	if (text.length === 0) return "";
+
+	const sourceMarker = text.search(/\bSources?\s*:/i);
+	if (sourceMarker >= 0) text = text.slice(0, sourceMarker).trim();
+	if (text.length === 0) return "";
+
+	return text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+
+function buildDeterministicSummaryLines(results: QueryResultData[]): string[] {
+	if (results.length === 0) {
+		return [
+			"No completed search results were available when the curator session finished.",
+			"",
+			"Sources",
+			"- None",
+		];
+	}
+
+	const lines: string[] = [
+		"Summary based on the currently selected search results.",
+		"",
+	];
+
+	const sourceUrls: string[] = [];
+	let successful = 0;
+	let failed = 0;
+
+	for (const result of results) {
+		if (result.error) {
+			failed += 1;
+			lines.push(`- ${result.query}: failed (${result.error})`);
+			continue;
+		}
+
+		successful += 1;
+		const preview = buildDeterministicAnswerPreview(result.answer);
+		if (preview.length > 0) {
+			lines.push(`- ${result.query}: ${preview}`);
+		} else {
+			lines.push(`- ${result.query}: returned ${result.results.length} source${result.results.length === 1 ? "" : "s"} without answer text.`);
+		}
+
+		for (const source of result.results) {
+			if (!sourceUrls.includes(source.url)) {
+				sourceUrls.push(source.url);
+			}
+		}
+	}
+
+	lines.push("");
+	lines.push(`Completed queries: ${results.length}`);
+	lines.push(`Successful: ${successful}`);
+	lines.push(`Failed: ${failed}`);
+	lines.push("");
+	lines.push("Sources");
+
+	if (sourceUrls.length === 0) {
+		lines.push("- None");
+	} else {
+		for (const url of sourceUrls.slice(0, 12)) {
+			lines.push(`- ${url}`);
+		}
+		if (sourceUrls.length > 12) {
+			lines.push(`- ... and ${sourceUrls.length - 12} more`);
+		}
+	}
+
+	return lines;
+}
+
+export function buildDeterministicSummary(results: QueryResultData[]): { summary: string; meta: SummaryMeta } {
+	const summary = buildDeterministicSummaryLines(results).join("\n").trim();
+	const nonEmptySummary = summary.length > 0
+		? summary
+		: "No completed search results were available when the curator session finished.\n\nSources\n- None";
+
+	return {
+		summary: nonEmptySummary,
+		meta: {
+			model: null,
+			durationMs: 0,
+			tokenEstimate: estimateTokens(nonEmptySummary),
+			fallbackUsed: true,
+			fallbackReason: "deterministic-submit-fallback",
+			edited: false,
+		},
+	};
+}
+
+async function resolveSummaryModel(
+	ctx: SummaryGenerationContext,
+	modelOverride?: string,
+): Promise<{ model: Model; apiKey: string; headers?: Record<string, string> }> {
+	const normalizedOverride = typeof modelOverride === "string" ? modelOverride.trim() : "";
+	if (normalizedOverride.length > 0) {
+		const slashIndex = normalizedOverride.indexOf("/");
+		if (slashIndex <= 0 || slashIndex >= normalizedOverride.length - 1) {
+			throw new Error(`Invalid summary model: ${normalizedOverride}. Use provider/model-id.`);
+		}
+		const provider = normalizedOverride.slice(0, slashIndex);
+		const modelId = normalizedOverride.slice(slashIndex + 1);
+		const selectedModel = ctx.modelRegistry.find(provider, modelId);
+		if (!selectedModel) {
+			throw new Error(`Summary model not found: ${normalizedOverride}`);
+		}
+		const selectedAuth = await ctx.modelRegistry.getApiKeyAndHeaders(selectedModel);
+		if (!selectedAuth.ok || !selectedAuth.apiKey) {
+			throw new Error(`No API key available for summary model ${normalizedOverride}`);
+		}
+		return { model: selectedModel, apiKey: selectedAuth.apiKey, headers: selectedAuth.headers };
+	}
+
+	for (const { provider, id } of PREFERRED_SUMMARY_MODELS) {
+		const model = getModel(provider, id);
+		if (!model) continue;
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (auth.ok && auth.apiKey) return { model, apiKey: auth.apiKey, headers: auth.headers };
+	}
+
+	throw new Error(`No API key available for summary models: ${PREFERRED_SUMMARY_MODELS.map(c => `${c.provider}/${c.id}`).join(", ")}`);
+}
+
+function getTextFromContentPart(part: unknown): string {
+	if (!part || typeof part !== "object") return "";
+	const value = part as Record<string, unknown>;
+	if (typeof value.text === "string") return value.text;
+	if (typeof value.refusal === "string") return value.refusal;
+	return "";
+}
+
+function getContentPartType(part: unknown): string {
+	if (!part || typeof part !== "object") return "unknown";
+	const value = part as Record<string, unknown>;
+	return typeof value.type === "string" ? value.type : "unknown";
+}
+
+export async function generateSummaryDraft(
+	results: QueryResultData[],
+	ctx: SummaryGenerationContext,
+	signal?: AbortSignal,
+	modelOverride?: string,
+	feedback?: string,
+): Promise<{ summary: string; meta: SummaryMeta }> {
+	if (!ctx || !ctx.modelRegistry) {
+		throw new Error("Summary generation context unavailable");
+	}
+
+	const startedAt = Date.now();
+	const { model, apiKey, headers } = await resolveSummaryModel(ctx, modelOverride);
+	const prompt = buildSummaryPrompt(results, feedback);
+
+	const userMessage: Message = {
+		role: "user",
+		content: [{ type: "text", text: prompt }],
+		timestamp: Date.now(),
+	};
+
+	const response = await complete(model, { messages: [userMessage] }, { apiKey, headers, signal });
+	if (response.stopReason === "aborted") {
+		throw new Error("Aborted");
+	}
+
+	const contentParts = Array.isArray(response.content) ? response.content : [];
+	const summary = contentParts
+		.map(part => getTextFromContentPart(part))
+		.filter(text => text.trim().length > 0)
+		.join("\n")
+		.trim();
+
+	if (summary.length === 0) {
+		const partTypes = contentParts.map(part => getContentPartType(part));
+		const typesLabel = partTypes.length > 0 ? partTypes.join(", ") : "none";
+		throw new Error(`Summary model returned empty response (content parts: ${typesLabel})`);
+	}
+
+	return {
+		summary,
+		meta: {
+			model: `${model.provider}/${model.id}`,
+			durationMs: Math.max(0, Date.now() - startedAt),
+			tokenEstimate: estimateTokens(summary),
+			fallbackUsed: false,
+			edited: false,
+		},
+	};
+}

package/vendor/pi-web-access/test/gemini-web-cookie-opt-in.test.mjs

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+const moduleUrl = new URL("../gemini-web-config.ts", import.meta.url).href;
+
+function runCookieAccessCheck(home, extraEnv = {}) {
+	const env = { ...process.env, HOME: home, USERPROFILE: home, ...extraEnv };
+	delete env.PI_ALLOW_BROWSER_COOKIES;
+	delete env.FEYNMAN_ALLOW_BROWSER_COOKIES;
+	Object.assign(env, extraEnv);
+
+	return spawnSync(process.execPath, ["--input-type=module"], {
+		input: `const { isBrowserCookieAccessAllowed } = await import(${JSON.stringify(moduleUrl)}); console.log(String(isBrowserCookieAccessAllowed()));`,
+		encoding: "utf8",
+		env,
+	});
+}
+
+test("browser cookie access is disabled unless explicitly allowed", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-cookie-opt-in-"));
+
+	let child = runCookieAccessCheck(home);
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "false");
+
+	await mkdir(join(home, ".linx"), { recursive: true });
+	await writeFile(join(home, ".linx", "pi-web-access.json"), JSON.stringify({ allowBrowserCookies: true }) + "\n", "utf8");
+
+	child = runCookieAccessCheck(home);
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "true");
+
+	const envHome = await mkdtemp(join(tmpdir(), "pi-web-access-cookie-env-"));
+	child = runCookieAccessCheck(envHome, { PI_ALLOW_BROWSER_COOKIES: "1" });
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "true");
+});

package/vendor/pi-web-access/test/pdf-extract.test.mjs

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { test } from "node:test";
+
+const extractorUrl = new URL("../pdf-extract.ts", import.meta.url).href;
+
+test("extractPDFToMarkdown works on Node 22 without native Promise.try", () => {
+  const child = spawnSync(process.execPath, ["--input-type=module"], {
+    input: buildChildScript(extractorUrl),
+    encoding: "utf8",
+    maxBuffer: 2 * 1024 * 1024,
+  });
+
+  assert.equal(
+    child.status,
+    0,
+    "PDF extraction failed in a child process. stderr summary:\n" + errorSummary(child.stderr),
+  );
+
+  assert.match(child.stdout, /Hello PDF/);
+});
+
+function buildChildScript(moduleUrl) {
+  return `
+    import { mkdtemp, readFile } from "node:fs/promises";
+    import { tmpdir } from "node:os";
+    import { join } from "node:path";
+
+    process.on("uncaughtException", (error) => {
+      console.error(error?.stack || error);
+      process.exit(1);
+    });
+    process.on("unhandledRejection", (error) => {
+      console.error(error?.stack || error);
+      process.exit(1);
+    });
+
+    Reflect.deleteProperty(Promise, "try");
+    if (typeof Promise.try !== "undefined") {
+      throw new Error("Expected Promise.try to be unavailable before PDF extraction");
+    }
+
+    const { extractPDFToMarkdown } = await import(${JSON.stringify(moduleUrl)});
+
+    const outputDir = await mkdtemp(join(tmpdir(), "pi-web-access-pdf-"));
+    const result = await extractPDFToMarkdown(
+      makePdf("Hello PDF"),
+      "https://example.test/hello.pdf",
+      { outputDir },
+    );
+
+    console.log(await readFile(result.outputPath, "utf8"));
+
+    function makePdf(text) {
+      const content = "BT /F1 24 Tf 72 720 Td (" + text + ") Tj ET";
+      const objects = [
+        "<< /Type /Catalog /Pages 2 0 R >>",
+        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>",
+        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+        "<< /Length " + Buffer.byteLength(content, "ascii") + " >>\\nstream\\n" + content + "\\nendstream",
+      ];
+      let body = "%PDF-1.4\\n";
+      const offsets = [0];
+
+      for (let index = 0; index < objects.length; index += 1) {
+        offsets.push(Buffer.byteLength(body, "ascii"));
+        body += String(index + 1) + " 0 obj\\n" + objects[index] + "\\nendobj\\n";
+      }
+
+      const xrefOffset = Buffer.byteLength(body, "ascii");
+      body += "xref\\n0 " + String(objects.length + 1) + "\\n";
+      body += "0000000000 65535 f \\n";
+
+      for (const offset of offsets.slice(1)) {
+        body += String(offset).padStart(10, "0") + " 00000 n \\n";
+      }
+
+      body += "trailer\\n<< /Size " + String(objects.length + 1) + " /Root 1 0 R >>\\n";
+      body += "startxref\\n" + String(xrefOffset) + "\\n%%EOF\\n";
+
+      return new TextEncoder().encode(body).buffer;
+    }
+  `;
+}
+
+function errorSummary(value, size = 1200) {
+  const marker = "TypeError: Promise.try is not a function";
+  const index = value.indexOf(marker);
+  if (index >= 0) {
+    return value.slice(index, index + size);
+  }
+
+  return value.length > size ? value.slice(-size) : value;
+}

package/vendor/pi-web-access/utils.ts

@@ -0,0 +1,44 @@
+export function formatSeconds(s: number): string {
+	const h = Math.floor(s / 3600);
+	const m = Math.floor((s % 3600) / 60);
+	const sec = s % 60;
+	if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
+	return `${m}:${String(sec).padStart(2, "0")}`;
+}
+
+export function readExecError(err: unknown): { code?: string; stderr: string; message: string } {
+	if (!err || typeof err !== "object") {
+		return { stderr: "", message: String(err) };
+	}
+	const code = (err as { code?: string }).code;
+	const message = (err as { message?: string }).message ?? "";
+	const stderrRaw = (err as { stderr?: Buffer | string }).stderr;
+	const stderr = Buffer.isBuffer(stderrRaw)
+		? stderrRaw.toString("utf-8")
+		: typeof stderrRaw === "string"
+			? stderrRaw
+			: "";
+	return { code, stderr, message };
+}
+
+export function isTimeoutError(err: unknown): boolean {
+	if (!err || typeof err !== "object") return false;
+	if ((err as { killed?: boolean }).killed) return true;
+	const name = (err as { name?: string }).name;
+	const code = (err as { code?: string }).code;
+	const message = (err as { message?: string }).message ?? "";
+	return name === "AbortError" || code === "ETIMEDOUT" || message.toLowerCase().includes("timed out");
+}
+
+export function trimErrorText(text: string): string {
+	return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+
+export function mapFfmpegError(err: unknown): string {
+	const { code, stderr, message } = readExecError(err);
+	if (code === "ENOENT") return "ffmpeg is not installed. Install with: brew install ffmpeg";
+	if (isTimeoutError(err)) return "ffmpeg timed out extracting frame";
+	if (stderr.includes("403")) return "Stream URL returned 403 — may have expired, try again";
+	const snippet = trimErrorText(stderr || message);
+	return snippet ? `ffmpeg failed: ${snippet}` : "ffmpeg failed";
+}