arcane-os 0.91.0 → 0.93.0

package/src/core/hosts/windows/ArcaneWindowControl.cs

@@ -38,7 +38,7 @@ namespace Arcane.Core.Hosts.Windows
         {
             if (appControl == null) return;
             appControlScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(
-                "globalThis[" + AppControlDocumentKey + "] = globalThis.crypto.randomUUID();");
+                "globalThis[" + AppControlDocumentKey + "] ??= globalThis.crypto.randomUUID();");
             if (closing) return;
             browser.NavigationStarting += AppControlNavigationStarting;
             browser.NavigationCompleted += AppControlNavigationCompleted;
@@ -140,7 +140,7 @@ namespace Arcane.Core.Hosts.Windows
                 { "url", webView.Source == null ? null : webView.Source.AbsoluteUri },
                 { "documentGeneration", appControlGeneration }, { "ready", AppControlDocumentReady() },
                 { "window", AppControlWindow() },
-                { "operations", new string[] { "status", "inspect", "capture", "act", "key", "resize" } }
+                { "operations", new string[] { "status", "diagnostics", "inspect", "capture", "act", "key", "resize" } }
             };
         }
 
@@ -158,6 +158,7 @@ namespace Arcane.Core.Hosts.Windows
         {
             cancellation.ThrowIfCancellationRequested();
             if (method == "app.control.status") return AppControlStatus();
+            if (method == "app.control.diagnostics") return nativeDiagnostics.Snapshot(parameters);
             if (method != "app.control.inspect" && method != "app.control.capture" && method != "app.control.act"
                 && method != "app.control.key" && method != "app.control.resize")
                 throw new ArgumentException("Unknown app-control method: " + method);

package/src/core/repositories.mjs

@@ -5,7 +5,7 @@ import Is from 'strong-type';
 import {ArcaneError, throwIfAborted} from '../errors.mjs';
 import {runProcess} from '../process.mjs';
 import {captureRepositoryRemote, captureRepositoryTarget, repositoryConfiguration, pullRepositoryTarget, pushRepositoryTarget,
-    repositoryPushArguments, repositoryStatus} from '../repository.mjs';
+    repositoryHeadArguments, repositoryHeadState, repositoryPushArguments, repositoryStatus} from '../repository.mjs';
 import {createGitIdentityRunner} from '../git-identity.mjs';
 
 export {readGitIdentity} from '../git-identity.mjs';
