@adhdev/daemon-core 0.9.82-rc.164 → 0.9.82-rc.166

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/providers/spec/cli-adapter.ts

@@ -30,6 +30,15 @@ export class SpecCliAdapter implements CliAdapter {
     readonly cliType: string;
     readonly cliName: string;
     readonly workingDir: string;
+    /**
+     * Marker the daemon's finalization gate checks: `getStatus()` returns
+     * `messages: []` by design here (chat history lives in the daemon's
+     * native-history pipeline, not the adapter). Without this flag,
+     * cli-provider-instance's `missing_final_assistant` gate would stall
+     * every turn until the 30s safety timeout because it expects the
+     * adapter to surface the final assistant message.
+     */
+    readonly chatMessagesOwnedExternally = true as const;
 
     private driver: SpecDriver;
     private spec: CliSpec;

package/src/providers/spec/native-history-executor.ts

@@ -256,9 +256,20 @@ function expandPath(template: string, input: NativeHistoryInput): string | null
     // Re-expand ~ in case the fallback used it.
     if (out.startsWith('~/')) out = path.join(os.homedir(), out.slice(2));
     const now = new Date();
+    // claude (and a couple of other Anthropic-CLI–style providers) writes
+    // its per-cwd transcript under the *resolved* path
+    // (/private/tmp/foo, not /tmp/foo on macOS where /tmp -> /private/tmp).
+    // Without realpath, the spec template `~/.claude/projects/{cwd_dashed}/…`
+    // builds `-tmp-foo` and never finds the actual `-private-tmp-foo` dir.
+    const workspaceRaw = input.workspace ?? '';
+    let workspaceResolved = workspaceRaw;
+    if (workspaceRaw) {
+        try { workspaceResolved = fs.realpathSync(workspaceRaw); }
+        catch { /* path may not exist yet — keep the raw value */ }
+    }
     const vars: Record<string, string> = {
-        cwd: input.workspace ?? '',
-        cwd_dashed: (input.workspace ?? '').replace(/\//g, '-'),
+        cwd: workspaceResolved,
+        cwd_dashed: workspaceResolved.replace(/\//g, '-'),
         session_id: input.providerSessionId || input.sessionId || input.historySessionId || '',
         yyyy: String(now.getUTCFullYear()),
         mm: String(now.getUTCMonth() + 1).padStart(2, '0'),

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 {