arcane-os 0.90.0 → 0.92.0

package/src/windows-git-executable.mjs

@@ -0,0 +1,103 @@
+import Is from 'strong-type';
+import {stat} from 'node:fs/promises';
+import path from 'node:path';
+import {throwIfAborted} from './errors.mjs';
+
+const is=new Is(false);
+let installedDirectory=null;
+
+// Git for Windows records its chosen location for third-party integrations.
+// Read both installation scopes/views in one owned Windows process. No guessed
+// installation paths or changes to the registry/environment are needed.
+const READ_INSTALLATIONS=String.raw`
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
+$installations = [System.Collections.Generic.List[string]]::new()
+$views = @([Microsoft.Win32.RegistryView]::Registry32)
+if ([Environment]::Is64BitOperatingSystem) {
+    $views = @([Microsoft.Win32.RegistryView]::Registry64, [Microsoft.Win32.RegistryView]::Registry32)
+}
+foreach ($hive in @([Microsoft.Win32.RegistryHive]::CurrentUser, [Microsoft.Win32.RegistryHive]::LocalMachine)) {
+    foreach ($view in $views) {
+        $base = [Microsoft.Win32.RegistryKey]::OpenBaseKey($hive, $view)
+        try {
+            $key = $base.OpenSubKey('Software\GitForWindows')
+            if ($null -ne $key) {
+                try {
+                    $location = $key.GetValue('InstallPath')
+                    if ($location -is [string] -and $location.Length -gt 0 -and -not $installations.Contains($location)) {
+                        $installations.Add($location)
+                    }
+                } finally { $key.Dispose() }
+            }
+        } finally { $base.Dispose() }
+    }
+}
+ConvertTo-Json -InputObject @($installations.ToArray()) -Compress
+`;
+
+function environmentKey(environment,name){
+    return Object.keys(environment).sort().find(function matchingKey(key){
+        return key.toLowerCase()===name;
+    });
+}
+
+export function appendWindowsGitDirectory(environment,directory){
+    const keys=Object.keys(environment).filter(function pathKey(key){
+        return key.toLowerCase()==='path';
+    }).sort();
+    const selectedKey=keys[0]??'Path';
+    // Node chooses the first case-insensitive key before omitting undefined.
+    // libuv uses the parent's PATH if the child has none; null becomes 'null'.
+    const selected=environment[selectedKey];
+    const original=selected===undefined
+        ?process.env[environmentKey(process.env,'path')]??'':selected;
+    const result={...environment};
+    for(const key of keys)delete result[key];
+    const originalPath=`${original}`;
+    result[selectedKey]=`${originalPath}${originalPath?';':''}"${directory}"`;
+    return result;
+}
+
+async function installedGitExists(directory){
+    try{
+        return (await stat(path.win32.join(directory,'git.exe'))).isFile();
+    }catch(error){
+        if(error.code==='ENOENT'||error.code==='ENOTDIR')return false;
+        throw error;
+    }
+}
+
+export async function windowsGitEnvironment(environment,{run,signal,onEvent}={}){
+    throwIfAborted(signal);
+    const retained=installedDirectory;
+    if(retained){
+        const available=await installedGitExists(retained);
+        throwIfAborted(signal);
+        if(available)return appendWindowsGitDirectory(environment,retained);
+        if(installedDirectory===retained)installedDirectory=null;
+    }
+
+    const systemRoot=process.env[environmentKey(process.env,'systemroot')];
+    if(!systemRoot)return environment;
+    const powershell=path.win32.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe');
+    const result=await run(powershell,['-NoProfile','-NonInteractive','-Command',READ_INSTALLATIONS],{
+        signal,onEvent,emitOutputEvents:false
+    });
+    throwIfAborted(signal);
+    const locations=JSON.parse(result.stdout);
+    if(!is.array(locations))throw new TypeError('Git installation discovery did not return a location list.');
+    for(const location of locations){
+        if(!is.string(location)||!path.win32.isAbsolute(location))continue;
+        const directory=path.win32.join(location,'cmd');
+        const available=await installedGitExists(directory);
+        throwIfAborted(signal);
+        if(available){
+            // Only successful, still-present discovery is retained. Concurrent
+            // first callers own separate lookups and cancellation independently.
+            installedDirectory=directory;
+            return appendWindowsGitDirectory(environment,directory);
+        }
+    }
+    return environment;
+}

package/src/workspace-runtime.mjs

