kennel 0.2.2 → 0.2.5

package/dist/plugins/external.d.ts

@@ -4,7 +4,8 @@ export type ExternalPluginEntry = {
     commit: string;
     packageName: string;
     id: string;
-    trigger: string;
+    directory?: string;
+    trigger?: string;
     entries: {
         client: string;
         clientSymbol: string;
@@ -12,13 +13,19 @@ export type ExternalPluginEntry = {
         serverSymbol: string;
         manifest: string;
         manifestSymbol: string;
+        api?: string;
+        apiSymbol?: string;
         css?: string;
     };
 };
 export declare function kennelConfigPath(): string;
-export declare function validateExternalPlugin(inputUrl: string, existing?: ExternalPluginEntry[]): Promise<ExternalPluginEntry>;
+export declare function validateExternalPlugin(inputUrl: string, existing?: ExternalPluginEntry[], options?: {
+    directory?: string;
+}): Promise<ExternalPluginEntry>;
 export declare function readExternalPlugins(): ExternalPluginEntry[];
-export declare function installExternalPlugin(url: string): Promise<ExternalPluginEntry>;
+export declare function installExternalPlugin(url: string, options?: {
+    directory?: string;
+}): Promise<ExternalPluginEntry>;
 export declare function kernelKey(plugins?: ExternalPluginEntry[]): string;
 export type ActiveKernel = {
     buildIdentity: string;
@@ -32,5 +39,24 @@ export type ActiveKernel = {
         symbol: string;
         trigger?: string;
     }>;
+    apiEntries: Array<{
+        id: string;
+        module: string;
+        symbol: string;
+    }>;
 };
+export declare function prepareExternalPluginModules(temp: string, target?: string, plugins?: ExternalPluginEntry[]): Promise<{
+    clientModule: string;
+    serverEntries: {
+        id: string;
+        module: string;
+        symbol: string;
+        trigger?: string;
+    }[];
+    apiEntries: {
+        id: string;
+        module: string;
+        symbol: string;
+    }[];
+}>;
 export declare function ensureKernel(plugins?: ExternalPluginEntry[]): Promise<ActiveKernel>;

package/dist/plugins/external.js

@@ -15,10 +15,10 @@ import { pathToFileURL, fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
 const CONFIG_FILE = join("kennel", "config.json");
 const VALID_ID = /^[a-z][a-z0-9-]*$/u;
-const CORE_IDS = new Set(["agents", "calendar", "mail", "notes", "projects", "tasks"]);
+const CORE_IDS = new Set(["agents", "notes"]);
 const KENNEL_KERNEL_SCHEMA = 2;
 const BUILD_RUNTIME = `node-${process.versions.node}`;
-const BUILD_IDENTITY = "kennel-external-kernel-v2";
+const BUILD_IDENTITY = "kennel-external-kernel-v3";
 function xdgConfigHome() {
     return process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
 }
@@ -103,6 +103,19 @@ function sourceCheckout(url, commit) {
     run("git", ["checkout", "--force", commit], { cwd: dir });
     return realpathSync(dir);
 }
+function pluginRoot(repoRoot, directory) {
+    if (!directory)
+        return repoRoot;
+    if (isAbsolute(directory) || directory.includes("\0"))
+        throw new Error(`Unsafe plugin directory: ${directory}`);
+    const target = resolve(repoRoot, directory);
+    const rel = relative(repoRoot, target);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        throw new Error(`Unsafe plugin directory: ${directory}`);
+    if (!existsSync(target) || !statSync(target).isDirectory())
+        throw new Error(`Missing plugin directory: ${directory}`);
+    return target;
+}
 function packageExportPath(exportsValue, key) {
     if (!exportsValue || typeof exportsValue !== "object" || Array.isArray(exportsValue))
         return undefined;
@@ -150,16 +163,12 @@ function internalSourceAliases(root = kernelSourceRoot()) {
     const aliases = {};
     for (const [name, path] of Object.entries({
         "@raggle-ai/agents": "packages/agents/src",
-        "@raggle-ai/calendar": "plugins/calendar/src",
         "@raggle-ai/folder-plugin": "packages/folder-plugin/src",
         "@raggle-ai/kennel-api": "packages/api/src",
-        "@raggle-ai/mail": "plugins/mail/src",
         "@raggle-ai/markdown": "packages/markdown/src",
         "@raggle-ai/notes": "packages/notes/src",
-        "@raggle-ai/projects": "plugins/projects/src",
         "@raggle-ai/schemas": "packages/schemas/src",
         "@raggle-ai/session-finding": "packages/session-finding/src",
-        "@raggle-ai/tasks": "plugins/tasks/src",
         "@raggle-ai/ui": "packages/ui/src",
         "kennel-client": "packages/api-client/src",
     })) {
@@ -188,7 +197,7 @@ function resolveAliasPath(target, suffix) {
 }
 function esbuildAliasPlugin(root = kernelSourceRoot()) {
     const sourceAliases = internalSourceAliases(root);
-    const hostPackages = ["@raggle-ai/barkdown", "@raggle-ai/scout-ui", "@tanstack/react-query", "@tanstack/react-router", "lucide-react", "react", "react-dom", "react/jsx-runtime", "yaml", "lexical"];
+    const hostPackages = ["@raggle-ai/barkdown", "@raggle-ai/scout-ui", "@tanstack/react-query", "@tanstack/react-router", "date-fns", "effect", "lucide-react", "react", "react-dom", "react/jsx-runtime", "yaml", "lexical"];
     return {
         name: "kennel-host-resolution",
         setup(build) {
@@ -241,9 +250,12 @@ async function validateImports(entry) {
         const manifestOut = join(dir, "manifest.mjs");
         const serverOut = join(dir, "server.mjs");
         const clientOut = join(dir, "client.mjs");
+        const apiOut = join(dir, "api.mjs");
         await bundleForImport(entry.entries.manifest, manifestOut, "browser");
         await bundleForImport(entry.entries.server, serverOut, "node");
         await bundleForImport(entry.entries.client, clientOut, "node");
+        if (entry.entries.api)
+            await bundleForImport(entry.entries.api, apiOut, "node");
         const manifestModule = await import(__rewriteRelativeImportExtension(pathToFileURL(manifestOut).href));
         const serverModule = await import(__rewriteRelativeImportExtension(pathToFileURL(serverOut).href));
         const clientModule = await import(__rewriteRelativeImportExtension(pathToFileURL(clientOut).href));
@@ -260,15 +272,22 @@ async function validateImports(entry) {
             throw new Error("client id mismatch");
         if (typeof client.component !== "function")
             throw new Error("client export missing component");
+        if (entry.entries.api && entry.entries.apiSymbol) {
+            const apiModule = await import(__rewriteRelativeImportExtension(pathToFileURL(apiOut).href));
+            if (typeof apiModule[entry.entries.apiSymbol] !== "function")
+                throw new Error("API export missing handler");
+        }
     }
     finally {
         await rm(dir, { force: true, recursive: true });
     }
 }
-export async function validateExternalPlugin(inputUrl, existing = []) {
+export async function validateExternalPlugin(inputUrl, existing = [], options = {}) {
     const { url, requestedRef } = splitRepositoryUrl(inputUrl);
     const commit = resolveCommit(url, requestedRef);
-    const root = sourceCheckout(url, commit);
+    const checkoutRoot = sourceCheckout(url, commit);
+    const directory = options.directory?.trim() || undefined;
+    const root = pluginRoot(checkoutRoot, directory);
     const pkgPath = join(root, "package.json");
     if (!existsSync(pkgPath))
         throw new Error("Plugin repository has no package.json at its root");
@@ -277,8 +296,6 @@ export async function validateExternalPlugin(inputUrl, existing = []) {
     const metadata = pkg.kennel?.plugin;
     if (!metadata || typeof metadata !== "object")
         throw new Error("package.json must define kennel.plugin metadata");
-    if (!metadata.exports || typeof metadata.exports !== "object")
-        throw new Error("kennel.plugin.exports is required");
     const id = stringField(metadata.id, "plugin id");
     if (!VALID_ID.test(id))
         throw new Error(`Invalid plugin id: ${id}`);
@@ -286,14 +303,23 @@ export async function validateExternalPlugin(inputUrl, existing = []) {
         throw new Error(`External plugin id collides with core plugin: ${id}`);
     if (existing.some((plugin) => plugin.id === id))
         throw new Error(`External plugin id is already installed: ${id}`);
-    const trigger = stringField(metadata.trigger, "trigger file");
-    if (trigger.includes("/") || trigger.includes("\\") || trigger === "." || trigger === "..")
+    const trigger = metadata.trigger === undefined ? undefined : stringField(metadata.trigger, "trigger file");
+    if (trigger && (trigger.includes("/") || trigger.includes("\\") || trigger === "." || trigger === ".."))
         throw new Error(`Invalid trigger file: ${trigger}`);
     const exportsValue = pkg.exports;
     const client = safeRelativeFile(root, packageExportPath(exportsValue, "./client"), "./client package export");
     const server = safeRelativeFile(root, packageExportPath(exportsValue, "./server"), "./server package export");
     const manifest = safeRelativeFile(root, packageExportPath(exportsValue, "./manifest"), "./manifest package export");
-    const cssValue = metadata.exports.css;
+    const apiPath = packageExportPath(exportsValue, "./api");
+    const apiExport = apiPath
+        ? safeRelativeFile(root, apiPath, "./api package export")
+        : undefined;
+    const apiSymbol = apiExport
+        ? typeof metadata.exports?.apiSymbol === "string"
+            ? metadata.exports.apiSymbol
+            : "default"
+        : undefined;
+    const cssValue = metadata.exports?.css;
     const css = cssValue === undefined ? undefined : safeRelativeFile(root, cssValue, "css export path");
     const entry = {
         url,
@@ -301,14 +327,22 @@ export async function validateExternalPlugin(inputUrl, existing = []) {
         commit,
         packageName,
         id,
-        trigger,
+        ...(directory ? { directory } : {}),
+        ...(trigger ? { trigger } : {}),
         entries: {
             client,
-            clientSymbol: stringField(metadata.exports.clientSymbol, "client export symbol"),
+            clientSymbol: typeof metadata.exports?.clientSymbol === "string"
+                ? metadata.exports.clientSymbol
+                : "default",
             server,
-            serverSymbol: stringField(metadata.exports.serverSymbol, "server export symbol"),
+            serverSymbol: typeof metadata.exports?.serverSymbol === "string"
+                ? metadata.exports.serverSymbol
+                : "default",
             manifest,
-            manifestSymbol: stringField(metadata.exports.manifestSymbol, "manifest export symbol"),
+            manifestSymbol: typeof metadata.exports?.manifestSymbol === "string"
+                ? metadata.exports.manifestSymbol
+                : "default",
+            ...(apiExport ? { api: apiExport, apiSymbol } : {}),
             ...(css ? { css } : {}),
         },
     };
@@ -319,13 +353,13 @@ export function readExternalPlugins() {
     const config = readJson(kennelConfigPath());
     return Array.isArray(config.externalPlugins) ? config.externalPlugins : [];
 }
-export async function installExternalPlugin(url) {
+export async function installExternalPlugin(url, options = {}) {
     const path = kennelConfigPath();
     const config = readJson(path);
     const externalPlugins = Array.isArray(config.externalPlugins) ? config.externalPlugins : [];
     let entry;
     try {
-        entry = await validateExternalPlugin(url, externalPlugins);
+        entry = await validateExternalPlugin(url, externalPlugins, options);
         const nextPlugins = [...externalPlugins, entry];
         await ensureKernel(nextPlugins);
         writeJsonAtomic(path, { ...config, externalPlugins: nextPlugins });
@@ -349,6 +383,7 @@ export function kernelKey(plugins = readExternalPlugins()) {
             requestedRef: plugin.requestedRef ?? null,
             packageName: plugin.packageName,
             id: plugin.id,
+            directory: plugin.directory ?? null,
             commit: plugin.commit,
             trigger: plugin.trigger,
             entries: plugin.entries,
@@ -369,7 +404,9 @@ async function readKernelMarker(marker, key) {
             kernel.key !== key ||
             !existsSync(resolve(kernel.webRoot, "index.html")) ||
             !Array.isArray(kernel.serverEntries) ||
-            kernel.serverEntries.some((entry) => !entry.id || !entry.module || !entry.symbol || !existsSync(entry.module)))
+            kernel.serverEntries.some((entry) => !entry.id || !entry.module || !entry.symbol || !existsSync(entry.module)) ||
+            !Array.isArray(kernel.apiEntries) ||
+            kernel.apiEntries.some((entry) => !entry.id || !entry.module || !entry.symbol || !existsSync(entry.module)))
             return undefined;
         return kernel;
     }
@@ -404,8 +441,7 @@ function moveIncompleteAside(target) {
     renameSync(target, broken);
     rmSync(broken, { force: true, recursive: true });
 }
-async function buildKernelTemp(temp, target, key, plugins) {
-    const sourceRoot = kernelSourceRoot();
+export async function prepareExternalPluginModules(temp, target = temp, plugins = readExternalPlugins()) {
     const clientModule = join(temp, "external-plugins.tsx");
     const serverDir = join(temp, "server");
     mkdirSync(serverDir, { recursive: true });
@@ -414,16 +450,29 @@ async function buildKernelTemp(temp, target, key, plugins) {
     const clientItems = plugins.map((plugin, index) => `  { ...manifest${index}, component: lazy(async () => ({ default: (await import(${JSON.stringify(plugin.entries.client)}))[${JSON.stringify(plugin.entries.clientSymbol)}].component })) }`).join(",\n");
     await writeFile(clientModule, `import { lazy } from "react";\nimport type { FolderPluginClient } from "@raggle-ai/folder-plugin/client";\n${cssImports}\n${clientImports}\nexport const externalFolderPlugins: FolderPluginClient[] = [\n${clientItems}\n];\n`);
     const serverEntries = [];
+    const apiEntries = [];
     for (const plugin of plugins) {
         const outfile = join(serverDir, `${plugin.id}.js`);
         await bundleForImport(plugin.entries.server, outfile, "node");
         serverEntries.push({ id: plugin.id, module: join(target, "server", `${plugin.id}.js`), symbol: plugin.entries.serverSymbol, trigger: plugin.trigger });
+        if (plugin.entries.api && plugin.entries.apiSymbol) {
+            const apiOutfile = join(serverDir, `${plugin.id}-api.js`);
+            await bundleForImport(plugin.entries.api, apiOutfile, "node");
+            apiEntries.push({ id: plugin.id, module: join(target, "server", `${plugin.id}-api.js`), symbol: plugin.entries.apiSymbol });
+        }
     }
+    return { clientModule, serverEntries, apiEntries };
+}
+async function buildKernelTemp(temp, target, key, plugins) {
+    const sourceRoot = kernelSourceRoot();
+    const { clientModule, serverEntries, apiEntries } = await prepareExternalPluginModules(temp, target, plugins);
     const vite = await import("vite");
     const previousClientModule = process.env.KENNEL_EXTERNAL_CLIENT_MODULE;
     const previousSourceRoot = process.env.KENNEL_KERNEL_SOURCE_ROOT;
+    const previousHostNodeModules = process.env.KENNEL_HOST_NODE_MODULES;
     process.env.KENNEL_EXTERNAL_CLIENT_MODULE = clientModule;
     process.env.KENNEL_KERNEL_SOURCE_ROOT = sourceRoot;
+    process.env.KENNEL_HOST_NODE_MODULES = resolve(cliRoot(), "node_modules");
     try {
         await vite.build({
             configFile: resolve(sourceRoot, "apps/web/vite.config.ts"),
@@ -442,6 +491,10 @@ async function buildKernelTemp(temp, target, key, plugins) {
             delete process.env.KENNEL_KERNEL_SOURCE_ROOT;
         else
             process.env.KENNEL_KERNEL_SOURCE_ROOT = previousSourceRoot;
+        if (previousHostNodeModules === undefined)
+            delete process.env.KENNEL_HOST_NODE_MODULES;
+        else
+            process.env.KENNEL_HOST_NODE_MODULES = previousHostNodeModules;
     }
     const kernel = {
         buildIdentity: BUILD_IDENTITY,
@@ -450,6 +503,7 @@ async function buildKernelTemp(temp, target, key, plugins) {
         key,
         webRoot: join(target, "web"),
         serverEntries,
+        apiEntries,
     };
     await writeFile(join(temp, "kernel.json"), JSON.stringify(kernel, null, 2));
     return kernel;
@@ -457,7 +511,7 @@ async function buildKernelTemp(temp, target, key, plugins) {
 export async function ensureKernel(plugins = readExternalPlugins()) {
     if (plugins.length === 0) {
         const webRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../web");
-        return { buildIdentity: BUILD_IDENTITY, schema: KENNEL_KERNEL_SCHEMA, runtime: BUILD_RUNTIME, key: "core", webRoot, serverEntries: [] };
+        return { buildIdentity: BUILD_IDENTITY, schema: KENNEL_KERNEL_SCHEMA, runtime: BUILD_RUNTIME, key: "core", webRoot, serverEntries: [], apiEntries: [] };
     }
     const key = kernelKey(plugins);
     const target = kernelRoot(key);

package/dist/site/server-plugins.d.ts

@@ -18,13 +18,8 @@ export type { FolderPluginContext, FolderPluginData, FolderPluginDetection, Fold
 export declare class FolderPluginFailure extends Error {
     constructor(message: string);
 }
-export declare function handleMailApiRoutes(request: import("node:http").IncomingMessage, response: import("node:http").ServerResponse, context: {
-    authorizeFolder: (value: string | null) => string;
-    mailDir?: string;
-    watch: (folder: string) => void;
-}): Promise<boolean>;
 export declare function folderServerRegistry(options?: {
-    mailDir?: string;
+    agentsHomeDir?: string;
 }): Map<string, FolderPluginServer>;
 export type FolderPluginScaffoldFile = {
     plugin: string;
@@ -50,5 +45,5 @@ export type FolderPluginScaffoldResult = {
 export declare function scaffoldFolderPlugins(folder: string, options?: {
     force?: boolean;
     write?: boolean;
-    mailDir?: string;
+    agentsHomeDir?: string;
 }): Promise<FolderPluginScaffoldResult>;