totemlayer 0.1.4 → 0.1.5

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`,
+        "--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.5";
 const MAX_KEY_BYTES = 8 * 1024;
 const MAX_ATTACHMENT_BYTES = 2 * 1024 * 1024;
 const collaborationSchema = z