kennel 0.2.12 → 0.2.15

package/kernel/packages/notes/src/ui/ai-composer-controls.tsx

@@ -1,70 +0,0 @@
-import { Plus } from "lucide-react"
-
-import { Button } from "@raggle-ai/ui/components/button"
-
-import type { AiInputAdapter } from "../data/ai-input.ts"
-
-type AiComposerControlsProps = {
-  adapter: AiInputAdapter
-  open: boolean
-  onOpenChange: (open: boolean) => void
-}
-
-function toggleComposer(open: boolean, onOpenChange: (open: boolean) => void) {
-  return () => onOpenChange(!open)
-}
-
-/** Desktop action supplied to the shared folder notes list. */
-export function AiComposerAction({
-  open,
-  onOpenChange,
-}: Omit<AiComposerControlsProps, "adapter">) {
-  const label = open ? "Hide bark input" : "Open bark input"
-  return (
-    <Button
-      aria-controls="bark-composer"
-      aria-expanded={open}
-      aria-label={label}
-      onClick={toggleComposer(open, onOpenChange)}
-      title={label}
-      type="button"
-      variant="outline"
-    >
-      <Plus aria-hidden="true" className="size-4" />
-    </Button>
-  )
-}
-
-/** Mobile toggle and host for the configured folder AI composer. */
-export function AiComposerControls({
-  adapter,
-  open,
-  onOpenChange,
-}: AiComposerControlsProps) {
-  const label = open ? "Hide bark input" : "Open bark input"
-  return (
-    <>
-      <Button
-        aria-controls="bark-composer"
-        aria-expanded={open}
-        aria-label={label}
-        className="mobile-bark-toggle"
-        onClick={toggleComposer(open, onOpenChange)}
-        title={label}
-        type="button"
-        variant="outline"
-      >
-        <Plus aria-hidden="true" />
-      </Button>
-      {open ? (
-        <section
-          aria-label="AI composer"
-          className="ai-input-host"
-          id="bark-composer"
-        >
-          <adapter.Composer />
-        </section>
-      ) : null}
-    </>
-  )
-}

package/kernel/packages/notes/src/ui/folder-notes-list.tsx

@@ -1,76 +0,0 @@
-import type { ReactNode } from "react"
-
-import type { FolderFile } from "@raggle-ai/ui/lib/folder-activity"
-import { NoteCard } from "@raggle-ai/ui/components/note-card"
-
-/**
- * Note rows for the main Notes tab, backed by the shared NoteCard so linked
- * notes render the same way everywhere.
- */
-export function FolderNotesList({
-  action,
-  documentHref,
-  error,
-  files = [],
-  filter,
-  folder,
-  folderHref,
-  loading,
-}: {
-  action?: ReactNode
-  documentHref: (file: FolderFile) => string
-  error: string
-  files?: FolderFile[]
-  filter?: ReactNode
-  folder?: string
-  folderHref: (folder: string) => string
-  loading: boolean
-}) {
-  const visible = [...files].sort(
-    (left, right) =>
-      right.activityAt - left.activityAt ||
-      `${left.folder ?? ""}/${left.relativePath}`.localeCompare(
-        `${right.folder ?? ""}/${right.relativePath}`,
-      ),
-  )
-
-  return (
-    <div className="mx-auto grid w-full max-w-3xl gap-4 px-4 py-5">
-      <div className="flex flex-wrap items-center justify-between gap-3">
-        <h1 className="m-0 text-2xl font-semibold text-[#233025]">Notes</h1>
-        {action}
-      </div>
-      {filter}
-      {loading ? <p className="m-0 text-sm text-[#6c7a6d]">Loading…</p> : null}
-      {error ? <p className="m-0 text-sm text-[#9c3a3a]">{error}</p> : null}
-      {!loading && !error && !visible.length ? (
-        <p className="m-0 text-sm text-[#6c7a6d]">
-          {files.length ? "No notes match this filter." : "No notes found."}
-        </p>
-      ) : null}
-      {visible.length ? (
-        <ol className="m-0 grid list-none gap-2 p-0">
-          {visible.map((file) => (
-            <li key={`${file.folder ?? ""}:${file.relativePath}`}>
-              <NoteCard
-                activityAt={file.activityAt}
-                context={
-                  file.folder
-                    ? `${file.folder.replace(/[\\/]+$/, "")}/${file.relativePath}`
-                    : folder
-                      ? `${folder.replace(/[\\/]+$/, "")}/${file.relativePath}`
-                      : file.relativePath
-                }
-                folderHref={file.folder ? folderHref(file.folder) : undefined}
-                href={documentHref(file)}
-                linkedFolder={file.folder}
-                path={file.relativePath}
-                title={file.name}
-              />
-            </li>
-          ))}
-        </ol>
-      ) : null}
-    </div>
-  )
-}

