@rynx-ai/plugin-channel-lark 0.1.10 → 0.1.11-beta.10

package/.rynx-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "id": "lark",
+  "version": "0.1.11",
+  "displayName": "Lark",
+  "description": "Lark and Feishu channel integration managed by the plugin.",
+  "apiRange": "^1.0.0",
+  "runtime": {
+    "entry": "./dist/runtime.js"
+  },
+  "channels": [
+    {
+      "id": "lark",
+      "displayName": "Lark"
+    }
+  ],
+  "settings": {
+    "ui": {
+      "entry": "./ui/index.html"
+    },
+    "background": {
+      "entry": "./dist/settings.js"
+    }
+  }
+}

package/dist/cli-mirror/mirror-index.d.ts

@@ -1,4 +1,4 @@
-import type { CodexSessionStore, ConversationSessionStore } from "@rynx-ai/core";
+import type { CodexSessionStore, ConversationSessionStore, SessionRegistry } from "@rynx-ai/core";
 import type { LarkConversationDirectory } from "../lark-conversation-directory.js";
 /**
  * Resolves a Codex thread id (the rollout-file UUID) back to the Feishu
@@ -32,10 +32,12 @@ export declare class CodexMirrorIndex {
     private readonly codexSessionStore;
     private readonly conversationSessionStore;
     private readonly conversationDirectory;
-    constructor({ codexSessionStore, conversationSessionStore, conversationDirectory, }: {
+    private readonly sessionRegistry;
+    constructor({ codexSessionStore, conversationSessionStore, conversationDirectory, sessionRegistry, }: {
         codexSessionStore: Pick<CodexSessionStore, "listAll" | "findByCodexSessionId">;
         conversationSessionStore: Pick<ConversationSessionStore, "findKeyBySessionId">;
         conversationDirectory: Pick<LarkConversationDirectory, "get">;
+        sessionRegistry: Pick<SessionRegistry, "get">;
     });
     /** codexSessionId → the full send target, or null when the thread isn't
      *  bound, its session isn't routed, or the conversation was never recorded. */

package/dist/cli-mirror/mirror-index.js

