Spaces:
Running
Running
sync: upstream 8dfff832 (v6.18.5) + custom addons (KeyRotator, 401/403 rotation, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
2e7b8ca Download src/free_claude_code/api/admin_static/code_sessions.js from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 57.5 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/api/admin_static/code_sessions.js
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/api/admin_static/code_sessions.js
-
curl -L -o code_sessions.js https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/api/admin_static/code_sessions.js
57.5 kB
(() => {
"use strict";
const UI = window.SessionUI;
const modelComboboxes = new Set();
let providerNames = new Map();
let modelControl,
reasoningControl,
providerControl,
harnessControl,
modeControl,
providerDraft = null,
harnesses = [],
catalog = [],
catalogLoaded = false,
catalogPhase = "starting",
catalogVersion = null,
catalogTarget = null,
catalogProviders = {},
catalogInstance = null,
catalogRequest = 0,
settingsPending = false;
let catalogFlight = null,
catalogAgain = false,
catalogRetryTimer = null,
catalogController = null;
let visibleIds = [],
query = "",
libraryToken = 0,
listFlight = null,
listAgain = false,
retryTimer = null;
let syncNotice = "",
availabilityNotice = "";
const base = "/admin/api/code";
const activeStatuses = new Set(["preparing", "running", "stopping"]);
const records = new Map();
const deleted = new Set();
const sends = new Set();
let api,
root,
feed,
epoch,
connected = false,
synchronized = false;
let desiredPath = null,
selected = null,
rendered = null,
syncToken = 0,
viewToken = 0;
let nextCursor = null,
libraryLoading = false,
notice = "",
available = false;
let activeDialog = null;
let viewActive = false,
activityKey = null,
activityTimer = null;
function element(tag, text, className) {
const node = document.createElement(tag);
if (text !== undefined) node.textContent = text;
if (className) node.className = className;
return window.FccFormControls.configure(node);
}
function button(text, action, className = "secondary-button") {
const node = element("button", text, className);
node.type = "button";
node.addEventListener("click", action);
return node;
}
function saved(id) {
try {
return JSON.parse(sessionStorage.getItem(`fcc.code.${id}`)) || {};
} catch {
return {};
}
}
function save(id, value) {
try {
sessionStorage.setItem(`fcc.code.${id}`, JSON.stringify(value));
} catch {
/* This tab still works when browser storage is unavailable. */
}
}
function get(id) {
if (!records.has(id))
records.set(id, {
id,
session: null,
run: null,
version: -1,
cursor: -1,
items: new Map(),
prompts: new Map(),
activeReviewIds: new Set(),
activePrompts: new Map(),
runs: new Map(),
loaded: false,
nextBefore: null,
});
return records.get(id);
}
function busy(record) {
return activeStatuses.has(record?.run?.status);
}
function pending(record) {
return [...(record?.activePrompts.values() || [])].some(
(entry) => entry.active,
);
}
function ready(record) {
return synchronized && record?.loaded && record.session?.status === "ready";
}
function compactTokens(tokens) {
let value = tokens;
let unit = 0;
const units = ["", "K", "M", "B"];
while (value >= 1000 && unit < units.length - 1) {
value /= 1000;
unit += 1;
}
let rounded = Math.round(value * 10) / 10;
if (rounded >= 1000 && unit < units.length - 1) {
rounded /= 1000;
unit += 1;
}
return `${rounded}${units[unit]}`;
}
function renderContextUsage(record) {
const node = root.querySelector("#codeContextUsage"),
used = record?.session?.context_used_tokens;
if (!node || !Number.isInteger(used) || used < 0) {
if (node) {
node.hidden = true;
node.textContent = "";
node.removeAttribute("title");
node.removeAttribute("aria-label");
}
return;
}
const maximum = catalog.find(
(model) => model.id === record.session.model,
)?.context_window_tokens,
knownMaximum = Number.isInteger(maximum) && maximum > 0,
percentage = knownMaximum ? Math.round((used / maximum) * 100) : null,
exactUsed = used.toLocaleString("en-US");
node.textContent = knownMaximum
? `${compactTokens(used)} / ${compactTokens(maximum)} (${percentage}%)`
: compactTokens(used);
const description = knownMaximum
? `Context used: ${exactUsed} of ${maximum.toLocaleString("en-US")} tokens (${percentage}%)`
: `Context used: ${exactUsed} tokens`;
node.title = description;
node.setAttribute("aria-label", description);
node.hidden = false;
}
function mergeEntries(target, entries, version) {
for (const value of entries || []) {
if ((target.get(value.id)?.version ?? -1) <= version)
target.set(value.id, { value, version });
}
}
function merge(data) {
if (data.epoch !== epoch) return;
const id = data.session_id || data.session?.id;
if (!id || deleted.has(id)) return;
const record = get(id),
version = data.version;
if (version >= record.version) {
if (!record.session || data.session.revision >= record.session.revision)
record.session = data.session;
record.run = data.run;
if (data.active_review_ids)
record.activeReviewIds = new Set(data.active_review_ids);
record.version = version;
record.cursor = Math.max(record.cursor, data.cursor || 0);
if (record.run) accepted(id, record.run.id);
}
mergeEntries(
record.runs,
[...(data.runs || []), ...(data.run ? [data.run] : [])],
version,
);
const items = data.item ? [data.item] : data.items || [],
outputChanged =
id === selected &&
items.some((item) => {
const previous = record.items.get(item.id);
return (
item.run_id === record.run?.id &&
version > (previous?.version ?? -1) &&
["kind", "title", "text", "html", "detail", "complete"].some(
(key) => previous?.value[key] !== item[key],
)
);
});
mergeEntries(record.items, items, version);
const prompts = data.prompt ? [data.prompt] : data.prompts || [];
mergeEntries(record.prompts, prompts, version);
for (const prompt of prompts) {
if ((record.activePrompts.get(prompt.id)?.version ?? -1) <= version)
record.activePrompts.set(prompt.id, {
active: ["pending", "answering"].includes(prompt.status),
version,
});
}
if (data.active_prompt_ids) {
const active = new Set(data.active_prompt_ids);
for (const promptId of new Set([
...record.activePrompts.keys(),
...active,
])) {
if ((record.activePrompts.get(promptId)?.version ?? -1) <= version)
record.activePrompts.set(promptId, {
active: active.has(promptId),
version,
});
}
}
return outputChanged;
}
function receive(type, event) {
const data = JSON.parse(event.data);
if (data.epoch !== epoch) return;
const previousRevision = records.get(data.session_id)?.session?.revision;
let outputChanged = false;
if (type === "session.deleted") {
removeDeletedSession(data.session_id, "Session deleted.");
} else {
outputChanged = merge(data) && type === "item.updated";
if (type === "session.notice" && data.session_id === selected)
notice = data.message;
}
if (
!selected &&
(type === "session.deleted" ||
data.session?.revision !== previousRevision)
)
void refreshLibrary();
render(outputChanged);
}
function clearActivity() {
clearTimeout(activityTimer);
activityTimer = null;
activityKey = null;
const node = root?.querySelector("#codeActivity");
if (node) node.hidden = true;
}
function renderActivity(outputChanged) {
const record = records.get(selected),
node = root?.querySelector("#codeActivity");
if (!viewActive || !node || !busy(record) || pending(record)) {
clearActivity();
return;
}
const key = `${selected}:${record.run.id}`;
if (activityKey === key && !outputChanged) return;
clearActivity();
activityKey = key;
activityTimer = setTimeout(() => {
activityTimer = null;
if (activityKey !== key) return;
const current = records.get(selected);
if (!viewActive || !busy(current) || pending(current)) {
clearActivity();
return;
}
const transcript = root.querySelector("#codeTranscript"),
bottom = UI.nearBottom(transcript);
node.hidden = false;
if (bottom) transcript.scrollTop = transcript.scrollHeight;
}, 500);
}
async function list(cursor = null) {
const requestEpoch = epoch,
token = syncToken,
route = viewToken,
search = query,
request = ++libraryToken;
const params = new URLSearchParams({ query: search });
if (cursor) params.set("cursor", cursor);
const data = await api(`${base}/sessions?${params}`);
if (
requestEpoch !== epoch ||
data.epoch !== epoch ||
token !== syncToken ||
route !== viewToken ||
search !== query ||
request !== libraryToken
)
return;
const ids = cursor ? [...visibleIds] : [];
for (const session of data.sessions) {
if (deleted.has(session.id)) continue;
const record = get(session.id);
if (
(!record.session || session.revision >= record.session.revision) &&
record.cursor <= data.cursor
)
record.session = session;
if (!ids.includes(session.id)) ids.push(session.id);
}
visibleIds = ids;
nextCursor = data.next_cursor;
render();
}
async function refreshLibrary() {
listAgain = true;
if (listFlight) return listFlight;
listFlight = (async () => {
while (listAgain && !selected) {
listAgain = false;
try {
await list();
} catch (error) {
restart(error.message);
break;
}
}
})();
try {
await listFlight;
} finally {
listFlight = null;
}
}
async function detail(id, before = null) {
const requestEpoch = epoch,
token = viewToken,
connection = syncToken;
const params = new URLSearchParams();
if (before) params.set("before", before);
else
// Reconcile unfinished entries even after they fall outside the newest page.
for (const { value } of get(id).items.values())
if (!value.complete) params.append("include_item_ids", value.id);
let data;
try {
data = await api(
`${base}/sessions/${id}${before ? "/items" : ""}?${params}`,
);
} catch (error) {
if (token !== viewToken || connection !== syncToken || selected !== id)
return;
if (error.status === 404) {
removeDeletedSession(id, "This session was deleted.");
render();
return;
}
throw error;
}
if (
requestEpoch !== epoch ||
data.epoch !== epoch ||
token !== viewToken ||
connection !== syncToken ||
selected !== id ||
deleted.has(id)
)
return;
const outputChanged = merge(data);
const record = get(id);
record.loaded = true;
record.nextBefore = data.next_before;
render(!before && outputChanged);
}
function olderCatalog(candidate, version = catalogTarget) {
return candidate && version && (candidate.generation_id < version.generation_id ||
(candidate.generation_id === version.generation_id && candidate.catalog_revision < version.catalog_revision));
}
async function readBootstrap() {
const token = syncToken;
const request = ++catalogRequest;
const controller = new AbortController();
catalogController = controller;
try {
const data = await api(`${base}/bootstrap`, { signal: controller.signal });
if (request !== catalogRequest || token !== syncToken || (epoch && data.epoch !== epoch) || olderCatalog(data.startup) || olderCatalog(data.startup, catalogVersion)) return false;
if (data.startup) catalogVersion = data.startup;
available = data.available;
catalogPhase = data.startup?.catalog || "ready";
catalogProviders = data.startup?.providers || {};
catalog = data.models;
harnesses = data.harnesses;
catalogLoaded = true;
availabilityNotice = data.message || "";
return true;
} catch (error) {
if (error.name !== "AbortError" && request === catalogRequest && token === syncToken) {
availabilityNotice = error.message;
if (!catalogLoaded) catalogPhase = "failed";
}
return false;
} finally {
if (catalogController === controller) catalogController = null;
}
}
async function bootstrap() {
if (!api || document.hidden) return false;
catalogAgain = true;
clearTimeout(catalogRetryTimer);
catalogRetryTimer = null;
if (catalogFlight) return catalogFlight;
catalogFlight = (async () => {
while (catalogAgain && !document.hidden) {
catalogAgain = false;
const refreshed = await readBootstrap();
render();
if (!refreshed && !catalogAgain) {
if (!document.hidden) catalogRetryTimer = setTimeout(() => void bootstrap(), 500);
return false;
}
}
return true;
})();
try {
return await catalogFlight;
} finally {
catalogFlight = null;
}
}
async function synchronize(readyData) {
const token = ++syncToken;
synchronized = false;
connected = true;
clearTimeout(retryTimer);
retryTimer = null;
if (epoch !== readyData.epoch) {
if (epoch) {
catalogVersion = null;
catalogTarget = null;
catalogLoaded = false;
catalogPhase = "starting";
}
epoch = readyData.epoch;
records.clear();
providerDraft = null;
deleted.clear();
rendered = null;
}
const included = new Set(
readyData.sessions.map((summary) => summary.session_id),
);
for (const record of records.values()) {
if (
!included.has(record.id) &&
busy(record) &&
record.cursor <= readyData.cursor
) {
// The run is no longer active; detail supplies its actual outcome.
record.run = null;
record.loaded = false;
record.cursor = readyData.cursor;
}
}
for (const summary of readyData.sessions)
merge({ ...summary, cursor: readyData.cursor });
render();
void bootstrap();
try {
const results = await Promise.allSettled([
list(),
selected ? detail(selected) : Promise.resolve(),
]);
if (token !== syncToken || !connected) return;
for (const result of results)
if (result.status === "rejected") throw result.reason;
synchronized = true;
syncNotice = "";
for (const id of records.keys()) if (saved(id).pending) void deliver(id);
} catch (error) {
if (token === syncToken) restart(error.message);
}
render();
}
function restart(message = "Reconnecting…") {
if (feed) feed.close();
feed = null;
connected = false;
synchronized = false;
++syncToken;
syncNotice = message;
if (retryTimer === null)
retryTimer = setTimeout(() => {
retryTimer = null;
connect();
}, 1000);
render();
}
function connect() {
if (feed || retryTimer !== null) return;
const source = new EventSource(`${base}/events`);
feed = source;
source.addEventListener("feed.ready", (event) => {
if (feed === source) void synchronize(JSON.parse(event.data));
});
for (const type of [
"session.updated",
"session.deleted",
"run.updated",
"item.updated",
"prompt.updated",
"session.notice",
])
source.addEventListener(type, (event) => {
if (feed === source) receive(type, event);
});
const disconnected = () => {
if (feed !== source) return;
restart();
// A stopped store cannot open its event feed. Read its availability
// so that the retry screen can explain why it is unavailable.
void bootstrap();
};
source.addEventListener("feed.resync_required", disconnected);
source.onerror = disconnected;
}
function replaceDeletedRoute(id) {
const view = root?.closest(".admin-view");
if (
!view ||
view.hidden ||
window.location.pathname !== `/admin/code/${id}`
)
return false;
history.replaceState({}, "", "/admin/code");
return true;
}
function removeDeletedSession(id, message) {
deleted.add(id);
records.delete(id);
visibleIds = visibleIds.filter((visibleId) => visibleId !== id);
const replaced = replaceDeletedRoute(id);
if (selected === id || replaced) {
activate("/admin/code");
notice = message;
}
}
function navigate(id) {
const path = id ? `/admin/code/${id}` : "/admin/code";
history.pushState({}, "", path);
activate(path);
}
function activate(path) {
viewActive = true;
if (path !== desiredPath) dismissDialog();
desiredPath = path;
if (!api) return;
let id = /^\/admin\/code\/([0-9a-f-]+)$/.exec(path)?.[1] || null;
const missing = id !== null && deleted.has(id);
if (missing) {
replaceDeletedRoute(id);
desiredPath = "/admin/code";
id = null;
}
if (id !== selected || !rendered) {
selected = id;
++viewToken;
rendered = null;
settingsPending = false;
providerDraft = null;
notice = "";
render();
if (connected && epoch) {
const reading = id ? detail(id) : refreshLibrary();
const token = viewToken;
void reading.catch((error) => {
if (token === viewToken) restart(error.message);
});
}
}
if (missing) {
notice = "This session was deleted.";
render();
}
connect();
render();
}
function accepted(id, operationId) {
const state = saved(id);
if (state.pending?.operation_id !== operationId) return;
const oldText = state.pending.text;
delete state.pending;
if (state.draft === oldText) state.draft = "";
save(id, state);
if (
selected === id &&
root?.querySelector("#codeComposer")?.value === oldText
)
root.querySelector("#codeComposer").value = "";
}
async function deliver(id) {
const command = saved(id).pending;
if (!command || sends.has(id) || !synchronized) return;
sends.add(id);
render();
try {
const receipt = await api(`${base}/sessions/${id}/turns`, {
method: "POST",
body: JSON.stringify(command),
});
accepted(id, receipt.id);
} catch (error) {
const state = saved(id);
if (state.pending?.operation_id === command.operation_id) {
if (error.status && error.status < 500) {
delete state.pending;
save(id, state);
}
if (selected === id) notice = error.message;
}
if (error.status === 400 || error.status === 409) {
await bootstrap();
}
} finally {
sends.delete(id);
render();
}
}
function submit() {
const record = records.get(selected);
if (
!ready(record) ||
busy(record) ||
pending(record) ||
!available ||
settingsPending ||
selectionError(record)
)
return;
const state = saved(selected),
text = root.querySelector("#codeComposer").value;
if (!state.pending && !text.trim()) return;
state.draft = text;
state.pending ||= {
operation_id: crypto.randomUUID(),
expected_revision: record.session.revision,
expected_epoch: epoch,
text,
};
save(selected, state);
notice = "";
void deliver(selected);
}
async function stop() {
const record = records.get(selected);
if (!busy(record)) return;
const id = selected,
run = record.run.id;
try {
await api(`${base}/sessions/${id}/stop`, {
method: "POST",
body: JSON.stringify({ operation_id: run }),
});
} catch (error) {
if (selected === id) notice = error.message;
}
render();
}
function dismissDialog() {
activeDialog?.();
}
function dialog(title, build, actionLabel, action) {
dismissDialog();
const node = element("dialog", undefined, "code-dialog"),
form = element("form");
const controller = new AbortController();
let disposed = false;
const heading = element("h3", title),
error = element("p", "", "code-notice");
error.setAttribute("role", "status");
heading.id = `code-dialog-${crypto.randomUUID()}`;
node.setAttribute("aria-labelledby", heading.id);
form.append(heading);
const actions = element("div", undefined, "code-actions");
const cancel = button("Cancel", close);
const confirm = button(actionLabel, () => {}, "primary-button");
confirm.type = "submit";
const context = {
signal: controller.signal,
isOpen: () => !disposed && node.open && node.isConnected,
isBusy: () => confirm.disabled,
setBusy(value) {
for (const control of form.querySelectorAll("input, select, button"))
if (control !== cancel) control.disabled = value;
},
message(text) {
error.textContent = text;
},
};
function close() {
if (disposed) return;
disposed = true;
controller.abort();
if (activeDialog === close) activeDialog = null;
node.close();
node.remove();
}
const value = build(form, context);
actions.append(cancel, confirm);
form.append(error, actions);
node.append(form);
node.addEventListener("close", close);
node.addEventListener("cancel", (event) => {
event.preventDefault();
close();
});
form.addEventListener("submit", async (event) => {
event.preventDefault();
if (!context.isOpen() || context.isBusy()) return;
context.setBusy(true);
try {
await action(value, context);
if (context.isOpen()) close();
} catch (failure) {
if (context.isOpen()) {
context.message(failure.message);
context.setBusy(false);
}
}
});
activeDialog = close;
root.append(node);
node.showModal();
}
function newSession() {
const id = crypto.randomUUID();
dialog(
"New code session",
(form, context) => {
const harness = element("select");
harness.append(new Option("Codex", "codex"));
const folder = element("input");
folder.required = true;
folder.autocomplete = "off";
label(form, "Harness", harness);
const field = element("div", undefined, "code-field");
const caption = element("label", "Folder");
folder.id = `code-folder-${id}`;
caption.htmlFor = folder.id;
const row = element("div", undefined, "code-folder-row");
let selectedPath = null;
const readFolder = () => selectedPath ?? folder.value;
const lineBreakNotice = element("p", "", "code-notice");
lineBreakNotice.id = `${folder.id}-notice`;
folder.setAttribute("aria-describedby", lineBreakNotice.id);
const manual = button("Enter path manually", () => {
setFolder("");
folder.focus();
});
manual.hidden = true;
function setFolder(path) {
const hasLineBreaks = /[\r\n]/.test(path);
selectedPath = hasLineBreaks ? path : null;
folder.readOnly = hasLineBreaks;
folder.value = path.replaceAll("\r", "␍").replaceAll("\n", "␊");
manual.hidden = !hasLineBreaks;
lineBreakNotice.textContent = hasLineBreaks
? "Line breaks in this folder name are shown as ␍ and ␊."
: "";
}
const browse = button("Browse…", async () => {
if (!context.isOpen() || context.isBusy()) return;
const initial = readFolder();
context.setBusy(true);
context.message("");
try {
const result = await api(`${base}/folder-picker`, {
method: "POST",
body: JSON.stringify({ initial_path: initial || null }),
signal: context.signal,
});
if (context.isOpen()) {
if (result.path !== null) setFolder(result.path);
context.message("");
}
} catch (failure) {
if (context.isOpen()) context.message(failure.message);
} finally {
if (context.isOpen()) {
context.setBusy(false);
folder.focus();
}
}
});
row.append(folder, browse);
field.append(caption, row, lineBreakNotice, manual);
form.append(field);
form.append(
element(
"p",
"Choose an existing folder on the computer running FCC. You can also enter its path manually.",
"code-notice",
),
);
return readFolder;
},
"Create session",
async (readFolder, context) => {
await api(`${base}/sessions`, {
method: "POST",
body: JSON.stringify({
session_id: id,
harness: "codex",
cwd: readFolder(),
}),
});
if (context.isOpen()) navigate(id);
},
);
}
async function updateSettings(changes) {
const id = selected,
record = records.get(id);
if (!ready(record) || settingsPending) return;
const revision = providerDraft?.revision ?? record.session.revision;
providerDraft = null;
settingsPending = true;
notice = "";
renderControls();
try {
const session = await api(`${base}/sessions/${id}`, {
method: "PATCH",
body: JSON.stringify({
expected_revision: revision,
...changes,
}),
});
if (
!deleted.has(id) &&
session.revision > (records.get(id)?.session?.revision || 0)
)
get(id).session = session;
} catch (error) {
if (selected === id) {
notice = error.message;
try {
await detail(id);
} catch (failure) {
restart(failure.message);
}
}
} finally {
if (selected === id) {
settingsPending = false;
render();
}
}
}
function selectionError(record) {
if (!record?.session) return "";
if (providerDraft) return "Choose a model for the selected provider.";
if (!catalogLoaded) return catalogPhase === "starting" ? "Models are loading…" : "Model list unavailable.";
const model = catalog.find((model) => model.id === record.session.model);
if (!model) return catalogProviders[record.session.provider_id] === "starting"
? "Models for the selected provider are loading…"
: "Selected model is unavailable. Choose another model.";
if (
record.session.reasoning_effort &&
!model.reasoning_efforts.includes(record.session.reasoning_effort)
)
return "Selected effort is unavailable. Choose another effort.";
return "";
}
function selectionLoading(record) {
if (!catalogLoaded) return catalogPhase === "starting";
return !!record?.session && !catalog.some((model) => model.id === record.session.model) &&
catalogProviders[record.session.provider_id] === "starting";
}
function remove() {
const record = records.get(selected),
id = selected,
revision = record.session.revision;
if (record.session.status === "delete_uncertain") {
void api(`${base}/sessions/${id}?expected_revision=${revision}`, {
method: "DELETE",
}).catch((error) => {
notice = error.message;
render();
});
return;
}
dialog(
"Delete session?",
(form) => {
form.append(
element(
"p",
"This deletes the conversation from FCC and Codex history. Your project files stay in place.",
),
);
},
"Delete session",
() =>
api(`${base}/sessions/${id}?expected_revision=${revision}`, {
method: "DELETE",
}),
);
}
function label(parent, title, input, description) {
const node = element("label", undefined, "code-field");
node.append(element("span", title), input);
if (description) node.append(element("small", description));
parent.append(node);
return node;
}
function shell() {
clearActivity();
dismissDialog();
root.replaceChildren();
modelComboboxes.clear();
modelControl =
reasoningControl =
providerControl =
harnessControl =
modeControl =
null;
const message = element("div", "", "session-notice");
message.id = "codeNotice";
message.setAttribute("role", "status");
if (selected) {
const id = selected,
record = get(id);
const controls = element(
"div",
undefined,
"session-controls code-session-controls",
);
providerControl = UI.selectControl(
"codeProvider",
"Provider",
[],
"",
(provider) => {
const current = records.get(selected);
modelControl.combobox.close();
providerDraft =
provider === current.session.provider_id
? null
: {
id: selected,
revision: current.session.revision,
provider,
};
renderControls();
},
);
modelControl = UI.modelControl(
"codeModel",
record.session?.model_name || "",
() =>
catalog
.filter(
(model) =>
model.provider_id ===
(providerDraft?.provider ||
records.get(selected)?.session?.provider_id),
)
.map((model) => model.model_name),
modelComboboxes,
(name) => {
const provider =
providerDraft?.provider ||
records.get(selected)?.session?.provider_id;
const model = catalog.find(
(model) =>
model.provider_id === provider && model.model_name === name,
);
if (model) void updateSettings({ model: model.id });
},
);
reasoningControl = UI.selectControl(
"codeReasoning",
"Effort",
[],
"",
(value) => {
void updateSettings({ reasoning_effort: value });
},
);
harnessControl = UI.selectControl(
"codeHarness",
"Harness",
[],
"",
() => {},
);
modeControl = UI.selectControl(
"codeMode",
"Mode",
[
["config", "Use config"],
["ask", "Ask"],
["auto_review", "Auto-review"],
["full_access", "Full access"],
],
record.session?.mode || "config",
(mode) => {
void updateSettings({ mode });
},
);
modeControl.select.title =
"Use config uses this session's original configured permission selection.";
controls.append(
providerControl.group,
modelControl.group,
reasoningControl.group,
harnessControl.group,
modeControl.group,
);
const selectionMessage = element(
"div",
"",
"code-control-error code-selection-error",
);
selectionMessage.id = "codeSelectionError";
selectionMessage.setAttribute("role", "status");
selectionMessage.hidden = true;
controls.append(selectionMessage);
for (const control of [
providerControl.select,
modelControl.input,
reasoningControl.select,
])
control.setAttribute("aria-describedby", selectionMessage.id);
const deletion = button("Delete", remove, "danger-button");
deletion.id = "codeDelete";
const deletionMessage = element("div", "", "code-control-error");
deletionMessage.id = "codeDeletionError";
deletionMessage.setAttribute("role", "status");
deletionMessage.hidden = true;
deletion.setAttribute("aria-describedby", deletionMessage.id);
const deletionGroup = element("div");
deletionGroup.append(deletion, deletionMessage);
const header = UI.header(
"← Code sessions",
() => navigate(null),
record.session?.title || "Code session",
"Code title",
(title) => {
if (
selected === id &&
title.value !== records.get(id)?.session?.title
)
void updateSettings({ title: title.value });
},
[deletionGroup],
controls,
);
header.append(element("p", "", "code-folder"));
const transcript = element("div", undefined, "session-transcript");
transcript.id = "codeTranscript";
transcript.setAttribute("aria-label", "Conversation");
const older = button(
"Load older messages",
async () => {
const oldHeight = transcript.scrollHeight,
top = transcript.scrollTop;
older.disabled = true;
try {
await detail(id, records.get(id).nextBefore);
if (selected === id)
transcript.scrollTop = top + transcript.scrollHeight - oldHeight;
} catch (error) {
restart(error.message);
}
older.disabled = false;
render();
},
"secondary-button session-older",
);
older.id = "codeOlder";
const activity = element("div", "Thinking…", "code-activity");
activity.id = "codeActivity";
activity.setAttribute("role", "status");
activity.hidden = true;
transcript.append(older, element("div", undefined, "code-items"), activity);
const composer = UI.composer(
"code",
saved(id).draft || "",
"Ask Codex to work on this folder…",
(value) => {
save(id, { ...saved(id), draft: value });
renderControls();
},
submit,
() => {
void stop();
},
);
const contextUsage = element("span", "", "code-context-usage");
contextUsage.id = "codeContextUsage";
contextUsage.setAttribute("role", "status");
contextUsage.hidden = true;
composer.querySelector(".session-composer-actions").prepend(contextUsage);
root.append(UI.shell(header, message, transcript, composer));
UI.resizeComposer(composer.querySelector("textarea"));
} else {
const create = button("New code session", newSession, "primary-button");
create.id = "codeNew";
const header = UI.libraryHeader(
"Code sessions",
"Work with Codex in a project folder.",
create,
);
const search = UI.search("Search titles and folders", query, (value) => {
query = value;
visibleIds = [];
nextCursor = null;
++libraryToken;
render();
void refreshLibrary();
});
const more = button(
"Load more sessions",
async () => {
libraryLoading = true;
render();
try {
await list(nextCursor);
} catch (error) {
restart(error.message);
}
libraryLoading = false;
render();
},
"secondary-button session-load-more",
);
more.id = "codeMore";
const library = element("div", undefined, "session-list");
library.id = "codeLibrary";
const wrapper = element("div", undefined, "session-library");
wrapper.append(header, search, message, library, more);
root.append(wrapper);
}
rendered = selected || "library";
}
function render(outputChanged = false) {
if (!root) return;
if (rendered !== (selected || "library")) shell();
const message = root.querySelector("#codeNotice");
message.textContent =
notice ||
availabilityNotice ||
syncNotice ||
(!connected ? "Connecting…" : !synchronized ? "Synchronizing…" : "");
message.hidden = !message.textContent;
if (!selected) {
const library = root.querySelector("#codeLibrary");
for (const child of [...library.children])
if (!child.dataset.id || !visibleIds.includes(child.dataset.id))
child.remove();
for (const record of visibleIds
.map((id) => records.get(id))
.filter((record) => record?.session)
.sort(
(a, b) =>
b.session.updated_at - a.session.updated_at ||
b.id.localeCompare(a.id),
)) {
let card = library.querySelector(
`[data-id="${CSS.escape(record.id)}"]`,
);
if (!card) {
card = UI.card("", "", "", () => navigate(record.id));
card.dataset.id = record.id;
}
card.children[0].textContent = record.session.title;
card.children[1].textContent = record.session.cwd;
card.children[2].textContent = busy(record)
? "Running"
: record.session.error || record.session.model;
library.append(card);
}
if (!library.children.length)
library.append(
element(
"div",
synchronized
? query
? "No matching sessions."
: "Start your first code session."
: "Loading sessions…",
"session-empty",
),
);
root.querySelector("#codeNew").disabled = !synchronized;
const more = root.querySelector("#codeMore");
more.hidden = !nextCursor;
more.disabled = !synchronized || libraryLoading;
return;
}
const record = records.get(selected),
title = root.querySelector(".session-title");
if (record?.session) {
if (document.activeElement !== title) title.value = record.session.title;
root.querySelector(".code-folder").textContent = record.session.cwd;
}
const transcript = root.querySelector("#codeTranscript"),
bottom = UI.nearBottom(transcript),
items = root.querySelector(".code-items");
const runs = [...(record?.runs.values() || [])]
.map((entry) => entry.value)
.sort((a, b) => a.ordinal - b.ordinal);
for (const run of runs) {
const source = [...record.items.values()]
.map((entry) => entry.value)
.filter((item) => item.run_id === run.id)
.sort((a, b) => a.sequence - b.sequence);
if (!source.length) continue;
let group = items.querySelector(`[data-run-id="${CSS.escape(run.id)}"]`);
if (!group) {
group = element("div", undefined, "code-run");
group.dataset.runId = run.id;
group.dataset.ordinal = run.ordinal;
group.append(
element("div", undefined, "code-run-items"),
UI.message("assistant", "Codex"),
);
group.lastChild.classList.add("code-outcome");
group.lastChild.append(element("div", "", "session-generation-status"));
const next = [...items.children].find(
(child) => Number(child.dataset.ordinal) > run.ordinal,
);
items.insertBefore(group, next || null);
}
for (const item of source) renderItem(group.firstChild, item, run);
const outcome = group.querySelector(".code-outcome");
outcome.hidden = !["failed", "interrupted"].includes(run.status);
const status = outcome.querySelector(".session-generation-status");
status.className = `session-generation-status ${run.status}`;
status.textContent =
run.error ||
(run.status === "interrupted" ? "Turn stopped." : "This turn failed.");
}
renderActivity(outputChanged);
if (bottom) transcript.scrollTop = transcript.scrollHeight;
root.querySelector("#codeOlder").hidden = !record?.nextBefore;
renderControls();
}
function renderControls() {
if (!selected || !root?.querySelector("#codeComposer")) return;
const record = records.get(selected),
isBusy = busy(record),
input = root.querySelector("#codeComposer");
renderContextUsage(record);
if (
providerDraft &&
(providerDraft.id !== selected ||
providerDraft.revision !== record?.session?.revision ||
isBusy ||
pending(record))
) {
providerDraft = null;
modelControl.combobox.close();
}
const send = root.querySelector("#codeSend"),
stop = root.querySelector("#codeStop");
send.hidden = isBusy;
stop.hidden = !isBusy;
stop.disabled = !connected || record?.run?.stop_requested;
send.textContent = saved(selected).pending ? "Retry Send" : "Send";
send.classList.toggle("startup-busy", selectionLoading(record));
send.setAttribute("aria-busy", String(selectionLoading(record)));
send.disabled =
!ready(record) ||
!available ||
!catalogLoaded ||
pending(record) ||
sends.has(selected) ||
settingsPending ||
!!selectionError(record) ||
(!input.value.trim() && !saved(selected).pending);
input.disabled = !record?.loaded || record?.session?.status !== "ready";
root.querySelector(".session-title").disabled =
!ready(record) || settingsPending;
const deletion = root.querySelector("#codeDelete");
deletion.textContent =
record?.session?.status === "delete_uncertain"
? "Check deletion"
: record?.session?.status === "deleting"
? "Deleting…"
: "Delete";
deletion.disabled =
!synchronized ||
!record?.loaded ||
record.session?.status === "deleting" ||
isBusy ||
pending(record);
const sessionDisabled =
!ready(record) ||
isBusy ||
pending(record) ||
settingsPending;
const disabled = sessionDisabled || !catalogLoaded || !catalog.length;
const provider =
providerDraft?.provider || record?.session?.provider_id || "";
if (modelControl.group.dataset.provider !== provider) {
modelControl.combobox.close();
modelControl.group.dataset.provider = provider;
}
const providers = [...new Set(catalog.map((model) => model.provider_id))];
if (provider && !providers.includes(provider)) providers.push(provider);
providerControl.update(
providers.map((value) => [value, providerNames.get(value) || value]),
provider,
);
providerControl.select.disabled = disabled;
modelControl.update(
providerDraft ? "" : record?.session?.model_name || "",
disabled,
);
modelControl.input.placeholder = "Choose a model";
harnessControl.update(
harnesses.map((harness) => [harness.id, harness.name]),
record?.session?.harness || "codex",
);
harnessControl.select.disabled = true;
modeControl.select.value = record?.session?.mode || "config";
modeControl.select.disabled = sessionDisabled;
const model = catalog.find((model) => model.id === record?.session?.model),
effort =
record?.session?.reasoning_effort ||
model?.default_reasoning_effort ||
"off";
const options = ["off", "low", "medium", "high", "xhigh", "max"].map(
(value) => [value, value],
);
reasoningControl.update(options, effort);
for (const option of reasoningControl.select.options)
option.disabled = !model?.reasoning_efforts.includes(option.value);
reasoningControl.select.disabled = disabled || !model;
const selectionMessage = root.querySelector("#codeSelectionError"),
deletionMessage = root.querySelector("#codeDeletionError");
selectionMessage.textContent = selectionError(record);
selectionMessage.hidden = !selectionMessage.textContent;
deletionMessage.textContent = record?.session?.error || "";
deletionMessage.hidden = !deletionMessage.textContent;
for (const node of root.querySelectorAll(".code-prompt")) {
const prompt = record?.prompts.get(node.dataset.id)?.value;
for (const control of node.querySelectorAll("input, select, button"))
control.disabled =
!ready(record) ||
!record.activePrompts.get(node.dataset.id)?.active ||
prompt?.status !== "pending" ||
node.dataset.claiming === "true";
}
UI.resizeComposer(input);
}
function renderItem(parent, item, run) {
if (item.kind === "prompt") {
const prompt = records.get(selected).prompts.get(item.id)?.value;
if (prompt) renderPrompt(parent, prompt, item.sequence);
return;
}
let node = parent.querySelector(`[data-id="${CSS.escape(item.id)}"]`);
if (!node) {
node = UI.message(
item.kind === "user" ? "user" : "assistant",
item.kind === "user" ? "You" : "Codex",
);
node.classList.add("code-item");
node.dataset.id = item.id;
node.dataset.kind = item.kind;
let content = node;
if (item.kind === "reasoning") {
content = UI.thinking();
node.append(content);
} else if (!["text", "user"].includes(item.kind)) {
content = element("details", undefined, "code-tool");
content.append(element("summary", item.title || "Tool"));
node.append(content);
}
content.append(
element(
"div",
"",
`code-prose ${item.kind === "user" ? "session-message-plain" : "session-markdown"}`,
),
element("pre", "", "code-item-detail"),
);
insertEntry(parent, node, item.sequence);
}
const summary = node.querySelector(".code-tool > summary");
if (summary) {
const childReview = item.kind === "subagent_auto_review";
const active = childReview
? records.get(selected).activeReviewIds.has(item.id)
: activeStatuses.has(run.status);
summary.textContent =
(childReview || item.kind === "auto_review") &&
!item.complete &&
!active
? `${childReview ? "Sub-agent " : ""}Auto-review: Result unavailable`
: item.title || "Tool";
}
const content = node.querySelector(".code-prose"),
value = item.html ?? item.text;
if (node.codeText !== value) {
if (item.html != null) content.innerHTML = item.html;
else content.textContent = item.text;
node.codeText = value;
}
const detail = node.querySelector(".code-item-detail");
detail.textContent = item.detail;
detail.hidden = !item.detail;
}
function insertEntry(parent, node, sequence) {
node.dataset.sequence = sequence;
const next = [...parent.children].find(
(child) => Number(child.dataset.sequence) > sequence,
);
parent.insertBefore(node, next || null);
}
function renderPrompt(parent, prompt, sequence) {
let node = parent.querySelector(`[data-id="${CSS.escape(prompt.id)}"]`);
if (!node) {
node = element("form", undefined, "code-prompt");
node.dataset.id = prompt.id;
node.append(
element("h3", prompt.form.title),
element("pre", prompt.form.detail || ""),
);
buildPrompt(node, prompt);
node.append(element("p", "", "code-prompt-state"));
insertEntry(parent, node, sequence);
}
node.querySelector(".code-prompt-state").textContent =
prompt.error ||
(!records.get(selected)?.activePrompts.get(prompt.id)?.active &&
["pending", "answering"].includes(prompt.status)
? "No longer active"
: "") ||
{
answering: "Answer sent…",
resolved: "Resolved",
expired: "No longer active",
}[prompt.status] ||
"";
}
function buildPrompt(form, prompt) {
const sessionId = selected,
actions = element("div", undefined, "code-actions");
let responseId = null,
submitting = false;
const answer = async (value) => {
if (
submitting ||
!ready(records.get(sessionId)) ||
!records.get(sessionId).activePrompts.get(prompt.id)?.active
)
return;
responseId ||= crypto.randomUUID();
submitting = true;
form.dataset.claiming = "true";
renderControls();
try {
await api(
`${base}/sessions/${sessionId}/prompts/${prompt.id}/responses`,
{
method: "POST",
body: JSON.stringify({ response_id: responseId, answer: value }),
},
);
} catch (error) {
form.querySelector(".code-prompt-state").textContent = error.message;
} finally {
submitting = false;
form.dataset.claiming = "false";
renderControls();
}
};
form.addEventListener("submit", (event) => event.preventDefault());
const choice = (text, value) =>
actions.append(
button(text, () => {
void answer(value);
}),
);
if (prompt.kind === "approval") {
for (const item of prompt.form.choices)
choice(item.label, { choice: item.id });
} else if (prompt.kind === "permissions") {
const checks = prompt.form.choices.map((item) => {
const input = element("input");
input.type = "checkbox";
input.value = item.id;
const label = element("label", undefined, "code-choice");
label.append(input, document.createTextNode(item.label));
form.append(label);
return input;
});
const scope = element("select");
scope.append(
new Option("This turn", "turn"),
new Option("This session", "session"),
);
label(form, "Allow for", scope);
actions.append(
button("Allow selected", () => {
void answer({
selected: checks
.filter((input) => input.checked)
.map((input) => input.value),
scope: scope.value,
});
}),
);
choice("Decline", { selected: [], scope: "turn" });
} else if (prompt.kind === "questions") {
const readers = prompt.form.questions.map((question) => {
const field = element("fieldset");
field.append(element("legend", question.label));
form.append(field);
if (question.options?.length) {
const name = `question-${crypto.randomUUID()}`,
radios = [];
for (const option of question.options) {
const radio = element("input");
radio.type = "radio";
radio.name = name;
radio.value = option.label;
radio.required = true;
const optionLabel = element("label", undefined, "code-choice");
optionLabel.append(
radio,
document.createTextNode(
option.label +
(option.description ? ` — ${option.description}` : ""),
),
);
field.append(optionLabel);
radios.push(radio);
}
let other;
if (question.allow_other) {
const radio = element("input");
radio.type = "radio";
radio.name = name;
radio.value = "__other__";
radios.push(radio);
const otherLabel = element("label", undefined, "code-choice");
otherLabel.append(radio, document.createTextNode("Other"));
field.append(otherLabel);
other = element("input");
other.type = question.secret ? "password" : "text";
other.autocomplete = "off";
label(field, "Your answer", other);
other.addEventListener("input", () => {
radio.checked = true;
});
}
return () => [
question.id,
[
radios.find((radio) => radio.checked)?.value === "__other__"
? other.value
: radios.find((radio) => radio.checked)?.value || "",
],
];
}
const input = element("input");
input.type = question.secret ? "password" : "text";
input.required = true;
input.autocomplete = "off";
label(field, question.header || "Your answer", input);
return () => [question.id, [input.value]];
});
actions.append(
button(
"Submit answers",
() => {
if (form.reportValidity())
void answer({
answers: Object.fromEntries(readers.map((read) => read())),
});
},
"primary-button",
),
);
} else {
const readers = [];
if (prompt.kind === "url") {
try {
const url = new URL(prompt.form.url);
if (["https:", "http:"].includes(url.protocol)) {
const link = element("a", "Open tool request");
link.href = url.href;
link.target = "_blank";
link.rel = "noopener noreferrer";
form.append(link);
} else throw new Error();
} catch {
form.append(element("p", "This tool supplied an unsupported link."));
}
} else if (prompt.form.unsupported)
form.append(
element(
"p",
"This tool's form cannot be displayed. Decline or cancel this request.",
),
);
else
for (const field of prompt.form.fields || []) {
const input = element(field.options?.length ? "select" : "input");
if (field.options?.length) {
input.multiple = field.type === "array";
if (!input.multiple) input.append(new Option("Choose…", ""));
field.options.forEach((option, index) =>
input.append(new Option(option.label, String(index))),
);
} else
input.type =
field.type === "boolean"
? "checkbox"
: ["integer", "number"].includes(field.type)
? "number"
: "text";
if (input.type === "number")
input.step = field.type === "integer" ? "1" : "any";
for (const [source, target] of [
["minimum", "min"],
["maximum", "max"],
["minLength", "minLength"],
["maxLength", "maxLength"],
])
if (field[source] != null) input[target] = field[source];
input.required = field.required && field.type !== "boolean";
input.autocomplete = "off";
if (field.default != null && !field.options?.length) {
if (input.type === "checkbox") input.checked = field.default;
else input.value = field.default;
}
label(form, field.label, input, field.description);
readers.push(() => {
if (input.type === "checkbox") return [field.id, input.checked];
if (!input.value && !field.required) return null;
if (field.options?.length)
return [
field.id,
input.multiple
? [...input.selectedOptions].map(
(option) => field.options[Number(option.value)].value,
)
: field.options[Number(input.value)].value,
];
return [
field.id,
input.type === "number" ? Number(input.value) : input.value,
];
});
}
if (!prompt.form.unsupported)
actions.append(
button(
"Submit",
() => {
if (form.reportValidity())
void answer({
action: "accept",
values: Object.fromEntries(
readers.map((read) => read()).filter(Boolean),
),
});
},
"primary-button",
),
);
choice("Decline", { action: "decline" });
choice("Cancel request", { action: "cancel" });
}
form.append(actions);
}
function deactivate() {
viewActive = false;
clearActivity();
dismissDialog();
}
window.addEventListener("pagehide", deactivate);
function pauseCatalog() {
clearTimeout(catalogRetryTimer);
catalogRetryTimer = null;
catalogAgain = false;
++catalogRequest;
catalogController?.abort();
}
window.addEventListener("pagehide", pauseCatalog);
document.addEventListener("visibilitychange", () => {
if (document.hidden) pauseCatalog();
else void bootstrap();
});
window.CodeSessions = {
setProviderNames(providers) {
providerNames = new Map(providers.map((provider) => [provider.provider_id, provider.display_name]));
},
initialize(client) {
api = client;
root = document.getElementById("codeRoot");
if (desiredPath) activate(desiredPath);
},
activate,
deactivate,
async refresh(status) {
if (!api) return false;
if (status?.startup) {
if (catalogInstance !== status.instance_id) {
catalogTarget = null;
catalogVersion = null;
++catalogRequest;
}
catalogInstance = status.instance_id;
if (!olderCatalog(status.startup)) catalogTarget = status.startup;
}
return bootstrap();
},
};
document.addEventListener("pointerdown", (event) => {
for (const combobox of modelComboboxes)
if (combobox.isOpen && !combobox.element.contains(event.target))
combobox.close();
});
})();
(() => {
"use strict";
const UI = window.SessionUI;
const modelComboboxes = new Set();
let providerNames = new Map();
let modelControl,
reasoningControl,
providerControl,
harnessControl,
modeControl,
providerDraft = null,
harnesses = [],
catalog = [],
catalogLoaded = false,
catalogPhase = "starting",
catalogVersion = null,
catalogTarget = null,
catalogProviders = {},
catalogInstance = null,
catalogRequest = 0,
settingsPending = false;
let catalogFlight = null,
catalogAgain = false,
catalogRetryTimer = null,
catalogController = null;
let visibleIds = [],
query = "",
libraryToken = 0,
listFlight = null,
listAgain = false,
retryTimer = null;
let syncNotice = "",
availabilityNotice = "";
const base = "/admin/api/code";
const activeStatuses = new Set(["preparing", "running", "stopping"]);
const records = new Map();
const deleted = new Set();
const sends = new Set();
let api,
root,
feed,
epoch,
connected = false,
synchronized = false;
let desiredPath = null,
selected = null,
rendered = null,
syncToken = 0,
viewToken = 0;
let nextCursor = null,
libraryLoading = false,
notice = "",
available = false;
let activeDialog = null;
let viewActive = false,
activityKey = null,
activityTimer = null;
function element(tag, text, className) {
const node = document.createElement(tag);
if (text !== undefined) node.textContent = text;
if (className) node.className = className;
return window.FccFormControls.configure(node);
}
function button(text, action, className = "secondary-button") {
const node = element("button", text, className);
node.type = "button";
node.addEventListener("click", action);
return node;
}
function saved(id) {
try {
return JSON.parse(sessionStorage.getItem(`fcc.code.${id}`)) || {};
} catch {
return {};
}
}
function save(id, value) {
try {
sessionStorage.setItem(`fcc.code.${id}`, JSON.stringify(value));
} catch {
/* This tab still works when browser storage is unavailable. */
}
}
function get(id) {
if (!records.has(id))
records.set(id, {
id,
session: null,
run: null,
version: -1,
cursor: -1,
items: new Map(),
prompts: new Map(),
activeReviewIds: new Set(),
activePrompts: new Map(),
runs: new Map(),
loaded: false,
nextBefore: null,
});