package/kernel/packages/notes/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@raggle-ai/tsconfig/base.json",
-  "compilerOptions": {
-    "target": "ES2022",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "jsx": "preserve",
-    "baseUrl": ".",
-    "allowImportingTsExtensions": true,
-    "paths": {
-      "~/*": ["${configDir}/../../packages/*/src"]
-    }
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "eslint.config.mjs"]
-}

package/kernel/packages/plugins/SKILL.md

@@ -1,39 +0,0 @@
----
-name: kennel-plugins
-description: Install, register, or build a trusted Kennel folder plugin. Use for `knl plugin add`, external plugin kernels, plugin tabs, or deciding where plugin code belongs.
----
-
-# Kennel Plugin Management
-
-## Ownership
-
-Keep each concern in its owner:
-
-| Concern                                                     | Location                               |
-| ----------------------------------------------------------- | -------------------------------------- |
-| Plugin contract and public client/server types              | `packages/plugins` (`kennel-plugins`)  |
-| Generic reusable viewer UI                                  | `packages/ui`                          |
-| Folder metadata API and server registry                     | `packages/api`                         |
-| Browser route and static external-plugin registry           | `apps/web`                             |
-| Install, pin, cache, validate, and compose external plugins | `cli/src/plugins/external.ts`          |
-| Built-in Agents and Notes feature code                      | `packages/agents` and `packages/notes` |
-| External plugin feature code                                | Its own repository                     |
-
-Keep new plugin feature code in its own repository. Add to `packages/plugins` only when every plugin needs a contract change. Add to `packages/ui` only when every viewer can use the UI component.
-
-## External plugin install
-
-1. Inspect the plugin `package.json`, `src/manifest.ts`, `src/client.tsx`, and `src/server.ts`.
-2. Require `package.json > kennel.plugin` with a unique non-core `id`. The conventional `./manifest`, `./client`, `./server`, and optional `./api` entries must default-export their values. Add `trigger` only when a file can make an otherwise unavailable plugin visible.
-3. Keep the manifest id and package id equal. The client and server must spread or otherwise return that manifest id.
-4. Ensure the repository TypeScript config works outside the Kennel workspace. Do not require unpublished workspace config files during kernel bundling.
-5. Install with `knl plugin add <git-url>`. It pins the resolved commit, validates exports, stores source in `~/.cache/kennel/plugins/sources/`, records the plugin in `~/.config/kennel/config.json`, and composes a static kernel in `~/.cache/kennel/kernels/`.
-6. Use `knl view <folder>` after installation. External plugins require the composed static viewer; a plain Vite hot viewer cannot show their tabs.
-
-## Change workflow
-
-- Start with the smallest plugin repository change. Do not copy plugin feature code into Kennel.
-- Change `packages/plugins`, `packages/api`, `apps/web`, and `cli` only when the plugin contract or trusted-kernel behavior needs it.
-- Keep plugin ids stable. Do not use core ids: `agents`, `calendar`, `mail`, `notes`, `projects`, or `tasks`.
-- Verify a real install in an isolated `XDG_CONFIG_HOME` and `XDG_CACHE_HOME` first. Then verify the tab and its selected route in the composed viewer.
-- A CLI behavior change requires a new `cli/package.json` version. The publish workflow releases it after merge to `main`.

