Files
openworker/harness/task-desk/server.mjs
Rohit PrasadandDevika Verma d53e058eda Introduce OpenWorker Harness SDK (in beta), agent service cluster and relevant developer documentation (#844)
Allow developers to easily build AI apps without worrying about the harness part.
Bundles the Rust agent runtime as a SDK (Rust and TypeScript) for building desktop and web applications. Applications can manage a local harness or connect to an authenticated harness service on k8s with separately scaled workers and sandbox execution.

The implementation is primarily contained in harness/, with deployment tooling in deploy/, Markdown guides in docs/harness/guides/, and the static documentation site in docs-site/. It does not replace the existing Python harness or migrate OpenWorker Desktop.

Co-authored-by: Devika Verma <devikaverma11@gmail.com>
2026-11-06 09:45:20 -08:00

398 lines
13 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// A single-operator application boundary. All execution remains in OpenWorker.
import http from "node:http";
import { readFile } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import { randomBytes, timingSafeEqual, createHash } from "node:crypto";
import { Readable } from "node:stream";
import { pipeline } from "node:stream/promises";
const id = "[A-Za-z0-9_-]{1,80}";
const eq = (a, b) =>
typeof a === "string" &&
Buffer.byteLength(a) === Buffer.byteLength(b) &&
timingSafeEqual(Buffer.from(a), Buffer.from(b));
const textOf = (v) =>
typeof v === "string"
? v
: Array.isArray(v)
? v.map((x) => x.text || "").join("\n")
: "";
export function allowed(method, path) {
if (
typeof path !== "string" ||
!/^\/[A-Za-z0-9_/?=&-]*$/.test(path) ||
path.startsWith("//")
)
return false;
const u = new URL(path, "http://local");
if (u.pathname + u.search !== path) return false;
const p = u.pathname;
if (method === "GET") {
if (p === "/sessions")
return [...u.searchParams].every(([k, v]) =>
k === "limit"
? /^\d{1,3}$/.test(v) && +v > 0 && +v <= 100
: k === "after" && new RegExp(`^${id}$`).test(v),
);
if (new RegExp(`^/sessions/${id}/events$`).test(p))
return [...u.searchParams].every(
([k, v]) => k === "after" && /^\d{1,16}$/.test(v),
);
return (
!u.search &&
new RegExp(
`^/sessions/${id}(/(turns/${id}|controls/${id}|artifacts(/${id}(/content)?)?))?$`,
).test(p)
);
}
return (
method === "POST" &&
!u.search &&
(p === "/sessions" ||
new RegExp(`^/sessions/${id}/(turns|controls|result)$`).test(p))
);
}
function apiOrigin(value) {
const u = new URL(value);
if (
(u.protocol !== "https:" &&
!(
u.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(u.hostname)
)) ||
u.username ||
u.password ||
u.pathname !== "/" ||
u.search ||
u.hash
)
throw Error(
"Use an explicit HTTPS API origin (HTTP allowed only on loopback)",
);
return u.origin;
}
async function body(req, limit = 140000) {
let size = 0;
const chunks = [];
for await (const chunk of req) {
size += chunk.length;
if (size > limit) throw Error("body_limit");
chunks.push(chunk);
}
return JSON.parse(Buffer.concat(chunks).toString() || "{}");
}
export async function start(config) {
const apis = config.apis.map(apiOrigin);
if (!apis.length || apis.length > 4) throw Error("Configure 1–4 APIs");
const token = (await readFile(config.api_token_file, "utf8")).trim();
const access = (await readFile(config.access_key_file, "utf8")).trim();
if (
![token, access].every((v) => /^[A-Za-z0-9_.-]{32,256}$/.test(v)) ||
eq(token, access)
)
throw Error("Distinct application and API keys required");
for (const k of ["environment_id", "coworker"])
if (!new RegExp(`^${id}$`).test(config[k])) throw Error("Invalid " + k);
if (typeof config.workspace !== "string" || !config.workspace.startsWith("/"))
throw Error("Configure workspace");
const upstream = async (path, method = "GET", payload, signal) => {
const headers = { Authorization: `Bearer ${token}` };
if (payload !== undefined)
headers["Content-Type"] = Buffer.isBuffer(payload)
? "application/octet-stream"
: "application/json";
let last;
for (const base of apis) {
try {
const r = await fetch(base + path, {
method,
headers,
redirect: "error",
body:
payload === undefined
? undefined
: Buffer.isBuffer(payload)
? payload
: JSON.stringify(payload),
signal: signal || AbortSignal.timeout(20000),
});
if (method === "GET" && r.status >= 500) {
await r.body?.cancel();
last = Error("upstream_unavailable");
continue;
}
return r;
} catch (e) {
last = e;
if (method !== "GET" || signal?.aborted) break;
}
}
throw last || Error("upstream_unavailable");
};
// Fail closed: this app must never run with an administrator or broad key.
const who = await upstream("/auth/me");
const principal = await who.json();
if (
!who.ok ||
principal.role !== "operator" ||
principal.scope?.kind !== "owned" ||
!principal.environments?.includes(config.environment_id)
)
throw Error(
"Task Desk requires an owned-scope operator with the configured environment grant",
);
const assets = new Map(
await Promise.all(
[
["/", "index.html", "text/html"],
["/app.js", "app.js", "text/javascript"],
["/style.css", "style.css", "text/css"],
].map(async ([p, f, type]) => [
p,
{
type,
bytes: await readFile(new URL("public/" + f, import.meta.url)),
},
]),
),
);
const sessions = new Map();
let attempts = [],
active = 0,
own;
const server = http.createServer(async (req, res) => {
res.setHeader("Cache-Control", "no-store");
res.setHeader("X-Content-Type-Options", "nosniff");
res.setHeader("Referrer-Policy", "no-referrer");
res.setHeader(
"Content-Security-Policy",
"default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'",
);
const send = (status, value) => {
if (res.headersSent) return res.destroy();
res.writeHead(status, { "Content-Type": "application/json" });
res.end(JSON.stringify(value));
};
if (
req.headers.host !== new URL(own).host ||
(req.headers.origin && req.headers.origin !== own) ||
["cross-site", "same-site"].includes(req.headers["sec-fetch-site"])
)
return send(403, { error: "origin_denied" });
if (req.method === "GET" && assets.has(req.url)) {
const a = assets.get(req.url);
res.writeHead(200, { "Content-Type": a.type });
return res.end(a.bytes);
}
if (
req.method !== "GET" &&
(req.headers.origin !== own ||
req.headers["content-type"] !== "application/json")
)
return send(403, { error: "origin_required" });
if (req.url === "/login" && req.method === "POST") {
attempts = attempts.filter((t) => Date.now() - t < 60000);
if (attempts.length >= 10) return send(429, { error: "try_later" });
attempts.push(Date.now());
try {
if (!eq((await body(req, 1024)).key, access))
return send(401, { error: "invalid_key" });
} catch {
return send(400, { error: "invalid_request" });
}
for (const [k, s] of sessions)
if (s.expiry < Date.now()) {
s.abort.abort();
sessions.delete(k);
}
if (sessions.size >= 16) return send(429, { error: "session_limit" });
const cookie = randomBytes(32).toString("hex");
sessions.set(cookie, {
expiry: Date.now() + 8 * 3600000,
abort: new AbortController(),
});
res.setHeader(
"Set-Cookie",
`ow_taskdesk=${cookie}; HttpOnly; SameSite=Strict; Path=/; Max-Age=28800${own.startsWith("https:") ? "; Secure" : ""}`,
);
return send(200, { ok: true });
}
const cookie = (req.headers.cookie || "")
.split(";")
.map((x) => x.trim())
.find((x) => x.startsWith("ow_taskdesk="))
?.slice(12);
const login = sessions.get(cookie);
if (!login || login.expiry < Date.now()) {
login?.abort.abort();
sessions.delete(cookie);
return send(401, { error: "login_required" });
}
if (req.url === "/logout" && req.method === "POST") {
login.abort.abort();
sessions.delete(cookie);
res.setHeader(
"Set-Cookie",
"ow_taskdesk=; HttpOnly; SameSite=Strict; Path=/; Max-Age=0",
);
return send(200, { ok: true });
}
if (req.url === "/config" && req.method === "GET")
return send(200, {
coworker: config.coworker,
mode: config.mode || "live",
});
const path = req.url?.startsWith("/api/") ? req.url.slice(4) : "";
if (!allowed(req.method, path))
return send(404, { error: "route_unavailable" });
if (active >= 24) return send(429, { error: "connection_limit" });
active++;
const abort = new AbortController();
res.on("close", () => abort.abort());
const stream = path.split("?")[0].endsWith("/events");
const signal = AbortSignal.any([
abort.signal,
login.abort.signal,
AbortSignal.timeout(
Math.min(login.expiry - Date.now(), stream ? 60000 : 25000),
),
]);
try {
let payload;
if (req.method === "POST") payload = await body(req);
if (path === "/sessions" && req.method === "POST") {
if (
Object.keys(payload).some(
(k) => !["request_id", "name"].includes(k),
) ||
!new RegExp(`^${id}$`).test(payload.request_id) ||
typeof payload.name !== "string" ||
!payload.name.trim() ||
payload.name.length > 120
)
return send(400, { error: "invalid_request" });
payload = {
request_id: payload.request_id,
parameters: {
name: payload.name,
coworker: config.coworker,
workspace: config.workspace,
environment_id: config.environment_id,
},
};
}
if (req.method === "POST" && path.endsWith("/result")) {
// Explicit export of the completed assistant response, not arbitrary host files.
// Deterministic IDs make an interrupted publication safely retryable.
const base = path.slice(0, -7),
s = await upstream(base, "GET", undefined, signal);
if (!s.ok) return send(s.status, { error: "snapshot_unavailable" });
const snapshot = await s.json();
if (
snapshot.turn?.status !== "completed" ||
payload.turn_id !== snapshot.turn.id
)
return send(409, { error: "result_not_complete" });
const message = [...snapshot.messages]
.reverse()
.find((m) => m.role === "assistant" && textOf(m.content));
if (!message) return send(409, { error: "no_assistant_result" });
const bytes = Buffer.from(textOf(message.content) + "\n");
if (bytes.length > 1024 * 1024)
return send(413, { error: "result_too_large" });
const digest = createHash("sha256").update(bytes).digest("hex");
const registration = await upstream(
base + "/artifacts",
"POST",
{
request_id: "result-" + snapshot.turn.id,
name: "result.md",
turn_id: snapshot.turn.id,
content_type: "text/markdown",
size: bytes.length,
sha256: digest,
},
signal,
);
if (!registration.ok)
return send(registration.status, {
error: "artifact_registration_failed",
});
const artifact = await registration.json();
if (artifact.status !== "ready") {
const upload = await upstream(
base + `/artifacts/${artifact.id}/content`,
"PUT",
bytes,
signal,
);
if (!upload.ok)
return send(upload.status, { error: "artifact_upload_incomplete" });
await upload.body?.cancel();
}
return send(200, { id: artifact.id });
}
let target = path;
if (stream && req.headers["last-event-id"]) {
if (!/^\d{1,16}$/.test(req.headers["last-event-id"]))
return send(400, { error: "invalid_cursor" });
target = path.split("?")[0] + "?after=" + req.headers["last-event-id"];
}
const r = await upstream(target, req.method, payload, signal);
const headers = {
"Content-Type": r.headers.get("content-type") || "application/json",
};
if (path.endsWith("/content")) {
headers["Content-Type"] = "application/octet-stream";
headers["Content-Disposition"] = 'attachment; filename="result.md"';
}
if (stream) headers["X-Accel-Buffering"] = "no";
res.writeHead(r.status, headers);
if (r.body) await pipeline(Readable.fromWeb(r.body), res);
else res.end();
} catch {
if (!res.destroyed)
send(503, {
error:
req.method === "GET"
? "upstream_unavailable"
: "outcome_unknown_retry_same_request",
});
} finally {
active--;
}
});
const host = config.private_network ? "0.0.0.0" : "127.0.0.1";
await new Promise((resolve, reject) => {
server.once("error", reject);
server.listen(config.port ?? 54350, host, resolve);
});
own = config.origin || `http://127.0.0.1:${server.address().port}`;
const u = new URL(own);
if (
u.origin !== own ||
(u.protocol !== "https:" &&
!(u.protocol === "http:" && u.hostname === "127.0.0.1"))
) {
server.close();
throw Error("App origin must use HTTPS or loopback HTTP");
}
return {
server,
url: own,
close: async () => {
for (const s of sessions.values()) s.abort.abort();
server.closeAllConnections();
await new Promise((r) => server.close(r));
},
};
}
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const app = await start(JSON.parse(await readFile(process.argv[2], "utf8")));
console.log("Task Desk: " + app.url);
for (const s of ["SIGTERM", "SIGINT"])
process.once(s, async () => {
await app.close();
process.exit(0);
});
}