@hold-rein/cli 0.0.0

package/dist/runtime/api/modules/model-proxies/model-proxy-repository.js

@@ -0,0 +1,146 @@
+import { randomUUID } from "node:crypto";
+import { asc, eq, gte } from "drizzle-orm";
+import { modelProxies, modelProxyCandidateLimits, modelProxyCandidates, modelTokenUsageHourly } from "../../db/index.js";
+export function createInMemoryModelProxyRepository() {
+    const proxies = new Map();
+    const save = (input, existing) => {
+        const now = new Date().toISOString();
+        const proxy = {
+            candidates: input.candidates
+                .map((candidate) => {
+                const candidateId = randomUUID();
+                return {
+                    createdAt: now,
+                    id: candidateId,
+                    limits: candidate.limits.map((limit) => ({
+                        candidateId,
+                        createdAt: now,
+                        id: randomUUID(),
+                        maxTokens: limit.maxTokens,
+                        updatedAt: now,
+                        windowHours: limit.windowHours ?? null,
+                        windowType: limit.windowType
+                    })),
+                    modelId: candidate.modelId,
+                    priority: candidate.priority,
+                    provider: candidate.provider,
+                    proxyId: existing?.id ?? randomUUID(),
+                    updatedAt: now
+                };
+            })
+                .sort((left, right) => left.priority - right.priority),
+            createdAt: existing?.createdAt ?? now,
+            id: existing?.id ?? randomUUID(),
+            modelId: input.modelId,
+            name: input.name,
+            updatedAt: now
+        };
+        proxy.candidates = proxy.candidates.map((candidate) => ({
+            ...candidate,
+            proxyId: proxy.id
+        }));
+        proxies.delete(existing?.modelId ?? input.modelId);
+        proxies.set(proxy.modelId, proxy);
+        return cloneProxy(proxy);
+    };
+    return {
+        createProxy: (input) => save(input),
+        deleteProxy: (modelId) => proxies.delete(modelId),
+        findProxyByModelId: (modelId) => cloneOptional(proxies.get(modelId)),
+        listProxies: () => [...proxies.values()].map(cloneProxy),
+        updateProxy: (modelId, input) => {
+            const existing = proxies.get(modelId);
+            return existing ? save(input, existing) : undefined;
+        }
+    };
+}
+export function createSqliteModelProxyRepository(database) {
+    const readProxy = (row) => ({
+        ...row,
+        candidates: database.db
+            .select()
+            .from(modelProxyCandidates)
+            .where(eq(modelProxyCandidates.proxyId, row.id))
+            .orderBy(asc(modelProxyCandidates.priority))
+            .all()
+            .map((candidate) => ({
+            ...candidate,
+            limits: database.db
+                .select()
+                .from(modelProxyCandidateLimits)
+                .where(eq(modelProxyCandidateLimits.candidateId, candidate.id))
+                .all()
+        }))
+    });
+    const insertProxy = (input, existing) => {
+        const now = new Date().toISOString();
+        const proxy = {
+            createdAt: existing?.createdAt ?? now,
+            id: existing?.id ?? randomUUID(),
+            modelId: input.modelId,
+            name: input.name,
+            updatedAt: now
+        };
+        if (existing) {
+            database.db.update(modelProxies).set(proxy).where(eq(modelProxies.id, existing.id)).run();
+            database.db.delete(modelProxyCandidates).where(eq(modelProxyCandidates.proxyId, proxy.id)).run();
+        }
+        else {
+            database.db.insert(modelProxies).values(proxy).run();
+        }
+        for (const candidate of input.candidates) {
+            const candidateRow = {
+                createdAt: now,
+                id: randomUUID(),
+                modelId: candidate.modelId,
+                priority: candidate.priority,
+                provider: candidate.provider,
+                proxyId: proxy.id,
+                updatedAt: now
+            };
+            database.db.insert(modelProxyCandidates).values(candidateRow).run();
+            database.db.insert(modelProxyCandidateLimits).values(candidate.limits.map((limit) => ({
+                candidateId: candidateRow.id,
+                createdAt: now,
+                id: randomUUID(),
+                maxTokens: limit.maxTokens,
+                updatedAt: now,
+                windowHours: limit.windowHours ?? null,
+                windowType: limit.windowType
+            }))).run();
+        }
+        return readProxy(proxy);
+    };
+    return {
+        createProxy: (input) => insertProxy(input),
+        deleteProxy: (modelId) => {
+            const row = database.db.select().from(modelProxies).where(eq(modelProxies.modelId, modelId)).get();
+            if (!row)
+                return false;
+            database.db.delete(modelProxies).where(eq(modelProxies.id, row.id)).run();
+            return true;
+        },
+        findProxyByModelId: (modelId) => {
+            const row = database.db.select().from(modelProxies).where(eq(modelProxies.modelId, modelId)).get();
+            return row ? readProxy(row) : undefined;
+        },
+        listModelTokenUsageSince: (from) => database.db.select().from(modelTokenUsageHourly).where(gte(modelTokenUsageHourly.hour, from)).all(),
+        listProxies: () => database.db.select().from(modelProxies).all().map(readProxy),
+        updateProxy: (modelId, input) => {
+            const row = database.db.select().from(modelProxies).where(eq(modelProxies.modelId, modelId)).get();
+            return row ? insertProxy(input, row) : undefined;
+        }
+    };
+}
+function cloneOptional(proxy) {
+    return proxy ? cloneProxy(proxy) : undefined;
+}
+function cloneProxy(proxy) {
+    return {
+        ...proxy,
+        candidates: proxy.candidates.map((candidate) => ({
+            ...candidate,
+            limits: candidate.limits.map((limit) => ({ ...limit }))
+        }))
+    };
+}