package/kernel/packages/plugins/eslint.config.js

@@ -1,10 +0,0 @@
-import baseConfig from "@raggle-ai/eslint-config/base"
-import reactConfig from "@raggle-ai/eslint-config/react"
-
-export default [
-  ...baseConfig,
-  ...reactConfig,
-  {
-    ignores: ["dist/**", "**/_generated/", "vendor/**"],
-  },
-]

package/kernel/packages/plugins/package.json

@@ -1,104 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "name": "kennel-plugins",
-  "version": "0.1.3",
-  "description": "Small shared contract for trusted folder view plugins in the Kennel web viewer.",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/raggle-ai/kennel.git",
-    "directory": "packages/plugins"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ],
-  "sideEffects": false,
-  "prettier": "@raggle-ai/prettier-config",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./client": {
-      "types": "./dist/client.d.ts",
-      "import": "./dist/client.js"
-    },
-    "./endpoint": {
-      "types": "./dist/endpoint.d.ts",
-      "import": "./dist/endpoint.js"
-    },
-    "./page": {
-      "types": "./dist/page.d.ts",
-      "import": "./dist/page.js"
-    },
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js"
-    },
-    "./subpath": {
-      "types": "./dist/subpath.d.ts",
-      "import": "./dist/subpath.js"
-    },
-    "./types": {
-      "types": "./dist/types.d.ts",
-      "import": "./dist/types.js"
-    },
-    "./validation": {
-      "types": "./dist/validation.d.ts",
-      "import": "./dist/validation.js"
-    }
-  },
-  "scripts": {
-    "build": "tsup",
-    "prepack": "bun run build",
-    "test": "bun test test/*.test.mjs",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier . --check --cache --cache-location .cache/.prettiercache --ignore-path ../../.prettierignore",
-    "format:fix": "prettier . --write --cache --cache-location .cache/.prettiercache --ignore-path ../../.prettierignore",
-    "lint": "eslint . --cache --cache-location .cache/.eslintcache",
-    "lint:fix": "eslint . --fix --cache --cache-location .cache/.eslintcache",
-    "clean": "git clean -xdf dist node_modules .cache .turbo/cache"
-  },
-  "dependencies": {
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "cmdk": "^1.1.1",
-    "lucide-react": "^0.562.0",
-    "next-themes": "^0.4.6",
-    "radix-ui": "^1.6.7",
-    "sonner": "^2.0.7",
-    "tailwind-merge": "^3.4.0"
-  },
-  "peerDependencies": {
-    "react": ">=18.3.0",
-    "react-dom": ">=18.3.0"
-  },
-  "devDependencies": {
-    "@eslint/compat": "catalog:eslint",
-    "@eslint/eslintrc": "catalog:eslint",
-    "@ianvs/prettier-plugin-sort-imports": "catalog:prettier",
-    "@prettier/plugin-oxc": "catalog:prettier",
-    "@raggle-ai/eslint-config": "workspace:*",
-    "@raggle-ai/prettier-config": "workspace:*",
-    "@raggle-ai/tsconfig": "workspace:*",
-    "@raggle-ai/ui": "workspace:*",
-    "kennel-client": "workspace:*",
-    "@types/node": "catalog:",
-    "@types/react": "catalog:react19",
-    "eslint": "catalog:eslint",
-    "eslint-plugin-unused-imports": "catalog:eslint",
-    "prettier": "catalog:prettier",
-    "prettier-plugin-classnames": "catalog:prettier",
-    "prettier-plugin-merge": "catalog:prettier",
-    "prettier-plugin-tailwindcss": "catalog:prettier",
-    "react": "catalog:react19",
-    "tsup": "8.5.1",
-    "typescript": "catalog:",
-    "typescript-eslint": "catalog:eslint"
-  }
-}

