Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

31.7 KB
Raw Blame
/** Work Louder Codex Micro settings, device state, and IPC contracts. */

import {
  INPUT_DEVICE_COMMAND_IDS,
  isInputDeviceCommandId,
  type InputDeviceAction,
  type InputDeviceCommandId,
  type InputDeviceDescriptor,
  type InputDevicePublishedTask,
  type InputDeviceRendererAction,
} from './inputDevices';

export const WORKLOUDER_CODEX_DEVICE_ID = 'worklouder-codex-micro';
export const WORKLOUDER_CREATOR_MICRO_2_DEVICE_ID = 'worklouder-creator-micro-2';

export const WORKLOUDER_MODELS = ['codex-micro', 'creator-micro-2'] as const;
export type WorkLouderModel = (typeof WORKLOUDER_MODELS)[number];
/** Settings currently lists both Work Louder boards. */
export const VISIBLE_WORKLOUDER_MODELS = WORKLOUDER_MODELS;

export const WORKLOUDER_CODEX_DEVICE: InputDeviceDescriptor = {
  id: WORKLOUDER_CODEX_DEVICE_ID,
  label: 'Work Louder Codex Micro',
  capabilities: [
    { kind: 'task-slots', count: 6 },
    { kind: 'commands' },
    { kind: 'voice' },
    { kind: 'encoder' },
    { kind: 'stick' },
    { kind: 'lighting', model: 'task-slots' },
  ],
};

export const WORKLOUDER_CREATOR_MICRO_2_DEVICE: InputDeviceDescriptor = {
  id: WORKLOUDER_CREATOR_MICRO_2_DEVICE_ID,
  label: 'Work Louder Creator Micro 2',
  capabilities: WORKLOUDER_CODEX_DEVICE.capabilities,
};

export const WORKLOUDER_DEVICES: Record<WorkLouderModel, InputDeviceDescriptor> = {
  'codex-micro': WORKLOUDER_CODEX_DEVICE,
  'creator-micro-2': WORKLOUDER_CREATOR_MICRO_2_DEVICE,
};

export function isWorkLouderModel(value: unknown): value is WorkLouderModel {
  return typeof value === 'string' && (WORKLOUDER_MODELS as readonly string[]).includes(value);
}

export const WORKLOUDER_CODEX_GET_STATE_CHANNEL = 'worklouder-codex:get-state';
export const WORKLOUDER_CODEX_SET_SETTINGS_CHANNEL = 'worklouder-codex:set-settings';
export const WORKLOUDER_CODEX_RESET_SETTINGS_CHANNEL = 'worklouder-codex:reset-settings';
export const WORKLOUDER_CODEX_OPEN_INPUT_MONITORING_CHANNEL =
  'worklouder-codex:open-input-monitoring-settings';
export const WORKLOUDER_CODEX_PROBE_CHANNEL = 'worklouder-codex:probe';
export const WORKLOUDER_CODEX_PUBLISH_TASKS_CHANNEL = 'worklouder-codex:publish-tasks';
export const WORKLOUDER_CODEX_SET_LAYOUT_PREVIEW_CHANNEL = 'worklouder-codex:set-layout-preview';

/** One sidebar task, as the renderer reports it for the agent keys. */
export type WorkLouderCodexPublishedTask = InputDevicePublishedTask;
export const WORKLOUDER_CODEX_STATE_CHANGED_CHANNEL = 'worklouder-codex:state-changed';
export const WORKLOUDER_CODEX_ACTION_CHANNEL = 'worklouder-codex:action';
export const WORKLOUDER_CODEX_PREVIEW_INPUT_CHANNEL = 'worklouder-codex:preview-input';

export const WORKLOUDER_CODEX_AGENT_SLOT_COUNT = 6;

export const WORKLOUDER_CODEX_AUTO_DIM_OPTIONS = [
  'off',
  '30-seconds',
  '1-minute',
  '3-minutes',
  '10-minutes',
  '30-minutes',
  '1-hour',
] as const;

export const WORKLOUDER_CODEX_AGENT_SOURCES = ['sidebar', 'last-sent', 'priority', 'custom'] as const;

export const WORKLOUDER_CODEX_COMMAND_SLOTS = [
  'ACT06',
  'ACT07',
  'ACT08',
  'ACT09',
  'ACT10',
  'ACT11',
  'ACT10_ACT11',
  'ACT12',
] as const;

/** Physical 1U keys on Creator Micro 2, in board order. */
export const WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS = [
  'AG00',
  'AG01',
  'AG02',
  'AG03',
  'AG04',
  'AG05',
  'ACT06',
  'ACT07',
  'ACT08',
  'ACT09',
  'ACT10',
  'ACT11',
  'ACT12',
] as const;
export type WorkLouderCreatorProgrammableKey =
  (typeof WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS)[number];

export const WORKLOUDER_CREATOR_DEFAULT_TASK_KEYS = [
  'AG00',
  'AG01',
  'AG02',
  'AG03',
  'AG04',
  'AG05',
] as const satisfies readonly WorkLouderCreatorProgrammableKey[];

