@zonease/happy 0.6.41 → 0.6.42

package/dist/lib.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-var api = require('./api-XeHlmApX.cjs');
-var logger = require('./persistence-DrfN7TzY.cjs');
+var api = require('./api-CIE4_cWd.cjs');
+var logger = require('./persistence-BcQmjobZ.cjs');
 var types = require('./types-DWeB7aqh.cjs');
 require('axios');
 require('node:events');
 require('socket.io-client');
 require('zod');
-require('./index-CDTNgfUf.cjs');
+require('./index-BeKrqPYR.cjs');
 require('@paralleldrive/cuid2');
 require('./time-Bj2HRkKH.cjs');
 require('node:crypto');
@@ -30,7 +30,7 @@ require('tweetnacl');
 require('@stablelib/base64');
 require('node:readline');
 require('expo-server-sdk');
-require('./sessionKeyCache-dDquDzn0.cjs');
+require('./sessionKeyCache-BwFUGgMs.cjs');
 require('chalk');
 require('fs');
 

package/dist/lib.d.cts

@@ -1309,6 +1309,7 @@ type ACPMessageData = {
     type: 'token_count';
     [key: string]: unknown;
 };
+type ACPProvider = 'gemini' | 'codex' | 'claude' | 'opencode' | 'cursor';
 type OrchestratorProvider = 'claude' | 'codex' | 'gemini';
 type OrchestratorSubmitTask = {
     taskKey?: string;
@@ -1461,7 +1462,7 @@ declare class ApiSessionClient extends EventEmitter {
      * @param provider - The agent provider sending the message (e.g., 'gemini', 'codex', 'claude')
      * @param body - The message payload (type: 'message' | 'reasoning' | 'tool-call' | 'tool-result')
      */
-    sendAgentMessage(provider: 'gemini' | 'codex' | 'claude' | 'opencode', body: ACPMessageData): void;
+    sendAgentMessage(provider: ACPProvider, body: ACPMessageData): void;
     /**
      * Send a batch of pre-built message content objects for backfill (session resume/copy).
      * Each item.content should be a complete message object (role + content) ready to encrypt.
@@ -1555,7 +1556,7 @@ interface SpawnSessionOptions {
     sessionTitle?: string;
     skipForkSession?: boolean;
     approvedNewDirectoryCreation?: boolean;
-    agent?: 'claude' | 'codex' | 'gemini';
+    agent?: 'claude' | 'codex' | 'gemini' | 'cursor';
     token?: string;
     environmentVariables?: {
         ANTHROPIC_BASE_URL?: string;

package/dist/lib.d.mts

@@ -1309,6 +1309,7 @@ type ACPMessageData = {
     type: 'token_count';
     [key: string]: unknown;
 };
+type ACPProvider = 'gemini' | 'codex' | 'claude' | 'opencode' | 'cursor';
 type OrchestratorProvider = 'claude' | 'codex' | 'gemini';
 type OrchestratorSubmitTask = {
     taskKey?: string;
@@ -1461,7 +1462,7 @@ declare class ApiSessionClient extends EventEmitter {
      * @param provider - The agent provider sending the message (e.g., 'gemini', 'codex', 'claude')
      * @param body - The message payload (type: 'message' | 'reasoning' | 'tool-call' | 'tool-result')
      */
-    sendAgentMessage(provider: 'gemini' | 'codex' | 'claude' | 'opencode', body: ACPMessageData): void;
+    sendAgentMessage(provider: ACPProvider, body: ACPMessageData): void;
     /**
      * Send a batch of pre-built message content objects for backfill (session resume/copy).
      * Each item.content should be a complete message object (role + content) ready to encrypt.
@@ -1555,7 +1556,7 @@ interface SpawnSessionOptions {
     sessionTitle?: string;
     skipForkSession?: boolean;
     approvedNewDirectoryCreation?: boolean;
-    agent?: 'claude' | 'codex' | 'gemini';
+    agent?: 'claude' | 'codex' | 'gemini' | 'cursor';
     token?: string;
     environmentVariables?: {
         ANTHROPIC_BASE_URL?: string;

package/dist/lib.mjs

@@ -1,11 +1,11 @@
-export { A as ApiClient, a as ApiSessionClient } from './api-K2-jr9ar.mjs';
-export { c as configuration, l as logger } from './persistence-CIUFyOwz.mjs';
+export { A as ApiClient, a as ApiSessionClient } from './api-Ew6xr81i.mjs';
+export { c as configuration, l as logger } from './persistence-D9tMm6bj.mjs';
 export { R as RawJSONLinesSchema } from './types-BoJh4Qfv.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
 import 'zod';
-import './index-CPKdvi7J.mjs';
+import './index-DTV7drqs.mjs';
 import '@paralleldrive/cuid2';
 import './time-DgsBLJA_.mjs';
 import 'node:crypto';
@@ -28,6 +28,6 @@ import 'tweetnacl';
 import '@stablelib/base64';
 import 'node:readline';
 import 'expo-server-sdk';
-import './sessionKeyCache-D2u3JUys.mjs';
+import './sessionKeyCache-pXTjpETo.mjs';
 import 'chalk';
 import 'fs';

package/dist/{loadableToolOutput-4EvraaNY.mjs → loadableToolOutput-2dMPAp4N.mjs}

@@ -1,192 +1,6 @@
-import { l as logger, c as configuration, p as packageJson } from './persistence-CIUFyOwz.mjs';
 import { randomUUID } from 'node:crypto';
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
-import os, { homedir } from 'node:os';
-import { join, basename, dirname } from 'node:path';
-import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { r as resolveToolsDir, s as startOfflineReconnection, b as saveToolOutputRecord } from './api-K2-jr9ar.mjs';
-import { a as detectGitWorktree } from './downloadImage-ia5SzlCV.mjs';
-
-class BasePermissionHandler {
-  pendingRequests = /* @__PURE__ */ new Map();
-  session;
-  pushClient;
-  isResetting = false;
-  isUserInteractionTool(toolName) {
-    return ["AskUserQuestion", "ExitPlanMode", "exit_plan_mode"].includes(toolName);
-  }
-  constructor(session, pushClient) {
-    this.session = session;
-    this.pushClient = pushClient;
-    this.setupRpcHandler();
-  }
-  /**
-   * Update the session reference (used after offline reconnection swaps sessions).
-   * This is critical for avoiding stale session references after onSessionSwap.
-   */
-  updateSession(newSession) {
-    logger.debug(`${this.getLogPrefix()} Session reference updated`);
-    this.session = newSession;
-    this.setupRpcHandler();
-  }
-  /**
-   * Setup RPC handler for permission responses.
-   */
-  setupRpcHandler() {
-    this.session.rpcHandlerManager.registerHandler(
-      "permission",
-      async (response) => {
-        const pending = this.pendingRequests.get(response.id);
-        if (!pending) {
-          logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
-          return;
-        }
-        this.pendingRequests.delete(response.id);
-        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
-        pending.resolve(result);
-        if (response.approved && (response.mode === "bypassPermissions" || response.decision === "approved_for_session")) {
-          this.approvePendingRequestsForSession(response);
-        }
-        this.session.updateAgentState((currentState) => {
-          const request = currentState.requests?.[response.id];
-          if (!request) return currentState;
-          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
-          let res = {
-            ...currentState,
-            requests: remainingRequests,
-            completedRequests: {
-              ...currentState.completedRequests,
-              [response.id]: {
-                ...request,
-                completedAt: Date.now(),
-                status: response.approved ? "approved" : "denied",
-                decision: result.decision,
-                mode: response.mode,
-                allowedTools: response.allowTools
-              }
-            }
-          };
-          return res;
-        });
-        logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
-      }
-    );
-  }
-  approvePendingRequestsForSession(response) {
-    const pendingSnapshot = Array.from(this.pendingRequests.entries());
-    const completedAt = Date.now();
-    for (const [id, pending] of pendingSnapshot) {
-      if (this.isUserInteractionTool(pending.toolName)) {
-        continue;
-      }
-      this.pendingRequests.delete(id);
-      pending.resolve({ decision: "approved_for_session" });
-    }
-    if (pendingSnapshot.length === 0) {
-      return;
-    }
-    this.session.updateAgentState((currentState) => {
-      const requests = { ...currentState.requests || {} };
-      const completedRequests = { ...currentState.completedRequests };
-      let changed = false;
-      for (const [id, pending] of pendingSnapshot) {
-        if (this.isUserInteractionTool(pending.toolName)) {
-          continue;
-        }
-        const request = requests[id];
-        if (!request) {
-          continue;
-        }
-        delete requests[id];
-        completedRequests[id] = {
-          ...request,
-          completedAt,
-          status: "approved",
-          decision: "approved_for_session",
-          mode: response.mode,
-          allowedTools: response.allowTools
-        };
-        changed = true;
-      }
-      if (!changed) {
-        return currentState;
-      }
-      return {
-        ...currentState,
-        requests,
-        completedRequests
-      };
-    });
-  }
-  /**
-   * Add a pending request to the agent state and send a push notification.
-   */
-  addPendingRequestToState(toolCallId, toolName, input) {
-    this.pushClient.sendToAllDevices(
-      "Permission Request",
-      `${this.getAgentName()} wants to ${toolName}`,
-      {
-        sessionId: this.session.sessionId,
-        requestId: toolCallId,
-        tool: toolName,
-        type: "permission_request"
-      }
-    );
-    this.session.updateAgentState((currentState) => ({
-      ...currentState,
-      requests: {
-        ...currentState.requests,
-        [toolCallId]: {
-          tool: toolName,
-          arguments: input,
-          createdAt: Date.now()
-        }
-      }
-    }));
-  }
-  /**
-   * Reset state for new sessions.
-   * This method is idempotent - safe to call multiple times.
-   */
-  reset() {
-    if (this.isResetting) {
-      logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
-      return;
-    }
-    this.isResetting = true;
-    try {
-      const pendingSnapshot = Array.from(this.pendingRequests.entries());
-      this.pendingRequests.clear();
-      for (const [id, pending] of pendingSnapshot) {
-        try {
-          pending.reject(new Error("Session reset"));
-        } catch (err) {
-          logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
-        }
-      }
-      this.session.updateAgentState((currentState) => {
-        const pendingRequests = currentState.requests || {};
-        const completedRequests = { ...currentState.completedRequests };
-        for (const [id, request] of Object.entries(pendingRequests)) {
-          completedRequests[id] = {
-            ...request,
-            completedAt: Date.now(),
-            status: "canceled",
-            reason: "Session reset"
-          };
-        }
-        return {
-          ...currentState,
-          requests: {},
-          completedRequests
-        };
-      });
-      logger.debug(`${this.getLogPrefix()} Permission handler reset`);
-    } finally {
-      this.isResetting = false;
-    }
-  }
-}
+import { l as logger } from './persistence-D9tMm6bj.mjs';
+import { s as saveToolOutputRecord } from './api-Ew6xr81i.mjs';
 
 class BaseReasoningProcessor {
   accumulator = "";
@@ -382,273 +196,6 @@ class BaseReasoningProcessor {
   }
 }
 
-const DEFAULT_MAX_SKILLS = 400;
-const DEFAULT_MAX_DEPTH = 10;
-const SKILL_FILE = "SKILL.md";
-const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  "dist",
-  "build",
-  "references",
-  "assets",
-  "templates"
-]);
-function parseFrontMatter(content) {
-  if (!content.startsWith("---")) return {};
-  const end = content.indexOf("\n---", 3);
-  if (end < 0) return {};
-  const block = content.slice(3, end).split(/\r?\n/);
-  const result = {};
-  for (let i = 0; i < block.length; i++) {
-    const line = block[i];
-    const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line.trim());
-    if (!match) continue;
-    const [, key, rawValue] = match;
-    let value = rawValue.trim().replace(/^['"]|['"]$/g, "");
-    if ((rawValue.trim() === ">-" || rawValue.trim() === ">" || rawValue.trim() === "|-" || rawValue.trim() === "|") && key === "description") {
-      const continuation = [];
-      while (i + 1 < block.length && /^\s+/.test(block[i + 1])) {
-        i++;
-        continuation.push(block[i].trim());
-      }
-      value = continuation.join(rawValue.trim().startsWith("|") ? "\n" : " ").trim();
-    }
-    if (key === "name" && value) result.name = value;
-    if (key === "description" && value) result.description = value;
-  }
-  return result;
-}
-function deriveSkillName(skillFilePath) {
-  return basename(dirname(skillFilePath));
-}
-function collectSkillFiles(root, maxDepth, maxFiles) {
-  const files = [];
-  function walk(dir, depth) {
-    if (files.length >= maxFiles || depth > maxDepth) return;
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (files.length >= maxFiles) return;
-      const fullPath = join(dir, entry.name);
-      if (entry.isFile() && entry.name === SKILL_FILE) {
-        files.push(fullPath);
-        continue;
-      }
-      if (!entry.isDirectory()) continue;
-      if (IGNORED_DIRECTORIES.has(entry.name)) continue;
-      walk(fullPath, depth + 1);
-    }
-  }
-  if (existsSync(root)) {
-    walk(root, 0);
-  }
-  return files;
-}
-function skillRoots(homeDir, includePluginCache) {
-  const roots = [
-    { path: join(homeDir, ".agents", "skills"), source: "agents" },
-    { path: join(homeDir, ".codex", "skills"), source: "codex" },
-    { path: join(homeDir, ".claude", "skills"), source: "claude" }
-  ];
-  if (includePluginCache) {
-    roots.push(
-      { path: join(homeDir, ".codex", "plugins", "cache"), source: "codex-plugin-cache" },
-      { path: join(homeDir, ".codex", ".tmp", "plugins", "plugins"), source: "codex-plugin-marketplace" }
-    );
-  }
-  return roots;
-}
-function discoverCodexSkills(options = {}) {
-  const homeDir = options.homeDir ?? homedir();
-  const maxSkills = options.maxSkills ?? DEFAULT_MAX_SKILLS;
-  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
-  const includePluginCache = options.includePluginCache ?? true;
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const root of skillRoots(homeDir, includePluginCache)) {
-    if (result.length >= maxSkills) break;
-    const skillFiles = collectSkillFiles(root.path, maxDepth, maxSkills - result.length);
-    for (const skillFile of skillFiles) {
-      if (result.length >= maxSkills) break;
-      let content = "";
-      try {
-        content = readFileSync(skillFile, "utf8");
-      } catch {
-        continue;
-      }
-      const frontMatter = parseFrontMatter(content);
-      const name = (frontMatter.name || deriveSkillName(skillFile)).trim();
-      if (!name) continue;
-      const key = name.toLowerCase();
-      if (seen.has(key)) continue;
-      seen.add(key);
-      result.push({
-        name,
-        description: frontMatter.description,
-        source: root.source
-      });
-    }
-  }
-  return result;
-}
-
-function detectWorkspaceSubdirectories(cwd) {
-  try {
-    const entries = readdirSync(cwd, { withFileTypes: true });
-    const repos = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const subDir = join(cwd, entry.name);
-      const info = detectGitWorktree(subDir);
-      if (info.isWorktree && info.worktreeBasePath && info.worktreeBranchName) {
-        repos.push({
-          path: subDir,
-          basePath: info.worktreeBasePath,
-          branchName: info.worktreeBranchName,
-          displayName: entry.name
-        });
-      }
-    }
-    if (repos.length > 0) {
-      return {
-        isWorktree: true,
-        workspaceRepos: repos,
-        workspacePath: cwd
-      };
-    }
-  } catch {
-  }
-  return {};
-}
-function detectWorktreeMetadata() {
-  if (process.env.HAPPY_WORKSPACE_REPOS) {
-    try {
-      const repos = JSON.parse(process.env.HAPPY_WORKSPACE_REPOS);
-      return {
-        isWorktree: true,
-        workspaceRepos: repos,
-        workspacePath: process.env.HAPPY_WORKSPACE_PATH
-      };
-    } catch {
-    }
-  }
-  if (process.env.HAPPY_WORKTREE_BASE_PATH) {
-    return {
-      isWorktree: true,
-      worktreeBasePath: process.env.HAPPY_WORKTREE_BASE_PATH,
-      worktreeBranchName: process.env.HAPPY_WORKTREE_BRANCH_NAME
-    };
-  }
-  const info = detectGitWorktree(process.cwd());
-  if (info.isWorktree) {
-    return {
-      isWorktree: true,
-      worktreeBasePath: info.worktreeBasePath,
-      worktreeBranchName: info.worktreeBranchName
-    };
-  }
-  const workspaceResult = detectWorkspaceSubdirectories(process.cwd());
-  if (workspaceResult.isWorktree) {
-    return workspaceResult;
-  }
-  return {};
-}
-function createSessionMetadata(opts) {
-  const state = {
-    controlledByUser: false
-  };
-  const metadata = {
-    path: process.cwd(),
-    host: os.hostname(),
-    version: packageJson.version,
-    os: os.platform(),
-    machineId: opts.machineId,
-    homeDir: os.homedir(),
-    happyHomeDir: configuration.happyHomeDir,
-    happyLibDir: projectPath(),
-    happyToolsDir: resolveToolsDir(),
-    startedFromDaemon: opts.startedBy === "daemon",
-    hostPid: process.pid,
-    startedBy: opts.startedBy || "terminal",
-    lifecycleState: "running",
-    lifecycleStateSince: Date.now(),
-    flavor: opts.flavor,
-    // Worktree metadata: env vars from daemon take priority, otherwise detect via git
-    ...detectWorktreeMetadata()
-  };
-  if (opts.flavor === "codex") {
-    metadata.skills = discoverCodexSkills();
-  }
-  return { state, metadata };
-}
-
-function createOfflineSessionStub(sessionTag) {
-  return {
-    sessionId: `offline-${sessionTag}`,
-    sendCodexMessage: () => {
-    },
-    sendAgentMessage: () => {
-    },
-    sendClaudeSessionMessage: () => {
-    },
-    keepAlive: () => {
-    },
-    sendSessionEvent: () => {
-    },
-    sendSessionDeath: () => {
-    },
-    updateLifecycleState: () => {
-    },
-    requestControlTransfer: async () => {
-    },
-    flush: async () => {
-    },
-    close: async () => {
-    },
-    updateMetadata: () => {
-    },
-    updateAgentState: () => {
-    },
-    onUserMessage: () => {
-    },
-    rpcHandlerManager: {
-      registerHandler: () => {
-      }
-    }
-  };
-}
-
-function setupOfflineReconnection(opts) {
-  const { api, sessionTag, metadata, state, response, onSessionSwap } = opts;
-  let session;
-  let reconnectionHandle = null;
-  if (!response) {
-    session = createOfflineSessionStub(sessionTag);
-    reconnectionHandle = startOfflineReconnection({
-      serverUrl: configuration.serverUrl,
-      onReconnected: async () => {
-        const resp = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
-        if (!resp) throw new Error("Server unavailable");
-        const realSession = api.sessionSyncClient(resp);
-        onSessionSwap(realSession);
-        return realSession;
-      },
-      onNotify: (msg) => {
-        console.log(msg);
-      }
-    });
-    return { session, reconnectionHandle, isOffline: true };
-  } else {
-    session = api.sessionSyncClient(response);
-    return { session, reconnectionHandle: null, isOffline: false };
-  }
-}
-
 const SUPPORTED_CATEGORIES = /* @__PURE__ */ new Set(["mode", "model", "thought_level"]);
 function isRecord(value) {
   return !!value && typeof value === "object";
@@ -1189,4 +736,4 @@ function summarizeBashToolOutput(options) {
   });
 }
 
-export { BasePermissionHandler as B, BaseReasoningProcessor as a, summarizeBashToolOutput as b, createSessionMetadata as c, handleAgentMessageChunk as d, handleToolCallUpdate as e, handleAgentThoughtChunk as f, handleToolCall as g, handleConfigMetadataEvent as h, handleLegacyMessageChunk as i, handlePlanUpdate as j, handleThinkingUpdate as k, setupOfflineReconnection as s };
+export { BaseReasoningProcessor as B, handleAgentMessageChunk as a, handleToolCallUpdate as b, handleAgentThoughtChunk as c, handleToolCall as d, handleLegacyMessageChunk as e, handlePlanUpdate as f, handleThinkingUpdate as g, handleConfigMetadataEvent as h, summarizeBashToolOutput as s };