package/kernel/packages/plugins/src/client.ts

@@ -1,73 +0,0 @@
-import type { ComponentType } from "react"
-
-import type { FolderPluginManifest } from "./types.ts"
-
-/**
- * Host actions a plugin view may call while rendering. These are injected by
- * the host (never imported by the plugin) and are absent when the server does
- * not provide them — e.g. a phone on `--lan` must never see server-side
- * "open in default app" actions. Plugins gate UI on presence, not on path
- * heuristics.
- */
-export type FolderPluginHostActions = {
-  /** Open a physical file in the host's default app (local hosts only). */
-  openPath: (path: string) => Promise<void>
-  /**
-   * Create an empty AGENTS.md in a folder and open it in the default
-   * Markdown app (local hosts only). Resolves with the created file path.
-   */
-  createAgentFile: (folder: string) => Promise<{ path: string }>
-}
-
-/**
- * Context the host injects into a plugin's client view. The host owns folder
- * resolution, navigation/link helpers, and a scoped request function. Plugins
- * never import `apps/web` helpers or alter the shell directly.
- */
-export type FolderPluginViewProps = {
-  /** Absolute folder path shown by the host. */
-  folder: string
-  /** Folder route id used as the shared query-key prefix for cache invalidation. */
-  folderId: string
-  /** Plugin-relative subpath: `""` for the list view, an id for a detail view. */
-  subpath: string
-  /** Absolute href to this plugin's list view, for back navigation. */
-  listHref: string
-  /** Absolute href to folder home (Notes), for shell back navigation. */
-  homeHref: string
-  /** Builds an absolute href for any plugin-relative subpath. */
-  href: (subpath: string) => string
-  /**
-   * Builds an absolute href for a document inside a folder, for hosts that
-   * serve documents. Undefined on hosts without a document route; content
-   * that references documents then renders as plain labels instead of links.
-   */
-  documentHref?: (folder: string, relativePath: string) => string | undefined
-  /**
-   * Fetches plugin data for an authorized folder and plugin-relative subpath.
-   * Resolves to the decoded JSON payload (throwing on an error response).
-   */
-  request: (subpath: string, init?: RequestInit) => Promise<unknown>
-  /**
-   * Host actions available to this view, when the server provides them (see
-   * `FolderPluginHostActions`). Undefined on remote/unavailable hosts.
-   */
-  hostActions?: FolderPluginHostActions
-}
-
-/** Browser-side entry for a trusted folder plugin. */
-export { isPluginPayloadError } from "./types.ts"
-/** Stable UTF-8 folder id shared by host routes and plugin query keys. */
-export function folderPathId(path: string) {
-  const bytes = new TextEncoder().encode(path)
-  let binary = ""
-  for (const byte of bytes) binary += String.fromCharCode(byte)
-  return btoa(binary)
-    .replaceAll("+", "-")
-    .replaceAll("/", "_")
-    .replaceAll("=", "")
-}
-
-export type FolderPluginClient = FolderPluginManifest & {
-  component: ComponentType<FolderPluginViewProps>
-}

package/kernel/packages/plugins/src/endpoint.ts