export const WORKLOUDER_CREATOR_KEYMAP_LAYOUT: readonly (readonly WorkLouderCreatorProgrammableKey[])[] =
  [
    ['AG00', 'AG01'],
    ['AG02', 'AG03', 'AG04', 'AG05'],
    ['ACT06', 'ACT07', 'ACT08', 'ACT09'],
    ['ACT10', 'ACT11', 'ACT12'],
  ];

/** 4×4 board cells. Encoder, analog stick, and status lights occupy the other three. */
export const WORKLOUDER_KEY_CELL: Record<
  WorkLouderCreatorProgrammableKey,
  { row: number; col: number }
> = {
  AG00: { row: 0, col: 1 },
  AG01: { row: 0, col: 2 },
  AG02: { row: 1, col: 0 },
  AG03: { row: 1, col: 1 },
  AG04: { row: 1, col: 2 },
  AG05: { row: 1, col: 3 },
  ACT06: { row: 2, col: 0 },
  ACT07: { row: 2, col: 1 },
  ACT08: { row: 2, col: 2 },
  ACT09: { row: 2, col: 3 },
  ACT10: { row: 3, col: 1 },
  ACT11: { row: 3, col: 2 },
  ACT12: { row: 3, col: 3 },
};

export type WorkLouderMergeDirection = 'right' | 'down';

/** A 2U cap covering `origin` and the neighbor `cover` (right or down). */
export interface WorkLouderKeyMerge {
  origin: WorkLouderCreatorProgrammableKey;
  cover: WorkLouderCreatorProgrammableKey;
}

function workLouderKeyAt(row: number, col: number): WorkLouderCreatorProgrammableKey | null {
  for (const key of WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS) {
    const cell = WORKLOUDER_KEY_CELL[key];
    if (cell.row === row && cell.col === col) return key;
  }
  return null;
}

export function workLouderMergeNeighbor(
  origin: WorkLouderCreatorProgrammableKey,
  direction: WorkLouderMergeDirection,
): WorkLouderCreatorProgrammableKey | null {
  const cell = WORKLOUDER_KEY_CELL[origin];
  return direction === 'right'
    ? workLouderKeyAt(cell.row, cell.col + 1)
    : workLouderKeyAt(cell.row + 1, cell.col);
}

export function workLouderMergeDirectionOf(
  merge: WorkLouderKeyMerge,
): WorkLouderMergeDirection | null {
  if (workLouderMergeNeighbor(merge.origin, 'right') === merge.cover) return 'right';
  if (workLouderMergeNeighbor(merge.origin, 'down') === merge.cover) return 'down';
  return null;
}

export function normalizeWorkLouderMerges(raw: unknown): WorkLouderKeyMerge[] {
  if (!Array.isArray(raw)) return [];
  const used = new Set<WorkLouderCreatorProgrammableKey>();
  const merges: WorkLouderKeyMerge[] = [];
  for (const item of raw) {
    if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
    const record = item as { origin?: unknown; cover?: unknown };
    if (!isWorkLouderCreatorProgrammableKey(record.origin)) continue;
    if (!isWorkLouderCreatorProgrammableKey(record.cover)) continue;
    if (!workLouderMergeDirectionOf({ origin: record.origin, cover: record.cover })) continue;
    if (used.has(record.origin) || used.has(record.cover)) continue;
    used.add(record.origin);
    used.add(record.cover);
    merges.push({ origin: record.origin, cover: record.cover });
  }
  return merges;
}

export function workLouderMergesFromMicrophoneFlag(
  separateMicrophoneKeys: boolean,
): WorkLouderKeyMerge[] {
  return separateMicrophoneKeys ? [] : [{ origin: 'ACT10', cover: 'ACT11' }];
}

export function workLouderLayoutMerges(layout: {
  merges?: unknown;
  separateMicrophoneKeys: boolean;
}): WorkLouderKeyMerge[] {
  if (layout.merges !== undefined) return normalizeWorkLouderMerges(layout.merges);
  return workLouderMergesFromMicrophoneFlag(layout.separateMicrophoneKeys);
}

export function workLouderMicrophoneKeysSeparate(
  merges: readonly WorkLouderKeyMerge[],
): boolean {
  return !merges.some((merge) => merge.origin === 'ACT10' && merge.cover === 'ACT11');
}

export function workLouderMergeForKey(
  merges: readonly WorkLouderKeyMerge[],
  key: string,
): WorkLouderKeyMerge | null {
  return merges.find((merge) => merge.origin === key || merge.cover === key) ?? null;
}

export function workLouderAvailableMergeDirections(
  merges: readonly WorkLouderKeyMerge[],
  origin: WorkLouderCreatorProgrammableKey,
): WorkLouderMergeDirection[] {
  const used = new Set(merges.flatMap((merge) => [merge.origin, merge.cover]));
  used.delete(origin);
  const current = workLouderMergeForKey(merges, origin);
  if (current?.origin === origin) used.delete(current.cover);
  const directions: WorkLouderMergeDirection[] = [];
  for (const direction of ['right', 'down'] as const) {
    const cover = workLouderMergeNeighbor(origin, direction);
    if (cover && !used.has(cover)) directions.push(direction);
  }
  return directions;
}