package/dist/runtime/api/modules/model-proxies/model-proxy-runtime.d.ts

@@ -0,0 +1,20 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelProxiesService, PendingProxyUsage } from "./model-proxies-service";
+export interface ModelProxyRuntimeCandidate {
+    modelId: string;
+    provider: string;
+}
+export interface ModelProxyRuntimeController {
+    getActiveModel: () => Model<Api>;
+    recordAssistantUsage: (usage: PendingProxyUsage) => Promise<void>;
+}
+export interface CreateModelProxyRuntimeControllerOptions {
+    activeCandidate: ModelProxyRuntimeCandidate;
+    activeModel?: Model<Api>;
+    proxyModelId: string;
+    resolveModel: (provider: string, modelId: string) => Promise<Model<Api> | null>;
+    service: ModelProxiesService;
+    setModel: (model: Model<Api>) => Promise<void> | void;
+}
+export declare function createModelProxyRuntimeController(options: CreateModelProxyRuntimeControllerOptions): ModelProxyRuntimeController;
+//# sourceMappingURL=model-proxy-runtime.d.ts.map

package/dist/runtime/api/modules/model-proxies/model-proxy-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-proxy-runtime.d.ts","sourceRoot":"","sources":["../../../src/modules/model-proxies/model-proxy-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEtF,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,2BAA2B;IAC1C,cAAc,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,oBAAoB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,wCAAwC;IACvD,eAAe,EAAE,0BAA0B,CAAC;IAC5C,WAAW,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IAChF,OAAO,EAAE,mBAAmB,CAAC;IAC7B,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACvD;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,2BAA2B,CAuD7B"}

package/dist/runtime/api/modules/model-proxies/model-proxy-runtime.js

