nomoreide 0.1.103 → 0.3.0

package/dist/core/process-manager.d.ts

@@ -1,99 +0,0 @@
-import type { ConfigStore } from "./config-store.js";
-import type { LogStore } from "./log-store.js";
-import { type PortHolder } from "./port-utils.js";
-import { type ServiceRegistry } from "./service-registry.js";
-import type { TimelineStore } from "./timeline-store.js";
-import type { ServiceStatus } from "./types.js";
-interface ProcessManagerOptions {
-    configStore: ConfigStore;
-    logStore: LogStore;
-    stopTimeoutMs?: number;
-    timelineStore?: TimelineStore;
-    /**
-     * Shared cross-session view of running services. When provided, the manager
-     * adopts services started by other sessions instead of spawning duplicates,
-     * and can stop services it did not spawn itself. Omit for an isolated manager
-     * (e.g. in tests) — behavior is then identical to a single-session manager.
-     */
-    registry?: ServiceRegistry;
-}
-export interface NoMoreIdeStatus {
-    services: Record<string, ServiceStatus>;
-}
-export interface StartServiceOptions {
-    killHolder?: boolean;
-}
-export declare class PortConflictError extends Error {
-    readonly code = "PORT_IN_USE";
-    readonly service: string;
-    readonly port: number;
-    readonly holder: PortHolder | null;
-    constructor(service: string, port: number, holder: PortHolder | null);
-}
-export declare class ProcessManager {
-    private readonly runtimes;
-    private readonly configStore;
-    private readonly logStore;
-    private readonly stopTimeoutMs;
-    private readonly timelineStore?;
-    private readonly registry?;
-    private readonly pendingWrites;
-    constructor(options: ProcessManagerOptions);
-    startService(name: string, options?: StartServiceOptions): Promise<ServiceStatus>;
-    stopService(name: string): Promise<ServiceStatus>;
-    restartService(name: string, options?: StartServiceOptions): Promise<ServiceStatus>;
-    setInspectorEnabled(name: string, enabled: boolean): Promise<ServiceStatus>;
-    private maybeStartInspector;
-    private stopInspector;
-    private inspectorStatus;
-    private recordInspectorEvent;
-    startBundle(name: string): Promise<ServiceStatus[]>;
-    stopBundle(name: string): Promise<ServiceStatus[]>;
-    /**
-     * Stop order scoped to the bundle's own members, in dependency order so we
-     * can reverse it. Falls back to declaration order if a cycle makes a topo
-     * sort impossible — stopping must never throw the way a start can.
-     */
-    private safeStopOrder;
-    /**
-     * Wait until a dependency looks ready before starting services that depend on
-     * it. A service with a port is "ready" once that port is bound; portless
-     * services have no probe, so we return immediately. Times out (warning, not
-     * error) so a slow/never-binding dependency can't wedge a bundle start.
-     */
-    private waitForServiceReady;
-    restartBundle(name: string): Promise<ServiceStatus[]>;
-    stopAll(): Promise<void>;
-    /**
-     * Resolves once every log/timeline write started so far has settled. Exit
-     * handlers append after the child is gone, so without this a caller that
-     * tears down the log directory right after `stopAll()` races those writes.
-     */
-    flushWrites(): Promise<void>;
-    killAllSync(signal?: NodeJS.Signals): void;
-    installShutdownHandlers(): () => void;
-    status(): NoMoreIdeStatus;
-    statusWithResources(): Promise<NoMoreIdeStatus>;
-    /**
-     * Fold in services started by sibling sessions. A registry entry wins only
-     * when this session has no running view of that service, so a locally-owned
-     * "running" status is never overwritten by the shared snapshot.
-     */
-    private mergeRegistry;
-    private startDockerComposeService;
-    private stopDockerComposeService;
-    readDockerServiceLogs(name: string, tail?: number): Promise<string>;
-    readDockerServiceStatus(name: string): Promise<import("./docker-service-runner.js").DockerContainerInfo>;
-    private getService;
-    private getBundle;
-    private captureStream;
-    private appendTimeline;
-    /**
-     * Register a fire-and-forget log/timeline write so `flushWrites()` can wait
-     * for it. These are telemetry about an operation, not the operation itself,
-     * so a failed write is dropped rather than escalated into an unhandled
-     * rejection that would take down the daemon (or fail an unrelated test).
-     */
-    private trackWrite;
-}
-export {};