@edenapp/types 0.2.1 → 0.3.1

package/AppManifest.d.ts

@@ -86,6 +86,72 @@ export interface FileHandlerConfig {
   icon?: string;
 }
 
+/**
+ * Supported setting input types
+ */
+export type SettingType =
+  | "text"
+  | "number"
+  | "checkbox"
+  | "radio"
+  | "select"
+  | "toggle"
+  | "textarea"
+  | "color"
+  | "range";
+
+/**
+ * Option for radio/select settings
+ */
+export interface SettingOption {
+  /** Value stored when this option is selected */
+  value: string;
+  /** Display label for this option */
+  label: string;
+  /** Optional description for this option */
+  description?: string;
+}
+
+/**
+ * Individual setting definition
+ */
+export interface SettingDefinition {
+  /** Unique key for this setting */
+  key: string;
+  /** Display label */
+  label: string;
+  /** Description shown as help text */
+  description?: string;
+  /** Input type */
+  type: SettingType;
+  /** Default value (as string, will be parsed based on type) */
+  defaultValue?: string;
+  /** Options for radio/select types */
+  options?: SettingOption[];
+  /** Placeholder for text/textarea */
+  placeholder?: string;
+  /** Min value for number/range */
+  min?: number;
+  /** Max value for number/range */
+  max?: number;
+  /** Step for number/range */
+  step?: number;
+}
+
+/**
+ * Settings category (group of related settings)
+ */
+export interface SettingsCategory {
+  /** Category ID */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Category icon (optional) */
+  icon?: string;
+  /** Settings in this category */
+  settings: SettingDefinition[];
+}
+
 /**
  * App Manifest Interface
  *
@@ -195,4 +261,10 @@ export interface AppManifest {
    * optional access control via allowedClients.
    */
   services?: ServiceDeclaration[];
+
+  /**
+   * App settings configuration.
+   * Defines settings categories and individual settings that can be configured.
+   */
+  settings?: SettingsCategory[];
 }

package/commands.generated.d.ts

@@ -243,7 +243,7 @@ export interface FsCommands {
   "fs/read": {
     args: {
     path: string;
-    encoding?: BufferEncoding };
+    encoding?: string };
     response: string;
   };
   /**
@@ -253,7 +253,7 @@ export interface FsCommands {
     args: {
     path: string;
     content: string;
-    encoding?: BufferEncoding };
+    encoding?: string };
     response: void;
   };
   /**
@@ -427,6 +427,104 @@ export interface ProcessCommands {
   };
 }
 
+/**
+ * SettingsCommands - Commands for the "settings" namespace
+ */
+export interface SettingsCommands {
+  /**
+   * Get a setting value (scoped to caller's app)
+   */
+  "settings/get": {
+    args: {
+    key: string };
+    response: { value: string | undefined };
+  };
+  /**
+   * Set a setting value (scoped to caller's app)
+   */
+  "settings/set": {
+    args: {
+    key: string;
+    value: string };
+    response: { success: boolean };
+  };
+  /**
+   * List all settings keys (scoped to caller's app)
+   */
+  "settings/list": {
+    args: { };
+    response: { keys: string[] };
+  };
+  /**
+   * Get all settings with values (scoped to caller's app)
+   */
+  "settings/get-all": {
+    args: { };
+    response: { settings: Record<string, string> };
+  };
+  /**
+   * Reset a setting to default (scoped to caller's app)
+   */
+  "settings/reset": {
+    args: {
+    key: string;
+    schema?: import("./index").SettingsCategory[] };
+    response: { success: boolean };
+  };
+  /**
+   * Get a setting from any app's namespace (superuser only)
+   */
+  "settings/get/su": {
+    args: {
+    appId: string;
+    key: string };
+    response: { value: string | undefined };
+  };
+  /**
+   * Set a setting in any app's namespace (superuser only)
+   */
+  "settings/set/su": {
+    args: {
+    appId: string;
+    key: string;
+    value: string };
+    response: { success: boolean };
+  };
+  /**
+   * List all settings in any app's namespace (superuser only)
+   */
+  "settings/list/su": {
+    args: {
+    appId: string };
+    response: { keys: string[] };
+  };
+  /**
+   * Get all settings with values for any app (superuser only)
+   */
+  "settings/get-all/su": {
+    args: {
+    appId: string };
+    response: { settings: Record<string, string> };
+  };
+  /**
+   * Reset a setting for any app (superuser only)
+   */
+  "settings/reset/su": {
+    args: {
+    appId: string;
+    key: string;
+    schema?: import("./index").SettingsCategory[] };
+    response: { success: boolean };
+  };
+  /**
+   * Get the Eden settings schema
+   */
+  "settings/schema": {
+    args: Record<string, never>;
+    response: { schema: import("./index").SettingsCategory[] };
+  };
+}
+
 /**
  * ViewCommands - Commands for the "view" namespace
  */