@@ -0,0 +1,45 @@
+export function createModelProxyRuntimeController(options) {
+    let activeCandidate = options.activeCandidate;
+    let activeModel = options.activeModel;
+    const pendingUsage = new Map();
+    return {
+        getActiveModel: () => {
+            if (!activeModel) {
+                throw new Error("Proxy active model is not initialized");
+            }
+            return activeModel;
+        },
+        recordAssistantUsage: async (usage) => {
+            if (usage.provider !== activeCandidate.provider ||
+                usage.modelId !== activeCandidate.modelId) {
+                return;
+            }
+            const key = usageKey(usage.provider, usage.modelId);
+            const existing = pendingUsage.get(key);
+            pendingUsage.set(key, {
+                inputToken: (existing?.inputToken ?? 0) + usage.inputToken,
+                modelId: usage.modelId,
+                outputToken: (existing?.outputToken ?? 0) + usage.outputToken,
+                provider: usage.provider
+            });
+            const nextCandidate = options.service.selectCandidate(options.proxyModelId, Object.fromEntries(pendingUsage));
+            if (!nextCandidate) {
+                throw new Error("Proxy fallback unavailable");
+            }
+            if (nextCandidate.provider === activeCandidate.provider &&
+                nextCandidate.modelId === activeCandidate.modelId) {
+                return;
+            }
+            const nextModel = await options.resolveModel(nextCandidate.provider, nextCandidate.modelId);
+            if (!nextModel) {
+                throw new Error("Unknown candidate provider or model");
+            }
+            activeCandidate = nextCandidate;
+            activeModel = nextModel;
+            await options.setModel(nextModel);
+        }
+    };
+}
+function usageKey(provider, modelId) {
+    return `${provider}\0${modelId}`;
+}

package/dist/runtime/api/modules/plugins/plugins-router.d.ts

@@ -0,0 +1,7 @@
+import { Router } from "express";
+import type { RuntimePluginManifest } from "@hold-rein/plugin-server";
+export interface CreatePluginsRouterOptions {
+    readonly plugins: readonly RuntimePluginManifest[];
+}
+export declare function createPluginsRouter(options: CreatePluginsRouterOptions): Router;
+//# sourceMappingURL=plugins-router.d.ts.map

package/dist/runtime/api/modules/plugins/plugins-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins-router.d.ts","sourceRoot":"","sources":["../../../src/modules/plugins/plugins-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEtE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACpD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,MAAM,CAU/E"}

package/dist/runtime/api/modules/plugins/plugins-router.js

@@ -0,0 +1,11 @@
+import { Router } from "express";
+import { sendSuccess } from "../../response/index.js";
+export function createPluginsRouter(options) {
+    const router = Router();
+    router.get("/", (_request, response) => {
+        sendSuccess(response, {
+            plugins: options.plugins
+        });
+    });
+    return router;
+}

package/dist/runtime/api/modules/skills/default-skills-service.d.ts

@@ -0,0 +1,3 @@
+import type { SkillsService } from "./skills-types";
+export declare function getDefaultSkillsService(): SkillsService;
+//# sourceMappingURL=default-skills-service.d.ts.map

package/dist/runtime/api/modules/skills/default-skills-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-skills-service.d.ts","sourceRoot":"","sources":["../../../src/modules/skills/default-skills-service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD,wBAAgB,uBAAuB,IAAI,aAAa,CAOvD"}

package/dist/runtime/api/modules/skills/default-skills-service.js

@@ -0,0 +1,9 @@
+import { createSkillsService } from "./skills-service.js";
+let service;
+export function getDefaultSkillsService() {
+    if (!service) {
+        service = createSkillsService();
+        void service.load();
+    }
+    return service;
+}

package/dist/runtime/api/modules/skills/index.d.ts

@@ -0,0 +1,5 @@
+export { getDefaultSkillsService } from "./default-skills-service";
+export { createSkillsRouter, type CreateSkillsRouterOptions } from "./skills-router";
+export { createSkillsService, type CreateSkillsServiceOptions } from "./skills-service";
+export type { InstalledSkill, SkillsConfig, SkillsService } from "./skills-types";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/api/modules/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/skills/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAE,mBAAmB,EAAE,KAAK,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AACxF,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/runtime/api/modules/skills/index.js

@@ -0,0 +1,3 @@
+export { getDefaultSkillsService } from "./default-skills-service.js";
+export { createSkillsRouter } from "./skills-router.js";
+export { createSkillsService } from "./skills-service.js";

package/dist/runtime/api/modules/skills/skills-router.d.ts

