@struktoai/mirage-node 0.0.1-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1671 @@
+import { Workspace as Workspace$1, Resource, WorkspaceOptions, ExecuteOptions, ExecuteResult, ProvisionResult, Accessor, IndexCacheStore, RegisteredOp, RegisteredCommand, PathSpec, FileStat, FindOptions, CommandOpts, FileCache, IndexConfig, LookupResult, IndexEntry, ListResult, OpRecord, S3Config as S3Config$1, S3ConfigRedacted as S3ConfigRedacted$1, S3Accessor, PgDriver, PostgresConfigResolved, PgQueryResult, PostgresAccessor, PostgresConfig, MongoDriver, MongoFindOptions, MongoDBConfigResolved, MongoDBAccessor, MongoDBConfig, SSCholarConfigResolved, SSCholarDriver, SSCholarAccessor, SSCholarConfig, VercelConfigResolved, VercelDriver, VercelAccessor, VercelConfig, PostHogConfigResolved, PostHogDriver, PostHogAccessor, PostHogConfig, SlackAccessor, DiscordAccessor, TrelloAccessor, LinearAccessor, LangfuseAccessor, GitHubAccessor, GitHubCIAccessor, GDocsAccessor, GSheetsAccessor, GSlidesAccessor, GDriveAccessor, DropboxAccessor, BoxAccessor, GmailAccessor } from '@struktoai/mirage-core';
+export * from '@struktoai/mirage-core';
+import { RedisClientType } from 'redis';
+import { ChildProcess } from 'node:child_process';
+import { Readable } from 'node:stream';
+import { SFTPWrapper } from 'ssh2';
+import { ImapFlow } from 'imapflow';
+
+interface NodeWorkspaceOptions extends WorkspaceOptions {
+    fuse?: boolean;
+    native?: boolean;
+}
+declare class Workspace extends Workspace$1 {
+    private readonly defaultNative;
+    private readonly autoFuseManager;
+    private fuseSetupPromise;
+    constructor(resources: Record<string, Resource>, options?: NodeWorkspaceOptions);
+    private ensureFuseReady;
+    execute(command: string, options?: ExecuteOptions & {
+        provision?: false | undefined;
+    }): Promise<ExecuteResult>;
+    execute(command: string, options: ExecuteOptions & {
+        provision: true;
+    }): Promise<ProvisionResult>;
+    execute(command: string, options: ExecuteOptions): Promise<ExecuteResult | ProvisionResult>;
+    close(): Promise<void>;
+}
+
+declare class DiskAccessor extends Accessor {
+    readonly root: string;
+    constructor(root: string);
+}
+
+interface DiskResourceOptions {
+    root: string;
+}
+interface DiskResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: string[];
+    files: Record<string, Uint8Array>;
+}
+declare class DiskResource implements Resource {
+    readonly kind: "disk";
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt = "{prefix}\n  Local disk filesystem. Mirrors the configured root directory.\n  Standard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.";
+    readonly root: string;
+    readonly accessor: DiskAccessor;
+    readonly index: IndexCacheStore;
+    readonly opsMap: Record<string, unknown>;
+    constructor(options: DiskResourceOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    streamPath(p: PathSpec): AsyncIterable<Uint8Array>;
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    writeFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    appendFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    exists(p: PathSpec): Promise<boolean>;
+    mkdir(p: PathSpec, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(p: PathSpec): Promise<void>;
+    unlink(p: PathSpec): Promise<void>;
+    rename(src: PathSpec, dst: PathSpec): Promise<void>;
+    truncate(p: PathSpec, length: number): Promise<void>;
+    copy(src: PathSpec, dst: PathSpec): Promise<void>;
+    rmR(p: PathSpec): Promise<void>;
+    du(p: PathSpec): Promise<number>;
+    find(p: PathSpec, options?: FindOptions): Promise<string[]>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<DiskResourceState>;
+    loadState(state: DiskResourceState): Promise<void>;
+}
+
+declare const DISK_PROMPT = "{prefix}\n  Local disk filesystem. Mirrors the configured root directory.\n  Standard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.";
+
+declare const DISK_OPS: readonly RegisteredOp[];
+
+/**
+ * Monkey-patch Node's `fs` module so that paths under any mirage mount
+ * route through the workspace. Paths NOT under a mount fall through to
+ * the real native fs. CJS-friendly; for ESM code you still need to use
+ * `ws.fs.*` directly since ESM bindings are frozen.
+ *
+ * Returns a `restore()` function that undoes the patch.
+ */
+declare function patchNodeFs(ws: Workspace$1): () => void;
+
+interface RedisStoreOptions {
+    url?: string;
+    client?: RedisClientType;
+    keyPrefix?: string;
+}
+declare class RedisStore {
+    readonly url: string;
+    readonly keyPrefix: string;
+    private readonly providedClient;
+    private clientPromise;
+    constructor(options?: RedisStoreOptions);
+    fk(path: string): string;
+    dk(): string;
+    mk(path: string): string;
+    client(): Promise<RedisClientType>;
+    getFile(path: string): Promise<Uint8Array | null>;
+    setFile(path: string, data: Uint8Array): Promise<void>;
+    delFile(path: string): Promise<void>;
+    hasFile(path: string): Promise<boolean>;
+    listFiles(prefix?: string): Promise<string[]>;
+    fileLen(path: string): Promise<number>;
+    getRange(path: string, start: number, end: number): Promise<Uint8Array>;
+    hasDir(path: string): Promise<boolean>;
+    addDir(path: string): Promise<void>;
+    removeDir(path: string): Promise<void>;
+    listDirs(): Promise<Set<string>>;
+    getModified(path: string): Promise<string | null>;
+    setModified(path: string, ts: string): Promise<void>;
+    delModified(path: string): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+}
+
+declare class RedisAccessor extends Accessor {
+    readonly store: RedisStore;
+    constructor(store: RedisStore);
+}
+
+interface RedisResourceOptions {
+    url?: string;
+    keyPrefix?: string;
+}
+interface RedisModule {
+    createClient: (options: {
+        url: string;
+    }) => RedisClientType;
+    RESP_TYPES: {
+        readonly BLOB_STRING: number;
+    };
+}
+interface RedisResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: string[];
+    keyPrefix: string;
+    files: Record<string, Uint8Array>;
+    dirs: string[];
+}
+declare class RedisResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly url: string;
+    readonly keyPrefix: string;
+    readonly store: RedisStore;
+    readonly accessor: RedisAccessor;
+    readonly index: IndexCacheStore;
+    readonly opsMap: Record<string, unknown>;
+    constructor(options?: RedisResourceOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    client(): Promise<RedisClientType>;
+    protected module(): Promise<RedisModule>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    streamPath(p: PathSpec): AsyncIterable<Uint8Array>;
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    writeFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    appendFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    exists(p: PathSpec): Promise<boolean>;
+    mkdir(p: PathSpec, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(p: PathSpec): Promise<void>;
+    unlink(p: PathSpec): Promise<void>;
+    rename(src: PathSpec, dst: PathSpec): Promise<void>;
+    truncate(p: PathSpec, length: number): Promise<void>;
+    copy(src: PathSpec, dst: PathSpec): Promise<void>;
+    rmR(p: PathSpec): Promise<void>;
+    du(p: PathSpec): Promise<number>;
+    find(p: PathSpec, options?: FindOptions): Promise<string[]>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<RedisResourceState>;
+    loadState(state: RedisResourceState): Promise<void>;
+}
+
+declare const REDIS_PROMPT = "Redis-backed persistent filesystem. Behaves like a standard filesystem.\nStandard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.";
+
+declare const REDIS_OPS: readonly RegisteredOp[];
+
+interface RedisResourceLike extends Resource {
+    readonly accessor: RedisAccessor;
+}
+declare function fileReadProvision(accessor: Accessor, paths: PathSpec[], _texts: string[], _opts: CommandOpts): Promise<ProvisionResult>;
+declare function headTailProvision(accessor: Accessor, paths: PathSpec[], _texts: string[], _opts: CommandOpts): Promise<ProvisionResult>;
+declare function metadataProvision(_accessor: Accessor, paths: PathSpec[], _texts: string[], _opts: CommandOpts): ProvisionResult;
+
+interface RedisFileCacheOptions extends RedisResourceOptions {
+    cacheLimit?: string | number;
+    maxDrainBytes?: number | null;
+}
+declare class RedisFileCacheStore extends RedisResource implements FileCache {
+    private readonly limit;
+    private readonly dataPrefix;
+    private readonly metaPrefix;
+    maxDrainBytes: number | null;
+    constructor(options?: RedisFileCacheOptions);
+    readonly cacheSize = 0;
+    get cacheLimit(): number;
+    cacheClient(): Promise<RedisClientType>;
+    get(key: string): Promise<Uint8Array | null>;
+    set(key: string, data: Uint8Array, options?: {
+        fingerprint?: string | null;
+        ttl?: number | null;
+    }): Promise<void>;
+    add(key: string, data: Uint8Array, options?: {
+        fingerprint?: string | null;
+        ttl?: number | null;
+    }): Promise<boolean>;
+    remove(key: string): Promise<void>;
+    exists(key: string | PathSpec): Promise<boolean>;
+    isFresh(key: string, remoteFingerprint: string): Promise<boolean>;
+    clear(): Promise<void>;
+    allCached(keys: readonly string[]): Promise<boolean>;
+    multiGet(keys: readonly string[]): Promise<(Uint8Array | null)[]>;
+}
+
+interface RedisIndexCacheOptions {
+    ttl?: number;
+    url?: string;
+    client?: RedisClientType;
+    keyPrefix?: string;
+}
+declare class RedisIndexCacheStore extends IndexCacheStore {
+    private readonly ttl;
+    private readonly url;
+    private readonly providedClient;
+    private readonly entryPrefix;
+    private readonly childrenPrefix;
+    private clientPromise;
+    constructor(options?: RedisIndexCacheOptions);
+    static fromConfig(config: IndexConfig, extra?: Omit<RedisIndexCacheOptions, 'ttl'>): RedisIndexCacheStore;
+    private entryKey;
+    private childrenKey;
+    private client;
+    get(resourcePath: string): Promise<LookupResult>;
+    put(resourcePath: string, entry: IndexEntry): Promise<void>;
+    listDir(resourcePath: string): Promise<ListResult>;
+    setDir(resourcePath: string, entries: readonly [string, IndexEntry][], expiredAt?: Date | null): Promise<void>;
+    invalidateDir(resourcePath: string): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    private serialize;
+}
+
+interface FuseHandle {
+    mountpoint: string;
+    unmount: () => Promise<void>;
+}
+interface MountOptions {
+    mountpoint?: string;
+    agentId?: string;
+    /**
+     * When true, `@zkochan/fuse-native`'s `autoUnmount` flag is set so the
+     * kernel releases the mount if the process exits abnormally. Defaults to
+     * `true` on Linux, `false` on darwin — macFUSE rejects the option with
+     * "unknown option `auto_unmount'". On darwin the SIGINT cleanup in
+     * FuseManager runs `diskutil unmount force` instead.
+     */
+    autoUnmount?: boolean;
+    /** Extra options forwarded verbatim to `@zkochan/fuse-native`. */
+    fuseOptions?: Record<string, unknown>;
+}
+declare function mount(ws: Workspace$1, options?: MountOptions): Promise<FuseHandle>;
+declare function mountBackground(ws: Workspace$1, options?: MountOptions): Promise<FuseHandle>;
+
+declare class FuseManager {
+    private handle;
+    private externalMountpoint;
+    private auto;
+    private cleanupEntry;
+    get mountpoint(): string | null;
+    set mountpoint(path: string | null);
+    setup(ws: Workspace$1, options?: MountOptions): Promise<string>;
+    unmount(ws?: Workspace$1): Promise<void>;
+    close(ws?: Workspace$1): Promise<void>;
+}
+
+interface FuseAttr {
+    mtime: Date;
+    atime: Date;
+    ctime: Date;
+    nlink: number;
+    size: number;
+    mode: number;
+    uid: number;
+    gid: number;
+}
+interface MirageFSOptions {
+    agentId?: string;
+}
+declare class MirageFS {
+    private readonly ws;
+    readonly agentId: string;
+    private readonly now;
+    private readonly prefixes;
+    private readonly handles;
+    private readonly prefetchCache;
+    private readonly prefetchInflight;
+    private nextFh;
+    private readonly uid;
+    private readonly gid;
+    constructor(ws: Workspace$1, options?: MirageFSOptions);
+    private whoamiContent;
+    private dirStat;
+    private fileStat;
+    private isVirtualDir;
+    private virtualChildren;
+    private cachedSize;
+    private cachedData;
+    /**
+     * Fetch bytes for a size-unknown file and cache them so the immediate
+     * getattr → open → read burst (and subsequent stats within the TTL) reuse
+     * the same fetch. Required because @zkochan/fuse-native doesn't expose
+     * libfuse's `direct_io` flag — without a real size from getattr, the kernel
+     * decides the file is empty and never issues read().
+     */
+    private prefetch;
+    /** Drain and return accumulated op records (mirrors Python's drain_ops). */
+    drainOps(): OpRecord[];
+    ops(): Record<string, unknown>;
+    private getattr;
+    private readdir;
+    private read;
+    private write;
+    private create;
+    private mkdir;
+    private unlink;
+    private rename;
+    private rmdir;
+    private truncate;
+    private statfs;
+    private chmod;
+    private chown;
+    private utimens;
+    private access;
+    private getattrValidate;
+    private open;
+    private release;
+    private flush;
+    private fsync;
+}
+
+interface NativeExecOptions {
+    cwd: string;
+    env?: Record<string, string>;
+    timeoutMs?: number | null;
+    signal?: AbortSignal;
+}
+type NativeExecResult = ExecuteResult;
+declare function nativeExec(command: string, options: NativeExecOptions): Promise<NativeExecResult>;
+interface NativeProcess {
+    raw: ChildProcess;
+    stdoutStream(): Readable;
+    stderrStream(): Readable | null;
+    wait(): Promise<number>;
+}
+declare function nativeExecStream(command: string, options: NativeExecOptions): NativeProcess;
+
+declare function isMacosMetadata(name: string): boolean;
+
+interface S3Config extends S3Config$1 {
+    profile?: string;
+}
+interface S3ConfigRedacted extends S3ConfigRedacted$1 {
+    profile?: string;
+}
+declare function redactConfig(config: S3Config): S3ConfigRedacted;
+
+interface S3ResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: S3ConfigRedacted;
+}
+declare class S3Resource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: S3Config;
+    readonly accessor: S3Accessor;
+    readonly index: IndexCacheStore;
+    readonly opsMap: Record<string, unknown>;
+    constructor(config: S3Config);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    streamPath(p: PathSpec): AsyncIterable<Uint8Array>;
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    writeFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    appendFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    exists(p: PathSpec): Promise<boolean>;
+    mkdir(p: PathSpec): Promise<void>;
+    rmdir(p: PathSpec): Promise<void>;
+    unlink(p: PathSpec): Promise<void>;
+    rename(src: PathSpec, dst: PathSpec): Promise<void>;
+    truncate(p: PathSpec, length: number): Promise<void>;
+    copy(src: PathSpec, dst: PathSpec): Promise<void>;
+    rmR(p: PathSpec): Promise<void>;
+    du(p: PathSpec): Promise<number>;
+    find(p: PathSpec, options?: FindOptions): Promise<string[]>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    getState(): Promise<S3ResourceState>;
+    loadState(_state: S3ResourceState): Promise<void>;
+}
+
+declare const GCS_ENDPOINT = "https://storage.googleapis.com";
+interface GCSConfig {
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint?: string;
+    region?: string;
+    timeoutMs?: number;
+}
+interface GCSConfigRedacted {
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    region: string;
+    timeoutMs?: number;
+}
+declare function redactGcsConfig(config: GCSConfig): GCSConfigRedacted;
+
+interface GCSResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GCSConfigRedacted;
+}
+declare class GCSResource extends S3Resource {
+    readonly kind: string;
+    readonly prompt: string;
+    readonly gcsConfig: GCSConfig;
+    private readonly gcsOps;
+    private readonly gcsCommands;
+    constructor(config: GCSConfig);
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    getState(): Promise<GCSResourceState>;
+    loadState(_state: GCSResourceState): Promise<void>;
+}
+
+declare const GCS_PROMPT = "{prefix}\n  Remote Google Cloud Storage bucket.\n  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.\n  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, jq, stat.\n  cat on .parquet/.orc/.feather returns a formatted table.";
+
+interface OCIConfig {
+    bucket: string;
+    namespace: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint?: string;
+    timeoutMs?: number;
+}
+interface OCIConfigRedacted {
+    bucket: string;
+    namespace: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    timeoutMs?: number;
+}
+declare function redactOciConfig(config: OCIConfig): OCIConfigRedacted;
+
+interface OCIResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: OCIConfigRedacted;
+}
+declare class OCIResource extends S3Resource {
+    readonly kind: string;
+    readonly prompt: string;
+    readonly ociConfig: OCIConfig;
+    private readonly ociOps;
+    private readonly ociCommands;
+    constructor(config: OCIConfig);
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    getState(): Promise<OCIResourceState>;
+    loadState(_state: OCIResourceState): Promise<void>;
+}
+
+declare const OCI_PROMPT = "{prefix}\n  Remote Oracle Cloud Object Storage.\n  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.\n  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, jq, stat.";
+
+interface R2Config {
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    accountId?: string;
+    endpoint?: string;
+    region?: string;
+    profile?: string;
+    timeoutMs?: number;
+}
+interface R2ConfigRedacted {
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    accountId?: string;
+    endpoint: string;
+    region: string;
+    profile?: string;
+    timeoutMs?: number;
+}
+declare function redactR2Config(config: R2Config): R2ConfigRedacted;
+
+interface R2ResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: R2ConfigRedacted;
+}
+declare class R2Resource extends S3Resource {
+    readonly kind: string;
+    readonly prompt: string;
+    readonly r2Config: R2Config;
+    private readonly r2Ops;
+    private readonly r2Commands;
+    constructor(config: R2Config);
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    getState(): Promise<R2ResourceState>;
+    loadState(_state: R2ResourceState): Promise<void>;
+}
+
+declare const R2_PROMPT = "{prefix}\n  Remote Cloudflare R2 bucket.\n  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.\n  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, jq, stat.\n  cat on .parquet/.orc/.feather returns a formatted table.";
+
+interface SupabaseConfig {
+    bucket: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    projectRef?: string;
+    endpoint?: string;
+    sessionToken?: string;
+    timeoutMs?: number;
+}
+interface SupabaseConfigRedacted {
+    bucket: string;
+    region: string;
+    projectRef?: string;
+    endpoint: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    timeoutMs?: number;
+}
+declare function resolvedSupabaseEndpoint(config: SupabaseConfig): string;
+declare function redactSupabaseConfig(config: SupabaseConfig): SupabaseConfigRedacted;
+
+interface SupabaseResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: SupabaseConfigRedacted;
+}
+declare class SupabaseResource extends S3Resource {
+    readonly kind: string;
+    readonly prompt: string;
+    readonly supabaseConfig: SupabaseConfig;
+    private readonly supabaseOps;
+    private readonly supabaseCommands;
+    constructor(config: SupabaseConfig);
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    getState(): Promise<SupabaseResourceState>;
+    loadState(_state: SupabaseResourceState): Promise<void>;
+}
+
+declare const SUPABASE_PROMPT = "{prefix}\n  Remote Supabase Storage bucket.\n  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.\n  Supports: ls, cat, head, tail, grep, wc, find, stat.";
+
+interface PgPoolLike {
+    query: (sql: string, params?: readonly unknown[]) => Promise<{
+        rows: unknown[];
+        rowCount: number | null;
+    }>;
+    end: () => Promise<void>;
+}
+declare class PostgresStore implements PgDriver {
+    readonly config: PostgresConfigResolved;
+    private poolPromise;
+    constructor(config: PostgresConfigResolved);
+    query<R = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<PgQueryResult<R>>;
+    databaseName(): Promise<string>;
+    close(): Promise<void>;
+    private _pool;
+    protected _connect(): Promise<PgPoolLike>;
+}
+
+interface PostgresResourceOptions {
+    config: PostgresConfig;
+    prefix?: string;
+}
+declare class PostgresResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: PostgresConfigResolved;
+    readonly store: PostgresStore;
+    readonly accessor: PostgresAccessor;
+    readonly index: IndexCacheStore;
+    constructor(options: PostgresResourceOptions | PostgresConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+}
+
+interface MongoCollectionLike {
+    find: (filter: Record<string, unknown>, options?: {
+        projection?: Record<string, unknown>;
+    }) => {
+        sort: (sort: Record<string, 1 | -1>) => MongoCursorLike;
+        skip: (n: number) => MongoCursorLike;
+        limit: (n: number) => MongoCursorLike;
+        toArray: () => Promise<Record<string, unknown>[]>;
+    };
+    countDocuments: (filter?: Record<string, unknown>) => Promise<number>;
+    listIndexes: () => {
+        toArray: () => Promise<Record<string, unknown>[]>;
+    };
+}
+interface MongoCursorLike {
+    sort: (sort: Record<string, 1 | -1>) => MongoCursorLike;
+    skip: (n: number) => MongoCursorLike;
+    limit: (n: number) => MongoCursorLike;
+    toArray: () => Promise<Record<string, unknown>[]>;
+}
+interface MongoDbLike {
+    listCollections: () => {
+        toArray: () => Promise<{
+            name: string;
+        }[]>;
+    };
+    collection: (name: string) => MongoCollectionLike;
+    admin: () => {
+        listDatabases: () => Promise<{
+            databases: {
+                name: string;
+            }[];
+        }>;
+    };
+}
+interface MongoClientLike {
+    connect: () => Promise<MongoClientLike>;
+    db: (name?: string) => MongoDbLike;
+    close: () => Promise<void>;
+}
+declare class MongoDBStore implements MongoDriver {
+    readonly uri: string;
+    private clientPromise;
+    constructor(uri: string);
+    listDatabases(): Promise<string[]>;
+    listCollections(database: string): Promise<string[]>;
+    findDocuments<T = Record<string, unknown>>(database: string, collection: string, filter?: Record<string, unknown>, options?: MongoFindOptions): Promise<T[]>;
+    countDocuments(database: string, collection: string, filter?: Record<string, unknown>): Promise<number>;
+    listIndexes(database: string, collection: string): Promise<Record<string, unknown>[]>;
+    close(): Promise<void>;
+    private _client;
+    protected _connect(): Promise<MongoClientLike>;
+}
+
+interface MongoDBResourceOptions {
+    config: MongoDBConfig;
+    prefix?: string;
+}
+declare class MongoDBResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: MongoDBConfigResolved;
+    readonly store: MongoDBStore;
+    readonly accessor: MongoDBAccessor;
+    readonly index: IndexCacheStore;
+    constructor(options: MongoDBResourceOptions | MongoDBConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+}
+
+interface SSCholarPaperResourceOptions {
+    config?: SSCholarConfig;
+    prefix?: string;
+    driver?: SSCholarDriver;
+}
+declare class SSCholarPaperResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: SSCholarConfigResolved;
+    readonly driver: SSCholarDriver;
+    readonly accessor: SSCholarAccessor;
+    readonly index: IndexCacheStore;
+    constructor(options?: SSCholarPaperResourceOptions | SSCholarConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+}
+
+interface SSCholarAuthorResourceOptions {
+    config?: SSCholarConfig;
+    prefix?: string;
+    driver?: SSCholarDriver;
+}
+declare class SSCholarAuthorResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: SSCholarConfigResolved;
+    readonly driver: SSCholarDriver;
+    readonly accessor: SSCholarAccessor;
+    readonly index: IndexCacheStore;
+    constructor(options?: SSCholarAuthorResourceOptions | SSCholarConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+}
+
+interface VercelResourceOptions {
+    config?: VercelConfig;
+    prefix?: string;
+    driver?: VercelDriver;
+}
+declare class VercelResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: VercelConfigResolved;
+    readonly driver: VercelDriver;
+    readonly accessor: VercelAccessor;
+    readonly index: IndexCacheStore;
+    constructor(options?: VercelResourceOptions | VercelConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+}
+
+interface PostHogResourceOptions {
+    config?: PostHogConfig;
+    prefix?: string;
+    driver?: PostHogDriver;
+}
+declare class PostHogResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: PostHogConfigResolved;
+    readonly driver: PostHogDriver;
+    readonly accessor: PostHogAccessor;
+    readonly index: IndexCacheStore;
+    constructor(options?: PostHogResourceOptions | PostHogConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+}
+
+interface SlackConfig {
+    token: string;
+    searchToken?: string;
+}
+interface SlackConfigRedacted {
+    token: '<REDACTED>';
+    searchToken?: '<REDACTED>';
+}
+declare function redactSlackConfig(config: SlackConfig): SlackConfigRedacted;
+declare function normalizeSlackConfig(input: Record<string, unknown>): SlackConfig;
+
+interface SlackResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: SlackConfigRedacted;
+}
+declare class SlackResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: SlackConfig;
+    readonly accessor: SlackAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: SlackConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<SlackResourceState>;
+    loadState(_state: SlackResourceState): Promise<void>;
+}
+
+interface SSHConfig {
+    host: string;
+    hostname?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    identityFile?: string;
+    passphrase?: string;
+    root?: string;
+    timeout?: number;
+    knownHosts?: string;
+}
+interface SSHConfigRedacted {
+    host: string;
+    hostname?: string;
+    port?: number;
+    username?: string;
+    password?: '<REDACTED>';
+    identityFile?: string;
+    passphrase?: '<REDACTED>';
+    root?: string;
+    timeout?: number;
+    knownHosts?: string;
+}
+declare function redactSshConfig(config: SSHConfig): SSHConfigRedacted;
+declare function normalizeSshConfig(input: Record<string, unknown>): SSHConfig;
+
+declare class SSHAccessor extends Accessor {
+    readonly config: SSHConfig;
+    private client;
+    private sftpClient;
+    private connectPromise;
+    constructor(config: SSHConfig);
+    sftp(): Promise<SFTPWrapper>;
+    private connect;
+    close(): Promise<void>;
+}
+
+interface SSHResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: SSHConfigRedacted;
+}
+declare class SSHResource implements Resource {
+    readonly kind: "ssh";
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt = "{prefix}\n  Remote filesystem via SSH/SFTP.\n  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.\n  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, stat, mkdir, touch, cp, mv, rm, tee.";
+    readonly config: SSHConfig;
+    readonly accessor: SSHAccessor;
+    readonly index: IndexCacheStore;
+    readonly opsMap: Record<string, unknown>;
+    constructor(config: SSHConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ops(): readonly RegisteredOp[];
+    commands(): readonly RegisteredCommand[];
+    streamPath(p: PathSpec): AsyncIterable<Uint8Array>;
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    writeFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    appendFile(p: PathSpec, data: Uint8Array): Promise<void>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    exists(p: PathSpec): Promise<boolean>;
+    mkdir(p: PathSpec, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(p: PathSpec): Promise<void>;
+    unlink(p: PathSpec): Promise<void>;
+    rename(src: PathSpec, dst: PathSpec): Promise<void>;
+    truncate(p: PathSpec, length: number): Promise<void>;
+    copy(src: PathSpec, dst: PathSpec): Promise<void>;
+    rmR(p: PathSpec): Promise<void>;
+    du(p: PathSpec): Promise<number>;
+    find(p: PathSpec, options?: FindOptions): Promise<string[]>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<SSHResourceState>;
+    loadState(_state: SSHResourceState): Promise<void>;
+}
+
+declare const SSH_PROMPT = "{prefix}\n  Remote filesystem via SSH/SFTP.\n  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.\n  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, stat, mkdir, touch, cp, mv, rm, tee.";
+
+declare const SSH_COMMANDS: readonly RegisteredCommand[];
+
+declare const SSH_OPS: readonly RegisteredOp[];
+
+interface DiscordConfig {
+    token: string;
+}
+interface DiscordConfigRedacted {
+    token: '<REDACTED>';
+}
+declare function redactDiscordConfig(_config: DiscordConfig): DiscordConfigRedacted;
+declare function normalizeDiscordConfig(input: Record<string, unknown>): DiscordConfig;
+
+interface DiscordResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: DiscordConfigRedacted;
+}
+declare class DiscordResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: DiscordConfig;
+    readonly accessor: DiscordAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: DiscordConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<DiscordResourceState>;
+    loadState(_state: DiscordResourceState): Promise<void>;
+}
+
+interface TrelloConfig {
+    apiKey: string;
+    apiToken: string;
+    workspaceId?: string;
+    boardIds?: readonly string[];
+    baseUrl?: string;
+}
+interface TrelloConfigRedacted {
+    apiKey: '<REDACTED>';
+    apiToken: '<REDACTED>';
+    workspaceId?: string;
+    boardIds?: readonly string[];
+    baseUrl?: string;
+}
+declare function redactTrelloConfig(config: TrelloConfig): TrelloConfigRedacted;
+declare function normalizeTrelloConfig(input: Record<string, unknown>): TrelloConfig;
+
+interface TrelloResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: TrelloConfigRedacted;
+}
+declare class TrelloResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: TrelloConfig;
+    readonly accessor: TrelloAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: TrelloConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    private filter;
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<TrelloResourceState>;
+    loadState(_state: TrelloResourceState): Promise<void>;
+}
+
+interface LinearConfig {
+    apiKey: string;
+    workspace?: string;
+    teamIds?: readonly string[];
+    baseUrl?: string;
+}
+interface LinearConfigRedacted {
+    apiKey: '<REDACTED>';
+    workspace?: string;
+    teamIds?: readonly string[];
+    baseUrl?: string;
+}
+declare function redactLinearConfig(config: LinearConfig): LinearConfigRedacted;
+declare function normalizeLinearConfig(input: Record<string, unknown>): LinearConfig;
+
+interface LinearResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: LinearConfigRedacted;
+}
+declare class LinearResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: LinearConfig;
+    readonly accessor: LinearAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: LinearConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    private filter;
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<LinearResourceState>;
+    loadState(_state: LinearResourceState): Promise<void>;
+}
+
+interface LangfuseConfig {
+    publicKey: string;
+    secretKey: string;
+    host?: string;
+    defaultTraceLimit?: number;
+    defaultSearchLimit?: number;
+    defaultFromTimestamp?: string;
+}
+interface LangfuseConfigRedacted {
+    publicKey: string;
+    secretKey: '<REDACTED>';
+    host?: string;
+    defaultTraceLimit?: number;
+    defaultSearchLimit?: number;
+    defaultFromTimestamp?: string;
+}
+declare function redactLangfuseConfig(config: LangfuseConfig): LangfuseConfigRedacted;
+declare function normalizeLangfuseConfig(input: Record<string, unknown>): LangfuseConfig;
+
+interface LangfuseResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: LangfuseConfigRedacted;
+}
+declare class LangfuseResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: LangfuseConfig;
+    readonly accessor: LangfuseAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: LangfuseConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(_p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<LangfuseResourceState>;
+    loadState(_state: LangfuseResourceState): Promise<void>;
+}
+
+interface GitHubConfig {
+    token: string;
+    owner: string;
+    repo: string;
+    ref?: string;
+    baseUrl?: string;
+}
+interface GitHubConfigRedacted {
+    token: '<REDACTED>';
+    owner: string;
+    repo: string;
+    ref?: string;
+    baseUrl?: string;
+}
+declare function redactGitHubConfig(config: GitHubConfig): GitHubConfigRedacted;
+declare function normalizeGitHubConfig(input: Record<string, unknown>): GitHubConfig;
+
+interface GitHubResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GitHubConfigRedacted;
+    defaultBranch: string;
+    truncated: boolean;
+}
+declare class GitHubResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly config: GitHubConfig;
+    readonly accessor: GitHubAccessor;
+    readonly index: IndexCacheStore;
+    private constructor();
+    static create(config: GitHubConfig): Promise<GitHubResource>;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GitHubResourceState>;
+    loadState(_state: GitHubResourceState): Promise<void>;
+}
+
+interface GitHubCIConfig {
+    token: string;
+    owner: string;
+    repo: string;
+    days?: number;
+    maxRuns?: number;
+    baseUrl?: string;
+}
+interface GitHubCIConfigRedacted {
+    token: '<REDACTED>';
+    owner: string;
+    repo: string;
+    days?: number;
+    maxRuns?: number;
+    baseUrl?: string;
+}
+declare function redactGitHubCIConfig(config: GitHubCIConfig): GitHubCIConfigRedacted;
+declare function normalizeGitHubCIConfig(input: Record<string, unknown>): GitHubCIConfig;
+
+interface GitHubCIResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GitHubCIConfigRedacted;
+}
+declare class GitHubCIResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: GitHubCIConfig;
+    readonly accessor: GitHubCIAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: GitHubCIConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GitHubCIResourceState>;
+    loadState(_state: GitHubCIResourceState): Promise<void>;
+}
+
+interface GDocsConfig {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>;
+}
+interface GDocsConfigRedacted {
+    clientId: string;
+    clientSecret: '<REDACTED>';
+    refreshToken: '<REDACTED>';
+}
+declare function redactGDocsConfig(config: GDocsConfig): GDocsConfigRedacted;
+declare function normalizeGDocsConfig(input: Record<string, unknown>): GDocsConfig;
+
+interface GDocsResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GDocsConfigRedacted;
+}
+declare class GDocsResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: GDocsConfig;
+    readonly accessor: GDocsAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: GDocsConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GDocsResourceState>;
+    loadState(_state: GDocsResourceState): Promise<void>;
+}
+
+interface GSheetsConfig {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>;
+}
+interface GSheetsConfigRedacted {
+    clientId: string;
+    clientSecret: '<REDACTED>';
+    refreshToken: '<REDACTED>';
+}
+declare function redactGSheetsConfig(config: GSheetsConfig): GSheetsConfigRedacted;
+declare function normalizeGSheetsConfig(input: Record<string, unknown>): GSheetsConfig;
+
+interface GSheetsResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GSheetsConfigRedacted;
+}
+declare class GSheetsResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: GSheetsConfig;
+    readonly accessor: GSheetsAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: GSheetsConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GSheetsResourceState>;
+    loadState(_state: GSheetsResourceState): Promise<void>;
+}
+
+interface GSlidesConfig {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>;
+}
+interface GSlidesConfigRedacted {
+    clientId: string;
+    clientSecret: '<REDACTED>';
+    refreshToken: '<REDACTED>';
+}
+declare function redactGSlidesConfig(config: GSlidesConfig): GSlidesConfigRedacted;
+declare function normalizeGSlidesConfig(input: Record<string, unknown>): GSlidesConfig;
+
+interface GSlidesResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GSlidesConfigRedacted;
+}
+declare class GSlidesResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: GSlidesConfig;
+    readonly accessor: GSlidesAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: GSlidesConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GSlidesResourceState>;
+    loadState(_state: GSlidesResourceState): Promise<void>;
+}
+
+interface GDriveConfig {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>;
+}
+interface GDriveConfigRedacted {
+    clientId: string;
+    clientSecret: '<REDACTED>';
+    refreshToken: '<REDACTED>';
+}
+declare function redactGDriveConfig(config: GDriveConfig): GDriveConfigRedacted;
+declare function normalizeGDriveConfig(input: Record<string, unknown>): GDriveConfig;
+
+interface GDriveResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GDriveConfigRedacted;
+}
+declare class GDriveResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: GDriveConfig;
+    readonly accessor: GDriveAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: GDriveConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GDriveResourceState>;
+    loadState(_state: GDriveResourceState): Promise<void>;
+}
+
+interface DropboxConfig {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>;
+}
+interface DropboxConfigRedacted {
+    clientId: string;
+    clientSecret: '<REDACTED>';
+    refreshToken: '<REDACTED>';
+}
+declare function redactDropboxConfig(config: DropboxConfig): DropboxConfigRedacted;
+declare function normalizeDropboxConfig(input: Record<string, unknown>): DropboxConfig;
+
+interface DropboxResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: DropboxConfigRedacted;
+}
+declare class DropboxResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: DropboxConfig;
+    readonly accessor: DropboxAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: DropboxConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<DropboxResourceState>;
+    loadState(_state: DropboxResourceState): Promise<void>;
+}
+
+interface BoxConfig {
+    clientId?: string;
+    clientSecret?: string;
+    refreshToken?: string;
+    accessToken?: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        refreshToken: string;
+        expiresIn: number;
+    }>;
+    onRefreshTokenRotated?: (newRefreshToken: string) => void | Promise<void>;
+}
+interface BoxConfigRedacted {
+    clientId?: string;
+    clientSecret?: '<REDACTED>';
+    refreshToken?: '<REDACTED>';
+    accessToken?: '<REDACTED>';
+}
+declare function redactBoxConfig(config: BoxConfig): BoxConfigRedacted;
+declare function normalizeBoxConfig(input: Record<string, unknown>): BoxConfig;
+
+interface BoxResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: BoxConfigRedacted;
+}
+declare class BoxResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: BoxConfig;
+    readonly accessor: BoxAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: BoxConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<BoxResourceState>;
+    loadState(_state: BoxResourceState): Promise<void>;
+}
+
+interface GmailConfig {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    refreshFn?: (refreshToken: string) => Promise<{
+        accessToken: string;
+        expiresIn: number;
+    }>;
+}
+interface GmailConfigRedacted {
+    clientId: string;
+    clientSecret: '<REDACTED>';
+    refreshToken: '<REDACTED>';
+}
+declare function redactGmailConfig(config: GmailConfig): GmailConfigRedacted;
+declare function normalizeGmailConfig(input: Record<string, unknown>): GmailConfig;
+
+interface GmailResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: GmailConfigRedacted;
+}
+declare class GmailResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly writePrompt: string;
+    readonly config: GmailConfig;
+    readonly accessor: GmailAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: GmailConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<GmailResourceState>;
+    loadState(_state: GmailResourceState): Promise<void>;
+}
+
+interface EmailConfig {
+    imapHost: string;
+    imapPort: number;
+    smtpHost: string;
+    smtpPort: number;
+    username: string;
+    password: string;
+    useSsl: boolean;
+    maxMessages: number;
+}
+interface EmailConfigRedacted extends Omit<EmailConfig, 'password'> {
+    password: '<REDACTED>';
+}
+declare function redactEmailConfig(config: EmailConfig): EmailConfigRedacted;
+interface EmailConfigInput {
+    imapHost: string;
+    imapPort?: number;
+    smtpHost: string;
+    smtpPort?: number;
+    username: string;
+    password: string;
+    useSsl?: boolean;
+    maxMessages?: number;
+}
+declare function buildEmailConfig(input: EmailConfigInput): EmailConfig;
+declare function normalizeEmailConfig(input: Record<string, unknown>): EmailConfig;
+
+declare class EmailAccessor extends Accessor {
+    readonly config: EmailConfig;
+    private clientPromise;
+    constructor(config: EmailConfig);
+    getImap(): Promise<ImapFlow>;
+    close(): Promise<void>;
+}
+
+interface EmailResourceState {
+    type: string;
+    needsOverride: boolean;
+    redactedFields: readonly string[];
+    config: EmailConfigRedacted;
+}
+declare class EmailResource implements Resource {
+    readonly kind: string;
+    readonly isRemote: boolean;
+    readonly indexTtl: number;
+    readonly prompt: string;
+    readonly config: EmailConfig;
+    readonly accessor: EmailAccessor;
+    readonly index: IndexCacheStore;
+    constructor(config: EmailConfig);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    commands(): readonly RegisteredCommand[];
+    ops(): readonly RegisteredOp[];
+    readFile(p: PathSpec): Promise<Uint8Array>;
+    readdir(p: PathSpec): Promise<string[]>;
+    stat(p: PathSpec): Promise<FileStat>;
+    fingerprint(p: PathSpec): Promise<string | null>;
+    glob(paths: readonly PathSpec[], prefix?: string): Promise<PathSpec[]>;
+    getState(): Promise<EmailResourceState>;
+    loadState(_state: EmailResourceState): Promise<void>;
+}
+
+declare const EMAIL_PROMPT = "{prefix}\n  <folder>/\n    <yyyy-mm-dd>/\n      <subject>__<uid>.email.json\n      <subject>__<uid>/           # if attachments exist\n        <attachment-filename>\n  Folders include: INBOX, Sent, Drafts, etc. cat shows email as JSON.";
+declare const EMAIL_WRITE_PROMPT = "  Write commands:\n    email-send \"to@email.com\" \"subject\" \"body\"\n    email-reply <email-path> \"reply body\"\n    email-forward <email-path> \"to@email.com\"";
+
+declare const EMAIL_COMMANDS: readonly RegisteredCommand[];
+
+declare const EMAIL_OPS: readonly RegisteredOp[];
+
+/**
+ * Construct a resource by registry name. Mirrors Python's
+ * `mirage.resource.registry.build_resource`.
+ *
+ * Each entry is an async factory that lazy-imports its module so that
+ * importing this file doesn't pull in every backend's dependencies.
+ * Only the resource you actually request gets loaded — important for
+ * S3/Redis whose peer deps (`@aws-sdk/client-s3`, `redis`) are optional.
+ *
+ * Configs are normalized from Python-style snake_case (used in YAML and
+ * by the Python `mirage.config` loader) to TS-idiomatic camelCase. So
+ * the same YAML file works in both Python and TS.
+ */
+type ResourceFactory = (config: Record<string, unknown>) => Promise<Resource>;
+/**
+ * Look up the registered names. Lazily-mutated by `register()` so users
+ * can extend the registry with custom resources.
+ */
+declare function knownResources(): string[];
+/**
+ * Register a custom resource factory under `name`. Existing entries
+ * are overwritten, mirroring Python's mutable REGISTRY dict.
+ */
+declare function register(name: string, factory: ResourceFactory): void;
+/**
+ * Build a resource instance by registry name. Throws if the name is
+ * unknown.
+ */
+declare function buildResource(name: string, config?: Record<string, unknown>): Promise<Resource>;
+
+declare const DISK_COMMANDS: readonly RegisteredCommand[];
+
+declare const REDIS_COMMANDS: readonly RegisteredCommand[];
+
+interface LocalAudioMetadata {
+    duration: number | null;
+    sampleRate: number | null;
+    channels: number | null;
+    bitrate: number | null;
+}
+type LocalAudioTranscriber = (raw: Uint8Array, startSec?: number, endSec?: number) => AsyncIterable<Uint8Array | string>;
+interface LocalAudioConfig {
+    modelDir?: string;
+    recognizer?: LocalAudioTranscriber;
+}
+declare function configure(opts: LocalAudioConfig): void;
+declare function getConfig(): Readonly<LocalAudioConfig>;
+declare function transcribe(raw: Uint8Array, startSec?: number, endSec?: number): AsyncIterable<Uint8Array>;
+declare function metadata(raw: Uint8Array): Promise<LocalAudioMetadata>;
+declare function estimateByteRange(meta: LocalAudioMetadata, fileSize: number, startSec?: number, endSec?: number): [number, number];
+declare function formatDuration(duration: number): string;
+declare function formatMetadata(meta: LocalAudioMetadata, path: string, fileSize?: number | null): string;
+
+declare const DISK_LOCAL_AUDIO_COMMANDS: readonly RegisteredCommand[];
+
+declare const RAM_LOCAL_AUDIO_COMMANDS: readonly RegisteredCommand[];
+
+declare const LOCAL_AUDIO_COMMANDS: {
+    ram: readonly RegisteredCommand[];
+    disk: readonly RegisteredCommand[];
+};
+
+export { type BoxConfig, type BoxConfigRedacted, BoxResource, type BoxResourceState, DISK_COMMANDS, DISK_LOCAL_AUDIO_COMMANDS, DISK_OPS, DISK_PROMPT, type DiscordConfig, type DiscordConfigRedacted, DiscordResource, type DiscordResourceState, DiskResource, type DiskResourceOptions, type DiskResourceState, type DropboxConfig, type DropboxConfigRedacted, DropboxResource, type DropboxResourceState, EMAIL_COMMANDS, EMAIL_OPS, EMAIL_PROMPT, EMAIL_WRITE_PROMPT, EmailAccessor, type EmailConfig, type EmailConfigInput, type EmailConfigRedacted, EmailResource, type EmailResourceState, type FuseAttr, type FuseHandle, FuseManager, type MountOptions as FuseMountOptions, type GCSConfig, type GCSConfigRedacted, GCSResource, type GCSResourceState, GCS_ENDPOINT, GCS_PROMPT, type GDocsConfig, type GDocsConfigRedacted, GDocsResource, type GDocsResourceState, type GDriveConfig, type GDriveConfigRedacted, GDriveResource, type GDriveResourceState, type GSheetsConfig, type GSheetsConfigRedacted, GSheetsResource, type GSheetsResourceState, type GSlidesConfig, type GSlidesConfigRedacted, GSlidesResource, type GSlidesResourceState, type GitHubCIConfig, type GitHubCIConfigRedacted, GitHubCIResource, type GitHubCIResourceState, type GitHubConfig, type GitHubConfigRedacted, GitHubResource, type GitHubResourceState, type GmailConfig, type GmailConfigRedacted, GmailResource, type GmailResourceState, LOCAL_AUDIO_COMMANDS, type LangfuseConfig, type LangfuseConfigRedacted, LangfuseResource, type LangfuseResourceState, type LinearConfig, type LinearConfigRedacted, LinearResource, type LinearResourceState, type LocalAudioConfig, type LocalAudioMetadata, type LocalAudioTranscriber, MirageFS, type MirageFSOptions, MongoDBResource, type MongoDBResourceOptions, MongoDBStore, type NativeExecOptions, type NativeExecResult, type NativeProcess, type OCIConfig, type OCIConfigRedacted, OCIResource, type OCIResourceState, OCI_PROMPT, PostHogResource, type PostHogResourceOptions, PostgresResource, type PostgresResourceOptions, PostgresStore, type R2Config, type R2ConfigRedacted, R2Resource, type R2ResourceState, R2_PROMPT, RAM_LOCAL_AUDIO_COMMANDS, REDIS_COMMANDS, REDIS_OPS, REDIS_PROMPT, RedisAccessor, type RedisFileCacheOptions, RedisFileCacheStore, type RedisIndexCacheOptions, RedisIndexCacheStore, RedisResource, type RedisResourceLike, type RedisResourceOptions, type RedisResourceState, RedisStore, type RedisStoreOptions, type ResourceFactory, type S3Config, type S3ConfigRedacted, S3Resource, type S3ResourceState, SSCholarAuthorResource, type SSCholarAuthorResourceOptions, SSCholarPaperResource, type SSCholarPaperResourceOptions, SSHAccessor, type SSHConfig, type SSHConfigRedacted, SSHResource, type SSHResourceState, SSH_COMMANDS, SSH_OPS, SSH_PROMPT, SUPABASE_PROMPT, type SlackConfig, type SlackConfigRedacted, SlackResource, type SlackResourceState, type SupabaseConfig, type SupabaseConfigRedacted, SupabaseResource, type SupabaseResourceState, type TrelloConfig, type TrelloConfigRedacted, TrelloResource, type TrelloResourceState, VercelResource, type VercelResourceOptions, Workspace, buildEmailConfig, buildResource, configure as configureLocalAudio, fileReadProvision, mount as fuseMount, mountBackground as fuseMountBackground, getConfig as getLocalAudioConfig, headTailProvision, isMacosMetadata, knownResources, estimateByteRange as localAudioEstimateByteRange, formatDuration as localAudioFormatDuration, formatMetadata as localAudioFormatMetadata, metadata as localAudioMetadata, transcribe as localAudioTranscribe, metadataProvision, nativeExec, nativeExecStream, normalizeBoxConfig, normalizeDiscordConfig, normalizeDropboxConfig, normalizeEmailConfig, normalizeGDocsConfig, normalizeGDriveConfig, normalizeGSheetsConfig, normalizeGSlidesConfig, normalizeGitHubCIConfig, normalizeGitHubConfig, normalizeGmailConfig, normalizeLangfuseConfig, normalizeLinearConfig, normalizeSlackConfig, normalizeSshConfig, normalizeTrelloConfig, patchNodeFs, redactBoxConfig, redactDiscordConfig, redactDropboxConfig, redactEmailConfig, redactGDocsConfig, redactGDriveConfig, redactGSheetsConfig, redactGSlidesConfig, redactGcsConfig, redactGitHubCIConfig, redactGitHubConfig, redactGmailConfig, redactLangfuseConfig, redactLinearConfig, redactOciConfig, redactR2Config, redactConfig as redactS3Config, redactSlackConfig, redactSshConfig, redactSupabaseConfig, redactTrelloConfig, register as registerResourceFactory, resolvedSupabaseEndpoint };