export function addWorkLouderMerge(
  merges: readonly WorkLouderKeyMerge[],
  origin: WorkLouderCreatorProgrammableKey,
  direction: WorkLouderMergeDirection,
): WorkLouderKeyMerge[] {
  const cover = workLouderMergeNeighbor(origin, direction);
  if (!cover) return [...merges];
  return [
    ...merges.filter(
      (merge) =>
        merge.origin !== origin &&
        merge.cover !== origin &&
        merge.origin !== cover &&
        merge.cover !== cover,
    ),
    { origin, cover },
  ];
}

export function removeWorkLouderMerge(
  merges: readonly WorkLouderKeyMerge[],
  key: string,
): WorkLouderKeyMerge[] {
  return merges.filter((merge) => merge.origin !== key && merge.cover !== key);
}

/** Firmware thread id N lights KV_OAI_AG0N. Extra task keys have no AG thread. */
export const WORKLOUDER_HID_AG_CODES = [
  'AG00',
  'AG01',
  'AG02',
  'AG03',
  'AG04',
  'AG05',
  'AG06',
  'AG07',
  'AG08',
  'AG09',
  'AG10',
  'AG11',
  'AG12',
] as const;
export const WORKLOUDER_CREATOR_LIT_TASK_KEY_COUNT = WORKLOUDER_HID_AG_CODES.length;
const WORKLOUDER_HID_ACT_CODES = [
  'ACT06',
  'ACT07',
  'ACT08',
  'ACT09',
  'ACT10',
  'ACT11',
  'ACT12',
] as const;

export const WORKLOUDER_CODEX_ANALOG_DIRECTIONS = ['up', 'right', 'down', 'left'] as const;
export const WORKLOUDER_CODEX_ENCODER_ACTIONS = ['left', 'right', 'click', 'longPress'] as const;
export const WORKLOUDER_CODEX_ENCODER_MODES = [
  'session-switch',
  'composer-navigation',
  'reasoning',
  'conversation-scroll',
  'custom',
] as const;

export const WORKLOUDER_CODEX_COMMAND_IDS = INPUT_DEVICE_COMMAND_IDS;

export const WORKLOUDER_CODEX_KEYCAP_IDS = [
  'FAST',
  'APPR',
  'REJ',
  'SPLIT',
  'MIC',
  'MIC1',
  'CODEX',
  'BUG',
  'OAI',
  'TERM',
  'DWN',
  'DEL',
  'NEW',
  'NAV',
  'MAGIC',
  'DIFF',
  'PLAY',
  'GIT',
  'BRCH',
  'BRANCH',
  'MRG',
  'PR',
  'PAINT',
  'LAB',
  'PARTY',
  'TIME',
  'MIND+',
  'MIND-',
  'EMPT1',
  'EMPT2',
  'EMPT3',
  'EMPT4',
  'EMPT5',
  'SETUP',
  'FOLD',
  'UPL',
  'APPS',
  'YOLO',
  'YEET',
] as const;

export type WorkLouderCodexAutoDim = (typeof WORKLOUDER_CODEX_AUTO_DIM_OPTIONS)[number];
export type WorkLouderCodexAgentSource = (typeof WORKLOUDER_CODEX_AGENT_SOURCES)[number];
export type WorkLouderCodexCommandSlot = (typeof WORKLOUDER_CODEX_COMMAND_SLOTS)[number];
export type WorkLouderCodexPreviewPart =
  | WorkLouderCodexCommandSlot
  | `AG0${0 | 1 | 2 | 3 | 4 | 5}`
  | 'analog'
  | 'encoder';

export interface WorkLouderCodexPreviewInput {
  part: WorkLouderCodexPreviewPart;
  pressed: boolean;
  /** Encoder detents: +1 is firmware ENC_CW, −1 is ENC_CC. Visual rotation flips this. */
  turn?: number;
  /** Stick angle on the hardware circle, 0–1. 0 is right, 0.25 down, 0.5 left, 0.75 up. */
  angle?: number;
  /** Stick deflection, 0–1. */
  distance?: number;
}

/** One detent on the drawn encoder. The hardware reports ticks, not a continuous angle. */
export const WORKLOUDER_CODEX_ENCODER_DETENT_DEG = 18;

/** How far the drawn stick cap travels at full deflection, in pixels. */
export const WORKLOUDER_CODEX_STICK_PREVIEW_TRAVEL_PX = 10;

/**
 * Pixel offset for the settings-page stick cap.
 *
 * The hardware circle is clockwise from the right, which matches screen
 * coordinates: x grows right, y grows down.
 */
