@willh/subtitle-correction-agent 0.1.2 → 0.1.3

package/dist/index.js

@@ -3272,21 +3272,81 @@ var require_main = __commonJS((exports) => {
 // src/index.ts
 import * as path6 from "path";
 import * as fs5 from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync } from "child_process";
 
 // node_modules/@github/copilot-sdk/dist/client.js
-var import_node = __toESM(require_main(), 1);
+var import_node2 = __toESM(require_main(), 1);
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { Socket } from "node:net";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// node_modules/@github/copilot-sdk/dist/generated/rpc.js
+function createServerRpc(connection) {
+  return {
+    ping: async (params) => connection.sendRequest("ping", params),
+    models: {
+      list: async () => connection.sendRequest("models.list", {})
+    },
+    tools: {
+      list: async (params) => connection.sendRequest("tools.list", params)
+    },
+    account: {
+      getQuota: async () => connection.sendRequest("account.getQuota", {})
+    }
+  };
+}
+function createSessionRpc(connection, sessionId) {
+  return {
+    model: {
+      getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
+      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params })
+    },
+    mode: {
+      get: async () => connection.sendRequest("session.mode.get", { sessionId }),
+      set: async (params) => connection.sendRequest("session.mode.set", { sessionId, ...params })
+    },
+    plan: {
+      read: async () => connection.sendRequest("session.plan.read", { sessionId }),
+      update: async (params) => connection.sendRequest("session.plan.update", { sessionId, ...params }),
+      delete: async () => connection.sendRequest("session.plan.delete", { sessionId })
+    },
+    workspace: {
+      listFiles: async () => connection.sendRequest("session.workspace.listFiles", { sessionId }),
+      readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
+      createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
+    },
+    fleet: {
+      start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
+    },
+    agent: {
+      list: async () => connection.sendRequest("session.agent.list", { sessionId }),
+      getCurrent: async () => connection.sendRequest("session.agent.getCurrent", { sessionId }),
+      select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
+      deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId })
+    },
+    compaction: {
+      compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
+    },
+    tools: {
+      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
+    },
+    permissions: {
+      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
+    }
+  };
+}
 
 // node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
-var SDK_PROTOCOL_VERSION = 2;
+var SDK_PROTOCOL_VERSION = 3;
 function getSdkProtocolVersion() {
   return SDK_PROTOCOL_VERSION;
 }
 
 // node_modules/@github/copilot-sdk/dist/session.js
+var import_node = __toESM(require_main(), 1);
 class CopilotSession {
   constructor(sessionId, connection, _workspacePath) {
     this.sessionId = sessionId;
@@ -3294,8 +3354,18 @@ class CopilotSession {
     this._workspacePath = _workspacePath;
   }
   eventHandlers = /* @__PURE__ */ new Set;
+  typedEventHandlers = /* @__PURE__ */ new Map;
   toolHandlers = /* @__PURE__ */ new Map;
   permissionHandler;
+  userInputHandler;
+  hooks;
+  _rpc = null;
+  get rpc() {
+    if (!this._rpc) {
+      this._rpc = createSessionRpc(this.connection, this.sessionId);
+    }
+    return this._rpc;
+  }
   get workspacePath() {
     return this._workspacePath;
   }
@@ -3328,30 +3398,123 @@ class CopilotSession {
         rejectWithError(error);
       }
     });
+    let timeoutId;
     try {
       await this.send(options);
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(`Timeout after ${effectiveTimeout}ms waiting for session.idle`)), effectiveTimeout);
+        timeoutId = setTimeout(() => reject(new Error(`Timeout after ${effectiveTimeout}ms waiting for session.idle`)), effectiveTimeout);
       });
       await Promise.race([idlePromise, timeoutPromise]);
       return lastAssistantMessage;
     } finally {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
       unsubscribe();
     }
   }