@@ -0,0 +1,7 @@
+import { Router } from "express";
+import type { SkillsService } from "./skills-types";
+export interface CreateSkillsRouterOptions {
+    skillsService?: SkillsService;
+}
+export declare function createSkillsRouter(options?: CreateSkillsRouterOptions): Router;
+//# sourceMappingURL=skills-router.d.ts.map

package/dist/runtime/api/modules/skills/skills-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-router.d.ts","sourceRoot":"","sources":["../../../src/modules/skills/skills-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA+B,MAAM,SAAS,CAAC;AAK9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,MAAM,WAAW,yBAAyB;IACxC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAUD,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,MAAM,CA4ER"}

package/dist/runtime/api/modules/skills/skills-router.js

@@ -0,0 +1,56 @@
+import { Router } from "express";
+import { sendError, sendSuccess } from "../../response/index.js";
+import { RESPONSE_CODE_DEFINITIONS } from "../../response/response-codes.js";
+import { getDefaultSkillsService } from "./default-skills-service.js";
+export function createSkillsRouter(options = {}) {
+    const router = Router();
+    const getService = () => options.skillsService ?? getDefaultSkillsService();
+    router.get("/skills", (_request, response) => {
+        void getService()
+            .listSkills()
+            .then((skills) => sendSuccess(response, { skills }))
+            .catch((error) => sendRouteError(response, error, "Failed to list skills"));
+    });
+    router.post("/skills/install", (request, response) => {
+        if (typeof request.body.repositoryUrl !== "string") {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "repositoryUrl must be a string");
+            return;
+        }
+        void getService()
+            .installSkill(request.body.repositoryUrl)
+            .then((skill) => sendSuccess(response, skill))
+            .catch((error) => sendRouteError(response, error, "Failed to install skill"));
+    });
+    router.patch("/skills/:skillId", (request, response) => {
+        if (typeof request.body.disabled !== "boolean") {
+            sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, "disabled must be a boolean");
+            return;
+        }
+        void getService()
+            .setSkillDisabled(request.params.skillId, request.body.disabled)
+            .then((skill) => {
+            if (!skill) {
+                sendError(response, RESPONSE_CODE_DEFINITIONS.notFound, "Unknown skill");
+                return;
+            }
+            sendSuccess(response, skill);
+        })
+            .catch((error) => sendRouteError(response, error, "Failed to update skill"));
+    });
+    router.delete("/skills/:skillId", (request, response) => {
+        void getService()
+            .uninstallSkill(request.params.skillId)
+            .then((deleted) => {
+            if (!deleted) {
+                sendError(response, RESPONSE_CODE_DEFINITIONS.notFound, "Unknown skill");
+                return;
+            }
+            sendSuccess(response, { id: request.params.skillId });
+        })
+            .catch((error) => sendRouteError(response, error, "Failed to uninstall skill"));
+    });
+    return router;
+}
+function sendRouteError(response, error, fallback) {
+    sendError(response, RESPONSE_CODE_DEFINITIONS.badRequest, error instanceof Error ? error.message : fallback);
+}

package/dist/runtime/api/modules/skills/skills-service.d.ts

@@ -0,0 +1,7 @@
+import type { SkillsService } from "./skills-types";
+export interface CreateSkillsServiceOptions {
+    installGitRepository?: (repositoryUrl: string, targetDir: string, ref?: string) => Promise<void>;
+    rootDir?: string;
+}
+export declare function createSkillsService(options?: CreateSkillsServiceOptions): SkillsService;
+//# sourceMappingURL=skills-service.d.ts.map

package/dist/runtime/api/modules/skills/skills-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-service.d.ts","sourceRoot":"","sources":["../../../src/modules/skills/skills-service.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAgC,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKlF,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,CAAC,EAAE,CACrB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,MAAM,KACT,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AASD,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,0BAA+B,GACvC,aAAa,CA6Gf"}

package/dist/runtime/api/modules/skills/skills-service.js

