kennel 0.2.13 → 0.2.15

package/kernel/packages/api/src/server/watcher.ts

@@ -1,46 +0,0 @@
-import { existsSync, statSync, watch, type FSWatcher } from "node:fs";
-import { dirname, resolve } from "node:path";
-
-/** Core owns native watchers synchronously, including watches for not-yet-created config files. */
-export function createWatcher(onChange: (path: string) => void) {
-  const watchers = new Map<string, FSWatcher>();
-  let closed = false;
-  return {
-    add(paths: string | string[]) {
-      if (closed) return;
-      for (const path of typeof paths === "string" ? [paths] : paths) {
-        let directory = resolve(path);
-        while (!existsSync(directory)) {
-          const parent = dirname(directory);
-          if (parent === directory) break;
-          directory = parent;
-        }
-        if (!statSync(directory).isDirectory()) directory = dirname(directory);
-        if (watchers.has(directory)) continue;
-        const watcher = watch(
-          directory,
-          { recursive: true, persistent: false },
-          (_, filename) => {
-            if (
-              closed ||
-              !filename ||
-              /(^|[/\\])(node_modules|\.git)([/\\]|$)/.test(String(filename))
-            )
-              return;
-            onChange(resolve(directory, String(filename)));
-          },
-        );
-        watcher.on("error", () => {
-          watcher.close();
-          watchers.delete(directory);
-        });
-        watchers.set(directory, watcher);
-      }
-    },
-    close() {
-      closed = true;
-      for (const watcher of watchers.values()) watcher.close();
-      watchers.clear();
-    },
-  };
-}

package/kernel/packages/api/src/shared/selection.ts

@@ -1,16 +0,0 @@
-export function replaceSelection(
-  content: string,
-  start: number,
-  end: number,
-  replacement: string,
-) {
-  if (
-    !Number.isInteger(start) ||
-    !Number.isInteger(end) ||
-    start < 0 ||
-    end <= start ||
-    end > content.length
-  )
-    throw new Error("Invalid selection range.");
-  return content.slice(0, start) + replacement + content.slice(end);
-}

package/kernel/packages/api/src/shared/viewer-route.ts

