arcane-os 0.1.0-dev.5

package/runtime/arcane/modules/SystemAppearance.js

@@ -0,0 +1,20 @@
+export default class SystemAppearance{
+    constructor(api=globalThis.Arcane?.appearance||null){ this.api=api; }
+
+    available(){ return Boolean(this.api&&typeof this.api.apply==='function'); }
+
+    async current(){
+        if(!this.api||typeof this.api.current!=='function') return {supported:false,platform:'browser'};
+        return this.api.current();
+    }
+
+    async apply(input={}){
+        if(!this.available()) return {supported:false,platform:'browser'};
+        const scheme=['system','light','dark'].includes(input.scheme)?input.scheme:'system';
+        return this.api.apply({
+            scheme,
+            captionColor:scheme==='system'?null:input.captionColor||null,
+            textColor:scheme==='system'?null:input.textColor||null
+        });
+    }
+}

package/runtime/arcane/modules/SystemPlatformPresentation.js

@@ -0,0 +1,51 @@
+(function installSystemPlatformPresentation(globalObject) {
+    'use strict';
+
+    const KERNEL_TYPES = Object.freeze(['nt', 'linux']);
+
+    function normalizedValue(value) {
+        return typeof value === 'string' ? value.trim().toLowerCase() : '';
+    }
+
+    function kernelType(status = {}) {
+        const candidates = [
+            status.kernelType,
+            status.platform,
+            status.rawPlatform,
+            status.execution?.effectivePlatform,
+            status.execution?.hostPlatform,
+        ].map(normalizedValue);
+
+        for (const value of candidates) {
+            if (value === 'windows' || value === 'win32' || value === 'nt') return 'nt';
+            if (value === 'linux') return 'linux';
+        }
+        return null;
+    }
+
+    function displayName(status = {}) {
+        const kernel = kernelType(status);
+        if (kernel === 'nt') return 'Microsoft NT';
+        if (kernel === 'linux') return 'Linux';
+        if (typeof status.displayName === 'string' && status.displayName.trim()) return status.displayName.trim();
+        if (typeof status.platform === 'string' && status.platform.trim()) return status.platform.trim();
+        return 'Unknown operating system';
+    }
+
+    function apply(status = {}, root = globalObject.document?.documentElement) {
+        const kernel = kernelType(status);
+        if (root?.classList) {
+            root.classList.remove('arcane-kernel', ...KERNEL_TYPES.map((type) => `arcane-kernel-${type}`));
+            if (kernel) root.classList.add('arcane-kernel', `arcane-kernel-${kernel}`);
+        }
+        if (root?.dataset) {
+            if (kernel) root.dataset.arcaneKernel = kernel;
+            else delete root.dataset.arcaneKernel;
+        }
+
+        // This marker is presentation metadata only. Native permission evidence remains authoritative.
+        return Object.freeze({ kernelType: kernel, displayName: displayName(status) });
+    }
+
+    globalObject.ArcaneSystemPlatformPresentation = Object.freeze({ kernelType, displayName, apply });
+})(globalThis);

package/runtime/arcane/modules/SystemToolRegistry.js

