kennel 0.2.43 → 0.2.45

package/dist/site/hot-viewer.js

@@ -6,10 +6,10 @@ import { createConnection } from 'node:net';
 import { tmpdir } from 'node:os';
 import { dirname, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { popUrl, pluginViewLinks } from './viewer.js';
+import { popUrl } from './viewer.js';
 import { createKennelClient } from '../core/api-client.js';
 import { pluginSetKey } from '../plugins/external.js';
-import { openPreview, previewTerminal } from './terminal.js';
+import { openPreview, previewTerminal } from '../tui/launcher.js';
 function sourceRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), '../../../..');
 }
@@ -179,7 +179,7 @@ export async function hotViewer(options, restarting = false) {
                 return hotViewer(options, true);
             throw new Error(stale);
         }
-        const terminal = previewTerminal(viewerUrl, options, pluginViewLinks(viewerUrl, options.root));
+        const terminal = previewTerminal(viewerUrl, options);
         if (options.open)
             openPreview(viewerUrl);
         try {
@@ -245,7 +245,7 @@ export async function hotViewer(options, restarting = false) {
         },
         stdio: ['ignore', 'inherit', 'inherit'],
     });
-    const terminal = previewTerminal(viewerUrl, options, pluginViewLinks(viewerUrl, options.root));
+    const terminal = previewTerminal(viewerUrl, options);
     void terminal.closed.then(() => {
         if (child.exitCode === null && child.signalCode === null)
             child.kill('SIGTERM');

package/dist/site/server-plugins.js

@@ -1,8 +1,8 @@
 // packages/api/src/server/plugins.ts
 import { pathToFileURL } from "node:url";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, stat as stat2, writeFile } from "node:fs/promises";
-import { dirname, resolve as resolve2, sep as sep2 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir, readFile as readFile2, stat as stat4, writeFile } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve5, sep as sep4 } from "node:path";
 
 // packages/plugins/src/server.ts
 class FolderPluginFailure extends Error {
@@ -12,15 +12,453 @@ class FolderPluginFailure extends Error {
   }
 }
 
