@creativeintelligence/abbie 0.1.5 → 0.1.7

package/dist/lib/tmux/context.js

@@ -1,239 +0,0 @@
-/**
- * tmux context builder.
- * Builds a structured snapshot of the tmux workspace for agent injection.
- */
-import * as bridge from "./bridge.js";
-import { redactContent, shouldFilterCommand, shouldFilterPath, shouldFilterSession, shouldFilterWindow, } from "./redaction.js";
-/**
- * Allowed commands for pane capture.
- * Only capture panes running these commands.
- */
-const ALLOWED_COMMANDS = new Set(["nvim", "vim", "vi", "zsh", "bash", "fish", "sh"]);
-/**
- * Build a structured tmux context.
- */
-export async function buildContext(options = {}) {
-    const { maxBytes = 200000, maxTotalLines = 4000, maxSessions, maxWindowsPerSession, maxPanesPerWindow, redact = true, redactMode = "balanced", filter = {}, includeAllCommands = false, } = options;
-    // Check if tmux is running
-    const tmuxRunning = await bridge.isRunning();
-    if (!tmuxRunning) {
-        return {
-            generatedAt: new Date().toISOString(),
-            tmuxRunning: false,
-            truncated: false,
-            sessions: [],
-        };
-    }
-    // Get all sessions
-    let sessions = await bridge.listSessions();
-    // Apply session filters
-    sessions = sessions.filter((s) => !shouldFilterSession(s.name, filter));
-    // Apply maxSessions limit
-    if (maxSessions !== undefined && sessions.length > maxSessions) {
-        sessions = sessions.slice(0, maxSessions);
-    }
-    const result = {
-        generatedAt: new Date().toISOString(),
-        tmuxRunning: true,
-        truncated: false,
-        sessions: [],
-    };
-    let totalBytes = 0;
-    let totalLines = 0;
-    let truncated = false;
-    let truncationReason;
-    for (const session of sessions) {
-        // Check byte limit
-        if (totalBytes >= maxBytes) {
-            truncated = true;
-            truncationReason = "max-bytes";
-            break;
-        }
-        // Check line limit
-        if (totalLines >= maxTotalLines) {
-            truncated = true;
-            truncationReason = "max-lines";
-            break;
-        }
-        let windows = await bridge.listWindows(session.name);
-        // Apply window filters
-        windows = windows.filter((w) => !shouldFilterWindow(w.name, filter));
-        // Apply maxWindowsPerSession limit
-        if (maxWindowsPerSession !== undefined && windows.length > maxWindowsPerSession) {
-            windows = windows.slice(0, maxWindowsPerSession);
-        }
-        const sessionContext = {
-            name: session.name,
-            attached: session.attached,
-            windows: [],
-        };
-        for (const window of windows) {
-            // Check limits again
-            if (totalBytes >= maxBytes || totalLines >= maxTotalLines) {
-                truncated = true;
-                truncationReason = totalBytes >= maxBytes ? "max-bytes" : "max-lines";
-                break;
-            }
-            let panes = await bridge.listPanes(window.index, session.name);
-            // Filter by allowed commands unless includeAllCommands is true
-            if (!includeAllCommands) {
-                panes = panes.filter((p) => ALLOWED_COMMANDS.has(p.currentCommand));
-            }
-            // Apply path and command filters
-            panes = panes.filter((p) => {
-                if (shouldFilterPath(p.currentPath, filter))
-                    return false;
-                if (shouldFilterCommand(p.currentCommand, filter))
-                    return false;
-                return true;
-            });
-            // Apply maxPanesPerWindow limit
-            if (maxPanesPerWindow !== undefined && panes.length > maxPanesPerWindow) {
-                panes = panes.slice(0, maxPanesPerWindow);
-            }
-            // Skip windows with no eligible panes
-            if (panes.length === 0) {
-                continue;
-            }
-            const windowContext = {
-                id: window.id,
-                index: window.index,
-                name: window.name,
-                active: window.active,
-                paneCount: window.panes,
-                panes: [],
-            };
-            for (const pane of panes) {
-                // Check limits
-                if (totalBytes >= maxBytes || totalLines >= maxTotalLines) {
-                    truncated = true;
-                    truncationReason = totalBytes >= maxBytes ? "max-bytes" : "max-lines";
-                    break;
-                }
-                // Capture the visible screen (based on pane height)
-                const capturedContent = await bridge.capturePane(window.index, pane.index, {
-                    session: session.name,
-                    lines: pane.height,
-                });
-                let screenContent = capturedContent;
-                let wasRedacted = false;
-                // Apply redaction
-                if (redact) {
-                    const redactionResult = redactContent(capturedContent, redactMode);
-                    screenContent = redactionResult.content;
-                    wasRedacted = redactionResult.wasRedacted;
-                }
-                // Calculate bytes and lines
-                const contentBytes = Buffer.byteLength(screenContent, "utf-8");
-                const contentLines = screenContent.split("\n").length;
-                // Check if adding this would exceed limits
-                if (totalBytes + contentBytes > maxBytes) {
-                    // Truncate content to fit
-                    const remainingBytes = maxBytes - totalBytes;
-                    screenContent = truncateToBytes(screenContent, remainingBytes);
-                    truncated = true;
-                    truncationReason = "max-bytes";
-                }
-                if (totalLines + contentLines > maxTotalLines) {
-                    // Truncate lines to fit
-                    const remainingLines = maxTotalLines - totalLines;
-                    const lines = screenContent.split("\n");
-                    screenContent = lines.slice(0, remainingLines).join("\n");
-                    truncated = true;
-                    truncationReason = "max-lines";
-                }
-                totalBytes += Buffer.byteLength(screenContent, "utf-8");
-                totalLines += screenContent.split("\n").length;
-                const paneContext = {
-                    index: pane.index,
-                    active: pane.active,
-                    cwd: pane.currentPath,
-                    cmd: pane.currentCommand,
-                    size: `${pane.width}x${pane.height}`,
-                    screen: screenContent,
-                    redacted: wasRedacted,
-                };
-                windowContext.panes.push(paneContext);
-            }
-            if (windowContext.panes.length > 0) {
-                sessionContext.windows.push(windowContext);
-            }
-        }
-        if (sessionContext.windows.length > 0) {
-            result.sessions.push(sessionContext);
-        }
-    }
-    result.truncated = truncated;
-    if (truncationReason) {
-        result.truncationReason = truncationReason;
-    }
-    return result;
-}
-/**
- * Truncate a string to a maximum number of bytes.
- */
-function truncateToBytes(str, maxBytes) {
-    const buf = Buffer.from(str, "utf-8");
-    if (buf.length <= maxBytes) {
-        return str;
-    }
-    // Binary search for the right length
-    let low = 0;
-    let high = str.length;
-    while (low < high) {
-        const mid = Math.ceil((low + high) / 2);
-        const slice = str.slice(0, mid);
-        if (Buffer.byteLength(slice, "utf-8") <= maxBytes) {
-            low = mid;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    return str.slice(0, low);
-}
-/**
- * Escape XML special characters.
- */
-function escapeXml(str) {
-    return str
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&apos;");
-}
-/**
- * Serialize context to XML.
- */
-export function toXml(context) {
-    const lines = [];
-    lines.push(`<tmux_context generated_at="${escapeXml(context.generatedAt)}" tmux_running="${context.tmuxRunning}" truncated="${context.truncated}"${context.truncationReason ? ` truncation_reason="${escapeXml(context.truncationReason)}"` : ""}>`);
-    for (const session of context.sessions) {
-        lines.push(`  <session name="${escapeXml(session.name)}" attached="${session.attached}">`);
-        for (const window of session.windows) {
-            lines.push(`    <window id="${escapeXml(window.id)}" index="${window.index}" name="${escapeXml(window.name)}" active="${window.active}" panes="${window.paneCount}">`);
-            for (const pane of window.panes) {
-                lines.push(`      <pane index="${pane.index}" active="${pane.active}" cwd="${escapeXml(pane.cwd)}" cmd="${escapeXml(pane.cmd)}" size="${pane.size}">`);
-                lines.push(`        <screen redacted="${pane.redacted}">`);
-                // Indent screen content and escape
-                const screenLines = pane.screen.split("\n");
-                for (const screenLine of screenLines) {
-                    lines.push(`          ${escapeXml(screenLine)}`);
-                }
-                lines.push("        </screen>");
-                lines.push("      </pane>");
-            }
-            lines.push("    </window>");
-        }
-        lines.push("  </session>");
-    }
-    lines.push("</tmux_context>");
-    return lines.join("\n");
-}
-/**
- * Serialize context to JSON.
- */
-export function toJson(context) {
-    return JSON.stringify(context, null, 2);
-}

package/dist/lib/tmux/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * tmux module - bridge and context building for agent prompts.
- */
-export * from "./bridge.js";
-export { buildContext, type ContextOptions, type PaneContext, type SessionContext, type TmuxContext, toJson, toXml, type WindowContext, } from "./context.js";
-export { type AgentPaneMapping, correlateAgentsToPanes, detectAgentType, extractProjectFromPath, getAllPanes, getFocusedPane, isAgentProcess, type MapResult, type PaneLocation, pathsMatch, type UnmappedPane, } from "./map.js";
-export { type FilterConfig, isSensitiveCommand, type RedactMode, redactContent, redactLine, redactTokens, shouldFilterCommand, shouldFilterPath, shouldFilterSession, shouldFilterWindow, shouldRedactLine, } from "./redaction.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/tmux/index.js

@@ -1,11 +0,0 @@
-/**
- * tmux module - bridge and context building for agent prompts.
- */
-// Core bridge primitives
-export * from "./bridge.js";
-// Context building
-export { buildContext, toJson, toXml, } from "./context.js";
-// Agent ↔ pane mapping
-export { correlateAgentsToPanes, detectAgentType, extractProjectFromPath, getAllPanes, getFocusedPane, isAgentProcess, pathsMatch, } from "./map.js";
-// Redaction utilities
-export { isSensitiveCommand, redactContent, redactLine, redactTokens, shouldFilterCommand, shouldFilterPath, shouldFilterSession, shouldFilterWindow, shouldRedactLine, } from "./redaction.js";

package/dist/lib/tmux/map.d.ts

@@ -1,57 +0,0 @@
-/**
- * Agent ↔ tmux pane correlation.
- * Maps active agent sessions to their tmux panes.
- */
-import { type ActiveSession } from "../active-sessions.js";
-export interface PaneLocation {
-    sessionName: string;
-    windowId: string;
-    windowIndex: number;
-    windowName: string;
-    paneIndex: number;
-    target: string;
-    cmd: string;
-    cwd: string;
-}
-export interface AgentPaneMapping {
-    session: ActiveSession;
-    pane: PaneLocation | null;
-    matchType: "process" | "cwd" | "none";
-}
-export interface UnmappedPane extends PaneLocation {
-    active: boolean;
-}
-export interface MapResult {
-    mappings: AgentPaneMapping[];
-    unmappedPanes: UnmappedPane[];
-}
-/**
- * Get all panes across all tmux sessions.
- */
-export declare function getAllPanes(): Promise<PaneLocation[]>;
-/**
- * Check if a pane is running an agent CLI.
- */
-export declare function isAgentProcess(cmd: string): boolean;
-/**
- * Detect which agent type a process is.
- */
-export declare function detectAgentType(cmd: string): string | null;
-/**
- * Check if two paths match (handles trailing slashes, ~).
- */
-export declare function pathsMatch(path1: string, path2: string): boolean;
-/**
- * Correlate active agent sessions with tmux panes.
- */
-export declare function correlateAgentsToPanes(): Promise<MapResult>;
-/**
- * Get the currently focused tmux pane.
- */
-export declare function getFocusedPane(): Promise<PaneLocation | null>;
-/**
- * Extract project name from a path.
- * Matches ~/Developer/apps/{project} or ~/Developer/utils/{project} patterns.
- */
-export declare function extractProjectFromPath(path: string): string | null;
-//# sourceMappingURL=map.d.ts.map

package/dist/lib/tmux/map.js

@@ -1,198 +0,0 @@
-/**
- * Agent ↔ tmux pane correlation.
- * Maps active agent sessions to their tmux panes.
- */
-import { getActiveSessionManager } from "../active-sessions.js";
-import * as bridge from "./bridge.js";
-/** Agent CLI process names to detect */
-const AGENT_PROCESSES = new Set([
-    "claude",
-    "codex",
-    "copilot",
-    "gemini",
-    "pi",
-    "opencode",
-    "droid",
-]);
-/**
- * Get all panes across all tmux sessions.
- */
-export async function getAllPanes() {
-    const panes = [];
-    const sessions = await bridge.listSessions();
-    for (const session of sessions) {
-        const windows = await bridge.listWindows(session.name);
-        for (const window of windows) {
-            const windowPanes = await bridge.listPanes(window.index, session.name);
-            for (const pane of windowPanes) {
-                panes.push({
-                    sessionName: session.name,
-                    windowId: window.id,
-                    windowIndex: window.index,
-                    windowName: window.name,
-                    paneIndex: pane.index,
-                    target: `${session.name}:${window.id}.${pane.index}`,
-                    cmd: pane.currentCommand,
-                    cwd: pane.currentPath,
-                });
-            }
-        }
-    }
-    return panes;
-}
-/**
- * Check if a pane is running an agent CLI.
- */
-export function isAgentProcess(cmd) {
-    const lowerCmd = cmd.toLowerCase();
-    return AGENT_PROCESSES.has(lowerCmd);
-}
-/**
- * Detect which agent type a process is.
- */
-export function detectAgentType(cmd) {
-    const lowerCmd = cmd.toLowerCase();
-    if (AGENT_PROCESSES.has(lowerCmd)) {
-        return lowerCmd;
-    }
-    return null;
-}
-/**
- * Normalize a path for comparison.
- */
-function normalizePath(path) {
-    // Remove trailing slashes, resolve ~ to home
-    let normalized = path.replace(/\/+$/, "");
-    if (normalized.startsWith("~")) {
-        const home = process.env.HOME || "/Users/luke";
-        normalized = normalized.replace(/^~/, home);
-    }
-    return normalized;
-}
-/**
- * Check if two paths match (handles trailing slashes, ~).
- */
-export function pathsMatch(path1, path2) {
-    return normalizePath(path1) === normalizePath(path2);
-}
-/**
- * Correlate active agent sessions with tmux panes.
- */
-export async function correlateAgentsToPanes() {
-    const manager = getActiveSessionManager();
-    const activeSessions = await manager.listAsync({ status: "running" });
-    const allPanes = await getAllPanes();
-    const mappings = [];
-    const mappedPaneTargets = new Set();
-    for (const session of activeSessions) {
-        let matchedPane = null;
-        let matchType = "none";
-        // Strategy 1: Find pane running the agent CLI with matching cwd
-        for (const pane of allPanes) {
-            if (isAgentProcess(pane.cmd) && session.cwd && pathsMatch(pane.cwd, session.cwd)) {
-                matchedPane = pane;
-                matchType = "process";
-                break;
-            }
-        }
-        // Strategy 2: If no process match, try cwd match only
-        if (!matchedPane && session.cwd) {
-            for (const pane of allPanes) {
-                if (pathsMatch(pane.cwd, session.cwd)) {
-                    matchedPane = pane;
-                    matchType = "cwd";
-                    break;
-                }
-            }
-        }
-        mappings.push({
-            session,
-            pane: matchedPane,
-            matchType,
-        });
-        if (matchedPane) {
-            mappedPaneTargets.add(matchedPane.target);
-        }
-    }
-    // Find unmapped panes (excluding agent processes that weren't matched)
-    const unmappedPanes = [];
-    for (const pane of allPanes) {
-        if (!mappedPaneTargets.has(pane.target)) {
-            // Get active status
-            const sessions = await bridge.listSessions();
-            const tmuxSession = sessions.find((s) => s.name === pane.sessionName);
-            let isActive = false;
-            if (tmuxSession) {
-                const windows = await bridge.listWindows(pane.sessionName);
-                const window = windows.find((w) => w.id === pane.windowId);
-                if (window) {
-                    const panes = await bridge.listPanes(window.index, pane.sessionName);
-                    const p = panes.find((pp) => pp.index === pane.paneIndex);
-                    isActive = p?.active ?? false;
-                }
-            }
-            unmappedPanes.push({
-                ...pane,
-                active: isActive,
-            });
-        }
-    }
-    return { mappings, unmappedPanes };
-}
-/**
- * Get the currently focused tmux pane.
- */
-export async function getFocusedPane() {
-    const running = await bridge.isRunning();
-    if (!running)
-        return null;
-    // Get all sessions and find the attached one
-    const sessions = await bridge.listSessions();
-    const attachedSession = sessions.find((s) => s.attached);
-    if (!attachedSession)
-        return null;
-    // Get windows and find the active one
-    const windows = await bridge.listWindows(attachedSession.name);
-    const activeWindow = windows.find((w) => w.active);
-    if (!activeWindow)
-        return null;
-    // Get panes and find the active one
-    const panes = await bridge.listPanes(activeWindow.index, attachedSession.name);
-    const activePane = panes.find((p) => p.active);
-    if (!activePane)
-        return null;
-    return {
-        sessionName: attachedSession.name,
-        windowId: activeWindow.id,
-        windowIndex: activeWindow.index,
-        windowName: activeWindow.name,
-        paneIndex: activePane.index,
-        target: `${attachedSession.name}:${activeWindow.id}.${activePane.index}`,
-        cmd: activePane.currentCommand,
-        cwd: activePane.currentPath,
-    };
-}
-/**
- * Extract project name from a path.
- * Matches ~/Developer/apps/{project} or ~/Developer/utils/{project} patterns.
- */
-export function extractProjectFromPath(path) {
-    const normalized = normalizePath(path);
-    const home = process.env.HOME || "/Users/luke";
-    // Pattern: ~/Developer/apps/{project}/...
-    const appsMatch = normalized.match(new RegExp(`^${home}/Developer/apps/([^/]+)`));
-    if (appsMatch) {
-        return appsMatch[1];
-    }
-    // Pattern: ~/Developer/utils/{project}/...
-    const utilsMatch = normalized.match(new RegExp(`^${home}/Developer/utils/([^/]+)`));
-    if (utilsMatch) {
-        return utilsMatch[1];
-    }
-    // Pattern: ~/Developer/{project}/...
-    const devMatch = normalized.match(new RegExp(`^${home}/Developer/([^/]+)`));
-    if (devMatch) {
-        return devMatch[1];
-    }
-    return null;
-}

package/dist/lib/tmux/panes.d.ts

@@ -1,27 +0,0 @@
-export type PaneMetrics = {
-    paneId: string;
-    cols: number;
-    rows: number;
-    cursorX: number;
-    cursorY: number;
-    cursorFlag: number;
-    title: string;
-};
-export declare function getPaneMetrics(paneId: string): Promise<PaneMetrics | null>;
-export declare function capturePaneScreen(paneId: string, opts: {
-    ansi: boolean;
-    rows: number;
-    cursor?: {
-        x: number;
-        y: number;
-        visible: boolean;
-    };
-}): Promise<string>;
-export declare function ensurePipePane(paneId: string, shellCommand: string, opts: {
-    onlyIfUnset: boolean;
-    bidirectional: boolean;
-}): Promise<{
-    attached: boolean;
-    error?: string;
-}>;
-//# sourceMappingURL=panes.d.ts.map

package/dist/lib/tmux/panes.js

@@ -1,151 +0,0 @@
-import { spawn } from "node:child_process";
-function isCsiFinalByte(code) {
-    return code >= 0x40 && code <= 0x7e;
-}
-function scanAnsiEscape(input, start) {
-    if (input[start] !== "\u001b")
-        return start;
-    const next = input[start + 1];
-    // CSI: ESC [ ... final
-    if (next === "[") {
-        let i = start + 2;
-        for (; i < input.length; i++) {
-            const code = input.charCodeAt(i);
-            if (isCsiFinalByte(code))
-                return i + 1;
-        }
-        return input.length;
-    }
-    // OSC: ESC ] ... BEL or ESC \
-    if (next === "]") {
-        let i = start + 2;
-        for (; i < input.length; i++) {
-            const code = input.charCodeAt(i);
-            if (code === 0x07 /* BEL */)
-                return i + 1;
-            if (input[i] === "\u001b" && input[i + 1] === "\\")
-                return i + 2;
-        }
-        return input.length;
-    }
-    return Math.min(input.length, start + 2);
-}
-function nextCodePoint(input, index) {
-    const cp = input.codePointAt(index) ?? 0;
-    const size = cp > 0xffff ? 2 : 1;
-    return { cp, size };
-}
-function markCursorAnsi(line, cursorX) {
-    // Best-effort: wrap the cursor cell with reverse-video toggles (7/27).
-    const x = Math.max(0, cursorX);
-    let out = "";
-    let visible = 0;
-    let i = 0;
-    while (i < line.length) {
-        if (line[i] === "\u001b") {
-            const end = scanAnsiEscape(line, i);
-            out += line.slice(i, end);
-            i = end;
-            continue;
-        }
-        const { cp, size } = nextCodePoint(line, i);
-        const ch = String.fromCodePoint(cp);
-        if (visible === x)
-            out += "\u001b[7m";
-        out += ch;
-        if (visible === x)
-            out += "\u001b[27m";
-        visible += 1;
-        i += size;
-    }
-    // If cursor is past EOL, render a reversed space.
-    if (x >= visible) {
-        out += "\u001b[7m \u001b[27m";
-    }
-    return out;
-}
-function runTmuxRaw(args) {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("tmux", args, { stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.on("data", (d) => {
-            stdout += d.toString("utf8");
-        });
-        proc.stderr.on("data", (d) => {
-            stderr += d.toString("utf8");
-        });
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve(stdout);
-            else
-                reject(new Error(stderr.trim() || `tmux ${args.join(" ")} exited ${code}`));
-        });
-        proc.on("error", reject);
-    });
-}
-export async function getPaneMetrics(paneId) {
-    try {
-        const out = await runTmuxRaw([
-            "display-message",
-            "-p",
-            "-t",
-            paneId,
-            "#{pane_width}\t#{pane_height}\t#{cursor_x}\t#{cursor_y}\t#{cursor_flag}\t#{pane_title}",
-        ]);
-        const [colsRaw, rowsRaw, cursorXRaw, cursorYRaw, cursorFlagRaw, titleRaw] = out
-            .trimEnd()
-            .split("\t");
-        const cols = Number.parseInt(colsRaw ?? "", 10);
-        const rows = Number.parseInt(rowsRaw ?? "", 10);
-        const cursorX = Number.parseInt(cursorXRaw ?? "", 10);
-        const cursorY = Number.parseInt(cursorYRaw ?? "", 10);
-        const cursorFlag = Number.parseInt(cursorFlagRaw ?? "", 10);
-        const title = titleRaw ?? "";
-        if (!Number.isFinite(cols) || !Number.isFinite(rows))
-            return null;
-        return { paneId, cols, rows, cursorX, cursorY, cursorFlag, title };
-    }
-    catch {
-        return null;
-    }
-}
-export async function capturePaneScreen(paneId, opts) {
-    const rows = Math.max(1, opts.rows);
-    const args = ["capture-pane", "-t", paneId, "-p"];
-    if (opts.ansi)
-        args.push("-e");
-    args.push("-S", `-${rows}`);
-    try {
-        // Preserve all whitespace; do not trim (important for full-screen apps).
-        const raw = await runTmuxRaw(args);
-        const cursor = opts.cursor;
-        if (!cursor || !cursor.visible)
-            return raw;
-        const lines = raw.replace(/\n$/, "").split("\n");
-        if (cursor.y < 0 || cursor.y >= lines.length)
-            return raw;
-        const target = lines[cursor.y] ?? "";
-        lines[cursor.y] = opts.ansi ? markCursorAnsi(target, cursor.x) : target;
-        return `${lines.join("\n")}\n`;
-    }
-    catch {
-        return "";
-    }
-}
-export async function ensurePipePane(paneId, shellCommand, opts) {
-    const args = ["pipe-pane", "-t", paneId];
-    if (opts.onlyIfUnset)
-        args.push("-o");
-    if (opts.bidirectional)
-        args.push("-I", "-O");
-    // If neither -I nor -O are specified, tmux defaults to -O (stdin connected).
-    args.push(shellCommand);
-    try {
-        await runTmuxRaw(args);
-        return { attached: true };
-    }
-    catch (err) {
-        return { attached: false, error: err instanceof Error ? err.message : String(err) };
-    }
-}