open-managed-agents 0.1.0

package/dist/src/control-plane/skills/archive.js

@@ -0,0 +1,169 @@
+import { createHash } from "node:crypto";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import yauzl from "yauzl";
+import { invalidRequest } from "../errors.js";
+import { MAX_SKILL_FILE_BYTES, MAX_SKILL_FILES, MAX_SKILL_VERSION_BYTES, } from "./types.js";
+export async function validateSkillUpload(inputs) {
+    if (inputs.length === 0)
+        throw invalidRequest("`files[]` is required");
+    const zip = inputs.length === 1 && inputs[0].name.toLowerCase().endsWith(".zip");
+    let raw;
+    try {
+        raw = zip ? await unzip(inputs[0].bytes) : inputs;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "status" in error)
+            throw error;
+        throw invalidRequest("Skill archive must be a valid zip", String(error));
+    }
+    return validateFiles(raw);
+}
+async function unzip(bytes) {
+    const zip = await openZip(bytes);
+    const files = [];
+    let total = 0;
+    try {
+        while (true) {
+            const entry = await nextEntry(zip);
+            if (entry === undefined)
+                break;
+            assertEntrySafe(entry);
+            if (entry.fileName.endsWith("/"))
+                continue;
+            if (entry.uncompressedSize > MAX_SKILL_FILE_BYTES)
+                throw invalidRequest("Skill file exceeds the 20 MiB limit");
+            total += entry.uncompressedSize;
+            if (total > MAX_SKILL_VERSION_BYTES)
+                throw invalidRequest("Skill content exceeds the 100 MiB limit");
+            if (files.length >= MAX_SKILL_FILES)
+                throw invalidRequest("Skill contains more than 500 files");
+            files.push({ name: entry.fileName, bytes: await readEntry(zip, entry) });
+        }
+    }
+    finally {
+        zip.close();
+    }
+    return files;
+}
+function openZip(bytes) {
+    return new Promise((resolve, reject) => yauzl.fromBuffer(Buffer.from(bytes), {
+        lazyEntries: true,
+        validateEntrySizes: true,
+        decodeStrings: true,
+    }, (error, zip) => error || !zip ? reject(error ?? new Error("Invalid zip")) : resolve(zip)));
+}
+function nextEntry(zip) {
+    return new Promise((resolve, reject) => {
+        const onEntry = (entry) => { cleanup(); resolve(entry); };
+        const onEnd = () => { cleanup(); resolve(undefined); };
+        const onError = (error) => { cleanup(); reject(error); };
+        const cleanup = () => { zip.off("entry", onEntry); zip.off("end", onEnd); zip.off("error", onError); };
+        zip.once("entry", onEntry);
+        zip.once("end", onEnd);
+        zip.once("error", onError);
+        zip.readEntry();
+    });
+}
+function assertEntrySafe(entry) {
+    const name = entry.fileName;
+    if ((entry.generalPurposeBitFlag & 1) !== 0)
+        throw invalidRequest("Encrypted zip entries are not supported");
+    if (name.includes("\\") || name.includes("\0") || name.startsWith("/") || name.split("/").includes("..")) {
+        throw invalidRequest("Skill archive contains an unsafe path");
+    }
+    const mode = (entry.externalFileAttributes >>> 16) & 0xffff;
+    const kind = mode & 0xf000;
+    if (kind !== 0 && kind !== 0x8000 && kind !== 0x4000)
+        throw invalidRequest("Skill archive contains a non-regular entry");
+}
+function readEntry(zip, entry) {
+    return new Promise((resolve, reject) => zip.openReadStream(entry, (error, stream) => {
+        if (error || !stream) {
+            reject(error ?? new Error("Cannot read zip entry"));
+            return;
+        }
+        const chunks = [];
+        let size = 0;
+        stream.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_SKILL_FILE_BYTES)
+                stream.destroy(new Error("Skill file exceeds the 20 MiB limit"));
+            else
+                chunks.push(chunk);
+        });
+        stream.once("error", reject);
+        stream.once("end", () => resolve(new Uint8Array(Buffer.concat(chunks))));
+    }));
+}
+function validateFiles(raw) {
+    if (raw.length === 0 || raw.length > MAX_SKILL_FILES)
+        throw invalidRequest("Skill must contain between 1 and 500 files");
+    const seen = new Set();
+    const folded = new Set();
+    const files = [];
+    let totalBytes = 0;
+    for (const item of raw) {
+        const path = normalizePath(item.name);
+        const lower = path.toLocaleLowerCase("en-US");
+        if (seen.has(path) || folded.has(lower))
+            throw invalidRequest("Skill contains duplicate paths");
+        seen.add(path);
+        folded.add(lower);
+        if (item.bytes.byteLength > MAX_SKILL_FILE_BYTES)
+            throw invalidRequest("Skill file exceeds the 20 MiB limit");
+        totalBytes += item.bytes.byteLength;
+        if (totalBytes > MAX_SKILL_VERSION_BYTES)
+            throw invalidRequest("Skill content exceeds the 100 MiB limit");
+        files.push({ path, bytes: item.bytes, size: item.bytes.byteLength, sha256: sha256(item.bytes) });
+    }
+    for (const path of seen) {
+        const segments = path.split("/");
+        for (let index = 1; index < segments.length; index += 1) {
+            const prefix = segments.slice(0, index).join("/");
+            if (seen.has(prefix) || folded.has(prefix.toLocaleLowerCase("en-US"))) {
+                throw invalidRequest("Skill contains a file/directory path conflict");
+            }
+        }
+    }
+    const roots = new Set(files.map((file) => file.path.split("/")[0]));
+    if (roots.size !== 1 || files.some((file) => !file.path.includes("/"))) {
+        throw invalidRequest("Zip must contain a top-level folder with all files inside it, including SKILL.md");
+    }
+    const directory = [...roots][0];
+    const skillFiles = files.filter((file) => file.path === `${directory}/SKILL.md`);
+    if (skillFiles.length !== 1)
+        throw invalidRequest("Skill must contain exactly one top-level SKILL.md");
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(skillFiles[0].bytes);
+    }
+    catch {
+        throw invalidRequest("SKILL.md must be valid UTF-8");
+    }
+    let frontmatter;
+    try {
+        ({ frontmatter } = parseFrontmatter(text));
+    }
+    catch (error) {
+        throw invalidRequest("SKILL.md frontmatter must be valid YAML", String(error));
+    }
+    const name = typeof frontmatter.name === "string" ? frontmatter.name : "";
+    const description = typeof frontmatter.description === "string" ? frontmatter.description : "";
+    if (!/^(?!anthropic$|claude$)(?!-)(?!.*--)[a-z0-9-]{1,64}(?<!-)$/.test(name))
+        throw invalidRequest("SKILL.md has an invalid name");
+    if (description.length === 0 || description.length > 1024)
+        throw invalidRequest("SKILL.md has an invalid description");
+    if (name !== directory)
+        throw invalidRequest(`The folder name '${directory}' must match the skill name '${name}' in SKILL.md.`);
+    const manifest = files.map(({ path, size, sha256 }) => ({ path, size, sha256 })).sort((a, b) => a.path.localeCompare(b.path));
+    return { name, description, directory, files, totalBytes, manifestSha256: sha256(Buffer.from(JSON.stringify(manifest))) };
+}
+function normalizePath(value) {
+    if (value.includes("\\") || value.includes("\0") || value.startsWith("/") || value.endsWith("/"))
+        throw invalidRequest("Skill contains an unsafe path");
+    const parts = value.split("/").filter((part) => part.length > 0 && part !== ".").map((part) => part.normalize("NFC"));
+    if (parts.length === 0 || parts.includes(".."))
+        throw invalidRequest("Skill contains an unsafe path");
+    return parts.join("/");
+}
+function sha256(bytes) { return createHash("sha256").update(bytes).digest("hex"); }

package/dist/src/control-plane/skills/routes.js

@@ -0,0 +1,41 @@
+import { File as NodeFile } from "node:buffer";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { invalidRequest, requestTooLarge, toApiErrorBody } from "../errors.js";
+import { parseLimit } from "../http.js";
+import { workspaceIdFrom } from "../workspace.js";
+export const MAX_SKILLS_UPLOAD_REQUEST_BYTES = 30 * 1024 * 1024;
+export function skillsRoutes(service, admission) {
+    const app = new Hono();
+    app.use("*", async (c, next) => { if (c.req.method !== "POST" || admission === undefined)
+        return next(); const release = admission.uploads.acquire(workspaceIdFrom(c)); try {
+        await next();
+    }
+    finally {
+        release();
+    } });
+    app.use("*", bodyLimit({ maxSize: MAX_SKILLS_UPLOAD_REQUEST_BYTES, onError: (c) => { const error = requestTooLarge("Request exceeds the maximum size. The Skills API accepts requests up to 30MBs."); return c.json(toApiErrorBody(error, c.get("requestId")), 413); } }));
+    app.post("/", async (c) => { const body = await multipart(c.req); return c.json(await service.create(workspaceIdFrom(c), stringField(body.display_title), await files(body["files[]"])), 200); });
+    app.get("/", (c) => c.json(service.list(workspaceIdFrom(c), parseLimit(c.req.query("limit")) ?? 20, c.req.query("page") || undefined), 200));
+    app.get("/:id", (c) => c.json(service.get(workspaceIdFrom(c), c.req.param("id")), 200));
+    app.delete("/:id", (c) => c.json(service.delete(workspaceIdFrom(c), c.req.param("id")), 200));
+    app.post("/:id/versions", async (c) => { const body = await multipart(c.req); return c.json(await service.createVersion(workspaceIdFrom(c), c.req.param("id"), await files(body["files[]"])), 200); });
+    app.get("/:id/versions", (c) => c.json(service.listVersions(workspaceIdFrom(c), c.req.param("id"), parseLimit(c.req.query("limit")) ?? 20, c.req.query("page") || undefined), 200));
+    app.get("/:id/versions/:version", (c) => c.json(service.getVersion(workspaceIdFrom(c), c.req.param("id"), c.req.param("version")), 200));
+    app.delete("/:id/versions/:version", (c) => c.json(service.deleteVersion(workspaceIdFrom(c), c.req.param("id"), c.req.param("version")), 200));
+    return app;
+}
+async function multipart(req) { try {
+    return await req.parseBody({ all: true });
+}
+catch (error) {
+    throw invalidRequest("Request body must be valid multipart/form-data", String(error));
+} }
+function isFile(value) { return value instanceof NodeFile || (!!value && typeof value === "object" && "arrayBuffer" in value && "name" in value); }
+async function files(value) { const values = Array.isArray(value) ? value : value === undefined ? [] : [value]; const out = []; for (const value of values) {
+    if (!isFile(value))
+        throw invalidRequest("`files[]` is required");
+    out.push({ name: value.name, bytes: new Uint8Array(await value.arrayBuffer()) });
+} if (out.length === 0)
+    throw invalidRequest("`files[]` is required"); return out; }
+function stringField(value) { return typeof value === "string" ? value : undefined; }

package/dist/src/control-plane/skills/service.js

@@ -0,0 +1,29 @@
+import { invalidRequest, notFound } from "../errors.js";
+import { validateSkillUpload } from "./archive.js";
+export class DefaultSkillsService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async create(workspaceId, displayTitle, files) {
+        const bundle = await validateSkillUpload(files);
+        const title = (displayTitle ?? bundle.name).trim();
+        if (!title)
+            throw invalidRequest("display_title must not be empty");
+        return this.store.createSkill(workspaceId, title, bundle);
+    }
+    async createVersion(workspaceId, skillId, files) {
+        this.get(workspaceId, skillId);
+        return this.store.createVersion(workspaceId, skillId, await validateSkillUpload(files));
+    }
+    get(workspaceId, skillId) { const value = this.store.getSkill(workspaceId, skillId); if (!value)
+        throw notFound(`Skill ${skillId} not found`); return value; }
+    list(workspaceId, limit, after) { return this.store.listSkills(workspaceId, limit, after); }
+    getVersion(workspaceId, skillId, version) { const value = this.store.getVersion(workspaceId, skillId, version); if (!value)
+        throw notFound(`Skill version ${version} not found`); return value; }
+    listVersions(workspaceId, skillId, limit, after) { this.get(workspaceId, skillId); return this.store.listVersions(workspaceId, skillId, limit, after); }
+    deleteVersion(workspaceId, skillId, version) { if (!this.store.deleteVersion(workspaceId, skillId, version))
+        throw notFound(`Skill version ${version} not found`); return { id: version, type: "skill_version_deleted" }; }
+    delete(workspaceId, skillId) { if (!this.store.deleteSkill(workspaceId, skillId))
+        throw notFound(`Skill ${skillId} not found`); return { id: skillId, type: "skill_deleted" }; }
+}

package/dist/src/control-plane/skills/store.js

