openmausbot 0.1.86 → 0.1.88

package/dist-server/server/skill-fetch.js

@@ -1,5 +1,6 @@
 // Fetch a skill's files from where users actually keep skills: a GitHub
-// repo, a folder inside one, or a direct SKILL.md. Network in, plain
+// repo, a folder inside one, a direct SKILL.md, or a skills.sh page that
+// points at one. Network in, plain
 // {path, content} list out — validation, scanning, and storage live in
 // skills.ts, so this file owns exactly one concern and its tests can hand
 // it a fake fetch.
@@ -53,8 +54,9 @@ function boundedImportFetch(fetcher) {
         return new Response(Buffer.concat(chunks), { status: response.status, headers: response.headers });
     };
 }
-/** owner/repo, github.com/owner/repo[/tree/<ref>/<path>], or a raw/blob URL
- * straight to a SKILL.md. Anything else is refused, loudly. */
+/** owner/repo, github.com/owner/repo[/tree/<ref>/<path>], a raw/blob URL
+ * straight to a SKILL.md, or a skills.sh/owner/repo[/skill] page. Anything
+ * else is refused, loudly. */
 export function parseSkillSource(input) {
     const text = input.trim();
     if (!text)
@@ -69,10 +71,21 @@ export function parseSkillSource(input) {
     if (tree) {
         return { owner: tree[1], repo: tree[2], ref: tree[3], path: tree[4] ?? "" };
     }
+    const registry = text.match(/^https?:\/\/skills\.sh\/([\w.-]+)\/([\w.-]+)(?:\/([\w.-]+))?\/?$/i);
+    if (registry) {
+        if ([registry[1], registry[2]].some((part) => part === "." || part === "..") ||
+            (registry[3] && !/^[a-z0-9]+(?:-[a-z0-9]+)*$/i.test(registry[3]))) {
+            return { error: "that does not look like a skills.sh repository or skill URL" };
+        }
+        // skills.sh is a registry over GitHub: each page installs from
+        // github.com/<owner>/<repo> filtered to the named skill, so resolve to
+        // the repo and remember the slug to filter discovery on.
+        return { owner: registry[1], repo: registry[2], path: "", skill: registry[3] };
+    }
     const shorthand = text.match(/^([\w.-]+)\/([\w.-]+)$/);
     if (shorthand)
         return { owner: shorthand[1], repo: shorthand[2], path: "" };
-    return { error: "that does not look like a GitHub repository, folder, or SKILL.md URL" };
+    return { error: "that does not look like a GitHub or skills.sh repository, folder, or SKILL.md URL" };
 }
 const CONTENT_ENTRY = z.object({
     type: z.string(),
@@ -114,21 +127,55 @@ async function listDir(target, path, fetcher) {
 export const MAX_SKILLS_PER_IMPORT = 30;
 const MAX_FOLDERS_WALKED = 24;
 const MAX_CHILDREN_PER_FOLDER = 60;
+/** Convert a skill name to a URL-safe slug, mirroring the skills.sh
+ * registry's own toSkillSlug: page slugs derive from each SKILL.md's name
+ * field, which can differ from the folder it lives in. */
+const toSkillSlug = (name) => name.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+/** The name field from a skill folder's SKILL.md frontmatter, or undefined
+ * when it cannot be read. Budget and timeout errors still propagate. */
+async function skillNameFrom(entries, fetcher) {
+    const skillMd = entries.find((entry) => entry.type === "file" && entry.name === "SKILL.md" && entry.download_url);
+    if (!skillMd)
+        return undefined;
+    try {
+        const text = await fetchText(skillMd.download_url, fetcher);
+        return text.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1]?.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+    }
+    catch (error) {
+        if (error instanceof ImportLimitError || (error instanceof Error && error.name === "TimeoutError"))
+            throw error;
+        return undefined;
+    }
+}
 /** Where SKILL.md folders live in real repos, per the registry's own
  * discovery order: the pasted path itself, then skills/, then .claude/skills/
- * and .agents/skills/, then one level of direct children. */
+ * and .agents/skills/, then one level of direct children. A requested
+ * skills.sh slug matches a folder whose name slugifies to it, else a skill
+ * whose SKILL.md name does, like the registry's own installer. */
 export async function discoverSkillDirs(target, fetcher) {
     const root = await listDir(target, target.path, fetcher);
-    if (root.some((entry) => entry.type === "file" && entry.name === "SKILL.md")) {
+    const wanted = target.skill ? toSkillSlug(target.skill) || undefined : undefined;
+    const dirMatches = (dir) => !!wanted && toSkillSlug(dir.split("/").at(-1)) === wanted;
+    const isWanted = async (dir, entries) => {
+        if (!wanted)
+            return true;
+        if (dirMatches(dir))
+            return true;
+        const name = await skillNameFrom(entries, fetcher);
+        return !!name && toSkillSlug(name) === wanted;
+    };
+    if (root.some((entry) => entry.type === "file" && entry.name === "SKILL.md") && (await isWanted(target.path, root))) {
         return [target.path];
     }
     const dirs = root.filter((entry) => entry.type === "dir");
     const found = [];
     const preferred = ["skills", ".claude", ".agents"];
-    const ordered = [...dirs].sort((a, b) => (preferred.includes(a.name) ? 0 : 1) - (preferred.includes(b.name) ? 0 : 1));
+    const rank = (name) => (wanted && toSkillSlug(name) === wanted ? 0 : preferred.includes(name) ? 1 : 2);
+    const ordered = [...dirs].sort((a, b) => rank(a.name) - rank(b.name));
+    const enough = () => found.length >= (wanted ? 1 : MAX_SKILLS_PER_IMPORT);
     // The shared fetch budget caps the whole walk, not each nested loop.
     for (const dir of ordered.slice(0, MAX_FOLDERS_WALKED)) {
-        if (found.length >= MAX_SKILLS_PER_IMPORT)
+        if (enough())
             break;
         const base = dir.name === ".claude" || dir.name === ".agents" ? `${dir.path}/skills` : dir.path;
         let children;
@@ -141,15 +188,21 @@ export async function discoverSkillDirs(target, fetcher) {
             continue;
         }
         if (children.some((entry) => entry.type === "file" && entry.name === "SKILL.md")) {
-            found.push(base);
+            if (await isWanted(base, children))
+                found.push(base);
             continue;
         }
-        for (const child of children.filter((entry) => entry.type === "dir").slice(0, MAX_CHILDREN_PER_FOLDER)) {
-            if (found.length >= MAX_SKILLS_PER_IMPORT)
+        const childDirs = children.filter((entry) => entry.type === "dir");
+        const exact = wanted ? childDirs.find((child) => dirMatches(child.path)) : undefined;
+        const candidates = exact
+            ? [exact, ...childDirs.filter((child) => child !== exact).slice(0, MAX_CHILDREN_PER_FOLDER - 1)]
+            : childDirs.slice(0, MAX_CHILDREN_PER_FOLDER);
+        for (const child of candidates) {
+            if (enough())
                 break;
             try {
                 const inner = await listDir(target, child.path, fetcher);
-                if (inner.some((entry) => entry.type === "file" && entry.name === "SKILL.md"))
+                if (inner.some((entry) => entry.type === "file" && entry.name === "SKILL.md") && (await isWanted(child.path, inner)))
                     found.push(child.path);
             }
             catch (error) {
@@ -191,8 +244,13 @@ export async function fetchSkillFromSource(input, fetcher = fetch) {
             return { skills: [{ source: parsed.rawUrl, files: [{ path: "SKILL.md", content }] }] };
         }
         const dirs = await discoverSkillDirs(parsed, fetcher);
-        if (!dirs.length)
-            return { error: "no SKILL.md found there — paste a skill folder or a repo with a skills/ directory" };
+        if (!dirs.length) {
+            return {
+                error: parsed.skill
+                    ? `no skill named "${parsed.skill}" found there — check the exact name on the skills.sh page`
+                    : "no SKILL.md found there — paste a skill folder or a repo with a skills/ directory",
+            };
+        }
         const skills = [];
         for (const dir of dirs)
             skills.push(await fetchSkillDir(parsed, dir, fetcher));

package/dist-server/server/skills.js

@@ -34,14 +34,11 @@ import { DATA_DIR } from "./config.js";
 import { redactSecretsInText } from "./redact.js";
 import { LEARN_SOURCE_PREFIX } from "./skill-learn.js";
 import { workspaceDir } from "./workspace.js";
-/** Spec rule: lowercase alphanumerics with single hyphens, 1-64 chars,
- * folder name must equal it. The regex IS the traversal gate — no dots, no
- * slashes, no way to name a skill "..". */
-const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-export const SKILL_NAME_MAX = 64;
-export const DESCRIPTION_MAX = 1024;
-/** One SKILL.md may be at most this large; the spec recommends <5k tokens. */
-export const SKILL_FILE_MAX_BYTES = 256 * 1024;
+import { isSkillName, parseSkillMd, scanSkillText, SKILL_FILE_MAX_BYTES } from "../shared/skill-md.js";
+// SKILL.md parsing and the static scan live in shared/ so the package
+// format (Admin and the renderer included) validates skills with the exact
+// same rules; re-exported here under their historical path.
+export { DESCRIPTION_MAX, isSkillName, parseSkillMd, scanSkillText, SKILL_FILE_MAX_BYTES, SKILL_NAME_MAX, } from "../shared/skill-md.js";
 /** Index budget: name+description lines only, ~100 tokens per skill. */
 export const INDEX_MAX_SKILLS = 30;
 export const INDEX_MAX_BYTES = 4_000;
@@ -51,58 +48,6 @@ export const STAGED_GIST_MAX = 240;
 /** Learned skills are duplicated onto their durable review card. Keep that
  * exact review payload bounded while leaving fetched skill imports unchanged. */
 export const STAGED_SKILL_FILE_MAX_BYTES = 32 * 1024;
-export function isSkillName(name) {
-    return name.length >= 1 && name.length <= SKILL_NAME_MAX && SKILL_NAME.test(name);
-}
-/** Minimal frontmatter reader for the two required keys plus the two we
- * display. Deliberately not a YAML engine: values are single-line strings in
- * every skill the spec's own examples show, and a parser that cannot
- * evaluate anchors or tags cannot be surprised by them. */
-export function parseSkillMd(raw) {
-    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-    if (!match)
-        return { error: "SKILL.md has no YAML frontmatter (--- block) at the top" };
-    const fields = {};
-    for (const line of match[1].split(/\r?\n/)) {
-        const kv = line.match(/^([A-Za-z][\w-]*):\s*(.*)$/);
-        if (!kv)
-            continue;
-        fields[kv[1].toLowerCase()] = kv[2].replace(/^["']|["']$/g, "").trim();
-    }
-    const name = fields.name ?? "";
-    const description = fields.description ?? "";
-    if (!isSkillName(name)) {
-        return { error: `frontmatter name ${JSON.stringify(name)} is not a valid skill name (lowercase, hyphens, max ${SKILL_NAME_MAX})` };
-    }
-    if (!description || description.length > DESCRIPTION_MAX) {
-        return { error: `frontmatter description is required and must be at most ${DESCRIPTION_MAX} characters` };
-    }
-    return {
-        name,
-        description,
-        license: fields.license || undefined,
-        compatibility: fields.compatibility || undefined,
-        body: match[2] ?? "",
-    };
-}
-/** Static red flags before a human review. Presence is a warning shown in
- * the review screen, never a silent rejection — the reviewer decides. These
- * are the three patterns the public registry audits actually caught. */
-export function scanSkillText(raw) {
-    const warnings = [];
-    if (/[A-Za-z0-9+/]{120,}={0,2}/.test(raw)) {
-        warnings.push("contains a long base64-looking blob — a common wrapper for hidden instructions or payloads");
-    }
-    if (/\b(curl|wget)\b[^\n]{0,200}\|\s*(ba|z|da)?sh\b/.test(raw)) {
-        warnings.push("pipes a download straight into a shell (curl|sh) — never enable without understanding why");
-    }
-    // zero-width and bidi-control characters hide text from the reviewer while
-    // the model still reads it — the invisible-instruction trick
-    if (/[\u200B-\u200F\u202A-\u202E\u2060-\u2064\uFEFF]/.test(raw)) {
-        warnings.push("contains invisible Unicode characters (zero-width or bidi controls) — text you cannot see");
-    }
-    return warnings;
-}
 const skillManifestEntrySchema = z.object({
     description: z.string(),
     enabled: z.boolean(),
@@ -115,6 +60,14 @@ const skillManifestEntrySchema = z.object({
     skippedFiles: z.array(z.string()),
     appliedStageId: z.string().optional(),
     storageRevision: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    package: z.object({
+        installId: z.string().regex(/^[a-f0-9]{32}$/),
+        key: z.string().min(1).max(64),
+        release: z.string().min(1).max(40),
+        r: z.string().regex(/^[a-f0-9]{64}$/),
+        w: z.string().regex(/^[a-f0-9]{64}$/),
+        via: z.literal("preset").optional(),
+    }).optional(),
 });
 const skillManifestSchema = z.record(z.string(), skillManifestEntrySchema);
 const managedLinksSchema = z.array(z.string());
@@ -498,7 +451,7 @@ function skillContentMatches(botId, name, entry) {
     }
 }
 function skillListing(botId, name, entry) {
-    const { appliedStageId, storageRevision: _storageRevision, ...visible } = entry;
+    const { appliedStageId, storageRevision: _storageRevision, package: _package, ...visible } = entry;
     const intact = skillContentMatches(botId, name, entry);
     return {
         name,
@@ -563,6 +516,26 @@ export function installSkill(botId, source, files) {
         return prepared;
     return installPreparedSkill(botId, source, prepared, { enabled: false });
 }
+/** The organization library's path: a skill the organization's Admin
+ * published arrives switched ON (the Admin is the review), with the install
+ * stamp that lets the library find it again. `source` is chosen by the
+ * caller (`org:<ref>@<release>`), never read from the package. */
+export function installOrgSkill(botId, source, skillMd, stamp) {
+    if (!source.startsWith("org:"))
+        return { error: "organization skills need an org: source" };
+    const prepared = preparedSkillFiles([{ path: "SKILL.md", content: skillMd }]);
+    if ("error" in prepared)
+        return prepared;
+    if (prepared.parsed.name !== stamp.key)
+        return { error: `the skill is named "${prepared.parsed.name}", not "${stamp.key}"` };
+    return installPreparedSkill(botId, source, prepared, { enabled: true, package: { ...stamp } });
+}
+/** A bot's skills that an organization install added, with their stamps. */
+export function skillPackageStamps(botId) {
+    return Object.entries(readManifest(botId)).flatMap(([name, entry]) => entry.package
+        ? [{ name, enabled: entry.enabled, stamp: { ...entry.package } }]
+        : []);
+}
 export function setSkillEnabled(botId, name, enabled) {
     if (!isSkillName(name))
         return { error: "invalid skill name" };
@@ -936,6 +909,7 @@ function installPreparedSkill(botId, source, prepared, options) {
         warnings: prepared.warnings,
         skippedFiles: prepared.skippedFiles,
         appliedStageId: options.appliedStageId,
+        ...(options.package ? { package: options.package } : {}),
     };
     const root = ensureSkillsRoot(botId);
     if (!root)

package/dist-server/server/steer-queue.js

@@ -81,14 +81,15 @@ export function queueSteeredMessage(botId, threadId, text, options = {}) {
     changed();
     return { id };
 }
-/** Where a thread stands among this bot's threads waiting for a free slot:
+/** Where a thread stands among this bot's threads waiting for the bot to
+ * become available (a full slot list or an active room turn):
  * 1 for the next to start. The drain visits queues in insertion order, so
  * insertion order is the line. Null when nothing of this bot's is waiting
  * on that thread. */
 export function queuedThreadPosition(botId, threadId) {
     let position = 0;
     for (const [candidate, entry] of queues) {
-        if (entry.botId !== botId || !entry.items.some((item) => item.reason === "capacity"))
+        if (entry.botId !== botId || !entry.items.some((item) => item.reason === "capacity" || item.reason === "group-turn"))
             continue;
         position += 1;
         if (candidate === threadId)