@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/hostSettingsSource.d.ts

@@ -0,0 +1,172 @@
+import { SETTINGS_WORKSPACE_TRUST_STATES } from './generated/settingsSchemaTables.js';
+import type { ManagedPolicyState, PluginHooksReading, SessionHooksReading, SettingsDocument } from './host.js';
+import type { PluginHookReaderState } from './pluginHooksWire.js';
+export type WorkspaceTrustState = (typeof SETTINGS_WORKSPACE_TRUST_STATES)[number];
+export declare const HOST_SETTINGS_LAYERS: readonly ["policySettings", "userSettings", "projectSettings", "localSettings", "flagSettings"];
+export type HostSettingsLayer = (typeof HOST_SETTINGS_LAYERS)[number];
+export declare const MANAGED_POLICY_STATES: readonly ["absent", "in-effect", "in-effect-pieces", "unreadable-covered", "unreadable-uncovered", "remote-unknown"];
+export declare const HOST_STARTUP_MODES: readonly ["safe", "bare", "none"];
+export type HostStartupMode = (typeof HOST_STARTUP_MODES)[number];
+export declare const HOST_SETTINGS_CARRIER_STATUSES: readonly ["loaded", "loaded-partial", "empty", "absent", "unreadable", "not-loaded"];
+export type HostSettingsCarrierStatus = (typeof HOST_SETTINGS_CARRIER_STATUSES)[number];
+export declare const HOST_SETTINGS_EMPTY_KINDS: readonly ["zero-byte", "whitespace", "empty-object"];
+export type HostSettingsEmptyKind = (typeof HOST_SETTINGS_EMPTY_KINDS)[number];
+export interface HostSettingsCarrierRead {
+    readonly id: string;
+    readonly status: HostSettingsCarrierStatus;
+    readonly emptyKind?: HostSettingsEmptyKind;
+    readonly issues?: readonly string[];
+}
+export interface HostSettingsLayerRead {
+    readonly enabled: boolean;
+    readonly doc: SettingsDocument | null;
+    readonly carriers: readonly HostSettingsCarrierRead[];
+}
+export interface HostManagedPolicyReading {
+    readonly state: ManagedPolicyState;
+}
+export interface HostSettingsSource {
+    readLayer(layer: HostSettingsLayer): HostSettingsLayerRead;
+    workspaceTrust(): WorkspaceTrustState;
+    managedPolicyReading(): HostManagedPolicyReading;
+    startupMode(): HostStartupMode;
+    enabledPluginHooks(): PluginHooksReading | 'none';
+    sessionHooks(): SessionHooksReading | 'none';
+}
+export interface HostSettingsLayerSnapshot {
+    readonly layer: HostSettingsLayer;
+    readonly enabled: boolean;
+    readonly outcome: HostSettingsCarrierStatus;
+    readonly doc: SettingsDocument | null;
+    readonly carriers: readonly HostSettingsCarrierRead[];
+    readonly issues: readonly string[];
+    readonly malformed: boolean;
+}
+export interface HostSettingsRead {
+    readonly layers: Readonly<Record<HostSettingsLayer, HostSettingsLayerSnapshot>>;
+    readonly trust: WorkspaceTrustState | 'unreadable';
+    readonly managed: ManagedPolicyState;
+    readonly startup: HostStartupMode;
+    readonly plugins: {
+        readonly state: PluginHookReaderState;
+        readonly reading?: PluginHooksReading;
+    };
+    readonly sessionHooks: {
+        readonly state: PluginHookReaderState;
+        readonly sources?: SessionHooksReading['sources'];
+    };
+    readonly debug: readonly string[];
+    readonly current?: HostSettingsRead;
+}
+export declare class HostSettingsSourceShapeError extends TypeError {
+    readonly code: "host_settings_source_shape";
+}
+export declare const SETTINGS_READ_BUDGET = 250000;
+export declare const HOST_SETTINGS_STATE_BUDGET: number;
+export declare const SETTINGS_MAX_CARRIERS_PER_LAYER = 1024;
+export declare const SETTINGS_MAX_ISSUES_PER_CARRIER = 4096;
+export declare function combineCarrierStatuses(carriers: readonly HostSettingsCarrierRead[]): HostSettingsCarrierStatus;
+export declare function readHostSettingsOnce(source: {} | null | undefined, who: string): HostSettingsRead;
+export declare function sourceOfRead(read: HostSettingsRead): HostSettingsSource;
+export declare function settingsValueOf(read: HostSettingsRead, key: string): {} | null | undefined;
+export declare function mergedBooleanOf(read: HostSettingsRead, key: string): boolean | undefined;
+export declare const CC_MERGE_ORDER: readonly ["userSettings", "projectSettings", "localSettings", "flagSettings", "policySettings"];
+export declare function nonManagedLayerDown(read: HostSettingsRead): boolean;
+export declare const ADOPTED_LAYERS: readonly ["userSettings", "projectSettings", "localSettings", "flagSettings"];
+export type AdoptedLayer = (typeof ADOPTED_LAYERS)[number];
+export interface HostLayerRule {
+    readonly layer: AdoptedLayer;
+    readonly rule: string;
+}
+export interface HostSettingsBaseline {
+    readonly docs: Readonly<Record<AdoptedLayer, SettingsDocument | null>>;
+    readonly loaded: readonly string[];
+    readonly issues: readonly string[];
+    readonly cleanAllow: Readonly<Record<AdoptedLayer, readonly string[]>>;
+    readonly cleanCarriers: Readonly<Record<AdoptedLayer, readonly string[]>>;
+    readonly protecting: {
+        readonly deny: readonly HostLayerRule[];
+        readonly ask: readonly HostLayerRule[];
+    };
+}
+export interface HostSettingsSession {
+    readonly version: string;
+    readonly parent: string | null;
+    readonly consented: readonly string[];
+    readonly baseline: HostSettingsBaseline | null;
+}
+export declare const parentVersionOf: (session: HostSettingsSession) => string | null;
+export declare function mintHostSettingsSession(parent: string | null, consented: readonly string[], baseline: HostSettingsBaseline | null): HostSettingsSession | undefined;
+export declare function remintSameContent(session: HostSettingsSession): HostSettingsSession;
+export declare function hostSettingsSessionFollows(stored: HostSettingsSession | undefined, next: HostSettingsSession): boolean;
+export declare const FIRST_SESSION: HostSettingsSession;
+export declare function sessionSnapshotOf(previous: {} | null | undefined): HostSettingsSession | undefined;
+export declare function permissionRulesOf(doc: SettingsDocument | null, bucket: 'allow' | 'deny' | 'ask'): readonly string[];
+export interface HostSettingsAdoption {
+    readonly read: HostSettingsRead;
+    readonly session: HostSettingsSession;
+    readonly trusted: boolean;
+    readonly clean: boolean;
+    readonly extraTighten: {
+        readonly deny: readonly HostLayerRule[];
+        readonly ask: readonly HostLayerRule[];
+    };
+    readonly allowByLayer: Readonly<Record<AdoptedLayer, readonly string[]>>;
+    readonly held?: {
+        readonly wouldDrop: {
+            readonly deny: readonly string[];
+            readonly ask: readonly string[];
+        };
+        readonly candidate?: HostSettingsSession;
+    };
+    readonly overflow?: true;
+}
+export declare function adoptHostSettingsRead(read: HostSettingsRead, session: HostSettingsSession, allowAdmitted?: (layer: AdoptedLayer) => boolean): HostSettingsAdoption;
+export type ManagedCommitVerdict = 'proceed' | 'refuse';
+export type ManagedRuleScopeVerdict = 'all-sources' | 'by-switch' | 'degrade';
+export type ManagedHooksRestrictionVerdict = 'use-read' | 'held-restrictions' | 'withhold';
+export type ManagedHttpListVerdict = 'use-read' | 'withhold';
+export interface ManagedReadingDisposition {
+    readonly commit: ManagedCommitVerdict;
+    readonly ruleScope: ManagedRuleScopeVerdict;
+    readonly hooksRestriction: ManagedHooksRestrictionVerdict;
+    readonly httpList: ManagedHttpListVerdict;
+}
+export declare const MANAGED_READING_DISPOSITIONS: Readonly<{
+    readonly absent: Readonly<{
+        commit: "proceed";
+        ruleScope: "all-sources";
+        hooksRestriction: "use-read";
+        httpList: "use-read";
+    }>;
+    readonly 'in-effect': Readonly<{
+        commit: "proceed";
+        ruleScope: "by-switch";
+        hooksRestriction: "use-read";
+        httpList: "use-read";
+    }>;
+    readonly 'in-effect-pieces': Readonly<{
+        commit: "proceed";
+        ruleScope: "degrade";
+        hooksRestriction: "use-read";
+        httpList: "use-read";
+    }>;
+    readonly 'unreadable-covered': Readonly<{
+        commit: "refuse";
+        ruleScope: "degrade";
+        hooksRestriction: "held-restrictions";
+        httpList: "use-read";
+    }>;
+    readonly 'unreadable-uncovered': Readonly<{
+        commit: "refuse";
+        ruleScope: "degrade";
+        hooksRestriction: "withhold";
+        httpList: "withhold";
+    }>;
+    readonly 'remote-unknown': Readonly<{
+        commit: "proceed";
+        ruleScope: "degrade";
+        hooksRestriction: "withhold";
+        httpList: "withhold";
+    }>;
+}>;