totemlayer 0.1.2 → 0.1.4

package/bin/sdk/transport.js

@@ -0,0 +1,197 @@
+import { apiError, TotemCanceledError, TotemError, TotemNetworkError, TotemTimeoutError, } from "./errors.js";
+export function idempotencyKey() {
+    return globalThis.crypto.randomUUID();
+}
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const cancel = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", cancel);
+            reject(new TotemCanceledError("Totem request canceled.", { code: "CANCELED" }));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", cancel);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", cancel, { once: true });
+        if (signal?.aborted)
+            cancel();
+    });
+}
+export class Transport {
+    #apiKey;
+    #baseUrl;
+    #fetch;
+    #timeoutMs;
+    #maxRetries;
+    #retryDelayMs;
+    constructor(options) {
+        if (!options.apiKey?.trim())
+            throw new TotemError("An agent API key is required.", { code: "INVALID_CONFIG" });
+        const url = new URL(options.baseUrl ?? "https://totemlayer.com");
+        const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+        if ((url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            url.pathname !== "/") {
+            throw new TotemError("baseUrl must be an HTTPS origin or a local HTTP origin.", {
+                code: "INVALID_CONFIG",
+            });
+        }
+        this.#apiKey = options.apiKey;
+        this.#baseUrl = `${url.origin}/api/v1/network`;
+        this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.#timeoutMs = options.timeoutMs ?? 15_000;
+        this.#maxRetries = options.maxRetries ?? 2;
+        this.#retryDelayMs = options.retryDelayMs ?? 250;
+        if (!Number.isFinite(this.#timeoutMs) ||
+            this.#timeoutMs < 1 ||
+            !Number.isInteger(this.#maxRetries) ||
+            this.#maxRetries < 0 ||
+            this.#maxRetries > 10 ||
+            !Number.isFinite(this.#retryDelayMs) ||
+            this.#retryDelayMs < 0) {
+            throw new TotemError("Invalid timeout or retry configuration.", { code: "INVALID_CONFIG" });
+        }
+    }
+    async request(method, path, options = {}) {
+        const url = new URL(`${this.#baseUrl}${path}`);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value !== undefined && value !== null)
+                url.searchParams.set(key, String(value));
+        }
+        const retrySafe = method === "GET" || options.retrySafe === true || Boolean(options.idempotencyKey);
+        const body = options.binaryBody ?? (options.body === undefined ? undefined : JSON.stringify(options.body));
+        const headers = {
+            Authorization: `Bearer ${this.#apiKey}`,
+            Accept: "application/json",
+            ...(body === undefined || options.binaryBody ? {} : { "Content-Type": "application/json" }),
+            ...(options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}),
+            ...(options.headers ?? {}),
+        };
+        for (let attempt = 0;; attempt++) {
+            if (options.signal?.aborted)
+                throw new TotemCanceledError("Totem request canceled.", { code: "CANCELED" });
+            const controller = new AbortController();
+            let timer;
+            let cancel;
+            let retryAfter = null;
+            try {
+                const aborted = new Promise((_, reject) => {
+                    cancel = () => {
+                        controller.abort();
+                        reject(new TotemCanceledError("Totem request canceled.", { code: "CANCELED" }));
+                    };
+                    options.signal?.addEventListener("abort", cancel, { once: true });
+                    if (options.signal?.aborted)
+                        cancel();
+                    timer = setTimeout(() => {
+                        controller.abort();
+                        reject(new TotemTimeoutError("Totem request timed out.", { code: "TIMEOUT" }));
+                    }, this.#timeoutMs);
+                });
+                const response = (async () => {
+                    const result = await this.#fetch(url.toString(), {
+                        method,
+                        headers,
+                        body: body instanceof Uint8Array ? new Uint8Array(body) : body,
+                        signal: controller.signal,
+                        redirect: "error",
+                        cache: "no-store",
+                    });
+                    retryAfter = result.headers.get("Retry-After");
+                    const requestId = result.headers.get("X-Request-Id") ?? undefined;
+                    let payload;
+                    try {
+                        payload = await result.json();
+                    }
+                    catch {
+                        if (!result.ok)
+                            throw apiError(result.status, undefined, requestId);
+                        throw new TotemError("Totem returned invalid JSON.", {
+                            code: "INVALID_RESPONSE",
+                            requestId,
+                        });
+                    }
+                    if (!result.ok)
+                        throw apiError(result.status, payload, requestId);
+                    if (!payload || typeof payload !== "object" || !("data" in payload)) {
+                        throw new TotemError("Totem returned an invalid response envelope.", {
+                            code: "INVALID_RESPONSE",
+                            requestId,
+                        });
+                    }
+                    return payload;
+                })();
+                return await Promise.race([response, aborted]);
+            }
+            catch (cause) {
+                const error = cause instanceof TotemError
+                    ? cause
+                    : new TotemNetworkError("Unable to reach Totem.", { code: "NETWORK_ERROR", cause });
+                const transient = error instanceof TotemNetworkError ||
+                    error instanceof TotemTimeoutError ||
+                    (error.status !== undefined && [408, 429, 500, 502, 503, 504].includes(error.status));
+                if (!retrySafe || !transient || attempt >= this.#maxRetries)
+                    throw error;
+                // The request timer and caller listener must not survive into backoff.
+                clearTimeout(timer);
+                if (cancel)
+                    options.signal?.removeEventListener("abort", cancel);
+                const seconds = retryAfter === null ? NaN : Number(retryAfter);
+                const parsedDate = retryAfter === null ? NaN : Date.parse(retryAfter);
+                const requestedDelay = Number.isFinite(seconds) ? seconds * 1000 : parsedDate - Date.now();
+                const fallback = this.#retryDelayMs * 2 ** attempt * (0.75 + Math.random() * 0.5);
+                await sleep(Math.min(30_000, Math.max(0, Number.isFinite(requestedDelay) ? requestedDelay : fallback)), options.signal);
+            }
+            finally {
+                clearTimeout(timer);
+                if (cancel)
+                    options.signal?.removeEventListener("abort", cancel);
+            }
+        }
+    }
+    async download(path, options = {}) {
+        const signal = AbortSignal.any([options.signal, AbortSignal.timeout(this.#timeoutMs)].filter(Boolean));
+        let response;
+        try {
+            response = await this.#fetch(`${this.#baseUrl}${path}`, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${this.#apiKey}` },
+                signal,
+                redirect: "error",
+                cache: "no-store",
+            });
+        }
+        catch (cause) {
+            throw new TotemNetworkError("Unable to download the attachment.", {
+                code: "NETWORK_ERROR",
+                cause,
+            });
+        }
+        if (!response.ok) {
+            const payload = await response.json().catch(() => undefined);
+            throw apiError(response.status, payload, response.headers.get("x-request-id") ?? undefined);
+        }
+        const reported = Number(response.headers.get("content-length"));
+        if (reported > 2 * 1024 * 1024)
+            throw new TotemError("The attachment exceeds the 2 MiB limit.", {
+                code: "ATTACHMENT_TOO_LARGE",
+            });
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.byteLength > 2 * 1024 * 1024)
+            throw new TotemError("The attachment exceeds the 2 MiB limit.", {
+                code: "ATTACHMENT_TOO_LARGE",
+            });
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const encoded = disposition.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+        return {
+            bytes,
+            mediaType: response.headers.get("content-type") ?? "application/octet-stream",
+            name: encoded ? decodeURIComponent(encoded) : "attachment",
+            sha256: response.headers.get("x-content-sha256"),
+        };
+    }
+}

package/bin/sdk/types.js

@@ -0,0 +1 @@
+export {};

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.2";
+const CLI_VERSION = "0.1.4";
 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,6 +241,13 @@ function help() {
   Confirm installation totem --version
   Run one-off           npx --yes totemlayer --help
 
+Agent messaging and local runtime
+  totem network --help
+  totem network run --provider ollama --model qwen3.5:9b
+
+Connect an AI app through MCP
+  totem mcp
+
 Authorization handshake
   totem challenge \\
     --presenter-agent <agent-id> \\
@@ -1734,6 +1741,35 @@ async function runRfq(options, baseUrl) {
 }
 
 async function main() {
+  if (process.argv[2] === "mcp") {
+    if (process.argv[3] === "install" || process.argv[3] === "--help" || process.argv[3] === "-h") {
+      const { installTotemMcp } = await import("./mcp-install.mjs");
+      try {
+        process.stdout.write(
+          await installTotemMcp(process.argv[3] === "install" ? process.argv.slice(4) : ["--help"]),
+        );
+      } catch (error) {
+        process.stderr.write(
+          `${error instanceof Error ? error.message : "Could not install the Totem MCP server."}\n`,
+        );
+        process.exitCode = 1;
+      }
+      return;
+    }
+    if (process.argv.length > 3) {
+      process.stderr.write("Unknown Totem MCP option. Run `totem mcp install --help`.\n");
+      process.exitCode = 1;
+      return;
+    }
+    const { mcpMain } = await import("./local-mcp.mjs");
+    await mcpMain();
+    return;
+  }
+  if (process.argv[2] === "network") {
+    const { networkMain } = await import("./network.mjs");
+    await networkMain(process.argv.slice(3));
+    return;
+  }
   let options;
   const jsonRequested = process.argv.slice(2).includes("--json");
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totemlayer",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Cross-platform CLI for TotemLayer agent identity and authorization",
   "type": "module",
   "bin": {
@@ -11,7 +11,8 @@
   "files": [
     "bin",
     "LICENSE.md",
-    "README.md"
+    "README.md",
+    "scripts/prepare.mjs"
   ],
   "engines": {
     "node": ">=22.14.0"
@@ -29,5 +30,12 @@
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/server": "2.0.0",
+    "zod": "4.4.3"
+  },
+  "scripts": {
+    "prepack": "node scripts/prepare.mjs"
   }
 }

package/scripts/prepare.mjs

@@ -0,0 +1,15 @@
+import { execFileSync } from "node:child_process";
+import { mkdir, readdir, copyFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+// Build from the sibling source every time a distributable is packed.
+const sdk = fileURLToPath(new URL("../../sdk/", import.meta.url));
+const destination = new URL("../bin/sdk/", import.meta.url);
+execFileSync(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build", "--prefix", sdk], {
+  stdio: "inherit",
+});
+await mkdir(destination, { recursive: true });
+for (const name of await readdir(new URL("../../sdk/dist/", import.meta.url))) {
+  if (name.endsWith(".js"))
+    await copyFile(new URL(`../../sdk/dist/${name}`, import.meta.url), new URL(name, destination));
+}