@leuria/cli 0.1.0 → 0.1.2

package/dist/{chunk-BXSAYWR3.js → chunk-JOCM56MT.js}

@@ -41,6 +41,14 @@ async function getRegistryEntry(id) {
   }
   return null;
 }
+function runnableHere(entry) {
+  const d = entry.distribution;
+  return Boolean(d.npx || d.uvx || d.binary?.[platformKey()]);
+}
+function clearRegistryCache() {
+  cache = null;
+  failedAt = 0;
+}
 
 // src/home.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
@@ -335,6 +343,7 @@ import { createHash } from "crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { dirname, join as join3 } from "path";
 import { promisify as promisify2 } from "util";
+import crossSpawn from "cross-spawn";
 
 // src/codex.ts
 import { execFile } from "child_process";
@@ -366,7 +375,11 @@ async function prepareCodexHome(agent) {
     "",
     "[features]",
     ...features.map((name) => `${name} = ${ENABLED_FEATURES.has(name)}`),
-    ""
+    "",
+    // Windows: the sandbox that needs no administrator rights (a restricted token).
+    // The other one asks for them the first time: out of the blue, and a dead end
+    // on a work computer without them.
+    ...process.platform === "win32" ? ["[windows]", 'sandbox = "unelevated"', ""] : []
   ];
   writeFileSync2(join2(home, "config.toml"), lines.join("\n"), { mode: 384 });
   writeFileSync2(stamp, agent.version);
@@ -454,9 +467,33 @@ async function ensureAgentOnce(id, options) {
   }
   if (installed?.version === entry.version) return installed;
   options.onProgress?.(`Installing ${entry.name} ${entry.version} from the ACP registry\u2026`);
