@stevenzxs/ccharness 1.0.0

package/dist/chunk-3yx3n6jw.js

@@ -0,0 +1,58 @@
+// @bun
+import {
+  init_log,
+  logError
+} from "./chunk-mss2zjet.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-347yx4gw.js";
+
+// src/utils/renderOptions.ts
+init_envUtils();
+init_log();
+import { openSync } from "fs";
+import { ReadStream } from "tty";
+var cachedStdinOverride = null;
+function getStdinOverride() {
+  if (cachedStdinOverride !== null) {
+    return cachedStdinOverride;
+  }
+  if (process.stdin.isTTY) {
+    cachedStdinOverride = undefined;
+    return;
+  }
+  if (isEnvTruthy(process.env.CI)) {
+    cachedStdinOverride = undefined;
+    return;
+  }
+  if (process.argv.includes("mcp")) {
+    cachedStdinOverride = undefined;
+    return;
+  }
+  if (process.platform === "win32") {
+    cachedStdinOverride = undefined;
+    return;
+  }
+  try {
+    const ttyFd = openSync("/dev/tty", "r");
+    const ttyStream = new ReadStream(ttyFd);
+    ttyStream.isTTY = true;
+    cachedStdinOverride = ttyStream;
+    return cachedStdinOverride;
+  } catch (err) {
+    logError(err);
+    cachedStdinOverride = undefined;
+    return;
+  }
+}
+function getBaseRenderOptions(exitOnCtrlC = false) {
+  const stdin = getStdinOverride();
+  const options = { exitOnCtrlC };
+  if (stdin) {
+    options.stdin = stdin;
+  }
+  return options;
+}
+
+export { getBaseRenderOptions };

package/dist/chunk-48dm35w8.js

@@ -0,0 +1,83 @@
+// @bun
+import {
+  extractConversationText,
+  init_sessionTitle
+} from "./chunk-yh10eg1t.js";
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-fyrdmq8b.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-c13w1efw.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-7fxg2tat.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/rename/generateSessionName.ts
+async function generateSessionName(messages, signal) {
+  const conversationText = extractConversationText(messages);
+  if (!conversationText) {
+    return null;
+  }
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([
+        'Generate a short kebab-case name (2-4 words) that captures the main topic of this conversation. Use lowercase words separated by hyphens. Examples: "fix-login-bug", "add-auth-feature", "refactor-api-client", "debug-test-failures". Return JSON with a "name" field.'
+      ]),
+      userPrompt: conversationText,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            name: { type: "string" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      },
+      signal,
+      options: {
+        querySource: "rename_generate_name",
+        agents: [],
+        isNonInteractiveSession: false,
+        hasAppendSystemPrompt: false,
+        mcpTools: []
+      }
+    });
+    const content = Array.isArray(result.message.content) ? extractTextContent(result.message.content) : result.message.content;
+    const response = safeParseJSON(content);
+    if (response && typeof response === "object" && "name" in response && typeof response.name === "string") {
+      return response.name;
+    }
+    return null;
+  } catch (error) {
+    logForDebugging(`generateSessionName failed: ${errorMessage(error)}`, {
+      level: "error"
+    });
+    return null;
+  }
+}
+var init_generateSessionName = __esm(() => {
+  init_claude();
+  init_debug();
+  init_errors();
+  init_json();
+  init_messages();
+  init_sessionTitle();
+  init_systemPromptType();
+});
+
+export { generateSessionName, init_generateSessionName };

package/dist/chunk-4a189mn2.js

@@ -0,0 +1,103 @@
+// @bun
+import {
+  AsyncDecompress,
+  AsyncDeflate,
+  AsyncGunzip,
+  AsyncGzip,
+  AsyncInflate,
+  AsyncUnzipInflate,
+  AsyncUnzlib,
+  AsyncZipDeflate,
+  AsyncZlib,
+  DecodeUTF8,
+  Decompress,
+  Deflate,
+  EncodeUTF8,
+  FlateErrorCode,
+  Gunzip,
+  Gzip,
+  Inflate,
+  Unzip,
+  UnzipInflate,
+  UnzipPassThrough,
+  Unzlib,
+  Zip,
+  ZipDeflate,
+  ZipPassThrough,
+  Zlib,
+  decompress,
+  decompressSync,
+  deflate,
+  deflateSync,
+  gunzip,
+  gunzipSync,
+  gzip,
+  gzipSync,
+  inflate,
+  inflateSync,
+  init_esm,
+  strFromU8,
+  strToU8,
+  unzip,
+  unzipSync,
+  unzlib,
+  unzlibSync,
+  zip,
+  zipSync,
+  zlib,
+  zlibSync
+} from "./chunk-xhj7g13b.js";
+import"./chunk-hhsxm2yr.js";
+init_esm();
+
+export {
+  zlibSync,
+  zlib,
+  zipSync,
+  zip,
+  unzlibSync,
+  unzlib,
+  unzipSync,
+  unzip,
+  strToU8,
+  strFromU8,
+  inflateSync,
+  inflate,
+  gzipSync,
+  gzip,
+  gunzipSync,
+  gunzip,
+  deflateSync,
+  deflate,
+  decompressSync,
+  decompress,
+  gzipSync as compressSync,
+  gzip as compress,
+  Zlib,
+  ZipPassThrough,
+  ZipDeflate,
+  Zip,
+  Unzlib,
+  UnzipPassThrough,
+  UnzipInflate,
+  Unzip,
+  Inflate,
+  Gzip,
+  Gunzip,
+  FlateErrorCode,
+  EncodeUTF8,
+  Deflate,
+  Decompress,
+  DecodeUTF8,
+  Gzip as Compress,
+  AsyncZlib,
+  AsyncZipDeflate,
+  AsyncUnzlib,
+  AsyncUnzipInflate,
+  AsyncInflate,
+  AsyncGzip,
+  AsyncGunzip,
+  AsyncDeflate,
+  AsyncDecompress,
+  AsyncGzip as AsyncCompress
+};