@@ -0,0 +1,233 @@
+import { createHash } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { invalidRequest, notFound } from "../errors.js";
+import { newSkillContentObjectId, newSkillId, newSkillVersionId } from "../ids.js";
+import { withSqliteTransaction } from "../sqlite-transaction.js";
+import { DEFAULT_SKILLS_MAX_VERSIONS, DEFAULT_SKILLS_WORKSPACE_MAX_BYTES, } from "./types.js";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS skills (
+ workspace_id TEXT NOT NULL, id TEXT NOT NULL, name TEXT NOT NULL,
+ display_title TEXT NOT NULL, source TEXT NOT NULL, latest_version TEXT,
+ created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+ PRIMARY KEY(workspace_id,id), UNIQUE(workspace_id,name), UNIQUE(workspace_id,display_title)
+);
+CREATE TABLE IF NOT EXISTS skill_versions (
+ workspace_id TEXT NOT NULL, skill_id TEXT NOT NULL, id TEXT NOT NULL, version TEXT NOT NULL,
+ description TEXT NOT NULL, directory TEXT NOT NULL, file_count INTEGER NOT NULL,
+ total_bytes INTEGER NOT NULL, manifest_sha256 TEXT NOT NULL, created_at TEXT NOT NULL,
+ PRIMARY KEY(workspace_id,skill_id,version), UNIQUE(workspace_id,id),
+ FOREIGN KEY(workspace_id,skill_id) REFERENCES skills(workspace_id,id) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS skill_files (
+ workspace_id TEXT NOT NULL, skill_id TEXT NOT NULL, version TEXT NOT NULL, path TEXT NOT NULL,
+ size_bytes INTEGER NOT NULL, sha256 TEXT NOT NULL, content_object_id TEXT NOT NULL UNIQUE,
+ PRIMARY KEY(workspace_id,skill_id,version,path),
+ FOREIGN KEY(workspace_id,skill_id,version) REFERENCES skill_versions(workspace_id,skill_id,version) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS pending_skill_content_rollbacks (
+ workspace_id TEXT NOT NULL, content_object_id TEXT PRIMARY KEY, created_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS pending_skill_content_deletes (
+ workspace_id TEXT NOT NULL, content_object_id TEXT PRIMARY KEY, created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS skills_list ON skills(workspace_id,id);
+CREATE INDEX IF NOT EXISTS skill_versions_list ON skill_versions(workspace_id,skill_id,version);
+`;
+let versionTick = 0;
+function newVersion() {
+    const base = Date.now() * 1000;
+    versionTick = (versionTick + 1) % 1000;
+    return String(base + versionTick);
+}
+// Versions are fixed-width 16-digit microsecond timestamps for the supported
+// clock range, so SQLite TEXT ordering is chronological ordering.
+export class SqliteSkillsStore {
+    db;
+    objectsDir;
+    memoryObjects;
+    maxWorkspaceBytes;
+    maxVersions;
+    workspaceBytesStmt;
+    constructor(db, objectRoot, opts = {}) {
+        this.db = db;
+        this.objectsDir = objectRoot === undefined ? undefined : resolve(objectRoot, "skill-objects");
+        this.memoryObjects = objectRoot === undefined ? new Map() : undefined;
+        if (this.objectsDir !== undefined) {
+            mkdirSync(this.objectsDir, { recursive: true, mode: 0o700 });
+            chmodSync(this.objectsDir, 0o700);
+        }
+        db.exec(SCHEMA);
+        this.maxWorkspaceBytes = opts.maxWorkspaceBytes ?? DEFAULT_SKILLS_WORKSPACE_MAX_BYTES;
+        this.maxVersions = opts.maxVersions ?? DEFAULT_SKILLS_MAX_VERSIONS;
+        this.workspaceBytesStmt = db.prepare("SELECT COALESCE(SUM(total_bytes),0) total FROM skill_versions WHERE workspace_id = ?");
+        // Deployment storage holds an exclusive appliance lock. Sweeping all
+        // pending intents is safe only under that documented single-process model.
+        this.sweep("pending_skill_content_rollbacks");
+        this.sweep("pending_skill_content_deletes");
+    }
+    createSkill(workspaceId, displayTitle, bundle) {
+        const now = new Date().toISOString();
+        const id = newSkillId();
+        const version = newVersion();
+        this.publish(workspaceId, { id, displayTitle, version, now, bundle, createOwner: true });
+        return this.getSkill(workspaceId, id);
+    }
+    createVersion(workspaceId, skillId, bundle) {
+        const owner = this.row(workspaceId, skillId);
+        if (!owner)
+            throw notFound(`Skill ${skillId} not found`);
+        if (owner.name !== bundle.name)
+            throw invalidRequest("Skill name and directory are immutable across versions");
+        const count = Number(this.db.prepare("SELECT COUNT(*) n FROM skill_versions WHERE workspace_id=? AND skill_id=?").get(workspaceId, skillId).n);
+        if (count >= this.maxVersions)
+            throw invalidRequest(`Skill may retain at most ${this.maxVersions} versions`);
+        const version = newVersion();
+        this.publish(workspaceId, { id: skillId, displayTitle: owner.display_title, version, now: new Date().toISOString(), bundle, createOwner: false });
+        return this.getVersion(workspaceId, skillId, version);
+    }
+    publish(workspaceId, input) {
+        const current = this.workspaceBytesStmt.get(workspaceId).total;
+        if (current + input.bundle.totalBytes > this.maxWorkspaceBytes)
+            throw invalidRequest("Workspace skill content quota exceeded");
+        const objects = input.bundle.files.map((file) => ({ file, id: newSkillContentObjectId() }));
+        withSqliteTransaction(this.db, () => {
+            const stmt = this.db.prepare("INSERT INTO pending_skill_content_rollbacks VALUES (?,?,?)");
+            for (const object of objects)
+                stmt.run(workspaceId, object.id, input.now);
+        });
+        try {
+            for (const object of objects)
+                this.writeObject(object.id, object.file.bytes);
+            withSqliteTransaction(this.db, () => {
+                if (input.createOwner) {
+                    this.db.prepare("INSERT INTO skills VALUES (?,?,?,?,?,?,?,?)").run(workspaceId, input.id, input.bundle.name, input.displayTitle, "custom", input.version, input.now, input.now);
+                }
+                else {
+                    this.db.prepare("UPDATE skills SET latest_version=?,updated_at=? WHERE workspace_id=? AND id=?").run(input.version, input.now, workspaceId, input.id);
+                }
+                this.db.prepare("INSERT INTO skill_versions VALUES (?,?,?,?,?,?,?,?,?,?)").run(workspaceId, input.id, newSkillVersionId(), input.version, input.bundle.description, input.bundle.directory, input.bundle.files.length, input.bundle.totalBytes, input.bundle.manifestSha256, input.now);
+                const fileStmt = this.db.prepare("INSERT INTO skill_files VALUES (?,?,?,?,?,?,?)");
+                for (const object of objects)
+                    fileStmt.run(workspaceId, input.id, input.version, object.file.path, object.file.size, object.file.sha256, object.id);
+                const clear = this.db.prepare("DELETE FROM pending_skill_content_rollbacks WHERE content_object_id=?");
+                for (const object of objects)
+                    clear.run(object.id);
+            });
+        }
+        catch (error) {
+            this.sweep("pending_skill_content_rollbacks");
+            throw normalizeConstraint(error, input.displayTitle);
+        }
+    }
+    getSkill(workspaceId, skillId) { const row = this.row(workspaceId, skillId); return row && toSkill(row); }
+    listSkills(workspaceId, limit, after) {
+        const rows = this.db.prepare(`SELECT * FROM skills WHERE workspace_id=? ${after ? "AND id>?" : ""} ORDER BY id LIMIT ?`).all(...(after ? [workspaceId, after, limit + 1] : [workspaceId, limit + 1]));
+        return page(rows, limit, toSkill, (row) => row.id);
+    }
+    getVersion(workspaceId, skillId, version) {
+        const resolved = version === "latest" ? this.row(workspaceId, skillId)?.latest_version : version;
+        if (!resolved)
+            return undefined;
+        const row = this.db.prepare("SELECT * FROM skill_versions WHERE workspace_id=? AND skill_id=? AND version=?").get(workspaceId, skillId, resolved);
+        const owner = this.row(workspaceId, skillId);
+        return row && owner ? toVersion(row, owner.name) : undefined;
+    }
+    getVersionFiles(workspaceId, skillId, version) {
+        return this.db.prepare("SELECT path,size_bytes,sha256 FROM skill_files WHERE workspace_id=? AND skill_id=? AND version=? ORDER BY path")
+            .all(workspaceId, skillId, version)
+            .map((row) => {
+            const file = row;
+            return { path: file.path, sizeBytes: file.size_bytes, sha256: file.sha256 };
+        });
+    }
+    listVersions(workspaceId, skillId, limit, after) {
+        const owner = this.row(workspaceId, skillId);
+        if (!owner)
+            return { data: [], has_more: false, next_page: null };
+        const rows = this.db.prepare(`SELECT * FROM skill_versions WHERE workspace_id=? AND skill_id=? ${after ? "AND version>?" : ""} ORDER BY version LIMIT ?`).all(...(after ? [workspaceId, skillId, after, limit + 1] : [workspaceId, skillId, limit + 1]));
+        return page(rows, limit, (row) => toVersion(row, owner.name), (row) => row.version);
+    }
+    deleteVersion(workspaceId, skillId, version) {
+        const resolved = version === "latest" ? this.row(workspaceId, skillId)?.latest_version : version;
+        if (!resolved)
+            return false;
+        const row = this.db.prepare("SELECT version FROM skill_versions WHERE workspace_id=? AND skill_id=? AND version=?").get(workspaceId, skillId, resolved);
+        if (!row)
+            return false;
+        const now = new Date().toISOString();
+        withSqliteTransaction(this.db, () => {
+            this.db.prepare("INSERT OR IGNORE INTO pending_skill_content_deletes SELECT workspace_id,content_object_id,? FROM skill_files WHERE workspace_id=? AND skill_id=? AND version=?").run(now, workspaceId, skillId, resolved);
+            this.db.prepare("DELETE FROM skill_versions WHERE workspace_id=? AND skill_id=? AND version=?").run(workspaceId, skillId, resolved);
+            const latest = this.db.prepare("SELECT version FROM skill_versions WHERE workspace_id=? AND skill_id=? ORDER BY version DESC LIMIT 1").get(workspaceId, skillId);
+            this.db.prepare("UPDATE skills SET latest_version=?,updated_at=? WHERE workspace_id=? AND id=?").run(latest?.version ?? null, now, workspaceId, skillId);
+        });
+        this.sweep("pending_skill_content_deletes");
+        return true;
+    }
+    deleteSkill(workspaceId, skillId) {
+        const owner = this.row(workspaceId, skillId);
+        if (!owner)
+            return false;
+        const count = this.db.prepare("SELECT COUNT(*) n FROM skill_versions WHERE workspace_id=? AND skill_id=?").get(workspaceId, skillId).n;
+        if (count > 0)
+            throw invalidRequest("Skill versions must be deleted before deleting the skill");
+        this.db.prepare("DELETE FROM skills WHERE workspace_id=? AND id=?").run(workspaceId, skillId);
+        return true;
+    }
+    openContent(workspaceId, skillId, version, path) {
+        const row = this.db.prepare("SELECT content_object_id FROM skill_files WHERE workspace_id=? AND skill_id=? AND version=? AND path=?").get(workspaceId, skillId, version, path);
+        if (!row)
+            return undefined;
+        if (this.memoryObjects !== undefined)
+            return this.memoryObjects.get(row.content_object_id)?.slice();
+        try {
+            return new Uint8Array(readFileSync(this.objectPath(row.content_object_id)));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    row(workspaceId, id) { return this.db.prepare("SELECT * FROM skills WHERE workspace_id=? AND id=?").get(workspaceId, id); }
+    objectPath(id) { if (this.objectsDir === undefined)
+        throw new Error("Skill object path unavailable for memory store"); const shard = createHash("sha256").update(id).digest("hex").slice(0, 2); return resolve(this.objectsDir, shard, id); }
+    writeObject(id, bytes) { if (this.memoryObjects !== undefined) {
+        if (this.memoryObjects.has(id))
+            throw new Error(`Skill content object ${id} already exists`);
+        this.memoryObjects.set(id, bytes.slice());
+        return;
+    } const path = this.objectPath(id); mkdirSync(dirname(path), { recursive: true, mode: 0o700 }); writeFileSync(path, bytes, { mode: 0o600, flag: "wx" }); }
+    sweep(table) {
+        const rows = this.db.prepare(`SELECT content_object_id FROM ${table}`).all();
+        for (const row of rows) {
+            if (this.memoryObjects !== undefined)
+                this.memoryObjects.delete(row.content_object_id);
+            else {
+                try {
+                    unlinkSync(this.objectPath(row.content_object_id));
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        continue;
+                }
+            }
+            this.db.prepare(`DELETE FROM ${table} WHERE content_object_id=?`).run(row.content_object_id);
+        }
+    }
+    close() { }
+}
+export class InMemorySkillsStore extends SqliteSkillsStore {
+    constructor(opts = {}) {
+        super(new DatabaseSync(":memory:"), undefined, opts);
+    }
+    close() { this.db.close(); }
+}
+function toSkill(row) { return { id: row.id, display_title: row.display_title, latest_version: row.latest_version, source: "custom", type: "skill", created_at: row.created_at, updated_at: row.updated_at }; }
+function toVersion(row, name) { return { id: row.id, skill_id: row.skill_id, version: row.version, name, description: row.description, directory: row.directory, type: "skill_version", created_at: row.created_at }; }
+function page(rows, limit, map, cursor) { const dataRows = rows.slice(0, limit); return { data: dataRows.map(map), has_more: rows.length > limit, next_page: rows.length > limit ? cursor(dataRows[dataRows.length - 1]) : null }; }
+function normalizeConstraint(error, displayTitle) { const message = error instanceof Error ? error.message : ""; if (message.includes("skills.workspace_id, skills.display_title"))
+    return invalidRequest(`Skill cannot reuse an existing display_title: ${displayTitle}`); if (message.includes("skills.workspace_id, skills.name"))
+    return invalidRequest("Skill cannot reuse an existing name"); return error; }

package/dist/src/control-plane/skills/types.js

@@ -0,0 +1,5 @@
+export const MAX_SKILL_FILE_BYTES = 20 * 1024 * 1024;
+export const MAX_SKILL_VERSION_BYTES = 100 * 1024 * 1024;
+export const MAX_SKILL_FILES = 500;
+export const DEFAULT_SKILLS_WORKSPACE_MAX_BYTES = 1024 * 1024 * 1024;
+export const DEFAULT_SKILLS_MAX_VERSIONS = 20;

package/dist/src/control-plane/sqlite-transaction.js

@@ -0,0 +1,15 @@
+let nextSavepointId = 0;
+export function withSqliteTransaction(db, fn) {
+    const savepoint = `oma_tx_${nextSavepointId++}`;
+    db.exec(`SAVEPOINT ${savepoint}`);
+    try {
+        const result = fn();
+        db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+        return result;
+    }
+    catch (error) {
+        db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+        throw error;
+    }
+}

package/dist/src/control-plane/vaults/mcp-oauth-validate.js

@@ -0,0 +1,165 @@
+import { invalidRequest } from "../errors.js";
+import { probeMcpInitialize, } from "../sessions/pi/mcp/probe.js";
+export async function validateMcpOauthCredential(service, deps, workspaceId, vaultId, credentialId) {
+    const credential = service.retrieveCredential(workspaceId, vaultId, credentialId);
+    if (credential.archived_at !== null)
+        throw invalidRequest("Credential is archived.");
+    if (credential.auth.type !== "mcp_oauth") {
+        throw invalidRequest("The request was invalid");
+    }
+    const initial = service.readOauthValidationSnapshot(workspaceId, vaultId, credentialId);
+    if (initial === undefined)
+        throw invalidRequest("The request was invalid");
+    const firstProbe = await probe(initial, deps, secretValues(initial));
+    const hasRefreshToken = initial.secrets.refreshToken !== undefined;
+    if (!isAuthRejection(firstProbe)) {
+        return result({
+            credentialId,
+            vaultId,
+            validatedAt: now(deps),
+            hasRefreshToken,
+            status: probeStatus(firstProbe),
+            probe: firstProbe,
+            refreshStatus: "not_attempted",
+        });
+    }
+    if (initial.refresh === undefined || !hasRefreshToken) {
+        return result({
+            credentialId,
+            vaultId,
+            validatedAt: now(deps),
+            hasRefreshToken,
+            status: "invalid",
+            probe: firstProbe,
+            refreshStatus: "no_refresh_token",
+        });
+    }
+    const refreshed = await deps.refresh.refreshCredential({
+        workspaceId,
+        vaultId,
+        credentialId,
+        trigger: "validate",
+        expectedAuthVersion: initial.authVersion,
+    });
+    if (refreshed.outcome !== "ok") {
+        const shouldReprobeCurrent = (refreshed.outcome === "skipped" && refreshed.reason === "stale_version") ||
+            (refreshed.outcome !== "skipped" && refreshed.persisted === "stale");
+        if (shouldReprobeCurrent) {
+            const current = service.readOauthValidationSnapshot(workspaceId, vaultId, credentialId);
+            if (current === undefined) {
+                assertCredentialStillActive(service, workspaceId, vaultId, credentialId);
+            }
+            else if (current.authVersion !== initial.authVersion) {
+                const currentProbe = await probe(current, deps, [
+                    ...secretValues(initial),
+                    ...secretValues(current),
+                ]);
+                return result({
+                    credentialId,
+                    vaultId,
+                    validatedAt: now(deps),
+                    hasRefreshToken: current.secrets.refreshToken !== undefined,
+                    status: isAuthRejection(currentProbe)
+                        ? "invalid"
+                        : probeStatus(currentProbe),
+                    probe: currentProbe,
+                    refreshStatus: refreshed.outcome === "skipped" ? "skipped" : "failed",
+                    refreshResponse: refreshed.tokenEndpointResponse,
+                });
+            }
+        }
+        return result({
+            credentialId,
+            vaultId,
+            validatedAt: now(deps),
+            hasRefreshToken,
+            status: refreshed.outcome === "invalid" ? "invalid" : "unknown",
+            probe: firstProbe,
+            refreshStatus: refreshed.outcome === "skipped" ? "skipped" : "failed",
+            refreshResponse: refreshed.tokenEndpointResponse,
+        });
+    }
+    const current = service.readOauthValidationSnapshot(workspaceId, vaultId, credentialId);
+    if (current === undefined) {
+        assertCredentialStillActive(service, workspaceId, vaultId, credentialId);
+        throw invalidRequest("The request was invalid");
+    }
+    const secondProbe = await probe(current, deps, [
+        ...secretValues(initial),
+        ...secretValues(current),
+    ]);
+    return result({
+        credentialId,
+        vaultId,
+        validatedAt: now(deps),
+        hasRefreshToken: current.secrets.refreshToken !== undefined,
+        status: isAuthRejection(secondProbe)
+            ? "invalid"
+            : probeStatus(secondProbe),
+        probe: secondProbe,
+        refreshStatus: "refreshed",
+        refreshResponse: refreshed.tokenEndpointResponse,
+    });
+}
+async function probe(state, deps, knownSecrets) {
+    const accessToken = state.secrets.accessToken;
+    return probeMcpInitialize(state.mcpServerUrl, accessToken === undefined ? undefined : `Bearer ${accessToken}`, deps.fetch, {
+        capBytes: 4096,
+        timeoutMs: deps.operationTimeoutMs,
+        knownSecrets,
+    });
+}
+function result(input) {
+    return {
+        type: "vault_credential_validation",
+        credential_id: input.credentialId,
+        vault_id: input.vaultId,
+        validated_at: input.validatedAt,
+        has_refresh_token: input.hasRefreshToken,
+        status: input.status,
+        mcp_probe: {
+            method: "initialize",
+            http_response: probeHttpResponse(input.probe),
+        },
+        refresh: {
+            status: input.refreshStatus,
+            http_response: refreshHttpResponse(input.refreshResponse),
+        },
+    };
+}
+function probeHttpResponse(probe) {
+    return probe.reached
+        ? {
+            status_code: probe.statusCode,
+            content_type: probe.contentType,
+            body: probe.body,
+            body_truncated: probe.bodyTruncated,
+        }
+        : null;
+}
+function refreshHttpResponse(response) {
+    return response === undefined
+        ? null
+        : { status_code: response.statusCode, content_type: response.contentType };
+}
+function probeStatus(probe) {
+    return probe.reached && probe.initializeSucceeded ? "valid" : "unknown";
+}
+function isAuthRejection(probe) {
+    return probe.reached && (probe.statusCode === 401 || probe.statusCode === 403);
+}
+function secretValues(state) {
+    return [
+        state.secrets.accessToken,
+        state.secrets.refreshToken,
+        state.secrets.clientSecret,
+    ].filter((value) => value !== undefined);
+}
+function now(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+function assertCredentialStillActive(service, workspaceId, vaultId, credentialId) {
+    const credential = service.retrieveCredential(workspaceId, vaultId, credentialId);
+    if (credential.archived_at !== null)
+        throw invalidRequest("Credential is archived.");
+}