@nikcli-ai/plugin 1.196.0 → 1.225.0

package/dist/index.d.ts

@@ -195,6 +195,26 @@ export interface Hooks {
     }, output: {
         env: Record<string, string>;
     }) => Promise<void>;
+    /**
+     * Modify a shell invocation before it is created.
+     *
+     * Runs before the permission check, and the permission check is performed against the *final*
+     * values written here — so a hook that rewrites the command cannot smuggle past an approval
+     * granted for the original one.
+     *
+     * `output.shell` is the shell binary to run the command with; leaving it `undefined` keeps
+     * nikcli's own shell selection. `output.env` is merged over the inherited process environment.
+     */
+    "shell.create.before"?: (input: {
+        sessionID: string;
+        command: string;
+    }, output: {
+        command: string;
+        cwd: string;
+        timeout: number;
+        shell?: string;
+        env: Record<string, string>;
+    }) => Promise<void>;
     "command.execute.before"?: (input: {
         command: string;
         sessionID: string;

package/dist/tool.d.ts

@@ -57,7 +57,7 @@ export declare function tool<Args extends z.ZodRawShape>(input: {
     execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<ToolResult>;
 };
 export declare namespace tool {
-    var schema: typeof z;
+    export { z as schema };
 }
 export type ToolDefinition = ReturnType<typeof tool>;
 export {};

package/dist/tui.d.ts

@@ -1,6 +1,7 @@
 import type { NikcliClient, Event, LspStatus, McpStatus, Todo, Message, Part, Provider, PermissionRequest, QuestionRequest, SessionStatus, Workspace, Config as SdkConfig } from "@nikcli-ai/sdk/v2";
 import type { CliRenderer, ParsedKey, RGBA } from "@opentui/core";
 import type { JSX, SolidPlugin } from "@opentui/solid";
+import type { Store } from "solid-js/store";
 import type { Config as PluginConfig, PluginOptions } from "./index.js";
 import type { Data as TuiV2Data } from "./v2/tui/context.js";
 export type { CliRenderer, SlotMode } from "@opentui/core";
@@ -85,15 +86,45 @@ export type TuiKeybindSet = {
     print: (name: string) => string;
 };
 export type TuiDialogProps = {
-    size?: "medium" | "large" | "xlarge";
+    size?: "medium" | "large" | "xlarge" | "full";
     onClose: () => void;
     children?: JSX.Element;
 };
+/** One open session tab, as reported to plugins. */
+export type TuiTab = {
+    sessionID: string;
+    title: string;
+    /** The tab currently shown. */
+    active: boolean;
+    /** A turn is running in this tab. */
+    busy: boolean;
+    /** Blocked on the user: a permission request or a question is waiting. */
+    attention: boolean;
+    /** Finished work this tab has not been looked at since. */
+    unread: boolean;
+};
+/**
+ * Observe and control the session tab strip.
+ *
+ * Tabs are otherwise internal to the TUI: a plugin could render into slots and navigate routes but
+ * had no way to know which sessions are open, which one is focused, or to open and close them.
+ */
+export type TuiTabsApi = {
+    /** Whether the tab strip is available in this TUI. */
+    enabled: () => boolean;
+    list: () => ReadonlyArray<TuiTab>;
+    /** Open a tab for any session, or focus it when already open. */
+    open: (sessionID: string) => void;
+    /** Focus an already-open tab. Returns false when that session has no tab. */
+    focus: (sessionID: string) => boolean;
+    /** Close a tab. Returns false when that session has no tab. */
+    close: (sessionID: string) => boolean;
+};
 export type TuiDialogStack = {
     replace: (render: () => JSX.Element, onClose?: () => void) => void;
     clear: () => void;
-    setSize: (size: "medium" | "large" | "xlarge") => void;
-    readonly size: "medium" | "large" | "xlarge";
+    setSize: (size: "medium" | "large" | "xlarge" | "full") => void;
+    readonly size: "medium" | "large" | "xlarge" | "full";
     readonly depth: number;
     readonly open: boolean;
 };
@@ -213,6 +244,31 @@ export type TuiKV = {
     set: (key: string, value: unknown) => void;
     readonly ready: boolean;
 };
+export type TuiMemoryEntry<Value extends object> = readonly [Store<Value>, (mutation: (draft: Value) => void) => void];
+export type TuiStoreEntry<Value extends object> = readonly [
+    Store<Value>,
+    (mutation: (draft: Value) => void) => Promise<void>
+];
+export type TuiStorage = {
+    /**
+     * Durable JSON state, namespaced per plugin: persisted to disk, survives hot
+     * reloads and TUI restarts, and stays in sync across running TUI instances.
+     * Values must be JSON-serializable; updates resolve once written.
+     */
+    store: <Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }) => TuiStoreEntry<Value>;
+    /**
+     * Ephemeral in-process state, keyed per plugin. Entries live above the plugin
+     * lifecycle, so a hot reload hands the same live store to the new generation
+     * and in-memory state survives editing the plugin source. Updates are
+     * synchronous, values need not be JSON-serializable, and everything is gone
+     * when the TUI exits. Use `api.kv` for state that must outlive the process.
+     */
+    memory: <Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }) => TuiMemoryEntry<Value>;
+};
 export type TuiState = {
     readonly ready: boolean;
     readonly config: SdkConfig;
@@ -283,6 +339,20 @@ export type TuiSlotMap = {
     "app.bottom": {};
     "home.bottom": {};
     "home.footer": {};
+    "session.prompt.top": {
+        sessionID: string;
+    };
+    /**
+     * The prompt's footer row (voice/web chips, shortcut hints, editor context).
+     * Rendered in `replace` mode: a plugin that registers it owns the whole row,
+     * and the built-in footer is what renders when none does.
+     */
+    "prompt.footer": {
+        sessionID?: string;
+        /** Named `promptMode` because `mode` is the slot's own render mode. */
+        promptMode: "normal" | "shell";
+        busy: boolean;
+    };
     "sidebar.content": {
         sessionID: string;
     };
@@ -375,6 +445,7 @@ export type TuiPluginApi = {
         DialogSelect: <Value = unknown>(props: TuiDialogSelectProps<Value>) => JSX.Element;
         toast: (input: TuiToast) => void;
         dialog: TuiDialogStack;
+        tabs: TuiTabsApi;
     };
     keybind: {
         match: (key: string, evt: ParsedKey) => boolean;
@@ -383,6 +454,7 @@ export type TuiPluginApi = {
     };
     readonly tuiConfig: Frozen<TuiConfigView>;
     kv: TuiKV;
+    storage: TuiStorage;
     state: TuiState;
     /** Full reactive data contract used by v2 TUI plugins. */
     data: TuiV2Data;

package/dist/v2/effect/tool.d.ts

@@ -35,7 +35,7 @@ export declare function tool<Args extends z.ZodRawShape>(input: {
     execute(args: z.core.$InferObjectOutput<Args, {}>, context: ToolContext): Promise<ToolResult>;
 };
 export declare namespace tool {
-    var schema: typeof z;
+    export { z as schema };
 }
 export declare const make: typeof tool;
 export type ToolDefinition = ReturnType<typeof tool>;

package/dist/v2/tui/context.d.ts

@@ -1,5 +1,6 @@
 import type { Agent, Command, ConnectorStatus, Event, McpResource, McpStatus, Message, Model, NikcliClient, Part, PermissionRequest, PermissionRule, Provider, Pty, QuestionRequest, ReferenceConfig, Session, SessionEntryAssistantReasoning, SessionEntryAssistantRetry, SessionEntryAssistantText, SessionEntryAssistantTool, SessionEntrySynthetic, SessionEntryUser } from "@nikcli-ai/sdk/v2";
 import type { JSX } from "@opentui/solid";
+import type { Store } from "solid-js/store";
 export type LocationRef = {
     readonly directory: string;
     readonly workspaceID?: string;
@@ -133,10 +134,28 @@ export interface UI {
     };
     readonly slot: (name: string, render: Slot) => () => void;
 }
+export interface Storage {
+    /**
+     * Durable JSON state: persisted to disk, survives hot reloads and TUI
+     * restarts, and stays in sync across running TUI instances.
+     */
+    store<Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }): readonly [Store<Value>, (mutation: (draft: Value) => void) => Promise<void>];
+    /**
+     * Ephemeral in-memory state: survives plugin hot reloads (the old and the new
+     * generation share the same live store) and is gone when the TUI exits.
+     * Updates are synchronous and values need not be JSON-serializable.
+     */
+    memory<Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }): readonly [Store<Value>, (mutation: (draft: Value) => void) => void];
+}
 export interface Context {
     readonly options: Readonly<Record<string, unknown>>;
     readonly client: NikcliClient;
     readonly data: Data;
+    readonly storage: Storage;
     readonly ui: UI;
 }
 export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nikcli-ai/plugin",
-  "version": "1.196.0",
+  "version": "1.225.0",
   "type": "module",
   "license": "MIT",
   "scripts": {
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsc --noEmit",
     "build": "tsc",
     "build:plugins": "bun run script/build-plugins.ts",
     "publish:plugins": "bun run script/publish-plugins.ts"
@@ -65,16 +65,17 @@
     }
   },
   "dependencies": {
-    "@nikcli-ai/sdk": "1.196.0",
+    "@nikcli-ai/sdk": "1.225.0",
     "@opentui/core": "0.1.91",
     "@opentui/solid": "0.1.91",
     "effect": "4.0.0-beta.83",
+    "solid-js": "1.9.10",
     "zod": "4.1.8"
   },
   "devDependencies": {
     "@tsconfig/node22": "22.0.2",
     "@types/node": "22.13.9",
     "typescript": "5.8.2",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2"
+    "@typescript/native": "npm:typescript@7.0.2"
   }
 }