Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

52.1 KB
Raw Blame
import { describe, expect, it, vi } from "vitest";
import {
  CONTROLLER_CAPABILITY_PROVIDER_LOGO_KINDS_V2,
  FILE_INLINE_MAX_BYTES,
  REMOTE_INVOKE_ALLOWLIST,
  sharedTaskHostPeer,
} from "@cindy/device-link";
import {
  createMobileMakerTransport,
  MOBILE_MAKER_CHANNELS,
} from "@/device-link/mobileMakerTransport";
import type { RemoteInvoke } from "@/device-link/mobileMakerTransport";
import { installPeerFileDownload } from "@/device-link/peerFileRegistry";
const fileCache = vi.hoisted(() => ({ readLatest: vi.fn(), readInline: vi.fn(), storeInline: vi.fn(), invalidate: vi.fn(), download: vi.fn() }));
vi.mock('@/device-link/peerFileCache', () => ({ createPeerFileCache: async () => fileCache }));
import { isDirectPreviewableMediaUrl, resolveMobileRemoteMedia } from "@/session/remoteMedia";
import { fetchRemoteAbsFileOnce } from '@/session/remoteAbsFileFetch';
import {
  setMobileAuthOwner,
  __testing as authOwnerTesting,
} from "@/auth/authOwnerGeneration";

function harness() {
  const calls: Array<{ deviceId: string; channel: string; args?: unknown[] }> =
    [];
  const invokeMock = vi.fn(
    async (deviceId: string, channel: string, args?: unknown[]) => {
      calls.push({ deviceId, channel, args });
      return { ok: true };
    },
  );
  const invoke: RemoteInvoke = (deviceId, channel, args) =>
    invokeMock(deviceId, channel, args) as Promise<never>;
  return {
    calls,
    invoke,
    maker: createMobileMakerTransport({ deviceId: "dev-1", invoke }),
  };
}

