import { type ConnectorStatusRow, type ExtensionRef, type SignedInSpace } from "@cotal-ai/core";
import { type LocalProcessContext } from "@cotal-ai/workspace";
export { resolveRuntimeSpace, resolveSpace } from "@cotal-ai/workspace";
/** Where the dashboard that holds the live `pid` in `web.pid` recorded its session. A dashboard started
 * as an owned service writes its own record beside its startup receipt and never writes `web.session`,
 * so the web service instance whose recorded process is that live pid names the file. Any other holder
 * is a dashboard that wrote `web.session`. The holder picks the record, and neither is read in place of
 * the other. Instance records that cannot be read throw. */
export declare function webSessionSource(context: LocalProcessContext, pid: number): {
    path: string;
    label: string;
    instance?: string;
};
/** The address the dashboard recorded in its session record once `listen()` succeeded, with the
 * readiness nonce recorded beside it, or `undefined` while there is no whole record. A record that
 * exists and cannot be read throws. */
export declare function webBoundAddress(path: string): {
    host: string;
    port: number;
    url: string;
    readiness: string;
} | undefined;
/** The address a mesh's dashboard recorded once it was listening, while the pid it recorded is alive.
 * Only its own records place it: `--port` moves it off its default port, and any other program can
 * own that port. {@link webSessionSource} picks the record. A record that exists and cannot be read
 * throws an error that names it, because a read error such as EISDIR carries no path. */
export declare function recordedWebUrl(context: LocalProcessContext): string | undefined;
/** True when an installed extension contributes the `web` service preset and its package is on disk,
 * so `cotal service add --preset web` can configure the dashboard. A manifest or package record that
 * cannot be read throws, like every other reader. */
export declare function webInstalled(): boolean;
export interface MachineStatus {
    nats: "path" | "bundled" | "missing";
}
/** One installed connector's harness readiness: the executables it declares (`requires`), the ones
 *  of those not on PATH, and its declared setup provider (`undefined` when a manifest cached before
 *  setup refs were cannot say). */
export interface HarnessStatus {
    name: string;
    requires: readonly string[];
    missing: string[];
    setup: ExtensionRef | null | undefined;
}
/** Machine-level readiness: the once-per-machine setup pieces. */
export declare function machineStatus(): Promise<MachineStatus>;
/** Every connector this machine can launch, read off each connector's own `requires` rather than a list
 *  of harness names: the live registry plus the installed extension manifest's cached requirements, so
 *  status never imports connector code. A manifest that cannot answer throws, like every other reader. */
export declare function connectorHarnesses(): HarnessStatus[];
/** The rows each connector's setup provider reports about what it installed, for the selected space
 *  when `signedIn` names it. Only a connector that declares a provider is imported; one whose cached
 *  metadata predates the setup ref is read from the connector itself. A declared provider that cannot
 *  be resolved renders as one red row naming the error, so the rest of status still prints. */
export declare function connectorStatusRows(harnesses: readonly HarnessStatus[], signedIn?: SignedInSpace): Promise<ConnectorStatusRow[]>;
//# sourceMappingURL=status.d.ts.map