@@ -528,4 +626,4 @@ export interface ViewCommands {
 /**
  * Global command map - merge all command namespaces
  */
-export interface CommandMap extends SystemCommands, AppbusCommands, DbCommands, FileCommands, FsCommands, EventCommands, NotificationCommands, PackageCommands, ProcessCommands, ViewCommands {}
+export interface CommandMap extends SystemCommands, AppbusCommands, DbCommands, FileCommands, FsCommands, EventCommands, NotificationCommands, PackageCommands, ProcessCommands, SettingsCommands, ViewCommands {}

package/events.generated.d.ts

@@ -38,6 +38,13 @@ export interface ProcessEvents {
   "process/exited": { appId: string; code: number };
 }
 
+/**
+ * SettingsEvents - Events for the "settings" namespace
+ */
+export interface SettingsEvents {
+  "settings/changed": { appId: string; key: string; value: string };
+}
+
 /**
  * ViewEvents - Events for the "view" namespace
  */
@@ -60,4 +67,4 @@ export interface ViewEvents {
 /**
  * Global event map - merge all event namespaces
  */
-export interface AppEvents extends FileEvents, NotificationEvents, PackageEvents, ProcessEvents, ViewEvents {}
+export interface AppEvents extends FileEvents, NotificationEvents, PackageEvents, ProcessEvents, SettingsEvents, ViewEvents {}

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@edenapp/types",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "TypeScript type definitions for the Eden platform",
   "types": "index.d.ts",
   "author": "Dariusz Majnert",
   "license": "MIT",
   "files": [
     "*.d.ts",
-    "ipc/",
     "README.md"
   ],
   "keywords": [
@@ -21,4 +20,4 @@
     "url": "https://github.com/b0czek/eden.git",
     "directory": "src/types"
   }
-}
+}

package/ipc/appbus.d.ts