describe("mobile maker transport", () => {
  // Unit: validate the real transport's versioned Host protocol, including an
  // older Host rejection. Creating a side chat is never retried as a new task.
  it('uses versioned side-chat channels and surfaces unsupported hosts without fallback', async () => {
    const calls: string[] = [];
    const maker = createMobileMakerTransport({ deviceId: 'side-host', invoke: (async (_device, channel, args) => {
      calls.push(channel);
      expect(args).toEqual(['main']);
      if (channel === 'maker:side-chat:list:v1') return [{ id: 'child' }];
      throw new Error('CHANNEL_NOT_ALLOWED');
    }) as RemoteInvoke });
    expect(await maker.listSideChats('main')).toEqual([{ id: 'child' }]);
    await expect(maker.createSideChat('main')).rejects.toThrow('CHANNEL_NOT_ALLOWED');
    expect(calls).toEqual(['maker:side-chat:list:v1', 'maker:side-chat:v1']);
  });
  it('writes reset preferences to the execution device and rejects a different account response', async () => {
    const invoke = vi.fn(async () => ({ providerId: 'openai-b', autoUse: { accountKey: 'bound-account' } }));
    const maker = createMobileMakerTransport({ deviceId: 'execution-device', invoke: invoke as RemoteInvoke });
    await maker.setCodexResetAutoUse({ minimumDays: 7 }, 'bound-account', 'openai-b');
    expect(invoke).toHaveBeenCalledWith('execution-device', 'maker:usage:codex-reset-auto-use', [{ minimumDays: 7 }, 'bound-account', 'openai-b']);
    invoke.mockResolvedValueOnce({ providerId: 'openai-b', autoUse: { accountKey: 'changed-account' } });
    await expect(maker.setCodexResetAutoUse({ enabled: true }, 'bound-account', 'openai-b')).rejects.toThrow('Account scope changed');
  });

  // Unit: a visible text snapshot is already cached by the reader. Its refresh
  // must await the Host, while retaining the existing confirmed-version cache.
  it('revalidates text without returning stale bytes or invalidating a confirmed version', async () => {
    setMobileAuthOwner('text-revalidation');
    const stale = { ossKey: '', size: 3, mimeType: 'text/plain', version: 'a'.repeat(64), inlineBase64: 'b2xk' };
    const current = { ...stale, version: 'b'.repeat(64), inlineBase64: 'bmV3' };
    fileCache.readLatest.mockResolvedValue(stale);
    fileCache.readInline.mockResolvedValue(current);
    const invoke = vi.fn(async () => ({ ...current, inlineBase64: undefined, transferRequired: true }));
    const maker = createMobileMakerTransport({ deviceId: 'text-host', invoke: invoke as RemoteInvoke });
    try {
      expect(await maker.fetchRemoteMedia('xdt-file://open?path=/text.txt', { stream: false, revalidate: true })).toEqual(current);
      expect(fileCache.readLatest).not.toHaveBeenCalled();
      expect(fileCache.invalidate).not.toHaveBeenCalled();
      expect(invoke).toHaveBeenCalledOnce();
    } finally {
      fileCache.readLatest.mockReset(); fileCache.readInline.mockReset();
      authOwnerTesting.reset(); vi.clearAllMocks();
    }
  });
  it('reads through an older shared host without sending unknown metadata-only fields', async () => {
    const result = { ossKey: '', size: 3, mimeType: 'text/plain', inlineBase64: 'YWJj' };
    const invoke = vi.fn(async (_device, _channel, [request]) => {
      if ('metadataOnly' in request) throw new Error('PERMISSION_DENIED');
      return result;
    });
    const maker = createMobileMakerTransport({ deviceId: sharedTaskHostPeer('shared', 'host'), invoke: invoke as RemoteInvoke });
    expect(await maker.fetchRemoteMedia('xdt-file://open?path=/a.txt', { stream: false })).toEqual(result);
    expect(await maker.fetchRemoteMedia('xdt-file://open?path=/a.txt', { stream: false })).toEqual(result);
    expect(invoke).toHaveBeenCalledTimes(2);
  });
  it('opens a cached file without waiting for connection or host metadata, then refreshes in background', async () => {
    setMobileAuthOwner('cache-first-owner');
    const cached = { ossKey: '', size: 3, mimeType: 'application/pdf', version: 'a'.repeat(64), inlineBase64: 'YWJj' };
    fileCache.readLatest.mockResolvedValueOnce(cached);
    let connect!: () => void;
    const beforeFetch = vi.fn(() => new Promise<void>(resolve => { connect = resolve; }));
    const invoke = vi.fn(async () => ({ ...cached, inlineBase64: undefined, transferRequired: true }));
    const maker = createMobileMakerTransport({ deviceId: 'cached-device', invoke: invoke as RemoteInvoke });
    try {
      expect(await maker.fetchRemoteMedia('xdt-file://open?path=/cached.pdf', { stream: false, beforeFetch })).toEqual(cached);
      expect(invoke).not.toHaveBeenCalled();
      expect(beforeFetch).toHaveBeenCalledOnce();
      connect();
      await vi.waitFor(() => expect(invoke).toHaveBeenCalledOnce());
    } finally { authOwnerTesting.reset(); vi.clearAllMocks(); }
  });
  // #6292 + #6299, unit: HTML owns its visible cache. Its background fetch must
  // return fresh bytes, not re-store the transport's stale snapshot indefinitely.
  it('refreshes HTML from the host even when the transfer cache contains an older copy', async () => {
    setMobileAuthOwner('html-refresh-owner');
    const cached = { ossKey: '', size: 3, mimeType: 'text/html', version: 'a'.repeat(64), inlineBase64: 'b2xk' };
    const fresh = { ...cached, version: 'b'.repeat(64), inlineBase64: 'bmV3' };
    fileCache.readLatest.mockResolvedValue(cached);
    const invoke = vi.fn(async () => fresh);
    const maker = createMobileMakerTransport({ deviceId: 'html-refresh', invoke: invoke as RemoteInvoke });
    try {
      const result = await fetchRemoteAbsFileOnce({ maker, deviceId: 'html-refresh', openLink: async () => {},
        presignGet: vi.fn() }, '/page.html');
      expect(result.inlineBase64).toBe(fresh.inlineBase64);
      expect(invoke).toHaveBeenCalled();
      expect(fileCache.readLatest).not.toHaveBeenCalled();
    } finally { fileCache.readLatest.mockReset(); authOwnerTesting.reset(); vi.clearAllMocks(); }
  });
  it('checks the host version on every small-file read, reuses disk bytes, and honors forced refresh', async () => {
    setMobileAuthOwner('cache-owner');
    const result = { ossKey: '', size: 3, mimeType: 'text/html', version: 'a'.repeat(64), inlineBase64: 'YWJj' };
    let stored: typeof result | null = null;
    fileCache.readInline.mockImplementation(async () => stored);
    fileCache.storeInline.mockImplementation(async (_device, _url, value) => { stored = value; });
    fileCache.invalidate.mockImplementation(async () => { stored = null; });
    const invoke = vi.fn(async (_device, _channel, [args]) => args.metadataOnly
      ? { ...result, inlineBase64: undefined, transferRequired: true } : result);
    const maker = createMobileMakerTransport({ deviceId: 'd', invoke: invoke as RemoteInvoke });
    try {
      expect(await maker.fetchRemoteMedia('xdt-file://open?path=/a.html', { stream: false })).toEqual(result);
      expect(await maker.fetchRemoteMedia('xdt-file://open?path=/a.html', { stream: false })).toEqual(result);
      expect(invoke).toHaveBeenCalledTimes(3);
      await maker.fetchRemoteMedia('xdt-file://open?path=/a.html', { stream: false, skipCache: true });
      expect(fileCache.invalidate).toHaveBeenCalledWith('d', 'xdt-file://open?path=/a.html');
      expect(invoke).toHaveBeenCalledTimes(5);
    } finally { authOwnerTesting.reset(); vi.clearAllMocks(); }
  });
  describe.each([
    ["video", "video/mp4", "mp4"],
    ["audio", "audio/mpeg", "mp3"],
  ] as const)("%s playback", (kind, mimeType, extension) => {
    it.each([FILE_INLINE_MAX_BYTES - 1, FILE_INLINE_MAX_BYTES, FILE_INLINE_MAX_BYTES + 1])(
      "resolves %i bytes to a URL accepted by the media player",
      async (size) => {
        const metadata = { ossKey: "", size, mimeType };
        const prepared = size <= FILE_INLINE_MAX_BYTES
          ? { ...metadata, inlineBase64: Buffer.alloc(size).toString("base64") }
          : { ...metadata, transferRequired: true };
        const uploaded = { ...metadata, ossKey: `media/playback.${extension}` };
        const invoke = vi.fn(async (_device, _channel, args) => {
          expect(args[0]).not.toHaveProperty("stream");
          return args[0].prepareOnly ? prepared : uploaded;
        });
        const getUrl = `https://media.example.invalid/playback.${extension}`;
        const presignGet = vi.fn(async () => ({ getUrl, expiresAt: "2099-01-01T00:00:00Z" }));
        const maker = createMobileMakerTransport({ deviceId: "d", invoke: invoke as RemoteInvoke });
        const resolved = await resolveMobileRemoteMedia(
          { kind, url: `cindy-media://blobs/${"a".repeat(64)}.${extension}` },
          { fetchRemoteMedia: maker.fetchRemoteMedia, presignGet },
        );
        expect(isDirectPreviewableMediaUrl(resolved.url)).toBe(true);
        expect(resolved).toMatchObject({ url: getUrl, mimeType, size, previewable: true });
        expect(resolved.inlineBase64).toBeUndefined();
        expect(presignGet).toHaveBeenCalledExactlyOnceWith(uploaded.ossKey);
        expect(invoke).toHaveBeenCalledTimes(2);
      },
    );
    it.each([FILE_INLINE_MAX_BYTES - 1, FILE_INLINE_MAX_BYTES])(
      "plays %i-byte inline media when an old host ignores prepareOnly",
      async (size) => {
        const metadata = { ossKey: "", size, mimeType };
        const inline = { ...metadata, inlineBase64: Buffer.alloc(size).toString("base64") };
        const invoke = vi.fn(async (_device, _channel, args) => {
          expect(args[0]).not.toHaveProperty("stream");
          return inline;
        });
        const presignGet = vi.fn();
        const maker = createMobileMakerTransport({ deviceId: "d", invoke: invoke as RemoteInvoke });
        const resolved = await resolveMobileRemoteMedia(
          { kind, url: `cindy-media://blobs/${"a".repeat(64)}.${extension}` },
          { fetchRemoteMedia: maker.fetchRemoteMedia, presignGet },
        );
        expect(isDirectPreviewableMediaUrl(resolved.url)).toBe(true);
        expect(resolved).toMatchObject({
          url: `data:${mimeType};base64,${inline.inlineBase64}`,
          mimeType,
          size,
          previewable: true,
        });
        expect(presignGet).not.toHaveBeenCalled();
        expect(invoke).toHaveBeenCalledTimes(2);
      },
    );
  });
  it.each(["audio/mpeg", "video/mp4", "image/png", "application/pdf", "application/octet-stream"])("retains %s previews while preserving peer for complete byte consumers", async (mimeType) => {
    const metadata = { ossKey: "", size: 70_000, mimeType, transferRequired: true };
    const direct = { ...metadata, transferRequired: false };
    const peer = vi.fn(async () => direct);
    const uninstall = installPeerFileDownload(peer);
    const invoke = vi.fn(async (_device, _channel, args) => {
      expect(args[0]).not.toHaveProperty("stream");
      if (args[0].op === "caps") return { fileRead: true };
      if (args[0].op === "fileUrl") return { ok: true, url: "xdt-file://open?path=/media" };
      return args[0].prepareOnly ? metadata : { ...metadata, ossKey: "stream/key", transferRequired: false };
    });
    try {
      const maker = createMobileMakerTransport({ deviceId: "d", invoke: invoke as RemoteInvoke });
      expect((await maker.fetchRemoteMedia("xdt-file://open?path=/media")).ossKey).toBe("stream/key");
      expect(peer).not.toHaveBeenCalled();
      expect(await maker.fileBrowser.readBytes("/p", "media")).toBe(direct);
      expect(peer).toHaveBeenCalledOnce();
      expect(await maker.fetchRemoteMedia("xdt-file://open?path=/media", { stream: false })).toBe(direct);
      expect(peer).toHaveBeenCalledTimes(2);
    } finally { uninstall(); }
  });
  it("does not return old-account OSS keys to a cleanup callback after account change", async () => {
    setMobileAuthOwner("first");
    const onDiscardOssKey = vi.fn();
    const maker = createMobileMakerTransport({
      deviceId: "d",
      invoke: async <T,>() => {
        setMobileAuthOwner("second");
        return { ossKey: "first/key", size: 1, mimeType: "text/html" } as T;
      },
    });
    try {
      await expect(
        maker.fetchRemoteMedia("xdt-file://open?path=/a", { onDiscardOssKey }),
      ).rejects.toThrow("FILE_PEER_CANCELLED");
      expect(onDiscardOssKey).not.toHaveBeenCalled();
    } finally {
      authOwnerTesting.reset();
    }
  });
  it.each([
    ["prepare", "abort"],
    ["prepare", "stale"],
    ["fallback", "abort"],
    ["fallback", "stale"],
  ])(
    "returns late %s OSS ownership before %s cancellation",
    async (phase, reason) => {
      const abort = new AbortController();
      let current = true;
      const uploaded = new Set<string>();
      const remove = vi.fn();
      const presignGet = vi.fn();
      const invoke = vi.fn(async (_device, _channel, args) => {
        expect(args[0]).not.toHaveProperty("onDiscardOssKey");
        if (phase === "fallback" && args[0].prepareOnly)
          return {
            ossKey: "",
            size: 70_000,
            mimeType: "text/html",
            transferRequired: true,
          };
        if (reason === "abort") abort.abort();
        else current = false;
        return {
          ossKey: "owned/late.html",
          size: 70_000,
          mimeType: "text/html",
        };
      });
      const uninstall = installPeerFileDownload(async () => null);
      const maker = createMobileMakerTransport({
        deviceId: "d",
        invoke: (device, channel, args) => invoke(device, channel, args) as Promise<never>,
        isCurrent: () => current,
      });
      const read = async () => {
        try {
          return await resolveMobileRemoteMedia(
            { kind: "image", url: "xdt-file://open?path=/late.html" },
            { fetchRemoteMedia: maker.fetchRemoteMedia, presignGet },
            { signal: abort.signal, onOssKey: (key) => uploaded.add(key) },
          );
        } finally {
          for (const key of uploaded) remove(key);
        }
      };
      try {
        await expect(read()).rejects.toThrow("FILE_PEER_CANCELLED");
        expect(remove).toHaveBeenCalledExactlyOnceWith("owned/late.html");
        expect(presignGet).not.toHaveBeenCalled();
        expect(invoke).toHaveBeenCalledTimes(phase === "prepare" ? 1 : 2);
      } finally {
        uninstall();
      }
    },
  );
  it("uses the shared inline/peer/OSS policy for media files", async () => {
    const direct = { ossKey: "", size: 70_000, mimeType: "text/plain" };
    const peer = vi.fn(async () => direct);
    const uninstall = installPeerFileDownload(peer);
    const invoke = vi
      .fn()
      .mockResolvedValueOnce({
        ossKey: "",
        size: 0,
        mimeType: "text/plain",
        inlineBase64: "",
      })
      .mockResolvedValueOnce({ ...direct, transferRequired: true, version: 'a'.repeat(64) });
    try {
      const maker = createMobileMakerTransport({ deviceId: "d", invoke });
      expect(
        (await maker.fetchRemoteMedia("xdt-file://open?path=/a")).inlineBase64,
      ).toBe("");
      expect(peer).not.toHaveBeenCalled();
      expect(await maker.fetchRemoteMedia("xdt-file://open?path=/b", { stream: false })).toBe(
        direct,
      );
      expect(peer).toHaveBeenCalledOnce();
      expect(peer.mock.calls[0]).toEqual(['d', 'xdt-file://open?path=/b', undefined, expect.any(Number), { ...direct, transferRequired: true, version: 'a'.repeat(64) }, undefined]);
      invoke.mockResolvedValueOnce({ ...direct, transferRequired: true, version: 'a'.repeat(64) });
      await maker.fetchRemoteMedia('xdt-file://open?path=/b', { stream: false, skipCache: true });
      expect(peer.mock.calls[1]).toEqual(['d', 'xdt-file://open?path=/b', undefined, expect.any(Number),
        { ...direct, transferRequired: true, version: 'a'.repeat(64), skipCache: true }, undefined]);
    } finally {
      uninstall();
    }
  });
  // Unit: exercise the complete HTML fetch adapter chain. A failed partial direct
  // download must clear its percentage while the existing OSS fallback prepares.
  it('forwards receiver progress through HTML fetching and resets it on upload fallback', async () => {
    const progress = vi.fn();
    const metadata = { ossKey: '', size: 100, mimeType: 'text/html' };
    const uninstall = installPeerFileDownload(async (_device, _url, _signal, _trace, _metadata, onProgress) => {
      onProgress?.(42, 100);
      return null;
    });
    const invoke = vi.fn().mockResolvedValueOnce({ ...metadata, transferRequired: true })
      .mockResolvedValueOnce({ ...metadata, ossKey: 'owned/page' });
    try {
      const maker = createMobileMakerTransport({ deviceId: 'd', invoke });
      const result = await fetchRemoteAbsFileOnce({ maker, deviceId: 'd', openLink: async () => {},
        presignGet: async () => ({ getUrl: 'https://example.test/page', expiresAt: '2099-01-01T00:00:00Z' }) },
      '/page.html', undefined, undefined, undefined, new AbortController().signal, progress);
      expect(result.url).toBe('https://example.test/page');
      expect(progress.mock.calls).toEqual([[42, 100], [0, 0]]);
      expect(invoke).toHaveBeenCalledTimes(2);
    } finally { uninstall(); }
  });
  it("cancels before caps and keeps old-host export on the existing job protocol", async () => {
    const invoke = vi
      .fn()
      .mockResolvedValueOnce({ ok: true })
      .mockResolvedValueOnce({ ok: true, transferId: "job", size: 3 })
      .mockResolvedValueOnce({ ok: true, state: "done", key: "oss/key" });
    const maker = createMobileMakerTransport({ deviceId: "d", invoke });
    const abort = new AbortController();
    abort.abort();
    await expect(
      maker.fileBrowser.readBytes("/p", "a", abort.signal),
    ).rejects.toThrow("CANCELLED");
    expect(invoke).not.toHaveBeenCalled();
    const open = vi.fn(async () => {});
    expect(
      (await maker.fileBrowser.readBytes("/p", "a", undefined, open)).ossKey,
    ).toBe("oss/key");
    expect(open).toHaveBeenCalledTimes(3);
    expect(invoke.mock.calls.map((call) => call[2][0].op)).toEqual([
      "caps",
      "exportFileStart",
      "exportFileStatus",
    ]);
  });
  it("rejects a legacy unscoped quota response for an independent account", async () => {
    const { maker, calls } = harness();
    await expect(maker.getCodexRateLimits("openai-second")).rejects.toThrow(
      "Account scope unsupported",
    );
    expect(calls.at(-1)).toMatchObject({
      channel: "maker:usage:codex-rate-limits",
      args: ["openai-second"],
    });
    await expect(
      maker.getAccountUsage("codex", "openai-second"),
    ).rejects.toThrow("Account scope unsupported");
  });

  it("accepts only the requested account in scoped quota responses", async () => {
    const invoke: RemoteInvoke = async () =>
      ({ providerId: "openai-second" }) as never;
    const maker = createMobileMakerTransport({ deviceId: "dev-1", invoke });
    await expect(
      maker.getCodexRateLimits("openai-second"),
    ).resolves.toMatchObject({ providerId: "openai-second" });
    await expect(maker.getCodexRateLimits("openai-third")).rejects.toThrow(
      "Account scope unsupported",
    );
  });
  it("reads subscription snapshots by family, scoping only independent accounts", async () => {
    const calls: Array<[string, unknown[] | undefined]> = [];
    const invoke: RemoteInvoke = async (_deviceId, channel, args) => {
      calls.push([channel, args]);
      return (args?.length ? { providerId: args[0] } : { creditUsagePercent: 1 }) as never;
    };
    const maker = createMobileMakerTransport({ deviceId: "dev-1", invoke });
    await maker.getSubscriptionUsage("claude", "anthropic");
    await maker.getSubscriptionUsage("xai");
    await maker.getSubscriptionUsage("xai", "grok-second");
    await maker.getClaudeSessionRoute("s1");
    expect(calls).toEqual([
      ["maker:usage:claude-subscription", []],
      ["maker:usage:xai-subscription", []],
      ["maker:usage:xai-subscription", ["grok-second"]],
      ["maker:claude-session-route:get", ["s1"]],
    ]);
    const legacy = createMobileMakerTransport({
      deviceId: "dev-1",
      invoke: async () => ({ creditUsagePercent: 1 }) as never,
    });
    await expect(legacy.getSubscriptionUsage("xai", "grok-second")).rejects.toThrow(
      "Account scope unsupported",
    );
  });
  it("documents the remote channels used by the mobile transport", () => {
    expect(MOBILE_MAKER_CHANNELS).toEqual([
      "ghosts:composer-list",
      "maker:create-session",
      "maker:get-capabilities",
      "maker:provider:list",
      "local-db:sessions:get",
      "local-db:conversations:search",
      "local-db:sessions:patch-meta",
      "local-db:messages:dismiss-error",
      "local-db:sessions:ack-interrupted",
      "maker:regenerate-title",
      "maker:predict-prompt",
      "local-db:messages:list",
      "local-db:messages:view",
      "local-db:messages:work-details",
      "local-db:messages:view-intent",
      "local-db:messages:around",
      "local-db:messages:around-client-id",
      "maker:send",
      "maker:list-active",
      "maker:set-model",
      "maker:switch-session-agent",
      "maker:get-session-agent-switch-intent",
      "maker:set-effort",
      "maker:set-permission-mode",
      "maker:set-fast-mode",
      "maker:set-thinking-enabled",
      "maker:set-extra-dirs",
      "maker:set-session-model-pref",
      "maker:apply-new-maker-draft-pref",
      "maker:get-new-maker-defaults",
      "maker:apply-new-maker-worktree-pref",
      "maker:get-new-maker-worktree-branch-pref",
      "maker:apply-new-maker-worktree-branch-pref",
      "maker:usage:model-pricing",
      "local-db:messages:estimatedSessionValue",
      "maker:usage:codex-rate-limits",
      "maker:usage:codex-rate-limit-reset",
      "maker:usage:codex-reset-auto-use",
      "maker:usage:claude-subscription",
      "maker:usage:xai-subscription",
      "maker:claude-session-route:get",
      "maker:api-key:present",
      "maker:list-agent-commands",
      "maker:list-agent-skills",
      "maker:scan-at-resources",
      "device-link:media:fetch",
      "device-link:voice:transcribe",
      "device-link:voice:dictionary-learning",
      "device-link:voice:dictionary:get",
      "maker:get-pending-interactions",
      "maker:resolve-interaction",
      "maker:get-context-usage",
      "maker:goal:set",
      "maker:goal:clear",
      "maker:goal:get-status",
      "maker:goal:pause",
      "maker:goal:resume",
      "maker:goal:update",
      "maker:fork",
      "maker:side-chat:v1",
      "maker:side-chat:list:v1",
      "maker:fork-strip-encrypted",
      "maker:get-session-tree",
      "maker:navigate-session-tree",
      "maker:rewind:preview",
      "maker:rewind:commit",
      "maker:message:delete",
      "maker:close-session",
      "maker:plugins:get-state",
      "maker:session:enable-orca",
      "maker:session:disable-orca",
      "maker:worker:create",
      "maker:orca:execution-devices",
      "maker:worker:switch-focus",
      "maker:worker:acknowledge-done",
      "maker:worker:archive",
      "maker:collaboration-settings:get",
      "local-db:orca-workflows:list-workers-by-lead",
      "local-db:orca-workflows:get-by-worker-session",
      "maker:schedule:list",
      "maker:schedule:get",
      "maker:schedule:list-templates",
      "maker:schedule:create-from-template",
      "maker:schedule:create",
      "maker:schedule:update",
      "maker:schedule:list-runs",
      "maker:schedule:run-now",
      "maker:schedule:pause",
      "maker:schedule:resume",
      "maker:schedule:delete",
      "maker:schedule:get-inflight-count",
      "maker:schedule:mark-run-read",
      "maker:schedule:mark-schedule-runs-read",
      "maker:schedule:delete-run",
      "notification:clear-session-attention",
      "maker:project-automation:remove-schedule",
      "maker:input:get-projection",
      "maker:input:enqueue",
      "maker:input:compact",
      "maker:compact-session",
      "maker:input:steer",
      "maker:input:stop",
      "maker:input:resume",
      "maker:input:retry-last-error",
      "maker:input:clear-error",
      "maker:input:cancel-usage-limit-wait",
      "maker:input:remove",
      "maker:input:update-text",
      "maker:input:update-content",
      "maker:input:move",
      "maker:input:set-expanded",
      "maker:input:set-interaction-lock",
      "maker:input:set-edit-lock",
      "maker:input:clear-session",
      "fs:list-dir",
      "fs:stat-path",
      "fs:mkdir-p",
      "worktree:detect-cwd",
      "worktree:list-branches",
      "worktree:suggest-name",
      "worktree:create",
      "worktree:discard-precreated",
      "worktree:cancel-precreated",
      "text-file:read-preview",
      "file-browser:remote-op",
    ]);
  });

  it("keeps mobile remote channels inside the desktop device-link allowlist", () => {
    expect(
      MOBILE_MAKER_CHANNELS.filter(
        (channel) => !REMOTE_INVOKE_ALLOWLIST.has(channel),
      ),
    ).toEqual([]);
  });

  it("routes tail-banner dismiss and interrupt ack with desktop preload argument order", async () => {
    const { calls, maker } = harness();

    await maker.dismissErrorMessage("s1", "error-client-1");
    await maker.ackInterruptedTurn("s1");

    expect(calls).toEqual([
      {
        channel: "local-db:messages:dismiss-error",
        args: ["s1", "error-client-1"],
        deviceId: "dev-1",
      },
      {
        channel: "local-db:sessions:ack-interrupted",
        args: ["s1"],
        deviceId: "dev-1",
      },
    ]);
  });

  it("routes Orca collaboration calls with desktop preload argument shapes", async () => {
    const { calls, maker } = harness();
    const options = { workerAgent: "codex" as const, role: "developer", label: "developer", workerPermissionMode: "auto" as const };

    await maker.orca.listExecutionDevices();
    await maker.orca.getCollabPolicy("/repo", "project");
    await maker.orca.enable("lead-1", options);
    await maker.orca.createWorker({ leadSessionId: "lead-1", role: "reviewer", label: "reviewer", agent: "pi", workerPermissionMode: "auto" });
    await maker.orca.listWorkers("lead-1");
    await maker.orca.getTeamByWorkerSession("worker-1");
    await maker.orca.switchFocus("lead-1", "w-1");
    await maker.orca.acknowledgeDone("lead-1", "w-1");
    await maker.orca.archiveWorker("lead-1", "w-1");
    await maker.orca.getCollaborationSettings();
    await maker.orca.disable("lead-1");

    expect(calls.map(({ channel, args }) => ({ channel, args }))).toEqual([
      { channel: "maker:orca:execution-devices", args: [] },
      { channel: "maker:plugins:get-state", args: ["collab", "/repo", "project"] },
      { channel: "maker:session:enable-orca", args: ["lead-1", options] },
      { channel: "maker:worker:create", args: [{ leadSessionId: "lead-1", role: "reviewer", label: "reviewer", agent: "pi", workerPermissionMode: "auto" }] },
      { channel: "local-db:orca-workflows:list-workers-by-lead", args: ["lead-1"] },
      { channel: "local-db:orca-workflows:get-by-worker-session", args: ["worker-1"] },
      { channel: "maker:worker:switch-focus", args: [{ leadSessionId: "lead-1", workerIdOrLabel: "w-1" }] },
      { channel: "maker:worker:acknowledge-done", args: [{ leadSessionId: "lead-1", workerId: "w-1" }] },
      { channel: "maker:worker:archive", args: [{ leadSessionId: "lead-1", workerId: "w-1" }] },
      { channel: "maker:collaboration-settings:get", args: [] },
      { channel: "maker:session:disable-orca", args: ["lead-1"] },
    ]);
  });

  it("routes message reads and sends with desktop preload argument order", async () => {
    const { calls, maker } = harness();

    await maker.listMessages("s1", { limit: 80 });
    await maker.aroundMessages("s1", "message-id", { radius: 60 });
    await maker.aroundMessagesByClientId("s1", "client-id", { radius: 40 });
    await maker.patchSessionMeta("s1", { title: "Renamed" });
    await maker.send("s1", "hello", undefined, { throwOnStartFailure: true });
    await maker.listActiveSessions();

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "local-db:messages:list",
        args: ["s1", { limit: 80 }],
      },
      {
        deviceId: "dev-1",
        channel: "local-db:messages:around",
        args: ["s1", "message-id", { radius: 60 }],
      },
      {
        deviceId: "dev-1",
        channel: "local-db:messages:around-client-id",
        args: ["s1", "client-id", { radius: 40 }],
      },
      {
        deviceId: "dev-1",
        channel: "local-db:sessions:patch-meta",
        args: ["s1", { title: "Renamed" }],
      },
      {
        deviceId: "dev-1",
        channel: "maker:send",
        args: ["s1", "hello", undefined, { throwOnStartFailure: true }],
      },
      {
        deviceId: "dev-1",
        channel: "maker:list-active",
        args: [{ summary: true, snapshotVersion: 2 }],
      },
    ]);
  });

  it("routes remote create-session through the desktop device-link channel", async () => {
    const { calls, maker } = harness();
    const opts = {
      agentKind: "claude-code" as const,
      workingDir: "/repo/xdt-maker",
      workspaceKind: "project" as const,
      model: "claude-sonnet-4-6",
      effort: "medium",
      permissionMode: "acceptEdits",
      fastMode: false,
    };

    await maker.createSession(opts);

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:create-session",
        args: [opts],
      },
    ]);
  });

  it("routes task search through the controlled desktop conversations:search channel", async () => {
    const { calls, maker } = harness();
    const request = { query: "needle", semanticMode: "keyword" as const };

    await maker.searchConversations(request);

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "local-db:conversations:search",
        args: [request],
      },
    ]);
  });

  it("routes capability reads through the controlled desktop maker channel", async () => {
    const { calls, maker } = harness();

    await maker.getCapabilities("claude-code");

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:get-capabilities",
        args: ["claude-code"],
      },
    ]);
  });

  it("mirrors the controlled desktop provider structure via maker:provider:list", async () => {
    const { calls, maker } = harness();

    await maker.listProviders();

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:provider:list",
        args: [
          {
            capabilities: [CONTROLLER_CAPABILITY_PROVIDER_LOGO_KINDS_V2],
          },
        ],
      },
    ]);
  });

  it("carries providerId into create-session only when a source is explicitly chosen", async () => {
    const { calls, maker } = harness();
    const base = {
      agentKind: "codex" as const,
      workspaceKind: "dialogue" as const,
      model: "gpt-5.5",
      permissionMode: "acceptEdits",
      fastMode: false,
    };

    await maker.createSession({ ...base, providerId: "openai" });

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:create-session",
        args: [{ ...base, providerId: "openai" }],
      },
    ]);
  });

  it("routes pending interactions through maker:resolve-interaction", async () => {
    const { calls, maker } = harness();
    const decision = {
      kind: "ask_user_question",
      answers: { question: "answer" },
    };

    await maker.getPendingInteractions("s1");
    await maker.resolveInteraction("req-1", decision);

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:get-pending-interactions",
        args: ["s1"],
      },
      {
        deviceId: "dev-1",
        channel: "maker:resolve-interaction",
        args: ["req-1", decision],
      },
    ]);
  });

  it("does not advertise or emit the unimplemented model-window confirmation protocol", async () => {
    const { calls, maker } = harness();

    await maker.setModel("s1", "small-model", "anthropic");
    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:set-model",
        args: ["s1", "small-model", "anthropic"],
      },
    ]);
  });

  it("sends model/provider/effort/Fast as one atomic set-model selection", async () => {
    const { calls, maker } = harness();

    await maker.setModel("s1", "fixed-model", "provider-a", {
      effort: null,
      fastMode: false,
    });

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:set-model",
        args: [
          "s1",
          "fixed-model",
          "provider-a",
          null,
          { effort: null, fastMode: false },
        ],
      },
    ]);
  });

  it("sends the remote-Agent location as the 7th switch-session-agent arg only when given", async () => {
    const { calls, maker } = harness();

    await maker.switchSessionAgent("s1", "claude-code", "claude-sonnet-4-6", "anthropic", "high", false, {
      agentDeviceId: null,
    });
    await maker.switchSessionAgent("s1", "codex", "gpt-5.5", null, undefined, undefined, {
      agentDeviceId: null,
    });
    await maker.switchSessionAgent("s1", "codex", "gpt-5.5", "openai", "high", true, {});
    await maker.switchSessionAgent("s1", "codex", "gpt-5.5", "openai", "high", true);

    expect(calls.map((call) => call.args)).toEqual([
      ["s1", "claude-code", "claude-sonnet-4-6", "anthropic", "high", false, { agentDeviceId: null }],
      ["s1", "codex", "gpt-5.5", null, null, null, { agentDeviceId: null }],
      // 未给位置 = 位置不变:与旧 6 参 wire 完全一致,旧被控端无感。
      ["s1", "codex", "gpt-5.5", "openai", "high", true],
      ["s1", "codex", "gpt-5.5", "openai", "high", true],
    ]);
    expect(calls.every((call) => call.channel === "maker:switch-session-agent")).toBe(true);
  });

  it("fails closed when a legacy Desktop returns model-window confirmation data", async () => {
    const invoke: RemoteInvoke = async () =>
      ({
        deferred: false,
        contextWindowConfirmationRequired: 272_000,
        contextTokensForConfirmation: 244_800,
      }) as never;
    const maker = createMobileMakerTransport({ deviceId: "dev-1", invoke });

    await expect(maker.setModel("s1", "pi-model")).rejects.toMatchObject({
      code: "PRECONDITION_FAILED",
      message:
        "remote model-window confirmation is unsupported; runtime selection was not changed",
    });
  });

  it("routes runtime controls and queue operations with stable channel names", async () => {
    const { calls, maker } = harness();

    await maker.setModel("s1", "claude-opus-4-7");
    await maker.setModel("s1", "gpt-5.5", "openai");
    await maker.switchSessionAgent(
      "s1",
      "codex",
      "gpt-5.5",
      "openai",
      "high",
      true,
    );
    await maker.getSessionAgentSwitchIntent("s1");
    await maker.setEffort("s1", "high");
    await maker.setPermissionMode("s1", "plan");
    await maker.setFastMode("s1", true);
    await maker.setExtraDirs("s1", ["/repo/docs"]);
    await maker.listAgentCommands("claude-code");
    await maker.listAgentCommands("pi", { sessionId: "s1" });
    await maker.listAgentSkills("claude-code", { workingDir: "/repo" });
    await maker.listAgentSkills("pi", { workingDir: "/repo", sessionId: "s1" });
    await maker.listAgentSkills("codex", {});
    await maker.scanAtResources("claude-code", {
      workingDir: "/repo",
      cap: 2000,
      query: "session",
    });
    await maker.fetchRemoteMedia("xdt-image://local/a.png");
    await maker.transcribeVoice({
      ossKey: "voice-key",
      mimeType: "audio/mp4",
      fileName: "voice.m4a",
    });
    await maker.recordVoiceDictionaryLearning({
      source: "mobile",
      rawTranscriptText: "xd maker",
      beforeText: "XDMaker",
      afterText: "XDMaker",
    });
    await maker.getVoiceDictionary();
    await maker.input.stop("s1", { pauseQueue: true });
    await maker.input.compact("s1");
    await maker.compactSession("s1");
    await maker.compactSession("s1", "");
    await maker.compactSession("s1", "focus on API design");
    await maker.input.retryLastError("s1");
    await maker.input.clearError("s1");
    await maker.input.cancelUsageLimitWait("s1");
    await maker.input.updateText("s1", "queued-1", "updated");
    await maker.input.updateContent("s1", "queued-1", {
      clientId: "queued-1",
    } as never);
    await maker.input.setEditLock("s1", "queued-1", true);
    await maker.input.setEditLock("s1", "queued-1", false);
    await maker.fs.readTextFilePreview("/repo/spec.md");
    await maker.getModelPricing();
    await maker.getCodexRateLimits();
    await maker.resetCodexRateLimits("018f4ec7-c6d8-7f10-8d43-9f8791d33000");
    await maker.getApiKeyPresent();
    await maker.setSessionModelPref({
      sessionId: "s1",
      agent: "codex",
      providerId: "openai",
      model: "gpt-5.5",
      effort: "high",
    });
    await maker.applyNewMakerDraftPref({
      agent: "codex",
      providerId: "openai",
      modelId: "gpt-5.5",
      active: false,
      fast: true,
    });

    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["maker:set-model", ["s1", "claude-opus-4-7"]],
      ["maker:set-model", ["s1", "gpt-5.5", "openai"]],
      [
        "maker:switch-session-agent",
        ["s1", "codex", "gpt-5.5", "openai", "high", true],
      ],
      ["maker:get-session-agent-switch-intent", ["s1"]],
      ["maker:set-effort", ["s1", "high"]],
      ["maker:set-permission-mode", ["s1", "plan"]],
      ["maker:set-fast-mode", ["s1", true]],
      ["maker:set-extra-dirs", ["s1", ["/repo/docs"]]],
      ["maker:list-agent-commands", ["claude-code"]],
      ["maker:list-agent-commands", ["pi", { sessionId: "s1" }]],
      ["maker:list-agent-skills", ["claude-code", { workingDir: "/repo" }]],
      [
        "maker:list-agent-skills",
        ["pi", { workingDir: "/repo", sessionId: "s1" }],
      ],
      ["maker:list-agent-skills", ["codex", {}]],
      [
        "maker:scan-at-resources",
        ["claude-code", { workingDir: "/repo", cap: 2000, query: "session" }],
      ],
      [
        "device-link:media:fetch",
        [{ url: "xdt-image://local/a.png", prepareOnly: true, metadataOnly: true }],
      ],
      [
        "device-link:voice:transcribe",
        [{ ossKey: "voice-key", mimeType: "audio/mp4", fileName: "voice.m4a" }],
      ],
      [
        "device-link:voice:dictionary-learning",
        [
          {
            source: "mobile",
            rawTranscriptText: "xd maker",
            beforeText: "XDMaker",
            afterText: "XDMaker",
          },
        ],
      ],
      ["device-link:voice:dictionary:get", []],
      ["maker:input:stop", ["s1", { pauseQueue: true }]],
      ["maker:input:compact", ["s1"]],
      ["maker:compact-session", ["s1"]],
      ["maker:compact-session", ["s1", ""]],
      ["maker:compact-session", ["s1", "focus on API design"]],
      ["maker:input:retry-last-error", ["s1"]],
      ["maker:input:clear-error", ["s1"]],
      ["maker:input:cancel-usage-limit-wait", ["s1"]],
      ["maker:input:update-text", ["s1", "queued-1", "updated"]],
      [
        "maker:input:update-content",
        ["s1", "queued-1", { clientId: "queued-1" }],
      ],
      ["maker:input:set-edit-lock", ["s1", "queued-1", true]],
      ["maker:input:set-edit-lock", ["s1", "queued-1", false]],
      ["text-file:read-preview", [{ filePath: "/repo/spec.md" }]],
      ["maker:usage:model-pricing", []],
      ["maker:usage:codex-rate-limits", []],
      [
        "maker:usage:codex-rate-limit-reset",
        ["018f4ec7-c6d8-7f10-8d43-9f8791d33000"],
      ],
      ["maker:api-key:present", []],
      [
        "maker:set-session-model-pref",
        [
          {
            sessionId: "s1",
            agent: "codex",
            providerId: "openai",
            model: "gpt-5.5",
            effort: "high",
          },
        ],
      ],
      [
        "maker:apply-new-maker-draft-pref",
        [
          {
            agent: "codex",
            providerId: "openai",
            modelId: "gpt-5.5",
            active: false,
            fast: true,
          },
        ],
      ],
    ]);
  });

  it("routes worktree probes and new-maker worktree defaults with device-link argument shapes", async () => {
    const { calls, maker } = harness();

    await maker.getNewMakerDefaults("claude-code");
    await maker.applyNewMakerWorktreePref(true);
    await maker.getNewMakerWorktreeBranchPref("/repo");
    await maker.applyNewMakerWorktreeBranchPref("/repo", "feature/mobile-sync");
    await maker.worktree.detectCwd("/repo/app");
    await maker.worktree.listBranches("/repo");
    await maker.worktree.suggestName("/repo");
    await maker.worktree.create({
      sessionId: "preset-session-1",
      baseRepo: "/repo",
      name: "auto-abc123",
      sourceBranch: "main",
      recoveryKey: "recovery-key-1234567890",
    });
    await maker.worktree.discardPrecreated({
      sessionId: "preset-session-1",
      path: "/repo/.cindy-worktrees/auto-abc123",
    });
    await maker.worktree.discardPrecreated({
      sessionId: "preset-session-2",
      recoveryKey: "recovery-key-0987654321",
    });

    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["maker:get-new-maker-defaults", ["claude-code"]],
      ["maker:apply-new-maker-worktree-pref", [{ worktreeEnabled: true }]],
      ["maker:get-new-maker-worktree-branch-pref", [{ baseRepo: "/repo" }]],
      [
        "maker:apply-new-maker-worktree-branch-pref",
        [
          {
            baseRepo: "/repo",
            sourceBranch: "feature/mobile-sync",
          },
        ],
      ],
      ["worktree:detect-cwd", [{ cwd: "/repo/app" }]],
      ["worktree:list-branches", [{ baseRepo: "/repo" }]],
      ["worktree:suggest-name", [{ baseRepo: "/repo" }]],
      [
        "worktree:create",
        [
          {
            sessionId: "preset-session-1",
            baseRepo: "/repo",
            name: "auto-abc123",
            sourceBranch: "main",
            recoveryKey: "recovery-key-1234567890",
          },
        ],
      ],
      [
        "worktree:discard-precreated",
        [
          {
            sessionId: "preset-session-1",
            path: "/repo/.cindy-worktrees/auto-abc123",
          },
        ],
      ],
      [
        "worktree:discard-precreated",
        [
          {
            sessionId: "preset-session-2",
            recoveryKey: "recovery-key-0987654321",
          },
        ],
      ],
    ]);
  });

  it("routes terminal worktree cancellation through its distinct host channel", async () => {
    const { calls, maker } = harness();
    const input = { sessionId: "uncertain-create", recoveryKey: "recovery-key-1234567890" };
    await maker.worktree.cancelPrecreated!(input);
    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["worktree:cancel-precreated", [input]],
    ]);
  });

  it("routes fork, native tree, rewind and delete actions through maker namespace", async () => {
    const { calls, maker } = harness();

    await maker.fork("s1", "m2");
    await maker.forkStripEncrypted("s1");
    await maker.getSessionTree("s1");
    await maker.navigateSessionTree("s1", "entry-2", {
      summarize: true,
      customInstructions: "Keep the decision context",
    });
    await maker.rewindPreview("s1", "m2");
    await maker.rewindCommit("s1", "m2");
    await maker.rewindCommit("s1", "m2", { allowFileRestore: false });
    await maker.deleteMessage("s1", "m2");

    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["maker:fork", ["s1", "m2"]],
      ["maker:fork-strip-encrypted", ["s1"]],
      ["maker:get-session-tree", ["s1"]],
      [
        "maker:navigate-session-tree",
        [
          "s1",
          "entry-2",
          {
            summarize: true,
            customInstructions: "Keep the decision context",
          },
        ],
      ],
      ["maker:rewind:preview", ["s1", "m2"]],
      ["maker:rewind:commit", ["s1", "m2"]],
      ["maker:rewind:commit", ["s1", "m2", { allowFileRestore: false }]],
      ["maker:message:delete", ["s1", "m2"]],
    ]);
  });

  it("passes trusted reference coordinates after update-text in desktop argument order", async () => {
    const { calls, maker } = harness();
    const refs = [
      {
        sessionId: "source",
        messageClientId: "anchor",
        deviceId: "dev-source",
      },
    ];
    const contexts = [
      {
        sessionId: "source",
        messageClientId: "anchor",
        source: "device-link" as const,
        deviceId: "dev-source",
        messages: [{ role: "user" as const, content: "trusted" }],
        range: "around-anchor" as const,
        messageCount: 1,
        truncated: false,
      },
    ];

    await maker.input.updateText(
      "target",
      "queued-1",
      "edited",
      refs,
      contexts,
    );

    expect(calls).toEqual([
      {
        deviceId: "dev-1",
        channel: "maker:input:update-text",
        args: ["target", "queued-1", "edited", refs, contexts],
      },
    ]);
  });

  it("routes the session read receipt with desktop preload argument order", async () => {
    const { calls, maker } = harness();

    await maker.clearSessionAttention("s1", "explicit");

    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["notification:clear-session-attention", ["s1", "explicit"]],
    ]);
  });

  it("routes scheduler actions with desktop preload argument order", async () => {
    const { calls, maker } = harness();

    await maker.schedule.list();
    await maker.schedule.list({ status: "paused" });
    await maker.schedule.get("sched-1");
    await maker.schedule.listTemplates();
    await maker.schedule.createFromTemplate({
      templateId: "standup-summary",
      paramValues: { project: "XDMaker" },
      overrides: { workingDir: "/repo" },
    });
    await maker.schedule.create({
      name: "Created",
      prompt: "run",
      kind: "cron",
      cronExpr: "*/10 * * * *",
      timezone: "Asia/Shanghai",
      recurring: true,
      intervalMs: 600_000,
      agentKind: "claude-code",
      workspaceKind: "project",
      workingDir: "/repo",
      useWorktree: false,
      notify: { desktop: true, feishu: false },
    });
    await maker.schedule.update("sched-1", { name: "Updated" });
    await maker.schedule.listRuns("sched-1", 50);
    await maker.schedule.runNow("sched-1");
    await maker.schedule.pause("sched-1");
    await maker.schedule.resume("sched-1");
    await maker.schedule.delete("sched-1");
    await maker.schedule.getInflightCount("sched-1");
    await maker.schedule.markRunRead("run-1");
    await maker.schedule.markScheduleRunsRead("sched-1");
    await maker.schedule.deleteRun("run-1");
    await maker.projectAutomation.removeSchedule({
      workingDir: "/repo",
      id: "daily",
    });

    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["maker:schedule:list", []],
      ["maker:schedule:list", [{ status: "paused" }]],
      ["maker:schedule:get", ["sched-1"]],
      ["maker:schedule:list-templates", []],
      [
        "maker:schedule:create-from-template",
        [
          {
            templateId: "standup-summary",
            paramValues: { project: "XDMaker" },
            overrides: { workingDir: "/repo" },
          },
        ],
      ],
      [
        "maker:schedule:create",
        [
          {
            name: "Created",
            prompt: "run",
            kind: "cron",
            cronExpr: "*/10 * * * *",
            timezone: "Asia/Shanghai",
            recurring: true,
            intervalMs: 600_000,
            agentKind: "claude-code",
            workspaceKind: "project",
            workingDir: "/repo",
            useWorktree: false,
            notify: { desktop: true, feishu: false },
          },
        ],
      ],
      ["maker:schedule:update", ["sched-1", { name: "Updated" }]],
      ["maker:schedule:list-runs", ["sched-1", 50]],
      ["maker:schedule:run-now", ["sched-1"]],
      ["maker:schedule:pause", ["sched-1"]],
      ["maker:schedule:resume", ["sched-1"]],
      ["maker:schedule:delete", ["sched-1"]],
      ["maker:schedule:get-inflight-count", ["sched-1"]],
      ["maker:schedule:mark-run-read", ["run-1"]],
      ["maker:schedule:mark-schedule-runs-read", ["sched-1"]],
      ["maker:schedule:delete-run", ["run-1"]],
      [
        "maker:project-automation:remove-schedule",
        [{ workingDir: "/repo", id: "daily" }],
      ],
    ]);
  });

  it("routes remote filesystem browse calls with device-link fs handler argument shape", async () => {
    const { calls, maker } = harness();

    await maker.fs.listDir("~");
    await maker.fs.statPath("/repo/app");
    await maker.fs.mkdirP("/repo/new-app");

    expect(calls.map((call) => [call.channel, call.args])).toEqual([
      ["fs:list-dir", [{ path: "~" }]],
      ["fs:stat-path", [{ path: "/repo/app" }]],
      ["fs:mkdir-p", [{ path: "/repo/new-app" }]],
    ]);
  });

  it("routes full file-browser ops through the aggregate remote-op channel", async () => {
    const { calls, maker } = harness();
    const wd = "/repo/project";

    await maker.fileBrowser.caps(wd);
    await maker.fileBrowser.listDir(wd, "apps/mobile");
    await maker.fileBrowser.listDir(wd, "dist", {
      includeIgnored: true,
      maxEntries: 2000,
    });
    await maker.fileBrowser.readFile(wd, "AGENTS.md", { acceptGzip: true });
    await maker.fileBrowser.readFile(wd, "AGENTS.md");
    await maker.fileBrowser.listAllFiles(wd, 20000);
    await maker.fileBrowser.searchCollect(wd, "UsageTracker", {
      maxMatches: 200,
    });
    await maker.fileBrowser.thumbnail(wd, "logo.png");
    await maker.fileBrowser.exportFileStart(wd, "big.bin");
    await maker.fileBrowser.exportFileStatus(wd, "exp_1");

    expect(calls.map((call) => call.channel)).toEqual(
      Array(10).fill("file-browser:remote-op"),
    );
    expect(calls.map((call) => call.args)).toEqual([
      [{ op: "caps", workdir: wd }],
      [{ op: "listDir", workdir: wd, relPath: "apps/mobile" }],
      [
        {
          op: "listDir",
          workdir: wd,
          relPath: "dist",
          includeIgnored: true,
          maxEntries: 2000,
        },
      ],
      [{ op: "readFile", workdir: wd, relPath: "AGENTS.md", acceptGzip: true }],
      [{ op: "readFile", workdir: wd, relPath: "AGENTS.md" }],
      [{ op: "listAllFiles", workdir: wd, cap: 20000 }],
      [
        {
          op: "searchCollect",
          workdir: wd,
          query: "UsageTracker",
          maxMatches: 200,
        },
      ],
      [{ op: "thumbnail", workdir: wd, relPath: "logo.png" }],
      [{ op: "exportFileStart", workdir: wd, relPath: "big.bin" }],
      [{ op: "exportFileStatus", workdir: wd, transferId: "exp_1" }],
    ]);
  });

  it("fails before invoking when the target device id is missing", async () => {
    const invokeMock = vi.fn();
    const invoke: RemoteInvoke = (deviceId, channel, args) =>
      invokeMock(deviceId, channel, args) as Promise<never>;
    const maker = createMobileMakerTransport({ deviceId: "", invoke });

    await expect(maker.listMessages("s1")).rejects.toThrow(
      "remote device id is required",
    );
    expect(invokeMock).not.toHaveBeenCalled();
  });
});

it('retries an existing image artifact on the task Host without sending a new prompt', async () => {
  const { calls, maker } = harness();
  await maker.input.retryImageDelivery('task', 'a'.repeat(64));
  expect(calls).toEqual([{ deviceId: 'dev-1', channel: 'maker:images:retry', args: ['task', 'a'.repeat(64)] }]);
});