pinokiod 7.5.35 → 7.5.37

package/kernel/bin/conda.js

@@ -69,79 +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_PATH = path.join(
-  "Lib",
-  "site-packages",
-  "conda",
-  "shell",
-  "condabin",
-  "_conda_activate.bat"
-)
-const WINDOWS_CONDA_ACTIVATE_PINOKIO_MARKER = ":PINOKIO_APPLY_CONDA_ENV"
-
-function windowsCondaActivateOriginalBlock(eol) {
-  return [
-    "    ) ELSE ENDLOCAL & (",
-    '        FOR /F "tokens=1,* delims==" %%A IN (%%T) DO (',
-    '            :: A, B = "key", "value"',
-    '            IF "%CONDA_DEBUG%" == "1" ECHO DEBUG: "%%A=%%B">&2',
-    '            IF "%%A"=="_CONDA_SCRIPT" (',
-    "                :: Script execution, fast exit if activation scripts fail",
-    '                CALL "%%B" || (',
-    '                    ECHO ERROR: Activation script "%%B" failed with code %ERRORLEVEL%.>&2',
-    '                    CALL :DELETE "%%T"',
-    '                    CALL :DELETE "%__conda_tmp%"',
-    "                    EXIT /B 4",
-    "                )",
-    '            ) ELSE IF "%%B"=="" (',
-    "                :: Unset variable",
-    '                SET "%%A="',
-    "            ) ELSE (",
-    "                :: Set variable",
-    '                SET "%%A=%%B"',
-    "            )",
-    "        )",
-    "        :: Clean up",
-    '        CALL :DELETE "%%T"',
-    '        CALL :DELETE "%__conda_tmp%"',
-    "        EXIT /B 0",
-    "    )",
-  ].join(eol)
-}
-
-function windowsCondaActivatePatchedBlock(eol) {
-  return [
-    '    ) ELSE ENDLOCAL & @CALL :PINOKIO_APPLY_CONDA_ENV "%%T" "%__conda_tmp%" & @GOTO :EOF',
-  ].join(eol)
-}
-
-function windowsCondaActivatePatchRoutines(eol) {
-  return [
-    ":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",
-    "",
-  ].join(eol)
-}
 
 class Conda {
   description = "Pinokio uses Conda to install various useful programs in an isolated manner."
@@ -234,57 +161,6 @@ class Conda {
       }
     }
   }
-  async ensureWindowsCondaActivateEchoPatch() {
-    if (this.kernel.platform !== "win32" || !(await this.hasCondaMeta())) {
-      return
-    }
-    const activatePath = this.kernel.bin.path(CONDA_ROOT_DIR, WINDOWS_CONDA_ACTIVATE_RELATIVE_PATH)
-    let content
-    try {
-      content = await fs.promises.readFile(activatePath, "utf8")
-    } catch (error) {
-      if (error && error.code === "ENOENT") {
-        return
-      }
-      throw error
-    }
-    const eol = content.includes("\r\n") ? "\r\n" : "\n"
-    const routineAnchor = `${eol}:: Routine to delete a temp file if CONDA_DEBUG is not set`
-    if (!content.includes(routineAnchor)) {
-      console.warn("Could not patch Conda CMD activation echo leak; missing _conda_activate.bat routine anchor")
-      return
-    }
-    if (content.includes(WINDOWS_CONDA_ACTIVATE_PINOKIO_MARKER)) {
-      if (content.includes(`${WINDOWS_CONDA_ACTIVATE_PINOKIO_MARKER}${eol}@ECHO OFF`)) {
-        return
-      }
-      const routineStart = content.indexOf(WINDOWS_CONDA_ACTIVATE_PINOKIO_MARKER)
-      const routineAnchorIndex = content.indexOf(routineAnchor, routineStart)
-      if (routineAnchorIndex < 0) {
-        console.warn("Could not update Conda CMD activation echo patch; missing _conda_activate.bat routine anchor")
-        return
-      }
-      const patched = [
-        content.slice(0, routineStart),
-        windowsCondaActivatePatchRoutines(eol),
-        content.slice(routineAnchorIndex + eol.length),
-      ].join("")
-      await fs.promises.writeFile(activatePath, patched)
-      return
-    }
-    const originalBlock = windowsCondaActivateOriginalBlock(eol)
-    if (!content.includes(originalBlock)) {
-      console.warn("Could not patch Conda CMD activation echo leak; unexpected _conda_activate.bat")
-      return
-    }
-    const patched = content
-      .replace(originalBlock, windowsCondaActivatePatchedBlock(eol))
-      .replace(
-        routineAnchor,
-        `${eol}${windowsCondaActivatePatchRoutines(eol)}:: Routine to delete a temp file if CONDA_DEBUG is not set`
-      )
-    await fs.promises.writeFile(activatePath, patched)
-  }
   async init() {
     if (this.kernel.homedir) {
         console.log("condarc init")
@@ -307,7 +183,6 @@ report_errors: false`)
         await this.ensureCompatibilityAlias()
       }
       await this.ensureWindowsOpenSslHooks()
-      await this.ensureWindowsCondaActivateEchoPatch()
     }
   }
   async check() {
@@ -456,7 +331,6 @@ report_errors: false`)
       )
     }
     await this.ensureWindowsOpenSslHooks()
