import type { Logger } from "pino";
import type { SandboxPackageManager, SessionPermissions } from "@/types";
import type { ProcessesRepository } from "../../storage/processesRepository.js";
declare const SIGNALS: readonly ["SIGTERM", "SIGINT", "SIGHUP", "SIGKILL"];
export type ProcessSignal = (typeof SIGNALS)[number];
export type ProcessOwner = {
    type: "plugin";
    id: string;
};
export type ProcessCreateInput = {
    command: string;
    name?: string;
    cwd?: string;
    env?: Record<string, string | number | boolean>;
    home?: string;
    packageManagers?: SandboxPackageManager[];
    allowedDomains?: string[];
    keepAlive?: boolean;
    allowLocalBinding?: boolean;
    owner?: ProcessOwner;
    userId: string;
};
export type ProcessInfo = {
    id: string;
    name: string;
    command: string;
    cwd: string;
    home: string | null;
    pid: number | null;
    keepAlive: boolean;
    desiredState: "running" | "stopped";
    status: "running" | "stopped" | "exited";
    restartCount: number;
    createdAt: number;
    updatedAt: number;
    lastStartedAt: number | null;
    lastExitedAt: number | null;
    logPath: string;
};
/**
 * Manages durable sandboxed background processes persisted in SQLite.
 * Expects: all state writes happen through this facade to keep pid/status in sync.
 */
export declare class Processes {
    private readonly baseDir;
    private readonly recordsDir;
    private readonly lock;
    private readonly logger;
    private readonly bootTimeProvider;
    private readonly repository;
    private readonly fallbackUserIdResolve;
    private readonly ownedStorage;
    private ownedStorageClosed;
    private readonly records;
    private readonly children;
    private currentBootTimeMs;
    private currentBootTimeKnown;
    private monitorHandle;
    constructor(baseDir: string, logger: Logger, options?: {
        bootTimeProvider?: () => Promise<number | null>;
        repository?: Pick<ProcessesRepository, "create" | "findAll" | "findById" | "update" | "delete" | "deleteByOwner">;
    });
    load(): Promise<void>;
    unload(): void;
    defaultUserId(): Promise<string>;
    create(input: ProcessCreateInput, permissions: SessionPermissions): Promise<ProcessInfo>;
    listByOwner(owner: ProcessOwner): Promise<ProcessInfo[]>;
    list(): Promise<ProcessInfo[]>;
    get(processId: string): Promise<ProcessInfo>;
    stop(processId: string, signal?: ProcessSignal): Promise<ProcessInfo>;
    remove(processId: string, signal?: ProcessSignal): Promise<void>;
    removeByOwner(owner: ProcessOwner, signal?: ProcessSignal): Promise<number>;
    stopAll(signal?: ProcessSignal): Promise<ProcessInfo[]>;
    private startMonitor;
    private refreshRecordStatusLocked;
    private restartRecordWithBackoffLocked;
    private removeRecordLocked;
    private startRecordLocked;
    private attachChildListeners;
    private stopRecordLocked;
    private writeRecordLocked;
    private processDir;
    private resolveCurrentBootTimeMsLocked;
    private clearStalePidForBootMismatch;
}
export {};
//# sourceMappingURL=processes.d.ts.map