@clinebot/core 0.0.0

package/README.md

@@ -0,0 +1,88 @@
+# @clinebot/core
+
+`@clinebot/core` is the stateful orchestration layer of the Cline SDK. It
+connects the agent runtime, provider settings, storage, default tools, and
+session lifecycle into a host-ready runtime.
+
+## What You Get
+
+- session lifecycle and orchestration primitives
+- provider settings and account services
+- default runtime tools and MCP integration
+- storage-backed session and team state helpers
+- host-facing Node helpers through `@clinebot/core/server`
+
+## Installation
+
+```bash
+npm install @clinebot/core
+```
+
+## Entry Points
+
+- `@clinebot/core`: runtime-agnostic core contracts and shared utilities
+- `@clinebot/core/server`: Node/server helpers for building hosts and runtimes
+
+## Typical Usage
+
+Most host apps should start with `@clinebot/core/server`.
+
+```ts
+import { createSessionHost } from "@clinebot/core/server";
+
+const host = await createSessionHost({});
+
+const result = await host.start({
+	config: {
+		providerId: "anthropic",
+		modelId: "claude-sonnet-4-6",
+		apiKey: process.env.ANTHROPIC_API_KEY ?? "",
+		cwd: process.cwd(),
+		enableTools: true,
+		systemPrompt: "You are a concise assistant.",
+	},
+	prompt: "Summarize this project.",
+	interactive: false,
+});
+
+console.log(result.result?.text);
+await host.dispose();
+```
+
+## Main APIs
+
+### Runtime and Sessions
+
+Use `@clinebot/core/server` for host-facing runtime assembly:
+
+- `createSessionHost(...)`
+- `DefaultSessionManager`
+- `DefaultRuntimeBuilder`
+
+### Default Tools
+
+`@clinebot/core` owns the built-in host tools and executors:
+
+- `createBuiltinTools(...)`
+- `createDefaultTools(...)`
+- `createDefaultExecutors(...)`
+
+### Storage and Settings
+
+The package also exports storage and settings helpers such as:
+
+- `ProviderSettingsManager`
+- `SqliteTeamStore`
+- SQLite RPC session backend helpers from `@clinebot/core/server`
+
+## Related Packages
+
+- `@clinebot/agents`: stateless agent loop and tool primitives
+- `@clinebot/llms`: provider/model configuration and handlers
+- `@clinebot/rpc`: remote session and runtime transport
+
+## More Examples
+
+- Repo examples: [apps/examples/cline-sdk](https://github.com/cline/cline/tree/main/apps/examples/cline-sdk)
+- Workspace overview: [README.md](https://github.com/cline/cline/blob/main/README.md)
+- API and architecture references: [DOC.md](https://github.com/cline/cline/blob/main/DOC.md), [ARCHITECTURE.md](https://github.com/cline/cline/blob/main/ARCHITECTURE.md)

package/dist/account/cline-account-service.d.ts

@@ -0,0 +1,34 @@
+import type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser } from "./types";
+export interface ClineAccountServiceOptions {
+    apiBaseUrl: string;
+    getAuthToken: () => Promise<string | undefined | null>;
+    getCurrentUserId?: () => Promise<string | undefined | null> | string | undefined | null;
+    getOrganizationMemberId?: (organizationId: string) => Promise<string | undefined | null> | string | undefined | null;
+    getHeaders?: () => Promise<Record<string, string> | undefined> | Record<string, string> | undefined;
+    requestTimeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export declare class ClineAccountService {
+    private readonly apiBaseUrl;
+    private readonly getAuthTokenFn;
+    private readonly getCurrentUserIdFn;
+    private readonly getOrganizationMemberIdFn;
+    private readonly getHeadersFn;
+    private readonly requestTimeoutMs;
+    private readonly fetchImpl;
+    constructor(options: ClineAccountServiceOptions);
+    fetchMe(): Promise<ClineAccountUser>;
+    fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+    fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
+    fetchPaymentTransactions(userId?: string): Promise<ClineAccountPaymentTransaction[]>;
+    fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+    fetchOrganizationBalance(organizationId: string): Promise<ClineAccountOrganizationBalance>;
+    fetchOrganizationUsageTransactions(input: {
+        organizationId: string;
+        memberId?: string;
+    }): Promise<ClineAccountOrganizationUsageTransaction[]>;
+    switchAccount(organizationId?: string | null): Promise<void>;
+    private resolveUserId;
+    private resolveOrganizationMemberId;
+    private request;
+}

package/dist/account/index.d.ts

@@ -0,0 +1,3 @@
+export { ClineAccountService, type ClineAccountServiceOptions, } from "./cline-account-service";
+export { type ClineAccountOperations, executeRpcClineAccountAction, isRpcClineAccountActionRequest, RpcClineAccountService, type RpcProviderActionExecutor, } from "./rpc";
+export type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, } from "./types";

package/dist/account/rpc.d.ts

@@ -0,0 +1,38 @@
+import type { RpcClineAccountActionRequest, RpcProviderActionRequest } from "@clinebot/shared";
+import type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser } from "./types";
+export interface ClineAccountOperations {
+    fetchMe(): Promise<ClineAccountUser>;
+    fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+    fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
+    fetchPaymentTransactions(userId?: string): Promise<ClineAccountPaymentTransaction[]>;
+    fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+    fetchOrganizationBalance(organizationId: string): Promise<ClineAccountOrganizationBalance>;
+    fetchOrganizationUsageTransactions(input: {
+        organizationId: string;
+        memberId?: string;
+    }): Promise<ClineAccountOrganizationUsageTransaction[]>;
+    switchAccount(organizationId?: string | null): Promise<void>;
+}
+export declare function isRpcClineAccountActionRequest(request: RpcProviderActionRequest): request is RpcClineAccountActionRequest;
+export declare function executeRpcClineAccountAction(request: RpcClineAccountActionRequest, service: ClineAccountOperations): Promise<unknown>;
+export interface RpcProviderActionExecutor {
+    runProviderAction(request: RpcProviderActionRequest): Promise<{
+        result: unknown;
+    }>;
+}
+export declare class RpcClineAccountService implements ClineAccountOperations {
+    private readonly executor;
+    constructor(executor: RpcProviderActionExecutor);
+    fetchMe(): Promise<ClineAccountUser>;
+    fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+    fetchUsageTransactions(userId?: string): Promise<ClineAccountUsageTransaction[]>;
+    fetchPaymentTransactions(userId?: string): Promise<ClineAccountPaymentTransaction[]>;
+    fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+    fetchOrganizationBalance(organizationId: string): Promise<ClineAccountOrganizationBalance>;
+    fetchOrganizationUsageTransactions(input: {
+        organizationId: string;
+        memberId?: string;
+    }): Promise<ClineAccountOrganizationUsageTransaction[]>;
+    switchAccount(organizationId?: string | null): Promise<void>;
+    private request;
+}

package/dist/account/types.d.ts

@@ -0,0 +1,74 @@
+export interface ClineAccountOrganization {
+    active: boolean;
+    memberId: string;
+    name: string;
+    organizationId: string;
+    roles: Array<"admin" | "member" | "owner">;
+}
+export interface ClineAccountUser {
+    id: string;
+    email: string;
+    displayName: string;
+    photoUrl: string;
+    createdAt: string;
+    updatedAt: string;
+    organizations: ClineAccountOrganization[];
+}
+export interface ClineAccountBalance {
+    balance: number;
+    userId: string;
+}
+export interface ClineAccountUsageTransaction {
+    aiInferenceProviderName: string;
+    aiModelName: string;
+    aiModelTypeName: string;
+    completionTokens: number;
+    costUsd: number;
+    createdAt: string;
+    creditsUsed: number;
+    generationId: string;
+    id: string;
+    metadata: {
+        additionalProp1: string;
+        additionalProp2: string;
+        additionalProp3: string;
+    };
+    operation?: string;
+    organizationId: string;
+    promptTokens: number;
+    totalTokens: number;
+    userId: string;
+}
+export interface ClineAccountPaymentTransaction {
+    paidAt: string;
+    creatorId: string;
+    amountCents: number;
+    credits: number;
+}
+export interface ClineAccountOrganizationBalance {
+    balance: number;
+    organizationId: string;
+}
+export interface ClineAccountOrganizationUsageTransaction {
+    aiInferenceProviderName: string;
+    aiModelName: string;
+    aiModelTypeName: string;
+    completionTokens: number;
+    costUsd: number;
+    createdAt: string;
+    creditsUsed: number;
+    generationId: string;
+    id: string;
+    memberDisplayName: string;
+    memberEmail: string;
+    metadata: {
+        additionalProp1: string;
+        additionalProp2: string;
+        additionalProp3: string;
+    };
+    operation?: string;
+    organizationId: string;
+    promptTokens: number;
+    totalTokens: number;
+    userId: string;
+}

package/dist/agents/agent-config-loader.d.ts

@@ -0,0 +1,18 @@
+import { AGENT_CONFIG_DIRECTORY_NAME, resolveDocumentsAgentConfigDirectoryPath } from "@clinebot/shared/storage";
+import { type AgentYamlConfig } from "./agent-config-parser";
+import { type UnifiedConfigDefinition, UnifiedConfigFileWatcher, type UnifiedConfigWatcherEvent } from "./unified-config-file-watcher";
+export type { AgentYamlConfig, BuildAgentConfigOverridesOptions, ParseYamlFrontmatterResult, } from "./agent-config-parser";
+export { parseAgentConfigFromYaml, parsePartialAgentConfigFromYaml, resolveAgentTools, toPartialAgentConfig, } from "./agent-config-parser";
+export type AgentConfigWatcher = UnifiedConfigFileWatcher<"agent", AgentYamlConfig>;
+export type AgentConfigWatcherEvent = UnifiedConfigWatcherEvent<"agent", AgentYamlConfig>;
+export { AGENT_CONFIG_DIRECTORY_NAME, resolveDocumentsAgentConfigDirectoryPath, };
+export declare function resolveAgentsConfigDirPath(): string;
+export declare function resolveAgentConfigSearchPaths(): string[];
+export interface CreateAgentConfigWatcherOptions {
+    directoryPathOrPaths?: string | ReadonlyArray<string>;
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export declare function createAgentConfigDefinition(directoryPathOrPaths?: string | ReadonlyArray<string>): UnifiedConfigDefinition<"agent", AgentYamlConfig>;
+export declare function createAgentConfigWatcher(options?: CreateAgentConfigWatcherOptions): AgentConfigWatcher;
+export declare function readAgentConfigsFromDisk(directoryPathOrPaths?: string | ReadonlyArray<string>): Promise<Map<string, AgentYamlConfig>>;

package/dist/agents/agent-config-parser.d.ts

@@ -0,0 +1,25 @@
+import type { AgentConfig, Tool } from "@clinebot/agents";
+import { type DefaultToolName } from "../default-tools";
+export interface AgentYamlConfig {
+    name: string;
+    description: string;
+    modelId?: string;
+    tools: DefaultToolName[];
+    skills?: string[];
+    systemPrompt: string;
+}
+export interface ParseYamlFrontmatterResult {
+    data: Record<string, unknown>;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError?: string;
+}
+export interface BuildAgentConfigOverridesOptions {
+    availableTools?: ReadonlyArray<Tool>;
+}
+export declare function isAgentConfigYamlFile(fileName: string): boolean;
+export declare function normalizeAgentConfigName(name: string): string;
+export declare function parseAgentConfigFromYaml(content: string): AgentYamlConfig;
+export declare function resolveAgentTools(toolNames: ReadonlyArray<DefaultToolName>, availableTools: ReadonlyArray<Tool>): Tool[];
+export declare function toPartialAgentConfig(config: AgentYamlConfig, options?: BuildAgentConfigOverridesOptions): Partial<Pick<AgentConfig, "modelId" | "systemPrompt" | "tools">>;
+export declare function parsePartialAgentConfigFromYaml(content: string, options?: BuildAgentConfigOverridesOptions): Partial<Pick<AgentConfig, "modelId" | "systemPrompt" | "tools">>;

package/dist/agents/hooks-config-loader.d.ts

@@ -0,0 +1,23 @@
+import type { HookEventName } from "@clinebot/agents";
+import { HOOKS_CONFIG_DIRECTORY_NAME, resolveDocumentsHooksDirectoryPath } from "@clinebot/shared/storage";
+export { HOOKS_CONFIG_DIRECTORY_NAME, resolveDocumentsHooksDirectoryPath };
+export declare function resolveHooksConfigSearchPaths(workspacePath?: string): string[];
+export declare enum HookConfigFileName {
+    TaskStart = "TaskStart",
+    TaskResume = "TaskResume",
+    TaskCancel = "TaskCancel",
+    TaskComplete = "TaskComplete",
+    PreToolUse = "PreToolUse",
+    PostToolUse = "PostToolUse",
+    UserPromptSubmit = "UserPromptSubmit",
+    PreCompact = "PreCompact",
+    SessionShutdown = "SessionShutdown"
+}
+export declare const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<Record<HookConfigFileName, HookEventName | undefined>>;
+export declare function toHookConfigFileName(fileName: string): HookConfigFileName | undefined;
+export interface HookConfigFileEntry {
+    fileName: HookConfigFileName;
+    hookEventName?: HookEventName;
+    path: string;
+}
+export declare function listHookConfigFiles(workspacePath?: string): HookConfigFileEntry[];

package/dist/agents/index.d.ts

@@ -0,0 +1,11 @@
+export type { AgentConfigWatcher, AgentConfigWatcherEvent, AgentYamlConfig, BuildAgentConfigOverridesOptions, CreateAgentConfigWatcherOptions, ParseYamlFrontmatterResult, } from "./agent-config-loader";
+export { AGENT_CONFIG_DIRECTORY_NAME, createAgentConfigDefinition, createAgentConfigWatcher, parseAgentConfigFromYaml, parsePartialAgentConfigFromYaml, readAgentConfigsFromDisk, resolveAgentConfigSearchPaths, resolveAgentsConfigDirPath, resolveAgentTools, resolveDocumentsAgentConfigDirectoryPath, toPartialAgentConfig, } from "./agent-config-loader";
+export { HOOK_CONFIG_FILE_EVENT_MAP, HOOKS_CONFIG_DIRECTORY_NAME, type HookConfigFileEntry, HookConfigFileName, listHookConfigFiles, resolveDocumentsHooksDirectoryPath, resolveHooksConfigSearchPaths, toHookConfigFileName, } from "./hooks-config-loader";
+export type { ResolveAgentPluginPathsOptions } from "./plugin-config-loader";
+export { discoverPluginModulePaths, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, } from "./plugin-config-loader";
+export type { LoadAgentPluginFromPathOptions } from "./plugin-loader";
+export { loadAgentPluginFromPath, loadAgentPluginsFromPaths, } from "./plugin-loader";
+export type { UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, } from "./unified-config-file-watcher";
+export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
+export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateUserInstructionConfigWatcherOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UserInstructionConfig, UserInstructionConfigType, UserInstructionConfigWatcher, UserInstructionConfigWatcherEvent, WorkflowConfig, } from "./user-instruction-config-loader";
+export { createRulesConfigDefinition, createSkillsConfigDefinition, createUserInstructionConfigWatcher, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveDocumentsRulesDirectoryPath, resolveDocumentsWorkflowsDirectoryPath, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./user-instruction-config-loader";

package/dist/agents/plugin-config-loader.d.ts

@@ -0,0 +1,22 @@
+import type { AgentConfig } from "@clinebot/agents";
+type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
+export declare function resolvePluginConfigSearchPaths(workspacePath?: string): string[];
+export declare function discoverPluginModulePaths(directoryPath: string): string[];
+export interface ResolveAgentPluginPathsOptions {
+    pluginPaths?: ReadonlyArray<string>;
+    workspacePath?: string;
+    cwd?: string;
+}
+export declare function resolveAgentPluginPaths(options?: ResolveAgentPluginPathsOptions): string[];
+export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPathsOptions {
+    mode?: "sandbox" | "in_process";
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+}
+export declare function resolveAndLoadAgentPlugins(options?: ResolveAndLoadAgentPluginsOptions): Promise<{
+    extensions: AgentPlugin[];
+    shutdown?: () => Promise<void>;
+}>;
+export {};

package/dist/agents/plugin-loader.d.ts

@@ -0,0 +1,9 @@
+import type { AgentConfig } from "@clinebot/agents";
+type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
+export interface LoadAgentPluginFromPathOptions {
+    exportName?: string;
+    cwd?: string;
+}
+export declare function loadAgentPluginFromPath(pluginPath: string, options?: LoadAgentPluginFromPathOptions): Promise<AgentPlugin>;
+export declare function loadAgentPluginsFromPaths(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions): Promise<AgentPlugin[]>;
+export {};

package/dist/agents/plugin-sandbox.d.ts

@@ -0,0 +1,12 @@
+import type { AgentConfig } from "@clinebot/agents";
+export interface PluginSandboxOptions {
+    pluginPaths: string[];
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+}
+export declare function loadSandboxedPlugins(options: PluginSandboxOptions): Promise<{
+    extensions: AgentConfig["extensions"];
+    shutdown: () => Promise<void>;
+}>;

package/dist/agents/unified-config-file-watcher.d.ts

@@ -0,0 +1,77 @@
+export interface UnifiedConfigFileContext<TType extends string = string> {
+    type: TType;
+    directoryPath: string;
+    fileName: string;
+    filePath: string;
+    content: string;
+}
+export interface UnifiedConfigFileCandidate {
+    directoryPath: string;
+    fileName: string;
+    filePath: string;
+}
+export interface UnifiedConfigDefinition<TType extends string = string, TItem = unknown> {
+    type: TType;
+    directories: ReadonlyArray<string>;
+    discoverFiles?: (directoryPath: string) => Promise<ReadonlyArray<UnifiedConfigFileCandidate>>;
+    includeFile?: (fileName: string, filePath: string) => boolean;
+    parseFile: (context: UnifiedConfigFileContext<TType>) => TItem;
+    resolveId: (item: TItem, context: UnifiedConfigFileContext<TType>) => string;
+}
+export interface UnifiedConfigWatcherOptions {
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export interface UnifiedConfigRecord<TType extends string = string, TItem = unknown> {
+    type: TType;
+    id: string;
+    item: TItem;
+    filePath: string;
+}
+export type UnifiedConfigWatcherEvent<TType extends string = string, TItem = unknown> = {
+    kind: "upsert";
+    record: UnifiedConfigRecord<TType, TItem>;
+} | {
+    kind: "remove";
+    type: TType;
+    id: string;
+    filePath: string;
+} | {
+    kind: "error";
+    type: TType;
+    error: unknown;
+    filePath?: string;
+};
+export declare class UnifiedConfigFileWatcher<TType extends string = string, TItem = unknown> {
+    private readonly definitions;
+    private readonly debounceMs;
+    private readonly emitParseErrors;
+    private readonly listeners;
+    private readonly recordsByType;
+    private readonly watchersByDirectory;
+    private readonly baseTypesByDirectory;
+    private watchedTypesByDirectory;
+    private readonly discoveredDirectoriesByType;
+    private readonly definitionsByType;
+    private readonly pendingTypes;
+    private flushTimer;
+    private refreshQueue;
+    private started;
+    constructor(definitions: ReadonlyArray<UnifiedConfigDefinition<TType, TItem>>, options?: UnifiedConfigWatcherOptions);
+    subscribe(listener: (event: UnifiedConfigWatcherEvent<TType, TItem>) => void): () => void;
+    start(): Promise<void>;
+    stop(): void;
+    refreshAll(): Promise<void>;
+    refreshType(type: TType): Promise<void>;
+    getSnapshot(type: TType): Map<string, UnifiedConfigRecord<TType, TItem>>;
+    getAllSnapshots(): Map<TType, Map<string, UnifiedConfigRecord<TType, TItem>>>;
+    private emit;
+    private enqueueRefresh;
+    private startDirectoryWatchers;
+    private syncDirectoryWatchers;
+    private scheduleFlush;
+    private refreshTypeInternal;
+    private loadDefinition;
+    private buildDesiredTypesByDirectory;
+    private readDirectoryFileCandidates;
+}

package/dist/agents/user-instruction-config-loader.d.ts

@@ -0,0 +1,63 @@
+import { RULES_CONFIG_DIRECTORY_NAME, resolveDocumentsRulesDirectoryPath, resolveDocumentsWorkflowsDirectoryPath, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME } from "@clinebot/shared/storage";
+import { type UnifiedConfigDefinition, UnifiedConfigFileWatcher, type UnifiedConfigWatcherEvent } from "./unified-config-file-watcher";
+export { RULES_CONFIG_DIRECTORY_NAME, resolveDocumentsRulesDirectoryPath, resolveDocumentsWorkflowsDirectoryPath, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, };
+export interface ParseMarkdownFrontmatterResult {
+    data: Record<string, unknown>;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError?: string;
+}
+export interface SkillConfig {
+    name: string;
+    description?: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface RuleConfig {
+    name: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface WorkflowConfig {
+    name: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export type UserInstructionConfigType = "skill" | "rule" | "workflow";
+export type UserInstructionConfig = SkillConfig | RuleConfig | WorkflowConfig;
+export type UserInstructionConfigWatcher = UnifiedConfigFileWatcher<UserInstructionConfigType, UserInstructionConfig>;
+export type UserInstructionConfigWatcherEvent = UnifiedConfigWatcherEvent<UserInstructionConfigType, UserInstructionConfig>;
+export interface CreateInstructionWatcherOptions {
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export interface CreateSkillsConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export interface CreateRulesConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export interface CreateWorkflowsConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export declare function parseSkillConfigFromMarkdown(content: string, fallbackName: string): SkillConfig;
+export declare function parseRuleConfigFromMarkdown(content: string, fallbackName: string): RuleConfig;
+export declare function parseWorkflowConfigFromMarkdown(content: string, fallbackName: string): WorkflowConfig;
+export declare function resolveSkillsConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveRulesConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveWorkflowsConfigSearchPaths(workspacePath?: string): string[];
+export declare function createSkillsConfigDefinition(options?: CreateSkillsConfigDefinitionOptions): UnifiedConfigDefinition<"skill", SkillConfig>;
+export declare function createRulesConfigDefinition(options?: CreateRulesConfigDefinitionOptions): UnifiedConfigDefinition<"rule", RuleConfig>;
+export declare function createWorkflowsConfigDefinition(options?: CreateWorkflowsConfigDefinitionOptions): UnifiedConfigDefinition<"workflow", WorkflowConfig>;
+export interface CreateUserInstructionConfigWatcherOptions extends CreateInstructionWatcherOptions {
+    skills?: CreateSkillsConfigDefinitionOptions;
+    rules?: CreateRulesConfigDefinitionOptions;
+    workflows?: CreateWorkflowsConfigDefinitionOptions;
+}
+export declare function createUserInstructionConfigWatcher(options?: CreateUserInstructionConfigWatcherOptions): UserInstructionConfigWatcher;

package/dist/auth/client.d.ts

@@ -0,0 +1,11 @@
+import type { OAuthLoginCallbacks, OAuthPrompt } from "./types.js";
+export interface OAuthClientCallbacksOptions {
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+    onOutput?: (message: string) => void;
+    openUrl?: (url: string) => void | Promise<void>;
+    onOpenUrlError?: (context: {
+        url: string;
+        error: unknown;
+    }) => void;
+}
+export declare function createOAuthClientCallbacks(options: OAuthClientCallbacksOptions): OAuthLoginCallbacks;

package/dist/auth/cline.d.ts

@@ -0,0 +1,41 @@
+import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface } from "./types.js";
+export type ClineTokenResolution = {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+};
+interface ClineAuthApiUser {
+    subject: string | null;
+    email: string;
+    name: string;
+    clineUserId: string | null;
+    accounts: string[] | null;
+}
+type HeaderMap = Record<string, string>;
+type HeaderInput = HeaderMap | (() => Promise<HeaderMap> | HeaderMap);
+export interface ClineOAuthProviderOptions {
+    apiBaseUrl: string;
+    headers?: HeaderInput;
+    callbackPath?: string;
+    callbackPorts?: number[];
+    requestTimeoutMs?: number;
+    /**
+     * Optional identity provider name for token exchange.
+     */
+    provider?: string;
+}
+export interface ClineOAuthCredentials extends OAuthCredentials {
+    metadata?: {
+        provider?: string;
+        tokenType?: string;
+        userInfo?: ClineAuthApiUser;
+        [key: string]: unknown;
+    };
+}
+export declare function loginClineOAuth(options: ClineOAuthProviderOptions & {
+    callbacks: OAuthLoginCallbacks;
+}): Promise<ClineOAuthCredentials>;
+export declare function refreshClineToken(current: ClineOAuthCredentials, options: ClineOAuthProviderOptions): Promise<ClineOAuthCredentials>;
+export declare function getValidClineCredentials(currentCredentials: ClineOAuthCredentials | null, providerOptions: ClineOAuthProviderOptions, options?: ClineTokenResolution): Promise<ClineOAuthCredentials | null>;
+export declare function createClineOAuthProvider(options: ClineOAuthProviderOptions): OAuthProviderInterface;
+export {};

package/dist/auth/codex.d.ts

@@ -0,0 +1,39 @@
+/**
+ * OpenAI Codex (ChatGPT OAuth) flow
+ *
+ * NOTE: This module uses Node.js crypto and http for the OAuth callback.
+ * It is only intended for CLI use, not browser environments.
+ */
+import type { OAuthCredentials, OAuthPrompt, OAuthProviderInterface } from "./types.js";
+export declare const OPENAI_CODEX_OAUTH_CONFIG: {
+    readonly authorizationEndpoint: "https://auth.openai.com/oauth/authorize";
+    readonly tokenEndpoint: "https://auth.openai.com/oauth/token";
+    readonly clientId: "app_EMoamEEZ73f0CkXaXp7hrann";
+    readonly redirectUri: "http://localhost:1455/auth/callback";
+    readonly scopes: "openid profile email offline_access";
+    readonly callbackPort: 1455;
+    readonly jwtClaimPath: "https://api.openai.com/auth";
+    readonly refreshBufferMs: number;
+    readonly retryableTokenGraceMs: number;
+    readonly httpTimeoutMs: number;
+};
+export type RefreshTokenResolution = {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+};
+export declare function loginOpenAICodex(options: {
+    onAuth: (info: {
+        url: string;
+        instructions?: string;
+    }) => void;
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+    onProgress?: (message: string) => void;
+    onManualCodeInput?: () => Promise<string>;
+    originator?: string;
+}): Promise<OAuthCredentials>;
+export declare function refreshOpenAICodexToken(refreshToken: string, fallback?: OAuthCredentials): Promise<OAuthCredentials>;
+export declare function getValidOpenAICodexCredentials(currentCredentials: OAuthCredentials | null, options?: RefreshTokenResolution): Promise<OAuthCredentials | null>;
+export declare function isOpenAICodexTokenExpired(credentials: OAuthCredentials, refreshBufferMs?: number): boolean;
+export declare function normalizeOpenAICodexCredentials(credentials: OAuthCredentials): OAuthCredentials;
+export declare const openaiCodexOAuthProvider: OAuthProviderInterface;

package/dist/auth/oca.d.ts

@@ -0,0 +1,22 @@
+import type { OAuthCredentials, OAuthLoginCallbacks, OAuthProviderInterface, OcaClientMetadata, OcaOAuthProviderOptions, OcaTokenResolution } from "./types.js";
+export declare const DEFAULT_INTERNAL_IDCS_CLIENT_ID = "a8331954c0cf48ba99b5dd223a14c6ea";
+export declare const DEFAULT_INTERNAL_IDCS_URL = "https://idcs-9dc693e80d9b469480d7afe00e743931.identity.oraclecloud.com";
+export declare const DEFAULT_INTERNAL_IDCS_SCOPES = "openid offline_access";
+export declare const DEFAULT_INTERNAL_OCA_BASE_URL = "https://code-internal.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+export declare const DEFAULT_EXTERNAL_IDCS_CLIENT_ID = "c1aba3deed5740659981a752714eba33";
+export declare const DEFAULT_EXTERNAL_IDCS_URL = "https://login-ext.identity.oraclecloud.com";
+export declare const DEFAULT_EXTERNAL_IDCS_SCOPES = "openid offline_access";
+export declare const DEFAULT_EXTERNAL_OCA_BASE_URL = "https://code.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+export declare const OCI_HEADER_OPC_REQUEST_ID = "opc-request-id";
+export declare function loginOcaOAuth(options: OcaOAuthProviderOptions & {
+    callbacks: OAuthLoginCallbacks;
+}): Promise<OAuthCredentials>;
+export declare function refreshOcaToken(credentials: OAuthCredentials, options?: OcaOAuthProviderOptions): Promise<OAuthCredentials>;
+export declare function getValidOcaCredentials(currentCredentials: OAuthCredentials | null, options?: OcaTokenResolution, providerOptions?: OcaOAuthProviderOptions): Promise<OAuthCredentials | null>;
+export declare function createOcaOAuthProvider(options?: OcaOAuthProviderOptions): OAuthProviderInterface;
+export declare function generateOcaOpcRequestId(taskId: string, token: string): Promise<string>;
+export declare function createOcaRequestHeaders(input: {
+    accessToken: string;
+    taskId: string;
+    metadata?: OcaClientMetadata;
+}): Promise<Record<string, string>>;

package/dist/auth/server.d.ts

@@ -0,0 +1,22 @@
+export interface OAuthCallbackPayload {
+    url: URL;
+    code?: string;
+    state?: string;
+    provider?: string;
+    error?: string;
+}
+export interface LocalOAuthServerOptions {
+    host?: string;
+    ports: number[];
+    callbackPath: string;
+    timeoutMs?: number;
+    expectedState?: string;
+    successHtml?: string;
+}
+export interface LocalOAuthServer {
+    callbackUrl: string;
+    waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+    cancelWait: () => void;
+    close: () => void;
+}
+export declare function startLocalOAuthServer(options: LocalOAuthServerOptions): Promise<LocalOAuthServer>;