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
// Sensitive-operation prompts — under approval access modes, when an
// agent wants to run a command, access a path, or call a connector that main
// flagged as sensitive, this module shows an allow-once / deny choice, plus
// a task-scoped choice only when main marks the
// category and actor eligible, alongside the durable local-access mode switch.
// Waiting for a human click is kept alive on the main side with progress
// heartbeats; Renderer never widens main's operation-approval boundary.
//
// Requests queue FIFO so concurrent workers can't stack overlapping dialogs.
const _bashPermLog = createLogger('bash-permission');
const _bashPermQueue = [];
let _bashPermDialogOpen = false;
const _bashPermCancelled = new Set();
const _bashPermTaskApproved = new Set();
const _bashPermDialogClosers = new Map();
const _BASH_PERMISSION_MODES = ['workspace_approval', 'all_files_approval', 'all_files_auto'];
const _BASH_PERMISSION_DEFAULT_MODE = 'all_files_approval';
const _CLI_PERMISSION_POLICIES = ['inherit', 'ask', 'full_access'];
const _BASH_PERMISSION_RISK_CATEGORIES = ['network_egress', 'destructive', 'priv_esc', 'sensitive_path', 'system_package_change', 'external_mutation'];
const _BASH_IRREVERSIBLE_ACTIONS = ['recursive_delete', 'untargeted_process_kill'];
function _bashIsMode(mode) {
return _BASH_PERMISSION_MODES.includes(mode);
}
function _bashT(key, fallback) {
try {
const v = t(key);
return v && v !== key ? v : fallback;
} catch (_) {
return fallback;
}
}
function _bashEscapeHtml(value) {
try {
if (typeof escapeHtml === 'function') return escapeHtml(String(value || ''));
} catch (_) { /* fall through */ }
return String(value || '')
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
}
function _bashReasonText(reasons) {
const list = Array.isArray(reasons) ? reasons : [];
const labels = list.map((r) => t(`bash.permission.reason.${r}`));
return labels.filter(Boolean).join(t('bash.permission.reason_sep'));
}
// Main keeps irreversible steps in approval even under all_files_auto. Without
// a word about why, a user who deliberately turned prompts off reads the
// dialog as the setting having failed, so the note names the mode explicitly.
function _bashIrreversibleText(info, currentMode) {
const list = Array.isArray(info && info.irreversible) ? info.irreversible : [];
const labels = [...new Set(list.filter((a) => _BASH_IRREVERSIBLE_ACTIONS.includes(a)))]
.map((a) => _bashT(`bash.permission.irreversible.${a}`, ''))
.filter(Boolean);
if (!labels.length) return '';
const actions = labels.join(t('bash.permission.reason_sep'));
if (currentMode !== 'all_files_auto') {
return _bashT('bash.permission.irreversible_note', '')
? t('bash.permission.irreversible_note', { actions })
: '';
}
// Name the level the way Settings does, read from the same key, so the user
// can connect the sentence to the switch they actually flipped.
const mode = _bashT('settings.localexec.mode.all_files_auto', 'all_files_auto');
return _bashT('bash.permission.irreversible_auto_note', '')
? t('bash.permission.irreversible_auto_note', { actions, mode })
: '';
}
const _BASH_EXTERNAL_MUTATION_KINDS = [
'database_write', 'remote_command', 'remote_file_write', 'service_change',
'deployment_change', 'external_api_write', 'remote_publish', 'external_launch',
];
function _bashExternalMutationText(findings) {
if (!Array.isArray(findings)) return '';
const operations = [];
for (const raw of findings.slice(0, 8)) {
if (!raw || typeof raw !== 'object' || !_BASH_EXTERNAL_MUTATION_KINDS.includes(raw.kind)) continue;
const kind = _bashT(`bash.permission.external_kind.${raw.kind}`, raw.kind);
const action = String(raw.action || '').replace(/\s+/g, ' ').trim().slice(0, 48);
const target = String(raw.target || '').replace(/\s+/g, ' ').trim().slice(0, 120);
operations.push([kind, action, target].filter(Boolean).join(' · '));
}
if (!operations.length) return '';
return t('bash.permission.external_operations', { operations: operations.join('\n') });
}
function _bashPermissionModeOptions() {
return _BASH_PERMISSION_MODES.map((mode) => ({
mode,
label: t(`settings.localexec.mode.${mode}`),
desc: t(`settings.localexec.mode.${mode}_desc`),
}));
}
function _bashIsCliPermissionPolicy(policy) {
return _CLI_PERMISSION_POLICIES.includes(policy);
}
function _bashCliPermissionModeOptions(info) {
const cli = String(info && info.cli || '').trim();
const advertised = Array.isArray(info && info.permission_policies)
? info.permission_policies.filter(_bashIsCliPermissionPolicy)
: ['inherit'];
const policies = [...new Set(advertised.length ? advertised : ['inherit'])];
return policies.map((policy) => ({
mode: policy,
label: t(`agents.cli_permission_${policy}`),
desc: t(`agents.cli_permission_${policy}_desc`, { cli }),
}));
}
function _bashAgentLabel(info) {
const id = String((info && (info.agent_id || info.agentId)) || '').trim();
const name = String((info && (info.agent_name || info.agentName)) || '').trim();
const loweredName = name.toLowerCase();
if (id === 'commander' || loweredName === 'commander' || loweredName === 'orkas_chat') {
return _bashT('chat.from_commander', 'Commander');
}
return name || id || t('bash.permission.agent_fallback');
}
async function _getBashPermissionCurrentMode() {
try {
const res = await window.orkas.invoke('permissions.getLocalExec');
const mode = res && res.mode;
return _bashIsMode(mode) ? mode : _BASH_PERMISSION_DEFAULT_MODE;
} catch (err) {
_bashPermLog.warn('get local access mode failed', { error: err && err.message });
return _BASH_PERMISSION_DEFAULT_MODE;
}
}
async function _setBashPermissionMode(mode) {
if (!_bashIsMode(mode)) return false;
try {
const res = await window.orkas.invoke('permissions.setLocalExecMode', { mode });
return !!(res && res.mode === mode && res.ok !== false);
} catch (err) {
_bashPermLog.warn('set local access mode failed', { mode, error: err && err.message });
return false;
}
}
function _showBashPermissionModeDialog({
title,
message,
context,
details,
detailsLabel,
currentMode,
requestId,
allowRun = true,
allowRunLabel = t('bash.permission.allow_run'),
primaryChoice = 'allow_once',
showModeControl = true,
modes = _bashPermissionModeOptions(),
modeValidator = _bashIsMode,
defaultMode = _BASH_PERMISSION_DEFAULT_MODE,
modeTitle = _bashT('bash.permission.mode_title', 'Permission level'),
modeHint = _bashT('bash.permission.mode_hint', 'You can also change this later in Settings > Tool execution permissions.'),
}) {
const safeCurrentMode = modeValidator(currentMode) ? currentMode : defaultMode;
return new Promise((resolve) => {
const overlay = document.createElement('div');
overlay.className = 'modal-overlay ui-dialog-overlay open';
const titleHtml = title ? `<div class="modal-title ui-dialog-title">${_bashEscapeHtml(title)}</div>` : '';
const msgHtml = _bashEscapeHtml(message).replace(/\n/g, '<br />');
const detailsChevronHtml = details && typeof window.uiIconHtml === 'function'
? window.uiIconHtml('chevron-down', 'sidebar-section-chevron') : '';
const detailsHtml = details ? `<details class="bash-permission-details"><summary>${detailsChevronHtml}${_bashEscapeHtml(detailsLabel)}</summary><pre>${_bashEscapeHtml(details)}</pre></details>` : '';
let selectedModeValue = safeCurrentMode;
const selectedItem = () => modes.find((item) => item.mode === selectedModeValue) || modes.find((item) => item.mode === safeCurrentMode) || modes[0];
const modeHtml = modes.map((item) => `
<button class="bash-permission-mode-option${item.mode === safeCurrentMode ? ' is-selected' : ''}" type="button" role="option" aria-selected="${item.mode === safeCurrentMode ? 'true' : 'false'}" data-mode="${_bashEscapeHtml(item.mode)}">
<span class="bash-permission-mode-check" aria-hidden="true">${item.mode === safeCurrentMode ? '✓' : ''}</span>
<span class="bash-permission-mode-copy">
<span class="bash-permission-mode-label">${_bashEscapeHtml(item.label)}</span>
<span class="bash-permission-mode-desc">${_bashEscapeHtml(item.desc)}</span>
</span>
</button>
`).join('');
const initialItem = selectedItem();
const caretHtml = (typeof window !== 'undefined' && typeof window.uiIconHtml === 'function')
? window.uiIconHtml('chevron-down', 'bash-permission-mode-trigger-caret')
: '<span class="bash-permission-mode-trigger-caret" aria-hidden="true">⌄</span>';
const modeControlHtml = showModeControl ? `
<div class="bash-permission-mode-control">
<button class="btn bash-permission-mode-trigger" type="button" aria-haspopup="listbox" aria-expanded="false">
<span class="bash-permission-mode-trigger-label">${_bashEscapeHtml(initialItem ? initialItem.label : modeTitle)}</span>
${caretHtml}
</button>
</div>` : '';
const runIsPrimary = allowRun && primaryChoice === 'allow_run';
const allowRunHtml = allowRun
? `<button class="btn${runIsPrimary ? ' btn-primary' : ''}" data-act="choice" data-id="allow_run">${_bashEscapeHtml(allowRunLabel)}</button>`
: '';
overlay.innerHTML = `
<div class="modal modal-standard ui-dialog bash-permission-dialog" role="dialog" aria-modal="true" aria-label="${_bashEscapeHtml(title)}">
${titleHtml}
${_uiDialogContextHtml(context)}
<div class="modal-body ui-dialog-message bash-permission-message">${msgHtml}${detailsHtml}</div>
<div class="bash-permission-footer">
<div class="modal-actions bash-permission-actions">
${modeControlHtml}
<span class="bash-permission-actions-spacer" aria-hidden="true"></span>
<button class="btn" data-act="cancel">${_bashEscapeHtml(t('bash.permission.deny'))}</button>
<button class="btn${runIsPrimary ? '' : ' btn-primary'}" data-act="choice" data-id="allow_once">${_bashEscapeHtml(t('bash.permission.allow_once'))}</button>
${allowRunHtml}
</div>
${showModeControl ? `<div class="bash-permission-mode-hint">${_bashEscapeHtml(modeHint)}</div>` : ''}
</div>
</div>
<div class="bash-permission-mode-menu" role="listbox" hidden>
${modeHtml}
</div>
`;
document.body.appendChild(overlay);
const releaseContext = _uiBindDialogContext(overlay, context);
const selectedMode = () => {
return modeValidator(selectedModeValue) ? selectedModeValue : safeCurrentMode;
};
const modeTrigger = overlay.querySelector('.bash-permission-mode-trigger');
const modeMenu = overlay.querySelector('.bash-permission-mode-menu');
const modeTriggerLabel = overlay.querySelector('.bash-permission-mode-trigger-label');
const modeOptions = Array.from(overlay.querySelectorAll('.bash-permission-mode-option'));
const updateModeUi = () => {
const item = selectedItem();
if (modeTriggerLabel && item) modeTriggerLabel.textContent = item.label;
modeOptions.forEach((btn) => {
const isSelected = btn.dataset.mode === selectedModeValue;
btn.classList.toggle('is-selected', isSelected);
btn.setAttribute('aria-selected', isSelected ? 'true' : 'false');
const check = btn.querySelector('.bash-permission-mode-check');
if (check) check.textContent = isSelected ? '✓' : '';
});
};
const closeMenu = () => {
if (!modeMenu || modeMenu.hidden) return;
modeMenu.hidden = true;
modeTrigger?.setAttribute('aria-expanded', 'false');
};
const positionMenu = () => {
if (!modeMenu || !modeTrigger) return;
const triggerRect = modeTrigger.getBoundingClientRect();
const overlayRect = overlay.getBoundingClientRect();
const menuWidth = Math.min(360, Math.max(320, overlayRect.width - 24));
modeMenu.style.width = `${menuWidth}px`;
modeMenu.style.left = `${Math.max(12, Math.min(triggerRect.left - overlayRect.left, overlayRect.width - menuWidth - 12))}px`;
const gap = 8;
modeMenu.style.maxHeight = '';
const menuHeight = modeMenu.offsetHeight;
const triggerWithinOverlay = {
top: triggerRect.top - overlayRect.top,
bottom: triggerRect.bottom - overlayRect.top,
};
const placement = _dropdownVerticalPlacement(
triggerWithinOverlay,
menuHeight,
overlayRect.height,
{ edge: 12, gap },
);
modeMenu.style.top = `${placement.top}px`;
modeMenu.style.maxHeight = `${Math.min(280, placement.availableHeight)}px`;
modeMenu.dataset.placement = placement.openAbove ? 'top' : 'bottom';
};
const openMenu = () => {
if (!modeMenu) return;
modeMenu.hidden = false;
positionMenu();
modeTrigger?.setAttribute('aria-expanded', 'true');
};
modeTrigger?.addEventListener('click', (e) => {
e.preventDefault();
e.stopPropagation();
if (!modeMenu) return;
if (modeMenu.hidden) openMenu();
else closeMenu();
});
modeOptions.forEach((btn) => {
btn.addEventListener('click', () => {
const mode = btn.dataset.mode;
if (modeValidator(mode)) {
selectedModeValue = mode;
updateModeUi();
}
closeMenu();
modeTrigger?.focus();
});
});
const onDocClick = (e) => {
const control = overlay.querySelector('.bash-permission-mode-control');
if (control && !control.contains(e.target) && modeMenu && !modeMenu.contains(e.target)) closeMenu();
};
const onKey = (e) => {
if (e.isComposing || e.keyCode === 229) return;
if (e.key === 'Escape') {
if (modeMenu && !modeMenu.hidden) {
closeMenu();
e.preventDefault();
return;
}
finish('deny');
}
};
let finished = false;
const finish = (choice, cancelled = false) => {
if (finished) return;
finished = true;
document.removeEventListener('keydown', onKey, true);
document.removeEventListener('click', onDocClick, true);
if (requestId) _bashPermDialogClosers.delete(requestId);
const mode = selectedMode();
releaseContext();
overlay.remove();
resolve({ choice, mode, cancelled });
};
if (requestId) {
_bashPermDialogClosers.set(requestId, () => finish('deny', true));
if (_bashPermCancelled.has(requestId)) finish('deny', true);
}
overlay.querySelectorAll('[data-act="choice"]').forEach((btn) => {
btn.addEventListener('click', () => finish(btn.dataset.id || 'deny'));
});
const cancelBtn = overlay.querySelector('[data-act="cancel"]');
const primaryBtn = overlay.querySelector(`[data-id="${runIsPrimary ? 'allow_run' : 'allow_once'}"]`);
cancelBtn.addEventListener('click', () => finish('deny'));
document.addEventListener('keydown', onKey, true);
document.addEventListener('click', onDocClick, true);
setTimeout(() => primaryBtn?.focus(), 0);
});
}
function _bashKeyFactsText(info) {
const facts = Array.isArray(info.key_facts) ? info.key_facts.slice(0, 6) : [];
const lines = [];
for (const fact of facts) {
if (!fact || !['risk', 'read', 'write', 'remove'].includes(fact.kind)) continue;
const operation = String(fact.operation || '');
if (fact.kind === 'risk') {
lines.push(`${_bashReasonText([fact.reason])} · ${operation}`);
} else {
lines.push(`${t(`bash.permission.key_${fact.kind}`)} · ${operation}: ${String(fact.target || '')}${fact.unresolved ? ` (${t('bash.permission.key_unresolved')})` : ''}`);
}
if (fact.detail) lines.push(`${t('bash.permission.key_evidence')}: ${String(fact.detail)}`);
}
if (info.unresolved_paths === true) lines.push(t('bash.permission.key_unknown_note'));
if (info.working_directory) lines.push(`${t('bash.permission.working_directory')}: ${String(info.working_directory)}`);
if (Number(info.facts_omitted) > 0) lines.push(t('bash.permission.key_more', { count: Number(info.facts_omitted) }));
return lines.join('\n');
}
async function _showBashPermissionDialog(info) {
const requestId = String(info.request_id || '');
if (_bashPermCancelled.delete(requestId)) {
_bashPermTaskApproved.delete(info.request_id);
return;
}
const isConnector = info._permission_kind === 'connector';
const agent = _bashAgentLabel(info);
const reasonsText = [
_bashReasonText(info.reasons),
info.unresolved_paths === true ? t('bash.permission.unresolved_paths') : '',
].filter(Boolean).join(t('bash.permission.reason_sep'));
const command = String(info.command || '');
const operation = String(info.operation || '').trim();
const subject = String(info.subject || '').trim();
const isAction = isConnector || !!(operation || subject);
const keyFactsText = !isAction ? _bashKeyFactsText(info) : '';
const baseMessage = isConnector ? _connectorActionMessage(info) : isAction
? t('bash.permission.action_message', {
agent,
operation: operation || t('bash.permission.action_fallback'),
reasons: reasonsText,
}) + (subject ? `\n\n${subject}` : '')
: t('bash.permission.message', { agent, reasons: reasonsText }) + '\n\n' + (keyFactsText || command);
const externalMutationText = _bashExternalMutationText(info.external_mutations);
const currentMode = await _getBashPermissionCurrentMode();
if (_bashPermCancelled.delete(requestId)) {
_bashPermTaskApproved.delete(info.request_id);
return;
}
// A read sensitive only for its personal location (Desktop, Documents,
// Downloads) is granted per folder: 2026-09-21 a user approved 58 images in
// two Desktop folders one by one.
const readFolder = !isConnector && info.can_allow_run === true
&& typeof info.read_folder === 'string' ? info.read_folder.trim() : '';
// Needs the resolved mode: the same step is worth flagging in every mode,
// but only an all_files_auto user is owed an explanation for being asked.
const message = [
baseMessage,
_bashIrreversibleText(info, currentMode),
externalMutationText,
...(!isConnector && info.can_allow_run === true
? [readFolder ? t('bash.permission.folder_read_scope', { agent, folder: readFolder }) : t('bash.permission.grant_scope')]
: []),
].filter(Boolean).join('\n\n');
const isSensitiveApproval = isConnector || (Array.isArray(info.reasons)
&& info.reasons.some((reason) => _BASH_PERMISSION_RISK_CATEGORIES.includes(reason)));
// Connector grants stay on the host's own terms.
const canAllowRun = isConnector ? info.can_allow_run === true
: info.unresolved_paths !== true && (!isSensitiveApproval || info.can_allow_run === true);
// An earlier queued permission can switch the account to Trusted while this
// connector waits. Its host gate already checked availability/prohibitions.
let result;
try {
result = isConnector && currentMode === 'all_files_auto'
? { choice: 'allow_once', mode: currentMode }
: await _showBashPermissionModeDialog({
title: t(isAction ? 'bash.permission.action_title' : 'bash.permission.title'),
message,
context: info,
...(isConnector ? {
details: _connectorActionDetails(info),
detailsLabel: t('connectors.action_confirm.details'),
} : {}),
...(keyFactsText && command ? { details: command, detailsLabel: t('bash.permission.command_preview') } : {}),
currentMode,
requestId,
allowRun: canAllowRun,
...(isConnector && info.usage_scope === true ? { allowRunLabel: t('bash.permission.allow_usage') } : {}),
...(readFolder ? { allowRunLabel: t('bash.permission.allow_folder_read'), primaryChoice: 'allow_run' } : {}),
showModeControl: true,
});
} catch (err) {
result = { choice: 'deny', mode: currentMode };
_bashPermLog.warn('operation permission dialog failed', {
error_type: err && typeof err.name === 'string' ? err.name : 'unknown',
});
}
if (result && result.cancelled) {
_bashPermCancelled.delete(requestId);
_bashPermTaskApproved.delete(info.request_id);
return;
}
const choice = result && typeof result === 'object' ? result.choice : result;
const selectedMode = _bashIsMode(result && result.mode)
? result.mode
: currentMode;
let decision = (choice === 'allow_once' || choice === 'allow_run') ? choice : 'deny';
if (!canAllowRun && decision === 'allow_run') decision = 'allow_once';
let effectiveMode = currentMode;
if (choice === 'allow_always' && isSensitiveApproval) {
decision = 'allow_once';
} else if (choice === 'allow_always') {
const ok = currentMode === 'all_files_auto' || await _setBashPermissionMode('all_files_auto');
if (ok) {
decision = 'allow_once';
effectiveMode = 'all_files_auto';
} else {
decision = 'deny';
}
} else if (decision !== 'deny' && selectedMode !== currentMode) {
const ok = await _setBashPermissionMode(selectedMode);
if (ok) effectiveMode = selectedMode;
else decision = 'deny';
}
if (_bashPermCancelled.delete(requestId)) {
_bashPermTaskApproved.delete(info.request_id);
return;
}
try {
await window.orkas.invoke(
isConnector ? 'connectors.action_confirm_response' : 'bash.permission_response',
isConnector
? { request_id: info.request_id, approved: decision !== 'deny', ...(decision === 'allow_run' ? { scope: info.usage_scope === true ? 'usage' : 'task' } : {}) }
: { request_id: info.request_id, decision },
);
} catch (err) {
_bashPermLog.warn('bash permission response failed', {
error_type: err && typeof err.name === 'string' ? err.name : 'unknown',
});
}
_bashPermCancelled.delete(requestId);
}
async function _drainBashPermissionQueue() {
if (_bashPermDialogOpen) return;
_bashPermDialogOpen = true;
try {
while (_bashPermQueue.length) {
const info = _bashPermQueue.shift();
if (info && info._permission_kind === 'local-agent') {
await _showLocalAgentPermissionDialog(info);
} else {
await _showBashPermissionDialog(info);
}
}
} finally {
_bashPermDialogOpen = false;
}
}
async function _showLocalAgentPermissionDialog(info) {
const requestId = String(info && info.request_id || '');
if (_bashPermCancelled.delete(requestId)) return;
const agent = _bashAgentLabel(info);
const action = String(info && (info.tool || info.description) || '').trim()
|| t('agents.cli_permission_action_fallback');
const details = [];
const description = String(info && info.description || '').trim();
const command = String(info && info.command || '').trim();
const subject = String(info && info.subject || '').trim();
if (description && description !== action) details.push(description);
if (command) details.push(command);
if (subject) details.push(subject);
const permission = [action, ...details]
.map((value) => String(value || '').replace(/\s+/g, ' ').trim())
.filter((value, index, values) => value && values.indexOf(value) === index)
.join(' · ');
const message = t('agents.cli_permission_requested', { permission });
const currentMode = _bashIsCliPermissionPolicy(info && info.permission_policy)
? info.permission_policy
: 'inherit';
const modes = _bashCliPermissionModeOptions(info);
const result = await _showBashPermissionModeDialog({
title: t('agents.cli_permission_prompt_title'),
message,
context: info,
currentMode,
requestId,
allowRun: info && info.can_allow_run === true,
showModeControl: true,
modes,
modeValidator: _bashIsCliPermissionPolicy,
defaultMode: 'inherit',
modeTitle: t('agents.cli_permission'),
modeHint: t('agents.cli_permission_mode_hint', { agent }),
});
if (result && result.cancelled) {
_bashPermCancelled.delete(requestId);
return;
}
const choice = result && typeof result === 'object' ? result.choice : result;
const selectedMode = _bashIsCliPermissionPolicy(result && result.mode)
? result.mode
: currentMode;
const decision = choice === 'allow_run'
? 'allow_run'
: choice === 'allow_once' ? 'allow_once' : 'deny';
try {
await window.orkas.invoke('localAgents.permissionResponse', {
request_id: requestId,
decision,
permission_policy: selectedMode,
});
} catch (err) {
_bashPermLog.warn('external CLI permission response failed', {
error_type: err && typeof err.name === 'string' ? err.name : 'unknown',
});
}
_bashPermCancelled.delete(requestId);
}
function _cancelBashPermissionRequests(payload, kind) {
const ids = Array.isArray(payload && payload.request_ids)
? payload.request_ids.filter((id) => typeof id === 'string')
: [];
const cancelled = new Set(ids);
for (const id of ids) {
if ((kind === 'connector' || kind === undefined) && payload.approved === true) _bashPermTaskApproved.add(id);
_bashPermCancelled.add(id);
const close = _bashPermDialogClosers.get(id);
if (close) close();
}
for (let i = _bashPermQueue.length - 1; i >= 0; i -= 1) {
const info = _bashPermQueue[i];
if (info && info._permission_kind === kind && cancelled.has(info.request_id)) {
_bashPermQueue.splice(i, 1);
_bashPermCancelled.delete(info.request_id);
if (kind !== 'local-agent') _bashPermTaskApproved.delete(info.request_id);
}
}
}
if (window.orkas && typeof window.orkas.onPushEvent === 'function') {
try {
const appWindow = window.location?.pathname?.endsWith('/preview.html') === true;
if (!appWindow) {
window.orkas.onPushEvent('bash:permission', (info) => {
if (!info || typeof info.request_id !== 'string') return;
_bashPermQueue.push(info);
_drainBashPermissionQueue();
});
window.orkas.onPushEvent('bash:permission_cancelled', (payload) => {
_cancelBashPermissionRequests(payload, undefined);
});
window.orkas.onPushEvent('local-agent:permission', (info) => {
if (!info || typeof info.request_id !== 'string') return;
_bashPermQueue.push({
...info,
_permission_kind: 'local-agent',
_renderer_received_at_ms: Date.now(),
});
_drainBashPermissionQueue();
});
window.orkas.onPushEvent('local-agent:permission_cancelled', (payload) => {
_cancelBashPermissionRequests(payload, 'local-agent');
});
}
window.orkas.onPushEvent('connectors:action-confirm', (info) => {
if (!info || typeof info.request_id !== 'string') return;
if (appWindow && info.usage_scope !== true) return;
_bashPermQueue.push({
...info,
_permission_kind: 'connector',
_renderer_received_at_ms: Date.now(),
});
_drainBashPermissionQueue();
});
window.orkas.onPushEvent('connectors:action-confirm-cancelled', (payload) => {
if (appWindow && payload?.usage_scope !== true) return;
_cancelBashPermissionRequests(payload, 'connector');
});
} catch (_err) { /* push channel unavailable; bash calls deny on timeout */ }
}