@@ -0,0 +1,28 @@
+const TOOL_PATTERN=/^[a-z][a-z0-9-]{0,63}$/;
+
+function quoteArgument(value){
+    const text=String(value??'');
+    if(!text||/[\s"';&|<>$`]/.test(text)) return `"${text.replace(/"/g,'\\"')}"`;
+    return text;
+}
+
+export default class SystemToolRegistry{
+    constructor(definitions=[]){this.tools=new Map();for(const definition of definitions)this.register(definition);}
+    register(definition={}){
+        const id=String(definition.id||'').trim().toLowerCase();
+        if(!TOOL_PATTERN.test(id)||this.tools.has(id))throw new TypeError(`Duplicate or invalid system tool: ${id}`);
+        if(typeof definition.command!=='function'&&typeof definition.command!=='string')throw new TypeError(`System tool ${id} requires a command builder.`);
+        const record=Object.freeze({id,label:String(definition.label||id),description:String(definition.description||''),usage:String(definition.usage||id),command:definition.command});
+        this.tools.set(id,record);return record;
+    }
+    list(){return [...this.tools.values()].sort((left,right)=>left.id.localeCompare(right.id));}
+    get(id){return this.tools.get(String(id||'').toLowerCase())||null;}
+    build(id,args=[]){
+        const tool=this.get(id);if(!tool)throw new RangeError(`Unknown system tool: ${id}`);
+        const command=typeof tool.command==='function'?tool.command(Array.from(args)):tool.command;
+        if(typeof command!=='string'||!command.trim())throw new TypeError(`System tool ${id} produced an empty command.`);
+        return command.trim();
+    }
+}
+
+export {quoteArgument};

package/runtime/arcane/modules/TerminalClient.js

@@ -0,0 +1,52 @@
+import TerminalSession from '../entities/TerminalSession.js';
+
+export default class TerminalClient extends EventTarget{
+    constructor(api=globalThis.Arcane?.terminal){
+        super();
+        this.api=api||null;
+        this.sessions=new Map();
+        this.unsubscribe=[];
+        const events=globalThis.Arcane?.events;
+        if(events?.on){
+            for(const type of ['terminal.output','terminal.exit','terminal.error']){
+                this.unsubscribe.push(events.on(type,data=>this.receive(type,data)));
+            }
+        }
+    }
+
+    get available(){ return Boolean(this.api?.start&&this.api?.write&&this.api?.close); }
+
+    async start(options={}){
+        if(!this.available) throw new Error('The Arcane native terminal capability is unavailable. Open Terminal from the installed Arcane shell.');
+        const result=await this.api.start(options);
+        const session=new TerminalSession({...result,state:'running'});
+        this.sessions.set(session.id,session);
+        this.emit('session',{session});
+        return session;
+    }
+
+    async write(id,data){ TerminalSession.id(id);return this.api.write(id,String(data??'')); }
+    async resize(id,columns,rows){ TerminalSession.id(id);return this.api.resize(id,Number(columns),Number(rows)); }
+    async signal(id,signal='interrupt'){ TerminalSession.id(id);return this.api.signal(id,String(signal)); }
+    async close(id){
+        TerminalSession.id(id);
+        const result=await this.api.close(id);
+        const session=this.sessions.get(id);
+        if(session) this.sessions.set(id,session.with({state:'closed'}));
+        return result;
+    }
+
+    receive(type,data={}){
+        const id=String(data.sessionId||'');
+        if(!id||!this.sessions.has(id)) return;
+        if(type==='terminal.exit'){
+            const session=this.sessions.get(id).with({state:'exited'});
+            this.sessions.set(id,session);
+            this.emit('exit',{...data,session});
+        }else if(type==='terminal.error') this.emit('error',data);
+        else this.emit('output',data);
+    }
+
+    emit(type,detail){ this.dispatchEvent(new CustomEvent(`terminal-${type}`,{detail})); }
+    destroy(){ for(const off of this.unsubscribe) if(typeof off==='function') off();this.unsubscribe=[]; }
+}

package/runtime/arcane/modules/TerminalCommandRegistry.js

@@ -0,0 +1,50 @@
+const COMMAND_PATTERN=/^(?:[a-z][a-z0-9:_-]{0,63}|\?)$/;
+
+export function splitCommandLine(input=''){
+    const source=String(input||'').trim();
+    const values=[];
+    let token='';
+    let quote='';
+    let escaped=false;
+    for(const character of source){
+        if(escaped){token+=character;escaped=false;continue;}
+        if(character==='\\'&&quote!=='\''){escaped=true;continue;}
+        if(quote){if(character===quote) quote='';else token+=character;continue;}
+        if(character==='"'||character==='\''){quote=character;continue;}
+        if(/\s/.test(character)){if(token){values.push(token);token='';}continue;}
+        token+=character;
+    }
+    if(escaped) token+='\\';
+    if(token) values.push(token);
+    return values;
+}
+
+export default class TerminalCommandRegistry{
+    constructor(commands=[]){
+        this.commands=new Map();
+        for(const command of commands) this.register(command);
+    }
+
+    register({name,aliases=[],description='',usage='',run}={}){
+        const normalized=String(name||'').trim().toLowerCase();
+        if(!COMMAND_PATTERN.test(normalized)) throw new TypeError('Terminal command names must use lowercase command syntax.');
+        if(typeof run!=='function') throw new TypeError(`Terminal command ${normalized} requires a run function.`);
+        const record=Object.freeze({name:normalized,aliases:Object.freeze(aliases.map(alias=>String(alias).toLowerCase())),description:String(description),usage:String(usage||normalized),run});
+        for(const key of [record.name,...record.aliases]){
+            if(!COMMAND_PATTERN.test(key)||this.commands.has(key)) throw new TypeError(`Duplicate or invalid terminal command: ${key}`);
+            this.commands.set(key,record);
+        }
+        return record;
+    }
+
+    resolve(name){ return this.commands.get(String(name||'').toLowerCase())||null; }
+    definitions(){ return [...new Set(this.commands.values())].sort((left,right)=>left.name.localeCompare(right.name)); }
+    completions(prefix=''){ const value=String(prefix).toLowerCase();return this.definitions().map(item=>item.name).filter(name=>name.startsWith(value)); }
+
+    async execute(line,context={}){
+        const [name,...args]=splitCommandLine(line);
+        const command=this.resolve(name);
+        if(!command) return {handled:false};
+        return {handled:true,value:await command.run({args,line:String(line),command,context})};
+    }
+}

package/runtime/arcane/modules/ThemeBootstrap.js

@@ -0,0 +1,26 @@
+import {loadAndApplyTheme} from './ThemeManager.js';
+
+const sharedKey='arcaneThemeReady';
+const listenerKey='arcaneThemeAppearanceListener';
+
+export function bootstrapArcaneTheme(options={}){
+    const useSharedPromise=Object.keys(options).length===0;
+    if(useSharedPromise&&globalThis[sharedKey]) return globalThis[sharedKey];
+
+    const ready=loadAndApplyTheme(options).catch(error=>{
+        console.warn('[Arcane theme] Unable to load the saved appearance; using the system theme.',error);
+        return {manager:null,state:null,error};
+    });
+
+    if(useSharedPromise) globalThis[sharedKey]=ready;
+    if(useSharedPromise&&globalThis.Arcane?.events?.on&&!globalThis[listenerKey]){
+        globalThis[listenerKey]=globalThis.Arcane.events.on('appearance.changed',async()=>{
+            const result=await ready;
+            if(result?.manager) await result.manager.load();
+        });
+    }
+    return ready;
+}
+
+export const arcaneThemeReady=bootstrapArcaneTheme();
+export default arcaneThemeReady;

package/runtime/arcane/modules/ThemeManager.js

@@ -0,0 +1,131 @@
+import Theme,{arcaneDarkThemeTokens,arcaneLightThemeTokens} from '../entities/Theme.js';
+import PreferenceStore from './PreferenceStore.js';
+import {applyAppearancePreferences,createAppearancePreferenceStore} from './AppearancePreferences.js';
+import SystemAppearance from './SystemAppearance.js';
+
+const skinSchema=Object.freeze([
+    {key:'appearance.activeSkin',type:'text',defaultValue:''},
+    {key:'appearance.customSkin',type:'text',defaultValue:''}
+]);
+
+export default class ThemeManager{
+    constructor({appearanceStore=null,skinStore=null,systemAppearance=null,root=null}={}){
+        this.appearanceStore=appearanceStore||createAppearancePreferenceStore();
+        this.skinStore=skinStore||new PreferenceStore({namespace:'arcane',schema:skinSchema});
+        this.root=root||globalThis.document?.documentElement||null;
+        this.systemAppearance=systemAppearance||new SystemAppearance();
+        this.appearance=this.appearanceStore.defaults();
+        this.skinState=this.skinStore.defaults();
+        this.customTheme=null;
+    }
+
+    async load(){
+        const [appearance,skinState]=await Promise.all([this.appearanceStore.load(),this.skinStore.load()]);
+        this.appearance=appearance;
+        this.skinState=skinState;
+        this.customTheme=parseTheme(skinState['appearance.customSkin']);
+        this.apply();
+        return this.current();
+    }
+
+    apply(){
+        if(!this.root) return this.current();
+        Theme.clear(this.root);
+        applyAppearancePreferences(this.appearance,this.root);
+        if(this.skinState['appearance.activeSkin']==='custom'&&this.customTheme) this.customTheme.apply(this.root);
+        return this.current();
+    }
+
+    current(){
+        const custom=this.skinState['appearance.activeSkin']==='custom'&&this.customTheme;
+        return {
+            mode:custom?'custom':this.appearance['appearance.colorScheme']||'system',
+            appearance:{...this.appearance},
+            theme:this.customTheme?.toJSON()||null
+        };
+    }
+
+    async setScheme(scheme='system'){
+        const normalized=['system','light','dark'].includes(scheme)?scheme:'system';
+        await Promise.all([
+            this.appearanceStore.set('appearance.colorScheme',normalized),
+            this.skinStore.set('appearance.activeSkin','')
+        ]);
+        this.appearance={...this.appearance,'appearance.colorScheme':normalized};
+        this.skinState={...this.skinState,'appearance.activeSkin':''};
+        this.apply();await this.syncSystemAppearance();this.emit();
+        return this.current();
+    }
+
+    async saveCustom(input={}){
+        const theme=Theme.fromJSON(input);
+        await Promise.all([
+            this.skinStore.set('appearance.customSkin',JSON.stringify(theme)),
+            this.skinStore.set('appearance.activeSkin','custom'),
+            this.appearanceStore.set('appearance.colorScheme',theme.scheme)
+        ]);
+        this.customTheme=theme;
+        this.skinState={...this.skinState,'appearance.customSkin':JSON.stringify(theme),'appearance.activeSkin':'custom'};
+        this.appearance={...this.appearance,'appearance.colorScheme':theme.scheme};
+        this.apply();await this.syncSystemAppearance();this.emit();
+        return this.current();
+    }
+
+    async activateCustom(){
+        if(!this.customTheme) await this.load();
+        if(!this.customTheme) return this.current();
+        await Promise.all([
+            this.skinStore.set('appearance.activeSkin','custom'),
+            this.appearanceStore.set('appearance.colorScheme',this.customTheme.scheme)
+        ]);
+        this.skinState={...this.skinState,'appearance.activeSkin':'custom'};
+        this.appearance={...this.appearance,'appearance.colorScheme':this.customTheme.scheme};
+        this.apply();await this.syncSystemAppearance();this.emit();
+        return this.current();
+    }
+
+    preview(input={}){
+        const theme=Theme.fromJSON(input);
+        if(this.root) theme.apply(this.root);
+        return theme;
+    }
+
+    async resetCustom(){
+        await Promise.all([
+            this.skinStore.set('appearance.customSkin',''),
+            this.skinStore.set('appearance.activeSkin','')
+        ]);
+        this.customTheme=null;
+        this.skinState={...this.skinState,'appearance.customSkin':'','appearance.activeSkin':''};
+        this.apply();await this.syncSystemAppearance();this.emit();
+        return this.current();
+    }
+
+    async syncSystemAppearance(){
+        const state=this.current();
+        const theme=state.mode==='custom'?this.customTheme:null;
+        const tokens=theme?.tokens||(state.mode==='dark'?arcaneDarkThemeTokens:state.mode==='light'?arcaneLightThemeTokens:null);
+        return this.systemAppearance.apply({
+            scheme:theme?.scheme||state.mode,
+            captionColor:tokens?.surface||null,
+            textColor:tokens?.text||null
+        });
+    }
+
+    emit(){
+        if(typeof globalThis.CustomEvent==='function'&&typeof globalThis.dispatchEvent==='function'){
+            globalThis.dispatchEvent(new CustomEvent('arcane-theme-change',{detail:this.current()}));
+        }
+    }
+}
+
+function parseTheme(value){
+    if(!value) return null;
+    try{return Theme.fromJSON(value);}catch{return null;}
+}
+
+export async function loadAndApplyTheme(options={}){
+    const manager=options.manager||new ThemeManager(options);
+    const state=await manager.load();
+    return {manager,state};
+}

package/runtime/arcane/modules/TimeGuard.js

@@ -0,0 +1,149 @@
+import Is from '../../node_modules/strong-type/index.js';
+import './DBOPFS.js';
+import UserEntity from '../entities/User.js';
+
+const is=new Is(false);
+
+class TimeGuard {
+    // Default to 17 day grace period from last check
+    #gracePeriod = 1000 * 60 * 60 * 24 * 17;
+    //                 ms    s    m    h    d
+
+    // Allow a six (6) hour grace period to handle time changes
+    #gracePeriodClock = 1000 * 60 * 60 * 6;
+    //                    ms    s    m   h
+
+    // Note, all times are in milliseconds
+    #storedTime = 0;
+    #lastSuccessfulTime = 0;
+
+    constructor() {
+        if (window.timeguard) {
+            return window.timeguard;
+        }
+
+        this.#loadTime();
+    }
+
+    #loadTime() {
+        this.#storedTime = window.user?.current_time || 0;
+        this.#lastSuccessfulTime = window.user?.last_successful_time || 0;
+
+        return true;
+    }
+
+//    set gracePeriod(v) {
+//        if(!is.number(v)) {
+//            throw new Error('gracePeriod must be number')
+//        }
+
+//        this.#gracePeriod = v;
+
+//        return true;
+//    }
+
+//    get gracePeriod() {
+//        return this.#gracePeriod;
+//    }
+
+    #checkTime(time=0) {
+        if(!is.number(time)) {
+            throw new Error('time must be number')
+        }
+
+        if (!time) {
+            throw new Error('time must be supplied');
+        }
+    }
+
+    setStoredTime(time=0) {
+        this.#checkTime(time);
+
+        if (time < this.#storedTime) {
+            //throw new Error('current time must be greater than last time check')
+        }
+
+        this.#storedTime = time;
+        window.user.current_time = time;
+
+        return true;
+    }
+
+    setLastSuccessfulCheckTime(time=0) {
+        this.#checkTime(time);
+
+        if (time < this.#lastSuccessfulTime) {
+            //console.log('Clock rollback detected');
+            throw new Error('current time must be greater than last time check');
+        }
+
+        this.#lastSuccessfulTime = time;
+        window.user.last_successful_time = time;
+
+        return true;
+    }
+
+    checkClockRollback() {
+        // Get current time and add time change grace period.
+        // This is to allow for time changes up to six hours
+        const currentTimeWithTimeChangeGracePeriod = Date.now() + this.#gracePeriodClock;
+
+        if (currentTimeWithTimeChangeGracePeriod < this.#storedTime) {
+            //console.log('Clock rollback detected');
+            throw new Error('Clock has been rolled back greater than six hours from last check');
+        }
+
+        return true;
+    }
+
+    checkGracePeriod() {
+        this.checkClockRollback();
+
+        const currentTime = Date.now();
+
+        if (currentTime < this.#lastSuccessfulTime) {
+            //console.log('Clock rollback detected');
+            throw new Error('current time must be greater than last time check')
+        }
+
+        const timeDifferenceBetweenChecks = currentTime - this.#lastSuccessfulTime;
+
+        console.log(timeDifferenceBetweenChecks);
+
+        // Note, if the last known time check has not been set, this error will always be emitted
+        if (timeDifferenceBetweenChecks > this.#gracePeriod) {
+            throw new Error('Grace period time has been exceeded or key is invalid');
+        }
+
+        return true;
+    }
+}
+
+
+window.addEventListener(
+    'user-entity-loaded',
+    instantiateTimeGuard
+);
+
+if(window.user?.ready){
+    instantiateTimeGuard();
+}
+
+function instantiateTimeGuard() {
+    if(!window.timeguard){
+        window.timeguard = new TimeGuard();
+
+        window.timeguard.ready = true;
+
+        const timeguardReady = new CustomEvent(
+            'time-guard-ready', {
+                detail: { db: window.timeguard }
+            }
+        );
+
+        window.dispatchEvent(timeguardReady);
+
+    }
+}
+
+export default TimeGuard;

package/runtime/arcane/modules/ToolCallRouter.js

@@ -0,0 +1,83 @@
+function parseArguments(value,name=''){
+    if(value&&typeof value==='object'){
+        return value;
+    }
+
+    if(typeof value!=='string'){
+        throw new Error(`Tool ${name} did not provide valid arguments.`);
+    }
+
+    try{
+        return JSON.parse(value);
+    }catch(error){
+        console.warn(error);
+        throw new Error(`Tool ${name} returned invalid JSON arguments.`);
+    }
+}
+
+function getResponseCalls(response={}){
+    const calls=response?.choices?.[0]?.message?.tool_calls;
+
+    if(!Array.isArray(calls)||!calls.length){
+        throw new Error('AI response did not contain a tool call.');
+    }
+
+    return calls;
+}
+
+function dispatch(name='',argumentsValue='',handlers={}){
+    if(typeof handlers[name]!=='function'){
+        throw new Error(`No handler is registered for tool ${name}.`);
+    }
+
+    return handlers[name](
+        parseArguments(argumentsValue,name)
+    );
+}
+
+async function handleResponse(response={},handlers={}){
+    const calls=getResponseCalls(response);
+    const results=[];
+
+    for(let i=0;i<calls.length;i++){
+        const toolCall=calls[i]?.function;
+
+        if(!toolCall?.name){
+            throw new Error('AI response contained an invalid tool call.');
+        }
+
+        results.push(
+            await dispatch(
+                toolCall.name,
+                toolCall.arguments,
+                handlers
+            )
+        );
+    }
+
+    return results.length===1
+        ?results[0]
+        :results;
+}
+
+async function handleStreamedCalls(calls={},handlers={}){
+    if(!calls||typeof calls!=='object'||Array.isArray(calls)){
+        throw new Error('Streamed tool calls must be an object.');
+    }
+
+    const names=Object.keys(calls);
+
+    return Promise.allSettled(
+        names.map(
+            name=>Promise.resolve().then(
+                ()=>dispatch(name,calls[name],handlers)
+            )
+        )
+    );
+}
+
+export {
+    handleResponse,
+    handleStreamedCalls,
+    parseArguments
+};