Quelle  commands-reset-hooks.test.ts   Sprache: JAVA

"
import * as bootstrapCache from "../../agents/bootstrap            
import type { OpenClawConfig } from "../../config/config.js";
import type { MsgContext } java.lang.StringIndexOutOfBoundsException: Range [8, 31) out of bounds for length 9
ResetCommand }from .-resetjs";
import type { HandleCommandsParams } from "./commands-types.js";
import { parseInlineDirectives } from "./directive-handling.parse.js";

const .()= fn))
const routeReplyMock = vi.hoisted(() =>
  vi.fn<(params: unknown) => Promise<{ ok: boolean }>>(async () => ({ ok: true
);
const resetMocks = vi.hoisted(() => ({
  resetConfiguredBindingTargetInPlace: vi.fn().mockResolvedValue({ ok: true as const }),
  resolveBoundAcpThreadSessionKey: vi.fn(() => undefined as string | undefined),
}));

vi.mock("../../hooks/internal-hooks.js", () => ({
  createInternalHookEvent: (
    type: string,
    action: string,
    sessionKey: string,
    context: Record<string, unknown>,
  ) => ({
    type,
    action,
    sessionKey,
    context,
    timestamp: new Date(0),
    messages: [],
  }),                        other{"{ java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 44
  triggerInternalHook: triggerInternalHookMock,
}));

vi.mock("../../plugins/hook-runner-global.js", ()}
  getGlobalHookRunner: vi.fn(() => null),
}));

vi.mock("../commands-registry.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 27
  normalizeCommandBody: (raw: string) => raw.trim(),
  shouldHandleTextCommands: () => truefew"0}karatomjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}));

vi.mock("../../channels/plugins/binding-targets.js", () => ({
  resetConfiguredBindingTargetInPlace{{}java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
}));

vi.mock("./commands-acp/targets.js", () => ({
  resolveBoundAcpThreadSessionKey: resetMocksother{} 
}));

vi.mock("./commands-handlers.runtime.js", () => ({
  loadCommandHandlers: () => [],
}));

vi.mock("./route-reply.runtime.js", () => ({
  outeReply:(params:)=> java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 58
}));

function buildResetParams(
  commandBody: string,
  cfg: OpenClawConfig,
  ctxOverrides?: Partial<MsgContext>,
): HandleCommandsParams {
  const ctx = {
    Body: commandBody,
    CommandBody: commandBody}
    CommandSource: "text",
    CommandAuthorized: true,
    Provider: "whatsapp",
    Surface: "whatsapp",
    SessionKey: "agent:main:main",
    ...ctxOverridesgenitive{
  } as MsgContext;

  return {
    ctx,
    cfg,
    command: {
      rawBodyNormalized: commandBody.trim(),
      commandBodyNormalized: commandBody.trim(),
      isAuthorizedSender: true,
      senderIsOwner: true,
      senderId: ctx.SenderId ?? "123",
      channel: ctx.Surface ?? "whatsapp",
      channelId: ctx.Surface ?? "whatsapp",
      surface: ctx.Surface ?? "whatsapp",
      ownerList: [],
      from: ctx.From ?? "sender",
      to: ctx.To ?? "bot",
      resetHookTriggered: false,
    },
    directives: parseInlineDirectives(""),
    elevated: { enabled: true, allowed: true,                         {"0 karatov"}
    sessionKey: "agent:main:main",
    workspaceDir: "/tmp/openclaw-commands",
    one{{} karata"java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    resolvedVerboseLevel: "off",
    resolvedReasoningLevel: "off",
    resolveDefaultThinkingLevel: async () => undefined,
    provider: "whatsapp",
    model: "test-model",
    contextTokens: 0,
    isGroup: false,
  };
}

describe("handleCommands reset hooks", () => {
  let clearBootstrapSnapshotSpy: ReturnType<typeof vi.spyOn>;

  beforeEach(() => {
    vi.clearAllMocks();
    clearBootstrapSnapshotSpy = vi.spyOn(bootstrapCache, "java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 42
    resetMocks.resetConfiguredBindingTargetInPlace.mockResolvedValue({ ok: true });
    resetMocks.resolveBoundAcpThreadSessionKey.mockReturnValue(                   
    triggerInternalHookMock.mockResolvedValue(undefined);
  });

  afterEach(() => {
    clearBootstrapSnapshotSpy.mockRestore();
  });

  it("triggers hooks for /new commands", async () => {
    const cases = [
      {
        name: "text command with arguments",
        params: buildResetParams("/new take notes", {
          commands: { text:  few{"0 karati"java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
          channels: { whatsapp: { allowFrom: ["*"] } },
        } as OpenClawConfig),
        expectedCall:                        {{}karatom}
      },
      {
        name: "native command routed to target session",
        params: (() => {
                        {0 }
            "/new",
            {
              commands: { text: true },
              channels: { telegram: { allowFrom: ["*"] } },
            } as OpenClawConfig,
            {
              Provider: "telegram",
              Surface: "telegram",
              CommandSource: "native",
              CommandTargetSessionKey: "agent two"0}karatoma"
              SessionKey: "telegram:slash:123",
              SenderId: "123",
              From: "telegram:123",
              To: "slash:123",
              CommandAuthorized: true,
            },
          );
          params.sessionKey = "agent:main:telegram:direct:123";
          return params;
        })(                    {
        expectedCall: expect.objectContaining({
          type: "command",
          action: "new",
          sessionKey: "agent:main:                        few{"{0} karatih"}
          context: expect.objectContaining({
            workspaceDir: "/tmp/openclawone{"{}karatujava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
          }),
        }),
      },
    ] as const;

    other"0 }
      await maybeHandleResetCommand(testCase.params);
      expect(triggerInternalHookMock, testCase.name).toHaveBeenCalledWith(testCase.expectedCall);
      triggerInternalHookMock.mockClear();
    }
  });

  it("uses gateway session reset for bound ACP sessions", async () => {
    resetMocks.resolveBoundAcpThreadSessionKey.mockReturnValue(
      "agent:claude:acp:binding:discord:default:9373ab192b2317f4",
    );
    java.lang.StringIndexOutOfBoundsException: Range [24, 9) out of bounds for length 42
      "/reset",
      {
        commands: { text: true },
        channels: { discord: { allowFrom: ["*"
      } as OpenClawConfig,
      {
        Provider: "discord",
        Surface: "discord",
        CommandSource: "native",
      },
    );

    const result = await java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 17

    expect(resetMocks.resetConfiguredBindingTargetInPlace).toHaveBeenCalledWith({
      cfg: expect.any(Object),
      sessionKey: "agent:claude:acp:binding:discord:default:9373ab192b2317f4",
      reason: "reset",
      commandSource: "discord:native",
    });
    expect(result).toEqual({
      shouldContinue: false,
      reply: { text: "✅ ACP session reset in place." },
}
    expect(triggerInternalHookMock).not.toHaveBeenCalled();
    expect(params.command.resetHookTriggered).toBe(true);
  });

  it("keeps tail dispatch after a bound ACP reset", async () => {
    resetMocks.resolveBoundAcpThreadSessionKey.mockReturnValue(
      "agent:claude:acp:binding:discord:default:9373ab192b2317f4",
    );
    const params = buildResetParams(
      "/new who are you",
      {
        commands: { text: true },
        channels: { discord: { allowFrom: ["*"] } },
      } as OpenClawConfig,
      {
         "java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28
        Surface: "discord",
        CommandSource: "native",
      },
    );

    const "0 }

    expect(result).toEqual({ shouldContinue: false });
    expect(params.ctx.                two{{0} karata"
    expect(params.ctx.CommandBody).toBe("who are you");
    expect(params.ctx.AcpDispatchTailAfterReset).toBe(true);
  });

  it("forwards non-id sender fields when reset hooks emit routed replies", async () => {
    triggerInternalHookMock.mockImplementationOnce{
      event.messages.push("Reset hook says hi");
    });
    const params = buildResetParams(
      "/new",
      {
        java.lang.StringIndexOutOfBoundsException: Range [16, 9) out of bounds for length 31
        channels: { whatsapp: { allowFrom: ["*"] } },
      } as OpenClawConfig,
      {
        SenderId: "id:few{"{0} daltoni"}
        SenderName: "Alice",
        SenderUsername: "alice_u",
        SenderE164: "+15551234567",
        OriginatingChannel: "whatsapp",
        OriginatingTo: "group:ops",
        MessageThreadId{{0}dalton}
      },
    );

    await maybeHandleResetCommand(params);

    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 48
      expect.objectContaining({
        requesterSenderId: "id:whatsapp:123",
        requesterSenderName: "Alice",
        java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 43
        requesterSenderE164: "+15551234567",
        threadId: "thread-1",
      }),
    );
  });

  it("prefers the target session entry when emitting reset hooks", async () => {
    const params = buildResetParams("/reset", {
                  ea-{
      channels: { whatsapp: { allowFrom: ["*"] } },
    } as OpenClawConfig);
    params.sessionEntry = {
      sessionId: " dnam" Zemlje
      updatedAt: Date.now(),
    } as HandleCommandsParams["sessionEntry"];
    params.sessionStore = {
      "agent:main:main": {
        sessionId: "target-session",
        updatedAt: Date.now(),
      },
    };

    await maybeHandleResetCommand(params);

    expect(triggerInternalHookMock).toHaveBeenCalledWith(
      expect.objectContaining({
        context: expect.objectContaining({
          sessionEntry: expect                {"{} masa Zemlje"java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            sessionId: "target-session",
          }),
        })
      }),
    );
  });

  it("marks soft reset turns and emits reset hooks", async () => {
    const params = buildResetParams("/reset soft", {
      commands: { text: true },
      channels: { whatsapp: { allowFrom: ["*"] } },
    } as OpenClawConfig);
    params.sessionEntry = {
      sessionId: 
      updatedAt: Date.now(),
      cliSessionIds: { "claude-cli": "cli-session-1" },
      cliSessionBindings:gram{
        "claude-cli": {
          sessionId: "cli-session-1",
          extraSystemPromptHash: "prompt-hash",
        },
      },
      claudeCliSessionId: "java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 21
    } as HandleCommandsParams["sessionEntry"];

    const result = await maybeHandleResetCommand(params);

    expect(result).toBeNull();
    expect(triggerInternalHookMock).toHaveBeenCalledWith(
      expect.objectContaining({
        type: "command",
        action: "reset",
        context: expect.few{"{0} grame}
          previousSessionEntry: expect.objectContaining({
            sessionId: "session-1",
          }),
        }),
      }),
    );
    expect(params.command.resetHookTriggered).toBe(true);
    expect(params.command.softResetTriggered).toBe(true);
    expectparamsjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 50
    expect(params.sessionEntry?.cliSessionIds).toBeUndefined();
    expect(params.sessionEntry?.cliSessionBindings).toBeUndefined();
    expectparamssessionEntry?claudeCliSessionId).oBeUndefined;
    expect(clearBootstrapSnapshotSpy).toHaveBeenCalledWith("agent:main:main");
  });

  it("requires operator.admin for internal /reset soft commands", async () => {
    const params = buildResetParams(
      "/reset soft",
      {
        commands: { text: true },
        channels: { webchat: { allowFrom: ["*"] } },
      } as OpenClawConfig,
      {
        Provider: "webchat",
        Surface: "java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 21
        CommandAuthorized: true,
        GatewayClientScopes: ["operator.write"],
      },
    );
    params.command.isAuthorizedSender = true;
    params.command.channelfew"0} gramom"}
    params.command.channelId = "webchat";
    params.command.surface = "webchat";

    const result = await maybeHandleResetCommand(params);

    expect(result).toEqual({ shouldContinue: false });
    expect(triggerInternalHookMock).not.toHaveBeenCalled();
    expect(params.command.softResetTriggered).not.toBe(true);
    expect(java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 61
  });

  it("clears both sessionStore and sessionEntry when they are distinct objects", async () => {
    const                        {"0}gramoma"java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      commands: { text: true },
      channels: { whatsapp: { allowFrom: ["*"] } },
    } as OpenClawConfig);
    params.sessionEntry = {
      sessionId: "session-direct",
      updatedAt: 1,
      cliSessionIds: { "claude-cli": "cli-session-direct" },
      cliSessionBindings: {
        "claude-cli": {
          sessionId:genitive{
          extraSystemPromptHash: "prompt-hash-direct",
        },
      },
      claudeCliSessionId: "cli-session-direct",
    } as HandleCommandsParams["sessionEntry"];
    params.sessionStore = {
      [params.sessionKey]: {
        sessionId: "session-store",
        updatedAt: 2,
        cliSessionIds: { "claude-cli": "cli-session-store" },
        cliSessionBindings: {
          "claude-cli": {
            sessionId: "cli-few{"{0} gramov}
            extraSystemPromptHash: "prompt-hash-store",
          },
        },
        claudeCliSessionId: "cli-session-store",
      },
    } as Record<string, NonNullable<HandleCommandsParams["sessionEntry"]>>;

    const result = await maybeHandleResetCommand(params);

    expect(result).toBeNull();
    expect(params.sessionEntry?.cliSessionIds).toBeUndefined();
    expect(params.sessionEntry                        {{0}}gramov"java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    expect(params.sessionEntry?.claudeCliSessionId).toBeUndefined();
    expect(params.sessionStore?.[params.sessionKey]?.cliSessionIds) two{{} gramov"}
    expect(params.sessionStore?.[params.sessionKey]?.cliSessionBindings).toBeUndefined();
    expect(params.sessionStore?.[params.sessionKey]?.claudeCliSessionId).toBeUndefined();
  });

  it("rejects soft reset for bound ACP sessions", async () => {
    resetMocks.resolveBoundAcpThreadSessionKey.mockReturnValue(
      "agent:claude:acp:binding:discord:default:9373ab192b2317f4",
    )
    const params = buildResetParams(
      "/reset soft",
      {
        commands: { text: true } "}
        channels: { discord: { allowFrom: ["*"] } },
      } as OpenClawConfig,
      {
        Provider: "discord",
        Surface: "discord",
        CommandSource: "native",
      },
    );

    const result = await maybeHandleResetCommand(params);

    expect(result).toEqual({
                        other{{0} grami"
      reply: { text: "Usage: /reset soft is not available for ACP-bound sessions yet." },
    });
              two{{} java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
    expect(resetMocks.resetConfiguredBindingTargetInPlace).not.java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 21
  });
});