@costrict/csc 4.0.1

package/dist/chunk-dtj6da60.js

@@ -0,0 +1,173 @@
+// @bun
+import {
+  init_overageCreditGrant,
+  invalidateOverageCreditGrantCache
+} from "./chunk-xx0570gb.js";
+import {
+  fetchUtilization,
+  init_usage
+} from "./chunk-xrt6e27s.js";
+import {
+  getOAuthHeaders,
+  init_api,
+  prepareApiRequest
+} from "./chunk-5krq9sjq.js";
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-85em0j2s.js";
+import {
+  getGlobalConfig,
+  getSubscriptionType,
+  hasClaudeAiBillingAccess,
+  init_auth,
+  init_billing,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-qp1047f9.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-q82r31er.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-nh3cd07f.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/adminRequests.ts
+async function createAdminRequest(params) {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/admin_requests`;
+  const response = await axios_default.post(url, params, { headers });
+  return response.data;
+}
+async function getMyAdminRequests(requestType, statuses) {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  let url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/admin_requests/me?request_type=${requestType}`;
+  for (const status of statuses) {
+    url += `&statuses=${status}`;
+  }
+  const response = await axios_default.get(url, {
+    headers
+  });
+  return response.data;
+}
+async function checkAdminRequestEligibility(requestType) {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/admin_requests/eligibility?request_type=${requestType}`;
+  const response = await axios_default.get(url, {
+    headers
+  });
+  return response.data;
+}
+var init_adminRequests = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_api();
+});
+
+// src/commands/extra-usage/extra-usage-core.ts
+async function runExtraUsage() {
+  if (!getGlobalConfig().hasVisitedExtraUsage) {
+    saveGlobalConfig((prev) => ({ ...prev, hasVisitedExtraUsage: true }));
+  }
+  invalidateOverageCreditGrantCache();
+  const subscriptionType = getSubscriptionType();
+  const isTeamOrEnterprise = subscriptionType === "team" || subscriptionType === "enterprise";
+  const hasBillingAccess = hasClaudeAiBillingAccess();
+  if (!hasBillingAccess && isTeamOrEnterprise) {
+    let extraUsage;
+    try {
+      const utilization = await fetchUtilization();
+      extraUsage = utilization?.extra_usage;
+    } catch (error) {
+      logError(error);
+    }
+    if (extraUsage?.is_enabled && extraUsage.monthly_limit === null) {
+      return {
+        type: "message",
+        value: "Your organization already has unlimited extra usage. No request needed."
+      };
+    }
+    try {
+      const eligibility = await checkAdminRequestEligibility("limit_increase");
+      if (eligibility?.is_allowed === false) {
+        return {
+          type: "message",
+          value: "Please contact your admin to manage extra usage settings."
+        };
+      }
+    } catch (error) {
+      logError(error);
+    }
+    try {
+      const pendingOrDismissedRequests = await getMyAdminRequests("limit_increase", ["pending", "dismissed"]);
+      if (pendingOrDismissedRequests && pendingOrDismissedRequests.length > 0) {
+        return {
+          type: "message",
+          value: "You have already submitted a request for extra usage to your admin."
+        };
+      }
+    } catch (error) {
+      logError(error);
+    }
+    try {
+      await createAdminRequest({
+        request_type: "limit_increase",
+        details: null
+      });
+      return {
+        type: "message",
+        value: extraUsage?.is_enabled ? "Request sent to your admin to increase extra usage." : "Request sent to your admin to enable extra usage."
+      };
+    } catch (error) {
+      logError(error);
+    }
+    return {
+      type: "message",
+      value: "Please contact your admin to manage extra usage settings."
+    };
+  }
+  const url = isTeamOrEnterprise ? "https://costrict.ai/admin-settings/usage" : "https://costrict.ai/settings/usage";
+  try {
+    const opened = await openBrowser(url);
+    return { type: "browser-opened", url, opened };
+  } catch (error) {
+    logError(error);
+    return {
+      type: "message",
+      value: `Failed to open browser. Please visit ${url} to manage extra usage.`
+    };
+  }
+}
+var init_extra_usage_core = __esm(() => {
+  init_adminRequests();
+  init_overageCreditGrant();
+  init_usage();
+  init_auth();
+  init_billing();
+  init_browser();
+  init_config();
+  init_log();
+});
+
+export { runExtraUsage, init_extra_usage_core };

package/dist/chunk-e3jdmhj3.js

@@ -0,0 +1,122 @@
+// @bun
+import {
+  notifyPermissionModeChanged,
+  notifySessionMetadataChanged
+} from "./chunk-2s460rgh.js";
+import {
+  applyConfigEnvironmentVariables,
+  init_managedEnv
+} from "./chunk-97kwfkef.js";
+import {
+  clearApiKeyHelperCache,
+  clearAwsCredentialsCache,
+  clearGcpCredentialsCache,
+  getGlobalConfig,
+  init_PermissionMode,
+  init_auth,
+  init_config1 as init_config,
+  init_settings1 as init_settings,
+  permissionModeFromString,
+  saveGlobalConfig,
+  toExternalPermissionMode,
+  updateSettingsForSource
+} from "./chunk-qp1047f9.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-z6e5jp2w.js";
+import {
+  init_state,
+  setMainLoopModelOverride
+} from "./chunk-h4b85amj.js";
+
+// src/state/onChangeAppState.ts
+init_state();
+init_auth();
+init_config();
+init_errors();
+init_log();
+init_managedEnv();
+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 { externalMetadataToAppState, onChangeAppState };

package/dist/chunk-e5ey47fq.js

@@ -0,0 +1,78 @@
+// @bun
+import {
+  init_computerUseLock,
+  isLockHeldLocally,
+  releaseComputerUseLock
+} from "./chunk-eq5csq9z.js";
+import {
+  init_escHotkey,
+  init_withResolvers,
+  unregisterEscHotkey,
+  withResolvers
+} from "./chunk-3dy7fxmg.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-z6e5jp2w.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/computerUse/cleanup.ts
+async function cleanupComputerUseAfterTurn(ctx) {
+  const appState = ctx.getAppState();
+  const hidden = appState.computerUseMcpState?.hiddenDuringTurn;
+  if (hidden && hidden.size > 0) {
+    const { unhideComputerUseApps } = await import("./chunk-4te4ttsn.js");
+    const unhide = unhideComputerUseApps([...hidden]).catch((err) => logForDebugging(`[Computer Use MCP] auto-unhide failed: ${errorMessage(err)}`));
+    const timeout = withResolvers();
+    const timer = setTimeout(timeout.resolve, UNHIDE_TIMEOUT_MS);
+    await Promise.race([unhide, timeout.promise]).finally(() => clearTimeout(timer));
+    ctx.setAppState((prev) => prev.computerUseMcpState?.hiddenDuringTurn === undefined ? prev : {
+      ...prev,
+      computerUseMcpState: {
+        ...prev.computerUseMcpState,
+        hiddenDuringTurn: undefined
+      }
+    });
+  }
+  if (!isLockHeldLocally())
+    return;
+  try {
+    unregisterEscHotkey();
+  } catch (err) {
+    logForDebugging(`[Computer Use MCP] unregisterEscHotkey failed: ${errorMessage(err)}`);
+  }
+  if (await releaseComputerUseLock()) {
+    ctx.sendOSNotification?.({
+      message: "Claude is done using your computer",
+      notificationType: "computer_use_exit"
+    });
+  }
+}
+var UNHIDE_TIMEOUT_MS = 5000;
+var init_cleanup = __esm(() => {
+  init_debug();
+  init_errors();
+  init_withResolvers();
+  init_computerUseLock();
+  init_escHotkey();
+});
+init_cleanup();
+
+export {
+  cleanupComputerUseAfterTurn
+};