adhdev 0.1.50 → 0.1.51

package/dist/index.js

@@ -4510,16 +4510,16 @@ var init_daemon_commands = __esm({
       async handleReadChat(args) {
         const provider2 = this.getProvider();
         const _log = (msg) => console.log(`[read_chat] ${msg}`);
-        if (provider2?.category === "cli") {
+        if (provider2?.category === "cli" || provider2?.category === "acp") {
           const adapter = this.getCliAdapter(provider2.type);
           if (adapter) {
-            _log(`CLI adapter: ${adapter.cliType}`);
+            _log(`${provider2.category} adapter: ${adapter.cliType}`);
             const status = adapter.getStatus?.();
             if (status) {
               return { success: true, messages: status.messages || [], status: status.status, activeModal: status.activeModal };
             }
           }
-          return { success: false, error: "CLI adapter not found" };
+          return { success: false, error: `${provider2.category} adapter not found` };
         }
         if (provider2?.category === "extension") {
           try {
@@ -4575,15 +4575,15 @@ var init_daemon_commands = __esm({
         if (!text) return { success: false, error: "text required" };
         const _log = (msg) => console.log(`[send_chat] ${msg}`);
         const provider2 = this.getProvider();
-        if (provider2?.category === "cli") {
+        if (provider2?.category === "cli" || provider2?.category === "acp") {
           const adapter = this.getCliAdapter(provider2.type);
           if (adapter) {
-            _log(`CLI adapter: ${adapter.cliType}`);
+            _log(`${provider2.category} adapter: ${adapter.cliType}`);
             try {
               await adapter.sendMessage(text);
-              return { success: true, sent: true, method: "cli-adapter", targetAgent: adapter.cliType };
+              return { success: true, sent: true, method: `${provider2.category}-adapter`, targetAgent: adapter.cliType };
             } catch (e) {
-              return { success: false, error: `CLI send failed: ${e.message}` };
+              return { success: false, error: `${provider2.category} send failed: ${e.message}` };
             }
           }
         }
@@ -6917,18 +6917,545 @@ var init_cli_provider_instance = __esm({
   }
 });
 
+// src/providers/acp-provider-instance.ts
+var path9, crypto, import_child_process6, import_readline, AcpProviderInstance;
+var init_acp_provider_instance = __esm({
+  "src/providers/acp-provider-instance.ts"() {
+    "use strict";
+    path9 = __toESM(require("path"));
+    crypto = __toESM(require("crypto"));
+    import_child_process6 = require("child_process");
+    import_readline = require("readline");
+    init_status_monitor();
+    AcpProviderInstance = class {
+      constructor(provider2, workingDir, cliArgs = []) {
+        this.cliArgs = cliArgs;
+        this.type = provider2.type;
+        this.provider = provider2;
+        this.workingDir = workingDir;
+        this.instanceId = `acp_${provider2.type}_${crypto.createHash("md5").update(require("os").hostname() + provider2.type + workingDir).digest("hex").slice(0, 8)}`;
+        this.monitor = new StatusMonitor();
+      }
+      type;
+      category = "acp";
+      provider;
+      context = null;
+      settings = {};
+      events = [];
+      monitor;
+      // Process
+      process = null;
+      readline = null;
+      requestId = 1;
+      pendingRequests = /* @__PURE__ */ new Map();
+      // State
+      sessionId = null;
+      messages = [];
+      currentStatus = "starting";
+      lastStatus = "starting";
+      generatingStartedAt = 0;
+      agentCapabilities = {};
+      currentModel;
+      currentMode;
+      activeToolCalls = [];
+      stopReason = null;
+      partialContent = "";
+      // Config
+      workingDir;
+      instanceId;
+      // ─── Lifecycle ─────────────────────────────────
+      async init(context) {
+        this.context = context;
+        this.settings = context.settings || {};
+        this.monitor.updateConfig({
+          approvalAlert: this.settings.approvalAlert !== false,
+          longGeneratingAlert: this.settings.longGeneratingAlert !== false,
+          longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180
+        });
+        await this.spawnAgent();
+      }
+      async onTick() {
+        if (this.process && this.process.exitCode !== null) {
+          this.currentStatus = "stopped";
+          this.detectStatusTransition();
+        }
+      }
+      getState() {
+        const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
+        const recentMessages = this.messages.slice(-50).map((m) => ({
+          role: m.role,
+          content: m.content.length > 2e3 ? m.content.slice(0, 2e3) + "\n... (truncated)" : m.content,
+          timestamp: m.timestamp
+        }));
+        if (this.currentStatus === "generating" && this.partialContent) {
+          const cleaned = this.partialContent.trim();
+          if (cleaned) {
+            recentMessages.push({
+              role: "assistant",
+              content: (cleaned.length > 2e3 ? cleaned.slice(0, 2e3) + "..." : cleaned) + "...",
+              timestamp: Date.now()
+            });
+          }
+        }
+        return {
+          type: this.type,
+          name: this.provider.name,
+          category: "acp",
+          status: this.currentStatus,
+          mode: "chat",
+          activeChat: {
+            id: this.sessionId || `${this.type}_${this.workingDir}`,
+            title: `${this.provider.name} \xB7 ${dirName}`,
+            status: this.currentStatus,
+            messages: recentMessages,
+            activeModal: this.currentStatus === "waiting_approval" ? {
+              message: this.activeToolCalls.find((t) => t.status === "running")?.name || "Permission requested",
+              buttons: ["Approve", "Reject"]
+            } : null,
+            inputContent: ""
+          },
+          workingDir: this.workingDir,
+          currentModel: this.currentModel,
+          currentPlan: this.currentMode,
+          instanceId: this.instanceId,
+          lastUpdated: Date.now(),
+          settings: this.settings,
+          pendingEvents: this.flushEvents()
+        };
+      }
+      onEvent(event, data) {
+        if (event === "send_message" && data?.text) {
+          this.sendPrompt(data.text).catch(
+            (e) => console.warn(`[ACP:${this.type}] sendPrompt error:`, e?.message)
+          );
+        } else if (event === "resolve_action") {
+          const action = data?.action || "approve";
+          this.resolvePermission(action === "approve" || action === "accept").catch((e) => console.warn(`[ACP:${this.type}] resolvePermission error:`, e?.message));
+        } else if (event === "cancel") {
+          this.cancelSession().catch(
+            (e) => console.warn(`[ACP:${this.type}] cancel error:`, e?.message)
+          );
+        }
+      }
+      dispose() {
+        if (this.process) {
+          try {
+            this.process.kill("SIGTERM");
+          } catch {
+          }
+          this.process = null;
+        }
+        if (this.readline) {
+          this.readline.close();
+          this.readline = null;
+        }
+        for (const [, req] of this.pendingRequests) {
+          clearTimeout(req.timer);
+          req.reject(new Error("Instance disposed"));
+        }
+        this.pendingRequests.clear();
+        this.monitor.reset();
+      }
+      // ─── ACP Process Management ──────────────────────
+      async spawnAgent() {
+        const spawnConfig = this.provider.spawn;
+        if (!spawnConfig) {
+          throw new Error(`[ACP:${this.type}] No spawn config defined`);
+        }
+        const command = spawnConfig.command;
+        const args = [...spawnConfig.args || [], ...this.cliArgs];
+        const env = { ...process.env, ...spawnConfig.env || {} };
+        console.log(`[ACP:${this.type}] Spawning: ${command} ${args.join(" ")} in ${this.workingDir}`);
+        this.process = (0, import_child_process6.spawn)(command, args, {
+          cwd: this.workingDir,
+          env,
+          stdio: ["pipe", "pipe", "pipe"],
+          shell: spawnConfig.shell || false
+        });
+        this.readline = (0, import_readline.createInterface)({ input: this.process.stdout });
+        this.readline.on("line", (line) => {
+          const trimmed = line.trim();
+          if (!trimmed) return;
+          try {
+            const msg = JSON.parse(trimmed);
+            this.handleMessage(msg);
+          } catch (e) {
+          }
+        });
+        this.process.stderr?.on("data", (data) => {
+          const text = data.toString().trim();
+          if (text) {
+            console.log(`[ACP:${this.type}:stderr] ${text.slice(0, 200)}`);
+          }
+        });
+        this.process.on("exit", (code, signal) => {
+          console.log(`[ACP:${this.type}] Process exited: code=${code} signal=${signal}`);
+          this.currentStatus = "stopped";
+          this.detectStatusTransition();
+        });
+        this.process.on("error", (err) => {
+          console.error(`[ACP:${this.type}] Process error:`, err.message);
+          this.currentStatus = "error";
+          this.detectStatusTransition();
+        });
+        await this.initialize();
+      }
+      // ─── ACP Protocol ────────────────────────────────
+      async initialize() {
+        try {
+          const result = await this.sendRequest("initialize", {
+            protocolVersion: "0.1.0",
+            clientInfo: {
+              name: "adhdev",
+              version: "0.1.0"
+            },
+            clientCapabilities: {
+              roots: true
+            },
+            workspaceFolders: [{
+              name: path9.basename(this.workingDir),
+              uri: `file://${this.workingDir}`
+            }]
+          });
+          this.agentCapabilities = result?.capabilities || {};
+          console.log(`[ACP:${this.type}] Initialized. Agent capabilities:`, JSON.stringify(this.agentCapabilities));
+          this.sendNotification("initialized");
+          await this.createSession();
+        } catch (e) {
+          console.error(`[ACP:${this.type}] Initialize failed:`, e?.message);
+          this.currentStatus = "error";
+        }
+      }
+      async createSession() {
+        try {
+          const result = await this.sendRequest("session/new", {
+            cwd: this.workingDir,
+            mcpServers: []
+          });
+          this.sessionId = result?.sessionId || null;
+          this.currentStatus = "idle";
+          this.messages = [];
+          if (result?.models?.currentModelId) {
+            this.currentModel = result.models.currentModelId;
+          }
+          console.log(`[ACP:${this.type}] Session created: ${this.sessionId}${this.currentModel ? ` (model: ${this.currentModel})` : ""}`);
+        } catch (e) {
+          console.warn(`[ACP:${this.type}] session/new failed:`, e?.message);
+          this.currentStatus = "idle";
+        }
+      }
+      async sendPrompt(text) {
+        this.messages.push({
+          role: "user",
+          content: text,
+          timestamp: Date.now()
+        });
+        this.currentStatus = "generating";
+        this.partialContent = "";
+        this.detectStatusTransition();
+        try {
+          const result = await this.sendRequest("session/prompt", {
+            sessionId: this.sessionId,
+            prompt: [{ type: "text", text }]
+          }, 3e5);
+          if (result?.stopReason) {
+            this.stopReason = result.stopReason;
+          }
+          if (this.partialContent.trim()) {
+            this.messages.push({
+              role: "assistant",
+              content: this.partialContent.trim(),
+              timestamp: Date.now()
+            });
+            this.partialContent = "";
+          }
+          this.currentStatus = "idle";
+          this.detectStatusTransition();
+        } catch (e) {
+          console.warn(`[ACP:${this.type}] prompt error:`, e?.message);
+          if (this.partialContent.trim()) {
+            this.messages.push({
+              role: "assistant",
+              content: this.partialContent.trim(),
+              timestamp: Date.now()
+            });
+            this.partialContent = "";
+          }
+          this.currentStatus = "idle";
+          this.detectStatusTransition();
+        }
+      }
+      async cancelSession() {
+        this.sendNotification("session/cancel", {
+          sessionId: this.sessionId
+        });
+        this.currentStatus = "idle";
+        this.detectStatusTransition();
+      }
+      permissionResolvers = [];
+      async resolvePermission(approved) {
+        const resolver = this.permissionResolvers.shift();
+        if (resolver) {
+          resolver(approved);
+        }
+        if (this.currentStatus === "waiting_approval") {
+          this.currentStatus = "generating";
+          this.detectStatusTransition();
+        }
+      }
+      // ─── JSON-RPC Transport ──────────────────────────
+      sendRequest(method, params, timeoutMs = 3e4) {
+        return new Promise((resolve6, reject) => {
+          if (!this.process?.stdin?.writable) {
+            reject(new Error("Process stdin not writable"));
+            return;
+          }
+          const id = this.requestId++;
+          const msg = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params
+          };
+          const timer = setTimeout(() => {
+            this.pendingRequests.delete(id);
+            reject(new Error(`Request ${method} timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          this.pendingRequests.set(id, { resolve: resolve6, reject, timer });
+          const line = JSON.stringify(msg) + "\n";
+          this.process.stdin.write(line);
+        });
+      }
+      sendNotification(method, params) {
+        if (!this.process?.stdin?.writable) return;
+        const msg = {
+          jsonrpc: "2.0",
+          method,
+          ...params && { params }
+        };
+        const line = JSON.stringify(msg) + "\n";
+        this.process.stdin.write(line);
+      }
+      handleMessage(msg) {
+        if ("id" in msg && msg.id !== void 0 && !("method" in msg && msg.method)) {
+          const pending = this.pendingRequests.get(msg.id);
+          if (pending) {
+            clearTimeout(pending.timer);
+            this.pendingRequests.delete(msg.id);
+            const resp = msg;
+            if (resp.error) {
+              pending.reject(new Error(`${resp.error.message} (${resp.error.code})`));
+            } else {
+              pending.resolve(resp.result);
+            }
+          }
+          return;
+        }
+        if ("method" in msg) {
+          this.handleNotification(msg);
+          if ("id" in msg && msg.id !== void 0) {
+            this.handleAgentRequest(msg);
+          }
+        }
+      }
+      handleNotification(msg) {
+        switch (msg.method) {
+          case "session/update": {
+            const params = msg.params;
+            this.handleSessionUpdate(params);
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      handleAgentRequest(msg) {
+        switch (msg.method) {
+          case "fs/readTextFile":
+          case "fs/writeTextFile": {
+            this.sendResponse(msg.id, null, {
+              code: -32601,
+              message: "File system access not supported by ADHDev client"
+            });
+            break;
+          }
+          case "requestPermission": {
+            this.currentStatus = "waiting_approval";
+            this.detectStatusTransition();
+            const promise = new Promise((resolve6) => {
+              this.permissionResolvers.push(resolve6);
+              setTimeout(() => {
+                const idx = this.permissionResolvers.indexOf(resolve6);
+                if (idx >= 0) {
+                  this.permissionResolvers.splice(idx, 1);
+                  resolve6(false);
+                }
+              }, 3e5);
+            });
+            promise.then((approved) => {
+              this.sendResponse(msg.id, {
+                outcome: approved ? "approved" : "denied"
+              });
+            });
+            break;
+          }
+          case "terminal/create":
+          case "terminal/output":
+          case "terminal/release":
+          case "terminal/kill":
+          case "terminal/waitForExit": {
+            this.sendResponse(msg.id, null, {
+              code: -32601,
+              message: "Terminal not supported by ADHDev client"
+            });
+            break;
+          }
+          default: {
+            this.sendResponse(msg.id, null, {
+              code: -32601,
+              message: `Method ${msg.method} not supported`
+            });
+          }
+        }
+      }
+      sendResponse(id, result, error) {
+        if (!this.process?.stdin?.writable) return;
+        const msg = {
+          jsonrpc: "2.0",
+          id,
+          ...error ? { error } : { result }
+        };
+        const line = JSON.stringify(msg) + "\n";
+        this.process.stdin.write(line);
+      }
+      // ─── ACP session/update 처리 ─────────────────────
+      handleSessionUpdate(params) {
+        if (!params) return;
+        if (params.messageDelta) {
+          const delta = params.messageDelta;
+          if (delta.content) {
+            for (const part of Array.isArray(delta.content) ? delta.content : [delta.content]) {
+              if (part.type === "text" && part.text) {
+                this.partialContent += part.text;
+              }
+            }
+          }
+          this.currentStatus = "generating";
+        }
+        if (params.message) {
+          const m = params.message;
+          let content = "";
+          if (typeof m.content === "string") {
+            content = m.content;
+          } else if (Array.isArray(m.content)) {
+            content = m.content.filter((p) => p.type === "text").map((p) => p.text || "").join("\n");
+          }
+          if (content.trim()) {
+            this.messages.push({
+              role: m.role || "assistant",
+              content: content.trim(),
+              timestamp: Date.now()
+            });
+            this.partialContent = "";
+          }
+        }
+        if (params.toolCallUpdate) {
+          const tc = params.toolCallUpdate;
+          const existing = this.activeToolCalls.find((t) => t.id === tc.id);
+          if (existing) {
+            if (tc.status) existing.status = tc.status;
+            if (tc.output) existing.output = tc.output;
+          } else {
+            this.activeToolCalls.push({
+              id: tc.id || `tc_${Date.now()}`,
+              name: tc.name || "unknown",
+              status: tc.status || "running",
+              input: typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
+            });
+          }
+        }
+        if (params.stopReason) {
+          this.stopReason = params.stopReason;
+          if (params.stopReason !== "cancelled") {
+            this.currentStatus = "idle";
+          }
+          this.activeToolCalls = [];
+          this.detectStatusTransition();
+        }
+        if (params.model) {
+          this.currentModel = params.model;
+        }
+      }
+      // ─── 상태 전이 감지 ────────────────────────────
+      detectStatusTransition() {
+        const now = Date.now();
+        const newStatus = this.currentStatus;
+        const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
+        const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
+        if (newStatus !== this.lastStatus) {
+          if (this.lastStatus === "idle" && newStatus === "generating") {
+            this.generatingStartedAt = now;
+            this.pushEvent({ event: "agent:generating_started", chatTitle, timestamp: now });
+          } else if (newStatus === "waiting_approval") {
+            if (!this.generatingStartedAt) this.generatingStartedAt = now;
+            this.pushEvent({
+              event: "agent:waiting_approval",
+              chatTitle,
+              timestamp: now,
+              modalMessage: this.activeToolCalls.find((t) => t.status === "running")?.name
+            });
+          } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
+            const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
+            this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now });
+            this.generatingStartedAt = 0;
+          } else if (newStatus === "stopped") {
+            this.pushEvent({ event: "agent:stopped", chatTitle, timestamp: now });
+          }
+          this.lastStatus = newStatus;
+        }
+        const agentKey = `${this.type}:acp`;
+        const monitorEvents = this.monitor.check(agentKey, newStatus, now);
+        for (const me of monitorEvents) {
+          this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
+        }
+      }
+      pushEvent(event) {
+        this.events.push(event);
+        if (this.events.length > 50) this.events = this.events.slice(-50);
+      }
+      flushEvents() {
+        const events = [...this.events];
+        this.events = [];
+        return events;
+      }
+      // ─── 외부 접근 ─────────────────────────────────
+      get cliType() {
+        return this.type;
+      }
+      get cliName() {
+        return this.provider.name;
+      }
+      /** ACP Agent capabilities (initialize 후 사용 가능) */
+      getCapabilities() {
+        return this.agentCapabilities;
+      }
+    };
+  }
+});
+
 // src/daemon-cli.ts
-var os10, path9, import_chalk, DaemonCliManager;
+var os10, path10, import_chalk, DaemonCliManager;
 var init_daemon_cli = __esm({
   "src/daemon-cli.ts"() {
     "use strict";
     os10 = __toESM(require("os"));
-    path9 = __toESM(require("path"));
+    path10 = __toESM(require("path"));
     import_chalk = __toESM(require("chalk"));
     init_provider_cli_adapter();
     init_cli_detector();
     init_config();
     init_cli_provider_instance();
+    init_acp_provider_instance();
     DaemonCliManager = class {
       adapters = /* @__PURE__ */ new Map();
       deps;
@@ -6963,20 +7490,54 @@ var init_daemon_cli = __esm({
       // ─── 세션 시작/중지 ──────────────────────────────
       async startSession(cliType, workingDir, cliArgs) {
         const trimmed = (workingDir || os10.homedir()).trim();
-        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path9.resolve(trimmed);
-        const cliInfo = await detectCLI(cliType);
-        if (!cliInfo) throw new Error(`${cliType} not found`);
-        const key = this.getCliKey(cliType, resolvedDir);
-        if (this.adapters.has(key)) {
-          console.log(import_chalk.default.yellow(`  \u26A1 CLI ${cliType} already running in ${resolvedDir}`));
-          return;
-        }
+        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path10.resolve(trimmed);
         const typeMap = {
           "claude-code": "claude-cli",
           "codex": "codex-cli"
         };
         const normalizedType = typeMap[cliType] || cliType;
         const provider2 = this.providerLoader.get(normalizedType);
+        const key = this.getCliKey(normalizedType, resolvedDir);
+        if (this.adapters.has(key)) {
+          console.log(import_chalk.default.yellow(`  \u26A1 ${cliType} already running in ${resolvedDir}`));
+          return;
+        }
+        if (provider2 && provider2.category === "acp") {
+          const instanceManager2 = this.deps.getInstanceManager();
+          if (!instanceManager2) throw new Error("InstanceManager not available");
+          console.log(import_chalk.default.cyan(`  \u{1F50C} Starting ACP agent: ${provider2.name} (${provider2.type}) in ${resolvedDir}`));
+          const acpInstance = new AcpProviderInstance(provider2, resolvedDir, cliArgs);
+          await instanceManager2.addInstance(key, acpInstance, {
+            settings: this.providerLoader.getSettings(normalizedType)
+          });
+          this.adapters.set(key, {
+            cliType: normalizedType,
+            workingDir: resolvedDir,
+            spawn: async () => {
+            },
+            shutdown: () => {
+              instanceManager2.removeInstance(key);
+            },
+            sendMessage: async (text) => {
+              acpInstance.onEvent("send_message", { text });
+            },
+            getStatus: () => ({ status: "idle", messages: [], activeModal: null }),
+            setOnStatusChange: () => {
+            },
+            setOnPtyData: () => {
+            }
+          });
+          console.log(import_chalk.default.green(`  \u2713 ACP agent started: ${provider2.name} in ${resolvedDir}`));
+          try {
+            addCliHistory({ cliType: normalizedType, dir: resolvedDir, cliArgs });
+          } catch (e) {
+            console.warn("[ACP] History save failed:", e?.message);
+          }
+          this.deps.onStatusChange();
+          return;
+        }
+        const cliInfo = await detectCLI(cliType);
+        if (!cliInfo) throw new Error(`${cliType} not found`);
         console.log(import_chalk.default.yellow(`  \u26A1 Starting CLI ${cliType} in ${resolvedDir}...`));
         if (provider2) {
           console.log(import_chalk.default.cyan(`  \u{1F4E6} Using provider: ${provider2.name} (${provider2.type})`));
@@ -7408,12 +7969,12 @@ var init_extension_provider_instance = __esm({
 });
 
 // src/providers/ide-provider-instance.ts
-var os11, crypto, IdeProviderInstance;
+var os11, crypto2, IdeProviderInstance;
 var init_ide_provider_instance = __esm({
   "src/providers/ide-provider-instance.ts"() {
     "use strict";
     os11 = __toESM(require("os"));
-    crypto = __toESM(require("crypto"));
+    crypto2 = __toESM(require("crypto"));
     init_extension_provider_instance();
     init_status_monitor();
     IdeProviderInstance = class {
@@ -7441,7 +8002,7 @@ var init_ide_provider_instance = __esm({
       constructor(provider2, instanceKey) {
         this.type = provider2.type;
         this.provider = provider2;
-        this.instanceId = instanceKey ? `${instanceKey}_${crypto.createHash("md5").update(os11.hostname() + instanceKey).digest("hex").slice(0, 8)}` : `${provider2.type}_${crypto.createHash("md5").update(os11.hostname() + provider2.type).digest("hex").slice(0, 8)}`;
+        this.instanceId = instanceKey ? `${instanceKey}_${crypto2.createHash("md5").update(os11.hostname() + instanceKey).digest("hex").slice(0, 8)}` : `${provider2.type}_${crypto2.createHash("md5").update(os11.hostname() + provider2.type).digest("hex").slice(0, 8)}`;
         this.monitor = new StatusMonitor();
       }
       // ─── Lifecycle ─────────────────────────────────
@@ -7680,9 +8241,9 @@ __export(adhdev_daemon_exports, {
   stopDaemon: () => stopDaemon
 });
 function getDaemonPidFile() {
-  const dir = path10.join(os12.homedir(), ".adhdev");
+  const dir = path11.join(os12.homedir(), ".adhdev");
   if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  return path10.join(dir, "daemon.pid");
+  return path11.join(dir, "daemon.pid");
 }
 function writeDaemonPid(pid) {
   fs6.writeFileSync(getDaemonPidFile(), String(pid), "utf-8");
@@ -7718,7 +8279,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os12, fs6, path10, crypto2, import_chalk2, DANGEROUS_PATTERNS, AdhdevDaemon;
+var os12, fs6, path11, crypto3, import_chalk2, DANGEROUS_PATTERNS, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -7741,8 +8302,8 @@ var init_adhdev_daemon = __esm({
     init_daemon_logger();
     os12 = __toESM(require("os"));
     fs6 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
-    crypto2 = __toESM(require("crypto"));
+    path11 = __toESM(require("path"));
+    crypto3 = __toESM(require("crypto"));
     import_chalk2 = __toESM(require("chalk"));
     DANGEROUS_PATTERNS = [
       /\brm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i,
@@ -7877,7 +8438,7 @@ var init_adhdev_daemon = __esm({
         this.commandHandler.setAgentStreamManager(this.agentStreamManager);
         this.startAgentStreamPolling();
         const machineId = os12.hostname().replace(/[^a-zA-Z0-9]/g, "_");
-        const machineHash = crypto2.createHash("md5").update(os12.hostname() + os12.homedir()).digest("hex").slice(0, 8);
+        const machineHash = crypto3.createHash("md5").update(os12.hostname() + os12.homedir()).digest("hex").slice(0, 8);
         const instanceId = `daemon_${machineId}_${machineHash}`;
         this.bridge = new CliBridgeConnection({
           serverUrl: options.serverUrl || config.serverUrl,
@@ -9065,16 +9626,16 @@ async function injectTokenToIDE(ide, connectionToken) {
   try {
     const os13 = await import("os");
     const fs7 = await import("fs");
-    const path11 = await import("path");
+    const path12 = await import("path");
     const platform7 = os13.platform();
     const home = os13.homedir();
     const getSettingsPath = (appName2) => {
       if (platform7 === "darwin") {
-        return path11.join(home, "Library", "Application Support", appName2, "User", "settings.json");
+        return path12.join(home, "Library", "Application Support", appName2, "User", "settings.json");
       } else if (platform7 === "win32") {
-        return path11.join(process.env.APPDATA || path11.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
+        return path12.join(process.env.APPDATA || path12.join(home, "AppData", "Roaming"), appName2, "User", "settings.json");
       } else {
-        return path11.join(home, ".config", appName2, "User", "settings.json");
+        return path12.join(home, ".config", appName2, "User", "settings.json");
       }
     };
     const loader = new ProviderLoader({ logFn: () => {
@@ -9092,7 +9653,7 @@ async function injectTokenToIDE(ide, connectionToken) {
         settings = {};
       }
     } else {
-      fs7.mkdirSync(path11.dirname(settingsPath), { recursive: true });
+      fs7.mkdirSync(path12.dirname(settingsPath), { recursive: true });
     }
     settings["adhdev.connectionToken"] = connectionToken;
     settings["adhdev.autoConnect"] = true;
@@ -9128,8 +9689,8 @@ async function startDaemonFlow() {
     const daemon = new AdhdevDaemon2();
     const { execSync: execSync6 } = await import("child_process");
     const os13 = await import("os");
-    const path11 = await import("path");
-    const logPath = path11.join(os13.homedir(), ".adhdev", "daemon.log");
+    const path12 = await import("path");
+    const logPath = path12.join(os13.homedir(), ".adhdev", "daemon.log");
     try {
       execSync6(`nohup adhdev daemon > "${logPath}" 2>&1 &`, {
         timeout: 3e3,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adhdev",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "description": "ADHDev CLI — Detect, install and configure your IDE + AI agent extensions",
   "main": "dist/index.js",
   "bin": {

package/providers/_builtin/acp/codex-cli/provider.js

@@ -12,11 +12,11 @@
  * @type {import('../../../../src/providers/contracts').ProviderModule}
  */
 module.exports = {
-  type: 'codex-cli',
-  name: 'Codex CLI',
+  type: 'codex-acp',
+  name: 'Codex (ACP)',
   category: 'acp',
 
-  displayName: 'Codex',
+  displayName: 'Codex (ACP)',
   icon: '🤖',
 
   // ACP spawn config — uses codex-acp adapter