kly 0.1.0

package/dist/shared/runtime-mode.mjs

@@ -0,0 +1,59 @@
+import { ENV_VARS } from "./constants.mjs";
+
+//#region src/shared/runtime-mode.ts
+/**
+* Check if running in sandbox mode
+* Sandbox mode: Isolated child process with restricted permissions
+*/
+function isSandbox() {
+	return process.env[ENV_VARS.SANDBOX_MODE] === "true";
+}
+/**
+* Check if running in MCP (Model Context Protocol) mode
+* MCP mode: Running as an MCP server for Claude Desktop integration
+*/
+function isMCP() {
+	return process.env[ENV_VARS.MCP_MODE] === "true";
+}
+/**
+* Check if running in programmatic mode
+* Programmatic mode: Imported as a library in another application
+*/
+function isProgrammatic() {
+	return process.env[ENV_VARS.PROGRAMMATIC] === "true";
+}
+/**
+* Check if running with trust all flag
+* Trust all: Skip permission prompts (for testing/automation)
+*/
+function isTrustAll() {
+	return process.env[ENV_VARS.TRUST_ALL] === "true";
+}
+/**
+* Get local reference environment variable
+*/
+function getLocalRef() {
+	return process.env[ENV_VARS.LOCAL_REF];
+}
+/**
+* Get remote reference environment variable
+*/
+function getRemoteRef() {
+	return process.env[ENV_VARS.REMOTE_REF];
+}
+/**
+* Detect the current runtime mode
+* This is the canonical implementation that should be used throughout the app
+*/
+function detectMode() {
+	if (isSandbox()) return "cli";
+	if (isMCP()) return "mcp";
+	if (isProgrammatic()) return "programmatic";
+	const scriptPath = process.argv[1] ?? "";
+	if (scriptPath.endsWith(".ts") || scriptPath.endsWith(".js")) return "cli";
+	return "programmatic";
+}
+
+//#endregion
+export { detectMode, getLocalRef, getRemoteRef, isMCP, isSandbox, isTrustAll };
+//# sourceMappingURL=runtime-mode.mjs.map

package/dist/shared/runtime-mode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-mode.mjs","names":[],"sources":["../../src/shared/runtime-mode.ts"],"sourcesContent":["/**\n * Runtime mode detection utilities\n * Centralizes environment variable checks for different execution modes\n */\n\nimport type { RuntimeMode } from \"../types\";\nimport { ENV_VARS } from \"./constants\";\n\n/**\n * Check if running in sandbox mode\n * Sandbox mode: Isolated child process with restricted permissions\n */\nexport function isSandbox(): boolean {\n  return process.env[ENV_VARS.SANDBOX_MODE] === \"true\";\n}\n\n/**\n * Check if running in MCP (Model Context Protocol) mode\n * MCP mode: Running as an MCP server for Claude Desktop integration\n */\nexport function isMCP(): boolean {\n  return process.env[ENV_VARS.MCP_MODE] === \"true\";\n}\n\n/**\n * Check if running in programmatic mode\n * Programmatic mode: Imported as a library in another application\n */\nexport function isProgrammatic(): boolean {\n  return process.env[ENV_VARS.PROGRAMMATIC] === \"true\";\n}\n\n/**\n * Check if running with trust all flag\n * Trust all: Skip permission prompts (for testing/automation)\n */\nexport function isTrustAll(): boolean {\n  return process.env[ENV_VARS.TRUST_ALL] === \"true\";\n}\n\n/**\n * Get local reference environment variable\n */\nexport function getLocalRef(): string | undefined {\n  return process.env[ENV_VARS.LOCAL_REF];\n}\n\n/**\n * Get remote reference environment variable\n */\nexport function getRemoteRef(): string | undefined {\n  return process.env[ENV_VARS.REMOTE_REF];\n}\n\n/**\n * Detect the current runtime mode\n * This is the canonical implementation that should be used throughout the app\n */\nexport function detectMode(): RuntimeMode {\n  // Sandbox mode: Running inside sandboxed child process\n  if (isSandbox()) {\n    return \"cli\"; // Sandbox always runs in CLI mode\n  }\n\n  // MCP mode: Check for MCP environment variable\n  if (isMCP()) {\n    return \"mcp\";\n  }\n\n  // Programmatic mode: Check for explicit flag\n  if (isProgrammatic()) {\n    return \"programmatic\";\n  }\n\n  // CLI mode: Running a .ts file directly with bun\n  const scriptPath = process.argv[1] ?? \"\";\n  const isDirectRun = scriptPath.endsWith(\".ts\") || scriptPath.endsWith(\".js\");\n  if (isDirectRun) {\n    return \"cli\";\n  }\n\n  // Default to programmatic (e.g., when imported as a module)\n  return \"programmatic\";\n}\n"],"mappings":";;;;;;;AAYA,SAAgB,YAAqB;AACnC,QAAO,QAAQ,IAAI,SAAS,kBAAkB;;;;;;AAOhD,SAAgB,QAAiB;AAC/B,QAAO,QAAQ,IAAI,SAAS,cAAc;;;;;;AAO5C,SAAgB,iBAA0B;AACxC,QAAO,QAAQ,IAAI,SAAS,kBAAkB;;;;;;AAOhD,SAAgB,aAAsB;AACpC,QAAO,QAAQ,IAAI,SAAS,eAAe;;;;;AAM7C,SAAgB,cAAkC;AAChD,QAAO,QAAQ,IAAI,SAAS;;;;;AAM9B,SAAgB,eAAmC;AACjD,QAAO,QAAQ,IAAI,SAAS;;;;;;AAO9B,SAAgB,aAA0B;AAExC,KAAI,WAAW,CACb,QAAO;AAIT,KAAI,OAAO,CACT,QAAO;AAIT,KAAI,gBAAgB,CAClB,QAAO;CAIT,MAAM,aAAa,QAAQ,KAAK,MAAM;AAEtC,KADoB,WAAW,SAAS,MAAM,IAAI,WAAW,SAAS,MAAM,CAE1E,QAAO;AAIT,QAAO"}