@@ -2,6 +2,7 @@ import Is from 'strong-type';
 import {randomUUID} from 'node:crypto';
 import {copyFile,lstat,mkdir,readFile,readdir,realpath,rename,rm,writeFile} from 'node:fs/promises';
 import path from 'node:path';
+import {materializeBrowserDecisions} from './browser-decisions-distribution.mjs';
 import {SDK_VERSION} from './constants.mjs';
 import {rewriteAssetReferences} from './import-map.mjs';
 import {getSdkRoot} from './runtime.mjs';
@@ -85,85 +86,6 @@ async function removeTemporaryTree(location){
     await rm(location,{recursive:true,force:true}).catch(()=>{});
 }
 
-async function materializeBrowserDecisions(destination, signal, onEvent) {
-    const transformers = 'https://cdn.jsdelivr.net/npm/@huggingface/transformers@4.3.0/';
-    const onnx = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.31.0-dev.20260914-8d85527a0/';
-    const files = [
-        {name: 'transformers.min.js', url: `${transformers}dist/transformers.min.js`},
-        {name: 'ort-wasm-simd-threaded.asyncify.mjs', url: `${onnx}dist/ort-wasm-simd-threaded.asyncify.mjs`},
-        {name: 'ort-wasm-simd-threaded.asyncify.wasm', url: `${onnx}dist/ort-wasm-simd-threaded.asyncify.wasm`},
-        {name: 'TRANSFORMERS-LICENSE', url: `${transformers}LICENSE`},
-        {name: 'ONNX-RUNTIME-LICENSE', url: `${onnx}LICENSE`}
-    ];
-    const controller = new AbortController();
-    function cancelDistribution() {
-        controller.abort(signal.reason);
-    }
-    signal?.addEventListener('abort', cancelDistribution, {once: true});
-    if (signal?.aborted) cancelDistribution();
-    let completed = 0;
-    try {
-        throwIfAborted(controller.signal);
-        await emit(
-            onEvent,
-            {type: 'workspace.decisions.started', completed, total: files.length}
-        );
-        throwIfAborted(controller.signal);
-        await mkdir(destination, {recursive: true});
-        async function acquireDistributionFile(file) {
-            try {
-                throwIfAborted(controller.signal);
-                const response = await fetch(file.url, {signal: controller.signal});
-                const content = new Uint8Array(await response.arrayBuffer());
-                if (!response.ok) {
-                    const error = new Error(`Browser decision distribution returned HTTP ${response.status} ${response.statusText}.`);
-                    error.code = 'ARCANE_DECISION_DISTRIBUTION_DOWNLOAD_FAILED';
-                    error.response = {
-                        url: response.url,
-                        status: response.status,
-                        statusText: response.statusText,
-                        headers: [...response.headers],
-                        content
-                    };
-                    throw error;
-                }
-                throwIfAborted(controller.signal);
-                // Upstream distribution content is opaque, including its own
-                // imports and license text. No SDK source rewriting applies.
-                await writeFile(path.join(destination, file.name), content);
-                throwIfAborted(controller.signal);
-                completed += 1;
-                await emit(
-                    onEvent,
-                    {type: 'workspace.decisions.progress', file: file.name, url: file.url, completed, total: files.length}
-                );
-            } catch (error) {
-                controller.abort(error);
-                throw error;
-            }
-        }
-        // One fixed distribution, acquired once for the selected projection;
-        // no model/app/architecture multiplier or installation script.
-        const outcomes = await Promise.allSettled(files.map(acquireDistributionFile));
-        const failures = new Set();
-        for (const outcome of outcomes) {
-            if (outcome.status === 'rejected') failures.add(outcome.reason);
-        }
-        if (failures.size === 1) throw [...failures][0];
-        if (failures.size > 1) {
-            throw new AggregateError([...failures], 'Browser decision distribution acquisition failed.');
-        }
-        throwIfAborted(controller.signal);
-    } finally {
-        signal?.removeEventListener('abort', cancelDistribution);
-    }
-    return {
-        transformersVersion: '4.3.0',
-        onnxRuntimeVersion: '1.31.0-dev.20260914-8d85527a0',
-        files: files.map(function distributionFilename(file) { return file.name; })
-    };
-}
-
 export async function materializeWorkspaceRuntimeContent({
     workspaceRoot,
     runtimeRoot=path.join(getSdkRoot(),'runtime'),