pinokiod 7.5.36 → 7.5.38

package/kernel/bin/conda.js

@@ -69,98 +69,6 @@ const LEGACY_SSL_CERT_DIR_HOOK_FILES = [
   "zz_pinokio_unset_ssl_cert_dir-win.ps1",
   "zz_pinokio_unset_ssl_cert_dir-win.sh",
 ]
-const WINDOWS_CONDA_ACTIVATE_RELATIVE_PATHS = [
-  path.join("condabin", "_conda_activate.bat"),
-  path.join("Lib", "site-packages", "conda", "shell", "condabin", "_conda_activate.bat"),
-]
-const WINDOWS_CONDA_ACTIVATE_BAT = [
-  ":: Copyright (C) 2012 Anaconda, Inc",
-  ":: SPDX-License-Identifier: BSD-3-Clause",
-  ":: Helper routine for activation, deactivation, and reactivation.",
-  "@ECHO OFF",
-  "SETLOCAL",
-  "",
-  ":: Generate a unique temporary filename using a GUID to support parallel workflows",
-  ":: (e.g., `start /b conda run ...`). %RANDOM% is insufficient because processes",
-  ":: started simultaneously get identical time-based seeds, producing collisions.",
-  ":: See: https://devblogs.microsoft.com/oldnewthing/20100617-00/?p=13673",
-  "FOR /F \"delims=\" %%G IN ('powershell -NoProfile -Command \"[guid]::NewGuid()\"') DO SET \"__conda_guid=%%G\"",
-  "SET \"__conda_tmp=%TEMP%\\__conda_tmp_%__conda_guid%.txt\"",
-  "",
-  ":: Run conda command and get its output",
-  ":: WARNING: This cannot be simplified into a FOR /F parsing loop because of the way",
-  ":: MSDOS associates the outer quotes for usebackq. E.g., the following:",
-  "::   `\"%CONDA_EXE%\" shell.cmd.exe activate \"name\"`",
-  ":: Which results in the following gibberish being run:",
-  "::   %CONDA_EXE%\" shell.cmd.exe activate \"environment",
-  ":: Producing an error like:",
-  "::   The filename, directory name, or volume label syntax is incorrect.",
-  ":: Instead we run the command and store the output for subsequent processing.",
-  "\"%CONDA_EXE%\" %_CE_M% %_CE_CONDA% shell.cmd.exe %* > \"%__conda_tmp%\"",
-  "IF NOT EXIST \"%__conda_tmp%\" (",
-  "    ECHO ERROR: Failed to create temp file for 'conda %*'.>&2",
-  "    ECHO.>&2",
-  "    ECHO This is likely a TEMP directory issue>&2",
-  "    ECHO ^(permissions, disk space, or invalid path^).>&2",
-  "    ECHO.>&2",
-  "    ECHO Ensure TEMP or TMP environment variables point to a writable location.>&2",
-  "    ECHO See: https://docs.conda.io/projects/conda/en/stable/user-guide/troubleshooting.html#temp-file-errors>&2",
-  "    ENDLOCAL & EXIT /B 1",
-  ") ELSE IF %ERRORLEVEL% NEQ 0 (",
-  "    ECHO ERROR: 'conda %*' exited with code %ERRORLEVEL%.>&2",
-  "    CALL :DELETE \"%__conda_tmp%\"",
-  "    ENDLOCAL & EXIT /B 2",
-  ")",
-  "",
-  ":: Check if conda produced output",
-  "FOR /F \"delims=\" %%T IN (%__conda_tmp%) DO (",
-  "    :: T = \"%TEMP%\\<uuid>.env\"",
-  "    IF NOT EXIST \"%%T\" (",
-  "        ECHO ERROR: Activation file missing for 'conda %*'.>&2",
-  "        CALL :DELETE \"%__conda_tmp%\"",
-  "        ENDLOCAL & EXIT /B 3",
-  "    ) ELSE ENDLOCAL & @CALL :PINOKIO_APPLY_CONDA_ENV \"%%T\" \"%__conda_tmp%\" & @GOTO :EOF",
-  ")",
-  "",
-  ":: If we get here, the FOR loop never ran which means no output",
-  "ECHO ERROR: No output from 'conda %*'.>&2",
-  "CALL :DELETE \"%__conda_tmp%\"",
-  "ENDLOCAL & EXIT /B 5",
-  "",
-  ":PINOKIO_APPLY_CONDA_ENV",
-  "@ECHO OFF",
-  "@FOR /F \"tokens=1,* delims==\" %%A IN (%~1) DO (",
-  "@IF \"%CONDA_DEBUG%\" == \"1\" ECHO DEBUG: \"%%A=%%B\">&2",
-  "@IF \"%%A\"==\"_CONDA_SCRIPT\" (",
-  "@CALL \"%%B\" || (",
-  "@ECHO ERROR: Activation script \"%%B\" failed with code %ERRORLEVEL%.>&2",
-  "@CALL :DELETE \"%~1\"",
-  "@CALL :DELETE \"%~2\"",
-  "@ECHO ON",
-  "@EXIT /B 4",
-  ")",
-  ") ELSE IF \"%%B\"==\"\" (",
-  "@SET \"%%A=\"",
-  ") ELSE (",
-  "@SET \"%%A=%%B\"",
-  ")",
-  ")",
-  "@CALL :DELETE \"%~1\"",
-  "@CALL :DELETE \"%~2\"",
-  "@ECHO ON",
-  "@EXIT /B 0",
-  "",
-  ":: Routine to delete a temp file if CONDA_DEBUG is not set",
-  ":: usage: call :DELETE \"path/to/file\"",
-  ":DELETE",
-  "IF \"%CONDA_DEBUG%\" == \"1\" (",
-  "    ECHO DEBUG: Retaining temporary file \"%~1\".>&2",
-  ") ELSE IF EXIST \"%~1\" (",
-  "    DEL /F /Q \"%~1\" 2>NUL",
-  ")",
-  "GOTO :EOF",
-  "",
-].join("\r\n")
 
 class Conda {
   description = "Pinokio uses Conda to install various useful programs in an isolated manner."
@@ -253,16 +161,6 @@ class Conda {
       }
     }
   }
