tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/tui/team/sessions.ts

@@ -15,6 +15,7 @@ import {
   classifyInstant,
   parseAuthority,
   parseAuthorityEpoch,
+  sanitizeAgentText,
   type AgentStatus,
   type StatusTracker,
 } from "../detect/classify.ts";
@@ -78,6 +79,19 @@ export interface PaneAgentEntry {
   command: string;
   /** `pane_current_path` — the pane's working directory. */
   dir: string;
+  /**
+   * Self-reported one-liner (`@agent_status_text`, sanitized + clamped to 32
+   * chars) — what the agent says it is doing ("refactoring auth"). ADDITIVE and
+   * present only while the pane's `@agent_state` stamp is FRESH (the metadata
+   * follows the same authority-staleness rules; stale/absent authority drops it).
+   */
+  statusText?: string;
+  /**
+   * Self-reported display name (`@agent_display_name`, sanitized) — label
+   * precedence over `kind` in the sidebar/chips. Same freshness gate as
+   * {@link statusText}. ADDITIVE.
+   */
+  displayName?: string;
 }
 
 /**
@@ -93,6 +107,9 @@ export function buildAgentEntry(input: {
   manifest: AgentManifest | undefined;
   state: AgentStatus;
   since: number | null;
+  /** Already-sanitized display metadata (undefined when absent/stale). */
+  statusText?: string;
+  displayName?: string;
 }): PaneAgentEntry | null {
   const { manifest, pane } = input;
   if (!manifest || manifest.id === "shell") return null;
@@ -107,6 +124,29 @@ export function buildAgentEntry(input: {
     title: pane.title,
     command: pane.cmd,
     dir: pane.dir,
+    ...(input.statusText !== undefined ? { statusText: input.statusText } : {}),
+    ...(input.displayName !== undefined ? { displayName: input.displayName } : {}),
+  };
+}
+
+/**
+ * PURE — the display metadata a pane's agent entry surfaces: the sanitized
+ * `@agent_status_text` / `@agent_display_name` options, gated on the SAME
+ * authority-freshness verdict as the state itself. `authorityFresh` is
+ * `parseAuthority(...) !== null` — when the pane's `@agent_state` stamp is
+ * absent or stale (a dead hook mid-turn), the metadata is dropped with it
+ * rather than lying alongside a scraped state.
+ */
+export function agentMetadataFor(
+  pane: Pick<PaneRecord, "statusTextRaw" | "displayNameRaw">,
+  authorityFresh: boolean,
+): { statusText?: string; displayName?: string } {
+  if (!authorityFresh) return {};
+  const statusText = sanitizeAgentText(pane.statusTextRaw);
+  const displayName = sanitizeAgentText(pane.displayNameRaw);
+  return {
+    ...(statusText !== undefined ? { statusText } : {}),
+    ...(displayName !== undefined ? { displayName } : {}),
   };
 }
 
@@ -138,6 +178,15 @@ export interface PaneDetail {
   paneId: string;
   agent: string | null;
   status: AgentStatus;
+  /** `window_index` of the pane's window — the notification path suppresses
+   *  toasts window-granularly, so the transition must know its window. */
+  windowIndex: number;
+  /** `pane_pid` — root of the pane's process tree (session-id capture probes from it). */
+  pid: number;
+  /** `pane_current_path` — the pane's working directory. */
+  dir: string;
+  /** Existing `@agent_session_id` stamp, or null (capture only fills empty ones). */
+  sessionId: string | null;
 }
 
 interface PaneRecord {
@@ -155,6 +204,12 @@ interface PaneRecord {
   authority: string;
   /** Raw `@agent_hint` pane option — forces a manifest when set. */
   hint: string;
+  /** Raw `@agent_session_id` pane option — the agent's own session id, if recorded. */
+  sessionId: string;
+  /** Raw `@agent_status_text` pane option — sanitized by {@link agentMetadataFor}. */
+  statusTextRaw: string;
+  /** Raw `@agent_display_name` pane option — sanitized by {@link agentMetadataFor}. */
+  displayNameRaw: string;
   /** `window_index` — the window (tab) this pane lives in. */
   windowIndex: number;
   /** `window_name`. */
@@ -182,12 +237,13 @@ export function excludeSidebarPanes<T extends { sidebar: boolean }>(panes: T[]):
 const SEVERITY: AgentStatus[] = ["blocked", "working", "done", "idle", "unknown"];
 
 /**
- * Whether a session should appear in the switcher. Any `_`-prefixed session is
- * internal plumbing (the `_tmux-ide-chrome` updater, scratch sessions, …) and
- * is filtered out so the cockpit never lists — or navigates into — infrastructure.
+ * Whether a session should appear in the switcher. `_`-prefixed sessions are
+ * internal plumbing (the `_tmux-ide-chrome` updater, the `_tmux-ide-app` host)
+ * and `zz-`-prefixed sessions are development scratch sessions — both are
+ * filtered out so the cockpit never lists — or navigates into — infrastructure.
  */
 export function isListableSession(name: string): boolean {
-  return !name.startsWith("_");
+  return !name.startsWith("_") && !name.startsWith("zz-");
 }
 
 function tmux(args: string[]): string {
@@ -300,10 +356,23 @@ export function listTeamSessions(
           paneId: pane.id,
           agent: manifest && manifest.id !== "shell" ? manifest.id : null,
           status,
+          windowIndex: pane.windowIndex,
+          pid: pane.pid,
+          dir: pane.dir,
+          sessionId: pane.sessionId.length > 0 ? pane.sessionId : null,
         });
         // Surface per-pane agent detail (same resolved manifest/status — nothing
-        // re-derived). Non-agent panes yield null and are skipped.
-        const entry = buildAgentEntry({ sessionName: name, pane, manifest, state: status, since });
+        // re-derived). Non-agent panes yield null and are skipped. Display
+        // metadata (@agent_status_text/@agent_display_name) is gated on the SAME
+        // freshness verdict as the authority state — stale/absent stamp drops it.
+        const entry = buildAgentEntry({
+          sessionName: name,
+          pane,
+          manifest,
+          state: status,
+          since,
+          ...agentMetadataFor(pane, authority !== null),
+        });
         if (entry) agents.push(entry);
         return status;
       });
@@ -332,7 +401,10 @@ function collectPanes(): Map<string, PaneRecord[]> {
     // title stays the trailing catch-all — window names/paths don't contain tabs
     // in practice. pane_current_path rides this SAME list-panes call (no extra
     // tmux round-trip) so per-pane agent entries can carry a working dir.
-    `#{session_name}\t#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{@agent_state}\t#{@agent_hint}\t#{${SIDEBAR_PANE_OPTION}}\t#{window_index}\t#{window_name}\t#{window_active}\t#{pane_current_path}\t#{pane_title}`,
+    // @agent_status_text/@agent_display_name ride the same caveat: the contract
+    // (skill/SKILL.md) says plain text; a stamped tab would shift this one
+    // pane's fields (sanitizeAgentText strips control chars AFTER the split).
+    `#{session_name}\t#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{@agent_state}\t#{@agent_hint}\t#{@agent_session_id}\t#{@agent_status_text}\t#{@agent_display_name}\t#{${SIDEBAR_PANE_OPTION}}\t#{window_index}\t#{window_name}\t#{window_active}\t#{pane_current_path}\t#{pane_title}`,
   ]);
   const bySession = new Map<string, PaneRecord[]>();
   for (const line of raw.split("\n").filter(Boolean)) {
@@ -343,6 +415,9 @@ function collectPanes(): Map<string, PaneRecord[]> {
       cmd = "",
       authority = "",
       hint = "",
+      sessionId = "",
+      statusTextRaw = "",
+      displayNameRaw = "",
       sidebar = "",
       windowIndex = "0",
       windowName = "",
@@ -358,6 +433,9 @@ function collectPanes(): Map<string, PaneRecord[]> {
       cmd,
       authority,
       hint,
+      sessionId,
+      statusTextRaw,
+      displayNameRaw,
       sidebar: sidebar === "1",
       windowIndex: Number(windowIndex) || 0,
       windowName,

package/packages/daemon/src/tui/team/wait.ts

@@ -0,0 +1,144 @@
+/**
+ * The `wait` conditions — the SHARED implementation behind `tmux-ide wait
+ * agent-status` / `tmux-ide wait output` (bin/cli.ts) and the control
+ * socket's `wait` verb (src/control/). Extracted from the CLI case so the
+ * socket is a transport over the same logic, not a second implementation.
+ *
+ * Both loops are deps-injected (fleet lister / pane capture, clock, sleep)
+ * so the polling logic unit-tests without tmux; the exported defaults wire
+ * the real io.
+ */
+import { capturePane } from "@tmux-ide/tmux-bridge";
+import type { AgentStatus, StatusTracker } from "../detect/classify.ts";
+import { createStatusTracker } from "../detect/classify.ts";
+import { findSessionStatus } from "./report.ts";
+import { listTeamSessions, type TeamSession } from "./sessions.ts";
+
+/** Default overall timeout (matches the CLI's historical default). */
+export const WAIT_DEFAULT_TIMEOUT_MS = 60_000;
+/** Poll cadence for the agent-status wait. */
+export const WAIT_STATUS_POLL_MS = 750;
+/** Poll cadence for the output-match wait. */
+export const WAIT_OUTPUT_POLL_MS = 500;
+
+const sleepMs = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
+
+/**
+ * PURE — test `text` (a pane capture) against `pattern`, line by line, and
+ * report the first matching LINE; falls back to whole-text matching (with the
+ * last line reported) so multi-line patterns still hit. A fresh RegExp per
+ * test so a user-supplied /g flag can't carry `lastIndex` between calls.
+ * Returns null when nothing matches.
+ */
+export function matchOutput(text: string, pattern: string): string | null {
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (new RegExp(pattern).test(line)) return line;
+  }
+  if (new RegExp(pattern).test(text)) return lines[lines.length - 1] ?? "";
+  return null;
+}
+
+export interface WaitAgentStatusResult {
+  ok: boolean;
+  session: string;
+  want: AgentStatus;
+  /** The session's last observed status (null = session absent). */
+  status: AgentStatus | null;
+  /** Set when `ok` is false: how long we waited. */
+  timedOutAfterMs?: number;
+}
+
+export interface WaitAgentStatusOpts {
+  timeoutMs?: number;
+  pollMs?: number;
+  /**
+   * The tracker threaded across polls (one PERSISTS per wait so the
+   * cross-tick working→idle `done` transition can be observed). Injected by
+   * tests; defaults to a fresh tracker.
+   */
+  tracker?: StatusTracker;
+  listSessions?: (tracker: StatusTracker) => TeamSession[];
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+/** Block until `session` reaches `want`, or time out. Never throws. */
+export async function waitForAgentStatus(
+  session: string,
+  want: AgentStatus,
+  opts: WaitAgentStatusOpts = {},
+): Promise<WaitAgentStatusResult> {
+  const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+  const pollMs = opts.pollMs ?? WAIT_STATUS_POLL_MS;
+  const tracker = opts.tracker ?? createStatusTracker();
+  const list = opts.listSessions ?? listTeamSessions;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? sleepMs;
+  const started = now();
+
+  for (;;) {
+    const status = findSessionStatus(list(tracker), session);
+    if (status === want) return { ok: true, session, want, status };
+    if (now() - started >= timeoutMs) {
+      return { ok: false, session, want, status, timedOutAfterMs: timeoutMs };
+    }
+    await sleep(pollMs);
+  }
+}
+
+export interface WaitOutputResult {
+  ok: boolean;
+  target: string;
+  pattern: string;
+  /** The matching line when `ok`; null on timeout. */
+  matched: string | null;
+  timedOutAfterMs?: number;
+}
+
+export interface WaitOutputOpts {
+  timeoutMs?: number;
+  pollMs?: number;
+  /** Pane capture (defaults to tmux-bridge's `capturePane`, 200 lines). */
+  capture?: (target: string) => string;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+/**
+ * Block until `target`'s captured output matches `pattern`, or time out.
+ * A capture failure (pane/session not (yet) available) keeps polling until
+ * the timeout. Throws only on an invalid regex — validate before looping.
+ */
+export async function waitForOutputMatch(
+  target: string,
+  pattern: string,
+  opts: WaitOutputOpts = {},
+): Promise<WaitOutputResult> {
+  new RegExp(pattern); // an invalid pattern is a usage error, surfaced up front
+  const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+  const pollMs = opts.pollMs ?? WAIT_OUTPUT_POLL_MS;
+  const capture = opts.capture ?? defaultCapture;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? sleepMs;
+  const started = now();
+
+  for (;;) {
+    let text = "";
+    try {
+      text = capture(target);
+    } catch {
+      // not capturable yet — keep polling
+    }
+    const matched = matchOutput(text, pattern);
+    if (matched !== null) return { ok: true, target, pattern, matched };
+    if (now() - started >= timeoutMs) {
+      return { ok: false, target, pattern, matched: null, timedOutAfterMs: timeoutMs };
+    }
+    await sleep(pollMs);
+  }
+}
+
+function defaultCapture(target: string): string {
+  return capturePane(target, { lines: 200 });
+}

package/scripts/build-macos-notifier.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/** Build the universal, appearance-aware native macOS notification helper. */
+import { execFileSync } from "node:child_process";
+import {
+  chmodSync,
+  cpSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+if (process.platform !== "darwin") {
+  throw new Error("build-macos-notifier must run on macOS with Xcode 26 or newer");
+}
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = resolve(here, "..");
+const sourceDir = join(root, "native", "macos", "notifier");
+const outputFlag = process.argv.indexOf("--output");
+const versionFlag = process.argv.indexOf("--version");
+const appPath = resolve(
+  outputFlag === -1
+    ? join(root, "packages", "daemon", "dist", "native", "TmuxIdeNotifier.app")
+    : process.argv[outputFlag + 1],
+);
+const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const version = String(
+  versionFlag === -1 ? packageJson.version || "1.0.0" : process.argv[versionFlag + 1],
+);
+const buildVersion = /^\d+(?:\.\d+){0,2}/.exec(version)?.[0] ?? "1";
+const signingIdentity = process.env.TMUX_IDE_CODESIGN_IDENTITY?.trim() || "-";
+const scratch = mkdtempSync(join(tmpdir(), "tmux-ide-notifier-"));
+
+function run(command, args, options = {}) {
+  execFileSync(command, args, { stdio: "inherit", ...options });
+}
+
+function output(command, args) {
+  return execFileSync(command, args, { encoding: "utf8" }).trim();
+}
+
+try {
+  const contents = join(appPath, "Contents");
+  const macosDir = join(contents, "MacOS");
+  const resourcesDir = join(contents, "Resources");
+  const stagedIcon = join(scratch, "AppIcon.icon");
+  const armBinary = join(scratch, "tmux-ide-notifier-arm64");
+  const x64Binary = join(scratch, "tmux-ide-notifier-x86_64");
+  const universalBinary = join(macosDir, "tmux-ide-notifier");
+
+  rmSync(appPath, { recursive: true, force: true });
+  mkdirSync(macosDir, { recursive: true });
+  mkdirSync(resourcesDir, { recursive: true });
+  cpSync(join(sourceDir, "AppIcon.icon"), stagedIcon, { recursive: true });
+
+  const swiftArgs = (target, output) => [
+    "swiftc",
+    "-O",
+    "-parse-as-library",
+    "-swift-version",
+    "5",
+    "-target",
+    target,
+    "-framework",
+    "AppKit",
+    "-framework",
+    "UserNotifications",
+    "-framework",
+    "Security",
+    join(sourceDir, "TmuxIdeNotifier.swift"),
+    "-o",
+    output,
+  ];
+  run("xcrun", swiftArgs("arm64-apple-macos11.0", armBinary));
+  run("xcrun", swiftArgs("x86_64-apple-macos11.0", x64Binary));
+  run("xcrun", ["lipo", "-create", armBinary, x64Binary, "-output", universalBinary]);
+  chmodSync(universalBinary, 0o755);
+
+  run("xcrun", [
+    "actool",
+    stagedIcon,
+    "--compile",
+    resourcesDir,
+    "--platform",
+    "macosx",
+    "--minimum-deployment-target",
+    "11.0",
+    "--target-device",
+    "mac",
+    "--app-icon",
+    "AppIcon",
+    "--standalone-icon-behavior",
+    "all",
+    "--output-partial-info-plist",
+    join(scratch, "icon-partial.plist"),
+    "--warnings",
+    "--notices",
+    "--errors",
+    "--output-format",
+    "human-readable-text",
+  ]);
+
+  const plist = readFileSync(join(sourceDir, "Info.plist"), "utf8")
+    // Apple bundle versions are numeric even when the npm release carries a
+    // prerelease suffix (for example 2.8.0-beta.1).
+    .replaceAll("__VERSION__", buildVersion)
+    .replaceAll("__BUILD_VERSION__", buildVersion);
+  writeFileSync(join(contents, "Info.plist"), plist);
+  writeFileSync(join(contents, "PkgInfo"), "APPL????");
+
+  // Portable release artifacts use an ad-hoc signature plus the helper's
+  // native compatibility delivery. A release environment can provide a
+  // Developer ID identity as part of a signed + notarized distribution; that
+  // makes the modern UNUserNotificationCenter path eligible at runtime.
+  const signArgs =
+    signingIdentity === "-"
+      ? ["--force", "--deep", "--sign", "-", "--timestamp=none", appPath]
+      : [
+          "--force",
+          "--deep",
+          "--options",
+          "runtime",
+          "--sign",
+          signingIdentity,
+          "--timestamp",
+          appPath,
+        ];
+  run("codesign", signArgs);
+  run("codesign", ["--verify", "--deep", "--strict", appPath]);
+
+  const architectures = new Set(output("xcrun", ["lipo", "-archs", universalBinary]).split(/\s+/));
+  for (const architecture of ["arm64", "x86_64"]) {
+    if (!architectures.has(architecture)) {
+      throw new Error(`native notifier is missing ${architecture}`);
+    }
+  }
+
+  const assetInfo = JSON.parse(
+    output("xcrun", ["assetutil", "--info", join(resourcesDir, "Assets.car")]),
+  );
+  const iconAppearances = new Set(
+    assetInfo.filter((entry) => entry.AssetType === "IconGroup").map((entry) => entry.Appearance),
+  );
+  for (const appearance of ["NSAppearanceNameAqua", "NSAppearanceNameDarkAqua"]) {
+    if (!iconAppearances.has(appearance)) {
+      throw new Error(`native notifier icon is missing ${appearance}`);
+    }
+  }
+
+  console.log(
+    `[build-macos-notifier] wrote ${appPath} (${[...architectures].join("+")}; Aqua+DarkAqua)`,
+  );
+} finally {
+  rmSync(scratch, { recursive: true, force: true });
+}

package/scripts/postinstall.js

@@ -91,7 +91,14 @@ const nextSettings = {
   },
 };
 
-writeFileSync(settingsPath, `${JSON.stringify(nextSettings, null, 2)}\n`);
+try {
+  writeFileSync(settingsPath, `${JSON.stringify(nextSettings, null, 2)}\n`);
+} catch (error) {
+  // Best-effort like everything above: sandboxed installs (e.g. a package
+  // manager building in a $HOME-restricted sandbox) may deny this write —
+  // that must never fail the install itself.
+  console.warn(`[tmux-ide] Skipping Claude settings update: ${error.message}`);
+}
 
 function shouldInstallClaudeIntegration() {
   return process.env.npm_config_global === "true";

package/scripts/prepublish-check.mjs

@@ -10,7 +10,7 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { accessSync, constants, existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 function run(command, args) {
@@ -42,3 +42,39 @@ if (cliJsMtime < cliTsMtime) {
     "bin/cli.js is older than bin/cli.ts — run: pnpm build:cli && git add bin/cli.js",
   );
 }
+
+// ---------------------------------------------------------------
+// Native macOS notification sender — release.yml builds this on a macOS 26
+// runner and injects it into packages/daemon/dist before npm publish. npm and
+// Homebrew consume the same tarball, so a missing bundle would silently put
+// users back on an unbranded AppleScript fallback.
+// ---------------------------------------------------------------
+const notifierRoot = join(
+  process.cwd(),
+  "packages",
+  "daemon",
+  "dist",
+  "native",
+  "TmuxIdeNotifier.app",
+  "Contents",
+);
+for (const relative of [
+  "Info.plist",
+  join("Resources", "Assets.car"),
+  join("Resources", "AppIcon.icns"),
+]) {
+  const path = join(notifierRoot, relative);
+  if (!existsSync(path)) {
+    throw new Error(
+      `native macOS notifier is incomplete (${relative} missing) — run pnpm build:macos-notifier on macOS`,
+    );
+  }
+}
+const notifierExecutable = join(notifierRoot, "MacOS", "tmux-ide-notifier");
+try {
+  accessSync(notifierExecutable, constants.X_OK);
+} catch {
+  throw new Error(
+    "native macOS notifier executable is missing or not executable — run pnpm build:macos-notifier on macOS",
+  );
+}

package/scripts/publish-tap.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Publish packaging/homebrew/Formula/tmux-ide.rb to the Homebrew tap repo
+# (wavyrai/homebrew-tap), i.e. the one-time seeding the CI `bump_tap` job
+# assumes. After this, every release keeps the tap current automatically
+# (given the TAP_PUSH_TOKEN secret — see .github/workflows/release.yml).
+#
+# Usage:
+#   scripts/publish-tap.sh [path-to-tap-checkout]
+#
+# With no argument, clones git@github.com:wavyrai/homebrew-tap.git into a
+# temp dir. The tap repo must already exist on GitHub (create it empty —
+# the name MUST be exactly `homebrew-tap` for `brew install
+# wavyrai/tap/tmux-ide` to resolve).
+set -euo pipefail
+
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+formula="$repo_root/packaging/homebrew/Formula/tmux-ide.rb"
+[[ -f "$formula" ]] || {
+  echo "formula not found: $formula" >&2
+  exit 1
+}
+
+tap_dir="${1:-}"
+cleanup=""
+if [[ -z "$tap_dir" ]]; then
+  tap_dir="$(mktemp -d)/homebrew-tap"
+  cleanup="$(dirname "$tap_dir")"
+  git clone git@github.com:wavyrai/homebrew-tap.git "$tap_dir"
+fi
+[[ -d "$tap_dir/.git" ]] || {
+  echo "not a git checkout: $tap_dir" >&2
+  exit 1
+}
+
+version="$(sed -nE 's#^  url ".*/tmux-ide-([0-9][^"]*)\.tgz"$#\1#p' "$formula")"
+[[ -n "$version" ]] || {
+  echo "could not read the version from the formula url" >&2
+  exit 1
+}
+
+mkdir -p "$tap_dir/Formula"
+cp "$formula" "$tap_dir/Formula/tmux-ide.rb"
+
+cd "$tap_dir"
+git add Formula/tmux-ide.rb
+if git diff --cached --quiet; then
+  echo "tap already has this formula version (v$version) — nothing to push."
+else
+  git commit -m "tmux-ide $version"
+  git push origin HEAD
+  echo "pushed tmux-ide v$version to $(git remote get-url origin)"
+fi
+
+[[ -n "$cleanup" ]] && rm -rf "$cleanup"
+echo "install with: brew install wavyrai/tap/tmux-ide"