@ccpocket/bridge 0.1.0

package/dist/sdk-process.js

@@ -0,0 +1,740 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { EventEmitter } from "node:events";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { normalizeToolResultContent, } from "./parser.js";
+// Tools that are auto-approved in acceptEdits mode
+export const ACCEPT_EDITS_AUTO_APPROVE = new Set([
+    "Read", "Glob", "Grep",
+    "Edit", "Write", "NotebookEdit",
+    "TaskCreate", "TaskUpdate", "TaskList", "TaskGet",
+    "EnterPlanMode", "AskUserQuestion",
+    "WebSearch", "WebFetch",
+    "Task", "Skill",
+]);
+const FILE_EDIT_TOOLS = new Set([
+    "Edit",
+    "Write",
+    "MultiEdit",
+    "NotebookEdit",
+]);
+function toFiniteNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return value;
+}
+export function isFileEditToolName(toolName) {
+    return FILE_EDIT_TOOLS.has(toolName);
+}
+export function extractTokenUsage(usage) {
+    if (!usage || typeof usage !== "object" || Array.isArray(usage)) {
+        return {};
+    }
+    const obj = usage;
+    const inputTokens = toFiniteNumber(obj.input_tokens)
+        ?? toFiniteNumber(obj.inputTokens);
+    const outputTokens = toFiniteNumber(obj.output_tokens)
+        ?? toFiniteNumber(obj.outputTokens);
+    const cachedReadTokens = toFiniteNumber(obj.cached_input_tokens)
+        ?? toFiniteNumber(obj.cache_read_input_tokens)
+        ?? toFiniteNumber(obj.cachedInputTokens)
+        ?? toFiniteNumber(obj.cacheReadInputTokens);
+    return {
+        ...(inputTokens != null ? { inputTokens } : {}),
+        ...(cachedReadTokens != null ? { cachedInputTokens: cachedReadTokens } : {}),
+        ...(outputTokens != null ? { outputTokens } : {}),
+    };
+}
+/**
+ * Parse a permission rule in ToolName(ruleContent) format.
+ * Matches the CLI's internal pzT() function: /^([^(]+)\(([^)]+)\)$/
+ */
+export function parseRule(rule) {
+    const match = rule.match(/^([^(]+)\(([^)]+)\)$/);
+    if (!match || !match[1] || !match[2])
+        return { toolName: rule };
+    return { toolName: match[1], ruleContent: match[2] };
+}
+/**
+ * Check if a tool invocation matches any session allow rule.
+ */
+export function matchesSessionRule(toolName, input, rules) {
+    for (const rule of rules) {
+        const parsed = parseRule(rule);
+        if (parsed.toolName !== toolName)
+            continue;
+        // No ruleContent -> matches any invocation of this tool
+        if (!parsed.ruleContent)
+            return true;
+        // Bash: prefix matching with ":*" suffix
+        if (toolName === "Bash" && typeof input.command === "string") {
+            if (parsed.ruleContent.endsWith(":*")) {
+                const prefix = parsed.ruleContent.slice(0, -2);
+                const firstWord = input.command.trim().split(/\s+/)[0] ?? "";
+                if (firstWord === prefix)
+                    return true;
+            }
+            else {
+                if (input.command === parsed.ruleContent)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Build a session allow rule string from a tool name and input.
+ * Bash: uses first word as prefix (e.g., "Bash(npm:*)")
+ * Others: tool name only (e.g., "Edit")
+ */
+export function buildSessionRule(toolName, input) {
+    if (toolName === "Bash" && typeof input.command === "string") {
+        const firstWord = input.command.trim().split(/\s+/)[0] ?? "";
+        if (firstWord)
+            return `${toolName}(${firstWord}:*)`;
+    }
+    return toolName;
+}
+/**
+ * Convert SDK messages to the ServerMessage format used by the WebSocket protocol.
+ * Exported for testing.
+ */
+export function sdkMessageToServerMessage(msg) {
+    switch (msg.type) {
+        case "system": {
+            const sys = msg;
+            if (sys.subtype === "init") {
+                return {
+                    type: "system",
+                    subtype: "init",
+                    sessionId: msg.session_id,
+                    model: sys.model,
+                    ...(sys.slash_commands ? { slashCommands: sys.slash_commands } : {}),
+                    ...(sys.skills ? { skills: sys.skills } : {}),
+                };
+            }
+            return null;
+        }
+        case "assistant": {
+            const ast = msg;
+            return {
+                type: "assistant",
+                message: ast.message,
+                ...(ast.uuid ? { messageUuid: ast.uuid } : {}),
+            };
+        }
+        case "user": {
+            const usr = msg;
+            // Filter out meta messages early (e.g., skill loading prompts).
+            // Following Happy Coder's approach: isMeta messages are not user-facing.
+            if (usr.isMeta)
+                return null;
+            const content = usr.message?.content;
+            if (!Array.isArray(content))
+                return null;
+            const results = content.filter((c) => c.type === "tool_result");
+            if (results.length > 0) {
+                const first = results[0];
+                const rawContent = first.content;
+                return {
+                    type: "tool_result",
+                    toolUseId: first.tool_use_id,
+                    content: normalizeToolResultContent(rawContent),
+                    ...(Array.isArray(rawContent) ? { rawContentBlocks: rawContent } : {}),
+                    ...(usr.uuid ? { userMessageUuid: usr.uuid } : {}),
+                };
+            }
+            // User text input (first prompt of each turn)
+            const texts = content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text);
+            if (texts.length > 0) {
+                return {
+                    type: "user_input",
+                    text: texts.join("\n"),
+                    ...(usr.uuid ? { userMessageUuid: usr.uuid } : {}),
+                    ...(usr.isSynthetic ? { isSynthetic: true } : {}),
+                    ...(usr.isMeta ? { isMeta: true } : {}),
+                };
+            }
+            return null;
+        }
+        case "result": {
+            const res = msg;
+            const tokenUsage = extractTokenUsage(res.usage);
+            if (res.subtype === "success") {
+                return {
+                    type: "result",
+                    subtype: "success",
+                    result: res.result,
+                    cost: res.total_cost_usd,
+                    duration: res.duration_ms,
+                    sessionId: msg.session_id,
+                    stopReason: res.stop_reason,
+                    ...tokenUsage,
+                };
+            }
+            // All other result subtypes are errors
+            const errorText = Array.isArray(res.errors) ? res.errors.join("\n") : "Unknown error";
+            // Suppress spurious CLI runtime errors (SDK bug: Bun API referenced on Node.js)
+            if (errorText.includes("Bun is not defined")) {
+                return null;
+            }
+            return {
+                type: "result",
+                subtype: "error",
+                error: errorText,
+                sessionId: msg.session_id,
+                stopReason: res.stop_reason,
+                ...tokenUsage,
+            };
+        }
+        case "stream_event": {
+            const stream = msg;
+            const event = stream.event;
+            if (event.type === "content_block_delta") {
+                const delta = event.delta;
+                if (delta.type === "text_delta" && delta.text) {
+                    return { type: "stream_delta", text: delta.text };
+                }
+                if (delta.type === "thinking_delta" && delta.thinking) {
+                    return { type: "thinking_delta", text: delta.thinking };
+                }
+            }
+            return null;
+        }
+        case "tool_use_summary": {
+            const summary = msg;
+            return {
+                type: "tool_use_summary",
+                summary: summary.summary,
+                precedingToolUseIds: summary.preceding_tool_use_ids,
+            };
+        }
+        default:
+            return null;
+    }
+}
+export class SdkProcess extends EventEmitter {
+    queryInstance = null;
+    _status = "idle";
+    _sessionId = null;
+    pendingPermissions = new Map();
+    _permissionMode;
+    get permissionMode() { return this._permissionMode; }
+    sessionAllowRules = new Set();
+    initTimeoutId = null;
+    // User message channel
+    userMessageResolve = null;
+    stopped = false;
+    pendingInput = null;
+    _projectPath = null;
+    toolCallsSinceLastResult = 0;
+    fileEditsSinceLastResult = 0;
+    get status() {
+        return this._status;
+    }
+    get isWaitingForInput() {
+        return this.userMessageResolve !== null;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get isRunning() {
+        return this.queryInstance !== null;
+    }
+    start(projectPath, options) {
+        if (this.queryInstance) {
+            this.stop();
+        }
+        this._projectPath = projectPath;
+        if (!existsSync(projectPath)) {
+            mkdirSync(projectPath, { recursive: true });
+        }
+        this.stopped = false;
+        this._sessionId = null;
+        this.pendingPermissions.clear();
+        this._permissionMode = options?.permissionMode;
+        this.sessionAllowRules.clear();
+        this.toolCallsSinceLastResult = 0;
+        this.fileEditsSinceLastResult = 0;
+        if (options?.initialInput) {
+            this.pendingInput = { text: options.initialInput };
+        }
+        this.setStatus("starting");
+        console.log(`[sdk-process] Starting SDK query (cwd: ${projectPath}, mode: ${options?.permissionMode ?? "default"})`);
+        // In -p mode with --input-format stream-json, Claude CLI won't emit
+        // system/init until the first user input. Set a fallback timeout to
+        // transition to "idle" if init hasn't arrived, since the process IS
+        // ready to accept input at that point.
+        if (this.initTimeoutId)
+            clearTimeout(this.initTimeoutId);
+        this.initTimeoutId = setTimeout(() => {
+            if (this._status === "starting") {
+                console.log("[sdk-process] Init timeout: setting status to idle (process ready for input)");
+                this.setStatus("idle");
+            }
+            this.initTimeoutId = null;
+        }, 3000);
+        this.queryInstance = query({
+            prompt: this.createUserMessageStream(),
+            options: {
+                cwd: projectPath,
+                resume: options?.sessionId,
+                continue: options?.continueMode,
+                permissionMode: options?.permissionMode ?? "default",
+                ...(options?.model ? { model: options.model } : {}),
+                ...(options?.effort ? { effort: options.effort } : {}),
+                ...(options?.maxTurns != null ? { maxTurns: options.maxTurns } : {}),
+                ...(options?.maxBudgetUsd != null ? { maxBudgetUsd: options.maxBudgetUsd } : {}),
+                ...(options?.fallbackModel ? { fallbackModel: options.fallbackModel } : {}),
+                ...(options?.forkSession != null ? { forkSession: options.forkSession } : {}),
+                ...(options?.persistSession != null ? { persistSession: options.persistSession } : {}),
+                hooks: {
+                    PostToolUse: [{
+                            hooks: [async (input) => {
+                                    this.handlePostToolUseHook(input);
+                                    return { continue: true };
+                                }],
+                        }],
+                },
+                includePartialMessages: true,
+                canUseTool: this.handleCanUseTool.bind(this),
+                settingSources: ["user", "project", "local"],
+                enableFileCheckpointing: true,
+                ...(options?.resumeSessionAt ? { resumeSessionAt: options.resumeSessionAt } : {}),
+            },
+        });
+        // Background message processing
+        this.processMessages().catch((err) => {
+            if (this.stopped) {
+                // Suppress errors from intentional stop (SDK bug: Bun API referenced on Node.js)
+                return;
+            }
+            console.error("[sdk-process] Message processing error:", err);
+            this.emitMessage({ type: "error", message: `SDK error: ${err instanceof Error ? err.message : String(err)}` });
+            this.setStatus("idle");
+            this.emit("exit", 1);
+        });
+        // Proactively fetch supported commands via SDK API (non-blocking)
+        this.fetchSupportedCommands();
+    }
+    stop() {
+        if (this.initTimeoutId) {
+            clearTimeout(this.initTimeoutId);
+            this.initTimeoutId = null;
+        }
+        this.stopped = true;
+        this.pendingInput = null;
+        if (this.queryInstance) {
+            console.log("[sdk-process] Stopping query");
+            this.queryInstance.close();
+            this.queryInstance = null;
+        }
+        this.pendingPermissions.clear();
+        this.userMessageResolve = null;
+        this.toolCallsSinceLastResult = 0;
+        this.fileEditsSinceLastResult = 0;
+        this.setStatus("idle");
+    }
+    interrupt() {
+        if (this.queryInstance) {
+            console.log("[sdk-process] Interrupting query");
+            this.pendingInput = null;
+            this.queryInstance.interrupt().catch((err) => {
+                console.error("[sdk-process] Interrupt error:", err);
+            });
+            this.pendingPermissions.clear();
+        }
+    }
+    sendInput(text) {
+        if (!this.userMessageResolve) {
+            // Queue the message instead of dropping it. The async generator
+            // (createUserMessageStream) checks pendingInput on each iteration,
+            // so the message will be delivered once the SDK is ready.
+            // NOTE: This is a single-slot queue — if called multiple times before
+            // the resolver is set, only the last message is preserved.
+            this.pendingInput = { text };
+            console.log("[sdk-process] Queued input (waiting for resolver)");
+            return;
+        }
+        const resolve = this.userMessageResolve;
+        this.userMessageResolve = null;
+        resolve({
+            type: "user",
+            session_id: this._sessionId ?? "",
+            message: {
+                role: "user",
+                content: [{ type: "text", text }],
+            },
+            parent_tool_use_id: null,
+        });
+    }
+    /**
+     * Send a message with an image attachment.
+     * @param text - The text message
+     * @param image - Base64-encoded image data with mime type
+     */
+    sendInputWithImage(text, image) {
+        if (!this.userMessageResolve) {
+            // Queue the message with image instead of dropping it.
+            this.pendingInput = { text, image };
+            console.log("[sdk-process] Queued input with image (waiting for resolver)");
+            return;
+        }
+        const resolve = this.userMessageResolve;
+        this.userMessageResolve = null;
+        const content = [];
+        // Add image block first (Claude processes images before text)
+        content.push({
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: image.mimeType,
+                data: image.base64,
+            },
+        });
+        // Add text block
+        content.push({ type: "text", text });
+        console.log(`[sdk-process] Sending message with image (${image.mimeType}, ${Math.round(image.base64.length / 1024)}KB base64)`);
+        resolve({
+            type: "user",
+            session_id: this._sessionId ?? "",
+            message: {
+                role: "user",
+                content,
+            },
+            parent_tool_use_id: null,
+        });
+    }
+    /**
+     * Approve a pending permission request.
+     * With the SDK, this actually blocks tool execution until approved.
+     */
+    approve(toolUseId, updatedInput) {
+        const id = toolUseId ?? this.firstPendingId();
+        const pending = id ? this.pendingPermissions.get(id) : undefined;
+        if (!pending) {
+            console.log("[sdk-process] approve() called but no pending permission requests");
+            return;
+        }
+        const mergedInput = updatedInput
+            ? { ...pending.input, ...updatedInput }
+            : pending.input;
+        this.pendingPermissions.delete(id);
+        pending.resolve({
+            behavior: "allow",
+            updatedInput: mergedInput,
+        });
+        if (this.pendingPermissions.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    /**
+     * Approve a pending permission request and add a session-scoped allow rule.
+     */
+    approveAlways(toolUseId) {
+        const id = toolUseId ?? this.firstPendingId();
+        const pending = id ? this.pendingPermissions.get(id) : undefined;
+        if (pending) {
+            const rule = buildSessionRule(pending.toolName, pending.input);
+            this.sessionAllowRules.add(rule);
+            console.log(`[sdk-process] Added session allow rule: ${rule}`);
+        }
+        this.approve(id);
+    }
+    /**
+     * Reject a pending permission request.
+     * The SDK's canUseTool will return deny, which tells Claude the tool was rejected.
+     */
+    reject(toolUseId, message) {
+        const id = toolUseId ?? this.firstPendingId();
+        const pending = id ? this.pendingPermissions.get(id) : undefined;
+        if (!pending) {
+            console.log("[sdk-process] reject() called but no pending permission requests");
+            return;
+        }
+        this.pendingPermissions.delete(id);
+        pending.resolve({
+            behavior: "deny",
+            message: message ?? "User rejected this action",
+        });
+        if (this.pendingPermissions.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    /**
+     * Answer an AskUserQuestion tool call.
+     * The SDK handles this through canUseTool with updatedInput.
+     */
+    answer(toolUseId, result) {
+        const pending = this.pendingPermissions.get(toolUseId);
+        if (!pending || pending.toolName !== "AskUserQuestion") {
+            console.log("[sdk-process] answer() called but no pending AskUserQuestion");
+            return;
+        }
+        this.pendingPermissions.delete(toolUseId);
+        pending.resolve({
+            behavior: "allow",
+            updatedInput: {
+                ...pending.input,
+                answers: { ...(pending.input.answers ?? {}), result },
+            },
+        });
+        if (this.pendingPermissions.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    /**
+     * Update permission mode for the current session.
+     * Only available while the query instance is active.
+     */
+    async setPermissionMode(mode) {
+        if (!this.queryInstance) {
+            throw new Error("No active query instance");
+        }
+        await this.queryInstance.setPermissionMode(mode);
+        this._permissionMode = mode;
+        this.emitMessage({
+            type: "system",
+            subtype: "set_permission_mode",
+            permissionMode: mode,
+            sessionId: this._sessionId ?? undefined,
+        });
+    }
+    /**
+     * Rewind files to their state at the specified user message.
+     * Requires enableFileCheckpointing to be enabled (done in start()).
+     */
+    async rewindFiles(userMessageId, dryRun) {
+        if (!this.queryInstance) {
+            return { canRewind: false, error: "No active query instance" };
+        }
+        try {
+            const result = await this.queryInstance.rewindFiles(userMessageId, { dryRun });
+            return result;
+        }
+        catch (err) {
+            return { canRewind: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    // ---- Private ----
+    /**
+     * Proactively fetch supported commands from the SDK.
+     * This may resolve before the first user input, providing slash commands
+     * without waiting for system/init.
+     */
+    fetchSupportedCommands() {
+        if (!this.queryInstance)
+            return;
+        const TIMEOUT_MS = 10_000;
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(() => resolve(null), TIMEOUT_MS);
+        });
+        Promise.race([
+            this.queryInstance.supportedCommands(),
+            timeoutPromise,
+        ])
+            .then((result) => {
+            if (this.stopped || !result)
+                return;
+            const slashCommands = result.map((cmd) => cmd.name);
+            console.log(`[sdk-process] supportedCommands() returned ${slashCommands.length} commands`);
+            this.emitMessage({
+                type: "system",
+                subtype: "supported_commands",
+                slashCommands,
+            });
+        })
+            .catch((err) => {
+            console.log(`[sdk-process] supportedCommands() failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    firstPendingId() {
+        const first = this.pendingPermissions.keys().next();
+        return first.done ? undefined : first.value;
+    }
+    /**
+     * Returns a snapshot of a pending permission request.
+     * Used by the bridge to support Clear & Accept flows.
+     */
+    getPendingPermission(toolUseId) {
+        const id = toolUseId ?? this.firstPendingId();
+        const pending = id ? this.pendingPermissions.get(id) : undefined;
+        if (!pending || !id)
+            return undefined;
+        return {
+            toolUseId: id,
+            toolName: pending.toolName,
+            input: { ...pending.input },
+        };
+    }
+    async *createUserMessageStream() {
+        while (!this.stopped) {
+            if (this.pendingInput) {
+                const { text, image } = this.pendingInput;
+                this.pendingInput = null;
+                console.log(`[sdk-process] Sending pending input${image ? " with image" : ""}`);
+                const content = [];
+                if (image) {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: image.mimeType,
+                            data: image.base64,
+                        },
+                    });
+                }
+                content.push({ type: "text", text });
+                yield {
+                    type: "user",
+                    session_id: this._sessionId ?? "",
+                    message: {
+                        role: "user",
+                        content,
+                    },
+                    parent_tool_use_id: null,
+                };
+                continue;
+            }
+            const msg = await new Promise((resolve) => {
+                this.userMessageResolve = resolve;
+            });
+            if (this.stopped)
+                break;
+            yield msg;
+        }
+    }
+    async processMessages() {
+        if (!this.queryInstance)
+            return;
+        for await (const message of this.queryInstance) {
+            if (this.stopped)
+                break;
+            // Convert SDK message to ServerMessage
+            let serverMsg = sdkMessageToServerMessage(message);
+            if (serverMsg?.type === "result") {
+                if (this.toolCallsSinceLastResult > 0 || this.fileEditsSinceLastResult > 0) {
+                    serverMsg = {
+                        ...serverMsg,
+                        ...(this.toolCallsSinceLastResult > 0
+                            ? { toolCalls: this.toolCallsSinceLastResult }
+                            : {}),
+                        ...(this.fileEditsSinceLastResult > 0
+                            ? { fileEdits: this.fileEditsSinceLastResult }
+                            : {}),
+                    };
+                }
+                this.toolCallsSinceLastResult = 0;
+                this.fileEditsSinceLastResult = 0;
+            }
+            if (serverMsg) {
+                this.emitMessage(serverMsg);
+            }
+            // Extract session ID from system/init
+            if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+                if (this.initTimeoutId) {
+                    clearTimeout(this.initTimeoutId);
+                    this.initTimeoutId = null;
+                }
+                this._sessionId = message.session_id;
+                this.setStatus("idle");
+            }
+            // Update status from message type
+            this.updateStatusFromMessage(message);
+        }
+        // Query finished
+        this.queryInstance = null;
+        this.setStatus("idle");
+        this.emit("exit", 0);
+    }
+    /**
+     * Core permission handler: called by SDK before each tool execution.
+     * Returns a Promise that resolves when the user approves/rejects.
+     */
+    async handleCanUseTool(toolName, input, options) {
+        // AskUserQuestion: always forward to client for response
+        if (toolName === "AskUserQuestion") {
+            return this.waitForPermission(options.toolUseID, toolName, input, options.signal);
+        }
+        // Auto-approve check: session allow rules
+        if (matchesSessionRule(toolName, input, this.sessionAllowRules)) {
+            return { behavior: "allow", updatedInput: input };
+        }
+        // SDK handles permissionMode internally, but canUseTool is only called
+        // for tools that the SDK thinks need permission. We emit the request
+        // to the mobile client and wait.
+        return this.waitForPermission(options.toolUseID, toolName, input, options.signal);
+    }
+    waitForPermission(toolUseId, toolName, input, signal) {
+        // Emit permission request to client
+        this.emitMessage({
+            type: "permission_request",
+            toolUseId,
+            toolName,
+            input,
+        });
+        this.setStatus("waiting_approval");
+        return new Promise((resolve) => {
+            this.pendingPermissions.set(toolUseId, { resolve, toolName, input });
+            // Handle abort (timeout)
+            if (signal.aborted) {
+                this.pendingPermissions.delete(toolUseId);
+                resolve({ behavior: "deny", message: "Permission request aborted" });
+                return;
+            }
+            signal.addEventListener("abort", () => {
+                if (this.pendingPermissions.has(toolUseId)) {
+                    this.pendingPermissions.delete(toolUseId);
+                    resolve({ behavior: "deny", message: "Permission request timed out" });
+                }
+            }, { once: true });
+        });
+    }
+    updateStatusFromMessage(msg) {
+        switch (msg.type) {
+            case "system":
+                // Already handled in processMessages for init
+                break;
+            case "assistant":
+                if (this.pendingPermissions.size === 0) {
+                    this.setStatus("running");
+                }
+                break;
+            case "user":
+                if (this.pendingPermissions.size === 0) {
+                    this.setStatus("running");
+                }
+                break;
+            case "result":
+                this.pendingPermissions.clear();
+                this.setStatus("idle");
+                break;
+        }
+    }
+    handlePostToolUseHook(input) {
+        if (!input || typeof input !== "object" || Array.isArray(input)) {
+            return;
+        }
+        const hookInput = input;
+        const toolName = hookInput.tool_name;
+        if (typeof toolName !== "string" || toolName.length === 0) {
+            return;
+        }
+        this.toolCallsSinceLastResult += 1;
+        if (isFileEditToolName(toolName)) {
+            this.fileEditsSinceLastResult += 1;
+        }
+    }
+    setStatus(status) {
+        if (this._status !== status) {
+            this._status = status;
+            this.emit("status", status);
+            this.emitMessage({ type: "status", status });
+        }
+    }
+    emitMessage(msg) {
+        this.emit("message", msg);
+    }
+}
+//# sourceMappingURL=sdk-process.js.map