gong-code 0.1.0

package/dist/chunk-zygzzzvk.js

@@ -0,0 +1,192 @@
+// @bun
+import"./chunk-78n9kfp8.js";
+import"./chunk-j8mxc6k6.js";
+import"./chunk-z0exw850.js";
+import"./chunk-3jf3k40v.js";
+import"./chunk-yvmhx96e.js";
+import"./chunk-qezv7msv.js";
+import"./chunk-sscms68s.js";
+import"./chunk-7e1qjk3s.js";
+import"./chunk-1gjysfnf.js";
+import"./chunk-vxgdzx6p.js";
+import"./chunk-kv147680.js";
+import"./chunk-2p0hvt8k.js";
+import"./chunk-ycr0hp6v.js";
+import"./chunk-9029sbq1.js";
+import"./chunk-ezpa510h.js";
+import"./chunk-kp6nepx4.js";
+import"./chunk-1jjzp2pa.js";
+import"./chunk-w1jew5sn.js";
+import"./chunk-g98m2qe6.js";
+import"./chunk-sez03qd9.js";
+import {
+  isEssentialTrafficOnly
+} from "./chunk-vsfj449x.js";
+import"./chunk-r4cxb6t7.js";
+import"./chunk-bp0ynk17.js";
+import"./chunk-7yexhdjs.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-rex82hys.js";
+import"./chunk-4s93jyky.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-318g78ty.js";
+import"./chunk-c0bdmy7w.js";
+import"./chunk-syxy4pf2.js";
+import {
+  __esm,
+  __toCommonJS
+} from "./chunk-eta5aekm.js";
+import {
+  checkGate_CACHED_OR_BLOCKING,
+  exports_auth,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getSecureStorage,
+  init_auth,
+  init_growthbook,
+  init_secureStorage
+} from "./chunk-y66bqywr.js";
+import"./chunk-nwk16bbd.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-rx6z23h0.js";
+import"./chunk-df5c1x8m.js";
+import"./chunk-65z8hg8j.js";
+import"./chunk-5cp2q9sh.js";
+import"./chunk-rjjakkw2.js";
+import"./chunk-0sbddf6m.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-q5b0kpr3.js";
+
+// src/bridge/trustedDevice.ts
+import { hostname } from "os";
+function isGateEnabled() {
+  return getFeatureValue_CACHED_MAY_BE_STALE(TRUSTED_DEVICE_GATE, false);
+}
+function getTrustedDeviceToken() {
+  if (!isGateEnabled()) {
+    return;
+  }
+  return readStoredToken();
+}
+function clearTrustedDeviceTokenCache() {
+  readStoredToken.cache?.clear?.();
+}
+function clearTrustedDeviceToken() {
+  if (!isGateEnabled()) {
+    return;
+  }
+  const secureStorage = getSecureStorage();
+  try {
+    const data = secureStorage.read();
+    if (data?.trustedDeviceToken) {
+      delete data.trustedDeviceToken;
+      secureStorage.update(data);
+    }
+  } catch {}
+  readStoredToken.cache?.clear?.();
+}
+async function enrollTrustedDevice() {
+  try {
+    if (!await checkGate_CACHED_OR_BLOCKING(TRUSTED_DEVICE_GATE)) {
+      logForDebugging(`[trusted-device] Gate ${TRUSTED_DEVICE_GATE} is off, skipping enrollment`);
+      return;
+    }
+    if (process.env.CLAUDE_TRUSTED_DEVICE_TOKEN) {
+      logForDebugging("[trusted-device] CLAUDE_TRUSTED_DEVICE_TOKEN env var is set, skipping enrollment (env var takes precedence)");
+      return;
+    }
+    const { getClaudeAIOAuthTokens } = (init_auth(), __toCommonJS(exports_auth));
+    const accessToken = getClaudeAIOAuthTokens()?.accessToken;
+    if (!accessToken) {
+      logForDebugging("[trusted-device] No OAuth token, skipping enrollment");
+      return;
+    }
+    const secureStorage = getSecureStorage();
+    if (isEssentialTrafficOnly()) {
+      logForDebugging("[trusted-device] Essential traffic only, skipping enrollment");
+      return;
+    }
+    const baseUrl = getOauthConfig().BASE_API_URL;
+    let response;
+    try {
+      response = await axios_default.post(`${baseUrl}/api/auth/trusted_devices`, { display_name: `Claude Code on ${hostname()} \xB7 ${process.platform}` }, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 1e4,
+        validateStatus: (s) => s < 500
+      });
+    } catch (err) {
+      logForDebugging(`[trusted-device] Enrollment request failed: ${errorMessage(err)}`);
+      return;
+    }
+    if (response.status !== 200 && response.status !== 201) {
+      logForDebugging(`[trusted-device] Enrollment failed ${response.status}: ${jsonStringify(response.data).slice(0, 200)}`);
+      return;
+    }
+    const token = response.data?.device_token;
+    if (!token || typeof token !== "string") {
+      logForDebugging("[trusted-device] Enrollment response missing device_token field");
+      return;
+    }
+    try {
+      const storageData = secureStorage.read();
+      if (!storageData) {
+        logForDebugging("[trusted-device] Cannot read storage, skipping token persist");
+        return;
+      }
+      storageData.trustedDeviceToken = token;
+      const result = secureStorage.update(storageData);
+      if (!result.success) {
+        logForDebugging(`[trusted-device] Failed to persist token: ${result.warning ?? "unknown"}`);
+        return;
+      }
+      readStoredToken.cache?.clear?.();
+      logForDebugging(`[trusted-device] Enrolled device_id=${response.data.device_id ?? "unknown"}`);
+    } catch (err) {
+      logForDebugging(`[trusted-device] Storage write failed: ${errorMessage(err)}`);
+    }
+  } catch (err) {
+    logForDebugging(`[trusted-device] Enrollment error: ${errorMessage(err)}`);
+  }
+}
+var TRUSTED_DEVICE_GATE = "tengu_sessions_elevated_auth_enforcement", readStoredToken;
+var init_trustedDevice = __esm(() => {
+  init_axios();
+  init_memoize();
+  init_oauth();
+  init_growthbook();
+  init_debug();
+  init_errors();
+  init_secureStorage();
+  init_slowOperations();
+  readStoredToken = memoize_default(() => {
+    const envToken = process.env.CLAUDE_TRUSTED_DEVICE_TOKEN;
+    if (envToken) {
+      return envToken;
+    }
+    return getSecureStorage().read()?.trustedDeviceToken;
+  });
+});
+init_trustedDevice();
+
+export {
+  getTrustedDeviceToken,
+  enrollTrustedDevice,
+  clearTrustedDeviceTokenCache,
+  clearTrustedDeviceToken
+};
+
+export { getTrustedDeviceToken, clearTrustedDeviceTokenCache, clearTrustedDeviceToken, enrollTrustedDevice, init_trustedDevice };