@@ -2,10 +2,12 @@ export class CodexMirrorIndex {
     codexSessionStore;
     conversationSessionStore;
     conversationDirectory;
-    constructor({ codexSessionStore, conversationSessionStore, conversationDirectory, }) {
+    sessionRegistry;
+    constructor({ codexSessionStore, conversationSessionStore, conversationDirectory, sessionRegistry, }) {
         this.codexSessionStore = codexSessionStore;
         this.conversationSessionStore = conversationSessionStore;
         this.conversationDirectory = conversationDirectory;
+        this.sessionRegistry = sessionRegistry;
     }
     /** codexSessionId → the full send target, or null when the thread isn't
      *  bound, its session isn't routed, or the conversation was never recorded. */
@@ -22,6 +24,10 @@ export class CodexMirrorIndex {
         if (!directory) {
             return null;
         }
+        const session = this.sessionRegistry.get(record.localThreadId);
+        if (!session) {
+            return null;
+        }
         return {
             codexSessionId,
             localThreadId: record.localThreadId,
@@ -29,7 +35,9 @@ export class CodexMirrorIndex {
             chatId: directory.chatId,
             threadId: directory.threadId,
             participants: directory.participants ?? [],
-            model: record.model,
+            // A null model means the provider CLI owns model selection. The mirror
+            // still needs a stable string label for transcript normalization.
+            model: session.execution.model ?? session.execution.provider,
         };
     }
     /** All Codex threads currently bound to a Feishu conversation (those whose

package/dist/host-adapters.d.ts

@@ -1,13 +1,20 @@
-import { type AgentCapabilities, type AgentRuntimeId, type CapabilityResult, type ConversationRuntime, type ConversationStreamRequest, type ModelListResponse, type SessionEvent, type ThreadGoal } from "@rynx-ai/core";
+import { type AgentCapabilities, type AgentRuntimeId, type CapabilityResult, type ConversationSessionRecord, type ConversationStreamRequest, type ModelListResponse, type SessionExecution, type SessionEvent, type ThreadGoal } from "@rynx-ai/core";
 import type { PluginAgentSummary, PluginHostClient, PluginResolvedSessionExecution, PluginSessionExecutionSnapshot } from "@rynx-ai/plugin-sdk";
 import { FileLarkActiveSessionStore } from "./lark-session-store.js";
-type LarkConversationRuntime = Pick<ConversationRuntime, "runLive">;
+import type { LarkConversationRuntime } from "./lark.js";
+interface HostSessionLaunchMeta {
+    sourceSessionId?: string;
+    agent?: string;
+    provider?: AgentRuntimeId;
+    model?: string;
+    reasoningEffort?: string;
+}
 /** Slow consumers fail the run instead of retaining an unbounded event stream. */
 export declare const LARK_RUN_EVENT_QUEUE_MAX_ITEMS = 256;
 export declare const LARK_RUN_EVENT_QUEUE_MAX_BYTES: number;
 /**
- * ConversationRuntime-shaped adapter backed exclusively by capability-checked
- * Host RPC. The plugin never receives the daemon's runtime, abort controller,
+ * ConversationRuntime-shaped adapter backed exclusively by the typed Host API.
+ * The plugin never receives the daemon's runtime, abort controller,
  * steer controller, or session bus.
  */
 export declare class HostConversationRuntime implements LarkConversationRuntime {
@@ -16,12 +23,12 @@ export declare class HostConversationRuntime implements LarkConversationRuntime
     runLive(input: ConversationStreamRequest): Promise<{
         provider: "codex" | "traex" | "claude";
         threadId: string;
-        model: string;
+        model: string | null;
         authSource: "codex_cli" | "traex_cli" | "claude_cli";
         generator: AsyncGenerator<SessionEvent, any, any>;
     }>;
 }
-/** Agent command adapter used by /models, /goal, and /fork. */
+/** Agent command adapter used by /models and /goal. Session fork is a Core RPC. */
 export declare class HostAgentCapabilities implements AgentCapabilities {
     private readonly host;
     constructor(host: PluginHostClient);
@@ -29,7 +36,6 @@ export declare class HostAgentCapabilities implements AgentCapabilities {
     getGoal(sessionId: string): Promise<CapabilityResult<ThreadGoal | null>>;
     setGoal(sessionId: string, objective: string): Promise<CapabilityResult>;
     clearGoal(sessionId: string): Promise<CapabilityResult>;
-    forkSession(fromSessionId: string, toSessionId: string): Promise<CapabilityResult>;
 }
 /** Narrow agent catalog + first-turn execution resolver backed by Host RPC. */
 export declare class HostAgentCatalog {
@@ -46,10 +52,14 @@ export declare class HostAgentCatalog {
 export declare class HostSessionProvisioner {
     private readonly host;
     readonly instanceId: string;
+    private readonly resolvedExecutions;
     constructor(host: PluginHostClient, instanceId: string);
-    provision(operationId: string): Promise<string>;
+    provision(operationId: string, session?: HostSessionLaunchMeta): Promise<string>;
+    takeExecution(sessionId: string): SessionExecution | undefined;
+    existingExecution(sessionId: string): Promise<SessionExecution | undefined>;
     allocationOperationId(sessionKey: string, previousSessionId?: string): string;
     forkOperationId(fromSessionId: string, newSessionKey: string): string;
+    fork(operationId: string, sourceSessionId: string, title?: string): Promise<string>;
     setTitle(sessionId: string, title: string): Promise<void>;
 }
 /**
@@ -61,6 +71,7 @@ export declare class HostSessionProvisioner {
 export declare class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore {
     private readonly operation;
     private mutationTail;
+    private readonly instanceDefaultAgent?;
     constructor(options: {
         filePath: string;
         provisioner: HostSessionProvisioner;
@@ -69,12 +80,14 @@ export declare class HostProvisionedLarkSessionStore extends FileLarkActiveSessi
     });
     private readonly provisioner;
     ensure(sessionKey: string): Promise<import("@rynx-ai/core").EnsureSessionResult>;
-    set(sessionKey: string, sessionId: string, cwd?: string): Promise<import("@rynx-ai/core").ConversationSessionRecord>;
+    set(sessionKey: string, sessionId: string, cwd?: string): Promise<ConversationSessionRecord>;
+    get(sessionKey: string): Promise<ConversationSessionRecord | null>;
     rotate(sessionKey: string): Promise<import("@rynx-ai/core").RotateSessionResult>;
-    bindCwd(sessionKey: string, cwd: string): Promise<import("@rynx-ai/core").ConversationSessionRecord>;
-    applySettings(sessionKey: string, settings: Parameters<FileLarkActiveSessionStore["applySettings"]>[1]): Promise<import("@rynx-ai/core").ConversationSessionRecord>;
-    setAgent(sessionKey: string, agentName: string): Promise<import("@rynx-ai/core").ConversationSessionRecord>;
-    freeze(sessionKey: string, execution: Parameters<FileLarkActiveSessionStore["freeze"]>[1]): Promise<import("@rynx-ai/core").ConversationSessionRecord>;
+    bindCwd(sessionKey: string, cwd: string): Promise<ConversationSessionRecord>;
+    applySettings(sessionKey: string, settings: Parameters<FileLarkActiveSessionStore["applySettings"]>[1]): Promise<ConversationSessionRecord>;
+    setAgent(sessionKey: string, agentName: string): Promise<ConversationSessionRecord>;
+    freeze(sessionKey: string, execution: Parameters<FileLarkActiveSessionStore["freeze"]>[1]): Promise<ConversationSessionRecord>;
+    private pinResolvedExecution;
     private withAllocation;
     private runMutation;
 }

package/dist/host-adapters.js

@@ -6,8 +6,8 @@ import { FileLarkActiveSessionStore, } from "./lark-session-store.js";
 export const LARK_RUN_EVENT_QUEUE_MAX_ITEMS = 256;
 export const LARK_RUN_EVENT_QUEUE_MAX_BYTES = 8 * 1024 * 1024;
 /**
- * ConversationRuntime-shaped adapter backed exclusively by capability-checked
- * Host RPC. The plugin never receives the daemon's runtime, abort controller,
+ * ConversationRuntime-shaped adapter backed exclusively by the typed Host API.
+ * The plugin never receives the daemon's runtime, abort controller,
  * steer controller, or session bus.
  */
 export class HostConversationRuntime {
@@ -37,7 +37,7 @@ export class HostConversationRuntime {
         const interrupt = () => {
             if (!runId || terminal)
                 return;
-            void this.host.call("session.interrupt", { runId }).catch(() => undefined);
+            void this.host.sessions.interrupt({ runId }).catch(() => undefined);
         };
         const accept = (event, payload) => {
             if (!runId) {
@@ -86,17 +86,11 @@ export class HostConversationRuntime {
             unsubscribeEvents();
         let started;
         try {
-            started = await this.host.call("session.run", {
+            started = await this.host.sessions.run({
                 sessionId: input.threadId,
+                model: input.model?.trim() || null,
+                reasoningEffort: input.reasoningEffort?.trim() || null,
                 message: input.message,
-                ...(input.provider ? { provider: input.provider } : {}),
-                ...(input.model ? { model: input.model } : {}),
-                ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
-                ...(input.cwd ? { cwd: input.cwd } : {}),
-                ...(input.agentName ? { agent: input.agentName } : {}),
-                ...(input.developerInstructions
-                    ? { developerInstructions: input.developerInstructions }
-                    : {}),
             });
             runId = started.runId;
             if (earlyOverflow) {
@@ -117,7 +111,7 @@ export class HostConversationRuntime {
         const unsteer = input.steer?.subscribe((text) => {
             if (!runId || terminal)
                 return;
-            void this.host.call("session.steer", { runId, text }).catch(() => undefined);
+            void this.host.sessions.steer({ runId, text }).catch(() => undefined);
         });
         input.signal?.addEventListener("abort", interrupt, { once: true });
         const generator = (async function* () {
@@ -142,26 +136,23 @@ export class HostConversationRuntime {
         };
     }
 }
-/** Agent command adapter used by /models, /goal, and /fork. */
+/** Agent command adapter used by /models and /goal. Session fork is a Core RPC. */
 export class HostAgentCapabilities {
     host;
     constructor(host) {
         this.host = host;
     }
     listModels(runtime) {
-        return this.host.call("session.models", runtime ? { runtime } : {});
+        return this.host.sessions.listModels(runtime ? { runtime } : undefined);
     }
     getGoal(sessionId) {
-        return this.host.call("session.goal.get", { sessionId });
+        return this.host.sessions.goals.get({ sessionId });
     }
     setGoal(sessionId, objective) {
-        return this.host.call("session.goal.set", { sessionId, objective });
+        return this.host.sessions.goals.set({ sessionId, objective });
     }
     clearGoal(sessionId) {
-        return this.host.call("session.goal.clear", { sessionId });
-    }
-    forkSession(fromSessionId, toSessionId) {
-        return this.host.call("session.fork", { fromSessionId, toSessionId });
+        return this.host.sessions.goals.clear({ sessionId });
     }
 }
 /** Narrow agent catalog + first-turn execution resolver backed by Host RPC. */
@@ -171,41 +162,82 @@ export class HostAgentCatalog {
         this.host = host;
     }
     list() {
-        return this.host.call("agent.catalog.list", {});
+        return this.host.agents.list();
     }
     get(id) {
-        return this.host.call("agent.catalog.get", { id });
+        return this.host.agents.get({ id });
     }
     resolveExecution(input) {
-        return this.host.call("agent.execution.resolve", input);
+        return this.host.agents.resolveExecution(input);
     }
 }
 /** Daemon-owned session allocator. operationId must identify one allocation attempt durably. */
 export class HostSessionProvisioner {
     host;
     instanceId;
+    resolvedExecutions = new Map();
     constructor(host, instanceId) {
         this.host = host;
         this.instanceId = instanceId;
     }
-    async provision(operationId) {
-        const result = await this.host.call("session.ensure", {
+    async provision(operationId, session = {}) {
+        const result = await this.host.sessions.ensure({
             scopeId: this.instanceId,
             operationId,
-            session: {},
+            session,
         });
         if (!result?.sessionId)
             throw new Error("host did not return a provisioned session id");
+        this.resolvedExecutions.set(result.sessionId, {
+            runtime: result.execution.provider,
+            ...(result.execution.model ? { model: result.execution.model } : {}),
+            ...(result.execution.reasoningEffort
+                ? { reasoningEffort: result.execution.reasoningEffort }
+                : {}),
+            ...(session.agent ? { agent: session.agent } : {}),
+        });
         return result.sessionId;
     }
+    takeExecution(sessionId) {
+        const execution = this.resolvedExecutions.get(sessionId);
+        this.resolvedExecutions.delete(sessionId);
+        return execution;
+    }
+    async existingExecution(sessionId) {
+        try {
+            const session = await this.host.sessions.get({ sessionId });
+            return {
+                runtime: session.execution.provider,
+                ...(session.execution.model ? { model: session.execution.model } : {}),
+                ...(session.execution.reasoningEffort
+                    ? { reasoningEffort: session.execution.reasoningEffort }
+                    : {}),
+            };
+        }
+        catch (error) {
+            if (hostErrorCode(error) === "SESSION_NOT_FOUND")
+                return undefined;
+            throw error;
+        }
+    }
     allocationOperationId(sessionKey, previousSessionId) {
         return stableOperationId("allocate", this.instanceId, sessionKey, previousSessionId ?? "initial");
     }
     forkOperationId(fromSessionId, newSessionKey) {
         return stableOperationId("fork", this.instanceId, fromSessionId, newSessionKey);
     }
+    async fork(operationId, sourceSessionId, title) {
+        const result = await this.host.sessions.fork({
+            sourceSessionId,
+            operationId,
+            ...(title ? { title } : {}),
+        });
+        if (!result?.sessionId)
+            throw new Error("host did not return a forked session id");
+        return result.sessionId;
+    }
     async setTitle(sessionId, title) {
-        await this.host.call("session.meta.setTitle", { sessionId, title });
+        await this.host.sessions.setTitle({ sessionId, title });
     }
 }
 /**
@@ -217,6 +249,7 @@ export class HostSessionProvisioner {
 export class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore {
     operation;
     mutationTail = Promise.resolve();
+    instanceDefaultAgent;
     constructor(options) {
         const operation = new AsyncLocalStorage();
         super({
@@ -224,52 +257,94 @@ export class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore
             defaultAgent: options.defaultAgent,
             now: options.now,
             createSessionId: async () => {
-                const operationId = operation.getStore();
-                if (!operationId)
+                const allocation = operation.getStore();
+                if (!allocation)
                     throw new Error("session allocation is missing its stable operation id");
-                return options.provisioner.provision(operationId);
+                return options.provisioner.provision(allocation.operationId, allocation.session);
             },
         });
         this.operation = operation;
         this.provisioner = options.provisioner;
+        this.instanceDefaultAgent = options.defaultAgent;
     }
     provisioner;
     async ensure(sessionKey) {
         return this.runMutation(async () => {
             const current = await super.get(sessionKey);
-            if (current)
-                return { ...current, source: "existing" };
-            return this.withAllocation(sessionKey, undefined, () => super.ensure(sessionKey));
+            const existingExecution = current
+                ? await this.provisioner.existingExecution(current.sessionId)
+                : undefined;
+            if (current && existingExecution) {
+                const pinned = current.runtime
+                    ? current
+                    : await super.freeze(sessionKey, existingExecution);
+                return { ...current, ...pinned, source: "existing" };
+            }
+            if (current) {
+                const replacement = await this.withAllocation(sessionKey, current.sessionId, launchMeta(current), () => super.rotate(sessionKey));
+                return {
+                    ...await this.pinResolvedExecution(sessionKey, replacement),
+                    source: "new",
+                };
+            }
+            const created = await this.withAllocation(sessionKey, undefined, this.instanceDefaultAgent ? { agent: this.instanceDefaultAgent } : {}, () => super.ensure(sessionKey));
+            return this.pinResolvedExecution(sessionKey, created);
         });
     }
     async set(sessionKey, sessionId, cwd) {
-        return this.runMutation(() => super.set(sessionKey, sessionId, cwd));
+        return this.runMutation(async () => this.pinResolvedExecution(sessionKey, await super.set(sessionKey, sessionId, cwd)));
     }
-    async rotate(sessionKey) {
+    async get(sessionKey) {
         return this.runMutation(async () => {
             const current = await super.get(sessionKey);
-            return this.withAllocation(sessionKey, current?.sessionId, () => super.rotate(sessionKey));
+            if (!current)
+                return current;
+            const existingExecution = await this.provisioner.existingExecution(current.sessionId);
+            if (existingExecution) {
+                return current.runtime ? current : super.freeze(sessionKey, existingExecution);
+            }
+            const replacement = await this.withAllocation(sessionKey, current.sessionId, launchMeta(current), () => super.rotate(sessionKey));
+            return this.pinResolvedExecution(sessionKey, replacement);
         });
     }
-    async bindCwd(sessionKey, cwd) {
+    async rotate(sessionKey) {
         return this.runMutation(async () => {
             const current = await super.get(sessionKey);
-            return this.withAllocation(sessionKey, current?.sessionId, () => super.bindCwd(sessionKey, cwd));
+            const rotated = await this.withAllocation(sessionKey, current?.sessionId, launchMeta(current), () => super.rotate(sessionKey));
+            return this.pinResolvedExecution(sessionKey, rotated);
         });
     }
+    async bindCwd(sessionKey, cwd) {
+        void sessionKey;
+        void cwd;
+        throw new Error("working directory is managed by the Session Project snapshot");
+    }
     async applySettings(sessionKey, settings) {
         return this.runMutation(async () => {
             if (!settings.rotate && (await super.get(sessionKey))) {
                 return super.applySettings(sessionKey, settings);
             }
             const current = await super.get(sessionKey);
-            return this.withAllocation(sessionKey, current?.sessionId, () => super.applySettings(sessionKey, settings));
+            const providerChanged = Boolean(settings.runtime && settings.runtime !== current?.runtime);
+            const updated = await this.withAllocation(sessionKey, current?.sessionId, launchMeta({
+                ...(providerChanged
+                    ? { provider: settings.runtime }
+                    : (current?.agent ?? this.instanceDefaultAgent)
+                        ? { agent: current?.agent ?? this.instanceDefaultAgent }
+                        : settings.runtime
+                            ? { provider: settings.runtime }
+                            : {}),
+                ...(settings.model ? { model: settings.model } : {}),
+                ...(settings.reasoningEffort ? { reasoningEffort: settings.reasoningEffort } : {}),
+            }), () => super.applySettings(sessionKey, settings));
+            return this.pinResolvedExecution(sessionKey, updated);
         });
     }
     async setAgent(sessionKey, agentName) {
         return this.runMutation(async () => {
             const current = await super.get(sessionKey);
-            return this.withAllocation(sessionKey, current?.sessionId, () => super.setAgent(sessionKey, agentName));
+            const updated = await this.withAllocation(sessionKey, current?.sessionId, { agent: agentName }, () => super.setAgent(sessionKey, agentName));
+            return this.pinResolvedExecution(sessionKey, updated);
         });
     }
     async freeze(sessionKey, execution) {
@@ -277,11 +352,22 @@ export class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore
             const current = await super.get(sessionKey);
             if (current)
                 return super.freeze(sessionKey, execution);
-            return this.withAllocation(sessionKey, undefined, () => super.freeze(sessionKey, execution));
+            const frozen = await this.withAllocation(sessionKey, undefined, launchMeta(execution), () => super.freeze(sessionKey, execution));
+            return this.pinResolvedExecution(sessionKey, frozen);
         });
     }
-    withAllocation(sessionKey, previousSessionId, run) {
-        return this.operation.run(this.provisioner.allocationOperationId(sessionKey, previousSessionId), run);
+    async pinResolvedExecution(sessionKey, record) {
+        const execution = this.provisioner.takeExecution(record.sessionId);
+        if (!execution)
+            return record;
+        const frozen = await super.freeze(sessionKey, execution);
+        return { ...record, ...frozen };
+    }
+    withAllocation(sessionKey, previousSessionId, session, run) {
+        return this.operation.run({
+            operationId: this.provisioner.allocationOperationId(sessionKey, previousSessionId),
+            session,
+        }, run);
     }
     async runMutation(run) {
         const previous = this.mutationTail;
@@ -298,6 +384,22 @@ export class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore
         }
     }
 }
+function launchMeta(input) {
+    if (!input)
+        return {};
+    return {
+        ...(input.agent ? { agent: input.agent } : {}),
+        ...(input.provider ? { provider: input.provider } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
+    };
+}
+function hostErrorCode(error) {
+    return error && typeof error === "object" && "code" in error &&
+        typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
 export function stableOperationId(kind, ...parts) {
     const digest = createHash("sha256").update(parts.join("\0")).digest("hex");
     return `${kind}-${digest}`;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-/** Public Lark plugin API. The manifest executable is the self-contained
- * `dist/runtime.mjs`, loaded only by @rynx-ai/plugin-runner; this module exports
- * no legacy in-process `RynxPlugin` manifest or daemon Channel factory. */
+/** Public Lark plugin API. Rynx loads the manifest's self-contained runtime
+ * module; this package exports no in-process daemon Channel factory. */
 export { LocalLarkBotRuntime } from "./lark.js";
-export { authorizeLark, larkConfigSchema, LARK_BOT_SCOPES, LARK_BOT_EVENTS, } from "./lark-setup.js";
+export { authorizeLark, larkConfigSchema, LARK_BOT_SCOPES, LARK_BOT_EVENTS, type LarkAuthorizationMaterial, type LarkSetupField, } from "./lark-setup.js";
 export { activate, createLarkPluginRuntime, LARK_CHANNEL_ID, type LarkPluginRuntimeOptions, } from "./runtime.js";
+export { createLarkPluginSettings, type LarkPluginSettingsOptions, } from "./settings.js";
 export { HostAgentCapabilities, HostAgentCatalog, HostConversationRuntime, HostProvisionedLarkSessionStore, HostSessionProvisioner, stableOperationId, } from "./host-adapters.js";

package/dist/index.js

@@ -1,7 +1,7 @@
-/** Public Lark plugin API. The manifest executable is the self-contained
- * `dist/runtime.mjs`, loaded only by @rynx-ai/plugin-runner; this module exports
- * no legacy in-process `RynxPlugin` manifest or daemon Channel factory. */
+/** Public Lark plugin API. Rynx loads the manifest's self-contained runtime
+ * module; this package exports no in-process daemon Channel factory. */
 export { LocalLarkBotRuntime } from "./lark.js";
 export { authorizeLark, larkConfigSchema, LARK_BOT_SCOPES, LARK_BOT_EVENTS, } from "./lark-setup.js";
 export { activate, createLarkPluginRuntime, LARK_CHANNEL_ID, } from "./runtime.js";
+export { createLarkPluginSettings, } from "./settings.js";
 export { HostAgentCapabilities, HostAgentCatalog, HostConversationRuntime, HostProvisionedLarkSessionStore, HostSessionProvisioner, stableOperationId, } from "./host-adapters.js";

package/dist/lark-config-store.d.ts

@@ -0,0 +1,30 @@
+import type { PluginExecutionDefaults } from "@rynx-ai/plugin-sdk";
+export interface LarkInstanceConfig {
+    id: string;
+    name: string;
+    enabled: boolean;
+    appId: string;
+    appSecret: string;
+    defaultAgent?: string;
+    executionDefaults: PluginExecutionDefaults;
+}
+export declare class LarkConfigStore {
+    private readonly file;
+    constructor(dataDir: string);
+    list(): LarkInstanceConfig[];
+    get(id: string): LarkInstanceConfig | undefined;
+    upsert(input: {
+        id?: string;
+        name: string;
+        enabled: boolean;
+        appId: string;
+        appSecret?: string;
+        defaultAgent?: string | null;
+        runtime?: PluginExecutionDefaults["runtime"];
+        allowedRoots?: string[];
+    }): LarkInstanceConfig;
+    remove(id: string): boolean;
+    setEnabled(id: string, enabled: boolean): LarkInstanceConfig;
+    private read;
+    private write;
+}