totemlayer 0.1.6 → 0.1.11

package/bin/runtime-installation.mjs

@@ -0,0 +1,305 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { cp, mkdir, lstat, open, readFile, realpath, rename, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { powershellInvocation } from "./platform-client.mjs";
+
+const execute = promisify(execFile);
+const packageRoot = fileURLToPath(new URL("../", import.meta.url));
+export function runtimeRoot(env = process.env) {
+  return resolve(env.TOTEM_CONFIG_DIR ?? join(homedir(), ".totem"));
+}
+export async function privateDirectory(path) {
+  await mkdir(path, { recursive: true, mode: 0o700 });
+  const info = await lstat(path);
+  if (
+    !info.isDirectory() ||
+    info.isSymbolicLink() ||
+    (process.getuid && info.uid !== process.getuid()) ||
+    (process.platform !== "win32" && (info.mode & 0o777) !== 0o700)
+  )
+    throw new Error("The runtime directory must be private and owned by this user.");
+}
+export async function privateRead(path) {
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const info = await handle.stat();
+    if (
+      !info.isFile() ||
+      info.nlink !== 1 ||
+      info.size > 65536 ||
+      (process.getuid && info.uid !== process.getuid()) ||
+      (process.platform !== "win32" && (info.mode & 0o777) !== 0o600)
+    )
+      throw new Error("Unsafe runtime state.");
+    return JSON.parse(await handle.readFile("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+export async function privateWrite(path, value) {
+  await privateDirectory(dirname(path));
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const handle = await open(
+    temporary,
+    constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0),
+    0o600,
+  );
+  try {
+    await handle.writeFile(JSON.stringify(value));
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await rename(temporary, path);
+}
+export async function ensureInstalledRuntime(env = process.env) {
+  const root = runtimeRoot(env);
+  await privateDirectory(root);
+  let previousVersion;
+  try {
+    previousVersion = (await privateRead(join(root, "runtime", "current.json"))).version;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const metadata = JSON.parse(await readFile(join(packageRoot, "package.json"), "utf8"));
+  if (!/^\d+\.\d+\.\d+$/.test(metadata.version)) throw new Error("Invalid runtime version.");
+  const runtime = join(root, "runtime");
+  const modules = join(root, "runtime-packages", metadata.version, "node_modules");
+  const destination = join(modules, "totemlayer");
+  await privateDirectory(runtime);
+  await privateDirectory(modules);
+  let exists = false;
+  try {
+    exists = (await lstat(join(destination, "bin", "automatic-runtime.mjs"))).isFile();
+  } catch {
+    /* First installation. */
+  }
+  if (!exists) {
+    const stage = join(modules, `totemlayer-stage-${process.pid}`);
+    await privateDirectory(stage);
+    for (const name of ["bin", "package.json", "LICENSE.md", "README.md"])
+      await cp(join(packageRoot, name), join(stage, name), { recursive: true, dereference: false });
+    const dependencies = [
+      { name: "zod", from: packageRoot },
+      { name: "@modelcontextprotocol/server", from: packageRoot },
+    ];
+    const copied = new Map();
+    for (const dependency of dependencies) {
+      let selected;
+      for (
+        let current = dependency.from;
+        current !== dirname(current);
+        current = dirname(current)
+      ) {
+        for (const candidate of [
+          join(current, "node_modules", dependency.name),
+          ...(current.endsWith("node_modules") ? [join(current, dependency.name)] : []),
+        ]) {
+          try {
+            selected = await realpath(candidate);
+            break;
+          } catch {}
+        }
+        if (selected) break;
+      }
+      if (!selected) throw new Error("Install Totem's runtime dependencies before starting it.");
+      const dependencyManifest = JSON.parse(await readFile(join(selected, "package.json"), "utf8"));
+      if (copied.has(dependency.name)) {
+        if (copied.get(dependency.name) !== dependencyManifest.version)
+          throw new Error("Conflicting runtime dependency versions.");
+        continue;
+      }
+      copied.set(dependency.name, dependencyManifest.version);
+      const target = join(modules, dependency.name);
+      await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+      await cp(selected, target, { recursive: true, dereference: false, errorOnExist: false });
+      for (const name of Object.keys(dependencyManifest.dependencies ?? {}))
+        dependencies.push({ name, from: selected });
+    }
+    // An earlier installation can already own this version directory; never delete it.
+    try {
+      await rename(stage, destination);
+    } catch (error) {
+      await rm(stage, { recursive: true, force: true });
+      if (!(await lstat(join(destination, "bin", "automatic-runtime.mjs")).catch(() => null)))
+        throw error;
+    }
+  }
+  const cli = join(runtime, "totem.mjs");
+  const supervisor = join(runtime, "supervisor.mjs");
+  const launcher = (target) =>
+    `import{readFile,lstat}from'node:fs/promises';import{join,dirname}from'node:path';import{fileURLToPath,pathToFileURL}from'node:url';const root=dirname(fileURLToPath(import.meta.url));const file=join(root,'current.json');const info=await lstat(file);if(info.isSymbolicLink()||(process.getuid&&info.uid!==process.getuid())||(process.platform!=='win32'&&(info.mode&511)!==384))throw Error('Unsafe runtime installation');process.env.TOTEM_CONFIG_DIR=join(root,'..');const{version}=JSON.parse(await readFile(file,'utf8'));if(!/^\\d+\\.\\d+\\.\\d+$/.test(version))throw Error('Invalid runtime version');await import(pathToFileURL(join(root,'..','runtime-packages',version,'node_modules','totemlayer','bin','${target}')));`;
+  for (const [path, contents] of [
+    [cli, launcher("totem.mjs")],
+    [supervisor, launcher("automatic-runtime.mjs")],
+  ]) {
+    const handle = await open(
+      path,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | (constants.O_NOFOLLOW ?? 0),
+      0o600,
+    );
+    try {
+      await handle.writeFile(contents);
+    } finally {
+      await handle.close();
+    }
+  }
+  await privateWrite(join(runtime, "current.json"), { version: metadata.version });
+  return {
+    root,
+    cli,
+    supervisor,
+    directory: runtime,
+    version: metadata.version,
+    upgraded: Boolean(previousVersion && previousVersion !== metadata.version),
+  };
+}
+const xml = (value) =>
+  String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+export async function installRuntimeService(runtime, env = process.env, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const run = options.execute ?? execute;
+  const node = process.execPath;
+  const home = env.HOME ?? env.USERPROFILE ?? homedir();
+  if (runtime.upgraded && platform !== "win32") {
+    try {
+      const status = await privateRead(join(runtime.directory, "supervisor.json"));
+      const owner = await privateRead(join(runtime.directory, "supervisor.lock", "owner.json"));
+      if (Number.isSafeInteger(status.pid) && status.pid > 1 && owner.pid === status.pid) {
+        const processInfo = await run("ps", ["-p", String(status.pid), "-o", "args="], {
+          encoding: "utf8",
+          timeout: 3000,
+          maxBuffer: 8192,
+        });
+        if (processInfo.stdout.trim() === `${node} ${runtime.supervisor}`) {
+          process.kill(status.pid, "SIGTERM");
+          const deadline = Date.now() + 20000;
+          while (Date.now() < deadline) {
+            try {
+              process.kill(status.pid, 0);
+            } catch (error) {
+              if (error.code === "ESRCH") break;
+              throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+          }
+        }
+      }
+    } catch {
+      /* Only stop a verified previous supervisor; other processes are preserved. */
+    }
+  }
+
+  const suffix =
+    runtime.root === resolve(join(homedir(), ".totem"))
+      ? ""
+      : `.${createHash("sha256").update(runtime.root).digest("hex").slice(0, 12)}`;
+  const label = `com.totem.runtime${suffix}`;
+  const unit = `totem-runtime${suffix}.service`;
+  const task = `TotemRuntime${suffix}`;
+  const serviceEnv = { TOTEM_CONFIG_DIR: runtime.root, PATH: env.PATH ?? "", HOME: home };
+  for (const name of [
+    "TOTEM_PROVIDER",
+    "TOTEM_MODEL",
+    "TOTEM_BASE_URL",
+    "TOTEM_AGENT_ID",
+    "TOTEM_AGENT_URL",
+    "TOTEM_AGENT_TOKEN_ENV",
+    "TOTEM_AGENT_COMMAND",
+    "TOTEM_AGENT_COMMAND_ARGS",
+  ])
+    if (env[name]) serviceEnv[name] = env[name];
+  await privateWrite(join(runtime.directory, "environment.json"), serviceEnv);
+  let providerSecrets = {};
+  try {
+    providerSecrets = await privateRead(join(runtime.directory, "provider-environment.json"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const secretNames = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"];
+  if (
+    env.TOTEM_AGENT_TOKEN_ENV &&
+    /^[A-Z][A-Z0-9_]{0,127}$/.test(env.TOTEM_AGENT_TOKEN_ENV) &&
+    !/^(TOTEM|AGENTTRUST)_/.test(env.TOTEM_AGENT_TOKEN_ENV)
+  )
+    secretNames.push(env.TOTEM_AGENT_TOKEN_ENV);
+  for (const name of secretNames) if (env[name]) providerSecrets[name] = env[name];
+  await privateWrite(join(runtime.directory, "provider-environment.json"), providerSecrets);
+  try {
+    if (platform === "darwin") {
+      const path = join(home, "Library", "LaunchAgents", `${label}.plist`);
+      await mkdir(dirname(path), { recursive: true });
+      const plist = `<?xml version="1.0"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>Label</key><string>${label}</string><key>ProgramArguments</key><array><string>${xml(node)}</string><string>${xml(runtime.supervisor)}</string></array><key>EnvironmentVariables</key><dict><key>TOTEM_CONFIG_DIR</key><string>${xml(runtime.root)}</string></dict><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>ThrottleInterval</key><integer>30</integer></dict></plist>`;
+      const handle = await open(
+        path,
+        constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | (constants.O_NOFOLLOW ?? 0),
+        0o600,
+      );
+      try {
+        await handle.writeFile(plist);
+      } finally {
+        await handle.close();
+      }
+      const domain = `gui/${process.getuid()}`;
+      // Preserve an already running supervisor; its launcher uses current.json after restart.
+      try {
+        await run("launchctl", ["print", `${domain}/${label}`]);
+        if (runtime.upgraded) {
+          await run("launchctl", ["bootout", `${domain}/${label}`]);
+          await run("launchctl", ["bootstrap", domain, path]);
+        }
+      } catch {
+        await run("launchctl", ["bootstrap", domain, path]);
+      }
+      return { mode: "launchd", persistent: true, label, path };
+    }
+    if (platform === "linux") {
+      const path = join(home, ".config", "systemd", "user", unit);
+      await mkdir(dirname(path), { recursive: true });
+      const quote = (value) =>
+        `"${String(value).replaceAll("%", "%%").replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+      const text = `[Unit]\nDescription=Totem automatic agent runtime\nAfter=network-online.target\n[Service]\nExecStart=${quote(node)} ${quote(runtime.supervisor)}\nEnvironment=${quote(`TOTEM_CONFIG_DIR=${runtime.root}`)}\nRestart=on-failure\nRestartSec=30\n[Install]\nWantedBy=default.target\n`;
+      const handle = await open(
+        path,
+        constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | (constants.O_NOFOLLOW ?? 0),
+        0o600,
+      );
+      try {
+        await handle.writeFile(text);
+      } finally {
+        await handle.close();
+      }
+      await run("systemctl", ["--user", "daemon-reload"]);
+      await run("systemctl", ["--user", "enable", "--now", unit]);
+      if (runtime.upgraded) await run("systemctl", ["--user", "restart", unit]);
+      return { mode: "systemd-user", persistent: true, label: unit, path };
+    }
+    if (platform === "win32") {
+      const literal = (value) => `'${String(value).replaceAll("'", "''")}'`;
+      const script = `$ErrorActionPreference='Stop';Stop-ScheduledTask -TaskName ${literal(task)} -ErrorAction SilentlyContinue;$action=New-ScheduledTaskAction -Execute ${literal(node)} -Argument ${literal('"' + runtime.supervisor + '"')};$trigger=New-ScheduledTaskTrigger -AtLogOn;$settings=New-ScheduledTaskSettingsSet -RestartCount 99 -RestartInterval (New-TimeSpan -Minutes 1);Register-ScheduledTask -TaskName ${literal(task)} -Action $action -Trigger $trigger -Settings $settings -Force | Out-Null;Start-ScheduledTask -TaskName ${literal(task)}`;
+      const invocation = powershellInvocation(script, env);
+      await run(invocation.command, invocation.args);
+      return { mode: "scheduled-task", persistent: true, label: task };
+    }
+  } catch {
+    /* Ephemeral/headless hosts often have no user service manager. */
+  }
+  const child = (options.spawn ?? spawn)(node, [runtime.supervisor], {
+    env: { ...env, TOTEM_CONFIG_DIR: runtime.root },
+    stdio: "ignore",
+    detached: true,
+    windowsHide: true,
+  });
+  child.on("error", () => {});
+  child.unref();
+  return { mode: "background-supervisor", persistent: false };
+}

package/bin/sdk/index.js

@@ -164,6 +164,11 @@ export class Totem {
             return { data: page.data.workItems, nextCursor: page.nextCursor ?? null };
         },
         iterateWorkItems: (id, query = {}, options) => paginate((cursor) => this.missions.workItemsPage(id, { ...query, cursor }, options), query.cursor),
+        assign: async (id, input, options = {}) => (await this.#transport.request("POST", `/missions/${encodeURIComponent(id)}/work-items`, {
+            ...options,
+            body: input,
+            idempotencyKey: options.idempotencyKey ?? idempotencyKey(),
+        })).data,
         claim: async (id, workItemId, options) => (await this.#transport.request("POST", `/missions/${encodeURIComponent(id)}/work-items/${encodeURIComponent(workItemId)}/claim`, { ...options, body: {} })).data,
         renew: async (id, workItemId, leaseToken, options) => (await this.#transport.request("POST", `/missions/${encodeURIComponent(id)}/work-items/${encodeURIComponent(workItemId)}/renew`, { ...options, body: { leaseToken }, retrySafe: true })).data,
         complete: async (id, workItemId, input, options = {}) => (await this.#transport.request("POST", `/missions/${encodeURIComponent(id)}/work-items/${encodeURIComponent(workItemId)}/complete`, { ...options, body: input, idempotencyKey: options.idempotencyKey ?? idempotencyKey() })).data,

package/bin/totem.mjs

@@ -4,7 +4,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stripVTControlCharacters } from "node:util";
 
-const CLI_VERSION = "0.1.6";
+const CLI_VERSION = "0.1.11";
 const DEFAULT_BASE_URL = "https://totemlayer.com";
 const API_KEY_PATTERN = /^at_(?:live|test)_[A-Za-z0-9_-]{20,}$/;
 const ACTION_PATTERN = /^[a-z0-9][a-z0-9._:-]*$/;
@@ -241,8 +241,8 @@ function help() {
   Confirm installation totem --version
   Run one-off           npx --yes totemlayer --help
 
-Connect once and receive Mission work (local preview)
-  Requires the matching local package; not yet published to npm.
+Connect once and receive messages and approved Mission work
+  Select Codex, Claude, a local model, or an owner-configured CLI/HTTP agent.
   totem setup
   totem status
   totem start --background
@@ -1748,6 +1748,11 @@ async function runRfq(options, baseUrl) {
 }
 
 async function main() {
+  if (!process.argv[2] || ["login", "install"].includes(process.argv[2])) {
+    const { installationMain } = await import("./installation.mjs");
+    process.exitCode = await installationMain(process.argv.slice(3), {});
+    return;
+  }
   if (["setup", "status", "doctor"].includes(process.argv[2])) {
     const { agentSetupMain, agentStatusMain } = await import("./agent-setup.mjs");
     const { readAgentRuntimeStatus } = await import("./agent-runner.mjs");
@@ -1786,6 +1791,11 @@ async function main() {
     await mcpMain();
     return;
   }
+  if (process.argv[2] === "cloud" && process.argv[3] === "setup") {
+    const { cloudBootstrapMain } = await import("./cloud-bootstrap.mjs");
+    process.exitCode = await cloudBootstrapMain(process.argv.slice(4));
+    return;
+  }
   if (process.argv[2] === "network") {
     const { networkMain } = await import("./network.mjs");
     await networkMain(process.argv.slice(3));

package/bin/worker-core/adapters.mjs

@@ -0,0 +1,279 @@
+import { spawn } from "node:child_process";
+import { isAbsolute } from "node:path";
+import { WorkerError, validateResult } from "./errors.mjs";
+
+const SYSTEM_ENV = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "SystemRoot",
+  "SYSTEMROOT",
+  "COMSPEC",
+  "PATHEXT",
+  "LOCALAPPDATA",
+  "APPDATA",
+];
+const RESERVED_ENV = /^(TOTEM|AGENTTRUST)_/i;
+
+function integer(value, fallback, maximum) {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result < 1 || result > maximum) {
+    throw new WorkerError("INVALID_ADAPTER_CONFIG");
+  }
+  return result;
+}
+
+function childEnvironment(values) {
+  const environment = {};
+  for (const key of SYSTEM_ENV) {
+    if (process.env[key] !== undefined) environment[key] = process.env[key];
+  }
+  for (const [key, value] of Object.entries(values ?? {})) {
+    if (RESERVED_ENV.test(key) || typeof value !== "string" || value.includes("\0")) {
+      throw new WorkerError("INVALID_ADAPTER_ENV");
+    }
+    environment[key] = value;
+  }
+  return environment;
+}
+
+/** All process configuration comes from the owner's runtime, never a queued task. */
+export function createCommandAdapter(config) {
+  if (
+    !config ||
+    typeof config.command !== "string" ||
+    !config.command.trim() ||
+    config.command.includes("\0") ||
+    !Array.isArray(config.args ?? []) ||
+    !(config.args ?? []).every((arg) => typeof arg === "string" && !arg.includes("\0")) ||
+    typeof config.cwd !== "string" ||
+    !isAbsolute(config.cwd)
+  ) {
+    throw new WorkerError("INVALID_ADAPTER_CONFIG");
+  }
+  const args = [...(config.args ?? [])];
+  const env = childEnvironment(config.env);
+  const timeoutMs = integer(config.timeoutMs, 15 * 60_000, 24 * 60 * 60_000);
+  const maxOutputBytes = integer(config.maxOutputBytes, 1024 * 1024, 16 * 1024 * 1024);
+  const parseResult = config.parseResult ?? ((output) => ({ status: "completed", output }));
+  if (typeof parseResult !== "function") throw new WorkerError("INVALID_ADAPTER_CONFIG");
+
+  return {
+    async run({ prompt, signal }) {
+      if (
+        typeof prompt !== "string" ||
+        !prompt.trim() ||
+        Buffer.byteLength(prompt) > maxOutputBytes
+      ) {
+        throw new WorkerError("INVALID_PROMPT");
+      }
+      if (signal?.aborted) throw new WorkerError("RUN_CANCELLED");
+      return new Promise((resolve, reject) => {
+        let child;
+        let failure;
+        let output = "";
+        let bytes = 0;
+        let killTimer;
+        // Also remove surviving descendants if the parent exits before escalation.
+        const kill = (kind) => {
+          try {
+            if (process.platform !== "win32" && child?.pid) process.kill(-child.pid, kind);
+            else child?.kill(kind);
+          } catch {
+            /* The process may already have exited. */
+          }
+        };
+        const stop = (code) => {
+          if (failure) return;
+          failure = new WorkerError(code);
+          // Kill the complete child process group on POSIX, including spawned tools.
+          kill("SIGTERM");
+          killTimer = setTimeout(() => kill("SIGKILL"), 1000);
+          killTimer.unref();
+        };
+        const cancel = () => stop("RUN_CANCELLED");
+        try {
+          child = spawn(config.command, args, {
+            cwd: config.cwd,
+            env,
+            shell: false,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+          });
+        } catch {
+          reject(new WorkerError("AGENT_START_FAILED"));
+          return;
+        }
+        const timeout = setTimeout(() => stop("RUN_TIMEOUT"), timeoutMs);
+        signal?.addEventListener("abort", cancel, { once: true });
+        if (signal?.aborted) cancel();
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          bytes += Buffer.byteLength(chunk);
+          if (bytes > maxOutputBytes) stop("OUTPUT_LIMIT_EXCEEDED");
+          else output += chunk;
+        });
+        // Drain stderr, but never expose provider diagnostics or credentials in logs.
+        child.stderr.on("data", (chunk) => {
+          bytes += chunk.length;
+          if (bytes > maxOutputBytes) stop("OUTPUT_LIMIT_EXCEEDED");
+        });
+        child.stdin.on("error", () => {
+          /* A failed child can close stdin early. */
+        });
+        child.on("error", () => {
+          failure ??= new WorkerError("AGENT_START_FAILED");
+        });
+        child.on("close", (code) => {
+          clearTimeout(timeout);
+          clearTimeout(killTimer);
+          signal?.removeEventListener("abort", cancel);
+          if (failure) {
+            kill("SIGKILL");
+            return reject(failure);
+          }
+          if (code !== 0) return reject(new WorkerError("AGENT_EXIT_FAILED"));
+          try {
+            resolve(validateResult(parseResult(output)));
+          } catch (error) {
+            reject(error instanceof WorkerError ? error : new WorkerError("INVALID_AGENT_RESULT"));
+          }
+        });
+        // Prompts cannot become argv, executable names, paths, or shell syntax.
+        child.stdin.end(prompt);
+      });
+    },
+  };
+}
+
+export function createCodexAdapter(config) {
+  const { command = "codex", model, ...rest } = config;
+  if (model !== undefined && (typeof model !== "string" || !model || model.startsWith("-"))) {
+    throw new WorkerError("INVALID_ADAPTER_CONFIG");
+  }
+  return createCommandAdapter({
+    ...rest,
+    command,
+    args: ["exec", "--sandbox", "workspace-write", ...(model ? ["--model", model] : []), "-"],
+  });
+}
+
+export function createClaudeCodeAdapter(config) {
+  const {
+    command = "claude",
+    model,
+    allowedTools = ["Read", "Glob", "Grep", "Edit", "Write"],
+    ...rest
+  } = config;
+  if (
+    !Array.isArray(allowedTools) ||
+    !allowedTools.every((tool) => typeof tool === "string" && tool.trim()) ||
+    (model !== undefined && (typeof model !== "string" || !model || model.startsWith("-")))
+  ) {
+    throw new WorkerError("INVALID_ADAPTER_CONFIG");
+  }
+  return createCommandAdapter({
+    ...rest,
+    command,
+    args: [
+      "-p",
+      "--output-format",
+      "json",
+      "--permission-mode",
+      "dontAsk",
+      ...(allowedTools.length ? ["--allowedTools", allowedTools.join(",")] : []),
+      ...(model ? ["--model", model] : []),
+    ],
+    parseResult(output) {
+      let result;
+      try {
+        result = JSON.parse(output);
+      } catch {
+        throw new WorkerError("INVALID_AGENT_RESULT");
+      }
+      if (result.is_error || result.subtype !== "success") {
+        throw new WorkerError("AGENT_REPORTED_FAILURE");
+      }
+      return { status: "completed", output: result.result };
+    },
+  });
+}
+
+/** A hosted agent's owner-configured HTTP endpoint implementing the result contract. */
+export function createHttpAdapter(config) {
+  let endpoint;
+  try {
+    endpoint = new URL(config.endpoint);
+  } catch {
+    throw new WorkerError("INVALID_ADAPTER_CONFIG");
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(endpoint.hostname);
+  if (
+    !["http:", "https:"].includes(endpoint.protocol) ||
+    (endpoint.protocol === "http:" && !local) ||
+    endpoint.username ||
+    endpoint.password ||
+    endpoint.search ||
+    endpoint.hash ||
+    (config.authorization !== undefined && typeof config.authorization !== "string")
+  )
+    throw new WorkerError("INVALID_ADAPTER_CONFIG");
+  const timeoutMs = integer(config.timeoutMs, 15 * 60_000, 24 * 60 * 60_000);
+  const maximum = integer(config.maxOutputBytes, 1024 * 1024, 16 * 1024 * 1024);
+  return {
+    async run({ prompt, signal, runId }) {
+      if (
+        typeof runId !== "string" ||
+        !/^[A-Za-z0-9_.:-]{1,200}$/.test(runId) ||
+        typeof prompt !== "string" ||
+        !prompt.trim() ||
+        Buffer.byteLength(prompt) > maximum
+      ) {
+        throw new WorkerError("INVALID_PROMPT");
+      }
+      if (signal?.aborted) throw new WorkerError("RUN_CANCELLED");
+      let response;
+      try {
+        response = await fetch(endpoint, {
+          method: "POST",
+          redirect: "manual",
+          headers: {
+            "content-type": "application/json",
+            "idempotency-key": runId,
+            ...(config.authorization ? { authorization: config.authorization } : {}),
+          },
+          body: JSON.stringify({ runId, prompt }),
+          signal: signal
+            ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
+            : AbortSignal.timeout(timeoutMs),
+        });
+      } catch {
+        throw new WorkerError("UNKNOWN_HTTP_OUTCOME");
+      }
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new WorkerError("HTTP_AGENT_FAILED");
+      }
+      let size = 0;
+      const chunks = [];
+      try {
+        for await (const chunk of response.body) {
+          size += chunk.length;
+          if (size > maximum) {
+            await response.body.cancel().catch(() => {});
+            throw new WorkerError("OUTPUT_LIMIT_EXCEEDED");
+          }
+          chunks.push(chunk);
+        }
+        return validateResult(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch (error) {
+        throw error instanceof WorkerError ? error : new WorkerError("INVALID_AGENT_RESULT");
+      }
+    },
+  };
+}