export function workLouderCodexStickPreviewOffset(
  angle: number,
  distance: number,
  radius: number = WORKLOUDER_CODEX_STICK_PREVIEW_TRAVEL_PX,
): { x: number; y: number } {
  if (!Number.isFinite(angle) || !Number.isFinite(distance) || !Number.isFinite(radius)) {
    return { x: 0, y: 0 };
  }
  const travel = Math.max(0, Math.min(1, distance));
  const theta = angle * Math.PI * 2;
  return {
    x: snapPreviewPx(Math.cos(theta) * travel * radius),
    y: snapPreviewPx(Math.sin(theta) * travel * radius),
  };
}

function snapPreviewPx(value: number): number {
  return Math.round(value * 100) / 100;
}
export type WorkLouderCodexAnalogDirection = (typeof WORKLOUDER_CODEX_ANALOG_DIRECTIONS)[number];
export type WorkLouderCodexEncoderAction = (typeof WORKLOUDER_CODEX_ENCODER_ACTIONS)[number];
export type WorkLouderCodexEncoderMode = (typeof WORKLOUDER_CODEX_ENCODER_MODES)[number];
export type WorkLouderCodexCommandId = InputDeviceCommandId;
export type WorkLouderCodexKeycapId = (typeof WORKLOUDER_CODEX_KEYCAP_IDS)[number];

export type WorkLouderCodexAction =
  | InputDeviceAction
  | { type: 'keycap'; keycapId: WorkLouderCodexKeycapId }
  /** Push-to-talk. Voice is press/release, so it only works on physical keys. */
  | { type: 'voice' };

export interface WorkLouderCodexKeyAssignment {
  keycapId: WorkLouderCodexKeycapId;
  /** Null means use the physical keycap's built-in Cindy action. */
  action: WorkLouderCodexAction | null;
}

export interface WorkLouderCodexLayout {
  version: 1;
  slots: Record<WorkLouderCodexCommandSlot, WorkLouderCodexKeyAssignment> &
    Partial<Record<WorkLouderCreatorProgrammableKey, WorkLouderCodexKeyAssignment>>;
  analogStick: Record<WorkLouderCodexAnalogDirection, WorkLouderCodexAction | null>;
  encoder: Record<WorkLouderCodexEncoderAction, WorkLouderCodexAction | null>;
  encoderMode: WorkLouderCodexEncoderMode;
  separateMicrophoneKeys: boolean;
  /** 2U caps covering a right or down neighbor. Source of truth; the mic flag is derived. */
  merges?: WorkLouderKeyMerge[];
  /** Which physical 1U keys are task keys, in board order. */
  taskKeys?: WorkLouderCreatorProgrammableKey[];
}

export interface WorkLouderCodexSettings {
  /** When false, this Cindy instance does not occupy the HID device. */
  deviceEnabled: boolean;
  /** Overall lighting intensity, in percent. Zero keeps HID input active with LEDs off. */
  lightingBrightness: number;
  lightingAutoDim: WorkLouderCodexAutoDim;
  agentSource: WorkLouderCodexAgentSource;
  customAgentKeys: Array<WorkLouderCodexAction | null>;
  /** When false, a single press switches tasks and a double press brings Cindy forward. */
  singleTapAgentKeys: boolean;
  layout: WorkLouderCodexLayout;
}

export type WorkLouderCodexSettingsPatch = Partial<WorkLouderCodexSettings>;

export type WorkLouderCodexConnectionStatus =
  | 'connecting'
  | 'connected'
  | 'not-detected'
  | 'disabled'
  | 'error'
  | 'unavailable';

export type WorkLouderCodexConnectionReason =
  | 'connection-timeout'
  | 'connection-failed'
  | 'permission-required'
  | 'device-in-use'
  | 'sdk-unavailable'
  | null;

export interface WorkLouderCodexDeviceState {
  deviceType: 'codex-micro' | 'creator-micro-2' | null;
  isUsbConnection: boolean | null;
  firmwareVersion: string | null;
  batteryPercentage: number | null;
  isCharging: boolean | null;
  inputMonitoringPermission: 'granted' | 'denied' | 'unknown' | 'not-required';
}

export interface WorkLouderCodexTaskOption {
  id: string;
  title: string | null;
  pinned: boolean;
}

export interface WorkLouderCodexAgentSlotState {
  slot: number;
  sessionId: string | null;
  title: string | null;
  action: WorkLouderCodexAction | null;
}

export interface WorkLouderCodexState {
  connectionStatus: WorkLouderCodexConnectionStatus;
  connectionReason: WorkLouderCodexConnectionReason;
  /** USB/Bluetooth presence, independent of whether this Cindy occupies HID. */
  devicePresent: boolean | null;
  device: WorkLouderCodexDeviceState;
  settings: WorkLouderCodexSettings;
  agentSlots: WorkLouderCodexAgentSlotState[];
  taskOptions: WorkLouderCodexTaskOption[];
  agentSlotCount: number;
}

export type WorkLouderAccessoriesState = Record<WorkLouderModel, WorkLouderCodexState>;

export type WorkLouderCodexRendererAction =
  | InputDeviceRendererAction
  | { type: 'keycap'; keycapId: WorkLouderCodexKeycapId };

