Skip to content

armgit / Orkas

Public Imported from GitHub
0

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.

fix(settings): restore preference state and recycle refresh

wyt65420f18e4f7
diff --git a/src/renderer/modules/settings.js b/src/renderer/modules/settings.js
index 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.js
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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();