@verboo/code 0.13.3 → 0.13.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist/cli.mjs +487 -424
  2. package/package.json +1 -1
package/dist/cli.mjs CHANGED
@@ -169759,7 +169759,7 @@ function getClaudeCodeUserAgent() {
169759
169759
  return `claude-code/${"99.0.0"}`;
169760
169760
  }
169761
169761
  function getVerbooCodeUserAgent() {
169762
- const version2 = typeof MACRO !== "undefined" ? "0.13.3" : "unknown";
169762
+ const version2 = typeof MACRO !== "undefined" ? "0.13.4" : "unknown";
169763
169763
  return `verboo-code/${version2}`;
169764
169764
  }
169765
169765
 
@@ -393986,7 +393986,7 @@ function getAnthropicEnvMetadata() {
393986
393986
  function getBuildAgeMinutes() {
393987
393987
  if (false)
393988
393988
  ;
393989
- const buildTime = new Date("2026-07-15T02:08:38.282Z").getTime();
393989
+ const buildTime = new Date("2026-07-15T13:23:40.197Z").getTime();
393990
393990
  if (isNaN(buildTime))
393991
393991
  return;
393992
393992
  return Math.floor((Date.now() - buildTime) / 60000);
@@ -422241,7 +422241,7 @@ function buildPrimarySection() {
422241
422241
  });
422242
422242
  return [{
422243
422243
  label: "Version",
422244
- value: "0.13.3"
422244
+ value: "0.13.4"
422245
422245
  }, {
422246
422246
  label: "Session name",
422247
422247
  value: nameValue
@@ -435170,7 +435170,7 @@ function getReleaseTagUrl(version2 = publicBuildVersion) {
435170
435170
  return `${VERBOO_RELEASES_URL}/tag/v${normalizePublicVersion(version2)}`;
435171
435171
  }
435172
435172
  function getPublicBuildVersion() {
435173
- return "0.13.3";
435173
+ return "0.13.4";
435174
435174
  }
435175
435175
  var import_semver10, VERBOO_RELEASES_URL = "https://github.com/verbeux-ai/code/releases", fallbackBuildVersion, publicBuildVersion;
435176
435176
  var init_version = __esm(() => {
@@ -437656,6 +437656,421 @@ var init_keybindings2 = __esm(() => {
437656
437656
  keybindings_default = keybindings;
437657
437657
  });
437658
437658
 
437659
+ // src/utils/plugins/officialMarketplaceStartupCheck.ts
437660
+ import { join as join114 } from "path";
437661
+ function isOfficialMarketplaceAutoInstallDisabled() {
437662
+ return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_OFFICIAL_MARKETPLACE_AUTOINSTALL);
437663
+ }
437664
+ function calculateNextRetryDelay(retryCount) {
437665
+ const delay = RETRY_CONFIG.INITIAL_DELAY_MS * Math.pow(RETRY_CONFIG.BACKOFF_MULTIPLIER, retryCount);
437666
+ return Math.min(delay, RETRY_CONFIG.MAX_DELAY_MS);
437667
+ }
437668
+ function shouldRetryInstallation(config3) {
437669
+ if (!config3.officialMarketplaceAutoInstallAttempted) {
437670
+ return true;
437671
+ }
437672
+ const failReason = config3.officialMarketplaceAutoInstallFailReason;
437673
+ const retryCount = config3.officialMarketplaceAutoInstallRetryCount || 0;
437674
+ const nextRetryTime = config3.officialMarketplaceAutoInstallNextRetryTime;
437675
+ const now2 = Date.now();
437676
+ if (retryCount >= RETRY_CONFIG.MAX_ATTEMPTS) {
437677
+ return false;
437678
+ }
437679
+ if (failReason === "policy_blocked") {
437680
+ return false;
437681
+ }
437682
+ if (nextRetryTime && now2 < nextRetryTime) {
437683
+ return false;
437684
+ }
437685
+ return failReason === "unknown" || failReason === "git_unavailable" || failReason === "gcs_unavailable" || failReason === undefined;
437686
+ }
437687
+ async function persistVerbooMarketplaceAutoUpdateDefault() {
437688
+ const knownMarketplaces = await loadKnownMarketplacesConfig();
437689
+ const entry = knownMarketplaces[VERBOO_MARKETPLACE_NAME];
437690
+ if (!entry || entry.autoUpdate !== undefined)
437691
+ return;
437692
+ knownMarketplaces[VERBOO_MARKETPLACE_NAME] = {
437693
+ ...entry,
437694
+ autoUpdate: true
437695
+ };
437696
+ await saveKnownMarketplacesConfig(knownMarketplaces);
437697
+ }
437698
+ function shouldRetryNativeMarketplaceInstallation(state2) {
437699
+ if (!state2?.attempted)
437700
+ return true;
437701
+ if ((state2.retryCount ?? 0) >= RETRY_CONFIG.MAX_ATTEMPTS)
437702
+ return false;
437703
+ if (state2.failReason === "policy_blocked")
437704
+ return false;
437705
+ if (state2.nextRetryTime && Date.now() < state2.nextRetryTime)
437706
+ return false;
437707
+ return true;
437708
+ }
437709
+ function saveNativeMarketplaceAutoInstallState(name, update) {
437710
+ saveGlobalConfig((current) => ({
437711
+ ...current,
437712
+ nativeMarketplaceAutoInstall: {
437713
+ ...current.nativeMarketplaceAutoInstall,
437714
+ [name]: {
437715
+ ...current.nativeMarketplaceAutoInstall?.[name],
437716
+ ...update
437717
+ }
437718
+ }
437719
+ }));
437720
+ }
437721
+ function checkAndInstallVerbooMarketplace() {
437722
+ if (!verbooMarketplaceAutoInstallPromise) {
437723
+ const promise3 = checkAndInstallVerbooMarketplaceImpl();
437724
+ verbooMarketplaceAutoInstallPromise = promise3;
437725
+ promise3.then(() => {
437726
+ if (verbooMarketplaceAutoInstallPromise === promise3) {
437727
+ verbooMarketplaceAutoInstallPromise = undefined;
437728
+ }
437729
+ }, () => {
437730
+ if (verbooMarketplaceAutoInstallPromise === promise3) {
437731
+ verbooMarketplaceAutoInstallPromise = undefined;
437732
+ }
437733
+ });
437734
+ }
437735
+ return verbooMarketplaceAutoInstallPromise;
437736
+ }
437737
+ async function checkAndInstallVerbooMarketplaceImpl() {
437738
+ const config3 = getGlobalConfig();
437739
+ const state2 = config3.nativeMarketplaceAutoInstall?.[VERBOO_MARKETPLACE_NAME];
437740
+ try {
437741
+ const knownMarketplaces = await loadKnownMarketplacesConfig();
437742
+ if (knownMarketplaces[VERBOO_MARKETPLACE_NAME]) {
437743
+ await persistVerbooMarketplaceAutoUpdateDefault();
437744
+ saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
437745
+ attempted: true,
437746
+ installed: true,
437747
+ failReason: undefined,
437748
+ retryCount: undefined,
437749
+ lastAttemptTime: undefined,
437750
+ nextRetryTime: undefined
437751
+ });
437752
+ return { installed: false, skipped: true, reason: "already_installed" };
437753
+ }
437754
+ if (!shouldRetryNativeMarketplaceInstallation(state2)) {
437755
+ return {
437756
+ installed: false,
437757
+ skipped: true,
437758
+ reason: state2?.failReason ?? "already_attempted"
437759
+ };
437760
+ }
437761
+ if (isOfficialMarketplaceAutoInstallDisabled()) {
437762
+ saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
437763
+ attempted: true,
437764
+ installed: false,
437765
+ failReason: "policy_blocked"
437766
+ });
437767
+ return { installed: false, skipped: true, reason: "policy_blocked" };
437768
+ }
437769
+ if (!isSourceAllowedByPolicy(VERBOO_MARKETPLACE_SOURCE)) {
437770
+ saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
437771
+ attempted: true,
437772
+ installed: false,
437773
+ failReason: "policy_blocked"
437774
+ });
437775
+ return { installed: false, skipped: true, reason: "policy_blocked" };
437776
+ }
437777
+ logForDebugging("Attempting to auto-install Verboo marketplace");
437778
+ await addMarketplaceSource(VERBOO_MARKETPLACE_SOURCE);
437779
+ await persistVerbooMarketplaceAutoUpdateDefault();
437780
+ saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
437781
+ attempted: true,
437782
+ installed: true,
437783
+ failReason: undefined,
437784
+ retryCount: undefined,
437785
+ lastAttemptTime: undefined,
437786
+ nextRetryTime: undefined
437787
+ });
437788
+ logEvent("tengu_official_marketplace_auto_install", {
437789
+ installed: true,
437790
+ skipped: false,
437791
+ verboo_marketplace: true
437792
+ });
437793
+ return { installed: true, skipped: false };
437794
+ } catch (error42) {
437795
+ const retryCount = (state2?.retryCount ?? 0) + 1;
437796
+ const now2 = Date.now();
437797
+ let configSaveFailed = false;
437798
+ try {
437799
+ saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
437800
+ attempted: true,
437801
+ installed: false,
437802
+ failReason: "unknown",
437803
+ retryCount,
437804
+ lastAttemptTime: now2,
437805
+ nextRetryTime: now2 + calculateNextRetryDelay(retryCount)
437806
+ });
437807
+ } catch (saveError) {
437808
+ configSaveFailed = true;
437809
+ logError2(toError(saveError));
437810
+ }
437811
+ logForDebugging(`Failed to auto-install Verboo marketplace: ${error42 instanceof Error ? error42.message : String(error42)}`, { level: "error" });
437812
+ logError2(toError(error42));
437813
+ logEvent("tengu_official_marketplace_auto_install", {
437814
+ installed: false,
437815
+ skipped: true,
437816
+ failed: true,
437817
+ verboo_marketplace: true,
437818
+ retry_count: retryCount
437819
+ });
437820
+ return {
437821
+ installed: false,
437822
+ skipped: true,
437823
+ reason: "unknown",
437824
+ configSaveFailed
437825
+ };
437826
+ }
437827
+ }
437828
+ async function prepareVerbooMarketplaceForExplicitInstall() {
437829
+ await checkAndInstallVerbooMarketplace();
437830
+ const knownMarketplaces = await loadKnownMarketplacesConfig();
437831
+ if (!knownMarketplaces[VERBOO_MARKETPLACE_NAME]) {
437832
+ await addMarketplaceSource(VERBOO_MARKETPLACE_SOURCE);
437833
+ }
437834
+ await persistVerbooMarketplaceAutoUpdateDefault();
437835
+ await refreshMarketplace(VERBOO_MARKETPLACE_NAME);
437836
+ }
437837
+ async function checkAndInstallNativeMarketplaces() {
437838
+ const verboo = await checkAndInstallVerbooMarketplace();
437839
+ const claude = await checkAndInstallOfficialMarketplace();
437840
+ return { verboo, claude };
437841
+ }
437842
+ async function checkAndInstallOfficialMarketplace() {
437843
+ const config3 = getGlobalConfig();
437844
+ try {
437845
+ const knownMarketplaces = await loadKnownMarketplacesConfig();
437846
+ if (knownMarketplaces[CLAUDE_MARKETPLACE_NAME]) {
437847
+ logForDebugging(`Official marketplace '${CLAUDE_MARKETPLACE_NAME}' already installed, skipping`);
437848
+ saveGlobalConfig((current) => ({
437849
+ ...current,
437850
+ officialMarketplaceAutoInstallAttempted: true,
437851
+ officialMarketplaceAutoInstalled: true
437852
+ }));
437853
+ return { installed: false, skipped: true, reason: "already_installed" };
437854
+ }
437855
+ if (!shouldRetryInstallation(config3)) {
437856
+ const reason = config3.officialMarketplaceAutoInstallFailReason ?? "already_attempted";
437857
+ logForDebugging(`Official marketplace auto-install skipped: ${reason}`);
437858
+ return {
437859
+ installed: false,
437860
+ skipped: true,
437861
+ reason
437862
+ };
437863
+ }
437864
+ if (isOfficialMarketplaceAutoInstallDisabled()) {
437865
+ logForDebugging("Official marketplace auto-install disabled via env var, skipping");
437866
+ saveGlobalConfig((current) => ({
437867
+ ...current,
437868
+ officialMarketplaceAutoInstallAttempted: true,
437869
+ officialMarketplaceAutoInstalled: false,
437870
+ officialMarketplaceAutoInstallFailReason: "policy_blocked"
437871
+ }));
437872
+ logEvent("tengu_official_marketplace_auto_install", {
437873
+ installed: false,
437874
+ skipped: true,
437875
+ policy_blocked: true
437876
+ });
437877
+ return { installed: false, skipped: true, reason: "policy_blocked" };
437878
+ }
437879
+ if (!isSourceAllowedByPolicy(CLAUDE_MARKETPLACE_SOURCE)) {
437880
+ logForDebugging("Official marketplace blocked by enterprise policy, skipping");
437881
+ saveGlobalConfig((current) => ({
437882
+ ...current,
437883
+ officialMarketplaceAutoInstallAttempted: true,
437884
+ officialMarketplaceAutoInstalled: false,
437885
+ officialMarketplaceAutoInstallFailReason: "policy_blocked"
437886
+ }));
437887
+ logEvent("tengu_official_marketplace_auto_install", {
437888
+ installed: false,
437889
+ skipped: true,
437890
+ policy_blocked: true
437891
+ });
437892
+ return { installed: false, skipped: true, reason: "policy_blocked" };
437893
+ }
437894
+ const cacheDir = getMarketplacesCacheDir();
437895
+ const installLocation = join114(cacheDir, CLAUDE_MARKETPLACE_NAME);
437896
+ const gcsSha = await fetchOfficialMarketplaceFromGcs(installLocation, cacheDir);
437897
+ if (gcsSha !== null) {
437898
+ const known = await loadKnownMarketplacesConfig();
437899
+ known[CLAUDE_MARKETPLACE_NAME] = {
437900
+ source: CLAUDE_MARKETPLACE_SOURCE,
437901
+ installLocation,
437902
+ lastUpdated: new Date().toISOString()
437903
+ };
437904
+ await saveKnownMarketplacesConfig(known);
437905
+ saveGlobalConfig((current) => ({
437906
+ ...current,
437907
+ officialMarketplaceAutoInstallAttempted: true,
437908
+ officialMarketplaceAutoInstalled: true,
437909
+ officialMarketplaceAutoInstallFailReason: undefined,
437910
+ officialMarketplaceAutoInstallRetryCount: undefined,
437911
+ officialMarketplaceAutoInstallLastAttemptTime: undefined,
437912
+ officialMarketplaceAutoInstallNextRetryTime: undefined
437913
+ }));
437914
+ logEvent("tengu_official_marketplace_auto_install", {
437915
+ installed: true,
437916
+ skipped: false,
437917
+ via_gcs: true
437918
+ });
437919
+ return { installed: true, skipped: false };
437920
+ }
437921
+ if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_plugin_official_mkt_git_fallback", true)) {
437922
+ logForDebugging("Official marketplace GCS failed; git fallback disabled by flag — skipping install");
437923
+ const retryCount = (config3.officialMarketplaceAutoInstallRetryCount || 0) + 1;
437924
+ const now2 = Date.now();
437925
+ const nextRetryTime = now2 + calculateNextRetryDelay(retryCount);
437926
+ saveGlobalConfig((current) => ({
437927
+ ...current,
437928
+ officialMarketplaceAutoInstallAttempted: true,
437929
+ officialMarketplaceAutoInstalled: false,
437930
+ officialMarketplaceAutoInstallFailReason: "gcs_unavailable",
437931
+ officialMarketplaceAutoInstallRetryCount: retryCount,
437932
+ officialMarketplaceAutoInstallLastAttemptTime: now2,
437933
+ officialMarketplaceAutoInstallNextRetryTime: nextRetryTime
437934
+ }));
437935
+ logEvent("tengu_official_marketplace_auto_install", {
437936
+ installed: false,
437937
+ skipped: true,
437938
+ gcs_unavailable: true,
437939
+ retry_count: retryCount
437940
+ });
437941
+ return { installed: false, skipped: true, reason: "gcs_unavailable" };
437942
+ }
437943
+ const gitAvailable = await checkGitAvailable();
437944
+ if (!gitAvailable) {
437945
+ logForDebugging("Git not available, skipping official marketplace auto-install");
437946
+ const retryCount = (config3.officialMarketplaceAutoInstallRetryCount || 0) + 1;
437947
+ const now2 = Date.now();
437948
+ const nextRetryDelay = calculateNextRetryDelay(retryCount);
437949
+ const nextRetryTime = now2 + nextRetryDelay;
437950
+ let configSaveFailed = false;
437951
+ try {
437952
+ saveGlobalConfig((current) => ({
437953
+ ...current,
437954
+ officialMarketplaceAutoInstallAttempted: true,
437955
+ officialMarketplaceAutoInstalled: false,
437956
+ officialMarketplaceAutoInstallFailReason: "git_unavailable",
437957
+ officialMarketplaceAutoInstallRetryCount: retryCount,
437958
+ officialMarketplaceAutoInstallLastAttemptTime: now2,
437959
+ officialMarketplaceAutoInstallNextRetryTime: nextRetryTime
437960
+ }));
437961
+ } catch (saveError) {
437962
+ configSaveFailed = true;
437963
+ const configError = toError(saveError);
437964
+ logError2(configError);
437965
+ logForDebugging(`Failed to save marketplace auto-install git_unavailable state: ${saveError}`, { level: "error" });
437966
+ }
437967
+ logEvent("tengu_official_marketplace_auto_install", {
437968
+ installed: false,
437969
+ skipped: true,
437970
+ git_unavailable: true,
437971
+ retry_count: retryCount
437972
+ });
437973
+ return {
437974
+ installed: false,
437975
+ skipped: true,
437976
+ reason: "git_unavailable",
437977
+ configSaveFailed
437978
+ };
437979
+ }
437980
+ logForDebugging("Attempting to auto-install official marketplace");
437981
+ await addMarketplaceSource(CLAUDE_MARKETPLACE_SOURCE);
437982
+ logForDebugging("Successfully auto-installed official marketplace");
437983
+ const previousRetryCount = config3.officialMarketplaceAutoInstallRetryCount || 0;
437984
+ saveGlobalConfig((current) => ({
437985
+ ...current,
437986
+ officialMarketplaceAutoInstallAttempted: true,
437987
+ officialMarketplaceAutoInstalled: true,
437988
+ officialMarketplaceAutoInstallFailReason: undefined,
437989
+ officialMarketplaceAutoInstallRetryCount: undefined,
437990
+ officialMarketplaceAutoInstallLastAttemptTime: undefined,
437991
+ officialMarketplaceAutoInstallNextRetryTime: undefined
437992
+ }));
437993
+ logEvent("tengu_official_marketplace_auto_install", {
437994
+ installed: true,
437995
+ skipped: false,
437996
+ retry_count: previousRetryCount
437997
+ });
437998
+ return { installed: true, skipped: false };
437999
+ } catch (error42) {
438000
+ const errorMessage2 = error42 instanceof Error ? error42.message : String(error42);
438001
+ if (errorMessage2.includes("xcrun: error:")) {
438002
+ markGitUnavailable();
438003
+ logForDebugging("Official marketplace auto-install: git is a non-functional macOS xcrun shim, treating as git_unavailable");
438004
+ logEvent("tengu_official_marketplace_auto_install", {
438005
+ installed: false,
438006
+ skipped: true,
438007
+ git_unavailable: true,
438008
+ macos_xcrun_shim: true
438009
+ });
438010
+ return {
438011
+ installed: false,
438012
+ skipped: true,
438013
+ reason: "git_unavailable"
438014
+ };
438015
+ }
438016
+ logForDebugging(`Failed to auto-install official marketplace: ${errorMessage2}`, { level: "error" });
438017
+ logError2(toError(error42));
438018
+ const retryCount = (config3.officialMarketplaceAutoInstallRetryCount || 0) + 1;
438019
+ const now2 = Date.now();
438020
+ const nextRetryDelay = calculateNextRetryDelay(retryCount);
438021
+ const nextRetryTime = now2 + nextRetryDelay;
438022
+ let configSaveFailed = false;
438023
+ try {
438024
+ saveGlobalConfig((current) => ({
438025
+ ...current,
438026
+ officialMarketplaceAutoInstallAttempted: true,
438027
+ officialMarketplaceAutoInstalled: false,
438028
+ officialMarketplaceAutoInstallFailReason: "unknown",
438029
+ officialMarketplaceAutoInstallRetryCount: retryCount,
438030
+ officialMarketplaceAutoInstallLastAttemptTime: now2,
438031
+ officialMarketplaceAutoInstallNextRetryTime: nextRetryTime
438032
+ }));
438033
+ } catch (saveError) {
438034
+ configSaveFailed = true;
438035
+ const configError = toError(saveError);
438036
+ logError2(configError);
438037
+ logForDebugging(`Failed to save marketplace auto-install failure state: ${saveError}`, { level: "error" });
438038
+ }
438039
+ logEvent("tengu_official_marketplace_auto_install", {
438040
+ installed: false,
438041
+ skipped: true,
438042
+ failed: true,
438043
+ retry_count: retryCount
438044
+ });
438045
+ return {
438046
+ installed: false,
438047
+ skipped: true,
438048
+ reason: "unknown",
438049
+ configSaveFailed
438050
+ };
438051
+ }
438052
+ }
438053
+ var RETRY_CONFIG, verbooMarketplaceAutoInstallPromise;
438054
+ var init_officialMarketplaceStartupCheck = __esm(() => {
438055
+ init_growthbook();
438056
+ init_config7();
438057
+ init_debug();
438058
+ init_envUtils();
438059
+ init_errors();
438060
+ init_log3();
438061
+ init_gitAvailability();
438062
+ init_marketplaceHelpers();
438063
+ init_marketplaceManager();
438064
+ init_officialMarketplace();
438065
+ init_officialMarketplaceGcs();
438066
+ RETRY_CONFIG = {
438067
+ MAX_ATTEMPTS: 10,
438068
+ INITIAL_DELAY_MS: 60 * 60 * 1000,
438069
+ BACKOFF_MULTIPLIER: 2,
438070
+ MAX_DELAY_MS: 7 * 24 * 60 * 60 * 1000
438071
+ };
438072
+ });
438073
+
437659
438074
  // src/utils/plugins/pluginStartupCheck.ts