package/dist/chunk-4a1qse8t.js

@@ -0,0 +1,227 @@
+// @bun
+import {
+  SAFE_ENV_VARS,
+  isProviderManagedEnvVar
+} from "./chunk-x8b7vft8.js";
+import {
+  notifyPermissionModeChanged,
+  notifySessionMetadataChanged
+} from "./chunk-nyenvnv5.js";
+import {
+  init_syncCache,
+  isRemoteManagedSettingsEligible
+} from "./chunk-fyrdmq8b.js";
+import {
+  clearApiKeyHelperCache,
+  clearAwsCredentialsCache,
+  clearGcpCredentialsCache,
+  getGlobalConfig,
+  getSettingsForSource,
+  getSettings_DEPRECATED,
+  init_PermissionMode,
+  init_auth,
+  init_config1 as init_config,
+  init_constants,
+  init_settings1 as init_settings,
+  isSettingSourceEnabled,
+  permissionModeFromString,
+  saveGlobalConfig,
+  toExternalPermissionMode,
+  updateSettingsForSource
+} from "./chunk-a07hgnvm.js";
+import {
+  clearCACertsCache,
+  clearMTLSCache,
+  clearProxyCache,
+  configureGlobalAgents,
+  init_caCerts,
+  init_mtls,
+  init_proxy
+} from "./chunk-6sehqbsm.js";
+import {
+  init_log,
+  logError
+} from "./chunk-mss2zjet.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-7fxg2tat.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-347yx4gw.js";
+import {
+  init_state,
+  setMainLoopModelOverride
+} from "./chunk-11q9h2zt.js";
+
+// src/utils/managedEnv.ts
+init_syncCache();
+init_caCerts();
+init_config();
+init_envUtils();
+init_mtls();
+init_proxy();
+init_constants();
+init_settings();
+function withoutSSHTunnelVars(env) {
+  if (!env || !process.env.ANTHROPIC_UNIX_SOCKET)
+    return env || {};
+  const {
+    ANTHROPIC_UNIX_SOCKET: _1,
+    ANTHROPIC_BASE_URL: _2,
+    ANTHROPIC_API_KEY: _3,
+    ANTHROPIC_AUTH_TOKEN: _4,
+    CLAUDE_CODE_OAUTH_TOKEN: _5,
+    ...rest
+  } = env;
+  return rest;
+}
+function withoutHostManagedProviderVars(env) {
+  if (!env)
+    return {};
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST)) {
+    return env;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!isProviderManagedEnvVar(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+var ccdSpawnEnvKeys;
+function withoutCcdSpawnEnvKeys(env) {
+  if (!env || !ccdSpawnEnvKeys)
+    return env || {};
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!ccdSpawnEnvKeys.has(key))
+      out[key] = value;
+  }
+  return out;
+}
+function filterSettingsEnv(env) {
+  return withoutCcdSpawnEnvKeys(withoutHostManagedProviderVars(withoutSSHTunnelVars(env)));
+}
+var TRUSTED_SETTING_SOURCES = [
+  "userSettings",
+  "flagSettings",
+  "policySettings"
+];
+function applySafeConfigEnvironmentVariables() {
+  if (ccdSpawnEnvKeys === undefined) {
+    ccdSpawnEnvKeys = process.env.CLAUDE_CODE_ENTRYPOINT === "claude-desktop" ? new Set(Object.keys(process.env)) : null;
+  }
+  Object.assign(process.env, filterSettingsEnv(getGlobalConfig().env));
+  for (const source of TRUSTED_SETTING_SOURCES) {
+    if (source === "policySettings")
+      continue;
+    if (!isSettingSourceEnabled(source))
+      continue;
+    Object.assign(process.env, filterSettingsEnv(getSettingsForSource(source)?.env));
+  }
+  isRemoteManagedSettingsEligible();
+  Object.assign(process.env, filterSettingsEnv(getSettingsForSource("policySettings")?.env));
+  const settingsEnv = filterSettingsEnv(getSettings_DEPRECATED()?.env);
+  for (const [key, value] of Object.entries(settingsEnv)) {
+    if (SAFE_ENV_VARS.has(key.toUpperCase())) {
+      process.env[key] = value;
+    }
+  }
+}
+function applyConfigEnvironmentVariables() {
+  Object.assign(process.env, filterSettingsEnv(getGlobalConfig().env));
+  Object.assign(process.env, filterSettingsEnv(getSettings_DEPRECATED()?.env));
+  clearCACertsCache();
+  clearMTLSCache();
+  clearProxyCache();
+  configureGlobalAgents();
+}
+
+// src/state/onChangeAppState.ts
+init_state();
+init_auth();
+init_config();
+init_errors();
+init_log();
+init_PermissionMode();
+init_settings();
+function externalMetadataToAppState(metadata) {
+  return (prev) => ({
+    ...prev,
+    ...typeof metadata.permission_mode === "string" ? {
+      toolPermissionContext: {
+        ...prev.toolPermissionContext,
+        mode: permissionModeFromString(metadata.permission_mode)
+      }
+    } : {},
+    ...typeof metadata.is_ultraplan_mode === "boolean" ? { isUltraplanMode: metadata.is_ultraplan_mode } : {}
+  });
+}
+function onChangeAppState({
+  newState,
+  oldState
+}) {
+  const prevMode = oldState.toolPermissionContext.mode;
+  const newMode = newState.toolPermissionContext.mode;
+  if (prevMode !== newMode) {
+    const prevExternal = toExternalPermissionMode(prevMode);
+    const newExternal = toExternalPermissionMode(newMode);
+    if (prevExternal !== newExternal) {
+      const isUltraplan = newExternal === "plan" && newState.isUltraplanMode && !oldState.isUltraplanMode ? true : null;
+      notifySessionMetadataChanged({
+        permission_mode: newExternal,
+        is_ultraplan_mode: isUltraplan
+      });
+    }
+    notifyPermissionModeChanged(newMode);
+  }
+  if (newState.mainLoopModel !== oldState.mainLoopModel && newState.mainLoopModel === null) {
+    updateSettingsForSource("userSettings", { model: undefined });
+    setMainLoopModelOverride(null);
+  }
+  if (newState.mainLoopModel !== oldState.mainLoopModel && newState.mainLoopModel !== null) {
+    updateSettingsForSource("userSettings", { model: newState.mainLoopModel });
+    setMainLoopModelOverride(newState.mainLoopModel);
+  }
+  if (newState.expandedView !== oldState.expandedView) {
+    const showExpandedTodos = newState.expandedView === "tasks";
+    const showSpinnerTree = newState.expandedView === "teammates";
+    if (getGlobalConfig().showExpandedTodos !== showExpandedTodos || getGlobalConfig().showSpinnerTree !== showSpinnerTree) {
+      saveGlobalConfig((current) => ({
+        ...current,
+        showExpandedTodos,
+        showSpinnerTree
+      }));
+    }
+  }
+  if (newState.verbose !== oldState.verbose && getGlobalConfig().verbose !== newState.verbose) {
+    const verbose = newState.verbose;
+    saveGlobalConfig((current) => ({
+      ...current,
+      verbose
+    }));
+  }
+  if (process.env.USER_TYPE === "ant") {
+    if (newState.tungstenPanelVisible !== oldState.tungstenPanelVisible && newState.tungstenPanelVisible !== undefined && getGlobalConfig().tungstenPanelVisible !== newState.tungstenPanelVisible) {
+      const tungstenPanelVisible = newState.tungstenPanelVisible;
+      saveGlobalConfig((current) => ({ ...current, tungstenPanelVisible }));
+    }
+  }
+  if (newState.settings !== oldState.settings) {
+    try {
+      clearApiKeyHelperCache();
+      clearAwsCredentialsCache();
+      clearGcpCredentialsCache();
+      if (newState.settings.env !== oldState.settings.env) {
+        applyConfigEnvironmentVariables();
+      }
+    } catch (error) {
+      logError(toError(error));
+    }
+  }
+}
+
+export { applySafeConfigEnvironmentVariables, applyConfigEnvironmentVariables, externalMetadataToAppState, onChangeAppState };

package/dist/chunk-4a4fx0xe.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-y5patg9p.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-b95s01h5.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/components/PressEnterToContinue.tsx
+function PressEnterToContinue() {
+  const $ = import_compiler_runtime.c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: "permission",
+      children: [
+        "Press ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          bold: true,
+          children: "Enter"
+        }, undefined, false, undefined, this),
+        " to continue\u2026"
+      ]
+    }, undefined, true, undefined, this);
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+var import_compiler_runtime, jsx_dev_runtime;
+var init_PressEnterToContinue = __esm(() => {
+  init_ink();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { PressEnterToContinue, init_PressEnterToContinue };