-  on(handler) {
-    this.eventHandlers.add(handler);
+  on(eventTypeOrHandler, handler) {
+    if (typeof eventTypeOrHandler === "string" && handler) {
+      const eventType = eventTypeOrHandler;
+      if (!this.typedEventHandlers.has(eventType)) {
+        this.typedEventHandlers.set(eventType, /* @__PURE__ */ new Set);
+      }
+      const storedHandler = handler;
+      this.typedEventHandlers.get(eventType).add(storedHandler);
+      return () => {
+        const handlers = this.typedEventHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(storedHandler);
+        }
+      };
+    }
+    const wildcardHandler = eventTypeOrHandler;
+    this.eventHandlers.add(wildcardHandler);
     return () => {
-      this.eventHandlers.delete(handler);
+      this.eventHandlers.delete(wildcardHandler);
     };
   }
   _dispatchEvent(event) {
+    this._handleBroadcastEvent(event);
+    const typedHandlers = this.typedEventHandlers.get(event.type);
+    if (typedHandlers) {
+      for (const handler of typedHandlers) {
+        try {
+          handler(event);
+        } catch (_error) {}
+      }
+    }
     for (const handler of this.eventHandlers) {
       try {
         handler(event);
       } catch (_error) {}
     }
   }
+  _handleBroadcastEvent(event) {
+    if (event.type === "external_tool.requested") {
+      const { requestId, toolName } = event.data;
+      const args = event.data.arguments;
+      const toolCallId = event.data.toolCallId;
+      const handler = this.toolHandlers.get(toolName);
+      if (handler) {
+        this._executeToolAndRespond(requestId, toolName, toolCallId, args, handler);
+      }
+    } else if (event.type === "permission.requested") {
+      const { requestId, permissionRequest } = event.data;
+      if (this.permissionHandler) {
+        this._executePermissionAndRespond(requestId, permissionRequest);
+      }
+    }
+  }
+  async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler) {
+    try {
+      const rawResult = await handler(args, {
+        sessionId: this.sessionId,
+        toolCallId,
+        toolName,
+        arguments: args
+      });
+      let result;
+      if (rawResult == null) {
+        result = "";
+      } else if (typeof rawResult === "string") {
+        result = rawResult;
+      } else {
+        result = JSON.stringify(rawResult);
+      }
+      await this.rpc.tools.handlePendingToolCall({ requestId, result });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      try {
+        await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
+      } catch (rpcError) {
+        if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+          throw rpcError;
+        }
+      }
+    }
+  }
+  async _executePermissionAndRespond(requestId, permissionRequest) {
+    try {
+      const result = await this.permissionHandler(permissionRequest, {
+        sessionId: this.sessionId
+      });
+      await this.rpc.permissions.handlePendingPermissionRequest({ requestId, result });
+    } catch (_error) {
+      try {
+        await this.rpc.permissions.handlePendingPermissionRequest({
+          requestId,
+          result: {
+            kind: "denied-no-approval-rule-and-could-not-request-from-user"
+          }
+        });
+      } catch (rpcError) {
+        if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+          throw rpcError;
+        }
+      }
+    }
+  }
   registerTools(tools) {
     this.toolHandlers.clear();
     if (!tools) {
@@ -3367,7 +3530,13 @@ class CopilotSession {
   registerPermissionHandler(handler) {
     this.permissionHandler = handler;
   }
-  async _handlePermissionRequest(request) {
+  registerUserInputHandler(handler) {
+    this.userInputHandler = handler;
+  }
+  registerHooks(hooks) {
+    this.hooks = hooks;
+  }
+  async _handlePermissionRequestV2(request) {
     if (!this.permissionHandler) {
       return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
     }
@@ -3380,28 +3549,75 @@ class CopilotSession {
       return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
     }
   }
+  async _handleUserInputRequest(request) {
+    if (!this.userInputHandler) {
+      throw new Error("User input requested but no handler registered");
+    }
+    try {
+      const result = await this.userInputHandler(request, {
+        sessionId: this.sessionId
+      });
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async _handleHooksInvoke(hookType, input) {
+    if (!this.hooks) {
+      return;
+    }
+    const handlerMap = {
+      preToolUse: this.hooks.onPreToolUse,
+      postToolUse: this.hooks.onPostToolUse,
+      userPromptSubmitted: this.hooks.onUserPromptSubmitted,
+      sessionStart: this.hooks.onSessionStart,
+      sessionEnd: this.hooks.onSessionEnd,
+      errorOccurred: this.hooks.onErrorOccurred
+    };
+    const handler = handlerMap[hookType];
+    if (!handler) {
+      return;
+    }
+    try {
+      const result = await handler(input, { sessionId: this.sessionId });
+      return result;
+    } catch (_error) {
+      return;
+    }
+  }
   async getMessages() {
     const response = await this.connection.sendRequest("session.getMessages", {
       sessionId: this.sessionId
     });
     return response.events;
   }
-  async destroy() {
+  async disconnect() {
     await this.connection.sendRequest("session.destroy", {
       sessionId: this.sessionId
     });
     this.eventHandlers.clear();
+    this.typedEventHandlers.clear();
     this.toolHandlers.clear();
     this.permissionHandler = undefined;
   }
+  async destroy() {
+    return this.disconnect();
+  }
+  async[Symbol.asyncDispose]() {
+    return this.disconnect();
+  }
   async abort() {
     await this.connection.sendRequest("session.abort", {
       sessionId: this.sessionId
     });
   }
+  async setModel(model) {
+    await this.rpc.model.switchTo({ modelId: model });
+  }
 }
 
 // node_modules/@github/copilot-sdk/dist/client.js
+var MIN_PROTOCOL_VERSION = 2;
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
 }
@@ -3413,6 +3629,17 @@ function toJsonSchema(parameters) {
   }
   return parameters;
 }
+function getNodeExecPath() {
+  if (process.versions.bun) {
+    return "node";
+  }
+  return process.execPath;
+}
+function getBundledCliPath() {
+  const sdkUrl = import.meta.resolve("@github/copilot/sdk");
+  const sdkPath = fileURLToPath(sdkUrl);
+  return join(dirname(dirname(sdkPath)), "index.js");
+}
 
 class CopilotClient {
   cliProcess = null;
@@ -3422,30 +3649,59 @@ class CopilotClient {
   actualHost = "localhost";
   state = "disconnected";
   sessions = /* @__PURE__ */ new Map;
+  stderrBuffer = "";
   options;
   isExternalServer = false;
   forceStopping = false;
+  modelsCache = null;
+  modelsCacheLock = Promise.resolve();
+  sessionLifecycleHandlers = /* @__PURE__ */ new Set;
+  typedLifecycleHandlers = /* @__PURE__ */ new Map;
+  _rpc = null;
+  processExitPromise = null;
+  negotiatedProtocolVersion = null;
+  get rpc() {
+    if (!this.connection) {
+      throw new Error("Client is not connected. Call start() first.");
+    }
+    if (!this._rpc) {
+      this._rpc = createServerRpc(this.connection);
+    }
+    return this._rpc;
+  }
   constructor(options = {}) {
     if (options.cliUrl && (options.useStdio === true || options.cliPath)) {
       throw new Error("cliUrl is mutually exclusive with useStdio and cliPath");
     }
+    if (options.isChildProcess && (options.cliUrl || options.useStdio === false)) {
+      throw new Error("isChildProcess must be used in conjunction with useStdio and not with cliUrl");
+    }
+    if (options.cliUrl && (options.githubToken || options.useLoggedInUser !== undefined)) {
+      throw new Error("githubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)");
+    }
     if (options.cliUrl) {
       const { host, port } = this.parseCliUrl(options.cliUrl);
       this.actualHost = host;
       this.actualPort = port;
       this.isExternalServer = true;
     }
+    if (options.isChildProcess) {
+      this.isExternalServer = true;
+    }
     this.options = {
-      cliPath: options.cliPath || "copilot",
+      cliPath: options.cliPath || getBundledCliPath(),
       cliArgs: options.cliArgs ?? [],
       cwd: options.cwd ?? process.cwd(),
       port: options.port || 0,
       useStdio: options.cliUrl ? false : options.useStdio ?? true,
+      isChildProcess: options.isChildProcess ?? false,
       cliUrl: options.cliUrl,
       logLevel: options.logLevel || "debug",
       autoStart: options.autoStart ?? true,
       autoRestart: options.autoRestart ?? true,
-      env: options.env ?? process.env
+      env: options.env ?? process.env,
+      githubToken: options.githubToken,
+      useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true)
     };
   }
   parseCliUrl(url) {
@@ -3488,7 +3744,7 @@ class CopilotClient {
       let lastError = null;
       for (let attempt = 1;attempt <= 3; attempt++) {
         try {
-          await session.destroy();
+          await session.disconnect();
           lastError = null;
           break;
         } catch (error) {
@@ -3500,7 +3756,7 @@ class CopilotClient {
         }
       }
       if (lastError) {
-        errors.push(new Error(`Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`));
+        errors.push(new Error(`Failed to disconnect session ${sessionId} after 3 attempts: ${lastError.message}`));
       }
     }
     this.sessions.clear();
@@ -3511,7 +3767,9 @@ class CopilotClient {
         errors.push(new Error(`Failed to dispose connection: ${error instanceof Error ? error.message : String(error)}`));
       }
       this.connection = null;
+      this._rpc = null;
     }
+    this.modelsCache = null;
     if (this.socket) {
       try {
         this.socket.end();
@@ -3530,6 +3788,8 @@ class CopilotClient {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
     return errors;
   }
   async forceStop() {
@@ -3540,7 +3800,9 @@ class CopilotClient {
         this.connection.dispose();
       } catch {}
       this.connection = null;
+      this._rpc = null;
     }
+    this.modelsCache = null;
     if (this.socket) {
       try {
         this.socket.destroy();
@@ -3555,8 +3817,13 @@ class CopilotClient {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
   }
-  async createSession(config = {}) {
+  async createSession(config) {
+    if (!config?.onPermissionRequest) {
+      throw new Error("An onPermissionRequest handler is required when creating a session. For example, to allow all permissions, use { onPermissionRequest: approveAll }.");
+    }
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -3567,18 +3834,25 @@ class CopilotClient {
     const response = await this.connection.sendRequest("session.create", {
       model: config.model,
       sessionId: config.sessionId,
+      clientName: config.clientName,
+      reasoningEffort: config.reasoningEffort,
       tools: config.tools?.map((tool) => ({
         name: tool.name,
         description: tool.description,
-        parameters: toJsonSchema(tool.parameters)
+        parameters: toJsonSchema(tool.parameters),
+        overridesBuiltInTool: tool.overridesBuiltInTool
       })),
       systemMessage: config.systemMessage,
       availableTools: config.availableTools,
       excludedTools: config.excludedTools,
       provider: config.provider,
-      requestPermission: !!config.onPermissionRequest,
+      requestPermission: true,
+      requestUserInput: !!config.onUserInputRequest,
+      hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
+      workingDirectory: config.workingDirectory,
       streaming: config.streaming,
       mcpServers: config.mcpServers,
+      envValueMode: "direct",
       customAgents: config.customAgents,
       configDir: config.configDir,
       skillDirectories: config.skillDirectories,
@@ -3588,13 +3862,20 @@ class CopilotClient {
     const { sessionId, workspacePath } = response;
     const session = new CopilotSession(sessionId, this.connection, workspacePath);
     session.registerTools(config.tools);
-    if (config.onPermissionRequest) {
-      session.registerPermissionHandler(config.onPermissionRequest);
+    session.registerPermissionHandler(config.onPermissionRequest);
+    if (config.onUserInputRequest) {
+      session.registerUserInputHandler(config.onUserInputRequest);
+    }
+    if (config.hooks) {
+      session.registerHooks(config.hooks);
     }
     this.sessions.set(sessionId, session);
     return session;
   }
-  async resumeSession(sessionId, config = {}) {
+  async resumeSession(sessionId, config) {
+    if (!config?.onPermissionRequest) {
+      throw new Error("An onPermissionRequest handler is required when resuming a session. For example, to allow all permissions, use { onPermissionRequest: approveAll }.");
+    }
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -3604,24 +3885,42 @@ class CopilotClient {
     }
     const response = await this.connection.sendRequest("session.resume", {
       sessionId,
+      clientName: config.clientName,
+      model: config.model,
+      reasoningEffort: config.reasoningEffort,
+      systemMessage: config.systemMessage,
+      availableTools: config.availableTools,
+      excludedTools: config.excludedTools,
       tools: config.tools?.map((tool) => ({
         name: tool.name,
         description: tool.description,
-        parameters: toJsonSchema(tool.parameters)
+        parameters: toJsonSchema(tool.parameters),
+        overridesBuiltInTool: tool.overridesBuiltInTool
       })),
       provider: config.provider,
-      requestPermission: !!config.onPermissionRequest,
+      requestPermission: true,
+      requestUserInput: !!config.onUserInputRequest,
+      hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
+      workingDirectory: config.workingDirectory,
+      configDir: config.configDir,
       streaming: config.streaming,
       mcpServers: config.mcpServers,
+      envValueMode: "direct",
       customAgents: config.customAgents,
       skillDirectories: config.skillDirectories,
-      disabledSkills: config.disabledSkills
+      disabledSkills: config.disabledSkills,
+      infiniteSessions: config.infiniteSessions,
+      disableResume: config.disableResume
     });
     const { sessionId: resumedSessionId, workspacePath } = response;
     const session = new CopilotSession(resumedSessionId, this.connection, workspacePath);
     session.registerTools(config.tools);
-    if (config.onPermissionRequest) {
-      session.registerPermissionHandler(config.onPermissionRequest);
+    session.registerPermissionHandler(config.onPermissionRequest);
+    if (config.onUserInputRequest) {
+      session.registerUserInputHandler(config.onUserInputRequest);
+    }
+    if (config.hooks) {
+      session.registerHooks(config.hooks);
     }
     this.sessions.set(resumedSessionId, session);
     return session;
@@ -3654,20 +3953,40 @@ class CopilotClient {
     if (!this.connection) {
       throw new Error("Client not connected");
     }
-    const result = await this.connection.sendRequest("models.list", {});
-    const response = result;
-    return response.models;
+    await this.modelsCacheLock;
+    let resolveLock;
+    this.modelsCacheLock = new Promise((resolve) => {
+      resolveLock = resolve;
+    });
+    try {
+      if (this.modelsCache !== null) {
+        return [...this.modelsCache];
+      }
+      const result = await this.connection.sendRequest("models.list", {});
+      const response = result;
+      const models = response.models;
+      this.modelsCache = models;
+      return [...models];
+    } finally {
+      resolveLock();
+    }
   }
   async verifyProtocolVersion() {
-    const expectedVersion = getSdkProtocolVersion();
-    const pingResult = await this.ping();
+    const maxVersion = getSdkProtocolVersion();
+    let pingResult;
+    if (this.processExitPromise) {
+      pingResult = await Promise.race([this.ping(), this.processExitPromise]);
+    } else {
+      pingResult = await this.ping();
+    }
     const serverVersion = pingResult.protocolVersion;
     if (serverVersion === undefined) {
-      throw new Error(`SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`);
+      throw new Error(`SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`);
     }
-    if (serverVersion !== expectedVersion) {
-      throw new Error(`SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`);
+    if (serverVersion < MIN_PROTOCOL_VERSION || serverVersion > maxVersion) {
+      throw new Error(`SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`);
     }
+    this.negotiatedProtocolVersion = serverVersion;
   }
   async getLastSessionId() {
     if (!this.connection) {
@@ -3689,25 +4008,66 @@ class CopilotClient {
     }
     this.sessions.delete(sessionId);
   }
-  async listSessions() {
+  async listSessions(filter) {
     if (!this.connection) {
       throw new Error("Client not connected");
     }
-    const response = await this.connection.sendRequest("session.list", {});
+    const response = await this.connection.sendRequest("session.list", { filter });
     const { sessions } = response;
     return sessions.map((s) => ({
       sessionId: s.sessionId,
       startTime: new Date(s.startTime),
       modifiedTime: new Date(s.modifiedTime),
       summary: s.summary,
-      isRemote: s.isRemote
+      isRemote: s.isRemote,
+      context: s.context
     }));
   }
+  async getForegroundSessionId() {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const response = await this.connection.sendRequest("session.getForeground", {});
+    return response.sessionId;
+  }
+  async setForegroundSessionId(sessionId) {
+    if (!this.connection) {
+      throw new Error("Client not connected");
+    }
+    const response = await this.connection.sendRequest("session.setForeground", { sessionId });
+    const result = response;
+    if (!result.success) {
+      throw new Error(result.error || "Failed to set foreground session");
+    }
+  }
+  on(eventTypeOrHandler, handler) {
+    if (typeof eventTypeOrHandler === "string" && handler) {
+      const eventType = eventTypeOrHandler;
+      if (!this.typedLifecycleHandlers.has(eventType)) {
+        this.typedLifecycleHandlers.set(eventType, /* @__PURE__ */ new Set);
+      }
+      const storedHandler = handler;
+      this.typedLifecycleHandlers.get(eventType).add(storedHandler);
+      return () => {
+        const handlers = this.typedLifecycleHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(storedHandler);
+        }
+      };
+    }
+    const wildcardHandler = eventTypeOrHandler;
+    this.sessionLifecycleHandlers.add(wildcardHandler);
+    return () => {
+      this.sessionLifecycleHandlers.delete(wildcardHandler);
+    };
+  }
   async startCLIServer() {
     return new Promise((resolve, reject) => {
+      this.stderrBuffer = "";
       const args = [
         ...this.options.cliArgs,
-        "--server",
+        "--headless",
+        "--no-auto-update",
         "--log-level",
         this.options.logLevel
       ];
@@ -3716,27 +4076,37 @@ class CopilotClient {
       } else if (this.options.port > 0) {
         args.push("--port", this.options.port.toString());
       }
+      if (this.options.githubToken) {
+        args.push("--auth-token-env", "COPILOT_SDK_AUTH_TOKEN");
+      }
+      if (!this.options.useLoggedInUser) {
+        args.push("--no-auto-login");
+      }
       const envWithoutNodeDebug = { ...this.options.env };
       delete envWithoutNodeDebug.NODE_DEBUG;
+      if (this.options.githubToken) {
+        envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.githubToken;
+      }
+      if (!existsSync(this.options.cliPath)) {
+        throw new Error(`Copilot CLI not found at ${this.options.cliPath}. Ensure @github/copilot is installed.`);
+      }
+      const stdioConfig = this.options.useStdio ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"];
       const isJsFile = this.options.cliPath.endsWith(".js");
-      const isAbsolutePath = this.options.cliPath.startsWith("/") || /^[a-zA-Z]:/.test(this.options.cliPath);
-      let command;
-      let spawnArgs;
       if (isJsFile) {
-        command = "node";
-        spawnArgs = [this.options.cliPath, ...args];
-      } else if (process.platform === "win32" && !isAbsolutePath) {
-        command = "cmd";
-        spawnArgs = ["/c", `${this.options.cliPath}`, ...args];
+        this.cliProcess = spawn(getNodeExecPath(), [this.options.cliPath, ...args], {
+          stdio: stdioConfig,
+          cwd: this.options.cwd,
+          env: envWithoutNodeDebug,
+          windowsHide: true
+        });
       } else {
-        command = this.options.cliPath;
-        spawnArgs = args;
+        this.cliProcess = spawn(this.options.cliPath, args, {
+          stdio: stdioConfig,
+          cwd: this.options.cwd,
+          env: envWithoutNodeDebug,
+          windowsHide: true
+        });
       }
-      this.cliProcess = spawn(command, spawnArgs, {
-        stdio: this.options.useStdio ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
-        cwd: this.options.cwd,
-        env: envWithoutNodeDebug
-      });
       let stdout = "";
       let resolved = false;
       if (this.options.useStdio) {
@@ -3754,6 +4124,7 @@ class CopilotClient {
         });
       }
       this.cliProcess.stderr?.on("data", (data) => {
+        this.stderrBuffer += data.toString();
         const lines = data.toString().split(`
 `);
         for (const line of lines) {
@@ -3766,13 +4137,39 @@ class CopilotClient {
       this.cliProcess.on("error", (error) => {
         if (!resolved) {
           resolved = true;
-          reject(new Error(`Failed to start CLI server: ${error.message}`));
+          const stderrOutput = this.stderrBuffer.trim();
+          if (stderrOutput) {
+            reject(new Error(`Failed to start CLI server: ${error.message}
+stderr: ${stderrOutput}`));
+          } else {
+            reject(new Error(`Failed to start CLI server: ${error.message}`));
+          }
         }
       });
+      this.processExitPromise = new Promise((_, rejectProcessExit) => {
+        this.cliProcess.on("exit", (code) => {
+          setTimeout(() => {
+            const stderrOutput = this.stderrBuffer.trim();
+            if (stderrOutput) {
+              rejectProcessExit(new Error(`CLI server exited with code ${code}
+stderr: ${stderrOutput}`));
+            } else {
+              rejectProcessExit(new Error(`CLI server exited unexpectedly with code ${code}`));
+            }
+          }, 50);
+        });
+      });
+      this.processExitPromise.catch(() => {});
       this.cliProcess.on("exit", (code) => {
         if (!resolved) {
           resolved = true;
-          reject(new Error(`CLI server exited with code ${code}`));
+          const stderrOutput = this.stderrBuffer.trim();
+          if (stderrOutput) {
+            reject(new Error(`CLI server exited with code ${code}
+stderr: ${stderrOutput}`));
+          } else {
+            reject(new Error(`CLI server exited with code ${code}`));
+          }
         } else if (this.options.autoRestart && this.state === "connected") {
           this.reconnect();
         }
@@ -3786,13 +4183,15 @@ class CopilotClient {
     });
   }
   async connectToServer() {
-    if (this.options.useStdio) {
-      return this.connectViaStdio();
+    if (this.options.isChildProcess) {
+      return this.connectToParentProcessViaStdio();
+    } else if (this.options.useStdio) {
+      return this.connectToChildProcessViaStdio();
     } else {
       return this.connectViaTcp();
     }
   }
-  async connectViaStdio() {
+  async connectToChildProcessViaStdio() {
     if (!this.cliProcess) {
       throw new Error("CLI process not started");
     }
@@ -3801,7 +4200,15 @@ class CopilotClient {
         throw err;
       }
     });
-    this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.cliProcess.stdout), new import_node.StreamMessageWriter(this.cliProcess.stdin));
+    this.connection = import_node2.createMessageConnection(new import_node2.StreamMessageReader(this.cliProcess.stdout), new import_node2.StreamMessageWriter(this.cliProcess.stdin));
+    this.attachConnectionHandlers();
+    this.connection.listen();
+  }
+  async connectToParentProcessViaStdio() {
+    if (this.cliProcess) {
+      throw new Error("CLI child process was unexpectedly started in parent process mode");
+    }
+    this.connection = import_node2.createMessageConnection(new import_node2.StreamMessageReader(process.stdin), new import_node2.StreamMessageWriter(process.stdout));
     this.attachConnectionHandlers();
     this.connection.listen();
   }
@@ -3812,7 +4219,7 @@ class CopilotClient {
     return new Promise((resolve, reject) => {
       this.socket = new Socket;
       this.socket.connect(this.actualPort, this.actualHost, () => {
-        this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.socket), new import_node.StreamMessageWriter(this.socket));
+        this.connection = import_node2.createMessageConnection(new import_node2.StreamMessageReader(this.socket), new import_node2.StreamMessageWriter(this.socket));
         this.attachConnectionHandlers();
         this.connection.listen();
         resolve();
@@ -3829,8 +4236,13 @@ class CopilotClient {
     this.connection.onNotification("session.event", (notification) => {
       this.handleSessionEventNotification(notification);
     });
-    this.connection.onRequest("tool.call", async (params) => await this.handleToolCallRequest(params));
-    this.connection.onRequest("permission.request", async (params) => await this.handlePermissionRequest(params));
+    this.connection.onNotification("session.lifecycle", (notification) => {
+      this.handleSessionLifecycleNotification(notification);
+    });
+    this.connection.onRequest("tool.call", async (params) => await this.handleToolCallRequestV2(params));
+    this.connection.onRequest("permission.request", async (params) => await this.handlePermissionRequestV2(params));
+    this.connection.onRequest("userInput.request", async (params) => await this.handleUserInputRequest(params));
+    this.connection.onRequest("hooks.invoke", async (params) => await this.handleHooksInvoke(params));
     this.connection.onClose(() => {
       if (this.state === "connected" && this.options.autoRestart) {
         this.reconnect();
@@ -3847,7 +4259,52 @@ class CopilotClient {
       session._dispatchEvent(notification.event);
     }
   }
-  async handleToolCallRequest(params) {
+  handleSessionLifecycleNotification(notification) {
+    if (typeof notification !== "object" || !notification || !("type" in notification) || typeof notification.type !== "string" || !("sessionId" in notification) || typeof notification.sessionId !== "string") {
+      return;
+    }
+    const event = notification;
+    const typedHandlers = this.typedLifecycleHandlers.get(event.type);
+    if (typedHandlers) {
+      for (const handler of typedHandlers) {
+        try {
+          handler(event);
+        } catch {}
+      }
+    }
+    for (const handler of this.sessionLifecycleHandlers) {
+      try {
+        handler(event);
+      } catch {}
+    }
+  }
+  async handleUserInputRequest(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
+      throw new Error("Invalid user input request payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    const result = await session._handleUserInputRequest({
+      question: params.question,
+      choices: params.choices,
+      allowFreeform: params.allowFreeform
+    });
+    return result;
+  }
+  async handleHooksInvoke(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
+      throw new Error("Invalid hooks invoke payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    const output = await session._handleHooksInvoke(params.hookType, params.input);
+    return { output };
+  }
+  async handleToolCallRequestV2(params) {
     if (!params || typeof params.sessionId !== "string" || typeof params.toolCallId !== "string" || typeof params.toolName !== "string") {
       throw new Error("Invalid tool call payload");
     }
@@ -3857,20 +4314,24 @@ class CopilotClient {
     }
     const handler = session.getToolHandler(params.toolName);
     if (!handler) {
-      return { result: this.buildUnsupportedToolResult(params.toolName) };
+      return {
+        result: {
+          textResultForLlm: `Tool '${params.toolName}' is not supported by this client instance.`,
+          resultType: "failure",
+          error: `tool '${params.toolName}' not supported`,
+          toolTelemetry: {}
+        }
+      };
     }
-    return await this.executeToolCall(handler, params);
-  }
-  async executeToolCall(handler, request) {
     try {
       const invocation = {
-        sessionId: request.sessionId,
-        toolCallId: request.toolCallId,
-        toolName: request.toolName,
-        arguments: request.arguments
+        sessionId: params.sessionId,
+        toolCallId: params.toolCallId,
+        toolName: params.toolName,
+        arguments: params.arguments
       };
-      const result = await handler(request.arguments, invocation);
-      return { result: this.normalizeToolResult(result) };
+      const result = await handler(params.arguments, invocation);
+      return { result: this.normalizeToolResultV2(result) };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
@@ -3883,7 +4344,7 @@ class CopilotClient {
       };
     }
   }
-  async handlePermissionRequest(params) {
+  async handlePermissionRequestV2(params) {
     if (!params || typeof params.sessionId !== "string" || !params.permissionRequest) {
       throw new Error("Invalid permission request payload");
     }
@@ -3892,7 +4353,7 @@ class CopilotClient {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
     try {
-      const result = await session._handlePermissionRequest(params.permissionRequest);
+      const result = await session._handlePermissionRequestV2(params.permissionRequest);
       return { result };
     } catch (_error) {
       return {
@@ -3902,7 +4363,7 @@ class CopilotClient {
       };
     }
   }
-  normalizeToolResult(result) {
+  normalizeToolResultV2(result) {
     if (result === undefined || result === null) {
       return {
         textResultForLlm: "Tool returned no result",
@@ -3924,14 +4385,6 @@ class CopilotClient {
   isToolResultObject(value) {
     return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
   }
-  buildUnsupportedToolResult(toolName) {
-    return {
-      textResultForLlm: `Tool '${toolName}' is not supported by this client instance.`,
-      resultType: "failure",
-      error: `tool '${toolName}' not supported`,
-      toolTelemetry: {}
-    };
-  }
   async reconnect() {
     this.state = "disconnected";
     try {
@@ -4966,7 +5419,7 @@ function parseArgs(args) {
   return result;
 }
 function resolveProjectRoot() {
-  const currentFile = fileURLToPath(import.meta.url);
+  const currentFile = fileURLToPath2(import.meta.url);
   let dir = path6.dirname(currentFile);
   while (true) {
     const candidate = path6.join(dir, "package.json");
@@ -5151,7 +5604,7 @@ var isDirectRun = (() => {
   if (typeof metaMain === "boolean") {
     return metaMain;
   }
-  const entryPath = fileURLToPath(import.meta.url);
+  const entryPath = fileURLToPath2(import.meta.url);
   return Boolean(process.argv[1]) && path6.resolve(process.argv[1]) === path6.resolve(entryPath);
 })();
 if (isDirectRun) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willh/subtitle-correction-agent",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "影片字幕校正代理人 - 使用 GitHub Copilot SDK",
   "type": "module",
   "files": [