/** Built-in Cindy behavior printed on each official Work Louder keycap. */
export const WORKLOUDER_CODEX_KEYCAP_ACTIONS: Readonly<
  Partial<Record<WorkLouderCodexKeycapId, WorkLouderCodexAction>>
> = {
  FAST: { type: 'command', commandId: 'composer.toggleFastMode' },
  APPR: { type: 'command', commandId: 'approval.approve' },
  REJ: { type: 'command', commandId: 'approval.decline' },
  SPLIT: { type: 'command', commandId: 'forkTask' },
  CODEX: { type: 'command', commandId: 'composer.submit' },
  BUG: { type: 'command', commandId: 'feedback' },
  OAI: { type: 'external-url', url: 'https://developers.openai.com' },
  TERM: { type: 'command', commandId: 'toggleTerminal' },
  DWN: { type: 'command', commandId: 'copyConversationMarkdown' },
  DEL: { type: 'command', commandId: 'archiveTask' },
  NEW: { type: 'command', commandId: 'newTask' },
  NAV: { type: 'command', commandId: 'openBrowserTab' },
  MAGIC: { type: 'command', commandId: 'toggleTaskPin' },
  DIFF: { type: 'command', commandId: 'toggleReviewTab' },
  PAINT: { type: 'command', commandId: 'composer.addPhotos' },
  LAB: { type: 'command', commandId: 'settings' },
  TIME: { type: 'command', commandId: 'manageTasks' },
  'MIND+': { type: 'command', commandId: 'composer.increaseReasoningEffort' },
  'MIND-': { type: 'command', commandId: 'composer.decreaseReasoningEffort' },
  SETUP: { type: 'command', commandId: 'settings' },
  FOLD: { type: 'command', commandId: 'openFolder' },
  UPL: { type: 'command', commandId: 'composer.addFiles' },
  APPS: { type: 'command', commandId: 'openSkills' },
  YOLO: { type: 'composer-text', text: ':yolo:' },
  YEET: { type: 'composer-text', text: ':yeet:' },
};

export const WORKLOUDER_CODEX_DEFAULT_LAYOUT: WorkLouderCodexLayout = {
  version: 1,
  slots: {
    ACT06: { keycapId: 'FAST', action: null },
    ACT07: { keycapId: 'APPR', action: null },
    ACT08: { keycapId: 'REJ', action: null },
    ACT09: { keycapId: 'SPLIT', action: null },
    ACT10: { keycapId: 'MIC', action: null },
    ACT11: { keycapId: 'EMPT1', action: null },
    ACT10_ACT11: { keycapId: 'MIC', action: null },
    ACT12: { keycapId: 'CODEX', action: null },
  },
  // The stick maps to the two axes of the screen: up/down moves through the
  // conversation, left/right opens and closes the panel on that side.
  analogStick: {
    up: { type: 'command', commandId: 'conversation.scrollUp' },
    right: { type: 'command', commandId: 'toggleRightSidebar' },
    down: { type: 'command', commandId: 'conversation.scrollDown' },
    left: { type: 'command', commandId: 'toggleSidebar' },
  },
  encoder: { left: null, right: null, click: null, longPress: null },
  encoderMode: 'session-switch',
  separateMicrophoneKeys: false,
  merges: [{ origin: 'ACT10', cover: 'ACT11' }],
  taskKeys: [...WORKLOUDER_CREATOR_DEFAULT_TASK_KEYS],
};

export const WORKLOUDER_CODEX_DEFAULT_SETTINGS: WorkLouderCodexSettings = {
  deviceEnabled: false,
  lightingBrightness: 100,
  lightingAutoDim: '3-minutes',
  agentSource: 'last-sent',
  customAgentKeys: Array.from({ length: WORKLOUDER_CODEX_AGENT_SLOT_COUNT }, () => null),
  singleTapAgentKeys: true,
  layout: WORKLOUDER_CODEX_DEFAULT_LAYOUT,
};

/**
 * Creator's factory kit is thirteen blank 1U caps (no 2U MIC). Same PCB as
 * Codex: merge/split is a layout choice. Push-to-talk defaults to ACT10
 * because a blank cap has no printed microphone fallback.
 */
export const WORKLOUDER_CREATOR_MICRO_2_DEFAULT_LAYOUT: WorkLouderCodexLayout = {
  version: 1,
  slots: {
    ACT06: { keycapId: 'EMPT1', action: { type: 'command', commandId: 'composer.toggleFastMode' } },
    ACT07: { keycapId: 'EMPT2', action: { type: 'command', commandId: 'approval.approve' } },
    ACT08: { keycapId: 'EMPT3', action: { type: 'command', commandId: 'approval.decline' } },
    ACT09: { keycapId: 'EMPT4', action: { type: 'command', commandId: 'forkTask' } },
    ACT10: { keycapId: 'EMPT1', action: { type: 'voice' } },
    ACT11: { keycapId: 'EMPT2', action: null },
    ACT10_ACT11: { keycapId: 'EMPT5', action: null },
    ACT12: { keycapId: 'EMPT3', action: { type: 'command', commandId: 'composer.submit' } },
  },
  analogStick: {
    up: { type: 'command', commandId: 'conversation.scrollUp' },
    right: { type: 'command', commandId: 'toggleRightSidebar' },
    down: { type: 'command', commandId: 'conversation.scrollDown' },
    left: { type: 'command', commandId: 'toggleSidebar' },
  },
  encoder: { left: null, right: null, click: null, longPress: null },
  encoderMode: 'session-switch',
  separateMicrophoneKeys: true,
  merges: [],
  taskKeys: [...WORKLOUDER_CREATOR_DEFAULT_TASK_KEYS],
};

