A desktop coding agent with free access to frontier models.
TypeScript
import { browserScript } from "@omnirush/cdp";
import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
import { rm } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import { app as startApp, faultProxy as startFaultProxy, resolveEvalEngine, SkipError } from "@omnirush/env";
import type { Den, MockHandle, Seed } from "@omnirush/env";
import { denFetch, evalIn as rawEvalIn } from "@omnirush/behaviors";
import type { DenFetchResult, DenSession } from "@omnirush/behaviors";
import { allocateFreePort } from "@omnirush/cdp";
import { startMockMcp } from "@omnirush/labs";
import { captureExternalBrowserUrls, electronProfilePaths } from "@omnirush/hosts";
import { configureProvider } from "./chat.ts";
export const repoRoot = fileURLToPath(new URL("../..", import.meta.url));
export function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
export function records(value: unknown): Record<string, unknown>[] {
return Array.isArray(value) ? value.filter(isRecord) : [];
}
export function itemOf(body: unknown): Record<string, unknown> {
if (!isRecord(body) || !isRecord(body.item)) {
throw new Error(`Response had no item: ${JSON.stringify(body).slice(0, 300)}`);
}
return body.item;
}
export function stringField(value: unknown, key: string): string {
return isRecord(value) && typeof value[key] === "string" ? value[key] : "";
}
export function booleanField(value: unknown, key: string): boolean | null {
return isRecord(value) && typeof value[key] === "boolean" ? value[key] : null;
}
async function activeOrganizationId(seed: Seed, session: DenSession): Promise<string> {
const result = await seed.api(session, "/v1/me/orgs");
const orgs = isRecord(result.body) ? records(result.body.orgs) : [];
const id = orgs[0] && typeof orgs[0].id === "string" ? orgs[0].id : "";
if (!result.response.ok || !id) {
throw new Error(`Resolving the active organization failed: HTTP ${result.response.status} ${result.text.slice(0, 500)}`);
}
return id;
}
async function mintMcpSession(seed: Seed, den: Den, organizationId: string): Promise<DenSession> {
const result = await seed.api(den.admin, "/v1/mcp/token", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({ scopes: ["mcp:read", "mcp:write"] }),
});
const token = stringField(result.body, "token");
if (!result.response.ok || !token.startsWith("ow_mcp_at_")) {
throw new Error(`Minting the MCP token failed: HTTP ${result.response.status} ${result.text.slice(0, 500)}`);
}
return { ...den.admin, token };
}
function withDispose<T extends object>(value: T, dispose: () => Promise<void>): T & AsyncDisposable {
return Object.assign(value, { [Symbol.asyncDispose]: dispose });
}
async function closeServer(server: Server): Promise<void> {
await new Promise<void>((resolve, reject) => {
server.close((error) => error ? reject(error) : resolve());
server.closeAllConnections();
});
}
function readBody(request: IncomingMessage): Promise<string> {
request.setEncoding("utf8");
return new Promise((resolve, reject) => {
let body = "";
request.on("data", (chunk: string) => {
body += chunk;
});
request.on("end", () => resolve(body));
request.on("error", reject);
});
}
function sendJson(response: ServerResponse, status: number, body: unknown): void {
response.writeHead(status, {
"access-control-allow-origin": "*",
"cache-control": "no-store",
"content-type": "application/json",
});
response.end(JSON.stringify(body));
}
function streamChunk(model: string, delta: Record<string, unknown>, finishReason: string | null = null) {
return {
id: `chatcmpl-${model}`,
object: "chat.completion.chunk",
created: 1,
model,
choices: [{ index: 0, delta, finish_reason: finishReason }],
};
}
function sendStream(response: ServerResponse, chunks: Record<string, unknown>[]): void {
response.writeHead(200, {
"cache-control": "no-cache",
connection: "keep-alive",
"content-type": "text/event-stream",
});
let delay = 200;
for (const chunk of chunks) {
setTimeout(() => response.write(`data: ${JSON.stringify(chunk)}\n\n`), delay);
delay += 200;
}
setTimeout(() => response.end("data: [DONE]\n\n"), delay);
}
function projectedTool(payload: Record<string, unknown>, ending: string): string | null {
for (const tool of records(payload.tools)) {
if (!isRecord(tool.function)) continue;
const name = tool.function.name;
if (typeof name === "string" && name.endsWith(ending)) return name;
}
return null;
}
function completedToolCount(payload: Record<string, unknown>): number {
return records(payload.messages).filter((message) => message.role === "tool").length;
}
export function toolJson(result: DenFetchResult): unknown {
const payloads = result.text.split("\n")
.filter((line) => line.startsWith("data:"))
.map((line) => JSON.parse(line.slice(5)) as unknown)
.filter(isRecord);
const rpc = payloads.find((payload) => isRecord(payload.result));
if (!rpc || !isRecord(rpc.result)) throw new Error(`MCP response had no result: ${result.text.slice(0, 500)}`);
const first = records(rpc.result.content)[0];
if (!first || typeof first.text !== "string") return rpc.result;
return JSON.parse(first.text);
}
export function rpcResult(result: DenFetchResult): Record<string, unknown> {
const payload = result.text.split("\n")
.filter((line) => line.startsWith("data:"))
.map((line) => JSON.parse(line.slice(5)) as unknown)
.find(isRecord);
if (!payload || !isRecord(payload.result)) {
throw new Error(`MCP response had no result: ${result.text.slice(0, 500)}`);
}
return payload.result;
}
export function mcpCallBody(id: number, name: string, args: Record<string, unknown>): string {
return JSON.stringify({
jsonrpc: "2.0",
id,
method: "tools/call",
params: { name, arguments: args },
});
}
export const connectStateExpression = () => {
const port = localStorage.getItem("omnirush.server.port") ?? "";
const baseUrl = port ? "http://127.0.0.1:" + port : "";
const token = localStorage.getItem("omnirush.server.token") ?? "";
if (!baseUrl || !token) return { ok: false, status: null, connectEnabled: null };
const request = new XMLHttpRequest();
request.open("GET", baseUrl + "/experimental/connect/state", false);
request.setRequestHeader("Authorization", "Bearer " + token);
request.send();
const raw = JSON.parse(request.responseText || "{}");
return { ok: request.status >= 200 && request.status < 300, status: raw?.status ?? null, connectEnabled: raw?.connectEnabled ?? null };
};
export const runtimeGenerationExpression = async () => {
const invokeDesktop = window.__OMNIRUSH_ELECTRON__?.invokeDesktop;
if (!invokeDesktop) return { running: false, baseUrl: "", generation: null };
const info = await invokeDesktop("omnirushServerInfo");
return {
running: info?.running === true,
baseUrl: String(info?.baseUrl ?? ""),
generation: typeof info?.generation === "number" ? info.generation : null,
};
};
export const cloudHealthExpression = (workspaceId: string) => {
const port = localStorage.getItem("omnirush.server.port");
const token = localStorage.getItem("omnirush.server.token");
if (!port || !token) return { error: "missing local server credentials" };
const request = new XMLHttpRequest();
request.open("GET", "http://127.0.0.1:" + port + "/workspace/" + encodeURIComponent(workspaceId) + "/mcp/omnirush-cloud/health?probe=1", false);
request.setRequestHeader("Authorization", "Bearer " + token);
request.send();
return JSON.parse(request.responseText || "{}");
};
export async function connectPolicyRuntimeRestart(seed: Seed, { place }: { place: import("@omnirush/env").Place }) {
const stamp = Date.now();
const den = await seed.den({
org: {
name: "Connect Policy Convergence",
admin: { email: `connect-policy-admin-${stamp}@omnirush.test`, name: "Connect Policy Admin" },
members: { fresh: { email: `connect-policy-member-${stamp}@omnirush.test`, name: "Fresh Profile Member" } },
},
});
const app = await startApp({ den, as: "fresh", place, localServerDelayMs: 5_000 });
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [app.workspaceId]));
return withDispose({ app }, async () => app.stop());
}
export async function clearConnectStateFiles(app: Awaited<ReturnType<typeof startApp>>): Promise<void> {
if (!app.handle.profileDir) throw new Error("The local desktop profile directory is unavailable.");
const paths = electronProfilePaths(app.handle.profileDir);
const candidates = [
`${paths.userDataDir}/omnirush-dev-data/xdg/config/omnirush/connect-state.json`,
`${paths.configHome}/omnirush/connect-state.json`,
`${paths.homeDir}/.config/omnirush/connect-state.json`,
];
await Promise.all(candidates.map((path) => rm(path, { force: true })));
}
export async function connectStateProvenance(seed: Seed) {
const stamp = Date.now();
const den = await seed.den({
org: {
name: "Connect State Provenance",
admin: { email: `connect-state-admin-${stamp}@omnirush.test`, name: "Connect State Admin" },
members: { fresh: { email: `connect-state-member-${stamp}@omnirush.test`, name: "Fresh Profile Member" } },
},
});
const app = await seed.desktop({ den, signIn: false });
const workspace = await seed.workspace(app, seed.tmpPath("connect-state-provenance"));
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [workspace.workspaceId]));
return { app, member: den.members.fresh };
}
export async function preseededConnect(seed: Seed) {
const stamp = Date.now();
const skillName = `preseeded-connect-proof-${stamp}`;
const connectionName = `Preseeded connection ${String(stamp).slice(-6)}`;
const proofPhrase = `Connect skill proof ${crypto.randomUUID()}`;
const prompt = `Find and read the organization skill named ${skillName}.`;
const providerName = "Connect discovery model";
const modelId = "connect-discovery-model";
const rawSourceText = `---\nname: ${skillName}\ndescription: Proves preseeded Connect skill discovery.\n---\n\nReturn this exact phrase: ${proofPhrase}.`;
const den = await seed.den({
org: { name: `Preseeded Connect ${stamp}`, admin: { name: "Connect Admin" } },
mocks: { connector: seed.mock({ agentWorkloads: [{
promptMarker: prompt,
finalReply: "The skill was read.",
finalReplyFrom: "last-tool-text",
steps: [
{ tool: "search_capabilities", arguments: { query: skillName, limit: 1, type: "skills" } },
{ tool: "execute_capability", arguments: {}, argumentsFrom: "capability-search" },
],
}] }) },
});
const organizationId = await activeOrganizationId(seed, den.admin);
const createdSkill = await seed.api(den.admin, "/v1/plugins", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({
name: skillName,
orgWide: true,
components: [{ type: "skill", input: { rawSourceText } }],
}),
});
const pluginId = stringField(isRecord(createdSkill.body) ? createdSkill.body.item : null, "id");
if (createdSkill.response.status !== 201 || !pluginId) throw new Error("Could not seed the Connect skill.");
const connection = await seed.orgConnection(den.admin, {
name: connectionName,
url: den.mocks.connector.mcpUrl,
authType: "oauth",
credentialMode: "per_member",
access: { orgWide: true },
});
const provider = await seed.api(den.admin, "/v1/llm-providers", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({
name: providerName, source: "custom", allMembers: true, memberIds: [], teamIds: [],
apiKey: "sk-omnirush-connect-eval-only",
customConfig: { id: "connect-discovery", name: providerName, npm: "@ai-sdk/openai-compatible",
options: { baseURL: `${den.mocks.connector.url}/v1` }, env: ["CONNECT_EVAL_API_KEY"],
models: [{ id: modelId, name: modelId, tool_call: true, limit: { context: 128000, output: 8192 } }],
},
}),
});
if (provider.response.status !== 201) throw new Error(`Could not publish the Connect fixture model: HTTP ${provider.response.status}`);
const mcpSession = await mintMcpSession(seed, den, organizationId);
const app = await seed.desktop({ den, signIn: false });
const workspace = await seed.workspace(app, seed.tmpPath("preseeded-connect"));
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [workspace.workspaceId]));
return {
app, den, prompt, proofPhrase, providerName, modelId,
admin: den.admin,
member: den.admin,
mcpSession,
pluginId,
rawSourceText,
skillName,
nonsenseName: `no-such-capability-${stamp}`,
connection,
connectionName,
workspaceId: workspace.workspaceId,
};
}
export async function connectorBranding(seed: Seed) {
const engine = resolveEvalEngine();
const proof = `Channel list ${crypto.randomUUID()}`;
const prompt = "List three of my Slack channels.";
const failurePrompt = "Read the three latest items in my Slack history.";
const toolArguments = { limit: 3 };
const inputSchema = { type: "object", properties: { limit: { type: "integer" } }, required: ["limit"] };
const search = (name: string) => ({ query: `Slack ${name}`, type: "mcp", limit: 1 });
const steps = (name: string) => engine === "v2" ? [{
tool: "execute",
arguments: { code: `
const found = await tools["omnirush-cloud"].search_capabilities(${JSON.stringify(search(name))});
const result = typeof found === "string" ? JSON.parse(found) : found;
const catalog = result.matches ? result : JSON.parse(result.content[0].text);
return await tools["omnirush-cloud"].execute_capability({ name: catalog.matches[0].name, body: ${JSON.stringify(toolArguments)} });
` },
}] : [
{ tool: "search_capabilities", arguments: search(name) },
{ tool: "execute_capability", arguments: { body: toolArguments }, argumentsFrom: "capability-search" },
];
const den = await seed.den({
org: { name: "Connector tool display", admin: { name: "Connector Admin" } },
mocks: { connector: seed.mock({
allowUnauthenticatedMcp: true,
tools: [
{ name: "list_channels", description: "List Slack channels", inputSchema,
delayMs: 4_000, result: { content: [{ type: "text", text: `OpenCode diagnostic: ${proof}` }] } },
{ name: "read_history", description: "Read Slack history", inputSchema,
delayMs: 4_000, result: { isError: true, content: [{ type: "text", text: "History lookup failed." }] } },
],
}) },
});
await seed.orgConnection(den.admin, {
name: "Slack", url: den.mocks.connector.mcpUrl, authType: "none", credentialMode: "shared", access: { orgWide: true },
});
const workloads = await fetch(`${den.mocks.connector.url}/admin/agent-workloads`, {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ workloads: [
{ promptMarker: prompt, latestUserTurn: true, finalReply: "Listed the channels.", steps: steps("list_channels") },
{ promptMarker: failurePrompt, latestUserTurn: true, finalReply: "The history lookup failed.", steps: steps("read_history") },
] }),
});
if (!workloads.ok) throw new Error("Could not arrange connector model turns.");
const modelId = "connector-display-model";
const provider = await seed.api(den.admin, "/v1/llm-providers", {
method: "POST",
body: JSON.stringify({
name: "Connector display model", source: "custom", allMembers: true, memberIds: [], teamIds: [],
apiKey: "sk-connector-display-fixture",
customConfig: {
id: "connector-display", name: "Connector display model", npm: "@ai-sdk/openai-compatible",
options: { baseURL: `${den.mocks.connector.url}/v1` }, env: ["CONNECTOR_DISPLAY_API_KEY"],
models: [{ id: modelId, name: "Connector display model", tool_call: true }],
},
}),
});
const llmProvider = isRecord(provider.body) && isRecord(provider.body.llmProvider) ? provider.body.llmProvider : null;
if (provider.response.status !== 201 || typeof llmProvider?.id !== "string") {
throw new Error(`Connector fixture model setup failed: HTTP ${provider.response.status}`);
}
const providerId = llmProvider.id;
const connected = await seed.api(den.admin, `/v1/llm-providers/${encodeURIComponent(providerId)}/connect`);
if (!connected.response.ok) throw new Error(`Connector fixture model connection failed: HTTP ${connected.response.status}`);
const app = await seed.desktop({
den, as: "admin", model: `${providerId}/${modelId}`,
// The isolated Den fixture has no production trace-upload account.
env: { OMNIRUSH_DEV_MODE: "1", OMNIRUSH_SESSION_UPLOAD_OPTIONAL: "1" },
});
const workspace = await seed.workspace(app, seed.tmpPath("connector-tool-call-branding"));
await seed.evalIn(app, browserScript(async () => {
const info = await window.__OMNIRUSH_ELECTRON__?.invokeDesktop?.("omnirushServerInfo");
if (!info?.running || !info.baseUrl) throw new Error("Local server is unavailable");
const baseUrl = String(info.baseUrl).replace(/\/+$/, "");
const authorization = "Bearer " + String(info.ownerToken ?? info.clientToken ?? "");
const deadline = Date.now() + 60_000;
let status = 0;
while (Date.now() < deadline) {
const response = await fetch(baseUrl + "/managed-policy", {
headers: { Authorization: authorization },
signal: AbortSignal.timeout(10_000),
});
status = response.status;
if (response.ok) return true;
await new Promise((resolve) => setTimeout(resolve, 500));
}
throw new Error(`Desktop policy did not become ready (HTTP ${status})`);
}, []), { awaitPromise: true, timeoutMs: 75_000 });
await configureProvider(seed, app, workspace.workspaceId, providerId, modelId, {
provider: { [providerId]: {
npm: "@ai-sdk/openai-compatible", name: "Connector display model",
options: { baseURL: `${den.mocks.connector.url}/v1`, apiKey: "sk-connector-display-fixture" },
models: { [modelId]: { name: "Connector display model" } },
} },
});
await seed.session(app);
return { app, den, prompt, failurePrompt, proof };
}
export async function connectorsQuickAdd(seed: Seed) {
const den = await seed.den({
org: { name: `Connectors Quick Add ${Date.now()}`, admin: { name: "Sarah" } },
mocks: { connector: seed.mock() },
});
const web = await seed.web({
den,
signedInAs: den.admin,
startPath: "/dashboard/mcp-connections",
headless: true,
viewport: { width: 1440, height: 1200 },
});
return { web, connector: den.mocks.connector };
}
export async function libraryConnectorDiscovery(seed: Seed) {
const den = await seed.den({ org: { name: `Library connector discovery ${Date.now()}`, admin: { name: "Library Connector Admin" } } });
const organizationId = await activeOrganizationId(seed, den.admin);
const app = await seed.desktop({ den, as: "admin" });
const workspace = await seed.workspace(app, seed.tmpPath("library-connector-discovery"));
await app.client.send("Emulation.setDeviceMetricsOverride", {
width: 820,
height: 760,
deviceScaleFactor: 1,
mobile: false,
});
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [workspace.workspaceId]));
return { app, organizationId, denWebUrl: den.ref.webUrl };
}
export async function librarySessionRestore(seed: Seed) {
const stamp = Date.now();
const den = await seed.den({
org: { name: `Library session restore ${stamp}`, admin: { name: "Library Session Restore Admin" } },
});
const proxy = await seed.faultProxy(den);
const proxiedDen = { ...den, ref: proxy.ref };
const app = await seed.desktop({ den: proxiedDen, signIn: false });
const workspace = await seed.workspace(app, seed.tmpPath("library-session-restore"));
const skillsRoute = `/workspace/${workspace.workspaceId}/extensions/skills`;
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((route) => { location.hash = route; return true; }, [`#${skillsRoute}`]));
return {
app,
proxy,
member: { ...den.admin, ...proxy.ref },
skillsRoute,
sessionRoute: `/workspace/${workspace.workspaceId}/session`,
};
}
export async function libraryAdvancedRefresh(seed: Seed) {
const den = await seed.den({
org: { name: `Library Advanced refresh ${Date.now()}`, admin: { name: "Library Refresh Admin" } },
mocks: { connector: seed.mock() },
});
const proxy = await seed.faultProxy(den);
const app = await seed.desktop({ den: { ...den, ref: proxy.ref }, as: "admin" });
const workspace = await seed.workspace(app, seed.tmpPath("library-advanced-refresh"));
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [workspace.workspaceId]));
return { app, proxy, admin: den.admin, connector: den.mocks.connector };
}
export async function libraryAuthoringRoutes(seed: Seed) {
const stamp = Date.now();
const skillName = `library-route-proof-${stamp}`;
const description = `Exact Den description ${stamp}`;
const instructions = `# Exact instructions\n\nReturn library route proof ${stamp}.`;
const expectedSource = `---\nname: ${skillName}\ndescription: ${description}\n---\n\n${instructions}`;
const connectionName = `Library route connection ${stamp}`;
const den = await seed.den({
org: { name: `Library authoring routes ${stamp}`, admin: { name: "Library Route Admin" } },
mocks: { connector: seed.mock() },
});
const organizationId = await activeOrganizationId(seed, den.admin);
const connection = await seed.orgConnection(den.admin, {
name: connectionName,
url: den.mocks.connector.mcpUrl,
authType: "oauth",
credentialMode: "per_member",
access: { orgWide: true },
});
const proxy = await seed.faultProxy(den);
const app = await seed.desktop({ den: { ...den, ref: proxy.ref }, signIn: false });
const workspace = await seed.workspace(app, seed.tmpPath("library-authoring-routes"));
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/extensions"; return true; }, [workspace.workspaceId]));
const web = await seed.web({ den, signedInAs: den.admin, startPath: "/dashboard/library", headless: true });
return {
app,
web,
proxy,
member: { ...den.admin, ...proxy.ref },
admin: den.admin,
organizationId,
skillName,
description,
instructions,
expectedSource,
connection,
connectionName,
};
}
export async function libraryConfigReadBudget(seed: Seed) {
const app = await seed.desktop({ name: "library-config-read-budget" });
await seed.workspace(app, repoRoot);
// TODO(primitive): seed.networkObserver
await seed.evalIn(app, () => {
window.__opencodeConfigReads = 0;
window.__librarySkillReads = 0;
window.__libraryLifecycleReads = 0;
const originalFetch = window.fetch;
window.fetch = function (...args) {
const target = args[0] instanceof Request ? args[0].url : String(args[0]);
if (typeof target === "string" && target.includes("/opencode-config")) window.__opencodeConfigReads += 1;
if (typeof target === "string" && target.includes("/skills/browser-automation")) window.__librarySkillReads += 1;
if (typeof target === "string" && (target.includes("/cloud-provider-sync/status") || target.includes("/opencode/config?") || target.endsWith("/mcp") || target.endsWith("/den-session"))) window.__libraryLifecycleReads += 1;
return originalFetch.apply(this, args);
};
const bridge = window.__OMNIRUSH_ELECTRON__;
if (bridge?.invokeDesktop) {
const originalInvoke = bridge.invokeDesktop.bind(bridge);
bridge.invokeDesktop = function (command, ...rest) {
if (command === "readOpencodeConfig") window.__opencodeConfigReads += 1;
return originalInvoke(command, ...rest);
};
}
location.hash = "#/settings/general";
return true;
});
return { app };
}
export async function libraryMcpConnectError(seed: Seed) {
const stamp = Date.now();
const den = await seed.den({
org: { name: `Library MCP connect error ${stamp}`, admin: { name: "Sarah" } },
mocks: { connector: seed.mock({ profileId: "synthetic-enterprise-oauth-mcp" }) },
});
const app = await seed.desktop({ den, as: "admin" });
const workspace = await seed.workspace(app, seed.tmpPath("library-mcp-connect-error"));
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [workspace.workspaceId]));
return {
app,
connector: den.mocks.connector,
name: `lib-connect-err-${stamp}`,
invalidUrl: `https://managed-mcp-${stamp}.invalid/mcp`,
workspaceId: workspace.workspaceId,
};
}
export async function librarySignedInStability(seed: Seed) {
const den = await seed.den({
org: { name: "Library Render Stability", admin: { name: "Library Admin" }, members: { member: { name: "Library Member" } } },
});
const app = await seed.desktop({ den, as: "member" });
const workspace = await seed.workspace(app, repoRoot);
// TODO(primitive): seed.networkObserver
await seed.evalIn(app, browserScript((workspaceId) => {
window.__libraryStability = { requests: [], denEvents: 0, samples: [] };
const originalFetch = window.fetch;
window.fetch = function (...args) {
const target = args[0] instanceof Request ? args[0].url : String(args[0]);
window.__libraryStability.requests.push(String(target));
return originalFetch.apply(this, args);
};
window.addEventListener("omnirush-den-settings-changed", () => { window.__libraryStability.denEvents += 1; });
location.hash = "#/workspace/" + workspaceId + "/settings/general";
return true;
}, [workspace.workspaceId]));
return { app };
}
export async function libraryStateTabs(seed: Seed) {
const app = await seed.desktop({ name: "library-state-tabs" });
await seed.workspace(app, repoRoot);
// TODO(primitive): seed.route
await seed.evalIn(app, () => { location.hash = "#/settings/general"; return true; });
return { app };
}
export async function localManagedMcp(seed: Seed) {
const stamp = Date.now();
const den = await seed.den({
org: { name: `Local managed MCP OAuth ${stamp}`, admin: { name: "Sarah" } },
mocks: { connector: seed.mock() },
});
const app = await seed.desktop({ den, as: "admin" });
const workspace = await seed.workspace(app, seed.tmpPath("local-managed-mcp"));
// TODO(primitive): seed.route
await seed.evalIn(app, browserScript((workspaceId) => { location.hash = "#/workspace/" + workspaceId + "/settings/general"; return true; }, [workspace.workspaceId]));
return { app, connector: den.mocks.connector, name: `local-managed-${stamp}`, workspaceId: workspace.workspaceId };
}
const slackClientSecret = "slack-eval-client-secret-32-bytes";
export const slackScopes = [
"search:read.public", "search:read.private", "chat:write", "channels:history", "groups:history",
"im:history", "mpim:history", "users:read", "channels:read",
];
async function slackWorld(seed: Seed, profileId: "slack-user-mcp" | "synthetic-enterprise-oauth-mcp", label: string) {
const den = await seed.den({
org: { name: `${label} ${Date.now()}`, admin: { name: "Sarah" } },
mocks: {
connector: seed.mock(profileId === "slack-user-mcp"
? { profileId, oauthClientSecret: slackClientSecret }
: { profileId }),
},
});
const connector = den.mocks.connector;
await connector.configureOAuthRedirectUris([`${den.ref.apiUrl}/v1/mcp-connections/oauth/callback`]);
const name = `${label} ${Date.now()}`;
const created = await seed.api(den.admin, "/v1/mcp-connections", {
method: "POST",
body: JSON.stringify({
name,
url: connector.mcpUrl,
authType: "oauth",
credentialMode: "shared",
authorizationServerIssuer: connector.url,
requestedScopes: profileId === "slack-user-mcp" ? slackScopes : ["mcp.read", "mcp.write", "offline_access"],
...(profileId === "slack-user-mcp" ? {
oauthClient: {
clientId: "enterprise-mcp-test-client",
clientSecret: slackClientSecret,
tokenEndpointAuthMethod: "client_secret_post",
},
} : {}),
access: { orgWide: true, memberIds: [], teamIds: [] },
}),
});
const connectionId = stringField(created.body, "id");
if (!created.response.ok || !connectionId) throw new Error(`Could not create ${name}.`);
const web = await seed.web({ den, signedInAs: den.admin, startPath: "/dashboard/your-connections", headless: true });
return { web, admin: den.admin, connector, connectionId, name };
}
export const slackReady = (seed: Seed) => slackWorld(seed, "slack-user-mcp", "Slack Style Ready");
export const slackRefreshDiagnostic = (seed: Seed) => slackWorld(seed, "slack-user-mcp", "Slack Style Refresh");
export const standardOauth = (seed: Seed) => slackWorld(seed, "synthetic-enterprise-oauth-mcp", "Standard OAuth MCP");
export const utf8Bytes = (value: string) => Buffer.byteLength(value, "utf8");
export function buildSkillMarkdown(name: string, headline: string, targetBytes: number): string {
const sentence = "Orchestre le développement complet d'apps mobiles — idée, étude de marché, validation, croissance, déploiement. 大小阈值测试。";
let markdown = `---\nname: ${name}\ndescription: Skill volumineux multi-octets qui prouve la limite de search_text.\n---\n\n# ${headline}\n\n`;
while (utf8Bytes(markdown) < targetBytes) markdown += sentence;
return markdown.trimEnd();
}
export async function largeSkill(seed: Seed) {
const unique = `${Date.now().toString(36)}${Math.floor(Math.random() * 1e6).toString(36)}`;
const den = await seed.den({ org: { name: `SearchText Overflow ${unique}` } });
const organizationId = await activeOrganizationId(seed, den.admin);
const headers = { "x-omnirush-org-id": organizationId };
const skillName = `grand-skill-multioctets-${unique}`;
const skillV1 = buildSkillMarkdown(skillName, "Orchestrateur V1", 120_000);
const created = await seed.api(den.admin, "/v1/config-objects", {
method: "POST",
headers,
body: JSON.stringify({ type: "skill", sourceMode: "cloud", input: { rawSourceText: skillV1 } }),
signal: AbortSignal.timeout(120_000),
});
const configObjectId = stringField(itemOf(created.body), "id");
const skillV2 = buildSkillMarkdown(skillName, "Orchestrateur V2", 200_000);
const versioned = await seed.api(den.admin, `/v1/config-objects/${encodeURIComponent(configObjectId)}/versions`, {
method: "POST",
headers,
body: JSON.stringify({ input: { rawSourceText: skillV2 }, reason: "spec: oversized multibyte update" }),
signal: AbortSignal.timeout(120_000),
});
const smallName = `petit-skill-${unique}`;
const smallBody = "Corps compact avec accents — été, déjà, très.";
const smallSkill = `---\nname: ${smallName}\ndescription: Petit skill témoin.\n---\n\n${smallBody}`;
const smallCreated = await seed.api(den.admin, "/v1/config-objects", {
method: "POST",
headers,
body: JSON.stringify({ type: "skill", sourceMode: "cloud", input: { rawSourceText: smallSkill } }),
});
return {
admin: den.admin,
created,
versioned,
configObjectId,
skillName,
skillV1,
skillV2,
smallName,
smallBody,
smallCreated,
};
}
async function capabilityWorld(seed: Seed, extraToolCount: number) {
const den = await seed.den({ mocks: { connector: seed.mock({ extraToolCount }) } });
const connection = await seed.orgConnection(den.admin, {
name: `Capability Search ${Date.now()}`,
url: den.mocks.connector.mcpUrl,
authType: "oauth",
credentialMode: "shared",
access: { orgWide: true },
});
const organizationId = await activeOrganizationId(seed, den.admin);
const mcpSession = await mintMcpSession(seed, den, organizationId);
const web = await seed.web({
den,
signedInAs: den.admin,
startPath: "/dashboard/your-connections",
headless: true,
viewport: { width: 1440, height: 1000 },
});
return { den, web, connector: den.mocks.connector, connection, mcpSession };
}
export const capabilitySearchScale = (seed: Seed) => capabilityWorld(seed, 400);
export async function capabilitySearchLatency(seed: Seed, { place }: { place: import("@omnirush/env").Place }) {
const healthy = await capabilityWorld(seed, 0);
const flakyPort = await allocateFreePort();
const loopback = `http://127.0.0.1:${flakyPort}`;
const proxy = await startFaultProxy({ webUrl: loopback, apiUrl: loopback }, { place });
const flakyMock = await startMockMcp({ port: flakyPort, issuer: proxy.ref.webUrl });
const flaky = await seed.orgConnection(healthy.den.admin, {
name: `Capability Search Flaky ${Date.now()}`,
url: `${proxy.ref.webUrl}/mcp`,
authType: "oauth",
credentialMode: "shared",
access: { orgWide: true },
});
return withDispose({ ...healthy, proxy, flakyMock, flaky }, async () => {
await flakyMock.stop();
await proxy[Symbol.asyncDispose]();
});
}
export async function mockToolsListCount(mock: MockHandle): Promise<number> {
const requests = await mock.requests();
return requests.filter((request) => {
const methods = Reflect.get(request, "rpcMethods");
return Array.isArray(methods) && methods.includes("tools/list");
}).length;
}
export async function pluginEditorWithConnector(seed: Seed) {
const stamp = Date.now();
const den = await seed.den({
org: { name: `Plugin from connector ${stamp}`, admin: { name: "Plugin Admin" } },
mocks: { crm: seed.mock({ allowUnauthenticatedMcp: true }) },
});
const connection = await seed.orgConnection(den.admin, {
name: `CRM connector ${stamp}`,
url: den.mocks.crm.mcpUrl,
authType: "none",
credentialMode: "shared",
access: { orgWide: true },
});
const marketplaceName = `Sales collection ${stamp}`;
const createdMarketplace = await seed.api(den.admin, "/v1/marketplaces", {
method: "POST",
body: JSON.stringify({ name: marketplaceName }),
});
const marketplaceId = stringField(isRecord(createdMarketplace.body) ? createdMarketplace.body.item : null, "id");
if (createdMarketplace.response.status !== 201 || !marketplaceId) {
throw new Error(`Creating the collection failed: HTTP ${createdMarketplace.response.status} ${createdMarketplace.text.slice(0, 500)}`);
}
const web = await seed.web({
den,
signedInAs: den.admin,
startPath: `/dashboard/plugins/new?marketplaceId=${marketplaceId}`,
headless: true,
viewport: { width: 1440, height: 1100 },
});
return {
den,
web,
connection,
marketplaceId,
marketplaceName,
pluginName: `Sales CRM ${stamp}`,
};
}
export async function libraryView(seed: Seed) {
const password = process.env.OMNIRUSH_EVAL_DEMO_PASSWORD?.trim() || "OmniRushDemo123!";
const caseyEmail = process.env.OMNIRUSH_EVAL_CREATOR_EMAIL?.trim() || "[email protected]";
const novaEmail = process.env.OMNIRUSH_EVAL_MEMBER_EMAIL?.trim() || "[email protected]";
const den = await seed.den({
reuseMembers: {
casey: { email: caseyEmail, password, name: "Casey Spec" },
nova: { email: novaEmail, password, name: "Nova Spec" },
},
mocks: {
connector: seed.mock({ publicUrl: process.env.OMNIRUSH_EVAL_LIBRARY_MOCK_PUBLIC_URL?.trim() || undefined }),
},
});
const organizationId = await activeOrganizationId(seed, den.admin);
const stamp = Date.now();
const connection = await seed.orgConnection(den.admin, {
name: `Library Spec Linear ${stamp}`,
url: den.mocks.connector.mcpUrl,
authType: "oauth",
credentialMode: "per_member",
access: { orgWide: true },
});
const pluginName = `AAA Spec Library Plugin ${stamp}`;
const skillName = `spec-library-${stamp}`;
const rawSourceText = `---\nname: ${skillName}\ndescription: Proves the member library view.\n---\n\nReturn the library proof phrase.`;
const createdPlugin = await seed.api(den.members.casey, "/v1/plugins", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({
name: pluginName,
sourceRepositoryUrl: "https://github.com/anthropics/knowledge-work-plugins",
components: [{ type: "skill", input: { rawSourceText } }],
}),
});
const pluginId = stringField(isRecord(createdPlugin.body) ? createdPlugin.body.item : null, "id");
if (!pluginId) throw new Error("Could not create the Library view plugin.");
const org = await seed.api(den.admin, "/v1/org", { headers: { "x-omnirush-org-id": organizationId } });
const novaMember = isRecord(org.body)
? records(org.body.members).find((member) => isRecord(member.user) && member.user.email === novaEmail)
: undefined;
const novaMemberId = novaMember && typeof novaMember.id === "string" ? novaMember.id : "";
if (!novaMemberId) throw new Error("Could not resolve Nova's organization membership.");
const teamName = `Spec Library Provenance Team ${stamp}`;
const createdTeam = await seed.api(den.admin, "/v1/teams", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({ name: teamName }),
});
const teamId = stringField(isRecord(createdTeam.body) ? createdTeam.body.team : null, "id");
if (!teamId) throw new Error("Could not create the Library provenance team.");
await seed.api(den.admin, `/v1/teams/${encodeURIComponent(teamId)}`, {
method: "PATCH",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({ memberIds: [novaMemberId] }),
});
for (const body of [{ orgMembershipId: novaMemberId, role: "viewer" }, { teamId, role: "viewer" }]) {
await seed.api(den.members.casey, `/v1/plugins/${encodeURIComponent(pluginId)}/access`, {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify(body),
});
}
const web = await seed.web({
den,
signedInAs: den.members.nova,
startPath: "/dashboard/library",
headless: true,
viewport: { width: 1280, height: 900 },
});
return withDispose({
web,
casey: den.members.casey,
nova: den.members.nova,
organizationId,
pluginId,
pluginName,
connection,
teamName,
}, async () => {
const headers = {
authorization: `Bearer ${den.members.casey.token}`,
"x-omnirush-org-id": organizationId,
};
await denFetch(den.members.casey, `/v1/plugins/${encodeURIComponent(pluginId)}/archive`, { method: "POST", headers }).catch(() => undefined);
await denFetch(den.admin, `/v1/teams/${encodeURIComponent(teamId)}`, { method: "DELETE", headers: { ...headers, authorization: `Bearer ${den.admin.token}` } }).catch(() => undefined);
await denFetch(den.admin, `/v1/mcp-connections/${encodeURIComponent(connection.id)}`, { method: "DELETE", headers: { authorization: `Bearer ${den.admin.token}` } }).catch(() => undefined);
});
}
async function listen(server: Server): Promise<string> {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (!address || typeof address === "string") throw new Error("The fixture did not bind a TCP port.");
return `http://127.0.0.1:${address.port}`;
}
async function configureWorkspaceModel(seed: Seed, input: {
app: import("@omnirush/cdp").Surface;
workspaceId: string;
providerId: string;
modelId: string;
fixtureUrl: string;
denApiUrl?: string;
mcpToken?: string;
appHostToken?: string;
directMcp?: { name: string; url: string };
}): Promise<void> {
// TODO(primitive): seed.workspaceRuntimeConfig
const result = await rawEvalIn(input.app, browserScript(async (inputWorkspaceId, providerId, value, modelId, inputValue, inputValue2, inputProviderId, inputModelId, inputValue3) => {
const port = localStorage.getItem("omnirush.server.port");
const token = localStorage.getItem("omnirush.server.token");
if (!port || !token) return "missing local server credentials";
const request = async (path: string, init?: RequestInit) => {
const response = await fetch("http://127.0.0.1:" + port + path, {
...init,
headers: { Authorization: "Bearer " + token, "Content-Type": "application/json" },
});
if (!response.ok) return path + " failed: " + response.status + " " + (await response.text()).slice(0, 500);
return "ok";
};
const workspaceId = inputWorkspaceId;
const patched = await request("/workspace/" + encodeURIComponent(workspaceId) + "/config", {
method: "PATCH",
body: JSON.stringify({ opencode: {
provider: {
[providerId]: {
npm: "@ai-sdk/openai-compatible",
name: "E2E MCP App model",
options: { baseURL: value, apiKey: "sk-e2e-fixture" },
models: { [modelId]: { name: "E2E MCP App model", tool_call: true } },
},
},
mcp: inputValue,
} }),
});
if (patched !== "ok") return patched;
const reloaded = await request("/workspace/" + encodeURIComponent(workspaceId) + "/engine/reload", { method: "POST" });
if (reloaded !== "ok" && !reloaded.includes("opencode_reload_timeout")) return reloaded;
if (inputValue2) {
const reconcile = await request("/workspace/" + encodeURIComponent(workspaceId) + "/mcp/omnirush-cloud/reconcile", {
method: "POST", body: JSON.stringify(inputValue2),
});
if (reconcile !== "ok") return reconcile;
}
const raw = localStorage.getItem("omnirush.preferences");
let preferences: Record<string, unknown> = {};
try { preferences = raw ? JSON.parse(raw) : {}; } catch {}
if (!preferences || typeof preferences !== "object" || Array.isArray(preferences)) preferences = {};
localStorage.setItem("omnirush.preferences", JSON.stringify({
...preferences,
defaultModel: { providerID: inputProviderId, modelID: inputModelId },
modelVariant: null,
providerStepCompleted: true,
}));
localStorage.setItem("omnirush.defaultModel", inputValue3);
localStorage.removeItem("omnirush.sessionModels." + workspaceId);
return "ok";
}, [input.workspaceId, input.providerId, `${input.fixtureUrl}/v1`, input.modelId, input.directMcp ? {
[input.directMcp.name]: { type: "remote", url: input.directMcp.url, enabled: true, oauth: false },
} : {}, input.denApiUrl && input.mcpToken ? {
config: {
type: "remote", url: `${input.denApiUrl}/mcp/agent`, enabled: true,
headers: { Authorization: `Bearer ${input.mcpToken}` }, oauth: false,
},
appHostAuthorization: input.appHostToken ? `Bearer ${input.appHostToken}` : undefined,
provider: input.providerId, model: input.modelId, trigger: "spec-primitives-migration",
} : null, input.providerId, input.modelId, `${input.providerId}/${input.modelId}`]), { awaitPromise: true, timeoutMs: 120_000 });
if (result !== "ok") throw new Error(`Configuring the fixture model failed: ${String(result)}`);
}
async function reloadConfiguredApp(app: import("@omnirush/cdp").Surface): Promise<void> {
// TODO(primitive): seed.reloadConfiguredDesktop
await rawEvalIn(app, () => { location.reload(); return true; }).catch(() => undefined);
const deadline = Date.now() + 60_000;
while (Date.now() < deadline) {
if (await rawEvalIn(app, () => (Boolean(window.__omnirushControl))).catch(() => false) === true) return;
await new Promise((resolve) => setTimeout(resolve, 250));
}
throw new Error("The configured desktop control did not return after reload.");
}
export const connectionActionReply = "Connect your Notion account to continue.";
export const ordinaryDiscoveryPrompt = "Create a dashboard using my notes.";
export const ordinaryDiscoveryReply = "I found the available capabilities for the dashboard.";
export const connectionActionPrompt = "I want to connect Notion.";
export const connectionStatusPrompt = "Check my Notion connection so I can sign in.";
export const allConnectorsPrompt = "Show me all the quick-add connectors.";
export const allConnectorsReply = "Here are all the connectors available to add.";
export const connectorCatalogPrompt = "I want to set up Slack.";
export const connectorCatalogReply = "Choose Slack to set it up, or browse the available connectors.";
export async function connectionActionMcpApp(seed: Seed) {
const providerId = "connection-action-mcp-app-provider";
const modelId = "connection-action-mcp-app-model";
const den = await seed.den({
org: { name: `Connection Action ${Date.now()}`, admin: { name: "Connection Admin" } },
mocks: {
connector: seed.mock({ agentWorkloads: [{
promptMarker: ordinaryDiscoveryPrompt,
latestUserTurn: true,
finalReply: ordinaryDiscoveryReply,
steps: [{ tool: "search_capabilities", arguments: { query: "Notion", type: "mcp" } }],
}, {
promptMarker: connectionActionPrompt,
latestUserTurn: true,
finalReply: connectionActionReply,
steps: [{ tool: "search_capabilities", arguments: { query: "Notion", type: "mcp", intent: "connect" } }],
}, {
promptMarker: connectionStatusPrompt,
latestUserTurn: true,
finalReply: connectionActionReply,
steps: [
{ tool: "search_capabilities", arguments: { query: "Notion", type: "mcp", limit: 1 } },
{ tool: "execute_capability", arguments: {}, argumentsFrom: "capability-search" },
],
}, {
promptMarker: connectorCatalogPrompt,
finalReply: connectorCatalogReply,
steps: [{ tool: "search_capabilities", arguments: { query: "Slack", type: "mcp", intent: "connect" } }],
}, {
promptMarker: allConnectorsPrompt,
finalReply: allConnectorsReply,
steps: [{ tool: "search_capabilities", arguments: { query: "quick add connectors", type: "connectors" } }],
}] }),
},
});
const organizationId = await activeOrganizationId(seed, den.admin);
const connection = await seed.orgConnection(den.admin, {
name: "Notion",
url: den.mocks.connector.mcpUrl,
authType: "oauth",
credentialMode: "per_member",
access: { orgWide: true },
});
const tokenResult = await seed.api(den.admin, "/v1/mcp/token", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({ scopes: ["mcp:read", "mcp:write"] }),
});
const mcpToken = stringField(tokenResult.body, "token");
const appHostToken = stringField(tokenResult.body, "appHostToken");
if (!mcpToken || !appHostToken || mcpToken === appHostToken) throw new Error("Distinct model and app-host tokens were not minted.");
const app = await seed.desktop({ den, as: "admin", name: "connection-action-mcp-app" });
const workspace = await seed.workspace(app, seed.tmpPath("connection-action-mcp-app"));
await configureWorkspaceModel(seed, {
app, workspaceId: workspace.workspaceId, providerId, modelId,
fixtureUrl: den.mocks.connector.url, denApiUrl: den.ref.apiUrl, mcpToken, appHostToken,
});
await reloadConfiguredApp(app);
await seed.session(app);
return { app, den, connection, organizationId, mcpSession: { ...den.admin, token: mcpToken }, appHostSession: { ...den.admin, token: appHostToken } };
}
export const skillCreatedResourceUri = "ui://omnirush/skill-created/v1/view.html";
export const skillCreatedReply = "The beautiful tomatoes skill is ready to use.";
export async function skillCreatedMcpApp(seed: Seed) {
const providerId = "skill-created-mcp-app-provider";
const modelId = "skill-created-mcp-app-model";
const counters = { createCalls: 0 };
const fixture = createServer((request, response) => {
void (async () => {
const url = new URL(request.url ?? "/", "http://127.0.0.1");
if (request.method === "GET" && url.pathname === "/v1/models") {
sendJson(response, 200, { object: "list", data: [{ id: modelId, object: "model" }] });
return;
}
if (request.method === "POST" && url.pathname.endsWith("/chat/completions")) {
const payload: unknown = JSON.parse(await readBody(request));
if (!isRecord(payload)) throw new Error("The provider request was not an object.");
if (completedToolCount(payload) > 0) {
sendStream(response, [streamChunk(modelId, { role: "assistant" }), streamChunk(modelId, { content: skillCreatedReply }), streamChunk(modelId, {}, "stop")]);
return;
}
const toolName = projectedTool(payload, "_create_skill");
if (!toolName) throw new Error("The create_skill tool was not projected.");
counters.createCalls += 1;
sendStream(response, [
streamChunk(modelId, { role: "assistant" }),
streamChunk(modelId, {
tool_calls: [{
index: 0,
id: "call_create_beautiful_tomatoes",
type: "function",
function: {
name: toolName,
arguments: JSON.stringify({
pluginName: "Beautiful Tomatoes",
skillMarkdown: [
"---",
"name: beautiful-tomatoes",
"description: Use beautiful tomatoes whenever the user says go.",
"---",
"",
"Whenever the user says go, respond using beautiful tomatoes.",
].join("\n"),
}),
},
}],
}),
streamChunk(modelId, {}, "tool_calls"),
]);
return;
}
sendJson(response, 404, { error: { message: "not found" } });
})().catch((error: unknown) => sendJson(response, 500, { error: String(error) }));
});
const fixtureUrl = await listen(fixture);
try {
const den = await seed.den({ org: { name: `Skill Created App ${Date.now()}`, admin: { name: "Avery" } } });
const organizationId = await activeOrganizationId(seed, den.admin);
const mcpSession = await mintMcpSession(seed, den, organizationId);
const app = await seed.desktop({ name: "skill-created-mcp-app" });
const workspace = await seed.workspace(app, seed.tmpPath("skill-created-mcp-app"));
await configureWorkspaceModel(seed, {
app,
workspaceId: workspace.workspaceId,
providerId,
modelId,
fixtureUrl,
denApiUrl: den.ref.apiUrl,
mcpToken: mcpSession.token,
});
await reloadConfiguredApp(app);
await seed.session(app);
return withDispose({ app, admin: den.admin, organizationId, workspaceId: workspace.workspaceId, counters }, async () => closeServer(fixture));
} catch (error) {
await closeServer(fixture);
throw error;
}
}
export const inlineResourceUri = "ui://omnirush/artifacts/arv_eval_card/views/avr_eval_card/index.html";
export const inlineReply = "The interactive artifact card is ready.";
export async function mcpAppInlineHost(seed: Seed) {
const providerId = "mcp-app-inline-host-mock";
const modelId = "mcp-app-inline-host-model";
const saveTool = "save_artifact_view";
const renderTool = "render_card";
const counters = { saveCalls: 0, renderCalls: 0, resourceReads: 0 };
const builder = await import("../../ee/apps/den-api/src/generated-artifact-view-builder.js");
const built = await builder.buildGeneratedArtifactViewInWorker({
reactSource: `export default function GeneratedArtifact({ data }) { return <article><h2>{data.title}</h2><p>{data.status}</p></article> }`,
cssSource: "body{margin:0;padding:18px;color:#172554;background:#eff6ff;font-family:system-ui,sans-serif}article{border:1px solid #93c5fd;border-radius:14px;padding:18px;background:white}",
outputSchema: { type: "object", properties: { title: { type: "string" }, status: { type: "string" } }, required: ["title", "status"] },
title: "Quarterly plan",
description: "Generated Artifact host acceptance fixture.",
});
if (!built.ok) throw new Error(`Generated Artifact build failed: ${JSON.stringify(built.diagnostics)}`);
const rpc = (message: Record<string, unknown>): Record<string, unknown> => {
if (message.method === "initialize") return {
jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2025-06-18", capabilities: { tools: {}, resources: {} }, serverInfo: { name: "inline-host", version: "1" } },
};
if (message.method === "tools/list") return {
jsonrpc: "2.0", id: message.id, result: { tools: [
{ name: saveTool, description: "Save artifact view", inputSchema: { type: "object", additionalProperties: false } },
{ name: renderTool, description: "Render artifact card", inputSchema: { type: "object", additionalProperties: false }, _meta: { ui: { resourceUri: inlineResourceUri } } },
] },
};
if (message.method === "resources/read") {
counters.resourceReads += 1;
return { jsonrpc: "2.0", id: message.id, result: { contents: [{
uri: inlineResourceUri,
mimeType: "text/html;profile=mcp-app",
blob: Buffer.from(built.html, "utf8").toString("base64"),
_meta: { ui: { prefersBorder: true, csp: { connectDomains: [], resourceDomains: [], frameDomains: [], baseUriDomains: [] } } },
}] } };
}
if (message.method === "tools/call") {
const params = isRecord(message.params) ? message.params : {};
if (params.name === saveTool) {
counters.saveCalls += 1;
return { jsonrpc: "2.0", id: message.id, result: { content: [{ type: "text", text: "Saved immutable Artifact view." }] } };
}
counters.renderCalls += 1;
return { jsonrpc: "2.0", id: message.id, result: {
content: [{ type: "text", text: "Quarterly plan: Ready" }],
structuredContent: { schemaVersion: "1", artifact: { title: "Quarterly plan" }, data: { title: "Quarterly plan", status: "Ready" } },
} };
}
return { jsonrpc: "2.0", id: message.id, result: {} };
};
const fixture = createServer((request, response) => {
void (async () => {
const url = new URL(request.url ?? "/", "http://127.0.0.1");
if (request.method === "GET" && url.pathname === "/v1/models") {
sendJson(response, 200, { object: "list", data: [{ id: modelId, object: "model" }] });
return;
}
if (url.pathname === "/mcp" && request.method === "POST") {
const parsed: unknown = JSON.parse(await readBody(request));
const messages = Array.isArray(parsed) ? parsed : [parsed];
const replies = messages.filter(isRecord).filter((message) => message.id !== undefined).map(rpc);
sendJson(response, 200, Array.isArray(parsed) ? replies : replies[0]);
return;
}
if (request.method === "POST" && url.pathname.endsWith("/chat/completions")) {
const payload: unknown = JSON.parse(await readBody(request));
if (!isRecord(payload)) throw new Error("The provider request was not an object.");
const completed = completedToolCount(payload);
if (completed >= 2) {
sendStream(response, [streamChunk(modelId, { role: "assistant" }), streamChunk(modelId, { content: inlineReply }), streamChunk(modelId, {}, "stop")]);
return;
}
const next = completed === 0 ? saveTool : renderTool;
const toolName = projectedTool(payload, next);
if (!toolName) throw new Error("The inline MCP tool was not projected.");
sendStream(response, [
streamChunk(modelId, { role: "assistant" }),
streamChunk(modelId, { tool_calls: [{ index: 0, id: `call_${next}`, type: "function", function: { name: toolName, arguments: "{}" } }] }),
streamChunk(modelId, {}, "tool_calls"),
]);
return;
}
sendJson(response, 404, { error: "not_found" });
})().catch((error: unknown) => sendJson(response, 500, { error: String(error) }));
});
const fixtureUrl = await listen(fixture);
try {
const app = await seed.desktop({ name: "mcp-app-inline-host" });
const workspace = await seed.workspace(app, seed.tmpPath("mcp-app-inline-host"));
await configureWorkspaceModel(seed, {
app,
workspaceId: workspace.workspaceId,
providerId,
modelId,
fixtureUrl,
directMcp: { name: "artifact-view", url: `${fixtureUrl}/mcp` },
});
await reloadConfiguredApp(app);
await seed.session(app);
return withDispose({ app, counters }, async () => closeServer(fixture));
} catch (error) {
await closeServer(fixture);
throw error;
}
}
export const remoteResourceUri = "ui://project-atlas/view.html";
export const remoteReply = "Project Atlas is open through its standard MCP server.";
export function rpcBody(id: number, method: string, params: Record<string, unknown>): string {
return JSON.stringify({ jsonrpc: "2.0", id, method, params });
}
export async function remoteMcpApps(seed: Seed) {
const providerId = "remote-mcp-apps-provider";
const modelId = "remote-mcp-apps-model";
const counters = { standardMcpCalls: 0 };
const state = { gatewayCapabilityName: "" };
const builder = await import("../../ee/apps/den-api/src/generated-artifact-view-builder.js");
const built = await builder.buildGeneratedArtifactViewInWorker({
reactSource: `export default function ProjectAtlas(props) { const app = props.data || { name: "Project Atlas", status: "Connected through OmniRush.ai Connect" }; return <main><h1>{app.name}</h1><p>{app.status}</p></main> }`,
cssSource: "body{margin:0;padding:18px;color:#172033;background:#f5f7fb;font-family:system-ui,sans-serif}main{padding:22px;border:1px solid #dbe4f0;border-radius:16px;background:white}",
outputSchema: { type: "object", additionalProperties: true },
title: "Project Atlas",
description: "A portable Remote MCP App acceptance fixture.",
});
if (!built.ok) throw new Error(`Project Atlas build failed: ${JSON.stringify(built.diagnostics)}`);
const standardRpc = (message: Record<string, unknown>): Record<string, unknown> => {
if (message.method === "initialize") return {
jsonrpc: "2.0",
id: message.id,
result: {
protocolVersion: "2025-06-18",
capabilities: { tools: { listChanged: false }, resources: { listChanged: false }, extensions: { "io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app"] } } },
serverInfo: { name: "project-atlas-connect-fixture", title: "Project Atlas Connect", version: "1.0.0", description: "A standard MCP App fixture served through OmniRush.ai Connect." },
},
};
if (message.method === "tools/list") return {
jsonrpc: "2.0",
id: message.id,
result: { tools: [
{
name: "open_project_atlas",
title: "Open Project Atlas",
description: "Open the Project Atlas MCP App.",
inputSchema: { type: "object", additionalProperties: false },
annotations: { readOnlyHint: true, destructiveHint: false },
_meta: { ui: { resourceUri: remoteResourceUri } },
},
{
name: "search_projects",
title: "Search projects",
description: "Search the connected project catalog.",
inputSchema: { type: "object", properties: { query: { type: "string" } }, additionalProperties: false },
annotations: { readOnlyHint: true, destructiveHint: false },
_meta: { ui: { visibility: ["app"] } },
},
] },
};
if (message.method === "resources/list") return { jsonrpc: "2.0", id: message.id, result: { resources: [] } };
if (message.method === "resources/templates/list") return { jsonrpc: "2.0", id: message.id, result: { resourceTemplates: [] } };
if (message.method === "resources/read") return {
jsonrpc: "2.0",
id: message.id,
result: { contents: [{
uri: remoteResourceUri,
mimeType: "text/html;profile=mcp-app",
text: built.html.replace("</body>", "<!-- Portable revision Connect 1.0.0 --></body>"),
_meta: { ui: { csp: { connectDomains: [], resourceDomains: [] }, prefersBorder: true } },
}] },
};
if (message.method === "tools/call") {
counters.standardMcpCalls += 1;
const params = isRecord(message.params) ? message.params : {};
if (params.name === "open_project_atlas") return {
jsonrpc: "2.0",
id: message.id,
result: {
content: [{ type: "text", text: "Project Atlas opened." }],
structuredContent: {
schemaVersion: "1",
artifact: { title: "Project Atlas", description: "A standard MCP App served through OmniRush.ai Connect." },
data: { name: "Project Atlas", status: "Connected through OmniRush.ai Connect" },
},
_meta: { source: "project-atlas-standard-mcp" },
},
};
return {
jsonrpc: "2.0",
id: message.id,
result: { content: [{ type: "text", text: "Atlas project result" }], structuredContent: { projects: [{ id: "project-atlas", name: "Atlas migration", status: "on_track" }] } },
};
}
return { jsonrpc: "2.0", id: message.id, result: {} };
};
const fixture = createServer((request, response) => {
void (async () => {
const url = new URL(request.url ?? "/", "http://127.0.0.1");
if (request.method === "GET" && url.pathname === "/v1/models") {
sendJson(response, 200, { object: "list", data: [{ id: modelId, object: "model" }] });
return;
}
if (url.pathname === "/mcp" && request.method === "POST") {
const parsed: unknown = JSON.parse(await readBody(request));
const messages = Array.isArray(parsed) ? parsed : [parsed];
const replies = messages.filter(isRecord).filter((message) => message.id !== undefined).map(standardRpc);
sendJson(response, 200, Array.isArray(parsed) ? replies : replies[0]);
return;
}
if (request.method === "POST" && url.pathname.endsWith("/chat/completions")) {
const payload: unknown = JSON.parse(await readBody(request));
if (!isRecord(payload)) throw new Error("The provider request was not an object.");
const leaked = records(payload.tools).some((tool) => isRecord(tool.function)
&& typeof tool.function.name === "string"
&& (tool.function.name.includes("open_project_atlas") || tool.function.name.includes("search_projects")));
if (leaked) throw new Error("Provider MCP tools leaked into the model tool list.");
const completed = completedToolCount(payload);
if (completed > 1) {
sendStream(response, [streamChunk(modelId, { role: "assistant" }), streamChunk(modelId, { content: remoteReply }), streamChunk(modelId, {}, "stop")]);
return;
}
const toolName = projectedTool(payload, completed === 0 ? "_search_capabilities" : "_execute_capability");
if (!toolName) throw new Error("The capability gateway tools were not projected.");
sendStream(response, [
streamChunk(modelId, { role: "assistant" }),
streamChunk(modelId, { tool_calls: [{
index: 0,
id: `call_atlas_${completed}`,
type: "function",
function: {
name: toolName,
arguments: completed === 0
? JSON.stringify({ query: "open Project Atlas", type: "mcp", limit: 5 })
: JSON.stringify({ name: state.gatewayCapabilityName, body: {} }),
},
}] }),
streamChunk(modelId, {}, "tool_calls"),
]);
return;
}
sendJson(response, 404, { error: "not_found" });
})().catch((error: unknown) => sendJson(response, 500, { error: String(error) }));
});
const fixtureUrl = await listen(fixture);
const profileDir = `/tmp/omnirush-remote-mcp-apps-profile-${Date.now()}`;
try {
const den = await seed.den({ org: { name: `Remote MCP Apps ${Date.now()}`, admin: { name: "Avery" } } });
const organizationId = await activeOrganizationId(seed, den.admin);
const initialConnection = await seed.orgConnection(den.admin, {
name: "Atlas read-only projects",
url: `${fixtureUrl}/mcp`,
authType: "none",
credentialMode: "shared",
access: { orgWide: true },
});
const tokenResult = await seed.api(den.admin, "/v1/mcp/token", {
method: "POST",
headers: { "x-omnirush-org-id": organizationId },
body: JSON.stringify({ scopes: ["mcp:read", "mcp:write"] }),
});
const mcpToken = stringField(tokenResult.body, "token");
const appHostToken = stringField(tokenResult.body, "appHostToken");
if (!mcpToken || !appHostToken || mcpToken === appHostToken) throw new Error("Den did not mint distinct model and App-host tokens.");
const app = await seed.desktop({ name: "remote-mcp-apps", profileDir });
const workspace = await seed.workspace(app, seed.tmpPath("remote-mcp-apps"));
await configureWorkspaceModel(seed, {
app,
workspaceId: workspace.workspaceId,
providerId,
modelId,
fixtureUrl,
denApiUrl: den.ref.apiUrl,
mcpToken,
appHostToken,
});
await reloadConfiguredApp(app);
const lateConnection = await seed.orgConnection(den.admin, {
name: "Atlas added after Desktop reconcile",
url: `${fixtureUrl}/mcp`,
authType: "none",
credentialMode: "shared",
access: { orgWide: true },
});
state.gatewayCapabilityName = `mcp:${lateConnection.id}:open_project_atlas`;
await seed.session(app);
const web = await seed.web({ den, signedInAs: den.admin, startPath: "/dashboard/library", headless: true });
return withDispose({
app,
web,
den,
organizationId,
initialConnection,
lateConnection,
mcpSession: { ...den.admin, token: mcpToken },
appHostSession: { ...den.admin, token: appHostToken },
workspaceId: workspace.workspaceId,
profileDir,
counters,
}, async () => {
await closeServer(fixture);
await rm(profileDir, { recursive: true, force: true });
});
} catch (error) {
await closeServer(fixture);
await rm(profileDir, { recursive: true, force: true });
throw error;
}
}
export async function connectorCatalogDiscovery(seed: Seed) {
const world = await connectionActionMcpApp(seed);
if (world.app.handle.hostKind !== "daytona") throw new SkipError("connector setup OS handoff witness requires Daytona Linux");
const response = await seed.api(world.den.admin, "/v1/mcp-connections/presets");
if (!isRecord(response.body) || !Array.isArray(response.body.presets)) throw new Error("Den did not return its connector presets.");
const presetIds = response.body.presets.map((preset: unknown) => {
if (!isRecord(preset) || typeof preset.presetId !== "string") throw new Error("Invalid connector preset.");
return preset.presetId;
});
const web = await seed.web({ den: world.den, signedInAs: world.den.admin, startPath: "/dashboard/mcp-connections", headless: true });
const browserUrls = await captureExternalBrowserUrls(world.app.handle);
return withDispose({ ...world, web, browserUrls, expectedIds: ["google-workspace", "microsoft-365", ...presetIds] }, async () => { await browserUrls[Symbol.asyncDispose](); });
}