aimux-cli 0.1.16 → 0.1.19

package/dist/debug.js

@@ -1,16 +1,224 @@
-import { createWriteStream } from "node:fs";
-let stream = null;
-function ensureStream() {
-    if (!stream) {
-        stream = createWriteStream("/tmp/aimux-debug.log", { flags: "a" });
+import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+const LEVEL_PRIORITY = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4,
+};
+const SENSITIVE_ASSIGNMENT_PATTERN = /\b([A-Za-z_][A-Za-z0-9_]*=)(?:\\"(?:[^"\\]|\\.)*\\"|\\'(?:[^'\\]|\\.)*\\'|"[^"]*"|'[^']*'|[^"',\s\]]+)/g;
+const DEFAULT_RUNTIME_CONFIG = {
+    enabled: false,
+    level: "info",
+    categories: ["*"],
+    maxBytes: 10_000_000,
+    maxFiles: 5,
+    path: "",
+    processKind: "cli",
+};
+let runtimeConfig = { ...DEFAULT_RUNTIME_CONFIG };
+function normalizeLevel(level, fallback) {
+    return level === "error" || level === "warn" || level === "info" || level === "debug" || level === "trace"
+        ? level
+        : fallback;
+}
+function isExplicitFalse(value) {
+    return ["0", "false", "off", "no"].includes(value.trim().toLowerCase());
+}
+function normalizeCategories(categories) {
+    const normalized = (categories ?? ["*"]).map((category) => category.trim()).filter(Boolean);
+    return normalized.length > 0 ? normalized : ["*"];
+}
+export function parseLogCategories(value) {
+    if (!value)
+        return undefined;
+    return normalizeCategories(value.split(","));
+}
+export function resolveLoggingRuntimeConfig(options) {
+    const env = options.env ?? process.env;
+    const cli = options.cli ?? {};
+    let enabled = options.config.enabled;
+    let level = options.config.level;
+    let categories = normalizeCategories(options.config.categories);
+    const envLog = env.AIMUX_LOG;
+    if (envLog !== undefined) {
+        if (isExplicitFalse(envLog)) {
+            enabled = false;
+        }
+        else {
+            enabled = true;
+            level = normalizeLevel(envLog, level);
+        }
+    }
+    if (env.AIMUX_LOG_LEVEL) {
+        enabled = true;
+        level = normalizeLevel(env.AIMUX_LOG_LEVEL, level);
+    }
+    const envCategories = parseLogCategories(env.AIMUX_LOG_CATEGORIES);
+    if (envCategories) {
+        enabled = true;
+        categories = envCategories;
+    }
+    if (cli.debug) {
+        enabled = true;
+        level = "debug";
+    }
+    if (cli.trace) {
+        enabled = true;
+        level = "trace";
+    }
+    if (cli.logLevel) {
+        enabled = true;
+        level = normalizeLevel(cli.logLevel, level);
+    }
+    const cliCategories = parseLogCategories(cli.logCategory);
+    if (cliCategories) {
+        enabled = true;
+        categories = cliCategories;
+    }
+    return {
+        enabled,
+        level,
+        categories,
+        maxBytes: options.config.maxBytes,
+        maxFiles: options.config.maxFiles,
+        path: options.path,
+        processKind: options.processKind,
+        projectId: options.projectId,
+        projectRoot: options.projectRoot,
+    };
+}
+export function configureLogging(config) {
+    runtimeConfig = {
+        ...runtimeConfig,
+        ...config,
+        enabled: config.enabled ?? runtimeConfig.enabled,
+        level: normalizeLevel(config.level, runtimeConfig.level),
+        categories: normalizeCategories(config.categories ?? runtimeConfig.categories),
+        maxBytes: config.maxBytes ?? runtimeConfig.maxBytes,
+        maxFiles: config.maxFiles ?? runtimeConfig.maxFiles,
+        path: config.path ?? runtimeConfig.path,
+        processKind: config.processKind ?? runtimeConfig.processKind,
+    };
+    return { ...runtimeConfig, categories: [...runtimeConfig.categories] };
+}
+export function getLoggingConfig() {
+    return { ...runtimeConfig, categories: [...runtimeConfig.categories] };
+}
+export function resetLoggingForTests() {
+    runtimeConfig = { ...DEFAULT_RUNTIME_CONFIG, categories: [...DEFAULT_RUNTIME_CONFIG.categories] };
+}
+function shouldLog(level, category) {
+    if (!runtimeConfig.enabled || !runtimeConfig.path)
+        return false;
+    if (LEVEL_PRIORITY[level] > LEVEL_PRIORITY[runtimeConfig.level])
+        return false;
+    return runtimeConfig.categories.includes("*") || runtimeConfig.categories.includes(category);
+}
+function rotatedPath(path, index) {
+    return `${path}.${index}`;
+}
+function rotateIfNeeded(path, incomingBytes) {
+    if (runtimeConfig.maxBytes <= 0 || runtimeConfig.maxFiles <= 0 || !existsSync(path))
+        return;
+    const size = statSync(path).size;
+    if (size + incomingBytes <= runtimeConfig.maxBytes)
+        return;
+    rmSync(rotatedPath(path, runtimeConfig.maxFiles), { force: true });
+    for (let i = runtimeConfig.maxFiles - 1; i >= 1; i -= 1) {
+        const source = rotatedPath(path, i);
+        if (existsSync(source)) {
+            renameSync(source, rotatedPath(path, i + 1));
+        }
+    }
+    renameSync(path, rotatedPath(path, 1));
+}
+function writeRecord(record) {
+    const line = `${JSON.stringify(record)}\n`;
+    try {
+        mkdirSync(dirname(runtimeConfig.path), { recursive: true });
+        rotateIfNeeded(runtimeConfig.path, Buffer.byteLength(line));
+        appendFileSync(runtimeConfig.path, line);
+    }
+    catch {
+        // Logging must never break aimux runtime behavior.
+    }
+}
+function sanitizeLogString(value) {
+    return value.replace(SENSITIVE_ASSIGNMENT_PATTERN, (match, assignment) => {
+        const name = assignment.slice(0, -1);
+        return isSensitiveLogName(name) ? `${assignment}<redacted>` : match;
+    });
+}
+function isSensitiveLogName(name) {
+    const normalized = name.toLowerCase();
+    return (normalized.includes("token") ||
+        normalized.includes("secret") ||
+        normalized.includes("password") ||
+        normalized.includes("credential") ||
+        normalized.includes("authorization") ||
+        normalized.includes("auth") ||
+        normalized === "key" ||
+        normalized.endsWith("key") ||
+        normalized.includes("_key"));
+}
+function sanitizeLogValue(value, seen = new WeakSet()) {
+    if (typeof value === "string")
+        return sanitizeLogString(value);
+    if (value === null || typeof value !== "object")
+        return value;
+    const jsonLike = value;
+    if (typeof jsonLike.toJSON === "function") {
+        try {
+            const serialized = jsonLike.toJSON();
+            if (serialized !== value)
+                return sanitizeLogValue(serialized, seen);
+        }
+        catch {
+            // Fall through to structural sanitization.
+        }
+    }
+    if (seen.has(value))
+        return "[Circular]";
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.map((entry) => sanitizeLogValue(entry, seen));
+    const output = {};
+    for (const [key, fieldValue] of Object.entries(value)) {
+        output[key] = isSensitiveLogName(key) ? "<redacted>" : sanitizeLogValue(fieldValue, seen);
     }
-    return stream;
+    return output;
 }