export const WORKLOUDER_CREATOR_MICRO_2_DEFAULT_SETTINGS: WorkLouderCodexSettings = {
  deviceEnabled: false,
  lightingBrightness: 100,
  lightingAutoDim: '3-minutes',
  agentSource: 'last-sent',
  customAgentKeys: Array.from({ length: WORKLOUDER_CODEX_AGENT_SLOT_COUNT }, () => null),
  singleTapAgentKeys: true,
  layout: WORKLOUDER_CREATOR_MICRO_2_DEFAULT_LAYOUT,
};

export const WORKLOUDER_CODEX_EMPTY_DEVICE_STATE: WorkLouderCodexDeviceState = {
  deviceType: null,
  isUsbConnection: null,
  firmwareVersion: null,
  batteryPercentage: null,
  isCharging: null,
  inputMonitoringPermission: 'unknown',
};

export function cloneWorkLouderCodexLayout(layout: WorkLouderCodexLayout): WorkLouderCodexLayout {
  const slotKeys = new Set<string>([
    ...WORKLOUDER_CODEX_COMMAND_SLOTS,
    ...WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS.filter((key) => layout.slots[key]),
  ]);
  return {
    ...layout,
    slots: Object.fromEntries(
      [...slotKeys].map((slot) => {
        const assignment = layout.slots[slot as WorkLouderCodexCommandSlot];
        return [
          slot,
          {
            ...assignment,
            action: cloneWorkLouderCodexAction(assignment?.action ?? null),
          },
        ];
      }),
    ) as WorkLouderCodexLayout['slots'],
    taskKeys: layout.taskKeys ? [...layout.taskKeys] : undefined,
    merges: layout.merges ? layout.merges.map((merge) => ({ ...merge })) : undefined,
    analogStick: Object.fromEntries(
      WORKLOUDER_CODEX_ANALOG_DIRECTIONS.map((direction) => [
        direction,
        cloneWorkLouderCodexAction(layout.analogStick[direction]),
      ]),
    ) as WorkLouderCodexLayout['analogStick'],
    encoder: Object.fromEntries(
      WORKLOUDER_CODEX_ENCODER_ACTIONS.map((action) => [
        action,
        cloneWorkLouderCodexAction(layout.encoder[action]),
      ]),
    ) as WorkLouderCodexLayout['encoder'],
  };
}

export function cloneWorkLouderCodexSettings(
  settings: WorkLouderCodexSettings,
): WorkLouderCodexSettings {
  return {
    ...settings,
    customAgentKeys: settings.customAgentKeys.map(cloneWorkLouderCodexAction),
    layout: cloneWorkLouderCodexLayout(settings.layout),
  };
}

export function createWorkLouderCodexDefaultSettings(
  model: WorkLouderModel = 'codex-micro',
): WorkLouderCodexSettings {
  return cloneWorkLouderCodexSettings(
    model === 'creator-micro-2'
      ? WORKLOUDER_CREATOR_MICRO_2_DEFAULT_SETTINGS
      : WORKLOUDER_CODEX_DEFAULT_SETTINGS,
  );
}

export function isWorkLouderCodexAutoDim(value: unknown): value is WorkLouderCodexAutoDim {
  return isStringOption(value, WORKLOUDER_CODEX_AUTO_DIM_OPTIONS);
}

export function isWorkLouderCodexAgentSource(value: unknown): value is WorkLouderCodexAgentSource {
  return isStringOption(value, WORKLOUDER_CODEX_AGENT_SOURCES);
}

/**
 * Saved values from older builds: `recent` was the visible sidebar, `pinned`
 * was a separate pinned-only list. Both now mean sidebar order.
 */
export function normalizeWorkLouderCodexAgentSource(value: unknown): WorkLouderCodexAgentSource {
  if (value === 'recent' || value === 'pinned') return 'sidebar';
  return isWorkLouderCodexAgentSource(value) ? value : WORKLOUDER_CODEX_DEFAULT_SETTINGS.agentSource;
}

export function isWorkLouderCodexCommandId(value: unknown): value is WorkLouderCodexCommandId {
  return isInputDeviceCommandId(value);
}

export function isWorkLouderCodexKeycapId(value: unknown): value is WorkLouderCodexKeycapId {
  return isStringOption(value, WORKLOUDER_CODEX_KEYCAP_IDS);
}

export function isWorkLouderCodexMicrophoneKeycap(
  keycapId: WorkLouderCodexKeycapId | null | undefined,
): boolean {
  return keycapId === 'MIC' || keycapId === 'MIC1';
}