package/dist/tool.d.mts

@@ -0,0 +1,42 @@
+import { StandardSchemaV1, Tool, ToolDefinition } from "./types.mjs";
+
+//#region src/tool.d.ts
+
+/**
+ * Tool definition input with required name
+ */
+interface ToolInput<TInput extends StandardSchemaV1, TResult = unknown> extends ToolDefinition<TInput, TResult> {
+  /** Tool name (used as subcommand in CLI, tool name in MCP) */
+  name: string;
+}
+/**
+ * Create a type-safe tool definition
+ *
+ * This is a helper function that enables TypeScript to infer the types
+ * of execute arguments from the inputSchema. Without this helper,
+ * TypeScript cannot establish the connection between schema and execute.
+ *
+ * @example
+ * ```typescript
+ * import { tool } from "kly"
+ * import { z } from "zod"
+ *
+ * const weatherTool = tool({
+ *   name: "weather",
+ *   description: "Get weather for a location",
+ *   inputSchema: z.object({
+ *     city: z.string().describe("City name"),
+ *     unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+ *   }),
+ *   execute: async ({ city, unit }) => {
+ *     // city is inferred as string
+ *     // unit is inferred as "celsius" | "fahrenheit"
+ *     return fetchWeather(city, unit)
+ *   },
+ * })
+ * ```
+ */
+declare function tool<TInput extends StandardSchemaV1, TResult = unknown>(definition: ToolInput<TInput, TResult>): Tool<TInput, TResult>;
+//#endregion
+export { tool };
+//# sourceMappingURL=tool.d.mts.map

package/dist/tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.mts","names":[],"sources":["../src/tool.ts"],"sourcesContent":[],"mappings":";;;;;;AAAsE;UAK5D,SAAyB,CAAA,eAAA,gBAAA,EAAA,UAAA,OAAA,CAAA,SACzB,cADyB,CACV,MADU,EACF,OADE,CAAA,CAAA;EACV;EAAQ,IAAA,EAAA,MAAA;;;AAgCjC;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,oBAAoB,iDACtB,UAAU,QAAQ,WAC7B,KAAK,QAAQ"}

package/dist/tool.mjs

@@ -0,0 +1,38 @@
+//#region src/tool.ts
+/**
+* Create a type-safe tool definition
+*
+* This is a helper function that enables TypeScript to infer the types
+* of execute arguments from the inputSchema. Without this helper,
+* TypeScript cannot establish the connection between schema and execute.
+*
+* @example
+* ```typescript
+* import { tool } from "kly"
+* import { z } from "zod"
+*
+* const weatherTool = tool({
+*   name: "weather",
+*   description: "Get weather for a location",
+*   inputSchema: z.object({
+*     city: z.string().describe("City name"),
+*     unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+*   }),
+*   execute: async ({ city, unit }) => {
+*     // city is inferred as string
+*     // unit is inferred as "celsius" | "fahrenheit"
+*     return fetchWeather(city, unit)
+*   },
+* })
+* ```
+*/
+function tool(definition) {
+	return {
+		...definition,
+		_brand: "Tool"
+	};
+}
+
+//#endregion
+export { tool };
+//# sourceMappingURL=tool.mjs.map

