Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { ErrorNotice } from '@/components/ui/error-notice';
import { Slider } from '@/components/ui/slider';
import { Button, type ButtonProps } from '@/components/ui/button';
import {
useEffect,
useMemo,
useState,
type Dispatch,
type ReactNode,
type SetStateAction,
} from 'react';
import {
ArrowLeft,
BatteryCharging,
Check,
ChevronDown,
ChevronRight,
ChevronUp,
Keyboard,
RotateCcw,
Usb,
} from 'lucide-react';
import { useTranslation } from 'react-i18next';
import { SelectParts as Select } from '@/components/ui/select';
import { Switch } from '@/components/ui/switch';
import { useCodexMicroGuard } from '@/hooks/useCodexMicroGuard';
import { useWorkLouderCodex } from '@/hooks/useWorkLouderCodex';
import { useSkillhub } from '@/features/skillhub/hooks/useSkillhub';
import { SegmentedControl } from '@/components/ui/segmented-control';
import { cn } from '@/lib/utils';
import {
WorkLouderCodexKeyboardLayout,
WorkLouderCodexKeycapPicker,
WorkLouderCodexPartEditor,
type WorkLouderCodexAgentKey,
type WorkLouderCodexControlPart,
type WorkLouderCodexEditableKey,
type WorkLouderCodexKeyHint,
} from './WorkLouderCodexKeyboardLayout';
import {
workLouderCodexCommandDescription,
workLouderCodexCommandName,
} from './workLouderCodexCommandCopy';
import {
InputDeviceConnectionStatus,
inputDeviceConnectionTone,
inputDeviceStatusLabelKey,
resolveInputDeviceStatusKey,
} from './InputDeviceConnectionStatus';
import {
WORKLOUDER_CODEX_AGENT_SLOT_COUNT,
WORKLOUDER_CODEX_AGENT_SOURCES,
WORKLOUDER_CODEX_ANALOG_DIRECTIONS,
WORKLOUDER_CODEX_AUTO_DIM_OPTIONS,
WORKLOUDER_CODEX_COMMAND_IDS,
WORKLOUDER_CODEX_COMMAND_SLOTS,
WORKLOUDER_CODEX_ENCODER_ACTIONS,
WORKLOUDER_CODEX_ENCODER_MODES,
WORKLOUDER_CODEX_KEYCAP_ACTIONS,
WORKLOUDER_CODEX_KEYCAP_IDS,
WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS,
canonicalizeWorkLouderCodexKeycapId,
cloneWorkLouderCodexLayout,
createWorkLouderCodexDefaultSettings,
creatorCommandAssignment,
isCreatorTaskKey,
isWorkLouderCodexBlankKeycap,
isWorkLouderCreatorProgrammableKey,
normalizeWorkLouderCreatorTaskKeys,
workLouderTaskKeysForLayout,
workLouderLayoutMerges,
workLouderMergeForKey,
workLouderAvailableMergeDirections,
addWorkLouderMerge,
removeWorkLouderMerge,
workLouderMicrophoneKeysSeparate,
isWorkLouderCodexDoubleKeycap,
isWorkLouderCodexMicrophoneKeycap,
type WorkLouderMergeDirection,
type WorkLouderCodexAction,
type WorkLouderCodexAgentSource,
type WorkLouderCodexAutoDim,
type WorkLouderCodexCommandId,
type WorkLouderCodexCommandSlot,
type WorkLouderCodexConnectionStatus,
type WorkLouderCodexKeycapId,
type WorkLouderCodexLayout,
type WorkLouderCreatorProgrammableKey,
type WorkLouderCodexPreviewInput,
type WorkLouderCodexPreviewPart,
type WorkLouderCodexSettingsPatch,
type WorkLouderCodexState,
type WorkLouderModel,
} from '../../../shared/workLouderCodex';
function workLouderCopyKey(model: WorkLouderModel, suffix: string): string {
return model === 'creator-micro-2'
? `settings.shortcuts.workLouderCodex.models.creatorMicro2.${suffix}`
: `settings.shortcuts.workLouderCodex.${suffix}`;
}
function blankKeycapLegend(
keycapId: WorkLouderCodexKeycapId,
t: ReturnType<typeof useTranslation>['t'],
): string {
return isWorkLouderCodexBlankKeycap(keycapId)
? t('settings.shortcuts.workLouderCodex.layout.editor.blank')
: keycapId;
}
function applyPreviewInput(
input: WorkLouderCodexPreviewInput,
setPressedParts: Dispatch<SetStateAction<ReadonlySet<WorkLouderCodexPreviewPart>>>,
setEncoderTurns: Dispatch<SetStateAction<number>>,
setAnalogStick: Dispatch<SetStateAction<{ angle: number; distance: number } | null>>,
): void {
setPressedParts((current) => {
const next = new Set(current);
if (input.pressed) next.add(input.part);
else next.delete(input.part);
return next;
});
if (input.part === 'encoder' && input.turn) {
const turn = input.turn;
setEncoderTurns((current) => current + turn);
}
if (input.part === 'analog') {
const distance = input.distance ?? 0;
setAnalogStick(distance > 0 ? { angle: input.angle ?? 0, distance } : null);
}
}
interface WorkLouderCodexEntryProps {
model?: WorkLouderModel;
state: WorkLouderCodexState | null;
loading: boolean;
grouped?: boolean;
onOpen(): void;
}
export function WorkLouderCodexEntry({
model = 'codex-micro',
state,
loading,
grouped = false,
onOpen,
}: WorkLouderCodexEntryProps) {
const { t } = useTranslation();
const enabled = state?.settings.deviceEnabled ?? false;
return (
<button
type="button"
onClick={onOpen}
className={cn(
'flex w-full items-center gap-3 text-left outline-none transition-colors',
grouped
? 'rounded-none border-0 bg-transparent px-4 py-[14px]'
: 'rounded-xl border p-4 border-[var(--settings-theme-card-border)] bg-[var(--settings-theme-card-bg)]',
'enabled:hover:bg-[var(--settings-menu-bg-hover)] focus-visible:ring-2 focus-visible:ring-[var(--focus-ring-soft)]',
)}
aria-label={t(workLouderCopyKey(model, 'openAria'))}
>
<span className="flex size-10 shrink-0 items-center justify-center rounded-xl bg-[var(--surface-chip)] text-[var(--text-secondary)]">
<CodexMicroGlyph />
</span>
<span className="flex min-w-0 flex-1 flex-col gap-1">
<span className="truncate text-13 font-medium text-[var(--text-primary)]">
{t(workLouderCopyKey(model, 'title'))}
</span>
<span className="text-12 leading-[1.4] text-[var(--text-secondary)]">
{t(workLouderCopyKey(model, 'entryDescription'))}
</span>
</span>
<span className="flex shrink-0 items-center gap-2">
<ConnectionStatus
enabled={enabled}
present={state?.devicePresent ?? null}
connectionStatus={state?.connectionStatus}
loading={loading}
compact
/>
<ChevronRight size={16} className="text-[var(--text-tertiary)]" aria-hidden="true" />
</span>
</button>
);
}
export function WorkLouderCodexEntryContainer({
model = 'codex-micro',
onOpen,
}: {
model?: WorkLouderModel;
onOpen(): void;
}) {
const { state, loading } = useWorkLouderCodex({ model, watchConnection: true });
return <WorkLouderCodexEntry model={model} state={state} loading={loading} onOpen={onOpen} />;
}
export function WorkLouderCodexSettings({
model = 'codex-micro',
onBack,
}: {
model?: WorkLouderModel;
onBack(): void;
}) {
const { t } = useTranslation();
const {
state,
loading,
saving,
error,
setSettings,
resetSettings,
openInputMonitoringSettings,
reload,
} = useWorkLouderCodex({ model, watchConnection: true });
const {
state: guardState,
loading: guardLoading,
saving: guardSaving,
error: guardError,
setEnabled: setGuardEnabled,
recover: recoverGuard,
} = useCodexMicroGuard();
const { skills, bootstrapped, refresh: refreshSkills } = useSkillhub();
const [brightnessDraft, setBrightnessDraft] = useState(100);
const [editingSlot, setEditingSlot] = useState<
WorkLouderCodexCommandSlot | WorkLouderCreatorProgrammableKey | null
>(null);
const [editingKeycapId, setEditingKeycapId] = useState<WorkLouderCodexKeycapId | null>(null);
const [editingAction, setEditingAction] = useState<WorkLouderCodexAction | null>(null);
const [editingSeparateMicrophoneKeys, setEditingSeparateMicrophoneKeys] = useState(false);
const [keycapQuery, setKeycapQuery] = useState('');
const [editingPart, setEditingPart] = useState<WorkLouderCodexEditableKey | null>(null);
const [pressedParts, setPressedParts] = useState<ReadonlySet<WorkLouderCodexPreviewPart>>(
() => new Set(),
);
const [encoderTurns, setEncoderTurns] = useState(0);
const [analogStick, setAnalogStick] = useState<{ angle: number; distance: number } | null>(null);
const settings = state?.settings ?? createWorkLouderCodexDefaultSettings(model);
const enabledSkills = useMemo(
() => skills.filter((skill) => skill.kind === 'skill' && !skill.parseError),
[skills],
);
const isDefault =
state !== null && workLouderCodexSettingsMatchRestoreDefaults(state.settings, model);
const isDefaultLayout =
JSON.stringify(settings.layout) ===
JSON.stringify(createWorkLouderCodexDefaultSettings(model).layout);
useEffect(() => {
if (state) setBrightnessDraft(state.settings.lightingBrightness);
}, [state?.settings.lightingBrightness]);
useEffect(() => {
if (!bootstrapped) void refreshSkills();
}, [bootstrapped, refreshSkills]);
useEffect(() => {
const api = window.electronAPI?.workLouderCodex;
void api?.setLayoutPreviewActive?.(true, model);
return () => {
void api?.setLayoutPreviewActive?.(false, model);
};
}, [model]);
useEffect(() => {
const unsubscribe = window.electronAPI?.workLouderCodex?.onPreviewInput?.((input) => {
applyPreviewInput(input, setPressedParts, setEncoderTurns, setAnalogStick);
});
return () => unsubscribe?.();
}, []);
const commitBrightness = ([brightness]: number[]): void => {
if (!state || saving || brightness === state.settings.lightingBrightness) return;
void setSettings({ lightingBrightness: brightness });
};
const patchLayout = (update: (layout: WorkLouderCodexLayout) => void): void => {
const layout = cloneWorkLouderCodexLayout(settings.layout);
update(layout);
void setSettings({ layout });
};
const layoutMerges = workLouderLayoutMerges(settings.layout);
const applyCommandKeycap = (
layout: WorkLouderCodexLayout,
slot: string,
keycapId: WorkLouderCodexKeycapId,
): void => {
const current = creatorCommandAssignment(layout, slot as WorkLouderCreatorProgrammableKey);
layout.slots[slot as WorkLouderCodexCommandSlot] = { ...current, keycapId };
if (slot === 'ACT10') {
layout.slots.ACT10_ACT11 = { ...layout.slots.ACT10 };
}
};
/**
* Every part of the board is configured by clicking it. A command key opens
* the keycap library; the other parts open a small editor of their own. That
* is why the panel below carries no per-key rows.
*/
const setCreatorTaskKey = (key: WorkLouderCreatorProgrammableKey, isTask: boolean): void => {
patchLayout((layout) => {
const selected = new Set(normalizeWorkLouderCreatorTaskKeys(layout.taskKeys));
if (isTask) selected.add(key);
else selected.delete(key);
layout.taskKeys = workLouderTaskKeysForLayout({
...layout,
taskKeys: WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS.filter((item) => selected.has(item)),
});
});
if (isTask) {
closeKeycapEditor();
setEditingPart(key);
return;
}
const assignment = creatorCommandAssignment(settings.layout, key);
setEditingPart(null);
setEditingSlot(key);
setEditingKeycapId(assignment.keycapId);
setEditingAction(assignment.action);
setEditingSeparateMicrophoneKeys(settings.layout.separateMicrophoneKeys);
setKeycapQuery('');
};
const creatorKeyRoleRow = (key: WorkLouderCreatorProgrammableKey, isTask: boolean): ReactNode => (
<>
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.agentKeys.role.label')}
description={t('settings.shortcuts.workLouderCodex.agentKeys.role.description')}
control={
<CreatorKeyRoleChoice
isTask={isTask}
disabled={!state}
taskLabel={t('settings.shortcuts.workLouderCodex.agentKeys.role.task')}
actionLabel={t('settings.shortcuts.workLouderCodex.agentKeys.role.action')}
ariaLabel={t('settings.shortcuts.workLouderCodex.agentKeys.role.label')}
onChange={(next) => setCreatorTaskKey(key, next)}
/>
}
/>
{isTask ? (
<p className="text-12 leading-[1.45] text-[var(--text-secondary)]">
{t('settings.shortcuts.workLouderCodex.agentKeys.taskHint')}
</p>
) : null}
</>
);
const editingProgrammableActionKey =
editingSlot !== null && isWorkLouderCreatorProgrammableKey(editingSlot);
const editingProgrammableTaskKey =
editingPart !== null && isWorkLouderCreatorProgrammableKey(editingPart);
const editingTaskIndex =
editingProgrammableTaskKey && isWorkLouderCreatorProgrammableKey(editingPart)
? normalizeWorkLouderCreatorTaskKeys(settings.layout.taskKeys).indexOf(editingPart)
: -1;
const openPartEditor = (key: WorkLouderCodexEditableKey): void => {
if (isWorkLouderCreatorProgrammableKey(key)) {
if (isCreatorTaskKey(settings.layout, key)) {
setEditingPart(key);
return;
}
const assignment = creatorCommandAssignment(settings.layout, key);
setEditingSlot(key);
setEditingKeycapId(assignment.keycapId);
setEditingAction(assignment.action);
setEditingSeparateMicrophoneKeys(settings.layout.separateMicrophoneKeys);
setKeycapQuery('');
return;
}
if (key.startsWith('ACT')) {
const slot = key as WorkLouderCodexCommandSlot;
setEditingSlot(slot);
setEditingKeycapId(settings.layout.slots[slot].keycapId);
setEditingAction(settings.layout.slots[slot].action);
setEditingSeparateMicrophoneKeys(settings.layout.separateMicrophoneKeys);
setKeycapQuery('');
return;
}
// A task key is only its own thing under "custom"; otherwise all six follow
// the shared rule and there is nothing per-key to edit.
if (key.startsWith('AG') && settings.agentSource !== 'custom') return;
setEditingPart(key);
};
const closeKeycapEditor = (): void => {
setEditingSlot(null);
setEditingKeycapId(null);
setEditingAction(null);
setEditingSeparateMicrophoneKeys(false);
setKeycapQuery('');
};
const saveKeycapEditor = (): void => {
if (!editingSlot || !editingKeycapId) return;
const slot = editingSlot;
patchLayout((layout) => {
const merged = workLouderMergeForKey(workLouderLayoutMerges(layout), slot)?.origin === slot;
let keycapId = canonicalizeWorkLouderCodexKeycapId(editingKeycapId);
if (keycapId !== 'MIC' && merged !== isWorkLouderCodexDoubleKeycap(keycapId)) {
keycapId = merged ? 'EMPT5' : 'EMPT1';
}
const action = editingAction;
applyCommandKeycap(layout, slot, keycapId);
layout.slots[slot as WorkLouderCodexCommandSlot] = {
...creatorCommandAssignment(layout, slot as WorkLouderCreatorProgrammableKey),
keycapId,
action,
};
if (slot === 'ACT10') {
layout.slots.ACT10_ACT11 = { ...layout.slots.ACT10 };
}
layout.taskKeys = workLouderTaskKeysForLayout(layout);
});
closeKeycapEditor();
};
const mergeEditingKey = (
origin: WorkLouderCreatorProgrammableKey,
direction: WorkLouderMergeDirection,
): void => {
const previousAction = creatorCommandAssignment(settings.layout, origin).action;
patchLayout((layout) => {
layout.merges = addWorkLouderMerge(workLouderLayoutMerges(layout), origin, direction);
layout.separateMicrophoneKeys = workLouderMicrophoneKeysSeparate(layout.merges);
const assignment = creatorCommandAssignment(layout, origin);
const nextKeycap = isWorkLouderCodexMicrophoneKeycap(assignment.keycapId)
? 'MIC'
: isWorkLouderCodexDoubleKeycap(assignment.keycapId)
? assignment.keycapId
: 'EMPT5';
layout.slots[origin] = { ...assignment, keycapId: nextKeycap };
layout.taskKeys = workLouderTaskKeysForLayout(layout);
});
setEditingPart(null);
setEditingSlot(origin);
setEditingKeycapId(
isWorkLouderCodexMicrophoneKeycap(creatorCommandAssignment(settings.layout, origin).keycapId)
? 'MIC'
: 'EMPT5',
);
setEditingAction(previousAction);
setKeycapQuery('');
};
const splitEditingKey = (key: WorkLouderCreatorProgrammableKey): void => {
const previous = creatorCommandAssignment(settings.layout, key);
const wasMic = isWorkLouderCodexMicrophoneKeycap(previous.keycapId);
patchLayout((layout) => {
layout.merges = removeWorkLouderMerge(workLouderLayoutMerges(layout), key);
layout.separateMicrophoneKeys = workLouderMicrophoneKeysSeparate(layout.merges);
const assignment = creatorCommandAssignment(layout, key);
if (isWorkLouderCodexDoubleKeycap(assignment.keycapId) && !wasMic) {
layout.slots[key] = { ...assignment, keycapId: 'EMPT1' };
}
layout.taskKeys = workLouderTaskKeysForLayout(layout);
});
setEditingPart(null);
setEditingSlot(key);
setEditingKeycapId(wasMic ? 'MIC' : 'EMPT1');
setEditingAction(previous.action);
};
const hintFor = (key: WorkLouderCodexEditableKey): WorkLouderCodexKeyHint | null => {
if (isWorkLouderCreatorProgrammableKey(key) && isCreatorTaskKey(settings.layout, key)) {
const index = normalizeWorkLouderCreatorTaskKeys(settings.layout.taskKeys).indexOf(key);
const slot = state?.agentSlots[index];
const custom = settings.agentSource === 'custom';
return {
legend: key,
name: custom
? index >= 0 && index < settings.customAgentKeys.length
? (actionLabel(settings.customAgentKeys[index] ?? null, t, state) ??
t('settings.shortcuts.workLouderCodex.agentKeys.newTask'))
: slot?.title || t('settings.shortcuts.workLouderCodex.agentKeys.newTask')
: slot?.title || t('settings.shortcuts.workLouderCodex.agentKeys.newTask'),
description: custom
? t('settings.shortcuts.workLouderCodex.agentKeys.customDescription')
: t(
`settings.shortcuts.workLouderCodex.agentKeys.source.options.${settings.agentSource}`,
),
};
}
if (key === 'analog') {
return {
legend: t('settings.shortcuts.workLouderCodex.layout.keyboard.analogStick'),
name: t('settings.shortcuts.workLouderCodex.analog.description'),
};
}
if (key === 'encoder') {
return {
legend: t('settings.shortcuts.workLouderCodex.layout.keyboard.encoder'),
name: t(
`settings.shortcuts.workLouderCodex.encoder.mode.options.${settings.layout.encoderMode}`,
),
description: t('settings.shortcuts.workLouderCodex.encoder.mode.description'),
};
}
const assignment = isWorkLouderCreatorProgrammableKey(key)
? creatorCommandAssignment(settings.layout, key)
: settings.layout.slots[key as WorkLouderCodexCommandSlot];
const action =
assignment.action ?? WORKLOUDER_CODEX_KEYCAP_ACTIONS[assignment.keycapId] ?? null;
if (isWorkLouderCodexMicrophoneKeycap(assignment.keycapId)) {
return {
legend: assignment.keycapId,
name: t('settings.shortcuts.workLouderCodex.actions.voice'),
description: t('settings.shortcuts.workLouderCodex.microphone.separate.description'),
};
}
if (action) {
return {
legend: blankKeycapLegend(assignment.keycapId, t),
name:
actionLabel(action, t, state) ??
t('settings.shortcuts.workLouderCodex.commandKeys.builtIn'),
description:
action.type === 'command'
? workLouderCodexCommandDescription(t, action.commandId)
: undefined,
};
}
return {
legend: blankKeycapLegend(assignment.keycapId, t),
name: t('settings.shortcuts.workLouderCodex.commandKeys.unmapped'),
};
};
return (
<div className="flex flex-col gap-[14px]">
<div className="flex items-center justify-between gap-3">
<div className="flex items-center gap-2">
<button
type="button"
onClick={onBack}
className="flex size-8 items-center justify-center rounded-md text-[var(--text-secondary)] transition-colors enabled:hover:bg-[var(--surface-chip)] enabled:hover:text-[var(--text-primary)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--focus-ring-soft)]"
aria-label={t('settings.shortcuts.workLouderCodex.back')}
>
<ArrowLeft size={17} />
</button>
<h2 className="text-16 font-medium leading-[1.2] text-[var(--settings-section-title)]">
{t(workLouderCopyKey(model, 'title'))}
</h2>
</div>
<SettingsResetButton
label={t('settings.shortcuts.reset')}
disabled={!state || saving || isDefault}
onClick={() => void resetSettings()}
/>
</div>
<SettingsCard className="flex items-center gap-4">
<div className="flex min-w-0 flex-1 flex-col gap-2">
<div className="flex flex-wrap items-center justify-between gap-2">
<p className="text-13 font-medium text-[var(--text-primary)]">
{t('settings.shortcuts.workLouderCodex.connection.toggle.label')}
</p>
<div className="flex items-center gap-2">
<Switch
checked={settings.deviceEnabled}
disabled={!state || saving}
onCheckedChange={(checked) => void setSettings({ deviceEnabled: checked })}
aria-label={t(workLouderCopyKey(model, 'connection.toggle.aria'))}
/>
<ConnectionStatus
enabled={settings.deviceEnabled}
present={state?.devicePresent ?? null}
connectionStatus={state?.connectionStatus}
loading={loading}
/>
</div>
</div>
<p className="text-12 leading-[1.45] text-[var(--text-secondary)]">
{settings.deviceEnabled
? connectionDescription(t, model, state)
: presenceDescription(t, model)}
</p>
{((settings.deviceEnabled && state?.connectionStatus === 'connected') ||
state?.devicePresent === true) &&
state?.device.deviceType && (
<div className="flex flex-wrap gap-2 pt-1">
<DeviceChip icon={<Keyboard size={12} />}>
{state.device.deviceType === 'creator-micro-2'
? 'Creator Micro 2'
: 'Codex Micro'}
</DeviceChip>
{state.device.isUsbConnection && (
<DeviceChip icon={<Usb size={12} />}>USB</DeviceChip>
)}
{state.device.batteryPercentage !== null && (
<DeviceChip
icon={state.device.isCharging ? <BatteryCharging size={12} /> : undefined}
>
{state.device.batteryPercentage}%
</DeviceChip>
)}
{state.device.firmwareVersion && (
<DeviceChip>
{t('settings.shortcuts.workLouderCodex.device.firmware', {
version: state.device.firmwareVersion,
})}
</DeviceChip>
)}
</div>
)}
</div>
</SettingsCard>
<SettingsCard className="flex flex-col gap-3">
<div className="flex items-start justify-between gap-3">
<div className="flex min-w-0 flex-col gap-1">
<h3 className="text-13 font-medium text-[var(--text-primary)]">
{t('settings.shortcuts.workLouderCodex.layout.keyboard.title')}
</h3>
<p className="text-12 leading-[1.45] text-[var(--text-secondary)]">
{t('settings.shortcuts.workLouderCodex.layout.keyboard.description')}
</p>
</div>
<SettingsResetButton
label={t('settings.shortcuts.workLouderCodex.layout.reset.button')}
title={t('settings.shortcuts.workLouderCodex.layout.reset.description')}
disabled={!state || saving || isDefaultLayout}
onClick={() =>
void setSettings({
layout: cloneWorkLouderCodexLayout(
createWorkLouderCodexDefaultSettings(model).layout,
),
})
}
/>
</div>
<div className="flex justify-center">
<WorkLouderCodexKeyboardLayout
layout={settings.layout}
agentSlots={state?.agentSlots ?? []}
disabled={!state || saving}
model={model}
labels={{
analogStick: t('settings.shortcuts.workLouderCodex.layout.keyboard.analogStick'),
encoder: t('settings.shortcuts.workLouderCodex.layout.keyboard.encoder'),
indicator: t('settings.shortcuts.workLouderCodex.layout.keyboard.indicator'),
}}
hintFor={hintFor}
canEdit={(key) =>
key === 'analog' ||
key === 'encoder' ||
key === 'ACT10_ACT11' ||
isWorkLouderCreatorProgrammableKey(key)
}
onEditKeycap={openPartEditor}
pressedParts={pressedParts}
encoderTurns={encoderTurns}
analogStick={analogStick}
/>
</div>
</SettingsCard>
{/* Task keys follow one shared assignment rule. Picking "custom" is what
makes them individually clickable. */}
<SettingsGroup title={t('settings.shortcuts.workLouderCodex.agentKeys.title')}>
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.agentKeys.source.label')}
description={t(
`settings.shortcuts.workLouderCodex.agentKeys.source.descriptions.${settings.agentSource}`,
)}
control={
<SelectControl
value={settings.agentSource}
disabled={!state || saving}
ariaLabel={t('settings.shortcuts.workLouderCodex.agentKeys.source.label')}
onChange={(value) =>
void setSettings({ agentSource: value as WorkLouderCodexAgentSource })
}
options={WORKLOUDER_CODEX_AGENT_SOURCES.map((source) => ({
value: source,
label: t(`settings.shortcuts.workLouderCodex.agentKeys.source.options.${source}`),
}))}
/>
}
/>
<SettingsDivider />
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.agentKeys.singleTap.label')}
description={t('settings.shortcuts.workLouderCodex.agentKeys.singleTap.description')}
control={
<Switch
checked={settings.singleTapAgentKeys}
disabled={!state || saving}
onCheckedChange={(checked) => void setSettings({ singleTapAgentKeys: checked })}
aria-label={t('settings.shortcuts.workLouderCodex.agentKeys.singleTap.aria')}
/>
}
/>
{normalizeWorkLouderCreatorTaskKeys(settings.layout.taskKeys).length >
WORKLOUDER_CODEX_AGENT_SLOT_COUNT && (
<>
<SettingsDivider />
<p className="px-1 py-2 text-12 leading-[1.45] text-[var(--text-secondary)]">
{t('settings.shortcuts.workLouderCodex.agentKeys.lightingLimit')}
</p>
</>
)}
</SettingsGroup>
<WorkLouderCodexKeycapPicker
open={editingSlot !== null}
slot={editingSlot}
double={Boolean(
editingSlot && workLouderMergeForKey(layoutMerges, editingSlot)?.origin === editingSlot,
)}
selectedKeycapId={editingKeycapId}
query={keycapQuery}
onQueryChange={setKeycapQuery}
onOpenChange={(open) => {
if (!open) closeKeycapEditor();
}}
onSelect={setEditingKeycapId}
onCancel={closeKeycapEditor}
onSave={saveKeycapEditor}
header={
editingProgrammableActionKey &&
editingSlot &&
isWorkLouderCreatorProgrammableKey(editingSlot)
? creatorKeyRoleRow(editingSlot, false)
: undefined
}
copy={{
title: t(
editingProgrammableActionKey
? 'settings.shortcuts.workLouderCodex.layout.editor.keyTitle'
: 'settings.shortcuts.workLouderCodex.layout.editor.title',
),
description: t(
editingProgrammableActionKey
? 'settings.shortcuts.workLouderCodex.layout.editor.keyDescription'
: 'settings.shortcuts.workLouderCodex.layout.editor.description',
),
searchPlaceholder: t(
'settings.shortcuts.workLouderCodex.layout.editor.searchPlaceholder',
),
close: t('settings.shortcuts.workLouderCodex.layout.editor.close'),
cancel: t('settings.shortcuts.workLouderCodex.layout.editor.cancel'),
save: t('settings.shortcuts.workLouderCodex.layout.editor.save'),
blank: t('settings.shortcuts.workLouderCodex.layout.editor.blank'),
}}
>
<div className="flex flex-col gap-3">
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.layout.editor.assignedShortcut')}
description={t('settings.shortcuts.workLouderCodex.commandKeys.builtInDescription')}
control={
<ActionSelect
action={editingAction}
state={state}
skills={enabledSkills}
disabled={!state || saving || !editingSlot}
allowVoice
emptyLabel={t('settings.shortcuts.workLouderCodex.commandKeys.builtIn')}
onChange={setEditingAction}
/>
}
/>
{editingSlot && isWorkLouderCreatorProgrammableKey(editingSlot) && (
<>
<SettingsDivider />
<KeyMergeControls
origin={editingSlot}
merges={layoutMerges}
disabled={!state || saving}
onMerge={(direction) => mergeEditingKey(editingSlot, direction)}
onSplit={() => splitEditingKey(editingSlot)}
/>
</>
)}
</div>
</WorkLouderCodexKeycapPicker>
{/* Task keys follow the shared order; custom source is the only per-key task pick. */}
<WorkLouderCodexPartEditor
open={Boolean(
editingPart &&
(editingPart.startsWith('AG') || isWorkLouderCreatorProgrammableKey(editingPart)),
)}
onOpenChange={(open) => {
if (!open) setEditingPart(null);
}}
onConfirm={() => {
if (editingPart && isWorkLouderCreatorProgrammableKey(editingPart)) {
patchLayout((layout) => {
const selected = new Set(normalizeWorkLouderCreatorTaskKeys(layout.taskKeys));
selected.add(editingPart);
layout.taskKeys = workLouderTaskKeysForLayout({
...layout,
taskKeys: WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS.filter((item) => selected.has(item)),
});
});
}
}}
title={
editingProgrammableTaskKey
? t('settings.shortcuts.workLouderCodex.layout.editor.keyTitle')
: (editingPart ?? '')
}
description={
editingProgrammableTaskKey
? t('settings.shortcuts.workLouderCodex.layout.editor.keyDescription')
: t('settings.shortcuts.workLouderCodex.agentKeys.customDescription')
}
closeLabel={t('settings.shortcuts.workLouderCodex.layout.editor.done')}
>
{editingPart &&
(editingPart.startsWith('AG') || isWorkLouderCreatorProgrammableKey(editingPart)) && (
<div className="flex flex-col gap-3">
{editingProgrammableTaskKey && isWorkLouderCreatorProgrammableKey(editingPart) && (
<>
{creatorKeyRoleRow(editingPart, true)}
{editingTaskIndex >= WORKLOUDER_CODEX_AGENT_SLOT_COUNT && (
<p className="text-12 leading-[1.45] text-[var(--text-secondary)]">
{t('settings.shortcuts.workLouderCodex.agentKeys.unlitKey')}
</p>
)}
</>
)}
{isWorkLouderCreatorProgrammableKey(editingPart) && (
<KeyMergeControls
origin={editingPart}
merges={layoutMerges}
disabled={!state || saving}
onMerge={(direction) => mergeEditingKey(editingPart, direction)}
onSplit={() => splitEditingKey(editingPart)}
/>
)}
{settings.agentSource === 'custom' &&
editingTaskIndex >= 0 &&
editingTaskIndex < WORKLOUDER_CODEX_AGENT_SLOT_COUNT && (
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.agentKeys.source.options.custom')}
description={t(
'settings.shortcuts.workLouderCodex.agentKeys.customDescription',
)}
control={
<ActionSelect
action={settings.customAgentKeys[editingTaskIndex] ?? null}
state={state}
skills={enabledSkills}
disabled={!state || saving}
emptyLabel={t('settings.shortcuts.workLouderCodex.agentKeys.newTask')}
allowTasks
allowKeycaps
onChange={(action) => {
if (
editingTaskIndex < 0 ||
editingTaskIndex >= settings.customAgentKeys.length
) {
return;
}
const customAgentKeys = settings.customAgentKeys.map((item) =>
item ? { ...item } : null,
);
customAgentKeys[editingTaskIndex] = action;
void setSettings({ customAgentKeys });
}}
/>
}
/>
)}
</div>
)}
</WorkLouderCodexPartEditor>
<WorkLouderCodexPartEditor
open={editingPart === 'analog'}
onOpenChange={(open) => {
if (!open) setEditingPart(null);
}}
title={t('settings.shortcuts.workLouderCodex.analog.title')}
description={t('settings.shortcuts.workLouderCodex.analog.description')}
closeLabel={t('settings.shortcuts.workLouderCodex.layout.editor.done')}
>
<div className="flex flex-col gap-3">
{WORKLOUDER_CODEX_ANALOG_DIRECTIONS.map((direction, index) => (
<div key={direction}>
{index > 0 && <SettingsDivider />}
<SettingsRow
label={t(`settings.shortcuts.workLouderCodex.analog.directions.${direction}`)}
description={t('settings.shortcuts.workLouderCodex.analog.description')}
control={
<ActionSelect
action={settings.layout.analogStick[direction]}
state={state}
skills={enabledSkills}
disabled={!state || saving}
emptyLabel={t('settings.shortcuts.workLouderCodex.actions.none')}
onChange={(action) =>
patchLayout((layout) => {
layout.analogStick[direction] = action;
})
}
/>
}
/>
</div>
))}
</div>
</WorkLouderCodexPartEditor>
<WorkLouderCodexPartEditor
open={editingPart === 'encoder'}
onOpenChange={(open) => {
if (!open) setEditingPart(null);
}}
title={t('settings.shortcuts.workLouderCodex.encoder.title')}
description={t('settings.shortcuts.workLouderCodex.encoder.mode.description')}
closeLabel={t('settings.shortcuts.workLouderCodex.layout.editor.done')}
>
<div className="flex flex-col gap-3">
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.encoder.mode.label')}
description={t('settings.shortcuts.workLouderCodex.encoder.mode.description')}
control={
<SelectControl
value={settings.layout.encoderMode}
disabled={!state || saving}
ariaLabel={t('settings.shortcuts.workLouderCodex.encoder.mode.label')}
onChange={(value) =>
patchLayout((layout) => {
layout.encoderMode = value as WorkLouderCodexLayout['encoderMode'];
})
}
options={WORKLOUDER_CODEX_ENCODER_MODES.map((mode) => ({
value: mode,
label: t(`settings.shortcuts.workLouderCodex.encoder.mode.options.${mode}`),
}))}
/>
}
/>
{settings.layout.encoderMode === 'custom' &&
WORKLOUDER_CODEX_ENCODER_ACTIONS.map((gesture) => (
<div key={gesture}>
<SettingsDivider />
<SettingsRow
label={t(`settings.shortcuts.workLouderCodex.encoder.gestures.${gesture}`)}
description={t('settings.shortcuts.workLouderCodex.encoder.customDescription')}
control={
<ActionSelect
action={settings.layout.encoder[gesture]}
state={state}
skills={enabledSkills}
disabled={!state || saving}
emptyLabel={t('settings.shortcuts.workLouderCodex.actions.none')}
onChange={(action) =>
patchLayout((layout) => {
layout.encoder[gesture] = action;
})
}
/>
}
/>
</div>
))}
</div>
</WorkLouderCodexPartEditor>
{error && (
<ErrorNotice
message={t(workLouderCopyKey(model, `errors.${error}`))}
actions={
error === 'load' && (
<Button size="sm" compact onClick={() => void reload()}>
{t('settings.shortcuts.workLouderCodex.retry')}
</Button>
)
}
/>
)}
{state?.device.inputMonitoringPermission === 'denied' && (
<SettingsGroup title={t('settings.shortcuts.workLouderCodex.device.title')}>
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.device.inputMonitoring.label')}
description={t(
`settings.shortcuts.workLouderCodex.device.inputMonitoring.${state?.device.inputMonitoringPermission ?? 'unknown'}`,
)}
control={
<Button
variant="secondary"
size="md"
compact
type="button"
onClick={() => void openInputMonitoringSettings()}
>
{t('settings.shortcuts.workLouderCodex.device.inputMonitoring.open')}
</Button>
}
/>
</SettingsGroup>
)}
<SettingsGroup title={t('settings.shortcuts.workLouderCodex.lighting.title')}>
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.lighting.brightness.label')}
description={t('settings.shortcuts.workLouderCodex.lighting.brightness.description')}
control={
<div className="flex min-w-[220px] items-center gap-3">
<Slider
min={0}
max={100}
step={10}
value={[brightnessDraft]}
disabled={!state || saving}
onValueChange={([brightness]) => setBrightnessDraft(brightness)}
onValueCommit={commitBrightness}
className="flex-1"
aria-label={t('settings.shortcuts.workLouderCodex.lighting.brightness.aria')}
/>
<span className="w-10 text-right text-12 tabular-nums text-[var(--text-secondary)]">
{brightnessDraft}%
</span>
</div>
}
/>
<SettingsDivider />
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.lighting.autoDim.label')}
description={t('settings.shortcuts.workLouderCodex.lighting.autoDim.description')}
control={
<SelectControl
value={settings.lightingAutoDim}
disabled={!state || saving}
ariaLabel={t('settings.shortcuts.workLouderCodex.lighting.autoDim.aria')}
onChange={(value) =>
void setSettings({ lightingAutoDim: value as WorkLouderCodexAutoDim })
}
options={WORKLOUDER_CODEX_AUTO_DIM_OPTIONS.map((option) => ({
value: option,
label: t(`settings.shortcuts.workLouderCodex.lighting.autoDim.options.${option}`),
}))}
/>
}
/>
</SettingsGroup>
{/* Both keyboards share the same Codex service and machine-local guard. */}
<SettingsGroup title={t('settings.shortcuts.workLouderCodex.codexGuard.title')}>
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.codexGuard.label')}
description={t(
`settings.shortcuts.workLouderCodex.codexGuard.descriptions.${guardDescriptionKey(
guardState?.status,
guardError,
)}`,
)}
control={
<div className="flex items-center justify-end gap-2">
{guardState?.enabled &&
guardState.restartRequired &&
!guardError &&
(guardState.status === 'protecting' || guardState.status === 'intercepted') && (
<span className="text-12 text-[var(--text-secondary)]">
{t('settings.shortcuts.workLouderCodex.codexGuard.restartRequired')}
</span>
)}
{guardState?.status === 'recovery-required' ? (
<SettingsSecondaryButton
loading={guardSaving}
disabled={guardSaving}
onClick={() => void recoverGuard()}
>
{t('settings.shortcuts.workLouderCodex.codexGuard.recover')}
</SettingsSecondaryButton>
) : (
<Switch
checked={guardState?.enabled ?? false}
disabled={
guardLoading ||
guardSaving ||
!guardState ||
!guardState.supported ||
guardState.status === 'paused'
}
onCheckedChange={(checked) => void setGuardEnabled(checked)}
aria-label={t('settings.shortcuts.workLouderCodex.codexGuard.aria')}
/>
)}
</div>
}
/>
</SettingsGroup>
</div>
);
}
function KeyMergeControls({
origin,
merges,
disabled,
onMerge,
onSplit,
}: {
origin: WorkLouderCreatorProgrammableKey;
merges: ReturnType<typeof workLouderLayoutMerges>;
disabled: boolean;
onMerge(direction: WorkLouderMergeDirection): void;
onSplit(): void;
}) {
const { t } = useTranslation();
const current = workLouderMergeForKey(merges, origin);
if (current?.origin === origin) {
return (
<SettingsRow
label={t('settings.shortcuts.workLouderCodex.layout.merge.split')}
description={t('settings.shortcuts.workLouderCodex.layout.merge.splitDescription')}
control={
<Button
variant="secondary"
size="md"
compact
type="button"
disabled={disabled}
onClick={onSplit}
className="shrink-0"
>
{t('settings.shortcuts.workLouderCodex.layout.merge.split')}
</Button>
}
/>
);
}
const directions = workLouderAvailableMergeDirections(merges, origin);
if (directions.length === 0) return null;
return (
<div className="flex flex-col gap-2">
{directions.map((direction) => (
<SettingsRow
key={direction}
label={t(`settings.shortcuts.workLouderCodex.layout.merge.${direction}`)}
description={t(`settings.shortcuts.workLouderCodex.layout.merge.${direction}Description`)}
control={
<Button
variant="secondary"
size="md"
compact
type="button"
disabled={disabled}
onClick={() => onMerge(direction)}
>
{t(`settings.shortcuts.workLouderCodex.layout.merge.${direction}`)}
</Button>
}
/>
))}
</div>
);
}
function ActionSelect({
action,
state,
skills,
disabled,
emptyLabel,
allowTasks = false,
allowKeycaps = false,
allowVoice = false,
onChange,
className,
}: {
action: WorkLouderCodexAction | null;
state: WorkLouderCodexState | null;
skills: SkillhubSkill[];
disabled: boolean;
emptyLabel: string;
allowTasks?: boolean;
allowKeycaps?: boolean;
/** Only physical keys can hold-to-talk; stick, encoder, and task editors omit it. */
allowVoice?: boolean;
onChange(action: WorkLouderCodexAction | null): void;
className?: string;
}) {
const { t } = useTranslation();
const groups: SelectOptionGroup[] = [
{
options: [
{ value: 'none', label: emptyLabel },
// Hold-to-talk voice on a physical key — how blank-cap boards bind it.
...(allowVoice
? [{ value: 'voice', label: t('settings.shortcuts.workLouderCodex.actions.voice') }]
: []),
],
},
];
if (allowTasks && state && state.taskOptions.length > 0) {
groups.push({
label: t('settings.shortcuts.workLouderCodex.actions.tasks'),
options: state.taskOptions.map((task) => ({
value: `task:${task.id}`,
label: task.title || t('ccAgent.common.unnamedSession'),
})),
});
}
groups.push({
label: t('settings.shortcuts.workLouderCodex.actions.commands'),
options: WORKLOUDER_CODEX_COMMAND_IDS.map((commandId) => ({
value: `command:${commandId}`,
label: workLouderCodexCommandName(t, commandId),
})),
});
if (allowKeycaps) {
groups.push({
label: t('settings.shortcuts.workLouderCodex.actions.keycaps'),
options: WORKLOUDER_CODEX_KEYCAP_IDS.filter(
(keycapId) => WORKLOUDER_CODEX_KEYCAP_ACTIONS[keycapId],
).map((keycapId) => ({
value: `keycap:${keycapId}`,
label: keycapId,
})),
});
}
if (skills.length > 0) {
groups.push({
label: t('settings.shortcuts.workLouderCodex.actions.skills'),
options: skills.map((skill) => ({
value: `skill:${skill.id}`,
label: skill.name,
})),
});
}
return (
<SelectControl
value={actionValue(action)}
disabled={disabled}
ariaLabel={t('settings.shortcuts.workLouderCodex.actions.choose')}
onChange={(value) => onChange(parseActionValue(value, state, skills))}
className={cn('min-w-[190px]', className)}
groups={groups}
/>
);
}
interface SelectOption {
value: string;
label: string;
disabled?: boolean;
}
interface SelectOptionGroup {
label?: string;
options: SelectOption[];
}
function SelectControl({
value,
disabled,
ariaLabel,
onChange,
options,
groups,
className,
}: {
value: string;
disabled: boolean;
ariaLabel: string;
onChange(value: string): void;
options?: SelectOption[];
groups?: SelectOptionGroup[];
className?: string;
}) {
const resolvedGroups = groups ?? [{ options: options ?? [] }];
return (
<Select.Root value={value} onValueChange={onChange} disabled={disabled}>
<Select.Trigger
aria-label={ariaLabel}
className={cn(
'flex h-9 min-w-[150px] items-center justify-between gap-2 rounded-full border px-3 text-12',
'border-[var(--settings-input-border)] bg-[var(--settings-input-bg)] text-[var(--settings-input-text)]',
'outline-none focus-visible:ring-2 focus-visible:ring-[var(--focus-ring-soft)]',
'data-[disabled]:cursor-not-allowed data-[disabled]:opacity-50',
className,
)}
>
<span className="min-w-0 truncate text-left">
<Select.Value />
</span>
<Select.Icon asChild>
<ChevronDown size={14} className="shrink-0 opacity-70" />
</Select.Icon>
</Select.Trigger>
<Select.Portal>
<Select.Content
position="popper"
side="bottom"
align="end"
sideOffset={4}
className={cn(
'z-[10010] w-[var(--radix-select-trigger-width)] overflow-hidden rounded-xl border p-1.5',
'max-h-[min(15rem,var(--radix-select-content-available-height))]',
'border-[var(--border-default)] bg-[var(--surface-elevated)]',
)}
>
<Select.ScrollUpButton className="flex h-5 items-center justify-center text-[var(--text-tertiary)]">
<ChevronUp size={14} />
</Select.ScrollUpButton>
<Select.Viewport>
{resolvedGroups.map((group, groupIndex) => (
<Select.Group key={group.label ?? `group-${groupIndex}`}>
{group.label && (
<Select.Label className="px-2.5 py-1 text-11 text-[var(--text-tertiary)]">
{group.label}
</Select.Label>
)}
{group.options.map((option) => (
<Select.Item
key={option.value}
value={option.value}
disabled={option.disabled}
className={cn(
'flex w-full cursor-pointer select-none items-center gap-2 rounded-[8px] px-2.5 py-1.5 text-left text-12 outline-none',
'text-[var(--text-primary)]',
'data-[state=checked]:font-medium',
'data-[disabled]:cursor-not-allowed data-[disabled]:opacity-50',
)}
>
<span className="flex h-4 w-4 shrink-0 items-center justify-center">
<Select.ItemIndicator>
<Check size={14} strokeWidth={2.25} />
</Select.ItemIndicator>
</span>
<Select.ItemText>{option.label}</Select.ItemText>
</Select.Item>
))}
</Select.Group>
))}
</Select.Viewport>
<Select.ScrollDownButton className="flex h-5 items-center justify-center text-[var(--text-tertiary)]">
<ChevronDown size={14} />
</Select.ScrollDownButton>
</Select.Content>
</Select.Portal>
</Select.Root>
);
}
/**
* Restore control for this device page.
* Always a compact icon+label button at the top-right of the unit it resets
* (page title or section header). Never a text link, never a standalone card.
*/
function SettingsResetButton({
label,
title,
disabled,
onClick,
}: {
label: string;
title?: string;
disabled?: boolean;
onClick: () => void;
}) {
return (
<Button
variant="secondary"
size="md"
compact
type="button"
title={title}
disabled={disabled}
onClick={onClick}
>
<RotateCcw size={13} aria-hidden />
{label}
</Button>
);
}
function SettingsCard({ className, children }: { className?: string; children: ReactNode }) {
return (
<div
className={cn(
'rounded-xl border border-[var(--settings-theme-card-border)] bg-[var(--settings-theme-card-bg)] p-5',
className,
)}
>
{children}
</div>
);
}
function SettingsGroup({ title, children }: { title: string; children: ReactNode }) {
return (
<div className="flex flex-col gap-2">
<h3 className="px-1 text-13 font-medium text-[var(--settings-section-title)]">{title}</h3>
<SettingsCard>{children}</SettingsCard>
</div>
);
}
function SettingsRow({
label,
description,
control,
}: {
label: string;
description: string;
control: ReactNode;
}) {
return (
<div className="flex flex-wrap items-center justify-between gap-5 py-2">
<div className="flex min-w-[220px] flex-1 flex-col gap-1">
<p className="text-13 font-medium text-[var(--text-primary)]">{label}</p>
<p className="text-12 leading-[1.45] text-[var(--text-secondary)]">{description}</p>
</div>
<div className="min-w-0 shrink-0 max-sm:w-full">{control}</div>
</div>
);
}
function CreatorKeyRoleChoice({
isTask,
disabled,
taskLabel,
actionLabel,
ariaLabel,
onChange,
}: {
isTask: boolean;
disabled: boolean;
taskLabel: string;
actionLabel: string;
ariaLabel: string;
onChange: (isTask: boolean) => void;
}) {
return (
<SegmentedControl
aria-label={ariaLabel}
value={isTask ? 'task' : 'action'}
onValueChange={(next) => {
if ((next === 'task') !== isTask) onChange(next === 'task');
}}
options={[
{ value: 'task', label: taskLabel },
{ value: 'action', label: actionLabel },
]}
disabled={disabled}
/>
);
}
function SettingsDivider() {
return <div className="my-1 h-px bg-[var(--settings-theme-card-border)]" />;
}
function SettingsSecondaryButton({ children, ...props }: Omit<ButtonProps, 'className' | 'type'>) {
return (
<Button variant="secondary" size="md" compact {...props} type="button" className="shrink-0">
{children}
</Button>
);
}
function DeviceChip({ icon, children }: { icon?: ReactNode; children: ReactNode }) {
return (
<span className="inline-flex items-center gap-1.5 rounded-full border border-[var(--settings-theme-card-border)] bg-[var(--surface-chip)] px-2 py-1 text-11 text-[var(--text-secondary)]">
{icon}
{children}
</span>
);
}
function ConnectionStatus({
enabled,
present = null,
connectionStatus = null,
loading,
compact = false,
}: {
enabled: boolean;
present?: boolean | null;
connectionStatus?: WorkLouderCodexConnectionStatus | null;
loading: boolean;
compact?: boolean;
}) {
const { t } = useTranslation();
const key = resolveInputDeviceStatusKey({
enabled,
present,
connectionStatus,
loading,
});
return (
<InputDeviceConnectionStatus
label={t(
`settings.shortcuts.workLouderCodex.connection.status.${inputDeviceStatusLabelKey(key)}`,
)}
tone={inputDeviceConnectionTone({ status: key, present })}
compact={compact}
/>
);
}
/**
* Icon for the Codex Micro entry row: the device's own silhouette rather than a
* generic keyboard. Round controls in the top corners, six task keys, a row of
* command keys, and the double-width microphone — the same shape as the board
* on the detail page, reduced to what still reads at 20px.
*
* Drawn as SVG so the 4.5-unit keys stay crisp, and in `currentColor` so it
* picks up the chip's text colour in both themes.
*/
function CodexMicroGlyph() {
// Four columns of 4.5 with 1 between them, inset half a unit.
const track = [0.5, 6, 11.5, 17];
return (
<svg width={20} height={20} viewBox="0 0 22 22" fill="none" aria-hidden="true">
{/* Row 1 — encoder, two task keys, analog stick. */}
<circle cx={2.75} cy={2.75} r={2.25} fill="currentColor" opacity={0.55} />
<rect x={6} y={0.5} width={4.5} height={4.5} rx={1} fill="currentColor" opacity={0.95} />
<rect x={11.5} y={0.5} width={4.5} height={4.5} rx={1} fill="currentColor" opacity={0.95} />
<circle cx={19.25} cy={2.75} r={2.25} fill="currentColor" opacity={0.55} />
{/* Row 2 — the remaining four task keys, the brightest caps on the board. */}
{track.map((x) => (
<rect
key={`task-${x}`}
x={x}
y={6}
width={4.5}
height={4.5}
rx={1}
fill="currentColor"
opacity={0.95}
/>
))}
{/* Row 3 — the four command keys. */}
{track.map((x) => (
<rect
key={`command-${x}`}
x={x}
y={11.5}
width={4.5}
height={4.5}
rx={1}
fill="currentColor"
opacity={0.45}
/>
))}
{/* Row 4 — status lights, the double-width microphone key, Codex. */}
<circle cx={2.75} cy={19.25} r={1} fill="currentColor" opacity={0.45} />
<rect x={6} y={17} width={10} height={4.5} rx={1} fill="currentColor" opacity={0.45} />
<rect x={17} y={17} width={4.5} height={4.5} rx={1} fill="currentColor" opacity={0.45} />
</svg>
);
}
function guardDescriptionKey(
status: import('../../../shared/codexMicroGuard').CodexMicroGuardStatus | undefined,
requestFailed: boolean,
): string {
if (requestFailed) return 'error';
switch (status) {
case 'paused':
return 'paused';
case 'unsupported':
return 'unsupported';
case 'protecting':
case 'intercepted':
return 'disabled';
case 'recovery-required':
return 'recovery-required';
case 'error':
return 'error';
case 'disabled':
case undefined:
return 'disabled';
}
}
function connectionDescription(
t: ReturnType<typeof useTranslation>['t'],
model: WorkLouderModel,
state: WorkLouderCodexState | null,
): string {
const key = state?.connectionReason ?? state?.connectionStatus ?? 'connecting';
return t(workLouderCopyKey(model, `connection.descriptions.${key}`));
}
function presenceDescription(
t: ReturnType<typeof useTranslation>['t'],
model: WorkLouderModel,
): string {
return t(workLouderCopyKey(model, 'connection.descriptions.disabled'));
}
function workLouderCodexSettingsMatchRestoreDefaults(
settings: WorkLouderCodexState['settings'],
model: WorkLouderModel = 'codex-micro',
): boolean {
const defaults = createWorkLouderCodexDefaultSettings(model);
return (
JSON.stringify({ ...settings, deviceEnabled: false }) ===
JSON.stringify({ ...defaults, deviceEnabled: false })
);
}
/**
* Human-readable name for whatever a key is bound to, for the hover tooltip.
* Returns null when the binding has no name worth showing on its own.
*/
function actionLabel(
action: WorkLouderCodexAction | null,
t?: ReturnType<typeof useTranslation>['t'],
state?: WorkLouderCodexState | null,
): string | null {
if (!action) return null;
switch (action.type) {
case 'command':
return t ? workLouderCodexCommandName(t, action.commandId) : action.commandId;
case 'voice':
return t ? t('settings.shortcuts.workLouderCodex.actions.voice') : 'voice';
case 'skill':
return action.name;
case 'keycap':
return action.keycapId;
case 'composer-text':
return action.text;
case 'external-url':
return action.url;
case 'task':
return (
state?.taskOptions.find((task) => task.id === action.sessionId)?.title ?? action.sessionId
);
}
}
function actionValue(action: WorkLouderCodexAction | null): string {
if (!action) return 'none';
switch (action.type) {
case 'command':
return `command:${action.commandId}`;
case 'voice':
return 'voice';
case 'task':
return `task:${action.sessionId}`;
case 'keycap':
return `keycap:${action.keycapId}`;
case 'skill':
return `skill:${action.skillId}`;
case 'composer-text':
return `text:${action.text}`;
case 'external-url':
return `url:${action.url}`;
}
}
function parseActionValue(
value: string,
state: WorkLouderCodexState | null,
skills: SkillhubSkill[],
): WorkLouderCodexAction | null {
if (value === 'none') return null;
if (value === 'voice') return { type: 'voice' };
if (value.startsWith('command:')) {
return { type: 'command', commandId: value.slice(8) as WorkLouderCodexCommandId };
}
if (value.startsWith('task:')) {
const sessionId = value.slice(5);
return state?.taskOptions.some((task) => task.id === sessionId)
? { type: 'task', sessionId }
: null;
}
if (value.startsWith('keycap:')) {
return { type: 'keycap', keycapId: value.slice(7) as WorkLouderCodexKeycapId };
}
if (value.startsWith('skill:')) {
const skillId = value.slice(6);
const skill = skills.find((item) => item.id === skillId);
return skill ? { type: 'skill', skillId, name: skill.name } : null;
}
if (value.startsWith('text:')) {
return { type: 'composer-text', text: value.slice(5) };
}
if (value.startsWith('url:')) {
const url = value.slice(4);
try {
const parsed = new URL(url);
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
} catch {
return null;
}
return { type: 'external-url', url };
}
return null;
}
export type { WorkLouderCodexSettingsPatch };