+function sanitizeLogFields(fields) {
+    if (!fields)
+        return undefined;
+    return sanitizeLogValue(fields);
+}
+export function logAt(level, message, category = "general", fields) {
+    if (!shouldLog(level, category))
+        return;
+    writeRecord({
+        ts: new Date().toISOString(),
+        level,
+        category,
+        message: sanitizeLogString(message),
+        pid: process.pid,
+        processKind: runtimeConfig.processKind,
+        projectId: runtimeConfig.projectId,
+        projectRoot: runtimeConfig.projectRoot,
+        fields: sanitizeLogFields(fields),
+    });
+}
+export const log = {
+    error: (message, category, fields) => logAt("error", message, category, fields),
+    warn: (message, category, fields) => logAt("warn", message, category, fields),
+    info: (message, category, fields) => logAt("info", message, category, fields),
+    debug: (message, category, fields) => logAt("debug", message, category, fields),
+    trace: (message, category, fields) => logAt("trace", message, category, fields),
+};
 export function debug(msg, category) {
-    const s = ensureStream();
-    const ts = new Date().toISOString().slice(11, 23);
-    const prefix = category ? `[${ts}] [${category}]` : `[${ts}]`;
-    s.write(`${prefix} ${msg}\n`);
+    log.debug(msg, category);
 }
 export function debugContext(action, file, sizeBytes) {
     const sizeKB = (sizeBytes / 1024).toFixed(1);
@@ -32,10 +240,5 @@ export function debugGit(filesChanged, diffLen) {
     debug(`git: ${filesChanged} files changed, diff ${diffLen} chars`, "git");
 }
 export function closeDebug() {
-    if (stream) {
-        debug("--- aimux session ended ---");
-        stream.end();
-        stream = null;
-    }
+    log.info("--- aimux session ended ---", "lifecycle");
 }
-//# sourceMappingURL=debug.js.map

package/dist/default-plugins/gh-pr-context.d.ts

@@ -1,8 +1,9 @@
 import type { AimuxPluginAPI, AimuxPluginInstance } from "../plugin-runtime.js";
+import { type RuntimeTopologySessionState } from "../runtime-core/topology-sessions.js";
 interface SessionTarget {
     id: string;
     worktreePath?: string;
 }
-export declare function collectGithubPrTargets(statusline: any, state: any, metadata: any): SessionTarget[];
+export declare function collectGithubPrTargets(statusline: any, state: any, metadata: any, topologySessions?: RuntimeTopologySessionState[]): SessionTarget[];
 export declare function createGithubPrContextPlugin(api: AimuxPluginAPI): AimuxPluginInstance;
 export {};

package/dist/default-plugins/gh-pr-context.js

@@ -3,6 +3,8 @@ import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { getProjectStateDirFor } from "../paths.js";
 import { writeJsonAtomic } from "../atomic-write.js";
+import { createRuntimeTopologyStore } from "../runtime-core/topology-store.js";
+import { listTopologySessionStates } from "../runtime-core/topology-sessions.js";
 const POLL_INTERVAL_MS = 60_000;
 const PR_CACHE_TTL_MS = 5 * 60_000;
 const PR_CACHE_PENDING_TTL_MS = 20_000;
@@ -104,21 +106,19 @@ async function resolveBranchPr(cwd, repo, branch) {
 function stableSerialize(value) {
     return JSON.stringify(value ?? null);
 }
-export function collectGithubPrTargets(statusline, state, metadata) {
+export function collectGithubPrTargets(statusline, state, metadata, topologySessions = []) {
     const targets = new Map();
-    for (const session of statusline?.sessions ?? []) {
-        const existingContext = metadata?.sessions?.[session.id]?.context ?? {};
-        targets.set(session.id, {
-            id: session.id,
-            worktreePath: session.worktreePath ?? existingContext.worktreePath ?? existingContext.cwd,
-        });
-    }
-    for (const session of state?.sessions ?? []) {
+    const statuslineById = new Map((statusline?.sessions ?? []).map((session) => [session.id, session]));
+    for (const session of topologySessions) {
         if (!targets.has(session.id)) {
+            const statuslineSession = statuslineById.get(session.id);
             const existingContext = metadata?.sessions?.[session.id]?.context ?? {};
             targets.set(session.id, {
                 id: session.id,
-                worktreePath: session.worktreePath ?? existingContext.worktreePath ?? existingContext.cwd,
+                worktreePath: session.worktreePath ??
+                    statuslineSession?.worktreePath ??
+                    existingContext.worktreePath ??
+                    existingContext.cwd,
             });
         }
     }
@@ -136,8 +136,10 @@ export function createGithubPrContextPlugin(api) {
     const projectStateDir = getProjectStateDirFor(api.projectRoot);
     const statuslinePath = join(projectStateDir, "statusline.json");
     const statePath = join(projectStateDir, "state.json");
+    const runtimeTopologyPath = join(projectStateDir, "runtime-topology.yaml");
     const metadataPath = join(projectStateDir, "metadata.json");
     const prCachePath = join(projectStateDir, "plugin-cache", "gh-pr-context.json");
+    const topologyStore = createRuntimeTopologyStore(runtimeTopologyPath);
     const prCache = new Map();
     const contextCache = new Map();
     const fileCache = new Map();
@@ -169,7 +171,11 @@ export function createGithubPrContextPlugin(api) {
         const statusline = loadCachedJson(statuslinePath);
         const state = loadCachedJson(statePath);
         const metadata = loadCachedJson(metadataPath);
-        return collectGithubPrTargets(statusline, state, metadata);
+        const topologySessions = listTopologySessionStates({
+            statuses: ["running", "idle", "offline"],
+            store: topologyStore,
+        });
+        return collectGithubPrTargets(statusline, state, metadata, topologySessions);
     }
     async function resolveCachedPr(repoRoot, cwd, repo, branch) {
         const cacheKey = `${repoRoot}::${branch ?? ""}`;
@@ -253,4 +259,3 @@ export function createGithubPrContextPlugin(api) {
         },
     };
 }
-//# sourceMappingURL=gh-pr-context.js.map

package/dist/default-plugins/transcript-length.js

@@ -1,8 +1,9 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { readHistory } from "../context/history.js";
 import { loadConfig } from "../config.js";
 import { getContextDir } from "../paths.js";
+import { loadMetadataState } from "../metadata-store.js";
 function formatBytes(bytes) {
     if (bytes < 1024)
         return `${bytes}b`;
@@ -34,8 +35,20 @@ function transcriptBytesSinceCheckpoint(sessionId) {
     const turns = readHistory(sessionId, lastTurnTs ? { since: lastTurnTs } : undefined).filter((turn) => !lastTurnTs || turn.ts > lastTurnTs);
     return turns.reduce((total, turn) => total + Buffer.byteLength(`${JSON.stringify(turn)}\n`), 0);
 }
+function externalTranscriptBytes(sessionId) {
+    const transcriptPath = loadMetadataState().sessions[sessionId]?.context?.transcriptPath;
+    if (!transcriptPath)
+        return undefined;
+    try {
+        const stat = statSync(transcriptPath);
+        return stat.isFile() ? stat.size : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function buildSegmentText(sessionId) {
-    const bytes = transcriptBytesSinceCheckpoint(sessionId);
+    const bytes = externalTranscriptBytes(sessionId) ?? transcriptBytesSinceCheckpoint(sessionId);
     return formatBytes(bytes);
 }
 export function createTranscriptLengthPlugin(api, options) {
@@ -91,4 +104,3 @@ export default function createConfiguredTranscriptLengthPlugin(api) {
         line: pluginConfig.line ?? "top",
     });
 }
-//# sourceMappingURL=transcript-length.js.map

package/dist/fast-control.js

@@ -32,12 +32,17 @@ export function resolveScopedWorktreePath(projectRoot, currentPath) {
     const match = worktrees.find((worktreePath) => fallback === worktreePath || fallback.startsWith(`${worktreePath}/`));
     return match ?? fallback;
 }
-function resolveContextWorktreePath(context, tmux, managedWindows) {
-    const byWindowId = context.currentWindowId
-        ? managedWindows.find((entry) => entry.target.windowId === context.currentWindowId)
-        : undefined;
-    if (byWindowId?.metadata.worktreePath) {
-        return pathResolve(byWindowId.metadata.worktreePath);
+function resolveContextWorktreePath(context, currentManagedWindow) {
+    if (currentManagedWindow?.metadata.worktreePath) {
+        return pathResolve(currentManagedWindow.metadata.worktreePath);
+    }
+    return resolveScopedWorktreePath(context.projectRoot, context.currentPath);
+}
+function resolveCurrentManagedWindow(context, tmux, managedWindows) {
+    if (context.currentWindowId) {
+        const byWindowId = managedWindows.find((entry) => entry.target.windowId === context.currentWindowId);
+        if (byWindowId)
+            return byWindowId;
     }
     const currentClientSession = context.currentClientSession?.trim();
     if (currentClientSession) {
@@ -46,12 +51,25 @@ function resolveContextWorktreePath(context, tmux, managedWindows) {
             .find((window) => window.active && !isDashboardWindowName(window.name));
         if (currentClientWindow) {
             const byActiveClientWindow = managedWindows.find((entry) => entry.target.windowId === currentClientWindow.id);
-            if (byActiveClientWindow?.metadata.worktreePath) {
-                return pathResolve(byActiveClientWindow.metadata.worktreePath);
-            }
+            if (byActiveClientWindow)
+                return byActiveClientWindow;
         }
     }
-    return resolveScopedWorktreePath(context.projectRoot, context.currentPath);
+    return managedWindows.find(({ target, metadata }) => target.windowName === context.currentWindow || metadata.label === context.currentWindow);
+}
+function compareSwitchableWindows(left, right, teammateParentSessionId) {
+    if (teammateParentSessionId) {
+        const leftOrder = typeof left.metadata.team?.order === "number" ? left.metadata.team.order : Number.POSITIVE_INFINITY;
+        const rightOrder = typeof right.metadata.team?.order === "number" ? right.metadata.team.order : Number.POSITIVE_INFINITY;
+        if (leftOrder !== rightOrder)
+            return leftOrder - rightOrder;
+        return left.target.windowIndex - right.target.windowIndex;
+    }
+    const kindRank = left.metadata.kind === "service" ? 1 : 0;
+    const otherKindRank = right.metadata.kind === "service" ? 1 : 0;
+    if (kindRank !== otherKindRank)
+        return kindRank - otherKindRank;
+    return left.target.windowIndex - right.target.windowIndex;
 }
 function urgencyFor(projectRoot, sessionId) {
     if (!sessionId)
@@ -70,21 +88,20 @@ export function listSwitchableAgentItems(context, tmux = new TmuxRuntimeManager(
     const tmuxSession = tmux.getProjectSession(context.projectRoot);
     const recentRankMap = getRecentRankMap(context.projectRoot, context.currentClientSession);
     const managedWindows = tmux.listManagedWindows(tmuxSession.sessionName);
-    const scopedWorktreePath = resolveContextWorktreePath(context, tmux, managedWindows);
+    const currentManagedWindow = resolveCurrentManagedWindow(context, tmux, managedWindows);
+    const teammateParentSessionId = currentManagedWindow?.metadata.team?.parentSessionId;
+    const scopedWorktreePath = resolveContextWorktreePath(context, currentManagedWindow);
     let managed = managedWindows
         .filter(({ target, metadata }) => {
         if (isDashboardWindowName(target.windowName))
             return false;
+        if (teammateParentSessionId) {
+            return metadata.kind !== "service" && metadata.team?.parentSessionId === teammateParentSessionId;
+        }
         const worktreePath = metadata.worktreePath || context.projectRoot;
-        return pathResolve(worktreePath) === scopedWorktreePath;
-    })
-        .sort((a, b) => {
-        const kindRank = a.metadata.kind === "service" ? 1 : 0;
-        const otherKindRank = b.metadata.kind === "service" ? 1 : 0;
-        if (kindRank !== otherKindRank)
-            return kindRank - otherKindRank;
-        return a.target.windowIndex - b.target.windowIndex;
+        return !metadata.team && pathResolve(worktreePath) === scopedWorktreePath;
     })
+        .sort((a, b) => compareSwitchableWindows(a, b, teammateParentSessionId))
         .map((entry) => ({
         ...entry,
         id: entry.metadata.sessionId,
@@ -92,6 +109,7 @@ export function listSwitchableAgentItems(context, tmux = new TmuxRuntimeManager(
             kind: entry.metadata.kind === "service" ? "service" : "agent",
             tool: entry.metadata.command || entry.target.windowName,
             label: entry.metadata.label,
+            launchCommandLine: entry.metadata.launchCommandLine,
             role: entry.metadata.role,
             id: entry.metadata.sessionId,
         }),
@@ -170,4 +188,3 @@ export function listSwitchableAgentMenuItems(context, tmux = new TmuxRuntimeMana
         return a.target.windowIndex - b.target.windowIndex;
     });
 }
-//# sourceMappingURL=fast-control.js.map

package/dist/hotkeys.js

@@ -118,4 +118,3 @@ export class HotkeyHandler {
         this.clearTimeout();
     }
 }
-//# sourceMappingURL=hotkeys.js.map

package/dist/http-client.js

@@ -1,7 +1,9 @@
 import http from "node:http";
 import https from "node:https";
+import { log } from "./debug.js";
 export async function requestJson(urlString, options = {}) {
     const url = new URL(urlString);
+    const logUrl = `${url.origin}${url.pathname}`;
     const transport = url.protocol === "https:" ? https : http;
     const bodyString = options.body === undefined
         ? undefined
@@ -19,8 +21,9 @@ export async function requestJson(urlString, options = {}) {
         headers["content-length"] = Buffer.byteLength(bodyString).toString();
     }
     return await new Promise((resolve, reject) => {
+        const method = options.method ?? (bodyString === undefined ? "GET" : "POST");
         const req = transport.request(url, {
-            method: options.method ?? (bodyString === undefined ? "GET" : "POST"),
+            method,
             headers,
             agent: false,
         }, (res) => {
@@ -33,17 +36,43 @@ export async function requestJson(urlString, options = {}) {
                     json = raw ? JSON.parse(raw) : {};
                 }
                 catch (error) {
+                    log.warn("http json parse failed", "http", {
+                        method,
+                        url: logUrl,
+                        status: res.statusCode ?? 0,
+                        bytes: Buffer.byteLength(raw),
+                        error: error instanceof Error ? error.message : String(error),
+                    });
                     reject(error);
                     return;
                 }
+                if ((res.statusCode ?? 0) >= 400) {
+                    log.warn("http request returned error status", "http", {
+                        method,
+                        url: logUrl,
+                        status: res.statusCode ?? 0,
+                    });
+                }
                 resolve({
                     status: res.statusCode ?? 0,
                     json,
                 });
             });
         });
-        req.on("error", reject);
+        req.on("error", (error) => {
+            log.warn("http request failed", "http", {
+                method,
+                url: logUrl,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            reject(error);
+        });
         req.setTimeout(options.timeoutMs ?? 0, () => {
+            log.warn("http request timed out", "http", {
+                method,
+                url: logUrl,
+                timeoutMs: options.timeoutMs ?? 0,
+            });
             req.destroy(new Error(`request timed out after ${options.timeoutMs ?? 0}ms`));
         });
         if (bodyString !== undefined) {
@@ -52,4 +81,3 @@ export async function requestJson(urlString, options = {}) {
         req.end();
     });
 }
-//# sourceMappingURL=http-client.js.map

package/dist/key-parser.js

@@ -276,4 +276,3 @@ export function matchKey(event, descriptor) {
         event.alt === wantAlt &&
         (event.name === key || event.char === key));
 }
-//# sourceMappingURL=key-parser.js.map

package/dist/last-used.js

@@ -90,4 +90,3 @@ function normalizeLastUsedState(state) {
 function pushRecentId(ids, itemId) {
     return [itemId, ...ids.filter((entry) => entry !== itemId)].slice(0, MAX_RECENT_IDS);
 }
-//# sourceMappingURL=last-used.js.map

package/dist/local-ui-server.d.ts

@@ -0,0 +1,22 @@
+export declare const DEFAULT_LOCAL_UI_HOST = "127.0.0.1";
+export declare const DEFAULT_LOCAL_UI_PORT = 43192;
+export interface LocalUiConfig {
+    connectionMode: "local";
+    daemonUrl: string;
+}
+export interface LocalUiServerOptions {
+    host?: string;
+    port?: number;
+    uiRoot?: string;
+    config: LocalUiConfig;
+}
+export interface LocalUiServerHandle {
+    host: string;
+    port: number;
+    url: string;
+    uiRoot: string;
+    close: () => Promise<void>;
+}
+export declare function resolveDefaultLocalUiRoot(): string;
+export declare function startLocalUiServer(options: LocalUiServerOptions): Promise<LocalUiServerHandle>;
+export declare function openUrlInBrowser(url: string): void;