package/dist/cli-21v3v6ny.md

@@ -0,0 +1 @@
+# CLI

package/dist/cli.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+// @bun
+import {
+  __require,
+  __toESM
+} from "./chunk-eta5aekm.js";
+
+// src/entrypoints/cli.tsx
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function loadProviderConfig() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+  const configPath = join(configDir, "providers.json");
+  try {
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      const defaultProvider = config.defaultProvider || "minimax";
+      const providerConfig = config.providers?.[defaultProvider];
+      if (!process.env.MODEL_PROVIDER) {
+        process.env.MODEL_PROVIDER = defaultProvider;
+      }
+      if (providerConfig?.apiKey) {
+        const provider = process.env.MODEL_PROVIDER;
+        if (provider === "minimax" && !process.env.MINIMAX_API_KEY) {
+          process.env.MINIMAX_API_KEY = providerConfig.apiKey;
+          process.env.ANTHROPIC_API_KEY = providerConfig.apiKey;
+        } else if (provider === "glm" && !process.env.GLM_API_KEY) {
+          process.env.GLM_API_KEY = providerConfig.apiKey;
+        } else if (provider === "openai" && !process.env.OPENAI_API_KEY) {
+          process.env.OPENAI_API_KEY = providerConfig.apiKey;
+        }
+      }
+      if (providerConfig?.model) {
+        const provider = process.env.MODEL_PROVIDER;
+        if (provider === "minimax" && !process.env.MINIMAX_MODEL) {
+          process.env.MINIMAX_MODEL = providerConfig.model;
+        } else if (provider === "glm" && !process.env.GLM_MODEL) {
+          process.env.GLM_MODEL = providerConfig.model;
+        } else if (provider === "openai" && !process.env.OPENAI_MODEL) {
+          process.env.OPENAI_MODEL = providerConfig.model;
+        }
+      }
+    }
+  } catch {}
+  if (!process.env.MODEL_PROVIDER) {
+    process.env.MODEL_PROVIDER = "minimax";
+  }
+}
+loadProviderConfig();
+if (process.env.MODEL_PROVIDER === "minimax") {
+  if (!process.env.ANTHROPIC_BASE_URL) {
+    process.env.ANTHROPIC_BASE_URL = "https://api.minimaxi.com/anthropic";
+  }
+  if (process.env.MINIMAX_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+    process.env.ANTHROPIC_API_KEY = process.env.MINIMAX_API_KEY;
+  }
+}
+var feature = (_name) => false;
+if (typeof globalThis.MACRO === "undefined") {
+  globalThis.MACRO = {
+    VERSION: "2.1.888",
+    BUILD_TIME: new Date().toISOString(),
+    FEEDBACK_CHANNEL: "",
+    ISSUES_EXPLAINER: "",
+    NATIVE_PACKAGE_URL: "",
+    PACKAGE_URL: "",
+    VERSION_CHANGELOG: ""
+  };
+}
+globalThis.BUILD_TARGET = "external";
+globalThis.BUILD_ENV = "production";
+globalThis.INTERFACE_TYPE = "stdio";
+process.env.COREPACK_ENABLE_AUTO_PIN = "0";
+if (process.env.CLAUDE_CODE_REMOTE === "true") {
+  const existing = process.env.NODE_OPTIONS || "";
+  process.env.NODE_OPTIONS = existing ? `${existing} --max-old-space-size=8192` : "--max-old-space-size=8192";
+}
+if (feature("ABLATION_BASELINE") && process.env.CLAUDE_CODE_ABLATION_BASELINE) {
+  for (const k of [
+    "CLAUDE_CODE_SIMPLE",
+    "CLAUDE_CODE_DISABLE_THINKING",
+    "DISABLE_INTERLEAVED_THINKING",
+    "DISABLE_COMPACT",
+    "DISABLE_AUTO_COMPACT",
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY",
+    "CLAUDE_CODE_DISABLE_BACKGROUND_TASKS"
+  ]) {
+    process.env[k] ??= "1";
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
+    console.log(`${MACRO.VERSION} (Claude Code)`);
+    return;
+  }
+  const { profileCheckpoint } = await import("./chunk-df5c1x8m.js");
+  profileCheckpoint("cli_entry");
+  if (feature("DUMP_SYSTEM_PROMPT") && args[0] === "--dump-system-prompt") {
+    profileCheckpoint("cli_dump_system_prompt_path");
+    const { enableConfigs } = await import("./chunk-07rervty.js");
+    enableConfigs();
+    const { getMainLoopModel } = await import("./chunk-07rervty.js");
+    const modelIdx = args.indexOf("--model");
+    const model = modelIdx !== -1 && args[modelIdx + 1] || getMainLoopModel();
+    const { getSystemPrompt } = await import("./chunk-07rervty.js");
+    const prompt = await getSystemPrompt([], model);
+    console.log(prompt.join(`
+`));
+    return;
+  }
+  if (process.argv[2] === "--claude-in-chrome-mcp") {
+    profileCheckpoint("cli_claude_in_chrome_mcp_path");
+    const { runClaudeInChromeMcpServer } = await import("./chunk-3f76a1ek.js");
+    await runClaudeInChromeMcpServer();
+    return;
+  } else if (process.argv[2] === "--chrome-native-host") {
+    profileCheckpoint("cli_chrome_native_host_path");
+    const { runChromeNativeHost } = await import("./chunk-5qw0mpvq.js");
+    await runChromeNativeHost();
+    return;
+  } else if (feature("CHICAGO_MCP") && process.argv[2] === "--computer-use-mcp") {
+    profileCheckpoint("cli_computer_use_mcp_path");
+    const { runComputerUseMcpServer } = await import("./chunk-e5gn6by6.js");
+    await runComputerUseMcpServer();
+    return;
+  }
+  if (feature("DAEMON") && args[0] === "--daemon-worker") {
+    const { runDaemonWorker } = await import("./chunk-3gcj7w95.js");
+    await runDaemonWorker(args[1]);
+    return;
+  }
+  if (feature("BRIDGE_MODE") && (args[0] === "remote-control" || args[0] === "rc" || args[0] === "remote" || args[0] === "sync" || args[0] === "bridge")) {
+    profileCheckpoint("cli_bridge_path");
+    const { enableConfigs } = await import("./chunk-07rervty.js");
+    enableConfigs();
+    const { getBridgeDisabledReason, checkBridgeMinVersion } = await import("./chunk-5f5sxgp0.js");
+    const { BRIDGE_LOGIN_ERROR } = await import("./chunk-cjqxdnf9.js");
+    const { bridgeMain } = await import("./chunk-pdkpssgv.js");
+    const { exitWithError } = await import("./chunk-5cp2q9sh.js");
+    const { getClaudeAIOAuthTokens } = await import("./chunk-07rervty.js");
+    if (!getClaudeAIOAuthTokens()?.accessToken) {
+      exitWithError(BRIDGE_LOGIN_ERROR);
+    }
+    const disabledReason = await getBridgeDisabledReason();
+    if (disabledReason) {
+      exitWithError(`Error: ${disabledReason}`);
+    }
+    const versionError = checkBridgeMinVersion();
+    if (versionError) {
+      exitWithError(versionError);
+    }
+    const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import("./chunk-07rervty.js");
+    await waitForPolicyLimitsToLoad();
+    if (!isPolicyAllowed("allow_remote_control")) {
+      exitWithError("Error: Remote Control is disabled by your organization's policy.");
+    }
+    await bridgeMain(args.slice(1));
+    return;
+  }
+  if (feature("DAEMON") && args[0] === "daemon") {
+    profileCheckpoint("cli_daemon_path");
+    const { enableConfigs } = await import("./chunk-07rervty.js");
+    enableConfigs();
+    const { initSinks } = await import("./chunk-pfzejvpt.js");
+    initSinks();
+    const { daemonMain } = await import("./chunk-6aq85gdq.js");
+    await daemonMain(args.slice(1));
+    return;
+  }
+  if (feature("BG_SESSIONS") && (args[0] === "ps" || args[0] === "logs" || args[0] === "attach" || args[0] === "kill" || args.includes("--bg") || args.includes("--background"))) {
+    profileCheckpoint("cli_bg_path");
+    const { enableConfigs } = await import("./chunk-07rervty.js");
+    enableConfigs();
+    const bg = await import("./chunk-az7jpbv8.js");
+    switch (args[0]) {
+      case "ps":
+        await bg.psHandler(args.slice(1));
+        break;
+      case "logs":
+        await bg.logsHandler(args[1]);
+        break;
+      case "attach":
+        await bg.attachHandler(args[1]);
+        break;
+      case "kill":
+        await bg.killHandler(args[1]);
+        break;
+      default:
+        await bg.handleBgFlag(args);
+    }
+    return;
+  }
+  if (feature("TEMPLATES") && (args[0] === "new" || args[0] === "list" || args[0] === "reply")) {
+    profileCheckpoint("cli_templates_path");
+    const { templatesMain } = await import("./chunk-gv8n85j2.js");
+    await templatesMain(args);
+    process.exit(0);
+  }
+  if (feature("BYOC_ENVIRONMENT_RUNNER") && args[0] === "environment-runner") {
+    profileCheckpoint("cli_environment_runner_path");
+    const { environmentRunnerMain } = await import("./chunk-53grnhp7.js");
+    await environmentRunnerMain(args.slice(1));
+    return;
+  }
+  if (feature("SELF_HOSTED_RUNNER") && args[0] === "self-hosted-runner") {
+    profileCheckpoint("cli_self_hosted_runner_path");
+    const { selfHostedRunnerMain } = await import("./chunk-3ffxa7zj.js");
+    await selfHostedRunnerMain(args.slice(1));
+    return;
+  }
+  const hasTmuxFlag = args.includes("--tmux") || args.includes("--tmux=classic");
+  if (hasTmuxFlag && (args.includes("-w") || args.includes("--worktree") || args.some((a) => a.startsWith("--worktree=")))) {
+    profileCheckpoint("cli_tmux_worktree_fast_path");
+    const { enableConfigs } = await import("./chunk-07rervty.js");
+    enableConfigs();
+    const { isWorktreeModeEnabled } = await import("./chunk-vxqhjyfz.js");
+    if (isWorktreeModeEnabled()) {
+      const { execIntoTmuxWorktree } = await import("./chunk-07rervty.js");
+      const result = await execIntoTmuxWorktree(args);
+      if (result.handled) {
+        return;
+      }
+      if (result.error) {
+        const { exitWithError } = await import("./chunk-5cp2q9sh.js");
+        exitWithError(result.error);
+      }
+    }
+  }
+  if (args.length === 1 && (args[0] === "--update" || args[0] === "--upgrade")) {
+    process.argv = [process.argv[0], process.argv[1], "update"];
+  }
+  if (args.includes("--bare")) {
+    process.env.CLAUDE_CODE_SIMPLE = "1";
+  }
+  const { startCapturingEarlyInput } = await import("./chunk-bv4c48a5.js");
+  startCapturingEarlyInput();
+  profileCheckpoint("cli_before_main_import");
+  const { main: cliMain } = await import("./chunk-867x8aq0.js");
+  profileCheckpoint("cli_after_main_import");
+  await cliMain();
+  profileCheckpoint("cli_after_main_complete");
+}
+main();

