fauxnix-cli 0.9.3 → 0.12.0

package/dist/commands/archive.js

@@ -28,19 +28,89 @@ const PS_GZ_FNS = [
     '  $fx_gz.Close()',
     '  return ,$fx_ms.ToArray()',
     '}',
-    'function fx-gz-dbytes($src) {',
-    '  $fx_fs = [IO.File]::OpenRead($src)',
-    '  $fx_gz = New-Object System.IO.Compression.GZipStream($fx_fs, [System.IO.Compression.CompressionMode]::Decompress)',
-    '  $fx_ms = New-Object System.IO.MemoryStream',
+    'function fx-gz-open($src, $isBytes) {',
+    '  if ($isBytes) { $fx_raw = New-Object System.IO.MemoryStream(,$src) }',
+    '  else { $fx_raw = [IO.File]::OpenRead($src) }',
+    '  try {',
+    '    return (New-Object System.IO.Compression.GZipStream($fx_raw, [System.IO.Compression.CompressionMode]::Decompress))',
+    '  } catch {',
+    '    $fx_raw.Dispose()',
+    '    throw',
+    '  }',
+    '}',
+    // Drain the complete stream before producing stdout. Besides keeping -t
+    // bounded, this preserves the old all-or-nothing behavior for malformed
+    // inputs while remembering which text decoder the second pass should use.
+    'function fx-gz-validate($src, $isBytes) {',
+    '  $fx_gz = fx-gz-open $src $isBytes',
     '  $fx_buf = New-Object byte[] 65536',
-    '  while ($true) {',
-    '    $fx_n = $fx_gz.Read($fx_buf, 0, $fx_buf.Length)',
-    '    if ($fx_n -le 0) { break }',
-    '    $fx_ms.Write($fx_buf, 0, $fx_n)',
+    '  $fx_dec = (New-Object System.Text.UTF8Encoding($false, $true)).GetDecoder()',
+    '  $fx_utf8 = $true',
+    '  try {',
+    '    while ($true) {',
+    '      $fx_n = $fx_gz.Read($fx_buf, 0, $fx_buf.Length)',
+    '      if ($fx_n -le 0) { break }',
+    '      if ($fx_utf8) {',
+    '        try { [void]$fx_dec.GetCharCount($fx_buf, 0, $fx_n, $false) }',
+    '        catch [System.Text.DecoderFallbackException] { $fx_utf8 = $false }',
+    '      }',
+    '    }',
+    '    if ($fx_utf8) {',
+    '      try { [void]$fx_dec.GetCharCount($fx_buf, 0, 0, $true) }',
+    '      catch [System.Text.DecoderFallbackException] { $fx_utf8 = $false }',
+    '    }',
+    '    return $fx_utf8',
+    '  } finally {',
+    '    $fx_gz.Dispose()',
+    '  }',
+    '}',
+    'function fx-gz-stream-text($src, $isBytes) {',
+    '  $fx_utf8 = fx-gz-validate $src $isBytes',
+    '  if ($fx_utf8) { $fx_enc = New-Object System.Text.UTF8Encoding($false, $true) }',
+    '  else { try { $fx_enc = [System.Text.Encoding]::GetEncoding(936) } catch { $fx_enc = [System.Text.Encoding]::ASCII } }',
+    '  $fx_gz = fx-gz-open $src $isBytes',
+    '  $fx_sr = New-Object System.IO.StreamReader($fx_gz, $fx_enc, $false, 65536)',
+    '  try {',
+    '    while ($true) {',
+    '      $fx_line = $fx_sr.ReadLine()',
+    '      if ($null -eq $fx_line) { break }',
+    '      Write-Output -NoEnumerate $fx_line',
+    '    }',
+    '  } finally {',
+    '    $fx_sr.Dispose()',
+    '  }',
+    '}',
+    // File output is streamed into a sibling temporary file. The destination
+    // changes only after a complete decompression, and the temporary is removed
+    // on every failed path.
+    'function fx-gz-stream-file($src, $dst) {',
+    '  $fx_full = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($dst)',
+    '  $fx_parent = [IO.Path]::GetDirectoryName($fx_full)',
+    "  $fx_tmp = [IO.Path]::Combine($fx_parent, '.fauxnix-gzip-' + [Guid]::NewGuid().ToString('N') + '.tmp')",
+    '  $fx_gz = $null',
+    '  $fx_os = $null',
+    '  try {',
+    '    $fx_gz = fx-gz-open $src $false',
+    "    $fx_os = New-Object System.IO.FileStream($fx_tmp, [IO.FileMode]::CreateNew, [IO.FileAccess]::Write, [IO.FileShare]::None)",
+    '    $fx_buf = New-Object byte[] 65536',
+    '    while ($true) {',
+    '      $fx_n = $fx_gz.Read($fx_buf, 0, $fx_buf.Length)',
+    '      if ($fx_n -le 0) { break }',
+    '      $fx_os.Write($fx_buf, 0, $fx_n)',
+    '    }',
+    '    $fx_os.Dispose(); $fx_os = $null',
+    '    $fx_gz.Dispose(); $fx_gz = $null',
+    '    if ([IO.File]::Exists($fx_full)) {',
+    '      $fx_null = [System.Management.Automation.Language.NullString]::Value',
+    '      [IO.File]::Replace($fx_tmp, $fx_full, $fx_null)',
+    '    }',
+    '    else { [IO.File]::Move($fx_tmp, $fx_full) }',
+    '  } catch {',
+    '    if ($null -ne $fx_os) { $fx_os.Dispose() }',
+    '    if ($null -ne $fx_gz) { $fx_gz.Dispose() }',
+    '    if ([IO.File]::Exists($fx_tmp)) { [IO.File]::Delete($fx_tmp) }',
+    '    throw',
     '  }',
-    '  $fx_gz.Close()',
-    '  $fx_fs.Close()',
-    '  return ,$fx_ms.ToArray()',
     '}',
 ].join('\n');
 /** Parse GNU gzip-style argv (works for gzip/gunzip/zcat). */