@@ -45,7 +45,7 @@ export function resolveArcaneDataPaths({dataRoot} = {}) {
 
 /** One connected checkout, composed into an application's own Core service. */
 export function createRepositoryWorkspace(
-    {name, directory, dataRoot, remote, remoteBase, branch, longPaths, cloneIdentity = {}, gitIdentity, onEvent, run = runProcess} = {}
+    {name, directory, dataRoot, remote, remoteBase, branch, initialBranch, longPaths, cloneIdentity = {}, gitIdentity, onEvent, run = runProcess} = {}
 ) {
     let selected = directory;
     if (selected === undefined) {
@@ -59,6 +59,12 @@ export function createRepositoryWorkspace(
     if (remote !== undefined) requireString(remote, 'remote');
     const remoteArgument = captureRepositoryRemote(remote, remoteBase);
     if (branch !== undefined) requireString(branch, 'branch');
+    if (initialBranch !== undefined) {
+        requireString(initialBranch, 'initialBranch');
+        if (!initialBranch.isWellFormed() || initialBranch.includes('\0')) {
+            throw new TypeError('initialBranch must be text representable as a native process argument.');
+        }
+    }
     if (longPaths !== undefined && !is.boolean(longPaths)) {
         throw new TypeError('longPaths must be a boolean when supplied.');
     }
@@ -126,9 +132,60 @@ export function createRepositoryWorkspace(
             arguments_,
             {cwd: path.dirname(repositoryDirectory), signal, onEvent}
         );
+        let outputs;
+        if (initialBranch !== undefined) {
+            const options = {cwd: repositoryDirectory, signal, onEvent};
+            outputs = [];
+            function completed(operation, observation) {
+                outputs.push({operation, stdout: observation.stdout, stderr: observation.stderr,
+                    code: observation.code, signal: observation.signal ?? null});
+            }
+            completed('clone', result);
+            try {
+                throwIfAborted(signal);
+                const advertised = await prepareRun('git', ['ls-remote', '--symref', '--', remoteArgument],
+                    {cwd: path.dirname(repositoryDirectory), signal, onEvent});
+                completed('observeRemote', advertised);
+                throwIfAborted(signal);
+                if (advertised.code !== 0) {
+                    throw new ArcaneError('ARCANE_OPERATION_FAILED', 'Git remote observation failed.', {details: advertised});
+                }
+                if (advertised.stdout === '') {
+                    const state = await prepareRun('git', [...repositoryHeadArguments], options);
+                    completed('observeHead', state);
+                    throwIfAborted(signal);
+                    if (state.code !== 0) {
+                        throw new ArcaneError('ARCANE_OPERATION_FAILED', 'Git branch state observation failed.', {details: state});
+                    }
+                    if (repositoryHeadState(state.stdout, state).unborn) {
+                        const references = await prepareRun('git', ['for-each-ref', '--format=%(refname)'], options);
+                        completed('observeRefs', references);
+                        throwIfAborted(signal);
+                        if (references.code !== 0) {
+                            throw new ArcaneError('ARCANE_OPERATION_FAILED', 'Git local ref observation failed.', {details: references});
+                        }
+                        // Git templates or hooks can supply local refs even
+                        // when the remote and this checkout's HEAD are unborn.
+                        if (references.stdout === '') {
+                            const selection = await prepareRun('git', ['symbolic-ref', 'HEAD', `refs/heads/${initialBranch}`], options);
+                            completed('selectInitialBranch', selection);
+                            throwIfAborted(signal);
+                            if (selection.code !== 0) {
+                                throw new ArcaneError('ARCANE_OPERATION_FAILED', 'Git initial branch selection failed.', {details: selection});
+                            }
+                        }
+                    }
+                }
+            } catch (cause) {
+                throw new ArcaneError(cause?.code ?? 'ARCANE_REPOSITORY_PREPARE_FAILED',
+                    cause instanceof Error ? cause.message : String(cause),
+                    {cause, details: {directory: repositoryDirectory, cloned: true, outputs}, exitCode: cause?.exitCode});
+            }
+        }
         throwIfAborted(signal);
         opened = true;
-        return {directory: repositoryDirectory, cloned: true, stdout: result.stdout, stderr: result.stderr};
+        return {directory: repositoryDirectory, cloned: true, stdout: result.stdout, stderr: result.stderr,
+            ...(outputs === undefined ? {} : {outputs})};
     }
 
     function accept(operation, signal) {

package/src/core-native-diagnostics-source.mjs

@@ -0,0 +1,13 @@
+import {readFile} from 'node:fs/promises';
+
+/** Project the one canonical diagnostic observer into a document-start script. */
+export async function createNativeDiagnosticsSource() {
+    const source = await readFile(new URL('../browser-runtime/core/native-diagnostics.mjs', import.meta.url), 'utf8');
+    return `(function installArcaneNativeDiagnostics(global){
+    'use strict';
+    if(global.top!==undefined&&global.top!==global)return;
+${source.replace(/^export (?=(?:async )?function )/gmu, '')}
+    installNativeDiagnostics(global);
+})(globalThis);
+`;
+}

package/src/git-text-snapshot.mjs

@@ -15,11 +15,12 @@ const snapshotRef = 'refs/arcane/text-snapshot';
  * One application service owns each dedicated cache directory. Construction
  * performs no I/O; refresh coalesces callers and close drains accepted work.
  */
-export function createGitTextSnapshot({cacheDirectory, remote, remoteBase, ref, selectPath, gitIdentity, onEvent, run = runProcess} = {}) {
+export function createGitTextSnapshot({cacheDirectory, remote, remoteBase, ref, selectPath, allowUnborn = false, gitIdentity, onEvent, run = runProcess} = {}) {
     for (const [name, value] of Object.entries({cacheDirectory, remote, ref})) {
         if (!is.string(value) || value === '') throw new TypeError(`${name} must be a nonempty string.`);
     }
     if (!is.function(selectPath)) throw new TypeError('selectPath must be a function.');
+    if (!is.boolean(allowUnborn)) throw new TypeError('allowUnborn must be a boolean.');
     const remoteArgument = captureRepositoryRemote(remote, remoteBase);
     const execute = createGitIdentityRunner(run, gitIdentity);
     const directory = path.resolve(cacheDirectory);
@@ -70,11 +71,28 @@ export function createGitTextSnapshot({cacheDirectory, remote, remoteBase, ref,
         try {
             await events.send({type: 'git.snapshot.refreshing', message: 'Refreshing the selected repository revision.', data: {ref}});
             await prepare(events);
+            if (allowUnborn) {
+                // No ref pattern or --exit-code: a successful complete empty
+                // advertisement is distinct from a missing selected ref.
+                const advertised = await git(['ls-remote', '--symref', '--', remoteArgument], {onEvent: events.send});
+                if (advertised.code !== 0) {
+                    throw new ArcaneError(ERROR_CODES.operationFailed, 'Git remote observation failed.', {details: advertised});
+                }
+                if (advertised.stdout === '') {
+                    const result = {revision: null, files: [], unborn: true};
+                    await events.send({type: 'git.snapshot.completed', message: 'The remote advertises no revision.',
+                        data: {revision: null, unborn: true, reused: retained?.unborn === true}});
+                    await events.drain();
+                    retained = result;
+                    return result;
+                }
+            }
             await git(['fetch', '--no-tags', '--no-write-fetch-head', '--', remoteArgument, `+${ref}:${snapshotRef}`], {onEvent: events.send});
             const selected = await git(['rev-parse', '--verify', `${snapshotRef}^{commit}`], {onEvent: events.send});
             const revision = selected.stdout.trim();
             if (retained?.revision === revision) {
-                await events.send({type: 'git.snapshot.completed', message: 'The selected repository revision is unchanged.', data: {revision, reused: true}});
+                await events.send({type: 'git.snapshot.completed', message: 'The selected repository revision is unchanged.',
+                    data: {revision, reused: true, ...(allowUnborn ? {unborn: false} : {})}});
                 await events.drain();
                 return retained;
             }
@@ -125,8 +143,9 @@ export function createGitTextSnapshot({cacheDirectory, remote, remoteBase, ref,
                     }
                 });
             }
-            const result = {revision, files: reader.finish()};
-            await events.send({type: 'git.snapshot.completed', message: 'Repository text snapshot is ready.', data: {revision, reused: false}});
+            const result = {revision, files: reader.finish(), ...(allowUnborn ? {unborn: false} : {})};
+            await events.send({type: 'git.snapshot.completed', message: 'Repository text snapshot is ready.',
+                data: {revision, reused: false, ...(allowUnborn ? {unborn: false} : {})}});
             await events.drain();
             retained = result;
             return result;
@@ -156,7 +175,8 @@ export function createGitTextSnapshot({cacheDirectory, remote, remoteBase, ref,
             accepted.then(settled, settled);
         }
         return waitForSnapshot(active, signal).then(function copyResult(snapshot) {
-            return {revision: snapshot.revision, files: snapshot.files.map(function copyFile(file) { return {...file}; })};
+            return {revision: snapshot.revision, files: snapshot.files.map(function copyFile(file) { return {...file}; }),
+                ...(allowUnborn ? {unborn: snapshot.unborn} : {})};
         });
     }
 

package/src/import-map.mjs

@@ -44,6 +44,7 @@ const SDK_BROWSER_SELF_IMPORTS=new Map([
     ['arcane-os/websocket-client','sdk/websocket-client.mjs'],
     ['arcane-os/core/client','sdk/core/client.mjs'],
     ['arcane-os/core/contracts','sdk/core/contracts.mjs'],
+    ['arcane-os/core/native-diagnostics','sdk/core/native-diagnostics.mjs'],
     ['arcane-os/document-acquisition','sdk/document-acquisition.mjs'],
     ['arcane-os/logging','sdk/logging.mjs'],
     ['arcane-os/browser-device','sdk/browser-device.mjs'],

package/src/process.mjs

@@ -3,6 +3,7 @@ import {spawn} from 'node:child_process';
 import path from 'node:path';
 import {ArcaneError,ERROR_CODES,throwIfAborted} from './errors.mjs';
 import {createEventQueue} from './event-queue.mjs';
+import {windowsGitEnvironment} from './windows-git-executable.mjs';
 
 const is = new Is(false);
 
@@ -195,6 +196,29 @@ export async function runProcess(command,args=[],{
     });
     throwIfAborted(signal);
 
+    let childEnvironment=env?{...process.env,...env}:process.env;
+    if(process.platform==='win32'&&command==='git'){
+        try{
+            childEnvironment=await windowsGitEnvironment(childEnvironment,{
+                run:runProcess,signal,
+                onEvent:function discoveryEvent(event){
+                    return events.send({
+                        ...event,type:event.type.replace(/^process\./u,'process.git.discovery.')
+                    });
+                }
+            });
+        }catch(error){
+            throwIfAborted(signal);
+            if(events.error)throw events.error;
+            await events.send({
+                type:'process.git.discovery.unavailable',
+                message:'Registered Git discovery was unavailable; using the existing command environment.',
+                data:{error}
+            });
+        }
+        throwIfAborted(signal);
+    }
+
     return new Promise((resolve,reject)=>{
         let stdout=outputEncodings.stdout!==null&&outputSelected(captureOutput,'stdout')?'':null;
         let stderr=outputEncodings.stderr!==null&&outputSelected(captureOutput,'stderr')?'':null;
@@ -369,7 +393,7 @@ export async function runProcess(command,args=[],{
         try{
             child=spawn(executable,executableArgs,{
                 cwd,
-                env:env?{...process.env,...env}:process.env,
+                env:childEnvironment,
                 shell:false,
                 detached:process.platform!=='win32',
                 windowsHide:true,

package/src/repository.mjs

@@ -85,6 +85,25 @@ export function repositoryPushArguments(selection) {
         : ['push', '--no-follow-tags', '--', selection.remoteArgument, `HEAD:${selection.target.ref}`];
 }
 
+// Both configuration and new-clone preparation consume Git's explicit initial
+// state. NUL framing keeps unusual working filenames outside these headers.
+export const repositoryHeadArguments = [
+    '--no-optional-locks', 'status', '--porcelain=v2', '-z', '--branch', '--untracked-files=no'
+];
+
+export function repositoryHeadState(output, details) {
+    const prefix = '# branch.oid ';
+    const record = output.split('\0').find(function branchCommit(value) {
+        return value.startsWith(prefix);
+    });
+    const revision = record?.slice(prefix.length);
+    if (!revision) {
+        throw new ArcaneError('ARCANE_REPOSITORY_HEAD_UNAVAILABLE',
+            'Git did not report its current commit or initial branch state.', {details});
+    }
+    return revision === '(initial)' ? {revision: null, unborn: true} : {revision, unborn: false};
+}
+
 /** Observe an existing workspace without initializing or refreshing it. */
 export async function repositoryConfiguration({workspaceRoot = process.cwd(), signal, onEvent, run = runProcess} = {}) {
     const repositoryRoot = path.resolve(workspaceRoot);
@@ -147,7 +166,12 @@ export async function repositoryConfiguration({workspaceRoot = process.cwd(), si
         upstream.urls = remotes.get(`remote.${remoteName}.url`) ?? [];
         upstream.pushUrls = remotes.get(`remote.${remoteName}.pushurl`) ?? [];
     }
-    return {repositoryRoot, headRef, origin, upstream};
+    const state = await readGitText([...repositoryHeadArguments], options);
+    if (state.result.code !== 0) throw processFailure(state, 'Git branch state observation failed.');
+    let headState;
+    try { headState = repositoryHeadState(state.output, state.result); }
+    catch (error) { error.rawStdout = state.rawStdout; throw error; }
+    return {repositoryRoot, headRef, ...headState, origin, upstream};
 }
 
 export async function repositoryStatus({

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;
+}