@@ -1,273 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http"
-
-export type ApiErrorCode =
-  | "aborted"
-  | "bad-request"
-  | "conflict"
-  | "failed"
-  | "forbidden"
-  | "internal"
-  | "method-not-allowed"
-  | "not-found"
-  | "payload-too-large"
-  | "timeout"
-
-const statusByCode: Record<ApiErrorCode, number> = {
-  aborted: 400,
-  "bad-request": 400,
-  conflict: 409,
-  failed: 500,
-  forbidden: 403,
-  internal: 500,
-  "method-not-allowed": 405,
-  "not-found": 404,
-  "payload-too-large": 413,
-  timeout: 504,
-}
-
-export class ApiError extends Error {
-  readonly code: ApiErrorCode
-  readonly status: number
-
-  constructor(code: ApiErrorCode, message: string) {
-    super(message)
-    this.name = "ApiError"
-    this.code = code
-    this.status = statusByCode[code]
-  }
-}
-
-export function apiError(code: ApiErrorCode, message: string) {
-  return new ApiError(code, message)
-}
-
-export function jsonResponse(
-  response: ServerResponse,
-  status: number,
-  body: unknown,
-  extraHeaders: Record<string, string> = {},
-) {
-  // Guard against double emission: a handler that already finished the
-  // response (or a client that disconnected after completion) must never
-  // trigger a `writeHead after end` crash.
-  if (response.writableEnded || response.headersSent || response.destroyed) {
-    return
-  }
-  response.writeHead(status, {
-    "Cache-Control": "no-store",
-    "Content-Type": "application/json; charset=utf-8",
-    ...extraHeaders,
-  })
-  response.end(JSON.stringify(body))
-}
-
-export function jsonError(
-  response: ServerResponse,
-  status: number,
-  code: ApiErrorCode,
-  message: string,
-  extraHeaders: Record<string, string> = {},
-) {
-  jsonResponse(response, status, { error: { code, message } }, extraHeaders)
-}
-
-/**
- * Same-origin guard for mutating requests (POST/DELETE). A browser sends
- * `Origin` (or `Referer`) on cross-site requests; require the header, when
- * present, to match the requested host and reject mutations without any
- * origin signal. GET requests never mutate and are exempt.
- */
-export function sameOrigin(request: IncomingMessage): boolean {
-  const host = request.headers.host
-  if (!host) return false
-
-  const origin = request.headers.origin
-  if (origin) {
-    try {
-      return new URL(origin).host === host
-    } catch {
-      return false
-    }
-  }
-
-  const referer = request.headers.referer
-  if (referer) {
-    try {
-      return new URL(referer).host === host
-    } catch {
-      return false
-    }
-  }
-
-  return false
-}
-
-/**
- * Read a request body bounded to `maxBytes` bytes. Real Node requests are
- * async-iterable; the caller must set `Content-Length` expectations too. An
- * oversized body or a cancellation aborts with a structured ApiError.
- */
-export async function readBoundedBody(
-  request: IncomingMessage,
-  maxBytes: number,
-  signal: AbortSignal,
-): Promise<string> {
-  const iterable = request as IncomingMessage & {
-    [Symbol.asyncIterator]?: () => AsyncIterableIterator<Buffer>
-  }
-  if (typeof iterable[Symbol.asyncIterator] !== "function") return ""
-
-  let total = 0
-  const chunks: Buffer[] = []
-  for await (const chunk of iterable) {
-    if (signal.aborted) throw apiError("aborted", "Request aborted")
-    total += chunk.length
-    if (total > maxBytes) {
-      throw apiError("payload-too-large", "Request body too large")
-    }
-    chunks.push(chunk)
-  }
-  return Buffer.concat(chunks).toString("utf8")
-}
-
-/**
- * JSON body helper for mutations. Returns the parsed object or throws a
- * structured bad-request error; non-Object payloads are rejected.
- */
-export function parseJsonBody(body: string): Record<string, unknown> {
-  if (!body.trim()) throw apiError("bad-request", "Request body required")
-  let value: unknown
-  try {
-    value = JSON.parse(body)
-  } catch {
-    throw apiError("bad-request", "Request body is not valid JSON")
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw apiError("bad-request", "Request body must be a JSON object")
-  }
-  return value as Record<string, unknown>
-}
-
-export type ApiRouteHandle<Context> = (ctx: {
-  body: string
-  context: Context
-  query: URLSearchParams
-  request: IncomingMessage
-  response: ServerResponse
-  signal: AbortSignal
-  url: URL
-}) => Promise<void> | void
-
-export type ApiRouteSpec<Context> = {
-  /** Only this HTTP method is accepted; anything else gets a 405. */
-  method: "GET" | "POST" | "DELETE"
-  /** Bounded request body in bytes; mutations without a body may set 0. */
-  maxBodyBytes?: number
-  /** Hard cap on handler execution; the child/request is cancelled after. */
-  timeoutMs?: number
-  /**
-   * Height of `ctx.body` before validation. Sizes over `maxBodyBytes` are
-   * rejected as 413, non-mutating methods never read a body.
-   */
-  handle: ApiRouteHandle<Context>
-}
-
-const methodAllowHeader = (method: string) => ({ Allow: method })
-
-/**
- * Run one declarative API route. Handles explicit method restriction,
- * same-origin protection for mutations, bounded bodies, abort on client
- * disconnect, timeouts, and structured JSON errors. Handlers never see raw
- * internals; unexpected errors become a generic 500 that cannot leak
- * command output or credentials.
- */
-export async function runApiRoute<Context>(
-  request: IncomingMessage,
-  response: ServerResponse,
-  url: URL,
-  spec: ApiRouteSpec<Context>,
-  context: Context,
-): Promise<void> {
-  const method = (request.method ?? "GET").toUpperCase()
-  if (method !== spec.method) {
-    jsonError(
-      response,
-      405,
-      "method-not-allowed",
-      `Method ${method} not allowed`,
-      methodAllowHeader(spec.method),
-    )
-    return
-  }
-
-  const controller = new AbortController()
-  const disconnect = () => controller.abort()
-  request.on?.("aborted", disconnect)
-  response.on?.("close", disconnect)
-
-  let timer: ReturnType<typeof setTimeout> | undefined
-  const timeoutPromise = spec.timeoutMs
-    ? new Promise<never>((_resolve, reject) => {
-        timer = setTimeout(() => {
-          // Cancel the child first (signal-aware handlers die immediately),
-          // then surface the timeout through the race below.
-          controller.abort()
-          reject(apiError("timeout", "Request timed out"))
-        }, spec.timeoutMs)
-      })
-    : null
-
-  try {
-    if (method !== "GET" && !sameOrigin(request)) {
-      throw apiError("forbidden", "Cross-origin mutations are not allowed")
-    }
-    const maxBody = spec.maxBodyBytes ?? (method === "GET" ? 0 : 1024 * 1024)
-    const body =
-      method === "GET"
-        ? ""
-        : await readBoundedBody(request, maxBody, controller.signal)
-    const ctx = {
-      body,
-      context,
-      query: url.searchParams,
-      request,
-      response,
-      signal: controller.signal,
-      url,
-    }
-    // The handler is raced against the deadline so an unresponsive handler
-    // cannot hang the server. Its own failures are collected and rethrown
-    // after the race (a late failure after a timeout is dropped silently).
-    let handlerError: unknown
-    const handlerPromise = (async () => {
-      await spec.handle(ctx)
-    })().catch((error: unknown) => {
-      handlerError = error
-    })
-    if (timeoutPromise) await Promise.race([handlerPromise, timeoutPromise])
-    else await handlerPromise
-    if (handlerError !== undefined) throw handlerError
-  } catch (error) {
-    if (error instanceof ApiError && error.code === "timeout") {
-      jsonError(response, 504, "timeout", error.message)
-      return
-    }
-    if (controller.signal.aborted) {
-      // Client is gone; nothing useful left to write.
-      return
-    }
-    if (error instanceof ApiError) {
-      jsonError(response, error.status, error.code, error.message)
-      return
-    }
-    if (error instanceof Error && error.name === "AbortError") {
-      jsonError(response, 400, "aborted", "Request aborted")
-      return
-    }
-    jsonError(response, 500, "internal", "Internal server error")
-  } finally {
-    if (timer) clearTimeout(timer)
-    request.removeListener?.("aborted", disconnect)
-    response.removeListener?.("close", disconnect)
-  }
-}