-  async ensureWindowsCondaActivateBat() {
-    if (this.kernel.platform !== "win32" || !(await this.hasCondaMeta())) {
-      return
-    }
-    for (const relativePath of WINDOWS_CONDA_ACTIVATE_RELATIVE_PATHS) {
-      const activatePath = this.kernel.bin.path(CONDA_ROOT_DIR, relativePath)
-      await fs.promises.mkdir(path.dirname(activatePath), { recursive: true })
-      await fs.promises.writeFile(activatePath, WINDOWS_CONDA_ACTIVATE_BAT)
-    }
-  }
   async init() {
     if (this.kernel.homedir) {
         console.log("condarc init")
@@ -285,7 +183,6 @@ report_errors: false`)
         await this.ensureCompatibilityAlias()
       }
       await this.ensureWindowsOpenSslHooks()
-      await this.ensureWindowsCondaActivateBat()
     }
   }
   async check() {
@@ -434,7 +331,6 @@ report_errors: false`)
       )
     }
     await this.ensureWindowsOpenSslHooks()
-    await this.ensureWindowsCondaActivateBat()
     await this.ensureCompatibilityAlias()
     ondata({ raw: `Install finished\r\n` })
     await this.kernel.bin.rm(installer, ondata)

package/kernel/shell.js

@@ -23,6 +23,7 @@ const ShellRunTemplate = require('./api/shell_run_template')
 const { PYTHON_INSTALL_SPEC } = require('./bin/conda-pins')
 const CondaRuntimeGuard = require('./shell_conda_runtime_guard')
 const home = os.homedir()
