@nextclaw/openclaw-compat 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,462 @@
+import { Config } from '@nextclaw/core';
+
+type PluginConfigUiHint = {
+    label?: string;
+    help?: string;
+    advanced?: boolean;
+    sensitive?: boolean;
+    placeholder?: string;
+};
+type PluginKind = string;
+type PluginManifest = {
+    id: string;
+    configSchema: Record<string, unknown>;
+    kind?: PluginKind;
+    channels?: string[];
+    providers?: string[];
+    skills?: string[];
+    name?: string;
+    description?: string;
+    version?: string;
+    uiHints?: Record<string, PluginConfigUiHint>;
+};
+type PluginManifestLoadResult = {
+    ok: true;
+    manifest: PluginManifest;
+    manifestPath: string;
+} | {
+    ok: false;
+    error: string;
+    manifestPath: string;
+};
+type OpenClawPluginTool = {
+    label?: string;
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+    execute: ((toolCallId: string, params: Record<string, unknown>) => Promise<unknown> | unknown) | ((params: Record<string, unknown>) => Promise<unknown> | unknown);
+};
+type OpenClawPluginToolContext = {
+    config?: Config;
+    workspaceDir?: string;
+    sessionKey?: string;
+    channel?: string;
+    chatId?: string;
+    sandboxed?: boolean;
+};
+type OpenClawPluginToolFactory = (ctx: OpenClawPluginToolContext) => OpenClawPluginTool | OpenClawPluginTool[] | null | undefined;
+type OpenClawPluginToolOptions = {
+    name?: string;
+    names?: string[];
+    optional?: boolean;
+};
+type OpenClawProviderPlugin = {
+    id: string;
+    label?: string;
+    docsPath?: string;
+    aliases?: string[];
+    envVars?: string[];
+    models?: Record<string, unknown>;
+    auth?: Array<Record<string, unknown>>;
+};
+type OpenClawChannelPlugin = {
+    id: string;
+    meta?: Record<string, unknown>;
+    capabilities?: Record<string, unknown>;
+    outbound?: {
+        sendText?: (ctx: {
+            cfg: Config;
+            to: string;
+            text: string;
+            accountId?: string | null;
+        }) => Promise<unknown> | unknown;
+        sendPayload?: (ctx: {
+            cfg: Config;
+            to: string;
+            text: string;
+            payload: unknown;
+            accountId?: string | null;
+        }) => Promise<unknown> | unknown;
+    };
+};
+type OpenClawPluginChannelRegistration = OpenClawChannelPlugin | {
+    plugin: OpenClawChannelPlugin;
+};
+type OpenClawPluginDefinition = {
+    id?: string;
+    name?: string;
+    description?: string;
+    version?: string;
+    kind?: PluginKind;
+    register?: (api: OpenClawPluginApi) => void | Promise<void>;
+    activate?: (api: OpenClawPluginApi) => void | Promise<void>;
+};
+type OpenClawPluginModule = OpenClawPluginDefinition | ((api: OpenClawPluginApi) => void | Promise<void>);
+type PluginLogger = {
+    debug?: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+};
+type PluginOrigin = "bundled" | "global" | "workspace" | "config";
+type PluginDiagnostic = {
+    level: "warn" | "error";
+    message: string;
+    pluginId?: string;
+    source?: string;
+};
+type PluginRecord = {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+    kind?: PluginKind;
+    source: string;
+    origin: PluginOrigin;
+    workspaceDir?: string;
+    enabled: boolean;
+    status: "loaded" | "disabled" | "error";
+    error?: string;
+    toolNames: string[];
+    channelIds: string[];
+    providerIds: string[];
+    configSchema: boolean;
+    configUiHints?: Record<string, PluginConfigUiHint>;
+    configJsonSchema?: Record<string, unknown>;
+};
+type PluginToolRegistration = {
+    pluginId: string;
+    factory: OpenClawPluginToolFactory;
+    names: string[];
+    optional: boolean;
+    source: string;
+};
+type PluginChannelRegistration = {
+    pluginId: string;
+    channel: OpenClawChannelPlugin;
+    source: string;
+};
+type PluginProviderRegistration = {
+    pluginId: string;
+    provider: OpenClawProviderPlugin;
+    source: string;
+};
+type PluginRuntime = {
+    version: string;
+    tools: {
+        createMemorySearchTool: (params: {
+            config?: Config;
+            agentSessionKey?: string;
+        }) => OpenClawPluginTool | null;
+        createMemoryGetTool: (params: {
+            config?: Config;
+            agentSessionKey?: string;
+        }) => OpenClawPluginTool | null;
+    };
+};
+type OpenClawPluginApi = {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+    source: string;
+    config: Config;
+    pluginConfig?: Record<string, unknown>;
+    runtime: PluginRuntime;
+    logger: PluginLogger;
+    registerTool: (tool: OpenClawPluginTool | OpenClawPluginToolFactory, opts?: OpenClawPluginToolOptions) => void;
+    registerChannel: (registration: OpenClawPluginChannelRegistration) => void;
+    registerProvider: (provider: OpenClawProviderPlugin) => void;
+    registerHook: (_events: string | string[], _handler: unknown, _opts?: unknown) => void;
+    registerGatewayMethod: (_method: string, _handler: unknown) => void;
+    registerCli: (_registrar: unknown, _opts?: unknown) => void;
+    registerService: (_service: unknown) => void;
+    registerCommand: (_command: unknown) => void;
+    registerHttpHandler: (_handler: unknown) => void;
+    registerHttpRoute: (_params: {
+        path: string;
+        handler: unknown;
+    }) => void;
+    resolvePath: (input: string) => string;
+};
+type PluginRegistry = {
+    plugins: PluginRecord[];
+    tools: PluginToolRegistration[];
+    channels: PluginChannelRegistration[];
+    providers: PluginProviderRegistration[];
+    diagnostics: PluginDiagnostic[];
+    resolvedTools: OpenClawPluginTool[];
+};
+type PluginUiMetadata = {
+    id: string;
+    configSchema?: Record<string, unknown>;
+    configUiHints?: Record<string, PluginConfigUiHint>;
+};
+
+type OpenClawPluginConfigSchema = {
+    type: "object";
+    additionalProperties: boolean;
+    properties: Record<string, unknown>;
+};
+declare function emptyPluginConfigSchema(): OpenClawPluginConfigSchema;
+declare function buildChannelConfigSchema(schema: Record<string, unknown>): Record<string, unknown>;
+declare function buildOauthProviderAuthResult(params: {
+    providerId: string;
+    defaultModel?: string;
+    access: string;
+    refresh?: string;
+    expires?: string | number;
+    email?: string;
+    credentialExtra?: Record<string, unknown>;
+    notes?: string[];
+}): {
+    profiles: Array<{
+        profileId: string;
+        credential: Record<string, unknown>;
+    }>;
+    defaultModel?: string;
+    notes?: string[];
+};
+declare function sleep(ms: number): Promise<void>;
+declare function normalizePluginHttpPath(rawPath: string): string;
+declare const DEFAULT_ACCOUNT_ID = "default";
+declare function normalizeAccountId(accountId?: string | null): string;
+declare const __nextclawPluginSdkCompat = true;
+type _CompatOnly = OpenClawPluginApi;
+
+type NormalizedPluginsConfig = {
+    enabled: boolean;
+    allow: string[];
+    deny: string[];
+    loadPaths: string[];
+    entries: Record<string, {
+        enabled?: boolean;
+        config?: unknown;
+    }>;
+};
+declare function normalizePluginsConfig(plugins: Config["plugins"] | undefined): NormalizedPluginsConfig;
+declare function resolveEnableState(id: string, config: NormalizedPluginsConfig): {
+    enabled: boolean;
+    reason?: string;
+};
+type PluginInstallSource = "npm" | "archive" | "path";
+type PluginInstallUpdate = {
+    pluginId: string;
+    source: PluginInstallSource;
+    spec?: string;
+    sourcePath?: string;
+    installPath?: string;
+    version?: string;
+    installedAt?: string;
+};
+declare function recordPluginInstall(config: Config, update: PluginInstallUpdate): Config;
+declare function enablePluginInConfig(config: Config, pluginId: string): Config;
+declare function disablePluginInConfig(config: Config, pluginId: string): Config;
+declare function addPluginLoadPath(config: Config, loadPath: string): Config;
+
+type PluginCandidate = {
+    idHint: string;
+    source: string;
+    rootDir: string;
+    origin: PluginOrigin;
+    workspaceDir?: string;
+    packageName?: string;
+    packageVersion?: string;
+    packageDescription?: string;
+    packageDir?: string;
+};
+type PluginDiscoveryResult = {
+    candidates: PluginCandidate[];
+    diagnostics: PluginDiagnostic[];
+};
+declare function discoverOpenClawPlugins(params: {
+    config?: Config;
+    workspaceDir?: string;
+    extraPaths?: string[];
+}): PluginDiscoveryResult;
+
+type PluginInstallLogger = {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+};
+type InstallPluginResult = {
+    ok: true;
+    pluginId: string;
+    targetDir: string;
+    manifestName?: string;
+    version?: string;
+    extensions: string[];
+} | {
+    ok: false;
+    error: string;
+};
+declare function resolvePluginInstallDir(pluginId: string, extensionsDir?: string): string;
+declare function installPluginFromArchive(params: {
+    archivePath: string;
+    extensionsDir?: string;
+    logger?: PluginInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedPluginId?: string;
+}): Promise<InstallPluginResult>;
+declare function installPluginFromDir(params: {
+    dirPath: string;
+    extensionsDir?: string;
+    logger?: PluginInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedPluginId?: string;
+}): Promise<InstallPluginResult>;
+declare function installPluginFromFile(params: {
+    filePath: string;
+    extensionsDir?: string;
+    logger?: PluginInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+}): Promise<InstallPluginResult>;
+declare function installPluginFromNpmSpec(params: {
+    spec: string;
+    extensionsDir?: string;
+    logger?: PluginInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedPluginId?: string;
+}): Promise<InstallPluginResult>;
+declare function installPluginFromPath(params: {
+    path: string;
+    extensionsDir?: string;
+    logger?: PluginInstallLogger;
+    mode?: "install" | "update";
+    dryRun?: boolean;
+    expectedPluginId?: string;
+}): Promise<InstallPluginResult>;
+
+type PluginLoadOptions = {
+    config: Config;
+    workspaceDir?: string;
+    logger?: PluginLogger;
+    mode?: "full" | "validate";
+    reservedToolNames?: string[];
+    reservedChannelIds?: string[];
+    reservedProviderIds?: string[];
+};
+declare function loadOpenClawPlugins(options: PluginLoadOptions): PluginRegistry;
+
+type PluginManifestRecord = {
+    id: string;
+    name?: string;
+    description?: string;
+    version?: string;
+    kind?: PluginKind;
+    channels: string[];
+    providers: string[];
+    skills: string[];
+    origin: PluginOrigin;
+    workspaceDir?: string;
+    rootDir: string;
+    source: string;
+    manifestPath: string;
+    schemaCacheKey?: string;
+    configSchema?: Record<string, unknown>;
+    configUiHints?: Record<string, PluginConfigUiHint>;
+};
+type PluginManifestRegistry = {
+    plugins: PluginManifestRecord[];
+    diagnostics: PluginDiagnostic[];
+};
+declare function loadPluginManifestRegistry(params: {
+    config?: Config;
+    workspaceDir?: string;
+    candidates?: PluginCandidate[];
+    diagnostics?: PluginDiagnostic[];
+}): PluginManifestRegistry;
+declare function toPluginUiMetadata(records: PluginManifestRecord[]): PluginUiMetadata[];
+declare function loadPluginUiMetadata(params: {
+    config?: Config;
+    workspaceDir?: string;
+}): PluginUiMetadata[];
+
+declare const PLUGIN_MANIFEST_FILENAME = "openclaw.plugin.json";
+declare const PLUGIN_MANIFEST_FILENAMES: readonly ["openclaw.plugin.json"];
+declare function resolvePluginManifestPath(rootDir: string): string;
+declare function loadPluginManifest(rootDir: string): PluginManifestLoadResult;
+type OpenClawPackageManifest = {
+    extensions?: string[];
+    install?: {
+        npmSpec?: string;
+        localPath?: string;
+        defaultChoice?: "npm" | "local";
+    };
+};
+type PackageManifest = {
+    name?: string;
+    version?: string;
+    description?: string;
+    openclaw?: OpenClawPackageManifest;
+};
+declare function getPackageManifestMetadata(manifest: PackageManifest | undefined): OpenClawPackageManifest | undefined;
+
+declare function createPluginRuntime(params: {
+    workspace: string;
+    config?: Config;
+}): PluginRuntime;
+
+declare function validateJsonSchemaValue(params: {
+    schema: Record<string, unknown>;
+    cacheKey: string;
+    value: unknown;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+};
+
+type PluginStatusReport = PluginRegistry & {
+    workspaceDir: string;
+};
+declare function buildPluginStatusReport(params: {
+    config: Config;
+    workspaceDir?: string;
+    logger?: PluginLogger;
+    reservedToolNames?: string[];
+    reservedChannelIds?: string[];
+    reservedProviderIds?: string[];
+}): PluginStatusReport;
+
+type UninstallActions = {
+    entry: boolean;
+    install: boolean;
+    allowlist: boolean;
+    loadPath: boolean;
+    directory: boolean;
+};
+type PluginInstallRecord = NonNullable<Config["plugins"]["installs"]>[string];
+type UninstallPluginResult = {
+    ok: true;
+    config: Config;
+    pluginId: string;
+    actions: UninstallActions;
+    warnings: string[];
+} | {
+    ok: false;
+    error: string;
+};
+declare function resolveUninstallDirectoryTarget(params: {
+    pluginId: string;
+    hasInstall: boolean;
+    installRecord?: PluginInstallRecord;
+    extensionsDir?: string;
+}): string | null;
+declare function removePluginFromConfig(config: Config, pluginId: string): {
+    config: Config;
+    actions: Omit<UninstallActions, "directory">;
+};
+declare function uninstallPlugin(params: {
+    config: Config;
+    pluginId: string;
+    deleteFiles?: boolean;
+    extensionsDir?: string;
+}): Promise<UninstallPluginResult>;
+
+export { DEFAULT_ACCOUNT_ID, type InstallPluginResult, type NormalizedPluginsConfig, type OpenClawChannelPlugin, type OpenClawPluginApi, type OpenClawPluginChannelRegistration, type OpenClawPluginConfigSchema, type OpenClawPluginDefinition, type OpenClawPluginModule, type OpenClawPluginTool, type OpenClawPluginToolContext, type OpenClawPluginToolFactory, type OpenClawPluginToolOptions, type OpenClawProviderPlugin, PLUGIN_MANIFEST_FILENAME, PLUGIN_MANIFEST_FILENAMES, type PackageManifest, type PluginCandidate, type PluginChannelRegistration, type PluginConfigUiHint, type PluginDiagnostic, type PluginDiscoveryResult, type PluginInstallLogger, type PluginInstallSource, type PluginInstallUpdate, type PluginKind, type PluginLoadOptions, type PluginLogger, type PluginManifest, type PluginManifestLoadResult, type PluginManifestRecord, type PluginManifestRegistry, type PluginOrigin, type PluginProviderRegistration, type PluginRecord, type PluginRegistry, type PluginRuntime, type PluginStatusReport, type PluginToolRegistration, type PluginUiMetadata, type UninstallActions, type UninstallPluginResult, type _CompatOnly, __nextclawPluginSdkCompat, addPluginLoadPath, buildChannelConfigSchema, buildOauthProviderAuthResult, buildPluginStatusReport, createPluginRuntime, disablePluginInConfig, discoverOpenClawPlugins, emptyPluginConfigSchema, enablePluginInConfig, getPackageManifestMetadata, installPluginFromArchive, installPluginFromDir, installPluginFromFile, installPluginFromNpmSpec, installPluginFromPath, loadOpenClawPlugins, loadPluginManifest, loadPluginManifestRegistry, loadPluginUiMetadata, normalizeAccountId, normalizePluginHttpPath, normalizePluginsConfig, recordPluginInstall, removePluginFromConfig, resolveEnableState, resolvePluginInstallDir, resolvePluginManifestPath, resolveUninstallDirectoryTarget, sleep, toPluginUiMetadata, uninstallPlugin, validateJsonSchemaValue };