@rynx-ai/plugin-channel-lark 0.1.9

package/dist/cli-mirror/rollout-watcher.js

@@ -0,0 +1,347 @@
+import { Buffer } from "node:buffer";
+import { watchFile, unwatchFile } from "node:fs";
+import { open, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+const NEWLINE = 0x0a;
+export function resolveCodexSessionsRoot() {
+    return path.join(homedir(), ".codex", "sessions");
+}
+function defaultDeps(pollMs) {
+    return {
+        sessionsRoot: resolveCodexSessionsRoot(),
+        async readdir(dir) {
+            const entries = await readdir(dir, { withFileTypes: true });
+            return entries.map((entry) => ({
+                name: entry.name,
+                isDirectory: entry.isDirectory(),
+                isFile: entry.isFile(),
+            }));
+        },
+        async fileSize(filePath) {
+            return (await stat(filePath)).size;
+        },
+        async readRange(filePath, start, end) {
+            const length = Math.max(0, end - start);
+            if (length === 0) {
+                return Buffer.alloc(0);
+            }
+            const handle = await open(filePath, "r");
+            try {
+                const buffer = Buffer.alloc(length);
+                const { bytesRead } = await handle.read(buffer, 0, length, start);
+                return buffer.subarray(0, bytesRead);
+            }
+            finally {
+                await handle.close();
+            }
+        },
+        watch(filePath, onChange) {
+            const listener = (curr, prev) => {
+                if (curr.size !== prev.size || curr.mtimeMs !== prev.mtimeMs) {
+                    onChange();
+                }
+            };
+            watchFile(filePath, { interval: pollMs }, listener);
+            return () => unwatchFile(filePath, listener);
+        },
+    };
+}
+export class CodexRolloutWatcher {
+    onEvent;
+    deps;
+    logger;
+    sessions = new Map();
+    constructor(onEvent, options = {}) {
+        this.onEvent = onEvent;
+        const base = defaultDeps(options.pollMs ?? 1000);
+        this.deps = { ...base, ...options.deps };
+        this.logger = options.logger;
+    }
+    /**
+     * Begin tracking a Codex thread. Locates its rollout file and baselines the
+     * cursor to the current EOF (only NEW activity is mirrored — no replay). If
+     * the file doesn't exist yet, the id stays pending and {@link relocatePending}
+     * will pick it up later.
+     */
+    async register(codexSessionId) {
+        if (this.sessions.has(codexSessionId)) {
+            return;
+        }
+        const state = {
+            codexSessionId,
+            filePath: null,
+            cursor: 0,
+            pending: Buffer.alloc(0),
+            unwatch: null,
+            tail: Promise.resolve(),
+        };
+        this.sessions.set(codexSessionId, state);
+        await this.locate(state);
+    }
+    unregister(codexSessionId) {
+        const state = this.sessions.get(codexSessionId);
+        if (!state) {
+            return;
+        }
+        state.unwatch?.();
+        this.sessions.delete(codexSessionId);
+    }
+    /** Try to locate rollout files for any still-pending ids (called by the
+     *  mirror's reconcile loop to pick up files created after registration). */
+    async relocatePending() {
+        await Promise.all([...this.sessions.values()]
+            .filter((state) => !state.filePath)
+            .map((state) => this.locate(state)));
+    }
+    /**
+     * Advance the cursor to current EOF without emitting events — used to "claim"
+     * lines the bridge itself wrote during a bridge-driven turn so the watcher
+     * doesn't re-mirror them.
+     */
+    async claimToEof(codexSessionId) {
+        const state = this.sessions.get(codexSessionId);
+        if (!state?.filePath) {
+            return;
+        }
+        try {
+            state.cursor = await this.deps.fileSize(state.filePath);
+            state.pending = Buffer.alloc(0);
+        }
+        catch (error) {
+            this.log("rollout.claim_failed", codexSessionId, error);
+        }
+    }
+    /** Test seam: feed appended text directly, bypassing the filesystem. */
+    ingestAppendedText(codexSessionId, text) {
+        const state = this.sessions.get(codexSessionId);
+        if (!state) {
+            return;
+        }
+        this.processChunk(state, Buffer.from(text, "utf8"));
+    }
+    stop() {
+        for (const state of this.sessions.values()) {
+            state.unwatch?.();
+        }
+        this.sessions.clear();
+    }
+    async locate(state) {
+        let filePath;
+        try {
+            filePath = await this.findRolloutFile(state.codexSessionId);
+        }
+        catch (error) {
+            this.log("rollout.locate_failed", state.codexSessionId, error);
+            return;
+        }
+        if (!filePath || state.filePath) {
+            return;
+        }
+        state.filePath = filePath;
+        try {
+            state.cursor = await this.deps.fileSize(filePath);
+        }
+        catch {
+            state.cursor = 0;
+        }
+        state.unwatch = this.deps.watch(filePath, () => {
+            this.scheduleGrowth(state);
+        });
+    }
+    async findRolloutFile(codexSessionId) {
+        const suffix = `-${codexSessionId}.jsonl`;
+        const walk = async (dir) => {
+            let entries;
+            try {
+                entries = await this.deps.readdir(dir);
+            }
+            catch {
+                return null;
+            }
+            // Files first (the match is usually a leaf in a date directory).
+            for (const entry of entries) {
+                if (entry.isFile && entry.name.startsWith("rollout-") && entry.name.endsWith(suffix)) {
+                    return path.join(dir, entry.name);
+                }
+            }
+            for (const entry of entries) {
+                if (entry.isDirectory) {
+                    const found = await walk(path.join(dir, entry.name));
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+            return null;
+        };
+        const roots = [this.deps.sessionsRoot, ...(this.deps.extraSessionsRoots ?? [])];
+        for (const root of roots) {
+            const found = await walk(root);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    scheduleGrowth(state) {
+        state.tail = state.tail
+            .catch(() => undefined)
+            .then(() => this.processGrowth(state));
+    }
+    async processGrowth(state) {
+        if (!state.filePath) {
+            return;
+        }
+        let size;
+        try {
+            size = await this.deps.fileSize(state.filePath);
+        }
+        catch (error) {
+            this.log("rollout.stat_failed", state.codexSessionId, error);
+            return;
+        }
+        if (size < state.cursor) {
+            // Truncated/rotated unexpectedly — re-baseline without emitting.
+            state.cursor = size;
+            state.pending = Buffer.alloc(0);
+            return;
+        }
+        if (size === state.cursor) {
+            return;
+        }
+        let chunk;
+        try {
+            chunk = await this.deps.readRange(state.filePath, state.cursor, size);
+        }
+        catch (error) {
+            this.log("rollout.read_failed", state.codexSessionId, error);
+            return;
+        }
+        state.cursor += chunk.length;
+        this.processChunk(state, chunk);
+    }
+    processChunk(state, chunk) {
+        const combined = state.pending.length ? Buffer.concat([state.pending, chunk]) : chunk;
+        const lastNewline = combined.lastIndexOf(NEWLINE);
+        if (lastNewline < 0) {
+            state.pending = combined;
+            return;
+        }
+        const complete = combined.subarray(0, lastNewline).toString("utf8");
+        state.pending = combined.subarray(lastNewline + 1);
+        for (const rawLine of complete.split("\n")) {
+            const line = rawLine.trim();
+            if (!line) {
+                continue;
+            }
+            const event = this.mapLine(state.codexSessionId, line);
+            if (event) {
+                this.onEvent(event);
+            }
+        }
+    }
+    mapLine(codexSessionId, line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const ts = parsed.timestamp;
+        const payload = parsed.payload;
+        if (!payload || typeof payload !== "object") {
+            return null;
+        }
+        const payloadType = typeof payload.type === "string" ? payload.type : undefined;
+        if (parsed.type === "event_msg") {
+            switch (payloadType) {
+                case "user_message": {
+                    const text = typeof payload.message === "string" ? payload.message.trim() : "";
+                    return text ? { kind: "userMessage", codexSessionId, text, ts } : null;
+                }
+                case "agent_message": {
+                    const text = typeof payload.message === "string" ? payload.message.trim() : "";
+                    if (!text) {
+                        return null;
+                    }
+                    return payload.phase === "final_answer"
+                        ? { kind: "assistantFinal", codexSessionId, text, ts }
+                        : { kind: "assistantCommentary", codexSessionId, text, ts };
+                }
+                case "task_complete":
+                    return { kind: "taskComplete", codexSessionId, ts };
+                default:
+                    return null;
+            }
+        }
+        if (parsed.type === "response_item") {
+            switch (payloadType) {
+                case "function_call": {
+                    const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+                    const name = typeof payload.name === "string" ? payload.name : "tool";
+                    return {
+                        kind: "toolStart",
+                        codexSessionId,
+                        callId,
+                        name,
+                        command: extractCommand(payload.arguments),
+                        ts,
+                    };
+                }
+                case "function_call_output": {
+                    const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+                    return { kind: "toolEnd", codexSessionId, callId, output: stringifyOutput(payload.output), ts };
+                }
+                default:
+                    return null;
+            }
+        }
+        return null;
+    }
+    log(event, codexSessionId, error) {
+        this.logger?.log({
+            event,
+            codex_session_id: codexSessionId,
+            ...(error ? { error: error instanceof Error ? error.message : String(error) } : {}),
+        });
+    }
+}
+/** Pull a human-readable command from a `function_call.arguments` JSON string. */
+function extractCommand(args) {
+    if (typeof args !== "string") {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(args);
+        const candidate = parsed.cmd ?? parsed.command;
+        if (typeof candidate === "string") {
+            return candidate;
+        }
+        if (Array.isArray(candidate)) {
+            return candidate.filter((part) => typeof part === "string").join(" ");
+        }
+    }
+    catch {
+        // Not JSON — ignore.
+    }
+    return undefined;
+}
+function stringifyOutput(output) {
+    if (output == null) {
+        return undefined;
+    }
+    if (typeof output === "string") {
+        return output;
+    }
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/host-adapters.d.ts

@@ -0,0 +1,82 @@
+import { type AgentCapabilities, type AgentRuntimeId, type CapabilityResult, type ConversationRuntime, type ConversationStreamRequest, type ModelListResponse, 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">;
+/** 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,
+ * steer controller, or session bus.
+ */
+export declare class HostConversationRuntime implements LarkConversationRuntime {
+    private readonly host;
+    constructor(host: PluginHostClient);
+    runLive(input: ConversationStreamRequest): Promise<{
+        provider: "codex" | "traex" | "claude";
+        threadId: string;
+        model: string;
+        authSource: "codex_cli" | "traex_cli" | "claude_cli";
+        generator: AsyncGenerator<SessionEvent, any, any>;
+    }>;
+}
+/** Agent command adapter used by /models, /goal, and /fork. */
+export declare class HostAgentCapabilities implements AgentCapabilities {
+    private readonly host;
+    constructor(host: PluginHostClient);
+    listModels(runtime?: AgentRuntimeId): Promise<ModelListResponse | null>;
+    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 {
+    private readonly host;
+    constructor(host: PluginHostClient);
+    list(): Promise<PluginAgentSummary[]>;
+    get(id: string): Promise<PluginAgentSummary | null>;
+    resolveExecution(input: {
+        defaultAgent?: string;
+        session: PluginSessionExecutionSnapshot;
+    }): Promise<PluginResolvedSessionExecution>;
+}
+/** Daemon-owned session allocator. operationId must identify one allocation attempt durably. */
+export declare class HostSessionProvisioner {
+    private readonly host;
+    readonly instanceId: string;
+    constructor(host: PluginHostClient, instanceId: string);
+    provision(operationId: string): Promise<string>;
+    allocationOperationId(sessionKey: string, previousSessionId?: string): string;
+    forkOperationId(fromSessionId: string, newSessionKey: string): string;
+    setTitle(sessionId: string, title: string): Promise<void>;
+}
+/**
+ * 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 declare class HostProvisionedLarkSessionStore extends FileLarkActiveSessionStore {
+    private readonly operation;
+    private mutationTail;
+    constructor(options: {
+        filePath: string;
+        provisioner: HostSessionProvisioner;
+        defaultAgent?: string;
+        now?: () => string;
+    });
+    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>;
+    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>;
+    private withAllocation;
+    private runMutation;
+}
+export declare function stableOperationId(kind: string, ...parts: string[]): string;
+export type { LarkConversationRuntime };