package/dist/server-n5f2q89z.md

@@ -0,0 +1 @@
+# Server

package/package.json

@@ -0,0 +1,161 @@
+{
+  "name": "gong-code",
+  "version": "0.1.0",
+  "description": "AI coding assistant in the terminal — supports MiniMax, GLM, OpenAI compatible APIs",
+  "type": "module",
+  "author": "gongzhen",
+  "license": "MIT",
+  "keywords": [
+    "ai",
+    "cli",
+    "coding-assistant",
+    "terminal",
+    "repl",
+    "minimax",
+    "glm",
+    "openai"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.2.0"
+  },
+  "bin": {
+    "gong-code": "dist/cli.js"
+  },
+  "workspaces": [
+    "packages/*",
+    "packages/@ant/*"
+  ],
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun run build.ts",
+    "dev": "bun run src/entrypoints/cli.tsx",
+    "prepublishOnly": "bun run build",
+    "lint": "biome lint src/",
+    "lint:fix": "biome lint --fix src/",
+    "format": "biome format --write src/",
+    "prepare": "git config core.hooksPath .githooks",
+    "test": "bun test",
+    "check:unused": "knip-bun",
+    "health": "bun run scripts/health-check.ts",
+    "docs:dev": "npx mintlify dev"
+  },
+  "dependencies": {
+    "sharp": "^0.34.5"
+  },
+  "devDependencies": {
+    "@alcalzone/ansi-tokenize": "^0.3.0",
+    "@ant/claude-for-chrome-mcp": "workspace:*",
+    "@ant/computer-use-input": "workspace:*",
+    "@ant/computer-use-mcp": "workspace:*",
+    "@ant/computer-use-swift": "workspace:*",
+    "@anthropic-ai/bedrock-sdk": "^0.26.4",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.87",
+    "@anthropic-ai/foundry-sdk": "^0.2.3",
+    "@anthropic-ai/mcpb": "^2.1.2",
+    "@anthropic-ai/sandbox-runtime": "^0.0.44",
+    "@anthropic-ai/sdk": "^0.80.0",
+    "@anthropic-ai/vertex-sdk": "^0.14.4",
+    "@aws-sdk/client-bedrock": "^3.1020.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1020.0",
+    "@aws-sdk/client-sts": "^3.1020.0",
+    "@aws-sdk/credential-provider-node": "^3.972.28",
+    "@aws-sdk/credential-providers": "^3.1020.0",
+    "@azure/identity": "^4.13.1",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@growthbook/growthbook": "^1.6.5",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.214.0",
+    "@opentelemetry/core": "^2.6.1",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.214.0",
+    "@opentelemetry/exporter-prometheus": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.214.0",
+    "@opentelemetry/resources": "^2.6.1",
+    "@opentelemetry/sdk-logs": "^0.214.0",
+    "@opentelemetry/sdk-metrics": "^2.6.1",
+    "@opentelemetry/sdk-trace-base": "^2.6.1",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@smithy/core": "^3.23.13",
+    "@smithy/node-http-handler": "^4.5.1",
+    "ajv": "^8.18.0",
+    "asciichart": "^1.5.25",
+    "audio-capture-napi": "workspace:*",
+    "auto-bind": "^5.0.1",
+    "axios": "^1.14.0",
+    "bidi-js": "^1.0.3",
+    "cacache": "^20.0.4",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "cli-boxes": "^4.0.1",
+    "cli-highlight": "^2.1.11",
+    "code-excerpt": "^4.0.0",
+    "color-diff-napi": "workspace:*",
+    "diff": "^8.0.4",
+    "emoji-regex": "^10.6.0",
+    "env-paths": "^4.0.0",
+    "execa": "^9.6.1",
+    "fflate": "^0.8.2",
+    "figures": "^6.1.0",
+    "fuse.js": "^7.1.0",
+    "get-east-asian-width": "^1.5.0",
+    "google-auth-library": "^10.6.2",
+    "highlight.js": "^11.11.1",
+    "https-proxy-agent": "^8.0.0",
+    "ignore": "^7.0.5",
+    "image-processor-napi": "workspace:*",
+    "indent-string": "^5.0.0",
+    "jsonc-parser": "^3.3.1",
+    "lodash-es": "^4.17.23",
+    "lru-cache": "^11.2.7",
+    "marked": "^17.0.5",
+    "modifiers-napi": "workspace:*",
+    "p-map": "^7.0.4",
+    "picomatch": "^4.0.4",
+    "plist": "^3.1.0",
+    "proper-lockfile": "^4.1.2",
+    "qrcode": "^1.5.4",
+    "react": "^19.2.4",
+    "react-compiler-runtime": "^1.0.0",
+    "react-reconciler": "^0.33.0",
+    "semver": "^7.7.4",
+    "shell-quote": "^1.8.3",
+    "signal-exit": "^4.1.0",
+    "stack-utils": "^2.0.6",
+    "strip-ansi": "^7.2.0",
+    "supports-hyperlinks": "^4.4.0",
+    "tree-kill": "^1.2.2",
+    "turndown": "^7.2.2",
+    "type-fest": "^5.5.0",
+    "undici": "^7.24.6",
+    "url-handler-napi": "workspace:*",
+    "usehooks-ts": "^3.1.1",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "vscode-languageserver-types": "^3.17.5",
+    "wrap-ansi": "^10.0.0",
+    "ws": "^8.20.0",
+    "xss": "^1.0.15",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6",
+    "@biomejs/biome": "^2.4.10",
+    "@types/bun": "^1.3.11",
+    "@types/cacache": "^20.0.1",
+    "@types/plist": "^3.0.5",
+    "@types/react": "^19.2.14",
+    "@types/react-reconciler": "^0.33.0",
+    "@types/sharp": "^0.32.0",
+    "@types/turndown": "^5.0.6",
+    "knip": "^6.1.1",
+    "typescript": "^6.0.2"
+  }
+}