@@ -1,232 +0,0 @@
-/**
- * AppBus Type Definitions
- *
- * Interface for app-to-app communication.
- * Used by both frontend (window.appBus) and backend (worker.appBus).
- */
-
-/**
- * Schema for fire-and-forget messages (send/on/once)
- * Keys are method names, values are the payload types
- */
-export type MessageSchema = Record<string, any>;
-
-/**
- * Schema for request/response (request/handle)
- * Keys are method names, values are { args, result } types
- */
-export type RequestSchema = Record<string, { args: any; result: any }>;
-
-/**
- * Defines a bidirectional communication protocol between two sides.
- * Use "host" for the side that exposes the service (exposeService).
- * Use "peer" for the side that connects to the service (connect).
- *
- * @example
- * type ChatProtocol = {
- *   // Messages the host sends, peer receives
- *   hostMessages: {
- *     'welcome': { text: string };
- *     'userJoined': { nickname: string };
- *   };
- *   // Messages the peer sends, host receives
- *   peerMessages: {
- *     'typing': { isTyping: boolean };
- *   };
- *   // Requests the host handles (peer calls request, host calls handle)
- *   hostHandles: {
- *     'join': { args: { nickname: string }; result: { success: boolean } };
- *     'sendMessage': { args: { text: string }; result: void };
- *   };
- *   // Requests the peer handles (host calls request, peer calls handle)
- *   peerHandles: {
- *     'ping': { args: {}; result: { pong: boolean } };
- *   };
- * };
- */
-export interface ChannelProtocol {
-  /** Messages sent by host, received by peer */
-  hostMessages: MessageSchema;
-  /** Messages sent by peer, received by host */
-  peerMessages: MessageSchema;
-  /** Requests that peer sends, host handles */
-  hostHandles: RequestSchema;
-  /** Requests that host sends, peer handles */
-  peerHandles: RequestSchema;
-}
-
-/**
- * Default empty protocol (all any)
- */
-type DefaultProtocol = {
-  hostMessages: MessageSchema;
-  peerMessages: MessageSchema;
-  hostHandles: RequestSchema;
-  peerHandles: RequestSchema;
-};
-
-/**
- * AppBus connection from the HOST perspective (the side that exposes the service).
- * - send() sends hostMessages
- * - on()/once() receives peerMessages
- * - request() calls peerHandles
- * - handle() implements hostHandles
- */
-export type HostConnection<P extends ChannelProtocol> = AppBusConnection<
-  P["hostMessages"],
-  P["peerMessages"],
-  P["peerHandles"],
-  P["hostHandles"]
->;
-
-/**
- * AppBus connection from the PEER perspective (the side that connects).
- * - send() sends peerMessages
- * - on()/once() receives hostMessages
- * - request() calls hostHandles
- * - handle() implements peerHandles
- */
-export type PeerConnection<P extends ChannelProtocol> = AppBusConnection<
-  P["peerMessages"],
-  P["hostMessages"],
-  P["hostHandles"],
-  P["peerHandles"]
->;
-
-/**
- * AppBus connection returned by connect()
- * Also used for frontend<->backend communication (appAPI)
- *
- * @typeParam TSend - Messages this side sends
- * @typeParam TReceive - Messages this side receives
- * @typeParam TRequest - Requests this side makes (other side handles)
- * @typeParam THandle - Requests this side handles (other side makes)
- *
- * For typed connections, use HostConnection<Protocol> or PeerConnection<Protocol>
- * which automatically flip the perspective.
- */
-export interface AppBusConnection<
-  TSend extends MessageSchema = MessageSchema,
-  TReceive extends MessageSchema = MessageSchema,
-  TRequest extends RequestSchema = RequestSchema,
-  THandle extends RequestSchema = RequestSchema,
-> {
-  /** Send a fire-and-forget message */
-  send<K extends keyof TSend>(method: K, args?: TSend[K]): void;
-
-  /** Listen for messages from the other side */
-  on<K extends keyof TReceive>(
-    method: K,
-    callback: (args: TReceive[K]) => void
-  ): void;
-  /** Listen for messages only once, then auto-remove */
-  once<K extends keyof TReceive>(
-    method: K,
-    callback: (args: TReceive[K]) => void
-  ): void;
-  /** Remove a listener */
-  off<K extends keyof TReceive>(
-    method: K,
-    callback: (args: TReceive[K]) => void
-  ): void;
-
-  /** Send a request and wait for response (other side handles) */
-  request<K extends keyof TRequest>(
-    method: K,
-    args?: TRequest[K]["args"]
-  ): Promise<TRequest[K]["result"]>;
-
-  /** Register a handler for requests from the other side */
-  handle<K extends keyof THandle>(
-    method: K,
-    handler: (
-      args: THandle[K]["args"]
-    ) => THandle[K]["result"] | Promise<THandle[K]["result"]>
-  ): void;
-  /** Remove a handler */
-  removeHandler<K extends keyof THandle>(method: K): void;
-
-  /** Check if the connection is active */
-  isConnected: () => boolean;
-  /** Register a callback for when the connection closes */
-  onClose: (callback: () => void) => void;
-  /** Close the connection */
-  close: () => void;
-}
-
-/**
- * Information about a connecting client
- */
-export interface ClientInfo {
-  appId: string;
-}
-
-/**
- * Callback invoked when a client connects to a service
- */
-export type ServiceConnectCallback = (
-  connection: AppBusConnection,
-  clientInfo: ClientInfo
-) => void;
-
-/**
- * Service registration options
- */
-export interface ServiceOptions {
-  description?: string;
-  allowedClients?: string[];
-}
-
-/**
- * Service info returned by listServices
- */
-export interface ServiceInfo {
-  appId: string;
-  serviceName: string;
-  description?: string;
-}
-
-/**
- * AppBus API - app-to-app communication
- */
-export interface AppBusAPI {
-  /**
-   * Register a service that other apps can connect to.
-   * When a client connects, onConnect is called with their AppBusConnection.
-   * @param serviceName - Name of the service
-   * @param onConnect - Callback invoked for each connecting client with their bidirectional connection
-   * @param options - Optional configuration
-   */
-  exposeService(
-    serviceName: string,
-    onConnect: ServiceConnectCallback,
-    options?: ServiceOptions
-  ): Promise<{ success: boolean; error?: string }>;
-
-  /**
-   * Unregister a service
-   * @param serviceName - Name of the service to unregister
-   */
-  unexposeService(serviceName: string): Promise<{ success: boolean }>;
-
-  /**
-   * Connect to another app's service
-   * @param targetAppId - App ID of the target app
-   * @param serviceName - Name of the service to connect to
-   */
-  connect(
-    targetAppId: string,
-    serviceName: string
-  ): Promise<AppBusConnection | { error: string }>;
-
-  /**
-   * List all available services
-   */
-  listServices(): Promise<{ services: ServiceInfo[] }>;
-
-  /**
-   * List services exposed by a specific app
-   * @param appId - App ID to query
-   */
-  listServicesByApp(appId: string): Promise<{ services: ServiceInfo[] }>;
-}

