@dsh-workbench/core 0.1.18 → 0.2.1

package/dist/types/app/layouts/rightbar/panel-mock.d.ts

@@ -1,6 +1,6 @@
 import type { UnitManifest } from '@dsh-workbench/shared';
 import type { CapabilityMap } from '../../../shared/hooks/use-capabilities';
-import type { PanelUnit } from './use-panels';
+import type { PanelPluginUnit, PanelUnit } from './use-panels';
 export interface PanelMockExpect {
     readonly rows: number;
     readonly badge?: string | null;
@@ -10,12 +10,13 @@ export interface PanelMock {
     readonly id: string;
     readonly label: string;
     readonly units: readonly PanelUnit[];
+    readonly plugins?: readonly PanelPluginUnit[];
     readonly capabilities: CapabilityMap | null;
     readonly busy?: boolean;
     readonly failed?: boolean;
     readonly drag?: {
         readonly from: number;
-        readonly over: number;
+        readonly over: number | null;
         readonly at?: {
             readonly x: number;
             readonly y: number;

package/dist/types/app/layouts/rightbar/panel-write.d.ts

@@ -0,0 +1,15 @@
+export declare const PANEL_SETTLE_MS = 4000;
+export interface BoardSignRow {
+    readonly id: string;
+    readonly shown: boolean;
+    readonly source: string;
+}
+export declare function panelBoardSignature(units: readonly BoardSignRow[], plugins: readonly BoardSignRow[], own: boolean): string;
+export declare function machineBoardSignature(defaults: readonly string[], changed: Readonly<Record<string, number>>): string;
+export declare function nextPending(pending: string | null, signature: string): string | null;
+export interface BoardSettle {
+    readonly pending: boolean;
+    begin(): void;
+    clear(): void;
+}
+export declare function useBoardSettle(signature: string): BoardSettle;

package/dist/types/app/layouts/rightbar/use-drag-listeners.d.ts

@@ -0,0 +1,6 @@
+export interface DragPointerHandlers {
+    readonly move: (x: number, y: number) => void;
+    readonly drop: (y: number) => void;
+    readonly cancel: () => void;
+}
+export declare function useDragListeners(active: boolean, handlers: DragPointerHandlers): void;

package/dist/types/app/layouts/rightbar/use-panels.d.ts

@@ -6,8 +6,22 @@ export interface PanelUnit {
     readonly source: 'default' | 'user';
     readonly hasCard: boolean;
 }
+export interface PanelPluginUnit {
+    readonly id: string;
+    readonly pkg: string;
+    readonly title: string;
+    readonly shown: boolean;
+    readonly source: 'default' | 'user';
+}
+export interface PanelBoardView {
+    readonly units: readonly PanelUnit[];
+    readonly plugins: readonly PanelPluginUnit[];
+    readonly defaults: readonly string[];
+    readonly own: boolean;
+    readonly changed: Readonly<Record<string, number>>;
+}
 export declare function shouldDropPanels(workspace: string | null, previous: string | null): boolean;
-export declare function useEnabledUnits(refreshToken: number, workspace: string | null): PanelUnit[] | null;
+export declare function useEnabledUnits(refreshToken: number, workspace: string | null): PanelBoardView | null;
 export declare function useSelectedProjectId(): string | null;
 export declare function useBoardWorkspace(workspaces: WorkspaceSnapshot, sessions: SessionsSnapshot): {
     readonly workspace: WorkspaceView | null;

package/dist/types/app/layouts/sidebar/__tests__/session-row-ui.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/app/units/registry.d.ts

@@ -3,19 +3,22 @@ import type { BoardModule, UnitClientFace } from '@dsh-workbench/shared';
 import { type BoardRegistry } from '../layouts/rightbar/registry';
 export interface ClientUnitRefusal {
     readonly unit: string;
+    readonly kind: ClientRefusalKind;
     readonly reasons: readonly string[];
 }
+export type ClientRefusalKind = 'no-manifest' | 'withdrawn' | 'old-shape';
 export interface ClientUnitRegistry {
     register(face: UnitClientFace): () => void;
     all(): readonly UnitClientFace[];
     manifests(): readonly UnitManifest[];
+    installable(): ReadonlySet<string> | null;
     refusals(): readonly ClientUnitRefusal[];
-    setManifests(manifests: readonly UnitManifest[]): void;
+    setManifests(manifests: readonly UnitManifest[], installable?: readonly string[]): void;
     readonly board: BoardRegistry;
     subscribe(listener: () => void): () => void;
     version(): number;
 }
-export declare function toBoardModule(face: UnitClientFace, manifest: UnitManifest): BoardModule;
+export declare function toBoardModule(face: UnitClientFace, manifest: UnitManifest): BoardModule | undefined;
 export declare function createClientUnitRegistry(options?: {
     readonly onUnknownUnit?: (unit: string) => void;
 }): ClientUnitRegistry;

package/dist/types/modules/panels/__tests__/diy-harness.d.ts

@@ -1,4 +1,5 @@
 import type { UnitManifest } from '@dsh-workbench/shared';
+import { type PanelStateStore } from '@dsh-workbench/shared/host';
 import type { BundleInstallOutcome } from '../model/market';
 import { panelsUnit } from '../unit';
 export type Application = 'applied' | 'restart-required' | 'overridden' | 'cancelled' | 'failed';
@@ -38,6 +39,13 @@ export declare function createDiyRig(): {
         outcome?: BundleInstallOutcome;
         withTools?: boolean;
         probe?: readonly ProbeStep[];
+        mounted?: readonly string[];
+        refused?: readonly {
+            unit: string;
+            reasons: readonly string[];
+        }[];
+        failures?: Readonly<Record<string, string>>;
+        panelState?: PanelStateStore;
     }) => {
         specs: string[];
         registered: {
@@ -45,6 +53,17 @@ export declare function createDiyRig(): {
             execute: (args: unknown, exec?: unknown) => Promise<unknown>;
         }[];
         panels: import("../model/service").PanelsService;
+        panelState: PanelStateStore;
+        registry: {
+            all: () => {
+                unit: string;
+            }[];
+            refusals: () => readonly {
+                unit: string;
+                reasons: readonly string[];
+            }[];
+            failureOf: (unit: string) => string | undefined;
+        };
         disposers: (() => void)[];
         commands: string[];
     };

package/dist/types/modules/panels/__tests__/diy-report.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/diy-tools-health.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/diy-tools-panel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/plugin-panel-market-parity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/plugin-panel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/plugin-tool-units.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/scope-machine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/__tests__/scope-support.d.ts

@@ -0,0 +1,51 @@
+import type { UnitManifest, UnitTool } from '@dsh-workbench/shared';
+import { type WorkspaceStore } from '@dsh-workbench/shared/host';
+import type { PanelEntry } from '../model/config';
+import { type PanelsService } from '../model/service';
+export declare const A = "/w/a";
+export declare const B = "/w/b";
+export declare const MACHINE_BOARD: string[];
+export declare const WORKSPACE_BOARD: string[];
+export declare function tool(name: string): UnitTool;
+export declare function unit(id: string, order: number, tools?: readonly UnitTool[], card?: boolean): UnitManifest;
+export declare const MACHINE_UNIT: UnitManifest;
+export declare const BOARDED_UNIT: UnitManifest;
+export declare const PROJECT_UNIT: UnitManifest;
+export declare const MIXED_UNIT: UnitManifest;
+export declare const UNITS: UnitManifest[];
+export declare let root: string;
+export declare let store: WorkspaceStore;
+export declare function mount(manifests?: readonly UnitManifest[], owned?: readonly string[]): PanelsService;
+export declare function writeBoard(workspace: string | null, shown: readonly string[]): void;
+export declare function writeBoardWith(workspace: string | null, shown: readonly string[], hidden: readonly string[]): void;
+export declare function fakeCtx(): {
+    get: () => undefined;
+    provide: () => () => void;
+    logger: {
+        info: () => void;
+        warn: () => void;
+    };
+};
+export declare function gate(manifests?: readonly UnitManifest[], owned?: readonly string[], ctx?: unknown): import("@dsh-workbench/shared/host").UnitMountResult;
+export declare function denied(mounted: ReturnType<typeof gate>, workspace: string): string[];
+export declare const EXEC: {
+    agent: {
+        session: {
+            header: {
+                cwd: string;
+            };
+        };
+    };
+};
+interface RanTool {
+    readonly text: string;
+    readonly units: PanelEntry[];
+}
+export declare function toolHarness(manifests?: readonly UnitManifest[], owned?: readonly string[]): {
+    panels: PanelsService;
+    run: (args: Record<string, unknown>, exec?: unknown) => Promise<RanTool>;
+};
+export declare function machineConfig(): string;
+export declare function workspaceConfig(workspace: string): string;
+export declare function readJson(file: string): unknown;
+export {};

package/dist/types/modules/panels/model/config.d.ts

@@ -3,6 +3,7 @@ export type PanelList = readonly string[];
 export interface PanelBoard {
     readonly shown: PanelList;
     readonly hidden: PanelList;
+    readonly order?: PanelList | undefined;
 }
 export declare const EMPTY_BOARD: PanelBoard;
 export interface ScopeBoards {
@@ -16,6 +17,8 @@ export interface ScopeQuery {
     readonly id: string;
     readonly boards: ScopeBoards;
 }
+export declare function overrideOf(board: PanelBoard | null, id: string): boolean | undefined;
+export declare function defaultOf(board: PanelBoard | null, id: string): boolean;
 export declare function resolveScope(query: ScopeQuery): boolean;
 export interface PanelEntry {
     readonly id: string;
@@ -27,10 +30,27 @@ export interface PanelEntry {
 }
 export declare function parseBoard(raw: unknown): PanelBoard;
 export declare function parseReleased(raw: unknown): string[];
-export declare function resolvePanels(manifests: readonly UnitManifest[], boards: ScopeBoards): PanelEntry[];
+export declare function resolvePanels(manifests: readonly UnitManifest[], boards: ScopeBoards, owned?: ReadonlySet<string>): PanelEntry[];
+export interface PanelPluginRef {
+    readonly pkg: string;
+    readonly title: string;
+    readonly name?: string | undefined;
+}
+export interface PanelPluginEntry {
+    readonly id: string;
+    readonly pkg: string;
+    readonly title: string;
+    readonly name?: string | undefined;
+    readonly order: number;
+    readonly shown: boolean;
+    readonly source: 'default' | 'user';
+}
+export declare const PLUGIN_PANEL_PREFIX = "plugin:";
+export declare function pluginPanelId(pkg: string): string;
+export declare function resolvePluginPanels(plugins: readonly PanelPluginRef[], boards: ScopeBoards): PanelPluginEntry[];
 export declare function withoutReleased(released: PanelList, id: string): string[];
 export declare function withReleased(released: PanelList, id: string): string[];
-export declare function withShown(board: PanelBoard, id: string): PanelBoard;
+export declare function withShown(board: PanelBoard, id: string, visible?: PanelList): PanelBoard;
 export declare function withHidden(board: PanelBoard, id: string): PanelBoard;
 export declare function withoutPanel(board: PanelBoard, id: string): PanelBoard;
-export declare function withMoved(board: PanelBoard, id: string, index: number): PanelBoard;
+export declare function withMoved(board: PanelBoard, id: string, index: number, visible: PanelList): PanelBoard;

package/dist/types/modules/panels/model/diy-report.d.ts

@@ -0,0 +1,63 @@
+import type { PanelUnitReport } from '@dsh-workbench/shared';
+import type { WorkshopModule } from '../../../shared/api/host/diy-workshop';
+export interface SuiteHealth {
+    readonly state: 'ok' | 'failed' | 'absent';
+    readonly reason?: string;
+}
+export interface RegistryLike {
+    all(): readonly {
+        readonly unit: string;
+    }[];
+    refusals(): readonly {
+        readonly unit: string;
+        readonly reasons: readonly string[];
+    }[];
+    failureOf(unit: string): string | undefined;
+}
+export declare function healthOf(options: {
+    readonly registry: RegistryLike | undefined;
+    readonly unit: string;
+    readonly installed: boolean;
+}): SuiteHealth;
+export declare function ageText(at: number, now: number): string;
+export declare function stampOf(at: number): string;
+export declare function readText(read: PanelUnitReport['cards'][number], now: number): string;
+export declare function renderPanel(options: {
+    readonly packagesDir: string;
+    readonly workspace: string | null;
+    readonly rows: readonly {
+        readonly unit: string;
+        readonly name: string;
+        readonly health: SuiteHealth;
+        readonly report?: PanelUnitReport;
+    }[];
+    readonly board: readonly string[];
+    readonly at: number;
+    readonly now: number;
+}): string;
+export interface ModuleStatus {
+    readonly unit: string;
+    readonly name: string;
+    readonly dir: string;
+    readonly installed: boolean;
+    readonly known: boolean;
+    readonly open: boolean;
+    readonly artifacts: readonly {
+        readonly path: string;
+        readonly at: string | null;
+    }[];
+    readonly stale: boolean;
+    readonly health: SuiteHealth;
+    readonly next: string;
+}
+export declare function statusOf(options: {
+    readonly dir: string;
+    readonly unit: string;
+    readonly name: string;
+    readonly installed: boolean;
+    readonly known: boolean;
+    readonly open: boolean;
+    readonly health: SuiteHealth;
+}): ModuleStatus;
+export declare function renderStatus(packagesDir: string, lines: readonly ModuleStatus[]): string;
+export declare function renderList(packagesDir: string, modules: readonly WorkshopModule[]): string;

package/dist/types/modules/panels/model/market-dispatch.d.ts

@@ -32,6 +32,10 @@ export type ProvisionResult = {
 } | {
     readonly ok: true;
     readonly action: 'update-plugin';
+} | {
+    readonly ok: true;
+    readonly action: 'update-workbench';
+    readonly change: BundleChange;
 } | {
     readonly ok: true;
     readonly action: 'uninstall-plugin';

package/dist/types/modules/panels/model/market-registry.d.ts

@@ -0,0 +1,12 @@
+import type { BundleChange } from '../../../shared/api/bundle-install';
+import type { BundleManager } from '../../../shared/api/host/bundle-manager';
+import { type RegistryNotebook } from '../../../shared/api/host/profile-registries';
+export interface RegistryFixDeps {
+    readonly registries?: RegistryNotebook | undefined;
+    readonly logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+}
+export declare function rememberInstalledSource(deps: RegistryFixDeps, manager: BundleManager, pkg: string, registry: string | undefined): Promise<void>;
+export declare function retryAfterRegistryFix(deps: RegistryFixDeps, manager: BundleManager, pkg: string, change: BundleChange): Promise<BundleChange>;

package/dist/types/modules/panels/model/market-registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/model/market-types.d.ts

@@ -64,6 +64,7 @@ export interface MarketService {
     updateDependency(id: string): Promise<readonly SharedDependency[]>;
     installBundle(spec: string, options?: BundleInstallOptions): Promise<BundleInstallOutcome>;
     updateBundle(unit: string): Promise<BundleInstallOutcome | null>;
+    updateWorkbench(pkg: string): Promise<BundleInstallOutcome>;
     removeBundle(pkg: string): Promise<BundleRemoveOutcome>;
     cancelInstall(requestId: string): Promise<BundleCancellation | null>;
     updatePlugin(pkg: string): Promise<PluginUpdateOutcome>;

package/dist/types/modules/panels/model/market.d.ts

@@ -1,8 +1,8 @@
 import type { DshShell } from '@dsh-workbench/shared';
 import type { UnitManifest } from '@dsh-workbench/shared';
 import type { BundleManager } from '../../../shared/api/host/bundle-manager';
-import type { InstalledModule, ProfileModule } from '../../../shared/api/host/installed-module';
-import { type RegistryNotebook } from '../../../shared/api/host/profile-registries';
+import type { InstalledModule, ProfileModule, ProfilePackage } from '../../../shared/api/host/installed-module';
+import type { RegistryNotebook } from '../../../shared/api/host/profile-registries';
 import type { UnitMountDeps } from '@dsh-workbench/shared/host';
 import { type PluginReferences } from './plugin-actions';
 import type { PluginLedger } from './plugin-ledger';
@@ -21,6 +21,7 @@ export declare function createMarketService(options: {
     bundles?: BundleManager | undefined;
     installed?: ((pkg: string) => InstalledModule) | undefined;
     modules?: (() => readonly ProfileModule[]) | undefined;
+    workbench?: ((pkg: string) => ProfilePackage | undefined) | undefined;
     registries?: RegistryNotebook | undefined;
     ledger?: PluginLedger | undefined;
     references?: (() => PluginReferences) | undefined;

package/dist/types/modules/panels/model/plugin-panel.d.ts

@@ -0,0 +1,3 @@
+import type { PanelPluginRef } from './config';
+import type { PluginLedger } from './plugin-ledger';
+export declare function pluginPanelRefs(ledger: PluginLedger): PanelPluginRef[];

package/dist/types/modules/panels/model/prefs.d.ts

@@ -1,10 +1,12 @@
+import type { BoardTarget } from './config';
 import type { PanelsService } from './service';
 export declare const PANELS_PREF_RESOURCE = "panels";
 export interface PanelsPrefAction {
-    readonly action: 'show' | 'hide' | 'enable' | 'disable' | 'move' | 'reset';
+    readonly action: 'show' | 'hide' | 'move' | 'reset' | 'follow';
     readonly id?: string;
     readonly index?: number;
     readonly path?: string;
+    readonly scope?: BoardTarget;
 }
 export declare function parsePanelsPrefAction(payload: unknown): PanelsPrefAction;
 export declare function applyPanelsPref(panels: PanelsService, payload: unknown): {

package/dist/types/modules/panels/model/service.d.ts

@@ -1,11 +1,12 @@
 import type { WorkspaceStore } from '@dsh-workbench/shared/host';
 import type { UnitManifest } from '@dsh-workbench/shared';
-import { type BoardTarget, type PanelEntry, type ScopeBoards } from './config';
+import { type BoardTarget, type PanelEntry, type PanelPluginEntry, type PanelPluginRef, type ScopeBoards } from './config';
 export declare const PANELS_MODULE_ID = "panels";
 export declare const PANELS_FILE = "config.json";
 export declare const RELEASED_FILE = "released.json";
 export interface PanelsService {
     list(workspace: string | null, target?: BoardTarget): PanelEntry[];
+    listPlugins(workspace: string | null, target?: BoardTarget): PanelPluginEntry[];
     boards(workspace: string | null): ScopeBoards;
     isReleased(id: string): boolean;
     release(id: string): void;
@@ -16,11 +17,14 @@ export interface PanelsService {
     hide(id: string, workspace: string | null, target?: BoardTarget): PanelEntry[];
     move(id: string, index: number, workspace: string | null, target?: BoardTarget): PanelEntry[];
     reset(workspace: string | null, target?: BoardTarget): PanelEntry[];
+    follow(workspace: string | null, id?: string): PanelEntry[];
+    changedBy(): ReadonlyMap<string, number>;
 }
 export declare function createPanelsService(options: {
     manifests: () => readonly UnitManifest[];
     store: WorkspaceStore;
     owned?: (() => readonly string[]) | undefined;
+    plugins?: (() => readonly PanelPluginRef[]) | undefined;
     logger?: {
         warn?(message: string): void;
     } | undefined;

package/dist/types/shared/api/bundle-install.d.ts

@@ -26,7 +26,14 @@ export interface BundleInspectionRefused {
     readonly reason: string;
     readonly registries?: readonly BundleRegistry[];
 }
-export type BundleInspection = BundleInspectionAccepted | BundleInspectionRefused;
+export interface BundleInspectionPlugin {
+    readonly status: 'plugin';
+    readonly pkg: string;
+    readonly registry: BundleRegistry;
+    readonly pluginName?: string;
+    readonly version?: string;
+}
+export type BundleInspection = BundleInspectionAccepted | BundleInspectionRefused | BundleInspectionPlugin;
 export interface BundleRegistriesPayload {
     readonly available: boolean;
     readonly registries: BundleRegistries | null;
@@ -100,6 +107,13 @@ export interface ModuleVersion {
     readonly local?: boolean;
     readonly refused?: readonly string[];
 }
+export interface WorkbenchVersion {
+    readonly pkg: string;
+    readonly installed: string;
+    readonly latest?: string;
+    readonly local?: boolean;
+}
 export interface ModuleVersionsPayload {
     readonly modules: readonly ModuleVersion[];
+    readonly workbench?: WorkbenchVersion;
 }

package/dist/types/shared/api/host/__tests__/approval-note-injection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/__tests__/panel-state-route.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/__tests__/plugin-catalog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/__tests__/plugin-login-hint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/__tests__/plugin-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/bundle-inspect-kind.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/bundle-routes-self.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/api/host/installed-module.d.ts

@@ -1,4 +1,5 @@
 import type { DshHostContext } from '@dsh-workbench/shared';
+import type { UnitDeclarationSource } from './unit-registry';
 export type InstalledModule = {
     readonly kind: 'module';
     readonly pkg: string;
@@ -24,10 +25,21 @@ export interface ProfileModule {
 }
 export declare function profileManifestOf(profileDir: string | null): Readonly<Record<string, unknown>> | undefined;
 export declare function profileModules(profileDir: string | null): readonly ProfileModule[];
+export declare function createDeclarationLookup(profileDir: string | null): (unit: string) => UnitDeclarationSource | undefined;
 export declare function moduleDeclarationOf(profileDir: string | null, pkg: string): unknown;
 export interface DeclarationGap {
     readonly pkg: string;
     readonly problems: readonly string[];
 }
 export declare function declarationGaps(profileDir: string | null): readonly DeclarationGap[] | undefined;
+export declare function declaredPluginCommands(profileDir: string | null): ReadonlyMap<string, ReadonlySet<string>>;
 export declare function readInstalledModule(profileDir: string | null, pkg: string): InstalledModule;
+export declare function isLocalDependencySpec(spec: string): boolean;
+export interface ProfilePackage {
+    readonly pkg: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+}
+export declare function readProfilePackage(profileDir: string | null, pkg: string): ProfilePackage | undefined;
+export declare function packageVersionAt(packageRoot: string): string | undefined;

package/dist/types/shared/api/host/mount-units.d.ts

@@ -49,6 +49,7 @@ export declare function mountUnits(units: readonly HostUnit[], deps: {
     } | undefined;
     manifests: () => readonly UnitManifest[];
     ownedUnits?: () => readonly string[];
+    installable?: () => readonly string[];
     opencliCommand?: string;
     probe?: UnitMountDeps['probe'];
     store?: UnitMountDeps['store'];

package/dist/types/shared/api/host/plugin-catalog.d.ts

@@ -0,0 +1,60 @@
+import type { DshShell } from '@dsh-workbench/shared';
+export interface PluginCommandArg {
+    readonly name: string;
+    readonly type: string;
+    readonly required: boolean;
+    readonly positional: boolean;
+    readonly valueRequired: boolean;
+    readonly choices: readonly string[];
+    readonly defaultValue?: unknown;
+    readonly help: string;
+}
+export interface PluginCommand {
+    readonly plugin: string;
+    readonly name: string;
+    readonly description: string;
+    readonly access: string;
+    readonly domain?: string;
+    readonly args: readonly PluginCommandArg[];
+}
+export interface PluginCommandSet {
+    readonly plugin: string;
+    readonly version: string;
+    readonly commands: readonly PluginCommand[];
+}
+export interface PluginRow {
+    readonly name: string;
+    readonly version: string;
+    readonly commands: readonly string[];
+}
+export interface CommandRow {
+    readonly site: string;
+    readonly name: string;
+    readonly description: string;
+    readonly access: string;
+    readonly args: readonly PluginCommandArg[];
+}
+export interface PluginCatalogSnapshot {
+    readonly ok: boolean;
+    readonly at: number;
+    readonly sets: readonly PluginCommandSet[];
+    readonly problems: readonly string[];
+}
+export interface PluginCatalog {
+    refresh(options?: {
+        readonly force?: boolean;
+    }): Promise<PluginCatalogSnapshot>;
+    snapshot(): PluginCatalogSnapshot;
+}
+export interface PluginCatalogOptions {
+    readonly shell?: DshShell | undefined;
+    readonly command: string;
+    readonly timeoutMs?: number;
+}
+export declare function parsePluginRows(stdout: string): PluginRow[] | undefined;
+export declare function parseCommandRows(stdout: string): CommandRow[] | undefined;
+export declare function attributeCommands(plugins: readonly PluginRow[], rows: readonly CommandRow[]): {
+    readonly sets: PluginCommandSet[];
+    readonly problems: string[];
+};
+export declare function createPluginCatalog(options: PluginCatalogOptions): PluginCatalog;

package/dist/types/shared/api/host/plugin-login-hint.d.ts

@@ -0,0 +1,2 @@
+export declare function loginUrlOfDomain(domain: string | undefined): string | undefined;
+export declare function pluginLoginHint(error: unknown, domain: string | undefined): string;

package/dist/types/shared/api/host/plugin-tools.d.ts

@@ -0,0 +1,10 @@
+import type { ApprovalDetail, ApprovalPolicy } from '@dsh-workbench/shared/host';
+import type { PluginCommand } from './plugin-catalog';
+export declare function pluginToolName(plugin: string, command: string): string;
+export declare function pluginToolParameters(command: PluginCommand): Record<string, unknown>;
+export declare function pluginToolDescription(command: PluginCommand): string;
+export declare function pluginToolWrites(command: PluginCommand): boolean;
+export declare function pluginToolArgv(command: PluginCommand, raw: unknown): string[];
+export declare function pluginKeyArgs(command: PluginCommand, raw: unknown): string;
+export declare function pluginApprovalQuestion(command: PluginCommand, raw: unknown): ApprovalDetail;
+export declare function pluginApprovalFor(command: PluginCommand): ApprovalPolicy;

package/dist/types/shared/api/host/plugin-units.d.ts

@@ -0,0 +1,47 @@
+import type { Opencli } from '@dsh-workbench/shared/host';
+import type { PluginCatalog } from './plugin-catalog';
+import type { UnitRegistry } from './unit-registry';
+export interface PluginRowRef {
+    readonly id: string;
+    readonly pkg: string;
+    readonly name?: string | undefined;
+}
+export interface PluginRowsSource {
+    listPlugins(workspace: string | null): readonly PluginRowRef[];
+    subscribe?(listener: () => void): () => void;
+}
+export interface PluginUnitRow {
+    readonly plugin: string;
+    readonly pkg: string;
+    readonly version: string;
+    readonly commands: number;
+    readonly synthesized: number;
+    readonly tools: readonly string[];
+}
+export interface PluginUnitReport {
+    readonly ok: boolean;
+    readonly at: number;
+    readonly plugins: readonly PluginUnitRow[];
+    readonly problems: readonly string[];
+}
+export interface PluginUnits {
+    refresh(options?: {
+        readonly force?: boolean;
+    }): Promise<PluginUnitReport>;
+    touch(): void;
+    report(): PluginUnitReport;
+    dispose(): void;
+}
+export interface PluginUnitsOptions {
+    readonly registry: UnitRegistry;
+    readonly catalog: PluginCatalog;
+    readonly rows: () => readonly PluginRowRef[];
+    readonly declared: (plugin: string) => ReadonlySet<string>;
+    readonly opencliFor: (plugin: string) => Opencli;
+    readonly toolNames?: () => ReadonlySet<string>;
+    readonly logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+}
+export declare function createPluginUnits(options: PluginUnitsOptions): PluginUnits;