sailfork / t3code-github / evals/ mcp-tool-use/ devices.test.ts

// @effect-diagnostics nodeBuiltinImport:off
import * as NodeFS from "node:fs";
import * as NodeZlib from "node:zlib";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Layer from "effect/Layer";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import {
  AGENT_DEVICE_SHELL,
  agentDeviceSessionError,
  agentDeviceSessions,
  describeSessions,
  deviceFailure,
  type LauncherTarget,
  launcherHelp,
  makeDeviceTools,
  type ShellCall,
} from "./devices.ts";
import {
  buildBase,
  buildMessages,
  cannedOutput,
  makeSample,
  McpToolUseCase,
  shellRequest,
  t3SubagentContext,
  t3SystemAppend,
  withDevices,
} from "./run.ts";
import { DeviceOperationError, LOCAL_DEVICE_HOST_ID } from "@t3tools/contracts";

const MAC = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const IPHONE = "BBBBBBBB-BBBB-4BBB-8BBB-BBBBBBBBBBBB";
const world = {
  devices: [
    {
      hostId: MAC,
      id: IPHONE,
      name: "Acme iPhone",
      platform: "ios",
      version: "iOS 26.0",
      booted: true,
      physical: false,
    },
  ],
  deviceHosts: { [MAC]: "build-mac" },
};
const screenshotFailure = {
  _tag: "DeviceOperationError",
  operation: "screenshot",
  reason: "request_failed",
  cause: null,
};
const decodeCase = Schema.decodeUnknownSync(McpToolUseCase);
const deviceCase = (setup: object) =>
  decodeCase({
    id: "device-case",
    area: "device-manager",
    kind: "guard",
    pattern: "device",
    experience: "A device case.",
    setup: { role: "top", world, ...setup },
    prompt: "Show a fresh screenshot of the iPhone on build-mac.",
    expect: {},
  });
const capture = JSON.parse(
  NodeZlib.gunzipSync(
    NodeFS.readFileSync(new URL("./templates/claude.json.gz", import.meta.url)),
  ).toString(),
).request.provider_native;
const model = "claude-opus-5-5";
const base = buildBase(capture, { model, keepUserInstructions: false });
const json = (text: string) => JSON.parse(text);