-  const agent = await install(entry);
-  await profileFor(id)?.prepare?.(agent);
-  return agent;
+  return install(entry);
+}
+function installedIds() {
+  const root = agentsDir();
+  if (!existsSync3(root)) return [];
+  const ids = readdirSync(root).filter((name) => name.includes("@") && existsSync3(join3(root, name, MANIFEST))).map((name) => name.slice(0, name.lastIndexOf("@")));
+  return [...new Set(ids)];
+}
+function pruneAgentVersions() {
+  const root = agentsDir();
+  for (const id of installedIds()) {
+    const versions = readdirSync(root).filter((name) => name.startsWith(`${id}@`) && existsSync3(join3(root, name, MANIFEST))).sort(compareVersions);
+    for (const old of versions.slice(0, -1)) rmSync(join3(root, old), { recursive: true, force: true });
+  }
+}
+async function updateAgents(onUpdated) {
+  clearRegistryCache();
+  for (const id of installedIds()) {
+    const installed = installedAgent(id);
+    const entry = await getRegistryEntry(id);
+    if (!installed || !entry || !runnableHere(entry) || compareVersions(entry.version, installed.version) <= 0) continue;
+    try {
+      const agent = await ensureAgent(id, { update: true });
+      await onUpdated?.(agent, installed.version);
+    } catch {
+    }
+  }
 }
 async function resolveAgentCommand(id, model) {
   if (isLlmId(id)) {
@@ -529,6 +566,12 @@ async function install(entry) {
     throw error;
   }
   const agent = { id: entry.id, name: entry.name, version: entry.version, dir, ...launch };
+  try {
+    await profileFor(entry.id)?.prepare?.(agent);
+  } catch (error) {
+    rmSync(dir, { recursive: true, force: true });
+    throw error;
+  }
   writeFileSync3(join3(dir, MANIFEST), `${JSON.stringify(agent, null, 2)}
 `);
   return agent;
@@ -538,12 +581,7 @@ async function installPackage(dir, spec, args, env) {
   if (process.versions.bun) {
     await execFileAsync2(process.execPath, ["add", spec], { cwd: dir, env: { ...process.env, BUN_BE_BUN: "1" }, timeout: 5 * 6e4 });
   } else {
-    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-    await execFileAsync2(npm, ["install", "--no-audit", "--no-fund", "--omit=dev", "--loglevel=error", spec], {
-      cwd: dir,
-      timeout: 5 * 6e4,
-      shell: process.platform === "win32"
-    });
+    await run("npm", ["install", "--no-audit", "--no-fund", "--omit=dev", "--loglevel=error", spec], { cwd: dir, timeout: 5 * 6e4 });
   }
   const name = spec.lastIndexOf("@") > 0 ? spec.slice(0, spec.lastIndexOf("@")) : spec;
   const pkgDir = join3(dir, "node_modules", ...name.split("/"));
@@ -555,6 +593,25 @@ async function installPackage(dir, spec, args, env) {
   const isScript = /\.[cm]?js$/.test(entry) || /^#!.*\b(node|bun)\b/.test(readFileSync3(entry, "utf-8").slice(0, 100));
   return isScript ? { command: process.execPath, launchArgs: [entry], args, env } : { command: entry, launchArgs: [], args, env };
 }
+function run(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = crossSpawn(command, args, { cwd: options.cwd, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    const timer = setTimeout(() => child.kill(), options.timeout);
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve();
+      else reject(new Error(`${command} ${args.join(" ")} failed (${code ?? "stopped"})${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}
 async function installBinary(dir, target) {
   const res = await fetch(target.archive, { signal: AbortSignal.timeout(5 * 6e4) });
   if (!res.ok) throw new Error(`Download failed (${res.status}): ${target.archive}`);
@@ -597,16 +654,17 @@ function compareVersions(a, b) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var VERSION = true ? "0.1.2" : "0.0.0-dev";
 
 // src/auth.ts
-import { spawn as spawn2 } from "child_process";
+import crossSpawn3 from "cross-spawn";
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join5 } from "path";
 
 // src/acp/acp-client.ts
 import { spawn } from "child_process";
+import crossSpawn2 from "cross-spawn";
 import { Readable, Writable } from "stream";
 var rawParams = {
   // biome-ignore lint/suspicious/noExplicitAny: ACP payloads are untyped here
@@ -669,11 +727,11 @@ var AcpLiveSession = class {
     const env = { ...process.env, ...this.options.envVars };
     for (const key of REMOVED_ENV_VARS) delete env[key];
     if (process.versions.bun) env.BUN_BE_BUN = "1";
-    const child = spawn(this.options.command, this.options.args, {
+    const child = crossSpawn2(this.options.command, this.options.args, {
       stdio: ["pipe", "pipe", "pipe"],
       env,
       cwd: this.options.cwd,
-      shell: process.platform === "win32",
+      windowsHide: true,
       // Its own process group, so close() also stops what the agent starts
       // (Gemini relaunches itself as a child process).
       detached: process.platform !== "win32"
@@ -877,7 +935,7 @@ ${file.text}
 function killTree(child) {
   try {
     if (process.platform === "win32" && child.pid) {
-      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else if (child.pid) {
       process.kill(-child.pid, "SIGTERM");
     } else {
@@ -1050,7 +1108,11 @@ function checkTimeoutMs() {
   const value = Number(process.env.LEURIA_CHECK_TIMEOUT_MS);
   return Number.isFinite(value) && value > 0 ? value : 15e3;
 }
-async function checkSignIn(id, onProgress) {
+function signInStallMs() {
+  const value = Number(process.env.LEURIA_SIGNIN_STALL_MS);
+  return Number.isFinite(value) && value > 0 ? value : 1e4;
+}
+async function checkSignIn(id, onProgress, options = {}) {
   if (isLlmId(id)) return checkLlm(id);
   const { session, close } = await open(id, onProgress);
   let timer;
@@ -1061,7 +1123,7 @@ async function checkSignIn(id, onProgress) {
   });
   try {
     const status = await Promise.race([timedOut, check()]);
-    rememberReady(id, status.ok);
+    if (!options.quiet) rememberReady(id, status.ok);
     return status;
   } finally {
     clearTimeout(timer);
@@ -1078,7 +1140,11 @@ async function checkSignIn(id, onProgress) {
 }
 async function signIn(id, options = {}) {
   if (isLlmId(id)) return checkLlm(id);
-  const link = options.onUrl && !options.terminal ? catchBrowserLinks(options.onUrl) : null;
+  let pageOpened = false;
+  const link = options.onUrl && !options.terminal ? catchBrowserLinks((url) => {
+    pageOpened = true;
+    options.onUrl?.(url);
+  }) : null;
   let opened;
   try {
     opened = await open(id, options.onProgress, options.terminal, link?.env);
@@ -1086,11 +1152,26 @@ async function signIn(id, options = {}) {
     link?.stop();
     throw error;
   }
-  const { agent, session, env, sandbox } = opened;
+  const { agent, env, sandbox } = opened;
   const close = () => {
     opened.close();
     link?.stop();
   };
+  async function authenticateOrStall(session, methodId) {
+    const auth = session.authenticate(methodId);
+    if (!link) return auth;
+    let timer;
+    const stalled = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        if (!pageOpened) resolve("stalled");
+      }, signInStallMs());
+    });
+    try {
+      return await Promise.race([auth, stalled]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   const cancelled = new Promise((resolve) => {
     const onAbort = () => {
       resolve({ ok: false, detail: "cancelled", methods: [] });
@@ -1100,11 +1181,12 @@ async function signIn(id, options = {}) {
     else options.signal?.addEventListener("abort", onAbort, { once: true });
   });
   try {
-    return await Promise.race([cancelled, run()]);
+    return await Promise.race([cancelled, run2()]);
   } finally {
     close();
   }
-  async function run() {
+  async function run2() {
+    let session = opened.session;
     const connected = await session.connect();
     if (connected.error) return { ok: false, detail: `the agent did not start: ${connected.error}`, methods: [] };
     const all = session.info?.authMethods ?? [];
@@ -1118,7 +1200,7 @@ async function signIn(id, options = {}) {
     if (isTerminal(method)) {
       session.close();
       const code = await new Promise((resolve, reject) => {
-        const child = spawn2(agent.command, [...agent.launchArgs, ...method.args ?? []], {
+        const child = crossSpawn3(agent.command, [...agent.launchArgs, ...method.args ?? []], {
           stdio: "inherit",
           cwd: sandbox,
           env: { ...process.env, ...env, ...method.env ?? {} }
@@ -1129,7 +1211,16 @@ async function signIn(id, options = {}) {
       if (code !== 0) return { ok: false, detail: `the sign-in ended with code ${code}`, methods };
       return checkSignIn(id, options.onProgress);
     }
-    const auth = await session.authenticate(method.id);
+    let auth = await authenticateOrStall(session, method.id);
+    if (auth === "stalled") {
+      opened.close();
+      if (options.signal?.aborted) return { ok: false, detail: "cancelled", methods };
+      opened = await open(id, options.onProgress, options.terminal, link?.env);
+      session = opened.session;
+      const again = await session.connect();
+      if (again.error) return { ok: false, detail: `the agent did not start: ${again.error}`, methods };
+      auth = await session.authenticate(method.id);
+    }
     if (auth.error) return { ok: false, detail: auth.error, methods };
     const created = await session.newSession();
     if (created.error) return { ok: false, detail: created.error, methods };
@@ -1224,8 +1315,18 @@ var GrantStore = class {
     for (const listener of this.changedListeners) listener(grant.origin);
     return true;
   }
-  /** Create or replace the origin's grant; returns the new token. Keeps the site's AI and model choice; `needs` replaces what it declared. */
-  create(origin, app, needs) {
+  /** Replace the site's skills (it changed its list). Its open conversations keep the skills they started with. */
+  setSkills(origin, skills) {
+    this.reload();
+    const grant = this.grants.find((g) => g.origin === normalizeOrigin(origin));
+    if (!grant) return false;
+    if (skills) grant.skills = skills;
+    else delete grant.skills;
+    this.save();
+    return true;
+  }
+  /** Create or replace the origin's grant; returns the new token. Keeps the site's AI and model choice; `needs` and `skills` replace what it declared. */
+  create(origin, app, needs, skills) {
     this.reload();
     const normalized = normalizeOrigin(origin);
     const token = randomBytes(32).toString("base64url");
@@ -1238,7 +1339,8 @@ var GrantStore = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...previous?.agent ? { agent: previous.agent } : {},
       ...previous?.model ? { model: previous.model } : {},
-      ...needs ? { needs } : {}
+      ...needs ? { needs } : {},
+      ...skills ? { skills } : {}
     });
     this.save();
     return token;
@@ -1456,7 +1558,7 @@ function parseEmbedBody(body) {
 }
 
 // src/pairing.ts
-import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 
 // src/needs.ts
 var EFFORTS = ["light", "standard", "deep"];
@@ -1473,13 +1575,363 @@ function parseNeeds(input) {
   return Object.keys(needs).length ? needs : void 0;
 }
 
+// src/skills.ts
+import { createHash as createHash4 } from "crypto";
+import cacache from "cacache";
+
+// src/skill-sources.ts
+import { createHash as createHash3 } from "crypto";
+import { lookup } from "dns/promises";
+import { mkdtemp, readdir, readFile, rm, stat } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { extname, join as join6, relative, sep } from "path";
+import { downloadTemplate } from "giget";
+import ipaddr from "ipaddr.js";
+import { parse as parseYaml } from "yaml";
+var TEXT_FILES = /* @__PURE__ */ new Set([".md", ".markdown", ".txt", ".json", ".yaml", ".yml", ".csv"]);
+var MAX_SKILL_BYTES = 256 * 1024;
+var MAX_FILES = 50;
+var MAX_TOTAL_BYTES = 1024 * 1024;
+var MAX_DESCRIPTION = 1024;
+var FETCH_TIMEOUT_MS = 15e3;
+var MAX_DEPTH = 5;
+var WELL_KNOWN = [".well-known/agent-skills", ".well-known/skills"];
+var DISCOVERY_V2 = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
+var SKILL_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var REPO_PART = /^[A-Za-z0-9_.-]+$/;
+function parseSkillSource(input, origin) {
+  let ref = input.trim();
+  if (ref.startsWith("/") || /^https?:\/\//i.test(ref)) {
+    const url = new URL(ref, origin);
+    if (url.hostname === "github.com") return parseGithubUrl(url);
+    if (url.origin !== origin) throw new Error(`${input}: skills come from GitHub or from the site's own origin (${origin})`);
+    url.hash = "";
+    return { kind: "site", url: url.toString() };
+  }
+  ref = ref.replace(/^github:/, "");
+  let pin;
+  let skill;
+  const hash = ref.indexOf("#");
+  if (hash >= 0) {
+    const fragment = ref.slice(hash + 1);
+    ref = ref.slice(0, hash);
+    const at2 = fragment.indexOf("@");
+    pin = (at2 >= 0 ? fragment.slice(0, at2) : fragment) || void 0;
+    skill = at2 >= 0 ? fragment.slice(at2 + 1) || void 0 : void 0;
+  }
+  const at = ref.match(/^([^/]+)\/([^/@]+)@(.+)$/);
+  if (at) return github(input, `${at[1]}/${at[2]}`, pin, void 0, skill ?? at[3]);
+  const parts = ref.split("/").filter(Boolean);
+  if (parts.length < 2) throw new Error(`${input}: expected owner/repo, owner/repo@skill, a GitHub URL, or a URL on the site`);
+  return github(input, `${parts[0]}/${parts[1]}`, pin, parts.slice(2).join("/") || void 0, skill);
+}
+function parseGithubUrl(url) {
+  const [owner, repo, marker, pin, ...rest] = url.pathname.split("/").filter(Boolean);
+  if (!owner || !repo) throw new Error(`${url}: not a GitHub repository`);
+  const tree = marker === "tree" && pin;
+  return github(url.toString(), `${owner}/${repo.replace(/\.git$/, "")}`, tree ? pin : void 0, tree ? rest.join("/") || void 0 : void 0, void 0);
+}
+function github(input, repo, ref, subpath, skill) {
+  const [owner, name] = repo.split("/");
+  if (![owner, name].every((part) => part && REPO_PART.test(part) && !/^\.+$/.test(part))) throw new Error(`${input}: not a GitHub repository`);
+  if (subpath && subpath.split("/").some((p) => p === ".." || p === "." || !p)) throw new Error(`${input}: bad folder`);
+  if (ref && !/^[\w./-]+$/.test(ref)) throw new Error(`${input}: bad ref`);
+  return { kind: "github", repo, ...ref ? { ref } : {}, ...subpath ? { subpath } : {}, ...skill ? { skill } : {} };
+}
+function sourceLabel(source) {
+  return source.kind === "github" ? source.repo : new URL(source.url).host;
+}
+async function fetchSkills(source) {
+  const skills = source.kind === "github" ? await fromGithub(source) : await fromSite(source.url);
+  if (!skills.length) throw new Error("no skill found");
+  return skills;
+}
+function parseSkillMd(text, files = {}) {
+  if (text.length > MAX_SKILL_BYTES) throw new Error("SKILL.md is too long");
+  const match = text.replace(/^/, "").match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) throw new Error("SKILL.md has no front matter");
+  const meta = parseYaml(match[1]);
+  const name = typeof meta?.name === "string" ? meta.name.trim() : "";
+  const description = typeof meta?.description === "string" ? meta.description.trim().replace(/\s+/g, " ") : "";
+  if (!SKILL_NAME.test(name) || name.length > 64) throw new Error(`SKILL.md name "${name}" is not a skill name`);
+  if (!description) throw new Error(`SKILL.md of ${name} has no description`);
+  return { name, description: description.slice(0, MAX_DESCRIPTION), body: match[2].trim(), files };
+}
+async function fromGithub(source) {
+  const dir = await mkdtemp(join6(tmpdir3(), "leuria-skills-"));
+  try {
+    const path2 = source.subpath ? `/${source.subpath}` : "";
+    await downloadTemplate(`gh:${source.repo}${path2}#${source.ref ?? "HEAD"}`, {
+      dir,
+      force: true,
+      forceClean: true,
+      registry: false,
+      silent: true,
+      ignore: (file) => !TEXT_FILES.has(extname(file).toLowerCase())
+    });
+    const found = [];
+    for (const skillFile of await findSkillFiles(dir, 0)) {
+      let skill;
+      try {
+        skill = parseSkillMd(await readFile(skillFile, "utf-8"));
+      } catch {
+        continue;
+      }
+      if (source.skill && skill.name !== source.skill) continue;
+      skill.files = await readTextFiles(join6(skillFile, ".."));
+      found.push(skill);
+    }
+    return found;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+async function findSkillFiles(dir, depth) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const own = entries.find((e) => e.isFile() && e.name.toLowerCase() === "skill.md");
+  if (own) return [join6(dir, own.name)];
+  if (depth >= MAX_DEPTH) return [];
+  const nested = await Promise.all(
+    entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => findSkillFiles(join6(dir, e.name), depth + 1))
+  );
+  return nested.flat();
+}
+async function readTextFiles(dir) {
+  const files = {};
+  let total = 0;
+  const walk = async (at, depth) => {
+    for (const entry of await readdir(at, { withFileTypes: true })) {
+      const full = join6(at, entry.name);
+      if (entry.isDirectory() && depth < MAX_DEPTH) await walk(full, depth + 1);
+      if (!entry.isFile() || !TEXT_FILES.has(extname(entry.name).toLowerCase())) continue;
+      const path2 = relative(dir, full).split(sep).join("/");
+      if (path2.toLowerCase() === "skill.md" || Object.keys(files).length >= MAX_FILES) continue;
+      const size = (await stat(full)).size;
+      if (size > MAX_SKILL_BYTES || total + size > MAX_TOTAL_BYTES) continue;
+      total += size;
+      files[path2] = await readFile(full, "utf-8");
+    }
+  };
+  await walk(dir, 0);
+  return files;
+}
+async function fromSite(url) {
+  const parsed = new URL(url);
+  if (/\/skill\.md$/i.test(parsed.pathname)) return [parseSkillMd(await siteText(url))];
+  const named2 = parsed.pathname.match(/\/\.well-known\/(?:agent-skills|skills)\/([^/]+)\/?$/)?.[1];
+  const base = parsed.pathname.replace(/\/\.well-known\/.*$/, "").replace(/\/$/, "");
+  for (const wellKnown of WELL_KNOWN) {
+    const indexUrl = `${parsed.origin}${base}/${wellKnown}/index.json`;
+    let index;
+    try {
+      index = JSON.parse(await siteText(indexUrl));
+    } catch {
+      continue;
+    }
+    const entries = indexEntries(index).filter((e) => !named2 || e.name === named2);
+    const skills = [];
+    for (const entry of entries) {
+      try {
+        skills.push(await fromIndexEntry(entry, indexUrl, `${parsed.origin}${base}/${wellKnown}/${entry.name}`));
+      } catch {
+      }
+    }
+    return skills;
+  }
+  throw new Error("the site has no .well-known/agent-skills/index.json");
+}
+function indexEntries(index) {
+  const record = index;
+  if (!record || !Array.isArray(record.skills)) return [];
+  const v2 = record.$schema === DISCOVERY_V2;
+  return record.skills.flatMap((raw) => {
+    const e = raw;
+    if (typeof e.name !== "string" || !SKILL_NAME.test(e.name)) return [];
+    if (v2) {
+      if (e.type !== "skill-md" || typeof e.url !== "string" || typeof e.digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(e.digest)) return [];
+      return [{ name: e.name, url: e.url, digest: e.digest }];
+    }
+    const files = Array.isArray(e.files) ? e.files.filter((f) => typeof f === "string" && !f.startsWith("/") && !f.includes("..")) : [];
+    return files.some((f) => f.toLowerCase() === "skill.md") ? [{ name: e.name, files }] : [];
+  });
+}
+async function fromIndexEntry(entry, indexUrl, folder) {
+  if (entry.url) {
+    const text = await siteText(new URL(entry.url, indexUrl).toString());
+    const digest = `sha256:${createHash3("sha256").update(text).digest("hex")}`;
+    if (digest !== entry.digest) throw new Error(`${entry.name}: SKILL.md doesn't match its digest`);
+    return named(parseSkillMd(text), entry.name);
+  }
+  const files = {};
+  let skillMd = "";
+  for (const file of (entry.files ?? []).slice(0, MAX_FILES)) {
+    const text = await siteText(`${folder}/${file}`);
+    if (file.toLowerCase() === "skill.md") skillMd = text;
+    else if (TEXT_FILES.has(extname(file).toLowerCase())) files[file] = text;
+  }
+  return named(parseSkillMd(skillMd, files), entry.name);
+}
+function named(skill, name) {
+  if (skill.name !== name) throw new Error(`the index names ${name}, its SKILL.md ${skill.name}`);
+  return skill;
+}
+async function siteText(url) {
+  const { hostname } = new URL(url);
+  const host = hostname.replace(/^\[|\]$/g, "");
+  if (!isLoopbackName(host)) {
+    const addresses = ipaddr.isValid(host) ? [{ address: host }] : await lookup(host, { all: true });
+    for (const { address } of addresses) {
+      const range = ipaddr.process(address).range();
+      if (range !== "unicast") throw new Error(`${hostname} resolves to a ${range} address`);
+    }
+  }
+  const res = await fetch(url, { redirect: "error", signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  if (!res.ok) throw new Error(`${url}: HTTP ${res.status}`);
+  if (Number(res.headers.get("content-length")) > MAX_SKILL_BYTES) throw new Error(`${url} is too large`);
+  const text = await res.text();
+  if (text.length > MAX_SKILL_BYTES) throw new Error(`${url} is too large`);
+  return text;
+}
+function isLoopbackName(host) {
+  if (host === "localhost" || host.endsWith(".localhost")) return true;
+  return ipaddr.isValid(host) && ipaddr.process(host).range() === "loopback";
+}
+
+// src/skills.ts
+var READ_SKILL = "read_skill";
+var MAX_REFS = 16;
+var MAX_SKILLS = 16;
+var MAX_REF_LENGTH = 300;
+function parseSkillRefs(input) {
+  const raw = typeof input === "string" ? [input] : Array.isArray(input) ? input : [];
+  const refs = [...new Set(raw.filter((r) => typeof r === "string").map((r) => r.trim()).filter((r) => r && r.length <= MAX_REF_LENGTH))];
+  return refs.length ? refs.slice(0, MAX_REFS) : void 0;
+}
+var sameRefs = (a, b) => (a ?? []).join("\n") === (b ?? []).join("\n");
+var SkillService = class {
+  constructor(options) {
+    this.options = options;
+    this.cache = options.cache === void 0 ? homePath("skills") : options.cache;
+  }
+  options;
+  cache;
+  memory = /* @__PURE__ */ new Map();
+  refreshing = /* @__PURE__ */ new Map();
+  /**
+   * Fetch and cache the skills `refs` name for `origin`. A ref that fails
+   * is logged and skipped; the first skill of a name wins.
+   */
+  async resolve(origin, refs) {
+    const list = [];
+    for (const ref of refs) {
+      let found;
+      try {
+        found = await (this.options.fetch ?? fetchRef)(ref, origin);
+      } catch (error) {
+        this.options.logger.warn("skill source failed", { origin, ref, error: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      for (const skill of found.skills) {
+        if (list.length >= MAX_SKILLS || list.some((s) => s.name === skill.name)) continue;
+        list.push({ name: skill.name, description: skill.description, source: found.source, shared: found.shared, integrity: await this.put(skill) });
+      }
+    }
+    return list;
+  }
+  /**
+   * A connected site sent its skill refs with a session: when they changed,
+   * fetch them in the background and update its grant. Sessions starting
+   * meanwhile keep the skills it had.
+   */
+  refresh(origin, refs) {
+    const grant = this.options.grants.get(origin);
+    if (!grant || sameRefs(grant.skills?.refs, refs) || this.refreshing.has(origin)) return;
+    const done = (async () => {
+      const list = refs ? await this.resolve(origin, refs) : [];
+      const before = new Set((this.options.grants.get(origin)?.skills?.list ?? []).map((s) => s.name));
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const marked = list.map((s) => before.has(s.name) ? s : { ...s, addedAt: now });
+      this.options.grants.setSkills(origin, refs ? { refs, list: marked } : void 0);
+    })().catch((error) => this.options.logger.warn("skills refresh failed", { origin, error: String(error) })).finally(() => this.refreshing.delete(origin));
+    this.refreshing.set(origin, done);
+  }
+  /** The skills a session of `origin` gets, from the cache. */
+  async forSession(origin) {
+    const list = this.options.grants.get(origin)?.skills?.list ?? [];
+    const loaded = await Promise.all(list.map((s) => this.get(s.integrity).catch(() => null)));
+    return loaded.filter((s) => s !== null);
+  }
+  /** Wait for background refreshes (tests). */
+  async settled() {
+    await Promise.all(this.refreshing.values());
+  }
+  async put(skill) {
+    const data = JSON.stringify(skill);
+    if (this.cache === null) {
+      const integrity = `sha256-${createHash4("sha256").update(data).digest("base64")}`;
+      this.memory.set(integrity, skill);
+      return integrity;
+    }
+    return String(await cacache.put(this.cache, `skill:${skill.name}`, data, { algorithms: ["sha256"] }));
+  }
+  async get(integrity) {
+    if (this.cache === null) {
+      const skill = this.memory.get(integrity);
+      if (!skill) throw new Error("not cached");
+      return skill;
+    }
+    return JSON.parse((await cacache.get.byDigest(this.cache, integrity)).toString("utf-8"));
+  }
+};
+async function fetchRef(ref, origin) {
+  const source = parseSkillSource(ref, origin);
+  return { skills: await fetchSkills(source), source: sourceLabel(source), shared: source.kind === "github" };
+}
+function skillsPrompt(skills) {
+  return [
+    "This site gives you skills: instructions for tasks on this site.",
+    `When a request matches a skill, call \`${READ_SKILL}\` with its name first and follow what it says.`,
+    "",
+    ...skills.map((s) => `- ${s.name}: ${s.description}`)
+  ].join("\n");
+}
+function readSkillTool(skills) {
+  return {
+    name: READ_SKILL,
+    description: "Read one of this site's skills: its instructions, or one of its files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", enum: skills.map((s) => s.name), description: "The skill's name." },
+        file: { type: "string", description: "A file the skill mentions, by its path. Leave out for the skill's instructions." }
+      },
+      required: ["name"]
+    },
+    annotations: { readOnlyHint: true }
+  };
+}
+function readSkill(skills, args) {
+  const skill = skills.find((s) => s.name === args.name);
+  if (!skill) throw new Error(`No skill named ${String(args.name)}. Skills: ${skills.map((s) => s.name).join(", ")}`);
+  if (typeof args.file === "string" && args.file) {
+    const file = skill.files[args.file.replace(/^\.\//, "")];
+    if (file === void 0) throw new Error(`${skill.name} has no file ${args.file}`);
+    return file;
+  }
+  const files = Object.keys(skill.files);
+  return files.length ? `${skill.body}
+
+---
+Files of this skill (read one with \`file\`): ${files.join(", ")}` : skill.body;
+}
+
 // src/pairing.ts
 var REQUEST_TTL_MS = 5 * 6e4;
 var MAX_PENDING = 20;
 var WAIT_MS = 25e3;
 var DENIED_COOLDOWN_MS = 3e4;
 var NONCE = /^[A-Za-z0-9_-]{22,128}$/;
-var hashNonce = (nonce) => createHash3("sha256").update(nonce).digest();
+var hashNonce = (nonce) => createHash5("sha256").update(nonce).digest();
 var Pairing = class {
   constructor(options) {
     this.options = options;
@@ -1508,7 +1960,7 @@ var Pairing = class {
     if (this.options.selfOrigins.has(origin)) return { error: "The link doesn't name a website." };
     if (typeof input.nonce !== "string" || !NONCE.test(input.nonce)) return { error: "The link is incomplete." };
     const app = typeof input.app === "string" && input.app.trim() ? input.app.trim().slice(0, 80) : void 0;
-    const request = this.open(origin, app, input.nonce, parseNeeds(input.needs));
+    const request = this.open(origin, app, input.nonce, parseNeeds(input.needs), parseSkillRefs(input.skills));
     return "error" in request ? request : { requestId: request.id };
   }
   /** Returns true when the request was a pairing route. */
@@ -1534,7 +1986,7 @@ var Pairing = class {
         sendJson(res, 403, { error: "Forbidden" });
         return true;
       }
-      sendJson(res, 200, { decision: request?.decision ?? "expired" });
+      sendJson(res, 200, { decision: request?.decision ?? "expired", ...request?.skills && !request.skills.list ? { skillsLoading: true } : {} });
       return true;
     }
     if (req.method === "POST" && action === "decide") {
@@ -1579,7 +2031,7 @@ var Pairing = class {
         return;
       }
       const app = typeof body.app === "string" && body.app.trim() ? body.app.trim().slice(0, 80) : void 0;
-      const opened = this.open(origin, app, nonce, parseNeeds(body.needs));
+      const opened = this.open(origin, app, nonce, parseNeeds(body.needs), parseSkillRefs(body.skills));
       if ("error" in opened) {
         sendJson(res, opened.status, { error: opened.error });
         return;
@@ -1604,7 +2056,7 @@ var Pairing = class {
     }
   }
   /** Ask the visitor about `origin`, or update the question already asked. */
-  open(origin, app, nonce, needs) {
+  open(origin, app, nonce, needs, skillRefs) {
     const denied = this.deniedAt.get(origin);
     if (denied && Date.now() - denied < DENIED_COOLDOWN_MS) return { error: "The visitor just said no to this site", status: 429 };
     const existing = [...this.requests.values()].find((r) => r.origin === origin && r.decision === "pending");
@@ -1612,6 +2064,7 @@ var Pairing = class {
       existing.nonce = hashNonce(nonce);
       if (app) existing.app = app;
       if (needs) existing.needs = needs;
+      if (skillRefs && !sameRefs(existing.skills?.refs, skillRefs)) this.fetchSkills(existing, skillRefs);
       this.options.onRequest?.(this.info(existing));
       return existing;
     }
@@ -1629,16 +2082,35 @@ var Pairing = class {
       waiters: /* @__PURE__ */ new Set()
     };
     this.requests.set(request.id, request);
+    if (skillRefs) this.fetchSkills(request, skillRefs);
     this.options.logger.info("pairing requested", { origin, app });
     this.options.onRequest?.(this.info(request));
     return request;
   }
+  /**
+   * Fetch the skills the site names, then show them: the question is asked
+   * again with them. Answered meanwhile: they go to the site's grant.
+   */
+  fetchSkills(request, refs) {
+    const { resolveSkills } = this.options;
+    if (!resolveSkills) return;
+    const skills = { refs };
+    request.skills = skills;
+    void resolveSkills(request.origin, refs).catch(() => []).then((list) => {
+      if (request.skills !== skills) return;
+      skills.list = list;
+      if (request.decision === "pending") this.options.onRequest?.(this.info(request));
+      else if (request.decision === "allowed") this.options.grants.setSkills(request.origin, { refs, list });
+    });
+  }
   info(request) {
+    const skills = request.skills;
     return {
       requestId: request.id,
       origin: request.origin,
       app: request.app,
       ...request.needs ? { needs: request.needs } : {},
+      ...skills ? { skills: { loading: !skills.list, list: (skills.list ?? []).map(({ name, description, source, shared }) => ({ name, description, source, shared })) } } : {},
       approveUrl: `http://127.0.0.1:${this.options.port}/connect/${request.id}`
     };
   }
@@ -1661,7 +2133,8 @@ var Pairing = class {
   }
   decide(request, allow, granted) {
     if (allow) {
-      request.token = this.options.grants.create(request.origin, request.app, request.needs);
+      const skills = request.skills ? { refs: request.skills.refs, list: request.skills.list ?? [] } : void 0;
+      request.token = this.options.grants.create(request.origin, request.app, request.needs, skills);
       granted?.(request.origin);
       request.decision = "allowed";
     } else {
@@ -1750,6 +2223,15 @@ button.ink:hover { background: var(--ink-hover); }
 button:disabled { opacity: 0.5; cursor: default; }
 button:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
 .small { font-size: 12px; }
+.skills { border: 1px solid var(--border); border-radius: 12px; padding: 10px 12px; font-size: 14px; }
+.skills summary { cursor: pointer; display: flex; justify-content: space-between; gap: 8px; list-style: none; }
+.skills summary::-webkit-details-marker { display: none; }
+.skills summary span:last-child { color: var(--muted); white-space: nowrap; }
+.skills[open] summary span:last-child::after { content: " \\25B4"; }
+.skills:not([open]) summary span:last-child::after { content: " \\25BE"; }
+.skills ul { margin-top: 10px; gap: 10px; }
+.skills li { display: block; }
+.skills li p { font-size: 13px; }
 `;
 var MARK = "M181 61 C184 74 191 82 206 86 C191 90 184 98 181 111 C178 98 171 90 156 86 C171 82 178 74 181 61 Z M59 92 C60 109 67 128 79 143 C91 158 105 168 124 174 C149 182 164 193 171 207 C177 219 177 239 177 255 C182 255 182 240 184 226 C188 199 201 187 223 179 C247 171 270 158 284 142 C298 127 303 109 303 92 C298 91 292 101 284 108 C265 125 245 130 226 126 C217 124 211 114 205 112 C199 110 199 116 199 121 C198 127 191 130 181 130 C171 130 165 127 163 121 C162 116 165 110 159 111 C151 112 148 122 137 126 C118 131 98 125 78 109 C69 102 65 91 59 92 Z";
 var LOGO = `<span class="logo" role="img" aria-label="Leuria"><svg width="22" height="22" viewBox="53 30 256 256" aria-hidden="true"><path d="${MARK}" fill="currentColor"/></svg>leuria</span>`;
@@ -1774,6 +2256,7 @@ function approvePage(request, agentName2) {
 <p>It will talk to ${agent}, on this computer.</p>
 <div><div class="eyebrow">It can</div><ul class="can"><li>${CHECK}Ask your AI to answer you</li><li>${CHECK}Let your AI use its own page's tools</li></ul></div>
 <div><div class="eyebrow">It can't</div><ul class="cant"><li>${CROSS}See your files or run programs</li><li>${CROSS}See what you do on other websites</li></ul></div>
+${skillsSection(request)}
 ${insecure ? `<p class="warn">This site doesn't use a secure connection.</p>` : ""}
 <p class="small">You can disconnect it at any time with <code>leuria sites revoke ${escapeHtml(request.origin)}</code>.</p>
 <div class="actions"><button type="button" class="soft" id="deny">Not now</button><button type="button" class="ink" id="allow">Allow</button></div>`;
@@ -1794,14 +2277,25 @@ async function decide(allow) {
 }
 document.getElementById("allow").addEventListener("click", () => decide(true));
 document.getElementById("deny").addEventListener("click", () => decide(false));
-// Answered in the Leuria app instead: close this window too.
+// Answered in the Leuria app instead: close this window too. The site's skills fetched: show them.
+const skillsLoading = ${request.skills && !request.skills.list ? "true" : "false"};
 setInterval(async () => {
   const res = await fetch(location.pathname + "/state").catch(() => null);
   const state = res && res.ok ? await res.json() : null;
   if (state && state.decision !== "pending") done("Answered in Leuria", "You can close this window.");
+  else if (state && skillsLoading && !state.skillsLoading) location.reload();
 }, 1500);`;
   return page("Connect your AI", body, script);
 }
+function skillsSection(request) {
+  const skills = request.skills;
+  if (!skills) return "";
+  if (!skills.list) return `<p>Checking the skills this site uses to guide your AI\u2026</p>`;
+  if (!skills.list.length) return "";
+  const count = skills.list.length === 1 ? "1 skill" : `${skills.list.length} skills`;
+  const items = skills.list.map((s) => `<li><strong>${escapeHtml(s.name)}</strong><p>${escapeHtml(s.description)}</p><p class="small">${s.shared ? `Shared skill \xB7 ${escapeHtml(s.source)}` : `From ${escapeHtml(s.source)}`}</p></li>`).join("");
+  return `<details class="skills"><summary><span>This site uses ${count} to guide your AI.</span><span>See details</span></summary><ul>${items}</ul></details>`;
+}
 function messagePage(title, text) {
   return page(title, `<h1>${escapeHtml(title)}</h1><p>${escapeHtml(text)}</p>`);
 }
@@ -1832,12 +2326,12 @@ var POST_ACTIONS = /* @__PURE__ */ new Set([
   "cancel",
   "close"
 ]);
-async function handleSessionRequest(req, res, pathname, sm, requester) {
+async function handleSessionRequest(req, res, pathname, sm, requester, onSkills) {
   const segments = pathname.split("/").filter(Boolean);
   if (segments[0] !== "session") return false;
   try {
     if (req.method === "POST" && segments.length === 2 && segments[1] === "prepare") {
-      await handlePrepare(req, res, sm, requester);
+      await handlePrepare(req, res, sm, requester, onSkills);
       return true;
     }
     const sessionId = segments[1];
@@ -1886,8 +2380,9 @@ async function runAction(req, sm, sessionId, action) {
       return sm.close(sessionId);
   }
 }
-async function handlePrepare(req, res, sm, origin) {
+async function handlePrepare(req, res, sm, origin, onSkills) {
   const body = await parseBody(req);
+  if ("skills" in body) onSkills?.(origin, parseSkillRefs(body.skills));
   if (body.prompt !== void 0 && (typeof body.prompt !== "string" || !body.prompt.trim())) {
     sendJson(res, 400, { error: "prompt must be a non-empty string when given" });
     return;
@@ -1938,8 +2433,8 @@ function handleStream(req, res, sm, sessionId) {
 // src/session-manager.ts
 import { randomUUID } from "crypto";
 import { mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join6 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join7 } from "path";
 
 // src/llm/llm-session.ts
 var LlmSession = class {
@@ -2260,6 +2755,12 @@ var SessionManager = class {
       return;
     }
     if (TERMINAL.has(session.status)) return;
+    const skills = await this.options.loadSkills?.(session.params.origin).catch(() => []) ?? [];
+    if (skills.length) {
+      this.options.webMcpServer.setSkills(session.id, skills);
+      session.params.systemPrompt = [session.params.systemPrompt, skillsPrompt(skills)].filter(Boolean).join("\n\n");
+    }
+    if (TERMINAL.has(session.status)) return;
     const live = launch.llm ? this.llmSession(session, launch.llm) : this.acpSession(session, launch);
     session.live = live;
     const timeoutMs = this.options.startTimeoutMs ?? 6e4;
@@ -2418,7 +2919,7 @@ var SessionManager = class {
    * files (CLAUDE.md, repo) to act on.
    */
   allocateSandbox(sessionId) {
-    const dir = join6(tmpdir3(), `leuria-${sessionId}`);
+    const dir = join7(tmpdir4(), `leuria-${sessionId}`);
     mkdirSync6(dir, { recursive: true });
     return dir;
   }
@@ -2509,6 +3010,7 @@ var WebMcpServer = class {
       tools: /* @__PURE__ */ new Map(),
       resources: /* @__PURE__ */ new Map(),
       prompts: /* @__PURE__ */ new Map(),
+      skills: [],
       pendingRequests: /* @__PURE__ */ new Map(),
       pingTimer: null
     };
@@ -2617,20 +3119,33 @@ var WebMcpServer = class {
     this.logger.info("WebMCP channel removed", { sessionId, channelId });
   }
   // ── In-process access (the engine's own agent loop for LLM providers) ──
-  /** The page tools a session's browser has declared. */
+  /** Give a session its site's skills: the agent then also gets `read_skill`. */
+  setSkills(sessionId, skills) {
+    const channelId = this.sessionChannels.get(sessionId);
+    const channel = channelId ? this.channels.get(channelId) : void 0;
+    if (channel) channel.skills = skills;
+  }
+  /** The tools a session's agent gets: the page's, and `read_skill` when the site has skills. */
   listTools(sessionId) {
     const channelId = this.sessionChannels.get(sessionId);
     const channel = channelId ? this.channels.get(channelId) : void 0;
-    return channel ? Array.from(channel.tools.values()) : [];
+    return channel ? this.toolsOf(channel) : [];
   }
-  /** Run a page tool in the browser; resolves with its JSON result. Throws on tool errors. */
+  /** Run a page tool in the browser (or `read_skill` here); resolves with its JSON result. Throws on tool errors. */
   async callTool(sessionId, name, args) {
     const channelId = this.sessionChannels.get(sessionId);
     const channel = channelId ? this.channels.get(channelId) : void 0;
     if (!channel) throw new Error("The page is not connected");
+    if (name === READ_SKILL && channel.skills.length) return readSkill(channel.skills, args);
     if (!channel.tools.has(name)) throw new Error(`Unknown tool: ${name}`);
     return this.forwardToBrowser(channel, "callTool", { tool: name, arguments: args });
   }
+  /** The page's tools, and the engine's `read_skill` in place of a page tool of that name. */
+  toolsOf(channel) {
+    const page2 = Array.from(channel.tools.values());
+    if (!channel.skills.length) return page2;
+    return [...page2.filter((t) => t.name !== READ_SKILL), readSkillTool(channel.skills)];
+  }
   // ── HTTP / WS dispatch (called from daemon) ──────────────────────────
   /** Returns true when the request path belongs to WebMCP. */
   matches(pathname) {
@@ -3036,7 +3551,7 @@ var WebMcpServer = class {
       }
       case "tools/list":
         return {
-          tools: Array.from(channel.tools.values()).map((t) => ({
+          tools: this.toolsOf(channel).map((t) => ({
             name: t.name,
             description: t.description,
             inputSchema: t.inputSchema,
@@ -3047,6 +3562,9 @@ var WebMcpServer = class {
         const name = req.params?.name;
         const args = req.params?.arguments;
         if (!name) throw new Error("Missing tool name");
+        if (name === READ_SKILL && channel.skills.length) {
+          return { content: [{ type: "text", text: readSkill(channel.skills, args ?? {}) }] };
+        }
         if (!channel.tools.has(name)) {
           throw new Error(`Unknown tool: ${name}`);
         }
@@ -3175,12 +3693,14 @@ async function startEngine(options) {
   const selfOrigins = /* @__PURE__ */ new Set([`http://127.0.0.1:${port}`, `http://localhost:${port}`]);
   const allowedHosts = /* @__PURE__ */ new Set([`127.0.0.1:${port}`, `localhost:${port}`]);
   const silent = options.silent ?? Boolean(options.admin);
+  const skills = options.skills ?? new SkillService({ grants, logger });
   const webMcpServer = new WebMcpServer(logger, port);
   const sessions = new SessionManager({
     webMcpServer,
     port,
     logger,
     resolveAgent: options.resolveAgent,
+    loadSkills: (origin) => skills.forSession(origin),
     startTimeoutMs: options.startTimeoutMs,
     stdioMcpCommand: options.stdioMcpCommand,
     onAgentState: options.onAgentState
@@ -3194,6 +3714,7 @@ async function startEngine(options) {
     port,
     linksOnly: silent,
     agentName: () => agentName2(),
+    resolveSkills: (origin, refs) => skills.resolve(origin, refs),
     onRequest: options.onPairingRequest,
     onDecided: options.onPairingDecided
   });
@@ -3328,7 +3849,8 @@ async function startEngine(options) {
         return;
       }
       const requester = caller.kind === "site" ? caller.origin : "local";
-      if (await handleSessionRequest(req, res, pathname, sessions, requester)) return;
+      const onSkills = caller.kind === "site" ? (origin, refs) => skills.refresh(origin, refs) : void 0;
+      if (await handleSessionRequest(req, res, pathname, sessions, requester, onSkills)) return;
       sendJson(res, 404, { error: "Not found" });
     } catch (err) {
       logger.error("request failed", {
@@ -3407,6 +3929,8 @@ export {
   decidePermission,
   installedAgent,
   ensureAgent,
+  pruneAgentVersions,
+  updateAgents,
   resolveAgentCommand,
   resolveSiteAgent,
   agentName,