lcclaude 1.0.0

package/dist/src/utils/deepLink/terminalLauncher.js

@@ -0,0 +1,321 @@
+import { spawn } from "child_process";
+import { basename } from "path";
+import { getGlobalConfig } from "../config.js";
+import { logForDebugging } from "../debug.js";
+import { execFileNoThrow } from "../execFileNoThrow.js";
+import { which } from "../which.js";
+const MACOS_TERMINALS = [
+  { name: "iTerm2", bundleId: "com.googlecode.iterm2", app: "iTerm" },
+  { name: "Ghostty", bundleId: "com.mitchellh.ghostty", app: "Ghostty" },
+  { name: "Kitty", bundleId: "net.kovidgoyal.kitty", app: "kitty" },
+  { name: "Alacritty", bundleId: "org.alacritty", app: "Alacritty" },
+  { name: "WezTerm", bundleId: "com.github.wez.wezterm", app: "WezTerm" },
+  {
+    name: "Terminal.app",
+    bundleId: "com.apple.Terminal",
+    app: "Terminal"
+  }
+];
+const LINUX_TERMINALS = [
+  "ghostty",
+  "kitty",
+  "alacritty",
+  "wezterm",
+  "gnome-terminal",
+  "konsole",
+  "xfce4-terminal",
+  "mate-terminal",
+  "tilix",
+  "xterm"
+];
+async function detectMacosTerminal() {
+  const stored = getGlobalConfig().deepLinkTerminal;
+  if (stored) {
+    const match = MACOS_TERMINALS.find((t) => t.app === stored);
+    if (match) {
+      return { name: match.name, command: match.app };
+    }
+  }
+  const termProgram = process.env.TERM_PROGRAM;
+  if (termProgram) {
+    const normalized = termProgram.replace(/\.app$/i, "").toLowerCase();
+    const match = MACOS_TERMINALS.find((t) => t.app.toLowerCase() === normalized || t.name.toLowerCase() === normalized);
+    if (match) {
+      return { name: match.name, command: match.app };
+    }
+  }
+  for (const terminal of MACOS_TERMINALS) {
+    const { code, stdout } = await execFileNoThrow("mdfind", [`kMDItemCFBundleIdentifier == "${terminal.bundleId}"`], { timeout: 5000, useCwd: false });
+    if (code === 0 && stdout.trim().length > 0) {
+      return { name: terminal.name, command: terminal.app };
+    }
+  }
+  for (const terminal of MACOS_TERMINALS) {
+    const { code: lsCode } = await execFileNoThrow("ls", [`/Applications/${terminal.app}.app`], { timeout: 1000, useCwd: false });
+    if (lsCode === 0) {
+      return { name: terminal.name, command: terminal.app };
+    }
+  }
+  return { name: "Terminal.app", command: "Terminal" };
+}
+async function detectLinuxTerminal() {
+  const termEnv = process.env.TERMINAL;
+  if (termEnv) {
+    const resolved = await which(termEnv);
+    if (resolved) {
+      return { name: basename(termEnv), command: resolved };
+    }
+  }
+  const xte = await which("x-terminal-emulator");
+  if (xte) {
+    return { name: "x-terminal-emulator", command: xte };
+  }
+  for (const terminal of LINUX_TERMINALS) {
+    const resolved = await which(terminal);
+    if (resolved) {
+      return { name: terminal, command: resolved };
+    }
+  }
+  return null;
+}
+async function detectWindowsTerminal() {
+  const wt = await which("wt.exe");
+  if (wt) {
+    return { name: "Windows Terminal", command: wt };
+  }
+  const pwsh = await which("pwsh.exe");
+  if (pwsh) {
+    return { name: "PowerShell", command: pwsh };
+  }
+  const powershell = await which("powershell.exe");
+  if (powershell) {
+    return { name: "PowerShell", command: powershell };
+  }
+  return { name: "Command Prompt", command: "cmd.exe" };
+}
+export async function detectTerminal() {
+  switch (process.platform) {
+    case "darwin":
+      return detectMacosTerminal();
+    case "linux":
+      return detectLinuxTerminal();
+    case "win32":
+      return detectWindowsTerminal();
+    default:
+      return null;
+  }
+}
+export async function launchInTerminal(claudePath, action) {
+  const terminal = await detectTerminal();
+  if (!terminal) {
+    logForDebugging("No terminal emulator detected", { level: "error" });
+    return false;
+  }
+  logForDebugging(`Launching in terminal: ${terminal.name} (${terminal.command})`);
+  const claudeArgs = ["--deep-link-origin"];
+  if (action.repo) {
+    claudeArgs.push("--deep-link-repo", action.repo);
+    if (action.lastFetchMs !== undefined) {
+      claudeArgs.push("--deep-link-last-fetch", String(action.lastFetchMs));
+    }
+  }
+  if (action.query) {
+    claudeArgs.push("--prefill", action.query);
+  }
+  switch (process.platform) {
+    case "darwin":
+      return launchMacosTerminal(terminal, claudePath, claudeArgs, action.cwd);
+    case "linux":
+      return launchLinuxTerminal(terminal, claudePath, claudeArgs, action.cwd);
+    case "win32":
+      return launchWindowsTerminal(terminal, claudePath, claudeArgs, action.cwd);
+    default:
+      return false;
+  }
+}
+async function launchMacosTerminal(terminal, claudePath, claudeArgs, cwd) {
+  switch (terminal.command) {
+    case "iTerm": {
+      const shCmd = buildShellCommand(claudePath, claudeArgs, cwd);
+      const script = `tell application "iTerm"
+  if running then
+    create window with default profile
+  else
+    activate
+  end if
+  tell current session of current window
+    write text ${appleScriptQuote(shCmd)}
+  end tell
+end tell`;
+      const { code } = await execFileNoThrow("osascript", ["-e", script], {
+        useCwd: false
+      });
+      if (code === 0)
+        return true;
+      break;
+    }
+    case "Terminal": {
+      const shCmd = buildShellCommand(claudePath, claudeArgs, cwd);
+      const script = `tell application "Terminal"
+  do script ${appleScriptQuote(shCmd)}
+  activate
+end tell`;
+      const { code } = await execFileNoThrow("osascript", ["-e", script], {
+        useCwd: false
+      });
+      return code === 0;
+    }
+    case "Ghostty": {
+      const args = [
+        "-na",
+        terminal.command,
+        "--args",
+        "--window-save-state=never"
+      ];
+      if (cwd)
+        args.push(`--working-directory=${cwd}`);
+      args.push("-e", claudePath, ...claudeArgs);
+      const { code } = await execFileNoThrow("open", args, { useCwd: false });
+      if (code === 0)
+        return true;
+      break;
+    }
+    case "Alacritty": {
+      const args = ["-na", terminal.command, "--args"];
+      if (cwd)
+        args.push("--working-directory", cwd);
+      args.push("-e", claudePath, ...claudeArgs);
+      const { code } = await execFileNoThrow("open", args, { useCwd: false });
+      if (code === 0)
+        return true;
+      break;
+    }
+    case "kitty": {
+      const args = ["-na", terminal.command, "--args"];
+      if (cwd)
+        args.push("--directory", cwd);
+      args.push(claudePath, ...claudeArgs);
+      const { code } = await execFileNoThrow("open", args, { useCwd: false });
+      if (code === 0)
+        return true;
+      break;
+    }
+    case "WezTerm": {
+      const args = ["-na", terminal.command, "--args", "start"];
+      if (cwd)
+        args.push("--cwd", cwd);
+      args.push("--", claudePath, ...claudeArgs);
+      const { code } = await execFileNoThrow("open", args, { useCwd: false });
+      if (code === 0)
+        return true;
+      break;
+    }
+  }
+  logForDebugging(`Failed to launch ${terminal.name}, falling back to Terminal.app`);
+  return launchMacosTerminal({ name: "Terminal.app", command: "Terminal" }, claudePath, claudeArgs, cwd);
+}
+async function launchLinuxTerminal(terminal, claudePath, claudeArgs, cwd) {
+  let args;
+  let spawnCwd;
+  switch (terminal.name) {
+    case "gnome-terminal":
+      args = cwd ? [`--working-directory=${cwd}`, "--"] : ["--"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "konsole":
+      args = cwd ? ["--workdir", cwd, "-e"] : ["-e"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "kitty":
+      args = cwd ? ["--directory", cwd] : [];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "wezterm":
+      args = cwd ? ["start", "--cwd", cwd, "--"] : ["start", "--"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "alacritty":
+      args = cwd ? ["--working-directory", cwd, "-e"] : ["-e"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "ghostty":
+      args = cwd ? [`--working-directory=${cwd}`, "-e"] : ["-e"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "xfce4-terminal":
+    case "mate-terminal":
+      args = cwd ? [`--working-directory=${cwd}`, "-x"] : ["-x"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    case "tilix":
+      args = cwd ? [`--working-directory=${cwd}`, "-e"] : ["-e"];
+      args.push(claudePath, ...claudeArgs);
+      break;
+    default:
+      args = ["-e", claudePath, ...claudeArgs];
+      spawnCwd = cwd;
+      break;
+  }
+  return spawnDetached(terminal.command, args, { cwd: spawnCwd });
+}
+async function launchWindowsTerminal(terminal, claudePath, claudeArgs, cwd) {
+  const args = [];
+  switch (terminal.name) {
+    case "Windows Terminal":
+      if (cwd)
+        args.push("-d", cwd);
+      args.push("--", claudePath, ...claudeArgs);
+      break;
+    case "PowerShell": {
+      const cdCmd = cwd ? `Set-Location ${psQuote(cwd)}; ` : "";
+      args.push("-NoExit", "-Command", `${cdCmd}& ${psQuote(claudePath)} ${claudeArgs.map(psQuote).join(" ")}`);
+      break;
+    }
+    default: {
+      const cdCmd = cwd ? `cd /d ${cmdQuote(cwd)} && ` : "";
+      args.push("/k", `${cdCmd}${cmdQuote(claudePath)} ${claudeArgs.map((a) => cmdQuote(a)).join(" ")}`);
+      break;
+    }
+  }
+  return spawnDetached(terminal.command, args, {
+    windowsVerbatimArguments: terminal.name === "Command Prompt"
+  });
+}
+function spawnDetached(command, args, opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+      cwd: opts.cwd,
+      windowsVerbatimArguments: opts.windowsVerbatimArguments
+    });
+    child.once("error", (err) => {
+      logForDebugging(`Failed to spawn ${command}: ${err.message}`, {
+        level: "error"
+      });
+      resolve(false);
+    });
+    child.once("spawn", () => {
+      child.unref();
+      resolve(true);
+    });
+  });
+}
+function buildShellCommand(claudePath, claudeArgs, cwd) {
+  const cdPrefix = cwd ? `cd ${shellQuote(cwd)} && ` : "";
+  return `${cdPrefix}${[claudePath, ...claudeArgs].map(shellQuote).join(" ")}`;
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function appleScriptQuote(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function psQuote(s) {
+  return `'${s.replace(/'/g, "''")}'`;
+}
+function cmdQuote(arg) {
+  const stripped = arg.replace(/"/g, "").replace(/%/g, "%%");
+  const escaped = stripped.replace(/(\\+)$/, "$1$1");
+  return `"${escaped}"`;
+}

package/dist/src/utils/deepLink/terminalPreference.js

@@ -0,0 +1,26 @@
+import { getGlobalConfig, saveGlobalConfig } from "../config.js";
+import { logForDebugging } from "../debug.js";
+const TERM_PROGRAM_TO_APP = {
+  iterm: "iTerm",
+  "iterm.app": "iTerm",
+  ghostty: "Ghostty",
+  kitty: "kitty",
+  alacritty: "Alacritty",
+  wezterm: "WezTerm",
+  apple_terminal: "Terminal"
+};
+export function updateDeepLinkTerminalPreference() {
+  if (process.platform !== "darwin")
+    return;
+  const termProgram = process.env.TERM_PROGRAM;
+  if (!termProgram)
+    return;
+  const app = TERM_PROGRAM_TO_APP[termProgram.toLowerCase()];
+  if (!app)
+    return;
+  const config = getGlobalConfig();
+  if (config.deepLinkTerminal === app)
+    return;
+  saveGlobalConfig((current) => ({ ...current, deepLinkTerminal: app }));
+  logForDebugging(`Stored deep link terminal preference: ${app}`);
+}

package/dist/src/utils/desktopDeepLink.js

@@ -0,0 +1,154 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { coerce as semverCoerce } from "semver";
+import { getSessionId } from "../bootstrap/state.js";
+import { getCwd } from "./cwd.js";
+import { logForDebugging } from "./debug.js";
+import { execFileNoThrow } from "./execFileNoThrow.js";
+import { pathExists } from "./file.js";
+import { gte as semverGte } from "./semver.js";
+const MIN_DESKTOP_VERSION = "1.1.2396";
+function isDevMode() {
+  if (true) {
+    return true;
+  }
+  const pathsToCheck = [process.argv[1] || "", process.execPath || ""];
+  const buildDirs = [
+    "/build-ant/",
+    "/build-ant-native/",
+    "/build-external/",
+    "/build-external-native/"
+  ];
+  return pathsToCheck.some((p) => buildDirs.some((dir) => p.includes(dir)));
+}
+function buildDesktopDeepLink(sessionId) {
+  const protocol = isDevMode() ? "claude-dev" : "claude";
+  const url = new URL(`${protocol}://resume`);
+  url.searchParams.set("session", sessionId);
+  url.searchParams.set("cwd", getCwd());
+  return url.toString();
+}
+async function isDesktopInstalled() {
+  if (isDevMode()) {
+    return true;
+  }
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return pathExists("/Applications/Claude.app");
+  } else if (platform === "linux") {
+    const { code, stdout } = await execFileNoThrow("xdg-mime", [
+      "query",
+      "default",
+      "x-scheme-handler/claude"
+    ]);
+    return code === 0 && stdout.trim().length > 0;
+  } else if (platform === "win32") {
+    const { code } = await execFileNoThrow("reg", [
+      "query",
+      "HKEY_CLASSES_ROOT\\claude",
+      "/ve"
+    ]);
+    return code === 0;
+  }
+  return false;
+}
+async function getDesktopVersion() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const { code, stdout } = await execFileNoThrow("defaults", [
+      "read",
+      "/Applications/Claude.app/Contents/Info.plist",
+      "CFBundleShortVersionString"
+    ]);
+    if (code !== 0) {
+      return null;
+    }
+    const version = stdout.trim();
+    return version.length > 0 ? version : null;
+  } else if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (!localAppData) {
+      return null;
+    }
+    const installDir = join(localAppData, "AnthropicClaude");
+    try {
+      const entries = await readdir(installDir);
+      const versions = entries.filter((e) => e.startsWith("app-")).map((e) => e.slice(4)).filter((v) => semverCoerce(v) !== null).sort((a, b) => {
+        const ca = semverCoerce(a);
+        const cb = semverCoerce(b);
+        return ca.compare(cb);
+      });
+      return versions.length > 0 ? versions[versions.length - 1] : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+export async function getDesktopInstallStatus() {
+  const installed = await isDesktopInstalled();
+  if (!installed) {
+    return { status: "not-installed" };
+  }
+  let version;
+  try {
+    version = await getDesktopVersion();
+  } catch {
+    return { status: "ready", version: "unknown" };
+  }
+  if (!version) {
+    return { status: "ready", version: "unknown" };
+  }
+  const coerced = semverCoerce(version);
+  if (!coerced || !semverGte(coerced.version, MIN_DESKTOP_VERSION)) {
+    return { status: "version-too-old", version };
+  }
+  return { status: "ready", version };
+}
+async function openDeepLink(deepLinkUrl) {
+  const platform = process.platform;
+  logForDebugging(`Opening deep link: ${deepLinkUrl}`);
+  if (platform === "darwin") {
+    if (isDevMode()) {
+      const { code } = await execFileNoThrow("osascript", [
+        "-e",
+        `tell application "Electron" to open location "${deepLinkUrl}"`
+      ]);
+      return code === 0;
+    }
+    const { code } = await execFileNoThrow("open", [deepLinkUrl]);
+    return code === 0;
+  } else if (platform === "linux") {
+    const { code } = await execFileNoThrow("xdg-open", [deepLinkUrl]);
+    return code === 0;
+  } else if (platform === "win32") {
+    const { code } = await execFileNoThrow("cmd", [
+      "/c",
+      "start",
+      "",
+      deepLinkUrl
+    ]);
+    return code === 0;
+  }
+  return false;
+}
+export async function openCurrentSessionInDesktop() {
+  const sessionId = getSessionId();
+  const installed = await isDesktopInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Claude Desktop is not installed. Install it from https://claude.ai/download"
+    };
+  }
+  const deepLinkUrl = buildDesktopDeepLink(sessionId);
+  const opened = await openDeepLink(deepLinkUrl);
+  if (!opened) {
+    return {
+      success: false,
+      error: "Failed to open Claude Desktop. Please try opening it manually.",
+      deepLinkUrl
+    };
+  }
+  return { success: true, deepLinkUrl };
+}

package/dist/src/utils/detectRepository.js

@@ -0,0 +1,98 @@
+import { getCwd } from "./cwd.js";
+import { logForDebugging } from "./debug.js";
+import { getRemoteUrl } from "./git.js";
+const repositoryWithHostCache = new Map;
+export function clearRepositoryCaches() {
+  repositoryWithHostCache.clear();
+}
+export async function detectCurrentRepository() {
+  const result = await detectCurrentRepositoryWithHost();
+  if (!result)
+    return null;
+  if (result.host !== "github.com")
+    return null;
+  return `${result.owner}/${result.name}`;
+}
+export async function detectCurrentRepositoryWithHost() {
+  const cwd = getCwd();
+  if (repositoryWithHostCache.has(cwd)) {
+    return repositoryWithHostCache.get(cwd) ?? null;
+  }
+  try {
+    const remoteUrl = await getRemoteUrl();
+    logForDebugging(`Git remote URL: ${remoteUrl}`);
+    if (!remoteUrl) {
+      logForDebugging("No git remote URL found");
+      repositoryWithHostCache.set(cwd, null);
+      return null;
+    }
+    const parsed = parseGitRemote(remoteUrl);
+    logForDebugging(`Parsed repository: ${parsed ? `${parsed.host}/${parsed.owner}/${parsed.name}` : null} from URL: ${remoteUrl}`);
+    repositoryWithHostCache.set(cwd, parsed);
+    return parsed;
+  } catch (error) {
+    logForDebugging(`Error detecting repository: ${error}`);
+    repositoryWithHostCache.set(cwd, null);
+    return null;
+  }
+}
+export function getCachedRepository() {
+  const parsed = repositoryWithHostCache.get(getCwd());
+  if (!parsed || parsed.host !== "github.com")
+    return null;
+  return `${parsed.owner}/${parsed.name}`;
+}
+export function parseGitRemote(input) {
+  const trimmed = input.trim();
+  const sshMatch = trimmed.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch?.[1] && sshMatch[2] && sshMatch[3]) {
+    if (!looksLikeRealHostname(sshMatch[1]))
+      return null;
+    return {
+      host: sshMatch[1],
+      owner: sshMatch[2],
+      name: sshMatch[3]
+    };
+  }
+  const urlMatch = trimmed.match(/^(https?|ssh|git):\/\/(?:[^@]+@)?([^/:]+(?::\d+)?)\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (urlMatch?.[1] && urlMatch[2] && urlMatch[3] && urlMatch[4]) {
+    const protocol = urlMatch[1];
+    const hostWithPort = urlMatch[2];
+    const hostWithoutPort = hostWithPort.split(":")[0] ?? "";
+    if (!looksLikeRealHostname(hostWithoutPort))
+      return null;
+    const host = protocol === "https" || protocol === "http" ? hostWithPort : hostWithoutPort;
+    return {
+      host,
+      owner: urlMatch[3],
+      name: urlMatch[4]
+    };
+  }
+  return null;
+}
+export function parseGitHubRepository(input) {
+  const trimmed = input.trim();
+  const parsed = parseGitRemote(trimmed);
+  if (parsed) {
+    if (parsed.host !== "github.com")
+      return null;
+    return `${parsed.owner}/${parsed.name}`;
+  }
+  if (!trimmed.includes("://") && !trimmed.includes("@") && trimmed.includes("/")) {
+    const parts = trimmed.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      const repo = parts[1].replace(/\.git$/, "");
+      return `${parts[0]}/${repo}`;
+    }
+  }
+  logForDebugging(`Could not parse repository from: ${trimmed}`);
+  return null;
+}
+function looksLikeRealHostname(host) {
+  if (!host.includes("."))
+    return false;
+  const lastSegment = host.split(".").pop();
+  if (!lastSegment)
+    return false;
+  return /^[a-zA-Z]+$/.test(lastSegment);
+}

package/dist/src/utils/diagLogs.js

@@ -0,0 +1,47 @@
+import { dirname } from "path";
+import { getFsImplementation } from "./fsOperations.js";
+import { jsonStringify } from "./slowOperations.js";
+export function logForDiagnosticsNoPII(level, event, data) {
+  const logFile = getDiagnosticLogFile();
+  if (!logFile) {
+    return;
+  }
+  const entry = {
+    timestamp: new Date().toISOString(),
+    level,
+    event,
+    data: data ?? {}
+  };
+  const fs = getFsImplementation();
+  const line = jsonStringify(entry) + `
+`;
+  try {
+    fs.appendFileSync(logFile, line);
+  } catch {
+    try {
+      fs.mkdirSync(dirname(logFile));
+      fs.appendFileSync(logFile, line);
+    } catch {}
+  }
+}
+function getDiagnosticLogFile() {
+  return process.env.CLAUDE_CODE_DIAGNOSTICS_FILE;
+}
+export async function withDiagnosticsTiming(event, fn, getData) {
+  const startTime = Date.now();
+  logForDiagnosticsNoPII("info", `${event}_started`);
+  try {
+    const result = await fn();
+    const additionalData = getData ? getData(result) : {};
+    logForDiagnosticsNoPII("info", `${event}_completed`, {
+      duration_ms: Date.now() - startTime,
+      ...additionalData
+    });
+    return result;
+  } catch (error) {
+    logForDiagnosticsNoPII("error", `${event}_failed`, {
+      duration_ms: Date.now() - startTime
+    });
+    throw error;
+  }
+}