@rynx-ai/daemon 0.1.10 → 0.1.11-beta.2

package/bundled-plugins/plugins/lark/dist/host-adapters.js

@@ -0,0 +1,504 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
+import { AgentRuntimeError, } from "@rynx-ai/core";
+import { FileLarkActiveSessionStore, } from "./lark-session-store.js";
+/** Slow consumers fail the run instead of retaining an unbounded event stream. */
+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,
+ * steer controller, or session bus.
+ */
+export class HostConversationRuntime {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async runLive(input) {
+        if (!input.threadId) {
+            throw new AgentRuntimeError("a daemon-provisioned session id is required", 400, "session_required");
+        }
+        if (input.signal?.aborted) {
+            throw new AgentRuntimeError("conversation run was cancelled", 499, "codex_cancelled");
+        }
+        const queue = new AsyncEventQueue({
+            maxItems: LARK_RUN_EVENT_QUEUE_MAX_ITEMS,
+            maxBytes: LARK_RUN_EVENT_QUEUE_MAX_BYTES,
+            sizeOf: jsonByteLength,
+            overflowError: runEventQueueOverflowError,
+        });
+        let runId;
+        let terminal = false;
+        const earlyEvents = [];
+        let earlyEventBytes = 0;
+        let earlyOverflow = false;
+        let unsubscribeEvents = () => { };
+        const interrupt = () => {
+            if (!runId || terminal)
+                return;
+            void this.host.call("session.interrupt", { runId }).catch(() => undefined);
+        };
+        const accept = (event, payload) => {
+            if (!runId) {
+                if (earlyOverflow)
+                    return;
+                const bytes = jsonByteLength({ event, payload });
+                if (earlyEvents.length >= LARK_RUN_EVENT_QUEUE_MAX_ITEMS
+                    || bytes > LARK_RUN_EVENT_QUEUE_MAX_BYTES - earlyEventBytes) {
+                    earlyOverflow = true;
+                    earlyEvents.length = 0;
+                    earlyEventBytes = 0;
+                    unsubscribeEvents();
+                    return;
+                }
+                earlyEvents.push({ event, payload });
+                earlyEventBytes += bytes;
+                return;
+            }
+            if (event === "session.run.event") {
+                const value = runEventPayload(payload);
+                if (value?.runId === runId && queue.push(value.event) === "overflow") {
+                    interrupt();
+                    terminal = true;
+                    unsubscribeEvents();
+                }
+                return;
+            }
+            if (event === "session.run.completed") {
+                const value = runTerminalPayload(payload);
+                if (value?.runId === runId) {
+                    terminal = true;
+                    queue.end();
+                }
+                return;
+            }
+            if (event === "session.run.failed") {
+                const value = runTerminalPayload(payload);
+                if (value?.runId === runId) {
+                    terminal = true;
+                    queue.fail(hostRunError(value));
+                }
+            }
+        };
+        unsubscribeEvents = this.host.events.subscribe(({ event, payload }) => accept(event, payload));
+        if (earlyOverflow)
+            unsubscribeEvents();
+        let started;
+        try {
+            started = await this.host.call("session.run", {
+                sessionId: input.threadId,
+                message: input.message,
+            });
+            runId = started.runId;
+            if (earlyOverflow) {
+                queue.fail(runEventQueueOverflowError(), true);
+                interrupt();
+                terminal = true;
+            }
+            else {
+                for (const early of earlyEvents.splice(0))
+                    accept(early.event, early.payload);
+                earlyEventBytes = 0;
+            }
+        }
+        catch (error) {
+            unsubscribeEvents();
+            throw toAgentRuntimeError(error);
+        }
+        const unsteer = input.steer?.subscribe((text) => {
+            if (!runId || terminal)
+                return;
+            void this.host.call("session.steer", { runId, text }).catch(() => undefined);
+        });
+        input.signal?.addEventListener("abort", interrupt, { once: true });
+        const generator = (async function* () {
+            try {
+                for await (const event of queue)
+                    yield event;
+            }
+            finally {
+                if (!terminal)
+                    interrupt();
+                input.signal?.removeEventListener("abort", interrupt);
+                unsteer?.();
+                unsubscribeEvents();
+            }
+        })();
+        return {
+            provider: started.provider,
+            threadId: started.sessionId,
+            model: started.model,
+            authSource: started.authSource,
+            generator,
+        };
+    }
+}
+/** 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 } : {});
+    }
+    getGoal(sessionId) {
+        return this.host.call("session.goal.get", { sessionId });
+    }
+    setGoal(sessionId, objective) {
+        return this.host.call("session.goal.set", { sessionId, objective });
+    }
+    clearGoal(sessionId) {
+        return this.host.call("session.goal.clear", { sessionId });
+    }
+}
+/** Narrow agent catalog + first-turn execution resolver backed by Host RPC. */
+export class HostAgentCatalog {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    list() {
+        return this.host.call("agent.catalog.list", {});
+    }
+    get(id) {
+        return this.host.call("agent.catalog.get", { id });
+    }
+    resolveExecution(input) {
+        return this.host.call("agent.execution.resolve", 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, session = {}) {
+        const result = await this.host.call("session.ensure", {
+            scopeId: this.instanceId,
+            operationId,
+            session,
+        });
+        if (!result?.sessionId)
+            throw new Error("host did not return a provisioned session id");
+        this.resolvedExecutions.set(result.sessionId, {
+            runtime: result.execution.provider,
+            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.call("session.meta.get", { sessionId });
+            return {
+                runtime: session.execution.provider,
+                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.call("session.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 });
+    }
+}
+/**
+ * File-backed Lark routing state whose every newly allocated machine session is
+ * minted by the daemon. Allocation operation ids are derived from the previous
+ * committed routing record, so a child crash between RPC and file commit replays
+ * the same host operation instead of creating a duplicate session.
+ */
+export class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore {
+    operation;
+    mutationTail = Promise.resolve();
+    instanceDefaultAgent;
+    constructor(options) {
+        const operation = new AsyncLocalStorage();
+        super({
+            filePath: options.filePath,
+            defaultAgent: options.defaultAgent,
+            now: options.now,
+            createSessionId: async () => {
+                const allocation = operation.getStore();
+                if (!allocation)
+                    throw new Error("session allocation is missing its stable operation id");
+                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);
+            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(async () => this.pinResolvedExecution(sessionKey, await super.set(sessionKey, sessionId, cwd)));
+    }
+    async get(sessionKey) {
+        return this.runMutation(async () => {
+            const current = await super.get(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 rotate(sessionKey) {
+        return this.runMutation(async () => {
+            const current = await super.get(sessionKey);
+            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);
+            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);
+            const updated = await this.withAllocation(sessionKey, current?.sessionId, { agent: agentName }, () => super.setAgent(sessionKey, agentName));
+            return this.pinResolvedExecution(sessionKey, updated);
+        });
+    }
+    async freeze(sessionKey, execution) {
+        return this.runMutation(async () => {
+            const current = await super.get(sessionKey);
+            if (current)
+                return super.freeze(sessionKey, execution);
+            const frozen = await this.withAllocation(sessionKey, undefined, launchMeta(execution), () => super.freeze(sessionKey, execution));
+            return this.pinResolvedExecution(sessionKey, frozen);
+        });
+    }
+    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;
+        let release;
+        this.mutationTail = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous.catch(() => undefined);
+        try {
+            return await run();
+        }
+        finally {
+            release();
+        }
+    }
+}
+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}`;
+}
+class AsyncEventQueue {
+    options;
+    values = [];
+    waiters = [];
+    bufferedBytes = 0;
+    ended = false;
+    failure;
+    constructor(options) {
+        this.options = options;
+    }
+    push(value) {
+        if (this.ended || this.failure)
+            return "closed";
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve({ value, done: false });
+            return "accepted";
+        }
+        const bytes = this.options.sizeOf(value);
+        if (this.values.length >= this.options.maxItems
+            || !Number.isSafeInteger(bytes)
+            || bytes < 0
+            || bytes > this.options.maxBytes - this.bufferedBytes) {
+            this.fail(this.options.overflowError(), true);
+            return "overflow";
+        }
+        this.values.push({ value, bytes });
+        this.bufferedBytes += bytes;
+        return "accepted";
+    }
+    end() {
+        if (this.ended || this.failure)
+            return;
+        this.ended = true;
+        for (const waiter of this.waiters.splice(0))
+            waiter.resolve({ value: undefined, done: true });
+    }
+    fail(error, discardBuffered = false) {
+        if (this.ended || this.failure)
+            return;
+        this.failure = error;
+        if (discardBuffered) {
+            this.values.length = 0;
+            this.bufferedBytes = 0;
+        }
+        for (const waiter of this.waiters.splice(0))
+            waiter.reject(error);
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                const entry = this.values.shift();
+                if (entry) {
+                    this.bufferedBytes -= entry.bytes;
+                    return Promise.resolve({ value: entry.value, done: false });
+                }
+                if (this.failure)
+                    return Promise.reject(this.failure);
+                if (this.ended)
+                    return Promise.resolve({ value: undefined, done: true });
+                return new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+            },
+        };
+    }
+}
+function jsonByteLength(value) {
+    try {
+        const encoded = JSON.stringify(value);
+        return encoded === undefined ? 0 : Buffer.byteLength(encoded, "utf8");
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+function runEventQueueOverflowError() {
+    return new AgentRuntimeError(`host run event queue exceeded ${LARK_RUN_EVENT_QUEUE_MAX_ITEMS} items or ${LARK_RUN_EVENT_QUEUE_MAX_BYTES} bytes; the run was interrupted`, 503, "plugin_event_queue_overflow");
+}
+function runEventPayload(value) {
+    if (!isRecord(value) || typeof value.runId !== "string" || !isRecord(value.event))
+        return undefined;
+    return value;
+}
+function runTerminalPayload(value) {
+    if (!isRecord(value) || typeof value.runId !== "string")
+        return undefined;
+    return value;
+}
+function hostRunError(payload) {
+    const code = payload.error?.code || "plugin_host_run_failed";
+    return new AgentRuntimeError(payload.error?.message || "host conversation run failed", code === "codex_cancelled" ? 499 : 500, code);
+}
+function toAgentRuntimeError(error) {
+    if (error instanceof AgentRuntimeError)
+        return error;
+    const code = isRecord(error) && typeof error.code === "string" ? error.code : "plugin_host_call_failed";
+    return new AgentRuntimeError(error instanceof Error ? error.message : String(error), 500, code);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/bundled-plugins/plugins/lark/dist/index.d.ts

@@ -0,0 +1,7 @@
+/** 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, 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/bundled-plugins/plugins/lark/dist/index.js

@@ -0,0 +1,7 @@
+/** 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";