package/dist/tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.mjs","names":[],"sources":["../src/tool.ts"],"sourcesContent":["import type { StandardSchemaV1, Tool, ToolDefinition } from \"./types\";\n\n/**\n * Tool definition input with required name\n */\ninterface ToolInput<TInput extends StandardSchemaV1, TResult = unknown>\n  extends ToolDefinition<TInput, TResult> {\n  /** Tool name (used as subcommand in CLI, tool name in MCP) */\n  name: string;\n}\n\n/**\n * Create a type-safe tool definition\n *\n * This is a helper function that enables TypeScript to infer the types\n * of execute arguments from the inputSchema. Without this helper,\n * TypeScript cannot establish the connection between schema and execute.\n *\n * @example\n * ```typescript\n * import { tool } from \"kly\"\n * import { z } from \"zod\"\n *\n * const weatherTool = tool({\n *   name: \"weather\",\n *   description: \"Get weather for a location\",\n *   inputSchema: z.object({\n *     city: z.string().describe(\"City name\"),\n *     unit: z.enum([\"celsius\", \"fahrenheit\"]).default(\"celsius\"),\n *   }),\n *   execute: async ({ city, unit }) => {\n *     // city is inferred as string\n *     // unit is inferred as \"celsius\" | \"fahrenheit\"\n *     return fetchWeather(city, unit)\n *   },\n * })\n * ```\n */\nexport function tool<TInput extends StandardSchemaV1, TResult = unknown>(\n  definition: ToolInput<TInput, TResult>,\n): Tool<TInput, TResult> {\n  return {\n    ...definition,\n    _brand: \"Tool\" as const,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,KACd,YACuB;AACvB,QAAO;EACL,GAAG;EACH,QAAQ;EACT"}

package/dist/types.d.mts