437660
438075
  var exports_pluginStartupCheck = {};
437661
438076
  __export(exports_pluginStartupCheck, {
@@ -437667,7 +438082,7 @@ __export(exports_pluginStartupCheck, {
437667
438082
  findMissingPlugins: () => findMissingPlugins,
437668
438083
  checkEnabledPlugins: () => checkEnabledPlugins
437669
438084
  });
437670
- import { join as join114 } from "path";
438085
+ import { join as join115 } from "path";
437671
438086
  async function checkEnabledPlugins() {
437672
438087
  const settings = getInitialSettings();
437673
438088
  const enabledPlugins = [];
@@ -437802,7 +438217,7 @@ async function installSelectedPlugins(pluginsToInstall, onProgress, scope = "use
437802
438217
  } else {
437803
438218
  registerPluginInstallation({
437804
438219
  pluginId,
437805
- installPath: join114(marketplaceInstallLocation, entry.source),
438220
+ installPath: join115(marketplaceInstallLocation, entry.source),
437806
438221
  version: entry.version
437807
438222
  }, scope, projectPath);
437808
438223
  }
@@ -437834,7 +438249,7 @@ var init_pluginStartupCheck = __esm(() => {
437834
438249
  });
437835
438250
 
437836
438251
  // src/services/plugins/pluginOperations.ts
437837
- import { dirname as dirname52, join as join115 } from "path";
438252
+ import { dirname as dirname52, join as join116 } from "path";
437838
438253
  function assertInstallableScope(scope) {
437839
438254
  if (!VALID_INSTALLABLE_SCOPES.includes(scope)) {
437840
438255
  throw new Error(`Invalid scope "${scope}". Must be one of: ${VALID_INSTALLABLE_SCOPES.join(", ")}`);
@@ -437920,6 +438335,16 @@ function getPluginInstallationFromV2(pluginId) {
437920
438335
  async function installPluginOp(plugin, scope = "user") {
437921
438336
  assertInstallableScope(scope);
437922
438337
  const { name: pluginName, marketplace: marketplaceName } = parsePluginIdentifier(plugin);
438338
+ if (marketplaceName?.toLowerCase() === VERBOO_MARKETPLACE_NAME) {
438339
+ try {
438340
+ await prepareVerbooMarketplaceForExplicitInstall();
438341
+ } catch (error42) {
438342
+ return {
438343
+ success: false,
438344
+ message: `Could not refresh Verboo marketplace before installing "${pluginName}": ` + errorMessage(error42)
438345
+ };
438346
+ }
438347
+ }
437923
438348
  let foundPlugin;
437924
438349
  let foundMarketplace;
437925
438350
  let marketplaceInstallLocation;
@@ -438312,7 +438737,7 @@ async function performPluginUpdate({
438312
438737
  throw e2;
438313
438738
  }
438314
438739
  const marketplaceDir = marketplaceStats.isDirectory() ? marketplaceInstallLocation : dirname52(marketplaceInstallLocation);
438315
- sourcePath = join115(marketplaceDir, entry.source);
438740
+ sourcePath = join116(marketplaceDir, entry.source);
438316
438741
  try {
438317
438742
  await fs3.stat(sourcePath);
438318
438743
  } catch (e2) {
@@ -438327,7 +438752,7 @@ async function performPluginUpdate({
438327
438752
  throw e2;
438328
438753
  }
438329
438754
  let pluginManifest;
438330
- const manifestPath = join115(sourcePath, ".claude-plugin", "plugin.json");
438755
+ const manifestPath = join116(sourcePath, ".claude-plugin", "plugin.json");
438331
438756
  try {
438332
438757
  pluginManifest = await loadPluginManifest(manifestPath, entry.name, entry.source);
438333
438758
  } catch {}
@@ -438385,6 +438810,8 @@ var init_pluginOperations = __esm(() => {
438385
438810
  init_dependencyResolver();
438386
438811
  init_installedPluginsManager();
438387
438812
  init_marketplaceManager();
438813
+ init_officialMarketplace();
438814
+ init_officialMarketplaceStartupCheck();
438388
438815
  init_pluginDirectories();
438389
438816
  init_pluginIdentifier();
438390
438817
  init_pluginInstallationHelpers();
@@ -438631,383 +439058,6 @@ var init_lspRecommendation = __esm(() => {
438631
439058
  init_officialMarketplace();
438632
439059
  });
438633
439060
 
438634
- // src/utils/plugins/officialMarketplaceStartupCheck.ts
438635
- import { join as join116 } from "path";
438636
- function isOfficialMarketplaceAutoInstallDisabled() {
438637
- return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_OFFICIAL_MARKETPLACE_AUTOINSTALL);
438638
- }
438639
- function calculateNextRetryDelay(retryCount) {
438640
- const delay = RETRY_CONFIG.INITIAL_DELAY_MS * Math.pow(RETRY_CONFIG.BACKOFF_MULTIPLIER, retryCount);
438641
- return Math.min(delay, RETRY_CONFIG.MAX_DELAY_MS);
438642
- }
438643
- function shouldRetryInstallation(config3) {
438644
- if (!config3.officialMarketplaceAutoInstallAttempted) {
438645
- return true;
438646
- }
438647
- const failReason = config3.officialMarketplaceAutoInstallFailReason;
438648
- const retryCount = config3.officialMarketplaceAutoInstallRetryCount || 0;
438649
- const nextRetryTime = config3.officialMarketplaceAutoInstallNextRetryTime;
438650
- const now2 = Date.now();
438651
- if (retryCount >= RETRY_CONFIG.MAX_ATTEMPTS) {
438652
- return false;
438653
- }
438654
- if (failReason === "policy_blocked") {
438655
- return false;
438656
- }
438657
- if (nextRetryTime && now2 < nextRetryTime) {
438658
- return false;
438659
- }
438660
- return failReason === "unknown" || failReason === "git_unavailable" || failReason === "gcs_unavailable" || failReason === undefined;
438661
- }
438662
- function shouldRetryNativeMarketplaceInstallation(state2) {
438663
- if (!state2?.attempted)
438664
- return true;
438665
- if ((state2.retryCount ?? 0) >= RETRY_CONFIG.MAX_ATTEMPTS)
438666
- return false;
438667
- if (state2.failReason === "policy_blocked")
438668
- return false;
438669
- if (state2.nextRetryTime && Date.now() < state2.nextRetryTime)
438670
- return false;
438671
- return true;
438672
- }
438673
- function saveNativeMarketplaceAutoInstallState(name, update) {
438674
- saveGlobalConfig((current) => ({
438675
- ...current,
438676
- nativeMarketplaceAutoInstall: {
438677
- ...current.nativeMarketplaceAutoInstall,
438678
- [name]: {
438679
- ...current.nativeMarketplaceAutoInstall?.[name],
438680
- ...update
438681
- }
438682
- }
438683
- }));
438684
- }
438685
- async function checkAndInstallVerbooMarketplace() {
438686
- const config3 = getGlobalConfig();
438687
- const state2 = config3.nativeMarketplaceAutoInstall?.[VERBOO_MARKETPLACE_NAME];
438688
- try {
438689
- const knownMarketplaces = await loadKnownMarketplacesConfig();
438690
- if (knownMarketplaces[VERBOO_MARKETPLACE_NAME]) {
438691
- saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
438692
- attempted: true,
438693
- installed: true,
438694
- failReason: undefined,
438695
- retryCount: undefined,
438696
- lastAttemptTime: undefined,
438697
- nextRetryTime: undefined
438698
- });
438699
- return { installed: false, skipped: true, reason: "already_installed" };
438700
- }
438701
- if (!shouldRetryNativeMarketplaceInstallation(state2)) {
438702
- return {
438703
- installed: false,
438704
- skipped: true,
438705
- reason: state2?.failReason ?? "already_attempted"
438706
- };
438707
- }
438708
- if (isOfficialMarketplaceAutoInstallDisabled()) {
438709
- saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
438710
- attempted: true,
438711
- installed: false,
438712
- failReason: "policy_blocked"
438713
- });
438714
- return { installed: false, skipped: true, reason: "policy_blocked" };
438715
- }
438716
- if (!isSourceAllowedByPolicy(VERBOO_MARKETPLACE_SOURCE)) {
438717
- saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
438718
- attempted: true,
438719
- installed: false,
438720
- failReason: "policy_blocked"
438721
- });
438722
- return { installed: false, skipped: true, reason: "policy_blocked" };
438723
- }
438724
- logForDebugging("Attempting to auto-install Verboo marketplace");
438725
- await addMarketplaceSource(VERBOO_MARKETPLACE_SOURCE);
438726
- saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
438727
- attempted: true,
438728
- installed: true,
438729
- failReason: undefined,
438730
- retryCount: undefined,
438731
- lastAttemptTime: undefined,
438732
- nextRetryTime: undefined
438733
- });
438734
- logEvent("tengu_official_marketplace_auto_install", {
438735
- installed: true,
438736
- skipped: false,
438737
- verboo_marketplace: true
438738
- });
438739
- return { installed: true, skipped: false };
438740
- } catch (error42) {
438741
- const retryCount = (state2?.retryCount ?? 0) + 1;
438742
- const now2 = Date.now();
438743
- let configSaveFailed = false;
438744
- try {
438745
- saveNativeMarketplaceAutoInstallState(VERBOO_MARKETPLACE_NAME, {
438746
- attempted: true,
438747
- installed: false,
438748
- failReason: "unknown",
438749
- retryCount,
438750
- lastAttemptTime: now2,
438751
- nextRetryTime: now2 + calculateNextRetryDelay(retryCount)
438752
- });
438753
- } catch (saveError) {
438754
- configSaveFailed = true;
438755
- logError2(toError(saveError));
438756
- }
438757
- logForDebugging(`Failed to auto-install Verboo marketplace: ${error42 instanceof Error ? error42.message : String(error42)}`, { level: "error" });
438758
- logError2(toError(error42));
438759
- logEvent("tengu_official_marketplace_auto_install", {
438760
- installed: false,
438761
- skipped: true,
438762
- failed: true,
438763
- verboo_marketplace: true,
438764
- retry_count: retryCount
438765
- });
438766
- return {
438767
- installed: false,
438768
- skipped: true,
438769
- reason: "unknown",
438770
- configSaveFailed
438771
- };
438772
- }
438773
- }
438774
- async function checkAndInstallNativeMarketplaces() {
438775
- const verboo = await checkAndInstallVerbooMarketplace();
438776
- const claude = await checkAndInstallOfficialMarketplace();
438777
- return { verboo, claude };
438778
- }
438779
- async function checkAndInstallOfficialMarketplace() {
438780
- const config3 = getGlobalConfig();
438781
- try {
438782
- const knownMarketplaces = await loadKnownMarketplacesConfig();
438783
- if (knownMarketplaces[CLAUDE_MARKETPLACE_NAME]) {
438784
- logForDebugging(`Official marketplace '${CLAUDE_MARKETPLACE_NAME}' already installed, skipping`);
438785
- saveGlobalConfig((current) => ({
438786
- ...current,
438787
- officialMarketplaceAutoInstallAttempted: true,
438788
- officialMarketplaceAutoInstalled: true
438789
- }));
438790
- return { installed: false, skipped: true, reason: "already_installed" };
438791
- }
438792
- if (!shouldRetryInstallation(config3)) {
438793
- const reason = config3.officialMarketplaceAutoInstallFailReason ?? "already_attempted";
438794
- logForDebugging(`Official marketplace auto-install skipped: ${reason}`);
438795
- return {
438796
- installed: false,
438797
- skipped: true,
438798
- reason
438799
- };
438800
- }
438801
- if (isOfficialMarketplaceAutoInstallDisabled()) {
438802
- logForDebugging("Official marketplace auto-install disabled via env var, skipping");
438803
- saveGlobalConfig((current) => ({
438804
- ...current,
438805
- officialMarketplaceAutoInstallAttempted: true,
438806
- officialMarketplaceAutoInstalled: false,
438807
- officialMarketplaceAutoInstallFailReason: "policy_blocked"
438808
- }));
438809
- logEvent("tengu_official_marketplace_auto_install", {
438810
- installed: false,
438811
- skipped: true,
438812
- policy_blocked: true
438813
- });
438814
- return { installed: false, skipped: true, reason: "policy_blocked" };
438815
- }
438816
- if (!isSourceAllowedByPolicy(CLAUDE_MARKETPLACE_SOURCE)) {
438817
- logForDebugging("Official marketplace blocked by enterprise policy, skipping");
438818
- saveGlobalConfig((current) => ({
438819
- ...current,
438820
- officialMarketplaceAutoInstallAttempted: true,
438821
- officialMarketplaceAutoInstalled: false,
438822
- officialMarketplaceAutoInstallFailReason: "policy_blocked"
438823
- }));
438824
- logEvent("tengu_official_marketplace_auto_install", {
438825
- installed: false,
438826
- skipped: true,
438827
- policy_blocked: true
438828
- });
438829
- return { installed: false, skipped: true, reason: "policy_blocked" };
438830
- }
438831
- const cacheDir = getMarketplacesCacheDir();
438832
- const installLocation = join116(cacheDir, CLAUDE_MARKETPLACE_NAME);
438833
- const gcsSha = await fetchOfficialMarketplaceFromGcs(installLocation, cacheDir);
438834
- if (gcsSha !== null) {
438835
- const known = await loadKnownMarketplacesConfig();
438836
- known[CLAUDE_MARKETPLACE_NAME] = {
438837
- source: CLAUDE_MARKETPLACE_SOURCE,
438838
- installLocation,
438839
- lastUpdated: new Date().toISOString()
438840
- };
438841
- await saveKnownMarketplacesConfig(known);
438842
- saveGlobalConfig((current) => ({
438843
- ...current,
438844
- officialMarketplaceAutoInstallAttempted: true,
438845
- officialMarketplaceAutoInstalled: true,
438846
- officialMarketplaceAutoInstallFailReason: undefined,
438847
- officialMarketplaceAutoInstallRetryCount: undefined,
438848
- officialMarketplaceAutoInstallLastAttemptTime: undefined,
438849
- officialMarketplaceAutoInstallNextRetryTime: undefined
438850
- }));
438851
- logEvent("tengu_official_marketplace_auto_install", {
438852
- installed: true,
438853
- skipped: false,
438854
- via_gcs: true
438855
- });
438856
- return { installed: true, skipped: false };
438857
- }
438858
- if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_plugin_official_mkt_git_fallback", true)) {
438859
- logForDebugging("Official marketplace GCS failed; git fallback disabled by flag — skipping install");
438860
- const retryCount = (config3.officialMarketplaceAutoInstallRetryCount || 0) + 1;
438861
- const now2 = Date.now();
438862
- const nextRetryTime = now2 + calculateNextRetryDelay(retryCount);
438863
- saveGlobalConfig((current) => ({
438864
- ...current,
438865
- officialMarketplaceAutoInstallAttempted: true,
438866
- officialMarketplaceAutoInstalled: false,
438867
- officialMarketplaceAutoInstallFailReason: "gcs_unavailable",
438868
- officialMarketplaceAutoInstallRetryCount: retryCount,
438869
- officialMarketplaceAutoInstallLastAttemptTime: now2,
438870
- officialMarketplaceAutoInstallNextRetryTime: nextRetryTime
438871
- }));
438872
- logEvent("tengu_official_marketplace_auto_install", {
438873
- installed: false,
438874
- skipped: true,
438875
- gcs_unavailable: true,
438876
- retry_count: retryCount
438877
- });
438878
- return { installed: false, skipped: true, reason: "gcs_unavailable" };
438879
- }
438880
- const gitAvailable = await checkGitAvailable();
438881
- if (!gitAvailable) {
438882
- logForDebugging("Git not available, skipping official marketplace auto-install");
438883
- const retryCount = (config3.officialMarketplaceAutoInstallRetryCount || 0) + 1;
438884
- const now2 = Date.now();
438885
- const nextRetryDelay = calculateNextRetryDelay(retryCount);
438886
- const nextRetryTime = now2 + nextRetryDelay;
438887
- let configSaveFailed = false;
438888
- try {
438889
- saveGlobalConfig((current) => ({
438890
- ...current,
438891
- officialMarketplaceAutoInstallAttempted: true,
438892
- officialMarketplaceAutoInstalled: false,
438893
- officialMarketplaceAutoInstallFailReason: "git_unavailable",
438894
- officialMarketplaceAutoInstallRetryCount: retryCount,
438895
- officialMarketplaceAutoInstallLastAttemptTime: now2,
438896
- officialMarketplaceAutoInstallNextRetryTime: nextRetryTime
438897
- }));
438898
- } catch (saveError) {
438899
- configSaveFailed = true;
438900
- const configError = toError(saveError);
438901
- logError2(configError);
438902
- logForDebugging(`Failed to save marketplace auto-install git_unavailable state: ${saveError}`, { level: "error" });
438903
- }
438904
- logEvent("tengu_official_marketplace_auto_install", {
438905
- installed: false,
438906
- skipped: true,
438907
- git_unavailable: true,
438908
- retry_count: retryCount
438909
- });
438910
- return {
438911
- installed: false,
438912
- skipped: true,
438913
- reason: "git_unavailable",
438914
- configSaveFailed
438915
- };
438916
- }
438917
- logForDebugging("Attempting to auto-install official marketplace");
438918
- await addMarketplaceSource(CLAUDE_MARKETPLACE_SOURCE);
438919
- logForDebugging("Successfully auto-installed official marketplace");
438920
- const previousRetryCount = config3.officialMarketplaceAutoInstallRetryCount || 0;
438921
- saveGlobalConfig((current) => ({
438922
- ...current,
438923
- officialMarketplaceAutoInstallAttempted: true,
438924
- officialMarketplaceAutoInstalled: true,
438925
- officialMarketplaceAutoInstallFailReason: undefined,
438926
- officialMarketplaceAutoInstallRetryCount: undefined,
438927
- officialMarketplaceAutoInstallLastAttemptTime: undefined,
438928
- officialMarketplaceAutoInstallNextRetryTime: undefined
438929
- }));
438930
- logEvent("tengu_official_marketplace_auto_install", {
438931
- installed: true,
438932
- skipped: false,
438933
- retry_count: previousRetryCount
438934
- });
438935
- return { installed: true, skipped: false };
438936
- } catch (error42) {
438937
- const errorMessage2 = error42 instanceof Error ? error42.message : String(error42);
438938
- if (errorMessage2.includes("xcrun: error:")) {
438939
- markGitUnavailable();
438940
- logForDebugging("Official marketplace auto-install: git is a non-functional macOS xcrun shim, treating as git_unavailable");
438941
- logEvent("tengu_official_marketplace_auto_install", {
438942
- installed: false,
438943
- skipped: true,
438944
- git_unavailable: true,
438945
- macos_xcrun_shim: true
438946
- });
438947
- return {
438948
- installed: false,
438949
- skipped: true,
438950
- reason: "git_unavailable"
438951
- };
438952
- }
438953
- logForDebugging(`Failed to auto-install official marketplace: ${errorMessage2}`, { level: "error" });
438954
- logError2(toError(error42));
438955
- const retryCount = (config3.officialMarketplaceAutoInstallRetryCount || 0) + 1;
438956
- const now2 = Date.now();
438957
- const nextRetryDelay = calculateNextRetryDelay(retryCount);
438958
- const nextRetryTime = now2 + nextRetryDelay;
438959
- let configSaveFailed = false;
438960
- try {
438961
- saveGlobalConfig((current) => ({
438962
- ...current,
438963
- officialMarketplaceAutoInstallAttempted: true,
438964
- officialMarketplaceAutoInstalled: false,
438965
- officialMarketplaceAutoInstallFailReason: "unknown",
438966
- officialMarketplaceAutoInstallRetryCount: retryCount,
438967
- officialMarketplaceAutoInstallLastAttemptTime: now2,
438968
- officialMarketplaceAutoInstallNextRetryTime: nextRetryTime
438969
- }));
438970
- } catch (saveError) {
438971
- configSaveFailed = true;
438972
- const configError = toError(saveError);
438973
- logError2(configError);
438974
- logForDebugging(`Failed to save marketplace auto-install failure state: ${saveError}`, { level: "error" });
438975
- }
438976
- logEvent("tengu_official_marketplace_auto_install", {
438977
- installed: false,
438978
- skipped: true,
438979
- failed: true,
438980
- retry_count: retryCount
438981
- });
438982
- return {
438983
- installed: false,
438984
- skipped: true,
438985
- reason: "unknown",
438986
- configSaveFailed
438987
- };
438988
- }
438989
- }
438990
- var RETRY_CONFIG;
438991
- var init_officialMarketplaceStartupCheck = __esm(() => {
438992
- init_growthbook();
438993
- init_config7();
438994
- init_debug();
438995
- init_envUtils();
438996
- init_errors();
438997
- init_log3();
438998
- init_gitAvailability();
438999
- init_marketplaceHelpers();
439000
- init_marketplaceManager();
439001
- init_officialMarketplace();
439002
- init_officialMarketplaceGcs();
439003
- RETRY_CONFIG = {
439004
- MAX_ATTEMPTS: 10,
439005
- INITIAL_DELAY_MS: 60 * 60 * 1000,
439006
- BACKOFF_MULTIPLIER: 2,
439007
- MAX_DELAY_MS: 7 * 24 * 60 * 60 * 1000
439008
- };
439009
- });
439010
-
439011
439061
  // src/state/pluginCommandsStore.ts
439012
439062
  function setPluginCommandsState(commands) {
439013
439063
  pluginCommandsStore.setState(() => [...commands]);
@@ -450889,6 +450939,10 @@ async function updatePlugin(pluginId, installations) {
450889
450939
  return wasUpdated ? pluginId : null;
450890
450940
  }
450891
450941
  async function updatePluginsForMarketplaces(marketplaceNames) {
450942
+ const pluginUpdateMarketplaces = new Set(Array.from(marketplaceNames).filter((name) => name.toLowerCase() !== VERBOO_MARKETPLACE_NAME));
450943
+ if (pluginUpdateMarketplaces.size === 0) {
450944
+ return [];
450945
+ }
450892
450946
  const installedPlugins = loadInstalledPluginsFromDisk();
450893
450947
  const pluginIds = Object.keys(installedPlugins.plugins);
450894
450948
  if (pluginIds.length === 0) {
@@ -450896,7 +450950,7 @@ async function updatePluginsForMarketplaces(marketplaceNames) {
450896
450950
  }
450897
450951
  const results = await Promise.allSettled(pluginIds.map(async (pluginId) => {
450898
450952
  const { marketplace } = parsePluginIdentifier(pluginId);
450899
- if (!marketplace || !marketplaceNames.has(marketplace.toLowerCase())) {
450953
+ if (!marketplace || !pluginUpdateMarketplaces.has(marketplace.toLowerCase())) {
450900
450954
  return null;
450901
450955
  }
450902
450956
  const allInstallations = installedPlugins.plugins[pluginId];
@@ -450921,11 +450975,18 @@ function autoUpdateMarketplacesAndPluginsInBackground() {
450921
450975
  return;
450922
450976
  }
450923
450977
  try {
450978
+ let verbooInstalledThisRun = false;
450979
+ try {
450980
+ const result = await checkAndInstallVerbooMarketplace();
450981
+ verbooInstalledThisRun = result.installed;
450982
+ } catch (error42) {
450983
+ logForDebugging(`Plugin autoupdate: failed to prepare Verboo marketplace: ${errorMessage(error42)}`, { level: "warn" });
450984
+ }
450924
450985
  const autoUpdateEnabledMarketplaces = await getAutoUpdateEnabledMarketplaces();
450925
450986
  if (autoUpdateEnabledMarketplaces.size === 0) {
450926
450987
  return;
450927
450988
  }
450928
- const refreshResults = await Promise.allSettled(Array.from(autoUpdateEnabledMarketplaces).map(async (name) => {
450989
+ const refreshResults = await Promise.allSettled(Array.from(autoUpdateEnabledMarketplaces).filter((name) => !(verbooInstalledThisRun && name.toLowerCase() === VERBOO_MARKETPLACE_NAME)).map(async (name) => {
450929
450990
  try {
450930
450991
  await refreshMarketplace(name, undefined, {
450931
450992
  disableCredentialHelper: true
@@ -450938,7 +450999,7 @@ function autoUpdateMarketplacesAndPluginsInBackground() {
450938
450999
  if (failures.length > 0) {
450939
451000
  logForDebugging(`Plugin autoupdate: ${failures.length} marketplace refresh(es) failed`, { level: "warn" });
450940
451001
  }
450941
- logForDebugging("Plugin autoupdate: checking installed plugins");
451002
+ logForDebugging("Plugin autoupdate: checking eligible installed plugins");
450942
451003
  const updatedPlugins = await updatePlugins(autoUpdateEnabledMarketplaces);
450943
451004
  if (updatedPlugins.length > 0) {
450944
451005
  if (pluginUpdateCallback) {
@@ -450961,6 +451022,8 @@ var init_pluginAutoupdate = __esm(() => {
450961
451022
  init_log3();
450962
451023
  init_installedPluginsManager();
450963
451024
  init_marketplaceManager();
451025
+ init_officialMarketplace();
451026
+ init_officialMarketplaceStartupCheck();
450964
451027
  init_pluginIdentifier();
450965
451028
  init_schemas5();
450966
451029
  });
@@ -451639,7 +451702,7 @@ function ManageMarketplaces({
451639
451702
  marginTop: 1,
451640
451703
  children: /* @__PURE__ */ jsx_runtime246.jsx(ThemedText, {
451641
451704
  dimColor: true,
451642
- children: "Auto-update enabled. Claude Code will automatically update this marketplace and its installed plugins."
451705
+ children: selectedMarketplace.name === VERBOO_MARKETPLACE_NAME ? "Auto-update enabled. Verboo Code will automatically update this marketplace." : "Auto-update enabled. Verboo Code will automatically update this marketplace and its installed plugins."
451643
451706
  })
451644
451707
  }),
451645
451708
  /* @__PURE__ */ jsx_runtime246.jsx(ThemedBox_default, {
@@ -486429,7 +486492,7 @@ var init_bridge_kick = __esm(() => {
486429
486492
  var call63 = async () => {
486430
486493
  return {
486431
486494
  type: "text",
486432
- value: `${"99.0.0"} (built ${"2026-07-15T02:08:38.282Z"})`
486495
+ value: `${"99.0.0"} (built ${"2026-07-15T13:23:40.197Z"})`
486433
486496
  };
486434
486497
  }, version2, version_default;
486435
486498
  var init_version2 = __esm(() => {
@@ -516647,7 +516710,7 @@ var init_schemas5 = __esm(() => {
516647
516710
  source: MarketplaceSourceSchema().describe("Where to fetch the marketplace from"),
516648
516711
  installLocation: exports_external.string().describe("Local cache path where marketplace manifest is stored"),
516649
516712
  lastUpdated: exports_external.string().describe("ISO 8601 timestamp of last marketplace refresh"),
516650
- autoUpdate: exports_external.boolean().optional().describe("Whether to automatically update this marketplace and its installed plugins on startup")
516713
+ autoUpdate: exports_external.boolean().optional().describe("Whether to automatically refresh this marketplace on startup")
516651
516714
  }));
516652
516715
  KnownMarketplacesFileSchema = lazySchema(() => exports_external.record(exports_external.string(), KnownMarketplaceSchema()));
516653
516716
  });
@@ -519502,7 +519565,7 @@ function printStartupScreen(modelOverride) {
519502
519565
  const home = process.env.HOME || process.env.USERPROFILE || "";
519503
519566
  const cwd2 = process.cwd();
519504
519567
  const displayCwd = home && cwd2.startsWith(home) ? `~${cwd2.slice(home.length)}` : cwd2;
519505
- const version3 = "0.13.3";
519568
+ const version3 = "0.13.4";
519506
519569
  const bold2 = `${ESC4}1m`;
519507
519570
  const PURPLE = rgb3(...ACCENT);
519508
519571
  const SOFT = rgb3(...CREAM);
@@ -537794,7 +537857,7 @@ var init_routerRateLimitHook = __esm(() => {
537794
537857
  function getSemverPart(version3) {
537795
537858
  return `${import_semver13.major(version3, { loose: true })}.${import_semver13.minor(version3, { loose: true })}.${import_semver13.patch(version3, { loose: true })}`;
537796
537859
  }
537797
- function useUpdateNotification(updatedVersion, initialVersion = "0.13.3") {
537860
+ function useUpdateNotification(updatedVersion, initialVersion = "0.13.4") {
537798
537861
  const [lastNotifiedSemver, setLastNotifiedSemver] = import_react225.useState(() => getSemverPart(initialVersion));
537799
537862
  const [pendingNotification2, setPendingNotification] = import_react225.useState(null);
537800
537863
  if (updatedVersion) {
@@ -537834,7 +537897,7 @@ function AutoUpdater({
537834
537897
  return;
537835
537898
  }
537836
537899
  if (false) {}
537837
- const currentVersion = "0.13.3";
537900
+ const currentVersion = "0.13.4";
537838
537901
  const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
537839
537902
  let latestVersion = await getLatestVersion(channel2);
537840
537903
  const isDisabled = isAutoUpdaterDisabled();
@@ -538187,17 +538250,17 @@ function PackageManagerAutoUpdater(t0) {
538187
538250
  const maxVersion = await getMaxVersion();
538188
538251
  if (maxVersion && latest && gt(latest, maxVersion)) {
538189
538252
  logForDebugging(`PackageManagerAutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latest} to ${maxVersion}`);
538190
- if (gte("0.13.3", maxVersion)) {
538191
- logForDebugging(`PackageManagerAutoUpdater: current version ${"0.13.3"} is already at or above maxVersion ${maxVersion}, skipping update`);
538253
+ if (gte("0.13.4", maxVersion)) {
538254
+ logForDebugging(`PackageManagerAutoUpdater: current version ${"0.13.4"} is already at or above maxVersion ${maxVersion}, skipping update`);
538192
538255
  setUpdateAvailable(false);
538193
538256
  return;
538194
538257
  }
538195
538258
  latest = maxVersion;
538196
538259
  }
538197
- const hasUpdate = latest && !gte("0.13.3", latest) && !shouldSkipVersion(latest);
538260
+ const hasUpdate = latest && !gte("0.13.4", latest) && !shouldSkipVersion(latest);
538198
538261
  setUpdateAvailable(!!hasUpdate);
538199
538262
  if (hasUpdate) {
538200
- logForDebugging(`PackageManagerAutoUpdater: Update available ${"0.13.3"} -> ${latest}`);
538263
+ logForDebugging(`PackageManagerAutoUpdater: Update available ${"0.13.4"} -> ${latest}`);
538201
538264
  }
538202
538265
  };
538203
538266
  $2[0] = t1;
@@ -538231,7 +538294,7 @@ function PackageManagerAutoUpdater(t0) {
538231
538294
  wrap: "truncate",
538232
538295
  children: [
538233
538296
  "currentVersion: ",
538234
- "0.13.3"
538297
+ "0.13.4"
538235
538298
  ]
538236
538299
  });
538237
538300
  $2[3] = verbose;
@@ -554182,10 +554245,10 @@ async function autoUpdateCliInBackground() {
554182
554245
  return;
554183
554246
  const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
554184
554247
  const latest = await getLatestVersion(channel2);
554185
- if (!latest || gte("0.13.3", latest))
554248
+ if (!latest || gte("0.13.4", latest))
554186
554249
  return;
554187
554250
  writeToStdout(`
554188
- Nova versão disponível: ${latest} (atual: ${"0.13.3"})
554251
+ Nova versão disponível: ${latest} (atual: ${"0.13.4"})
554189
554252
  `);
554190
554253
  writeToStdout(`Atualizando automaticamente...
554191
554254
  `);
@@ -571879,7 +571942,7 @@ function WelcomeV2() {
571879
571942
  dimColor: true,
571880
571943
  children: [
571881
571944
  "v",
571882
- "0.13.3",
571945
+ "0.13.4",
571883
571946
  " "
571884
571947
  ]
571885
571948
  })
@@ -572066,7 +572129,7 @@ function WelcomeV2() {
572066
572129
  dimColor: true,
572067
572130
  children: [
572068
572131
  "v",
572069
- "0.13.3",
572132
+ "0.13.4",
572070
572133
  " "
572071
572134
  ]
572072
572135
  })
@@ -572282,7 +572345,7 @@ function AppleTerminalWelcomeV2(t0) {
572282
572345
  dimColor: true,
572283
572346
  children: [
572284
572347
  "v",
572285
- "0.13.3",
572348
+ "0.13.4",
572286
572349
  " "
572287
572350
  ]
572288
572351
  });
@@ -572491,7 +572554,7 @@ function AppleTerminalWelcomeV2(t0) {
572491
572554
  dimColor: true,
572492
572555
  children: [
572493
572556
  "v",
572494
- "0.13.3",
572557
+ "0.13.4",
572495
572558
  " "
572496
572559
  ]
572497
572560
  });
@@ -589893,7 +589956,7 @@ __export(exports_update, {
589893
589956
  });
589894
589957
  async function update() {
589895
589958
  logEvent("tengu_update_check", {});
589896
- writeToStdout(`Current version: ${"0.13.3"}
589959
+ writeToStdout(`Current version: ${"0.13.4"}
589897
589960
  `);
589898
589961
  const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
589899
589962
  writeToStdout(`Checking for updates to ${channel2} version...
@@ -589978,8 +590041,8 @@ async function update() {
589978
590041
  writeToStdout(`Verboo Code is managed by Homebrew.
589979
590042
  `);
589980
590043
  const latest = await getLatestVersion(channel2);
589981
- if (latest && !gte("0.13.3", latest)) {
589982
- writeToStdout(`Update available: ${"0.13.3"} → ${latest}
590044
+ if (latest && !gte("0.13.4", latest)) {
590045
+ writeToStdout(`Update available: ${"0.13.4"} → ${latest}
589983
590046
  `);
589984
590047
  writeToStdout(`
589985
590048
  `);
@@ -589995,8 +590058,8 @@ async function update() {
589995
590058
  writeToStdout(`Verboo Code is managed by winget.
589996
590059
  `);
589997
590060
  const latest = await getLatestVersion(channel2);
589998
- if (latest && !gte("0.13.3", latest)) {
589999
- writeToStdout(`Update available: ${"0.13.3"} → ${latest}
590061
+ if (latest && !gte("0.13.4", latest)) {
590062
+ writeToStdout(`Update available: ${"0.13.4"} → ${latest}
590000
590063
  `);
590001
590064
  writeToStdout(`
590002
590065
  `);
@@ -590012,8 +590075,8 @@ async function update() {
590012
590075
  writeToStdout(`Verboo Code is managed by apk.
590013
590076
  `);
590014
590077
  const latest = await getLatestVersion(channel2);
590015
- if (latest && !gte("0.13.3", latest)) {
590016
- writeToStdout(`Update available: ${"0.13.3"} → ${latest}
590078
+ if (latest && !gte("0.13.4", latest)) {
590079
+ writeToStdout(`Update available: ${"0.13.4"} → ${latest}
590017
590080
  `);
590018
590081
  writeToStdout(`
590019
590082
  `);
@@ -590066,11 +590129,11 @@ async function update() {
590066
590129
  `);
590067
590130
  await gracefulShutdown(1);
590068
590131
  }
590069
- if (result.latestVersion === "0.13.3") {
590070
- writeToStdout(source_default.green(`Verboo Code is up to date (${"0.13.3"})`) + `
590132
+ if (result.latestVersion === "0.13.4") {
590133
+ writeToStdout(source_default.green(`Verboo Code is up to date (${"0.13.4"})`) + `
590071
590134
  `);
590072
590135
  } else {
590073
- writeToStdout(source_default.green(`Successfully updated from ${"0.13.3"} to version ${result.latestVersion}`) + `
590136
+ writeToStdout(source_default.green(`Successfully updated from ${"0.13.4"} to version ${result.latestVersion}`) + `
590074
590137
  `);
590075
590138
  await regenerateCompletionCache();
590076
590139
  }
@@ -590130,12 +590193,12 @@ async function update() {
590130
590193
  `);
590131
590194
  await gracefulShutdown(1);
590132
590195
  }
590133
- if (latestVersion === "0.13.3") {
590134
- writeToStdout(source_default.green(`Verboo Code is up to date (${"0.13.3"})`) + `
590196
+ if (latestVersion === "0.13.4") {
590197
+ writeToStdout(source_default.green(`Verboo Code is up to date (${"0.13.4"})`) + `
590135
590198
  `);
590136
590199
  await gracefulShutdown(0);
590137
590200
  }
590138
- writeToStdout(`New version available: ${latestVersion} (current: ${"0.13.3"})
590201
+ writeToStdout(`New version available: ${latestVersion} (current: ${"0.13.4"})
590139
590202
  `);
590140
590203
  writeToStdout(`Installing update...
590141
590204
  `);
@@ -590180,7 +590243,7 @@ async function update() {
590180
590243
  logForDebugging(`update: Installation status: ${status2}`);
590181
590244
  switch (status2) {
590182
590245
  case "success":
590183
- writeToStdout(source_default.green(`Successfully updated from ${"0.13.3"} to version ${latestVersion}`) + `
590246
+ writeToStdout(source_default.green(`Successfully updated from ${"0.13.4"} to version ${latestVersion}`) + `
590184
590247
  `);
590185
590248
  await regenerateCompletionCache();
590186
590249
  break;
@@ -591435,7 +591498,7 @@ ${customInstructions}` : customInstructions;
591435
591498
  is_native_binary: isInBundledMode()
591436
591499
  });
591437
591500
  logMemoryDiagnostics("start", {
591438
- version: "0.13.3",
591501
+ version: "0.13.4",
591439
591502
  debug: debug2,
591440
591503
  debugToStderr,
591441
591504
  print: print ?? false,
@@ -592246,7 +592309,7 @@ Usage: verboo --remote "your task description"`, () => gracefulShutdown(1));
592246
592309
  pendingHookMessages
592247
592310
  }, renderAndRun);
592248
592311
  }
592249
- }).version(`0.13.3 (${cliDesc})`, "-v, --version", "Output the version number");
592312
+ }).version(`0.13.4 (${cliDesc})`, "-v, --version", "Output the version number");
592250
592313
  program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
592251
592314
  program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
592252
592315
  if (canUserConfigureAdvisor()) {
@@ -592821,7 +592884,7 @@ if (false) {}
592821
592884
  async function main2() {
592822
592885
  const args = process.argv.slice(2);
592823
592886
  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
592824
- console.log(`${"0.13.3"} (Verboo Code)`);
592887
+ console.log(`${"0.13.4"} (Verboo Code)`);
592825
592888
  return;
592826
592889
  }
592827
592890
  if (!IS_VERBOO_CLI && args.includes("--provider")) {
@@ -592995,4 +593058,4 @@ async function main2() {
592995
593058
  }
592996
593059
  main2();
592997
593060
 
592998
- //# debugId=9B94BFBFDE46F31464756E2164756E21
593061
+ //# debugId=7D8FCCCDBB863D5564756E2164756E21
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@verboo/code",
3
- "version": "0.13.3",
3
+ "version": "0.13.4",
4
4
  "description": "Verboo Code — coding agent for the Verboo platform",
5
5
  "type": "module",
6
6
  "bin": {