@makinbakin/sdk 0.0.0-bootstrap.0

package/_internal/app/components/ui/form.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { type ControllerProps, type FieldPath, type FieldValues } from "react-hook-form";
+import { Label } from "./label";
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare function FormField<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>): import("react/jsx-runtime").JSX.Element;
+declare function useFormField(): {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare function FormItem({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function FormLabel({ className, ...props }: React.ComponentProps<typeof Label>): import("react/jsx-runtime").JSX.Element;
+declare function FormControl({ ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function FormDescription({ className, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+declare function FormMessage({ className, children, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element | null;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField, };

package/_internal/app/components/ui/input-group.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./button";
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-end" | "inline-start" | "block-start" | "block-end" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): import("react/jsx-runtime").JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "sm" | "xs" | "icon-xs" | "icon-sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

package/_internal/app/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+export { Input };

package/_internal/app/components/ui/label.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Label({ className, ...props }: React.ComponentProps<"label">): import("react/jsx-runtime").JSX.Element;
+export { Label };

package/_internal/app/components/ui/popover.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { Popover as PopoverPrimitive } from "@base-ui/react/popover";
+declare function Popover({ ...props }: PopoverPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTrigger({ ...props }: PopoverPrimitive.Trigger.Props): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, alignOffset, side, sideOffset, ...props }: PopoverPrimitive.Popup.Props & Pick<PopoverPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTitle({ className, ...props }: PopoverPrimitive.Title.Props): import("react/jsx-runtime").JSX.Element;
+declare function PopoverDescription({ className, ...props }: PopoverPrimitive.Description.Props): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

package/_internal/app/components/ui/progress.d.ts

@@ -0,0 +1,7 @@
+import { Progress as ProgressPrimitive } from "@base-ui/react/progress";
+declare function Progress({ className, children, value, ...props }: ProgressPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare function ProgressTrack({ className, ...props }: ProgressPrimitive.Track.Props): import("react/jsx-runtime").JSX.Element;
+declare function ProgressIndicator({ className, ...props }: ProgressPrimitive.Indicator.Props): import("react/jsx-runtime").JSX.Element;
+declare function ProgressLabel({ className, ...props }: ProgressPrimitive.Label.Props): import("react/jsx-runtime").JSX.Element;
+declare function ProgressValue({ className, ...props }: ProgressPrimitive.Value.Props): import("react/jsx-runtime").JSX.Element;
+export { Progress, ProgressTrack, ProgressIndicator, ProgressLabel, ProgressValue, };

package/_internal/app/components/ui/select.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+declare const Select: typeof SelectPrimitive.Root;
+declare function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: SelectPrimitive.Trigger.Props & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: SelectPrimitive.Popup.Props & Pick<SelectPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger">): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: SelectPrimitive.GroupLabel.Props): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: SelectPrimitive.Item.Props): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/_internal/app/components/ui/separator.d.ts

@@ -0,0 +1,3 @@
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+declare function Separator({ className, orientation, ...props }: SeparatorPrimitive.Props): import("react/jsx-runtime").JSX.Element;
+export { Separator };

package/_internal/app/components/ui/sheet.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { Dialog as SheetPrimitive } from "@base-ui/react/dialog";
+declare function Sheet({ ...props }: SheetPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare function SheetTrigger({ ...props }: SheetPrimitive.Trigger.Props): import("react/jsx-runtime").JSX.Element;
+declare function SheetClose({ ...props }: SheetPrimitive.Close.Props): import("react/jsx-runtime").JSX.Element;
+declare function SheetContent({ className, children, side, showCloseButton, ...props }: SheetPrimitive.Popup.Props & {
+    side?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SheetFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SheetTitle({ className, ...props }: SheetPrimitive.Title.Props): import("react/jsx-runtime").JSX.Element;
+declare function SheetDescription({ className, ...props }: SheetPrimitive.Description.Props): import("react/jsx-runtime").JSX.Element;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/_internal/app/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/_internal/app/components/ui/switch.d.ts

@@ -0,0 +1,5 @@
+import { Switch as SwitchPrimitive } from "@base-ui/react/switch";
+declare function Switch({ className, size, ...props }: SwitchPrimitive.Root.Props & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+export { Switch };

package/_internal/app/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/_internal/app/components/ui/tabs.d.ts

@@ -0,0 +1,10 @@
+import { Tabs as TabsPrimitive } from "@base-ui/react/tabs";
+import { type VariantProps } from "class-variance-authority";
+declare function Tabs({ className, orientation, ...props }: TabsPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, ...props }: TabsPrimitive.List.Props & VariantProps<typeof tabsListVariants>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: TabsPrimitive.Tab.Props): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: TabsPrimitive.Panel.Props): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/_internal/app/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

package/_internal/app/components/ui/tooltip.d.ts

@@ -0,0 +1,6 @@
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip";
+declare function TooltipProvider({ delay, ...props }: TooltipPrimitive.Provider.Props): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: TooltipPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, ...props }: TooltipPrimitive.Popup.Props & Pick<TooltipPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/_internal/app/components/underline-tabs.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+export interface UnderlineTab {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface UnderlineTabsProps {
+    tabs: readonly UnderlineTab[];
+    value: string;
+    onValueChange: (id: string) => void;
+    className?: string;
+    rightSlot?: ReactNode;
+}
+export declare function UnderlineTabs({ tabs, value, onValueChange, className, rightSlot }: UnderlineTabsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_internal/app/hooks/use-assets.d.ts

@@ -0,0 +1,25 @@
+import type { AssetMeta, TrashedAssetMeta } from '../types';
+interface UseAssetsOptions {
+    type?: string;
+    agent?: string;
+    taskId?: string;
+    tag?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare function useAssets(options?: UseAssetsOptions): {
+    assets: AssetMeta[];
+    total: number;
+    loading: boolean;
+    refresh: () => Promise<void>;
+    deleteAsset: (filename: string) => Promise<boolean>;
+};
+export declare function useTrash(): {
+    items: TrashedAssetMeta[];
+    loading: boolean;
+    refresh: () => Promise<void>;
+    restoreAsset: (filename: string) => Promise<boolean>;
+    permanentDeleteAsset: (filename: string) => Promise<boolean>;
+    emptyTrash: () => Promise<boolean>;
+};
+export {};

package/_internal/app/hooks/use-content-store.d.ts

@@ -0,0 +1,36 @@
+import type { ActivityEvent, ContentState, Heartbeat } from '../types';
+interface AuditEntry {
+    ts: string;
+    event: string;
+    agent: string;
+    data: Record<string, unknown>;
+}
+interface ReindexProgressEntry {
+    indexed: number;
+    done: boolean;
+}
+interface ContentStore extends ContentState {
+    loading: boolean;
+    auditEntries: AuditEntry[];
+    activityEvents: ActivityEvent[];
+    sseConnected: boolean;
+    taskboardVersion: number;
+    debug: boolean;
+    reindexProgress: Record<string, ReindexProgressEntry>;
+    setFiles: (files: Record<string, string>) => void;
+    updateFile: (key: string, content: string) => void;
+    setHeartbeats: (heartbeats: Record<string, Heartbeat>) => void;
+    setConnected: (connected: boolean) => void;
+    appendAuditEntry: (entry: AuditEntry) => void;
+    appendActivityEvent: (event: ActivityEvent) => void;
+    setActivityEvents: (events: ActivityEvent[]) => void;
+    setSseConnected: (connected: boolean) => void;
+    bumpTaskboard: () => void;
+    setDebug: (debug: boolean) => void;
+    toggleDebug: () => void;
+    setReindexProgress: (table: string, indexed: number, done: boolean) => void;
+    clearReindexProgress: () => void;
+    initialize: () => Promise<void>;
+}
+export declare const useContentStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ContentStore>>;
+export {};

package/_internal/app/hooks/use-debug.d.ts

@@ -0,0 +1 @@
+export declare function useDebug(): [debug: boolean, toggleDebug: () => void];

package/_internal/app/hooks/use-form-guard.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Warns the user via the browser's beforeunload dialog when they have unsaved changes.
+ * Pass `isDirty` from react-hook-form's `formState.isDirty` or a manual flag.
+ */
+export declare function useFormGuard(isDirty: boolean): void;

package/_internal/app/hooks/use-query-state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Syncs a single string value to a URL query parameter.
+ * Returns [value, setValue, pushValue] like useState.
+ * - setValue uses router.replace (no history entry) — good for filters, search, view toggles
+ * - pushValue uses router.push (creates history entry) — good for opening drawers/modals
+ * When value equals defaultValue, the param is removed from the URL.
+ */
+export declare function useQueryState(key: string, defaultValue?: string): [string, (v: string) => void, (v: string) => void];
+/**
+ * Syncs a string[] to a URL query parameter (comma-separated).
+ * Returns [values, setValues] like useState.
+ * When array is empty, the param is removed from the URL.
+ */
+export declare function useQueryArrayState(key: string): [string[], (v: string[]) => void];

package/_internal/app/hooks/use-runtime-status.d.ts

@@ -0,0 +1,12 @@
+interface RuntimeStatus {
+    restartNeeded: boolean;
+    restarting: boolean;
+    restart: () => Promise<void>;
+    markDirty: () => void;
+}
+/**
+ * Check if the active runtime needs a restart after config changes.
+ * Shared across agent detail, models page, and team grid.
+ */
+export declare function useRuntimeStatus(): RuntimeStatus;
+export {};

package/_internal/app/hooks/use-schedule.d.ts

@@ -0,0 +1,63 @@
+export interface ScheduleJob {
+    id: string;
+    displayName: string;
+    description?: string;
+    agentId?: string;
+    humanSchedule: string;
+    cron?: string;
+    paused: boolean;
+    pauseReason?: string;
+    pauseUntil?: string;
+    skipNextN?: number;
+    skippedCount?: number;
+    enabled: boolean;
+    isBakinJob: boolean;
+    source?: 'bakin' | 'runtime' | 'adopted';
+    canAdopt?: boolean;
+    canRestoreNative?: boolean;
+    allowOverlap: boolean;
+    maxFailures: number;
+    consecutiveFailures: number;
+    requireTriage?: boolean;
+    owner?: string;
+    workflowId?: string;
+    taskPrompt?: string;
+    taskTitle?: string;
+    toolsAllow?: string[];
+    toolsAllowMissing?: boolean;
+    tz?: string;
+    lastTaskId?: string;
+    nextRun?: string;
+    lastRun?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface RunEntry {
+    runId: string;
+    timestamp: string;
+    status: 'success' | 'failure' | 'skipped';
+    taskId?: string;
+    error?: string;
+}
+interface UseScheduleOptions {
+    agent?: string;
+}
+export declare function useScheduleJobs(options?: UseScheduleOptions): {
+    jobs: ScheduleJob[];
+    loading: boolean;
+    refresh: () => Promise<void>;
+    pauseJob: (jobId: string, pauseUntil?: string) => Promise<boolean>;
+    resumeJob: (jobId: string) => Promise<boolean>;
+    deleteJob: (jobId: string) => Promise<boolean>;
+    runNow: (jobId: string) => Promise<boolean>;
+    updateJob: (jobId: string, data: Record<string, unknown>) => Promise<boolean>;
+    adoptJob: (jobId: string, data: Record<string, unknown>) => Promise<boolean>;
+    restoreNative: (jobId: string) => Promise<boolean>;
+    skipNext: (jobId: string, n?: number) => Promise<boolean>;
+    duplicateJob: (jobId: string, overrides?: Record<string, unknown>) => Promise<boolean>;
+};
+export declare function useRunHistory(jobId: string | null, limit?: number): {
+    runs: RunEntry[];
+    loading: boolean;
+};
+export {};

package/_internal/app/hooks/use-search.d.ts

@@ -0,0 +1,65 @@
+export interface SearchResult {
+    id: string;
+    table: string;
+    score: number;
+    fields: Record<string, unknown>;
+    _table?: string;
+    /** Per-index score breakdown (e.g. { search: 0.8, embeddings: 0.6 }) */
+    indexScores?: Record<string, number>;
+}
+export interface SearchResponse {
+    results: SearchResult[];
+    aggregations?: Record<string, Array<{
+        value: string;
+        count: number;
+    }>>;
+    meta?: {
+        query: string;
+        total: number;
+        took_ms: number;
+        source: 'search' | 'fallback';
+    };
+}
+export interface UseSearchOptions {
+    /**
+     * Plugin id to route the query to. When set, the hook fetches
+     * `/api/plugins/{plugin}/search?q=...` — the plugin owns its table
+     * name and the client never sees the raw `bakin_` prefix. Omit for
+     * cross-plugin search, which falls back to `/api/search?q=...`.
+     */
+    plugin?: string;
+    /** Max results */
+    limit?: number;
+    /** Facet fields to include aggregation counts for */
+    facets?: string[];
+    /** Debounce delay in ms (default: 250) */
+    debounce?: number;
+    /** Fallback filter function when search returns no results or errors */
+    fallback?: (query: string) => SearchResult[];
+}
+export interface UseSearchReturn {
+    results: SearchResult[];
+    aggregations: Record<string, Array<{
+        value: string;
+        count: number;
+    }>>;
+    loading: boolean;
+    error: string | null;
+    meta: SearchResponse['meta'] | null;
+    search: (query: string) => void;
+    clear: () => void;
+}
+/**
+ * Given a client-side filtered list and search results, reorder the list
+ * so matched items appear first (by score). Items not in results keep
+ * their original order at the end.
+ */
+export declare function reorderBySearchResults<T extends {
+    id: string;
+}>(items: T[], searchResults: SearchResult[]): T[];
+/**
+ * React hook for Bakin search with debouncing, AbortController, and an
+ * optional client-side fallback. Scopes to a plugin via `plugin:` or
+ * runs cross-plugin when omitted.
+ */
+export declare function useSearch(options?: UseSearchOptions): UseSearchReturn;

package/_internal/app/hooks/use-sidebar.d.ts

@@ -0,0 +1,4 @@
+export declare function useSidebar(): {
+    collapsed: boolean;
+    toggle: () => void;
+};

package/_internal/app/hooks/use-sse.d.ts

@@ -0,0 +1 @@
+export declare function useSSE(): void;

package/_internal/app/hooks/use-toast.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+export interface Toast {
+    id: string;
+    message: ReactNode;
+    type: 'success' | 'error' | 'info';
+    duration?: number;
+}
+interface ToastStore {
+    toasts: Toast[];
+    add: (toast: Omit<Toast, 'id'>) => void;
+    dismiss: (id: string) => void;
+}
+export declare const useToastStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ToastStore>>;
+/** Convenience: call from anywhere without hooks */
+export declare function toast(message: ReactNode, type?: Toast['type'], duration?: number): void;
+export {};

package/_internal/app/hooks/use-vertical-resize.d.ts

@@ -0,0 +1,22 @@
+interface Options {
+    defaultHeight: number;
+    minHeight: number;
+    maxHeight: number;
+    /** When set, height is persisted in localStorage under `bakin-vresize:${storageKey}`. */
+    storageKey?: string;
+}
+interface HandleProps {
+    onMouseDown: (e: React.MouseEvent) => void;
+    onTouchStart: (e: React.TouchEvent) => void;
+}
+interface Return {
+    height: number;
+    setHeight: (h: number) => void;
+    handleProps: HandleProps;
+}
+/**
+ * Resize a panel by dragging its top edge. The handle lives at the top of the
+ * element; dragging upward grows the panel, dragging downward shrinks it.
+ */
+export declare function useVerticalResize({ defaultHeight, minHeight, maxHeight, storageKey }: Options): Return;
+export {};

package/_internal/app/lib/browser-notify.d.ts

@@ -0,0 +1,5 @@
+export declare function isNotificationsSupported(): boolean;
+export declare function isNotificationsEnabled(): boolean;
+export declare function requestNotificationPermission(): Promise<boolean>;
+export declare function toggleNotifications(enabled: boolean): void;
+export declare function sendBrowserNotification(title: string, body: string): void;

package/_internal/app/lib/map-audit-message.d.ts

@@ -0,0 +1,7 @@
+import type { ActivityEvent } from '../types';
+/** Map an audit event name + data into a human-readable message */
+export declare function mapAuditMessage(event: string, data: Record<string, unknown>): string;
+/** Convert an exec tool name like "bakin_exec_foo_bar" into "Foo bar" */
+export declare function humanizeExecName(name: string): string;
+/** Filter out infrastructure noise that isn't useful in the user-facing feed */
+export declare function isNoisyEvent(evt: ActivityEvent): boolean;

package/_internal/app/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/_internal/app/types/index.d.ts

@@ -0,0 +1,126 @@
+export interface TaskLogEntry {
+    timestamp: string;
+    author: string;
+    message: string;
+}
+export interface Task {
+    id: string;
+    title: string;
+    agent?: string;
+    checked: boolean;
+    date?: string;
+    blockedReason?: string;
+    description?: string;
+    log?: TaskLogEntry[];
+}
+export interface TaskColumns {
+    inProgress: Task[];
+    todo: Task[];
+    done: Task[];
+    blocked: Task[];
+}
+export interface TaskBoard {
+    columns: TaskColumns;
+    timestamp?: string;
+}
+export type ColumnId = keyof TaskColumns;
+export interface CalendarEvent {
+    time?: string;
+    text: string;
+}
+export interface CalendarDay {
+    date: string;
+    label?: string;
+    events: CalendarEvent[];
+}
+export interface RecurringEvent {
+    schedule: string;
+    text: string;
+}
+export interface MemoryEntry {
+    type: 'decision' | 'learned' | 'note';
+    text: string;
+}
+export interface MemoryDay {
+    date: string;
+    entries: MemoryEntry[];
+}
+export interface Heartbeat {
+    status: 'working' | 'idle' | 'down';
+    currentTask?: string;
+    timestamp: string;
+}
+export interface ProjectMeta {
+    filename: string;
+    title: string;
+    status?: string;
+    content: string;
+}
+export interface AssetVariantMeta {
+    role: 'thumbnail' | 'optimized' | 'webp';
+    path: string;
+    filename: string;
+    size: number;
+    mimeType: string;
+}
+export interface AssetMeta {
+    path: string;
+    filename: string;
+    type: 'text' | 'images' | 'video' | 'audio' | 'plans' | 'research' | 'pdf' | 'data' | 'other';
+    mimeType: string;
+    size: number;
+    mtimeMs?: number;
+    metadata: {
+        agent: string;
+        taskId: string | null;
+        created: string;
+        tool?: string;
+        description?: string;
+        tags?: string[];
+        originalFilename?: string;
+    };
+    variants?: AssetVariantMeta[];
+}
+export interface TrashedAssetMeta {
+    filename: string;
+    originalFilename: string;
+    type: string;
+    mimeType: string;
+    size: number;
+    deletedAt: string;
+    expiresAt: string;
+    metadata: {
+        agent: string;
+        taskId: string | null;
+        created: string;
+        tool?: string;
+        description?: string;
+        tags?: string[];
+    } | null;
+}
+export interface OfficeData {
+    asciiMap: string;
+    statusTable: {
+        agent: string;
+        status: string;
+        task: string;
+        heartbeat: string;
+    }[];
+    history: string[];
+}
+export interface ActivityEvent {
+    id: string;
+    ts: string;
+    type: 'log' | 'audit' | 'alert';
+    agent: string;
+    message: string;
+    taskId?: string;
+    taskTitle?: string;
+    eventName?: string;
+    duplicate?: boolean;
+}
+export interface ContentState {
+    files: Record<string, string>;
+    heartbeats: Record<string, Heartbeat>;
+    connected: boolean;
+}

package/_internal/core/adapters/runtime/capabilities.d.ts

@@ -0,0 +1,2 @@
+export type ChannelCapability = 'message' | 'rich-content' | 'interactive-approval' | 'modal-input' | 'threaded-replies' | 'edit-after-send' | 'cancel-rendered';
+export declare function hasChannelCapability(capabilities: readonly ChannelCapability[], capability: ChannelCapability): boolean;