@agentproto/cli 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import * as childProc from 'child_process';
 import { execFile, spawn } from 'child_process';
 import { createHash, randomUUID, randomBytes } from 'crypto';
-import { mkdtemp, writeFile, chmod, rm, mkdir, unlink, readFile, readdir, stat } from 'fs/promises';
+import { mkdtemp, writeFile, chmod, rm, mkdir, readFile, unlink, readdir, stat } from 'fs/promises';
 import { tmpdir, userInfo, hostname, homedir, platform } from 'os';
 import { resolve, join, dirname, isAbsolute, normalize, relative, basename } from 'path';
 import { promisify, parseArgs } from 'util';
@@ -106,8 +106,8 @@ async function collectAgentprotoNamespaceRoots(start) {
   for (let depth = 0; depth < 16; depth++) {
     for (const candidate of candidatesAt(cur)) {
       try {
-        const stat2 = await promises.stat(candidate);
-        if (stat2.isDirectory()) roots.push(candidate);
+        const stat3 = await promises.stat(candidate);
+        if (stat3.isDirectory()) roots.push(candidate);
       } catch {
       }
     }
@@ -485,9 +485,315 @@ async function saveLedger(path, ledger) {
   await chmod(path, 384).catch(() => {
   });
 }
+async function runInstallProfile(slug, args) {
+  const { values } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    strict: true,
+    options: {
+      force: { type: "boolean", short: "f" },
+      "dry-run": { type: "boolean" },
+      "skip-setup": { type: "boolean" },
+      cwd: { type: "string" },
+      package: { type: "string" }
+    }
+  });
+  if (!slug.startsWith("runtime-profile/")) {
+    process.stderr.write(
+      `agentproto install: expected slug starting with 'runtime-profile/', got '${slug}'.
+`
+    );
+    return 2;
+  }
+  const profileName = slug.slice("runtime-profile/".length);
+  if (!/^[a-z][a-z0-9-]*$/.test(profileName)) {
+    process.stderr.write(
+      `agentproto install: invalid profile name '${profileName}'. Lower-kebab only.
+`
+    );
+    return 2;
+  }
+  let packageName;
+  if (typeof values.package === "string" && values.package) {
+    packageName = values.package;
+  } else {
+    const aliased = await readProfileAlias(profileName);
+    packageName = aliased ?? `@agentproto/runtime-profile-${profileName}`;
+  }
+  let mod;
+  try {
+    mod = await import(packageName);
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `agentproto install: could not load profile package '${packageName}'. Install it first with: npm i -g ${packageName}
+  cause: ${cause}
+`
+    );
+    return 1;
+  }
+  const filesDir = typeof mod.FILES_DIR === "string" ? mod.FILES_DIR : null;
+  const loadProfileManifest = mod.loadProfileManifest;
+  if (!filesDir || !loadProfileManifest) {
+    process.stderr.write(
+      `agentproto install: profile package '${packageName}' does not export FILES_DIR + loadProfileManifest.
+`
+    );
+    return 1;
+  }
+  const manifest = await loadProfileManifest();
+  const cwd = values.cwd ? resolve(values.cwd) : process.cwd();
+  const dryRun = values["dry-run"] === true;
+  const force = values.force === true;
+  process.stdout.write(
+    `agentproto install ${slug} v${manifest.version} \u2192 ${cwd}
+  ${manifest.description}
+`
+  );
+  const ledgerPath = ledgerPathFor2(profileName);
+  const prevLedger = await loadLedger2(ledgerPath);
+  const newLedger = {
+    slug,
+    version: manifest.version,
+    installedAt: prevLedger?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: []
+  };
+  let applied = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const entry of manifest.files) {
+    const src = resolve(filesDir, entry.src);
+    const dest = resolve(cwd, entry.dest);
+    const prev = prevLedger?.files.find((f) => f.dest === entry.dest) ?? null;
+    try {
+      const srcBuf = await readFile(src);
+      const result = await applyStrategy({
+        strategy: entry.strategy,
+        srcBuf,
+        dest,
+        prev,
+        force,
+        dryRun
+      });
+      newLedger.files.push({
+        dest: entry.dest,
+        strategy: entry.strategy,
+        hashAfter: result.hashAfter,
+        appliedAt: result.wrote ? (/* @__PURE__ */ new Date()).toISOString() : prev?.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (result.wrote) {
+        applied += 1;
+        process.stdout.write(`  ${result.action.padEnd(10)} ${entry.dest}
+`);
+        if (entry.executable && !dryRun) {
+          await chmod(dest, 493);
+        }
+      } else {
+        skipped += 1;
+        process.stdout.write(`  ${result.action.padEnd(10)} ${entry.dest}
+`);
+      }
+    } catch (err) {
+      failed += 1;
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`  FAIL       ${entry.dest} \u2014 ${msg}
+`);
+    }
+  }
+  if (!dryRun) {
+    await saveLedger2(ledgerPath, newLedger);
+  }
+  process.stdout.write(
+    `agentproto install ${slug}: ${applied} applied, ${skipped} skipped, ${failed} failed${dryRun ? " (dry-run)" : ""}
+`
+  );
+  return failed === 0 ? 0 : 1;
+}
+async function applyStrategy(opts) {
+  const { strategy, srcBuf, dest, prev, force, dryRun } = opts;
+  const destExists = await fileExists(dest);
+  if (strategy === "preserve") {
+    if (destExists) {
+      const currentHash = await hashFile(dest);
+      return { wrote: false, action: "preserve", hashAfter: currentHash };
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, srcBuf);
+    }
+    return { wrote: true, action: "create", hashAfter: sha256(srcBuf) };
+  }
+  if (strategy === "overwrite") {
+    const srcHash = sha256(srcBuf);
+    if (destExists && !force) {
+      const destHash = await hashFile(dest);
+      if (destHash === srcHash) {
+        return { wrote: false, action: "unchanged", hashAfter: destHash };
+      }
+      if (prev && prev.hashAfter !== destHash) {
+        return {
+          wrote: false,
+          action: "user-edit",
+          hashAfter: destHash
+        };
+      }
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, srcBuf);
+    }
+    return {
+      wrote: true,
+      action: destExists ? "update" : "create",
+      hashAfter: srcHash
+    };
+  }
+  if (strategy === "merge-json-deep") {
+    const srcJson = parseJsonOrThrow(srcBuf.toString("utf8"), "src");
+    let merged = srcJson;
+    if (destExists) {
+      const destRaw = await readFile(dest, "utf8");
+      const destJson = parseJsonOrThrow(destRaw, "dest");
+      merged = deepMerge(destJson, srcJson);
+    }
+    const out = `${JSON.stringify(merged, null, 2)}
+`;
+    const outBuf = Buffer.from(out, "utf8");
+    const outHash = sha256(outBuf);
+    if (destExists) {
+      const destHash = await hashFile(dest);
+      if (destHash === outHash) {
+        return { wrote: false, action: "unchanged", hashAfter: destHash };
+      }
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, outBuf);
+    }
+    return {
+      wrote: true,
+      action: destExists ? "merge" : "create",
+      hashAfter: outHash
+    };
+  }
+  if (strategy === "append") {
+    const srcText = srcBuf.toString("utf8");
+    if (destExists) {
+      const destText = await readFile(dest, "utf8");
+      if (destText.includes(srcText)) {
+        return {
+          wrote: false,
+          action: "unchanged",
+          hashAfter: sha256(Buffer.from(destText, "utf8"))
+        };
+      }
+      const out = `${destText.endsWith("\n") ? destText : `${destText}
+`}${srcText}`;
+      const outBuf = Buffer.from(out, "utf8");
+      if (!dryRun) {
+        await ensureDir(dirname(dest));
+        await writeFile(dest, outBuf);
+      }
+      return { wrote: true, action: "append", hashAfter: sha256(outBuf) };
+    }
+    if (!dryRun) {
+      await ensureDir(dirname(dest));
+      await writeFile(dest, srcBuf);
+    }
+    return { wrote: true, action: "create", hashAfter: sha256(srcBuf) };
+  }
+  throw new Error(`Unknown strategy: ${strategy}`);
+}
+function deepMerge(target, source) {
+  if (target && source && typeof target === "object" && typeof source === "object" && !Array.isArray(target) && !Array.isArray(source)) {
+    const out = { ...target };
+    for (const [k, v] of Object.entries(source)) {
+      out[k] = deepMerge(target[k], v);
+    }
+    return out;
+  }
+  if (Array.isArray(target) && Array.isArray(source)) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const item of [...target, ...source]) {
+      const key = JSON.stringify(item);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(item);
+    }
+    return out;
+  }
+  return source ?? target;
+}
+function parseJsonOrThrow(raw, side) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`merge-json-deep ${side} not valid JSON: ${msg}`);
+  }
+}
+function sha256(buf) {
+  return createHash("sha256").update(buf).digest("hex");
+}
+async function hashFile(path) {
+  const buf = await readFile(path);
+  return sha256(buf);
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dir) {
+  try {
+    await stat(dir);
+  } catch {
+    await mkdir(dir, { recursive: true });
+  }
+}
+function ledgerPathFor2(profileName) {
+  return join(homedir(), ".agentproto", "profiles", `${profileName}.json`);
+}
+async function loadLedger2(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveLedger2(path, ledger) {
+  await ensureDir(dirname(path));
+  await writeFile(path, `${JSON.stringify(ledger, null, 2)}
+`);
+}
+async function readProfileAlias(profileName) {
+  const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
+  const path = join(base, "config.json");
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    const aliased = parsed.profileAliases?.[profileName];
+    return typeof aliased === "string" ? aliased : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/install.ts
 async function runInstall(args) {
+  const slugPeek = args.find((a) => !a.startsWith("-"));
+  if (slugPeek?.startsWith("runtime-profile/")) {
+    return runInstallProfile(
+      slugPeek,
+      args.filter((a) => a !== slugPeek)
+    );
+  }
   const { values, positionals } = parseArgs({
     args: [...args],
     allowPositionals: true,
@@ -780,7 +1086,7 @@ async function runDownloadInstaller(opts) {
     }
     if (extractCode !== 0) return extractCode;
     const srcBin = join(extractDir, opts.extractBin);
-    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir2(), ".local", "bin");
+    const binDir = process.env["AGENTPROTO_BIN_DIR"] ?? join(homedir3(), ".local", "bin");
     await mkdir(binDir, { recursive: true });
     const destBin = join(binDir, opts.extractBin.split("/").pop());
     const cpCode = await spawnInherit("cp", ["-p", srcBin, destBin]);
@@ -806,7 +1112,7 @@ async function runDownloadInstaller(opts) {
     });
   }
 }
-function homedir2() {
+function homedir3() {
   return process.env["HOME"] ?? process.env["USERPROFILE"] ?? "/";
 }
 function spawnInherit(cmd, argv) {
@@ -1329,28 +1635,51 @@ createDoctype({
   validate(def) {
     const result = extensionFrontmatterSchema.safeParse(def);
     if (!result.success) {
-      throw new Error(`defineExtension (AIP-40): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+      throw new Error(
+        `defineExtension (AIP-40): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+      );
     }
   },
   build(def) {
     return { ...def };
   }
 });
+function parseExtensionManifest(source) {
+  const parsed = matter(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parseExtensionManifest: missing or empty frontmatter");
+  }
+  const result = extensionFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parseExtensionManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+
+// ../extension/dist/index.mjs
 function specFromExtension(extension, opts = {}) {
   const { parent } = opts;
   const isRoot = extension.extends === "none";
   if (!isRoot && !parent) {
-    throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' extends '${extension.extends}' but no parent spec was provided in opts.parent`);
+    throw new Error(
+      `specFromExtension (AIP-40): extension '${extension.slug}' extends '${extension.extends}' but no parent spec was provided in opts.parent`
+    );
   }
   if (isRoot && !extension.path_convention) {
-    throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype (extends: none) and MUST declare path_convention`);
+    throw new Error(
+      `specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype (extends: none) and MUST declare path_convention`
+    );
   }
   if (parent && extension.tighten) {
     verifyTightening(extension);
   }
   const slugName = extension.slug.split(":")[1] ?? extension.slug;
   const pathTemplate = extension.path_convention ?? null;
-  const extensionKeys = new Set(Object.keys(extension.add_fields?.properties ?? {}));
+  const extensionKeys = new Set(
+    Object.keys(extension.add_fields?.properties ?? {})
+  );
   const define = (params) => {
     const withDefaults = { ...params };
     if (extension.defaults) {
@@ -1366,10 +1695,8 @@ function specFromExtension(extension, opts = {}) {
     const parentOnly = {};
     const extensionOnly = {};
     for (const [key, value] of Object.entries(withDefaults)) {
-      if (extensionKeys.has(key))
-        extensionOnly[key] = value;
-      else
-        parentOnly[key] = value;
+      if (extensionKeys.has(key)) extensionOnly[key] = value;
+      else parentOnly[key] = value;
     }
     const parentHandle = parent.define(parentOnly);
     return Object.freeze({
@@ -1380,7 +1707,11 @@ function specFromExtension(extension, opts = {}) {
   const parse = isRoot ? rootParse(extension) : parent.parse;
   const pathOf = (handle) => {
     if (pathTemplate) {
-      return resolvePathTemplate(pathTemplate, handle, slugName);
+      return resolvePathTemplate(
+        pathTemplate,
+        handle,
+        slugName
+      );
     }
     return parent.pathOf(handle);
   };
@@ -1397,36 +1728,33 @@ function verifyTightening(extension, parent) {
   const t = extension.tighten ?? {};
   for (const [field, override] of Object.entries(t)) {
     if (typeof override.minLength === "number" && typeof override.maxLength === "number" && override.minLength > override.maxLength) {
-      throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minLength (${override.minLength}) > maxLength (${override.maxLength})`);
+      throw new Error(
+        `specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minLength (${override.minLength}) > maxLength (${override.maxLength})`
+      );
     }
     if (typeof override.minimum === "number" && typeof override.maximum === "number" && override.minimum > override.maximum) {
-      throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minimum (${override.minimum}) > maximum (${override.maximum})`);
+      throw new Error(
+        `specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: minimum (${override.minimum}) > maximum (${override.maximum})`
+      );
     }
     if (override.enum !== void 0 && !Array.isArray(override.enum)) {
-      throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: enum must be an array`);
+      throw new Error(
+        `specFromExtension (AIP-40): extension '${extension.slug}' tighten.${field}: enum must be an array`
+      );
     }
   }
 }
 function rootParse(extension) {
   return (source) => {
-    throw new Error(`specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype \u2014 supply your own parser or extend a public AIP for parser inheritance`);
+    throw new Error(
+      `specFromExtension (AIP-40): extension '${extension.slug}' is a root doctype \u2014 supply your own parser or extend a public AIP for parser inheritance`
+    );
   };
 }
 function resolvePathTemplate(template, handle, doctypeSlug) {
   const identity = typeof handle.id === "string" && handle.id || typeof handle.slug === "string" && handle.slug || typeof handle.name === "string" && handle.name || "unknown";
   return template.replace(/<slug>/g, identity).replace(/<DOCTYPE>/g, doctypeSlug.toUpperCase());
 }
-function parseExtensionManifest(source) {
-  const parsed = matter(source);
-  if (Object.keys(parsed.data).length === 0) {
-    throw new Error("parseExtensionManifest: missing or empty frontmatter");
-  }
-  const result = extensionFrontmatterSchema.safeParse(parsed.data);
-  if (!result.success) {
-    throw new Error(`parseExtensionManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
-  }
-  return { frontmatter: result.data, body: parsed.content };
-}
 
 // ../mcp-server/dist/index.mjs
 async function createMcpServer(opts) {
@@ -5551,7 +5879,7 @@ var RemoteController = class {
     let bearerTokenHash = "";
     if (exposesGateway) {
       bearerToken = randomBytes(32).toString("base64url");
-      bearerTokenHash = sha256(bearerToken);
+      bearerTokenHash = sha2562(bearerToken);
     }
     const state = {
       provider: providerId,
@@ -5616,7 +5944,7 @@ function pickProvider(id) {
   const _exhaustive = id;
   throw new Error(`unknown remote provider: ${String(_exhaustive)}`);
 }
-function sha256(input2) {
+function sha2562(input2) {
   return createHash("sha256").update(input2).digest("hex");
 }
 function errToMessage(err) {
@@ -5709,7 +6037,7 @@ var WorkspacePathError = class extends Error {
 };
 function createWorkspaceFs(opts) {
   const root = resolve(opts.workspace);
-  function resolvePath4(path) {
+  function resolvePath42(path) {
     if (typeof path !== "string" || path.length === 0) {
       throw new WorkspacePathError("path must be a non-empty string");
     }
@@ -5729,18 +6057,18 @@ function createWorkspaceFs(opts) {
   }
   return {
     async readFile(path) {
-      const abs = resolvePath4(path);
+      const abs = resolvePath42(path);
       const buf = await readFile(abs);
       return buf.toString("utf8");
     },
     async writeFile(path, content) {
-      const abs = resolvePath4(path);
+      const abs = resolvePath42(path);
       await mkdir(dirname(abs), { recursive: true });
       await writeFile(abs, content);
     },
     async exists(path) {
       try {
-        const abs = resolvePath4(path);
+        const abs = resolvePath42(path);
         return existsSync(abs);
       } catch {
         return false;
@@ -5945,8 +6273,8 @@ async function runServe(args) {
     values.workspace ?? cfgDaemon.workspace ?? process.cwd()
   );
   try {
-    const stat2 = await promises.stat(workspace);
-    if (!stat2.isDirectory()) {
+    const stat3 = await promises.stat(workspace);
+    if (!stat3.isDirectory()) {
       process.stderr.write(
         `agentproto serve: --workspace "${workspace}" is not a directory.
 `