+const WINDOWS_CMD_CONDA_COMMAND_PATTERN = /(?:^|[&|()]\s*)@?\s*(?:call\s+)?(?:"[^"]*[\\/]conda(?:\.bat|\.exe)?"|(?:[a-z]:)?[^&|()\s"]*[\\/]conda(?:\.bat|\.exe)?|conda(?:\.bat|\.exe)?)\s+/i
 
 function normalizeComparablePath(filePath, platform) {
   const normalized = path.normalize(filePath)
@@ -335,6 +336,31 @@ class Shell {
     const name = (shellName || '').toLowerCase()
     return name.includes('powershell') || name.includes('pwsh')
   }
+  hasCondaCommand(message) {
+    if (Array.isArray(message)) {
+      return message.some((item) => this.hasCondaCommand(item))
+    }
+    if (message && message.constructor === Object) {
+      return this.hasCondaCommand(this.buildStructuredMessage(message))
+    }
+    return typeof message === "string" && WINDOWS_CMD_CONDA_COMMAND_PATTERN.test(message)
+  }
+  shouldSuppressCmdEchoForConda(params) {
+    return this.platform === "win32" &&
+      this.isCmdShell() &&
+      !(params && params.input) &&
+      this.hasCondaCommand(params && params.message)
+  }
+  prepareCommandExecution(params, command) {
+    if (!this.shouldSuppressCmdEchoForConda(params)) {
+      return { command }
+    }
+    return {
+      command,
+      preview: command,
+      quietCmd: true,
+    }
+  }
   isUnresolvedTemplate(value) {
     return typeof value === "string" && /^\{\{[\s\S]*\}\}$/.test(value)
   }
@@ -413,6 +439,10 @@ class Shell {
     this.decsyncBuffer = ''
     this.stateSync.reset()
     this.envArgsPreviewed = false
+    this.commandEchoPreview = null
+    this.commandEchoPreviewed = false
+    this.exec_cmd = null
+    this.quietCmdExecution = false
 
     /*
       params := {
@@ -1399,8 +1429,17 @@ class Shell {
   async exec(params) {
     this.parser = new ShellParser()
     this.emitEnvArgsPreview(params)
+    const originalParams = {
+      input: params && params.input,
+      message: params && params.message,
+    }
     params = await this.activate(params)
     this.cmd = this.build(params)
+    const preparedCommand = this.prepareCommandExecution(originalParams, this.cmd)
+    this.exec_cmd = preparedCommand.command
+    this.commandEchoPreview = preparedCommand.preview || null
+    this.commandEchoPreviewed = false
+    this.quietCmdExecution = !!preparedCommand.quietCmd
     let res = await new Promise((resolve, reject) => {
       this.resolve = resolve
       this.reject = reject
@@ -1420,7 +1459,10 @@ class Shell {
         if (!this.ptyProcess) {
           // ptyProcess doesn't exist => create
           this.done = false
-          this.ptyProcess = pty.spawn(this.shell, this.args, config)
+          const shellArgs = this.quietCmdExecution && this.isCmdShell()
+            ? this.args.concat(this.args.some((arg) => /^\/q$/i.test(arg)) ? [] : ["/Q"])
+            : this.args
+          this.ptyProcess = pty.spawn(this.shell, shellArgs, config)
           this.ptyProcess.onData((data) => {
             if (!this.monitor) {
               this.monitor = ""
@@ -1853,7 +1895,11 @@ ${cleaned}
             }
             if (this.ptyProcess) {
               this.stateSync.noteInput()
-              this.ptyProcess.write(`${this.cmd}${this.EOL}`)
+              if (this.commandEchoPreview && !this.commandEchoPreviewed) {
+                this.commandEchoPreviewed = true
+                this.queue.push(`${this.commandEchoPreview}${this.EOL}`)
+              }
+              this.ptyProcess.write(`${this.exec_cmd || this.cmd}${this.EOL}`)
 //              setTimeout(() => {
 //                this.ptyProcess.write('\x1B[?2004h');
 //              }, 500)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "7.5.36",
+  "version": "7.5.38",
   "description": "",
   "main": "index.js",
   "scripts": {

package/test/conda-bin.test.js

@@ -125,24 +125,6 @@ const EXPECTED_WINDOWS_OPENSSL_HOOKS = {
   ].join('\n'),
 }
 
-const WINDOWS_CONDA_ACTIVATE_PATHS = [
-  path.join('bin', 'miniforge', 'condabin', '_conda_activate.bat'),
-  path.join(
-    'bin',
-    'miniforge',
-    'Lib',
-    'site-packages',
-    'conda',
-    'shell',
-    'condabin',
-    '_conda_activate.bat'
-  ),
-]
-const WINDOWS_CONDA_ACTIVATE_LEAK_BLOCK = [
-  '    ) ELSE ENDLOCAL & (',
-  '        FOR /F "tokens=1,* delims==" %%A IN (%%T) DO (',
-].join('\r\n')
-
 async function seedWindowsOpenSslHooks(root, condaRootName) {
   const condaHookRoot = path.join(root, 'bin', condaRootName, 'etc', 'conda')
   for (const hookRelativePath of Object.keys(EXPECTED_WINDOWS_OPENSSL_HOOKS)) {
@@ -161,15 +143,6 @@ async function seedWindowsOpenSslHooks(root, condaRootName) {
   }
 }
 
-async function seedWindowsCondaActivateScripts(root, content = 'corrupted helper\r\n') {
-  const activatePaths = WINDOWS_CONDA_ACTIVATE_PATHS.map((activatePath) => path.join(root, activatePath))
-  for (const activatePath of activatePaths) {
-    await fs.mkdir(path.dirname(activatePath), { recursive: true })
-    await fs.writeFile(activatePath, content)
-  }
-  return activatePaths
-}
-
 async function assertWindowsOpenSslHooksPatched(root, condaRootName) {
   const condaHookRoot = path.join(root, 'bin', condaRootName, 'etc', 'conda')
   for (const [hookRelativePath, expectedContent] of Object.entries(EXPECTED_WINDOWS_OPENSSL_HOOKS)) {
@@ -230,24 +203,6 @@ test('Conda init patches Windows OpenSSL hooks for legacy Miniconda roots', asyn
   await assertWindowsOpenSslHooksPatched(root, 'miniconda')
 })
 
-test('Conda init replaces Windows CMD activation helper files', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-cmd-activate-replace-'))
-  await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
-  const activatePaths = await seedWindowsCondaActivateScripts(root)
-  const conda = createConda(createKernel(root))
-
-  await conda.init()
-  await conda.init()
-
-  const contents = await Promise.all(activatePaths.map((activatePath) => fs.readFile(activatePath, 'utf8')))
-  assert.equal(contents[0], contents[1])
-  assert.equal(contents[0].includes(WINDOWS_CONDA_ACTIVATE_LEAK_BLOCK), false)
-  assert.match(contents[0], /ENDLOCAL & @CALL :PINOKIO_APPLY_CONDA_ENV "%%T" "%__conda_tmp%" & @GOTO :EOF/)
-  assert.match(contents[0], /:PINOKIO_APPLY_CONDA_ENV\r\n@ECHO OFF/)
-  assert.match(contents[0], /@CALL "%%B" \|\| \(/)
-  assert.match(contents[0], /@ECHO ON\r\n@EXIT \/B 0/)
-})
-
 test('Conda pins Python 3.10.20 consistently across platforms', async () => {
   assert.equal(PYTHON_INSTALL_SPEC, 'python=3.10.20')
   assert.equal(WINDOWS_PYTHON_SSL_FIX_SPEC, 'python=3.10.20=*_1_cpython')
@@ -312,9 +267,6 @@ test('Conda install keeps the Windows Python 3.10.20 SSL-fixed build pin', async
     condaInstall.message[1],
     'conda install -y --override-channels -c conda-forge "python=3.10.20=*_1_cpython" "conda-libmamba-solver>=25.4.0"'
   )
-  for (const activatePath of WINDOWS_CONDA_ACTIVATE_PATHS.map((activatePath) => path.join(root, activatePath))) {
-    assert.match(await fs.readFile(activatePath, 'utf8'), /:PINOKIO_APPLY_CONDA_ENV/)
-  }
 })
 
 test('Conda install replaces legacy miniconda with a compatibility alias to miniforge', async () => {

package/test/shell-conda-runtime-guard.test.js

@@ -917,6 +917,38 @@ test('internal shell activation inspects only when shell.run guard option is set
   assert.equal(events.some((event) => event.type === 'notify'), true)
 })
 
+test('Windows cmd suppresses echo only for explicit conda shell.run commands', () => {
+  const shell = new Shell({ bracketedPasteSupport: {} })
+  shell.platform = 'win32'
+  shell.shell = 'cmd.exe'
+  const command = 'conda_hook & conda deactivate & conda activate base & conda install -y -c conda-forge ffmpeg'
+
+  assert.equal(shell.shouldSuppressCmdEchoForConda({
+    message: 'conda install -y -c conda-forge ffmpeg',
+  }), true)
+  assert.equal(shell.shouldSuppressCmdEchoForConda({
+    message: 'python main.py',
+  }), false)
+  assert.equal(shell.shouldSuppressCmdEchoForConda({
+    message: 'conda_hook',
+  }), false)
+  assert.equal(shell.shouldSuppressCmdEchoForConda({
+    input: true,
+    message: 'conda install -y -c conda-forge ffmpeg',
+  }), false)
+
+  const prepared = shell.prepareCommandExecution({
+    message: 'conda install -y -c conda-forge ffmpeg',
+  }, command)
+  assert.equal(prepared.preview, command)
+  assert.equal(prepared.command, command)
+  assert.equal(prepared.quietCmd, true)
+
+  assert.deepEqual(shell.prepareCommandExecution({
+    message: 'python main.py',
+  }, command), { command })
+})
+
 test('rewrite warning is scoped to each user-visible shell flow', async () => {
   CondaRuntimeGuard.resetNoticeSessionsForTest()
   const { context, events, root } = createContext()