adhdev 0.7.2 → 0.7.6

package/dist/index.js

@@ -2303,6 +2303,10 @@ var init_extension_provider_instance = __esm({
       // meta
       instanceId;
       ideType = "";
+      chatId = null;
+      chatTitle = null;
+      agentName = "";
+      extensionId = "";
       constructor(provider) {
         this.type = provider.type;
         this.provider = provider;
@@ -2329,8 +2333,8 @@ var init_extension_provider_instance = __esm({
           category: "extension",
           status: this.currentStatus,
           activeChat: this.messages.length > 0 ? {
-            id: `${this.type}_session`,
-            title: this.provider.name,
+            id: this.chatId || this.instanceId,
+            title: this.chatTitle || this.agentName || this.provider.name,
             status: this.currentStatus,
             messages: this.messages,
             activeModal: this.activeModal,
@@ -2352,6 +2356,10 @@ var init_extension_provider_instance = __esm({
           if (data?.activeModal !== void 0) this.activeModal = data.activeModal;
           if (data?.model) this.currentModel = data.model;
           if (data?.mode) this.currentMode = data.mode;
+          if (typeof data?.sessionId === "string" && data.sessionId.trim()) this.chatId = data.sessionId;
+          if (typeof data?.title === "string" && data.title.trim()) this.chatTitle = data.title;
+          if (typeof data?.agentName === "string" && data.agentName.trim()) this.agentName = data.agentName;
+          if (typeof data?.extensionId === "string" && data.extensionId.trim()) this.extensionId = data.extensionId;
           if (data?.status) {
             const newStatus = data.status;
             this.detectTransition(newStatus, data);
@@ -2371,11 +2379,6 @@ var init_extension_provider_instance = __esm({
         return this.instanceId;
       }
       // ─── status transition detect ──────────────────────────────
-      // NOTE: Extension transitions are TRACKED but NOT emitted as events.
-      // The parent IdeProviderInstance already emits identical events
-      // (generating_started, generating_completed, waiting_approval)
-      // via its own detectAgentTransitions(). Emitting here would cause
-      // duplicate toasts with slightly different content.
       detectTransition(newStatus, data) {
         const now = Date.now();
         const agentStatus = newStatus === "streaming" || newStatus === "generating" ? "generating" : newStatus === "waiting_approval" ? "waiting_approval" : "idle";
@@ -2384,7 +2387,40 @@ var init_extension_provider_instance = __esm({
         if (agentStatus !== this.lastAgentStatus) {
           if (this.lastAgentStatus === "idle" && agentStatus === "generating") {
             this.generatingStartedAt = now;
+            this.pushEvent({
+              event: "agent:generating_started",
+              chatTitle: this.resolveChatTitle(data),
+              timestamp: now,
+              ideType: this.ideType || this.type,
+              agentType: this.type,
+              agentName: this.agentName || this.provider.name,
+              extensionId: this.extensionId || this.type
+            });
+          } else if (agentStatus === "waiting_approval") {
+            if (!this.generatingStartedAt) this.generatingStartedAt = now;
+            this.pushEvent({
+              event: "agent:waiting_approval",
+              chatTitle: this.resolveChatTitle(data),
+              timestamp: now,
+              ideType: this.ideType || this.type,
+              agentType: this.type,
+              agentName: this.agentName || this.provider.name,
+              extensionId: this.extensionId || this.type,
+              modalMessage: data?.activeModal?.message,
+              modalButtons: data?.activeModal?.buttons
+            });
           } else if (agentStatus === "idle" && (this.lastAgentStatus === "generating" || this.lastAgentStatus === "waiting_approval")) {
+            const duration3 = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
+            this.pushEvent({
+              event: "agent:generating_completed",
+              chatTitle: this.resolveChatTitle(data),
+              duration: duration3,
+              timestamp: now,
+              ideType: this.ideType || this.type,
+              agentType: this.type,
+              agentName: this.agentName || this.provider.name,
+              extensionId: this.extensionId || this.type
+            });
             this.generatingStartedAt = 0;
           }
           this.lastAgentStatus = agentStatus;
@@ -2404,6 +2440,10 @@ var init_extension_provider_instance = __esm({
         this.events = [];
         return events;
       }
+      resolveChatTitle(data) {
+        const title = typeof data?.title === "string" && data.title.trim() ? data.title.trim() : this.chatTitle;
+        return title || this.agentName || this.provider.name;
+      }
     };
   }
 });
@@ -3096,9 +3136,9 @@ var init_initializer = __esm({
           await this.connectIdePort(port, ide);
         }
         if (cdpManagers.size > 0) {
-          LOG.info("CDP", `${cdpManagers.size} IDE(s) connected: ${[...cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(", ")}`);
+          LOG.info("IDE", `${cdpManagers.size} IDE window(s) attached: ${[...cdpManagers.entries()].map(([k, m]) => `${k}:${m.getPort()}`).join(", ")}`);
         } else {
-          LOG.warn("CDP", `No IDEs connected \u2014 tried: ${filtered.map((p) => `${p.ide}:${p.port}`).join(", ")}`);
+          LOG.warn("IDE", `No IDE windows attached \u2014 tried: ${filtered.map((p) => `${p.ide}:${p.port}`).join(", ")}`);
         }
       }
       // ─── Per-port connection (multi-window aware) ───
@@ -3124,7 +3164,7 @@ var init_initializer = __esm({
           if (connected) {
             registerExtensionProviders(providerLoader, manager, ide);
             cdpManagers.set(ide, manager);
-            LOG.info("CDP", `Connected: ${ide} (port ${port})`);
+            LOG.info("IDE", `Attached: ${ide} (port ${port})`);
             await this.config.onConnected?.(ide, manager, ide);
           }
           return;
@@ -3157,7 +3197,7 @@ var init_initializer = __esm({
           if (connected) {
             registerExtensionProviders(providerLoader, manager, ide);
             cdpManagers.set(managerKey, manager);
-            LOG.info("CDP", `Connected: ${managerKey} (port ${port}${targets.length > 1 ? `, page "${target.title}"` : ""})`);
+            LOG.info("IDE", `Attached window: ${managerKey} (port ${port}${targets.length > 1 ? `, page "${target.title}"` : ""})`);
             await this.config.onConnected?.(ide, manager, managerKey);
           }
         }
@@ -3186,7 +3226,7 @@ var init_initializer = __esm({
           } catch {
           }
           this.config.cdpManagers.delete(key);
-          LOG.info("CDP", `Removed stale manager: ${key} (${reason})`);
+          LOG.info("IDE", `Detached window: ${key} (${reason})`);
           await this.config.onDisconnected?.(ide, manager, key, reason);
         }
       }
@@ -4590,7 +4630,6 @@ function handleSetProviderSetting(h, args) {
 }
 async function handleExtensionScript(h, args, scriptName) {
   const { agentType, ideType } = args || {};
-  LOG.info("Command", `[ExtScript] ${scriptName} agentType=${agentType} ideType=${ideType} session=${h.currentSession?.sessionId || ""}`);
   if (!agentType) return { success: false, error: "agentType is required" };
   const loader = h.ctx.providerLoader;
   if (!loader) return { success: false, error: "ProviderLoader not initialized" };
@@ -4816,7 +4855,75 @@ var init_workspace_commands = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/commands/handler.ts
-var DaemonCommandHandler;
+function logAtLevel(level, category, message) {
+  switch (level) {
+    case "debug":
+      LOG.debug(category, message);
+      return;
+    case "warn":
+      LOG.warn(category, message);
+      return;
+    case "error":
+      LOG.error(category, message);
+      return;
+    default:
+      LOG.info(category, message);
+  }
+}
+function getCommandLogLevel(cmd) {
+  return COMMAND_DEBUG_LEVELS.has(cmd) ? "debug" : "info";
+}
+function summarizeLogValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized) return '""';
+    if (normalized.length <= 80) return JSON.stringify(normalized);
+    return `${JSON.stringify(normalized.slice(0, 80))}\u2026(${normalized.length} chars)`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.length} items]`;
+  if (typeof value === "object") return "{...}";
+  return String(value);
+}
+function summarizeCommandArgs(args) {
+  if (!args || typeof args !== "object") return "-";
+  const preferredKeys = [
+    "targetSessionId",
+    "providerType",
+    "agentType",
+    "ideType",
+    "model",
+    "mode",
+    "action",
+    "button",
+    "key",
+    "force",
+    "offset",
+    "limit",
+    "cols",
+    "rows",
+    "path",
+    "command",
+    "commandId",
+    "workspace",
+    "dir",
+    "url",
+    "text",
+    "message",
+    "data",
+    "value"
+  ];
+  const entries = [];
+  for (const key of preferredKeys) {
+    if (!(key in args) || args[key] === void 0) continue;
+    const value = key === "text" || key === "message" ? `${String(args[key] || "").length} chars` : key === "data" ? `${String(args[key] || "").length} chars` : summarizeLogValue(args[key]);
+    entries.push(`${key}=${value}`);
+  }
+  return entries.length ? entries.join(" ") : "{...}";
+}
+var COMMAND_DEBUG_LEVELS, DaemonCommandHandler;
 var init_handler = __esm({
   "../../oss/packages/daemon-core/src/commands/handler.ts"() {
     "use strict";
@@ -4831,6 +4938,15 @@ var init_handler = __esm({
     init_workspace_commands();
     init_workspaces();
     init_workspace_activity();
+    COMMAND_DEBUG_LEVELS = /* @__PURE__ */ new Set([
+      "pty_input",
+      "pty_resize",
+      "cdp_eval",
+      "cdp_batch",
+      "cdp_dom_query",
+      "cdp_dom_dump",
+      "cdp_dom_debug"
+    ]);
     DaemonCommandHandler = class {
       _ctx;
       _agentStream = null;
@@ -4978,23 +5094,54 @@ var init_handler = __esm({
         }
         return void 0;
       }
+      logCommandStart(cmd, args) {
+        const routeBits = [
+          this._currentRoute.session?.sessionId ? `session=${this._currentRoute.session.sessionId}` : "",
+          this._currentRoute.managerKey ? `manager=${this._currentRoute.managerKey}` : "",
+          this._currentRoute.providerType ? `provider=${this._currentRoute.providerType}` : ""
+        ].filter(Boolean).join(" ");
+        const summary = summarizeCommandArgs(args);
+        logAtLevel(
+          getCommandLogLevel(cmd),
+          "Command",
+          `[${cmd}] start${routeBits ? ` ${routeBits}` : ""} args=${summary}`
+        );
+      }
+      logCommandEnd(cmd, result, startedAt) {
+        const durationMs = Date.now() - startedAt;
+        const parts = [`[${cmd}] end`, `success=${result.success}`, `duration=${durationMs}ms`];
+        if (typeof result.error === "string" && result.error) {
+          parts.push(`error=${JSON.stringify(result.error)}`);
+        }
+        const level = result.success ? getCommandLogLevel(cmd) : "warn";
+        logAtLevel(level, "Command", parts.join(" "));
+      }
       setAgentStreamManager(manager) {
         this._agentStream = manager;
       }
       // ─── Command Dispatcher ──────────────────────────
       async handle(cmd, args) {
         this._currentRoute = this.resolveRoute(args);
+        const startedAt = Date.now();
+        this.logCommandStart(cmd, args);
+        let result;
         if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {
           const cdpCommands = ["send_chat", "read_chat", "list_chats", "new_chat", "switch_chat", "set_mode", "change_model", "set_thought_level", "resolve_action"];
           if (cdpCommands.includes(cmd)) {
-            return { success: false, error: "No targetSessionId specified \u2014 cannot route command" };
+            result = { success: false, error: "No targetSessionId specified \u2014 cannot route command" };
+            this.logCommandEnd(cmd, result, startedAt);
+            return result;
           }
         }
         try {
-          return await this.dispatch(cmd, args);
+          result = await this.dispatch(cmd, args);
+          this.logCommandEnd(cmd, result, startedAt);
+          return result;
         } catch (e) {
           LOG.error("Command", `[${cmd}] Unhandled error: ${e?.message || e}`);
-          return { success: false, error: `Internal error: ${e?.message || "unknown"}` };
+          result = { success: false, error: `Internal error: ${e?.message || "unknown"}` };
+          this.logCommandEnd(cmd, result, startedAt);
+          return result;
         }
       }
       async dispatch(cmd, args) {
@@ -37695,7 +37842,13 @@ function forwardAgentStreamsToIdeInstance(instanceManager, ideType, streams) {
       status: stream.status || "idle",
       activeModal: stream.activeModal || null,
       model: stream.model || void 0,
-      mode: stream.mode || void 0
+      mode: stream.mode || void 0,
+      sessionId: stream.sessionId || stream.instanceId || void 0,
+      title: stream.title || stream.agentName || void 0,
+      agentType: stream.agentType || void 0,
+      agentName: stream.agentName || void 0,
+      extensionId: stream.extensionId || void 0,
+      inputContent: stream.inputContent || ""
     });
   }
 }
@@ -37768,14 +37921,13 @@ var init_provider_instance_manager = __esm({
           try {
             const state = instance.getState();
             states.push(state);
-            for (const event of state.pendingEvents) {
-              for (const listener of this.eventListeners) {
-                listener({
-                  ...event,
-                  providerType: instance.type,
-                  instanceId: state.instanceId,
-                  targetSessionId: state.instanceId,
-                  providerCategory: state.category
+            this.emitPendingEvents(instance.type, state);
+            if (state.category === "ide") {
+              for (const childState of state.extensions) {
+                this.emitPendingEvents(childState.type, childState, {
+                  targetSessionId: childState.instanceId,
+                  workspaceName: state.workspace || void 0,
+                  parentSessionId: state.instanceId
                 });
               }
             }
@@ -37824,6 +37976,21 @@ var init_provider_instance_manager = __esm({
       onEvent(listener) {
         this.eventListeners.push(listener);
       }
+      emitPendingEvents(providerType, state, extra = {}) {
+        for (const event of state.pendingEvents) {
+          for (const listener of this.eventListeners) {
+            listener({
+              ...event,
+              providerType,
+              instanceId: state.instanceId,
+              targetSessionId: state.instanceId,
+              providerCategory: state.category,
+              workspaceName: state.workspace || void 0,
+              ...extra
+            });
+          }
+        }
+      }
       /**
       * Forward event to specific Instance
       */
@@ -41562,7 +41729,7 @@ async function initDaemonComponents(config2) {
       const ideInstance = instanceManager.getInstance(instanceKey);
       if (ideInstance) {
         instanceManager.removeInstance(instanceKey);
-        LOG.info("CDP", `Instance removed after disconnect: ${instanceKey}`);
+        LOG.info("IDE", `Instance removed after detach: ${instanceKey}`);
       }
       if (ideInstance?.getInstanceId) {
         agentStreamManager?.resetParentSession(ideInstance.getInstanceId());
@@ -41997,6 +42164,40 @@ var init_server_connection = __esm({
 });
 
 // src/daemon-p2p.ts
+function normalizeSharePermission(permission) {
+  if (!permission) return void 0;
+  if (permission === "view") return "remote_view";
+  if (permission === "control") return "remote_control";
+  if (permission === "full") return "remote_full";
+  return permission;
+}
+function canPeerStartScreenshots(permission) {
+  if (!permission) return true;
+  return permission === "remote_view" || permission === "remote_control" || permission === "remote_full";
+}
+function canPeerSendMessages(permission) {
+  if (!permission) return true;
+  return permission === "chat_control" || permission === "remote_control" || permission === "remote_full";
+}
+function canPeerUseRemoteInput(permission) {
+  if (!permission) return true;
+  return permission === "remote_full";
+}
+function canPeerUsePrivilegedShareCommand(commandType, permission) {
+  if (!permission) return true;
+  switch (commandType) {
+    case "read_chat":
+    case "list_chats":
+      return true;
+    case "send_chat":
+    case "new_chat":
+    case "switch_chat":
+    case "resolve_action":
+      return canPeerSendMessages(permission);
+    default:
+      return false;
+  }
+}
 var fs11, path13, os16, import_node_module, esmRequire, logFile, log, logDebug, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p.ts"() {
@@ -42209,7 +42410,7 @@ ${e?.stack || ""}`);
         }
       }
       /** P2P connect Start */
-      async initiateconnection(peerId) {
+      async initiateconnection(peerId, sharePermission) {
         if (!this.nodeDatachannel) {
           log("Cannot initiate \u2014 node-datachannel not available");
           return;
@@ -42302,6 +42503,7 @@ ${e?.stack || ""}`);
           pc,
           dataChannel: null,
           state: "connecting",
+          sharePermission: normalizeSharePermission(sharePermission),
           screenshotActive: false,
           connectedAt: Date.now(),
           pendingCandidates: [],
@@ -42423,10 +42625,15 @@ ${e?.stack || ""}`);
           }
           if (parsed.type === "screenshot_start") {
             const peer = this.peers.get(peerId);
+            const permission = peer?.sharePermission;
             if (!parsed.ideType) {
               log(`screenshot_start: REJECTED \u2014 no ideType from peer ${peerId}`);
               return;
             }
+            if (!canPeerStartScreenshots(permission)) {
+              log(`screenshot_start: REJECTED \u2014 permission=${permission || "trusted"} peer=${peerId}`);
+              return;
+            }
             if (peer) {
               peer.screenshotActive = true;
               peer.screenshotIdeType = parsed.ideType;
@@ -42455,23 +42662,27 @@ ${e?.stack || ""}`);
             return;
           }
           if (parsed.type === "pty_input") {
+            const permission = this.peers.get(peerId)?.sharePermission;
+            if (permission) {
+              log(`pty_input: REJECTED \u2014 permission=${permission} peer=${peerId}`);
+              return;
+            }
             if (this.ptyInputHandler && parsed.data) {
               this.ptyInputHandler(parsed.cliType || "", parsed.data);
             }
             return;
           }
           if (parsed.type === "pty_resize") {
+            const permission = this.peers.get(peerId)?.sharePermission;
+            if (permission) {
+              log(`pty_resize: REJECTED \u2014 permission=${permission} peer=${peerId}`);
+              return;
+            }
             if (this.ptyResizeHandler && parsed.cols && parsed.rows) {
               this.ptyResizeHandler(parsed.cliType || "", parsed.cols, parsed.rows);
             }
             return;
           }
-          if (parsed.type === "chat_history") {
-            const { agent, offset, limit, id, instanceId } = parsed;
-            const result = readChatHistory(agent || "", offset || 0, limit || 30, instanceId);
-            this.sendToPeer(peerId, { type: "chat_history_result", id, ...result, agent });
-            return;
-          }
           this.handleFileRequest(peerId, parsed);
         } catch (e) {
           log(`Parse error from peer ${peerId}: ${e?.message}`);
@@ -42590,6 +42801,11 @@ ${e?.stack || ""}`);
       // ─── P2P command/input/file handling ────────────────
       async handleP2PCommand(peerId, msg) {
         const { id, commandType, data } = msg;
+        const permission = this.peers.get(peerId)?.sharePermission;
+        if (!canPeerUsePrivilegedShareCommand(commandType, permission)) {
+          this.sendToPeer(peerId, { type: "command_result", id, success: false, error: "Permission denied" });
+          return;
+        }
         if (!this.commandHandler) {
           this.sendToPeer(peerId, { type: "command_result", id, success: false, error: "No handler" });
           return;
@@ -42603,6 +42819,11 @@ ${e?.stack || ""}`);
       }
       async handleInputEvent(peerId, msg) {
         const { id, action, params, instanceId } = msg;
+        const permission = this.peers.get(peerId)?.sharePermission;
+        if (!canPeerUseRemoteInput(permission)) {
+          this.sendToPeer(peerId, { id, type: "response", success: false, error: "Permission denied" });
+          return;
+        }
         if (!this.inputHandler) {
           this.sendToPeer(peerId, { id, type: "response", success: false, error: "No input handler" });
           return;
@@ -42620,6 +42841,11 @@ ${e?.stack || ""}`);
         }
       }
       async handleFileRequest(peerId, req) {
+        const permission = this.peers.get(peerId)?.sharePermission;
+        if (permission) {
+          this.sendToPeer(peerId, { id: req.id, success: false, error: "Permission denied" });
+          return;
+        }
         let response;
         if (this.fileRequestHandler) {
           try {
@@ -42645,7 +42871,7 @@ ${e?.stack || ""}`);
         const peerId = payload?.peerId;
         if (type === "p2p_ready") {
           log(`p2p_ready from peer ${peerId}`);
-          this.initiateconnection(peerId);
+          this.initiateconnection(peerId, payload?.sharePermission);
           return;
         }
         if (type === "p2p_answer") {
@@ -42658,6 +42884,9 @@ ${e?.stack || ""}`);
             log(`p2p_answer for unknown peer ${peerId} \u2014 ignoring`);
             return;
           }
+          if (payload?.sharePermission) {
+            peer.sharePermission = normalizeSharePermission(payload.sharePermission);
+          }
           if (peer.remoteDescriptionSet) {
             log(`p2p_answer ignored: already applied for peer ${peerId} (duplicate relay)`);
             return;
@@ -42694,6 +42923,9 @@ ${e?.stack || ""}`);
           }
           const peer = this.peers.get(peerId);
           if (peer?.pc && payload.candidate) {
+            if (payload?.sharePermission) {
+              peer.sharePermission = normalizeSharePermission(payload.sharePermission);
+            }
             log(`p2p_ice received from peer ${peerId}: ${String(payload.candidate).substring(0, 80)}`);
             if (!peer.remoteDescriptionSet) {
               peer.pendingCandidates.push({
@@ -43033,7 +43265,7 @@ var init_adhdev_daemon = __esm({
     fs12 = __toESM(require("fs"));
     path14 = __toESM(require("path"));
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.7.2";
+    pkgVersion = "0.7.6";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [