@majkapp/plugin-kit 1.2.0 → 1.2.1

package/dist/majk-interface-types.d.ts

@@ -0,0 +1,979 @@
+/**
+ * Type definitions for the Majk Interface
+ * These types define what's available to plugins via ctx.majk
+ *
+ * Extracted from majk app interface definitions without implementation dependencies
+ */
+export type EntityId = string;
+export type Unsubscribe = () => void;
+export interface BaseEntity {
+    id: EntityId;
+    createdAt: Date;
+    updatedAt: Date;
+    version: number;
+}
+export type StandardEventType = 'created' | 'updated' | 'deleted';
+export type PluginEventType = 'installing' | 'installed' | 'install_failed' | 'starting' | 'started' | 'start_failed' | 'stopping' | 'stopped' | 'stop_failed' | 'uninstalling' | 'uninstalled' | 'uninstall_failed' | 'reloading' | 'reloaded' | 'reload_failed' | 'enabling' | 'enabled' | 'disabling' | 'disabled';
+export type RepositoryEventType = StandardEventType | PluginEventType;
+export type EntityType = 'message' | 'conversation' | 'agent' | 'tool' | 'project' | 'mcpServer' | 'event' | 'execution' | 'toolGeneration' | 'archivedConversation' | 'teamMember' | 'prompt' | 'workflow' | 'integration' | 'credential' | 'variable' | 'file' | 'workspace' | 'task' | 'notebook' | 'collection' | 'todo' | 'setting' | 'template' | 'snippet' | string;
+export interface RepositoryEvent<T = any> {
+    type: RepositoryEventType;
+    entityType: EntityType;
+    entity: T;
+    timestamp: Date;
+    metadata?: {
+        source?: string;
+        operationId?: string;
+        userId?: string;
+        conversationId?: string;
+        [key: string]: any;
+    };
+}
+export interface EventFilter<T = any> {
+    entityType?: EntityType | EntityType[];
+    eventType?: RepositoryEventType | RepositoryEventType[];
+    entityId?: EntityId | EntityId[];
+    predicate?: (event: RepositoryEvent<T>) => boolean;
+    metadata?: {
+        [key: string]: any;
+    };
+}
+export type EventListener<T = any> = (event: RepositoryEvent<T>) => void | Promise<void>;
+export interface Subscription {
+    unsubscribe: () => void;
+    id: string;
+    filter?: EventFilter<any> | 'ALL_EVENTS';
+}
+export interface QueryBuilder<T = any> {
+    whereType(eventType: RepositoryEventType): QueryBuilder<T>;
+    where(predicate: (event: RepositoryEvent<T>) => boolean): QueryBuilder<T>;
+    subscribe(listener: EventListener<T>): Subscription;
+}
+export interface QueryableEventChannel<T = any> {
+    query(): QueryBuilder<T>;
+    onCreated(listener: (entity: T) => void | Promise<void>): Subscription;
+    onUpdated(listener: (entity: T) => void | Promise<void>): Subscription;
+    onDeleted(listener: (entity: T) => void | Promise<void>): Subscription;
+    subscribe(listener: EventListener<T>, filter?: EventFilter<T>): Subscription;
+}
+export interface EventBusAPI {
+    messages<T = any>(): QueryableEventChannel<T>;
+    conversations<T = any>(): QueryableEventChannel<T>;
+    agents<T = any>(): QueryableEventChannel<T>;
+    tools<T = any>(): QueryableEventChannel<T>;
+    projects<T = any>(): QueryableEventChannel<T>;
+    mcpServers<T = any>(): QueryableEventChannel<T>;
+    integrations<T = any>(): QueryableEventChannel<T>;
+    todos<T = any>(): QueryableEventChannel<T>;
+    channel<T = any>(entityType: string): QueryableEventChannel<T>;
+    subscribe<T = any>(listener: EventListener<T>, filter?: EventFilter<T>): Subscription;
+    subscribeAll<T = any>(listener: (event: RepositoryEvent<T>) => void): Subscription;
+    getDiagnostics(): {
+        channels: string[];
+        stats: {
+            eventsEmitted: Record<string, number>;
+            listenersRegistered: Record<string, number>;
+        };
+        listeners: Array<{
+            entityType: string;
+            count: number;
+        }>;
+        lastEventTime?: Date;
+    };
+}
+export interface PluginInfo {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    type: 'in-process' | 'external-process';
+    enabled: boolean;
+    running: boolean;
+    root: string;
+    health?: PluginHealth;
+    hotReloadEnabled?: boolean;
+}
+export interface PluginHealth {
+    healthy: boolean;
+    errors?: string[];
+    warnings?: string[];
+    lastChecked?: Date;
+}
+export interface PluginCapabilityInfo {
+    type: string;
+    data: any;
+}
+export interface PluginLog {
+    timestamp: Date;
+    level: 'debug' | 'info' | 'warn' | 'error' | 'system' | 'stdout' | 'stderr';
+    message: string;
+    args?: any[];
+}
+export interface InstallPluginOptions {
+    ignoreScripts?: boolean;
+    enableOnInstall?: boolean;
+    startOnInstall?: boolean;
+}
+export interface InstallPluginResult {
+    pluginId: string;
+    version: string;
+    root: string;
+}
+export interface GetLogsOptions {
+    level?: 'debug' | 'info' | 'warn' | 'error' | 'system' | 'stdout' | 'stderr';
+    since?: Date;
+    limit?: number;
+}
+export interface PluginManagementAPI {
+    install(identifier: string, options?: InstallPluginOptions): Promise<InstallPluginResult>;
+    uninstall(pluginId: string): Promise<boolean>;
+    list(): Promise<PluginInfo[]>;
+    get(pluginId: string): Promise<PluginInfo | null>;
+    start(pluginId: string): Promise<void>;
+    stop(pluginId: string): Promise<void>;
+    restart(pluginId: string): Promise<void>;
+    reload(pluginId: string): Promise<void>;
+    enable(pluginId: string): Promise<void>;
+    disable(pluginId: string): Promise<void>;
+    isRunning(pluginId: string): boolean;
+    getHealth(pluginId: string): Promise<PluginHealth | null>;
+    getCapabilities(pluginId: string): Promise<PluginCapabilityInfo[]>;
+    getLogs(pluginId: string, options?: GetLogsOptions): Promise<PluginLog[]>;
+    clearLogs(pluginId: string): Promise<void>;
+    setHotReload(pluginId: string, enabled: boolean): Promise<void>;
+    isHotReloadEnabled(pluginId: string): Promise<boolean>;
+}
+export interface SecretScope {
+    type: 'global' | 'project' | 'integration';
+    id?: string;
+}
+export interface SecretInfo {
+    key: string;
+    scope: SecretScope;
+    description?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    lastUsedAt?: Date;
+    tags?: string[];
+}
+export interface ScopedSecretsAPI {
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    has(key: string): Promise<boolean>;
+    list(): Promise<string[]>;
+    delete(key: string): Promise<boolean>;
+}
+export interface SecretsAPI {
+    set(key: string, value: string, scope?: SecretScope): Promise<void>;
+    get(key: string, scope?: SecretScope): Promise<string | null>;
+    has(key: string, scope?: SecretScope): Promise<boolean>;
+    list(scope?: SecretScope): Promise<SecretInfo[]>;
+    delete(key: string, scope?: SecretScope): Promise<boolean>;
+    forProject(projectId: string): ScopedSecretsAPI;
+    forIntegration(integrationId: string): ScopedSecretsAPI;
+}
+export interface StartTaskRequest {
+    title: string;
+    message: string;
+    agentId?: string;
+    teamMemberId?: string;
+    workingDirectory?: string;
+    context?: Record<string, any>;
+    triggerImmediately?: boolean;
+    taskType?: 'code-project' | 'automation' | 'analysis' | 'chat' | 'research';
+}
+export interface TaskFilter {
+    status?: 'pending' | 'running' | 'completed' | 'failed';
+    agentId?: string;
+    teamMemberId?: string;
+    startedAfter?: Date;
+    startedBefore?: Date;
+}
+export interface TaskMessage {
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: string;
+    timestamp: Date;
+    seq: number;
+}
+export interface TaskProgress {
+    stage?: string;
+    message?: string;
+    percentage?: number;
+    messageCount?: number;
+    toolCall?: {
+        name: string;
+        status: string;
+    };
+}
+export interface TaskResult {
+    success: boolean;
+    output?: any;
+    error?: string;
+    conversationId?: string;
+    duration?: number;
+}
+export interface TaskError {
+    code: string;
+    message: string;
+    details?: any;
+}
+export interface TaskHandle {
+    readonly id: string;
+    readonly conversationId: string;
+    readonly title: string;
+    readonly status: 'pending' | 'running' | 'completed' | 'failed';
+    readonly agentId: string;
+    readonly teamMemberId?: string;
+    readonly startedAt: Date;
+    readonly completedAt?: Date;
+    send(message: string): Promise<void>;
+    waitForCompletion(timeout?: number): Promise<TaskResult>;
+    stop(): Promise<void>;
+    onMessage(handler: (message: TaskMessage) => void): Unsubscribe;
+    onProgress(handler: (progress: TaskProgress) => void): Unsubscribe;
+    onComplete(handler: (result: TaskResult) => void): Unsubscribe;
+    onError(handler: (error: TaskError) => void): Unsubscribe;
+    getMessages(): Promise<TaskMessage[]>;
+    getConversation(): Promise<any>;
+}
+export type TaskEventHandler = (event: TaskEvent) => void;
+export interface TaskEvent {
+    taskId: string;
+    conversationId: string;
+    agentId: string;
+    timestamp: Date;
+}
+export interface TaskAPI {
+    start(request: StartTaskRequest): Promise<TaskHandle>;
+    get(taskId: string): Promise<TaskHandle | null>;
+    list(filter?: TaskFilter): Promise<TaskHandle[]>;
+    onTaskStarted(handler: TaskEventHandler): Unsubscribe;
+    onTaskCompleted(handler: TaskEventHandler): Unsubscribe;
+    onTaskFailed(handler: TaskEventHandler): Unsubscribe;
+}
+export type AccountType = 'aws-cognito' | 'azure-entra' | 'gcp-iam' | 'api-key' | 'system-default' | string;
+export interface AccountMetadata {
+    region?: string;
+    createdAt: Date;
+    lastUsedAt?: Date;
+    [key: string]: any;
+}
+export interface TimeWindow {
+    milliseconds?: number;
+    seconds?: number;
+    minutes?: number;
+    hours?: number;
+}
+export interface CredentialOptions {
+    forceRefresh?: boolean;
+    purpose?: string;
+    timeout?: number;
+}
+export interface RefreshOptions {
+    force?: boolean;
+}
+export interface RefreshResult {
+    success: boolean;
+    expiresAt?: Date;
+    error?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    reason?: string;
+    details?: any;
+}
+export interface TokenInfo {
+    expiresAt: Date;
+    issuedAt: Date;
+    timeUntilExpiry: number;
+    isExpired: boolean;
+    scopes?: string[];
+}
+export interface AutoRefreshConfig {
+    beforeExpiry: TimeWindow;
+    onRefresh?: (result: RefreshResult) => void;
+    onError?: (error: Error) => void;
+}
+export interface AutoRefreshHandle {
+    stop(): void;
+    isActive(): boolean;
+    refresh(): Promise<RefreshResult>;
+}
+export interface AwsSdkCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+    expiration?: Date;
+}
+export interface CognitoTokenSet {
+    idToken: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: Date;
+}
+export interface AzureSdkCredentials {
+    accessToken: string;
+    subscriptionId: string;
+    tenantId: string;
+    expiration?: Date;
+}
+export interface AccountJSON {
+    id: string;
+    name: string;
+    type: AccountType;
+    expiresAt?: string;
+    metadata: AccountMetadata;
+}
+interface BaseCredentials {
+    accountType: AccountType;
+    accountId: string;
+    expiresAt?: Date;
+    metadata: {
+        issuedAt: Date;
+        region?: string;
+        [key: string]: any;
+    };
+}
+export interface AwsCognitoCredentials extends BaseCredentials {
+    accountType: 'aws-cognito';
+    bearerToken: string;
+    aws: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken: string;
+        region: string;
+    };
+    cognito: {
+        idToken: string;
+        accessToken: string;
+        refreshToken: string;
+    };
+}
+export interface AzureEntraCredentials extends BaseCredentials {
+    accountType: 'azure-entra';
+    bearerToken: string;
+    azure: {
+        accessToken: string;
+        subscriptionId: string;
+        tenantId: string;
+        region: string;
+    };
+}
+export interface ApiKeyCredentials extends BaseCredentials {
+    accountType: 'api-key';
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface SystemDefaultCredentials extends BaseCredentials {
+    accountType: 'system-default';
+}
+export type Credentials = AwsCognitoCredentials | AzureEntraCredentials | ApiKeyCredentials | SystemDefaultCredentials;
+export interface SystemAccount {
+    readonly id: string;
+    readonly name: string;
+    readonly type: AccountType;
+    readonly expiresAt?: Date;
+    readonly metadata: AccountMetadata;
+    getCredentials(options?: CredentialOptions): Promise<Credentials>;
+    isValid(): Promise<boolean>;
+    isExpired(): boolean;
+    isExpiringSoon(window?: TimeWindow): boolean;
+    isOAuthAccount(): this is OAuthAccount;
+    isAwsAccount(): this is AwsAccount;
+    isAzureAccount(): this is AzureAccount;
+    toJSON(): AccountJSON;
+}
+export interface OAuthAccount extends SystemAccount {
+    refresh(options?: RefreshOptions): Promise<RefreshResult>;
+    validate(): Promise<ValidationResult>;
+    getTokenInfo(): Promise<TokenInfo>;
+    autoRefresh(config: AutoRefreshConfig): AutoRefreshHandle;
+}
+export interface AwsAccount extends OAuthAccount {
+    type: 'aws-cognito';
+    getRegion(): string;
+    getBedrockToken(): Promise<string>;
+    getAwsCredentials(): Promise<AwsSdkCredentials>;
+    getCognitoTokens(): Promise<CognitoTokenSet>;
+}
+export interface AzureAccount extends OAuthAccount {
+    type: 'azure-entra';
+    getRegion(): string;
+    getAzureToken(): Promise<string>;
+    getAzureCredentials(): Promise<AzureSdkCredentials>;
+}
+export type AuthEvent = AuthStateChangeEvent | AuthTokenRefreshedEvent | AuthErrorEvent | AccountChangedEvent;
+export interface AuthStateChangeEvent {
+    type: 'auth:state-changed';
+    isAuthenticated: boolean;
+    accountId?: string;
+    accountType?: AccountType;
+    timestamp: Date;
+}
+export interface AuthTokenRefreshedEvent {
+    type: 'auth:token-refreshed';
+    accountId: string;
+    expiresAt: Date;
+    timestamp: Date;
+}
+export interface AuthErrorEvent {
+    type: 'auth:error';
+    error: string;
+    accountId?: string;
+    timestamp: Date;
+}
+export interface AccountChangedEvent {
+    type: 'auth:account-changed';
+    action: 'added' | 'removed' | 'updated' | 'selected';
+    accountId: string;
+    accountType: AccountType;
+    timestamp: Date;
+}
+export interface AuthAPI {
+    getAccount(): Promise<SystemAccount | null>;
+    getAccountsOfType(type: AccountType | '*'): Promise<SystemAccount[]>;
+    getCredentials(options?: CredentialOptions): Promise<Credentials>;
+    isAuthenticated(): Promise<boolean>;
+}
+export interface Message extends BaseEntity {
+    conversationId: string;
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: string;
+    seq: number;
+}
+export interface Conversation extends BaseEntity {
+    agentId: string;
+    title: string;
+    status: 'active' | 'completed' | 'failed' | 'cancelled';
+    messageCount: number;
+    lastMessageAt?: Date;
+    workingDirectory?: string;
+    projectId?: string;
+    teamMemberId?: string;
+    startedAt?: Date;
+    endedAt?: Date;
+    completion?: any;
+    metadata?: Record<string, any>;
+}
+export interface Agent extends BaseEntity {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    mcpServerIds: string[];
+    isActive: boolean;
+    tags: string[];
+    configuration?: {
+        streaming?: boolean;
+        timeout?: number;
+        retryAttempts?: number;
+        rateLimiting?: {
+            requestsPerMinute?: number;
+            tokensPerMinute?: number;
+        };
+        customHeaders?: Record<string, string>;
+    };
+}
+export interface TeamMemberSkills {
+    primary: string[];
+    secondary: string[];
+    languages: string[];
+    frameworks: string[];
+    tools: string[];
+}
+export interface TeamMemberPersonality {
+    workStyle?: string;
+    codeStyle?: string;
+    reviewStyle?: string;
+    communicationStyle?: string;
+}
+export interface TeamMemberCodeStats {
+    linesWritten: number;
+    filesModified: number;
+    testsWritten: number;
+    reviewsPassed: number;
+    commitsCreated: number;
+}
+export interface TeamMemberMetadata {
+    totalTasks: number;
+    successfulTasks: number;
+    projectHistory: string[];
+    codeStats: TeamMemberCodeStats;
+    [key: string]: any;
+}
+export interface TeamMember extends BaseEntity {
+    name: string;
+    role: string;
+    skills: TeamMemberSkills;
+    systemPrompt?: string;
+    model?: string;
+    mcpServerIds: string[];
+    projectIds: string[];
+    isActive: boolean;
+    personality: TeamMemberPersonality;
+    expertise: string[];
+    metadata: TeamMemberMetadata;
+    avatar?: string;
+    title?: string;
+    tags?: string[];
+}
+export interface Todo extends BaseEntity {
+    title: string;
+    description?: string;
+    status: 'pending' | 'active' | 'completed';
+    priority: 'low' | 'medium' | 'high';
+    assignedTo?: string;
+    projectId?: string;
+    conversationIds: string[];
+    metadata?: Record<string, any>;
+}
+export type WorkStrategy = 'autonomous' | 'collaborative' | 'supervised' | 'manual' | string;
+export interface Project extends BaseEntity {
+    name: string;
+    description?: string;
+    path: string;
+    workStrategy: WorkStrategy;
+    teamMemberIds: string[];
+}
+export interface MCPServer extends BaseEntity {
+    name: string;
+    description?: string;
+    type: 'local' | 'remote' | 'docker';
+    status: string;
+    connectionConfig: any;
+    toolIds: string[];
+}
+export interface ConversationFilter {
+    status?: 'active' | 'completed' | 'failed' | 'cancelled';
+    agentId?: string;
+    projectId?: string;
+    teamMemberId?: string;
+    createdAfter?: Date;
+    createdBefore?: Date;
+}
+export interface MessageQueryOptions {
+    limit?: number;
+    beforeSeq?: number;
+    afterSeq?: number;
+}
+export interface ConversationHandle {
+    readonly id: string;
+    readonly agentId: string;
+    readonly title: string;
+    readonly status: 'active' | 'completed' | 'failed' | 'cancelled';
+    readonly messageCount: number;
+    readonly lastMessageAt?: Date;
+    readonly workingDirectory?: string;
+    readonly projectId?: string;
+    readonly teamMemberId?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly version: number;
+    refresh(): Promise<void>;
+    getMessages(options?: MessageQueryOptions): Promise<Message[]>;
+    send(message: string): Promise<void>;
+    getAgent(): Promise<any>;
+    onChange(handler: (entity: Conversation) => void): Unsubscribe;
+    onDelete(handler: () => void): Unsubscribe;
+    toEntity(): Conversation;
+}
+export interface ConversationAPI {
+    get(id: string): Promise<ConversationHandle | null>;
+    list(filter?: ConversationFilter): Promise<ConversationHandle[]>;
+    exists(id: string): Promise<boolean>;
+    count(filter?: ConversationFilter): Promise<number>;
+    search(query: string): Promise<ConversationHandle[]>;
+    channel(): any;
+}
+export interface CreateTeammateRequest {
+    name: string;
+    role: string;
+    skills?: TeamMemberSkills;
+    systemPrompt?: string;
+    model?: string;
+    mcpServerIds?: string[];
+    personality?: TeamMemberPersonality;
+    expertise?: string[];
+    metadata?: Partial<TeamMemberMetadata>;
+    avatar?: string;
+    title?: string;
+    tags?: string[];
+}
+export interface TeammateUpdate {
+    name?: string;
+    role?: string;
+    skills?: TeamMemberSkills;
+    systemPrompt?: string;
+    model?: string;
+    mcpServerIds?: string[];
+    isActive?: boolean;
+    personality?: TeamMemberPersonality;
+    expertise?: string[];
+    metadata?: Partial<TeamMemberMetadata>;
+    avatar?: string;
+    title?: string;
+    tags?: string[];
+}
+export interface TeammateFilter {
+    role?: string;
+    isActive?: boolean;
+    projectId?: string;
+}
+export interface TeammateHandle {
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+    readonly skills: TeamMemberSkills;
+    readonly systemPrompt?: string;
+    readonly model?: string;
+    readonly mcpServerIds: string[];
+    readonly projectIds: string[];
+    readonly isActive: boolean;
+    readonly personality: TeamMemberPersonality;
+    readonly expertise: string[];
+    readonly metadata: TeamMemberMetadata;
+    readonly avatar?: string;
+    readonly title?: string;
+    readonly tags?: string[];
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly version: number;
+    refresh(): Promise<void>;
+    update(updates: Partial<TeamMember>): Promise<void>;
+    delete(): Promise<boolean>;
+    assignToProject(projectId: string): Promise<void>;
+    unassignFromProject(projectId: string): Promise<void>;
+    getProjects(): Promise<any[]>;
+    onChange(handler: (entity: TeamMember) => void): Unsubscribe;
+    onDelete(handler: () => void): Unsubscribe;
+    toEntity(): TeamMember;
+}
+export interface TeammateAPI {
+    create(data: CreateTeammateRequest): Promise<TeammateHandle>;
+    get(id: string): Promise<TeammateHandle | null>;
+    list(filter?: TeammateFilter): Promise<TeammateHandle[]>;
+    update(id: string, updates: TeammateUpdate): Promise<TeammateHandle>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    count(filter?: TeammateFilter): Promise<number>;
+    channel(): any;
+}
+export interface CreateTodoRequest {
+    title: string;
+    description?: string;
+    status?: 'pending' | 'active' | 'completed';
+    priority?: 'low' | 'medium' | 'high';
+    assignedTo?: string;
+    projectId?: string;
+    metadata?: Record<string, any>;
+}
+export interface TodoUpdate {
+    title?: string;
+    description?: string;
+    status?: 'pending' | 'active' | 'completed';
+    priority?: 'low' | 'medium' | 'high';
+    assignedTo?: string;
+    projectId?: string;
+    metadata?: Record<string, any>;
+}
+export interface TodoFilter {
+    status?: 'pending' | 'active' | 'completed';
+    priority?: 'low' | 'medium' | 'high';
+    assignedTo?: string;
+    projectId?: string;
+}
+export interface SpawnOptions {
+    message?: string;
+    agentId?: string;
+    triggerImmediately?: boolean;
+}
+export interface TodoHandle {
+    readonly id: string;
+    readonly title: string;
+    readonly description?: string;
+    readonly status: 'pending' | 'active' | 'completed';
+    readonly priority: 'low' | 'medium' | 'high';
+    readonly assignedTo?: string;
+    readonly projectId?: string;
+    readonly conversationIds: string[];
+    readonly metadata?: Record<string, any>;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly version: number;
+    refresh(): Promise<void>;
+    update(updates: Partial<Todo>): Promise<void>;
+    delete(): Promise<boolean>;
+    complete(): Promise<void>;
+    assignTo(teammateId: string): Promise<void>;
+    linkToConversation(conversationId: string): Promise<void>;
+    spawn(options?: SpawnOptions): Promise<TaskHandle>;
+    onChange(handler: (entity: Todo) => void): Unsubscribe;
+    onDelete(handler: () => void): Unsubscribe;
+    toEntity(): Todo;
+}
+export interface TodoAPI {
+    create(data: CreateTodoRequest): Promise<TodoHandle>;
+    get(id: string): Promise<TodoHandle | null>;
+    list(filter?: TodoFilter): Promise<TodoHandle[]>;
+    update(id: string, updates: TodoUpdate): Promise<TodoHandle>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    count(filter?: TodoFilter): Promise<number>;
+    channel(): any;
+}
+export interface CreateProjectRequest {
+    name: string;
+    description?: string;
+    path: string;
+    workStrategy?: WorkStrategy;
+    teamMemberIds?: string[];
+}
+export interface ProjectUpdate {
+    name?: string;
+    description?: string;
+    path?: string;
+    workStrategy?: WorkStrategy;
+    teamMemberIds?: string[];
+}
+export interface ProjectFilter {
+    teamMemberId?: string;
+}
+export interface ProjectHandle {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly path: string;
+    readonly workStrategy: WorkStrategy;
+    readonly teamMemberIds: string[];
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly version: number;
+    refresh(): Promise<void>;
+    update(updates: Partial<Project>): Promise<void>;
+    delete(): Promise<boolean>;
+    addTeammate(teammateId: string): Promise<void>;
+    removeTeammate(teammateId: string): Promise<void>;
+    getTeammates(): Promise<any[]>;
+    setWorkStrategy(strategy: WorkStrategy): Promise<void>;
+    onChange(handler: (entity: Project) => void): Unsubscribe;
+    onDelete(handler: () => void): Unsubscribe;
+    toEntity(): Project;
+}
+export interface ProjectAPI {
+    create(data: CreateProjectRequest): Promise<ProjectHandle>;
+    get(id: string): Promise<ProjectHandle | null>;
+    list(filter?: ProjectFilter): Promise<ProjectHandle[]>;
+    update(id: string, updates: ProjectUpdate): Promise<ProjectHandle>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    count(filter?: ProjectFilter): Promise<number>;
+    channel(): any;
+}
+export interface CreateMCPServerRequest {
+    name: string;
+    description?: string;
+    type: 'local' | 'remote' | 'docker';
+    connectionConfig: {
+        command?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        workingDirectory?: string;
+        url?: string;
+    };
+}
+export interface MCPServerUpdate {
+    name?: string;
+    description?: string;
+    connectionConfig?: {
+        command?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        workingDirectory?: string;
+        url?: string;
+    };
+}
+export interface MCPServerFilter {
+    type?: 'local' | 'remote' | 'docker';
+    status?: 'connected' | 'disconnected' | 'error';
+}
+export interface ConnectionTestResult {
+    success: boolean;
+    error?: string;
+    latency?: number;
+}
+export interface MCPServerHandle {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly type: 'local' | 'remote' | 'docker';
+    readonly status: string;
+    readonly connectionConfig: any;
+    readonly toolIds: string[];
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly version: number;
+    refresh(): Promise<void>;
+    update(updates: Partial<MCPServer>): Promise<void>;
+    delete(): Promise<boolean>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    testConnection(): Promise<ConnectionTestResult>;
+    getTools(): Promise<any[]>;
+    onChange(handler: (entity: MCPServer) => void): Unsubscribe;
+    onDelete(handler: () => void): Unsubscribe;
+    toEntity(): MCPServer;
+}
+export interface MCPServerAPI {
+    create(data: CreateMCPServerRequest): Promise<MCPServerHandle>;
+    get(id: string): Promise<MCPServerHandle | null>;
+    list(filter?: MCPServerFilter): Promise<MCPServerHandle[]>;
+    update(id: string, updates: MCPServerUpdate): Promise<MCPServerHandle>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    count(filter?: MCPServerFilter): Promise<number>;
+    channel(): any;
+}
+export interface CreateAgentRequest {
+    name: string;
+    description?: string;
+    systemPrompt: string;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    mcpServerIds?: string[];
+    configuration?: {
+        streaming?: boolean;
+        timeout?: number;
+        retryAttempts?: number;
+        rateLimiting?: {
+            requestsPerMinute?: number;
+            tokensPerMinute?: number;
+        };
+        customHeaders?: Record<string, string>;
+    };
+    tags?: string[];
+    isActive?: boolean;
+}
+export interface AgentUpdate {
+    name?: string;
+    description?: string;
+    systemPrompt?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    mcpServerIds?: string[];
+    configuration?: {
+        streaming?: boolean;
+        timeout?: number;
+        retryAttempts?: number;
+        rateLimiting?: {
+            requestsPerMinute?: number;
+            tokensPerMinute?: number;
+        };
+        customHeaders?: Record<string, string>;
+    };
+    tags?: string[];
+    isActive?: boolean;
+}
+export interface AgentFilter {
+    isActive?: boolean;
+    model?: string;
+    tags?: string[];
+}
+export interface TestResult {
+    success: boolean;
+    response?: string;
+    error?: string;
+    duration?: number;
+}
+export interface AgentHandle {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly systemPrompt: string;
+    readonly model: string;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly mcpServerIds: string[];
+    readonly isActive: boolean;
+    readonly tags: string[];
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly version: number;
+    refresh(): Promise<void>;
+    update(updates: Partial<Agent>): Promise<void>;
+    delete(): Promise<boolean>;
+    test(message: string): Promise<TestResult>;
+    clone(modifications?: Partial<CreateAgentRequest>): Promise<AgentHandle>;
+    getMCPServers(): Promise<any[]>;
+    addMCPServer(serverId: string): Promise<void>;
+    removeMCPServer(serverId: string): Promise<void>;
+    onChange(handler: (entity: Agent) => void): Unsubscribe;
+    onDelete(handler: () => void): Unsubscribe;
+    toEntity(): Agent;
+}
+export interface AgentAPI {
+    create(data: CreateAgentRequest): Promise<AgentHandle>;
+    get(id: string): Promise<AgentHandle | null>;
+    list(filter?: AgentFilter): Promise<AgentHandle[]>;
+    update(id: string, updates: AgentUpdate): Promise<AgentHandle>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    count(filter?: AgentFilter): Promise<number>;
+    test(agentId: string, message: string): Promise<TestResult>;
+    clone(agentId: string, modifications?: Partial<CreateAgentRequest>): Promise<AgentHandle>;
+    channel(): any;
+}
+export interface AddKnowledgeInput {
+    conversationId: string;
+    title: string;
+    content: string;
+    references?: string[];
+    tree?: string;
+}
+export interface KnowledgeNode {
+    id: string;
+    title: string;
+    content: string;
+    references: string[];
+    conversationId: string;
+    tree: string;
+    createdAt: Date;
+}
+export interface KnowledgeTree {
+    name: string;
+    conversationId: string;
+    nodes: KnowledgeNode[];
+}
+export interface KnowledgeSearchOptions {
+    conversationId?: string;
+    tree?: string;
+    limit?: number;
+}
+export interface KnowledgeAPI {
+    add(input: AddKnowledgeInput): Promise<void>;
+    search(query: string, options?: KnowledgeSearchOptions): Promise<KnowledgeNode[]>;
+    getByReference(ref: string): Promise<KnowledgeNode[]>;
+    getTree(conversationId: string, treeName: string): Promise<KnowledgeTree>;
+    listTrees(conversationId: string): Promise<string[]>;
+}
+export interface MajkInterface {
+    readonly version: string;
+    readonly plugins: PluginManagementAPI;
+    readonly secrets: SecretsAPI;
+    readonly tasks: TaskAPI;
+    readonly eventBus: EventBusAPI;
+    readonly auth: AuthAPI;
+    readonly conversations: ConversationAPI;
+    readonly todos: TodoAPI;
+    readonly projects: ProjectAPI;
+    readonly teammates: TeammateAPI;
+    readonly mcpServers: MCPServerAPI;
+    readonly knowledge: KnowledgeAPI;
+    readonly agents: AgentAPI;
+}
+export {};
+//# sourceMappingURL=majk-interface-types.d.ts.map