totemlayer 0.1.4 → 0.1.6

package/bin/collaboration-listener.mjs

@@ -7,9 +7,9 @@ import { setTimeout as sleep } from "node:timers/promises";
 
 import { inspectLocalRepository } from "./repository.mjs";
 import { localClientEnvironment, streamingClientInvocation } from "./platform-client.mjs";
+import { runFile } from "./mission-worker.mjs";
 
 const MAX_RUNS_PER_TASK = 16;
-const MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
 const MAX_PROMPT_BYTES = 32 * 1024;
 const DEFAULT_RUN_TIMEOUT_MS = 15 * 60 * 1000;
 
@@ -84,7 +84,10 @@ function runnerCommand(provider, sessionId, platform = process.platform) {
   if (provider === "codex")
     invocation = sessionId
       ? { command: "codex", args: ["exec", "resume", "--json", sessionId, "-"] }
-      : { command: "codex", args: ["exec", "--sandbox", "workspace-write", "--json", "-"] };
+      : {
+          command: "codex",
+          args: ["exec", "--sandbox", "workspace-write", "--json", "-"],
+        };
   else if (provider === "claude")
     invocation = {
       command: "claude",
@@ -106,7 +109,9 @@ function runnerCommand(provider, sessionId, platform = process.platform) {
 }
 
 function runnerEnvironment(repositoryRoot, environment = process.env) {
-  return localClientEnvironment(environment, { TOTEM_REPOSITORY_ROOT: repositoryRoot });
+  return localClientEnvironment(environment, {
+    TOTEM_REPOSITORY_ROOT: repositoryRoot,
+  });
 }
 
 export async function runLocalCollaborationAgent({
@@ -120,79 +125,42 @@ export async function runLocalCollaborationAgent({
   spawnProcess = spawn,
 }) {
   const { command, args } = runnerCommand(provider, sessionId, platform);
-  return new Promise((resolveRun, rejectRun) => {
-    const child = spawnProcess(command, args, {
-      cwd: repositoryRoot,
-      env: runnerEnvironment(repositoryRoot),
-      stdio: ["pipe", "pipe", "pipe"],
-      shell: false,
-    });
-    let output = "";
-    let totalOutputBytes = 0;
-    let observedSession = sessionId ?? null;
-    let finalResponse = "";
-    let finished = false;
-    const fail = (error) => {
-      if (finished) return;
-      finished = true;
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", abort);
-      rejectRun(error);
-    };
-    const abort = () => child.kill("SIGTERM");
-    const timer = setTimeout(() => child.kill("SIGTERM"), timeoutMs);
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted) abort();
-    child.stdout.on("data", (chunk) => {
-      totalOutputBytes += chunk.byteLength;
-      output += chunk.toString("utf8");
-      if (totalOutputBytes > MAX_OUTPUT_BYTES) child.kill("SIGTERM");
-      if (provider !== "codex") return;
-      let newline;
-      while ((newline = output.indexOf("\n")) >= 0) {
-        const line = output.slice(0, newline);
-        output = output.slice(newline + 1);
-        try {
-          const event = JSON.parse(line);
-          if (event.type === "thread.started" && typeof event.thread_id === "string")
-            observedSession = event.thread_id;
-          if (event.type === "item.completed" && event.item?.type === "agent_message")
-            finalResponse = String(event.item.text ?? "");
-        } catch {
-          // Ignore non-JSON progress lines; never echo model output to CLI logs.
-        }
-      }
-    });
-    child.stderr.on("data", () => {});
-    child.once("error", (error) => fail(error));
-    child.once("close", (code) => {
-      if (finished) return;
-      if (signal?.aborted) return fail(new Error("The collaboration listener was stopped."));
-      if (code !== 0)
-        return fail(
-          new Error(
-            `The ${provider} run exited with status ${code ?? "unknown"}. Check that client's local logs and permissions.`,
-          ),
-        );
-      if (provider === "claude") {
-        try {
-          const result = JSON.parse(output);
-          observedSession = result.session_id ?? observedSession;
-          finalResponse = typeof result.result === "string" ? result.result : "";
-          if (result.is_error) return fail(new Error("Claude reported a failed run."));
-        } catch {
-          return fail(new Error("Claude returned an invalid JSON result."));
-        }
-      }
-      if (!observedSession)
-        return fail(new Error(`${provider} did not return a resumable session ID.`));
-      finished = true;
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", abort);
-      resolveRun({ sessionId: observedSession, finalResponse });
-    });
-    child.stdin.end(prompt);
+  const { stdout } = await runFile(command, args, {
+    cwd: repositoryRoot,
+    env: runnerEnvironment(repositoryRoot),
+    input: prompt,
+    signal,
+    timeoutMs,
+    platform,
+    spawnProcess,
   });
+  let observedSession = sessionId ?? null;
+  let finalResponse = "";
+  if (provider === "claude") {
+    let result;
+    try {
+      result = JSON.parse(stdout);
+    } catch {
+      throw new Error("Claude returned an invalid JSON result.");
+    }
+    observedSession = result.session_id ?? observedSession;
+    finalResponse = typeof result.result === "string" ? result.result : "";
+    if (result.is_error) throw new Error("Claude reported a failed run.");
+  } else {
+    for (const line of stdout.split("\n")) {
+      try {
+        const event = JSON.parse(line);
+        if (event.type === "thread.started" && typeof event.thread_id === "string")
+          observedSession = event.thread_id;
+        if (event.type === "item.completed" && event.item?.type === "agent_message")
+          finalResponse = String(event.item.text ?? "");
+      } catch {
+        // Ignore non-JSON progress lines; never echo model output to CLI logs.
+      }
+    }
+  }
+  if (!observedSession) throw new Error(`${provider} did not return a resumable session ID.`);
+  return { sessionId: observedSession, finalResponse };
 }
 
 async function readJournal(file) {
@@ -216,7 +184,12 @@ async function latestOutboundTaskCursor(client, taskId, cursor, signal) {
   let latest = cursor;
   for (let page = 0; page < 20; page++) {
     const result = await client.messages.list(
-      { direction: "outbound", taskId, limit: 100, ...(latest ? { cursor: latest } : {}) },
+      {
+        direction: "outbound",
+        taskId,
+        limit: 100,
+        ...(latest ? { cursor: latest } : {}),
+      },
       { signal },
     );
     const messages = result.data ?? [];
@@ -247,7 +220,9 @@ export async function runCollaborationListener({
   if (!Number.isInteger(pollMs) || pollMs < 1000 || pollMs > 60000)
     throw new Error("--poll-ms must be between 1000 and 60000.");
   const root = resolve(repositoryRoot);
-  const repository = await inspectLocalRepository({ TOTEM_REPOSITORY_ROOT: root });
+  const repository = await inspectLocalRepository({
+    TOTEM_REPOSITORY_ROOT: root,
+  });
   const identity = await client.agent({ signal });
   const peer = await client.resolve(peerAddress, { signal });
   if (!peer?.id || peer.address !== peerAddress) throw new Error("The allowed peer was not found.");
@@ -267,7 +242,12 @@ export async function runCollaborationListener({
   }
   try {
     const journal = await readJournal(journalFile);
-    const binding = { agentId: identity.id, peerAddress, repository: repository.repository, root };
+    const binding = {
+      agentId: identity.id,
+      peerAddress,
+      repository: repository.repository,
+      root,
+    };
     if (journal.binding && JSON.stringify(journal.binding) !== JSON.stringify(binding))
       throw new Error("This journal belongs to a different agent, peer, or checkout.");
     if (!journal.binding) {
@@ -301,7 +281,11 @@ export async function runCollaborationListener({
             continue;
           }
           if (prior?.status === "started" || prior?.status === "failed") {
-            emit({ type: "needs_attention", messageId: message.id, taskId: message.taskId });
+            emit({
+              type: "needs_attention",
+              messageId: message.id,
+              taskId: message.taskId,
+            });
             continue;
           }
           const task = await client.tasks.get(message.taskId, { signal });
@@ -352,7 +336,12 @@ export async function runCollaborationListener({
           const outboundBefore = await latestOutboundTaskCursor(client, task.id, undefined, signal);
           journal.messages[message.id] = { status: "started", taskId: task.id };
           await saveJournal(journalFile, journal);
-          emit({ type: "started", messageId: message.id, taskId: task.id, provider });
+          emit({
+            type: "started",
+            messageId: message.id,
+            taskId: task.id,
+            provider,
+          });
           try {
             const result = await runAgent({
               provider,
@@ -377,12 +366,23 @@ export async function runCollaborationListener({
               sessionId: result.sessionId,
               runCount: (savedTask?.runCount ?? 0) + 1,
             };
-            journal.messages[message.id] = { status: "completed", taskId: task.id };
+            journal.messages[message.id] = {
+              status: "completed",
+              taskId: task.id,
+            };
             await saveJournal(journalFile, journal);
             await client.messages.ack(message.id, { signal });
-            emit({ type: "completed", messageId: message.id, taskId: task.id, provider });
+            emit({
+              type: "completed",
+              messageId: message.id,
+              taskId: task.id,
+              provider,
+            });
           } catch (error) {
-            journal.messages[message.id] = { status: "failed", taskId: task.id };
+            journal.messages[message.id] = {
+              status: "failed",
+              taskId: task.id,
+            };
             await saveJournal(journalFile, journal);
             await client.tasks
               .postUpdate(task.id, listenerStatusText(provider, "failed"), {

package/bin/docker-test-sandbox.mjs

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { realpath } from "node:fs/promises";
+
+export const NODE_TEST_IMAGE =
+  "node:24-alpine@sha256:d32cdf619f63fe0471182d08996dd516c6275bb5fd31ae06e55a570bd9e1ad43";
+
+/** Only an isolated repository is mounted. No credentials or Docker socket enter tests. */
+export async function runDockerNodeTests(checkout, signal, runFile) {
+  const root = await realpath(checkout);
+  if (root.includes(",") || /[\r\n]/.test(root)) throw new Error("Unsupported sandbox mount path.");
+  const name = `totem-node-test-${randomUUID()}`;
+  const uid = typeof process.getuid === "function" ? process.getuid() : 1000;
+  const gid = typeof process.getgid === "function" ? process.getgid() : 1000;
+  try {
+    const result = await runFile(
+      "docker",
+      [
+        "run",
+        "--rm",
+        "--pull=never",
+        "--name",
+        name,
+        "--network=none",
+        "--read-only",
+        "--cap-drop=ALL",
+        "--security-opt=no-new-privileges",
+        "--pids-limit=64",
+        "--memory=512m",
+        "--cpus=1",
+        "--user",
+        `${uid}:${gid}`,
+        "--tmpfs",
+        "/tmp:rw,nosuid,nodev,noexec,size=64m,mode=1777",
+        "--env",
+        "HOME=/tmp",
+        "--env",
+        "TMPDIR=/tmp",
+        "--mount",
+        `type=bind,source=${root},target=/workspace,readonly`,
+        "--workdir",
+        "/workspace",
+        NODE_TEST_IMAGE,
+        "node",
+        "--test",
+      ],
+      { signal, timeoutMs: 120000, acceptNonZero: true },
+    );
+    return {
+      command: "node --test (Docker; no network, credentials, or host home)",
+      exitCode: result.exitCode,
+      output: `${result.stdout}\n${result.stderr}`.slice(0, 8000),
+    };
+  } finally {
+    // Interrupting the Docker client does not reliably stop its container.
+    // Cleanup targets only our random name and deliberately ignores the aborted signal.
+    await runFile("docker", ["rm", "--force", name], {
+      timeoutMs: 10000,
+      acceptNonZero: true,
+    });
+  }
+}

package/bin/local-model-provider.mjs

@@ -0,0 +1,29 @@
+/** Resolve only local, credential-free HTTP model endpoints. Never follow redirects. */
+export function localModelEndpoint(provider = "qwen-local", { ollamaUrl, qwenUrl, nimUrl } = {}) {
+  if (!["qwen-local", "ollama", "ollama-local", "nim-local"].includes(provider))
+    throw new Error("Choose qwen-local, ollama-local, or nim-local.");
+  const qwen = provider === "qwen-local";
+  const openai = qwen || provider === "nim-local";
+  const url = new URL(
+    openai
+      ? qwen
+        ? (qwenUrl ?? "http://127.0.0.1:8087/v1")
+        : (nimUrl ?? "http://127.0.0.1:8000/v1")
+      : (ollamaUrl ?? "http://127.0.0.1:11434"),
+  );
+  if (
+    !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) ||
+    url.protocol !== "http:" ||
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash ||
+    !(openai ? ["/v1", "/v1/"].includes(url.pathname) : url.pathname === "/")
+  )
+    throw new Error(
+      openai
+        ? `The ${qwen ? "Qwen" : "NIM"} model must use a credential-free local HTTP /v1 endpoint.`
+        : "The Ollama model must use a credential-free local HTTP origin.",
+    );
+  return `${url.origin}${openai ? "/v1/chat/completions" : "/api/chat"}`;
+}

package/bin/mcp-install.mjs

@@ -1,9 +1,10 @@
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { installedClientInvocation } from "./platform-client.mjs";
+import { installedClientInvocation, localClientEnvironment } from "./platform-client.mjs";
 
 const DEFAULT_ORIGIN = "https://totemlayer.com";
 const DEFAULT_NAME = "totem-local";
@@ -157,3 +158,241 @@ export async function installTotemMcp(args, environment = process.env, runtime =
     );
   return `Connected ${options.name} to ${command} at ${options.baseUrl}. Restart ${command}, then ask it to call totem_get_identity. The Totem CLI package must remain installed.\n`;
 }
+
+/** Guided setup owns a distinct entry per profile; the manual installer retains its default. */
+export function managedMcpName(profileName) {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(profileName) || profileName.length > 64)
+    fail("Choose a valid saved profile before configuring MCP.");
+  const plain = `totem-${profileName}`;
+  return plain.length <= 64
+    ? plain
+    : `totem_${profileName.slice(0, 24)}_${createHash("sha256").update(profileName).digest("hex").slice(0, 32)}`;
+}
+
+function managedArgs(profile, name) {
+  const variables = [
+    "--env",
+    `TOTEM_BASE_URL=${profile.baseUrl}`,
+    "--env",
+    `TOTEM_NETWORK_API_KEY_FILE=${profile.credentialFile}`,
+  ];
+  return profile.client === "codex"
+    ? ["mcp", "add", name, ...variables, "--", process.execPath, SERVER_ENTRY, "mcp"]
+    : [
+        "mcp",
+        "add",
+        ...variables,
+        "--scope",
+        "user",
+        "--transport",
+        "stdio",
+        name,
+        "--",
+        process.execPath,
+        SERVER_ENTRY,
+        "mcp",
+      ];
+}
+
+function matchesManagedEntry(entry, profile, name) {
+  const transport = entry?.transport;
+  const expectedEnvironment = {
+    TOTEM_BASE_URL: profile.baseUrl,
+    TOTEM_NETWORK_API_KEY_FILE: profile.credentialFile,
+  };
+  return (
+    entry?.name === name &&
+    entry.enabled !== false &&
+    !entry.disabled_reason &&
+    ["enabled_tools", "disabled_tools", "startup_timeout_sec", "tool_timeout_sec"].every(
+      (key) => entry[key] == null,
+    ) &&
+    transport?.type === "stdio" &&
+    transport.command === process.execPath &&
+    JSON.stringify(transport.args) === JSON.stringify([SERVER_ENTRY, "mcp"]) &&
+    transport.cwd == null &&
+    (transport.env_vars == null ||
+      (Array.isArray(transport.env_vars) && transport.env_vars.length === 0)) &&
+    transport.env &&
+    Object.keys(transport.env).length === 2 &&
+    Object.entries(expectedEnvironment).every(([key, value]) => transport.env[key] === value) &&
+    Object.keys(transport).every((key) =>
+      ["type", "command", "args", "env", "env_vars", "cwd"].includes(key),
+    ) &&
+    Object.keys(entry).every((key) =>
+      [
+        "name",
+        "enabled",
+        "disabled_reason",
+        "transport",
+        "enabled_tools",
+        "disabled_tools",
+        "startup_timeout_sec",
+        "tool_timeout_sec",
+      ].includes(key),
+    )
+  );
+}
+
+async function managedCall(profile, args, environment, runtime) {
+  try {
+    const result = runtime.runClient
+      ? await runtime.runClient(profile.client, args, environment)
+      : runClient(profile.client, args, environment, {
+          platform: process.platform,
+          spawnProcess: spawnSync,
+          ...runtime,
+        });
+    return { ...result, status: result.status ?? 0 };
+  } catch (error) {
+    return { status: 1, stdout: "", stderr: typeof error?.stderr === "string" ? error.stderr : "" };
+  }
+}
+
+async function inspectEntry(profile, environment, runtime) {
+  const name = managedMcpName(profile.profileName);
+  const response = await managedCall(
+    profile,
+    ["mcp", "get", name, ...(profile.client === "codex" ? ["--json"] : [])],
+    environment,
+    runtime,
+  );
+  if (response.status !== 0)
+    return {
+      name,
+      state: /no mcp server|not found|does not exist/i.test(
+        `${response.stdout}\n${response.stderr}`,
+      )
+        ? "not_configured"
+        : "unavailable",
+    };
+  if (profile.client !== "codex") return { name, state: "unverified" };
+  try {
+    return { name, state: "present", entry: JSON.parse(response.stdout) };
+  } catch {
+    return { name, state: "unverified" };
+  }
+}
+
+function reconnectAdvice(profile, name) {
+  return `Inspect ${name} with \`${profile.client} mcp get ${name}\`. To replace that exact entry after reviewing it, run \`${profile.client} mcp remove ${name}\`, then \`totem setup --profile ${profile.profileName} --install-mcp\`. Other entries are preserved.`;
+}
+
+export async function inspectManagedTotemMcp(profile, environment = process.env, runtime = {}) {
+  const inspected = await inspectEntry(profile, localClientEnvironment(environment), runtime);
+  if (
+    inspected.state === "present" &&
+    matchesManagedEntry(inspected.entry, profile, inspected.name)
+  )
+    return {
+      name: inspected.name,
+      state: "configured_unverified",
+      message: `The ${inspected.name} settings match this profile. Verify client sign-in and tool connectivity in the AI app with totem_get_identity.`,
+    };
+  if (inspected.state === "not_configured")
+    return {
+      name: inspected.name,
+      state: "not_configured",
+      message: `Run totem setup --profile ${profile.profileName} --install-mcp to add this profile's connection.`,
+    };
+  return {
+    name: inspected.name,
+    state: "needs_attention",
+    message: `${inspected.state === "unavailable" ? "The client configuration could not be read." : "The existing entry could not be verified against this saved profile."} ${reconnectAdvice(profile, inspected.name)}`,
+  };
+}
+
+export async function installManagedTotemMcp(
+  profile,
+  previousProfile,
+  environment = process.env,
+  runtime = {},
+) {
+  if (!["codex", "claude"].includes(profile.client))
+    fail("Choose an existing AI app for MCP setup.");
+  try {
+    await validateKeyFile(profile.credentialFile, runtime.platform ?? process.platform);
+  } catch {
+    return {
+      name: managedMcpName(profile.profileName),
+      state: "needs_attention",
+      message:
+        "The saved private key file is unavailable or unsafe. Check this profile before changing MCP settings.",
+    };
+  }
+  const safeEnvironment = localClientEnvironment(environment);
+  const inspected = await inspectEntry(profile, safeEnvironment, runtime);
+  const { name } = inspected;
+  const guidance = reconnectAdvice(profile, name);
+  if (inspected.state === "not_configured") {
+    try {
+      await (runtime.install ?? installTotemMcp)(
+        [
+          profile.client,
+          "--key-file",
+          profile.credentialFile,
+          "--base-url",
+          profile.baseUrl,
+          "--name",
+          name,
+        ],
+        safeEnvironment,
+        runtime,
+      );
+      if (profile.client === "codex") {
+        const after = await inspectEntry(profile, safeEnvironment, runtime);
+        if (after.state !== "present" || !matchesManagedEntry(after.entry, profile, name))
+          return {
+            name,
+            state: "needs_attention",
+            message: `The new MCP settings could not be verified against this profile. ${guidance}`,
+          };
+      }
+      return {
+        name,
+        state: "installed_unverified",
+        message: `${name} settings were saved. Restart the AI app and call totem_get_identity to verify its connection.`,
+      };
+    } catch {
+      return {
+        name,
+        state: "needs_attention",
+        message: `The connection is saved, but MCP installation could not be completed. ${guidance}`,
+      };
+    }
+  }
+  if (inspected.state === "present" && matchesManagedEntry(inspected.entry, profile, name))
+    return {
+      name,
+      state: "configured_unverified",
+      message: `${name} already matches this profile; nothing changed. Verify its identity in your AI app with totem_get_identity.`,
+    };
+  const ownsPrevious =
+    previousProfile?.profileName === profile.profileName &&
+    previousProfile.client === profile.client &&
+    inspected.state === "present" &&
+    matchesManagedEntry(inspected.entry, previousProfile, name);
+  if (!ownsPrevious)
+    return {
+      name,
+      state: "needs_attention",
+      message: `The existing entry was preserved because its ownership and settings could not be verified. ${guidance}`,
+    };
+  // Codex add can update this exact named entry. No remove occurs: unsupported client
+  // versions fail safely, and an exact read-back is required before reporting an update.
+  const updated = await managedCall(profile, managedArgs(profile, name), safeEnvironment, runtime);
+  if (updated.status === 0) {
+    const after = await inspectEntry(profile, safeEnvironment, runtime);
+    if (after.state === "present" && matchesManagedEntry(after.entry, profile, name))
+      return {
+        name,
+        state: "updated_unverified",
+        message: `${name} now references this profile's current private key. Restart the AI app and verify it with totem_get_identity.`,
+      };
+  }
+  return {
+    name,
+    state: "needs_attention",
+    message: `The managed MCP update could not be verified. ${guidance}`,
+  };
+}

package/bin/mcp.mjs

@@ -8,7 +8,7 @@ import * as z from "zod/v4";
 import { Totem } from "./sdk/index.js";
 import { inspectLocalRepository, verifyLocalRepoClaim } from "./repository.mjs";
 
-const VERSION = "0.1.4";
+const VERSION = "0.1.6";
 const MAX_KEY_BYTES = 8 * 1024;
 const MAX_ATTACHMENT_BYTES = 2 * 1024 * 1024;
 const collaborationSchema = z