-    await this.ensureWindowsCondaActivateEchoPatch()
     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,33 @@ 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)
+  }
+  buildCmdEchoSuppressedCommand(command) {
+    return `@echo off\r\n${command}\r\n@echo on`
+  }
+  prepareCommandExecution(params, command) {
+    if (!this.shouldSuppressCmdEchoForConda(params)) {
+      return { command }
+    }
+    return {
+      command: this.buildCmdEchoSuppressedCommand(command),
+      preview: command,
+    }
+  }
   isUnresolvedTemplate(value) {
     return typeof value === "string" && /^\{\{[\s\S]*\}\}$/.test(value)
   }
@@ -413,6 +441,9 @@ class Shell {
     this.decsyncBuffer = ''
     this.stateSync.reset()
     this.envArgsPreviewed = false
+    this.commandEchoPreview = null
+    this.commandEchoPreviewed = false
+    this.exec_cmd = null
 
     /*
       params := {
@@ -1399,8 +1430,16 @@ 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
     let res = await new Promise((resolve, reject) => {
       this.resolve = resolve
       this.reject = reject
@@ -1853,7 +1892,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.35",
+  "version": "7.5.37",
   "description": "",
   "main": "index.js",
   "scripts": {

package/test/conda-bin.test.js

@@ -125,58 +125,6 @@ const EXPECTED_WINDOWS_OPENSSL_HOOKS = {
   ].join('\n'),
 }
 
-const WINDOWS_CONDA_ACTIVATE_PATH = path.join(
-  'bin',
-  'miniforge',
-  'Lib',
-  'site-packages',
-  'conda',
-  'shell',
-  'condabin',
-  '_conda_activate.bat'
-)
-const WINDOWS_CONDA_ACTIVATE_ORIGINAL_BLOCK = [
-  '    ) ELSE ENDLOCAL & (',
-  '        FOR /F "tokens=1,* delims==" %%A IN (%%T) DO (',
-  '            :: A, B = "key", "value"',
-  '            IF "%CONDA_DEBUG%" == "1" ECHO DEBUG: "%%A=%%B">&2',
-  '            IF "%%A"=="_CONDA_SCRIPT" (',
-  '                :: Script execution, fast exit if activation scripts fail',
-  '                CALL "%%B" || (',
-  '                    ECHO ERROR: Activation script "%%B" failed with code %ERRORLEVEL%.>&2',
-  '                    CALL :DELETE "%%T"',
-  '                    CALL :DELETE "%__conda_tmp%"',
-  '                    EXIT /B 4',
-  '                )',
-  '            ) ELSE IF "%%B"=="" (',
-  '                :: Unset variable',
-  '                SET "%%A="',
-  '            ) ELSE (',
-  '                :: Set variable',
-  '                SET "%%A=%%B"',
-  '            )',
-  '        )',
-  '        :: Clean up',
-  '        CALL :DELETE "%%T"',
-  '        CALL :DELETE "%__conda_tmp%"',
-  '        EXIT /B 0',
-  '    )',
-].join('\r\n')
-const WINDOWS_CONDA_ACTIVATE_SCRIPT = [
-  '@ECHO OFF',
-  'SETLOCAL',
-  'FOR /F "delims=" %%T IN (%__conda_tmp%) DO (',
-  '    IF NOT EXIST "%%T" (',
-  '        ENDLOCAL & EXIT /B 3',
-  WINDOWS_CONDA_ACTIVATE_ORIGINAL_BLOCK,
-  ')',
-  '',
-  ':: Routine to delete a temp file if CONDA_DEBUG is not set',
-  ':DELETE',
-  'GOTO :EOF',
-  '',
-].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)) {
@@ -195,13 +143,6 @@ async function seedWindowsOpenSslHooks(root, condaRootName) {
   }
 }
 
-async function seedWindowsCondaActivateScript(root, content = WINDOWS_CONDA_ACTIVATE_SCRIPT) {
-  const activatePath = path.join(root, WINDOWS_CONDA_ACTIVATE_PATH)
-  await fs.mkdir(path.dirname(activatePath), { recursive: true })
-  await fs.writeFile(activatePath, content)
-  return activatePath
-}
-
 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)) {
@@ -262,83 +203,6 @@ test('Conda init patches Windows OpenSSL hooks for legacy Miniconda roots', asyn
   await assertWindowsOpenSslHooksPatched(root, 'miniconda')
 })
 
-test('Conda init patches Windows CMD activation echo leak idempotently', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-cmd-activate-patch-'))
-  await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
-  const activatePath = await seedWindowsCondaActivateScript(root)
-  const conda = createConda(createKernel(root))
-
-  await conda.init()
-  const patched = await fs.readFile(activatePath, 'utf8')
-  await conda.init()
-
-  assert.equal(await fs.readFile(activatePath, 'utf8'), patched)
-  assert.equal(patched.includes(WINDOWS_CONDA_ACTIVATE_ORIGINAL_BLOCK), false)
-  assert.match(patched, /ENDLOCAL & @CALL :PINOKIO_APPLY_CONDA_ENV "%%T" "%__conda_tmp%" & @GOTO :EOF/)
-  assert.match(patched, /:PINOKIO_APPLY_CONDA_ENV\r\n@ECHO OFF/)
-  assert.match(patched, /@CALL "%%B" \|\| \(/)
-  assert.match(patched, /@ECHO ON\r\n@EXIT \/B 0/)
-  assert.match(patched, /:: Routine to delete a temp file if CONDA_DEBUG is not set/)
-})
-
-test('Conda init updates the earlier Windows CMD activation echo patch', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-cmd-activate-update-patch-'))
-  await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
-  const oldPatch = WINDOWS_CONDA_ACTIVATE_SCRIPT
-    .replace(
-      WINDOWS_CONDA_ACTIVATE_ORIGINAL_BLOCK,
-      '    ) ELSE ENDLOCAL & @CALL :PINOKIO_APPLY_CONDA_ENV "%%T" "%__conda_tmp%" & @GOTO :EOF'
-    )
-    .replace(
-      '\r\n:: Routine to delete a temp file if CONDA_DEBUG is not set',
-      [
-        '\r\n:PINOKIO_APPLY_CONDA_ENV',
-        '@FOR /F "tokens=1,* delims==" %%A IN (%~1) DO (',
-        '@IF "%CONDA_DEBUG%" == "1" ECHO DEBUG: "%%A=%%B">&2',
-        ')',
-        '@CALL :DELETE "%~1"',
-        '@CALL :DELETE "%~2"',
-        '@EXIT /B 0',
-        ':: Routine to delete a temp file if CONDA_DEBUG is not set',
-      ].join('\r\n')
-    )
-  const activatePath = await seedWindowsCondaActivateScript(root, oldPatch)
-  const conda = createConda(createKernel(root))
-
-  await conda.init()
-
-  const patched = await fs.readFile(activatePath, 'utf8')
-  assert.match(patched, /:PINOKIO_APPLY_CONDA_ENV\r\n@ECHO OFF/)
-  assert.match(patched, /@ECHO ON\r\n@EXIT \/B 0/)
-})
-
-test('Conda init leaves unexpected Windows CMD activation script unchanged', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-cmd-activate-unexpected-'))
-  await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
-  const unexpected = '@ECHO OFF\r\nREM unexpected upstream script\r\n'
-  const activatePath = await seedWindowsCondaActivateScript(root, unexpected)
-  const conda = createConda(createKernel(root))
-
-  await conda.init()
-
-  assert.equal(await fs.readFile(activatePath, 'utf8'), unexpected)
-})
-
-test('Conda init leaves Windows CMD activation script unchanged when patch anchor is missing', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-cmd-activate-missing-anchor-'))
-  await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
-  const missingAnchor = WINDOWS_CONDA_ACTIVATE_SCRIPT.replace(
-    '\r\n:: Routine to delete a temp file if CONDA_DEBUG is not set',
-    '\r\n:: unexpected routine header'
-  )
-  const activatePath = await seedWindowsCondaActivateScript(root, missingAnchor)
-  const conda = createConda(createKernel(root))
-
-  await conda.init()
-
-  assert.equal(await fs.readFile(activatePath, 'utf8'), missingAnchor)
-})
-
 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')
@@ -381,7 +245,6 @@ test('Conda install keeps the Windows Python 3.10.20 SSL-fixed build pin', async
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-python-pin-win32-'))
   const kernel = createKernel(root, 'win32')
   const calls = []
-  let activatePath
 
   kernel.bin.mods = []
   kernel.bin.download = async () => {}
@@ -392,7 +255,6 @@ test('Conda install keeps the Windows Python 3.10.20 SSL-fixed build pin', async
       const miniforge = path.join(root, 'bin', 'miniforge')
       await fs.mkdir(path.join(miniforge, 'conda-meta'), { recursive: true })
       await fs.writeFile(path.join(miniforge, 'python.exe'), 'fake python\n')
-      activatePath = await seedWindowsCondaActivateScript(root)
     }
   }
 
@@ -405,7 +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"'
   )
-  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,37 @@ 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, `@echo off\r\n${command}\r\n@echo on`)
+
+  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()