@adhdev/daemon-core 0.9.82-rc.165 → 0.9.82-rc.167

package/src/providers/sdk/v1/schemas/primitives/tui-modal-v1.json

@@ -36,6 +36,12 @@
       "type": "string",
       "description": "Regex source matching a single button line. Capture group 1 is the button label. Example: `^[\\s❯>]*\\d+\\.\\s+(.+)$`."
     },
+    "buttonLabelGroup": {
+      "type": "integer",
+      "minimum": 1,
+      "default": 1,
+      "description": "Capture group number to use as the button label when `buttonPattern` contains non-label groups such as selected-row markers."
+    },
     "buttonFlags": {
       "type": "string",
       "pattern": "^[gimsuy]*$",

package/src/providers/sdk/v1/validators/manifest.ts

@@ -9,7 +9,7 @@
  * offending field without guessing.
  *
  * Validation lives in the SDK layer (not in provider-loader) so dashboards,
- * registry workers, and the marketplace publish flow can all reuse the
+ * registry workers, and the provider publish flow can all reuse the
  * same code path and produce identical error messages.
  */
 

package/src/providers/sdk/v1/validators/taint.ts

@@ -2,7 +2,7 @@
  * Static taint analyzer for extended-tier override JS.
  *
  * Goal: classify the override JS shipped with an extended-tier provider into
- * one of three risk tiers, so the marketplace + daemon trust prompt can
+ * one of three risk tiers, so the dashboard + daemon trust prompt can
  * surface accurate language to the operator instead of a single generic
  * "this provider contains JS" warning.
  *

package/src/shared-types.ts

@@ -525,7 +525,39 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
-}
+    /**
+     * Provider trust classification — derived from the on-disk layer the
+     * manifest came from and the shape of the manifest. Dashboards use
+     * this to render a trust badge and gate activation of
+     * `external-untrusted` providers behind a confirm modal.
+     */
+    trust?: ProviderTrust;
+    /** Daemon-side human-readable description of the trust value. */
+    trustDescription?: string;
+    /** True when activation needs a user-side confirmation step. */
+    requiresConfirmation?: boolean;
+    /** Which on-disk layer the manifest lives in. */
+    sourceLayer?: 'user' | 'upstream' | 'external';
+    /** For external providers, the source-name namespace it came from. */
+    sourceName?: string | null;
+    /** Manifest-declared version, e.g. "1.2.1". */
+    providerVersion?: string;
+    /** Underlying executable name (CLI/binary providers). */
+    binary?: string;
+    /** Lifecycle label from the manifest: "Stable", "Beta", … */
+    status?: string;
+    /** One-line provider description from the manifest. */
+    details?: string;
+    /** Manifest-declared links: homepage, docs, repo, … */
+    links?: Record<string, string>;
+}
+
+export type ProviderTrust =
+    | 'user-custom'
+    | 'trusted'
+    | 'trusted-with-scripts'
+    | 'external-safe'
+    | 'external-untrusted';
 
 export interface MachineProviderCheckResult {
     ok: boolean;

package/src/status/snapshot.ts

@@ -145,21 +145,56 @@ function buildAvailableProviders(
         lastDetection?: AvailableProviderInfo['lastDetection'];
         lastVerification?: AvailableProviderInfo['lastVerification'];
         meshCoordinator?: AvailableProviderInfo['meshCoordinator'];
+        _sourceTrust?: AvailableProviderInfo['trust'];
+        _sourceLayer?: AvailableProviderInfo['sourceLayer'];
+        _sourceName?: string | null;
+        providerVersion?: string;
+        binary?: string;
+        status?: string;
+        details?: string;
+        links?: Record<string, string>;
     }> = providerLoader.getAvailableProviderInfos?.() || providerLoader.getAll();
-    return providers.map((provider) => ({
-        type: provider.type,
-        name: provider.displayName || provider.type,
-        displayName: provider.displayName || provider.type,
-        icon: provider.icon || '💻',
-        category: provider.category,
-        ...(provider.installed !== undefined ? { installed: provider.installed } : {}),
-        ...(provider.detectedPath !== undefined ? { detectedPath: provider.detectedPath } : {}),
-        ...(provider.enabled !== undefined ? { enabled: provider.enabled } : {}),
-        ...(provider.machineStatus !== undefined ? { machineStatus: provider.machineStatus } : {}),
-        ...(provider.lastDetection !== undefined ? { lastDetection: provider.lastDetection } : {}),
-        ...(provider.lastVerification !== undefined ? { lastVerification: provider.lastVerification } : {}),
-        ...(provider.meshCoordinator !== undefined ? { meshCoordinator: provider.meshCoordinator } : {}),
-    }));
+    // Trust helpers come from daemon-core; resolve them lazily so the
+    // status snapshot path stays loadable in older bundles that don't
+    // ship provider-trust yet.
+    let describeTrust: (trust: AvailableProviderInfo['trust']) => string = () => '';
+    let requiresConfirmation: (trust: AvailableProviderInfo['trust']) => boolean = () => false;
+    try {
+        const mod = require('../providers/provider-trust.js') as typeof import('../providers/provider-trust.js');
+        describeTrust = mod.describeTrust as typeof describeTrust;
+        requiresConfirmation = mod.requiresConfirmation as typeof requiresConfirmation;
+    } catch { /* enrichment only */ }
+    return providers.map((provider) => {
+        const trust = (provider as any)._sourceTrust as AvailableProviderInfo['trust'] | undefined;
+        const sourceLayer = (provider as any)._sourceLayer as AvailableProviderInfo['sourceLayer'] | undefined;
+        const sourceName = (provider as any)._sourceName as string | null | undefined;
+        return {
+            type: provider.type,
+            name: provider.displayName || provider.type,
+            displayName: provider.displayName || provider.type,
+            icon: provider.icon || '💻',
+            category: provider.category,
+            ...(provider.installed !== undefined ? { installed: provider.installed } : {}),
+            ...(provider.detectedPath !== undefined ? { detectedPath: provider.detectedPath } : {}),
+            ...(provider.enabled !== undefined ? { enabled: provider.enabled } : {}),
+            ...(provider.machineStatus !== undefined ? { machineStatus: provider.machineStatus } : {}),
+            ...(provider.lastDetection !== undefined ? { lastDetection: provider.lastDetection } : {}),
+            ...(provider.lastVerification !== undefined ? { lastVerification: provider.lastVerification } : {}),
+            ...(provider.meshCoordinator !== undefined ? { meshCoordinator: provider.meshCoordinator } : {}),
+            ...(trust ? {
+                trust,
+                trustDescription: describeTrust(trust),
+                requiresConfirmation: requiresConfirmation(trust),
+            } : {}),
+            ...(sourceLayer ? { sourceLayer } : {}),
+            ...(sourceName ? { sourceName } : {}),
+            ...(provider.providerVersion ? { providerVersion: provider.providerVersion } : {}),
+            ...(provider.binary ? { binary: provider.binary } : {}),
+            ...(provider.status ? { status: provider.status } : {}),
+            ...(provider.details ? { details: provider.details } : {}),
+            ...(provider.links ? { links: provider.links } : {}),
+        };
+    });
 }
 
 export function buildMachineInfo(profile: 'full' | 'live' | 'metadata' = 'full'): MachineInfo {