happy-imou-cloud 2.1.1 → 2.1.2

package/dist/{runGemini-BMiho2ab.mjs → runGemini-Bmoxehlh.mjs}

@@ -1,10 +1,10 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { randomUUID } from 'node:crypto';
-import { l as logger, f as connectionState, A as ApiClient } from './api-DBy5lPZw.mjs';
-import { B as BasePermissionHandler, C as ConversationHistory$1, e as ensureManagedProviderMachine, M as MissingMachineIdError, s as syncControlledByUserState, b as MessageQueue2, h as hashObject, d as MessageBuffer, r as registerKillSessionHandler, w as waitForResponseCompleteWithAbort, f as closeProviderSession, l as launchRuntimeHandleWithFactoryResult, i as inferToolResultError, j as forwardAgentMessageToProviderSession } from './registerKillSessionHandler-D4_wpN18.mjs';
-import { g as getInitialGeminiModel, r as readGeminiLocalConfig, G as GEMINI_MODEL_ENV, s as saveGeminiModelToConfig, a as createGeminiBackend, b as stopCaffeinate } from './index-66vjECEd.mjs';
-import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-Dn9FxfxU.mjs';
+import { l as logger, b as connectionState, A as ApiClient } from './api-Cxifhw5r.mjs';
+import { B as BasePermissionHandler, C as ConversationHistory$1, r as resolveHappyOrgQueuedTurn, e as ensureManagedProviderMachine, M as MissingMachineIdError, s as syncControlledByUserState, b as MessageQueue2, h as hashObject, d as registerKillSessionHandler, f as MessageBuffer, i as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, j as finalizeHappyOrgTurn, k as closeProviderSession, l as launchRuntimeHandleWithFactoryResult, m as inferToolResultError, n as forwardAgentMessageToProviderSession } from './registerKillSessionHandler-BFBkz_XT.mjs';
+import { g as getInitialGeminiModel, r as readGeminiLocalConfig, G as GEMINI_MODEL_ENV, s as saveGeminiModelToConfig, a as createGeminiBackend, b as stopCaffeinate } from './index-Des7I5WX.mjs';
+import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-BaOWkVcu.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
 import 'ps-list';
@@ -15,7 +15,7 @@ import 'node:child_process';
 import 'node:readline';
 import 'tweetnacl';
 import 'axios';
-import './persistence-BOWh1NER.mjs';
+import './persistence-6d4U4Sh8.mjs';
 import 'open';
 import 'chalk';
 import 'fs';
@@ -430,6 +430,116 @@ class ConversationHistory extends ConversationHistory$1 {
   }
 }
 
