Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.
JavaScript agent-collaborationagent-harnessagent-orchestrationagent-teamagent-workflowai-assistantai-automationai-employeeai-productivityai-teamai-workflowautonomous-agentsclaude-code-guiclaude-coworkdesktop-agentlocal-firstmulti-agentmulti-agent-systemself-evolving-agentstask-automation
fix(settings): restore preference state and recycle refresh
wyt65420f18e4f7
diff --git a/src/renderer/modules/settings.js b/src/renderer/modules/settings.jsindex d6c4be1d..30cf8045 100644--- a/src/renderer/modules/settings.js+++ b/src/renderer/modules/settings.js@@ -59,6 +59,9 @@ let _settingsState = {taskNotificationsToggleEpoch: 0,taskNotificationPermissionRefreshTimer: null,taskNotificationPermissionLogKey: '',+ metacognition: null,+ metacognitionToggleEpoch: 0,+ localExecModeEpoch: 0,clientConfigBound: false,recycleBound: false,orkasApiCredential: null,@@ -735,9 +738,9 @@ function _settingsBindRecycleBinOnce() {const _LOCALEXEC_MODES = ['workspace_approval', 'all_files_approval', 'all_files_auto'];async function _settingsRefreshLocalExec() {- const epoch = _settingsState.localExecToggleEpoch;+ const epoch = _settingsState.localExecModeEpoch;const res = await window.orkas.invoke('permissions.getLocalExec');- if (epoch !== _settingsState.localExecToggleEpoch) return;+ if (epoch !== _settingsState.localExecModeEpoch) return;const mode = (res && res.ok && _LOCALEXEC_MODES.includes(res.mode)) ? res.mode : 'all_files_approval';_settingsState.localExec = { mode };_settingsRenderLocalExec();diff --git a/src/renderer/modules/settings_tabs.js b/src/renderer/modules/settings_tabs.jsindex c0ae7dd2..ce98c968 100644--- a/src/renderer/modules/settings_tabs.js+++ b/src/renderer/modules/settings_tabs.js@@ -21,7 +21,10 @@ function activateSettingsTab(name) {panes.forEach((pane) => {pane.hidden = pane.dataset.settingsPane !== target;});- if (target === 'data' && typeof window.initTaskCleanup === 'function') window.initTaskCleanup();+ if (target === 'data') {+ if (typeof window.initRecycleBin === 'function') window.initRecycleBin();+ if (typeof window.initTaskCleanup === 'function') window.initTaskCleanup();+ }}const _settingsTabsBound = new WeakSet();diff --git a/test/e2e/settings_e2e_persistence.spec.ts b/test/e2e/settings_e2e_persistence.spec.tsindex b23df4bc..14c7c0ad 100644--- a/test/e2e/settings_e2e_persistence.spec.ts+++ b/test/e2e/settings_e2e_persistence.spec.ts@@ -147,6 +147,7 @@ test.describe('settings persistence', () => {const state = await metacognitionOrkas.invoke<{ enabled: boolean }>('prefs.getMetacognition');return state.enabled;}).toBe(true);+ await expect(toggle).toBeEnabled();const relaunchedPage = await metacognitionOrkas.relaunch();await openGeneralSettings(relaunchedPage);diff --git a/test/renderer/settings-general-telemetry.test.ts b/test/renderer/settings-general-telemetry.test.tsnew file mode 100644index 00000000..0a720dc7--- /dev/null+++ b/test/renderer/settings-general-telemetry.test.ts@@ -0,0 +1,210 @@+import { readFileSync } from 'node:fs';+import { resolve } from 'node:path';+import vm from 'node:vm';+import { describe, expect, it, vi } from 'vitest';++const settingsSource = readFileSync(+ resolve(__dirname, '../../src/renderer/modules/settings.js'),+ 'utf8',+);++function loadHarness(invokeImpl: (channel: string, payload?: any) => Promise<any>) {+ const listeners = new Map<string, () => Promise<void>>();+ const metacognitionToggle: any = {+ checked: false,+ disabled: false,+ dataset: {},+ addEventListener(type: string, handler: () => Promise<void>) {+ listeners.set(`metacognition:${type}`, handler);+ },+ };+ const radios = ['workspace_approval', 'all_files_approval', 'all_files_auto'].map(value => ({+ value, checked: false,+ addEventListener(type: string, handler: () => Promise<void>) {+ listeners.set(`localexec:${value}:${type}`, handler);+ },+ }));+ const dataRootButton: any = {+ dataset: {},+ addEventListener(type: string, handler: () => Promise<void>) {+ listeners.set(`data-root:${type}`, handler);+ },+ };+ const elements: Record<string, any> = {+ 'settings-localexec-modes': { dataset: {}, querySelectorAll: () => radios },+ 'settings-metacognition-toggle': metacognitionToggle,+ 'settings-metacognition-status': { textContent: '' },+ 'settings-data-root-btn': dataRootButton,+ 'settings-data-root-path': { textContent: '' },+ };+ const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };+ const sandbox: any = {+ console,+ createLogger: () => logger,+ t: (key: string) => key,+ escapeHtml: (value: unknown) => String(value ?? ''),+ document: {+ getElementById: (id: string) => elements[id] || null,+ querySelectorAll: () => [],+ },+ window: {+ addEventListener: vi.fn(),+ orkas: { invoke: vi.fn(invokeImpl) },+ },+ setTimeout,+ clearTimeout,+ setInterval,+ clearInterval,+ URL,+ };+ vm.runInNewContext(settingsSource, sandbox, { filename: 'settings.js' });+ return {+ sandbox,+ listeners,+ metacognitionToggle,+ radios,+ logger,+ };+}++describe('Settings general preference recovery', () => {+ it('persists an early metacognition toggle while the initial read is still pending', async () => {+ let finishInitialRead: ((value: any) => void) | undefined;+ const initialRead = new Promise((resolve) => {+ finishInitialRead = resolve;+ });+ const h = loadHarness(async (channel) => {+ if (channel === 'prefs.getMetacognition') return initialRead;+ if (channel === 'prefs.setMetacognition') return { ok: true, enabled: true };+ return { ok: true };+ });++ h.sandbox._settingsBindMetacognitionOnce();+ const refresh = h.sandbox._settingsRefreshMetacognition();+ h.metacognitionToggle.checked = true;+ await h.listeners.get('metacognition:change')!();+ finishInitialRead!({ ok: true, enabled: false, envForcedOff: false });+ await refresh;++ expect(h.metacognitionToggle.checked).toBe(true);+ expect(h.metacognitionToggle.disabled).toBe(false);+ });++ it('keeps the environment kill switch authoritative when the preference write settles last', async () => {+ const initialRead = Promise.withResolvers<any>();+ const preferenceWrite = Promise.withResolvers<any>();+ const h = loadHarness(async (channel) => {+ if (channel === 'prefs.getMetacognition') return initialRead.promise;+ if (channel === 'prefs.setMetacognition') return preferenceWrite.promise;+ return { ok: true };+ });++ h.sandbox._settingsBindMetacognitionOnce();+ const refresh = h.sandbox._settingsRefreshMetacognition();+ h.metacognitionToggle.checked = true;+ const toggle = h.listeners.get('metacognition:change')!();+ initialRead.resolve({ ok: true, enabled: false, envForcedOff: true });+ await refresh;++ expect(h.metacognitionToggle.checked).toBe(false);+ expect(h.metacognitionToggle.disabled).toBe(true);++ preferenceWrite.resolve({ ok: true, enabled: true });+ await toggle;++ expect(h.metacognitionToggle.checked).toBe(false);+ expect(h.metacognitionToggle.disabled).toBe(true);+ });++ it('reconciles persisted metacognition state when an early toggle write is rejected', async () => {+ const initialRead = Promise.withResolvers<any>();+ let readCalls = 0;+ const h = loadHarness(async (channel) => {+ if (channel === 'prefs.getMetacognition') {+ readCalls += 1;+ if (readCalls === 1) return initialRead.promise;+ return { ok: true, enabled: true, envForcedOff: false };+ }+ if (channel === 'prefs.setMetacognition') return { ok: false, error: 'update_rejected' };+ return { ok: true };+ });++ h.sandbox._settingsBindMetacognitionOnce();+ const refresh = h.sandbox._settingsRefreshMetacognition();+ h.metacognitionToggle.checked = true;+ await h.listeners.get('metacognition:change')!();+ initialRead.resolve({ ok: true, enabled: true, envForcedOff: false });+ await refresh;++ expect(readCalls).toBe(2);+ expect(h.metacognitionToggle.checked).toBe(true);+ expect(h.metacognitionToggle.disabled).toBe(false);+ });++ it('keeps requested and actual metacognition state on a rejected write', async () => {+ const h = loadHarness(async (channel) => {+ if (channel === 'prefs.getMetacognition') {+ return { ok: true, enabled: false, envForcedOff: false };+ }+ if (channel === 'prefs.setMetacognition') return { ok: false, error: '/private/prefs' };+ return { ok: true };+ });++ await h.sandbox._settingsRefreshMetacognition();+ h.sandbox._settingsRenderMetacognition();+ h.metacognitionToggle.checked = true;+ await h.listeners.get('metacognition:change')!();++ expect(h.metacognitionToggle.checked).toBe(false);+ expect(h.metacognitionToggle.disabled).toBe(false);+ expect(JSON.stringify(h.logger.warn.mock.calls)).not.toContain('/private/prefs');+ });++ it('logs a rejected data-root open without exposing private paths', async () => {+ const h = loadHarness(async (channel) => (+ channel === 'app.openDataRoot'+ ? { ok: false, error: '/private/data-root' }+ : { ok: true }+ ));++ h.sandbox._settingsRenderDataRoot();+ await h.listeners.get('data-root:click')!();++ expect(h.logger.warn).toHaveBeenCalledWith('open data root rejected', { error_code: 'open_rejected' });+ expect(JSON.stringify(h.logger.warn.mock.calls)).not.toContain('/private/data-root');+ });+++ it('keeps a newly saved access mode when the initial read settles late', async () => {+ const read = Promise.withResolvers<any>();+ const h = loadHarness(async (channel, payload) => {+ if (channel === 'permissions.getLocalExec') return read.promise;+ if (channel === 'permissions.setLocalExecMode') return { ok: true, mode: payload.mode };+ return { ok: true };+ });+ h.sandbox._settingsRenderLocalExec();+ const refresh = h.sandbox._settingsRefreshLocalExec();+ h.radios[0].checked = true;+ await h.listeners.get('localexec:workspace_approval:change')!();+ read.resolve({ ok: true, mode: 'all_files_auto' });+ await refresh;+ expect(h.radios.map(r => r.checked)).toEqual([true, false, false]);+ });++ it.each(['reject', 'throw'])('recovers the self-evolution control after a %s write', async (failure) => {+ const h = loadHarness(async (channel) => {+ if (channel === 'prefs.getMetacognition') return { ok: true, enabled: false, envForcedOff: false };+ if (channel === 'prefs.setMetacognition') {+ if (failure === 'throw') throw new Error('fixture write failure');+ return { ok: false };+ }+ return { ok: true };+ });+ await h.sandbox._settingsRefreshMetacognition();+ h.metacognitionToggle.checked = true;+ await h.listeners.get('metacognition:change')!();+ expect(h.metacognitionToggle.checked).toBe(false);+ expect(h.metacognitionToggle.disabled).toBe(false);+ expect(h.logger.warn).toHaveBeenCalledTimes(1);+ });+});diff --git a/test/renderer/settings-tabs.test.ts b/test/renderer/settings-tabs.test.tsindex f445e931..10414ffd 100644--- a/test/renderer/settings-tabs.test.ts+++ b/test/renderer/settings-tabs.test.ts@@ -99,6 +99,18 @@ function loadSettingsTabsModule() {}describe('settings tabs module', () => {+ it('refreshes local recycle data whenever the user returns to Data', () => {+ const { window, tabs } = loadSettingsTabsModule();+ window.initRecycleBin = vi.fn();+ tabs[1].click();+ expect(window.initRecycleBin).not.toHaveBeenCalled();+ tabs[0].click();+ expect(window.initRecycleBin).toHaveBeenCalledTimes(1);+ tabs[2].click();+ tabs[0].keydown('Home');+ expect(window.initRecycleBin).toHaveBeenCalledTimes(2);+ });+it('initializes shared task cleanup on entering Data without requiring hosted data hooks', () => {const { window, tabs } = loadSettingsTabsModule();window.initTaskCleanup = vi.fn();