@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/client/favicon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <rect width="512" height="512" fill="#edf4f1"/>
+  <rect x="110" y="100" width="290" height="310" rx="60" fill="#f3f8f5" stroke="#69aa9f" stroke-width="18"/>
+  <g fill="none" stroke="#28474d" stroke-width="19" stroke-linecap="round" stroke-linejoin="round"><polyline points="211,210 165,256 211,302"/><polyline points="251,315 302,315"/></g>
+  <g fill="#69aa9f"><circle cx="350" cy="185" r="12"/><circle cx="350" cy="256" r="12"/><circle cx="350" cy="327" r="12"/></g>
+</svg>

package/dist/client/index.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light" />
+    <meta name="description" content="A private, local reader for Codex sessions" />
+    <meta name="theme-color" content="#18262d" />
+    <meta name="apple-mobile-web-app-title" content="Agent Hub" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <link rel="icon" href="/favicon.ico" sizes="16x16 32x32 48x48 64x64" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" sizes="any" />
+    <link rel="apple-touch-icon" href="/apple-touch-icon.png" sizes="180x180" />
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <title>Agent Hub</title>
+    <script type="module" crossorigin src="/assets/index-CKKT4cMK.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-4ejyszaV.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/client/manifest.webmanifest

@@ -0,0 +1,21 @@
+{
+  "id": "/",
+  "name": "Agent Hub",
+  "short_name": "Agent Hub",
+  "description": "A private, local reader for Codex sessions",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#f7fafa",
+  "theme_color": "#18262d",
+  "icons": [
+    { "src": "/icons/icon-192.png", "sizes": "192x192", "type": "image/png", "purpose": "any" },
+    { "src": "/icons/icon-512.png", "sizes": "512x512", "type": "image/png", "purpose": "any" },
+    {
+      "src": "/icons/icon-maskable-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
+    }
+  ]
+}

package/dist/server/server/adapters/claude/claude-session-source.js

