feishu-codex-connector 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,994 @@
+import { registerApp } from '@larksuiteoapi/node-sdk';
+import { ThreadEvent } from '@openai/codex-sdk';
+
+type Tenant = 'feishu' | 'lark';
+type BridgeAccessMode = 'read-only' | 'workspace' | 'full';
+type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+type CodexBackend = 'sdk' | 'exec-json' | 'app-server';
+type CodexAuthMode = 'api-key' | 'codex-home' | 'inherit-user';
+type ReplyMode = 'card' | 'markdown' | 'text';
+type LarkCliIdentityPreset = 'bot-only' | 'user-default' | 'disabled';
+type SecretRef = {
+    source: 'keystore';
+    id: string;
+} | {
+    source: 'env';
+    name: string;
+} | {
+    source: 'file';
+    path: string;
+} | {
+    source: 'exec';
+    command: string;
+    args?: string[];
+};
+interface ProfileAccess {
+    allowedUsers: string[];
+    allowedChats: string[];
+    admins: string[];
+    requireMentionInGroup: boolean;
+    allowUserCliInGroups: boolean;
+}
+interface PermissionConfig {
+    defaultAccess: BridgeAccessMode;
+    maxAccess: BridgeAccessMode;
+    networkAccess: boolean;
+}
+interface AppConfig {
+    id: string;
+    secret: SecretRef;
+}
+interface CodexAuthConfig {
+    mode: CodexAuthMode;
+    apiKey?: SecretRef;
+}
+interface CodexConfig {
+    backend: CodexBackend;
+    auth: CodexAuthConfig;
+    codexHome: string;
+    inheritUserCodexHome: boolean;
+    codexPath?: string;
+    baseUrl?: string;
+    config?: Record<string, unknown>;
+}
+interface FeishuCliConfig {
+    enabled: boolean;
+    identityPreset: LarkCliIdentityPreset;
+    configDir: string;
+}
+interface AttachmentConfig {
+    maxCount: number;
+    maxBytes: number;
+    maxFileBytes: number;
+    imageMaxBytes: number;
+    cacheTtlMs: number;
+}
+interface PreferencesConfig {
+    replyMode: ReplyMode;
+    showToolCalls: boolean;
+    maxConcurrency: number;
+    debounceMs: number;
+    idleTimeoutMinutes?: number;
+}
+interface ProfileConfig {
+    schemaVersion: 1;
+    name: string;
+    tenant: Tenant;
+    app: AppConfig;
+    codex: CodexConfig;
+    feishuCli: FeishuCliConfig;
+    permissions: PermissionConfig;
+    access: ProfileAccess;
+    preferences: PreferencesConfig;
+    attachments: AttachmentConfig;
+    workspaces: {
+        default?: string;
+    };
+}
+interface CreateProfileInput {
+    name: string;
+    tenant: Tenant;
+    appId: string;
+    appSecret: SecretRef;
+    codexAuth: CodexAuthConfig;
+    workspace?: string;
+    home?: string;
+    codexBackend?: CodexBackend;
+    codexPath?: string;
+}
+declare function createDefaultProfileConfig(input: CreateProfileInput): ProfileConfig;
+declare function normalizeProfileConfig(value: unknown): ProfileConfig;
+declare function isSecretRef(value: unknown): value is SecretRef;
+declare function redactProfileConfig(profile: ProfileConfig): ProfileConfig;
+
+type BridgeSource = 'im' | 'card' | 'comment';
+type ActorType = 'user' | 'bot';
+type ChatType = 'private' | 'group' | 'topic';
+interface BridgeMention {
+    id: string;
+    name?: string;
+    isBot?: boolean;
+    isAll?: boolean;
+}
+interface BridgeResource {
+    kind: 'image' | 'file' | 'audio' | 'video' | 'sticker';
+    fileKey?: string;
+    messageId?: string;
+    name?: string;
+    mime?: string;
+    size?: number;
+    required?: boolean;
+}
+interface BridgeResourceData {
+    bytes: Buffer;
+    name?: string;
+    mime?: string;
+}
+interface BridgeCommentTarget {
+    fileToken: string;
+    fileType: string;
+    commentId: string;
+    replyId?: string;
+    isWhole?: boolean;
+}
+interface BridgeMessage {
+    source: BridgeSource;
+    scopeId: string;
+    chatId?: string;
+    threadId?: string;
+    commentScopeId?: string;
+    commentTarget?: BridgeCommentTarget;
+    messageId: string;
+    actorId: string;
+    actorName?: string;
+    actorType?: ActorType;
+    chatType: ChatType;
+    text: string;
+    mentions: BridgeMention[];
+    resources: BridgeResource[];
+    raw: unknown;
+}
+interface BridgeAction {
+    source: 'card';
+    token: string;
+    value?: Record<string, unknown>;
+    scopeId: string;
+    chatId: string;
+    messageId: string;
+    operatorOpenId: string;
+    raw: unknown;
+    formValues?: Record<string, unknown>;
+}
+interface BridgeReply {
+    mode: 'card' | 'markdown' | 'text' | 'comment';
+    content: unknown;
+}
+interface ChannelGateway {
+    onMessage?(handler: (message: BridgeMessage) => Promise<void> | void): void;
+    onAction?(handler: (action: BridgeAction) => Promise<void> | void): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(target: {
+        chatId?: string;
+        messageId?: string;
+        commentScopeId?: string;
+        commentTarget?: BridgeCommentTarget;
+    }, reply: BridgeReply): Promise<{
+        messageId?: string;
+    } | void>;
+    updateMessage?(messageId: string, reply: BridgeReply): Promise<void>;
+    downloadResource?(message: BridgeMessage, resource: BridgeResource): Promise<BridgeResourceData>;
+    createGroupChat?(input: {
+        name: string;
+        inviteOpenId: string;
+        description?: string;
+    }): Promise<{
+        chatId: string;
+        name: string;
+    }>;
+    listJoinedChats?(): Promise<Array<{
+        chatId: string;
+        name?: string;
+    }>>;
+}
+
+type ActorRole = 'owner' | 'admin' | 'allowed-user' | 'group-member' | 'comment-mention' | 'denied';
+interface AccessDecision {
+    ok: boolean;
+    role: ActorRole;
+    isAdmin: boolean;
+    isOwner: boolean;
+    reason?: 'unauthorized-user' | 'unauthorized-chat' | 'mention-required' | 'bot-actor';
+}
+interface AccessContext {
+    profile: ProfileConfig;
+    message: Pick<BridgeMessage, 'source' | 'actorId' | 'actorType' | 'chatId' | 'chatType' | 'mentions'>;
+    ownerOpenId?: string;
+    botOpenId?: string;
+}
+declare function evaluateAccess(context: AccessContext): AccessDecision;
+declare function canRunAdminCommand(decision: AccessDecision): boolean;
+
+interface ApprovalRequest {
+    id: string;
+    runId: string;
+    scopeId: string;
+    cwd: string;
+    sandbox: string;
+    action: string;
+    command?: string;
+    riskSummary?: string;
+}
+type CodexBridgeEvent = {
+    type: 'thread';
+    threadId: string;
+} | {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'tool_start';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_end';
+    id: string;
+    output: string;
+    isError: boolean;
+} | {
+    type: 'usage';
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reasoningOutputTokens?: number;
+} | {
+    type: 'approval_request';
+    request: ApprovalRequest;
+} | {
+    type: 'done';
+    reason: 'normal' | 'interrupted' | 'timeout';
+} | {
+    type: 'error';
+    message: string;
+};
+interface CodexRunInput {
+    runId: string;
+    prompt: string;
+    cwdRealpath: string;
+    threadId?: string;
+    sandbox: CodexSandboxMode;
+    networkAccess: boolean;
+    imagePaths?: string[];
+    env?: Record<string, string>;
+    apiKey?: string;
+    baseUrl?: string;
+    codexHome?: string;
+    codexPath?: string;
+    config?: Record<string, unknown>;
+    idleTimeoutMs?: number;
+}
+interface CodexThreadListInput {
+    cwdRealpath?: string;
+}
+interface CodexThreadSummary {
+    threadId: string;
+    updatedAt?: number;
+    summary?: string;
+}
+interface RunnerAvailability {
+    ok: boolean;
+    label: string;
+    detail?: string;
+}
+interface CodexRunHandle {
+    runId: string;
+    threadId?: string;
+    events: AsyncIterable<CodexBridgeEvent>;
+    stop(): Promise<void>;
+}
+interface CodexRunner {
+    start(input: CodexRunInput): Promise<CodexRunHandle>;
+    resume(threadId: string, input: CodexRunInput): Promise<CodexRunHandle>;
+    listThreads(input: CodexThreadListInput): Promise<CodexThreadSummary[]>;
+    stop(runId: string): Promise<void>;
+    checkAvailability(): Promise<RunnerAvailability>;
+}
+
+type NonceState = 'fresh' | 'used' | 'revoked';
+interface CallbackNonceStore {
+    state(nonce: string): NonceState;
+    consume(nonce: string): boolean;
+    revoke(nonce: string): void;
+}
+declare class MemoryCallbackNonceStore implements CallbackNonceStore {
+    private readonly used;
+    private readonly revoked;
+    state(nonce: string): NonceState;
+    consume(nonce: string): boolean;
+    revoke(nonce: string): void;
+}
+
+interface CallbackKey {
+    version: number;
+    secret: string;
+    retired?: boolean;
+}
+interface CallbackSignInput {
+    runId: string;
+    scopeId: string;
+    chatId: string;
+    operatorOpenId: string;
+    action: string;
+    policyFingerprint: string;
+    ttlMs: number;
+}
+interface CallbackVerifyExpected {
+    runId: string;
+    scopeId: string;
+    chatId: string;
+    operatorOpenId: string;
+    action: string;
+    policyFingerprint: string;
+}
+interface CallbackPayload {
+    r: string;
+    s: string;
+    c: string;
+    o: string;
+    a: string;
+    exp: number;
+    fp: string;
+    n: string;
+    kv: number;
+}
+type CallbackVerifyResult = {
+    ok: true;
+    payload: CallbackPayload;
+} | {
+    ok: false;
+    reason: 'malformed' | 'unknown-key' | 'bad-signature' | 'expired' | 'context-mismatch' | 'nonce-replay' | 'nonce-revoked';
+};
+declare class CallbackAuth {
+    private readonly nonceStore;
+    private readonly keys;
+    private readonly now;
+    private readonly createNonce;
+    constructor(keys: CallbackKey[], nonceStore: CallbackNonceStore, opts?: {
+        now?: () => number;
+        createNonce?: () => string;
+    });
+    sign(input: CallbackSignInput): string;
+    verify(token: string, expected: CallbackVerifyExpected): CallbackVerifyResult;
+    private signingKey;
+}
+
+interface SessionCatalogEntry {
+    key: string;
+    scopeId: string;
+    cwdRealpath: string;
+    policyFingerprint: string;
+    codexThreadId: string;
+    status: 'active' | 'archived';
+    updatedAt: number;
+    summary?: string;
+}
+declare class SessionCatalog {
+    private readonly path;
+    private readonly now;
+    constructor(path: string, now?: () => number);
+    activeFor(input: Pick<SessionCatalogEntry, 'scopeId' | 'cwdRealpath' | 'policyFingerprint'>): Promise<SessionCatalogEntry | undefined>;
+    upsertActive(input: Omit<SessionCatalogEntry, 'key' | 'status' | 'updatedAt'>): Promise<SessionCatalogEntry>;
+    archiveScope(scopeId: string): Promise<void>;
+    recentCompatible(input: Pick<SessionCatalogEntry, 'scopeId' | 'cwdRealpath' | 'policyFingerprint'>, limit?: number): Promise<SessionCatalogEntry[]>;
+    recentForScopeWorkspace(scopeId: string, cwdRealpath: string, limit?: number): Promise<SessionCatalogEntry[]>;
+    byKey(key: string): Promise<SessionCatalogEntry | undefined>;
+    restoreActive(key: string): Promise<SessionCatalogEntry | undefined>;
+    private read;
+    private write;
+}
+declare function catalogKey(scopeId: string, cwdRealpath: string, policyFingerprint: string): string;
+
+declare class ResumeNonceStore {
+    private readonly now;
+    private readonly entries;
+    constructor(now?: () => number);
+    issue(key: string, ttlMs?: number): string;
+    consume(nonce: string): string | undefined;
+    private gc;
+}
+
+interface SessionRecord {
+    threadId?: string;
+    cwdRealpath?: string;
+    idleTimeoutMinutes?: number;
+    updatedAt: number;
+}
+declare class SessionStore {
+    private readonly path;
+    private readonly now;
+    constructor(path: string, now?: () => number);
+    get(scopeId: string): Promise<SessionRecord | undefined>;
+    set(scopeId: string, threadId: string, cwdRealpath: string): Promise<void>;
+    setTimeout(scopeId: string, minutes: number | undefined): Promise<void>;
+    clear(scopeId: string): Promise<void>;
+    private read;
+}
+
+declare class WorkspaceStore {
+    private readonly path;
+    constructor(path: string);
+    cwdFor(scopeId: string): Promise<string | undefined>;
+    setCwd(scopeId: string, cwd: string): Promise<void>;
+    clearCwd(scopeId: string): Promise<void>;
+    saveAlias(name: string, cwd: string): Promise<void>;
+    removeAlias(name: string): Promise<void>;
+    alias(name: string): Promise<string | undefined>;
+    aliases(): Promise<Record<string, string>>;
+    private read;
+    private write;
+}
+
+interface CommandContext {
+    profile: ProfileConfig;
+    access: AccessDecision;
+    message: BridgeMessage;
+    sessions: SessionStore;
+    sessionCatalog: SessionCatalog;
+    workspaces: WorkspaceStore;
+    runner: CodexRunner;
+    stopScope: (scopeId: string) => Promise<boolean>;
+    queueSnapshot: (scopeId: string) => unknown;
+    processSnapshot?: () => Promise<unknown> | unknown;
+    saveProfile?: (profile: ProfileConfig) => Promise<void>;
+    callbackAuth?: CallbackAuth;
+    formValues?: Record<string, unknown>;
+    resumeNonces?: ResumeNonceStore;
+    gateway?: ChannelGateway;
+    lifecycle?: {
+        exit?: (target?: string) => Promise<void>;
+        reconnect?: () => Promise<void>;
+    };
+}
+type CommandResult = {
+    handled: false;
+} | {
+    handled: true;
+    reply?: BridgeReply;
+    sensitive?: boolean;
+};
+declare function routeCommand(context: CommandContext): Promise<CommandResult>;
+declare function parseCommand(text: string): {
+    name: string;
+    args: string[];
+} | undefined;
+
+interface RegistrationResult {
+    appId: string;
+    appSecret: string;
+    tenant: Tenant;
+    operatorOpenId?: string;
+}
+interface BootstrapRunOptions {
+    profile?: string;
+    tenant?: Tenant;
+    appId?: string;
+    appSecret?: string;
+    workspace?: string;
+    codexAuth?: CodexAuthMode;
+    codexApiKey?: string;
+    codexPath?: string;
+    home?: string;
+}
+interface RegistrationWizardOptions {
+    register?: typeof registerApp;
+    renderQr?: (url: string) => void;
+    qrImagePath?: string;
+    log?: Pick<Console, 'log'>;
+}
+declare function runRegistrationWizard(options?: RegistrationWizardOptions): Promise<RegistrationResult>;
+declare function ensureProfileForRun(options?: BootstrapRunOptions): Promise<string>;
+declare function bootstrapProfile(options?: BootstrapRunOptions): Promise<string>;
+
+declare const DEFAULT_HOME_DIR = "~/.feishu-codex";
+interface BridgePaths {
+    home: string;
+    configFile: string;
+    activeProfileFile: string;
+    registryDir: string;
+    profilesDir: string;
+}
+interface ProfilePaths {
+    root: string;
+    config: string;
+    sessions: string;
+    sessionCatalog: string;
+    workspaces: string;
+    mediaDir: string;
+    logsDir: string;
+    secretsKey: string;
+    secretsStore: string;
+    codexHome: string;
+    feishuCliDir: string;
+}
+declare function expandTilde(path: string, home?: string): string;
+declare function getBridgeHome(env?: NodeJS.ProcessEnv): string;
+declare function bridgePaths(home?: string): BridgePaths;
+declare function profilePaths(profile: string, home?: string): ProfilePaths;
+declare function parentDir(path: string): string;
+declare function tempRoot(): string;
+
+declare class LocalKeystore {
+    private readonly paths;
+    constructor(paths: Pick<ProfilePaths, 'secretsKey' | 'secretsStore'>);
+    set(id: string, value: string): Promise<void>;
+    get(id: string): Promise<string | undefined>;
+    delete(id: string): Promise<void>;
+    export(includeSecrets?: boolean): Promise<Record<string, string>>;
+    private key;
+    private readPlain;
+    private writePlain;
+}
+
+interface RootConfigFile {
+    schemaVersion: 1;
+    activeProfile?: string;
+    profiles: Record<string, ProfileConfig>;
+}
+interface ProfileSummary {
+    name: string;
+    active: boolean;
+    tenant: Tenant;
+    appIdSuffix: string;
+    workspaceStatus: 'configured' | 'missing';
+    backend: string;
+    codexAuthMode: CodexAuthMode;
+    feishuCliIdentity: string;
+}
+interface CreateProfileWithSecretsInput {
+    name: string;
+    tenant: Tenant;
+    appId: string;
+    appSecret: string;
+    codexAuthMode: CodexAuthMode;
+    codexApiKey?: string;
+    workspace?: string;
+    codexPath?: string;
+    codexBackend?: CreateProfileInput['codexBackend'];
+    setActive?: boolean;
+}
+declare class ProfileStore {
+    private readonly home;
+    readonly paths: BridgePaths;
+    constructor(home?: string);
+    profilePaths(name: string): ProfilePaths;
+    keystore(name: string): LocalKeystore;
+    init(): Promise<void>;
+    create(input: CreateProfileWithSecretsInput): Promise<ProfileConfig>;
+    read(name?: string): Promise<ProfileConfig>;
+    write(profile: ProfileConfig): Promise<void>;
+    list(): Promise<ProfileSummary[]>;
+    use(name: string): Promise<void>;
+    activeProfile(): Promise<string | undefined>;
+    remove(name: string, opts?: {
+        purge?: boolean;
+        yes?: boolean;
+    }): Promise<string>;
+    export(name: string, opts?: {
+        includeSecrets?: boolean;
+    }): Promise<unknown>;
+    importFilesFrom(name: string, sourceDir: string): Promise<void>;
+    private assertExists;
+    private writeRootConfig;
+    private clearActiveIf;
+}
+declare function profileExists(path: string): Promise<boolean>;
+declare function profileNameFromPath(path: string): string;
+declare function profileLogPath(paths: ProfilePaths, kind: string): string;
+
+interface SecretResolverOptions {
+    keystore?: LocalKeystore;
+    env?: NodeJS.ProcessEnv;
+}
+declare class SecretResolver {
+    private readonly options;
+    private readonly env;
+    constructor(options?: SecretResolverOptions);
+    resolve(ref: SecretRef): Promise<string>;
+}
+
+interface CommentRunInput {
+    profile: ProfileConfig;
+    runner: CodexRunner;
+    gateway: ChannelGateway;
+    commentScopeId: string;
+    prompt: string;
+    cwdRealpath: string;
+    apiKey?: string;
+}
+declare function runDocumentComment(input: CommentRunInput): Promise<string>;
+declare function stripMarkdown(value: string): string;
+
+declare function scopeForChat(input: {
+    chatId?: string;
+    threadId?: string;
+    chatType?: ChatType;
+    fileToken?: string;
+    commentId?: string;
+    nonce?: string;
+    documentLevel?: boolean;
+}): string;
+declare function messageRequiresMention(message: Pick<BridgeMessage, 'chatType' | 'mentions'>, botOpenId?: string): boolean;
+declare function hasRealBotMention(mentions: readonly {
+    id: string;
+    isBot?: boolean;
+    isAll?: boolean;
+}[], botOpenId?: string): boolean;
+declare function hashId(value: string): string;
+
+interface LarkCliProjection {
+    preset: FeishuCliConfig['identityPreset'];
+    env: Record<string, string>;
+    configDigest: string;
+    health: 'disabled' | 'app' | 'user-ready' | 'missing-config';
+}
+declare function projectLarkCliIdentity(profile: ProfileConfig): Promise<LarkCliProjection>;
+
+interface AgentAttachment {
+    kind: 'image' | 'file';
+    path?: string;
+    name?: string;
+    bytes?: number;
+    mime?: string;
+    required?: boolean;
+    decision?: 'accepted' | 'rejected';
+    reason?: string;
+}
+interface RunPolicyInput {
+    profile: ProfileConfig;
+    scopeId: string;
+    message: Pick<BridgeMessage, 'chatType'>;
+    access: AccessDecision;
+    cwdRealpath: string;
+    prompt: string;
+    attachments: AgentAttachment[];
+    requestedAccess?: BridgeAccessMode;
+    feishuCliConfigDigest?: string;
+}
+type RunPolicyDecision = {
+    ok: true;
+    access: BridgeAccessMode;
+    sandbox: CodexSandboxMode;
+    networkAccess: boolean;
+    policyFingerprint: string;
+    attachments: AgentAttachment[];
+    runScopedEnv: Record<string, string>;
+} | {
+    ok: false;
+    rejectReason: {
+        code: 'access-denied' | 'user-cli-group-blocked' | 'attachment-policy' | 'prompt-empty';
+        userVisible: string;
+    };
+};
+declare function evaluateRunPolicy(input: RunPolicyInput): RunPolicyDecision;
+
+interface CachedMedia {
+    path: string;
+    hash: string;
+    bytes: number;
+    mime?: string;
+}
+declare class MediaCache {
+    private readonly root;
+    constructor(root: string);
+    putBytes(bytes: Buffer, opts?: {
+        name?: string;
+        mime?: string;
+    }): Promise<CachedMedia>;
+    fromFile(path: string, opts?: {
+        mime?: string;
+        kind?: AgentAttachment['kind'];
+        required?: boolean;
+    }): Promise<AgentAttachment>;
+    gc(ttlMs: number, now?: number): Promise<number>;
+}
+declare function hashFile(path: string): Promise<string>;
+
+interface PolicyFingerprintInput {
+    scopeId: string;
+    cwdRealpath: string;
+    sandbox: string;
+    networkAccess: boolean;
+    accessDigest: unknown;
+    resourceDigest: unknown;
+    attachmentDigest: unknown;
+    codexAuthMode: string;
+    codexHome?: string;
+    runtimeIdentity?: string;
+    feishuCliIdentityPreset: string;
+    feishuCliConfigDigest?: string;
+}
+declare function policyFingerprint(input: PolicyFingerprintInput): string;
+declare function accessPolicyDigest(profile: ProfileConfig): string;
+declare function stableJson(value: unknown): string;
+
+declare function clampAccess(requested: BridgeAccessMode, max: BridgeAccessMode): BridgeAccessMode;
+declare function accessToSandbox(access: BridgeAccessMode): CodexSandboxMode;
+declare function decideAccess(config: PermissionConfig, requested?: BridgeAccessMode): BridgeAccessMode;
+
+type WorkspaceRejectReason = 'empty-cwd' | 'relative-cwd' | 'missing-cwd' | 'not-directory' | 'broad-cwd' | 'inaccessible-cwd';
+type WorkspaceResult = {
+    ok: true;
+    cwdRealpath: string;
+} | {
+    ok: false;
+    reason: WorkspaceRejectReason;
+    userVisible: string;
+};
+declare function resolveWorkspace(input: string | undefined): Promise<WorkspaceResult>;
+declare function isBroadWorkspace(path: string): boolean;
+
+interface PromptBuilderInput {
+    message: BridgeMessage;
+    botOpenId?: string;
+    quotedMessages?: Array<{
+        actorId: string;
+        text: string;
+        messageId: string;
+    }>;
+    interactiveCards?: unknown[];
+    attachments?: AgentAttachment[];
+    text?: string;
+}
+declare function buildPrompt(input: PromptBuilderInput): string;
+declare const BRIDGE_INSTRUCTIONS: string;
+
+interface ToolBlock {
+    id: string;
+    name: string;
+    input: unknown;
+    output?: string;
+    isError?: boolean;
+    status: 'running' | 'done';
+}
+interface RunState {
+    runId: string;
+    status: 'queued' | 'running' | 'done' | 'interrupted' | 'timeout' | 'error';
+    text: string;
+    tools: ToolBlock[];
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cachedInputTokens?: number;
+        reasoningOutputTokens?: number;
+    };
+    error?: string;
+    threadId?: string;
+}
+declare function createRunState(runId: string): RunState;
+declare function applyRunEvent(state: RunState, event: CodexBridgeEvent, secrets?: readonly string[]): RunState;
+
+interface RunCardContext {
+    scopeId: string;
+    chatId: string;
+    operatorOpenId: string;
+    policyFingerprint: string;
+    workspaceLabel: string;
+    sandbox: string;
+    authMode: string;
+    callbackAuth?: CallbackAuth;
+}
+interface FeishuCard {
+    config: {
+        wide_screen_mode: boolean;
+        update_multi?: boolean;
+    };
+    header: {
+        title: {
+            tag: 'plain_text';
+            content: string;
+        };
+        template: string;
+    };
+    elements: unknown[];
+}
+declare function buildRunCard(state: RunState, context: RunCardContext): FeishuCard;
+declare function renderMarkdownFallback(state: RunState): string;
+
+declare function redactSecrets(text: string, explicitSecrets?: readonly string[]): string;
+
+declare class ExecJsonRunner implements CodexRunner {
+    private readonly command;
+    private readonly args;
+    private readonly active;
+    constructor(command: string, args?: string[]);
+    start(input: CodexRunInput): Promise<CodexRunHandle>;
+    resume(threadId: string, input: CodexRunInput): Promise<CodexRunHandle>;
+    stop(runId: string): Promise<void>;
+    listThreads(_input: CodexThreadListInput): Promise<CodexThreadSummary[]>;
+    checkAvailability(): Promise<RunnerAvailability>;
+    private spawn;
+}
+
+declare class CodexSdkRunner implements CodexRunner {
+    private readonly active;
+    start(input: CodexRunInput): Promise<CodexRunHandle>;
+    resume(threadId: string, input: CodexRunInput): Promise<CodexRunHandle>;
+    stop(runId: string): Promise<void>;
+    listThreads(_input: CodexThreadListInput): Promise<CodexThreadSummary[]>;
+    checkAvailability(): Promise<RunnerAvailability>;
+    private run;
+    private streamEvents;
+}
+declare function codexBinaryLooksAvailable(codexPath: string): Promise<boolean>;
+
+declare class SdkEventTranslator {
+    private readonly textByItem;
+    translate(event: ThreadEvent): CodexBridgeEvent[];
+    private itemStarted;
+    private itemUpdated;
+    private itemCompleted;
+    private textDelta;
+}
+
+interface RunBridgeOptions {
+    profile?: string;
+    workspace?: string;
+    home?: string;
+    preflight?: boolean;
+    bootstrapOwner?: boolean;
+    appId?: string;
+    appSecret?: string;
+    tenant?: Tenant;
+    codexAuth?: CodexAuthMode;
+    codexApiKey?: string;
+    codexPath?: string;
+    pollChat?: string[];
+}
+declare function runBridge(options?: RunBridgeOptions): Promise<void>;
+declare function runnerForProfile(profile: {
+    codex: {
+        backend: string;
+        codexPath?: string;
+    };
+}): CodexRunner;
+
+declare class ProcessPool {
+    private readonly maxConcurrency;
+    private active;
+    private readonly waiters;
+    constructor(maxConcurrency: number);
+    snapshot(): {
+        active: number;
+        queued: number;
+        maxConcurrency: number;
+    };
+    acquire(opts?: {
+        wait?: boolean;
+    }): Promise<() => void>;
+    private release;
+}
+
+interface StartRunInput {
+    profile: ProfileConfig;
+    runner: CodexRunner;
+    secretResolver: SecretResolver;
+    sessions: SessionStore;
+    sessionCatalog: SessionCatalog;
+    workspaces: WorkspaceStore;
+    message: BridgeMessage;
+    access: AccessDecision;
+    prompt: string;
+    attachments: AgentAttachment[];
+    runId: string;
+    now?: number;
+    onEvent?: (event: CodexBridgeEvent) => void | Promise<void>;
+}
+type StartRunResult = {
+    ok: true;
+    handle: CodexRunHandle;
+    cwdRealpath: string;
+    policy: Extract<RunPolicyDecision, {
+        ok: true;
+    }>;
+    resumeFrom?: string;
+} | {
+    ok: false;
+    workspace?: WorkspaceResult;
+    policy?: Extract<RunPolicyDecision, {
+        ok: false;
+    }>;
+    userVisible: string;
+    code: string;
+};
+declare function startRun(input: StartRunInput): Promise<StartRunResult>;
+
+interface OrchestratorInput {
+    profile: ProfileConfig;
+    runner: CodexRunner;
+    secretResolver: SecretResolver;
+    sessions: SessionStore;
+    sessionCatalog: SessionCatalog;
+    workspaces: WorkspaceStore;
+    pool?: ProcessPool;
+    runId?: () => string;
+    onEvent?: (scopeId: string, event: CodexBridgeEvent) => void | Promise<void>;
+}
+interface SubmitInput {
+    message: BridgeMessage;
+    access: AccessDecision;
+    prompt: string;
+    attachments?: AgentAttachment[];
+}
+declare class RunOrchestrator {
+    private readonly input;
+    private readonly scopes;
+    private readonly pool;
+    private readonly runId;
+    constructor(input: OrchestratorInput);
+    snapshot(scopeId?: string): unknown;
+    isActive(scopeId: string): boolean;
+    submit(input: SubmitInput): Promise<StartRunResult | {
+        ok: true;
+        queued: true;
+    }>;
+    stop(scopeId: string): Promise<boolean>;
+    private startInScope;
+    private state;
+}
+
+interface BindBridgeRuntimeInput {
+    profile: ProfileConfig;
+    paths: ProfilePaths;
+    gateway: ChannelGateway;
+    runner: CodexRunner;
+    secretResolver: SecretResolver;
+    appSecret: string;
+    ownerOpenId?: string;
+    botOpenId?: string;
+    bootstrapOwner?: boolean;
+    saveProfile?: (profile: ProfileConfig) => Promise<void>;
+    processSnapshot?: () => Promise<unknown> | unknown;
+    lifecycle?: {
+        exit?: (target?: string) => Promise<void>;
+        reconnect?: () => Promise<void>;
+    };
+}
+declare function bindBridgeRuntime(input: BindBridgeRuntimeInput): RunOrchestrator;
+
+declare class RuntimeLock {
+    private readonly path;
+    private locked;
+    constructor(path: string);
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    private isStale;
+}
+declare function profileLock(profile: string, home?: string): RuntimeLock;
+declare function appLock(appId: string, home?: string): RuntimeLock;
+
+interface ProcessRecord {
+    id: string;
+    pid: number;
+    profile: string;
+    tenant: string;
+    appId: string;
+    botName?: string;
+    startedAt: number;
+    host: string;
+    platform: string;
+    logPath?: string;
+}
+declare class RuntimeRegistry {
+    private readonly path;
+    constructor(home?: string);
+    register(record: Omit<ProcessRecord, 'id' | 'pid' | 'startedAt' | 'host' | 'platform'> & Partial<Pick<ProcessRecord, 'id' | 'pid' | 'startedAt'>>): Promise<ProcessRecord>;
+    unregister(idOrPid: string | number): Promise<void>;
+    list(): Promise<ProcessRecord[]>;
+    find(idOrPid: string | number): Promise<ProcessRecord | undefined>;
+    kill(idOrPid: string | number, signal?: NodeJS.Signals): Promise<ProcessRecord | undefined>;
+    private read;
+    private write;
+}
+declare function isAlive(pid: number): boolean;
+
+export { type AccessContext, type AccessDecision, type ActorRole, type ActorType, type AgentAttachment, type AppConfig, type ApprovalRequest, type AttachmentConfig, BRIDGE_INSTRUCTIONS, type BindBridgeRuntimeInput, type BootstrapRunOptions, type BridgeAccessMode, type BridgeAction, type BridgeCommentTarget, type BridgeMention, type BridgeMessage, type BridgePaths, type BridgeReply, type BridgeResource, type BridgeResourceData, type BridgeSource, type CachedMedia, CallbackAuth, type CallbackKey, type CallbackNonceStore, type CallbackPayload, type CallbackSignInput, type CallbackVerifyExpected, type CallbackVerifyResult, type ChannelGateway, type ChatType, type CodexAuthConfig, type CodexAuthMode, type CodexBackend, type CodexBridgeEvent, type CodexConfig, type CodexRunHandle, type CodexRunInput, type CodexRunner, type CodexSandboxMode, CodexSdkRunner, type CodexThreadListInput, type CodexThreadSummary, type CommandContext, type CommandResult, type CommentRunInput, type CreateProfileInput, type CreateProfileWithSecretsInput, DEFAULT_HOME_DIR, ExecJsonRunner, type FeishuCard, type FeishuCliConfig, type LarkCliIdentityPreset, type LarkCliProjection, LocalKeystore, MediaCache, MemoryCallbackNonceStore, type NonceState, type OrchestratorInput, type PermissionConfig, type PolicyFingerprintInput, type PreferencesConfig, ProcessPool, type ProcessRecord, type ProfileAccess, type ProfileConfig, type ProfilePaths, ProfileStore, type ProfileSummary, type PromptBuilderInput, type RegistrationResult, type RegistrationWizardOptions, type ReplyMode, type RootConfigFile, type RunBridgeOptions, type RunCardContext, RunOrchestrator, type RunPolicyDecision, type RunPolicyInput, type RunState, type RunnerAvailability, RuntimeLock, RuntimeRegistry, SdkEventTranslator, type SecretRef, SecretResolver, type SecretResolverOptions, SessionCatalog, type SessionCatalogEntry, SessionStore, type StartRunInput, type StartRunResult, type SubmitInput, type Tenant, type ToolBlock, type WorkspaceRejectReason, type WorkspaceResult, WorkspaceStore, accessPolicyDigest, accessToSandbox, appLock, applyRunEvent, bindBridgeRuntime, bootstrapProfile, bridgePaths, buildPrompt, buildRunCard, canRunAdminCommand, catalogKey, clampAccess, codexBinaryLooksAvailable, createDefaultProfileConfig, createRunState, decideAccess, ensureProfileForRun, evaluateAccess, evaluateRunPolicy, expandTilde, getBridgeHome, hasRealBotMention, hashFile, hashId, isAlive, isBroadWorkspace, isSecretRef, messageRequiresMention, normalizeProfileConfig, parentDir, parseCommand, policyFingerprint, profileExists, profileLock, profileLogPath, profileNameFromPath, profilePaths, projectLarkCliIdentity, redactProfileConfig, redactSecrets, renderMarkdownFallback, resolveWorkspace, routeCommand, runBridge, runDocumentComment, runRegistrationWizard, runnerForProfile, scopeForChat, stableJson, startRun, stripMarkdown, tempRoot };