package/ipc/edenapi.d.ts

@@ -1,61 +0,0 @@
-/**
- * Eden API Type Definitions
- *
- * Interface for shell commands and event subscriptions.
- * Used by both frontend (window.edenAPI) and backend (worker.edenAPI).
- */
-
-import type { CommandName, CommandArgs, CommandResult } from "../commands";
-import type { EventName, EventData } from "../events";
-
-/**
- * Eden API - shell commands and event subscriptions
- */
-export interface EdenAPI {
-  /**
-   * Execute a shell command with type-safe arguments
-   * @param command - The command name (e.g., "process/launch")
-   * @param args - Type-safe arguments for the command
-   * @returns Promise with the command result
-   *
-   * @example
-   * ```typescript
-   * await edenAPI.shellCommand("process/launch", {
-   *   appId: "my-app",
-   *   bounds: { x: 0, y: 0, width: 800, height: 600 }
-   * });
-   * ```
-   */
-  shellCommand<T extends CommandName>(
-    command: T,
-    args: CommandArgs<T>
-  ): Promise<CommandResult<T>>;
-
-  /**
-   * Subscribe to a system event
-   * @param event - The event name
-   * @param callback - Callback function receiving typed event data
-   */
-  subscribe<T extends EventName>(
-    event: T,
-    callback: (data: EventData<T>) => void
-  ): Promise<void>;
-
-  /**
-   * Unsubscribe from a system event
-   */
-  unsubscribe<T extends EventName>(
-    event: T,
-    callback: (data: EventData<T>) => void
-  ): void;
-
-  /**
-   * Check if an event is supported by the system
-   */
-  isEventSupported(event: string): Promise<boolean>;
-
-  /**
-   * Get the launch arguments passed to this app.
-   */
-  getLaunchArgs(): string[];
-}

package/ipc/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * IPC Type Definitions
- */
-
-export * from "./edenapi";
-export * from "./appbus";

package/runtime.generated.d.ts

@@ -1,13 +0,0 @@
-/**
- * AUTO-GENERATED FILE - DO NOT EDIT
- * 
- * Type declarations for runtime arrays.
- * Generated by scripts/generate-commands.ts
- * Run 'pnpm run codegen' to regenerate.
- */
-
-// Command names array
-export declare const COMMAND_NAMES: readonly string[];
-
-// Event names array
-export declare const APP_EVENT_NAMES: readonly string[];