it.effect("answers device calls with T3's handlers over the case's world", () =>
  Effect.gen(function* () {
    const { devices, deviceHosts } = deviceCase({}).setup.world ?? {};
    const tools = yield* makeDeviceTools({ devices: devices ?? [], deviceHosts }, base.environment);
    const listed = json((yield* tools.call("device_list", {})).text);
    assert.deepEqual(listed.devices, world.devices);
    assert.deepEqual(
      listed.hosts.map((host: { label: string }) => host.label),
      ["This machine", "build-mac"],
    );
    const opened = json((yield* tools.call("device_open", { hostId: MAC, deviceId: IPHONE })).text);
    const { command } = opened.agentDevice;
    assert.match(command, /^\/home\/user\/\.t3\/userdata\/device\/.+\/agent-device$/);
    assert.include(opened.quickStart, command);
    assert.deepEqual(tools.launchers, [command]);
    // The image never reaches the model; T3's text result has the rest.
    assert.deepEqual(json((yield* tools.call("device_screenshot", {})).text).screenshot, {
      mimeType: "image/png",
      width: 1206,
      height: 2622,
    });
    const failed = yield* tools.call("device_screenshot", {}, deviceFailure(screenshotFailure));
    assert.isTrue(failed.isError);
    assert.include(failed.text, "screenshot failed");
    const elsewhere = yield* tools.call("device_open", { hostId: "local", deviceId: IPHONE });
    assert.isTrue(elsewhere.isError);
    assert.include(elsewhere.text, IPHONE);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("lists the boot state T3 left a device in", () =>
  Effect.gen(function* () {
    const { devices, deviceHosts } = deviceCase({}).setup.world ?? {};
    const stopped = (devices ?? []).map((device) => ({ ...device, booted: false }));
    const tools = yield* makeDeviceTools({ devices: stopped, deviceHosts }, base.environment);
    const before = json((yield* tools.call("device_list", {})).text);
    assert.isFalse(before.devices.find((d: { id: string }) => d.id === IPHONE).booted);
    yield* tools.call("device_open", { hostId: MAC, deviceId: IPHONE });
    const after = json((yield* tools.call("device_list", {})).text);
    assert.isTrue(after.devices.find((d: { id: string }) => d.id === IPHONE).booted);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it("decodes only T3 device errors as injected failures", () => {
  assert.isDefined(deviceFailure(screenshotFailure));
  assert.isUndefined(deviceFailure({ error: "Synthetic hub is unavailable", isError: true }));
  assert.isUndefined(deviceFailure("default"));
});

it.effect("rebuilds prior device results with T3, whose sessions reach the measured turn", () =>
  Effect.gen(function* () {
    const testCase = deviceCase({
      priorTurns: [
        { role: "user", text: "Show me Settings on the iPhone on build-mac." },
        {
          role: "assistant",
          toolCalls: [
            { tool: "device_list", input: {}, result: "default" },
            { tool: "device_open", input: { hostId: MAC, deviceId: IPHONE }, result: "default" },
          ],
        },
      ],
      mocks: { device_screenshot: screenshotFailure },
    });
    const sample = makeSample(testCase, base);
    assert.throws(() => buildMessages(sample), /run withDevices/);
    yield* withDevices(sample);
    const shown = JSON.stringify(buildMessages(sample));
    const [launcher = ""] = sample.devices?.launchers ?? [];
    assert.include(shown, launcher);
    assert.notInclude(shown, `"content":"default"`);
    const tools = sample.devices!;
    assert.isFalse((yield* tools.call("device_screenshot", {})).isError);
    const mock = deviceFailure(testCase.setup.mocks?.device_screenshot);
    assert.isTrue((yield* tools.call("device_screenshot", {}, mock)).isError);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("gives a native subagent T3's SubagentStart context instead of T3's append", () =>
  Effect.gen(function* () {
    const subagentContext = yield* Effect.promise(() => t3SubagentContext(model));
    const native = {
      ...buildBase(capture, { model, keepUserInstructions: false, nativeSubagent: true }),
      subagentContext,
    };
    const system = (blocks: typeof base.system) =>
      blocks.map((block) => String(block.text)).join("");
    assert.include(system(base.system), t3SystemAppend(model));
    assert.notInclude(system(native.system), t3SystemAppend(model));
    const testCase = deviceCase({ role: "native-subagent" });
    const shown = (sample: typeof native) =>
      buildMessages(makeSample(testCase, sample))[0]?.content.map((block) => String(block.text));
    const reminders = shown(native)?.join("\n") ?? "";
    // A ref without T3's hook gives the subagent nothing.
    assert.equal(
      reminders.includes("SubagentStart hook additional context"),
      subagentContext !== "",
    );
    assert.include(reminders, subagentContext);
    // Claude Code 2.1.310 records the hook's context after the task, and sends it that way.
    const blocks = shown({ ...native, subagentContext: "## T3 Code devices" }) ?? [];
    assert.equal(blocks.at(-2), testCase.prompt);
    assert.equal(
      blocks.at(-1),
      "<system-reminder>\nSubagentStart hook additional context: ## T3 Code devices\n</system-reminder>",
    );
  }),
);

it.effect("tells the shell simulator the launchers T3 returned and agent-device's real CLI", () =>
  Effect.gen(function* () {
    const sample = makeSample(deviceCase({}), base);
    yield* withDevices(sample);
    const call = { tool: "Bash", input: { command: "ls /tmp" } };
    const told = (request: ReturnType<typeof shellRequest>) => JSON.stringify(request.messages);
    assert.notInclude(told(shellRequest(sample, call, "claude-haiku-5-5")), "launchers T3's");
    const opened = yield* sample.devices!.call("device_open", { hostId: MAC, deviceId: IPHONE });
    const { command } = json(opened.text).agentDevice;
    const request = shellRequest(sample, call, "claude-haiku-5-5");
    assert.include(told(request), `agent-device launchers T3's device_open returned: ${command}`);
    // agent-device's own syntax: a positional recording path, and `record stop` with no flag.
    assert.include(request.system, AGENT_DEVICE_SHELL);
    assert.include(
      request.system,
      "agent-device record start [path] [--scope <app|device|system>]",
    );
    assert.include(request.system, "| record stop |");
    assert.include(request.system, "Unknown flag: --stop. Did you mean --scope?");
    // A case without devices keeps the shell prompt every other case has.
    const plain = makeSample(deviceCase({ world: {} }), base);
    assert.notInclude(shellRequest(plain, call, "claude-haiku-5-5").system, "agent-device");
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it("prints agent-device's own help for a lone help command on a returned launcher", () => {
  const help = (topic: string) =>
    AGENT_DEVICE_SHELL.split(`$ agent-device help${topic ? ` ${topic}` : ""}\n`)[1]
      ?.split("\n$ agent-device help")[0]
      ?.trimEnd();
  // Commands from the paired runs. The simulator once answered the first with a placeholder.
  const launcher = "/home/user/.t3/userdata/device/bin/agent-device";
  const target = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/303617b9730210ef3c86c52d.json --session t3-4c43aa31e607633b85e9ff2f`;
  const asked = (command: string) => launcherHelp([launcher], command);
  assert.match(help("") ?? "", /^agent-device <command> \[args\] \[--json\]\n/);
  assert.equal(asked(`${launcher} help ${target}`), help(""));
  assert.equal(asked(`${launcher} record --help ${target}`), help("record"));
  assert.equal(asked(`${launcher} help open ${target}`), help("open"));
  assert.equal(asked(`${launcher} --help 2>&1`), help(""));
  assert.equal(asked(`${launcher} help settings --session=t3-1`), help("settings"));
  // A password reaches fill from stdin, so request_secret's file never enters argv.
  assert.equal(asked(`${launcher} fill --help ${target}`), help("fill"));
  assert.include(help("fill"), "fill <x y|@ref|selector> --text-stdin");
  // Anything else stays with the simulator: other topics, pipes, aliases, other commands.
  assert.isUndefined(asked(`${launcher} metro --help ${target}`));
  assert.isUndefined(asked(`${launcher} help record 2>&1 | head -40`));
  assert.isUndefined(asked(`AD=${launcher}; $AD help record`));
  assert.isUndefined(asked(`${launcher} snapshot -i ${target}`));
  assert.isUndefined(asked(`/usr/local/bin/agent-device help`));
});

it("pins agent-device's help to the version T3 installs", () => {
  const versions = JSON.parse(
    NodeFS.readFileSync(
      new URL("../../apps/server/src/device/deviceToolVersions.json", import.meta.url),
      "utf8",
    ),
  );
  assert.include(AGENT_DEVICE_SHELL, `agent-device ${versions["agent-device"]} prints this help`);
});

// agent-device 0.21.31's errors as a real Mac printed them (stderr, exit status 1).
const NO_SESSION =
  "Error (SESSION_NOT_FOUND): No active session. Run open first.\nHint: Run open first or pass an explicit device selector.";
const APP_RECORDING_BEFORE_OPEN =
  "Error (INVALID_ARGS): record start with app scope and an explicit session requires an active app session; run open <app> first, or use --scope device to record the full screen\nHint: Check command arguments and run --help for usage examples.";
/** agent-device 0.21.31's snapshot-runtime-binding refusal, with the CLI's default hint. */
const iosSnapshotRefused = (session: string) =>
  `Error (SESSION_NOT_FOUND): iOS snapshot requires an active app session on the target device. Run open first (for example: open --session ${session} --platform ios --device "<name>" <app>).\nHint: Run open first or pass an explicit device selector.`;
const APP_RECORDING_WITHOUT_APP =
  "Error (UNKNOWN): App-scoped recording requires an active app session; open the app under test before recording.\nHint: Unexpected internal error. Retry with --debug and report the diagnostics log if it persists.";

it.effect("answers the returned launcher as agent-device does before and after open", () =>
  Effect.gen(function* () {
    const { devices = [], deviceHosts } = deviceCase({}).setup.world ?? {};
    const tools = yield* makeDeviceTools({ devices, deviceHosts }, base.environment);
    const opened = json((yield* tools.call("device_open", { hostId: MAC, deviceId: IPHONE })).text);
    const { command, targetArgs, session: bound } = opened.agentDevice;
    // This ref's launcher: a bound one names its session; the shared one takes device_open's flags.
    const session: string = bound ?? targetArgs[targetArgs.indexOf("--session") + 1];
    const line = (args: string) =>
      bound === undefined ? `${command} ${args} ${targetArgs.join(" ")}` : `${command} ${args}`;
    const history: Array<ShellCall> = [];
    const answer = (args: string) => tools.sessionError(history, line(args));
    const ran = (args: string, output: string) =>
      history.push({ tool: "Bash", input: { command: line(args) }, output });

    const shot = answer("screenshot /tmp/shot.png") ?? "";
    assert.isTrue(shot.startsWith(`Exit code 1\n${NO_SESSION}\nDiagnostic ID: `));
    assert.match(
      shot,
      new RegExp(
        `\\nDiagnostics Log: /home/user/\\.agent-device/remote-diagnostics/${session}/requests/[\\da-f]{16}\\.ndjson

	
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	evals/mcp-tool-use/devices.test.ts at main · sailfork/t3code-github · Sailfork
	
		
, ), ); for (const args of ["press @e3 --settle", 'fill @e5 "hello world"', "scroll down", "home"]) { assert.include(answer(args), NO_SESSION, args); } assert.include(answer("record start /tmp/run.mp4"), APP_RECORDING_BEFORE_OPEN); // An iOS snapshot needs an app open in the session. assert.include(answer("snapshot -i"), iosSnapshotRefused("sim")); // With the device selector both refs pass, these run without a session. for (const args of [ "open", "devices", "apps", "settings appearance dark", "alert accept", "install com.acme.app /tmp/Acme.app", "record start --scope device /tmp/run.mp4", ]) { assert.isUndefined(answer(args), args); } // Unknown flags, JSON output and compound commands stay with the simulator. assert.isUndefined(answer("screenshot --bogus /tmp/shot.png")); assert.isUndefined(answer("screenshot --json /tmp/shot.png")); assert.isUndefined(tools.sessionError(history, `${line("screenshot /tmp/a.png")} && echo ok`)); assert.deepEqual([...tools.sessions(history)], [[session, undefined]]); ran("open com.acme.missing", "Exit code 1\nError (APP_NOT_INSTALLED): App not installed"); assert.include(answer("screenshot /tmp/shot.png"), NO_SESSION); ran("open", `Opened: ${session}`); assert.isUndefined(answer("screenshot /tmp/shot.png")); assert.isUndefined(answer("press @e3")); assert.include(answer("record start /tmp/run.mp4"), APP_RECORDING_WITHOUT_APP); assert.isUndefined(answer("record start --scope device /tmp/run.mp4")); assert.include(answer("snapshot -i"), iosSnapshotRefused(session)); ran("open com.acme.app", "Opened: com.acme.app"); assert.isUndefined(answer("record start /tmp/run.mp4")); assert.isUndefined(answer("snapshot -i")); assert.deepEqual([...tools.sessions(history)], [[session, { app: true }]]); ran("close", "Closed"); assert.include( tools.sessionError(history, `${line("screenshot /tmp/a.png")} 2>&1`), NO_SESSION, ); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); const shared = (session: string): LauncherTarget => ({ command: "/home/user/.t3/userdata/device/bin/agent-device", session, bound: false, deviceId: IPHONE, ios: true, iosSimulator: true, }); const boundTarget: LauncherTarget = { command: "/home/user/.t3/userdata/device/targets/t3-bound/agent-device", session: "t3-bound", bound: true, deviceId: IPHONE, ios: true, iosSimulator: true, }; const bash = (command: string, output = "OK"): ShellCall => ({ tool: "Bash", input: { command }, output, }); const errorCode = ( targets: ReadonlyArray<LauncherTarget>, history: ReadonlyArray<ShellCall>, command: string, ) => agentDeviceSessionError(targets, agentDeviceSessions(targets, {}, history), command)?.code; it("names the session on either ref: the bound launcher's own, or the shared one's --session", () => { const flags = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/x.json`; const sharedTargets = [shared("t3-a"), shared("t3-b")]; // The shared launcher answers each session its flags name; without one, its own check (not // modelled) refuses before agent-device runs. const opened = [bash(`${sharedTargets[0]!.command} open com.acme.app ${flags} --session t3-a`)]; assert.isUndefined( errorCode( sharedTargets, opened, `${sharedTargets[0]!.command} screenshot ${flags} --session t3-a`, ), ); assert.equal( errorCode( sharedTargets, opened, `${sharedTargets[0]!.command} screenshot ${flags} --session=t3-b`, ), "SESSION_NOT_FOUND", ); assert.isUndefined(errorCode(sharedTargets, [], `${sharedTargets[0]!.command} screenshot`)); // The bound launcher needs no flags, and an explicit --session still wins. assert.equal( errorCode([boundTarget], [], `${boundTarget.command} screenshot`), "SESSION_NOT_FOUND", ); assert.equal(errorCode([boundTarget], [], `${boundTarget.command} record start`), "INVALID_ARGS"); const boundOpen = [bash(`${boundTarget.command} open`)]; assert.isUndefined(errorCode([boundTarget], boundOpen, `${boundTarget.command} screenshot`)); assert.equal( errorCode([boundTarget], boundOpen, `${boundTarget.command} record start /tmp/r.mp4`), "UNKNOWN", ); assert.equal( errorCode([boundTarget], boundOpen, `${boundTarget.command} screenshot --session other`), "SESSION_NOT_FOUND", ); // Without a selector, agent-device's record and close refuse a missing named session with // other text; that stays with the simulator. assert.isUndefined( errorCode(sharedTargets, [], `${sharedTargets[0]!.command} record start --session t3-a`), ); }); it("follows the session through aliases, compound calls, snapshots and whole-screen recordings", () => { const launcher = boundTarget.command; const after = (...history: ReadonlyArray<ShellCall>) => agentDeviceSessions([boundTarget], {}, history).get("t3-bound"); assert.deepEqual(after(bash(`AD=${launcher}; "$AD" open com.acme.app`)), { app: true }); // A failed lone open starts nothing; an open in a failed compound call still counts. assert.isUndefined(after(bash(`${launcher} open com.acme.app`, "Exit code 1\nError (X): no"))); assert.deepEqual( after(bash(`${launcher} open com.acme.app && ${launcher} press @e9`, "Exit code 1\nboom")), { app: true }, ); // Dead tails, remote agent-device and help start nothing. assert.isUndefined(after(bash(`false && ${launcher} open`, "Exit code 1"))); assert.isUndefined(after(bash("ssh build-mac agent-device open com.acme.app"))); assert.isUndefined(after(bash(`${launcher} help open`))); // agent-device publishes a session for a sessionless Android snapshot, without an app. An iOS // snapshot without an app fails and starts nothing. assert.isUndefined(after(bash(`${launcher} snapshot -i`))); const android = { ...boundTarget, ios: false, iosSimulator: false }; assert.deepEqual( agentDeviceSessions([android], {}, [bash(`${launcher} snapshot -i`)]).get("t3-bound"), { app: false }, ); // A whole-screen recording holds a session only until it stops. const recording = bash(`${launcher} record start --scope device /tmp/r.mp4`); assert.deepEqual(after(recording), { app: false, recordingOnly: true }); assert.isUndefined(errorCode([boundTarget], [recording], `${launcher} screenshot`)); assert.isUndefined(after(recording, bash(`${launcher} record stop`))); assert.equal( errorCode( [boundTarget], [recording, bash(`${launcher} record stop`)], `${launcher} screenshot`, ), "SESSION_NOT_FOUND", ); assert.deepEqual(after(bash(`${launcher} open`), bash(`${launcher} close`)), undefined); }); it("follows the shared launcher's session through flags held in a variable or an array", () => { // Forms Sonnet used with the shared launcher in a live sample. const target = shared("t3-a"); const flags = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/x.json --session t3-a`; const after = (history: ShellCall, targets = [target]) => agentDeviceSessions(targets, {}, [history]).get("t3-a"); const opened = bash( `AD=${target.command}; A="${flags}"; $AD open com.acme.app $A 2>&1 | tail -5; sleep 5; $AD snapshot -i $A 2>&1 | head -60`, "Opened: com.acme.app", ); assert.deepEqual(after(opened), { app: true }); const array = bash(`A=(${flags}); ${target.command} open "\${A[@]}" 2>&1 | head -60`); assert.deepEqual(after(array), { app: false }); // With two sessions behind the shared launcher, unread flags name neither. assert.isUndefined(after(array, [target, shared("t3-b")])); // agent-device still sees no session for a plain command after a failed open in a variable. const failed = bash( `AD=${target.command}; A="${flags}"; $AD open $A`, "Exit code 1\nError (X): no", ); assert.equal( errorCode([target], [failed], `${target.command} screenshot ${flags}`), "SESSION_NOT_FOUND", ); }); it.effect("starts sessions the world says prior turns opened, and rejects unknown devices", () => Effect.gen(function* () { const testCase = deviceCase({ world: { ...world, agentDeviceSessions: { [IPHONE]: { app: "com.acme.app" } } }, priorTurns: [ { role: "user", text: "Show me Settings on the iPhone on build-mac." }, { role: "assistant", toolCalls: [ { tool: "device_open", input: { hostId: MAC, deviceId: IPHONE }, result: "default" }, ], }, ], }); const sample = makeSample(testCase, base); yield* withDevices(sample); const tools = sample.devices!; const [launcher = ""] = tools.launchers; assert.deepEqual([...tools.sessions(sample.shell).values()], [{ app: true }]); const call = { tool: "Bash", input: { command: "ls" } }; assert.include( JSON.stringify(shellRequest(sample, call, "claude-haiku-5-5").messages), "is open with an app", ); assert.isUndefined(tools.sessionError(sample.shell, `${launcher} record start /tmp/r.mp4`)); const { devices = [], deviceHosts } = testCase.setup.world ?? {}; const unknown = { devices, deviceHosts, agentDeviceSessions: { "not-a-device": {} } }; const exit = yield* Effect.exit(makeDeviceTools(unknown, base.environment)); assert.isTrue(exit._tag === "Failure"); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it.effect( "answers a shell mock first, then help, then the session error, before the simulator", () => Effect.gen(function* () { const sample = makeSample(deviceCase({}), base); yield* withDevices(sample); const opened = yield* sample.devices!.call("device_open", { hostId: MAC, deviceId: IPHONE }); const { command, targetArgs, session } = json(opened.text).agentDevice; const flags = session === undefined ? ` ${targetArgs.join(" ")}` : ""; const told = () => JSON.stringify( shellRequest(sample, { tool: "Bash", input: {} }, "claude-haiku-5-5").messages, ); assert.include(told(), "has not started"); assert.include(cannedOutput(sample, `${command} screenshot /tmp/a.png${flags}`), NO_SESSION); assert.match(cannedOutput(sample, `${command} help record`) ?? "", /^Usage:/); assert.isUndefined(cannedOutput(sample, `${command} open com.acme.app${flags}`)); const outage = makeSample( deviceCase({ shellMocks: [ { match: "\\bagent-device\\b", output: "Exit code 1\nError (COMMAND_FAILED): down" }, ], }), base, ); yield* withDevices(outage); yield* outage.devices!.call("device_open", { hostId: MAC, deviceId: IPHONE }); assert.include(cannedOutput(outage, `${command} screenshot /tmp/a.png${flags}`), "down"); sample.shell.push({ tool: "Bash", input: { command: `${command} open com.acme.app${flags}` }, output: "Opened: com.acme.app", }); assert.isUndefined(cannedOutput(sample, `${command} screenshot /tmp/a.png${flags}`)); assert.include(told(), "is open with an app"); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it("keeps a redirection's descriptor out of the app an open names, on either launcher", () => { // Sol R10 B1: `open 2>&1` once read as `open 2`, an app the real shell never passes. const flags = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/x.json --session t3-a`; for (const [target, args] of [ [shared("t3-a"), ` ${flags}`], [boundTarget, ""], ] as const) { for (const redirect of ["2>&1", "2>&1 | tail -5", "2>/dev/null"]) { const opened = [ bash(`${target.command} open${args} ${redirect}`, `Opened: ${target.session}`), ]; assert.deepEqual( agentDeviceSessions([target], {}, opened).get(target.session), { app: false }, redirect, ); assert.equal( errorCode([target], opened, `${target.command} record start /tmp/run.mp4${args}`), "UNKNOWN", redirect, ); } } }); it("follows opens the parser cannot prove ran, in calls that did not fail", () => { // Opus R10 B1(b): shapes from run 5, where `&&` before `;` leaves an open uncertain. const launcher = boundTarget.command; const after = (command: string, output = "Opened: com.acme.app") => agentDeviceSessions([boundTarget], {}, [bash(command, output)]).get("t3-bound"); assert.deepEqual( after(`mkdir -p /tmp/p && ${launcher} open com.acme.app 2>&1 | tail -3; echo done`), { app: true }, ); assert.deepEqual(after(`cd /tmp && ${launcher} open com.acme.app; ${launcher} snapshot -i`), { app: true, }); // The launcher alias such a call sets, too, here and in later calls. assert.deepEqual(after(`mkdir -p /tmp/p && AD=${launcher}; $AD open com.acme.app`), { app: true, }); assert.deepEqual(after(`mkdir -p /tmp/p && AD="${launcher}"; "\${AD}" open com.acme.app`), { app: true, }); assert.deepEqual( agentDeviceSessions([boundTarget], {}, [ bash(`cd /tmp && AD=${launcher}; echo ready`), bash("$AD open com.acme.app"), ]).get("t3-bound"), { app: true }, ); // A failed call credits only what certainly ran. assert.isUndefined( after(`mkdir -p /tmp/p && ${launcher} open com.acme.app; echo done`, "Exit code 1\nno"), ); assert.isUndefined( after(`mkdir -p /tmp/p && AD=${launcher}; $AD open com.acme.app`, "Exit code 1\nno"), ); }); const SPARE_MAC = "cccccccc-cccc-4ccc-8ccc-cccccccccccc"; const SPARE_PHONE = "DDDDDDDD-DDDD-4DDD-8DDD-DDDDDDDDDDDD"; const twoMacs = { devices: [ ...world.devices, { ...world.devices[0]!, hostId: SPARE_MAC, id: SPARE_PHONE, name: "Acme Spare iPhone" }, ], deviceHosts: { ...world.deviceHosts, [SPARE_MAC]: "spare-mac" }, }; const deviceTools = (extra: object) => makeDeviceTools( { ...twoMacs, ...extra } as Parameters<typeof makeDeviceTools>[0], base.environment, ); it.effect("lists a host whose discovery fails as T3 does: failed, with none of its devices", () => Effect.gen(function* () { // F1's saved device_list: the hub answered, but its device list timed out. const failure = new DeviceOperationError({ operation: "list", reason: "request_failed", cause: null, }); const tools = yield* deviceTools({ deviceDiscoveryFailures: { [MAC]: failure } }); const listed = json((yield* tools.call("device_list", {})).text); assert.deepEqual(listed.hostStatuses[MAC], { status: "failed", detail: "Device list failed: Could not communicate with device support. Try refreshing devices.", }); assert.equal(listed.hostStatuses[SPARE_MAC].status, "ready"); assert.deepEqual( listed.devices.map((device: { id: string }) => device.id), [SPARE_PHONE], ); const opened = yield* tools.call("device_open", { hostId: MAC, deviceId: IPHONE }); assert.isTrue(opened.isError); assert.include(opened.text, IPHONE); assert.isFalse( (yield* tools.call("device_open", { hostId: SPARE_MAC, deviceId: SPARE_PHONE })).isError, ); // A failed host with no devices of its own still needs its label. const unlabeled = yield* Effect.exit( deviceTools({ deviceDiscoveryFailures: { "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee": failure } }), ); assert.isTrue(unlabeled._tag === "Failure"); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it.effect("denies every device tool with T3's own error when agent device access is off", () => Effect.gen(function* () { const tools = yield* deviceTools({ deviceAgentAccess: false }); for (const [name, input] of [ ["device_list", {}], ["device_open", { hostId: MAC, deviceId: IPHONE }], ["device_screenshot", {}], ["device_close", {}], ] as const) { const result = yield* tools.call(name, input); assert.isTrue(result.isError, name); // Refs before typed screenshot errors print their generic screenshot failure instead, and // later refs may add how to turn access on. const denied = result.text.startsWith( "Agent device access is turned off for this environment.", ); assert.isTrue( denied || (name === "device_screenshot" && result.text === "Device screenshot failed."), `${name}: ${result.text}`, ); } // T3 drops its device text for a thread without the capability, on refs that have it. assert.notInclude(t3SystemAppend(model, false), "## T3 Code devices"); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it.effect("reports an unreadable capture as T3 does: a successful 0×0 screenshot", () => Effect.gen(function* () { const tools = yield* deviceTools({ deviceInvalidCapture: true }); yield* tools.call("device_open", { hostId: MAC, deviceId: IPHONE }); const shot = yield* tools.call("device_screenshot", {}); assert.isFalse(shot.isError); assert.deepEqual(json(shot.text).screenshot, { mimeType: "image/png", width: 0, height: 0 }); const sample = makeSample( deviceCase({ world: { ...world, deviceInvalidCapture: true } }), base, ); yield* withDevices(sample); const told = JSON.stringify(shellRequest(sample, { tool: "Bash", input: {} }, model).messages); assert.include(told, "agent-device's own screenshot finds the PNG and is unaffected"); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it.effect("refuses an open on a device another thread's agent-device session holds", () => Effect.gen(function* () { const tools = yield* deviceTools({ deviceOwners: { [IPHONE]: "acme-design-review" } }); // T3 names the owner's session as it names every thread's. const owner = "t3-a062c547ef0b6bf8ee839b67"; assert.deepEqual(tools.owners, [ { deviceId: IPHONE, threadId: "acme-design-review", session: owner }, ]); // T3 has no cross-thread gate: device_open succeeds, and device_list shows only this thread. const opened = json((yield* tools.call("device_open", { hostId: MAC, deviceId: IPHONE })).text); assert.deepEqual(json((yield* tools.call("device_list", {})).text).open, [ { hostId: MAC, deviceId: IPHONE }, ]); const { command, targetArgs, session: bound } = opened.agentDevice; const own: string = bound ?? targetArgs[targetArgs.indexOf("--session") + 1]; const target = (session = own) => bound === undefined ? targetArgs.map((arg: string) => (arg === own ? session : arg)).join(" ") : session === own ? "" : `--session ${session}`; const line = (args: string, session?: string) => `${command} ${args} ${target(session)}`.trim(); const history: Array<ShellCall> = []; const answer = (args: string, session?: string) => tools.sessionError(history, line(args, session)) ?? ""; const inUse = `Error (DEVICE_IN_USE): Device is already in use by session "${owner}".\nHint: Run agent-device session list to inspect active sessions. To reuse this device, rerun the command with --session ${owner}. To open a new session on this device, first run agent-device close --session ${owner}.`; assert.include( answer("open com.acme.app"), `${inUse} To wait for the device to free up, run the same open with --wait <ms>.\nDiagnostic ID: `, ); assert.include( answer("open --wait 5000"), `Error (DEVICE_IN_USE): Device is already in use by session "${owner}".\nHint: Waited 5000ms for this device and it stayed busy. Run agent-device session list`, ); assert.notInclude(answer("open --wait 5000"), "--wait <ms>"); // The hint's reuse works, in the other thread's session. assert.equal(answer("screenshot /tmp/a.png", owner), ""); assert.equal(answer("open com.acme.app", owner), ""); // A failed open starts nothing, in a compound call too. history.push({ tool: "Bash", input: { command: `${line("open com.acme.app")} && ${line("screenshot /tmp/a.png")}` }, output: "Exit code 1\nError (DEVICE_IN_USE): Device is already in use", }); assert.deepEqual( [...tools.sessions(history)], [ [own, undefined], [owner, { app: true }], ], ); const sample = makeSample( deviceCase({ world: { ...twoMacs, deviceOwners: { [IPHONE]: "acme-design-review" } } }), base, ); yield* withDevices(sample); const told = JSON.stringify(shellRequest(sample, { tool: "Bash", input: {} }, model).messages); assert.include( told, `${owner} (Acme iPhone, ${IPHONE}, on build-mac) belongs to another T3 thread (acme-design-review)`, ); // Closing the owner's session frees the device. history.push({ tool: "Bash", input: { command: line("close", owner) }, output: "Closed" }); assert.equal(answer("open com.acme.app"), ""); assert.include(describeSessions(tools.sessions(history), tools.owners), "was closed"); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it.effect("leaves a free device free when another thread holds a different one", () => Effect.gen(function* () { const tools = yield* deviceTools({ deviceOwners: { [IPHONE]: "acme-design-review" } }); const opened = json( (yield* tools.call("device_open", { hostId: SPARE_MAC, deviceId: SPARE_PHONE })).text, ); const { command, targetArgs, session } = opened.agentDevice; const flags = session === undefined ? ` ${targetArgs.join(" ")}` : ""; assert.isUndefined(tools.sessionError([], `${command} open com.acme.app${flags}`)); assert.include( tools.sessionError([], `${command} screenshot /tmp/a.png${flags}`) ?? "", "SESSION_NOT_FOUND", ); // The local host always exists and holds none of the world's devices. assert.isFalse( (yield* tools.call("device_list", {})).text.includes(`"hostId":"${LOCAL_DEVICE_HOST_ID}"`), ); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); type Opened = { command: string; targetArgs: Array<string>; session?: string }; /** This ref's command line for a launcher: a bound one needs no flags; the shared one takes them. */ const commandLine = (opened: Opened, args: string, session?: string) => { const own = opened.session ?? opened.targetArgs[opened.targetArgs.indexOf("--session") + 1]; if (opened.session !== undefined) return `${opened.command} ${args}${session === undefined ? "" : ` --session ${session}`}`; const flags = opened.targetArgs.map((arg) => (arg === own && session ? session : arg)); return `${opened.command} ${args} ${flags.join(" ")}`; }; it.effect( "tells the simulator each launcher's device, and routes DEVICE_IN_USE to the held one", () => Effect.gen(function* () { // Opus R11-B3(a): in run 6 the simulator gave the free spare's plain open the owner's // DEVICE_IN_USE twice. It could not tell which device a flagless bound launcher drives. const owner = "t3-a062c547ef0b6bf8ee839b67"; const sample = makeSample( deviceCase({ world: { ...twoMacs, deviceOwners: { [IPHONE]: "acme-design-review" } } }), base, ); yield* withDevices(sample); const tools = sample.devices!; const open = (hostId: string, deviceId: string) => Effect.map( tools.call("device_open", { hostId, deviceId }), (result): Opened => json(result.text).agentDevice, ); const held = yield* open(MAC, IPHONE); const spare = yield* open(SPARE_MAC, SPARE_PHONE); const session = (opened: Opened) => opened.session ?? opened.targetArgs[opened.targetArgs.indexOf("--session") + 1]; const told = (command: string) => String( shellRequest(sample, { tool: "Bash", input: { command } }, model).messages[0]?.content[0] ?.text, ); // Run 6's history: the held device's plain open, refused without the simulator. const heldOpen = commandLine(held, "open com.acme.app --metro-port 8095"); const refused = cannedOutput(sample, heldOpen) ?? ""; assert.include( refused, `Error (DEVICE_IN_USE): Device is already in use by session "${owner}".`, ); sample.shell.push({ tool: "Bash", input: { command: heldOpen }, output: refused }); // The spare's plain open goes to the simulator, which now knows it drives the free spare. const spareOpen = commandLine(spare, "open com.acme.app --metro-port 8095"); assert.isUndefined(cannedOutput(sample, spareOpen)); const free = told(spareOpen); assert.include( free, `agent-device launchers T3's device_open returned: ${ held.session === undefined ? `${held.command} (shared: each command's --udid or --serial and --session name its device and session)` : `${held.command} (drives Acme iPhone, ${IPHONE}, on build-mac, in session ${held.session}); ${spare.command} (drives Acme Spare iPhone, ${SPARE_PHONE}, on spare-mac, in session ${spare.session})` }`, ); assert.include( free, `${session(held)} (Acme iPhone, ${IPHONE}, on build-mac) has not started; ${session(spare)} (Acme Spare iPhone, ${SPARE_PHONE}, on spare-mac) has not started; ${owner} (Acme iPhone, ${IPHONE}, on build-mac) belongs to another T3 thread (acme-design-review) and holds its device with an app open.`, ); assert.include( free, `In the new call, \`${spareOpen}\` drives Acme Spare iPhone, ${SPARE_PHONE}, on spare-mac, which no other session holds: it prints no DEVICE_IN_USE.`, ); assert.notInclude(free, "Error (DEVICE_IN_USE)"); // A compound open of the held device gets agent-device's exact refusal, for that open only. const piped = commandLine(held, "open com.acme.app"); const refusal = told(`${piped} 2>&1 | tail -5`); assert.include( refusal, `In the new call, \`${piped}\` drives Acme iPhone, ${IPHONE}, on build-mac, which session ${owner} holds: it fails with exit code 1, printing "Error (DEVICE_IN_USE): Device is already in use by session "${owner}"." and "Hint: Run agent-device session list to inspect active sessions. To reuse this device,`, ); assert.notInclude(refusal, "no other session holds"); // One call may try the held device, then fall back to the spare through an alias. const alias = spare.session === undefined ? `A=${spare.command}; "$A" open com.acme.app ${spare.targetArgs.join(" ")}` : `A=${spare.command}; "$A" open com.acme.app`; const both = told(`${piped} || echo busy; ${alias}`); assert.include(both, `which session ${owner} holds: it fails with exit code 1`); assert.include( both, `on spare-mac, which no other session holds: it prints no DEVICE_IN_USE`, ); // An open in the other thread's own session is not refused, and gets no route. assert.notInclude(told(commandLine(held, "open com.acme.app", owner)), "In the new call"); // An open after the same call closes the other thread's session finds the device free. const reopen = told(`${commandLine(held, "close", owner)}; ${piped}`); assert.include( reopen, `\`${piped}\` drives Acme iPhone, ${IPHONE}, on build-mac, which no other session holds: it prints no DEVICE_IN_USE`, ); assert.notInclude(reopen, `which session ${owner} holds`); // Neither do commands other than open. assert.notInclude( told(`${commandLine(spare, "screenshot /tmp/a.png")} && echo ok`), "In the new call", ); // A world where no other thread holds a device gets no route either. const alone = makeSample(deviceCase({}), base); yield* withDevices(alone); const own: Opened = json( (yield* alone.devices!.call("device_open", { hostId: MAC, deviceId: IPHONE })).text, ).agentDevice; const request = shellRequest( alone, { tool: "Bash", input: { command: `${commandLine(own, "open com.acme.app")} | tail -3` } }, model, ); assert.notInclude(JSON.stringify(request.messages), "In the new call"); assert.include( JSON.stringify(request.messages), `${session(own)} (Acme iPhone, ${IPHONE}, on build-mac) has not started`, ); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); it("tells the simulator 0.21.31's --foreground and session list behaviour", () => { // Opus R11-B3(b): 0.21.31 (session2.js ys) refuses only an open --foreground with no app or URL. // Run 6's simulator refused `open <app> --foreground` in 9 base samples. assert.include( AGENT_DEVICE_SHELL, "open --foreground with no app or URL fails with exit code 1 when the command passes --udid or --device", ); assert.include(AGENT_DEVICE_SHELL, "open <app> --foreground works."); // Run 6's simulator answered the DEVICE_IN_USE hint's `session list` with "Unknown command". assert.include( AGENT_DEVICE_SHELL, "session list prints, as JSON, the started sessions on the launcher's host, other threads' too", ); // Neither is refused without the simulator. for (const args of ["open com.acme.app --foreground", "session list"]) { assert.isUndefined( agentDeviceSessionError( [boundTarget], new Map([["t3-bound", undefined]]), `${boundTarget.command} ${args}`, ), args, ); } });
evals/mcp-tool-use/devices.test.ts at main · sailfork/t3code-github · Sailfork
,\n ),\n );\n for (const args of [\"press @e3 --settle\", 'fill @e5 \"hello world\"', \"scroll down\", \"home\"]) {\n assert.include(answer(args), NO_SESSION, args);\n }\n assert.include(answer(\"record start /tmp/run.mp4\"), APP_RECORDING_BEFORE_OPEN);\n // An iOS snapshot needs an app open in the session.\n assert.include(answer(\"snapshot -i\"), iosSnapshotRefused(\"sim\"));\n // With the device selector both refs pass, these run without a session.\n for (const args of [\n \"open\",\n \"devices\",\n \"apps\",\n \"settings appearance dark\",\n \"alert accept\",\n \"install com.acme.app /tmp/Acme.app\",\n \"record start --scope device /tmp/run.mp4\",\n ]) {\n assert.isUndefined(answer(args), args);\n }\n // Unknown flags, JSON output and compound commands stay with the simulator.\n assert.isUndefined(answer(\"screenshot --bogus /tmp/shot.png\"));\n assert.isUndefined(answer(\"screenshot --json /tmp/shot.png\"));\n assert.isUndefined(tools.sessionError(history, `${line(\"screenshot /tmp/a.png\")} && echo ok`));\n assert.deepEqual([...tools.sessions(history)], [[session, undefined]]);\n\n ran(\"open com.acme.missing\", \"Exit code 1\\nError (APP_NOT_INSTALLED): App not installed\");\n assert.include(answer(\"screenshot /tmp/shot.png\"), NO_SESSION);\n ran(\"open\", `Opened: ${session}`);\n assert.isUndefined(answer(\"screenshot /tmp/shot.png\"));\n assert.isUndefined(answer(\"press @e3\"));\n assert.include(answer(\"record start /tmp/run.mp4\"), APP_RECORDING_WITHOUT_APP);\n assert.isUndefined(answer(\"record start --scope device /tmp/run.mp4\"));\n assert.include(answer(\"snapshot -i\"), iosSnapshotRefused(session));\n ran(\"open com.acme.app\", \"Opened: com.acme.app\");\n assert.isUndefined(answer(\"record start /tmp/run.mp4\"));\n assert.isUndefined(answer(\"snapshot -i\"));\n assert.deepEqual([...tools.sessions(history)], [[session, { app: true }]]);\n ran(\"close\", \"Closed\");\n assert.include(\n tools.sessionError(history, `${line(\"screenshot /tmp/a.png\")} 2>&1`),\n NO_SESSION,\n );\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nconst shared = (session: string): LauncherTarget => ({\n command: \"/home/user/.t3/userdata/device/bin/agent-device\",\n session,\n bound: false,\n deviceId: IPHONE,\n ios: true,\n iosSimulator: true,\n});\nconst boundTarget: LauncherTarget = {\n command: \"/home/user/.t3/userdata/device/targets/t3-bound/agent-device\",\n session: \"t3-bound\",\n bound: true,\n deviceId: IPHONE,\n ios: true,\n iosSimulator: true,\n};\nconst bash = (command: string, output = \"OK\"): ShellCall => ({\n tool: \"Bash\",\n input: { command },\n output,\n});\nconst errorCode = (\n targets: ReadonlyArray\u003cLauncherTarget>,\n history: ReadonlyArray\u003cShellCall>,\n command: string,\n) => agentDeviceSessionError(targets, agentDeviceSessions(targets, {}, history), command)?.code;\n\nit(\"names the session on either ref: the bound launcher's own, or the shared one's --session\", () => {\n const flags = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/x.json`;\n const sharedTargets = [shared(\"t3-a\"), shared(\"t3-b\")];\n // The shared launcher answers each session its flags name; without one, its own check (not\n // modelled) refuses before agent-device runs.\n const opened = [bash(`${sharedTargets[0]!.command} open com.acme.app ${flags} --session t3-a`)];\n assert.isUndefined(\n errorCode(\n sharedTargets,\n opened,\n `${sharedTargets[0]!.command} screenshot ${flags} --session t3-a`,\n ),\n );\n assert.equal(\n errorCode(\n sharedTargets,\n opened,\n `${sharedTargets[0]!.command} screenshot ${flags} --session=t3-b`,\n ),\n \"SESSION_NOT_FOUND\",\n );\n assert.isUndefined(errorCode(sharedTargets, [], `${sharedTargets[0]!.command} screenshot`));\n // The bound launcher needs no flags, and an explicit --session still wins.\n assert.equal(\n errorCode([boundTarget], [], `${boundTarget.command} screenshot`),\n \"SESSION_NOT_FOUND\",\n );\n assert.equal(errorCode([boundTarget], [], `${boundTarget.command} record start`), \"INVALID_ARGS\");\n const boundOpen = [bash(`${boundTarget.command} open`)];\n assert.isUndefined(errorCode([boundTarget], boundOpen, `${boundTarget.command} screenshot`));\n assert.equal(\n errorCode([boundTarget], boundOpen, `${boundTarget.command} record start /tmp/r.mp4`),\n \"UNKNOWN\",\n );\n assert.equal(\n errorCode([boundTarget], boundOpen, `${boundTarget.command} screenshot --session other`),\n \"SESSION_NOT_FOUND\",\n );\n // Without a selector, agent-device's record and close refuse a missing named session with\n // other text; that stays with the simulator.\n assert.isUndefined(\n errorCode(sharedTargets, [], `${sharedTargets[0]!.command} record start --session t3-a`),\n );\n});\n\nit(\"follows the session through aliases, compound calls, snapshots and whole-screen recordings\", () => {\n const launcher = boundTarget.command;\n const after = (...history: ReadonlyArray\u003cShellCall>) =>\n agentDeviceSessions([boundTarget], {}, history).get(\"t3-bound\");\n assert.deepEqual(after(bash(`AD=${launcher}; \"$AD\" open com.acme.app`)), { app: true });\n // A failed lone open starts nothing; an open in a failed compound call still counts.\n assert.isUndefined(after(bash(`${launcher} open com.acme.app`, \"Exit code 1\\nError (X): no\")));\n assert.deepEqual(\n after(bash(`${launcher} open com.acme.app && ${launcher} press @e9`, \"Exit code 1\\nboom\")),\n { app: true },\n );\n // Dead tails, remote agent-device and help start nothing.\n assert.isUndefined(after(bash(`false && ${launcher} open`, \"Exit code 1\")));\n assert.isUndefined(after(bash(\"ssh build-mac agent-device open com.acme.app\")));\n assert.isUndefined(after(bash(`${launcher} help open`)));\n // agent-device publishes a session for a sessionless Android snapshot, without an app. An iOS\n // snapshot without an app fails and starts nothing.\n assert.isUndefined(after(bash(`${launcher} snapshot -i`)));\n const android = { ...boundTarget, ios: false, iosSimulator: false };\n assert.deepEqual(\n agentDeviceSessions([android], {}, [bash(`${launcher} snapshot -i`)]).get(\"t3-bound\"),\n { app: false },\n );\n // A whole-screen recording holds a session only until it stops.\n const recording = bash(`${launcher} record start --scope device /tmp/r.mp4`);\n assert.deepEqual(after(recording), { app: false, recordingOnly: true });\n assert.isUndefined(errorCode([boundTarget], [recording], `${launcher} screenshot`));\n assert.isUndefined(after(recording, bash(`${launcher} record stop`)));\n assert.equal(\n errorCode(\n [boundTarget],\n [recording, bash(`${launcher} record stop`)],\n `${launcher} screenshot`,\n ),\n \"SESSION_NOT_FOUND\",\n );\n assert.deepEqual(after(bash(`${launcher} open`), bash(`${launcher} close`)), undefined);\n});\n\nit(\"follows the shared launcher's session through flags held in a variable or an array\", () => {\n // Forms Sonnet used with the shared launcher in a live sample.\n const target = shared(\"t3-a\");\n const flags = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/x.json --session t3-a`;\n const after = (history: ShellCall, targets = [target]) =>\n agentDeviceSessions(targets, {}, [history]).get(\"t3-a\");\n const opened = bash(\n `AD=${target.command}; A=\"${flags}\"; $AD open com.acme.app $A 2>&1 | tail -5; sleep 5; $AD snapshot -i $A 2>&1 | head -60`,\n \"Opened: com.acme.app\",\n );\n assert.deepEqual(after(opened), { app: true });\n const array = bash(`A=(${flags}); ${target.command} open \"\\${A[@]}\" 2>&1 | head -60`);\n assert.deepEqual(after(array), { app: false });\n // With two sessions behind the shared launcher, unread flags name neither.\n assert.isUndefined(after(array, [target, shared(\"t3-b\")]));\n // agent-device still sees no session for a plain command after a failed open in a variable.\n const failed = bash(\n `AD=${target.command}; A=\"${flags}\"; $AD open $A`,\n \"Exit code 1\\nError (X): no\",\n );\n assert.equal(\n errorCode([target], [failed], `${target.command} screenshot ${flags}`),\n \"SESSION_NOT_FOUND\",\n );\n});\n\nit.effect(\"starts sessions the world says prior turns opened, and rejects unknown devices\", () =>\n Effect.gen(function* () {\n const testCase = deviceCase({\n world: { ...world, agentDeviceSessions: { [IPHONE]: { app: \"com.acme.app\" } } },\n priorTurns: [\n { role: \"user\", text: \"Show me Settings on the iPhone on build-mac.\" },\n {\n role: \"assistant\",\n toolCalls: [\n { tool: \"device_open\", input: { hostId: MAC, deviceId: IPHONE }, result: \"default\" },\n ],\n },\n ],\n });\n const sample = makeSample(testCase, base);\n yield* withDevices(sample);\n const tools = sample.devices!;\n const [launcher = \"\"] = tools.launchers;\n assert.deepEqual([...tools.sessions(sample.shell).values()], [{ app: true }]);\n const call = { tool: \"Bash\", input: { command: \"ls\" } };\n assert.include(\n JSON.stringify(shellRequest(sample, call, \"claude-haiku-5-5\").messages),\n \"is open with an app\",\n );\n assert.isUndefined(tools.sessionError(sample.shell, `${launcher} record start /tmp/r.mp4`));\n const { devices = [], deviceHosts } = testCase.setup.world ?? {};\n const unknown = { devices, deviceHosts, agentDeviceSessions: { \"not-a-device\": {} } };\n const exit = yield* Effect.exit(makeDeviceTools(unknown, base.environment));\n assert.isTrue(exit._tag === \"Failure\");\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit.effect(\n \"answers a shell mock first, then help, then the session error, before the simulator\",\n () =>\n Effect.gen(function* () {\n const sample = makeSample(deviceCase({}), base);\n yield* withDevices(sample);\n const opened = yield* sample.devices!.call(\"device_open\", { hostId: MAC, deviceId: IPHONE });\n const { command, targetArgs, session } = json(opened.text).agentDevice;\n const flags = session === undefined ? ` ${targetArgs.join(\" \")}` : \"\";\n const told = () =>\n JSON.stringify(\n shellRequest(sample, { tool: \"Bash\", input: {} }, \"claude-haiku-5-5\").messages,\n );\n assert.include(told(), \"has not started\");\n assert.include(cannedOutput(sample, `${command} screenshot /tmp/a.png${flags}`), NO_SESSION);\n assert.match(cannedOutput(sample, `${command} help record`) ?? \"\", /^Usage:/);\n assert.isUndefined(cannedOutput(sample, `${command} open com.acme.app${flags}`));\n const outage = makeSample(\n deviceCase({\n shellMocks: [\n { match: \"\\\\bagent-device\\\\b\", output: \"Exit code 1\\nError (COMMAND_FAILED): down\" },\n ],\n }),\n base,\n );\n yield* withDevices(outage);\n yield* outage.devices!.call(\"device_open\", { hostId: MAC, deviceId: IPHONE });\n assert.include(cannedOutput(outage, `${command} screenshot /tmp/a.png${flags}`), \"down\");\n sample.shell.push({\n tool: \"Bash\",\n input: { command: `${command} open com.acme.app${flags}` },\n output: \"Opened: com.acme.app\",\n });\n assert.isUndefined(cannedOutput(sample, `${command} screenshot /tmp/a.png${flags}`));\n assert.include(told(), \"is open with an app\");\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit(\"keeps a redirection's descriptor out of the app an open names, on either launcher\", () => {\n // Sol R10 B1: `open 2>&1` once read as `open 2`, an app the real shell never passes.\n const flags = `--platform ios --udid ${IPHONE} --config /home/user/.t3/userdata/device/hosts/x.json --session t3-a`;\n for (const [target, args] of [\n [shared(\"t3-a\"), ` ${flags}`],\n [boundTarget, \"\"],\n ] as const) {\n for (const redirect of [\"2>&1\", \"2>&1 | tail -5\", \"2>/dev/null\"]) {\n const opened = [\n bash(`${target.command} open${args} ${redirect}`, `Opened: ${target.session}`),\n ];\n assert.deepEqual(\n agentDeviceSessions([target], {}, opened).get(target.session),\n { app: false },\n redirect,\n );\n assert.equal(\n errorCode([target], opened, `${target.command} record start /tmp/run.mp4${args}`),\n \"UNKNOWN\",\n redirect,\n );\n }\n }\n});\n\nit(\"follows opens the parser cannot prove ran, in calls that did not fail\", () => {\n // Opus R10 B1(b): shapes from run 5, where `&&` before `;` leaves an open uncertain.\n const launcher = boundTarget.command;\n const after = (command: string, output = \"Opened: com.acme.app\") =>\n agentDeviceSessions([boundTarget], {}, [bash(command, output)]).get(\"t3-bound\");\n assert.deepEqual(\n after(`mkdir -p /tmp/p && ${launcher} open com.acme.app 2>&1 | tail -3; echo done`),\n { app: true },\n );\n assert.deepEqual(after(`cd /tmp && ${launcher} open com.acme.app; ${launcher} snapshot -i`), {\n app: true,\n });\n // The launcher alias such a call sets, too, here and in later calls.\n assert.deepEqual(after(`mkdir -p /tmp/p && AD=${launcher}; $AD open com.acme.app`), {\n app: true,\n });\n assert.deepEqual(after(`mkdir -p /tmp/p && AD=\"${launcher}\"; \"\\${AD}\" open com.acme.app`), {\n app: true,\n });\n assert.deepEqual(\n agentDeviceSessions([boundTarget], {}, [\n bash(`cd /tmp && AD=${launcher}; echo ready`),\n bash(\"$AD open com.acme.app\"),\n ]).get(\"t3-bound\"),\n { app: true },\n );\n // A failed call credits only what certainly ran.\n assert.isUndefined(\n after(`mkdir -p /tmp/p && ${launcher} open com.acme.app; echo done`, \"Exit code 1\\nno\"),\n );\n assert.isUndefined(\n after(`mkdir -p /tmp/p && AD=${launcher}; $AD open com.acme.app`, \"Exit code 1\\nno\"),\n );\n});\n\nconst SPARE_MAC = \"cccccccc-cccc-4ccc-8ccc-cccccccccccc\";\nconst SPARE_PHONE = \"DDDDDDDD-DDDD-4DDD-8DDD-DDDDDDDDDDDD\";\nconst twoMacs = {\n devices: [\n ...world.devices,\n { ...world.devices[0]!, hostId: SPARE_MAC, id: SPARE_PHONE, name: \"Acme Spare iPhone\" },\n ],\n deviceHosts: { ...world.deviceHosts, [SPARE_MAC]: \"spare-mac\" },\n};\nconst deviceTools = (extra: object) =>\n makeDeviceTools(\n { ...twoMacs, ...extra } as Parameters\u003ctypeof makeDeviceTools>[0],\n base.environment,\n );\n\nit.effect(\"lists a host whose discovery fails as T3 does: failed, with none of its devices\", () =>\n Effect.gen(function* () {\n // F1's saved device_list: the hub answered, but its device list timed out.\n const failure = new DeviceOperationError({\n operation: \"list\",\n reason: \"request_failed\",\n cause: null,\n });\n const tools = yield* deviceTools({ deviceDiscoveryFailures: { [MAC]: failure } });\n const listed = json((yield* tools.call(\"device_list\", {})).text);\n assert.deepEqual(listed.hostStatuses[MAC], {\n status: \"failed\",\n detail:\n \"Device list failed: Could not communicate with device support. Try refreshing devices.\",\n });\n assert.equal(listed.hostStatuses[SPARE_MAC].status, \"ready\");\n assert.deepEqual(\n listed.devices.map((device: { id: string }) => device.id),\n [SPARE_PHONE],\n );\n const opened = yield* tools.call(\"device_open\", { hostId: MAC, deviceId: IPHONE });\n assert.isTrue(opened.isError);\n assert.include(opened.text, IPHONE);\n assert.isFalse(\n (yield* tools.call(\"device_open\", { hostId: SPARE_MAC, deviceId: SPARE_PHONE })).isError,\n );\n // A failed host with no devices of its own still needs its label.\n const unlabeled = yield* Effect.exit(\n deviceTools({ deviceDiscoveryFailures: { \"eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee\": failure } }),\n );\n assert.isTrue(unlabeled._tag === \"Failure\");\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit.effect(\"denies every device tool with T3's own error when agent device access is off\", () =>\n Effect.gen(function* () {\n const tools = yield* deviceTools({ deviceAgentAccess: false });\n for (const [name, input] of [\n [\"device_list\", {}],\n [\"device_open\", { hostId: MAC, deviceId: IPHONE }],\n [\"device_screenshot\", {}],\n [\"device_close\", {}],\n ] as const) {\n const result = yield* tools.call(name, input);\n assert.isTrue(result.isError, name);\n // Refs before typed screenshot errors print their generic screenshot failure instead, and\n // later refs may add how to turn access on.\n const denied = result.text.startsWith(\n \"Agent device access is turned off for this environment.\",\n );\n assert.isTrue(\n denied || (name === \"device_screenshot\" && result.text === \"Device screenshot failed.\"),\n `${name}: ${result.text}`,\n );\n }\n // T3 drops its device text for a thread without the capability, on refs that have it.\n assert.notInclude(t3SystemAppend(model, false), \"## T3 Code devices\");\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit.effect(\"reports an unreadable capture as T3 does: a successful 0×0 screenshot\", () =>\n Effect.gen(function* () {\n const tools = yield* deviceTools({ deviceInvalidCapture: true });\n yield* tools.call(\"device_open\", { hostId: MAC, deviceId: IPHONE });\n const shot = yield* tools.call(\"device_screenshot\", {});\n assert.isFalse(shot.isError);\n assert.deepEqual(json(shot.text).screenshot, { mimeType: \"image/png\", width: 0, height: 0 });\n const sample = makeSample(\n deviceCase({ world: { ...world, deviceInvalidCapture: true } }),\n base,\n );\n yield* withDevices(sample);\n const told = JSON.stringify(shellRequest(sample, { tool: \"Bash\", input: {} }, model).messages);\n assert.include(told, \"agent-device's own screenshot finds the PNG and is unaffected\");\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit.effect(\"refuses an open on a device another thread's agent-device session holds\", () =>\n Effect.gen(function* () {\n const tools = yield* deviceTools({ deviceOwners: { [IPHONE]: \"acme-design-review\" } });\n // T3 names the owner's session as it names every thread's.\n const owner = \"t3-a062c547ef0b6bf8ee839b67\";\n assert.deepEqual(tools.owners, [\n { deviceId: IPHONE, threadId: \"acme-design-review\", session: owner },\n ]);\n // T3 has no cross-thread gate: device_open succeeds, and device_list shows only this thread.\n const opened = json((yield* tools.call(\"device_open\", { hostId: MAC, deviceId: IPHONE })).text);\n assert.deepEqual(json((yield* tools.call(\"device_list\", {})).text).open, [\n { hostId: MAC, deviceId: IPHONE },\n ]);\n const { command, targetArgs, session: bound } = opened.agentDevice;\n const own: string = bound ?? targetArgs[targetArgs.indexOf(\"--session\") + 1];\n const target = (session = own) =>\n bound === undefined\n ? targetArgs.map((arg: string) => (arg === own ? session : arg)).join(\" \")\n : session === own\n ? \"\"\n : `--session ${session}`;\n const line = (args: string, session?: string) => `${command} ${args} ${target(session)}`.trim();\n const history: Array\u003cShellCall> = [];\n const answer = (args: string, session?: string) =>\n tools.sessionError(history, line(args, session)) ?? \"\";\n const inUse = `Error (DEVICE_IN_USE): Device is already in use by session \"${owner}\".\\nHint: Run agent-device session list to inspect active sessions. To reuse this device, rerun the command with --session ${owner}. To open a new session on this device, first run agent-device close --session ${owner}.`;\n assert.include(\n answer(\"open com.acme.app\"),\n `${inUse} To wait for the device to free up, run the same open with --wait \u003cms>.\\nDiagnostic ID: `,\n );\n assert.include(\n answer(\"open --wait 5000\"),\n `Error (DEVICE_IN_USE): Device is already in use by session \"${owner}\".\\nHint: Waited 5000ms for this device and it stayed busy. Run agent-device session list`,\n );\n assert.notInclude(answer(\"open --wait 5000\"), \"--wait \u003cms>\");\n // The hint's reuse works, in the other thread's session.\n assert.equal(answer(\"screenshot /tmp/a.png\", owner), \"\");\n assert.equal(answer(\"open com.acme.app\", owner), \"\");\n // A failed open starts nothing, in a compound call too.\n history.push({\n tool: \"Bash\",\n input: { command: `${line(\"open com.acme.app\")} && ${line(\"screenshot /tmp/a.png\")}` },\n output: \"Exit code 1\\nError (DEVICE_IN_USE): Device is already in use\",\n });\n assert.deepEqual(\n [...tools.sessions(history)],\n [\n [own, undefined],\n [owner, { app: true }],\n ],\n );\n const sample = makeSample(\n deviceCase({ world: { ...twoMacs, deviceOwners: { [IPHONE]: \"acme-design-review\" } } }),\n base,\n );\n yield* withDevices(sample);\n const told = JSON.stringify(shellRequest(sample, { tool: \"Bash\", input: {} }, model).messages);\n assert.include(\n told,\n `${owner} (Acme iPhone, ${IPHONE}, on build-mac) belongs to another T3 thread (acme-design-review)`,\n );\n // Closing the owner's session frees the device.\n history.push({ tool: \"Bash\", input: { command: line(\"close\", owner) }, output: \"Closed\" });\n assert.equal(answer(\"open com.acme.app\"), \"\");\n assert.include(describeSessions(tools.sessions(history), tools.owners), \"was closed\");\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit.effect(\"leaves a free device free when another thread holds a different one\", () =>\n Effect.gen(function* () {\n const tools = yield* deviceTools({ deviceOwners: { [IPHONE]: \"acme-design-review\" } });\n const opened = json(\n (yield* tools.call(\"device_open\", { hostId: SPARE_MAC, deviceId: SPARE_PHONE })).text,\n );\n const { command, targetArgs, session } = opened.agentDevice;\n const flags = session === undefined ? ` ${targetArgs.join(\" \")}` : \"\";\n assert.isUndefined(tools.sessionError([], `${command} open com.acme.app${flags}`));\n assert.include(\n tools.sessionError([], `${command} screenshot /tmp/a.png${flags}`) ?? \"\",\n \"SESSION_NOT_FOUND\",\n );\n // The local host always exists and holds none of the world's devices.\n assert.isFalse(\n (yield* tools.call(\"device_list\", {})).text.includes(`\"hostId\":\"${LOCAL_DEVICE_HOST_ID}\"`),\n );\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\ntype Opened = { command: string; targetArgs: Array\u003cstring>; session?: string };\n/** This ref's command line for a launcher: a bound one needs no flags; the shared one takes them. */\nconst commandLine = (opened: Opened, args: string, session?: string) => {\n const own = opened.session ?? opened.targetArgs[opened.targetArgs.indexOf(\"--session\") + 1];\n if (opened.session !== undefined)\n return `${opened.command} ${args}${session === undefined ? \"\" : ` --session ${session}`}`;\n const flags = opened.targetArgs.map((arg) => (arg === own && session ? session : arg));\n return `${opened.command} ${args} ${flags.join(\" \")}`;\n};\n\nit.effect(\n \"tells the simulator each launcher's device, and routes DEVICE_IN_USE to the held one\",\n () =>\n Effect.gen(function* () {\n // Opus R11-B3(a): in run 6 the simulator gave the free spare's plain open the owner's\n // DEVICE_IN_USE twice. It could not tell which device a flagless bound launcher drives.\n const owner = \"t3-a062c547ef0b6bf8ee839b67\";\n const sample = makeSample(\n deviceCase({ world: { ...twoMacs, deviceOwners: { [IPHONE]: \"acme-design-review\" } } }),\n base,\n );\n yield* withDevices(sample);\n const tools = sample.devices!;\n const open = (hostId: string, deviceId: string) =>\n Effect.map(\n tools.call(\"device_open\", { hostId, deviceId }),\n (result): Opened => json(result.text).agentDevice,\n );\n const held = yield* open(MAC, IPHONE);\n const spare = yield* open(SPARE_MAC, SPARE_PHONE);\n const session = (opened: Opened) =>\n opened.session ?? opened.targetArgs[opened.targetArgs.indexOf(\"--session\") + 1];\n const told = (command: string) =>\n String(\n shellRequest(sample, { tool: \"Bash\", input: { command } }, model).messages[0]?.content[0]\n ?.text,\n );\n // Run 6's history: the held device's plain open, refused without the simulator.\n const heldOpen = commandLine(held, \"open com.acme.app --metro-port 8095\");\n const refused = cannedOutput(sample, heldOpen) ?? \"\";\n assert.include(\n refused,\n `Error (DEVICE_IN_USE): Device is already in use by session \"${owner}\".`,\n );\n sample.shell.push({ tool: \"Bash\", input: { command: heldOpen }, output: refused });\n\n // The spare's plain open goes to the simulator, which now knows it drives the free spare.\n const spareOpen = commandLine(spare, \"open com.acme.app --metro-port 8095\");\n assert.isUndefined(cannedOutput(sample, spareOpen));\n const free = told(spareOpen);\n assert.include(\n free,\n `agent-device launchers T3's device_open returned: ${\n held.session === undefined\n ? `${held.command} (shared: each command's --udid or --serial and --session name its device and session)`\n : `${held.command} (drives Acme iPhone, ${IPHONE}, on build-mac, in session ${held.session}); ${spare.command} (drives Acme Spare iPhone, ${SPARE_PHONE}, on spare-mac, in session ${spare.session})`\n }`,\n );\n assert.include(\n free,\n `${session(held)} (Acme iPhone, ${IPHONE}, on build-mac) has not started; ${session(spare)} (Acme Spare iPhone, ${SPARE_PHONE}, on spare-mac) has not started; ${owner} (Acme iPhone, ${IPHONE}, on build-mac) belongs to another T3 thread (acme-design-review) and holds its device with an app open.`,\n );\n assert.include(\n free,\n `In the new call, \\`${spareOpen}\\` drives Acme Spare iPhone, ${SPARE_PHONE}, on spare-mac, which no other session holds: it prints no DEVICE_IN_USE.`,\n );\n assert.notInclude(free, \"Error (DEVICE_IN_USE)\");\n\n // A compound open of the held device gets agent-device's exact refusal, for that open only.\n const piped = commandLine(held, \"open com.acme.app\");\n const refusal = told(`${piped} 2>&1 | tail -5`);\n assert.include(\n refusal,\n `In the new call, \\`${piped}\\` drives Acme iPhone, ${IPHONE}, on build-mac, which session ${owner} holds: it fails with exit code 1, printing \"Error (DEVICE_IN_USE): Device is already in use by session \"${owner}\".\" and \"Hint: Run agent-device session list to inspect active sessions. To reuse this device,`,\n );\n assert.notInclude(refusal, \"no other session holds\");\n // One call may try the held device, then fall back to the spare through an alias.\n const alias =\n spare.session === undefined\n ? `A=${spare.command}; \"$A\" open com.acme.app ${spare.targetArgs.join(\" \")}`\n : `A=${spare.command}; \"$A\" open com.acme.app`;\n const both = told(`${piped} || echo busy; ${alias}`);\n assert.include(both, `which session ${owner} holds: it fails with exit code 1`);\n assert.include(\n both,\n `on spare-mac, which no other session holds: it prints no DEVICE_IN_USE`,\n );\n // An open in the other thread's own session is not refused, and gets no route.\n assert.notInclude(told(commandLine(held, \"open com.acme.app\", owner)), \"In the new call\");\n // An open after the same call closes the other thread's session finds the device free.\n const reopen = told(`${commandLine(held, \"close\", owner)}; ${piped}`);\n assert.include(\n reopen,\n `\\`${piped}\\` drives Acme iPhone, ${IPHONE}, on build-mac, which no other session holds: it prints no DEVICE_IN_USE`,\n );\n assert.notInclude(reopen, `which session ${owner} holds`);\n // Neither do commands other than open.\n assert.notInclude(\n told(`${commandLine(spare, \"screenshot /tmp/a.png\")} && echo ok`),\n \"In the new call\",\n );\n\n // A world where no other thread holds a device gets no route either.\n const alone = makeSample(deviceCase({}), base);\n yield* withDevices(alone);\n const own: Opened = json(\n (yield* alone.devices!.call(\"device_open\", { hostId: MAC, deviceId: IPHONE })).text,\n ).agentDevice;\n const request = shellRequest(\n alone,\n { tool: \"Bash\", input: { command: `${commandLine(own, \"open com.acme.app\")} | tail -3` } },\n model,\n );\n assert.notInclude(JSON.stringify(request.messages), \"In the new call\");\n assert.include(\n JSON.stringify(request.messages),\n `${session(own)} (Acme iPhone, ${IPHONE}, on build-mac) has not started`,\n );\n }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),\n);\n\nit(\"tells the simulator 0.21.31's --foreground and session list behaviour\", () => {\n // Opus R11-B3(b): 0.21.31 (session2.js ys) refuses only an open --foreground with no app or URL.\n // Run 6's simulator refused `open \u003capp> --foreground` in 9 base samples.\n assert.include(\n AGENT_DEVICE_SHELL,\n \"open --foreground with no app or URL fails with exit code 1 when the command passes --udid or --device\",\n );\n assert.include(AGENT_DEVICE_SHELL, \"open \u003capp> --foreground works.\");\n // Run 6's simulator answered the DEVICE_IN_USE hint's `session list` with \"Unknown command\".\n assert.include(\n AGENT_DEVICE_SHELL,\n \"session list prints, as JSON, the started sessions on the launcher's host, other threads' too\",\n );\n // Neither is refused without the simulator.\n for (const args of [\"open com.acme.app --foreground\", \"session list\"]) {\n assert.isUndefined(\n agentDeviceSessionError(\n [boundTarget],\n new Map([[\"t3-bound\", undefined]]),\n `${boundTarget.command} ${args}`,\n ),\n args,\n );\n }\n});\n","preview":null,"history":null,"version":"7261949e14575fcfc00b7aaa985ef48550406902"},"/_session?shell=1":null}