@@ -0,0 +1,282 @@
+import { SandboxRuntimeConfig } from "@anthropic-ai/sandbox-runtime";
+
+//#region src/types.d.ts
+
+/**
+ * Standard Schema V1 interface (inlined to avoid external dependency)
+ * @see https://github.com/standard-schema/standard-schema
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  interface Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    readonly types?: Types<Input, Output>;
+  }
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+  interface FailureResult {
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  interface Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment>;
+  }
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+}
+/**
+ * Extract output type from a Standard Schema
+ */
+type InferOutput<TSchema> = TSchema extends StandardSchemaV1<unknown, infer Output> ? Output : never;
+/**
+ * Runtime execution mode
+ */
+type RuntimeMode = "cli" | "mcp" | "programmatic";
+/**
+ * Model configuration information (basic info without secrets)
+ */
+interface ModelInfo {
+  /** Model configuration name */
+  name: string;
+  /** Provider (openai, anthropic, etc.) */
+  provider: string;
+  /** Model name (e.g., gpt-4, claude-3-opus) */
+  model?: string;
+  /** Whether this is the current active model */
+  isCurrent: boolean;
+}
+/**
+ * Full model configuration including API keys
+ */
+interface ModelConfig {
+  /** Provider (openai, anthropic, etc.) */
+  provider: string;
+  /** Model name (e.g., gpt-4, claude-3-opus) */
+  model?: string;
+  /** API key */
+  apiKey?: string;
+  /** Base URL */
+  baseURL?: string;
+}
+/**
+ * Models management interface
+ * Provides access to configured LLM models and their credentials
+ */
+interface ModelsContext {
+  /**
+   * List all configured models (without API keys)
+   */
+  list(): ModelInfo[];
+  /**
+   * Get the current active model info
+   */
+  getCurrent(): ModelInfo | null;
+  /**
+   * Get a specific model info by name
+   */
+  get(name: string): ModelInfo | null;
+  /**
+   * Get full configuration for a model (including API key)
+   *
+   * ⚠️  SECURITY: This method requires user permission
+   * The first time this is called, the user will be prompted to grant permission.
+   * Permission can be granted for:
+   * - One time only
+   * - Always for this app
+   * - Denied
+   *
+   * @param name - Model name (if not specified, returns current model)
+   * @returns Full config or null if not found/configured
+   * @throws Error if permission is denied
+   *
+   * @example
+   * ```typescript
+   * const config = await context.models.getConfigAsync();
+   * if (config) {
+   *   // Use config.provider, config.apiKey, config.model etc.
+   * }
+   * ```
+   */
+  getConfigAsync(name?: string): Promise<ModelConfig | null>;
+}
+/**
+ * Context passed to the execute function
+ */
+interface ExecuteContext {
+  /** Current runtime mode */
+  mode: RuntimeMode;
+  /** Abort signal for cancellation */
+  abortSignal?: AbortSignal;
+  /**
+   * Models management
+   * Access configured LLM models and their credentials
+   * @example
+   * ```typescript
+   * const config = context.models.getConfig();
+   * if (config) {
+   *   // Use config.provider, config.apiKey, config.model etc.
+   *   // to create your own AI SDK provider instance
+   * }
+   * ```
+   */
+  models: ModelsContext;
+}
+/**
+ * Tool definition (Vercel AI SDK style)
+ * Core building block that can be used standalone or within defineApp
+ */
+interface ToolDefinition<TInput extends StandardSchemaV1, TResult = unknown> {
+  /** Description of what the tool does (used by LLM for tool selection) */
+  description?: string;
+  /** Input schema (Standard Schema compliant: Zod, Valibot, ArkType, etc.) */
+  inputSchema: TInput;
+  /** Execute function that performs the tool's action */
+  execute: (args: InferOutput<TInput>, context: ExecuteContext) => Promise<TResult>;
+}
+/**
+ * Tool instance returned by tool()
+ * Each tool has a name for CLI subcommand and MCP registration
+ */
+interface Tool<TInput extends StandardSchemaV1, TResult = unknown> extends ToolDefinition<TInput, TResult> {
+  /** Tool name (used as subcommand in CLI, tool name in MCP) */
+  name: string;
+  /** Type brand for tool identification */
+  readonly _brand: "Tool";
+}
+/**
+ * Any tool type for collections
+ */
+type AnyTool = Tool<StandardSchemaV1, unknown>;
+/**
+ * Base app metadata
+ */
+interface AppMetadata {
+  /** App name */
+  name: string;
+  /** Semantic version */
+  version: string;
+  /** App description */
+  description: string;
+}
+/**
+ * App definition with tools array
+ *
+ * @example
+ * ```typescript
+ * defineApp({
+ *   name: "my-app",
+ *   version: "0.1.0",
+ *   description: "My CLI app",
+ *   tools: [greetTool, farewellTool],
+ *   instructions: "When user expresses greeting intent, prefer the greet tool",
+ * })
+ * ```
+ */
+/**
+ * App permissions declaration
+ * Simplified user-friendly interface for declaring app permissions
+ */
+interface AppPermissions {
+  /**
+   * API Keys access - needed to call LLM APIs
+   *
+   * When enabled:
+   * - Grants access to models.getConfigAsync() to retrieve API keys
+   * - Automatically allows network access to common LLM API domains:
+   *   • api.openai.com
+   *   • *.anthropic.com
+   *   • generativelanguage.googleapis.com
+   *   • api.deepseek.com
+   *
+   * @default false
+   */
+  apiKeys?: boolean;
+  /**
+   * Sandbox configuration
+   * Uses @anthropic-ai/sandbox-runtime configuration directly
+   *
+   * Defaults when not specified:
+   * - Network: No access (apiKeys=true adds LLM APIs automatically)
+   * - Filesystem: Current directory read/write only
+   * - Protected: ~/.kly, ~/.ssh, ~/.aws, ~/.gnupg always denied
+   *
+   * @example
+   * ```typescript
+   * // Minimal: just need GitHub API access
+   * permissions: {
+   *   sandbox: {
+   *     network: { allowedDomains: ["api.github.com"] }
+   *   }
+   * }
+   *
+   * // Full control
+   * permissions: {
+   *   apiKeys: true, // LLM domains added automatically
+   *   sandbox: {
+   *     network: {
+   *       allowedDomains: ["api.github.com"] // Add more domains
+   *     },
+   *     filesystem: {
+   *       allowWrite: ["./output", "/tmp"],
+   *       denyRead: ["/etc"]
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  sandbox?: Partial<SandboxRuntimeConfig>;
+}
+interface AppDefinition<TTools extends AnyTool[] = AnyTool[]> extends AppMetadata {
+  /** Array of tools */
+  tools: TTools;
+  /**
+   * AI instructions for Skill mode
+   * Hints for AI routing when this app is composed with others
+   */
+  instructions?: string;
+  /**
+   * Permissions required by this app
+   * Declare upfront what your app needs to access
+   * @example
+   * ```typescript
+   * permissions: {
+   *   apiKeys: true,
+   *   network: { allow: "llm-apis" }
+   * }
+   * ```
+   */
+  permissions?: AppPermissions;
+}
+/**
+ * Kly app instance returned by defineApp
+ */
+interface KlyApp<TTools extends AnyTool[] = AnyTool[]> {
+  /** Original app configuration */
+  readonly definition: AppDefinition<TTools>;
+  /** Execute a specific tool by name */
+  execute(toolName: string, args?: Record<string, unknown>): Promise<unknown>;
+  /** Get all available tools */
+  readonly tools: Map<string, AnyTool>;
+}
+/**
+ * Validation error with structured issues
+ */
+declare class ValidationError extends Error {
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+//#endregion
+export { AnyTool, AppDefinition, AppPermissions, ExecuteContext, InferOutput, KlyApp, ModelConfig, ModelInfo, ModelsContext, RuntimeMode, StandardSchemaV1, Tool, ToolDefinition, ValidationError };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/types.mjs

@@ -0,0 +1,19 @@
+//#region src/types.ts
+/**
+* Validation error with structured issues
+*/
+var ValidationError = class extends Error {
+	constructor(issues) {
+		const message = issues.map((issue) => {
+			const path = issue.path?.map((p) => typeof p === "object" ? p.key : p).join(".");
+			return path ? `${path}: ${issue.message}` : issue.message;
+		}).join("\n");
+		super(message);
+		this.issues = issues;
+		this.name = "ValidationError";
+	}
+};
+
+//#endregion
+export { ValidationError };
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":["issues: ReadonlyArray<StandardSchemaV1.Issue>"],"sources":["../src/types.ts"],"sourcesContent":["import type { SandboxRuntimeConfig } from \"@anthropic-ai/sandbox-runtime\";\n\n/**\n * Standard Schema V1 interface (inlined to avoid external dependency)\n * @see https://github.com/standard-schema/standard-schema\n */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n  readonly \"~standard\": StandardSchemaV1.Props<Input, Output>;\n}\n\nexport declare namespace StandardSchemaV1 {\n  interface Props<Input = unknown, Output = Input> {\n    readonly version: 1;\n    readonly vendor: string;\n    readonly validate: (\n      value: unknown,\n    ) => Result<Output> | Promise<Result<Output>>;\n    readonly types?: Types<Input, Output>;\n  }\n\n  type Result<Output> = SuccessResult<Output> | FailureResult;\n\n  interface SuccessResult<Output> {\n    readonly value: Output;\n    readonly issues?: undefined;\n  }\n\n  interface FailureResult {\n    readonly issues: ReadonlyArray<Issue>;\n  }\n\n  interface Issue {\n    readonly message: string;\n    readonly path?: ReadonlyArray<PropertyKey | PathSegment>;\n  }\n\n  interface PathSegment {\n    readonly key: PropertyKey;\n  }\n\n  interface Types<Input = unknown, Output = Input> {\n    readonly input: Input;\n    readonly output: Output;\n  }\n}\n\n/**\n * Extract output type from a Standard Schema\n */\nexport type InferOutput<TSchema> =\n  TSchema extends StandardSchemaV1<unknown, infer Output> ? Output : never;\n\n/**\n * Runtime execution mode\n */\nexport type RuntimeMode = \"cli\" | \"mcp\" | \"programmatic\";\n\n/**\n * Model configuration information (basic info without secrets)\n */\nexport interface ModelInfo {\n  /** Model configuration name */\n  name: string;\n  /** Provider (openai, anthropic, etc.) */\n  provider: string;\n  /** Model name (e.g., gpt-4, claude-3-opus) */\n  model?: string;\n  /** Whether this is the current active model */\n  isCurrent: boolean;\n}\n\n/**\n * Full model configuration including API keys\n */\nexport interface ModelConfig {\n  /** Provider (openai, anthropic, etc.) */\n  provider: string;\n  /** Model name (e.g., gpt-4, claude-3-opus) */\n  model?: string;\n  /** API key */\n  apiKey?: string;\n  /** Base URL */\n  baseURL?: string;\n}\n\n/**\n * Models management interface\n * Provides access to configured LLM models and their credentials\n */\nexport interface ModelsContext {\n  /**\n   * List all configured models (without API keys)\n   */\n  list(): ModelInfo[];\n\n  /**\n   * Get the current active model info\n   */\n  getCurrent(): ModelInfo | null;\n\n  /**\n   * Get a specific model info by name\n   */\n  get(name: string): ModelInfo | null;\n\n  /**\n   * Get full configuration for a model (including API key)\n   *\n   * ⚠️  SECURITY: This method requires user permission\n   * The first time this is called, the user will be prompted to grant permission.\n   * Permission can be granted for:\n   * - One time only\n   * - Always for this app\n   * - Denied\n   *\n   * @param name - Model name (if not specified, returns current model)\n   * @returns Full config or null if not found/configured\n   * @throws Error if permission is denied\n   *\n   * @example\n   * ```typescript\n   * const config = await context.models.getConfigAsync();\n   * if (config) {\n   *   // Use config.provider, config.apiKey, config.model etc.\n   * }\n   * ```\n   */\n  getConfigAsync(name?: string): Promise<ModelConfig | null>;\n}\n\n/**\n * Context passed to the execute function\n */\nexport interface ExecuteContext {\n  /** Current runtime mode */\n  mode: RuntimeMode;\n  /** Abort signal for cancellation */\n  abortSignal?: AbortSignal;\n  /**\n   * Models management\n   * Access configured LLM models and their credentials\n   * @example\n   * ```typescript\n   * const config = context.models.getConfig();\n   * if (config) {\n   *   // Use config.provider, config.apiKey, config.model etc.\n   *   // to create your own AI SDK provider instance\n   * }\n   * ```\n   */\n  models: ModelsContext;\n}\n\n/**\n * Tool definition (Vercel AI SDK style)\n * Core building block that can be used standalone or within defineApp\n */\nexport interface ToolDefinition<\n  TInput extends StandardSchemaV1,\n  TResult = unknown,\n> {\n  /** Description of what the tool does (used by LLM for tool selection) */\n  description?: string;\n  /** Input schema (Standard Schema compliant: Zod, Valibot, ArkType, etc.) */\n  inputSchema: TInput;\n  /** Execute function that performs the tool's action */\n  execute: (\n    args: InferOutput<TInput>,\n    context: ExecuteContext,\n  ) => Promise<TResult>;\n}\n\n/**\n * Tool instance returned by tool()\n * Each tool has a name for CLI subcommand and MCP registration\n */\nexport interface Tool<TInput extends StandardSchemaV1, TResult = unknown>\n  extends ToolDefinition<TInput, TResult> {\n  /** Tool name (used as subcommand in CLI, tool name in MCP) */\n  name: string;\n  /** Type brand for tool identification */\n  readonly _brand: \"Tool\";\n}\n\n/**\n * Any tool type for collections\n */\nexport type AnyTool = Tool<StandardSchemaV1, unknown>;\n\n/**\n * Base app metadata\n */\nexport interface AppMetadata {\n  /** App name */\n  name: string;\n  /** Semantic version */\n  version: string;\n  /** App description */\n  description: string;\n}\n\n/**\n * App definition with tools array\n *\n * @example\n * ```typescript\n * defineApp({\n *   name: \"my-app\",\n *   version: \"0.1.0\",\n *   description: \"My CLI app\",\n *   tools: [greetTool, farewellTool],\n *   instructions: \"When user expresses greeting intent, prefer the greet tool\",\n * })\n * ```\n */\n/**\n * App permissions declaration\n * Simplified user-friendly interface for declaring app permissions\n */\nexport interface AppPermissions {\n  /**\n   * API Keys access - needed to call LLM APIs\n   *\n   * When enabled:\n   * - Grants access to models.getConfigAsync() to retrieve API keys\n   * - Automatically allows network access to common LLM API domains:\n   *   • api.openai.com\n   *   • *.anthropic.com\n   *   • generativelanguage.googleapis.com\n   *   • api.deepseek.com\n   *\n   * @default false\n   */\n  apiKeys?: boolean;\n\n  /**\n   * Sandbox configuration\n   * Uses @anthropic-ai/sandbox-runtime configuration directly\n   *\n   * Defaults when not specified:\n   * - Network: No access (apiKeys=true adds LLM APIs automatically)\n   * - Filesystem: Current directory read/write only\n   * - Protected: ~/.kly, ~/.ssh, ~/.aws, ~/.gnupg always denied\n   *\n   * @example\n   * ```typescript\n   * // Minimal: just need GitHub API access\n   * permissions: {\n   *   sandbox: {\n   *     network: { allowedDomains: [\"api.github.com\"] }\n   *   }\n   * }\n   *\n   * // Full control\n   * permissions: {\n   *   apiKeys: true, // LLM domains added automatically\n   *   sandbox: {\n   *     network: {\n   *       allowedDomains: [\"api.github.com\"] // Add more domains\n   *     },\n   *     filesystem: {\n   *       allowWrite: [\"./output\", \"/tmp\"],\n   *       denyRead: [\"/etc\"]\n   *     }\n   *   }\n   * }\n   * ```\n   */\n  sandbox?: Partial<SandboxRuntimeConfig>;\n}\n\nexport interface AppDefinition<TTools extends AnyTool[] = AnyTool[]>\n  extends AppMetadata {\n  /** Array of tools */\n  tools: TTools;\n  /**\n   * AI instructions for Skill mode\n   * Hints for AI routing when this app is composed with others\n   */\n  instructions?: string;\n  /**\n   * Permissions required by this app\n   * Declare upfront what your app needs to access\n   * @example\n   * ```typescript\n   * permissions: {\n   *   apiKeys: true,\n   *   network: { allow: \"llm-apis\" }\n   * }\n   * ```\n   */\n  permissions?: AppPermissions;\n}\n\n/**\n * Kly app instance returned by defineApp\n */\nexport interface KlyApp<TTools extends AnyTool[] = AnyTool[]> {\n  /** Original app configuration */\n  readonly definition: AppDefinition<TTools>;\n  /** Execute a specific tool by name */\n  execute(toolName: string, args?: Record<string, unknown>): Promise<unknown>;\n  /** Get all available tools */\n  readonly tools: Map<string, AnyTool>;\n}\n\n/**\n * Validation error with structured issues\n */\nexport class ValidationError extends Error {\n  constructor(public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>) {\n    const message = issues\n      .map((issue) => {\n        const path = issue.path\n          ?.map((p) => (typeof p === \"object\" ? p.key : p))\n          .join(\".\");\n        return path ? `${path}: ${issue.message}` : issue.message;\n      })\n      .join(\"\\n\");\n    super(message);\n    this.name = \"ValidationError\";\n  }\n}\n"],"mappings":";;;;AAqTA,IAAa,kBAAb,cAAqC,MAAM;CACzC,YAAY,AAAgBA,QAA+C;EACzE,MAAM,UAAU,OACb,KAAK,UAAU;GACd,MAAM,OAAO,MAAM,MACf,KAAK,MAAO,OAAO,MAAM,WAAW,EAAE,MAAM,EAAG,CAChD,KAAK,IAAI;AACZ,UAAO,OAAO,GAAG,KAAK,IAAI,MAAM,YAAY,MAAM;IAClD,CACD,KAAK,KAAK;AACb,QAAM,QAAQ;EATY;AAU1B,OAAK,OAAO"}

