@yaklabs-ai/plugin-sdk 0.12.4 → 0.13.0

package/dist/kay-app.d.ts

@@ -2729,6 +2729,13 @@ export declare interface KayAppPluginApi {
      * which blocks the daemon; see {@link KayAppRepos}.
      */
     readonly repos: KayAppRepos;
+    /**
+     * File I/O in user folders (stat, read, list, walk, realpath, write, mkdir, rename), run by the
+     * host on its own worker threads under a deadline and answered as a typed result. Always present
+     * and ungated, like {@link paths}. Use it instead of `node:fs`, whose sync calls block the
+     * daemon; see {@link KayAppUserFiles}.
+     */
+    readonly userFiles: KayAppUserFiles;
     /**
      * Read/arrange access to the live desktop workspace. Present whenever the host has a workspace
      * (a headless daemon may not); absence is a host fact, never a grant signal. Reading the snapshot
@@ -4224,6 +4231,135 @@ export declare interface KayAppUiActionSessionEvent extends KayAppSessionEventBa
     readonly toolCallId: string;
 }
 
+export declare interface KayAppUserFileEntry {
+    readonly name: string;
+    /** From the directory entry itself: a symlink is reported as `symlink`, never followed. */
+    readonly kind: KayAppUserFileKind;
+}
+
+/**
+ * The plugin-facing user-files contract: file I/O in folders the user owns, done by the host on
+ * its own worker threads.
+ *
+ * Ungated and always present, like `app.paths`. It confers no authority: a plugin runs in the
+ * daemon's process and can call `node:fs` itself. What the door adds is where the work runs. A
+ * `node:fs` sync call blocks the daemon's event loop for as long as the path takes to answer,
+ * which under a macOS-protected folder or on a drive that stopped answering can be a very long
+ * time (kay#11575); an async one holds a thread of the pool the whole daemon shares. The host runs
+ * each request on a dedicated worker, gives it a deadline, and answers a typed result instead of
+ * throwing.
+ *
+ * This is a leaf module. It lives beside both target SDKs, like `time.ts`, so the `kay.agent` SDK
+ * exposes the same door without importing the `kay.app` surface.
+ */
+export declare type KayAppUserFileKind = "file" | "directory" | "symlink" | "other";
+
+export declare interface KayAppUserFileListing {
+    readonly entries: readonly KayAppUserFileEntry[];
+    /** True when the directory had more entries than `maxEntries`; the rest were not read. */
+    readonly entryLimitReached: boolean;
+}
+
+/**
+ * File I/O in user folders, run by the host off the daemon's main thread. Every path is absolute.
+ * No method rejects; each answers a {@link KayAppUserFilesResult}. This is not a sandbox: it does
+ * not limit which paths a plugin may touch. Added in SDK 0.12.5: a plugin that calls it declares
+ * `compatibility.sdk` `^0.12.5`, so an older Bonsai refuses a directory or repository plugin at
+ * load instead of the call failing.
+ */
+export declare interface KayAppUserFiles {
+    /** Follows symlinks. */
+    stat(path: string, options?: KayAppUserFilesCallOptions): Promise<KayAppUserFilesResult<KayAppUserFileStat>>;
+    /** UTF-8. */
+    readText(path: string, options?: KayAppUserFilesReadTextOptions): Promise<KayAppUserFilesResult<string>>;
+    list(path: string, options?: KayAppUserFilesListOptions): Promise<KayAppUserFilesResult<KayAppUserFileListing>>;
+    /** Depth-first below `path`; symlinks are reported, never followed. */
+    walk(path: string, options?: KayAppUserFilesWalkOptions): Promise<KayAppUserFilesResult<KayAppUserFileWalk>>;
+    /** The path with every symlink resolved. */
+    realpath(path: string, options?: KayAppUserFilesCallOptions): Promise<KayAppUserFilesResult<string>>;
+    /**
+     * Creates or replaces a UTF-8 file, not atomically. After `timeout` or `aborted` the write may
+     * still happen.
+     */
+    writeText(path: string, content: string, options?: KayAppUserFilesCallOptions): Promise<KayAppUserFilesResult<null>>;
+    /** Creates the directory and any missing parents; succeeds when it already exists. */
+    mkdir(path: string, options?: KayAppUserFilesCallOptions): Promise<KayAppUserFilesResult<null>>;
+    rename(from: string, to: string, options?: KayAppUserFilesCallOptions): Promise<KayAppUserFilesResult<null>>;
+}
+
+export declare interface KayAppUserFilesCallOptions {
+    /** Deadline in milliseconds from the call, waiting included. Default 5000, at most 60000. */
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+
+export declare interface KayAppUserFilesListOptions extends KayAppUserFilesCallOptions {
+    /** Default 5000, at most 50000. */
+    readonly maxEntries?: number;
+}
+
+export declare interface KayAppUserFilesReadTextOptions extends KayAppUserFilesCallOptions {
+    /** A larger file answers `error` with code `EFBIG`. Default 8 MiB, at most 64 MiB. */
+    readonly maxBytes?: number;
+}
+
+/**
+ * Every answer. `missing`: nothing exists at the path (ENOENT). `timeout`: no answer from the path
+ * in time. Its `reason` is `deadline` (this request ran out of time), `cooling-down` (a request at
+ * or above this path timed out recently, so the host did not try) or `saturated` (the host's
+ * workers are stuck on other paths, so it did not try). `aborted`: the caller's signal fired.
+ * `error`: anything else, with the Node error `code` when there is one (`EACCES`, `EISDIR`,
+ * `EFBIG` for a file over `maxBytes`, `EINVAL` for a relative path).
+ */
+export declare type KayAppUserFilesResult<T> = {
+    readonly kind: "ok";
+    readonly value: T;
+} | {
+    readonly kind: "missing";
+} | {
+    readonly kind: "timeout";
+    readonly reason: "deadline" | "cooling-down" | "saturated";
+    readonly detail: string;
+} | {
+    readonly kind: "aborted";
+} | {
+    readonly kind: "error";
+    readonly code?: string;
+    readonly detail: string;
+};
+
+export declare interface KayAppUserFileStat {
+    /** What the path is after following symlinks; never `symlink`. */
+    readonly kind: "file" | "directory" | "other";
+    /** Bytes. */
+    readonly size: number;
+    /** Milliseconds since the Unix epoch. */
+    readonly modifiedAtMs: number;
+}
+
+export declare interface KayAppUserFilesWalkOptions extends KayAppUserFilesCallOptions {
+    /** Default 10000, at most 100000. */
+    readonly maxEntries?: number;
+    /** Deepest level reported; the root's children are depth 1. Default 16, at most 64. */
+    readonly maxDepth?: number;
+    /** Report and descend into dot-prefixed entries. Default true. */
+    readonly includeHidden?: boolean;
+}
+
+export declare interface KayAppUserFileWalk {
+    readonly entries: readonly KayAppUserFileWalkEntry[];
+    /** True when the walk stopped at `maxEntries`. */
+    readonly entryLimitReached: boolean;
+    /** True when a directory at `maxDepth` was reported but not descended into. */
+    readonly depthLimitReached: boolean;
+}
+
+export declare interface KayAppUserFileWalkEntry {
+    /** Path segments below the walk's root. */
+    readonly segments: readonly string[];
+    readonly kind: KayAppUserFileKind;
+}
+
 export declare interface KayAppWhiteboard {
     /**
      * Binds read-only Whiteboard access to the exact context issued to this plugin's session source.
@@ -6360,8 +6496,6 @@ export declare interface UriModule {
     readonly permissionDefaults?: UriPermissionDefaults;
     /** Requires a resolved URI connection before any verb handler runs. */
     readonly requiresConnection?: boolean;
-    /** Host-only marker: dispatch mutations as native file operations after locate finalization. */
-    readonly hostNativeFileMutations?: true;
     /**
      * This module refuses a whole-content overwrite of an address the dispatching
      * session has never read or written, when content is already stored there
@@ -6373,7 +6507,7 @@ export declare interface UriModule {
      * A module without the flag never receives the marked dispatch and behaves
      * exactly as before. Enforcement depth past this floor — refusing a write to
      * content that CHANGED since the read — stays the module's own call:
-     * `builtin:local-file` and host-native projections enforce both halves; the
+     * `builtin:local-file` enforces both halves; the
      * artifact factory enforces the floor and leaves change detection to its
      * `edit` anchor. A module declaring this flag obligates itself to one more
      * thing: every revision its mutations report must be a value its own reads

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaklabs-ai/plugin-sdk",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "description": "The Kay plugin SDK — types and helpers for authoring a Kay directory plugin.",
   "author": "YakLabs",
   "type": "module",
@@ -17,6 +17,10 @@
       "types": "./dist/kay-app.d.ts",
       "default": "./dist/kay-app.js"
     },
+    "./fs": {
+      "types": "./dist/fs.d.ts",
+      "default": "./dist/fs.js"
+    },
     "./kay-agent/testing": {
       "types": "./dist/kay-agent-testing.d.ts",
       "default": "./dist/kay-agent-testing.js"