Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
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)] }]);
});