package/dist/ui/components/confirm.d.mts

@@ -0,0 +1,13 @@
+//#region src/ui/components/confirm.d.ts
+/**
+ * Simplified confirm function
+ *
+ * @example
+ * ```typescript
+ * const proceed = await confirm("Continue?", true);
+ * ```
+ */
+declare function confirm(message: string, defaultValue?: boolean): Promise<boolean>;
+//#endregion
+export { confirm };
+//# sourceMappingURL=confirm.d.mts.map

package/dist/ui/components/confirm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirm.d.mts","names":[],"sources":["../../../src/ui/components/confirm.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;iBAAsB,OAAA,2CAGnB"}

package/dist/ui/components/confirm.mjs

@@ -0,0 +1,37 @@
+import { isMCP, isSandbox } from "../../shared/runtime-mode.mjs";
+import { isTTY } from "../utils/tty.mjs";
+import { sendIPCRequest } from "../../sandbox/ipc-client.mjs";
+import * as p from "@clack/prompts";
+
+//#region src/ui/components/confirm.ts
+/**
+* Simplified confirm function
+*
+* @example
+* ```typescript
+* const proceed = await confirm("Continue?", true);
+* ```
+*/
+async function confirm(message, defaultValue = false) {
+	if (isSandbox()) return sendIPCRequest("prompt:confirm", {
+		message,
+		defaultValue
+	});
+	if (!isTTY()) {
+		if (isMCP()) console.warn(`[MCP Warning] Interactive confirmation not available. Using default value (${defaultValue}) for: ${message}`);
+		return defaultValue;
+	}
+	const result = await p.confirm({
+		message,
+		initialValue: defaultValue
+	});
+	if (p.isCancel(result)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	return result;
+}
+
+//#endregion
+export { confirm };
+//# sourceMappingURL=confirm.mjs.map

package/dist/ui/components/confirm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirm.mjs","names":[],"sources":["../../../src/ui/components/confirm.ts"],"sourcesContent":["import * as p from \"@clack/prompts\";\nimport { sendIPCRequest } from \"../../sandbox/ipc-client\";\nimport { isMCP, isSandbox } from \"../../shared/runtime-mode\";\nimport { isTTY } from \"../utils/tty\";\n\n/**\n * Simplified confirm function\n *\n * @example\n * ```typescript\n * const proceed = await confirm(\"Continue?\", true);\n * ```\n */\nexport async function confirm(\n  message: string,\n  defaultValue = false,\n): Promise<boolean> {\n  // Sandbox mode: use IPC to request confirm from host\n  if (isSandbox()) {\n    return sendIPCRequest<boolean>(\"prompt:confirm\", { message, defaultValue });\n  }\n\n  if (!isTTY()) {\n    // In MCP mode, warn about using default value for confirmation\n    if (isMCP()) {\n      console.warn(\n        `[MCP Warning] Interactive confirmation not available. Using default value (${defaultValue}) for: ${message}`,\n      );\n    }\n    return defaultValue;\n  }\n\n  const result = await p.confirm({\n    message,\n    initialValue: defaultValue,\n  });\n\n  if (p.isCancel(result)) {\n    p.cancel(\"Operation cancelled\");\n    process.exit(0);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,eAAsB,QACpB,SACA,eAAe,OACG;AAElB,KAAI,WAAW,CACb,QAAO,eAAwB,kBAAkB;EAAE;EAAS;EAAc,CAAC;AAG7E,KAAI,CAAC,OAAO,EAAE;AAEZ,MAAI,OAAO,CACT,SAAQ,KACN,8EAA8E,aAAa,SAAS,UACrG;AAEH,SAAO;;CAGT,MAAM,SAAS,MAAM,EAAE,QAAQ;EAC7B;EACA,cAAc;EACf,CAAC;AAEF,KAAI,EAAE,SAAS,OAAO,EAAE;AACtB,IAAE,OAAO,sBAAsB;AAC/B,UAAQ,KAAK,EAAE;;AAGjB,QAAO"}

