opencode-sidebar 0.1.0

package/dist/lib/tmux.js

@@ -0,0 +1,371 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { MAX_BACKGROUND_SESSIONS } from "./constants.js";
+import { sessionWindowTitle, tmuxWindowName } from "./util.js";
+const execFileAsync = promisify(execFile);
+let cachedRightPaneID;
+const SESSION_OPTION = "@opencode_session_id";
+const DIRECTORY_OPTION = "@opencode_directory";
+const TITLE_OPTION = "@opencode_title";
+const PREVIEW_SESSION_OPTION = "@opencode_preview_session_id";
+const PREVIEW_DIRECTORY_OPTION = "@opencode_preview_directory";
+const PREVIEW_TITLE_OPTION = "@opencode_preview_title";
+const PREVIEW_PANE_OPTION = "@opencode_preview_pane_id";
+async function runTmux(args) {
+    const { stdout } = await execFileAsync("tmux", args, {
+        maxBuffer: 1024 * 1024,
+    });
+    return stdout.trim();
+}
+async function getPaneWidth(paneID) {
+    return Number(await runTmux([
+        "display-message",
+        "-p",
+        "-t",
+        paneID,
+        "#{pane_width}",
+    ]));
+}
+export function isTmux() {
+    return Boolean(process.env.TMUX && process.env.TMUX_PANE);
+}
+export async function getCurrentPaneID() {
+    if (!process.env.TMUX_PANE)
+        throw new Error("Not running inside tmux");
+    return process.env.TMUX_PANE;
+}
+export async function getSessionName() {
+    return runTmux(["display-message", "-p", "#{session_name}"]);
+}
+export async function listActiveSessionWindows() {
+    const session = await getSessionName();
+    const output = await runTmux([
+        "list-panes",
+        "-a",
+        "-t",
+        session,
+        "-F",
+        `#{pane_id}\t#{window_id}\t#{window_name}\t#{window_active}\t#{${SESSION_OPTION}}\t#{${DIRECTORY_OPTION}}\t#{${TITLE_OPTION}}`,
+    ]);
+    return output
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => line.split("\t"))
+        .filter((parts) => parts[4])
+        .map(([paneID, windowID, windowName, active, sessionID, directory, title]) => ({
+        paneID,
+        windowID,
+        windowName,
+        active: active === "1",
+        sessionID,
+        directory,
+        title,
+    }));
+}
+export function trimBackgroundSessions(records, maxBackgroundSessions = MAX_BACKGROUND_SESSIONS) {
+    if (maxBackgroundSessions < 0)
+        return [];
+    return [...records]
+        .filter((record) => !record.active)
+        .sort((a, b) => {
+        const windowA = Number(a.windowID.replace(/^@/, ""));
+        const windowB = Number(b.windowID.replace(/^@/, ""));
+        return windowA - windowB;
+    })
+        .slice(0, Math.max(0, records.filter((record) => !record.active).length - maxBackgroundSessions));
+}
+export async function findWindowBySessionID(sessionID) {
+    const windows = await listActiveSessionWindows();
+    return windows.find((window) => window.sessionID === sessionID);
+}
+export async function renameSessionWindow(sessionID, directory, title) {
+    const preview = await getPreviewSessionMeta();
+    const target = await findAnyWindowBySessionID(sessionID);
+    if (preview?.sessionID === sessionID && preview.paneID) {
+        await setPreviewSession({
+            sessionID,
+            directory,
+            title,
+            paneID: preview.paneID,
+        });
+        await setPaneSession({
+            paneID: preview.paneID,
+            sessionID,
+            directory,
+            title,
+        });
+        await setPaneTitle(preview.paneID, sessionWindowTitle(directory, title));
+        return true;
+    }
+    if (!target)
+        return false;
+    await runTmux(["rename-window", "-t", target.windowID, tmuxWindowName(directory, title)]).catch(() => { });
+    await runTmux(["set-option", "-w", "-t", target.windowID, SESSION_OPTION, sessionID]).catch(() => { });
+    await runTmux(["set-option", "-w", "-t", target.windowID, DIRECTORY_OPTION, directory]).catch(() => { });
+    await runTmux(["set-option", "-w", "-t", target.windowID, TITLE_OPTION, title]).catch(() => { });
+    return true;
+}
+export async function findBackgroundWindowBySessionID(sessionID) {
+    const preview = await getPreviewSessionMeta();
+    const windows = await listActiveSessionWindows();
+    return windows.find((window) => {
+        if (window.sessionID !== sessionID)
+            return false;
+        if (preview?.paneID && window.paneID === preview.paneID)
+            return false;
+        return !window.active || Boolean(window.sessionID);
+    });
+}
+export async function findAnyWindowBySessionID(sessionID) {
+    const preview = await getPreviewSessionMeta();
+    const windows = await listActiveSessionWindows();
+    const previewWindow = preview?.paneID ? windows.find((window) => window.paneID === preview.paneID) : undefined;
+    if (previewWindow?.sessionID === sessionID) {
+        return {
+            ...previewWindow,
+            preview: true,
+        };
+    }
+    const parked = windows.find((window) => window.sessionID === sessionID);
+    if (!parked)
+        return undefined;
+    return {
+        ...parked,
+        preview: false,
+    };
+}
+export async function setPreviewSession(input) {
+    const session = await getSessionName();
+    await runTmux(["set-option", "-t", session, PREVIEW_SESSION_OPTION, input.sessionID]);
+    await runTmux(["set-option", "-t", session, PREVIEW_DIRECTORY_OPTION, input.directory]);
+    await runTmux(["set-option", "-t", session, PREVIEW_TITLE_OPTION, input.title]);
+    if (input.paneID) {
+        await runTmux(["set-option", "-t", session, PREVIEW_PANE_OPTION, input.paneID]);
+    }
+}
+export async function getPreviewSession() {
+    const session = await getSessionName();
+    const value = await runTmux(["show-options", "-v", "-t", session, PREVIEW_SESSION_OPTION]).catch(() => "");
+    return value || undefined;
+}
+export async function getPreviewSessionMeta() {
+    const sessionID = await getPreviewSession();
+    if (!sessionID)
+        return undefined;
+    const session = await getSessionName();
+    const directory = await runTmux(["show-options", "-v", "-t", session, PREVIEW_DIRECTORY_OPTION]).catch(() => "");
+    const title = await runTmux(["show-options", "-v", "-t", session, PREVIEW_TITLE_OPTION]).catch(() => "");
+    const paneID = await runTmux(["show-options", "-v", "-t", session, PREVIEW_PANE_OPTION]).catch(() => "");
+    return {
+        sessionID,
+        directory,
+        title,
+        paneID,
+    };
+}
+export async function clearPreviewSession() {
+    const session = await getSessionName();
+    await runTmux(["set-option", "-u", "-t", session, PREVIEW_SESSION_OPTION]).catch(() => { });
+    await runTmux(["set-option", "-u", "-t", session, PREVIEW_DIRECTORY_OPTION]).catch(() => { });
+    await runTmux(["set-option", "-u", "-t", session, PREVIEW_TITLE_OPTION]).catch(() => { });
+    await runTmux(["set-option", "-u", "-t", session, PREVIEW_PANE_OPTION]).catch(() => { });
+}
+export async function killSessionWindowBySessionID(sessionID) {
+    const preview = await getPreviewSessionMeta();
+    if (preview?.sessionID === sessionID && preview.paneID) {
+        await clearPreviewSession();
+        await killPane(preview.paneID).catch(() => { });
+        return true;
+    }
+    const target = await findAnyWindowBySessionID(sessionID);
+    if (!target)
+        return false;
+    if (target.preview) {
+        await clearPreviewSession();
+    }
+    await killWindow(target.windowID);
+    return true;
+}
+export async function getCurrentWindowID() {
+    return runTmux(["display-message", "-p", "#{window_id}"]);
+}
+export async function killWindow(windowID) {
+    await runTmux(["kill-window", "-t", windowID]);
+}
+export async function killPane(paneID) {
+    await runTmux(["kill-pane", "-t", paneID]);
+}
+export async function pruneBackgroundSessions(options) {
+    const keep = new Set(options?.keepSessionIDs ?? []);
+    const windows = await listActiveSessionWindows();
+    const victims = trimBackgroundSessions(windows.filter((window) => !keep.has(window.sessionID)), options?.maxBackgroundSessions);
+    for (const window of victims) {
+        await killWindow(window.windowID).catch(() => { });
+    }
+    return victims;
+}
+export async function clearWindowSession(windowID) {
+    await runTmux(["set-option", "-u", "-w", "-t", windowID, SESSION_OPTION]).catch(() => { });
+    await runTmux(["set-option", "-u", "-w", "-t", windowID, DIRECTORY_OPTION]).catch(() => { });
+    await runTmux(["set-option", "-u", "-w", "-t", windowID, TITLE_OPTION]).catch(() => { });
+}
+export async function setPaneSession(input) {
+    await runTmux(["set-option", "-p", "-t", input.paneID, SESSION_OPTION, input.sessionID]).catch(() => { });
+    await runTmux(["set-option", "-p", "-t", input.paneID, DIRECTORY_OPTION, input.directory]).catch(() => { });
+    await runTmux(["set-option", "-p", "-t", input.paneID, TITLE_OPTION, input.title]).catch(() => { });
+}
+export async function getRightPaneID(selectorPaneID) {
+    if (cachedRightPaneID) {
+        const all = await runTmux(["list-panes", "-a", "-F", "#{pane_id}"]).catch(() => "");
+        if (all.split("\n").includes(cachedRightPaneID)) {
+            return cachedRightPaneID;
+        }
+        cachedRightPaneID = undefined;
+    }
+    const pane = await runTmux([
+        "list-panes",
+        "-t",
+        selectorPaneID,
+        "-F",
+        "#{pane_id} #{pane_left}",
+    ]);
+    const selectorLeft = Number(await runTmux([
+        "display-message",
+        "-p",
+        "-t",
+        selectorPaneID,
+        "#{pane_left}",
+    ]));
+    let nearest;
+    for (const line of pane.split("\n")) {
+        const [paneID, left] = line.trim().split(" ");
+        if (!paneID || left === undefined)
+            continue;
+        if (paneID === selectorPaneID)
+            continue;
+        const numericLeft = Number(left);
+        if (numericLeft <= selectorLeft)
+            continue;
+        if (!nearest || numericLeft < nearest.left) {
+            nearest = { paneID, left: numericLeft };
+        }
+    }
+    if (nearest) {
+        cachedRightPaneID = nearest.paneID;
+        return nearest.paneID;
+    }
+    return undefined;
+}
+export async function splitRightPane(selectorPaneID, cwd) {
+    const totalWidth = await getPaneWidth(selectorPaneID);
+    const idealSidebarWidth = 52;
+    const minimumSidebarWidth = 36;
+    const minimumRightWidth = 44;
+    const sidebarWidth = Math.max(minimumSidebarWidth, Math.min(idealSidebarWidth, totalWidth - minimumRightWidth));
+    const rightWidth = Math.max(1, totalWidth - sidebarWidth);
+    const paneID = await runTmux([
+        "split-window",
+        "-h",
+        "-d",
+        "-t",
+        selectorPaneID,
+        "-l",
+        String(rightWidth),
+        "-c",
+        cwd,
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "",
+    ]);
+    cachedRightPaneID = paneID;
+    return paneID;
+}
+export async function respawnPane(paneID, cwd, command) {
+    await runTmux([
+        "respawn-pane",
+        "-k",
+        "-t",
+        paneID,
+        "-c",
+        cwd,
+        ...command,
+    ]);
+}
+export async function selectPane(paneID) {
+    await runTmux(["select-pane", "-t", paneID]);
+}
+export async function setPaneTitle(paneID, title) {
+    await runTmux(["select-pane", "-t", paneID, "-T", title]);
+}
+export async function getPaneWindowID(paneID) {
+    return runTmux(["display-message", "-p", "-t", paneID, "#{window_id}"]);
+}
+export async function bindToggleKeys(selectorPaneID) {
+    const rightPaneID = await getRightPaneID(selectorPaneID);
+    if (!rightPaneID)
+        return;
+    const session = await getSessionName();
+    await runTmux(["bind-key", "-n", "M-]", "select-pane", "-t", rightPaneID]);
+    await runTmux(["bind-key", "-n", "M-b", "select-window", "-t", `${session}:0`]);
+}
+export async function ensureTmuxLayout(cwd) {
+    const selectorPaneID = await getCurrentPaneID();
+    let rightPaneID = await getRightPaneID(selectorPaneID);
+    if (!rightPaneID) {
+        rightPaneID = await splitRightPane(selectorPaneID, cwd);
+    }
+    await bindToggleKeys(selectorPaneID);
+    return {
+        selectorPaneID,
+        rightPaneID,
+    };
+}
+export async function swapPreviewWithSessionPane(input) {
+    await runTmux(["swap-pane", "-d", "-s", input.sessionPaneID, "-t", input.previewPaneID]);
+    cachedRightPaneID = input.sessionPaneID;
+    await setPreviewSession({
+        ...input.nextSession,
+        paneID: input.sessionPaneID,
+    });
+    await setPaneSession({
+        paneID: input.sessionPaneID,
+        sessionID: input.nextSession.sessionID,
+        directory: input.nextSession.directory,
+        title: input.nextSession.title,
+    });
+    const launcherWindowID = await getCurrentWindowID();
+    await clearWindowSession(launcherWindowID);
+    if (input.previewSession) {
+        await runTmux(["rename-window", "-t", input.hiddenWindowID, tmuxWindowName(input.previewSession.directory, input.previewSession.title)]).catch(() => { });
+        await runTmux(["set-option", "-w", "-t", input.hiddenWindowID, SESSION_OPTION, input.previewSession.sessionID]).catch(() => { });
+        await runTmux(["set-option", "-w", "-t", input.hiddenWindowID, DIRECTORY_OPTION, input.previewSession.directory]).catch(() => { });
+        await runTmux(["set-option", "-w", "-t", input.hiddenWindowID, TITLE_OPTION, input.previewSession.title]).catch(() => { });
+    }
+    else {
+        await killWindow(input.hiddenWindowID);
+    }
+    await setPaneTitle(input.sessionPaneID, sessionWindowTitle(input.nextSession.directory, input.nextSession.title));
+}
+export async function parkPreviewSession(input) {
+    const output = await runTmux([
+        "break-pane",
+        "-d",
+        "-s",
+        input.previewPaneID,
+        "-P",
+        "-F",
+        "#{window_id}\t#{pane_id}",
+    ]);
+    const [windowID, paneID] = output.split("\t");
+    cachedRightPaneID = undefined;
+    await runTmux(["rename-window", "-t", windowID, tmuxWindowName(input.directory, input.title)]).catch(() => { });
+    await runTmux(["set-option", "-w", "-t", windowID, SESSION_OPTION, input.sessionID]).catch(() => { });
+    await runTmux(["set-option", "-w", "-t", windowID, DIRECTORY_OPTION, input.directory]).catch(() => { });
+    await runTmux(["set-option", "-w", "-t", windowID, TITLE_OPTION, input.title]).catch(() => { });
+    await clearPreviewSession();
+    return {
+        windowID,
+        paneID,
+    };
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/util.js

@@ -0,0 +1,135 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function truncate(input, width) {
+    if (width <= 0)
+        return "";
+    if (input.length <= width)
+        return input;
+    if (width <= 1)
+        return input.slice(0, width);
+    return input.slice(0, width - 1) + "…";
+}
+export function relativeTime(timestamp, now = Date.now()) {
+    const delta = Math.max(0, now - timestamp);
+    const minute = 60_000;
+    const hour = 60 * minute;
+    const day = 24 * hour;
+    const week = 7 * day;
+    const month = 30 * day;
+    if (delta < minute)
+        return "now";
+    if (delta < hour)
+        return `${Math.floor(delta / minute)}m`;
+    if (delta < day)
+        return `${Math.floor(delta / hour)}h`;
+    if (delta < week)
+        return `${Math.floor(delta / day)}d`;
+    if (delta < month)
+        return `${Math.floor(delta / week)}w`;
+    return `${Math.floor(delta / month)}mo`;
+}
+export function normalizeDirectory(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        throw new Error("Directory path is empty");
+    const expanded = trimmed.startsWith("~/") ? path.join(process.env.HOME ?? "", trimmed.slice(2)) : trimmed;
+    return path.resolve(expanded);
+}
+export async function assertDirectoryExists(directory) {
+    const stats = await fs.stat(directory);
+    if (!stats.isDirectory()) {
+        throw new Error(`${directory} is not a directory`);
+    }
+}
+export function directoryLabel(directory, preferred) {
+    return preferred?.trim() || path.basename(directory) || directory;
+}
+export function directorySubtitle(directory, root) {
+    if (!root || root === directory)
+        return directory;
+    return `${directory}  ·  ${path.basename(root)}`;
+}
+export function sessionWorkspace(sessionID) {
+    return `opencode-session-${sessionID}`;
+}
+export function sessionWindowTitle(directory, title) {
+    const base = path.basename(directory) || directory;
+    return `OpenCode · ${base} · ${truncate(title || "New session", 60)}`;
+}
+export function tmuxWindowName(directory, title) {
+    const base = path.basename(directory) || directory;
+    return truncate(`${base} · ${title || "New session"}`, 24);
+}
+export function parseFileUrl(input) {
+    if (!input)
+        return undefined;
+    if (!input.startsWith("file://"))
+        return input;
+    try {
+        return fileURLToPath(input);
+    }
+    catch {
+        return input;
+    }
+}
+export function distinct(items) {
+    return [...new Set(items)];
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function isPrintable(input) {
+    return input.length === 1 && input >= " " && input !== "\u007f";
+}
+export function sanitizePastedText(input) {
+    return input.replace(/[\r\n]+/g, "").replace(/\t+/g, " ");
+}
+export function wrapTextHard(input, width) {
+    if (width <= 0)
+        return [];
+    if (!input)
+        return [""];
+    const lines = [];
+    for (const paragraph of input.split(/\r?\n/)) {
+        if (!paragraph) {
+            lines.push("");
+            continue;
+        }
+        const words = paragraph.split(/\s+/).filter(Boolean);
+        let current = "";
+        const pushChunk = (chunk) => {
+            if (!chunk)
+                return;
+            lines.push(chunk);
+        };
+        for (const word of words) {
+            if (word.length > width) {
+                if (current) {
+                    lines.push(current);
+                    current = "";
+                }
+                for (let index = 0; index < word.length; index += width) {
+                    pushChunk(word.slice(index, index + width));
+                }
+                continue;
+            }
+            if (!current) {
+                current = word;
+                continue;
+            }
+            const next = `${current} ${word}`;
+            if (next.length <= width) {
+                current = next;
+            }
+            else {
+                lines.push(current);
+                current = word;
+            }
+        }
+        if (current) {
+            lines.push(current);
+        }
+    }
+    return lines.length ? lines : [""];
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "opencode-sidebar",
+  "version": "0.1.0",
+  "description": "tmux sidebar launcher for OpenCode",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "Arnav Kumar (https://github.com/arnavpisces)",
+  "homepage": "https://github.com/arnavpisces/opencode-sidebar#readme",
+  "bugs": {
+    "url": "https://github.com/arnavpisces/opencode-sidebar/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arnavpisces/opencode-sidebar.git"
+  },
+  "keywords": [
+    "opencode",
+    "tmux",
+    "ink",
+    "cli"
+  ],
+  "bin": {
+    "opencode-sidebar": "bin/opencode-sidebar.js"
+  },
+  "files": [
+    "bin/opencode-sidebar.js",
+    "dist",
+    "scripts/system-dependencies.mjs",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && ./node_modules/.bin/tsc -p tsconfig.build.json",
+    "start": "npm run build && node ./bin/opencode-sidebar.js",
+    "dev": "bun --watch src/index.tsx",
+    "launcher": "./bin/opencode-sidebar-tmux",
+    "launcher:tmux": "./bin/opencode-sidebar-tmux",
+    "open:test": "bun run src/dev-open-session.ts",
+    "prepack": "npm run verify",
+    "test": "bun test",
+    "test:tmux:cleanup": "./test/run-tmux-cleanup.sh",
+    "test:tmux:flow": "./test/run-tmux-flow.sh",
+    "test:tmux:sigint-cleanup": "./test/run-sidebar-sigint-cleanup.sh",
+    "typecheck": "tsc --noEmit",
+    "verify": "npm run typecheck && npm run test && npm run build",
+    "verify:release": "npm run verify && npm run verify:tmux",
+    "verify:tmux": "npm run test:tmux:flow && npm run test:tmux:cleanup && npm run test:tmux:sigint-cleanup"
+  },
+  "dependencies": {
+    "@opencode-ai/sdk": "1.3.15",
+    "ink": "6.8.0",
+    "react": "19.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.15.3",
+    "@types/react": "19.2.2",
+    "bun-types": "1.3.11",
+    "typescript": "5.8.3"
+  }
+}

package/scripts/system-dependencies.mjs

@@ -0,0 +1,42 @@
+import { spawnSync } from "node:child_process"
+
+const SYSTEM_DEPENDENCIES = [
+  {
+    command: "tmux",
+    probeArgs: ["-V"],
+    installHint: "Install tmux and make sure it is available on PATH.",
+  },
+  {
+    command: "opencode",
+    probeArgs: ["--version"],
+    installHint: "Install the OpenCode CLI and make sure it is available on PATH.",
+  },
+]
+
+function dependencyExists(command, probeArgs) {
+  const result = spawnSync(command, probeArgs, {
+    stdio: "ignore",
+  })
+  return result.error?.code !== "ENOENT"
+}
+
+export function getSystemDependencyReport() {
+  const missing = SYSTEM_DEPENDENCIES.filter((dependency) => !dependencyExists(dependency.command, dependency.probeArgs))
+  return {
+    allFound: missing.length === 0,
+    missing,
+  }
+}
+
+export function formatMissingDependencyMessage(report) {
+  if (report.allFound) {
+    return "[opencode-sidebar] Found required system dependencies: tmux, opencode."
+  }
+
+  const details = report.missing.map((dependency) => `- ${dependency.command}: ${dependency.installHint}`).join("\n")
+  return [
+    "[opencode-sidebar] Installed, but some required system dependencies are missing.",
+    details,
+    "[opencode-sidebar] The package will not run until those commands are installed.",
+  ].join("\n")
+}