wip

package.json

@@ -60,6 +60,16 @@
         "command": "corker.micromamba.clear.all",
         "title": "Micromamba: clear all",
         "enablement": "corker.micromamba.can.clear.all"
+      },
+      {
+        "command": "corker.micromamba.use.global.home.dir",
+        "title": "Micromamba: use global home directory",
+        "enablement": "corker.micromamba.can.use.global.home.dir"
+      },
+      {
+        "command": "corker.micromamba.use.local.home.dir",
+        "title": "Micromamba: use local home directory",
+        "enablement": "corker.micromamba.can.use.local.home.dir"
       }
     ]
   },
@@ -132,7 +142,9 @@
       "@typescript-eslint"
     ],
     "root": true,
-    "ignorePatterns": ["out"]
+    "ignorePatterns": [
+      "out"
+    ]
   },
   "prettier": {
     "printWidth": 100,
@@ -145,4 +157,4 @@
     "preset": "ts-jest",
     "testEnvironment": "node"
   }
-}
+}

src/_definitions.ts

@@ -1,20 +1,3 @@
-import { Observable } from 'rxjs'
-import { EnvironmentPrefix } from './environments'
-
-export type ExtensionContext = {
-  rootDir: string
-  micromambaDir: string
-  micromambaPath: string
-}
-
-export type ActiveEnvironmentPrefix = EnvironmentPrefix | undefined
-
 export interface DisposableLike {
   dispose: () => void
 }
-
-export interface ActiveEnvironmentManager {
-  readonly prefix$: Observable<ActiveEnvironmentPrefix>
-  activate(prefix: EnvironmentPrefix): void
-  deactivate(): void
-}

src/activations/activateCommands.ts

@@ -2,7 +2,10 @@ import { Observable } from 'rxjs'
 import { exhaustMap } from 'rxjs/operators'
 import * as vscode from 'vscode'
 import { CommandLike, commands } from '../commands'