/** Voice is carried either by a printed MIC keycap (Codex) or a bound action. */
export function isWorkLouderCodexVoiceAssignment(
  assignment: Pick<WorkLouderCodexKeyAssignment, 'keycapId' | 'action'> | null | undefined,
): boolean {
  if (!assignment) return false;
  if (assignment.action) return assignment.action.type === 'voice';
  return isWorkLouderCodexMicrophoneKeycap(assignment.keycapId);
}

export function isWorkLouderCodexDoubleKeycap(
  keycapId: WorkLouderCodexKeycapId | null | undefined,
): boolean {
  return keycapId === 'EMPT5';
}

/** Unprinted caps in the hardware catalogue. They carry no legend. */
export function isWorkLouderCodexBlankKeycap(
  keycapId: WorkLouderCodexKeycapId | null | undefined,
): boolean {
  return (
    keycapId === 'EMPT1' ||
    keycapId === 'EMPT2' ||
    keycapId === 'EMPT3' ||
    keycapId === 'EMPT4' ||
    keycapId === 'EMPT5'
  );
}

/** Extra 1U blanks. EMPT1 is the only one the picker needs to show. */
export function isWorkLouderCodexDuplicateBlankKeycap(
  keycapId: WorkLouderCodexKeycapId | null | undefined,
): boolean {
  return keycapId === 'EMPT2' || keycapId === 'EMPT3' || keycapId === 'EMPT4';
}

/** Fold identical catalogue SKUs onto one picker item. */
export function canonicalizeWorkLouderCodexKeycapId(
  keycapId: WorkLouderCodexKeycapId,
): WorkLouderCodexKeycapId {
  if (keycapId === 'MIC1') return 'MIC';
  return isWorkLouderCodexDuplicateBlankKeycap(keycapId) ? 'EMPT1' : keycapId;
}

export function isWorkLouderCreatorProgrammableKey(
  value: unknown,
): value is WorkLouderCreatorProgrammableKey {
  return (
    typeof value === 'string' &&
    (WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS as readonly string[]).includes(value)
  );
}

export function normalizeWorkLouderCreatorTaskKeys(
  raw: unknown,
): WorkLouderCreatorProgrammableKey[] {
  const selected = new Set<WorkLouderCreatorProgrammableKey>();
  if (Array.isArray(raw)) {
    for (const item of raw) {
      if (isWorkLouderCreatorProgrammableKey(item)) selected.add(item);
    }
  } else if (raw == null) {
    for (const key of WORKLOUDER_CREATOR_DEFAULT_TASK_KEYS) selected.add(key);
  }
  return WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS.filter((key) => selected.has(key));
}

/** A 2U cap covers two switches; neither can be a task key. */
export function workLouderTaskKeysForLayout(
  layout: Pick<WorkLouderCodexLayout, 'separateMicrophoneKeys' | 'merges'> & {
    taskKeys?: unknown;
  },
): WorkLouderCreatorProgrammableKey[] {
  const keys = normalizeWorkLouderCreatorTaskKeys(layout.taskKeys);
  const blocked = new Set(
    workLouderLayoutMerges(layout).flatMap((merge) => [merge.origin, merge.cover]),
  );
  return keys.filter((key) => !blocked.has(key));
}

export function creatorTaskKeySet(
  layout: Pick<WorkLouderCodexLayout, 'taskKeys'>,
): Set<WorkLouderCreatorProgrammableKey> {
  return new Set(normalizeWorkLouderCreatorTaskKeys(layout.taskKeys));
}

export function isCreatorTaskKey(
  layout: Pick<WorkLouderCodexLayout, 'taskKeys'>,
  key: string,
): boolean {
  return isWorkLouderCreatorProgrammableKey(key) && creatorTaskKeySet(layout).has(key);
}

export function assignCreatorHidCodes(
  taskKeys: readonly WorkLouderCreatorProgrammableKey[],
): Map<WorkLouderCreatorProgrammableKey, string> {
  const task = normalizeWorkLouderCreatorTaskKeys(taskKeys);
  const taskSet = new Set(task);
  const command = WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS.filter((key) => !taskSet.has(key));
  const assigned = new Map<WorkLouderCreatorProgrammableKey, string>();
  // Firmware only emits AG00–AG05. Extra task keys keep ACT codes; Cindy maps
  // those HID reports onto the remaining task slots in software.
  const firmwareAg = WORKLOUDER_HID_AG_CODES.slice(0, WORKLOUDER_CODEX_AGENT_SLOT_COUNT);
  const litCount = Math.min(task.length, firmwareAg.length);
  for (let index = 0; index < litCount; index += 1) {
    assigned.set(task[index]!, firmwareAg[index]!);
  }
  const leftoverAg = firmwareAg.slice(litCount);
  const restCodes = [...WORKLOUDER_HID_ACT_CODES, ...leftoverAg];
  const rest = [...task.slice(litCount), ...command];
  rest.forEach((key, index) => {
    assigned.set(key, restCodes[index]!);
  });
  return assigned;
}