package/dist/ui/components/form.d.mts

@@ -0,0 +1,50 @@
+//#region src/ui/components/form.d.ts
+/**
+ * Field definition for forms
+ */
+interface FormField {
+  /** Field name/key */
+  name: string;
+  /** Display label */
+  label: string;
+  /** Field type */
+  type: "string" | "number" | "boolean" | "enum";
+  /** Whether field is required */
+  required?: boolean;
+  /** Default value */
+  defaultValue?: unknown;
+  /** Description/help text */
+  description?: string;
+  /** Enum options (for type: "enum") */
+  enumValues?: string[];
+}
+/**
+ * Configuration for form component
+ */
+interface FormConfig {
+  /** Form fields */
+  fields: FormField[];
+  /** Form title */
+  title?: string;
+}
+/**
+ * Prompt for multiple fields sequentially
+ *
+ * @example
+ * ```typescript
+ * const values = await form({
+ *   title: "User Registration",
+ *   fields: [
+ *     { name: "name", label: "Your name", type: "string", required: true },
+ *     { name: "age", label: "Your age", type: "number", defaultValue: 18 },
+ *     { name: "role", label: "Role", type: "enum", enumValues: ["admin", "user"] },
+ *     { name: "subscribe", label: "Subscribe to newsletter?", type: "boolean" }
+ *   ]
+ * });
+ * // values: { name: string, age: number, role: string, subscribe: boolean }
+ * ```
+ */
+declare function form(config: FormConfig): Promise<Record<string, unknown>>;
+//#endregion
+export { FormConfig, FormField, form };
+//# sourceMappingURL=form.d.mts.map

package/dist/ui/components/form.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.d.mts","names":[],"sources":["../../../src/ui/components/form.ts"],"sourcesContent":[],"mappings":";;AASA;AAoBA;AAwBsB,UA5CL,SAAA,CA4CS;EAChB;EACC,IAAA,EAAA,MAAA;EAAR;EAAO,KAAA,EAAA,MAAA;;;;;;;;;;;;;;;UA1BO,UAAA;;UAEP;;;;;;;;;;;;;;;;;;;;;iBAsBY,IAAA,SACZ,aACP,QAAQ"}