@@ -1,198 +0,0 @@
-import type { FolderTab } from "@raggle-ai/ui/lib/folder-activity";
-
-export type ViewerSection = "notes" | "projects" | "sessions";
-
-export type ViewerPluginView = {
-  pluginId: string;
-  subpath?: string;
-};
-
-export type ViewerRoute = {
-  document?: string;
-  collectionId?: string;
-  embedded: boolean;
-  folder?: string;
-  /**
-   * Explicit chat side-panel mode (`panel=1`): edge-to-edge embedded chrome
-   * with the host bridge (close/resize/selection) active.
-   */
-  panel: boolean;
-  section?: ViewerSection;
-  /** Chat session (`client:nativeId`) that annotations are sent to. */
-  session?: string;
-  sessionId?: string;
-  /** Folder plugin view, e.g. `views/mail` or `views/mail/<id>`. */
-  view?: ViewerPluginView;
-};
-
-const folderPrefix = "/folder/";
-const sectionTabs: Record<ViewerSection, FolderTab> = {
-  notes: "files",
-  projects: "projects",
-  sessions: "sessions",
-};
-
-import { folderPathId as encodeBase64Url } from "kennel-plugins/client";
-
-function decodeBase64Url(value: string) {
-  const padded = `${value}${"=".repeat((4 - (value.length % 4)) % 4)}`;
-  const binary = atob(padded.replaceAll("-", "+").replaceAll("_", "/"));
-  return new TextDecoder().decode(
-    Uint8Array.from(binary, (character) => character.charCodeAt(0)),
-  );
-}
-
-function url(value: string) {
-  if (/^https?:\/\//.test(value)) return new URL(value);
-  if (value.startsWith("?")) return new URL(`/${value}`, "http://127.0.0.1");
-  return new URL(value || "/", "http://127.0.0.1");
-}
-
-function tabSection(tab: string | null): ViewerSection | undefined {
-  if (tab === "files") return "notes";
-  if (tab === "projects" || tab === "sessions") return tab;
-  return undefined;
-}
-
-export function folderPathId(path: string) {
-  return encodeBase64Url(path);
-}
-
-export function decodeFolderPathId(id: string) {
-  return decodeBase64Url(id);
-}
-
-export function folderSectionHref(folder: string, section: ViewerSection) {
-  return `/folder/${folderPathId(folder)}/${section}`;
-}
-
-export function folderPluginHref(
-  folder: string,
-  pluginId: string,
-  subpath = "",
-) {
-  const base = `/folder/${folderPathId(folder)}/views/${pluginId}`;
-  return subpath ? `${base}/${encodeURIComponent(subpath)}` : base;
-}
-
-export function folderCollectionHref(folder: string, collectionId: string) {
-  return `/folder/${folderPathId(folder)}/collections/${folderPathId(collectionId)}`;
-}
-
-export function folderDocumentHref(folder: string, document: string) {
-  return `/folder/${folderPathId(folder)}/document/${folderPathId(document)}`;
-}
-
-// Sessions functionality is commented out (can be re-enabled).
-// export function sessionTranscriptHref(folder: string, sessionId: string) {
-//   return `/folder/${folderPathId(folder)}/session/${folderPathId(sessionId)}`
-// }
-
-// export function decodeSessionId(id: string) {
-//   return decodeBase64Url(id)
-// }
-
-export function parseViewerRoute(value: string): ViewerRoute {
-  const current = url(value);
-  const session = current.searchParams.get("session") ?? undefined;
-  const folder = current.searchParams.get("folder");
-  if (folder) {
-    return {
-      document:
-        current.searchParams.get("document") ??
-        current.searchParams.get("file") ??
-        undefined,
-      embedded: current.searchParams.get("embedded") === "1",
-      folder,
-      panel: current.searchParams.get("panel") === "1",
-      // Sessions functionality is commented out (can be re-enabled).
-      // section: tabSection(current.searchParams.get("tab")) ?? "sessions",
-      section: tabSection(current.searchParams.get("tab")) ?? "notes",
-      ...(session ? { session } : {}),
-    };
-  }
-
-  const parts = current.pathname.split("/").filter(Boolean);
-  if (parts[0] !== "folder" || !parts[1]) {
-    return {
-      document:
-        current.searchParams.get("file") ??
-        current.searchParams.get("document") ??
-        undefined,
-      embedded: current.searchParams.get("embedded") === "1",
-      folder: undefined,
-      panel: current.searchParams.get("panel") === "1",
-      section: tabSection(current.searchParams.get("tab")),
-      ...(session ? { session } : {}),
-    };
-  }
-
-  const section = parts[2];
-  const route: ViewerRoute = {
-    embedded: current.searchParams.get("embedded") === "1",
-    folder: decodeFolderPathId(parts[1]),
-    panel: current.searchParams.get("panel") === "1",
-    ...(session ? { session } : {}),
-  };
-
-  if (section === "collections" && parts[3]) {
-    return { ...route, collectionId: decodeFolderPathId(parts[3]) };
-  }
-
-  // Folder plugin ids come from the active kernel. The API and client registry
-  // still reject unknown ids; route parsing must not hide an installed external
-  // plugin behind the Notes selection state.
-  if (section === "views" && parts[3]) {
-    return {
-      ...route,
-      view: {
-        pluginId: parts[3],
-        ...(parts[4] ? { subpath: parts[4] } : {}),
-      },
-    };
-  }
-
-  if (
-    section === "notes" ||
-    section === "projects" ||
-    section === "sessions"
-  ) {
-    return { ...route, section };
-  }
-
-  if (section === "document" && parts[3]) {
-    return { ...route, document: decodeFolderPathId(parts[3]) };
-  }
-
-  // Sessions functionality is commented out (can be re-enabled).
-  // if (section === "session" && parts[3]) {
-  //   return { ...route, sessionId: decodeFolderPathId(parts[3]) }
-  // }
-
-  // Sessions functionality is commented out (can be re-enabled).
-  // return { ...route, section: "sessions" }
-  return { ...route, section: "notes" };
-}
-
-export function routeFolderTab(route: ViewerRoute): FolderTab | undefined {
-  if (!route.section) return undefined;
-  return sectionTabs[route.section];
-}
-
-export function isDocumentRoute(value: string) {
-  return Boolean(parseViewerRoute(value).document);
-}
-
-export function legacyFolderRedirect(value: string) {
-  const current = url(value);
-  const folder = current.searchParams.get("folder");
-  if (!folder) return undefined;
-
-  const session = current.searchParams.get("session");
-  const suffix = session ? `?session=${encodeURIComponent(session)}` : "";
-  const document = current.searchParams.get("document");
-  if (document) return `${folderDocumentHref(folder, document)}${suffix}`;
-
-  const section = tabSection(current.searchParams.get("tab")) ?? "notes";
-  return `${folderSectionHref(folder, section)}${suffix}`;
-}

package/kernel/packages/api/test/core.test.ts

@@ -1,352 +0,0 @@
-import { fetch } from "bun";
-import { afterEach, expect, test } from "bun:test";
-import { mkdir, mkdtemp, realpath, rm, writeFile, symlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createKennelApi } from "../src/server";
-import { createKennelClient } from "../src/client";
-import {
-  configuredFolderServerRegistry,
-  scaffoldFolderPlugins,
-} from "../src/server/plugins";
-import type { FolderPluginServer } from "kennel-plugins/server";
-import { createCoreFolderIndex } from "@raggle-ai/schemas/node";
-
-const cleanup: (() => Promise<unknown>)[] = [];
-afterEach(async () => {
-  for (const fn of cleanup.splice(0).reverse()) await fn();
-});
-async function fixture(
-  options: Partial<Parameters<typeof createKennelApi>[0]> = {},
-) {
-  const root = await mkdtemp(join(tmpdir(), "kennel-core-"));
-  cleanup.push(() => rm(root, { recursive: true, force: true }));
-  await writeFile(join(root, "note.md"), "# Original\n");
-  const api = createKennelApi({ root, ...options });
-  cleanup.push(() => api.close());
-  const address = await api.listen(0);
-  if (!address || typeof address === "string")
-    throw new Error("Missing listener");
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-  return { api, root, baseUrl, client: createKennelClient({ baseUrl, fetch }) };
-}
-
-test("standalone API serves the shared client without window or Vite", async () => {
-  const { client, root, baseUrl } = await fixture();
-  expect((await client.health()).viewer).toBe("kennel-core");
-  const href = `/?folder=${encodeURIComponent(root)}`;
-  expect((await client.document(href, "note.md")).content).toBe("# Original\n");
-  expect(
-    (await client.documents(href)).documents.some(
-      (item) => item.path === "note.md",
-    ),
-  ).toBe(true);
-  const input = {
-    folder: root,
-    path: "note.md",
-    original: "# Original\n",
-    start: 2,
-    end: 10,
-    replacement: "Updated",
-  };
-  const edit = () =>
-    fetch(`${baseUrl}/api/document/edit`, {
-      method: "POST",
-      headers: { Origin: baseUrl, "Content-Type": "application/json" },
-      body: JSON.stringify(input),
-    });
-  expect((await edit()).status).toBe(200);
-  expect((await edit()).status).toBe(409);
-  expect((await client.document(href, "note.md")).content).toBe("# Updated\n");
-});
-
-test("remote core denies host actions, ACP and global discovery", async () => {
-  const { client, baseUrl, root } = await fixture({ host: "0.0.0.0" });
-  expect(await client.capabilities()).toMatchObject({
-    local: false,
-    acp: false,
-    hostActions: "none",
-  });
-  for (const path of [
-    "open-path",
-    "open-folder",
-    "document/edit",
-    "acp/connect",
-    "project-search",
-    "entities",
-  ]) {
-    expect(
-      (await fetch(`${baseUrl}/api/${path}?path=${encodeURIComponent(root)}`))
-        .status,
-    ).toBe(403);
-  }
-  expect(
-    (
-      await fetch(`${baseUrl}/api/health`, {
-        headers: { Host: "attacker.example" },
-      })
-    ).status,
-  ).toBe(403);
-  expect(
-    (await fetch(`${baseUrl}/api/document?file=../outside.md`)).status,
-  ).toBe(404);
-  await symlink("/etc/passwd", join(root, "escape.md"));
-  expect((await fetch(`${baseUrl}/api/document?file=escape.md`)).status).toBe(
-    404,
-  );
-});
-
-test("single-file core does not list or serve siblings", async () => {
-  const root = await mkdtemp(join(tmpdir(), "kennel-lock-"));
-  cleanup.push(() => rm(root, { recursive: true, force: true }));
-  const lockedFile = join(root, "one.md");
-  await writeFile(lockedFile, "one");
-  await writeFile(join(root, "two.md"), "two");
-  const { client, baseUrl } = await fixture({ root, lockedFile });
-  expect(
-    (await client.documents("/")).documents.map((item) => item.path),
-  ).toEqual(["one.md"]);
-  expect((await fetch(`${baseUrl}/api/document?file=two.md`)).status).toBe(404);
-  const edit = await fetch(`${baseUrl}/api/document/edit`, {
-    method: "POST",
-    headers: { Origin: baseUrl, "Content-Type": "application/json" },
-    body: JSON.stringify({
-      folder: root,
-      path: "two.md",
-      original: "two",
-      start: 0,
-      end: 3,
-      replacement: "changed",
-    }),
-  });
-  expect(edit.status).toBe(403);
-});
-
-test("SSE works outside Vite and closes with the core", async () => {
-  const { api, baseUrl, root } = await fixture({ restrictToRoot: true });
-  const response = await fetch(`${baseUrl}/api/events`);
-  expect(response.headers.get("content-type")).toContain("text/event-stream");
-  const reader = response.body!.getReader();
-  expect(new TextDecoder().decode((await reader.read()).value)).toContain(
-    "connected",
-  );
-  // Wait for the watcher's initial scan, then trigger a known metadata file.
-  await new Promise((done) => setTimeout(done, 200));
-  await writeFile(join(root, "note.md"), "changed");
-  const next = await Promise.race([
-    reader.read(),
-    new Promise<never>((_, fail) =>
-      setTimeout(() => fail(new Error("No change event")), 3000),
-    ),
-  ]);
-  expect(new TextDecoder().decode(next.value)).toContain(
-    "kennel:metadata-changed",
-  );
-  await api.close();
-  await reader.cancel().catch(() => {});
-  await api.close();
-});
-
-test("local mutations reject cross-origin requests and unknown API paths stay 404", async () => {
-  const { baseUrl } = await fixture();
-  for (const path of ["document/edit", "open-folder", "acp/connect"]) {
-    const response = await fetch(`${baseUrl}/api/${path}`, {
-      method: "POST",
-      headers: {
-        Origin: "https://attacker.example",
-        "Content-Type": "application/json",
-      },
-      body: "{}",
-    });
-    expect(response.status).toBe(403);
-  }
-  expect((await fetch(`${baseUrl}/api/missing`)).status).toBe(404);
-});
-
-test("client keeps HTTP errors structured and checks config responses", async () => {
-  const client = createKennelClient({
-    fetch: async () =>
-      new Response(
-        JSON.stringify({ error: { code: "forbidden", message: "Denied" } }),
-        { status: 403, headers: { "Content-Type": "application/json" } },
-      ),
-  });
-  await expect(client.config()).rejects.toMatchObject({
-    code: "forbidden",
-    status: 403,
-    message: "Denied",
-  });
-});
-
-function plugin(id: string): FolderPluginServer {
-  return {
-    id,
-    label: id,
-    detect: async () => ({ status: "unavailable" }),
-    handle: async () => ({ kind: "unavailable" }),
-  };
-}
-
-test("plugin registry config disables and orders only registered plugins", () => {
-  const calendar = plugin("calendar");
-  const tasks = plugin("tasks");
-  const projects = plugin("projects");
-  const registry = new Map([
-    [calendar.id, calendar],
-    [tasks.id, tasks],
-    [projects.id, projects],
-  ]);
-
-  const filtered = configuredFolderServerRegistry(registry, {
-    plugins: {
-      disable: ["tasks", "missing"],
-      order: ["missing", "projects"],
-    },
-  });
-
-  expect([...filtered.keys()]).toEqual(["projects", "calendar"]);
-  expect(filtered.get("tasks")).toBeUndefined();
-  expect(registry.get("tasks")).toBe(tasks);
-});
-
-test("folder kennel.json filters plugin metadata and direct plugin routes", async () => {
-  const { baseUrl, root } = await fixture();
-  await writeFile(join(root, "todo.json"), JSON.stringify({ tasks: [] }));
-  await writeFile(
-    join(root, "kennel.json"),
-    JSON.stringify({
-      plugins: { disable: ["tasks", "ghost"], order: ["projects"] },
-    }),
-  );
-
-  const metadata = await fetch(
-    `${baseUrl}/api/metadata?part=plugins&path=${encodeURIComponent(root)}`,
-  ).then((response) => response.json());
-  expect(
-    metadata.plugins.items.map((item: { id: string }) => item.id),
-  ).not.toContain("tasks");
-  expect(metadata.plugins.configWarnings).toEqual([
-    'unknown plugin id "tasks" — not installed in this build',
-    'unknown plugin id "ghost" — not installed in this build',
-    'unknown plugin id "projects" — not installed in this build',
-  ]);
-
-  const direct = await fetch(
-    `${baseUrl}/api/plugins/tasks?path=${encodeURIComponent(root)}`,
-  );
-  expect(direct.status).toBe(404);
-});
-
-test("nearest malformed kennel.json falls back to default plugins", async () => {
-  const { baseUrl, root } = await fixture();
-  await writeFile(join(root, "todo.json"), JSON.stringify({ tasks: [] }));
-  await writeFile(join(root, "kennel.json"), "{");
-
-  const metadata = await fetch(
-    `${baseUrl}/api/metadata?part=plugins&path=${encodeURIComponent(root)}`,
-  ).then((response) => response.json());
-  expect(metadata.plugins.configWarnings).toEqual([]);
-  expect(
-    metadata.plugins.items.map((item: { id: string }) => item.id),
-  ).not.toContain("tasks");
-});
-
-test("scaffold has no core starter files without external plugins", async () => {
-  const root = await mkdtemp(join(tmpdir(), "kennel-init-"));
-  cleanup.push(() => rm(root, { recursive: true, force: true }));
-
-  const first = await scaffoldFolderPlugins(root);
-  expect(first.created).toEqual([]);
-  expect(first.skipped).toEqual([]);
-  expect(first.supported).toEqual([]);
-
-  const forced = await scaffoldFolderPlugins(root, { force: true });
-  expect(forced.created).toEqual([]);
-  expect(forced.skipped).toEqual([]);
-  expect(forced.supported).toEqual([]);
-});
-
-test("scaffold write:false reports supported files without creating them", async () => {
-  const root = await mkdtemp(join(tmpdir(), "kennel-init-"));
-  cleanup.push(() => rm(root, { recursive: true, force: true }));
-
-  const result = await scaffoldFolderPlugins(root, { write: false });
-  expect(result.created).toEqual([]);
-  expect(result.skipped).toEqual([]);
-  expect(result.supported).toEqual([]);
-});
-
-test("workspace discovery surfaces declared schema core folders with titles", async () => {
-  const root = await realpath(await mkdtemp(join(tmpdir(), "kennel-schemas-")));
-  cleanup.push(() => rm(root, { recursive: true, force: true }));
-  for (const folder of ["startups", "meetups"])
-    await mkdir(join(root, folder));
-  await writeFile(
-    join(root, "raggle.json"),
-    JSON.stringify({
-      schemas: [
-        { path: "startups", schema: "startups/schema.json" },
-        { path: "meetups", schema: "meetups/schema.json" },
-      ],
-    }),
-  );
-  const schema = (title: string) =>
-    JSON.stringify({
-      title,
-      "x-kennel": { icon: "rocket", ui: { primaryField: "title" } },
-    });
-  await writeFile(join(root, "startups/schema.json"), schema("Startups"));
-  await writeFile(join(root, "meetups/schema.json"), schema("Meetups"));
-  await writeFile(join(root, "startups/oumi.md"), "# Oumi\n");
-  await writeFile(join(root, "meetups/open-coffee.md"), "# Open Coffee\n");
-
-  const { baseUrl } = await fixture({ root });
-  const folder = encodeURIComponent(root);
-
-  const discovery = await (
-    await fetch(`${baseUrl}/api/metadata?path=${folder}&part=discovery`)
-  ).json();
-  expect(discovery.workspace.schemas).toMatchObject([
-    {
-      folder: join(root, "startups"),
-      schemaPath: join(root, "startups/schema.json"),
-      title: "Startups",
-    },
-    {
-      folder: join(root, "meetups"),
-      schemaPath: join(root, "meetups/schema.json"),
-      title: "Meetups",
-    },
-  ]);
-  // The root owns the declarations; it is not itself inside a schema folder.
-  expect(discovery.workspace.schemaPath).toBeUndefined();
-
-  const workspace = await (
-    await fetch(`${baseUrl}/api/metadata?path=${folder}&part=workspace`)
-  ).json();
-  expect(workspace.workspace.schemas).toEqual(discovery.workspace.schemas);
-  expect(workspace.workspace.schemaPath).toBeUndefined();
-  const direct = await createCoreFolderIndex().list(root);
-  expect(workspace.workspace.schemas.map((entry: any) => [entry.id, entry.count, entry.revision]))
-    .toEqual(direct.collections.map((entry) => [entry.id, entry.count, entry.revision]));
-  expect(workspace.workspace.schemas[0].records).toBeUndefined();
-  const readCollection = async (id = "startups") => {
-    const response = await fetch(`${baseUrl}/api/metadata?path=${folder}&part=collections&id=${encodeURIComponent(id)}`);
-    return { status: response.status, body: await response.json() };
-  };
-  const first = await readCollection();
-  expect(first.status).toBe(200);
-  expect(first.body.collection.records[0].title).toBe("Oumi");
-  expect((await readCollection("../outside")).status).toBe(404);
-  // The real host watcher must invalidate the cache, not merely a new index instance.
-  await writeFile(join(root, "startups/oumi.md"), "---\ntitle: Renamed Oumi\n---\n");
-  const deadline = Date.now() + 5000;
-  let latest = first;
-  while (Date.now() < deadline) {
-    latest = await readCollection();
-    if (latest.body.collection.records[0].title === "Renamed Oumi") break;
-    await new Promise((done) => setTimeout(done, 25));
-  }
-  expect(latest.body.collection.records[0].title).toBe("Renamed Oumi");
-  expect(latest.body.collection.revision).not.toBe(first.body.collection.revision);
-});