@@ -121,7 +191,7 @@ function gzBlock(args, ctx, forced) {
                 : "  [Console]::Error.WriteLine('gzip: compressed data not written to a terminal. Use -f to force compression.')",
             '  $script:fx_exit = 1',
         ].join('\n')
-        : p.decompress
+        : p.decompress || p.test
             ? [
                 // NOTE stdin fidelity limitation: pipeline stdin arrives as decoded
                 // text lines, so only gzip streams that survived the text pipeline
@@ -130,13 +200,7 @@ function gzBlock(args, ctx, forced) {
                 "  if ($fx_txt -ne '') { $fx_txt = $fx_txt + \"`n\" }",
                 '  $fx_in = [System.Text.Encoding]::UTF8.GetBytes($fx_txt)',
                 '  try {',
-                '    $fx_ms = New-Object System.IO.MemoryStream(,$fx_in)',
-                '    $fx_gz = New-Object System.IO.Compression.GZipStream($fx_ms, [System.IO.Compression.CompressionMode]::Decompress)',
-                '    $fx_mo = New-Object System.IO.MemoryStream',
-                '    $fx_buf = New-Object byte[] 65536',
-                '    while ($true) { $fx_n = $fx_gz.Read($fx_buf, 0, $fx_buf.Length); if ($fx_n -le 0) { break }; $fx_mo.Write($fx_buf, 0, $fx_n) }',
-                '    $fx_gz.Close()',
-                '    fx-lines (fx-dec $fx_mo.ToArray())',
+                p.test ? '    [void](fx-gz-validate $fx_in $true)' : '    fx-gz-stream-text $fx_in $true',
                 '  } catch {',
                 "    [Console]::Error.WriteLine('gzip: stdin: not in gzip format')",
                 '    $script:fx_exit = 1',
@@ -163,14 +227,13 @@ function gzBlock(args, ctx, forced) {
         '    }',
     ];
     if (p.test) {
-        fileLoop.push('    try { $fx_tb = fx-gz-dbytes $fx_f }', "    catch { [Console]::Error.WriteLine('gzip: ' + $fx_f + ': not in gzip format'); $script:fx_exit = 1 }", '    continue');
+        fileLoop.push('    try { [void](fx-gz-validate $fx_f $false) }', "    catch { [Console]::Error.WriteLine('gzip: ' + $fx_f + ': not in gzip format'); $script:fx_exit = 1 }", '    continue');
     }
     else if (p.decompress) {
         fileLoop.push('    $fx_low = $fx_f.ToLower()', "    if (-not ($fx_low.EndsWith('.gz') -or $fx_low.EndsWith('.tgz'))) {", "      [Console]::Error.WriteLine('gzip: ' + $fx_f + ': unknown suffix -- ignored')", '      $script:fx_exit = 2', '      continue', '    }', '    $fx_out = $fx_f.Substring(0, $fx_f.Length - 3)', "    if ($fx_low.EndsWith('.tgz')) { $fx_out = $fx_f.Substring(0, $fx_f.Length - 4) + '.tar' }", '    try {', p.stdout
-            ? '      fx-lines (fx-dec (fx-gz-dbytes $fx_f))'
+            ? '      fx-gz-stream-text $fx_f $false'
             : [
-                '      $fx_o = fx-gz-dbytes $fx_f',
-                '      [IO.File]::WriteAllBytes($fx_out, $fx_o)',
+                '      fx-gz-stream-file $fx_f $fx_out',
                 '      try { (Get-Item -LiteralPath $fx_out).LastWriteTime = (Get-Item -LiteralPath $fx_f).LastWriteTime } catch {}',
                 '      if (-not ' + b(p.keep) + ') { Remove-Item -LiteralPath $fx_f -Force }',
             ].join('\n'), "    } catch { [Console]::Error.WriteLine('gzip: ' + $fx_f + ': not in gzip format'); $script:fx_exit = 1 }");
@@ -201,6 +264,8 @@ const gunzip = (args, ctx) => gzBlock(args, ctx, { decompress: true });
 const zcat = (args, ctx) => gzBlock(args, ctx, { decompress: true, stdout: true });
 /* ------------------------------------------------------------------ */
 /* tar — Windows 10+ ships bsdtar as tar.exe, pass everything through  */
+/* Intentionally unspec'd: registerSpec fail-loud would reject GNU     */
+/* flags bsdtar accepts (--numeric-owner, …). Same class as find.      */
 /* ------------------------------------------------------------------ */
 const tar = (args) => {
     return [
@@ -276,7 +341,7 @@ const zip = (args) => {
         "    $fx_dst = $fx_arc",
         '    $fx_rename = $false',
         "    if (-not $fx_arc.ToLower().EndsWith('.zip')) { $fx_dst = $fx_arc + '.zip'; $fx_rename = $true }",
-        '    Compress-Archive -Path $fx_valid -DestinationPath $fx_dst -Force -ErrorAction Stop',
+        '    Compress-Archive -LiteralPath $fx_valid -DestinationPath $fx_dst -Force -ErrorAction Stop',
         // PS 5.1 Compress-Archive writes `\` entry separators; rewrite them to `/`
         // so GNU unzip/bsdtar see proper directory entries.
         '    Add-Type -AssemblyName System.IO.Compression.FileSystem',
@@ -374,8 +439,87 @@ const unzip = (args) => {
     ].join('\n');
 };
 /* ------------------------------------------------------------------ */
-/* exports                                                             */
+/* CommandSpec (C-5 archive slice)                                     */
+/* tar stays unspec'd: fx-native to tar.exe; unknown GNU flags must    */
+/* reach bsdtar. gzip -f is a no-op today and the stdin-from-terminal  */
+/* message advertises it, so it is unsupported (force from terminal)   */
+/* rather than a silent ignore.                                        */
 /* ------------------------------------------------------------------ */
+const gzipOptions = [
+    { short: 'd', long: '--decompress', support: 'implemented' },
+    { long: '--uncompress', support: 'implemented' },
+    { short: 'k', long: '--keep', support: 'implemented' },
+    { short: 'c', long: '--stdout', support: 'implemented' },
+    { long: '--to-stdout', support: 'implemented' },
+    { short: 't', long: '--test', support: 'implemented' },
+    { short: '1', long: '--fast', support: 'implemented' },
+    { short: '2', support: 'implemented' },
+    { short: '3', support: 'implemented' },
+    { short: '4', support: 'implemented' },
+    { short: '5', support: 'implemented' },
+    { short: '6', support: 'implemented' },
+    { short: '7', support: 'implemented' },
+    { short: '8', support: 'implemented' },
+    { short: '9', long: '--best', support: 'implemented' },
+    { short: 'f', long: '--force', support: 'unsupported', reason: 'force from terminal' },
+    { short: 'q', long: '--quiet', support: 'unsupported', reason: 'quiet' },
+    { short: 'v', long: '--verbose', support: 'unsupported', reason: 'verbose' },
+    { short: 'n', long: '--no-name', support: 'unsupported', reason: 'no-name' },
+    { short: 'r', long: '--recursive', support: 'unsupported', reason: 'recursive' },
+    { short: 'S', long: '--suffix', takesValue: true, support: 'unsupported', reason: 'suffix' },
+];
+export const specs = [
+    {
+        names: ['gzip'],
+        options: gzipOptions,
+        effects: ['read', 'write', 'delete'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: gzip,
+    },
+    {
+        names: ['gunzip'],
+        options: gzipOptions,
+        effects: ['read', 'write', 'delete'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: gunzip,
+    },
+    {
+        names: ['zcat'],
+        options: gzipOptions,
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: zcat,
+    },
+    {
+        names: ['zip'],
+        options: [
+            // Compress-Archive always recurses directory inputs; -q is already quiet.
+            { short: 'r', support: 'implemented' },
+            { short: 'q', support: 'implemented' },
+            { short: 'x', long: '--exclude', takesValue: true, support: 'unsupported', reason: 'exclude patterns' },
+        ],
+        effects: ['read', 'write'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: zip,
+    },
+    {
+        names: ['unzip'],
+        options: [
+            { short: 'l', support: 'implemented' },
+            { short: 'o', support: 'implemented' },
+            { short: 'q', support: 'implemented' },
+            { short: 'd', long: '--directory', takesValue: true, support: 'implemented' },
+        ],
+        effects: ['read', 'write'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: unzip,
+    },
+];
 export const handlers = {
     tar,
     gzip,

package/dist/commands/install-all.js

@@ -2,9 +2,9 @@ import { registerAll, registerSpecs } from '../registry.js';
 import { handlers as files, specs as fileSpecs } from './files.js';
 import { handlers as textFilters, specs as textFilterSpecs } from './text-filters.js';
 import { handlers as textIo, specs as textIoSpecs } from './text-io.js';
-import { handlers as sysinfo } from './sysinfo.js';
+import { handlers as sysinfo, specs as sysinfoSpecs } from './sysinfo.js';
 import { handlers as net } from './net.js';
-import { handlers as archive } from './archive.js';
+import { handlers as archive, specs as archiveSpecs } from './archive.js';
 /** Register every built-in Linux command translator. Side-effectful import. */
 export function installAll() {
     registerAll(files);
@@ -16,5 +16,7 @@ export function installAll() {
     registerSpecs(fileSpecs);
     registerSpecs(textIoSpecs);
     registerSpecs(textFilterSpecs);
+    registerSpecs(archiveSpecs);
+    registerSpecs(sysinfoSpecs);
 }
 installAll();

package/dist/commands/net.d.ts

@@ -1,2 +1,11 @@
 import { Handler } from '../registry.js';
+/**
+ * GNU wget-style default output basename for the curl fallback.
+ *
+ * A valid UTF-8 percent sequence is decoded exactly once. Malformed sequences
+ * remain literal, while characters Windows cannot put in a filename are
+ * percent-encoded again. This keeps encoded separators inside one basename
+ * instead of accidentally turning them into local path components.
+ */
+export declare function urlFileName(u: string): string;
 export declare const handlers: Record<string, Handler>;

package/dist/commands/net.js

@@ -105,21 +105,57 @@ const curl = (args) => {
 /* ------------------------------------------------------------------ */
 /* wget                                                                */
 /* ------------------------------------------------------------------ */
-/** GNU wget default output filename derived from a literal URL (index.html when bare). */
-function urlFileName(u) {
-    // keep only the path component (drop scheme, host, query, fragment)
-    let p = u.split('#')[0].split('?')[0];
-    const sm = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.exec(p);
-    if (sm)
-        p = p.slice(sm[0].length);
-    const slash = p.indexOf('/');
-    if (slash >= 0)
-        p = p.slice(slash + 1);
-    else
-        p = '';
-    if (p === '')
-        return 'index.html'; // no path (or trailing /) → GNU default
-    return p;
+const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
+function percentEncodeChar(char) {
+    return Array.from(Buffer.from(char, 'utf8'), (byte) => '%' + byte.toString(16).toUpperCase()).join('');
+}
+/**
+ * GNU wget-style default output basename for the curl fallback.
+ *
+ * A valid UTF-8 percent sequence is decoded exactly once. Malformed sequences
+ * remain literal, while characters Windows cannot put in a filename are
+ * percent-encoded again. This keeps encoded separators inside one basename
+ * instead of accidentally turning them into local path components.
+ */
+export function urlFileName(u) {
+    let pathname;
+    try {
+        pathname = new URL(u).pathname;
+    }
+    catch {
+        return 'index.html';
+    }
+    // URL normalisation handles dot segments. A bare path or trailing slash uses
+    // wget's conventional index filename.
+    if (pathname === '' || pathname.endsWith('/'))
+        return 'index.html';
+    const rawName = pathname.slice(pathname.lastIndexOf('/') + 1);
+    let decoded = rawName;
+    try {
+        decoded = decodeURIComponent(rawName);
+    }
+    catch {
+        // Keep malformed percent escapes literal so naming remains deterministic.
+    }
+    let safe = '';
+    for (const char of decoded) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code <= 0x1f || code === 0x7f || /[<>:"/\\|?*]/.test(char)) {
+            safe += percentEncodeChar(char);
+        }
+        else {
+            safe += char;
+        }
+    }
+    // Windows strips trailing dots/spaces and treats DOS device basenames as
+    // special even when an extension is present. Preserve the intended text in
+    // a stable, ordinary filename instead.
+    safe = safe.replace(/[. ]+$/, (suffix) => Array.from(suffix, (char) => percentEncodeChar(char)).join(''));
+    if (safe === '' || safe === '.' || safe === '..')
+        return 'index.html';
+    if (WINDOWS_DEVICE_NAME.test(safe))
+        safe = '_' + safe;
+    return safe;
 }
 /** Map GNU wget argv → curl.exe argv (only literal words are rewritten). */
 function mapWgetArgs(args) {

package/dist/commands/sysinfo.d.ts

@@ -1,2 +1,3 @@
-import { Handler } from '../registry.js';
+import { CommandSpec, Handler } from '../registry.js';
+export declare const specs: CommandSpec[];
 export declare const handlers: Record<string, Handler>;