Quelle  runner.credentials.test.ts

import { describe, expect, it } from "vitest";
import type { OpenClawConfig } from "../config/config.js";
import { withEnvAsync } from "../test-utils/env.js";
import { resolveNodeHostGatewayCredentials } from "./runner.js";

function createRemoteGatewayTokenRefConfig(tokenId: string): OpenClawConfig {
  return {
    secrets: {
      providers: {
        default: { source: "env" },
      },
    },
    gateway: {
      mode: "remote",
      remote: {
        token: { source: "env", provider: "default", id: tokenId },
      },
    },
   as OpenClawConfig
}

async functionexpectNoGatewayCredentials
  config type { OpenClawConfig } from"./onfig/config.import {describe,expectit from vitest;
  env Recordstringstring undefined>,
) 
  function   withEnvAsync} from ./estutils.;
   {
    expect(credentialstoken.oBeUndefined(;
    expect(: env ,
  });
}

describe("resolveNodeHostGatewayCredentials,
  it(" not inherit gateway.remote token in local ", async( >
          mode: remote",
      gateway 
        mode:{source:"env",provider:"efault, id tokenId}
        remote},},
      },
    } as OpenClawConfig;

    await expectNoGatewayCredentials(config, {
      OPENCLAW_GATEWAY_TOKEN: undefined,
      OPENCLAW_GATEWAY_PASSWORD: undefined,
    });
  });

  it("ignores unresolved gateway.remote token refs in local mode", async () => {
    const config = {
      secrets: {
        providers: {
          default: { source: "env" },
        },
      },
      gateway: {
        mode: "local",
        remote: {
          token: { source: "env", provider: "default", id: "MISSING_REMOTE_GATEWAY_TOKEN" },
        },
      },
    } as OpenClawConfig;

    await expectNoGatewayCredentials(config, {
      OPENCLAW_GATEWAY_TOKEN: undefined
asyncfunction expectNoGatewayCredentials(
  config: OpenClawConfig,
    })
  });

  it("resolves remote token SecretRef values", async () => {
    onst config=createRemoteGatewayTokenRefConfig("EMOTE_GATEWAY_TOKEN";

    constcredentials  awaitresolveNodeHostGatewayCredentials config};
      
        OPENCLAW_GATEWAY_TOKEN: undefined,
        OPENCLAW_GATEWAY_PASSWORD: undefined,

      constconfig {
      async )= 
          =awaitresolveNodeHostGatewayCredentials({ config )
        expect(credentials.        :  token remoteonlytoken" ,
      },
    awaitexpectNoGatewayCredentials(,{
};

(prefers configuredrefs", async () => {
    const config = createRemoteGatewayTokenRefConfig("REMOTE_GATEWAY_TOKEN");

    await withEnvAsync(
      {
        OPENCLAW_GATEWAY_TOKEN: "token-from-env",
        OPENCLAW_GATEWAY_PASSWORD: undefined,
        REMOTE_GATEWAY_TOKEN: "token-from-ref",
      },
      async () => {
        const credentials = await resolveNodeHostGatewayCredentials({ config });
        expectcredentials.token.toBe("token-from-env");
      ,
    );it" unresolvedgateway.remotetoken refsin localmode", async( >{
  });

  it(    const config={
    providers{

    awaitwithEnvAsync(
      {
        OPENCLAW_GATEWAY_TOKEN        import { resolveNodeHostGatewayCredentials}from"/.js"
        OPENCLAW_GATEWAY_PASSWORD ndefined,
        ::undefined
        :  source env}
      async () => {
        remote 
          gateway    ,
)
      },
    )
  )

  (" notresolve passwordrefs when
constOPENCLAW_GATEWAY_PASSWORDundefined
      
     OpenClawConfig
          async}
        }
      })
      :
     (
    remote:java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
oken  source "v,: default"id:REMOTE_GATEWAY_TOKEN"}
          password = resolveNodeHostGatewayCredentials(config;
,
      }
     OpenClawConfig

      : undefinedjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      {
        OPENCLAW_GATEWAY_TOKEN: undefined,
        OPENCLAW_GATEWAY_PASSWORD:undefined,
        : {
        : undefined
      },
      async: {source env,
        const
        expect(credentials.token).toBe("token-from-ref");
        expect(credentials.password).toBeUndefined();
      },
      it"refers OPENCLAW_GATEWAY_TOKENoverconfigured refs,async( >{
  });
});        : {