@devicecloud.dev/dcd 5.11.0-beta.1 → 5.11.0-beta.2

package/dist/commands/live.d.ts

@@ -1,2 +1,4 @@
+/** Printed to stderr by every `dcd live` command. */
+export declare const LIVE_DEPRECATION: string;
 export declare const liveCommand: import("citty").CommandDef<import("citty").ArgsDef>;
 export default liveCommand;

package/dist/commands/live.js

@@ -10,6 +10,8 @@ import { resolveApiUrl } from '../utils/config-store.js';
 import { colors, formatUrl } from '../utils/styling.js';
 import { ui } from '../utils/ui.js';
 const PLATFORM_OPTIONS = ['android', 'ios'];
+/** Printed to stderr by every `dcd live` command. */
+export const LIVE_DEPRECATION = ui.deprecation('`dcd live` is deprecated and will be removed. Use `dcd device` instead: see `dcd device --help`.');
 const READY_TIMEOUT_MS = 180_000;
 const READY_POLL_MS = 2_000;
 async function requireAuth(keyFlag) {
@@ -591,8 +593,15 @@ export const liveCommand = defineCommand({
     meta: {
         name: 'live',
         description: 'Start and interact with a live device session',
+        // Replaced by `dcd device` (Agent Devices plan 3.4). Kept working for
+        // existing scripts, but no longer listed in `dcd --help`.
+        hidden: true,
     },
     subCommands,
+    // Runs before any subcommand. On stderr, so --json output is unchanged.
+    setup() {
+        process.stderr.write(`${LIVE_DEPRECATION}\n`);
+    },
     // citty's runCommand does not early-return after dispatching to a
     // subcommand — it still invokes the parent `run` afterwards. So when a
     // subcommand was matched, bail out here; otherwise the menu would print

package/dist/commands/login.js

@@ -33,11 +33,11 @@
  */
 import * as p from '@clack/prompts';
 import { defineCommand } from 'citty';
-import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { ENVIRONMENTS, inferEnvFromApiUrl, resolveFrontendUrl, } from '../config/environments.js';
 import { getSupabaseKey } from '../config/supabase-key.js';
 import { jsonFlag } from '../config/flags/output.flags.js';
+import { openBrowser } from '../utils/browser.js';
 import { canPrompt } from '../utils/ci.js';
 import { CliError, logger } from '../utils/cli.js';
 import { readConfig, writeConfig } from '../utils/config-store.js';
@@ -235,21 +235,6 @@ export const loginCommand = defineCommand({
         }
     },
 });
-function openBrowser(url) {
-    const cmd = process.platform === 'darwin'
-        ? { bin: 'open', args: [url] }
-        : process.platform === 'win32'
-            ? { bin: 'cmd', args: ['/c', 'start', '""', url] }
-            : { bin: 'xdg-open', args: [url] };
-    try {
-        const child = spawn(cmd.bin, cmd.args, { detached: true, stdio: 'ignore' });
-        child.unref();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function pollForClaim(apiUrl, state, codeVerifier) {
     const claimUrl = `${apiUrl}/cli-login/claim`;
     const deadline = Date.now() + LOGIN_TIMEOUT_MS;

package/dist/commands/mcp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `dcd mcp`: the MCP server over stdio, for MCP clients to launch. It serves
+ * the dcd_* cloud-test tools and the device tools (see src/mcp/bridge.ts).
+ * Nothing but JSON-RPC may reach stdout.
+ */
+export declare const mcpCommand: import("citty").CommandDef<{
+    readonly 'read-only': {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly description: "Serve only tools that change nothing (also DCD_MCP_READONLY=1)";
+    };
+}>;

package/dist/commands/mcp.js

@@ -0,0 +1,29 @@
+import { defineCommand } from 'citty';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createBridgeServer } from '../mcp/bridge.js';
+import { isReadOnly, logStderr } from '../mcp/context.js';
+import { telemetry } from '../services/telemetry.service.js';
+/**
+ * `dcd mcp`: the MCP server over stdio, for MCP clients to launch. It serves
+ * the dcd_* cloud-test tools and the device tools (see src/mcp/bridge.ts).
+ * Nothing but JSON-RPC may reach stdout.
+ */
+export const mcpCommand = defineCommand({
+    meta: {
+        name: 'mcp',
+        description: 'Run the DeviceCloud MCP server on stdio (cloud tests and cloud devices)',
+    },
+    args: {
+        'read-only': {
+            type: 'boolean',
+            default: false,
+            description: 'Serve only tools that change nothing (also DCD_MCP_READONLY=1)',
+        },
+    },
+    async run() {
+        telemetry.setCommand('mcp');
+        const server = await createBridgeServer();
+        await server.connect(new StdioServerTransport());
+        logStderr(`DeviceCloud MCP server running on stdio${isReadOnly() ? ' (read-only)' : ''}`);
+    },
+});

package/dist/gateways/device-gateway.d.ts

@@ -0,0 +1,88 @@
+import type { AuthContext } from '../types/domain/auth.types.js';
+import type { DeviceArtifactsPage, DeviceBundleUploadUrls, DeviceFlowBundle, DeviceCatalogue, DeviceCommandResult, DeviceHumanStatus, DeviceInstalledApp, DeviceLogs, DeviceRunResponse, DeviceScreen, DeviceScreenshot, DeviceSession, StartDeviceSessionRequest } from '../types/domain/device-session.types.js';
+/**
+ * An error answer from /device/sessions. Unlike ApiError it keeps the API's
+ * machine code (`LIVE_NOT_FOUND`, `LIVE_SPEND_CAP`, …) and the `session`
+ * block some errors carry, because `dcd device` maps the code to an exit code
+ * and prints the session in its JSON envelope.
+ */
+export declare class DeviceApiError extends Error {
+    code: null | string;
+    session: DeviceSession | null;
+    status: number;
+    constructor(message: string, status: number, code: null | string, session: DeviceSession | null);
+}
+/** The Agent Devices session API (dcd docs/device-v1-plan.md, section 4.1). */
+export declare const DeviceGateway: {
+    artifacts(baseUrl: string, auth: AuthContext, id: string, before?: string): Promise<DeviceArtifactsPage>;
+    bundleUploadUrls(baseUrl: string, auth: AuthContext, bytes: number): Promise<DeviceBundleUploadUrls>;
+    command(baseUrl: string, auth: AuthContext, id: string, commandId: string): Promise<DeviceRunResponse>;
+    /** Whether the session waits for a person, or was handed back. */
+    human(baseUrl: string, auth: AuthContext, id: string): Promise<{
+        human: DeviceHumanStatus;
+        session: DeviceSession;
+    }>;
+    inspect(baseUrl: string, auth: AuthContext, id: string): Promise<{
+        screen: DeviceScreen;
+        session: DeviceSession;
+    }>;
+    install(baseUrl: string, auth: AuthContext, id: string, app: {
+        binaryUploadId: string;
+    } | {
+        url: string;
+    }): Promise<{
+        app: DeviceInstalledApp;
+        session: DeviceSession;
+    }>;
+    launch(baseUrl: string, auth: AuthContext, id: string, body: {
+        appId?: string;
+        clearState?: boolean;
+    }): Promise<{
+        result: DeviceCommandResult;
+        session: DeviceSession;
+    }>;
+    list(baseUrl: string, auth: AuthContext, all?: boolean): Promise<{
+        sessions: DeviceSession[];
+    }>;
+    logs(baseUrl: string, auth: AuthContext, id: string, lines: number): Promise<{
+        logs: DeviceLogs;
+        session: DeviceSession;
+    }>;
+    models(baseUrl: string, auth: AuthContext): Promise<DeviceCatalogue>;
+    registerBundle(baseUrl: string, auth: AuthContext, body: {
+        backblaze: boolean;
+        bytes: number;
+        enc?: unknown;
+        id: string;
+        sha: string;
+        supabase: boolean;
+    }): Promise<{
+        bundle: DeviceFlowBundle;
+    }>;
+    /** Ask a person for help: the session moves to needs_human until they hand it back. */
+    requestHuman(baseUrl: string, auth: AuthContext, id: string, reason: string): Promise<{
+        human: DeviceHumanStatus;
+        session: DeviceSession;
+    }>;
+    run(baseUrl: string, auth: AuthContext, id: string, body: {
+        env?: Record<string, string>;
+        flow?: string;
+        flowUploadId: string;
+    } | {
+        env?: Record<string, string>;
+        yaml: string;
+    }): Promise<DeviceRunResponse>;
+    screenshot(baseUrl: string, auth: AuthContext, id: string): Promise<{
+        screenshot: DeviceScreenshot;
+        session: DeviceSession;
+    }>;
+    start(baseUrl: string, auth: AuthContext, body: StartDeviceSessionRequest): Promise<{
+        session: DeviceSession;
+    }>;
+    status(baseUrl: string, auth: AuthContext, id: string): Promise<{
+        session: DeviceSession;
+    }>;
+    stop(baseUrl: string, auth: AuthContext, id: string): Promise<{
+        session: DeviceSession;
+    }>;
+};

package/dist/gateways/device-gateway.js

@@ -0,0 +1,140 @@
+import { ApiGateway } from './api-gateway.js';
+/**
+ * An error answer from /device/sessions. Unlike ApiError it keeps the API's
+ * machine code (`LIVE_NOT_FOUND`, `LIVE_SPEND_CAP`, …) and the `session`
+ * block some errors carry, because `dcd device` maps the code to an exit code
+ * and prints the session in its JSON envelope.
+ */
+export class DeviceApiError extends Error {
+    code;
+    session;
+    status;
+    constructor(message, status, code, session) {
+        super(message);
+        this.name = 'DeviceApiError';
+        this.status = status;
+        this.code = code;
+        this.session = session;
+    }
+}
+/**
+ * The API's error envelope: `{ statusCode, message, error? }`, where `error`
+ * is either Nest's status text or a machine code such as LIVE_NOT_FOUND.
+ * Only an upper-case code is kept, so "Not Found" never reads as one.
+ */
+async function toDeviceApiError(res, path) {
+    const text = await res.text();
+    let body = {};
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        // Not JSON: a proxy page or plain text. The text is the message.
+    }
+    const raw = Array.isArray(body.message) ? body.message.join('; ') : body.message;
+    let message = typeof raw === 'string' && raw ? raw : text.trim() || `HTTP ${res.status}`;
+    if (res.status === 401) {
+        message =
+            'Authentication failed — your credentials are invalid or expired. ' +
+                `Re-run \`dcd login\` or check your API key. (${message})`;
+    }
+    const code = typeof body.error === 'string' && /^[A-Z][A-Z0-9_]+$/.test(body.error) ? body.error : null;
+    if (code === 'LIVE_HUMAN_IN_CONTROL') {
+        // The API's text points at MCP and raw HTTP too; a CLI user needs the command.
+        const id = /^\/device\/sessions\/([^/?]+)/.exec(path)?.[1];
+        const name = id ? decodeURIComponent(id) : '<id>';
+        message =
+            `A person has taken control of ${name} in the console, so it takes no commands until they hand it back. ` +
+                `Wait for that with \`dcd device human ${name} --wait\`.`;
+    }
+    const session = body.session && typeof body.session === 'object' ? body.session : null;
+    return new DeviceApiError(message, res.status, code, session);
+}
+async function request(baseUrl, auth, method, path, body) {
+    const url = `${baseUrl}${path}`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method,
+            headers: {
+                ...auth.headers,
+                // Recorded as the command's source in the session timeline.
+                'x-dcd-source': 'cli',
+                ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message === 'fetch failed') {
+            throw ApiGateway.enhanceFetchError(error, url);
+        }
+        throw error;
+    }
+    if (!res.ok)
+        throw await toDeviceApiError(res, path);
+    try {
+        return (await res.json());
+    }
+    catch (error) {
+        throw new Error(`${method} ${path}: the API returned an invalid JSON response (${error instanceof Error ? error.message : String(error)})`, { cause: error });
+    }
+}
+const sessionPath = (id) => `/device/sessions/${encodeURIComponent(id)}`;
+/** The Agent Devices session API (dcd docs/device-v1-plan.md, section 4.1). */
+export const DeviceGateway = {
+    artifacts(baseUrl, auth, id, before) {
+        const query = new URLSearchParams({ limit: '200', ...(before && { before }) });
+        return request(baseUrl, auth, 'GET', `${sessionPath(id)}/artifacts?${query}`);
+    },
+    bundleUploadUrls(baseUrl, auth, bytes) {
+        return request(baseUrl, auth, 'POST', '/device/bundles/upload-url', { bytes });
+    },
+    command(baseUrl, auth, id, commandId) {
+        return request(baseUrl, auth, 'GET', `${sessionPath(id)}/commands/${encodeURIComponent(commandId)}`);
+    },
+    /** Whether the session waits for a person, or was handed back. */
+    human(baseUrl, auth, id) {
+        return request(baseUrl, auth, 'GET', `${sessionPath(id)}/human`);
+    },
+    inspect(baseUrl, auth, id) {
+        return request(baseUrl, auth, 'GET', `${sessionPath(id)}/inspect`);
+    },
+    install(baseUrl, auth, id, app) {
+        return request(baseUrl, auth, 'POST', `${sessionPath(id)}/install`, app);
+    },
+    launch(baseUrl, auth, id, body) {
+        return request(baseUrl, auth, 'POST', `${sessionPath(id)}/launch`, body);
+    },
+    list(baseUrl, auth, all = false) {
+        return request(baseUrl, auth, 'GET', `/device/sessions${all ? '?all=true' : ''}`);
+    },
+    logs(baseUrl, auth, id, lines) {
+        return request(baseUrl, auth, 'GET', `${sessionPath(id)}/logs?lines=${lines}`);
+    },
+    models(baseUrl, auth) {
+        return request(baseUrl, auth, 'GET', '/device/models');
+    },
+    registerBundle(baseUrl, auth, body) {
+        return request(baseUrl, auth, 'POST', '/device/bundles', body);
+    },
+    /** Ask a person for help: the session moves to needs_human until they hand it back. */
+    requestHuman(baseUrl, auth, id, reason) {
+        return request(baseUrl, auth, 'POST', `${sessionPath(id)}/request-human`, { reason });
+    },
+    run(baseUrl, auth, id, body) {
+        return request(baseUrl, auth, 'POST', `${sessionPath(id)}/run`, body);
+    },
+    screenshot(baseUrl, auth, id) {
+        return request(baseUrl, auth, 'GET', `${sessionPath(id)}/screenshot`);
+    },
+    start(baseUrl, auth, body) {
+        return request(baseUrl, auth, 'POST', '/device/sessions', body);
+    },
+    status(baseUrl, auth, id) {
+        return request(baseUrl, auth, 'GET', sessionPath(id));
+    },
+    stop(baseUrl, auth, id) {
+        return request(baseUrl, auth, 'DELETE', sessionPath(id));
+    },
+};

package/dist/index.js

@@ -3,10 +3,12 @@ import { updateSettings } from '@clack/prompts';
 import { defineCommand, runCommand, showUsage } from 'citty';
 import { artifactsCommand } from './commands/artifacts.js';
 import { cloudCommand } from './commands/cloud.js';
+import { deviceCommand } from './commands/device.js';
 import { listCommand } from './commands/list.js';
 import { liveCommand } from './commands/live.js';
 import { loginCommand } from './commands/login.js';
 import { logoutCommand } from './commands/logout.js';
+import { mcpCommand } from './commands/mcp.js';
 import { statusCommand } from './commands/status.js';
 import { switchOrgCommand } from './commands/switch-org.js';
 import { upgradeCommand } from './commands/upgrade.js';
@@ -30,7 +32,9 @@ const main = defineCommand({
         list: listCommand,
         status: statusCommand,
         artifacts: artifactsCommand,
+        device: deviceCommand,
         live: liveCommand,
+        mcp: mcpCommand,
         login: loginCommand,
         logout: logoutCommand,
         whoami: whoamiCommand,

package/dist/mcp/bridge.d.ts

@@ -0,0 +1,27 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { type Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { AuthContext } from '../types/domain/auth.types.js';
+/**
+ * How long one forwarded call may take. Longer than dcd_run_cloud_test's
+ * longest wait (3600s) plus an upload. The MCP client calling this server
+ * still applies its own timeout, and its cancel is passed through.
+ */
+export declare const CALL_TIMEOUT_MS: number;
+/** A hosted tool with this bridge's local inputs added. */
+export declare function withLocalInputs(tool: Tool): Tool;
+/**
+ * Do the local part of a call (uploads, reading a file) and return the
+ * arguments the hosted tool takes.
+ */
+export declare function resolveLocalInputs(name: string, args: Record<string, unknown>, ctx: {
+    apiUrl: string;
+    auth: AuthContext;
+}): Promise<Record<string, unknown>>;
+/**
+ * Build the `dcd mcp` server. Without a reachable hosted endpoint (no
+ * credentials yet, or an API without it), it still serves the dcd_* tools
+ * and says why on stderr.
+ */
+export declare function createBridgeServer(opts?: {
+    callTimeoutMs?: number;
+}): Promise<Server>;

package/dist/mcp/bridge.js

@@ -0,0 +1,209 @@
+/**
+ * `dcd mcp`: one stdio MCP server with two sets of tools (dcd plan 4.4).
+ *
+ * - The `dcd_*` cloud-test tools, from the same in-process server `dcd-mcp`
+ *   runs (createServer), reached over an in-memory transport.
+ * - The device tools, proxied from the hosted endpoint at `<api>/mcp`, so
+ *   they are defined (and contract-tested) once, in the API. The bridge adds
+ *   what a remote server can't do: `install_app` takes a local `app_path`,
+ *   and `run` takes a local `path` (a flow file, or a directory uploaded as
+ *   a bundle).
+ *
+ * Auth is the CLI's: an API key or a `dcd login` session (getContext). The
+ * hosted endpoint accepts both. A session is renewed before it expires, and
+ * the remote connection is remade with it.
+ *
+ * stdout is the JSON-RPC channel: everything else goes to stderr.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { uploadLocalApp } from '../utils/app-upload.js';
+import { getCliVersion } from '../utils/cli.js';
+import { uploadFlowBundle } from '../utils/device-bundle.js';
+import { getContext, isReadOnly, logStderr } from './context.js';
+import { errorResult, runTool } from './helpers.js';
+import { createServer } from './server.js';
+const INSTRUCTIONS = 'DeviceCloud tools. dcd_* tools run Maestro test suites in the cloud. The device tools lease a cloud iOS or Android device for you to drive: start_device, then inspect_screen / take_screenshot, launch_app, run, and stop_device when done. Call cheat_sheet first for Maestro syntax. Local files: install_app takes app_path and run takes path (a flow file or a directory), which this server uploads for you.';
+/**
+ * How long one forwarded call may take. Longer than dcd_run_cloud_test's
+ * longest wait (3600s) plus an upload. The MCP client calling this server
+ * still applies its own timeout, and its cancel is passed through.
+ */
+export const CALL_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+const READ_ONLY_INSTRUCTIONS = 'DeviceCloud tools, read-only: nothing here starts a device, runs a test or changes anything. dcd_* tools read cloud test runs and their results. The device tools read open device sessions: list_devices, get_device_status, inspect_screen, take_screenshot, get_logs.';
+/** The inputs this bridge adds to hosted tools, and what they say. */
+const LOCAL_INPUTS = {
+    install_app: {
+        description: ' Or pass app_path, a build on this machine (.apk, or a simulator .app / .zip / Expo .tar.gz), which is uploaded first.',
+        properties: {
+            app_path: {
+                type: 'string',
+                description: 'A build on this machine to upload and install. Pass this, app_binary_id or app_url.',
+            },
+        },
+    },
+    run: {
+        description: ' Or pass path: a flow file on this machine (sent as yaml), or a directory of flows (uploaded as a bundle; flow picks the entry file inside it).',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'A local flow file, or a directory of flows. Pass this, yaml or flow_upload_id.',
+            },
+        },
+    },
+};
+/** A hosted tool with this bridge's local inputs added. */
+export function withLocalInputs(tool) {
+    const extra = LOCAL_INPUTS[tool.name];
+    if (!extra)
+        return tool;
+    return {
+        ...tool,
+        description: `${tool.description ?? ''}${extra.description}`,
+        inputSchema: {
+            ...tool.inputSchema,
+            properties: { ...tool.inputSchema.properties, ...extra.properties },
+        },
+    };
+}
+/**
+ * Do the local part of a call (uploads, reading a file) and return the
+ * arguments the hosted tool takes.
+ */
+export async function resolveLocalInputs(name, args, ctx) {
+    if (name === 'install_app' && typeof args.app_path === 'string') {
+        const { app_path: filePath, ...rest } = args;
+        logStderr(`Uploading ${filePath}…`);
+        const binaryId = await uploadLocalApp({
+            ...ctx,
+            filePath: filePath,
+            log: logStderr,
+            showProgress: false,
+        });
+        return { ...rest, app_binary_id: binaryId };
+    }
+    if (name === 'run' && typeof args.path === 'string') {
+        const { path: flowPath, ...rest } = args;
+        const info = await stat(flowPath).catch(() => null);
+        if (!info)
+            throw new Error(`No such file or directory: ${flowPath}`);
+        if (info.isDirectory()) {
+            logStderr(`Uploading the flows in ${flowPath}…`);
+            const bundle = await uploadFlowBundle({ ...ctx, dir: flowPath, log: logStderr });
+            return { ...rest, flow_upload_id: bundle.id };
+        }
+        return { ...rest, yaml: await readFile(flowPath, 'utf8') };
+    }
+    return args;
+}
+/**
+ * The hosted device tools, over one connection made on first use and shared
+ * by every call.
+ *
+ * Auth goes on each request, not on the connection. Remaking the connection
+ * when a session is renewed would close it under calls still running (a `run`
+ * can take minutes), and they would fail with "Connection closed" while the
+ * flow carried on. The hosted /mcp is stateless, so nothing ties the
+ * connection to the auth it started with.
+ */
+class RemoteDevices {
+    connecting = null;
+    tools = null;
+    /** Calls that arrive together share one connect. A failed one is retried by the next call. */
+    connect() {
+        this.connecting ??= this.open().catch((error) => {
+            this.connecting = null;
+            throw error;
+        });
+        return this.connecting;
+    }
+    async open() {
+        const { apiUrl } = await getContext();
+        const client = new Client({ name: 'dcd-mcp-bridge', version: getCliVersion() });
+        await client.connect(new StreamableHTTPClientTransport(new URL(`${apiUrl}/mcp`), {
+            fetch: async (url, init) => {
+                const { auth } = await getContext();
+                const headers = new Headers(init?.headers);
+                for (const [key, value] of Object.entries(auth.headers))
+                    headers.set(key, value);
+                return fetch(url, { ...init, headers });
+            },
+        }));
+        return client;
+    }
+    async list() {
+        if (this.tools)
+            return this.tools;
+        const client = await this.connect();
+        const { tools } = await client.listTools();
+        this.tools = tools;
+        return tools;
+    }
+    has(name) {
+        return this.tools?.some((t) => t.name === name) ?? false;
+    }
+    /** Annotated read-only by the hosted server: changes nothing, costs nothing. */
+    isReadOnly(name) {
+        return this.tools?.find((t) => t.name === name)?.annotations?.readOnlyHint === true;
+    }
+}
+/**
+ * Build the `dcd mcp` server. Without a reachable hosted endpoint (no
+ * credentials yet, or an API without it), it still serves the dcd_* tools
+ * and says why on stderr.
+ */
+export async function createBridgeServer(opts = {}) {
+    const callTimeoutMs = opts.callTimeoutMs ?? CALL_TIMEOUT_MS;
+    const [localClientSide, localServerSide] = InMemoryTransport.createLinkedPair();
+    await createServer().connect(localServerSide);
+    const local = new Client({ name: 'dcd-mcp-bridge', version: getCliVersion() });
+    await local.connect(localClientSide);
+    const localNames = new Set((await local.listTools()).tools.map((t) => t.name));
+    const remote = new RemoteDevices();
+    const readOnly = isReadOnly();
+    const server = new Server({ name: 'devicecloud', version: getCliVersion() }, {
+        capabilities: { tools: {} },
+        instructions: readOnly ? READ_ONLY_INSTRUCTIONS : INSTRUCTIONS,
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const { tools: localTools } = await local.listTools();
+        let deviceTools = [];
+        try {
+            deviceTools = (await remote.list())
+                // Read-only mode keeps only the tools that change nothing.
+                .filter((t) => !readOnly || t.annotations?.readOnlyHint === true)
+                .map((t) => withLocalInputs(t));
+        }
+        catch (error) {
+            logStderr(`Device tools unavailable: ${error instanceof Error ? error.message : String(error)}. Serving the dcd_* tools only.`);
+        }
+        return { tools: [...localTools, ...deviceTools] };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        // The client's own timeout and cancel apply, not the SDK's 60s default:
+        // dcd_run_cloud_test can wait an hour, and a device run or upload is long.
+        const options = { signal: extra.signal, timeout: callTimeoutMs, resetTimeoutOnProgress: true };
+        const { name } = request.params;
+        const args = (request.params.arguments ?? {});
+        if (localNames.has(name)) {
+            return (await local.callTool({ name, arguments: args }, undefined, options));
+        }
+        return runTool(`device ${name}`, async () => {
+            await remote.list();
+            if (!remote.has(name))
+                return errorResult(`Unknown tool: ${name}`);
+            // The list hides these in read-only mode; refuse them if called anyway.
+            if (readOnly && !remote.isReadOnly(name)) {
+                return errorResult(`${name} is not available in read-only mode.`);
+            }
+            const client = await remote.connect();
+            const remoteArgs = await resolveLocalInputs(name, args, await getContext());
+            return (await client.callTool({ name, arguments: remoteArgs }, undefined, options));
+        });
+    });
+    return server;
+}

package/dist/methods.js

@@ -125,7 +125,7 @@ export const uploadBinary = async (config) => {
             if (exists && binaryId) {
                 if (log) {
                     ux.info(colors.dim('SHA hash matches existing binary with ID: ') + formatId(binaryId) + colors.dim(', skipping upload. Force upload with --ignore-sha-check'));
-                    ux.action.stop(colors.info('Skipping upload'));
+                    ux.action.stop('Skipping upload');
                 }
                 return binaryId;
             }
@@ -158,13 +158,13 @@ export const uploadBinary = async (config) => {
             startTime,
         });
         if (log) {
-            ux.action.stop(colors.success('\n✓ Binary uploaded with ID: ') + formatId(uploadId));
+            ux.action.stop(colors.success('Binary uploaded with ID: ') + formatId(uploadId));
         }
         return uploadId;
     }
     catch (error) {
         if (log) {
-            ux.action.stop(colors.error('✗ Failed'));
+            ux.action.fail(colors.error('Failed'));
         }
         if (debug) {
             console.error('[DEBUG] === BINARY UPLOAD FAILED ===');

package/dist/services/moropo.service.js

@@ -59,7 +59,7 @@ export class MoropoService {
         }
         catch (error) {
             if (!quiet && !json) {
-                ux.action.stop('failed');
+                ux.action.fail('failed');
             }
             // Remove the temp directory (and any partially-written zip inside it)
             if (moropoDir) {

package/dist/services/results-polling.service.js

@@ -121,7 +121,7 @@ export class ResultsPollingService {
             // displayFinalResults. Anything else aborts mid-poll with the spinner
             // still live, which would corrupt the terminal under the error output.
             if (!options.json && !(error instanceof RunFailedError)) {
-                ux.action.stop(colors.error('failed'));
+                ux.action.fail(colors.error('failed'));
             }
             throw error;
         }