tmux-ide 2.1.5 → 2.6.1

package/packages/daemon/src/lib/app-config.ts

@@ -0,0 +1,336 @@
+/**
+ * The one global config — `~/.tmux-ide/config.json` (overridable via
+ * `TMUX_IDE_CONFIG`).
+ *
+ * Everything that used to be hardcoded chrome behaviour lives here: the
+ * root-table key binds (`M-p`/`M-k`/`M-m`), the shared THEME TOKENS consumed by
+ * BOTH the tmux chrome (status bar / pane chips / actions menu / cheat sheet)
+ * AND the OpenTUI widgets, the updater cadence, and the notification/restore/
+ * update-check toggles. One palette, one keymap, one file — the foundation for
+ * the "one cohesive app" milestone.
+ *
+ * The tokens are SEMANTIC (accent/muted/fg + per-status colors + glyphs), not
+ * per-surface: a single `theme` block drives every surface, so re-theming the
+ * whole product is a one-file edit + a re-adopt (no code change).
+ *
+ * {@link parseAppConfig} is PURE — a deep partial merge over the defaults where
+ * any missing or mistyped field falls back to its default and it never throws.
+ * {@link loadAppConfig} is the thin io wrapper (missing/malformed file →
+ * defaults); {@link getAppConfig} caches that read for the process. The old
+ * per-concern readers ({@link ../tui/chrome/notify.ts}, {@link ../restore.ts})
+ * now delegate here.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentStatus } from "../tui/detect/classify.ts";
+
+// ---------------------------------------------------------------------------
+// Shape
+// ---------------------------------------------------------------------------
+
+/**
+ * Root-table key binds (tmux key names) for the per-widget PANEL popups —
+ * every widget is a floating app dialog one keystroke away, esc to close (the
+ * "one-app" milestone). Only widgets that exist AND stand alone are here:
+ * `preview` is a companion that renders the explorer's selection (nothing to
+ * show on its own) and `setup` is the onboarding wizard, so neither gets a key.
+ */
+export interface AppPanelKeys {
+  /** File explorer panel (default `M-e`). */
+  explorer: string;
+  /** Git changes panel (default `M-g`). */
+  changes: string;
+  /** Config editor panel (default `M-,`). */
+  config: string;
+}
+
+/** Root-table key binds (tmux key names) for the chrome popups + widget panels. */
+export interface AppKeys {
+  /** Switcher popup (default `M-p`). */
+  popup: string;
+  /** Home cockpit popup — the full fleet home from any session (default `M-h`). */
+  home: string;
+  /** Cheat-sheet popup (default `M-k`). */
+  cheatsheet: string;
+  /** Actions menu (default `M-m`). */
+  menu: string;
+  /** Sidebar (app nav column) toggle (default `M-b`). */
+  sidebar: string;
+  /** Per-widget panel popups (default `M-e`/`M-g`/`M-,`). */
+  panels: AppPanelKeys;
+}
+
+/** Per-agent-status color token (tmux `colourN` / `#rrggbb`). */
+export type AppThemeStatus = Record<AgentStatus, string>;
+
+/** The two state glyphs — filled (active/present) and hollow (inactive/quiet). */
+export interface AppThemeGlyphs {
+  active: string;
+  inactive: string;
+}
+
+/**
+ * The shared palette — semantic tokens, not per-surface styles. Chrome builders
+ * and widgets both map these into their own render layer, so the whole product
+ * reads as one system.
+ */
+export interface AppTheme {
+  /** Primary/brand accent (default `colour75`). */
+  accent: string;
+  /** Muted/secondary foreground for dim text (default `colour240`). */
+  muted: string;
+  /** Default foreground (default `colour250`). */
+  fg: string;
+  /** Per-status colors (blocked/working/done/idle/unknown). */
+  status: AppThemeStatus;
+  /** The filled/hollow state glyphs. */
+  glyphs: AppThemeGlyphs;
+}
+
+/** Chrome updater cadence. */
+export interface AppUpdater {
+  /** Milliseconds between ticks (default 2000). */
+  tickMs: number;
+  /** Write a disaster-recovery snapshot every N ticks (default 15). */
+  snapshotEvery: number;
+}
+
+/** Notification channel toggles. */
+export interface AppNotifications {
+  toast: boolean;
+  macos: boolean;
+}
+
+/** Restore behaviour toggles. */
+export interface AppRestore {
+  resumeAgents: boolean;
+}
+
+/** Update-check toggles (consumed later by the update-flow card). */
+export interface AppUpdates {
+  check: boolean;
+}
+
+/** First-run welcome toggles. */
+export interface AppWelcome {
+  /**
+   * Whether the first-run welcome card may show (default true). Set false to
+   * suppress it independently of the `~/.tmux-ide/welcomed` marker file (which
+   * records that it has already been shown once).
+   */
+  show: boolean;
+}
+
+/** Agent-integration auto-discovery config. */
+export interface AppIntegrations {
+  /**
+   * Whether the first-adopt integration OFFER may show (default true). Set false
+   * to suppress the one-time "claude detected — install the integration?" popup
+   * independently of the `<home>/integration-offered` marker (which records that
+   * it has already been shown once).
+   */
+  offer: boolean;
+}
+
+/** Worktree flow config (`tmux-ide worktree`). */
+export interface AppWorktrees {
+  /**
+   * Base directory for worktree checkouts. Empty (default) → a sibling
+   * `<repo>-worktrees` dir next to each repo. A non-empty value overrides that
+   * base; a relative path is resolved against the repo.
+   */
+  dir: string;
+}
+
+/** The whole config. */
+export interface AppConfig {
+  keys: AppKeys;
+  theme: AppTheme;
+  updater: AppUpdater;
+  notifications: AppNotifications;
+  restore: AppRestore;
+  updates: AppUpdates;
+  welcome: AppWelcome;
+  integrations: AppIntegrations;
+  worktrees: AppWorktrees;
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+/** The built-in config — every field's fallback. */
+export const DEFAULT_APP_CONFIG: AppConfig = {
+  keys: {
+    popup: "M-p",
+    home: "M-h",
+    cheatsheet: "M-k",
+    menu: "M-m",
+    sidebar: "M-b",
+    panels: { explorer: "M-e", changes: "M-g", config: "M-," },
+  },
+  theme: {
+    accent: "colour75",
+    muted: "colour240",
+    fg: "colour250",
+    status: {
+      blocked: "colour203",
+      working: "colour221",
+      done: "colour111",
+      idle: "colour114",
+      unknown: "colour244",
+    },
+    glyphs: { active: "●", inactive: "○" },
+  },
+  updater: { tickMs: 2000, snapshotEvery: 15 },
+  notifications: { toast: true, macos: false },
+  restore: { resumeAgents: false },
+  updates: { check: true },
+  welcome: { show: true },
+  integrations: { offer: true },
+  worktrees: { dir: "" },
+};
+
+/** The default theme tokens — the fallback threaded into the pure builders. */
+export const DEFAULT_THEME: AppTheme = DEFAULT_APP_CONFIG.theme;
+
+/** The default key binds — the fallback for the bind command builders. */
+export const DEFAULT_KEYS: AppKeys = DEFAULT_APP_CONFIG.keys;
+
+// ---------------------------------------------------------------------------
+// Pure parse (deep partial merge over defaults)
+// ---------------------------------------------------------------------------
+
+/** A plain object, or `{}` for anything that isn't one (arrays included). */
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+/** A non-empty string, else the default. */
+function pickString(value: unknown, fallback: string): string {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+
+/** A boolean, else the default. */
+function pickBool(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+/** A positive integer, else the default. */
+function pickPosInt(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+/**
+ * PURE — merge an unknown (typically parsed JSON) over {@link DEFAULT_APP_CONFIG}.
+ * Every block/leaf is validated independently: a missing or mistyped field falls
+ * back to its default, so partial and garbage configs both resolve to a complete,
+ * well-typed {@link AppConfig}. Never throws.
+ */
+export function parseAppConfig(input: unknown): AppConfig {
+  const D = DEFAULT_APP_CONFIG;
+  const root = asObject(input);
+  const keys = asObject(root.keys);
+  const panels = asObject(keys.panels);
+  const theme = asObject(root.theme);
+  const status = asObject(theme.status);
+  const glyphs = asObject(theme.glyphs);
+  const updater = asObject(root.updater);
+  const notifications = asObject(root.notifications);
+  const restore = asObject(root.restore);
+  const updates = asObject(root.updates);
+  const welcome = asObject(root.welcome);
+  const integrations = asObject(root.integrations);
+  const worktrees = asObject(root.worktrees);
+  return {
+    keys: {
+      popup: pickString(keys.popup, D.keys.popup),
+      home: pickString(keys.home, D.keys.home),
+      cheatsheet: pickString(keys.cheatsheet, D.keys.cheatsheet),
+      menu: pickString(keys.menu, D.keys.menu),
+      sidebar: pickString(keys.sidebar, D.keys.sidebar),
+      panels: {
+        explorer: pickString(panels.explorer, D.keys.panels.explorer),
+        changes: pickString(panels.changes, D.keys.panels.changes),
+        config: pickString(panels.config, D.keys.panels.config),
+      },
+    },
+    theme: {
+      accent: pickString(theme.accent, D.theme.accent),
+      muted: pickString(theme.muted, D.theme.muted),
+      fg: pickString(theme.fg, D.theme.fg),
+      status: {
+        blocked: pickString(status.blocked, D.theme.status.blocked),
+        working: pickString(status.working, D.theme.status.working),
+        done: pickString(status.done, D.theme.status.done),
+        idle: pickString(status.idle, D.theme.status.idle),
+        unknown: pickString(status.unknown, D.theme.status.unknown),
+      },
+      glyphs: {
+        active: pickString(glyphs.active, D.theme.glyphs.active),
+        inactive: pickString(glyphs.inactive, D.theme.glyphs.inactive),
+      },
+    },
+    updater: {
+      tickMs: pickPosInt(updater.tickMs, D.updater.tickMs),
+      snapshotEvery: pickPosInt(updater.snapshotEvery, D.updater.snapshotEvery),
+    },
+    notifications: {
+      toast: pickBool(notifications.toast, D.notifications.toast),
+      macos: pickBool(notifications.macos, D.notifications.macos),
+    },
+    restore: { resumeAgents: pickBool(restore.resumeAgents, D.restore.resumeAgents) },
+    updates: { check: pickBool(updates.check, D.updates.check) },
+    welcome: { show: pickBool(welcome.show, D.welcome.show) },
+    integrations: { offer: pickBool(integrations.offer, D.integrations.offer) },
+    worktrees: { dir: pickString(worktrees.dir, D.worktrees.dir) },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// io
+// ---------------------------------------------------------------------------
+
+/**
+ * Absolute path to the config file: `TMUX_IDE_CONFIG` when set (tests / per-run
+ * overrides), else `~/.tmux-ide/config.json`.
+ */
+export function appConfigPath(): string {
+  return process.env.TMUX_IDE_CONFIG ?? join(homedir(), ".tmux-ide", "config.json");
+}
+
+/**
+ * io — read + parse the config. A missing or malformed file resolves to the full
+ * defaults ({@link parseAppConfig} never throws). Reads fresh each call; use
+ * {@link getAppConfig} for the cached per-process read.
+ */
+export function loadAppConfig(): AppConfig {
+  const path = appConfigPath();
+  if (!existsSync(path)) return parseAppConfig(undefined);
+  try {
+    return parseAppConfig(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    // malformed file — full defaults
+    return parseAppConfig(undefined);
+  }
+}
+
+let cached: AppConfig | null = null;
+
+/**
+ * The process-cached config. Resolved once on first use — config changes take
+ * effect on the next process (e.g. a re-adopt spawns fresh CLI invocations), so
+ * caching is safe and keeps the hot updater tick from re-reading the file.
+ */
+export function getAppConfig(): AppConfig {
+  if (!cached) cached = loadAppConfig();
+  return cached;
+}
+
+/** Drop the cache so the next {@link getAppConfig} re-reads. Test-only. */
+export function _resetForTests(): void {
+  cached = null;
+}

package/packages/daemon/src/lib/app-settings.ts

@@ -0,0 +1,53 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+export interface AppSettings {
+  remoteAccess: {
+    enabled: boolean;
+    token: string | null;
+  };
+}
+
+const DEFAULT_SETTINGS: AppSettings = {
+  remoteAccess: {
+    enabled: false,
+    token: null,
+  },
+};
+
+function settingsDir(): string {
+  return process.env.TMUX_IDE_SETTINGS_DIR ?? join(homedir(), ".tmux-ide");
+}
+
+export function appSettingsPath(): string {
+  return join(settingsDir(), "app-settings.json");
+}
+
+function normalizeSettings(value: unknown): AppSettings {
+  if (!value || typeof value !== "object") return structuredClone(DEFAULT_SETTINGS);
+  const remote = (value as { remoteAccess?: unknown }).remoteAccess;
+  if (!remote || typeof remote !== "object") return structuredClone(DEFAULT_SETTINGS);
+  const enabled = (remote as { enabled?: unknown }).enabled === true;
+  const rawToken = (remote as { token?: unknown }).token;
+  const token = typeof rawToken === "string" && rawToken.length > 0 ? rawToken : null;
+  return { remoteAccess: { enabled, token } };
+}
+
+export function readAppSettings(): AppSettings {
+  const path = appSettingsPath();
+  if (!existsSync(path)) return structuredClone(DEFAULT_SETTINGS);
+  try {
+    return normalizeSettings(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return structuredClone(DEFAULT_SETTINGS);
+  }
+}
+
+export function writeAppSettings(next: AppSettings): void {
+  const path = appSettingsPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(normalizeSettings(next), null, 2)}\n`, "utf-8");
+  renameSync(tmp, path);
+}

package/packages/daemon/src/lib/auth/types.ts

@@ -0,0 +1,2 @@
+// Schema extracted to @tmux-ide/contracts (T056). Re-export shim.
+export { AuthConfigSchema, type AuthConfig } from "@tmux-ide/contracts";

package/packages/daemon/src/lib/auth-token.ts

@@ -0,0 +1,5 @@
+import { randomBytes } from "node:crypto";
+
+export function generateAuthToken(): string {
+  return randomBytes(32).toString("base64url");
+}

package/packages/daemon/src/lib/canonical-daemon.ts

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export interface CanonicalDaemonInfo {
+  readonly pid: number;
+  readonly port: number;
+  readonly version: string;
+  readonly startedAt: string;
+  readonly bindHostname: string;
+  readonly authToken: string | null;
+}
+
+const DAEMON_INFO_DIR_ENV = "TMUX_IDE_DAEMON_INFO_DIR";
+const REGISTRY_DIR_ENV = "TMUX_IDE_REGISTRY_DIR";
+const DAEMON_INFO_FILE = "daemon.json";
+
+export function getCanonicalDaemonInfoPath(): string {
+  const dir =
+    process.env[DAEMON_INFO_DIR_ENV] ??
+    process.env[REGISTRY_DIR_ENV] ??
+    join(homedir(), ".tmux-ide");
+  return join(dir, DAEMON_INFO_FILE);
+}
+
+function parseCanonicalDaemonInfo(raw: unknown): CanonicalDaemonInfo | null {
+  if (!raw || typeof raw !== "object") return null;
+  const info = raw as Partial<CanonicalDaemonInfo>;
+  const pid = info.pid;
+  const port = info.port;
+  if (typeof pid !== "number" || typeof port !== "number") return null;
+  if (!Number.isInteger(pid) || !Number.isInteger(port)) return null;
+  if (typeof info.version !== "string" || typeof info.startedAt !== "string") return null;
+  if (typeof info.bindHostname !== "string") return null;
+  if (info.authToken !== null && typeof info.authToken !== "string") return null;
+  return {
+    pid,
+    port,
+    version: info.version,
+    startedAt: info.startedAt,
+    bindHostname: info.bindHostname,
+    authToken: info.authToken,
+  };
+}
+
+export function writeCanonicalDaemonInfo(info: CanonicalDaemonInfo): void {
+  const path = getCanonicalDaemonInfoPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const persisted: CanonicalDaemonInfo = {
+    pid: info.pid,
+    port: info.port,
+    version: info.version,
+    startedAt: info.startedAt,
+    bindHostname: info.bindHostname,
+    authToken: info.authToken,
+  };
+  writeFileSync(tmpPath, JSON.stringify(persisted, null, 2) + "\n", "utf-8");
+  renameSync(tmpPath, path);
+}
+
+export function readCanonicalDaemonInfo(): CanonicalDaemonInfo | null {
+  const path = getCanonicalDaemonInfoPath();
+  if (!existsSync(path)) return null;
+  try {
+    return parseCanonicalDaemonInfo(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return null;
+  }
+}
+
+export function clearCanonicalDaemonInfo(): void {
+  rmSync(getCanonicalDaemonInfoPath(), { force: true });
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function probeHostname(bindHostname: string): string {
+  return bindHostname === "0.0.0.0" ? "127.0.0.1" : bindHostname;
+}
+
+function timeoutSignal(ms: number): AbortSignal {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), ms).unref?.();
+  return controller.signal;
+}
+
+/**
+ * Version-skew guard. A client (desktop app, editor extension, second
+ * CLI) attaching to the canonical daemon compiles in the daemon
+ * version it expects. If the live daemon advertises a different
+ * `version`, the wire contract may have drifted — warn loudly rather
+ * than failing silently on a mismatched action/WS schema.
+ */
+export function warnOnDaemonVersionSkew(info: CanonicalDaemonInfo, expectedVersion: string): void {
+  if (info.version === expectedVersion) return;
+  console.warn(
+    `[tmux-ide] canonical daemon version skew: daemon.json reports ` +
+      `"${info.version}" but this client expects "${expectedVersion}". ` +
+      `The action/WS contract may have drifted — restart the canonical ` +
+      `daemon (tmux-ide) so it matches this client build.`,
+  );
+}
+
+export async function isCanonicalDaemonAlive(info: CanonicalDaemonInfo): Promise<boolean> {
+  if (!isPidAlive(info.pid)) return false;
+  try {
+    const res = await fetch(`http://${probeHostname(info.bindHostname)}:${info.port}/health`, {
+      signal: timeoutSignal(750),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}