@hsusulist/luc 0.2.5 → 0.3.1

package/install.ps1

@@ -43,6 +43,10 @@ $script:UseAnsi = $false
 $script:InAltScreen = $false
 $script:Interactive = $false
 $script:Version = ''
+$script:MaintenanceAction = 'install'
+$script:ExistingComponents = @()
+$script:ExistingInstall = $null
+$script:ScriptDirectory = if ($PSCommandPath) { Split-Path -Parent $PSCommandPath } else { $null }
 
 # ---------------------------------------------------------------------------
 # Console helpers
@@ -253,6 +257,153 @@ function Show-SourcePage {
     }
 }
 
+function Get-InstalledDetails {
+    param([string]$RequestedPath)
+
+    $state = $null
+    $stateFile = Join-Path (Join-Path $env:LOCALAPPDATA 'LUC') 'state.json'
+    if (Test-Path -LiteralPath $stateFile -PathType Leaf) {
+        try {
+            $state = Get-Content -LiteralPath $stateFile -Raw | ConvertFrom-Json -ErrorAction Stop
+        } catch {
+            Write-Note "Could not read the install state: $($_.Exception.Message)" 'warn'
+        }
+    }
+
+    $path = $RequestedPath
+    if (-not $path -and $script:ScriptDirectory -and
+        (Test-Path -LiteralPath (Join-Path $script:ScriptDirectory 'luc.exe') -PathType Leaf)) {
+        $path = $script:ScriptDirectory
+    }
+    if (-not $path -and $state -and $state.installPath) { $path = [string]$state.installPath }
+    if (-not $path) { $path = $defaultInstallPath }
+    $path = Resolve-InstallPathValue $path
+    if (-not (Test-Path -LiteralPath (Join-Path $path 'luc.exe') -PathType Leaf)) { return $null }
+
+    if ($state -and $state.installPath) {
+        try {
+            $statePath = Resolve-InstallPathValue ([string]$state.installPath)
+            if (-not [string]::Equals($statePath, $path, [StringComparison]::OrdinalIgnoreCase)) {
+                $state = $null
+            }
+        } catch {
+            Write-Note "Could not resolve the install state path: $($_.Exception.Message)" 'warn'
+            $state = $null
+        }
+    } elseif ($RequestedPath) {
+        $state = $null
+    }
+
+    $uninstallKey = 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\Luc_is1'
+    $registeredPath = $null
+    $registeredVersion = $null
+    try {
+        $registration = Get-ItemProperty -LiteralPath $uninstallKey -ErrorAction Stop
+        $registeredPath = [string]$registration.InstallLocation
+        $registeredVersion = [string]$registration.DisplayVersion
+    } catch { }
+    $registeredMatches = $false
+    if ($registeredPath) {
+        try {
+            $registeredMatches = [string]::Equals(
+                (Resolve-InstallPathValue $registeredPath), $path, [StringComparison]::OrdinalIgnoreCase)
+            if (-not $registeredMatches) { $registeredVersion = $null }
+        } catch {
+            Write-Note "Could not resolve the Windows installer path: $($_.Exception.Message)" 'warn'
+            $registeredPath = $null
+            $registeredVersion = $null
+        }
+    }
+    $innoStateMatches = $state -and $state.source -eq 'inno' -and $state.installPath
+
+    $rawComponents = @()
+    if ($state -and $state.components) {
+        $rawComponents = @($state.components)
+    } else {
+        $manifestFile = Join-Path $path '.luc-manifest.json'
+        if (Test-Path -LiteralPath $manifestFile -PathType Leaf) {
+            try {
+                $manifest = Get-Content -LiteralPath $manifestFile -Raw | ConvertFrom-Json -ErrorAction Stop
+                if ($manifest.components) { $rawComponents = @($manifest.components) }
+            } catch {
+                Write-Note "Could not read the install manifest: $($_.Exception.Message)" 'warn'
+            }
+        }
+    }
+    if ($rawComponents.Count -eq 0) {
+        if ($registeredMatches -or ($innoStateMatches -and -not $registeredPath)) {
+            try {
+                $saved = (Get-ItemProperty -LiteralPath 'HKCU:\Software\LUC' -Name Components -ErrorAction Stop).Components
+                if ($saved) { $rawComponents = @([string]$saved -split '[,\s]+') }
+            } catch { }
+        }
+    }
+
+    $components = @()
+    foreach ($name in $rawComponents) {
+        $name = ([string]$name).ToLowerInvariant()
+        if ($name -eq 'ailib') { $name = 'ai' }
+        if ($optionalComponents -contains $name -and $components -notcontains $name) {
+            $components += $name
+        }
+    }
+
+    $uninstaller = $null
+    if ($innoStateMatches -or $registeredMatches) {
+        $uninstaller = Get-ChildItem -LiteralPath $path -Filter 'unins*.exe' -File -ErrorAction SilentlyContinue |
+            Select-Object -First 1
+    }
+    return [pscustomobject]@{
+        Path        = $path
+        Version     = if ($state -and $state.version) { [string]$state.version } elseif ($registeredVersion) { $registeredVersion } else { 'unknown' }
+        Components  = $components
+        Uninstaller = $uninstaller
+    }
+}
+
+function Show-MaintenancePage {
+    param($Install)
+
+    $items = @(
+        @{ Action = 'libraries'; Label = 'Install libraries'; Desc = 'Add or remove optional components' },
+        @{ Action = 'repair';    Label = 'Fix / reinstall';   Desc = 'Reinstall the current components' }
+    )
+    if ($Install.Uninstaller) {
+        $items += @{ Action = 'uninstall'; Label = 'Uninstall'; Desc = 'Remove LUC from this computer' }
+    }
+    $items += @{ Action = 'cancel'; Label = 'Cancel'; Desc = 'Exit without making changes' }
+    $index = 0
+    while ($true) {
+        Clear-Tui
+        Write-TuiHeader 'LUC is installed' 'Choose an action'
+        Write-Tui ("  Version   {0}" -f $Install.Version)
+        Write-Tui ("  Folder    {0}" -f $Install.Path) '90'
+        Write-Tui ''
+        for ($i = 0; $i -lt $items.Count; $i++) {
+            $marker = if ($i -eq $index) { '>' } else { ' ' }
+            $code = if ($i -eq $index) { '1;36' } else { '' }
+            Write-Tui ("  $marker " + $items[$i].Label) $code
+            Write-Tui ("      " + $items[$i].Desc) '90'
+            Write-Tui ''
+        }
+        Write-TuiFooter 'Up/Down move   Enter select   q quit'
+        $key = [Console]::ReadKey($true)
+        switch ($key.Key) {
+            'UpArrow'   { $index = ($index - 1 + $items.Count) % $items.Count }
+            'DownArrow' { $index = ($index + 1) % $items.Count }
+            'Enter'     { return $items[$index].Action }
+            'Escape'    { return 'cancel' }
+            'Q'         { return 'cancel' }
+        }
+    }
+}
+
+function Start-InnoUninstaller {
+    param($Install)
+    if (-not $Install.Uninstaller) { throw 'The Windows installer uninstaller was not found.' }
+    Start-Process -FilePath $Install.Uninstaller.FullName -ArgumentList '/NORESTART' | Out-Null
+}
+
 function Show-LicenseEntry {
     param([string]$LicenseText)
     Show-LicensePage $LicenseText
@@ -846,7 +997,7 @@ public static extern bool MoveFileEx(string existingFileName, string newFileName
 }
 
 function Install-ArchivePlan {
-    param([object[]]$Items)
+    param([object[]]$Items, [string[]]$RemovePaths = @())
     $journal = New-Object System.Collections.ArrayList
     try {
         foreach ($item in $Items) {
@@ -865,6 +1016,13 @@ function Install-ArchivePlan {
             try { Move-Item -LiteralPath $item.Staging -Destination $destination -Force }
             catch { throw "Cannot write '$destination': $($_.Exception.Message)" }
         }
+        foreach ($destination in $RemovePaths) {
+            if (-not (Test-Path -LiteralPath $destination -PathType Leaf)) { continue }
+            $old = "$destination.luc-old-$([guid]::NewGuid().ToString('N').Substring(0, 8))"
+            try { Move-Item -LiteralPath $destination -Destination $old -Force }
+            catch { throw "Cannot remove '$destination'. Close the program using it and try again." }
+            [void]$journal.Add([pscustomobject]@{ Destination = $destination; Old = $old })
+        }
     } catch {
         $failure = $_
         for ($i = $journal.Count - 1; $i -ge 0; $i--) {
@@ -966,6 +1124,26 @@ $downloadTemp = $null
 $tempChecksumFile = $null
 $zip = $null
 try {
+    if ($script:Interactive -and -not $LCodeOnly -and -not $Components) {
+        $script:ExistingInstall = Get-InstalledDetails -RequestedPath $InstallPath
+        if ($script:ExistingInstall) {
+            Enter-AltScreen
+            $script:MaintenanceAction = Show-MaintenancePage $script:ExistingInstall
+            Exit-AltScreen
+            if ($script:MaintenanceAction -eq 'cancel') {
+                Write-Note 'Installation cancelled.' 'warn'
+                exit 2
+            }
+            if ($script:MaintenanceAction -eq 'uninstall') {
+                Start-InnoUninstaller $script:ExistingInstall
+                Write-Note 'LUC uninstaller started.' 'ok'
+                exit 0
+            }
+            $InstallPath = $script:ExistingInstall.Path
+            $script:ExistingComponents = @($script:ExistingInstall.Components)
+        }
+    }
+
     $sourceSpecified = $PSBoundParameters.ContainsKey('Source')
     if (-not $Source) {
         if ($ArchivePath) { $Source = 'local' } else { $Source = 'github' }
@@ -1081,7 +1259,13 @@ try {
     $licenseText = Read-ZipEntryText $zip 'LICENCE'
     if (-not $licenseText) { $licenseText = 'LUC is free software released under the Apache License 2.0.' }
 
-    $selected = if ($LCodeOnly) { @('lcode') } else { @() }
+    if ($LCodeOnly) {
+        $selected = @('lcode')
+    } elseif ($script:MaintenanceAction -ne 'install') {
+        $selected = @($script:ExistingComponents)
+    } else {
+        $selected = @()
+    }
     if (-not $LCodeOnly -and $Components) {
         foreach ($item in $Components) {
             foreach ($name in ($item -split '[,\s]+')) {
@@ -1094,7 +1278,8 @@ try {
         }
     }
 
-    if (-not $LCodeOnly -and $script:Interactive -and -not $Components) {
+    if (-not $LCodeOnly -and $script:Interactive -and -not $Components -and
+        $script:MaintenanceAction -ne 'repair') {
         Enter-AltScreen
         $picked = Show-ComponentPage -Preselected $selected -LicenseText $licenseText
         Exit-AltScreen
@@ -1115,6 +1300,14 @@ try {
         $InstallPath = Resolve-InstallPathValue $InstallPath
     }
 
+    if (-not $script:ExistingInstall -or
+        -not [string]::Equals($script:ExistingInstall.Path, $InstallPath, [StringComparison]::OrdinalIgnoreCase)) {
+        $script:ExistingInstall = Get-InstalledDetails -RequestedPath $InstallPath
+    }
+    if ($script:ExistingInstall) {
+        $script:ExistingComponents = @($script:ExistingInstall.Components)
+    }
+
     $vsCodeTarget = Join-Path $env:USERPROFILE '.vscode\extensions\hsusulist.luc'
     $binaryName = if ($LCodeOnly) { 'lcode.exe' } else { 'luc.exe' }
     $upgrade = Test-Path -LiteralPath (Join-Path $InstallPath $binaryName) -PathType Leaf
@@ -1140,6 +1333,10 @@ try {
             Exit-AltScreen
             if ($null -eq $picked -or -not $InstallPath) { Write-Note 'Installation cancelled.' 'warn'; exit 2 }
             $selected = @($picked)
+            $InstallPath = Resolve-InstallPathValue $InstallPath
+            $script:ExistingInstall = Get-InstalledDetails -RequestedPath $InstallPath
+            $script:ExistingComponents = if ($script:ExistingInstall) { @($script:ExistingInstall.Components) } else { @() }
+            $upgrade = Test-Path -LiteralPath (Join-Path $InstallPath $binaryName) -PathType Leaf
         }
     }
 
@@ -1149,10 +1346,24 @@ try {
         throw "Installation archive did not produce $binaryName."
     }
 
+    $removePaths = @()
+    if ($upgrade -and -not $LCodeOnly -and $script:ExistingComponents.Count -gt 0) {
+        $previousPlan = Get-ArchivePlan -Zip $zip -SelectedComponents $script:ExistingComponents -Target $InstallPath -VsCodeTarget $vsCodeTarget
+        $newDestinations = @{}
+        foreach ($item in $archivePlan.Items) { $newDestinations[$item.Destination.ToLowerInvariant()] = $true }
+        foreach ($item in $previousPlan.Items) {
+            if (-not $newDestinations.ContainsKey($item.Destination.ToLowerInvariant()) -and
+                (Test-Path -LiteralPath $item.Destination -PathType Leaf)) {
+                $removePaths += $item.Destination
+            }
+        }
+    }
+
     $roots = @($InstallPath)
-    if ($selected -contains 'vscode') { $roots += $vsCodeTarget }
+    if (($selected -contains 'vscode') -or ($script:ExistingComponents -contains 'vscode')) { $roots += $vsCodeTarget }
+    $lockItems = @($archivePlan.Items) + @($removePaths | ForEach-Object { @{ Destination = $_ } })
     Write-Step 'Checking for running programs and locked files'
-    Test-InstallLocks -Items $archivePlan.Items -Roots $roots
+    Test-InstallLocks -Items $lockItems -Roots $roots
     Write-StepDone 'No running LUC process blocks the install'
 
     Test-DiskSpace $InstallPath $archivePlan.TotalBytes
@@ -1165,17 +1376,19 @@ try {
     Write-StepDone "Extracted $($archivePlan.Items.Count) files"
 
     Write-Step 'Installing files'
-    Install-ArchivePlan $archivePlan.Items
-    Write-StepDone 'Files installed'
+    Install-ArchivePlan -Items $archivePlan.Items -RemovePaths $removePaths
+    if ($removePaths.Count) { Write-StepDone "Files installed; removed $($removePaths.Count) deselected files" }
+    else { Write-StepDone 'Files installed' }
 
     if (-not (Test-Path -LiteralPath (Join-Path $InstallPath $binaryName) -PathType Leaf)) {
         throw "Installation finished without $binaryName. The previous version was restored."
     }
 
     Write-InstallManifest $script:Version $InstallPath $selected -LCodeOnly:$LCodeOnly
-    Write-InstallState $script:Version $InstallPath $selected $Source -LCodeOnly:$LCodeOnly
+    $stateSource = if ($script:ExistingInstall -and $script:ExistingInstall.Uninstaller) { 'inno' } else { $Source }
+    Write-InstallState $script:Version $InstallPath $selected $stateSource -LCodeOnly:$LCodeOnly
 
-    # Keep a copy of this script next to luc.exe so that "luc --install" works
+    # Keep a copy of this script next to luc.exe so that "luc install" works
     # even when the archive was built before install.ps1 was bundled in it.
     if (-not $LCodeOnly) {
         try {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@hsusulist/luc",
-  "version": "0.2.5",
-  "description": "LUC language installer and launcher for Windows",
+  "version": "0.3.1",
+  "description": "LUC language installer and launcher",
   "bin": {
     "luc": "bin/luc.js"
   },
   "files": [
     "bin",
     "scripts",
+    "src",
     "install.ps1",
     "LICENCE",
     "README.md"
@@ -17,9 +18,7 @@
     "postpack": "node scripts/postpack.js",
     "postinstall": "node scripts/postinstall.js"
   },
-  "os": [
-    "win32"
-  ],
+  "os": ["win32", "linux"],
   "engines": {
     "node": ">=16"
   },

package/scripts/build-linux.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function buildLinux(packageDir, name) {
+  const sourceDir = path.join(packageDir, 'src');
+  const files = ['luc_core.c', 'luc_libs.c', 'luc_trans.c'].map((file) =>
+    path.join(sourceDir, file)
+  );
+  for (const file of files) {
+    if (!fs.existsSync(file)) {
+      throw new Error('Linux source is missing from this npm package: ' + file);
+    }
+  }
+
+  const outputDir = path.join(packageDir, 'native');
+  const output = path.join(outputDir, name);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const compiler = process.env.CC || 'cc';
+  const args = ['-O2', '-std=gnu99', '-o', output].concat(files, ['-lm', '-ldl']);
+  const result = spawnSync(compiler, args, { stdio: 'inherit' });
+  if (result.error) {
+    throw new Error('could not start ' + compiler + ' to build LUC: ' + result.error.message);
+  }
+  if (result.status !== 0) {
+    throw new Error(compiler + ' failed to build LUC (exit code ' + result.status + ').');
+  }
+  return output;
+}
+
+module.exports = { buildLinux };

package/scripts/postinstall.js

@@ -5,6 +5,12 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
+if (process.platform === 'linux') {
+  const { buildLinux } = require('./build-linux');
+  buildLinux(path.join(__dirname, '..'), 'luc');
+  process.exit(0);
+}
+
 function findBinary() {
   const candidates = [];
   const local = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
@@ -35,7 +41,7 @@ if (process.platform !== 'win32' || findBinary()) {
 
 const script = path.join(__dirname, '..', 'install.ps1');
 if (!fs.existsSync(script)) {
-  console.warn('luc: install.ps1 is missing; run "luc --install" after installing.');
+  console.warn('luc: install.ps1 is missing; run "luc install" after installing.');
   process.exit(0);
 }
 
@@ -47,6 +53,6 @@ const result = spawnSync(
 );
 
 if (result.error || result.status !== 0) {
-  console.warn('luc: automatic install did not finish. Run "luc --install" to open the installer.');
+  console.warn('luc: automatic install did not finish. Run "luc install" to open the installer.');
 }
 process.exit(0);

package/scripts/postpack.js

@@ -9,3 +9,17 @@ for (const name of ['install.ps1', 'LICENCE']) {
   } catch (_) {
   }
 }
+
+const source = path.join(process.cwd(), 'src');
+const marker = path.join(process.cwd(), '.npm-source-bundle-generated');
+if (fs.existsSync(marker)) {
+  fs.rmSync(source, { recursive: true, force: true });
+  fs.unlinkSync(marker);
+}
+
+const helper = path.join(process.cwd(), 'scripts', 'build-linux.js');
+const helperMarker = path.join(process.cwd(), '.npm-build-linux-generated');
+if (fs.existsSync(helperMarker)) {
+  fs.unlinkSync(helper);
+  fs.unlinkSync(helperMarker);
+}

package/scripts/prepack.js

@@ -17,3 +17,30 @@ function copy(name) {
 
 copy('install.ps1');
 copy('LICENCE');
+
+const source = path.join(root, 'src');
+const target = path.join(here, 'src');
+if (fs.existsSync(target)) {
+  throw new Error('refusing to overwrite existing npm/src directory');
+}
+fs.mkdirSync(target);
+for (const name of ['luc_core.c', 'luc_libs.c', 'luc_nums.c', 'luc_trans.c', 'luc.h']) {
+  const from = path.join(source, name);
+  if (!fs.existsSync(from)) throw new Error('missing release source: ' + from);
+  fs.copyFileSync(from, path.join(target, name));
+}
+const linuxEditor = path.join(source, 'lcode-linux', 'lcode.c');
+if (!fs.existsSync(linuxEditor)) throw new Error('missing Linux editor source: ' + linuxEditor);
+fs.mkdirSync(path.join(target, 'lcode-linux'));
+fs.copyFileSync(linuxEditor, path.join(target, 'lcode-linux', 'lcode.c'));
+fs.writeFileSync(path.join(here, '.npm-source-bundle-generated'), 'generated by prepack\n');
+
+const helper = path.join(__dirname, 'build-linux.js');
+const packagedHelper = path.join(here, 'scripts', 'build-linux.js');
+if (helper !== packagedHelper) {
+  if (fs.existsSync(packagedHelper)) {
+    throw new Error('refusing to overwrite existing scripts/build-linux.js');
+  }
+  fs.copyFileSync(helper, packagedHelper);
+  fs.writeFileSync(path.join(here, '.npm-build-linux-generated'), 'generated by prepack\n');
+}