@holon-run/agentinbox 0.1.0

package/dist/src/terminal.js

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalDispatcher = void 0;
+exports.detectTerminalContext = detectTerminalContext;
+exports.renderAgentPrompt = renderAgentPrompt;
+exports.assignedAgentIdFromContext = assignedAgentIdFromContext;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function detectTerminalContext(env = process.env) {
+    const tmuxPaneId = normalizeOptionalString(env.TMUX_PANE);
+    const termProgram = normalizeOptionalString(env.TERM_PROGRAM);
+    const tty = detectTty(env);
+    const itermSessionId = normalizeItermSessionId(env.ITERM_SESSION_ID ?? env.TERM_SESSION_ID);
+    const runtime = detectRuntimeContext(env);
+    if (tmuxPaneId) {
+        return {
+            runtimeKind: runtime.runtimeKind,
+            runtimeSessionId: runtime.runtimeSessionId,
+            backend: "tmux",
+            tmuxPaneId,
+            tty,
+            termProgram,
+            itermSessionId,
+        };
+    }
+    if (itermSessionId || termProgram === "iTerm.app") {
+        return {
+            runtimeKind: runtime.runtimeKind,
+            runtimeSessionId: runtime.runtimeSessionId,
+            backend: "iterm2",
+            tty,
+            termProgram,
+            itermSessionId,
+        };
+    }
+    throw new Error("unable to detect a supported terminal context");
+}
+function renderAgentPrompt(input) {
+    const base = `AgentInbox: ${input.newItemCount} new items arrived in inbox ${input.inboxId}.`;
+    if (input.summary) {
+        return `${base} Summary: ${input.summary}. Please read the inbox, process them, and ack when finished.`;
+    }
+    return `${base} Please read the inbox, process them, and ack when finished.`;
+}
+function assignedAgentIdFromContext(input) {
+    const primary = normalizeOptionalString(input.runtimeSessionId)
+        ?? normalizeOptionalString(input.tmuxPaneId)
+        ?? normalizeOptionalString(input.itermSessionId)
+        ?? normalizeOptionalString(input.tty);
+    if (!primary) {
+        throw new Error("unable to derive agentId from terminal context");
+    }
+    const normalized = primary.replace(/[^a-zA-Z0-9]+/g, "").toLowerCase();
+    if (normalized.length > 0) {
+        return `agent_${input.runtimeKind ?? "unknown"}_${normalized.slice(0, 40)}`;
+    }
+    const digest = node_crypto_1.default.createHash("sha256").update(primary).digest("hex").slice(0, 16);
+    return `agent_${input.runtimeKind ?? "unknown"}_${digest}`;
+}
+class TerminalDispatcher {
+    execAsync;
+    options;
+    constructor(execAsync = execFileAsync, options = {}) {
+        this.execAsync = execAsync;
+        this.options = options;
+    }
+    async dispatch(target, prompt) {
+        if (target.backend === "tmux") {
+            if (!target.tmuxPaneId) {
+                throw new Error(`tmux terminal target ${target.targetId} is missing tmuxPaneId`);
+            }
+            await this.execAsync("tmux", ["send-keys", "-t", target.tmuxPaneId, prompt, "Enter"]);
+            return;
+        }
+        if (target.backend === "iterm2") {
+            await dispatchToIterm2(target, prompt, this.execAsync, this.options.iterm2ApiPath);
+            return;
+        }
+        throw new Error(`unsupported terminal backend: ${String(target.backend)}`);
+    }
+    async probe(target) {
+        try {
+            if (target.backend === "tmux") {
+                if (!target.tmuxPaneId) {
+                    return false;
+                }
+                const result = await this.execAsync("tmux", ["display-message", "-p", "-t", target.tmuxPaneId, "#{pane_id}"]);
+                return result.stdout.trim() === target.tmuxPaneId;
+            }
+            if (target.backend === "iterm2") {
+                const sessionId = normalizeOptionalString(target.itermSessionId);
+                if (!sessionId) {
+                    return false;
+                }
+                const it2api = resolveIterm2ApiPath(this.options.iterm2ApiPath);
+                const result = await this.execAsync(it2api, ["list-sessions"]);
+                return result.stdout.includes(sessionId);
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+}
+exports.TerminalDispatcher = TerminalDispatcher;
+function detectTty(env) {
+    const direct = tryReadCurrentTty();
+    if (direct) {
+        return direct;
+    }
+    const parent = tryReadParentTty(env.PPID);
+    return parent;
+}
+function tryReadCurrentTty() {
+    try {
+        const tty = (0, node_child_process_1.execFileSync)("tty", [], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        if (!tty || tty === "not a tty") {
+            return null;
+        }
+        return tty;
+    }
+    catch {
+        return null;
+    }
+}
+function tryReadParentTty(ppid) {
+    if (!ppid) {
+        return null;
+    }
+    try {
+        const tty = (0, node_child_process_1.execFileSync)("ps", ["-o", "tty=", "-p", ppid], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (!tty || tty === "??") {
+            return null;
+        }
+        return tty.startsWith("/dev/") ? tty : `/dev/${tty}`;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeItermSessionId(raw) {
+    const value = normalizeOptionalString(raw);
+    if (!value) {
+        return null;
+    }
+    const parts = value.split(":");
+    return parts[parts.length - 1] || null;
+}
+function detectRuntimeContext(env) {
+    const codexThreadId = normalizeOptionalString(env.CODEX_THREAD_ID);
+    if (codexThreadId) {
+        return {
+            runtimeKind: "codex",
+            runtimeSessionId: codexThreadId,
+        };
+    }
+    const claudeSessionId = normalizeOptionalString(env.CLAUDE_CODE_SESSION_ID
+        ?? env.CLAUDECODE_SESSION_ID
+        ?? env.CLAUDE_SESSION_ID);
+    if (claudeSessionId) {
+        return {
+            runtimeKind: "claude_code",
+            runtimeSessionId: claudeSessionId,
+        };
+    }
+    // Fallback: try to detect Claude Code from filesystem
+    const claudeCodeFromFs = detectClaudeCodeFromFileSystem(env);
+    if (claudeCodeFromFs) {
+        return claudeCodeFromFs;
+    }
+    return {
+        runtimeKind: "unknown",
+        runtimeSessionId: null,
+    };
+}
+function detectClaudeCodeFromFileSystem(env) {
+    try {
+        // Walk up the process tree to find a claude process
+        const claudePid = findClaudeProcessInAncestry();
+        if (!claudePid) {
+            return null;
+        }
+        // Read Claude Code session file
+        const sessionFile = node_path_1.default.join(node_os_1.default.homedir(), ".claude", "sessions", `${String(claudePid)}.json`);
+        if (!node_fs_1.default.existsSync(sessionFile)) {
+            return null;
+        }
+        const sessionContent = node_fs_1.default.readFileSync(sessionFile, "utf8");
+        const sessionData = JSON.parse(sessionContent);
+        // Validate session data structure
+        if (!sessionData.sessionId || typeof sessionData.sessionId !== "string") {
+            return null;
+        }
+        // Verify this session matches current working directory
+        // This helps avoid picking up wrong claude sessions
+        if (sessionData.cwd) {
+            const currentProject = node_path_1.default.basename(process.cwd());
+            const sessionProject = node_path_1.default.basename(sessionData.cwd);
+            if (currentProject !== sessionProject) {
+                return null;
+            }
+        }
+        return {
+            runtimeKind: "claude_code",
+            runtimeSessionId: sessionData.sessionId,
+        };
+    }
+    catch {
+        // Silently fail if filesystem detection fails
+        return null;
+    }
+}
+function findClaudeProcessInAncestry() {
+    let currentPid = process.ppid;
+    const maxIterations = 10; // Prevent infinite loops
+    let iterations = 0;
+    while (currentPid && iterations < maxIterations) {
+        const processName = tryGetProcessName(currentPid);
+        if (processName?.includes("claude")) {
+            return currentPid;
+        }
+        // Get parent of current process
+        const parentPid = tryGetParentPid(currentPid);
+        if (!parentPid) {
+            break;
+        }
+        currentPid = parentPid;
+        iterations++;
+    }
+    return null;
+}
+function tryGetParentPid(pid) {
+    try {
+        const output = (0, node_child_process_1.execFileSync)("ps", ["-p", String(pid), "-o", "ppid="], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const ppid = parseInt(output.trim(), 10);
+        return isNaN(ppid) || ppid === 0 ? null : ppid;
+    }
+    catch {
+        return null;
+    }
+}
+function tryGetProcessName(pid) {
+    try {
+        const output = (0, node_child_process_1.execFileSync)("ps", ["-p", String(pid), "-o", "comm="], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return output.trim();
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeOptionalString(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+async function dispatchToIterm2(target, prompt, execAsync, iterm2ApiPath) {
+    const sessionId = normalizeOptionalString(target.itermSessionId);
+    if (!sessionId) {
+        throw new Error(`iTerm2 terminal target ${target.targetId} is missing itermSessionId`);
+    }
+    const it2api = resolveIterm2ApiPath(iterm2ApiPath);
+    await execAsync(it2api, ["send-text", sessionId, prompt]);
+    // Background Codex/Claude sessions only submit reliably when Return is sent
+    // in a second call rather than concatenated to the original prompt payload.
+    await execAsync(it2api, ["send-text", sessionId, "\r"]);
+}
+function resolveIterm2ApiPath(override) {
+    if (override) {
+        return override;
+    }
+    const candidates = [
+        "/Applications/iTerm.app/Contents/Resources/it2api",
+        "/Applications/iTerm.app/Contents/Resources/utilities/it2api",
+    ];
+    for (const candidate of candidates) {
+        if (node_fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("unable to locate iTerm2 it2api helper");
+}

package/dist/src/util.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowIso = nowIso;
+exports.generateId = generateId;
+exports.parseJsonArg = parseJsonArg;
+exports.asObject = asObject;
+exports.jsonResponse = jsonResponse;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function nowIso() {
+    return new Date().toISOString();
+}
+function generateId(prefix) {
+    return `${prefix}_${node_crypto_1.default.randomUUID()}`;
+}
+function parseJsonArg(raw) {
+    if (!raw) {
+        return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("expected a JSON object");
+    }
+    return parsed;
+}
+function asObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function jsonResponse(data) {
+    return JSON.stringify(data, null, 2);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@holon-run/agentinbox",
+  "version": "0.1.0",
+  "description": "Local event subscription and delivery service for agents.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/holon-run/agentinbox.git"
+  },
+  "homepage": "https://agentinbox.holon.run",
+  "bugs": {
+    "url": "https://github.com/holon-run/agentinbox/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "agentinbox": "dist/src/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "node --watch --loader ts-node/esm src/cli.ts",
+    "docs:dev": "mdorigin dev --root docs/site",
+    "docs:search": "mdorigin build search --root docs/site",
+    "docs:index": "mdorigin build index --root docs/site",
+    "docs:build": "npm run docs:search && mdorigin build cloudflare --root docs/site --search dist/search",
+    "docs:build:cloudflare": "npm run docs:build",
+    "docs:deploy": "npm run docs:index && npm run docs:build && npx wrangler@4 deploy --config wrangler.jsonc",
+    "prepack": "npm run build",
+    "test": "node --require ts-node/register --test test/*.test.ts"
+  },
+  "dependencies": {
+    "@holon-run/uxc-daemon-client": "^0.13.3",
+    "jexl": "^2.3.0",
+    "sql.js": "^1.13.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "@types/sql.js": "^1.4.9",
+    "mdorigin": "^0.5.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2"
+  }
+}