const WORKLOUDER_FIRMWARE_AGENT_KEYS = WORKLOUDER_HID_AG_CODES.slice(
  0,
  WORKLOUDER_CODEX_AGENT_SLOT_COUNT,
) as WorkLouderCreatorProgrammableKey[];

/**
 * The shared `keys` zone paints every keycap. Mute it unless the six firmware
 * AG keys are exactly the task-key set — otherwise a demoted AG key still
 * washes green, and extra ACT task keys inherit the same wash.
 */
export function workLouderShouldMuteKeyZone(
  taskKeys: readonly WorkLouderCreatorProgrammableKey[] | undefined,
): boolean {
  const keys = normalizeWorkLouderCreatorTaskKeys(taskKeys);
  return (
    keys.length > WORKLOUDER_CODEX_AGENT_SLOT_COUNT ||
    WORKLOUDER_FIRMWARE_AGENT_KEYS.some((key) => !keys.includes(key))
  );
}

export function buildCreatorMicro2AgentKeymap(
  taskKeys: readonly WorkLouderCreatorProgrammableKey[] = WORKLOUDER_CREATOR_DEFAULT_TASK_KEYS,
): string[][] {
  const hid = assignCreatorHidCodes(normalizeWorkLouderCreatorTaskKeys(taskKeys));
  return WORKLOUDER_CREATOR_KEYMAP_LAYOUT.map((row) =>
    row.map((physical) => `KV_OAI_${hid.get(physical)}`),
  );
}

export type CreatorHidRole =
  | { role: 'task'; slot: number; physical: WorkLouderCreatorProgrammableKey }
  | { role: 'command'; physical: WorkLouderCreatorProgrammableKey };

export function resolveCreatorHidRole(
  hidKey: string,
  taskKeys: readonly WorkLouderCreatorProgrammableKey[],
): CreatorHidRole | null {
  const normalized = normalizeWorkLouderCreatorTaskKeys(taskKeys);
  const assigned = assignCreatorHidCodes(normalized);
  for (const physical of WORKLOUDER_CREATOR_PROGRAMMABLE_KEYS) {
    if (assigned.get(physical) !== hidKey) continue;
    const slot = normalized.indexOf(physical);
    if (slot >= 0) return { role: 'task', slot, physical };
    return { role: 'command', physical };
  }
  // Older keymaps wrote AG06–AG12 onto extra keys. Firmware may still emit those.
  const leftoverAg = /^AG(0[0-9]|1[0-2])$/.exec(hidKey);
  if (leftoverAg) {
    const slot = Number(leftoverAg[1]);
    const physical = normalized[slot];
    if (physical) return { role: 'task', slot, physical };
  }
  return null;
}

/** Codex keeps factory AG/ACT codes. HID key name is the physical key. */
export function resolveFactoryHidRole(
  hidKey: string,
  taskKeys: readonly WorkLouderCreatorProgrammableKey[],
): CreatorHidRole | null {
  if (!isWorkLouderCreatorProgrammableKey(hidKey)) return null;
  const normalized = normalizeWorkLouderCreatorTaskKeys(taskKeys);
  const slot = normalized.indexOf(hidKey);
  if (slot >= 0) return { role: 'task', slot, physical: hidKey };
  return { role: 'command', physical: hidKey };
}

export function resolveWorkLouderHidRole(
  hidKey: string,
  taskKeys: readonly WorkLouderCreatorProgrammableKey[],
  deviceType?: string | null,
): CreatorHidRole | null {
  if (deviceType === 'codex-micro') return resolveFactoryHidRole(hidKey, taskKeys);
  return resolveCreatorHidRole(hidKey, taskKeys);
}

const DEFAULT_CREATOR_COMMAND_ASSIGNMENT: WorkLouderCodexKeyAssignment = {
  keycapId: 'EMPT1',
  action: null,
};

export function creatorCommandAssignment(
  layout: WorkLouderCodexLayout,
  key: WorkLouderCreatorProgrammableKey,
): WorkLouderCodexKeyAssignment {
  return layout.slots[key] ?? DEFAULT_CREATOR_COMMAND_ASSIGNMENT;
}

export function isWorkLouderCodexEncoderMode(value: unknown): value is WorkLouderCodexEncoderMode {
  return isStringOption(value, WORKLOUDER_CODEX_ENCODER_MODES);
}

export function workLouderCodexAutoDimMs(value: WorkLouderCodexAutoDim): number | null {
  switch (value) {
    case 'off':
      return null;
    case '30-seconds':
      return 30_000;
    case '1-minute':
      return 60_000;
    case '3-minutes':
      return 180_000;
    case '10-minutes':
      return 600_000;
    case '30-minutes':
      return 1_800_000;
    case '1-hour':
      return 3_600_000;
  }
}

function isStringOption<T extends string>(value: unknown, options: readonly T[]): value is T {
  return typeof value === 'string' && (options as readonly string[]).includes(value);
}

function cloneWorkLouderCodexAction(
  action: WorkLouderCodexAction | null,
): WorkLouderCodexAction | null {
  return action ? { ...action } : null;
}