@xfey/tutti 0.1.0

package/dist/server-shell/smoke/e2e-client.js

@@ -0,0 +1,304 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { createHostProjectApiClientFromRelay, createRelayApiClientFromRelay, } from "@tutti/api-client";
+import { serializeRuntimeLogLine } from "@tutti/shared/utils";
+const DEFAULT_SMOKE_LOGIN_PAYLOAD = {
+    email: "tutti-smoke@example.invalid",
+    display_name: "Tutti Smoke",
+};
+const DEFAULT_POLL_TIMEOUT_MS = 30_000;
+const DEFAULT_POLL_INTERVAL_MS = 500;
+export class E2ESmokeFlowError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "E2ESmokeFlowError";
+    }
+}
+export class E2ESmokeCookieJar {
+    cookies = new Map();
+    getCookieHeader() {
+        if (this.cookies.size === 0) {
+            return undefined;
+        }
+        return Array.from(this.cookies.entries())
+            .map(([name, value]) => `${name}=${value}`)
+            .join("; ");
+    }
+    storeFromResponse(response) {
+        if (response.headers === undefined) {
+            return;
+        }
+        for (const setCookieHeader of readSetCookieHeaders(response.headers)) {
+            this.storeSetCookieHeader(setCookieHeader);
+        }
+    }
+    storeSetCookieHeader(header) {
+        const [pair, ...attributes] = header.split(";");
+        const separatorIndex = pair?.indexOf("=") ?? -1;
+        if (pair === undefined || separatorIndex <= 0) {
+            return;
+        }
+        const name = pair.slice(0, separatorIndex).trim();
+        const value = pair.slice(separatorIndex + 1).trim();
+        if (name === "") {
+            return;
+        }
+        const shouldDelete = attributes.some((attribute) => {
+            const [attributeName, attributeValue] = attribute.trim().split("=", 2);
+            return attributeName?.toLowerCase() === "max-age" && attributeValue === "0";
+        });
+        if (shouldDelete) {
+            this.cookies.delete(name);
+            return;
+        }
+        this.cookies.set(name, value);
+    }
+}
+function defaultNow() {
+    return new Date();
+}
+function resolveFetch(fetchImpl) {
+    if (fetchImpl !== undefined) {
+        return fetchImpl;
+    }
+    if (globalThis.fetch === undefined) {
+        throw new E2ESmokeFlowError("missing_fetch", "No fetch implementation is available.");
+    }
+    return globalThis.fetch.bind(globalThis);
+}
+function resolveOrigin(options) {
+    if (options.origin !== undefined && options.origin.trim() !== "") {
+        return new URL(options.origin).origin;
+    }
+    return new URL(options.relayBaseUrl).origin;
+}
+function readSetCookieHeaders(headers) {
+    const withGetSetCookie = headers;
+    const explicit = withGetSetCookie.getSetCookie?.();
+    if (explicit !== undefined && explicit.length > 0) {
+        return explicit;
+    }
+    const combined = headers.get("set-cookie");
+    return combined === null ? [] : splitCombinedSetCookieHeader(combined);
+}
+function headersFromInit(headersInit) {
+    const headers = new Headers();
+    if (headersInit === undefined) {
+        return headers;
+    }
+    if (Array.isArray(headersInit)) {
+        for (const [key, value] of headersInit) {
+            headers.set(key, value);
+        }
+        return headers;
+    }
+    if ("forEach" in headersInit && typeof headersInit.forEach === "function") {
+        headersInit.forEach((value, key) => headers.set(key, value));
+        return headers;
+    }
+    const recordHeaders = headersInit;
+    for (const [key, value] of Object.entries(recordHeaders)) {
+        headers.set(key, value);
+    }
+    return headers;
+}
+function splitCombinedSetCookieHeader(value) {
+    const headers = [];
+    let start = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        if (value[index] !== ",") {
+            continue;
+        }
+        const rest = value.slice(index + 1);
+        if (/^\s*[^=;,\s]+=/.test(rest)) {
+            headers.push(value.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    headers.push(value.slice(start).trim());
+    return headers.filter((header) => header !== "");
+}
+function createCookieAwareFetch(options) {
+    const fetchImpl = resolveFetch(options.fetch);
+    return async (input, init = {}) => {
+        const headers = headersFromInit(init.headers);
+        if (!headers.has("origin")) {
+            headers.set("origin", options.origin);
+        }
+        const cookieHeader = options.cookieJar.getCookieHeader();
+        if (cookieHeader !== undefined && !headers.has("cookie")) {
+            headers.set("cookie", cookieHeader);
+        }
+        const response = await fetchImpl(input, {
+            ...init,
+            headers,
+        });
+        options.cookieJar.storeFromResponse(response);
+        return response;
+    };
+}
+function relayClientOptions(input) {
+    return {
+        relayBaseUrl: input.relayBaseUrl,
+        fetch: input.fetch,
+        credentials: "include",
+    };
+}
+function emitSmokeLog(session, stage, fields = {}) {
+    session.log?.(serializeRuntimeLogLine({
+        level: "info",
+        service: "tutti-smoke",
+        component: "e2e-client",
+        message: "e2e smoke step completed",
+        fields: {
+            stage,
+            ...fields,
+        },
+        now: session.now,
+    }));
+}
+function loginPayload(input) {
+    return {
+        ...DEFAULT_SMOKE_LOGIN_PAYLOAD,
+        ...(input ?? {}),
+    };
+}
+function readRelayProjectRefFromJoin(joinEntry) {
+    if (joinEntry.relay_project !== undefined) {
+        return joinEntry.relay_project.relay_project_ref;
+    }
+    if (joinEntry.next.kind === "open_workspace") {
+        return joinEntry.next.relay_project_ref;
+    }
+    return undefined;
+}
+function requireRelayProjectRef(input) {
+    const relayProjectRef = input.acceptJoin.result?.relay_project.relay_project_ref ??
+        readRelayProjectRefFromJoin(input.joinEntry);
+    if (relayProjectRef === undefined) {
+        throw new E2ESmokeFlowError("join_accept_missing_project", "Relay join did not return a project ref.", {
+            accept_disposition: input.acceptJoin.disposition.kind,
+            join_next: input.joinEntry.next.kind,
+        });
+    }
+    return relayProjectRef;
+}
+export function createE2ESmokeSession(options) {
+    const cookieJar = new E2ESmokeCookieJar();
+    const origin = resolveOrigin(options);
+    const now = options.now ?? defaultNow;
+    const fetch = createCookieAwareFetch({
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+        cookieJar,
+        origin,
+    });
+    const relayBaseUrl = options.relayBaseUrl;
+    const relay = createRelayApiClientFromRelay({
+        relayBaseUrl,
+        fetch,
+        credentials: "include",
+    });
+    return {
+        relayBaseUrl,
+        origin,
+        relay,
+        cookieJar,
+        fetch,
+        now,
+        ...(options.log === undefined ? {} : { log: options.log }),
+        hostForProject: (relayProjectRef) => createHostProjectApiClientFromRelay({
+            ...relayClientOptions({ relayBaseUrl, fetch }),
+            relayProjectRef,
+        }),
+    };
+}
+export async function loginRelaySmokeAccount(session, input) {
+    const response = await session.relay.login(loginPayload(input), { now: session.now });
+    emitSmokeLog(session, "relay_login", {
+        disposition: response.disposition.kind,
+        account_ref: response.result?.account.account_ref,
+    });
+    return response;
+}
+export async function loginJoinAndOpenWorkspace(session, input) {
+    const joinEntry = await session.relay.getJoinEntry(input.joinToken);
+    emitSmokeLog(session, "join_entry", {
+        token_state: joinEntry.token_state,
+        next: joinEntry.next.kind,
+        relay_project_ref: readRelayProjectRefFromJoin(joinEntry),
+    });
+    if (joinEntry.token_state !== "valid") {
+        throw new E2ESmokeFlowError("join_entry_invalid", "Relay join token is invalid or expired.", {
+            token_state: joinEntry.token_state,
+            next: joinEntry.next.kind,
+        });
+    }
+    const login = await loginRelaySmokeAccount(session, input.login);
+    const acceptJoin = await session.relay.acceptJoin(input.joinToken, { now: session.now });
+    const relayProjectRef = requireRelayProjectRef({ acceptJoin, joinEntry });
+    emitSmokeLog(session, "join_accept", {
+        disposition: acceptJoin.disposition.kind,
+        relay_project_ref: relayProjectRef,
+    });
+    const openProject = await session.relay.openProject(relayProjectRef, { now: session.now });
+    emitSmokeLog(session, "project_open", {
+        disposition: openProject.disposition.kind,
+        relay_project_ref: relayProjectRef,
+        client_session_created: openProject.result?.client_session !== undefined,
+    });
+    if (openProject.disposition.kind !== "opened") {
+        throw new E2ESmokeFlowError("project_open_failed", "Relay project is not openable.", {
+            disposition: openProject.disposition.kind,
+            relay_project_ref: relayProjectRef,
+        });
+    }
+    return {
+        joinEntry,
+        login,
+        acceptJoin,
+        openProject,
+        relayProjectRef,
+        host: session.hostForProject(relayProjectRef),
+    };
+}
+export async function pollE2ESmoke(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+    const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const sleepImpl = options.sleep ?? sleep;
+    const now = options.now ?? defaultNow;
+    const startedAt = Date.now();
+    let attempts = 0;
+    let lastValue;
+    for (;;) {
+        attempts += 1;
+        const value = await options.read();
+        lastValue = value;
+        if (options.predicate(value)) {
+            options.log?.(serializeRuntimeLogLine({
+                level: "info",
+                service: "tutti-smoke",
+                component: "e2e-client",
+                message: "e2e smoke poll matched",
+                fields: {
+                    label: options.label,
+                    attempts,
+                    ...(options.describe?.(value) ?? {}),
+                },
+                now,
+            }));
+            return value;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new E2ESmokeFlowError("poll_timeout", "Timed out waiting for smoke condition.", {
+                label: options.label,
+                attempts,
+                ...(lastValue === undefined ? {} : { last: options.describe?.(lastValue) }),
+            });
+        }
+        await sleepImpl(intervalMs);
+    }
+}
+//# sourceMappingURL=e2e-client.js.map

package/dist/server-shell/smoke/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./e2e-client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server-shell/smoke/index.js

@@ -0,0 +1,2 @@
+export * from "./e2e-client.js";
+//# sourceMappingURL=index.js.map

package/dist/skills/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const USER_SKILLS_DIRECTORY_NAME: "skills";
+export declare const SKILL_MD_FILE_NAME: "SKILL.md";
+export declare const MAX_SKILL_ZIP_BYTES: number;
+export declare const MAX_SKILL_TOTAL_UNCOMPRESSED_BYTES: number;
+export declare const MAX_SKILL_FILE_BYTES: number;
+export declare const MAX_SKILL_FILE_COUNT = 1000;
+export declare const MAX_SKILL_DIRECTORY_DEPTH = 24;
+//# sourceMappingURL=constants.d.ts.map

package/dist/skills/constants.js

@@ -0,0 +1,9 @@
+import { MAX_SKILL_ZIP_STAGED_UPLOAD_BYTES } from "@tutti/shared/schemas/api";
+export const USER_SKILLS_DIRECTORY_NAME = "skills";
+export const SKILL_MD_FILE_NAME = "SKILL.md";
+export const MAX_SKILL_ZIP_BYTES = MAX_SKILL_ZIP_STAGED_UPLOAD_BYTES;
+export const MAX_SKILL_TOTAL_UNCOMPRESSED_BYTES = 200 * 1024 * 1024;
+export const MAX_SKILL_FILE_BYTES = 50 * 1024 * 1024;
+export const MAX_SKILL_FILE_COUNT = 1_000;
+export const MAX_SKILL_DIRECTORY_DEPTH = 24;
+//# sourceMappingURL=constants.js.map

package/dist/skills/errors.d.ts

@@ -0,0 +1,6 @@
+export type SkillServiceErrorCode = "invalid_skill_name" | "skill_not_found" | "invalid_zip" | "validation_failed" | "filesystem_error";
+export declare class SkillServiceError extends Error {
+    readonly code: SkillServiceErrorCode;
+    constructor(code: SkillServiceErrorCode, message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/skills/errors.js

@@ -0,0 +1,9 @@
+export class SkillServiceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SkillServiceError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/skills/index.d.ts

@@ -0,0 +1,41 @@
+import type { SkillDetailProjection, SkillProjection } from "@tutti/shared/schemas/api";
+import { type UserSkillImportPlan } from "./zip-import.js";
+export { MAX_SKILL_DIRECTORY_DEPTH, MAX_SKILL_FILE_BYTES, MAX_SKILL_FILE_COUNT, MAX_SKILL_TOTAL_UNCOMPRESSED_BYTES, MAX_SKILL_ZIP_BYTES, SKILL_MD_FILE_NAME, USER_SKILLS_DIRECTORY_NAME, } from "./constants.js";
+export { SkillServiceError } from "./errors.js";
+export type { SkillServiceErrorCode } from "./errors.js";
+export { isValidSkillName, parseSkillMarkdown } from "./metadata.js";
+export type { ParsedSkillMarkdown } from "./metadata.js";
+export { prepareUserSkillZipImport } from "./zip-import.js";
+export type { UserSkillImportPlan } from "./zip-import.js";
+export type UserSkillImportDisposition = {
+    kind: "created";
+    skill_name: string;
+} | {
+    kind: "replaced";
+    skill_name: string;
+};
+export type UserSkillDeleteDisposition = {
+    kind: "deleted";
+    skill_name: string;
+} | {
+    kind: "not_found";
+    skill_name: string;
+};
+export type UserSkillImportResult = {
+    disposition: UserSkillImportDisposition;
+    skill: SkillDetailProjection;
+};
+export declare function getUserSkillsRoot(tuttiHome: string): string;
+export declare function listUserSkills(tuttiHome: string): SkillProjection[];
+export declare function readUserSkill(tuttiHome: string, skillName: string): SkillDetailProjection;
+export declare function importUserSkillZip(options: {
+    tuttiHome: string;
+    zipBuffer: Buffer;
+    fileName: string;
+}): Promise<UserSkillImportResult>;
+export declare function commitUserSkillImport(options: {
+    tuttiHome: string;
+    plan: UserSkillImportPlan;
+}): UserSkillImportResult;
+export declare function deleteUserSkill(tuttiHome: string, skillName: string): UserSkillDeleteDisposition;
+//# sourceMappingURL=index.d.ts.map

package/dist/skills/index.js

@@ -0,0 +1,171 @@
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { SKILL_MD_FILE_NAME, USER_SKILLS_DIRECTORY_NAME } from "./constants.js";
+import { SkillServiceError } from "./errors.js";
+import { isValidSkillName, parseSkillMarkdown, } from "./metadata.js";
+import { prepareUserSkillZipImport, writeCandidateFiles, } from "./zip-import.js";
+export { MAX_SKILL_DIRECTORY_DEPTH, MAX_SKILL_FILE_BYTES, MAX_SKILL_FILE_COUNT, MAX_SKILL_TOTAL_UNCOMPRESSED_BYTES, MAX_SKILL_ZIP_BYTES, SKILL_MD_FILE_NAME, USER_SKILLS_DIRECTORY_NAME, } from "./constants.js";
+export { SkillServiceError } from "./errors.js";
+export { isValidSkillName, parseSkillMarkdown } from "./metadata.js";
+export { prepareUserSkillZipImport } from "./zip-import.js";
+export function getUserSkillsRoot(tuttiHome) {
+    return join(tuttiHome, USER_SKILLS_DIRECTORY_NAME);
+}
+function assertValidSkillName(skillName) {
+    if (!isValidSkillName(skillName)) {
+        throw new SkillServiceError("invalid_skill_name", "Skill name is invalid");
+    }
+}
+function ensureInside(parent, child) {
+    const parentPath = resolve(parent);
+    const childPath = resolve(child);
+    if (childPath !== parentPath && !childPath.startsWith(`${parentPath}/`)) {
+        throw new SkillServiceError("validation_failed", "Skill path is invalid");
+    }
+}
+function skillDirectory(tuttiHome, skillName) {
+    assertValidSkillName(skillName);
+    const root = getUserSkillsRoot(tuttiHome);
+    const directory = join(root, skillName);
+    ensureInside(root, directory);
+    return directory;
+}
+function readSkillMarkdown(filePath) {
+    let skillMd;
+    try {
+        skillMd = readFileSync(filePath, "utf8");
+    }
+    catch {
+        throw new SkillServiceError("skill_not_found", "Skill does not exist");
+    }
+    const metadata = parseSkillMarkdown(skillMd);
+    return { ...metadata, skill_md: skillMd };
+}
+function toSkillProjection(options) {
+    return {
+        name: options.metadata.name,
+        description: options.metadata.description,
+        ...(options.metadata.short_description === undefined
+            ? {}
+            : { short_description: options.metadata.short_description }),
+        enabled: true,
+        source: "user",
+        ...(options.updatedAt === undefined ? {} : { updated_at: options.updatedAt }),
+    };
+}
+function readSkillProjection(directory) {
+    const skillMdPath = join(directory, SKILL_MD_FILE_NAME);
+    const parsed = readSkillMarkdown(skillMdPath);
+    const stat = statSync(skillMdPath);
+    return toSkillProjection({
+        metadata: parsed,
+        updatedAt: stat.mtime.toISOString(),
+    });
+}
+export function listUserSkills(tuttiHome) {
+    const root = getUserSkillsRoot(tuttiHome);
+    if (!existsSync(root)) {
+        return [];
+    }
+    const items = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !isValidSkillName(entry.name)) {
+            continue;
+        }
+        try {
+            const projection = readSkillProjection(join(root, entry.name));
+            if (projection.name === entry.name) {
+                items.push(projection);
+            }
+        }
+        catch {
+            // Keep the management surface available even if a stale local directory is malformed.
+        }
+    }
+    return items.sort((left, right) => left.name.localeCompare(right.name));
+}
+export function readUserSkill(tuttiHome, skillName) {
+    const directory = skillDirectory(tuttiHome, skillName);
+    const skillMdPath = join(directory, SKILL_MD_FILE_NAME);
+    if (!existsSync(skillMdPath)) {
+        throw new SkillServiceError("skill_not_found", "Skill does not exist");
+    }
+    const parsed = readSkillMarkdown(skillMdPath);
+    if (parsed.name !== skillName) {
+        throw new SkillServiceError("validation_failed", "Skill metadata is invalid");
+    }
+    const stat = statSync(skillMdPath);
+    return {
+        ...toSkillProjection({
+            metadata: parsed,
+            updatedAt: stat.mtime.toISOString(),
+        }),
+        skill_md: parsed.skill_md,
+    };
+}
+export async function importUserSkillZip(options) {
+    const plan = await prepareUserSkillZipImport({
+        zipBuffer: options.zipBuffer,
+        fileName: options.fileName,
+    });
+    return commitUserSkillImport({
+        tuttiHome: options.tuttiHome,
+        plan,
+    });
+}
+export function commitUserSkillImport(options) {
+    const candidate = options.plan;
+    const root = getUserSkillsRoot(options.tuttiHome);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const destination = skillDirectory(options.tuttiHome, candidate.skillName);
+    const existed = existsSync(destination);
+    const tempParent = mkdtempSync(join(tmpdir(), "tutti-skill-import-"));
+    const tempSkillRoot = join(tempParent, candidate.skillName);
+    const backupPath = join(root, `.trash-${candidate.skillName}-${process.pid}-${Date.now()}`);
+    try {
+        writeCandidateFiles(tempSkillRoot, candidate);
+        if (existed) {
+            renameSync(destination, backupPath);
+        }
+        try {
+            renameSync(tempSkillRoot, destination);
+        }
+        catch (error) {
+            if (existed) {
+                renameSync(backupPath, destination);
+            }
+            throw error;
+        }
+        if (existed) {
+            rmSync(backupPath, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        rmSync(tempParent, { recursive: true, force: true });
+        if (error instanceof SkillServiceError) {
+            throw error;
+        }
+        throw new SkillServiceError("filesystem_error", "Failed to import skill");
+    }
+    rmSync(tempParent, { recursive: true, force: true });
+    return {
+        disposition: {
+            kind: existed ? "replaced" : "created",
+            skill_name: candidate.skillName,
+        },
+        skill: readUserSkill(options.tuttiHome, candidate.skillName),
+    };
+}
+export function deleteUserSkill(tuttiHome, skillName) {
+    const directory = skillDirectory(tuttiHome, skillName);
+    if (!existsSync(directory)) {
+        return { kind: "not_found", skill_name: skillName };
+    }
+    if (!statSync(directory).isDirectory()) {
+        throw new SkillServiceError("validation_failed", "Skill path is invalid");
+    }
+    rmSync(directory, { recursive: true, force: true });
+    return { kind: "deleted", skill_name: skillName };
+}
+//# sourceMappingURL=index.js.map

package/dist/skills/metadata.d.ts

@@ -0,0 +1,8 @@
+export type ParsedSkillMarkdown = {
+    name: string;
+    description: string;
+    short_description?: string;
+};
+export declare function isValidSkillName(value: string): boolean;
+export declare function parseSkillMarkdown(skillMd: string): ParsedSkillMarkdown;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/skills/metadata.js

@@ -0,0 +1,80 @@
+import { SkillServiceError } from "./errors.js";
+const SKILL_NAME_PATTERN = /^[a-z0-9_-]+$/u;
+export function isValidSkillName(value) {
+    return SKILL_NAME_PATTERN.test(value);
+}
+export function parseSkillMarkdown(skillMd) {
+    const frontmatter = extractFrontmatter(skillMd);
+    const values = parseSimpleYamlFrontmatter(frontmatter);
+    const name = values.get("name");
+    const description = values.get("description");
+    const shortDescription = values.get("metadata.short-description") ??
+        values.get("metadata.short_description") ??
+        values.get("short_description");
+    if (name === undefined || description === undefined) {
+        throw new SkillServiceError("validation_failed", "SKILL.md metadata is incomplete");
+    }
+    if (!isValidSkillName(name)) {
+        throw new SkillServiceError("validation_failed", "Skill name is invalid");
+    }
+    return {
+        name,
+        description,
+        ...(shortDescription === undefined ? {} : { short_description: shortDescription }),
+    };
+}
+function extractFrontmatter(skillMd) {
+    const normalized = skillMd.replace(/\r\n/gu, "\n");
+    if (!normalized.startsWith("---\n")) {
+        throw new SkillServiceError("validation_failed", "SKILL.md frontmatter is missing");
+    }
+    const end = normalized.indexOf("\n---", 4);
+    if (end === -1) {
+        throw new SkillServiceError("validation_failed", "SKILL.md frontmatter is missing");
+    }
+    return normalized.slice(4, end);
+}
+function parseSimpleYamlFrontmatter(frontmatter) {
+    const values = new Map();
+    let section;
+    for (const rawLine of frontmatter.split("\n")) {
+        const line = rawLine.trimEnd();
+        if (line.trim() === "" || line.trimStart().startsWith("#")) {
+            continue;
+        }
+        const nested = /^(\s+)([A-Za-z0-9_.-]+):\s*(.*)$/u.exec(line);
+        if (nested !== null && section !== undefined) {
+            const key = nested[2];
+            const rawValue = nested[3];
+            if (key !== undefined && rawValue !== undefined && rawValue.trim() !== "") {
+                values.set(`${section}.${key}`, parseFrontmatterScalar(rawValue));
+            }
+            continue;
+        }
+        const topLevel = /^([A-Za-z0-9_.-]+):\s*(.*)$/u.exec(line);
+        if (topLevel === null) {
+            throw new SkillServiceError("validation_failed", "SKILL.md frontmatter is invalid");
+        }
+        const key = topLevel[1];
+        const rawValue = topLevel[2];
+        if (key === undefined || rawValue === undefined) {
+            throw new SkillServiceError("validation_failed", "SKILL.md frontmatter is invalid");
+        }
+        if (rawValue.trim() === "") {
+            section = key;
+            continue;
+        }
+        section = undefined;
+        values.set(key, parseFrontmatterScalar(rawValue));
+    }
+    return values;
+}
+function parseFrontmatterScalar(rawValue) {
+    const value = rawValue.trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+//# sourceMappingURL=metadata.js.map

package/dist/skills/zip-import.d.ts

@@ -0,0 +1,18 @@
+import { type ParsedSkillMarkdown } from "./metadata.js";
+export type BufferedZipFileEntry = {
+    path: string;
+    data: Buffer;
+    mode: number;
+};
+export type UserSkillImportPlan = {
+    skillName: string;
+    rootPrefix: string;
+    files: BufferedZipFileEntry[];
+    metadata: ParsedSkillMarkdown;
+};
+export declare function prepareUserSkillZipImport(options: {
+    zipBuffer: Buffer;
+    fileName: string;
+}): Promise<UserSkillImportPlan>;
+export declare function writeCandidateFiles(destinationRoot: string, candidate: UserSkillImportPlan): void;
+//# sourceMappingURL=zip-import.d.ts.map