agents-inc 0.159.0 → 0.161.0

package/dist/chunk-XA4SWA2Z.js

@@ -0,0 +1,591 @@
+#!/usr/bin/env node
+import {
+  claimSlug,
+  computeFileHash,
+  glob,
+  injectForkedFromMetadata,
+  readFile,
+  readLocalSkillMetadata,
+  readSkillMetadata,
+  resolveInstallPaths,
+  validateSkillPath,
+  writeFile,
+  writeMetadataYaml
+} from "./chunk-YSQ76LWG.js";
+import {
+  getCategoryDomain,
+  typedEntries
+} from "./chunk-BLGETWYI.js";
+import {
+  GITHUB_SOURCE,
+  LOCAL_SKILLS_PATH,
+  STANDARD_FILES,
+  seedExternalSkillSchema,
+  seedPayloadSchema
+} from "./chunk-AMZO4YJK.js";
+
+// src/cli/lib/seed/external-skills.ts
+import path from "path";
+function pluginInstallError(ids) {
+  return [
+    "This configuration cannot be installed: these skills travel inside it, so no marketplace serves them and they cannot be installed as plugins:",
+    ...ids.map((id) => `  ${id}`),
+    "Re-share it with each skill above set to eject, which is the only way a carried skill installs."
+  ].join("\n");
+}
+function selectedExternals(payload) {
+  return typedEntries(payload.external ?? {}).flatMap(([id, skill]) => {
+    const entry = payload.skills[id];
+    return entry ? [{ id, skill, entry }] : [];
+  });
+}
+function askedForAsPlugin(externals) {
+  return externals.filter(({ entry }) => entry.install !== "eject").map(({ id }) => id);
+}
+function externalSlug(id) {
+  return id;
+}
+function skillAuthor(repo) {
+  const [owner = repo] = repo.split("/");
+  return `@${owner}`;
+}
+function repoRef(repo) {
+  return `${GITHUB_SOURCE.GITHUB_PREFIX}${repo}`;
+}
+function externalSkillDir(id, scope, projectDir) {
+  return path.join(resolveInstallPaths(projectDir, scope).skillsDir, id);
+}
+function externalCatalogueEntry(install) {
+  return {
+    id: install.id,
+    slug: externalSlug(install.id),
+    displayName: install.skill.displayName,
+    description: install.skill.description,
+    // Boundary cast held by the guard above it: the category was confirmed against the catalogue
+    // the payload names, and this one has just been shown to declare it too.
+    category: install.skill.categoryId,
+    author: skillAuthor(install.skill.repo),
+    path: `${LOCAL_SKILLS_PATH}/${install.id}/`,
+    conflictsWith: [],
+    requires: [],
+    alternatives: [],
+    discourages: [],
+    // Local and custom for the same reason: the bytes are on this machine and nowhere else, and
+    // the skill was authored outside the vocabulary this catalogue ships.
+    local: true,
+    custom: true,
+    localPath: install.skillDir
+  };
+}
+function seatExternalSkill({ id, skill, entry }, matrix, projectDir) {
+  const domain = getCategoryDomain(skill.categoryId);
+  if (domain === void 0) return [];
+  const install = {
+    id,
+    skill,
+    domain,
+    scope: entry.scope,
+    skillDir: externalSkillDir(id, entry.scope, projectDir)
+  };
+  matrix.skills[id] = externalCatalogueEntry(install);
+  claimSlug(matrix.slugMap, externalSlug(id), id);
+  return [install];
+}
+function registerExternalSkills(payload, matrix, projectDir) {
+  const externals = selectedExternals(payload);
+  const asPlugin = askedForAsPlugin(externals);
+  if (asPlugin.length > 0) throw new Error(pluginInstallError(asPlugin));
+  return externals.flatMap((external) => seatExternalSkill(external, matrix, projectDir));
+}
+async function writeExternalSkills(installs) {
+  for (const install of installs) {
+    await writeSkillTree(install);
+    await writeSkillManifest(install);
+    await registerSkillOnDisk(install);
+  }
+}
+async function writeSkillTree(install) {
+  for (const [relativePath, contents] of Object.entries(install.skill.files)) {
+    const filePath = path.join(install.skillDir, relativePath);
+    validateSkillPath(filePath, install.skillDir, relativePath);
+    await writeFile(filePath, contents);
+  }
+}
+var FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---/;
+var NAME_FIELD = /^name:.*$/m;
+function withInstalledName(manifest, install) {
+  const named = `name: ${install.id}`;
+  const block = FRONTMATTER_BLOCK.exec(manifest);
+  if (!block) {
+    return `---
+${named}
+description: ${install.skill.description}
+---
+
+${manifest}`;
+  }
+  const [whole, fields = ""] = block;
+  const renamed = NAME_FIELD.test(fields) ? fields.replace(NAME_FIELD, named) : `${named}
+${fields}`;
+  return `---
+${renamed}
+---${manifest.slice(whole.length)}`;
+}
+async function writeSkillManifest(install) {
+  const manifestPath = path.join(install.skillDir, STANDARD_FILES.SKILL_MD);
+  await writeFile(manifestPath, withInstalledName(await readFile(manifestPath), install));
+}
+function externalSkillMetadata(install, shipped) {
+  return {
+    author: skillAuthor(install.skill.repo),
+    usageGuidance: `Use when working with ${install.skill.displayName}`,
+    ...shipped,
+    displayName: install.skill.displayName,
+    slug: install.id,
+    category: install.skill.categoryId,
+    domain: install.domain,
+    cliDescription: install.skill.description,
+    custom: true
+  };
+}
+async function registerSkillOnDisk(install) {
+  const metadataPath = path.join(install.skillDir, STANDARD_FILES.METADATA_YAML);
+  const shipped = await readLocalSkillMetadata(install.skillDir);
+  await writeMetadataYaml(metadataPath, externalSkillMetadata(install, shipped));
+  await injectForkedFromMetadata(
+    install.skillDir,
+    install.id,
+    await computeFileHash(path.join(install.skillDir, STANDARD_FILES.SKILL_MD)),
+    { source: repoRef(install.skill.repo), path: install.skill.path }
+  );
+}
+function unnameableRepoMessage(id) {
+  return `${id} travels inside a shared configuration, and this installation does not record the repository its content came from`;
+}
+function uncarryableContentMessage(id, reason) {
+  return `${id} travels inside a shared configuration, and ${reason}`;
+}
+function repoFromRef(ref) {
+  if (ref === void 0 || !ref.startsWith(GITHUB_SOURCE.GITHUB_PREFIX)) return void 0;
+  return ref.slice(GITHUB_SOURCE.GITHUB_PREFIX.length);
+}
+async function readSkillTree(skillDir) {
+  const files = await glob("**/*", skillDir, { dot: true });
+  const entries = await Promise.all(
+    files.map(async (file) => [file, await readFile(path.join(skillDir, file))])
+  );
+  return Object.fromEntries(entries);
+}
+async function readCarriedSkill({ id, skillDir, provenance }) {
+  if (provenance.path === void 0) return { carries: "nothing" };
+  const repo = repoFromRef(provenance.source);
+  if (repo === void 0) return { carries: "unshareable", line: unnameableRepoMessage(id) };
+  const described = await readSkillMetadata(path.join(skillDir, STANDARD_FILES.METADATA_YAML));
+  if (!described.usable) {
+    return { carries: "unshareable", line: uncarryableContentMessage(id, described.reason) };
+  }
+  const parsed = seedExternalSkillSchema.safeParse({
+    displayName: described.metadata.displayName,
+    description: described.metadata.cliDescription,
+    categoryId: described.metadata.category,
+    repo,
+    path: provenance.path,
+    files: await readSkillTree(skillDir)
+  });
+  if (!parsed.success) {
+    const reason = parsed.error.issues.map((issue) => issue.message).join("; ");
+    return { carries: "unshareable", line: uncarryableContentMessage(id, reason) };
+  }
+  return { carries: "content", id, skill: parsed.data };
+}
+async function readCarriedSkills(owned) {
+  const reads = await Promise.all(owned.map(readCarriedSkill));
+  return {
+    external: Object.fromEntries(
+      reads.flatMap((read) => read.carries === "content" ? [[read.id, read.skill]] : [])
+    ),
+    uncarryable: reads.flatMap((read) => read.carries === "unshareable" ? [read.line] : [])
+  };
+}
+
+// ../../node_modules/hono/dist/utils/cookie.js
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var _serialize = (name, value, opt = {}) => {
+  if (!validCookieNameRegEx.test(name)) {
+    throw new Error("Invalid cookie name");
+  }
+  let cookie = `${name}=${value}`;
+  if (name.startsWith("__Secure-") && !opt.secure) {
+    throw new Error("__Secure- Cookie must have Secure attributes");
+  }
+  if (name.startsWith("__Host-")) {
+    if (!opt.secure) {
+      throw new Error("__Host- Cookie must have Secure attributes");
+    }
+    if (opt.path !== "/") {
+      throw new Error('__Host- Cookie must have Path attributes with "/"');
+    }
+    if (opt.domain) {
+      throw new Error("__Host- Cookie must not have Domain attributes");
+    }
+  }
+  for (const key of ["domain", "path", "sameSite", "priority"]) {
+    if (opt[key] && /[;\r\n]/.test(opt[key])) {
+      throw new Error(`${key} must not contain ";", "\\r", or "\\n"`);
+    }
+  }
+  if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 3456e4) {
+      throw new Error(
+        "Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration."
+      );
+    }
+    cookie += `; Max-Age=${opt.maxAge | 0}`;
+  }
+  if (opt.domain && opt.prefix !== "host") {
+    cookie += `; Domain=${opt.domain}`;
+  }
+  if (opt.path) {
+    cookie += `; Path=${opt.path}`;
+  }
+  if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 3456e7) {
+      throw new Error(
+        "Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future."
+      );
+    }
+    cookie += `; Expires=${opt.expires.toUTCString()}`;
+  }
+  if (opt.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (opt.secure) {
+    cookie += "; Secure";
+  }
+  if (opt.sameSite) {
+    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+  }
+  if (opt.priority) {
+    cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;
+  }
+  if (opt.partitioned) {
+    if (!opt.secure) {
+      throw new Error("Partitioned Cookie must have Secure attributes");
+    }
+    cookie += "; Partitioned";
+  }
+  return cookie;
+};
+var serialize = (name, value, opt) => {
+  value = encodeURIComponent(value);
+  return _serialize(name, value, opt);
+};
+
+// ../../node_modules/hono/dist/client/utils.js
+var mergePath = (base, path2) => {
+  base = base.replace(/\/+$/, "");
+  base = base + "/";
+  path2 = path2.replace(/^\/+/, "");
+  return base + path2;
+};
+var replaceUrlParam = (urlString, params) => {
+  for (const [k, v] of Object.entries(params)) {
+    const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??(?=/|$)");
+    urlString = urlString.replace(reg, v ? `/${v}` : "");
+  }
+  return urlString;
+};
+var buildSearchParams = (query) => {
+  const searchParams = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0) {
+      continue;
+    }
+    if (Array.isArray(v)) {
+      for (const v2 of v) {
+        searchParams.append(k, v2);
+      }
+    } else {
+      searchParams.set(k, v);
+    }
+  }
+  return searchParams;
+};
+var replaceUrlProtocol = (urlString, protocol) => {
+  switch (protocol) {
+    case "ws":
+      return urlString.replace(/^http/, "ws");
+    case "http":
+      return urlString.replace(/^ws/, "http");
+  }
+};
+var removeIndexString = (urlString) => {
+  if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) {
+    return urlString.replace(/\/index(?=\?|$)/, "/");
+  }
+  return urlString.replace(/\/index(?=\?|$)/, "");
+};
+function isObject(item) {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+  if (!isObject(target) && !isObject(source)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    const value = source[key];
+    if (isObject(merged[key]) && isObject(value)) {
+      merged[key] = deepMerge(merged[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+
+// ../../node_modules/hono/dist/client/client.js
+var createProxy = (callback, path2) => {
+  const proxy = new Proxy(() => {
+  }, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") {
+        return void 0;
+      }
+      return createProxy(callback, [...path2, key]);
+    },
+    apply(_1, _2, args) {
+      return callback({
+        path: path2,
+        args
+      });
+    }
+  });
+  return proxy;
+};
+var ClientRequestImpl = class {
+  url;
+  method;
+  buildSearchParams;
+  queryParams = void 0;
+  pathParams = {};
+  rBody;
+  cType = void 0;
+  constructor(url, method, options) {
+    this.url = url;
+    this.method = method;
+    this.buildSearchParams = options.buildSearchParams;
+  }
+  fetch = async (args, opt) => {
+    if (args) {
+      if (args.query) {
+        this.queryParams = this.buildSearchParams(args.query);
+      }
+      if (args.form) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(args.form)) {
+          if (v === void 0) {
+            continue;
+          }
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              form.append(k, v2);
+            }
+          } else {
+            form.append(k, v);
+          }
+        }
+        this.rBody = form;
+      }
+      if (args.json) {
+        this.rBody = JSON.stringify(args.json);
+        this.cType = "application/json";
+      }
+      if (args.param) {
+        this.pathParams = args.param;
+      }
+    }
+    let methodUpperCase = this.method.toUpperCase();
+    const headerValues = {
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
+    };
+    if (args?.cookie) {
+      const cookies = [];
+      for (const [key, value] of Object.entries(args.cookie)) {
+        cookies.push(serialize(key, value, { path: "/" }));
+      }
+      headerValues["Cookie"] = cookies.join(",");
+    }
+    if (this.cType) {
+      headerValues["Content-Type"] = this.cType;
+    }
+    const headers = new Headers(headerValues ?? void 0);
+    let url = this.url;
+    url = removeIndexString(url);
+    url = replaceUrlParam(url, this.pathParams);
+    if (this.queryParams) {
+      url = url + "?" + this.queryParams.toString();
+    }
+    methodUpperCase = this.method.toUpperCase();
+    const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+    return (opt?.fetch || fetch)(url, {
+      body: setBody ? this.rBody : void 0,
+      method: methodUpperCase,
+      headers,
+      ...opt?.init
+    });
+  };
+};
+var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
+  const buildSearchParamsOption = options?.buildSearchParams ?? buildSearchParams;
+  const parts = [...opts.path];
+  const lastParts = parts.slice(-3).reverse();
+  if (lastParts[0] === "toString") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback.toString();
+  }
+  if (lastParts[0] === "valueOf") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback;
+  }
+  let method = "";
+  if (/^\$/.test(lastParts[0])) {
+    const last = parts.pop();
+    if (last) {
+      method = last.replace(/^\$/, "");
+    }
+  }
+  const path2 = parts.join("/");
+  const url = mergePath(baseUrl, path2);
+  if (method === "url" || method === "path") {
+    let result = url;
+    if (opts.args[0]) {
+      if (opts.args[0].param) {
+        result = replaceUrlParam(url, opts.args[0].param);
+      }
+      if (opts.args[0].query) {
+        result = result + "?" + buildSearchParamsOption(opts.args[0].query).toString();
+      }
+    }
+    result = removeIndexString(result);
+    if (method === "url") {
+      return new URL(result);
+    }
+    return result.slice(baseUrl.replace(/\/+$/, "").length).replace(/^\/?/, "/");
+  }
+  if (method === "ws") {
+    const webSocketUrl = replaceUrlProtocol(
+      opts.args[0] && opts.args[0].param ? replaceUrlParam(url, opts.args[0].param) : url,
+      "ws"
+    );
+    const targetUrl = new URL(webSocketUrl);
+    const queryParams = opts.args[0]?.query;
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((item) => targetUrl.searchParams.append(key, item));
+        } else {
+          targetUrl.searchParams.set(key, value);
+        }
+      });
+    }
+    const establishWebSocket = (...args) => {
+      if (options?.webSocket !== void 0 && typeof options.webSocket === "function") {
+        return options.webSocket(...args);
+      }
+      return new WebSocket(...args);
+    };
+    return establishWebSocket(targetUrl.toString());
+  }
+  const req = new ClientRequestImpl(url, method, {
+    buildSearchParams: buildSearchParamsOption
+  });
+  if (method) {
+    options ??= {};
+    const reqOptions = { ...opts.args[1] };
+    const baseHeaders = options.headers;
+    const reqHeaders = reqOptions.headers;
+    if (baseHeaders && reqHeaders) {
+      reqOptions.headers = async () => ({
+        ...typeof baseHeaders === "function" ? await baseHeaders() : baseHeaders,
+        ...typeof reqHeaders === "function" ? await reqHeaders() : reqHeaders
+      });
+    }
+    const args = deepMerge(options, reqOptions);
+    return req.fetch(opts.args[0], args);
+  }
+  return req;
+}, []);
+
+// ../api/src/client.ts
+var resolvePolicy = ({
+  headers = {},
+  credentials = "include"
+}) => ({ headers, credentials });
+var createApiClient = ({
+  baseUrl,
+  fetch: fetch2,
+  ...policy
+}) => {
+  const { headers, credentials } = resolvePolicy(policy);
+  return hc(baseUrl, {
+    headers,
+    init: { credentials },
+    // Spread rather than named. Under `exactOptionalPropertyTypes` hc's
+    // optional `fetch` does not accept an explicit `undefined`, so writing
+    // `fetch,` here is a TS2379 whenever a caller omits one.
+    ...fetch2 && { fetch: fetch2 }
+  });
+};
+
+// src/cli/lib/seed/fetch-seed.ts
+var SEED_API_URL = process.env.AGENTS_INC_API_URL ?? "https://api.agentsinc.sh";
+var SEED_USER_AGENT = "agents-inc-cli";
+var store = createApiClient({
+  baseUrl: SEED_API_URL,
+  headers: { accept: "application/json", "user-agent": SEED_USER_AGENT },
+  credentials: "omit"
+});
+async function fetchSeedConfig(id) {
+  let response;
+  try {
+    response = await store.configs[":id"].$get({ param: { id: encodeURIComponent(id) } });
+  } catch {
+    return { ok: false, error: `Could not reach ${SEED_API_URL} \u2014 check your connection.` };
+  }
+  if (response.status === 404) {
+    return { ok: false, error: `No configuration found for id '${id}'.` };
+  }
+  if (!response.ok) {
+    return { ok: false, error: `Fetching configuration failed (HTTP ${response.status}).` };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { ok: false, error: "The configuration store returned something that is not JSON." };
+  }
+  const parsed = seedPayloadSchema.safeParse(body);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: `Configuration '${id}' is not in a format this version of the CLI can install. Shared ids are never migrated \u2014 re-share the configuration to mint a current one, or update the CLI if that id came from a newer version.`
+    };
+  }
+  return { ok: true, payload: parsed.data };
+}
+
+export {
+  registerExternalSkills,
+  writeExternalSkills,
+  readCarriedSkills,
+  SEED_API_URL,
+  SEED_USER_AGENT,
+  fetchSeedConfig
+};
+//# sourceMappingURL=chunk-XA4SWA2Z.js.map