@@ -0,0 +1,220 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { sessionTitleFromMarkdown } from "../../domain/session-text.js";
+import { isExpectedIoError as expectedIo } from "../shared/io-errors.js";
+import { CheckpointedJsonlDecoder } from "../shared/jsonl-decoder.js";
+import { MAX_SESSION_DIAGNOSTICS } from "../shared/limits.js";
+import { acceptedPathOrder, mutableTelemetry, sameFingerprint, } from "../shared/source-cache.js";
+import { claudeInteraction, claudeRecordBindings, validClaudeId } from "./interaction.js";
+import { appendClaudeRecords, claudeDecoderDiagnostics, createClaudeState, } from "./session-normalizer.js";
+export class ClaudeSessionSource {
+    directory;
+    descriptor;
+    #decoder = new CheckpointedJsonlDecoder();
+    #snapshot = null;
+    #telemetry = mutableTelemetry();
+    lastRefreshTelemetry() {
+        return { ...this.#telemetry };
+    }
+    #cache = new Map();
+    #rejected = new Map();
+    constructor(directory, instanceKey, { agent = "claude" } = {}) {
+        this.directory = directory;
+        this.descriptor = {
+            sourceType: "claude-jsonl",
+            instanceKey,
+            agent,
+            displayName: "Claude Code",
+        };
+    }
+    async refresh() {
+        const diagnostics = [];
+        const bindings = [];
+        this.#telemetry = mutableTelemetry();
+        const warn = (...items) => {
+            diagnostics.push(...items.slice(0, Math.max(0, MAX_SESSION_DIAGNOSTICS - diagnostics.length)));
+        };
+        const next = new Map();
+        const rejected = new Map();
+        const seen = new Set();
+        const projects = join(this.directory, "projects");
+        try {
+            const candidates = await discoverClaudeFiles(projects, warn);
+            candidates.sort((a, b) => acceptedPathOrder(this.#cache, relative(this.directory, a.path), relative(this.directory, b.path)));
+            for (const { path, nativeId } of candidates) {
+                if (seen.has(nativeId)) {
+                    warn({
+                        code: "duplicate_native_session_id",
+                        severity: "warning",
+                        message: "Duplicate Claude session file ignored",
+                        ordinal: null,
+                    });
+                    continue;
+                }
+                const key = relative(this.directory, path);
+                const old = this.#cache.get(key) ?? this.#rejected.get(key);
+                let decoded;
+                let fingerprint;
+                try {
+                    const info = await stat(path);
+                    fingerprint = { sourceRelativePath: key, size: info.size, mtimeMs: info.mtimeMs };
+                    if (old && sameFingerprint(old.fingerprint, fingerprint)) {
+                        if (old.entry !== undefined) {
+                            next.set(key, old);
+                            seen.add(nativeId);
+                        }
+                        else {
+                            rejected.set(key, old);
+                            warn(...old.state.diagnostics);
+                        }
+                        continue;
+                    }
+                    const started = performance.now();
+                    decoded = await this.#decoder.decode({ path }, old?.checkpoint);
+                    this.#telemetry.decodeMs += performance.now() - started;
+                    this.#telemetry[decoded.mode === "append" ? "appendFiles" : "fullFiles"]++;
+                    this.#telemetry.probeBytes += decoded.telemetry.probeBytes;
+                    this.#telemetry.decodeBytes += decoded.telemetry.decodeBytes;
+                }
+                catch (error) {
+                    if (!expectedIo(error))
+                        throw error;
+                    warn({
+                        code: "session_unavailable",
+                        severity: "warning",
+                        message: "Claude session could not be read",
+                        ordinal: null,
+                    });
+                    continue;
+                }
+                const append = decoded.mode === "append" && !!old;
+                const base = append ? old.state : createClaudeState(nativeId);
+                const started = performance.now();
+                const bindingEvents = decoded.records.flatMap(claudeRecordBindings);
+                const state = appendClaudeRecords(base, decoded.records, claudeDecoderDiagnostics(decoded.diagnostics), bindingEvents);
+                this.#telemetry.normalizeMs += performance.now() - started;
+                if (state.identityConflict) {
+                    warn(...state.diagnostics);
+                    rejected.set(key, { fingerprint, checkpoint: decoded.checkpoint, state });
+                    continue;
+                }
+                const entry = old?.entry !== undefined && old.state === state
+                    ? old.entry
+                    : materializeClaudeSession(state, nativeId, this.descriptor);
+                const localId = entry.localId;
+                next.set(key, {
+                    fingerprint,
+                    checkpoint: decoded.checkpoint,
+                    state,
+                    entry,
+                });
+                seen.add(nativeId);
+                bindings.push(...bindingEvents.map((event) => ({ ...event, localId })));
+            }
+        }
+        catch (error) {
+            if (!expectedIo(error))
+                throw error;
+            if (error.code !== "ENOENT")
+                warn({
+                    code: "source_unavailable",
+                    severity: "warning",
+                    message: "Claude projects directory could not be read",
+                    ordinal: null,
+                });
+        }
+        this.#cache = next;
+        this.#rejected = rejected;
+        const sessions = [...next.values()].map((cached) => cached.entry);
+        const snapshot = {
+            bindings,
+            sessions,
+            diagnostics,
+            signature: JSON.stringify([
+                [...next].map(([path, cached]) => [path, cached.fingerprint, cached.checkpoint]),
+                diagnostics,
+            ]),
+        };
+        if (this.#snapshot?.signature === snapshot.signature)
+            return this.#snapshot;
+        this.#snapshot = snapshot;
+        return snapshot;
+    }
+}
+export async function createClaudeSessionSource(configDirectory, options = {}) {
+    const directory = resolve(configDirectory);
+    return new ClaudeSessionSource(directory, `claude-jsonl\0${directory}`, options);
+}
+async function discoverClaudeFiles(projects, warn) {
+    const candidates = [];
+    for (const project of (await readdir(projects, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!project.isDirectory())
+            continue;
+        let files;
+        try {
+            files = await readdir(join(projects, project.name), { withFileTypes: true });
+        }
+        catch (error) {
+            if (!expectedIo(error))
+                throw error;
+            warn({
+                code: "project_unavailable",
+                severity: "warning",
+                message: "Claude project directory could not be read",
+                ordinal: null,
+            });
+            continue;
+        }
+        for (const file of files.sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!file.isFile() || !file.name.endsWith(".jsonl"))
+                continue;
+            const nativeId = file.name.slice(0, -6);
+            if (!validClaudeId(nativeId))
+                continue;
+            candidates.push({ path: join(projects, project.name, file.name), nativeId });
+        }
+    }
+    return candidates;
+}
+function materializeClaudeSession(state, nativeId, descriptor) {
+    const projectDirectory = state.project ?? state.firstCwd;
+    const origin = {
+        sourceType: descriptor.sourceType,
+        agent: descriptor.agent,
+        runtimeName: descriptor.displayName,
+        runtimeVersion: state.version,
+    };
+    const localId = `thread:${nativeId}`;
+    const normalized = {
+        session: {
+            id: localId,
+            sourceId: nativeId,
+            origin,
+            title: state.customTitle ??
+                state.aiTitle ??
+                (state.firstUser ? sessionTitleFromMarkdown(state.firstUser) : null) ??
+                "Untitled session",
+            workingDirectory: state.cwd,
+            projectDirectory,
+            taskName: state.taskName,
+            createdAt: state.createdAt,
+            updatedAt: state.updatedAt,
+            archived: false,
+            parentId: null,
+            childIds: [],
+            subagent: null,
+            warningCount: state.diagnostics.length,
+            diagnostics: state.diagnostics,
+        },
+        timeline: state.timeline,
+        interaction: claudeInteraction(projectDirectory, state.taskName),
+    };
+    return {
+        localId,
+        nativeSessionId: nativeId,
+        parentNativeSessionId: null,
+        origin,
+        normalized,
+    };
+}
+//# sourceMappingURL=claude-session-source.js.map

package/dist/server/server/adapters/claude/identity.js

@@ -0,0 +1,28 @@
+import { validProjectDirectory } from "../../domain/project-directory.js";
+const string = (value) => (typeof value === "string" ? value : null);
+/** Native identity and directory/version/time evidence is accumulated separately from content. */
+export function appendClaudeIdentity(state, row, ordinal, retainDiagnostic) {
+    const identities = [string(row.sessionId), string(row.session_id)].filter(Boolean);
+    if (identities.some((identity) => identity !== state.nativeId)) {
+        state.identityConflict = true;
+        retainDiagnostic({
+            code: "conflicting_native_session_id",
+            severity: "warning",
+            message: "Claude record identity conflicts with its session file",
+            ordinal: ordinal,
+        });
+        return false;
+    }
+    const timestamp = string(row.timestamp);
+    if (timestamp && Number.isFinite(Date.parse(timestamp))) {
+        state.createdAt ??= timestamp;
+        state.updatedAt = timestamp;
+    }
+    if (validProjectDirectory(row.cwd)) {
+        state.firstCwd ??= row.cwd;
+        state.cwd = row.cwd;
+    }
+    state.version = string(row.version) ?? state.version;
+    return true;
+}
+//# sourceMappingURL=identity.js.map

package/dist/server/server/adapters/claude/interaction.js

@@ -0,0 +1,68 @@
+import { validTaskName } from "../../../shared/task-name.js";
+import { validProjectDirectory } from "../../domain/project-directory.js";
+import { shellQuote } from "../../interaction/tmux-launcher.js";
+import { bindingAttempts } from "../shared/binding-protocol.js";
+import { DEFAULT_KEY_BINDINGS, interruptSteps } from "../shared/session-management.js";
+export const validClaudeId = (id) => /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(id);
+export function claudeBindingCommand(operationId = "", projectDirectory, taskName = null) {
+    if (operationId && !validClaudeId(operationId))
+        throw new Error("Invalid operation ID");
+    if (taskName !== null && !validTaskName(taskName))
+        throw new Error("Invalid task name");
+    // Claude worktree isolation rejects tmux commands; the launcher supplies its known name.
+    return `! printf 'AHUB_TMUX_BIND_V3\\n%s\\n%s\\n%s\\n%s\\n%s\\n' "\${TMUX%%,*}" "$AHUB_TMUX_SESSION_NAME" ${shellQuote(operationId)} ${shellQuote(validProjectDirectory(projectDirectory) ? projectDirectory : "")} ${shellQuote(JSON.stringify(taskName))}`;
+}
+/** Only call with the main user record's native bash stdout wrapper. */
+export function claudeBindingAttempts(text, ordinal) {
+    const found = [];
+    for (const match of text.matchAll(/<bash-stdout>([\s\S]*?)<\/bash-stdout>/g)) {
+        const lines = match[1].replace(/\r\n?/g, "\n").split("\n");
+        found.push(...bindingAttempts(lines, ordinal, validClaudeId));
+    }
+    return found;
+}
+export function claudeInteraction(projectDirectory, taskName) {
+    return {
+        transport: "tmux",
+        bindingCommand: claudeBindingCommand("", projectDirectory, taskName),
+        interruptSteps,
+        keyBindings: DEFAULT_KEY_BINDINGS,
+    };
+}
+/** Only native main-session user shell wrappers can supply binding evidence. */
+export function claudeRecordBindings(record) {
+    const row = record.value;
+    if (row.type !== "user" ||
+        row.isSidechain === true ||
+        row.parent_tool_use_id != null ||
+        row.isMeta === true ||
+        row.isCompactSummary === true ||
+        row.subtype === "subagent")
+        return [];
+    const message = row.message;
+    if (!message ||
+        typeof message !== "object" ||
+        !("role" in message) ||
+        message.role !== "user" ||
+        !("content" in message))
+        return [];
+    const content = typeof message.content === "string"
+        ? [{ type: "text", text: message.content }]
+        : message.content;
+    if (!Array.isArray(content))
+        return [];
+    const attempts = content.flatMap((block) => block &&
+        block.type === "text" &&
+        typeof block.text === "string" &&
+        /^\s*<bash-(?:input|stdout|stderr)>/.test(block.text)
+        ? claudeBindingAttempts(block.text, record.ordinal)
+        : []);
+    const time = typeof row.timestamp === "string" ? Date.parse(row.timestamp) : NaN;
+    return attempts.map((attempt, position) => ({
+        time: Number.isFinite(time) ? time : 0,
+        ordinal: record.ordinal,
+        position,
+        attempt,
+    }));
+}
+//# sourceMappingURL=interaction.js.map

package/dist/server/server/adapters/claude/prompt-readiness.js

@@ -0,0 +1,12 @@
+/** Allow cursor drift within columns 1–5 and two rows of the prompt. */
+export function claudePromptPosition(snapshot) {
+    if (!snapshot || snapshot.cursorX < 1 || snapshot.cursorX > 5)
+        return null;
+    const lines = snapshot.content.split("\n");
+    for (let row = Math.max(0, snapshot.cursorY - 2); row <= snapshot.cursorY + 2; row++) {
+        if (/^❯[^\S\r\n\u2028\u2029]*$/u.test(lines[row] ?? ""))
+            return row;
+    }
+    return null;
+}
+//# sourceMappingURL=prompt-readiness.js.map

package/dist/server/server/adapters/claude/ready-script.js

@@ -0,0 +1,25 @@
+import { execFile } from "node:child_process";
+/** Context is opaque text scoped to a single launch attempt. */
+export async function checkClaudeReadyScript(script, current, context, timeout) {
+    const stdout = await new Promise((resolve, reject) => {
+        const child = execFile(script, [], { timeout: Math.max(1, timeout), maxBuffer: 1024 * 1024, killSignal: "SIGKILL" }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+        child.stdin?.on("error", reject);
+        child.stdin?.end(JSON.stringify({ current, context }));
+    });
+    const result = JSON.parse(stdout);
+    if (!result ||
+        typeof result !== "object" ||
+        !("ready" in result) ||
+        typeof result.ready !== "boolean" ||
+        !("context" in result) ||
+        typeof result.context !== "string") {
+        throw new Error("Claude readiness script must return { ready: boolean, context: string }");
+    }
+    return { ready: result.ready, context: result.context };
+}
+//# sourceMappingURL=ready-script.js.map

package/dist/server/server/adapters/claude/session-manager.js

@@ -0,0 +1,106 @@
+import { lstat, readdir, rm, rmdir } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { attachCommand, TmuxLauncher } from "../../interaction/tmux-launcher.js";
+import { SessionLaunchError, } from "../../management/session-manager.js";
+import { exitSteps, resolveDirectory } from "../shared/session-management.js";
+import { claudeBindingCommand, validClaudeId } from "./interaction.js";
+import { claudePromptPosition } from "./prompt-readiness.js";
+import { checkClaudeReadyScript } from "./ready-script.js";
+/** Never deliver bootstrap input unless the native prompt is confirmed ready. */
+export const BINDING_PROMPT_WAIT_MS = 15_000;
+export class ClaudeSessionManager {
+    configDirectory;
+    tmux;
+    readyScript;
+    constructor(configDirectory, tmux = new TmuxLauncher(), readyScript) {
+        this.configDirectory = configDirectory;
+        this.tmux = tmux;
+        this.readyScript = readyScript;
+    }
+    interruptAfterBinding = true;
+    isValidNativeId = validClaudeId;
+    resolveDirectory = resolveDirectory;
+    async launch(options) {
+        if (options.resumeNativeId !== undefined && !this.isValidNativeId(options.resumeNativeId))
+            throw new Error("Invalid resume identity");
+        const target = await this.tmux.launch(options.operationId, options.workingDirectory, [
+            "env",
+            `CLAUDE_CONFIG_DIR=${this.configDirectory}`,
+            "claude",
+            ...(options.resumeNativeId ? ["--resume", options.resumeNativeId] : []),
+            ...(options.worktree ? ["--worktree"] : []),
+            ...(options.yolo ? ["--dangerously-skip-permissions"] : []),
+        ]);
+        try {
+            const deadline = Date.now() + BINDING_PROMPT_WAIT_MS;
+            let context = "";
+            let ready = false;
+            while (Date.now() < deadline) {
+                const snapshot = await this.tmux.transport.captureTerminalWithCursor(target);
+                if (Date.now() >= deadline)
+                    break;
+                if (snapshot) {
+                    const result = this.readyScript
+                        ? await checkClaudeReadyScript(this.readyScript, snapshot, context, deadline - Date.now())
+                        : { ready: claudePromptPosition(snapshot) !== null, context: "" };
+                    if (Date.now() >= deadline)
+                        break;
+                    context = result.context;
+                    if (result.ready) {
+                        ready = true;
+                        break;
+                    }
+                }
+                await delay(Math.min(1_000, Math.max(0, deadline - Date.now())));
+            }
+            if (!ready)
+                throw new Error("Claude Code prompt readiness was not confirmed before timeout. Attach to tmux to check the session.");
+            await this.tmux.transport.sendMessage(target, claudeBindingCommand(options.operationId, options.projectDirectory, options.taskName ?? null));
+            return target;
+        }
+        catch (error) {
+            throw new SessionLaunchError("unknown", error instanceof Error ? error.message : String(error), attachCommand(target.socketPath, `ahub-${options.operationId}`), target);
+        }
+    }
+    async delete(nativeId) {
+        if (!this.isValidNativeId(nativeId))
+            throw new Error("Invalid Claude session identity");
+        const projects = join(this.configDirectory, "projects");
+        let entries;
+        try {
+            entries = await readdir(projects, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        for (const project of entries) {
+            if (!project.isDirectory())
+                continue;
+            const directory = join(projects, project.name);
+            const session = join(directory, nativeId);
+            try {
+                if ((await lstat(session)).isDirectory()) {
+                    await rm(join(session, "subagents"), { recursive: true, force: true });
+                    try {
+                        await rmdir(session);
+                    }
+                    catch (error) {
+                        if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? ""))
+                            throw error;
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            await rm(join(directory, `${nativeId}.jsonl`), { force: true });
+        }
+    }
+    exitSteps = exitSteps;
+}
+export const createClaudeSessionManager = (configDirectory, socket, readyScript) => new ClaudeSessionManager(configDirectory, new TmuxLauncher(socket), readyScript);
+//# sourceMappingURL=session-manager.js.map