@themoltnet/legreffier 0.1.0 → 0.2.0

package/dist/index.js

@@ -2,13 +2,12 @@
 import { jsxs, jsx } from "react/jsx-runtime";
 import { parseArgs } from "node:util";
 import { useInput, Box, Text, useApp, render } from "ink";
-import { join, basename } from "node:path";
+import { join } from "node:path";
 import { useState, useEffect, useReducer, useRef } from "react";
 import figlet from "figlet";
-import { readFile, writeFile, mkdir, chmod, rm } from "node:fs/promises";
+import { readFile, mkdir, writeFile, chmod, rm } from "node:fs/promises";
 import { homedir } from "node:os";
-import { randomBytes as randomBytes$1, createHash } from "crypto";
-import { execSync } from "node:child_process";
+import { createHash, randomBytes as randomBytes$1 } from "crypto";
 import open from "open";
 const colors = {
   // Primary — teal/cyan (The Network)
@@ -350,13 +349,13 @@ function CliSummaryBox({
     }
   ) });
 }
-const jsonBodySerializer = {
+const jsonBodySerializer$1 = {
   bodySerializer: (body) => JSON.stringify(
     body,
     (_key, value) => typeof value === "bigint" ? value.toString() : value
   )
 };
-const createSseClient = ({
+const createSseClient$1 = ({
   onRequest,
   onSseError,
   onSseEvent,
@@ -490,7 +489,7 @@ const createSseClient = ({
   const stream = createStream();
   return { stream };
 };
-const separatorArrayExplode = (style) => {
+const separatorArrayExplode$1 = (style) => {
   switch (style) {
     case "label":
       return ".";
@@ -502,7 +501,7 @@ const separatorArrayExplode = (style) => {
       return "&";
   }
 };
-const separatorArrayNoExplode = (style) => {
+const separatorArrayNoExplode$1 = (style) => {
   switch (style) {
     case "form":
       return ",";
@@ -514,7 +513,7 @@ const separatorArrayNoExplode = (style) => {
       return ",";
   }
 };
-const separatorObjectExplode = (style) => {
+const separatorObjectExplode$1 = (style) => {
   switch (style) {
     case "label":
       return ".";
@@ -526,7 +525,7 @@ const separatorObjectExplode = (style) => {
       return "&";
   }
 };
-const serializeArrayParam = ({
+const serializeArrayParam$1 = ({
   allowReserved,
   explode,
   name: name2,
@@ -534,7 +533,7 @@ const serializeArrayParam = ({
   value
 }) => {
   if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode$1(style));
     switch (style) {
       case "label":
         return `.${joinedValues2}`;
@@ -546,12 +545,12 @@ const serializeArrayParam = ({
         return `${name2}=${joinedValues2}`;
     }
   }
-  const separator = separatorArrayExplode(style);
+  const separator = separatorArrayExplode$1(style);
   const joinedValues = value.map((v) => {
     if (style === "label" || style === "simple") {
       return allowReserved ? v : encodeURIComponent(v);
     }
-    return serializePrimitiveParam({
+    return serializePrimitiveParam$1({
       allowReserved,
       name: name2,
       value: v
@@ -559,7 +558,7 @@ const serializeArrayParam = ({
   }).join(separator);
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
 };
-const serializePrimitiveParam = ({
+const serializePrimitiveParam$1 = ({
   allowReserved,
   name: name2,
   value
@@ -574,7 +573,7 @@ const serializePrimitiveParam = ({
   }
   return `${name2}=${allowReserved ? value : encodeURIComponent(value)}`;
 };
-const serializeObjectParam = ({
+const serializeObjectParam$1 = ({
   allowReserved,
   explode,
   name: name2,
@@ -606,9 +605,9 @@ const serializeObjectParam = ({
         return joinedValues2;
     }
   }
-  const separator = separatorObjectExplode(style);
+  const separator = separatorObjectExplode$1(style);
   const joinedValues = Object.entries(value).map(
-    ([key, v]) => serializePrimitiveParam({
+    ([key, v]) => serializePrimitiveParam$1({
       allowReserved,
       name: style === "deepObject" ? `${name2}[${key}]` : key,
       value: v
@@ -616,10 +615,10 @@ const serializeObjectParam = ({
   ).join(separator);
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
 };
-const PATH_PARAM_RE = /\{[^{}]+\}/g;
-const defaultPathSerializer = ({ path, url: _url }) => {
+const PATH_PARAM_RE$1 = /\{[^{}]+\}/g;
+const defaultPathSerializer$1 = ({ path, url: _url }) => {
   let url = _url;
-  const matches = _url.match(PATH_PARAM_RE);
+  const matches = _url.match(PATH_PARAM_RE$1);
   if (matches) {
     for (const match of matches) {
       let explode = false;
@@ -643,14 +642,14 @@ const defaultPathSerializer = ({ path, url: _url }) => {
       if (Array.isArray(value)) {
         url = url.replace(
           match,
-          serializeArrayParam({ explode, name: name2, style, value })
+          serializeArrayParam$1({ explode, name: name2, style, value })
         );
         continue;
       }
       if (typeof value === "object") {
         url = url.replace(
           match,
-          serializeObjectParam({
+          serializeObjectParam$1({
             explode,
             name: name2,
             style,
@@ -663,7 +662,7 @@ const defaultPathSerializer = ({ path, url: _url }) => {
       if (style === "matrix") {
         url = url.replace(
           match,
-          `;${serializePrimitiveParam({
+          `;${serializePrimitiveParam$1({
             name: name2,
             value
           })}`
@@ -678,7 +677,7 @@ const defaultPathSerializer = ({ path, url: _url }) => {
   }
   return url;
 };
-const getUrl = ({
+const getUrl$1 = ({
   baseUrl,
   path,
   query,
@@ -688,7 +687,7 @@ const getUrl = ({
   const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
   let url = (baseUrl ?? "") + pathUrl;
   if (path) {
-    url = defaultPathSerializer({ path, url });
+    url = defaultPathSerializer$1({ path, url });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -699,7 +698,7 @@ const getUrl = ({
   }
   return url;
 };
-function getValidRequestBody(options) {
+function getValidRequestBody$1(options) {
   const hasBody = options.body !== void 0;
   const isSerializedBody = hasBody && options.bodySerializer;
   if (isSerializedBody) {
@@ -714,7 +713,7 @@ function getValidRequestBody(options) {
   }
   return void 0;
 }
-const getAuthToken = async (auth, callback) => {
+const getAuthToken$1 = async (auth, callback) => {
   const token = typeof callback === "function" ? await callback(auth) : callback;
   if (!token) {
     return;
@@ -727,7 +726,7 @@ const getAuthToken = async (auth, callback) => {
   }
   return token;
 };
-const createQuerySerializer = ({
+const createQuerySerializer$1 = ({
   parameters = {},
   ...args
 } = {}) => {
@@ -741,7 +740,7 @@ const createQuerySerializer = ({
         }
         const options = parameters[name2] || args;
         if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
+          const serializedArray = serializeArrayParam$1({
             allowReserved: options.allowReserved,
             explode: true,
             name: name2,
@@ -751,7 +750,7 @@ const createQuerySerializer = ({
           });
           if (serializedArray) search.push(serializedArray);
         } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
+          const serializedObject = serializeObjectParam$1({
             allowReserved: options.allowReserved,
             explode: true,
             name: name2,
@@ -761,7 +760,7 @@ const createQuerySerializer = ({
           });
           if (serializedObject) search.push(serializedObject);
         } else {
-          const serializedPrimitive = serializePrimitiveParam({
+          const serializedPrimitive = serializePrimitiveParam$1({
             allowReserved: options.allowReserved,
             name: name2,
             value
@@ -774,7 +773,7 @@ const createQuerySerializer = ({
   };
   return querySerializer;
 };
-const getParseAs = (contentType) => {
+const getParseAs$1 = (contentType) => {
   if (!contentType) {
     return "stream";
   }
@@ -798,7 +797,7 @@ const getParseAs = (contentType) => {
   }
   return;
 };
-const checkForExistence = (options, name2) => {
+const checkForExistence$1 = (options, name2) => {
   if (!name2) {
     return false;
   }
@@ -807,15 +806,15 @@ const checkForExistence = (options, name2) => {
   }
   return false;
 };
-const setAuthParams = async ({
+const setAuthParams$1 = async ({
   security,
   ...options
 }) => {
   for (const auth of security) {
-    if (checkForExistence(options, auth.name)) {
+    if (checkForExistence$1(options, auth.name)) {
       continue;
     }
-    const token = await getAuthToken(auth, options.auth);
+    const token = await getAuthToken$1(auth, options.auth);
     if (!token) {
       continue;
     }
@@ -837,35 +836,35 @@ const setAuthParams = async ({
     }
   }
 };
-const buildUrl = (options) => getUrl({
+const buildUrl$1 = (options) => getUrl$1({
   baseUrl: options.baseUrl,
   path: options.path,
   query: options.query,
-  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer$1(options.querySerializer),
   url: options.url
 });
-const mergeConfigs = (a, b) => {
+const mergeConfigs$1 = (a, b) => {
   const config = { ...a, ...b };
   if (config.baseUrl?.endsWith("/")) {
     config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
   }
-  config.headers = mergeHeaders(a.headers, b.headers);
+  config.headers = mergeHeaders$1(a.headers, b.headers);
   return config;
 };
-const headersEntries = (headers) => {
+const headersEntries$1 = (headers) => {
   const entries = [];
   headers.forEach((value, key) => {
     entries.push([key, value]);
   });
   return entries;
 };
-const mergeHeaders = (...headers) => {
+const mergeHeaders$1 = (...headers) => {
   const mergedHeaders = new Headers();
   for (const header of headers) {
     if (!header) {
       continue;
     }
-    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    const iterator = header instanceof Headers ? headersEntries$1(header) : Object.entries(header);
     for (const [key, value] of iterator) {
       if (value === null) {
         mergedHeaders.delete(key);
@@ -883,7 +882,7 @@ const mergeHeaders = (...headers) => {
   }
   return mergedHeaders;
 };
-class Interceptors {
+let Interceptors$1 = class Interceptors {
   fns = [];
   clear() {
     this.fns = [];
@@ -916,13 +915,13 @@ class Interceptors {
     this.fns.push(fn);
     return this.fns.length - 1;
   }
-}
-const createInterceptors = () => ({
-  error: new Interceptors(),
-  request: new Interceptors(),
-  response: new Interceptors()
+};
+const createInterceptors$1 = () => ({
+  error: new Interceptors$1(),
+  request: new Interceptors$1(),
+  response: new Interceptors$1()
 });
-const defaultQuerySerializer = createQuerySerializer({
+const defaultQuerySerializer$1 = createQuerySerializer$1({
   allowReserved: false,
   array: {
     explode: true,
@@ -933,34 +932,34 @@ const defaultQuerySerializer = createQuerySerializer({
     style: "deepObject"
   }
 });
-const defaultHeaders = {
+const defaultHeaders$1 = {
   "Content-Type": "application/json"
 };
-const createConfig = (override = {}) => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
+const createConfig$1 = (override = {}) => ({
+  ...jsonBodySerializer$1,
+  headers: defaultHeaders$1,
   parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
+  querySerializer: defaultQuerySerializer$1,
   ...override
 });
-const createClient = (config = {}) => {
-  let _config = mergeConfigs(createConfig(), config);
+const createClient$1 = (config = {}) => {
+  let _config = mergeConfigs$1(createConfig$1(), config);
   const getConfig = () => ({ ..._config });
   const setConfig = (config2) => {
-    _config = mergeConfigs(_config, config2);
+    _config = mergeConfigs$1(_config, config2);
     return getConfig();
   };
-  const interceptors = createInterceptors();
+  const interceptors = createInterceptors$1();
   const beforeRequest = async (options) => {
     const opts = {
       ..._config,
       ...options,
       fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
+      headers: mergeHeaders$1(_config.headers, options.headers),
       serializedBody: void 0
     };
     if (opts.security) {
-      await setAuthParams({
+      await setAuthParams$1({
         ...opts,
         security: opts.security
       });
@@ -974,7 +973,7 @@ const createClient = (config = {}) => {
     if (opts.body === void 0 || opts.serializedBody === "") {
       opts.headers.delete("Content-Type");
     }
-    const url = buildUrl(opts);
+    const url = buildUrl$1(opts);
     return { opts, url };
   };
   const request = async (options) => {
@@ -982,7 +981,7 @@ const createClient = (config = {}) => {
     const requestInit = {
       redirect: "follow",
       ...opts,
-      body: getValidRequestBody(opts)
+      body: getValidRequestBody$1(opts)
     };
     let request2 = new Request(url, requestInit);
     for (const fn of interceptors.request.fns) {
@@ -1026,7 +1025,7 @@ const createClient = (config = {}) => {
       response
     };
     if (response.ok) {
-      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      const parseAs = (opts.parseAs === "auto" ? getParseAs$1(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
       if (response.status === 204 || response.headers.get("Content-Length") === "0") {
         let emptyData;
         switch (parseAs) {
@@ -1104,7 +1103,7 @@ const createClient = (config = {}) => {
   const makeMethodFn = (method) => (options) => request({ ...options, method });
   const makeSseFn = (method) => async (options) => {
     const { opts, url } = await beforeRequest(options);
-    return createSseClient({
+    return createSseClient$1({
       ...opts,
       body: opts.body,
       headers: opts.headers,
@@ -1122,7 +1121,7 @@ const createClient = (config = {}) => {
     });
   };
   return {
-    buildUrl,
+    buildUrl: buildUrl$1,
     connect: makeMethodFn("CONNECT"),
     delete: makeMethodFn("DELETE"),
     get: makeMethodFn("GET"),
@@ -1149,8 +1148,8 @@ const createClient = (config = {}) => {
     trace: makeMethodFn("TRACE")
   };
 };
-const client = createClient(
-  createConfig({ baseUrl: "https://api.themolt.net" })
+const client = createClient$1(
+  createConfig$1({ baseUrl: "https://api.themolt.net" })
 );
 const startLegreffierOnboarding = (options) => (options.client ?? client).post({
   url: "/public/legreffier/start",
@@ -1161,85 +1160,6 @@ const startLegreffierOnboarding = (options) => (options.client ?? client).post({
   }
 });
 const getLegreffierOnboardingStatus = (options) => (options.client ?? client).get({ url: "/public/legreffier/status/{workflowId}", ...options });
-class MoltNetError extends Error {
-  code;
-  statusCode;
-  detail;
-  constructor(message, options) {
-    super(message);
-    this.name = "MoltNetError";
-    this.code = options.code;
-    this.statusCode = options.statusCode;
-    this.detail = options.detail;
-  }
-}
-function problemToError(problem, statusCode) {
-  return new MoltNetError(problem.title ?? "Request failed", {
-    code: problem.type ?? problem.code ?? "UNKNOWN",
-    statusCode,
-    detail: problem.detail
-  });
-}
-async function writeMcpConfig(mcpConfig, dir2) {
-  const targetDir = dir2 ?? process.cwd();
-  const filePath = join(targetDir, ".mcp.json");
-  let existing = {};
-  try {
-    const content = await readFile(filePath, "utf-8");
-    existing = JSON.parse(content);
-  } catch {
-  }
-  const merged = {
-    ...existing,
-    mcpServers: {
-      ...existing.mcpServers ?? {},
-      ...mcpConfig.mcpServers
-    }
-  };
-  await writeFile(filePath, JSON.stringify(merged, null, 2) + "\n");
-  return filePath;
-}
-function getConfigDir() {
-  return join(homedir(), ".config", "moltnet");
-}
-function getConfigPath(configDir) {
-  return join(configDir ?? getConfigDir(), "moltnet.json");
-}
-async function readConfig(configDir) {
-  const dir2 = configDir ?? getConfigDir();
-  try {
-    const content = await readFile(join(dir2, "moltnet.json"), "utf-8");
-    return JSON.parse(content);
-  } catch {
-  }
-  try {
-    const content = await readFile(join(dir2, "credentials.json"), "utf-8");
-    console.warn("Warning: credentials.json is deprecated. New writes use moltnet.json. Support will be removed in 3 minor versions.");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function writeConfig(config, configDir) {
-  const dir2 = configDir ?? getConfigDir();
-  await mkdir(dir2, { recursive: true });
-  const filePath = join(dir2, "moltnet.json");
-  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", {
-    mode: 384
-  });
-  await chmod(filePath, 384);
-  return filePath;
-}
-async function updateConfigSection(section, data, configDir) {
-  const config = await readConfig(configDir);
-  if (!config) {
-    throw new Error("No config found — run `moltnet register` first");
-  }
-  const existing = config[section] ?? {};
-  const updated = { ...existing, ...data };
-  Object.assign(config, { [section]: updated });
-  await writeConfig(config, configDir);
-}
 /*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
 const ed25519_CURVE = {
   p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
@@ -1716,175 +1636,901 @@ const wNAF = (n) => {
   }
   return { p, f };
 };
-etc.sha512Sync = (...m) => {
-  const hash = createHash("sha512");
-  m.forEach((msg) => hash.update(msg));
-  return hash.digest();
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(
+    body,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  )
 };
-const DOMAIN_PREFIX = "moltnet:v1";
-function buildSigningBytes(message, nonce) {
-  const msgHash = createHash("sha256").update(Buffer.from(message, "utf-8")).digest();
-  const nonceBytes = Buffer.from(nonce, "utf-8");
-  const prefix = Buffer.from(DOMAIN_PREFIX, "utf-8");
-  const buf = Buffer.alloc(
-    prefix.length + 4 + msgHash.length + 4 + nonceBytes.length
-  );
-  let offset = 0;
-  prefix.copy(buf, offset);
-  offset += prefix.length;
-  buf.writeUInt32BE(msgHash.length, offset);
-  offset += 4;
-  msgHash.copy(buf, offset);
-  offset += msgHash.length;
-  buf.writeUInt32BE(nonceBytes.length, offset);
-  offset += 4;
-  nonceBytes.copy(buf, offset);
-  return new Uint8Array(buf);
-}
-const cryptoService = {
-  /**
-   * Generate a new Ed25519 keypair
-   */
-  async generateKeyPair() {
-    const privateKeyBytes = utils.randomPrivateKey();
-    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
-    const privateKey = Buffer.from(privateKeyBytes).toString("base64");
-    const publicKey = `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
-    const fingerprint = this.generateFingerprint(publicKeyBytes);
-    return { publicKey, privateKey, fingerprint };
-  },
-  /**
-   * Generate human-readable fingerprint from public key
-   * Format: A1B2-C3D4-E5F6-G7H8 (first 16 hex chars of SHA256)
-   */
-  generateFingerprint(publicKeyBytes) {
-    const hash = createHash("sha256").update(publicKeyBytes).digest("hex");
-    const segments = hash.slice(0, 16).toUpperCase().match(/.{4}/g) ?? [];
-    return segments.join("-");
-  },
-  /**
-   * Parse public key from string format
-   */
-  parsePublicKey(publicKey) {
-    const base64 = publicKey.replace(/^ed25519:/, "");
-    return new Uint8Array(Buffer.from(base64, "base64"));
-  },
-  /**
-   * Sign a message with private key
-   */
-  async sign(message, privateKeyBase64) {
-    const privateKeyBytes = new Uint8Array(
-      Buffer.from(privateKeyBase64, "base64")
-    );
-    const messageBytes = new TextEncoder().encode(message);
-    const signature = await signAsync(messageBytes, privateKeyBytes);
-    return Buffer.from(signature).toString("base64");
-  },
-  /**
-   * Verify a signature against a message and public key
-   */
-  async verify(message, signature, publicKey) {
-    try {
-      const publicKeyBytes = this.parsePublicKey(publicKey);
-      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
-      const messageBytes = new TextEncoder().encode(message);
-      return await verifyAsync(signatureBytes, messageBytes, publicKeyBytes);
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Sign a (message, nonce) pair using deterministic pre-hash.
-   * Uses buildSigningBytes for domain separation and canonical serialization.
-   */
-  async signWithNonce(message, nonce, privateKeyBase64) {
-    const privateKeyBytes = new Uint8Array(
-      Buffer.from(privateKeyBase64, "base64")
-    );
-    const signingBytes = buildSigningBytes(message, nonce);
-    const signature = await signAsync(signingBytes, privateKeyBytes);
-    return Buffer.from(signature).toString("base64");
-  },
-  /**
-   * Verify a signature produced by signWithNonce.
-   */
-  async verifyWithNonce(message, nonce, signature, publicKey) {
-    try {
-      const publicKeyBytes = this.parsePublicKey(publicKey);
-      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
-      const signingBytes = buildSigningBytes(message, nonce);
-      return await verifyAsync(signatureBytes, signingBytes, publicKeyBytes);
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * Create a signed message object
-   */
-  async createSignedMessage(message, privateKeyBase64, publicKey) {
-    const signature = await this.sign(message, privateKeyBase64);
-    return { message, signature, publicKey };
-  },
-  /**
-   * Verify a signed message object
-   */
-  async verifySignedMessage(signedMessage) {
-    return this.verify(
-      signedMessage.message,
-      signedMessage.signature,
-      signedMessage.publicKey
-    );
-  },
-  /**
-   * Generate a random challenge for authentication
-   */
-  generateChallenge() {
-    return `moltnet:challenge:${randomBytes$1(32).toString("hex")}:${Date.now()}`;
-  },
-  /**
-   * Derive public key from private key
-   */
-  async derivePublicKey(privateKeyBase64) {
-    const privateKeyBytes = new Uint8Array(
-      Buffer.from(privateKeyBase64, "base64")
+const createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(
+            `SSE failed: ${response.status} ${response.statusText}`
+          );
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(
+                    line.replace(/^retry:\s*/, ""),
+                    10
+                  );
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent == null ? void 0 : onSseEvent({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError == null ? void 0 : onSseError(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(
+          retryDelay * 2 ** (attempt - 1),
+          sseMaxRetryDelay ?? 3e4
+        );
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+const separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+const separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+const separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+const serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name: name2,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name2}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name2}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name: name2,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({
+  allowReserved,
+  name: name2,
+  value
+}) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these."
     );
-    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
-    return `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
-  },
-  /**
-   * Get fingerprint from public key string
-   */
-  getFingerprintFromPublicKey(publicKey) {
-    const publicKeyBytes = this.parsePublicKey(publicKey);
-    return this.generateFingerprint(publicKeyBytes);
-  },
-  /**
-   * Create a proof of identity ownership (for DCR metadata)
-   */
-  async createIdentityProof(identityId, privateKeyBase64) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const message = `moltnet:register:${identityId}:${timestamp}`;
-    const signature = await this.sign(message, privateKeyBase64);
-    return { message, signature, timestamp };
-  },
-  /**
-   * Verify an identity proof
-   */
-  async verifyIdentityProof(proof, publicKey, expectedIdentityId) {
-    const isValid = await this.verify(
-      proof.message,
-      proof.signature,
-      publicKey
+  }
+  return `${name2}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name: name2,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name2}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values2 = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values2 = [
+        ...values2,
+        key,
+        allowReserved ? v : encodeURIComponent(v)
+      ];
+    });
+    const joinedValues2 = values2.join(",");
+    switch (style) {
+      case "form":
+        return `${name2}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name2}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name2}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name2 = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name2.endsWith("*")) {
+        explode = true;
+        name2 = name2.substring(0, name2.length - 1);
+      }
+      if (name2.startsWith(".")) {
+        name2 = name2.substring(1);
+        style = "label";
+      } else if (name2.startsWith(";")) {
+        name2 = name2.substring(1);
+        style = "matrix";
+      }
+      const value = path[name2];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(
+          match,
+          serializeArrayParam({ explode, name: name2, style, value })
+        );
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name: name2,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name: name2,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(
+        style === "label" ? `.${value}` : value
+      );
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+const getUrl = ({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+const getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+const createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name2 in queryParams) {
+        const value = queryParams[name2];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name2] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name: name2,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name: name2,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name: name2,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+const getParseAs = (contentType) => {
+  var _a2;
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = (_a2 = contentType.split(";")[0]) == null ? void 0 : _a2.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some(
+    (type) => cleanContent.startsWith(type)
+  )) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+const checkForExistence = (options, name2) => {
+  var _a2, _b;
+  if (!name2) {
+    return false;
+  }
+  if (options.headers.has(name2) || ((_a2 = options.query) == null ? void 0 : _a2[name2]) || ((_b = options.headers.get("Cookie")) == null ? void 0 : _b.includes(`${name2}=`))) {
+    return true;
+  }
+  return false;
+};
+const setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name2 = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name2] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name2}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name2, token);
+        break;
+    }
+  }
+};
+const buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+const mergeConfigs = (a, b) => {
+  var _a2;
+  const config = { ...a, ...b };
+  if ((_a2 = config.baseUrl) == null ? void 0 : _a2.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+const headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+const mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : value
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+class Interceptors2 {
+  constructor() {
+    __publicField(this, "fns", []);
+  }
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+}
+const createInterceptors = () => ({
+  error: new Interceptors2(),
+  request: new Interceptors2(),
+  response: new Interceptors2()
+});
+const defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+const defaultHeaders = {
+  "Content-Type": "application/json"
+};
+const createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+const createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response;
+    try {
+      response = await _fetch(request2);
+    } catch (error2) {
+      let finalError2 = error2;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(
+            error2,
+            void 0,
+            request2,
+            opts
+          );
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? void 0 : {
+        error: finalError2,
+        request: request2,
+        response: void 0
+      };
+    }
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData();
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === "data" ? emptyData : {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "json":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+    }
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? void 0 : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+createClient(
+  createConfig({ baseUrl: "https://api.themolt.net" })
+);
+class MoltNetError extends Error {
+  constructor(message, options) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "statusCode");
+    __publicField(this, "detail");
+    this.name = "MoltNetError";
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+    this.detail = options.detail;
+  }
+}
+function problemToError(problem, statusCode) {
+  return new MoltNetError(problem.title ?? "Request failed", {
+    code: problem.type ?? problem.code ?? "UNKNOWN",
+    statusCode,
+    detail: problem.detail
+  });
+}
+async function writeMcpConfig(mcpConfig, dir2) {
+  const targetDir = dir2 ?? process.cwd();
+  const filePath = join(targetDir, ".mcp.json");
+  let existing = {};
+  try {
+    const content = await readFile(filePath, "utf-8");
+    existing = JSON.parse(content);
+  } catch {
+  }
+  const merged = {
+    ...existing,
+    mcpServers: {
+      ...existing.mcpServers ?? {},
+      ...mcpConfig.mcpServers
+    }
+  };
+  await writeFile(filePath, JSON.stringify(merged, null, 2) + "\n");
+  return filePath;
+}
+function getConfigDir() {
+  return join(homedir(), ".config", "moltnet");
+}
+function getConfigPath(configDir) {
+  return join(configDir ?? getConfigDir(), "moltnet.json");
+}
+async function readConfig(configDir) {
+  const dir2 = configDir ?? getConfigDir();
+  try {
+    const content = await readFile(join(dir2, "moltnet.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+  }
+  try {
+    const content = await readFile(join(dir2, "credentials.json"), "utf-8");
+    console.warn(
+      "Warning: credentials.json is deprecated. New writes use moltnet.json. Support will be removed in 3 minor versions."
     );
-    if (!isValid) return false;
-    const expectedPrefix = `moltnet:register:${expectedIdentityId}:`;
-    if (!proof.message.startsWith(expectedPrefix)) return false;
-    const proofTime = new Date(proof.timestamp).getTime();
-    const now = Date.now();
-    const fiveMinutes = 5 * 60 * 1e3;
-    if (now - proofTime > fiveMinutes) return false;
-    return true;
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeConfig(config, configDir) {
+  const dir2 = configDir ?? getConfigDir();
+  await mkdir(dir2, { recursive: true });
+  const filePath = join(dir2, "moltnet.json");
+  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+  await chmod(filePath, 384);
+  return filePath;
+}
+async function updateConfigSection(section, data, configDir) {
+  const config = await readConfig(configDir);
+  if (!config) {
+    throw new Error("No config found — run `moltnet register` first");
   }
+  const existing = config[section] ?? {};
+  const updated = { ...existing, ...data };
+  Object.assign(config, { [section]: updated });
+  await writeConfig(config, configDir);
+}
+etc.sha512Sync = (...m) => {
+  const hash = createHash("sha512");
+  m.forEach((msg) => hash.update(msg));
+  return hash.digest();
 };
 if (!etc.sha512Sync) {
   etc.sha512Sync = (...m) => {
@@ -1990,19 +2636,25 @@ function toSSHPrivateKey(seedBase64) {
   ].join("\n");
 }
 async function exportSSHKey(opts) {
-  const config = await readConfig(opts?.configDir);
+  const config = await readConfig(opts == null ? void 0 : opts.configDir);
   if (!config) {
-    throw new Error(`No config found at ${getConfigPath(opts?.configDir)} — run \`moltnet register\` first`);
+    throw new Error(
+      `No config found at ${getConfigPath(opts == null ? void 0 : opts.configDir)} — run \`moltnet register\` first`
+    );
   }
   const privateKeySSH = toSSHPrivateKey(config.keys.private_key);
   const publicKeySSH = toSSHPublicKey(config.keys.public_key);
-  const outputDir = opts?.outputDir ?? join(opts?.configDir ?? getConfigDir(), "ssh");
+  const outputDir = (opts == null ? void 0 : opts.outputDir) ?? join((opts == null ? void 0 : opts.configDir) ?? getConfigDir(), "ssh");
   await mkdir(outputDir, { recursive: true });
   const privatePath = join(outputDir, "id_ed25519");
   const publicPath = join(outputDir, "id_ed25519.pub");
   await writeFile(privatePath, privateKeySSH, { mode: 384 });
   await writeFile(publicPath, publicKeySSH, { mode: 420 });
-  await updateConfigSection("ssh", { private_key_path: privatePath, public_key_path: publicPath }, opts?.configDir);
+  await updateConfigSection(
+    "ssh",
+    { private_key_path: privatePath, public_key_path: publicPath },
+    opts == null ? void 0 : opts.configDir
+  );
   return { privatePath, publicPath };
 }
 const POLL_INTERVAL_MS = 5e3;
@@ -2020,7 +2672,7 @@ function toErrorMessage(err2) {
 }
 const POLL_TIMEOUT_MS = 5 * 60 * 1e3;
 function makeClient(baseUrl) {
-  return createClient({ baseUrl });
+  return createClient$1({ baseUrl });
 }
 async function startOnboarding(baseUrl, body) {
   const client2 = makeClient(baseUrl);
@@ -2067,24 +2719,49 @@ async function pollUntil(baseUrl, workflowId, targetStatuses, onTick) {
     `Timed out waiting for status: ${targetStatuses.join(" or ")}`
   );
 }
+const SKILL_DIRS = {
+  claude: ".claude/skills"
+  // codex: '.agents/skills',
+};
+const SKILL_VERSION = "legreffier-v0.1.0";
 const SKILLS = [
   {
     name: "legreffier",
-    url: "https://raw.githubusercontent.com/getlarge/themoltnet/main/.claude/skills/legreffier/SKILL.md"
+    url: `https://raw.githubusercontent.com/getlarge/themoltnet/${SKILL_VERSION}/.claude/skills/legreffier/SKILL.md`
   }
 ];
-async function downloadSkills(repoDir) {
+async function downloadSkills(repoDir, agentTypes) {
+  const dirs = agentTypes.map((t) => SKILL_DIRS[t]).filter((d) => !!d);
+  if (dirs.length === 0) return;
   for (const skill of SKILLS) {
-    const dir2 = join(repoDir, ".claude", "skills", skill.name);
-    await mkdir(dir2, { recursive: true });
     const res = await fetch(skill.url);
     if (!res.ok) {
       throw new Error(`Failed to download skill ${skill.name} (${res.status})`);
     }
     const content = await res.text();
-    await writeFile(join(dir2, "SKILL.md"), content, "utf-8");
+    for (const skillDir of dirs) {
+      const destDir = join(repoDir, skillDir, skill.name);
+      await mkdir(destDir, { recursive: true });
+      await writeFile(join(destDir, "SKILL.md"), content, "utf-8");
+    }
   }
 }
+function buildPermissions(agentName) {
+  return [
+    // Read-only git commands used by session activation & commit workflow
+    "Bash(git config *)",
+    "Bash(git diff *)",
+    "Bash(git log *)",
+    "Bash(git rev-parse *)",
+    "Bash(git worktree list)",
+    // Signing CLI
+    "Bash(moltnet sign *)",
+    // Worktree symlink creation
+    "Bash(ln -s *)",
+    // All MCP tools for this agent's server
+    `mcp__${agentName}__*`
+  ];
+}
 function toEnvPrefix(agentName) {
   return agentName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
 }
@@ -2106,9 +2783,23 @@ async function writeSettingsLocal({
   } catch {
   }
   const prefix = toEnvPrefix(agentName);
+  const existingServers = Array.isArray(
+    existing.enabledMcpjsonServers
+  ) ? existing.enabledMcpjsonServers : [];
+  const enabledMcpjsonServers = existingServers.includes(agentName) ? existingServers : [...existingServers, agentName];
+  const newPerms = buildPermissions(agentName);
+  const existingAllow = Array.isArray(existing.permissions?.allow) ? existing.permissions.allow : [];
+  const mergedAllow = [
+    ...existingAllow,
+    ...newPerms.filter((p) => !existingAllow.includes(p))
+  ];
   const settings = {
     ...existing,
-    enableAllProjectMcpServers: true,
+    enabledMcpjsonServers,
+    permissions: {
+      ...existing.permissions,
+      allow: mergedAllow
+    },
     env: {
       ...existing.env,
       [`${prefix}_GITHUB_APP_ID`]: appSlug,
@@ -2120,49 +2811,27 @@ async function writeSettingsLocal({
   };
   await writeFile(filePath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
 }
-function deriveProjectSlug(cwd = process.cwd()) {
-  try {
-    const origin = execSync("git remote get-url origin", {
-      cwd,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).toString().trim();
-    const match = origin.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
-    if (match) {
-      return match[1].replace("/", "-");
-    }
-  } catch {
-  }
-  return basename(cwd);
-}
-function getStatePath(projectSlug, agentName) {
-  return join(
-    homedir(),
-    ".config",
-    "moltnet",
-    projectSlug,
-    `legreffier-init.${agentName}.state.json`
-  );
+function getStatePath(configDir) {
+  return join(configDir, "legreffier-init.state.json");
 }
-async function readState(projectSlug, agentName) {
+async function readState(configDir) {
   try {
-    const raw = await readFile(getStatePath(projectSlug, agentName), "utf-8");
+    const raw = await readFile(getStatePath(configDir), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
-async function writeState(state, projectSlug, agentName) {
-  const path = getStatePath(projectSlug, agentName);
-  await mkdir(join(homedir(), ".config", "moltnet", projectSlug), {
-    recursive: true
-  });
+async function writeState(state, configDir) {
+  await mkdir(configDir, { recursive: true });
+  const path = getStatePath(configDir);
   await writeFile(path, JSON.stringify(state, null, 2) + "\n", {
     mode: 384
   });
 }
-async function clearState(projectSlug, agentName) {
+async function clearState(configDir) {
   try {
-    await rm(getStatePath(projectSlug, agentName));
+    await rm(getStatePath(configDir));
   } catch {
   }
 }
@@ -2172,6 +2841,7 @@ async function runAgentSetupPhase(opts) {
     repoDir,
     configDir,
     agentName,
+    agentTypes,
     publicKey,
     fingerprint,
     appSlug,
@@ -2180,7 +2850,6 @@ async function runAgentSetupPhase(opts) {
     identityId,
     clientId,
     clientSecret,
-    projectSlug,
     dispatch
   } = opts;
   dispatch({ type: "phase", phase: "agent_setup" });
@@ -2230,7 +2899,7 @@ async function runAgentSetupPhase(opts) {
     );
   }
   dispatch({ type: "step", key: "skills", status: "running" });
-  await downloadSkills(repoDir);
+  await downloadSkills(repoDir, agentTypes);
   dispatch({ type: "step", key: "skills", status: "done" });
   dispatch({ type: "step", key: "settings", status: "running" });
   await writeSettingsLocal({
@@ -2243,7 +2912,7 @@ async function runAgentSetupPhase(opts) {
     clientSecret
   });
   dispatch({ type: "step", key: "settings", status: "done" });
-  await clearState(projectSlug, agentName);
+  await clearState(configDir);
 }
 async function exchangeManifestCode(code) {
   const res = await fetch(
@@ -2326,10 +2995,9 @@ async function lookupBotUser(appSlug, { maxRetries = 5, baseDelayMs = 2e3 } = {}
   }
   throw new Error(`GitHub user lookup failed for app "${appSlug}"`);
 }
-async function writePem(pem, appSlug, projectSlug) {
-  const dir2 = join(homedir(), ".config", "moltnet", projectSlug);
-  await mkdir(dir2, { recursive: true });
-  const path = join(dir2, `${appSlug}.pem`);
+async function writePem(pem, appSlug, configDir) {
+  await mkdir(configDir, { recursive: true });
+  const path = join(configDir, `${appSlug}.pem`);
   await writeFile(path, pem, { mode: 384 });
   await chmod(path, 384);
   return path;
@@ -2361,7 +3029,6 @@ async function runGithubAppPhase(opts) {
     apiUrl: apiUrl2,
     agentName,
     configDir,
-    projectSlug,
     publicKey,
     privateKey,
     fingerprint,
@@ -2370,7 +3037,7 @@ async function runGithubAppPhase(opts) {
     dispatch
   } = opts;
   const existingConfig = await readConfig(configDir);
-  const existingState = await readState(projectSlug, agentName);
+  const existingState = await readState(configDir);
   if (existingConfig?.github?.app_id) {
     dispatch({ type: "step", key: "githubApp", status: "skipped" });
     dispatch({
@@ -2385,13 +3052,7 @@ async function runGithubAppPhase(opts) {
     };
   }
   if (existingState?.appSlug && existingState?.appId) {
-    const pemPath2 = join(
-      homedir(),
-      ".config",
-      "moltnet",
-      projectSlug,
-      `${existingState.appSlug}.pem`
-    );
+    const pemPath2 = join(configDir, `${existingState.appSlug}.pem`);
     dispatch({ type: "step", key: "githubApp", status: "skipped" });
     dispatch({ type: "appSlug", appSlug: existingState.appSlug });
     return {
@@ -2416,7 +3077,7 @@ async function runGithubAppPhase(opts) {
   }
   const ghCreds = await exchangeManifestCode(codeResult.githubCode);
   dispatch({ type: "appSlug", appSlug: ghCreds.appSlug });
-  const pemPath = await writePem(ghCreds.pem, ghCreds.appSlug, projectSlug);
+  const pemPath = await writePem(ghCreds.pem, ghCreds.appSlug, configDir);
   await writeState(
     {
       workflowId,
@@ -2428,8 +3089,7 @@ async function runGithubAppPhase(opts) {
       appId: ghCreds.appId,
       appSlug: ghCreds.appSlug
     },
-    projectSlug,
-    agentName
+    configDir
   );
   dispatch({ type: "step", key: "githubApp", status: "done" });
   return {
@@ -2468,10 +3128,187 @@ async function runGitSetupPhase(opts) {
   );
   dispatch({ type: "step", key: "gitSetup", status: "done" });
 }
+etc.sha512Sync = (...m) => {
+  const hash = createHash("sha512");
+  m.forEach((msg) => hash.update(msg));
+  return hash.digest();
+};
+const DOMAIN_PREFIX = "moltnet:v1";
+function buildSigningBytes(message, nonce) {
+  const msgHash = createHash("sha256").update(Buffer.from(message, "utf-8")).digest();
+  const nonceBytes = Buffer.from(nonce, "utf-8");
+  const prefix = Buffer.from(DOMAIN_PREFIX, "utf-8");
+  const buf = Buffer.alloc(
+    prefix.length + 4 + msgHash.length + 4 + nonceBytes.length
+  );
+  let offset = 0;
+  prefix.copy(buf, offset);
+  offset += prefix.length;
+  buf.writeUInt32BE(msgHash.length, offset);
+  offset += 4;
+  msgHash.copy(buf, offset);
+  offset += msgHash.length;
+  buf.writeUInt32BE(nonceBytes.length, offset);
+  offset += 4;
+  nonceBytes.copy(buf, offset);
+  return new Uint8Array(buf);
+}
+const cryptoService = {
+  /**
+   * Generate a new Ed25519 keypair
+   */
+  async generateKeyPair() {
+    const privateKeyBytes = utils.randomPrivateKey();
+    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
+    const privateKey = Buffer.from(privateKeyBytes).toString("base64");
+    const publicKey = `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
+    const fingerprint = this.generateFingerprint(publicKeyBytes);
+    return { publicKey, privateKey, fingerprint };
+  },
+  /**
+   * Generate human-readable fingerprint from public key
+   * Format: A1B2-C3D4-E5F6-G7H8 (first 16 hex chars of SHA256)
+   */
+  generateFingerprint(publicKeyBytes) {
+    const hash = createHash("sha256").update(publicKeyBytes).digest("hex");
+    const segments = hash.slice(0, 16).toUpperCase().match(/.{4}/g) ?? [];
+    return segments.join("-");
+  },
+  /**
+   * Parse public key from string format
+   */
+  parsePublicKey(publicKey) {
+    const base64 = publicKey.replace(/^ed25519:/, "");
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  },
+  /**
+   * Sign a message with private key
+   */
+  async sign(message, privateKeyBase64) {
+    const privateKeyBytes = new Uint8Array(
+      Buffer.from(privateKeyBase64, "base64")
+    );
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = await signAsync(messageBytes, privateKeyBytes);
+    return Buffer.from(signature).toString("base64");
+  },
+  /**
+   * Verify a signature against a message and public key
+   */
+  async verify(message, signature, publicKey) {
+    try {
+      const publicKeyBytes = this.parsePublicKey(publicKey);
+      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
+      const messageBytes = new TextEncoder().encode(message);
+      return await verifyAsync(signatureBytes, messageBytes, publicKeyBytes);
+    } catch {
+      return false;
+    }
+  },
+  /**
+   * Sign a (message, nonce) pair using deterministic pre-hash.
+   * Uses buildSigningBytes for domain separation and canonical serialization.
+   */
+  async signWithNonce(message, nonce, privateKeyBase64) {
+    const privateKeyBytes = new Uint8Array(
+      Buffer.from(privateKeyBase64, "base64")
+    );
+    const signingBytes = buildSigningBytes(message, nonce);
+    const signature = await signAsync(signingBytes, privateKeyBytes);
+    return Buffer.from(signature).toString("base64");
+  },
+  /**
+   * Verify a signature produced by signWithNonce.
+   */
+  async verifyWithNonce(message, nonce, signature, publicKey) {
+    try {
+      const publicKeyBytes = this.parsePublicKey(publicKey);
+      const signatureBytes = new Uint8Array(Buffer.from(signature, "base64"));
+      const signingBytes = buildSigningBytes(message, nonce);
+      return await verifyAsync(signatureBytes, signingBytes, publicKeyBytes);
+    } catch {
+      return false;
+    }
+  },
+  /**
+   * Create a signed message object
+   */
+  async createSignedMessage(message, privateKeyBase64, publicKey) {
+    const signature = await this.sign(message, privateKeyBase64);
+    return { message, signature, publicKey };
+  },
+  /**
+   * Verify a signed message object
+   */
+  async verifySignedMessage(signedMessage) {
+    return this.verify(
+      signedMessage.message,
+      signedMessage.signature,
+      signedMessage.publicKey
+    );
+  },
+  /**
+   * Generate a random challenge for authentication
+   */
+  generateChallenge() {
+    return `moltnet:challenge:${randomBytes$1(32).toString("hex")}:${Date.now()}`;
+  },
+  /**
+   * Derive public key from private key
+   */
+  async derivePublicKey(privateKeyBase64) {
+    const privateKeyBytes = new Uint8Array(
+      Buffer.from(privateKeyBase64, "base64")
+    );
+    const publicKeyBytes = await getPublicKeyAsync(privateKeyBytes);
+    return `ed25519:${Buffer.from(publicKeyBytes).toString("base64")}`;
+  },
+  /**
+   * Get fingerprint from public key string
+   */
+  getFingerprintFromPublicKey(publicKey) {
+    const publicKeyBytes = this.parsePublicKey(publicKey);
+    return this.generateFingerprint(publicKeyBytes);
+  },
+  /**
+   * Create a proof of identity ownership (for DCR metadata)
+   */
+  async createIdentityProof(identityId, privateKeyBase64) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const message = `moltnet:register:${identityId}:${timestamp}`;
+    const signature = await this.sign(message, privateKeyBase64);
+    return { message, signature, timestamp };
+  },
+  /**
+   * Verify an identity proof
+   */
+  async verifyIdentityProof(proof, publicKey, expectedIdentityId) {
+    const isValid = await this.verify(
+      proof.message,
+      proof.signature,
+      publicKey
+    );
+    if (!isValid) return false;
+    const expectedPrefix = `moltnet:register:${expectedIdentityId}:`;
+    if (!proof.message.startsWith(expectedPrefix)) return false;
+    const proofTime = new Date(proof.timestamp).getTime();
+    const now = Date.now();
+    const fiveMinutes = 5 * 60 * 1e3;
+    if (now - proofTime > fiveMinutes) return false;
+    return true;
+  }
+};
+if (!etc.sha512Sync) {
+  etc.sha512Sync = (...m) => {
+    const hash = createHash("sha512");
+    m.forEach((msg) => hash.update(msg));
+    return hash.digest();
+  };
+}
 async function runIdentityPhase(opts) {
-  const { apiUrl: apiUrl2, agentName, configDir, projectSlug, dispatch } = opts;
+  const { apiUrl: apiUrl2, agentName, configDir, dispatch } = opts;
   const existingConfig = await readConfig(configDir);
-  const existingState = await readState(projectSlug, agentName);
+  const existingState = await readState(configDir);
   if (existingConfig?.keys?.public_key && existingConfig?.oauth2?.client_id) {
     dispatch({ type: "step", key: "keypair", status: "skipped" });
     dispatch({ type: "step", key: "register", status: "skipped" });
@@ -2527,7 +3364,7 @@ async function runIdentityPhase(opts) {
         skipped: true
       };
     }
-    await clearState(projectSlug, agentName);
+    await clearState(configDir);
   }
   const available = await checkAppNameAvailable(agentName);
   if (!available) {
@@ -2554,8 +3391,7 @@ async function runIdentityPhase(opts) {
       agentName,
       phase: "awaiting_github"
     },
-    projectSlug,
-    agentName
+    configDir
   );
   await writeConfig(
     {
@@ -2614,6 +3450,7 @@ async function runInstallationPhase(opts) {
     clientSecret: result.clientSecret ?? ""
   };
 }
+const SUPPORTED_AGENTS = ["claude"];
 const AGENTS = [
   {
     id: "claude",
@@ -2643,7 +3480,7 @@ function AgentSelect({ onSelect }) {
       setSelected((i) => i < AGENTS.length - 1 ? i + 1 : i);
     } else if (key.return) {
       const agent2 = AGENTS[selected];
-      if (agent2 && agent2.available) {
+      if (agent2?.available && SUPPORTED_AGENTS.includes(agent2.id)) {
         onSelect(agent2.id);
       }
     }
@@ -2929,19 +3766,16 @@ function InitApp({
     void (async () => {
       try {
         const configDir = join(dir2, ".moltnet", name2);
-        const projectSlug = deriveProjectSlug(dir2);
         const identity = await runIdentityPhase({
           apiUrl: apiUrl2,
           agentName: name2,
           configDir,
-          projectSlug,
           dispatch
         });
         const githubApp = await runGithubAppPhase({
           apiUrl: apiUrl2,
           agentName: name2,
           configDir,
-          projectSlug,
           publicKey: identity.publicKey,
           privateKey: identity.privateKey,
           fingerprint: identity.fingerprint,
@@ -2967,6 +3801,7 @@ function InitApp({
           repoDir: dir2,
           configDir,
           agentName: name2,
+          agentTypes: selectedAgent ? [selectedAgent] : [],
           publicKey: identity.publicKey,
           fingerprint: identity.fingerprint,
           appSlug: githubApp.appSlug,
@@ -2975,7 +3810,6 @@ function InitApp({
           identityId: installation.identityId,
           clientId: installation.clientId || identity.clientId,
           clientSecret: installation.clientSecret || identity.clientSecret,
-          projectSlug,
           dispatch
         });
         const mcpUrl = apiUrl2.replace("://api.", "://mcp.") + "/mcp";
@@ -3031,7 +3865,6 @@ function InitApp({
     }
   );
 }
-const SUPPORTED_AGENTS = ["claude"];
 const { values } = parseArgs({
   args: process.argv.slice(2),
   options: {
@@ -3051,6 +3884,14 @@ if (!name) {
   );
   process.exit(1);
 }
+const AGENT_NAME_RE = /^[a-z0-9][a-z0-9-]{0,37}[a-z0-9]$/;
+if (!AGENT_NAME_RE.test(name)) {
+  process.stderr.write(
+    `Invalid agent name: "${name}". Must be 2-39 lowercase alphanumeric characters or hyphens, starting and ending with a letter or digit.
+`
+  );
+  process.exit(1);
+}
 if (agentFlag && !SUPPORTED_AGENTS.includes(agentFlag)) {
   process.stderr.write(
     `Unsupported agent: ${agentFlag}. Supported: ${SUPPORTED_AGENTS.join(", ")}