@@ -0,0 +1,264 @@
+import { execFile } from "node:child_process";
+import { cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { promisify } from "node:util";
+import { SKILL_DIR } from "../../config/const.js";
+const execFileAsync = promisify(execFile);
+const CONFIG_FILE_NAME = "skills.json";
+export function createSkillsService(options = {}) {
+    const rootDir = options.rootDir ?? SKILL_DIR;
+    const configPath = join(rootDir, CONFIG_FILE_NAME);
+    const installGitRepository = options.installGitRepository ?? cloneGitRepository;
+    let config = {};
+    let loaded = false;
+    const ensureLoaded = async () => {
+        if (loaded) {
+            return;
+        }
+        await mkdir(rootDir, { recursive: true });
+        config = await readConfig(configPath);
+        loaded = true;
+    };
+    const persistConfig = async () => {
+        await mkdir(rootDir, { recursive: true });
+        await writeFile(configPath, `${JSON.stringify(normalizeConfig(config), null, 2)}\n`, "utf8");
+    };
+    const listSkills = async () => {
+        await ensureLoaded();
+        const entries = await readSkillEntries(rootDir);
+        const skills = await Promise.all(entries.map((entry) => readInstalledSkill(rootDir, entry.name, config)));
+        return skills
+            .filter((skill) => skill !== null)
+            .sort((leftSkill, rightSkill) => leftSkill.name.localeCompare(rightSkill.name));
+    };
+    return {
+        installSkill: async (repositoryUrl) => {
+            await ensureLoaded();
+            const source = getSkillSourceFromGithubUrl(repositoryUrl);
+            const skillId = source.skillId;
+            const targetDir = join(rootDir, skillId);
+            const existing = await readInstalledSkill(rootDir, skillId, config);
+            if (existing) {
+                throw new Error("Skill is already installed");
+            }
+            await installSkillSource(source, targetDir, installGitRepository);
+            const installedSkill = await readInstalledSkill(rootDir, skillId, config);
+            if (!installedSkill) {
+                await rm(targetDir, { force: true, recursive: true });
+                throw new Error("Installed repository does not contain SKILL.md");
+            }
+            return installedSkill;
+        },
+        listEnabledSkillDirs: async () => {
+            const skills = await listSkills();
+            return skills
+                .filter((skill) => !skill.disabled)
+                .map((skill) => skill.path);
+        },
+        listSkills,
+        load: async () => {
+            await mkdir(rootDir, { recursive: true });
+            config = await readConfig(configPath);
+            loaded = true;
+        },
+        setSkillDisabled: async (skillId, disabled) => {
+            await ensureLoaded();
+            const skill = await readInstalledSkill(rootDir, skillId, config);
+            if (!skill) {
+                return null;
+            }
+            config = normalizeConfig({
+                ...config,
+                [skillId]: {
+                    ...config[skillId],
+                    disabled
+                }
+            });
+            await persistConfig();
+            return { ...skill, disabled };
+        },
+        uninstallSkill: async (skillId) => {
+            await ensureLoaded();
+            const skill = await readInstalledSkill(rootDir, skillId, config);
+            if (!skill) {
+                return false;
+            }
+            await rm(skill.path, { force: true, recursive: true });
+            const { [skillId]: _removed, ...remainingConfig } = config;
+            config = normalizeConfig(remainingConfig);
+            await persistConfig();
+            return true;
+        }
+    };
+}
+async function readConfig(configPath) {
+    try {
+        return normalizeConfig(JSON.parse(await readFile(configPath, "utf8")));
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeConfig(value) {
+    if (!value || typeof value !== "object") {
+        return {};
+    }
+    const legacyDisabledSkillIds = value
+        .disabledSkillIds;
+    if (Array.isArray(legacyDisabledSkillIds)) {
+        return Object.fromEntries([...new Set(legacyDisabledSkillIds.filter(isNonEmptyString))]
+            .sort()
+            .map((skillId) => [skillId, { disabled: true }]));
+    }
+    return Object.fromEntries(Object.entries(value)
+        .filter(([skillId, entry]) => isNonEmptyString(skillId) && isPlainObject(entry))
+        .sort(([leftSkillId], [rightSkillId]) => leftSkillId.localeCompare(rightSkillId))
+        .map(([skillId, entry]) => [skillId, normalizeConfigEntry(entry)]));
+}
+function normalizeConfigEntry(entry) {
+    const normalizedEntry = { ...entry };
+    if (typeof normalizedEntry.disabled !== "boolean") {
+        delete normalizedEntry.disabled;
+    }
+    return normalizedEntry;
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function readSkillEntries(rootDir) {
+    try {
+        return (await readdir(rootDir, { withFileTypes: true })).filter((entry) => entry.isDirectory());
+    }
+    catch {
+        return [];
+    }
+}
+async function readInstalledSkill(rootDir, skillId, config) {
+    const skillPath = join(rootDir, skillId);
+    try {
+        const content = await readFile(join(skillPath, "SKILL.md"), "utf8");
+        return {
+            disabled: config[skillId]?.disabled === true,
+            id: skillId,
+            name: parseSkillName(content) ?? basename(skillPath),
+            path: skillPath
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseSkillName(content) {
+    const frontmatterMatch = /^---\n(?<frontmatter>[\s\S]*?)\n---/u.exec(content);
+    const frontmatter = frontmatterMatch?.groups?.frontmatter;
+    if (!frontmatter) {
+        return undefined;
+    }
+    for (const line of frontmatter.split("\n")) {
+        const nameMatch = /^name:\s*(?<name>.+?)\s*$/u.exec(line);
+        const rawName = nameMatch?.groups?.name;
+        if (rawName) {
+            return rawName.replace(/^["']|["']$/gu, "");
+        }
+    }
+    return undefined;
+}
+async function installSkillSource(source, targetDir, installGitRepository) {
+    if (!source.skillSubdirectory) {
+        if (source.ref) {
+            await installGitRepository(source.repositoryUrl, targetDir, source.ref);
+        }
+        else {
+            await installGitRepository(source.repositoryUrl, targetDir);
+        }
+        return;
+    }
+    const cloneDir = await mkdtemp(join(tmpdir(), "hold-rein-skill-"));
+    try {
+        await installGitRepository(source.repositoryUrl, cloneDir, source.ref);
+        await cp(join(cloneDir, source.skillSubdirectory), targetDir, {
+            errorOnExist: true,
+            recursive: true
+        });
+    }
+    catch (error) {
+        await rm(targetDir, { force: true, recursive: true });
+        throw error;
+    }
+    finally {
+        await rm(cloneDir, { force: true, recursive: true });
+    }
+}
+function getSkillSourceFromGithubUrl(repositoryUrl) {
+    const trimmedUrl = repositoryUrl.trim();
+    const rootMatch = /^https:\/\/github\.com\/[^/\s]+\/(?<repo>[^/\s]+?)(?:\.git)?\/?$/u.exec(trimmedUrl) ??
+        /^git@github\.com:[^/\s]+\/(?<repo>[^/\s]+?)(?:\.git)?$/u.exec(trimmedUrl);
+    const rootRepo = rootMatch?.groups?.repo;
+    if (rootRepo && isValidRepositoryName(rootRepo)) {
+        return {
+            repositoryUrl: trimmedUrl,
+            skillId: rootRepo
+        };
+    }
+    const webMatch = /^https:\/\/github\.com\/[^/\s]+\/(?<repo>[^/\s]+)\/(?<kind>tree|blob)\/(?<ref>[^/\s]+)(?:\/(?<path>.*))?\/?$/u.exec(trimmedUrl);
+    const repo = webMatch?.groups?.repo;
+    const kind = webMatch?.groups?.kind;
+    const ref = webMatch?.groups?.ref;
+    const path = webMatch?.groups?.path;
+    if (!repo || !kind || !ref || !isValidRepositoryName(repo)) {
+        throw new Error("repositoryUrl must be a GitHub repository URL");
+    }
+    const pathSegments = normalizeGithubPathSegments(path);
+    const skillSubdirectory = kind === "blob"
+        ? getSkillDirectoryFromBlobPath(pathSegments)
+        : pathSegments.join("/");
+    const source = {
+        ref,
+        repositoryUrl: getHttpsGitRepositoryUrl(trimmedUrl, repo),
+        skillId: basename(skillSubdirectory || repo)
+    };
+    if (skillSubdirectory) {
+        source.skillSubdirectory = skillSubdirectory;
+    }
+    return source;
+}
+function getSkillDirectoryFromBlobPath(pathSegments) {
+    if (pathSegments.at(-1) !== "SKILL.md") {
+        throw new Error("repositoryUrl must be a GitHub repository URL");
+    }
+    return pathSegments.slice(0, -1).join("/");
+}
+function getHttpsGitRepositoryUrl(trimmedUrl, repo) {
+    const repositoryBaseMatch = new RegExp(`^(?<base>https://github\\.com/[^/\\s]+/${escapeRegExp(repo)})/`, "u").exec(trimmedUrl);
+    const repositoryBase = repositoryBaseMatch?.groups?.base;
+    if (!repositoryBase) {
+        throw new Error("repositoryUrl must be a GitHub repository URL");
+    }
+    return `${repositoryBase}.git`;
+}
+function normalizeGithubPathSegments(path) {
+    if (!path) {
+        return [];
+    }
+    const segments = path.split("/").filter((segment) => segment.length > 0);
+    if (segments.some((segment) => segment === "." || segment === "..")) {
+        throw new Error("repositoryUrl must be a GitHub repository URL");
+    }
+    return segments;
+}
+function isValidRepositoryName(repo) {
+    return /^[A-Za-z0-9._-]+$/u.test(repo);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+async function cloneGitRepository(repositoryUrl, targetDir, ref) {
+    const args = ref
+        ? ["clone", "--depth", "1", "--branch", ref, repositoryUrl, targetDir]
+        : ["clone", "--depth", "1", repositoryUrl, targetDir];
+    await execFileAsync("git", args);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/runtime/api/modules/skills/skills-types.d.ts

@@ -0,0 +1,22 @@
+export interface InstalledSkill {
+    disabled: boolean;
+    id: string;
+    name: string;
+    path: string;
+}
+export interface SkillsConfig {
+    [skillId: string]: SkillConfigEntry;
+}
+export interface SkillConfigEntry {
+    disabled?: boolean;
+    [property: string]: unknown;
+}
+export interface SkillsService {
+    installSkill: (repositoryUrl: string) => Promise<InstalledSkill>;
+    listEnabledSkillDirs: () => Promise<string[]>;
+    listSkills: () => Promise<InstalledSkill[]>;
+    load: () => Promise<void>;
+    setSkillDisabled: (skillId: string, disabled: boolean) => Promise<InstalledSkill | null>;
+    uninstallSkill: (skillId: string) => Promise<boolean>;
+}
+//# sourceMappingURL=skills-types.d.ts.map

package/dist/runtime/api/modules/skills/skills-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-types.d.ts","sourceRoot":"","sources":["../../../src/modules/skills/skills-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAAC;CACrC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IACjE,oBAAoB,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9C,UAAU,EAAE,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC5C,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,gBAAgB,EAAE,CAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,OAAO,KACd,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IACpC,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACvD"}

package/dist/runtime/api/modules/skills/skills-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/api/modules/usage-stats/default-usage-stats-service.d.ts

@@ -0,0 +1,3 @@
+import { type UsageStatsService } from "./usage-stats-service";
+export declare function getDefaultUsageStatsService(): UsageStatsService;
+//# sourceMappingURL=default-usage-stats-service.d.ts.map

package/dist/runtime/api/modules/usage-stats/default-usage-stats-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-usage-stats-service.d.ts","sourceRoot":"","sources":["../../../src/modules/usage-stats/default-usage-stats-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,uBAAuB,CAAC;AAI/B,wBAAgB,2BAA2B,IAAI,iBAAiB,CAc/D"}