+// packages/knl/src/server.ts
+import { stat as stat2 } from "node:fs/promises";
+import { join } from "node:path";
+
+// packages/knl/src/knl.ts
+import { readdir, stat } from "node:fs/promises";
+import { basename, dirname as dirname3, relative, resolve as resolve3, sep as sep2 } from "node:path";
+import * as esbuild from "esbuild";
+
+// packages/knl/src/folder-guard.ts
+import { existsSync, realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { dirname, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var knlHostResolveDir = dirname(fileURLToPath(import.meta.url));
+var knlHostPackageFolders = (() => {
+  const folders = [];
+  let current = knlHostResolveDir;
+  while (true) {
+    const nodeModules = resolve(current, "node_modules");
+    if (existsSync(nodeModules))
+      folders.push(nodeModules);
+    const parent = dirname(current);
+    if (parent === current)
+      return folders;
+    current = parent;
+  }
+})();
+async function knlRealRoot(owner) {
+  const expected = resolve(await realpath(owner), "knl");
+  const real = await realpath(resolve(owner, "knl"));
+  if (real !== expected)
+    throw new Error("knl/ must be a folder, not a link to another place.");
+  return real;
+}
+async function knlReadRoots(owner) {
+  const packages = await Promise.all(knlHostPackageFolders.map((folder) => realpath(folder).catch(() => {
+    return;
+  })));
+  return [
+    await knlRealRoot(owner),
+    ...packages.filter((folder) => Boolean(folder))
+  ];
+}
+function isKnlReadable(file, roots) {
+  let real;
+  try {
+    real = realpathSync(file);
+  } catch {
+    real = resolve(file);
+  }
+  return roots.some((root) => real === root || real.startsWith(`${root}${sep}`));
+}
+function knlReadError(file) {
+  return `KNL pages can only use files in knl/ and installed packages: ${file}`;
+}
+function assertKnlReadable(file, roots) {
+  if (!isKnlReadable(file, roots))
+    throw new Error(knlReadError(file));
+}
+
+// packages/knl/src/tailwind.ts
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { compile } from "@tailwindcss/node";
+import { Scanner } from "@tailwindcss/oxide";
+var require2 = createRequire(import.meta.url);
+function starterKnlStyles() {
+  return `@layer theme, utilities;
+@import "tailwindcss/theme.css" layer(theme) prefix(knl);
+@import "tailwindcss/utilities.css" layer(utilities) source(none);
+
+@theme {
+  --font-sans: system-ui, sans-serif;
+}
+`;
+}
+async function compileKnlCss(js, stylesheet, roots) {
+  const base = dirname2(stylesheet);
+  assertKnlReadable(stylesheet, roots);
+  const css = await readFile(stylesheet, "utf8").catch((error) => {
+    if (error.code === "ENOENT")
+      return starterKnlStyles();
+    throw error;
+  });
+  const compiler = await compile(css, {
+    base,
+    from: stylesheet,
+    onDependency: (path) => assertKnlReadable(path, roots),
+    customJsResolver: async (id) => {
+      throw new Error(`KNL does not load Tailwind plugins or configs (${id}).`);
+    },
+    customCssResolver: async (id) => id === "tailwindcss" || id.startsWith("tailwindcss/") ? require2.resolve(id) : undefined
+  });
+  const sources = [...compiler.sources];
+  if (compiler.root !== "none") {
+    sources.push({
+      ...compiler.root ?? { base, pattern: "**/*" },
+      negated: false
+    });
+  }
+  for (const source of sources) {
+    if (source.negated)
+      continue;
+    const fixed = source.pattern.split("/");
+    const glob = fixed.findIndex((part) => /[*?[{]/.test(part));
+    assertKnlReadable(resolve2(source.base, fixed.slice(0, glob < 0 ? undefined : glob).join("/")), roots);
+  }
+  const scanner = new Scanner({ sources });
+  const candidates = [
+    ...scanner.scan(),
+    ...scanner.scanFiles([{ content: js, extension: "js" }])
+  ];
+  return compiler.build(candidates);
+}
+
+// packages/knl/src/knl.ts
+var KNK_FOLDER = "knl";
+var MAX_SOURCE_BYTES = 512 * 1024;
+var MAX_JS_BYTES = 5 * 1024 * 1024;
+var MODULE_FILES = ["index.tsx", "index.ts"];
+function sourceFor(file, knlRoot, scanRoot, owner) {
+  const id = toModuleId(file, knlRoot);
+  return {
+    id,
+    file,
+    relative: relative(scanRoot, file).split(sep2).join("/"),
+    folder: dirname3(file),
+    owner
+  };
+}
+function toModuleId(file, knlRoot) {
+  const relativeKnl = relative(knlRoot, file).split(sep2).join("/");
+  return relativeKnl.replace(/\/?index\.(tsx|ts)$/, "") || "index";
+}
+async function collectKnlSources(scanRoot, owner) {
+  const knlRoot = resolve3(scanRoot, KNK_FOLDER);
+  const knlEntries = await readdir(knlRoot, { withFileTypes: true }).catch(() => []);
+  const sources = [];
+  const addModule = async (folder) => {
+    for (const candidate of MODULE_FILES) {
+      const file = resolve3(folder, candidate);
+      if (await stat(file).then((d) => d.isFile()).catch(() => false)) {
+        sources.push(sourceFor(file, knlRoot, scanRoot, owner));
+        return;
+      }
+    }
+  };
+  await addModule(knlRoot);
+  for (const entry of knlEntries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name.startsWith(".") || entry.name === "node_modules")
+      continue;
+    await addModule(resolve3(knlRoot, entry.name));
+  }
+  return sources.sort((left, right) => {
+    const rank = (left.id === "index" ? 0 : 1) - (right.id === "index" ? 0 : 1);
+    return rank !== 0 ? rank : left.id.localeCompare(right.id);
+  });
+}
+async function loadKnlSources(viewRoot, linkedFolders = []) {
+  const sources = [
+    ...await collectKnlSources(viewRoot, viewRoot),
+    ...(await Promise.all(linkedFolders.map(async (folder) => (await collectKnlSources(folder, folder)).map((source) => ({
+      ...source,
+      id: `${basename(folder)}:${source.id}`,
+      relative: `${basename(folder)}/${source.relative}`
+    }))))).flat()
+  ];
+  return { sources };
+}
+var MAX_CACHED_MODULES = 200;
+var compileCache = new Map;
+function knlNodePaths(knlRoot) {
+  return [resolve3(knlRoot, "node_modules"), ...knlHostPackageFolders];
+}
+async function compileKnlSource(source) {
+  const sourceBytes = (await stat(source.file)).size;
+  const tooLarge = (bytes, what) => ({
+    id: source.id,
+    relative: source.relative,
+    js: "",
+    css: "",
+    issues: [
+      {
+        path: source.relative,
+        message: `Module ${what} is too large (${bytes} bytes; limit ${MAX_SOURCE_BYTES}).`
+      }
+    ]
+  });
+  if (sourceBytes > MAX_SOURCE_BYTES)
+    return tooLarge(sourceBytes, "source");
+  const cached = compileCache.get(source.file);
+  const unchanged = cached && (await Promise.all(cached.dependencies.map(async ({ file, mtimeMs }) => (await stat(file).catch(() => {
+    return;
+  }))?.mtimeMs === mtimeMs))).every(Boolean);
+  const knlRoot = resolve3(source.owner, KNK_FOLDER);
+  let issuePath = source.relative;
+  try {
+    const nodePaths = knlNodePaths(knlRoot);
+    const roots = await knlReadRoots(source.owner);
+    assertKnlReadable(source.file, roots);
+    let js;
+    if (cached && unchanged) {
+      js = cached.js;
+    } else {
+      const result = await esbuild.build({
+        absWorkingDir: source.folder,
+        stdin: {
+          contents: `import { createElement } from "react"
+import { createRoot } from "react-dom/client"
+import Component from ${JSON.stringify(source.file)}
+
+globalThis.__knlMount = (container, context, onError) => {
+  const root = createRoot(container, { onUncaughtError: onError })
+  root.render(createElement(Component, context))
+}
+`,
+          sourcefile: `${source.file}.mount.ts`,
+          loader: "ts",
+          resolveDir: source.folder
+        },
+        bundle: true,
+        format: "iife",
+        target: "es2022",
+        jsx: "automatic",
+        platform: "browser",
+        write: false,
+        minify: false,
+        sourcemap: false,
+        logLevel: "silent",
+        metafile: true,
+        nodePaths,
+        plugins: [readGuard(roots)]
+      });
+      js = result.outputFiles?.[0]?.text ?? "";
+      const files = new Set([
+        resolve3(knlRoot, "package.json"),
+        ...Object.keys(result.metafile.inputs).map((file) => resolve3(source.folder, file)).filter((file) => file !== `${source.file}.mount.ts`)
+      ]);
+      const dependencies = await Promise.all([...files].map(async (file) => ({
+        file,
+        mtimeMs: (await stat(file).catch(() => {
+          return;
+        }))?.mtimeMs
+      })));
+      compileCache.delete(source.file);
+      compileCache.set(source.file, { js, dependencies });
+      if (compileCache.size > MAX_CACHED_MODULES)
+        compileCache.delete(compileCache.keys().next().value);
+    }
+    const stylesheet = resolve3(knlRoot, "style.css");
+    issuePath = relative(source.owner, stylesheet).split(sep2).join("/");
+    const css = await compileKnlCss(js, stylesheet, roots);
+    issuePath = source.relative;
+    if (js.length + css.length > MAX_JS_BYTES) {
+      return {
+        id: source.id,
+        relative: source.relative,
+        js: "",
+        css: "",
+        issues: [
+          {
+            path: source.relative,
+            message: `Compiled module is too large (${js.length + css.length} bytes; limit ${MAX_JS_BYTES}).`
+          }
+        ]
+      };
+    }
+    return { id: source.id, relative: source.relative, js, css, issues: [] };
+  } catch (error) {
+    return {
+      id: source.id,
+      relative: source.relative,
+      js: "",
+      css: "",
+      issues: knlBuildIssues(error, issuePath, source)
+    };
+  }
+}
+var guardResolve = Symbol("knl-guard");
+function readGuard(roots) {
+  return {
+    name: "knl-read-guard",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        if (args.pluginData === guardResolve)
+          return;
+        const resolveFrom = (resolveDir) => build.resolve(args.path, {
+          importer: args.importer,
+          kind: args.kind,
+          pluginData: guardResolve,
+          resolveDir
+        });
+        const readable = (result) => result.namespace !== "file" || !result.path || isKnlReadable(result.path, roots);
+        let result = await resolveFrom(args.resolveDir);
+        const bare = !/^(?:\.{1,2}(?:\/|$)|\/)/.test(args.path);
+        if (bare && result.errors.length === 0 && !readable(result))
+          result = await resolveFrom(knlHostResolveDir);
+        if (result.errors.length > 0)
+          return { errors: result.errors };
+        if (!readable(result))
+          return { errors: [{ text: knlReadError(args.path) }] };
+        return result;
+      });
+    }
+  };
+}
+function knlBuildIssues(error, relativePath, source) {
+  const failures = error?.errors;
+  if (Array.isArray(failures) && failures.length > 0) {
+    const first = failures[0];
+    const file = first?.location?.file ? relative(source.owner, resolve3(source.folder, first.location.file)).split(sep2).join("/") : relativePath;
+    const location = first?.location ? `${file}:${first.location.line ?? "?"}` : relativePath;
+    return [
+      { path: location, message: first?.text ?? "Module failed to compile." }
+    ];
+  }
+  return [
+    {
+      path: relativePath,
+      message: error instanceof Error && error.message ? error.message : "Module failed to compile."
+    }
+  ];
+}
+function starterKnlSource() {
+  return `// knl/index.tsx — this folder's homepage (KNL folder web framework).
+// Every other page lives in its own folder: knl/<page>/index.tsx.
+import * as React from "react"
+
+export default function Home() {
+  return (
+    <div className="knl:p-4 knl:font-sans">
+      <h1 className="knl:m-0 knl:text-2xl">Home</h1>
+      <p>Edit this file to build the homepage.</p>
+    </div>
+  )
+}
+`;
+}
+
+// packages/knl/src/manifest.ts
+var knlManifest = {
+  id: "knl",
+  label: "KNL"
+};
+
+// packages/knl/src/server.ts
+function createKnlPlugin() {
+  return {
+    ...knlManifest,
+    async detect(context) {
+      const hasKnlFolder = await stat2(join(context.folder, KNK_FOLDER)).then((entry) => entry.isDirectory()).catch(() => false);
+      if (!hasKnlFolder)
+        return { status: "unavailable" };
+      const { sources } = await loadKnlSources(context.folder, context.linkedFolders ?? []);
+      if (!sources.some((source) => source.id === "index"))
+        return { status: "unavailable" };
+      return {
+        count: sources.length,
+        pages: sources.filter((source) => source.id !== "index" && !source.id.endsWith(":index")).map((source) => ({
+          id: source.id,
+          label: source.id.replaceAll(/[-_]/g, " ").replace(/^./, (letter) => letter.toUpperCase())
+        })),
+        status: "available"
+      };
+    },
+    async handle(context, subpath) {
+      const { sources } = await loadKnlSources(context.folder, context.linkedFolders ?? []);
+      const folder = context.folder;
+      if (sources.length === 0) {
+        return { kind: "available", data: { folder, status: "unavailable" } };
+      }
+      const requested = subpath.trim() || "index";
+      const selected = sources.filter((source) => source.id === requested);
+      if (selected.length === 0) {
+        return {
+          kind: "available",
+          data: {
+            folder,
+            status: "error",
+            message: `KNL page not found: ${requested}`
+          }
+        };
+      }
+      const compiled = await Promise.all(selected.map(compileKnlSource));
+      const entries = compiled.map((result) => {
+        const source = sources.find((item) => item.id === result.id);
+        return {
+          id: result.id,
+          relative: result.relative,
+          ...result.js ? { js: result.js } : {},
+          css: result.css,
+          ...result.issues.length > 0 ? { issues: result.issues } : {},
+          owner: source?.owner ?? folder
+        };
+      });
+      const failing = entries.filter((entry) => entry.issues?.length);
+      if (failing.length > 0) {
+        return {
+          kind: "available",
+          data: {
+            folder,
+            status: "error",
+            entries,
+            issues: failing[0]?.issues
+          }
+        };
+      }
+      return {
+        kind: "available",
+        data: {
+          folder,
+          status: "available",
+          entries
+        }
+      };
+    },
+    async init() {
+      return {
+        files: [
+          { path: "knl/index.tsx", content: starterKnlSource() },
+          { path: "knl/style.css", content: starterKnlStyles() },
+          {
+            path: "knl/package.json",
+            content: `${JSON.stringify({ private: true, type: "module" }, null, 2)}
+`
+          },
+          { path: "knl/.gitignore", content: `node_modules/
+` }
+        ]
+      };
+    }
+  };
+}
+
 // packages/notes/src/server.ts
