| import fs from "node:fs"; |
| import http from "node:http"; |
| import path from "node:path"; |
| import { afterEach, expect, it, onTestFinished } from "vitest"; |
| import { withTestTimeout } from "../../../test/helpers/promise.js"; |
| import { useAutoCleanupTempDirTracker } from "../../../test/helpers/temp-dir.js"; |
| import { |
| claimAgentRunApprovalAuthority, |
| claimAgentRunDelegatedAuthority, |
| releaseAgentRunDelegatedAuthority, |
| validateAgentRunDelegatedAuthority, |
| } from "../../infra/agent-run-registry.js"; |
| import { createCompiledSdkHost } from "../../plugins/compiled-sdk-host.test-support.js"; |
| import { registerComputerUseProvider } from "../../plugins/computer-use-contract.js"; |
| import { createPluginRecord } from "../../plugins/loader-records.js"; |
| import { computerUseSdkEntrypoint } from "../../plugins/loader-sdk-bridge-artifacts.test-support.js"; |
| import { createEmptyPluginRegistry } from "../../plugins/registry-empty.js"; |
| import { |
| createColdPluginConfig, |
| createColdPluginFixture, |
| } from "../../plugins/test-helpers/cold-plugin-fixtures.js"; |
| import { createDeferredCore } from "../../shared/deferred.js"; |
| import { createOpenClawTestState } from "../../test-utils/openclaw-test-state.js"; |
| import { createAgentRuntimeApprovalAuthorityValidator } from "../agent-runtime-identity-token.js"; |
| import { createGatewayAuxHandlers } from "../server-aux-handlers.js"; |
| import { createDirectChatContext } from "../server-chat.agent-events.test-helpers.js"; |
| import { computerHandlers } from "../server-methods/computer.js"; |
| import type { RespondFn } from "../server-methods/types.js"; |
| import { createGatewayComputerService } from "./computer-service.js"; |
|
|
| const tempDirs = useAutoCleanupTempDirTracker(afterEach); |
|
|
| it.each(["direct-run", "parent-closes-scope", "scope-closes"] as const)( |
| "cancels %s authority after native input is queued in the real child and before its final effect", |
| async (mode) => { |
| const state = await createOpenClawTestState({ label: "computer-authority" }); |
| const entered = createDeferredCore<http.ServerResponse>(); |
| const blockerEntered = createDeferredCore(); |
| const revokedQueued = createDeferredCore(); |
| const revokedCancelled = createDeferredCore(); |
| const gate = http.createServer((request, response) => { |
| if (request.url === "/gate/allowed") { |
| entered.resolve(response); |
| return; |
| } |
| if (request.url === "/gate/blocker") { |
| blockerEntered.resolve(); |
| return; |
| } |
| if (request.url === "/queued/revoked") { |
| revokedQueued.resolve(); |
| } |
| if (request.url === "/cancelled/revoked") { |
| revokedCancelled.resolve(); |
| } |
| response.writeHead(204).end(); |
| }); |
| onTestFinished(async () => { |
| gate.closeAllConnections(); |
| if (gate.listening) { |
| await new Promise<void>((resolve, reject) => { |
| gate.close((error) => (error ? reject(error) : resolve())); |
| }); |
| } |
| await state.cleanup(); |
| }); |
| await new Promise<void>((resolve, reject) => { |
| gate.once("error", reject); |
| gate.listen(0, "127.0.0.1", resolve); |
| }); |
| const address = gate.address(); |
| if (!address || typeof address === "string") { |
| throw new Error("Native input gate did not acquire a loopback port"); |
| } |
| const pluginId = "fixture-authority-computer"; |
| const pluginRoot = state.path("plugin"); |
| fs.mkdirSync(pluginRoot); |
| const fixture = createColdPluginFixture({ |
| rootDir: pluginRoot, |
| pluginId, |
| manifest: { providers: [], channels: [], channelConfigs: {}, providerAuthChoices: [] }, |
| }); |
| const events = state.path("native-events.txt"); |
| const allowedEffect = state.path("allowed-effect.txt"); |
| const revokedEffect = state.path("revoked-effect.txt"); |
| const blockerEffect = state.path("blocker-effect.txt"); |
| fs.writeFileSync( |
| fixture.runtimeSource, |
| ` |
| const fs = require("node:fs"); |
| const http = require("node:http"); |
| const { registerComputerUseProvider } = require("openclaw/plugin-sdk/computer-use"); |
| const record = (event) => fs.appendFileSync(${JSON.stringify(events)}, event + "\\n"); |
| const effects = ${JSON.stringify({ allowed: allowedEffect, revoked: revokedEffect, blocker: blockerEffect })}; |
| const request = (route, signal) => new Promise((resolve, reject) => { |
| const req = http.get("http://127.0.0.1:${address.port}/" + route, { signal }, (response) => { |
| response.resume(); |
| response.once("end", resolve); |
| response.once("error", reject); |
| }); |
| req.once("error", reject); |
| }); |
| process.once("exit", (code) => record("exit:" + code)); |
| module.exports = { |
| id: ${JSON.stringify(pluginId)}, |
| register(api) { |
| registerComputerUseProvider(api, { |
| id: ${JSON.stringify(pluginId)}, label: "Synthetic authority computer", isAvailable: () => true, |
| capabilities: () => ({ |
| contractVersion: 2, |
| provider: { id: ${JSON.stringify(pluginId)}, label: "Synthetic authority computer", generation: "authority-generation" }, |
| actions: ["screenshot", "type"], targets: ["screen"], deliveryModes: ["foreground"], observations: ["image"], |
| features: { recording: false, agentCursor: false, multiDisplay: false }, |
| }), |
| async openExecution() { |
| let tail = Promise.resolve(); |
| return { |
| async snapshot() { return JSON.stringify({ format: "png", base64: "c3ludGhldGlj" }); }, |
| async act(paramsJSON, signal) { |
| if (!signal) throw new Error("Native input did not receive its cancellation lifetime"); |
| const label = JSON.parse(paramsJSON).text; |
| if (!Object.hasOwn(effects, label)) throw new Error("Unexpected synthetic input"); |
| const prior = tail; |
| const result = prior.then(async () => { |
| try { |
| signal.throwIfAborted(); |
| await request("gate/" + label, signal); |
| signal.throwIfAborted(); |
| fs.writeFileSync(effects[label], "applied"); |
| record("effect:" + label); |
| return JSON.stringify({ ok: true }); |
| } catch (error) { |
| if (signal.aborted) { |
| record("cancelled:" + label); |
| await request("cancelled/" + label); |
| } |
| throw error; |
| } |
| }); |
| tail = result.catch(() => {}); |
| await request("queued/" + label); |
| return await result; |
| }, |
| async close(reason) { await tail; record("close:" + reason); }, |
| }; |
| }, |
| }); |
| }, |
| }; |
| `, |
| ); |
| const config = createColdPluginConfig(pluginRoot, pluginId); |
| config.plugins!.allow = [pluginId]; |
| config.desktop = { host: { enabled: true, managed: true } }; |
| await state.writeConfig(config); |
| const sdkHost = createCompiledSdkHost(computerUseSdkEntrypoint, (prefix) => |
| tempDirs.make(prefix), |
| ); |
| const env = { |
| PATH: path.dirname(process.execPath), |
| HOME: state.home, |
| USERPROFILE: state.home, |
| OPENCLAW_HOME: state.home, |
| OPENCLAW_STATE_DIR: state.stateDir, |
| OPENCLAW_CONFIG_PATH: state.configPath, |
| OPENCLAW_DISABLE_BUNDLED_PLUGINS: "1", |
| ...(sdkHost ? { OPENCLAW_DEV_SOURCE_ROOT: sdkHost } : {}), |
| NODE_ENV: "test", |
| }; |
| const registry = createEmptyPluginRegistry(); |
| registry.plugins.push( |
| createPluginRecord({ |
| id: pluginId, |
| source: fixture.runtimeSource, |
| origin: "config", |
| enabled: true, |
| configSchema: true, |
| }), |
| ); |
| registerComputerUseProvider( |
| { |
| registerNodeHostCommand: (command) => |
| registry.nodeHostCommands.push({ |
| pluginId, |
| pluginName: "Synthetic authority computer", |
| command, |
| source: fixture.runtimeSource, |
| }), |
| }, |
| { |
| id: pluginId, |
| label: "Synthetic authority computer", |
| isAvailable: () => true, |
| capabilities: () => ({ |
| contractVersion: 2, |
| provider: { |
| id: pluginId, |
| label: "Synthetic authority computer", |
| generation: "authority-generation", |
| }, |
| actions: ["screenshot", "type"], |
| targets: ["screen"], |
| deliveryModes: ["foreground"], |
| observations: ["image"], |
| features: { recording: false, agentCursor: false, multiDisplay: false }, |
| }), |
| openExecution: async () => { |
| throw new Error("Native execution must run in the child"); |
| }, |
| }, |
| ); |
| let desktopCurrent = true; |
| const service = createGatewayComputerService({ |
| getConfig: () => config, |
| getPluginRegistry: () => registry, |
| hostDesktopService: { |
| observe: async () => { |
| throw new Error("Unexpected desktop observer"); |
| }, |
| status: async () => { |
| throw new Error("Unexpected desktop status"); |
| }, |
| acquireComputer: async () => ({ |
| env, |
| isCurrent: () => desktopCurrent, |
| release: () => { |
| desktopCurrent = false; |
| }, |
| }), |
| }, |
| }); |
| const parentAuthority = claimAgentRunDelegatedAuthority({ |
| instanceId: "computer-live-instance", |
| runId: "computer-live-run", |
| }); |
| const scopeLifetime = new AbortController(); |
| const authority = |
| mode === "direct-run" |
| ? parentAuthority |
| : claimAgentRunApprovalAuthority(parentAuthority, [scopeLifetime.signal]); |
| const unrelated = claimAgentRunApprovalAuthority(parentAuthority, [ |
| new AbortController().signal, |
| ]); |
| const aux = createGatewayAuxHandlers({ |
| log: {}, |
| getNativeApprovalRouteCoordinator: () => undefined, |
| activateRuntimeSecrets: async () => { |
| throw new Error("Unexpected secrets reload"); |
| }, |
| sharedGatewaySessionGenerationState: { current: undefined, required: null }, |
| resolveSharedGatewaySessionGenerationForConfig: () => undefined, |
| clients: [], |
| channelManager: { |
| startChannel: async () => new Map(), |
| stopChannel: async () => {}, |
| isManuallyStopped: () => false, |
| resolveRuntimeAccountId: (_channel, accountId) => accountId, |
| }, |
| logChannels: { info: () => {} }, |
| onAgentRunAuthorityClosed: (closed) => service.revokeRunAuthority(closed), |
| }); |
| const validateAuthority = createAgentRuntimeApprovalAuthorityValidator(); |
| const requestLifetime = new AbortController(); |
| const pending: Promise<unknown>[] = []; |
| const invoke = async (text: string) => { |
| const params = { |
| command: "computer.act", |
| generation: "authority-generation", |
| params: { action: "type", text, executionId: "123e4567-e89b-42d3-a456-426614174000" }, |
| idempotencyKey: text, |
| }; |
| let response: Parameters<RespondFn> | undefined; |
| await computerHandlers["computer.invoke"]!({ |
| req: { type: "req", id: text, method: "computer.invoke", params }, |
| params, |
| signal: requestLifetime.signal, |
| respond: (...args) => { |
| response = args; |
| }, |
| isWebchatConnect: () => false, |
| client: { |
| connId: "computer-agent-rpc", |
| connect: { |
| minProtocol: 1, |
| maxProtocol: 1, |
| client: { id: "gateway-client", version: "test", platform: "test", mode: "backend" }, |
| }, |
| internal: { |
| syntheticClient: true, |
| agentRuntimeIdentity: { |
| kind: "agentRuntime", |
| agentId: "main", |
| sessionKey: "agent:main:computer-proof", |
| operationalRunInstance: authority.operationalRunInstance, |
| delegatedAuthority: { ...authority, kind: "local" }, |
| }, |
| }, |
| }, |
| context: createDirectChatContext({ |
| gatewayComputerService: service, |
| validateAgentRuntimeApprovalAuthority: validateAuthority, |
| }), |
| }); |
| expect(response).toBeDefined(); |
| return response!; |
| }; |
| try { |
| expect(await service.status()).toMatchObject({ configured: true, available: true }); |
| const allowed = invoke("allowed"); |
| pending.push(allowed); |
| const releaseAllowed = await Promise.race([ |
| entered.promise, |
| allowed.then(() => { |
| throw new Error("Allowed native input never reached its gate"); |
| }), |
| ]); |
| releaseAgentRunDelegatedAuthority(unrelated); |
| expect(validateAgentRunDelegatedAuthority(authority)).toBe(true); |
| releaseAllowed.writeHead(204).end(); |
| expect((await allowed)[0]).toBe(true); |
| expect(fs.readFileSync(allowedEffect, "utf8")).toBe("applied"); |
|
|
| const blocker = invoke("blocker"); |
| pending.push(blocker); |
| await Promise.race([ |
| blockerEntered.promise, |
| blocker.then(() => { |
| throw new Error("Blocking native input never reached its gate"); |
| }), |
| ]); |
| const revoked = invoke("revoked"); |
| pending.push(revoked); |
| await Promise.race([ |
| revokedQueued.promise, |
| revoked.then(() => { |
| throw new Error("Revoked native input never entered the child queue"); |
| }), |
| ]); |
| if (mode === "scope-closes") { |
| scopeLifetime.abort(); |
| expect(validateAgentRunDelegatedAuthority(parentAuthority)).toBe(true); |
| } else { |
| expect(releaseAgentRunDelegatedAuthority(parentAuthority)).toBe(true); |
| } |
| expect(requestLifetime.signal.aborted).toBe(false); |
| |
| await withTestTimeout( |
| revokedCancelled.promise, |
| 10_000, |
| "Run revocation did not cancel queued native input", |
| ); |
| await service.close(); |
| expect((await blocker)[0]).toBe(false); |
| expect((await revoked)[0]).toBe(false); |
| expect(fs.existsSync(blockerEffect)).toBe(false); |
| expect(fs.existsSync(revokedEffect)).toBe(false); |
| const nativeEvents = fs.readFileSync(events, "utf8"); |
| expect(nativeEvents).toContain("cancelled:blocker\n"); |
| expect(nativeEvents).toContain("cancelled:revoked\n"); |
| expect(nativeEvents).toContain("close:gateway-disconnect\n"); |
| expect(nativeEvents).toContain("exit:0\n"); |
| expect(desktopCurrent).toBe(false); |
| console.log( |
| `[computer-authority-proof] ${mode}: live input applied; sibling claim closure preserved owner; revoked queued input cancelled before effect; native child exit joined`, |
| ); |
| } finally { |
| releaseAgentRunDelegatedAuthority(authority); |
| releaseAgentRunDelegatedAuthority(parentAuthority); |
| releaseAgentRunDelegatedAuthority(unrelated); |
| requestLifetime.abort(); |
| try { |
| await service.close(); |
| await Promise.allSettled(pending); |
| } finally { |
| await aux.stopOperatorInteractions(); |
| } |
| } |
| }, |
| 90_000, |
| ); |
|
|