-import { ActiveEnvironmentManager, DisposableLike, ExtensionContext } from '../_definitions'
+import { DisposableLike } from '../_definitions'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
+import { EnvironmentManager } from '../environments/makeEnvironmentManager'
+import { ExtensionContext } from 'vscode'
 
 async function askToReloadWindow(): Promise<void> {
   const action = 'Reload'
@@ -14,8 +17,9 @@ async function askToReloadWindow(): Promise<void> {
 }
 
 export const activateCommands = (
-  extContext: ExtensionContext,
-  manager: ActiveEnvironmentManager,
+  ctx: ExtensionContext,
+  info: MicromambaInfo,
+  manager: EnvironmentManager,
 ): DisposableLike => {
   const commands$ = new Observable<CommandLike>((subscriber) => {
     const dis = vscode.Disposable.from(
@@ -28,7 +32,7 @@ export const activateCommands = (
   const sub = commands$
     .pipe(
       exhaustMap(async (x: CommandLike) => {
-        await x({ extContext, manager })
+        await x({ info, manager, ctx })
         askToReloadWindow().then()
       }),
     )

src/activations/activateContextFlags.ts

@@ -1,35 +1,38 @@
 import * as vscode from 'vscode'
-import { DisposableLike, ExtensionContext } from '../_definitions'
+import { DisposableLike } from '../_definitions'
 import { Observable } from 'rxjs'
 import { concatMap } from 'rxjs/operators'
 import { EnvironmentInfo, findMicromambaEnvironmentQuickPickItems } from '../environments'
 import sh from '../helpers/sh'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
 const setContext = <T>(key: string, value: T): void => {
   vscode.commands.executeCommand('setContext', key, value)
 }
 
 export const activateContextFlags = (
-  extContext: ExtensionContext,
+  mInfo: MicromambaInfo,
   info$: Observable<EnvironmentInfo>,
 ): DisposableLike => {
   const sub = info$
     .pipe(
-      concatMap(async (info) => ({
-        info,
-        items: await findMicromambaEnvironmentQuickPickItems(extContext),
+      concatMap(async (eInfo) => ({
+        eInfo,
+        items: await findMicromambaEnvironmentQuickPickItems(mInfo),
       })),
     )
-    .subscribe(async ({ info, items }) => {
-      const name = info.environmentName
+    .subscribe(async ({ eInfo, items }) => {
+      const name = eInfo.environmentName
       const item = items.find((x) => x.data.content.name === name)
       const hasCreatedEnvs = items.length > 0
       const hasActivatedEnv = !!item
-      const hasMicromambaDir = await sh.testd(extContext.micromambaDir)
+      const hasMicromambaDir = await sh.testd(mInfo.micromambaDir)
       setContext('corker.micromamba.can.activate.environment', hasCreatedEnvs)
       setContext('corker.micromamba.can.deactivate.environment', hasActivatedEnv)
       setContext('corker.micromamba.can.remove.environment', hasActivatedEnv)
       setContext('corker.micromamba.can.clear.all', hasMicromambaDir)
+      setContext('corker.micromamba.can.use.global.home.dir', mInfo.isLocal)
+      setContext('corker.micromamba.can.use.local.home.dir', !mInfo.isLocal)
     })
   return { dispose: () => sub.unsubscribe() }
 }

src/activations/activateDotEnvFile.ts

@@ -1,9 +1,10 @@
 import { Observable } from 'rxjs'
 import { createEnvFile, EnvironmentInfo } from '../environments'
-import { DisposableLike, ExtensionContext } from '../_definitions'
+import { DisposableLike } from '../_definitions'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
 export function activateDotEnvFile(
-  extContext: ExtensionContext,
+  extContext: MicromambaInfo,
   info$: Observable<EnvironmentInfo>,
 ): DisposableLike {
   const sub = info$.subscribe((info) => {

src/activations/activateProcessEnv.ts

@@ -1,13 +1,14 @@
 import * as path from 'path'
 import { pathKey } from '../helpers/infra'
 import { Observable } from 'rxjs'
-import { DisposableLike, ExtensionContext } from '../_definitions'
+import { DisposableLike } from '../_definitions'
 import { EnvironmentInfo } from '../environments'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
 const originalPath = process.env[pathKey]
 
 export function activateProcessEnv(
-  extContext: ExtensionContext,
+  extContext: MicromambaInfo,
   info$: Observable<EnvironmentInfo>,
 ): DisposableLike {
   const sub = info$.subscribe((info) => {

src/activations/activateStatusBarItem.ts

@@ -1,11 +1,14 @@
 import * as vscode from 'vscode'
-import { ActiveEnvironmentManager, DisposableLike } from '../_definitions'
+import { DisposableLike } from '../_definitions'
+import { EnvironmentManager } from '../environments/makeEnvironmentManager'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
-export function activateStatusBarItem(manager: ActiveEnvironmentManager): DisposableLike {
+export function activateStatusBarItem(mInfo: MicromambaInfo, manager: EnvironmentManager): DisposableLike {
   const statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left)
+  const suffix = mInfo.isLocal ? 'L' : 'G'
   const sub = manager.prefix$.subscribe((name) => {
-    if (name) statusBarItem.text = `µenv[${name}]`
-    else statusBarItem.text = `µenv<none>`
+    if (name) statusBarItem.text = `µenv[${name}](${suffix})`
+    else statusBarItem.text = `µenv<none>(${suffix})`
     statusBarItem.show()
   })
   return vscode.Disposable.from(statusBarItem, { dispose: () => sub.unsubscribe() })

src/activations/activateTerminal.ts

@@ -2,12 +2,13 @@ import * as vscode from 'vscode'
 import * as path from 'path'
 import { pathKey } from '../helpers/infra'
 import { Observable } from 'rxjs'
-import { DisposableLike, ExtensionContext } from '../_definitions'
+import { DisposableLike } from '../_definitions'
 import { EnvironmentInfo } from '../environments'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
 export function activateTerminal(
   context: vscode.ExtensionContext,
-  extContext: ExtensionContext,
+  extContext: MicromambaInfo,
   info$: Observable<EnvironmentInfo>,
 ): DisposableLike {
   const { environmentVariableCollection: col } = context

src/activations/activateWorkspaceState.ts

@@ -1,18 +1,19 @@
 import * as vscode from 'vscode'
 import { skip } from 'rxjs/operators'
-import { ActiveEnvironmentManager, ActiveEnvironmentPrefix, DisposableLike } from '../_definitions'
+import { DisposableLike } from '../_definitions'
+import { EnvironmentManager } from '../environments/makeEnvironmentManager'
 
 export function activateWorkspaceState(
   context: vscode.ExtensionContext,
-  manager: ActiveEnvironmentManager,
+  manager: EnvironmentManager,
 ): DisposableLike {
   const key = 'micromamba.active.environment.name'
   const { workspaceState } = context
-  const prefix = workspaceState.get<ActiveEnvironmentPrefix>(key)
+  const prefix = workspaceState.get<string | undefined>(key)
   if (prefix) manager.activate(prefix)
   else manager.deactivate()
   const sub = manager.prefix$
     .pipe(skip(1))
-    .subscribe((x: ActiveEnvironmentPrefix) => workspaceState.update(key, x))
+    .subscribe((x) => workspaceState.update(key, x))
   return { dispose: (): void => sub.unsubscribe() }
 }

src/commands/_definitions.ts

@@ -1,8 +1,11 @@
-import { ActiveEnvironmentManager, ExtensionContext } from '../_definitions'
+import { ExtensionContext } from 'vscode'
+import { EnvironmentManager } from '../environments/makeEnvironmentManager'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
 export type CommandLike = (context: CommandContext) => Promise<void>
 
 export interface CommandContext {
-  extContext: ExtensionContext
-  manager: ActiveEnvironmentManager
+  ctx: ExtensionContext
+  info: MicromambaInfo
+  manager: EnvironmentManager
 }

src/commands/commands.ts

@@ -3,6 +3,8 @@ import { runClearAllCommand } from './runClearAllCommand'
 import { runCreateEnvironmentCommand } from './runCreateEnvironmentCommand'
 import { runDeactivateEnvironmentCommand } from './runDeactivateEnvironmentCommand'
 import { runRemoveEnvironmentCommand } from './runRemoveEnvironmentCommand'
+import { runUseGlobalHomeDirCommand } from './runUseGlobalHomeDirCommand'
+import { runUseLocalHomeDirCommand } from './runUseLocalHomeDirCommand'
 import { CommandLike } from './_definitions'
 
 export type CommandInfo = [string, CommandLike]
@@ -13,4 +15,6 @@ export const commands: Array<CommandInfo> = [
   ['corker.micromamba.deactivate.environment', runDeactivateEnvironmentCommand],
   ['corker.micromamba.remove.environment', runRemoveEnvironmentCommand],
   ['corker.micromamba.clear.all', runClearAllCommand],
+  ['corker.micromamba.use.global.home.dir', runUseGlobalHomeDirCommand],
+  ['corker.micromamba.use.local.home.dir', runUseLocalHomeDirCommand],
 ]

src/commands/runActivateEnvironmentCommand.ts

@@ -1,7 +1,7 @@
 import { pickMicromambaEnvironmentPrefixName } from '../environments'
 import { CommandLike } from './_definitions'
 
-export const runActivateEnvironmentCommand: CommandLike = async ({ extContext, manager }) => {
+export const runActivateEnvironmentCommand: CommandLike = async ({ info: extContext, manager }) => {
   const prefixName = await pickMicromambaEnvironmentPrefixName(
     extContext,
     'Select environment to activate',

src/commands/runClearAllCommand.ts

@@ -4,7 +4,7 @@ import rimraf from 'rimraf'
 import { CommandLike } from './_definitions'
 import sh from '../helpers/sh'
 
-export const runClearAllCommand: CommandLike = async ({ extContext, manager }) => {
+export const runClearAllCommand: CommandLike = async ({ info: extContext, manager }) => {
   manager.deactivate()
   const { micromambaDir } = extContext
   const tempDir = `${micromambaDir}_temp`

src/commands/runCreateEnvironmentCommand.ts

@@ -1,13 +1,13 @@
 import * as vscode from 'vscode'
 import { join } from 'path'
-import { ExtensionContext } from '../_definitions'
 import { CommandLike } from './_definitions'
 import { ensureMicromamba, makeMicromambaCreateEnvironmentTask } from '../micromamba'
 import { MicromambaEnvironmentFile, pickMicromambaEnvironmentFile } from '../environments'
 import { isNativeError } from 'util/types'
 import sh from '../helpers/sh'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
-const _ensureMicromambaDir = async (extContext: ExtensionContext) => {
+const _ensureMicromambaDir = async (extContext: MicromambaInfo) => {
   try {
     await sh.mkdirp(extContext.micromambaDir)
     const gitIgnorePath = join(extContext.micromambaDir, '.gitignore')
@@ -17,7 +17,7 @@ const _ensureMicromambaDir = async (extContext: ExtensionContext) => {
   }
 }
 
-const _ensureMicromamba = async (extContext: ExtensionContext): Promise<void> => {
+const _ensureMicromamba = async (extContext: MicromambaInfo): Promise<void> => {
   try {
     await vscode.window.withProgress(
       {
@@ -35,7 +35,7 @@ const _ensureMicromamba = async (extContext: ExtensionContext): Promise<void> =>
   }
 }
 
-const _createEnvironment = async (extContext: ExtensionContext, environmentFile: MicromambaEnvironmentFile): Promise<void> => {
+const _createEnvironment = async (extContext: MicromambaInfo, environmentFile: MicromambaEnvironmentFile): Promise<void> => {
   try {
     const workspaceFolder = vscode.workspace.workspaceFolders?.[0]
     if (!workspaceFolder) return Promise.resolve()
@@ -53,7 +53,7 @@ const _createEnvironment = async (extContext: ExtensionContext, environmentFile:
   }
 }
 
-export const runCreateEnvironmentCommand: CommandLike = async ({ extContext, manager }) => {
+export const runCreateEnvironmentCommand: CommandLike = async ({ info: extContext, manager }) => {
   try {
     manager.deactivate()
     const environmentFile = await pickMicromambaEnvironmentFile(extContext)

src/commands/runRemoveEnvironmentCommand.ts

@@ -5,7 +5,7 @@ import { CommandLike } from './_definitions'
 import { pickMicromambaEnvironmentPrefixName } from '../environments'
 import sh from '../helpers/sh'
 
-export const runRemoveEnvironmentCommand: CommandLike = async ({ extContext, manager }) => {
+export const runRemoveEnvironmentCommand: CommandLike = async ({ info: extContext, manager }) => {
   const prefixName = await pickMicromambaEnvironmentPrefixName(
     extContext,
     'Select environment to remove',

src/commands/runUseGlobalHomeDirCommand.ts

@@ -0,0 +1,30 @@
+import { Uri, window } from 'vscode'
+import { CommandLike } from './_definitions'
+import { setGlobalMicromambaHomeDir } from '../helpers/makeMicromambaInfo'
+import { isWindows } from '../helpers/infra'
+import os from 'os'
+import { join } from 'path'
+import sh from '../helpers/sh'
+
+export const runUseGlobalHomeDirCommand: CommandLike = async ({ ctx, manager }) => {
+  if (isWindows) {
+    const uris = await window.showOpenDialog({
+      canSelectFolders: true,
+      openLabel: 'Home',
+      title: 'micromamba: Global home directory',
+      defaultUri: Uri.file('C:/')
+    })
+    if (!uris) return
+    const homeDir = join(uris[0].fsPath, '.micromamba')
+    await sh.mkdirp(homeDir)
+    await setGlobalMicromambaHomeDir(ctx, homeDir)
+    manager.deactivate()
+    window.showInformationMessage(`micromamba: Global home directory: ${homeDir}`)
+  } else {
+    const homeDir = join(os.homedir(), '.vscode-micromamba')
+    await sh.mkdirp(homeDir)
+    await setGlobalMicromambaHomeDir(ctx, homeDir)
+    manager.deactivate()
+    window.showInformationMessage(`micromamba: Global home directory: ${homeDir}`)
+  }
+}

src/commands/runUseLocalHomeDirCommand.ts

@@ -0,0 +1,7 @@
+import { setGlobalMicromambaHomeDir } from '../helpers/makeMicromambaInfo'
+import { CommandLike } from './_definitions'
+
+export const runUseLocalHomeDirCommand: CommandLike = async ({ ctx, manager }) => {
+  await setGlobalMicromambaHomeDir(ctx, undefined)
+  manager.deactivate()
+}

src/environments/createEnvFile.ts

@@ -1,14 +1,14 @@
 import * as fs from 'fs'
 import { join } from 'path'
 import { EnvironmentVariables } from '../micromamba'
-import { ExtensionContext } from '../_definitions'
+import { MicromambaInfo } from '../helpers/makeMicromambaInfo'
 
 export const escapeValue = (value: string): string =>
   value.replace(/\n/g, '\\n').replace(/"/g, '""')
 
 export const createEnvFile = (
   vars: EnvironmentVariables,
-  extContext: ExtensionContext,
+  extContext: MicromambaInfo,
   prefixName: string,
 ): void => {
   const envFilePath = join(extContext.micromambaDir, `.env.${prefixName}`)