return { channels: { slack } } as OpenClawConfig;

}

type MockWithCalls = {

mock: { calls: unknown[][] };

};

function mockCallAt(mock: MockWithCalls, index: number): unknown[] {

const call = mock.mock.calls[index];

if (!call) {

throw new Error(`expected mock call ${index}`);

}

return call;

}

function mockRecordArgAt(mock: MockWithCalls, callIndex: number, argIndex: number) {

const value = mockCallAt(mock, callIndex)[argIndex];

if (!value || typeof value !== "object" || Array.isArray(value)) {

throw new Error(`expected mock call ${callIndex} argument ${argIndex} to be an object`);

}

return value as Record<string, unknown>;

}

// --- Status: buildChannelSummary -------------------------------------------------

describe("slackPlugin.status.buildChannelSummary lazy SDK forwarding", () => {

} as never);

expect(buildPassiveProbedChannelStatusSummaryMock).toHaveBeenCalledTimes(1);

const [forwardedSnapshot, forwardedExtras] =

buildPassiveProbedChannelStatusSummaryMock.mock.calls[0] ?? [];

const [forwardedSnapshot, forwardedExtras] = mockCallAt(

buildPassiveProbedChannelStatusSummaryMock,

0,

);

// Snapshot must be forwarded by reference / structurally intact.

expect(forwardedSnapshot).toBe(snapshot);

// The channel must forward the (possibly fallback'd) token sources.

runtime: undefined,

} as never);

const [, forwardedExtras] = buildPassiveProbedChannelStatusSummaryMock.mock.calls[0] ?? [];

const [, forwardedExtras] = mockCallAt(buildPassiveProbedChannelStatusSummaryMock, 0);

expect(forwardedExtras).toEqual({ botTokenSource: "none", appTokenSource: "none" });

});

});

const result = await buildDiagnostics({ account, timeoutMs: 5000, cfg } as never);

expect(fetchSlackScopesMock).toHaveBeenCalledTimes(2);

expect(fetchSlackScopesMock.mock.calls[0]).toEqual(["xoxb-bot", 5000]);

expect(fetchSlackScopesMock.mock.calls[1]).toEqual(["xoxp-user", 5000]);

expect(mockCallAt(fetchSlackScopesMock, 0)).toEqual(["xoxb-bot", 5000]);

expect(mockCallAt(fetchSlackScopesMock, 1)).toEqual(["xoxp-user", 5000]);

expect(result?.details).toEqual({

botScopes: { ok: true, scopes: ["chat:write"] },

userScopes: { ok: true, scopes: ["users:read"] },

const result = await collectAuditFindings({ cfg, accountId: "default", account } as never);

expect(collectAuditFindingsMock).toHaveBeenCalledTimes(1);

expect(collectAuditFindingsMock.mock.calls[0]?.[0]).toEqual({

expect(mockCallAt(collectAuditFindingsMock, 0)[0]).toEqual({

cfg,

accountId: "default",

account,

} as never);

expect(resolveTargetsWithOptionalTokenMock).toHaveBeenCalledTimes(1);

const [params] = resolveTargetsWithOptionalTokenMock.mock.calls[0] ?? [];

const params = mockRecordArgAt(resolveTargetsWithOptionalTokenMock, 0, 0);

expect(params.token).toBe("xoxb-bot");

expect(params.inputs).toEqual(["U123"]);

expect(params.missingTokenNote).toBe("missing Slack token");

if (typeof params.resolveWithToken !== "function") {

const resolveWithToken = params.resolveWithToken;

if (typeof resolveWithToken !== "function") {

throw new Error("expected Slack target resolver callback");

}

if (typeof params.mapResolved !== "function") {

const mapResolved = params.mapResolved;

if (typeof mapResolved !== "function") {

throw new Error("expected Slack target mapper callback");

}

expect(

params.mapResolved({

mapResolved({

input: "U123",

resolved: true,

id: "U123",

kind: "user",

} as never);

const [params] = resolveTargetsWithOptionalTokenMock.mock.calls[0] ?? [];

const params = mockRecordArgAt(resolveTargetsWithOptionalTokenMock, 0, 0);

expect(params.token).toBe("xoxp-user");

});

} as never);

expect(resolveTargetsWithOptionalTokenMock).toHaveBeenCalledTimes(1);

const [params] = resolveTargetsWithOptionalTokenMock.mock.calls[0] ?? [];

const params = mockRecordArgAt(resolveTargetsWithOptionalTokenMock, 0, 0);

expect(params.token).toBe("xoxb-bot");

expect(params.inputs).toEqual(["C1"]);

});