@rynx-ai/plugin-channel-lark 0.1.9

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

@@ -0,0 +1,46 @@
+import type { CodexSessionStore, ConversationSessionStore } 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
+ * conversation it's bound to, so a CLI-driven turn observed on disk can be
+ * mirrored into the right chat. Reverse-walks the three stores the bridge
+ * already maintains:
+ *
+ *   codexSessionId
+ *     → `.codex-proxy/sessions.json`            (CodexSessionStore)         → localThreadId (= sessionId)
+ *     → `.codex-proxy/lark-sessions.json`       (ConversationSessionStore)  → conversationKey
+ *     → `.codex-proxy/lark-conversations.json`  (LarkConversationDirectory) → chatId/threadId/participants
+ *
+ * The middle step is a reverse map lookup, not an id parse: the session id is
+ * opaque (`sess_<uuid>`), so the conversation key lives only in the routing map.
+ */
+export interface MirrorTarget {
+    codexSessionId: string;
+    localThreadId: string;
+    conversationKey: string;
+    chatId: string;
+    threadId?: string;
+    /** open_ids that have participated (used to @-mention the user). */
+    participants: string[];
+    model: string;
+}
+export interface BoundSession {
+    codexSessionId: string;
+    conversationKey: string;
+}
+export declare class CodexMirrorIndex {
+    private readonly codexSessionStore;
+    private readonly conversationSessionStore;
+    private readonly conversationDirectory;
+    constructor({ codexSessionStore, conversationSessionStore, conversationDirectory, }: {
+        codexSessionStore: Pick<CodexSessionStore, "listAll" | "findByCodexSessionId">;
+        conversationSessionStore: Pick<ConversationSessionStore, "findKeyBySessionId">;
+        conversationDirectory: Pick<LarkConversationDirectory, "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. */
+    resolveTarget(codexSessionId: string): Promise<MirrorTarget | null>;
+    /** All Codex threads currently bound to a Feishu conversation (those whose
+     *  session id resolves to a routing key). */
+    listBoundCodexSessionIds(): Promise<BoundSession[]>;
+}

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

@@ -0,0 +1,48 @@
+export class CodexMirrorIndex {
+    codexSessionStore;
+    conversationSessionStore;
+    conversationDirectory;
+    constructor({ codexSessionStore, conversationSessionStore, conversationDirectory, }) {
+        this.codexSessionStore = codexSessionStore;
+        this.conversationSessionStore = conversationSessionStore;
+        this.conversationDirectory = conversationDirectory;
+    }
+    /** codexSessionId → the full send target, or null when the thread isn't
+     *  bound, its session isn't routed, or the conversation was never recorded. */
+    async resolveTarget(codexSessionId) {
+        const record = await this.codexSessionStore.findByCodexSessionId(codexSessionId);
+        if (!record) {
+            return null;
+        }
+        const conversationKey = await this.conversationSessionStore.findKeyBySessionId(record.localThreadId);
+        if (!conversationKey) {
+            return null;
+        }
+        const directory = await this.conversationDirectory.get(conversationKey);
+        if (!directory) {
+            return null;
+        }
+        return {
+            codexSessionId,
+            localThreadId: record.localThreadId,
+            conversationKey,
+            chatId: directory.chatId,
+            threadId: directory.threadId,
+            participants: directory.participants ?? [],
+            model: record.model,
+        };
+    }
+    /** All Codex threads currently bound to a Feishu conversation (those whose
+     *  session id resolves to a routing key). */
+    async listBoundCodexSessionIds() {
+        const records = await this.codexSessionStore.listAll();
+        const bound = [];
+        for (const record of records) {
+            const conversationKey = await this.conversationSessionStore.findKeyBySessionId(record.localThreadId);
+            if (conversationKey) {
+                bound.push({ codexSessionId: record.codexSessionId, conversationKey });
+            }
+        }
+        return bound;
+    }
+}

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

@@ -0,0 +1,85 @@
+import { CodexMirrorIndex } from "./mirror-index.js";
+import { CodexRolloutWatcher, type RolloutEvent, type RolloutWatcherDeps } from "./rollout-watcher.js";
+import type { LarkMessageSender } from "../lark.js";
+/** What the mirror needs from the message sender. `createText` is required (the
+ *  user-message relay); the card methods are optional (degrade to plain text). */
+export type MirrorSender = Pick<LarkMessageSender, "createText"> & Partial<Pick<LarkMessageSender, "createCard" | "batchUpdateCard" | "sendInteractive">>;
+/** Read-only view of which conversations have a bridge-driven turn running, so
+ *  the mirror can skip those (they're already shown live in Feishu). */
+export interface InFlightView {
+    isInFlight(conversationKey: string): boolean;
+}
+export interface RolloutMirrorLogger {
+    log(entry: Record<string, unknown>): void;
+}
+export interface CodexRolloutMirrorOptions {
+    index: Pick<CodexMirrorIndex, "resolveTarget" | "listBoundCodexSessionIds">;
+    messageSender: MirrorSender;
+    inFlight: InFlightView;
+    cardThrottleMs?: number;
+    reconcileIntervalMs?: number;
+    pollMs?: number;
+    /** This bot's own open_id, excluded from the @-mention target. */
+    botOpenId?: string | null;
+    logger?: RolloutMirrorLogger;
+    /**
+     * Sessions roots scanned for rollout files, newest runtime first. Lets the
+     * mirror cover both codex (`~/.codex/sessions`) and traex
+     * (`~/.trae/cli/sessions`). Defaults to the watcher's built-in codex root.
+     */
+    sessionsRoots?: string[];
+    /** Inject a watcher (tests). Defaults to a real {@link CodexRolloutWatcher}. */
+    watcher?: CodexRolloutWatcher;
+    /** Filesystem seam forwarded to the default watcher (tests). */
+    watcherDeps?: Partial<RolloutWatcherDeps>;
+}
+/**
+ * Mirrors CLI-driven Codex turns (a `codex resume` takeover from a terminal)
+ * back into the bound Feishu conversation. Owns a {@link CodexRolloutWatcher},
+ * turns its {@link RolloutEvent}s into a per-session state machine, relays each
+ * user message as text, and drives a live-updating standalone card for each
+ * assistant reply — reusing the same card pipeline as the live Feishu flow.
+ */
+export declare class CodexRolloutMirror {
+    private readonly index;
+    private readonly sender;
+    private readonly inFlight;
+    private readonly cardThrottleMs;
+    private readonly reconcileIntervalMs;
+    private readonly botOpenId;
+    private readonly logger;
+    private readonly watcher;
+    private readonly states;
+    private readonly tails;
+    private reconcileTimer;
+    constructor(options: CodexRolloutMirrorOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Called by the ingestor when it observes a Codex thread binding, so we
+     *  begin watching that rollout file immediately (with the key in hand). */
+    noteBoundSession(codexSessionId: string): Promise<void>;
+    /** Called by the ingestor when a bridge-driven turn completes, to claim the
+     *  lines the bridge itself wrote so the watcher won't re-mirror them. */
+    claimToEof(codexSessionId: string): Promise<void>;
+    /** Public entry point for the per-session serialized processing (also the
+     *  test seam — feed {@link RolloutEvent}s directly without a real watcher). */
+    handleEvent(event: RolloutEvent): Promise<void>;
+    private enqueue;
+    private reconcile;
+    private getState;
+    /** Resolve (and cache) the Feishu target. Returns null when unbound/unrecorded. */
+    private resolveTarget;
+    private process;
+    private relayUserMessage;
+    private sendTextChunks;
+    /** `@<user> 发送内容"xxxxxx"`, at-mentioning the single non-bot participant
+     *  when known. Returns both the mentioned form and a plain fallback. */
+    private buildRelayText;
+    private canUseCard;
+    private ensureCard;
+    private ingest;
+    private finalizeCard;
+}
+/** Map rollout tool names onto the names the card pipeline's `classifyToolKind`
+ *  understands, so command/web-search tools render with the right icon/kind. */
+export declare function normalizeToolName(name: string): string;

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

@@ -0,0 +1,333 @@
+import { randomUUID } from "node:crypto";
+import { CodexRolloutWatcher } from "./rollout-watcher.js";
+import { createInitialCardState, LarkTurnCardController, } from "../lark-card-stream.js";
+import { chunkLarkReplyText } from "../lark-content.js";
+import { deriveConversationShortId } from "../lark-conversation-directory.js";
+const RELAY_TEXT_MAX_CHARS = 2000;
+const defaultLogger = {
+    log(entry) {
+        console.log(JSON.stringify({ level: "info", type: "lark_mirror", ...entry }));
+    },
+};
+/**
+ * Mirrors CLI-driven Codex turns (a `codex resume` takeover from a terminal)
+ * back into the bound Feishu conversation. Owns a {@link CodexRolloutWatcher},
+ * turns its {@link RolloutEvent}s into a per-session state machine, relays each
+ * user message as text, and drives a live-updating standalone card for each
+ * assistant reply — reusing the same card pipeline as the live Feishu flow.
+ */
+export class CodexRolloutMirror {
+    index;
+    sender;
+    inFlight;
+    cardThrottleMs;
+    reconcileIntervalMs;
+    botOpenId;
+    logger;
+    watcher;
+    states = new Map();
+    tails = new Map();
+    reconcileTimer = null;
+    constructor(options) {
+        this.index = options.index;
+        this.sender = options.messageSender;
+        this.inFlight = options.inFlight;
+        this.cardThrottleMs = options.cardThrottleMs ?? 250;
+        this.reconcileIntervalMs = options.reconcileIntervalMs ?? 30000;
+        this.botOpenId = options.botOpenId ?? null;
+        this.logger = options.logger ?? defaultLogger;
+        const watcherDeps = { ...options.watcherDeps };
+        const roots = options.sessionsRoots?.filter(Boolean) ?? [];
+        if (roots.length > 0 && watcherDeps.sessionsRoot === undefined) {
+            watcherDeps.sessionsRoot = roots[0];
+            watcherDeps.extraSessionsRoots = roots.slice(1);
+        }
+        this.watcher =
+            options.watcher ??
+                new CodexRolloutWatcher((event) => void this.enqueue(event), {
+                    deps: watcherDeps,
+                    pollMs: options.pollMs,
+                    logger: { log: (entry) => this.logger.log({ event: "mirror.watcher", ...entry }) },
+                });
+    }
+    async start() {
+        let registered = 0;
+        try {
+            const bound = await this.index.listBoundCodexSessionIds();
+            for (const { codexSessionId } of bound) {
+                await this.watcher.register(codexSessionId);
+                registered += 1;
+            }
+        }
+        catch (error) {
+            this.logger.log({ event: "mirror.start_failed", error: errMsg(error) });
+        }
+        this.logger.log({ event: "mirror.started", registered });
+        this.reconcileTimer = setInterval(() => void this.reconcile(), this.reconcileIntervalMs);
+        this.reconcileTimer.unref?.();
+    }
+    async stop() {
+        if (this.reconcileTimer) {
+            clearInterval(this.reconcileTimer);
+            this.reconcileTimer = null;
+        }
+        this.watcher.stop();
+        await Promise.all([...this.states.values()].map((state) => this.finalizeCard(state)));
+        this.states.clear();
+    }
+    /** Called by the ingestor when it observes a Codex thread binding, so we
+     *  begin watching that rollout file immediately (with the key in hand). */
+    async noteBoundSession(codexSessionId) {
+        try {
+            await this.watcher.register(codexSessionId);
+        }
+        catch (error) {
+            this.logger.log({ event: "mirror.note_failed", codex_session_id: codexSessionId, error: errMsg(error) });
+        }
+    }
+    /** Called by the ingestor when a bridge-driven turn completes, to claim the
+     *  lines the bridge itself wrote so the watcher won't re-mirror them. */
+    async claimToEof(codexSessionId) {
+        await this.watcher.claimToEof(codexSessionId);
+    }
+    /** Public entry point for the per-session serialized processing (also the
+     *  test seam — feed {@link RolloutEvent}s directly without a real watcher). */
+    handleEvent(event) {
+        return this.enqueue(event);
+    }
+    enqueue(event) {
+        const key = event.codexSessionId;
+        const previous = this.tails.get(key) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(() => this.process(event));
+        const tracked = next.finally(() => {
+            if (this.tails.get(key) === tracked) {
+                this.tails.delete(key);
+            }
+        });
+        this.tails.set(key, tracked);
+        return tracked;
+    }
+    async reconcile() {
+        try {
+            const bound = await this.index.listBoundCodexSessionIds();
+            for (const { codexSessionId } of bound) {
+                await this.watcher.register(codexSessionId); // idempotent
+            }
+            await this.watcher.relocatePending();
+        }
+        catch (error) {
+            this.logger.log({ event: "mirror.reconcile_failed", error: errMsg(error) });
+        }
+    }
+    getState(codexSessionId) {
+        let state = this.states.get(codexSessionId);
+        if (!state) {
+            state = {
+                target: null,
+                targetResolved: false,
+                unresolvedLogged: false,
+                controller: null,
+                lastFinal: null,
+                fallbackFinal: null,
+            };
+            this.states.set(codexSessionId, state);
+        }
+        return state;
+    }
+    /** Resolve (and cache) the Feishu target. Returns null when unbound/unrecorded. */
+    async resolveTarget(state, codexSessionId) {
+        if (state.targetResolved && state.target) {
+            return state.target;
+        }
+        const target = await this.index.resolveTarget(codexSessionId);
+        state.target = target;
+        state.targetResolved = Boolean(target);
+        if (!target && !state.unresolvedLogged) {
+            state.unresolvedLogged = true;
+            this.logger.log({ event: "mirror.target_unresolved", codex_session_id: codexSessionId });
+        }
+        return target;
+    }
+    async process(event) {
+        const state = this.getState(event.codexSessionId);
+        const target = await this.resolveTarget(state, event.codexSessionId);
+        if (!target) {
+            return;
+        }
+        // De-dup gate (re-checked here at dequeue time): while the bridge drives a
+        // turn for this conversation, its rollout lines are already shown live in
+        // Feishu — skip them entirely.
+        if (this.inFlight.isInFlight(target.conversationKey)) {
+            return;
+        }
+        switch (event.kind) {
+            case "userMessage":
+                await this.finalizeCard(state);
+                await this.relayUserMessage(target, event.text);
+                return;
+            case "assistantCommentary":
+                await this.ensureCard(state, target);
+                await this.ingest(state, { type: "token", text: event.text });
+                return;
+            case "assistantFinal":
+                state.lastFinal = event.text;
+                state.fallbackFinal = event.text;
+                await this.ensureCard(state, target);
+                await this.ingest(state, { type: "message_completed", text: event.text });
+                return;
+            case "toolStart":
+                await this.ensureCard(state, target);
+                await this.ingest(state, {
+                    type: "tool",
+                    event: "on_tool_start",
+                    name: normalizeToolName(event.name),
+                    input: { id: event.callId, command: event.command },
+                });
+                return;
+            case "toolEnd":
+                await this.ingest(state, {
+                    type: "tool",
+                    event: "on_tool_end",
+                    name: "command_execution",
+                    output: { id: event.callId, status: "completed", aggregatedOutput: event.output ?? null },
+                });
+                return;
+            case "taskComplete":
+                await this.finalizeCard(state);
+                return;
+        }
+    }
+    async relayUserMessage(target, text) {
+        const { mentioned, plain } = this.buildRelayText(target, text);
+        try {
+            await this.sendTextChunks(target.chatId, mentioned);
+            this.logger.log({
+                event: "mirror.user_relayed",
+                codex_session_id: target.codexSessionId,
+                conversation_key: target.conversationKey,
+            });
+        }
+        catch (error) {
+            // The @-mention can be rejected by some chats; never let that drop the
+            // user's question — retry once without the mention.
+            if (mentioned !== plain) {
+                try {
+                    await this.sendTextChunks(target.chatId, plain);
+                    this.logger.log({
+                        event: "mirror.user_relayed",
+                        codex_session_id: target.codexSessionId,
+                        conversation_key: target.conversationKey,
+                        fallback: "plain",
+                    });
+                    return;
+                }
+                catch (retryError) {
+                    this.logger.log({ event: "mirror.relay_failed", codex_session_id: target.codexSessionId, error: errMsg(retryError) });
+                    return;
+                }
+            }
+            this.logger.log({ event: "mirror.relay_failed", codex_session_id: target.codexSessionId, error: errMsg(error) });
+        }
+    }
+    async sendTextChunks(chatId, text) {
+        for (const chunk of chunkLarkReplyText(text)) {
+            // Feishu caps the message `uuid` at 50 chars — a bare randomUUID (36)
+            // stays well under and is unique per chunk.
+            await this.sender.createText({ chatId, text: chunk, uuid: randomUUID() });
+        }
+    }
+    /** `@<user> 发送内容"xxxxxx"`, at-mentioning the single non-bot participant
+     *  when known. Returns both the mentioned form and a plain fallback. */
+    buildRelayText(target, text) {
+        const trimmed = text.length > RELAY_TEXT_MAX_CHARS ? `${text.slice(0, RELAY_TEXT_MAX_CHARS)}…` : text;
+        const plain = `发送内容"${trimmed}"`;
+        const participants = target.participants.filter((id) => id && id !== this.botOpenId);
+        const mentioned = participants.length === 1 ? `<at user_id="${participants[0]}"></at> ${plain}` : plain;
+        return { mentioned, plain };
+    }
+    canUseCard() {
+        return Boolean(this.sender.createCard && this.sender.batchUpdateCard && this.sender.sendInteractive);
+    }
+    async ensureCard(state, target) {
+        if (state.controller || !this.canUseCard()) {
+            return;
+        }
+        const controller = new LarkTurnCardController({
+            sender: this.sender,
+            session: { chatId: target.chatId, threadId: target.threadId },
+            initialState: createInitialCardState({
+                localThreadId: target.localThreadId,
+                model: target.model,
+                resumeShortId: deriveConversationShortId(target.conversationKey),
+            }),
+            throttleMs: this.cardThrottleMs,
+            logger: { log: (entry) => this.logger.log({ event: "mirror.card", ...entry }) },
+            // No stop button: the bridge can't cancel a CLI-driven turn.
+        });
+        try {
+            await controller.startStandalone();
+            state.controller = controller;
+        }
+        catch (error) {
+            this.logger.log({ event: "mirror.card_start_failed", codex_session_id: target.codexSessionId, error: errMsg(error) });
+        }
+    }
+    async ingest(state, event) {
+        if (!state.controller) {
+            return;
+        }
+        await state.controller.ingestEvent(event);
+    }
+    async finalizeCard(state) {
+        if (state.controller) {
+            const controller = state.controller;
+            state.controller = null;
+            const finalAnswer = state.lastFinal ?? undefined;
+            state.lastFinal = null;
+            state.fallbackFinal = null;
+            try {
+                await controller.finalize({ status: "completed", finalAnswer });
+            }
+            catch (error) {
+                this.logger.log({ event: "mirror.card_finalize_failed", error: errMsg(error) });
+            }
+            return;
+        }
+        // No card capability: emit the accumulated final answer as plain text.
+        if (state.fallbackFinal && state.target) {
+            const final = state.fallbackFinal;
+            state.fallbackFinal = null;
+            state.lastFinal = null;
+            try {
+                for (const chunk of chunkLarkReplyText(final)) {
+                    await this.sender.createText({
+                        chatId: state.target.chatId,
+                        text: chunk,
+                        uuid: randomUUID(),
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.log({ event: "mirror.final_relay_failed", error: errMsg(error) });
+            }
+        }
+    }
+}
+/** Map rollout tool names onto the names the card pipeline's `classifyToolKind`
+ *  understands, so command/web-search tools render with the right icon/kind. */
+export function normalizeToolName(name) {
+    const lower = name.toLowerCase();
+    if (lower === "exec_command" || lower === "shell" || lower === "local_shell" || lower.includes("exec")) {
+        return "command_execution";
+    }
+    if (lower.includes("web_search")) {
+        return "web_search";
+    }
+    if (lower.startsWith("mcp")) {
+        return name;
+    }
+    return name;
+}
+function errMsg(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/cli-mirror/rollout-watcher.d.ts

@@ -0,0 +1,109 @@
+import { Buffer } from "node:buffer";
+/**
+ * Tails Codex "rollout" files (`~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<id>.jsonl`)
+ * and emits high-level conversation events. This is the only way to observe a
+ * session that the user took over from a terminal (`codex resume <id>`): the
+ * CLI is a separate process, so its turns surface only on disk — the bridge's
+ * own app-server connection never sees them.
+ *
+ * The watcher knows nothing about Feishu/cards; it just turns appended JSONL
+ * lines into {@link RolloutEvent}s. All filesystem access goes through an
+ * injectable {@link RolloutWatcherDeps} seam so the parser/state machine can be
+ * unit-tested by feeding synthetic text via {@link CodexRolloutWatcher.ingestAppendedText}.
+ */
+export type RolloutEvent = {
+    kind: "userMessage";
+    codexSessionId: string;
+    text: string;
+    ts?: string;
+} | {
+    kind: "assistantCommentary";
+    codexSessionId: string;
+    text: string;
+    ts?: string;
+} | {
+    kind: "assistantFinal";
+    codexSessionId: string;
+    text: string;
+    ts?: string;
+} | {
+    kind: "toolStart";
+    codexSessionId: string;
+    callId: string;
+    name: string;
+    command?: string;
+    ts?: string;
+} | {
+    kind: "toolEnd";
+    codexSessionId: string;
+    callId: string;
+    output?: string;
+    ts?: string;
+} | {
+    kind: "taskComplete";
+    codexSessionId: string;
+    ts?: string;
+};
+export interface RolloutDirEntry {
+    name: string;
+    isDirectory: boolean;
+    isFile: boolean;
+}
+export interface RolloutWatcherDeps {
+    /** Root scanned for `rollout-*-<id>.jsonl`. Defaults to `~/.codex/sessions`. */
+    sessionsRoot: string;
+    /**
+     * Additional sessions roots scanned after {@link sessionsRoot}. Lets one
+     * watcher cover multiple runtimes (e.g. codex `~/.codex/sessions` plus
+     * traex `~/.trae/cli/sessions`) since a rollout id lives in exactly one.
+     */
+    extraSessionsRoots?: string[];
+    readdir(dir: string): Promise<RolloutDirEntry[]>;
+    fileSize(filePath: string): Promise<number>;
+    /** Read bytes `[start, end)` from `filePath`. */
+    readRange(filePath: string, start: number, end: number): Promise<Buffer>;
+    /** Begin watching `filePath`; call `onChange` when it grows. Returns unwatch. */
+    watch(filePath: string, onChange: () => void): () => void;
+}
+export interface RolloutWatcherLogger {
+    log(entry: Record<string, unknown>): void;
+}
+export declare function resolveCodexSessionsRoot(): string;
+export declare class CodexRolloutWatcher {
+    private readonly onEvent;
+    private readonly deps;
+    private readonly logger?;
+    private readonly sessions;
+    constructor(onEvent: (event: RolloutEvent) => void, options?: {
+        deps?: Partial<RolloutWatcherDeps>;
+        pollMs?: number;
+        logger?: RolloutWatcherLogger;
+    });
+    /**
+     * 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.
+     */
+    register(codexSessionId: string): Promise<void>;
+    unregister(codexSessionId: string): void;
+    /** Try to locate rollout files for any still-pending ids (called by the
+     *  mirror's reconcile loop to pick up files created after registration). */
+    relocatePending(): Promise<void>;
+    /**
+     * 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.
+     */
+    claimToEof(codexSessionId: string): Promise<void>;
+    /** Test seam: feed appended text directly, bypassing the filesystem. */
+    ingestAppendedText(codexSessionId: string, text: string): void;
+    stop(): void;
+    private locate;
+    private findRolloutFile;
+    private scheduleGrowth;
+    private processGrowth;
+    private processChunk;
+    private mapLine;
+    private log;
+}