very-happy-cli 0.2.159 → 0.2.161

package/dist/handleResumeCommand-DnVmy7a3.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var spawnHappyCLI = require('./spawnHappyCLI-BhYj84rv.cjs');
+var axios = require('axios');
+var tweetnacl = require('tweetnacl');
+var z = require('zod');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var localHappyAgentAuth = require('./localHappyAgentAuth-BXiHPXdC.cjs');
+require('cross-spawn');
+require('node:path');
+require('./projectPath-ChLhdOyt.cjs');
+require('path');
+require('url');
+require('./logger-Bc8-u1w0.cjs');
+require('chalk');
+require('node:util');
+require('node:crypto');
+require('node:os');
+require('./package-Cl5BEP5x.cjs');
+require('node:fs/promises');
+
+const ResumableMetadataSchema = z.z.object({
+  path: z.z.string().min(1),
+  flavor: z.z.string().optional(),
+  claudeSessionId: z.z.string().optional(),
+  codexThreadId: z.z.string().optional()
+}).passthrough();
+function resolveSessionRecordByPrefix(records, sessionId) {
+  const trimmed = sessionId.trim();
+  if (!trimmed) {
+    throw new Error("Happy session ID is required: very-happy resume <session-id>");
+  }
+  const matches = records.filter((record) => record.id.startsWith(trimmed));
+  if (matches.length === 0) {
+    throw new Error(`No Happy session found matching "${trimmed}"`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous Happy session "${trimmed}" matches ${matches.length} sessions. Be more specific.`);
+  }
+  return matches[0];
+}
+function decryptBoxBundle(bundle, recipientSecretKey) {
+  if (bundle.length < 56) {
+    return null;
+  }
+  const ephemeralPublicKey = bundle.slice(0, 32);
+  const nonce = bundle.slice(32, 56);
+  const ciphertext = bundle.slice(56);
+  const decrypted = tweetnacl.box.open(ciphertext, nonce, ephemeralPublicKey, recipientSecretKey);
+  return decrypted ? new Uint8Array(decrypted) : null;
+}
+function readAgentCredentials() {
+  const credentialPath = localHappyAgentAuth.getLocalHappyAgentCredentialPath();
+  const credentials = localHappyAgentAuth.readLocalHappyAgentCredentials();
+  if (!credentials) {
+    throw new Error(
+      `Cannot use the legacy CLI resume path without ${credentialPath}. This credential is produced only by the source-only internal control-plane prototype; do not install the unrelated npm package named happy-agent. Use the Web session controls instead.`
+    );
+  }
+  return credentials;
+}
+function resolveSessionEncryption(session, credentials) {
+  if (session.dataEncryptionKey) {
+    const encrypted = authRelay.decodeBase64(session.dataEncryptionKey);
+    const sessionKey = decryptBoxBundle(encrypted.slice(1), credentials.contentKeyPair.secretKey);
+    if (!sessionKey) {
+      throw new Error(`Failed to decrypt data key for Happy session ${session.id}`);
+    }
+    return {
+      key: sessionKey,
+      variant: "dataKey"
+    };
+  }
+  return {
+    key: credentials.secret,
+    variant: "legacy"
+  };
+}
+function decryptSessionMetadata(session, credentials) {
+  const encryption = resolveSessionEncryption(session, credentials);
+  const encryptedMetadata = authRelay.decodeBase64(session.metadata);
+  const metadata = encryption.variant === "dataKey" ? authRelay.decryptWithDataKey(encryptedMetadata, encryption.key) : authRelay.decryptLegacy(encryptedMetadata, encryption.key);
+  if (!metadata) {
+    throw new Error(`Failed to decrypt metadata for Happy session ${session.id}`);
+  }
+  try {
+    return ResumableMetadataSchema.parse(metadata);
+  } catch {
+    throw new Error(`Happy session ${session.id} is missing resumable metadata.`);
+  }
+}
+async function fetchSessions(credentials) {
+  try {
+    const response = await axios.get(`${configuration.configuration.serverUrl}/v1/sessions`, {
+      headers: {
+        Authorization: `Bearer ${credentials.token}`,
+        "X-Happy-Client": `cli-coding-session/${configuration.configuration.currentCliVersion}`
+      }
+    });
+    return response.data.sessions;
+  } catch (error) {
+    if (error instanceof axios.AxiosError) {
+      if (error.response?.status === 401) {
+        throw new Error(
+          "Legacy CLI resume authentication expired. Re-provision it from the source-only internal control-plane prototype; do not install the unrelated npm package named happy-agent."
+        );
+      }
+      throw new Error(`Failed to load Happy sessions: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function resolveHappySession(sessionId) {
+  const credentials = readAgentCredentials();
+  const sessions = await fetchSessions(credentials);
+  const matched = resolveSessionRecordByPrefix(sessions, sessionId);
+  return {
+    id: matched.id,
+    active: matched.active,
+    metadata: decryptSessionMetadata(matched, credentials)
+  };
+}
+
+function parseResumeCommandArgs(args) {
+  if (args.includes("-h") || args.includes("--help")) {
+    return {
+      showHelp: true,
+      sessionId: ""
+    };
+  }
+  if (args.length === 0) {
+    throw new Error("Happy session ID is required: very-happy resume <session-id>");
+  }
+  if (args.length > 1) {
+    throw new Error(`Unexpected arguments for very-happy resume: ${args.slice(1).join(" ")}`);
+  }
+  return {
+    showHelp: false,
+    sessionId: args[0]
+  };
+}
+function resolveFlavor(metadata) {
+  if (metadata.flavor === "codex" || metadata.codexThreadId) {
+    return "codex";
+  }
+  if (metadata.flavor === "claude" || metadata.claudeSessionId) {
+    return "claude";
+  }
+  return null;
+}
+function buildResumeLaunch(session, options = {}) {
+  const { metadata } = session;
+  const flavor = resolveFlavor(metadata);
+  if (flavor === "codex") {
+    const args = ["codex"];
+    if (options.freshConversation) ; else {
+      if (!metadata.codexThreadId) {
+        throw new Error(`Happy session ${session.id} is missing its Codex thread ID.`);
+      }
+      args.push("--resume", metadata.codexThreadId);
+    }
+    if (options.startedBy) {
+      args.push("--started-by", options.startedBy);
+    }
+    return {
+      cwd: metadata.path,
+      args
+    };
+  }
+  if (flavor === "claude") {
+    const args = ["claude"];
+    if (options.claudeStartingMode) {
+      args.push("--happy-starting-mode", options.claudeStartingMode);
+    }
+    if (options.startedBy) {
+      args.push("--started-by", options.startedBy);
+    }
+    if (options.freshConversation) ; else {
+      if (!metadata.claudeSessionId) {
+        throw new Error(`Happy session ${session.id} is missing its Claude session ID.`);
+      }
+      args.push("--resume", metadata.claudeSessionId);
+    }
+    return {
+      cwd: metadata.path,
+      args
+    };
+  }
+  throw new Error(`Happy session ${session.id} uses unsupported flavor "${metadata.flavor ?? "unknown"}".`);
+}
+function formatResumeHelp() {
+  return [
+    "very-happy resume - Resume a previous Happy session",
+    "",
+    "Usage:",
+    "  very-happy resume <happy-session-id>",
+    "",
+    "Examples:",
+    "  very-happy resume cmmij8olq00dp5jcxr3wtbpau",
+    "  very-happy resume cmmij8",
+    "",
+    "This reuses the saved worktree/path and resumes the underlying agent session",
+    "when the backend supports it."
+  ].join("\n");
+}
+function spawnResumeChild(launch) {
+  return new Promise((resolve, reject) => {
+    const child = spawnHappyCLI.spawnHappyCLI(launch.args, {
+      cwd: launch.cwd,
+      env: process.env,
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`Resumed session exited via signal ${signal}`));
+        return;
+      }
+      resolve(code);
+    });
+  });
+}
+async function handleResumeCommand(args) {
+  const parsed = parseResumeCommandArgs(args);
+  if (parsed.showHelp) {
+    console.log(formatResumeHelp());
+    return;
+  }
+  const session = await resolveHappySession(parsed.sessionId);
+  const launch = buildResumeLaunch(session);
+  if (!node_fs.existsSync(launch.cwd)) {
+    throw new Error(`Saved session path does not exist: ${launch.cwd}`);
+  }
+  const exitCode = await spawnResumeChild(launch);
+  if (typeof exitCode === "number" && exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+exports.buildResumeLaunch = buildResumeLaunch;
+exports.formatResumeHelp = formatResumeHelp;
+exports.handleResumeCommand = handleResumeCommand;
+exports.parseResumeCommandArgs = parseResumeCommandArgs;

package/dist/ids-B6ZC0HGt.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+const TERMINAL_ID_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+function isValidSessionId(id) {
+  return typeof id === "string" && SESSION_ID_RE.test(id);
+}
+function isValidTerminalId(id) {
+  return typeof id === "string" && TERMINAL_ID_RE.test(id);
+}
+
+exports.isValidSessionId = isValidSessionId;
+exports.isValidTerminalId = isValidTerminalId;

package/dist/ids-DU6sLx4C.mjs

@@ -0,0 +1,10 @@
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+const TERMINAL_ID_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+function isValidSessionId(id) {
+  return typeof id === "string" && SESSION_ID_RE.test(id);
+}
+function isValidTerminalId(id) {
+  return typeof id === "string" && TERMINAL_ID_RE.test(id);
+}
+
+export { isValidTerminalId as a, isValidSessionId as i };

package/dist/index-B6UGRQ7h.mjs

@@ -0,0 +1,102 @@
+import { query as query$1 } from '@anthropic-ai/claude-agent-sdk';
+export { AbortError } from '@anthropic-ai/claude-agent-sdk';
+import { p as pinSmallFastModel, e as ensureLocalProxyBypass } from './smallFastModel-BLNgMrwR.mjs';
+
+const HAPPY_DEFAULT_ENTRYPOINT = "remote_mobile";
+function resolveHappyEntrypoint(currentValue) {
+  if (currentValue && currentValue.length > 0) {
+    return currentValue;
+  }
+  return HAPPY_DEFAULT_ENTRYPOINT;
+}
+
+function query(params) {
+  const opts = params.options;
+  let systemPrompt = void 0;
+  if (opts?.customSystemPrompt) {
+    systemPrompt = opts.customSystemPrompt;
+  } else if (opts?.appendSystemPrompt) {
+    systemPrompt = {
+      type: "preset",
+      preset: "claude_code",
+      append: opts.appendSystemPrompt
+    };
+  }
+  const sdkOptions = {
+    cwd: opts?.cwd,
+    additionalDirectories: opts?.additionalDirectories,
+    resume: opts?.resume,
+    continue: opts?.continue,
+    model: opts?.model,
+    fallbackModel: opts?.fallbackModel,
+    maxTurns: opts?.maxTurns,
+    permissionMode: opts?.permissionMode,
+    allowDangerouslySkipPermissions: opts?.allowDangerouslySkipPermissions ?? opts?.permissionMode === "bypassPermissions",
+    allowedTools: opts?.allowedTools,
+    disallowedTools: opts?.disallowedTools,
+    mcpServers: opts?.mcpServers,
+    systemPrompt,
+    settings: opts?.settingsPath,
+    // Load filesystem settings the way the real `claude` CLI does. The
+    // agent SDK does NOT load these by default (the rename from
+    // @anthropic-ai/claude-code flipped the default to "isolated" — the
+    // sdk.d.ts comment claiming "omitted = all sources" is stale), so a
+    // remote/web session would otherwise ignore ~/.claude/CLAUDE.md, the
+    // project .claude/, AND skills (skills are discovered from these dirs).
+    // 'user' brings in the global CLAUDE.md (e.g. "reply in Chinese"),
+    // 'project'/'local' bring in repo-level CLAUDE.md + settings → parity
+    // with a plain CLI invocation. This is the whole point of running our
+    // own fork: remote sessions should behave like local ones.
+    settingSources: ["user", "project", "local"],
+    strictMcpConfig: opts?.strictMcpConfig,
+    sessionId: void 0,
+    effort: opts?.effort,
+    forkSession: opts?.forkSession,
+    tools: opts?.tools,
+    persistSession: opts?.persistSession,
+    includePartialMessages: opts?.includePartialMessages,
+    forwardSubagentText: true,
+    enableFileCheckpointing: true,
+    extraArgs: { "replay-user-messages": null },
+    onElicitation: opts?.onElicitation,
+    onUserDialog: opts?.onUserDialog,
+    supportedDialogKinds: opts?.onUserDialog ? opts.supportedDialogKinds : void 0
+  };
+  if (opts?.abort) {
+    const controller = new AbortController();
+    if (opts.abort.aborted) {
+      controller.abort(opts.abort.reason);
+    } else {
+      opts.abort.addEventListener("abort", () => controller.abort(opts.abort?.reason), { once: true });
+    }
+    sdkOptions.abortController = controller;
+  }
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  for (const [key, value] of Object.entries(opts?.env ?? {})) {
+    if (typeof value === "string") env[key] = value;
+  }
+  env.CLAUDE_CODE_ENTRYPOINT = resolveHappyEntrypoint(env.CLAUDE_CODE_ENTRYPOINT);
+  pinSmallFastModel(env);
+  if (opts?.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+    ensureLocalProxyBypass(env);
+  }
+  if (sdkOptions.allowDangerouslySkipPermissions && typeof process.getuid === "function" && process.getuid() === 0 && env.IS_SANDBOX === void 0) {
+    env.IS_SANDBOX = "1";
+  }
+  sdkOptions.env = env;
+  if (opts?.canCallTool) {
+    const callback = opts.canCallTool;
+    sdkOptions.canUseTool = async (toolName, input, options) => {
+      return callback(toolName, input, options);
+    };
+  }
+  return query$1({
+    prompt: params.prompt,
+    options: sdkOptions
+  });
+}
+
+export { query };

package/dist/{index-2mCaeKyf.mjs → index-CAFwetLk.mjs}

@@ -1,56 +1,86 @@
-import { D as DefaultTransport, A as AcpBackend } from './AcpBackend-VsfkZiVF.mjs';
-export { a as DEFAULT_IDLE_TIMEOUT_MS, b as DEFAULT_TOOL_CALL_TIMEOUT_MS, e as extractErrorDetail, f as formatDuration, c as formatDurationMinutes, h as handleAgentMessageChunk, d as handleAgentThoughtChunk, g as handleLegacyMessageChunk, i as handlePlanUpdate, j as handleThinkingUpdate, k as handleToolCall, l as handleToolCallUpdate, p as parseArgsFromContent } from './AcpBackend-VsfkZiVF.mjs';
-import { r as readSettings, v as notifyDaemonSessionStarted, w as encodeBase64, l as logger, x as BUILTIN_TODO_DISCOVERY, c as configuration, P as PROMPT_QUEUE_CAPABILITY, y as reportSessionEditToDaemon } from './limits-CjRj8IX5.mjs';
-import { A as AcpSessionManager } from './AcpSessionManager-rYtVb0kN.mjs';
-import { h as initialMachineMetadata, j as createSessionMetadata, k as setupOfflineReconnection, l as StreamRelay, M as MessageQueue2, m as hashObject, n as startHappyServer, o as registerAgentAttachmentDownloads, u as TitleGenerator, v as registerKillSessionHandler, C as CLAUDE_ATTACHMENT_KINDS, w as stageClaudeAttachments, x as appendStagedAttachmentsToPrompt, B as BasePermissionHandler, E as EditReportThrottle, y as extractAcpEditPaths, z as writeSessionModeFile, F as normalizeAcpPermissionMode, H as removeSessionModeFile } from './index-BF6WfgV5.mjs';
-import { p as preparePiTeamsRuntime } from './piRuntime-kLZNpAAl.mjs';
+import { D as DefaultTransport, A as AcpBackend } from './AcpBackend-6U6pQgx1.mjs';
+export { a as DEFAULT_IDLE_TIMEOUT_MS, b as DEFAULT_TOOL_CALL_TIMEOUT_MS, e as extractErrorDetail, f as formatDuration, c as formatDurationMinutes, h as handleAgentMessageChunk, d as handleAgentThoughtChunk, g as handleLegacyMessageChunk, i as handlePlanUpdate, j as handleThinkingUpdate, k as handleToolCall, l as handleToolCallUpdate, p as parseArgsFromContent } from './AcpBackend-6U6pQgx1.mjs';
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import { A as AcpSessionManager } from './AcpSessionManager-CoMWFVw3.mjs';
+import { l as BUILTIN_TODO_DISCOVERY, P as PROMPT_QUEUE_CAPABILITY } from './index-qdS1friN.mjs';
+import { r as registerAgentAttachmentDownloads } from './agentAttachments-M_B5qEF2.mjs';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-CSGxr71v.mjs';
+import { p as preparePiTeamsRuntime } from './piRuntime-BwRdhK_N.mjs';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { h as connectionState, A as ApiClient } from './types-Dh-s4Lqs.mjs';
-import { p as projectPath } from './terminalTitleSuggest-DKgX3osW.mjs';
+import { c as connectionState, A as ApiClient } from './api-SffjRQ1b.mjs';
+import { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-Cbc8Rgtd.mjs';
+import { h as hashObject, s as startHappyServer } from './deterministicJson-p835AdAU.mjs';
+import { readSettings } from './persistence-oET5n61f.mjs';
+import { g as getInitialMachineMetadata } from './machineMetadata-BHjehxJY.mjs';
+import { c as createSessionMetadata } from './createSessionMetadata-mIeehclp.mjs';
+import { s as setupOfflineReconnection } from './setupOfflineReconnection-CVViqZft.mjs';
+import { n as notifyDaemonSessionStarted, g as reportSessionEditToDaemon } from './controlClient-DjoKTtgK.mjs';
+import { e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import { S as StreamRelay } from './streamRelay-FPVbHpbM.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { B as BasePermissionHandler } from './BasePermissionHandler-BvvhBTja.mjs';
+import { T as TitleGenerator } from './titleGenerator-ox6ptCsp.mjs';
+import { w as writeSessionModeFile, n as normalizeAcpPermissionMode, r as removeSessionModeFile } from './sessionModeFile-CDmDyRkD.mjs';
+import { E as EditReportThrottle, e as extractAcpEditPaths } from './editPaths-BVfS_FFL.mjs';
 import 'node:child_process';
 import '@agentclientprotocol/sdk';
-import 'zod';
-import '@paralleldrive/cuid2';
-import 'node:fs/promises';
-import 'node:fs';
-import 'tweetnacl';
+import './time-BZNdNiIV.mjs';
+import './contentLogMetadata-BlWI0egu.mjs';
+import './package-uOg9SCKi.mjs';
 import 'chalk';
 import 'node:util';
+import 'node:fs';
+import '@paralleldrive/cuid2';
+import 'zod';
 import 'node:os';
-import 'cross-spawn';
-import 'node:readline';
-import './agentGuidance-KgvYuF3R.mjs';
+import 'node:fs/promises';
+import './attachmentLimits-yba1uHFO.mjs';
+import './resources-BdFBQi8r.mjs';
 import 'axios';
-import 'socket.io-client';
-import 'fs/promises';
-import 'ink';
-import 'react';
-import '@anthropic-ai/claude-agent-sdk';
 import 'node:events';
+import 'socket.io-client';
+import './limits-DIo7rEBR.mjs';
+import './lidState-C2dI0FAN.mjs';
 import 'os';
 import 'child_process';
-import 'fs';
-import 'path';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
+import './registerCommonHandlers-CrgvJsOy.mjs';
+import 'util';
+import 'fs/promises';
 import 'crypto';
-import 'ps-list';
-import 'tmp';
-import 'open';
-import 'fastify';
-import 'fastify-type-provider-zod';
-import 'node:module';
+import 'path';
+import 'cross-spawn';
+import './sync-CxD-w_40.mjs';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import 'tweetnacl';
+import './types-CkqAACXx.mjs';
+import './client-Brn-UwVk.mjs';
+import './context-C9GHPLEm.mjs';
+import './sessionOps-C_f1wKOr.mjs';
+import './tools-BmQQUATY.mjs';
+import './tools-BZabNIid.mjs';
+import './client-CXb1VJui.mjs';
+import './peerTools-Dz3_7Bkk.mjs';
+import './ids-DU6sLx4C.mjs';
+import './remoteSessionClient-CO7qOjR0.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'node:http';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import 'http';
-import 'util';
-import 'inquirer';
-import 'node:url';
-import 'node:readline/promises';
-import 'node-pty';
+import './assistantTools-CgiTbnWb.mjs';
+import './terminals-Dlg0x3nY.mjs';
+import './terminalTitleSuggest-CeKsX_V6.mjs';
+import './tmuxSocket-B8Yx20sT.mjs';
+import './bootstrap-BNQq05jR.mjs';
+import './agentGuidance-CQuNlNx8.mjs';
+import './trimIdent-BAjmv_TG.mjs';
+import './previewPath-CXN4Vag0.mjs';
+import './detectCLI-CSGMlV51.mjs';
+import 'fs';
+import './localHappyAgentAuth-DCsetiyG.mjs';
 import 'url';
+import 'node:module';
+import './oneShotPrompts-DT4p6RNd.mjs';
 
 function createAcpBackend(options) {
   const backendOptions = {
@@ -596,7 +626,7 @@ async function runAcp(opts) {
   }
   await api.getOrCreateMachine({
     machineId: settings.machineId,
-    metadata: initialMachineMetadata
+    metadata: getInitialMachineMetadata()
   });
   const { state, metadata } = createSessionMetadata({
     flavor: resolveSessionFlavor(opts.agentName),

package/dist/index-Cqx-Raq6.mjs

@@ -0,0 +1,68 @@
+import { p as packageJson } from './package-uOg9SCKi.mjs';
+import module$1 from 'node:module';
+import { existsSync } from 'node:fs';
+import { readdir, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function isStandaloneVersionRequest(args) {
+  return args.length === 1 && args[0] === "--version";
+}
+const SELF_CHECK_FLAG = "--self-check";
+function isSelfCheckRequest(args) {
+  return args.length === 1 && args[0] === SELF_CHECK_FLAG;
+}
+
+function happyHomeDirFromEnv(env, home = homedir()) {
+  return env.HAPPY_HOME_DIR ? env.HAPPY_HOME_DIR.replace(/^~/, home) : join(home, ".happy");
+}
+function compileCacheRoot(happyHomeDir) {
+  return join(happyHomeDir, "cache", "compile");
+}
+function compileCacheDir(happyHomeDir, cliVersion) {
+  return join(compileCacheRoot(happyHomeDir), cliVersion.replace(/[^\w.+-]/g, "_"));
+}
+function enableCompileCacheIfPossible(cliVersion, env = process.env) {
+  try {
+    const enable = module$1.enableCompileCache;
+    if (typeof enable !== "function") return;
+    const happyHome = happyHomeDirFromEnv(env);
+    if (!existsSync(happyHome)) return;
+    enable(compileCacheDir(happyHome, cliVersion));
+  } catch {
+  }
+}
+async function pruneStaleCompileCaches(happyHomeDir, cliVersion) {
+  const root = compileCacheRoot(happyHomeDir);
+  const keep = compileCacheDir(happyHomeDir, cliVersion);
+  const removed = [];
+  let entries;
+  try {
+    entries = await readdir(root);
+  } catch {
+    return removed;
+  }
+  for (const name of entries) {
+    const dir = join(root, name);
+    if (dir === keep) continue;
+    try {
+      await rm(dir, { recursive: true, force: true });
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
+
+async function run(args) {
+  enableCompileCacheIfPossible(packageJson.version);
+  if (isStandaloneVersionRequest(args) || isSelfCheckRequest(args)) {
+    const { selfCheckMain } = await import('./selfCheck-hJ6PCh7v.mjs');
+    process.exit(await selfCheckMain({ verbose: isSelfCheckRequest(args) }));
+  }
+  const { main } = await import('./main-BktM4A1K.mjs');
+  await main();
+}
+void run(process.argv.slice(2));
+
+export { isStandaloneVersionRequest as i, pruneStaleCompileCaches as p };

package/dist/index-D3kI0hDR.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
+var smallFastModel = require('./smallFastModel-D_uxGMo3.cjs');
+
+const HAPPY_DEFAULT_ENTRYPOINT = "remote_mobile";
+function resolveHappyEntrypoint(currentValue) {
+  if (currentValue && currentValue.length > 0) {
+    return currentValue;
+  }
+  return HAPPY_DEFAULT_ENTRYPOINT;
+}
+
+function query(params) {
+  const opts = params.options;
+  let systemPrompt = void 0;
+  if (opts?.customSystemPrompt) {
+    systemPrompt = opts.customSystemPrompt;
+  } else if (opts?.appendSystemPrompt) {
+    systemPrompt = {
+      type: "preset",
+      preset: "claude_code",
+      append: opts.appendSystemPrompt
+    };
+  }
+  const sdkOptions = {
+    cwd: opts?.cwd,
+    additionalDirectories: opts?.additionalDirectories,
+    resume: opts?.resume,
+    continue: opts?.continue,
+    model: opts?.model,
+    fallbackModel: opts?.fallbackModel,
+    maxTurns: opts?.maxTurns,
+    permissionMode: opts?.permissionMode,
+    allowDangerouslySkipPermissions: opts?.allowDangerouslySkipPermissions ?? opts?.permissionMode === "bypassPermissions",
+    allowedTools: opts?.allowedTools,
+    disallowedTools: opts?.disallowedTools,
+    mcpServers: opts?.mcpServers,
+    systemPrompt,
+    settings: opts?.settingsPath,
+    // Load filesystem settings the way the real `claude` CLI does. The
+    // agent SDK does NOT load these by default (the rename from
+    // @anthropic-ai/claude-code flipped the default to "isolated" — the
+    // sdk.d.ts comment claiming "omitted = all sources" is stale), so a
+    // remote/web session would otherwise ignore ~/.claude/CLAUDE.md, the
+    // project .claude/, AND skills (skills are discovered from these dirs).
+    // 'user' brings in the global CLAUDE.md (e.g. "reply in Chinese"),
+    // 'project'/'local' bring in repo-level CLAUDE.md + settings → parity
+    // with a plain CLI invocation. This is the whole point of running our
+    // own fork: remote sessions should behave like local ones.
+    settingSources: ["user", "project", "local"],
+    strictMcpConfig: opts?.strictMcpConfig,
+    sessionId: void 0,
+    effort: opts?.effort,
+    forkSession: opts?.forkSession,
+    tools: opts?.tools,
+    persistSession: opts?.persistSession,
+    includePartialMessages: opts?.includePartialMessages,
+    forwardSubagentText: true,
+    enableFileCheckpointing: true,
+    extraArgs: { "replay-user-messages": null },
+    onElicitation: opts?.onElicitation,
+    onUserDialog: opts?.onUserDialog,
+    supportedDialogKinds: opts?.onUserDialog ? opts.supportedDialogKinds : void 0
+  };
+  if (opts?.abort) {
+    const controller = new AbortController();
+    if (opts.abort.aborted) {
+      controller.abort(opts.abort.reason);
+    } else {
+      opts.abort.addEventListener("abort", () => controller.abort(opts.abort?.reason), { once: true });
+    }
+    sdkOptions.abortController = controller;
+  }
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  for (const [key, value] of Object.entries(opts?.env ?? {})) {
+    if (typeof value === "string") env[key] = value;
+  }
+  env.CLAUDE_CODE_ENTRYPOINT = resolveHappyEntrypoint(env.CLAUDE_CODE_ENTRYPOINT);
+  smallFastModel.pinSmallFastModel(env);
+  if (opts?.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+    smallFastModel.ensureLocalProxyBypass(env);
+  }
+  if (sdkOptions.allowDangerouslySkipPermissions && typeof process.getuid === "function" && process.getuid() === 0 && env.IS_SANDBOX === void 0) {
+    env.IS_SANDBOX = "1";
+  }
+  sdkOptions.env = env;
+  if (opts?.canCallTool) {
+    const callback = opts.canCallTool;
+    sdkOptions.canUseTool = async (toolName, input, options) => {
+      return callback(toolName, input, options);
+    };
+  }
+  return claudeAgentSdk.query({
+    prompt: params.prompt,
+    options: sdkOptions
+  });
+}
+
+Object.defineProperty(exports, "AbortError", {
+    enumerable: true,
+    get: function () { return claudeAgentSdk.AbortError; }
+});
+exports.query = query;