335 lines
8.2 KiB
JavaScript
335 lines
8.2 KiB
JavaScript
const DEFAULT_TASKS = [
|
|
{
|
|
id: "task-generic-fit",
|
|
name: "Generic Fit",
|
|
text:
|
|
"You should evaluate for my fit to the job. You don't need to suggest interview prep, we'll leave those for later. a bit of tuning to your answers: please keep things more compact, a single section for the evaluation is enough, you don't need to analyze every bullet point in the posting."
|
|
},
|
|
{
|
|
id: "task-ratings-only",
|
|
name: "Ratings Only",
|
|
text:
|
|
"Give ratings out of 10 with headings and do not include any other text.\n\n1. Fit evaluation: my fit to the role.\n2. Company status: how well this company offers career development for me.\n3. Pay: use $25 CAD per hour as a baseline; rate the compensation."
|
|
}
|
|
];
|
|
|
|
const DEFAULT_SETTINGS = {
|
|
apiKey: "",
|
|
apiBaseUrl: "https://api.openai.com/v1",
|
|
apiKeyHeader: "Authorization",
|
|
apiKeyPrefix: "Bearer ",
|
|
model: "gpt-4o-mini",
|
|
systemPrompt:
|
|
"You are a precise, honest assistant. Be concise and avoid inventing details, be critical about evaluations. You should put in a small summary of all the sections at the end. You should answer in no longer than 3 sections including the summary. And remember to bold or italicize key points.",
|
|
resume: "",
|
|
tasks: DEFAULT_TASKS,
|
|
theme: "system"
|
|
};
|
|
|
|
const OUTPUT_STORAGE_KEY = "lastOutput";
|
|
const AUTO_RUN_KEY = "autoRunDefaultTask";
|
|
let activeAbortController = null;
|
|
let keepalivePort = null;
|
|
const streamState = {
|
|
active: false,
|
|
outputText: "",
|
|
subscribers: new Set()
|
|
};
|
|
|
|
function resetAbort() {
|
|
if (activeAbortController) {
|
|
activeAbortController.abort();
|
|
activeAbortController = null;
|
|
}
|
|
closeKeepalive();
|
|
}
|
|
|
|
function openKeepalive(tabId) {
|
|
if (!tabId || keepalivePort) return;
|
|
try {
|
|
keepalivePort = chrome.tabs.connect(tabId, { name: "wwcompanion-keepalive" });
|
|
keepalivePort.onDisconnect.addListener(() => {
|
|
keepalivePort = null;
|
|
});
|
|
} catch {
|
|
keepalivePort = null;
|
|
}
|
|
}
|
|
|
|
function closeKeepalive() {
|
|
if (!keepalivePort) return;
|
|
try {
|
|
keepalivePort.disconnect();
|
|
} catch {
|
|
// Ignore disconnect failures.
|
|
}
|
|
keepalivePort = null;
|
|
}
|
|
|
|
chrome.runtime.onInstalled.addListener(async () => {
|
|
const stored = await chrome.storage.local.get(Object.keys(DEFAULT_SETTINGS));
|
|
const updates = {};
|
|
|
|
for (const [key, value] of Object.entries(DEFAULT_SETTINGS)) {
|
|
const existing = stored[key];
|
|
const missing =
|
|
existing === undefined ||
|
|
existing === null ||
|
|
(key === "tasks" && !Array.isArray(existing));
|
|
|
|
if (missing) updates[key] = value;
|
|
}
|
|
|
|
if (Object.keys(updates).length) {
|
|
await chrome.storage.local.set(updates);
|
|
}
|
|
});
|
|
|
|
chrome.runtime.onConnect.addListener((port) => {
|
|
if (port.name !== "analysis") return;
|
|
|
|
streamState.subscribers.add(port);
|
|
port.onDisconnect.addListener(() => {
|
|
streamState.subscribers.delete(port);
|
|
});
|
|
|
|
if (streamState.active) {
|
|
safePost(port, {
|
|
type: "SYNC",
|
|
text: streamState.outputText,
|
|
streaming: true
|
|
});
|
|
}
|
|
|
|
port.onMessage.addListener((message) => {
|
|
if (message?.type === "START_ANALYSIS") {
|
|
streamState.outputText = "";
|
|
resetAbort();
|
|
const controller = new AbortController();
|
|
activeAbortController = controller;
|
|
const request = handleAnalysisRequest(port, message.payload, controller.signal);
|
|
void request
|
|
.catch((error) => {
|
|
if (error?.name === "AbortError") {
|
|
safePost(port, { type: "ABORTED" });
|
|
return;
|
|
}
|
|
safePost(port, {
|
|
type: "ERROR",
|
|
message: error?.message || "Unknown error during analysis."
|
|
});
|
|
})
|
|
.finally(() => {
|
|
if (activeAbortController === controller) {
|
|
activeAbortController = null;
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (message?.type === "ABORT_ANALYSIS") {
|
|
resetAbort();
|
|
}
|
|
});
|
|
|
|
});
|
|
|
|
chrome.runtime.onMessage.addListener((message) => {
|
|
if (message?.type !== "RUN_DEFAULT_TASK") return;
|
|
void chrome.storage.local.set({ [AUTO_RUN_KEY]: Date.now() });
|
|
if (chrome.action?.openPopup) {
|
|
void chrome.action.openPopup().catch(() => {});
|
|
}
|
|
});
|
|
|
|
function buildUserMessage(resume, task, posting) {
|
|
return [
|
|
"=== RESUME ===",
|
|
resume || "",
|
|
"",
|
|
"=== TASK ===",
|
|
task || "",
|
|
"",
|
|
"=== JOB POSTING ===",
|
|
posting || ""
|
|
].join("\n");
|
|
}
|
|
|
|
function safePost(port, message) {
|
|
try {
|
|
port.postMessage(message);
|
|
} catch {
|
|
// Port can disconnect when the popup closes; ignore post failures.
|
|
}
|
|
}
|
|
|
|
function broadcast(message) {
|
|
for (const port of streamState.subscribers) {
|
|
safePost(port, message);
|
|
}
|
|
}
|
|
|
|
async function handleAnalysisRequest(port, payload, signal) {
|
|
streamState.outputText = "";
|
|
streamState.active = true;
|
|
|
|
const {
|
|
apiKey,
|
|
apiBaseUrl,
|
|
apiKeyHeader,
|
|
apiKeyPrefix,
|
|
model,
|
|
systemPrompt,
|
|
resume,
|
|
taskText,
|
|
postingText,
|
|
tabId
|
|
} = payload || {};
|
|
|
|
if (!apiBaseUrl) {
|
|
safePost(port, { type: "ERROR", message: "Missing API base URL." });
|
|
return;
|
|
}
|
|
|
|
if (apiKeyHeader && !apiKey) {
|
|
safePost(port, { type: "ERROR", message: "Missing API key." });
|
|
return;
|
|
}
|
|
|
|
if (!model) {
|
|
safePost(port, { type: "ERROR", message: "Missing model name." });
|
|
return;
|
|
}
|
|
|
|
if (!postingText) {
|
|
safePost(port, { type: "ERROR", message: "No job posting text provided." });
|
|
return;
|
|
}
|
|
|
|
if (!taskText) {
|
|
safePost(port, { type: "ERROR", message: "No task prompt selected." });
|
|
return;
|
|
}
|
|
|
|
const userMessage = buildUserMessage(resume, taskText, postingText);
|
|
|
|
await chrome.storage.local.set({ [OUTPUT_STORAGE_KEY]: "" });
|
|
openKeepalive(tabId);
|
|
|
|
try {
|
|
await streamChatCompletion({
|
|
apiKey,
|
|
apiBaseUrl,
|
|
apiKeyHeader,
|
|
apiKeyPrefix,
|
|
model,
|
|
systemPrompt: systemPrompt || "",
|
|
userMessage,
|
|
signal,
|
|
onDelta: (text) => {
|
|
streamState.outputText += text;
|
|
broadcast({ type: "DELTA", text });
|
|
}
|
|
});
|
|
|
|
broadcast({ type: "DONE" });
|
|
} finally {
|
|
streamState.active = false;
|
|
await chrome.storage.local.set({ [OUTPUT_STORAGE_KEY]: streamState.outputText });
|
|
closeKeepalive();
|
|
}
|
|
}
|
|
|
|
function buildChatUrl(apiBaseUrl) {
|
|
const trimmed = (apiBaseUrl || "").trim().replace(/\/+$/, "");
|
|
if (!trimmed) return "";
|
|
if (trimmed.endsWith("/chat/completions")) return trimmed;
|
|
return `${trimmed}/chat/completions`;
|
|
}
|
|
|
|
function buildAuthHeader(apiKeyHeader, apiKeyPrefix, apiKey) {
|
|
if (!apiKeyHeader) return null;
|
|
return {
|
|
name: apiKeyHeader,
|
|
value: `${apiKeyPrefix || ""}${apiKey || ""}`
|
|
};
|
|
}
|
|
|
|
async function streamChatCompletion({
|
|
apiKey,
|
|
apiBaseUrl,
|
|
apiKeyHeader,
|
|
apiKeyPrefix,
|
|
model,
|
|
systemPrompt,
|
|
userMessage,
|
|
signal,
|
|
onDelta
|
|
}) {
|
|
const chatUrl = buildChatUrl(apiBaseUrl);
|
|
if (!chatUrl) {
|
|
throw new Error("Invalid API base URL.");
|
|
}
|
|
|
|
const headers = {
|
|
"Content-Type": "application/json"
|
|
};
|
|
|
|
const authHeader = buildAuthHeader(apiKeyHeader, apiKeyPrefix, apiKey);
|
|
if (authHeader) {
|
|
headers[authHeader.name] = authHeader.value;
|
|
}
|
|
|
|
const response = await fetch(chatUrl, {
|
|
method: "POST",
|
|
headers,
|
|
body: JSON.stringify({
|
|
model,
|
|
stream: true,
|
|
messages: [
|
|
{ role: "system", content: systemPrompt },
|
|
{ role: "user", content: userMessage }
|
|
]
|
|
}),
|
|
signal
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
throw new Error(`OpenAI API error ${response.status}: ${errorText}`);
|
|
}
|
|
|
|
const reader = response.body.getReader();
|
|
const decoder = new TextDecoder();
|
|
let buffer = "";
|
|
|
|
// OpenAI streams Server-Sent Events; parse incremental deltas from data lines.
|
|
while (true) {
|
|
const { value, done } = await reader.read();
|
|
if (done) break;
|
|
|
|
buffer += decoder.decode(value, { stream: true });
|
|
const lines = buffer.split("\n");
|
|
buffer = lines.pop() || "";
|
|
|
|
for (const line of lines) {
|
|
const trimmed = line.trim();
|
|
if (!trimmed.startsWith("data:")) continue;
|
|
|
|
const data = trimmed.slice(5).trim();
|
|
if (!data) continue;
|
|
if (data === "[DONE]") return;
|
|
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(data);
|
|
} catch {
|
|
continue;
|
|
}
|
|
|
|
const delta = parsed?.choices?.[0]?.delta?.content;
|
|
if (delta) onDelta(delta);
|
|
}
|
|
}
|
|
}
|