-import { readdir, realpath, stat } from "node:fs/promises";
+import { readdir as readdir2, realpath as realpath2, stat as stat3 } from "node:fs/promises";
 import {
-  basename,
+  basename as basename2,
   extname,
   isAbsolute,
-  relative,
-  resolve,
-  sep
+  relative as relative2,
+  resolve as resolve4,
+  sep as sep3
 } from "node:path";
 
 // packages/notes/src/manifest.ts
@@ -42,11 +480,11 @@ var llmNoteLimit = 20;
 async function listMarkdownFiles(folder) {
   const files = [];
   const visit = async (current) => {
-    const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir2(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name.startsWith("."))
         continue;
-      const path = resolve(current, entry.name);
+      const path = resolve4(current, entry.name);
       if (entry.isDirectory()) {
         await visit(path);
         continue;
@@ -54,22 +492,22 @@ async function listMarkdownFiles(folder) {
       if (!entry.isFile() || !markdownExtensions.has(extname(entry.name))) {
         continue;
       }
-      const details = await stat(path).catch(() => {
+      const details = await stat3(path).catch(() => {
         return;
       });
       files.push({
         activityAt: details?.mtimeMs ?? 0,
-        name: basename(entry.name, extname(entry.name)),
-        relativePath: relative(folder, path).split(sep).join("/")
+        name: basename2(entry.name, extname(entry.name)),
+        relativePath: relative2(folder, path).split(sep3).join("/")
       });
     }
   };
   await visit(folder);
   return files.sort((left, right) => right.activityAt - left.activityAt);
 }
-var canonical = (path) => realpath(path).catch(() => path);
+var canonical = (path) => realpath2(path).catch(() => path);
 function inside(path, root) {
-  const local = relative(root, path);
+  const local = relative2(root, path);
   return local === "" || !local.startsWith("..") && !isAbsolute(local);
 }
 async function withoutManaged(groups, managedRoots) {
@@ -81,7 +519,7 @@ async function withoutManaged(groups, managedRoots) {
       return { ...group, files: [] };
     }
     const files = await Promise.all(group.files.map(async (file) => {
-      const real = await canonical(resolve(group.folder, file.relativePath));
+      const real = await canonical(resolve4(group.folder, file.relativePath));
       return roots.some((root) => inside(real, root)) ? undefined : file;
     }));
     return { ...group, files: files.filter((file) => file !== undefined) };
@@ -131,7 +569,7 @@ async function notesLlmSections({
       continue;
     seen.add(identity);
     const files = await listMarkdownFiles(source);
-    const paths = files.map((file) => resolve(source, file.relativePath));
+    const paths = files.map((file) => resolve4(source, file.relativePath));
     groups.push({ folder: source, paths });
     files.forEach((file, index) => notes.push({ activityAt: file.activityAt, path: paths[index] }));
   }
@@ -203,14 +641,14 @@ function parsePluginRegistryConfig(content) {
   };
 }
 async function nearestKennelConfig(folder) {
-  for (let current = folder;; current = dirname(current)) {
-    const candidate = resolve2(current, "kennel.json");
-    const details = await stat2(candidate).catch(() => {
+  for (let current = folder;; current = dirname4(current)) {
+    const candidate = resolve5(current, "kennel.json");
+    const details = await stat4(candidate).catch(() => {
       return;
     });
     if (details?.isFile())
       return candidate;
-    if (dirname(current) === current)
+    if (dirname4(current) === current)
       return;
   }
 }
@@ -219,13 +657,13 @@ async function folderPluginRegistryConfig(folder) {
   if (!path)
     return defaultPluginRegistryConfig;
   try {
-    return parsePluginRegistryConfig(await readFile(path, "utf8"));
+    return parsePluginRegistryConfig(await readFile2(path, "utf8"));
   } catch {
     return defaultPluginRegistryConfig;
   }
 }
 function createFolderServerPlugins() {
-  return [createNotesPlugin()];
+  return [createNotesPlugin(), createKnlPlugin()];
 }
 function folderServerRegistry() {
   return new Map(createFolderServerPlugins().map((plugin) => [plugin.id, plugin]));
@@ -267,7 +705,7 @@ async function folderServerRegistryAsync() {
       ...server,
       async detect(context) {
         const detection = await server.detect(context);
-        if (detection.status === "unavailable" && existsSync(resolve2(context.folder, entry.trigger))) {
+        if (detection.status === "unavailable" && existsSync2(resolve5(context.folder, entry.trigger))) {
           return { status: "available" };
         }
         return detection;
@@ -305,7 +743,7 @@ async function externalApiHandlers() {
   return handlers;
 }
 async function scaffoldFolderPlugins(folder, options = {}) {
-  const root = resolve2(folder);
+  const root = resolve5(folder);
   const registry = folderServerRegistry();
   const created = [];
   const skipped = [];
@@ -316,8 +754,8 @@ async function scaffoldFolderPlugins(folder, options = {}) {
     const context = { folder: root };
     const result = await plugin.init(context);
     const files = result.files.filter((file) => {
-      const target = resolve2(root, file.path);
-      const contained = target === root || target.startsWith(root + sep2);
+      const target = resolve5(root, file.path);
+      const contained = target === root || target.startsWith(root + sep4);
       return contained && file.path !== ".";
     });
     supported.push({
@@ -325,15 +763,15 @@ async function scaffoldFolderPlugins(folder, options = {}) {
       files: files.map((file) => file.path)
     });
     for (const file of files) {
-      const target = resolve2(root, file.path);
-      const exists = await stat2(target).then(() => true).catch(() => false);
+      const target = resolve5(root, file.path);
+      const exists = await stat4(target).then(() => true).catch(() => false);
       if (exists && !options.force) {
         skipped.push({ path: file.path, plugin: plugin.id });
         continue;
       }
       if (options.write === false)
         continue;
-      await mkdir(dirname(target), { recursive: true });
+      await mkdir(dirname4(target), { recursive: true });
       await writeFile(target, file.content);
       created.push({ path: file.path, plugin: plugin.id });
     }

package/dist/site/viewer.d.ts

@@ -1,6 +1,3 @@
-import { type PluginView } from "./terminal.js";
-/** Installed-plugin view links for the terminal menu; each is hyperlinked. */
-export declare function pluginViewLinks(viewerUrl: string, root: string): PluginView[];
 export type ViewerOptions = {
     dryRun: boolean;
     host: string;