+const GEMINI_PERMISSION_MODES = [
+  "default",
+  "read-only",
+  "safe-yolo",
+  "yolo"
+];
+function isGeminiPermissionMode(value) {
+  return typeof value === "string" && GEMINI_PERMISSION_MODES.includes(value);
+}
+function hasMetaOverride(message, key) {
+  return Object.prototype.hasOwnProperty.call(message.meta ?? {}, key);
+}
+function resolveGeminiQueuedMessage(message, currentState) {
+  const previousState = { ...currentState };
+  const currentPermissionMode = isGeminiPermissionMode(currentState.permissionMode) ? currentState.permissionMode : void 0;
+  let permissionMode = currentPermissionMode;
+  let invalidPermissionMode = null;
+  if (hasMetaOverride(message, "permissionMode")) {
+    if (isGeminiPermissionMode(message.meta?.permissionMode)) {
+      permissionMode = message.meta.permissionMode;
+    } else if (message.meta?.permissionMode) {
+      invalidPermissionMode = String(message.meta.permissionMode);
+    }
+  }
+  const hasModelOverride = hasMetaOverride(message, "model");
+  const model = hasModelOverride ? message.meta?.model || void 0 : currentState.model;
+  const originalUserMessage = message.content.text;
+  let queuedText = originalUserMessage;
+  const isFirstMessage = currentState.isFirstMessage ?? true;
+  let nextIsFirstMessage = isFirstMessage;
+  if (isFirstMessage && message.meta?.appendSystemPrompt) {
+    queuedText = `${message.meta.appendSystemPrompt}
+
+${originalUserMessage}`;
+    nextIsFirstMessage = false;
+  }
+  const nextState = {
+    permissionMode: permissionMode ?? "default",
+    model,
+    isFirstMessage: nextIsFirstMessage
+  };
+  return {
+    previousState,
+    nextState,
+    invalidPermissionMode,
+    hasModelOverride,
+    queuedMessage: {
+      text: queuedText,
+      mode: {
+        permissionMode: nextState.permissionMode ?? "default",
+        model,
+        originalUserMessage
+      }
+    }
+  };
+}
+function bindGeminiUserMessageQueue(opts) {
+  let currentState = { ...opts.initialState };
+  opts.session.onUserMessage((message) => {
+    const happyOrgResult = opts.happyOrg ? resolveHappyOrgQueuedTurn({
+      metadata: opts.happyOrg.getMetadata(),
+      message
+    }) : {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false,
+      statusMessage: void 0
+    };
+    if (opts.happyOrg && happyOrgResult.nextMetadata) {
+      opts.happyOrg.updateMetadata(() => happyOrgResult.nextMetadata);
+    }
+    if (happyOrgResult.blocked) {
+      if (happyOrgResult.statusMessage) {
+        opts.happyOrg?.emitStatusMessage(happyOrgResult.statusMessage);
+      }
+      logger.debugLargeJson("[gemini] User message blocked by Happy Org runtime:", message);
+      return;
+    }
+    const resolution = resolveGeminiQueuedMessage(message, currentState);
+    currentState = resolution.nextState;
+    resolution.queuedMessage.mode.happyOrg = happyOrgResult.queuedTurn;
+    opts.onResolvedMessage?.(resolution);
+    opts.messageQueue.push(resolution.queuedMessage.text, resolution.queuedMessage.mode);
+    logger.debugLargeJson("[gemini] User message queued:", message);
+  });
+}
+
+function normalizeGeminiBackendError(error) {
+  if (typeof error === "string") {
+    return error.trim() || "Gemini runtime exited unexpectedly";
+  }
+  if (error instanceof Error) {
+    return error.message.trim() || "Gemini runtime exited unexpectedly";
+  }
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    const fields = [record.message, record.details, record.detail, record.stderr].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean);
+    if (fields.length > 0) {
+      return fields.join("\n");
+    }
+    try {
+      const serialized = JSON.stringify(record);
+      if (serialized && serialized !== "{}") {
+        return serialized;
+      }
+    } catch {
+    }
+  }
+  return "Gemini runtime exited unexpectedly";
+}
 async function runGemini(opts) {
   const sessionTag = randomUUID();
   connectionState.setBackend("Gemini");
@@ -511,67 +621,21 @@ async function runGemini(opts) {
   await syncControlledByUserState(session, false);
   const messageQueue = new MessageQueue2((mode) => hashObject({
     permissionMode: mode.permissionMode,
-    model: mode.model
+    model: mode.model,
+    happyOrg: mode.happyOrg ? {
+      taskId: mode.happyOrg.context.taskId,
+      organizationId: mode.happyOrg.context.organizationId,
+      memberAgentId: mode.happyOrg.context.memberAgentId,
+      supervisorAgentId: mode.happyOrg.context.supervisorAgentId,
+      reopenContext: mode.happyOrg.reopenContext ?? null
+    } : null
   }));
   const conversationHistory = new ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
-  let currentPermissionMode = void 0;
-  let currentModel = void 0;
-  session.onUserMessage((message) => {
-    let messagePermissionMode = currentPermissionMode;
-    if (message.meta?.permissionMode) {
-      const validModes = ["default", "read-only", "safe-yolo", "yolo"];
-      if (validModes.includes(message.meta.permissionMode)) {
-        messagePermissionMode = message.meta.permissionMode;
-        currentPermissionMode = messagePermissionMode;
-        updatePermissionMode(messagePermissionMode);
-        logger.debug(`[Gemini] Permission mode updated from user message to: ${currentPermissionMode}`);
-      } else {
-        logger.debug(`[Gemini] Invalid permission mode received: ${message.meta.permissionMode}`);
-      }
-    } else {
-      logger.debug(`[Gemini] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
-    }
-    if (currentPermissionMode === void 0) {
-      currentPermissionMode = "default";
-      updatePermissionMode("default");
-    }
-    let messageModel = currentModel;
-    if (message.meta?.hasOwnProperty("model")) {
-      if (message.meta.model === null) {
-        messageModel = void 0;
-        currentModel = void 0;
-      } else if (message.meta.model) {
-        const previousModel = currentModel;
-        messageModel = message.meta.model;
-        currentModel = messageModel;
-        if (previousModel !== messageModel) {
-          updateDisplayedModel(messageModel, true);
-          messageBuffer.addMessage(`Model changed to: ${messageModel}`, "system");
-          logger.debug(`[Gemini] Model changed from ${previousModel} to ${messageModel}`);
-        }
-      }
-    }
-    const originalUserMessage = message.content.text;
-    let fullPrompt = originalUserMessage;
-    if (isFirstMessage && message.meta?.appendSystemPrompt) {
-      fullPrompt = message.meta.appendSystemPrompt + "\n\n" + originalUserMessage;
-      isFirstMessage = false;
-    }
-    const mode = {
-      permissionMode: messagePermissionMode || "default",
-      model: messageModel,
-      originalUserMessage
-      // Store original message separately
-    };
-    messageQueue.push(fullPrompt, mode);
-    conversationHistory.addUserMessage(originalUserMessage);
-  });
   let thinking = false;
   session.keepAlive(thinking, "remote");
   const keepAliveInterval = setInterval(() => {
     session.keepAlive(thinking, "remote");
   }, 2e3);
-  let isFirstMessage = true;
   const sendReady = () => {
     session.sendSessionEvent({ type: "ready" });
     try {
@@ -604,12 +668,22 @@ async function runGemini(opts) {
   let shouldExit = false;
   let runtimeHandle = null;
   let unsubscribeRuntimeMessages = null;
+  let handleQueuedUserMessage = null;
+  let emitGeminiStatusMessage = null;
+  let turnAbortedSent = false;
+  let turnInFlight = false;
+  let shouldInjectHistoryOnNextSession = false;
+  let currentModeHash = null;
+  let unexpectedRuntimeStopRecovery = null;
   async function handleAbort() {
     logger.debug("[Gemini] Abort requested - stopping current task");
-    session.sendAgentMessage("gemini", {
-      type: "turn_aborted",
-      id: randomUUID()
-    });
+    if (!turnAbortedSent) {
+      session.sendAgentMessage("gemini", {
+        type: "turn_aborted",
+        id: randomUUID()
+      });
+      turnAbortedSent = true;
+    }
     reasoningProcessor.abort();
     diffProcessor.reset();
     try {
@@ -670,6 +744,10 @@ async function runGemini(opts) {
       logger.debug(`[gemini] Model unchanged, skipping update message`);
     }
   };
+  emitGeminiStatusMessage = (message) => {
+    messageBuffer.addMessage(message, "status");
+    session.sendSessionEvent({ type: "message", message });
+  };
   if (hasTTY) {
     console.clear();
     const DisplayComponent = () => {
@@ -710,10 +788,56 @@ async function runGemini(opts) {
   const updatePermissionMode = (mode) => {
     permissionHandler.setPermissionMode(mode);
   };
+  handleQueuedUserMessage = ({ previousState, nextState, invalidPermissionMode, hasModelOverride }) => {
+    if (invalidPermissionMode) {
+      logger.debug(`[Gemini] Invalid permission mode received: ${invalidPermissionMode}`);
+    } else if (nextState.permissionMode) {
+      logger.debug(`[Gemini] Permission mode resolved to: ${nextState.permissionMode}`);
+    }
+    updatePermissionMode(nextState.permissionMode ?? "default");
+    if (hasModelOverride && nextState.model && previousState.model !== nextState.model) {
+      updateDisplayedModel(nextState.model, true);
+      messageBuffer.addMessage(`Model changed to: ${nextState.model}`, "system");
+      logger.debug(`[Gemini] Model changed from ${previousState.model} to ${nextState.model}`);
+    }
+  };
+  bindGeminiUserMessageQueue({
+    session,
+    messageQueue,
+    initialState: {},
+    happyOrg: {
+      getMetadata: () => session.getMetadataSnapshot?.() ?? metadata,
+      updateMetadata: (handler) => session.updateMetadata(handler),
+      emitStatusMessage: (message) => {
+        emitGeminiStatusMessage?.(message);
+      }
+    },
+    onResolvedMessage: (resolution) => {
+      handleQueuedUserMessage?.(resolution);
+    }
+  });
+  const emitTurnReport = (report) => {
+    session.sendAgentMessage("gemini", {
+      type: "turn-report",
+      id: randomUUID(),
+      report
+    });
+  };
   let accumulatedResponse = "";
   let isResponseInProgress = false;
   let hadToolCallInTurn = false;
   let taskStartedSent = false;
+  const resetTurnState = () => {
+    reasoningProcessor.abort();
+    diffProcessor.reset();
+    accumulatedResponse = "";
+    isResponseInProgress = false;
+    hadToolCallInTurn = false;
+    taskStartedSent = false;
+    turnAbortedSent = false;
+    thinking = false;
+    session.keepAlive(thinking, "remote");
+  };
   const disposeRuntimeHandle = async () => {
     if (!runtimeHandle) {
       return;
@@ -728,6 +852,37 @@ async function runGemini(opts) {
       logger.debug("[Gemini] Error disposing runtime session:", error);
     }
   };
+  const queueHistoryInjectionForRestart = (reason) => {
+    messageBuffer.addMessage("\u2550".repeat(40), "status");
+    if (conversationHistory.hasHistory()) {
+      shouldInjectHistoryOnNextSession = true;
+      const message = `${reason} Preserving ${conversationHistory.size()} earlier messages of context.`;
+      emitGeminiStatusMessage?.(message);
+      logger.debug(`[Gemini] Will inject conversation history after restart: ${conversationHistory.getSummary()}`);
+      return;
+    }
+    emitGeminiStatusMessage?.(reason);
+  };
+  const recoverUnexpectedRuntimeStop = async (detail) => {
+    if (shouldExit || messageQueue.isClosed() || unexpectedRuntimeStopRecovery) {
+      return;
+    }
+    const errorMessage = normalizeGeminiBackendError(detail);
+    unexpectedRuntimeStopRecovery = (async () => {
+      queueHistoryInjectionForRestart(
+        `Gemini runtime stopped unexpectedly (${errorMessage}). Starting a new Gemini session on the next message...`
+      );
+      await disposeRuntimeHandle();
+      currentModeHash = null;
+      permissionHandler.reset();
+      resetTurnState();
+    })();
+    try {
+      await unexpectedRuntimeStopRecovery;
+    } finally {
+      unexpectedRuntimeStopRecovery = null;
+    }
+  };
   function setupGeminiMessageHandler(activeRuntimeHandle) {
     const forwardAgentMessage = (agentMessage) => {
       forwardAgentMessageToProviderSession(agentMessage, {
@@ -757,10 +912,13 @@ async function runGemini(opts) {
           logger.debug(`[gemini] Status changed: ${msg.status}${statusDetail ? ` - ${statusDetail}` : ""}`);
           if (msg.status === "error") {
             logger.debug(`[gemini] \u26A0\uFE0F Error status received: ${statusDetail || "Unknown error"}`);
-            session.sendAgentMessage("gemini", {
-              type: "turn_aborted",
-              id: randomUUID()
-            });
+            if (!turnAbortedSent) {
+              session.sendAgentMessage("gemini", {
+                type: "turn_aborted",
+                id: randomUUID()
+              });
+              turnAbortedSent = true;
+            }
           }
           if (msg.status === "running") {
             thinking = true;
@@ -775,6 +933,9 @@ async function runGemini(opts) {
             messageBuffer.addMessage("Thinking...", "system");
           } else if (msg.status === "idle" || msg.status === "stopped") {
             reasoningProcessor.complete();
+            if (msg.status === "stopped" && !turnInFlight) {
+              void recoverUnexpectedRuntimeStop(msg.detail);
+            }
           } else if (msg.status === "error") {
             thinking = false;
             session.keepAlive(thinking, "remote");
@@ -934,7 +1095,6 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
     };
   }
   try {
-    let currentModeHash = null;
     let pending = null;
     while (!shouldExit) {
       let message = pending;
@@ -957,19 +1117,11 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       if (!message) {
         break;
       }
-      let injectHistoryContext = false;
       if (runtimeHandle && currentModeHash && message.hash !== currentModeHash) {
         logger.debug("[Gemini] Mode changed \u2013 restarting Gemini session");
-        messageBuffer.addMessage("\u2550".repeat(40), "status");
-        if (conversationHistory.hasHistory()) {
-          messageBuffer.addMessage(`Switching model (preserving ${conversationHistory.size()} messages of context)...`, "status");
-          injectHistoryContext = true;
-          logger.debug(`[Gemini] Will inject conversation history: ${conversationHistory.getSummary()}`);
-        } else {
-          messageBuffer.addMessage("Starting new Gemini session (mode changed)...", "status");
-        }
+        queueHistoryInjectionForRestart("Starting new Gemini session (execution settings changed)...");
         permissionHandler.reset();
-        reasoningProcessor.abort();
+        resetTurnState();
         await disposeRuntimeHandle();
         const launchedRuntime = await launchGeminiRuntimeHandle(message.mode);
         const actualModel = launchedRuntime.model;
@@ -985,7 +1137,9 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       const userMessageToShow = message.mode?.originalUserMessage || message.message;
       messageBuffer.addMessage(userMessageToShow, "user");
       isProcessingMessage = true;
+      let turnStatus = "task_complete";
       try {
+        turnInFlight = true;
         let activeHandle = runtimeHandle;
         if (!activeHandle) {
           const launchedRuntime = await launchGeminiRuntimeHandle(message.mode);
@@ -1005,12 +1159,17 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         isResponseInProgress = false;
         hadToolCallInTurn = false;
         taskStartedSent = false;
+        turnAbortedSent = false;
         let promptToSend = message.message;
-        if (injectHistoryContext && conversationHistory.hasHistory()) {
+        if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
           const historyContext = conversationHistory.getContextForNewSession();
           promptToSend = historyContext + promptToSend;
           logger.debug(`[gemini] Injected conversation history context (${historyContext.length} chars)`);
         }
+        if (message.mode.happyOrg) {
+          promptToSend = buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
+        }
+        conversationHistory.addUserMessage(userMessageToShow);
         logger.debug(`[gemini] Sending prompt to Gemini (length: ${promptToSend.length}): ${promptToSend.substring(0, 100)}...`);
         logger.debug(`[gemini] Full prompt: ${promptToSend}`);
         const MAX_RETRIES = 3;
@@ -1020,8 +1179,9 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           try {
             await activeHandle.sendPrompt(promptToSend);
             logger.debug("[gemini] Prompt sent successfully");
-            await waitForResponseCompleteWithAbort(activeHandle.backend, abortController.signal, 12e4);
+            await waitForResponseCompleteWithAbort(activeHandle.backend, abortController.signal, 10 * 6e4);
             logger.debug("[gemini] Response complete");
+            shouldInjectHistoryOnNextSession = false;
             break;
           } catch (promptError) {
             lastError = promptError;
@@ -1059,6 +1219,14 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       } catch (error) {
         logger.debug("[gemini] Error in gemini session:", error);
         const isAbortError = error instanceof Error && error.name === "AbortError";
+        turnStatus = "turn_aborted";
+        if (!turnAbortedSent) {
+          session.sendAgentMessage("gemini", {
+            type: "turn_aborted",
+            id: randomUUID()
+          });
+          turnAbortedSent = true;
+        }
         if (isAbortError) {
           messageBuffer.addMessage("Aborted by user", "status");
           session.sendSessionEvent({ type: "message", message: "Aborted by user" });
@@ -1071,8 +1239,8 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             const errorMessage = errObj.message || errObj.error?.message || "";
             const errorString = String(error);
             if (errorCode === 404 || errorDetails.includes("notFound") || errorDetails.includes("404") || errorMessage.includes("not found") || errorMessage.includes("404")) {
-              const currentModel2 = displayedModel || "gemini-2.5-pro";
-              errorMsg = `Model "${currentModel2}" not found. Available models: gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite`;
+              const currentModel = displayedModel || "gemini-2.5-pro";
+              errorMsg = `Model "${currentModel}" not found. Available models: gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite`;
             } else if (errorCode === -32603 || errorDetails.includes("empty response") || errorDetails.includes("Model stream ended")) {
               errorMsg = "Gemini API returned empty response after retries. This is a temporary issue - please try again.";
             } else if (errorCode === 429 || errorDetails.includes("429") || errorMessage.includes("429") || errorString.includes("429") || errorDetails.includes("rateLimitExceeded") || errorDetails.includes("RESOURCE_EXHAUSTED") || errorMessage.includes("Rate limit exceeded") || errorMessage.includes("Resource exhausted") || errorString.includes("rateLimitExceeded") || errorString.includes("RESOURCE_EXHAUSTED")) {
@@ -1105,9 +1273,26 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           });
         }
       } finally {
+        turnInFlight = false;
         permissionHandler.reset();
         reasoningProcessor.abort();
         diffProcessor.reset();
+        const finalizedTurn = finalizeHappyOrgTurn({
+          metadata: session.getMetadataSnapshot?.() ?? null,
+          queuedTurn: message.mode.happyOrg,
+          responseText: accumulatedResponse,
+          turnStatus
+        });
+        if (finalizedTurn.nextMetadata && typeof session.updateMetadata === "function") {
+          session.updateMetadata(() => finalizedTurn.nextMetadata);
+        }
+        if (finalizedTurn.report) {
+          emitTurnReport(finalizedTurn.report);
+        }
+        if (finalizedTurn.terminateMessage) {
+          emitGeminiStatusMessage?.(finalizedTurn.terminateMessage);
+        }
+        accumulatedResponse = finalizedTurn.cleanedText;
         if (accumulatedResponse.trim()) {
           const { text: messageText, options } = parseOptionsFromText(accumulatedResponse);
           conversationHistory.addAssistantMessage(messageText);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-imou-cloud",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "hicloud - Imou 企业定制版。关键是 happy！移动端远程 AI 编程工具，支持 Claude Code、Codex 和 Gemini CLI",
   "author": "long.zhu",
   "license": "MIT",
@@ -33,13 +33,13 @@
       }
     }
   },
-  "files": [
-    "dist",
-    "compat",
-    "bin",
-    "scripts",
-    "package.json"
-  ],
+  "files": [
+    "dist",
+    "compat",
+    "bin",
+    "scripts",
+    "package.json"
+  ],
   "scripts": {
     "// ==== TypeScript & Build ====": "",
     "why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
@@ -85,7 +85,7 @@
     "unlink:dev": "node scripts/link-dev.cjs unlink"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.14.1",
+    "@agentclientprotocol/sdk": "0.14.1",
     "@stablelib/base64": "^2.0.1",
     "@stablelib/hex": "^2.0.1",
     "@types/cross-spawn": "^6.0.6",

package/scripts/build.mjs

@@ -1,68 +1,68 @@
-#!/usr/bin/env node
-
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, rmSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ensureAcpSdkCompat } from './ensureAcpSdkCompat.mjs';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const packageRoot = resolve(here, '..');
-const workspaceRoot = resolve(packageRoot, '..', '..');
-const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
-
-function resolveTool(binName, packageSpecs) {
-  const suffix = process.platform === 'win32' ? '.cmd' : '';
-  const packageLocalBin = resolve(packageRoot, 'node_modules', '.bin', `${binName}${suffix}`);
-  const workspaceLocalBin = resolve(workspaceRoot, 'node_modules', '.bin', `${binName}${suffix}`);
-
-  if (existsSync(packageLocalBin)) {
-    return {
-      command: packageLocalBin,
-      prefixArgs: [],
-    };
-  }
-
-  if (existsSync(workspaceLocalBin)) {
-    return {
-      command: workspaceLocalBin,
-      prefixArgs: [],
-    };
-  }
-
-  return {
-    command: 'npx',
-    prefixArgs: ['-y', ...packageSpecs.flatMap((packageSpec) => ['-p', packageSpec]), binName],
-  };
-}
-
-function runStep(name, command, args) {
-  console.log(`\n[build] ${name}`);
-  console.log(`> ${command} ${args.join(' ')}`);
-
-  const result = spawnSync(command, args, {
-    cwd: packageRoot,
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-    env: process.env,
-  });
-
-  if (result.status !== 0) {
-    throw new Error(`[build] Step failed: ${name}`);
-  }
-}
-
-function runTool(name, tool, args) {
-  runStep(name, tool.command, [...tool.prefixArgs, ...args]);
-}
-
-const tsc = resolveTool('tsc', [`typescript@${packageJson.devDependencies.typescript}`]);
-const pkgroll = resolveTool('pkgroll', [
-  `pkgroll@${packageJson.devDependencies.pkgroll}`,
-  `typescript@${packageJson.devDependencies.typescript}`,
-]);
-
-ensureAcpSdkCompat();
-rmSync(resolve(packageRoot, 'dist'), { recursive: true, force: true });
-runTool('typecheck', tsc, ['--noEmit']);
-runTool('bundle', pkgroll, []);
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureAcpSdkCompat } from './ensureAcpSdkCompat.mjs';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const workspaceRoot = resolve(packageRoot, '..', '..');
+const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+
+function resolveTool(binName, packageSpecs) {
+  const suffix = process.platform === 'win32' ? '.cmd' : '';
+  const packageLocalBin = resolve(packageRoot, 'node_modules', '.bin', `${binName}${suffix}`);
+  const workspaceLocalBin = resolve(workspaceRoot, 'node_modules', '.bin', `${binName}${suffix}`);
+
+  if (existsSync(packageLocalBin)) {
+    return {
+      command: packageLocalBin,
+      prefixArgs: [],
+    };
+  }
+
+  if (existsSync(workspaceLocalBin)) {
+    return {
+      command: workspaceLocalBin,
+      prefixArgs: [],
+    };
+  }
+
+  return {
+    command: 'npx',
+    prefixArgs: ['-y', ...packageSpecs.flatMap((packageSpec) => ['-p', packageSpec]), binName],
+  };
+}
+
+function runStep(name, command, args) {
+  console.log(`\n[build] ${name}`);
+  console.log(`> ${command} ${args.join(' ')}`);
+
+  const result = spawnSync(command, args, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+    env: process.env,
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`[build] Step failed: ${name}`);
+  }
+}
+
+function runTool(name, tool, args) {
+  runStep(name, tool.command, [...tool.prefixArgs, ...args]);
+}
+
+const tsc = resolveTool('tsc', [`typescript@${packageJson.devDependencies.typescript}`]);
+const pkgroll = resolveTool('pkgroll', [
+  `pkgroll@${packageJson.devDependencies.pkgroll}`,
+  `typescript@${packageJson.devDependencies.typescript}`,
+]);
+
+ensureAcpSdkCompat();
+rmSync(resolve(packageRoot, 'dist'), { recursive: true, force: true });
+runTool('typecheck', tsc, ['--noEmit']);
+runTool('bundle', pkgroll, []);