import os from "node:os";

import path from "node:path";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import {

clearCurrentPluginMetadataSnapshot,

resolvePluginMetadataControlPlaneFingerprint,

import type { InstalledPluginIndex } from "./installed-plugin-index.js";

import { listOpenClawPluginManifestMetadata } from "./manifest-metadata-scan.js";

import { normalizeProviderModelIdWithManifest } from "./manifest-model-id-normalization.js";

import { clearPluginMetadataLifecycleCaches } from "./plugin-metadata-lifecycle.js";

import type { PluginMetadataSnapshot } from "./plugin-metadata-snapshot.js";

import { createEmptyPluginRegistry } from "./registry-empty.js";

import { resetPluginRuntimeStateForTest, setActivePluginRegistry } from "./runtime.js";

manifestHash: string;

prefix: string;

workspaceDir?: string;

config?: OpenClawConfig;

}): PluginMetadataSnapshot {

const policyHash = resolveInstalledPluginIndexPolicyHash({});

const config = params.config ?? {};

const policyHash = resolveInstalledPluginIndexPolicyHash(config);

const index: InstalledPluginIndex = {

version: 1,

hostContractVersion: "test-host",

};

return {

policyHash,

configFingerprint: resolvePluginMetadataControlPlaneFingerprint(

{},

{

env: process.env,

index,

policyHash,

workspaceDir: params.workspaceDir,

},

),

configFingerprint: resolvePluginMetadataControlPlaneFingerprint(config, {

env: process.env,

index,

policyHash,

workspaceDir: params.workspaceDir,

}),

workspaceDir: params.workspaceDir,

index,

registryDiagnostics: [],

});

}

function normalizeDemoModelWithEnv(

env: NodeJS.ProcessEnv,

modelId = "demo-model",

): string | undefined {

return normalizeProviderModelIdWithManifest({

provider: "demo",

env,

context: { provider: "demo", modelId },

});

}

describe("manifest model id normalization", () => {

beforeEach(() => {

resetPluginRuntimeStateForTest();

expect(normalizeDemoModel()).toBe("alpha/demo-model");

});

it("reuses current metadata when callers omit config", () => {

const config: OpenClawConfig = { plugins: { allow: ["normalizer"] } };

setCurrentPluginMetadataSnapshot(

createCurrentSnapshot({

manifestHash: "alpha",

prefix: "alpha",

config,

}),

{ config, env: process.env },

);

expect(normalizeDemoModel()).toBe("alpha/demo-model");

});

it("validates explicit env before reusing current metadata", () => {

setCurrentPluginMetadataSnapshot(

createCurrentSnapshot({

manifestHash: "alpha",

prefix: "alpha",

}),

{ config: {}, env: process.env },

);

const stateDir = makeTempDir();

const pluginDir = path.join(stateDir, "extensions", "normalizer");

writeInstallIndex({ stateDir, pluginDir });

writeNormalizerManifest({ pluginDir, prefix: "bravo" });

const env = {

...process.env,

OPENCLAW_STATE_DIR: stateDir,

OPENCLAW_HOME: undefined,

OPENCLAW_DISABLE_BUNDLED_PLUGINS: "1",

OPENCLAW_BUNDLED_PLUGINS_DIR: undefined,

};

expect(normalizeDemoModelWithEnv(env)).toBe("bravo/demo-model");

});

it("reflects manifest edits and state-dir changes on the next lookup", () => {

const stateDirA = makeTempDir();

const pluginDirA = path.join(stateDirA, "extensions", "normalizer");

expect(normalizeDemoModel()).toBe("alpha/demo-model");

writeNormalizerManifest({ pluginDir: pluginDirA, prefix: "bravo-local" });

clearPluginMetadataLifecycleCaches();

expect(normalizeDemoModel()).toBe("bravo-local/demo-model");

const stateDirB = makeTempDir();

writeNormalizerManifest({ pluginDir: pluginDirB, prefix: "charlie" });

process.env.OPENCLAW_STATE_DIR = stateDirB;

clearPluginMetadataLifecycleCaches();

expect(normalizeDemoModel()).toBe("charlie/demo-model");

});