aimux-cli 0.1.16 → 0.1.19

package/dist/remote-access.js

@@ -0,0 +1,90 @@
+const ACTOR_HEADER = "x-aimux-actor";
+const ROLE_HEADER = "x-aimux-actor-role";
+const USER_ID_HEADER = "x-aimux-actor-user-id";
+const DISPLAY_NAME_HEADER = "x-aimux-actor-display-name";
+const EMAIL_HEADER = "x-aimux-actor-email";
+const SHARE_ID_HEADER = "x-aimux-share-id";
+const SHARE_SESSION_ID_HEADER = "x-aimux-share-session-id";
+const RELAY_HEADER_PREFIX = "x-aimux-";
+function headerValue(headers, name) {
+    if (!headers)
+        return undefined;
+    const direct = headers[name];
+    if (typeof direct === "string")
+        return direct.trim() || undefined;
+    const lowerName = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === lowerName)
+            return value.trim() || undefined;
+    }
+    return undefined;
+}
+function hasRelayActorHeaders(headers) {
+    if (!headers)
+        return false;
+    return Object.keys(headers).some((key) => key.toLowerCase().startsWith(RELAY_HEADER_PREFIX));
+}
+function actorFromJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const record = parsed;
+        return {
+            role: record.role === "owner" || record.role === "guest" ? record.role : undefined,
+            userId: typeof record.userId === "string" ? record.userId : undefined,
+            displayName: typeof record.displayName === "string" ? record.displayName : undefined,
+            email: typeof record.email === "string" ? record.email : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function parseRemoteActor(headers) {
+    const actorJson = headerValue(headers, ACTOR_HEADER);
+    const jsonActor = actorJson ? actorFromJson(actorJson) : null;
+    const role = headerValue(headers, ROLE_HEADER) ?? jsonActor?.role;
+    if (!role) {
+        return hasRelayActorHeaders(headers) ? { role: "guest" } : null;
+    }
+    if (role !== "owner" && role !== "guest") {
+        return { role: "guest" };
+    }
+    return {
+        role,
+        userId: headerValue(headers, USER_ID_HEADER) ?? jsonActor?.userId,
+        displayName: headerValue(headers, DISPLAY_NAME_HEADER) ?? jsonActor?.displayName,
+        email: headerValue(headers, EMAIL_HEADER) ?? jsonActor?.email,
+        shareId: headerValue(headers, SHARE_ID_HEADER),
+        shareSessionId: headerValue(headers, SHARE_SESSION_ID_HEADER),
+    };
+}
+export function assertRemoteAccessAllowed(actor, method, pathname, searchParams) {
+    if (!actor || actor.role === "owner")
+        return { ok: true };
+    if (actor.role !== "guest")
+        return { ok: false, status: 403, error: "remote actor role is not allowed" };
+    if (method !== "GET")
+        return { ok: false, status: 403, error: "shared guests are read-only" };
+    if (pathname === "/health")
+        return { ok: true };
+    const proxyMatch = pathname.match(/^\/proxy\/[^/]+\/\d+(\/.*)$/);
+    if (!proxyMatch)
+        return { ok: false, status: 403, error: "shared guests cannot access daemon routes" };
+    const subPath = proxyMatch[1] || "/";
+    if (subPath === "/agents/output" || subPath === "/agents/history" || subPath === "/events") {
+        if (!actor.shareSessionId) {
+            return { ok: false, status: 403, error: "shared guest route requires an authorized share session" };
+        }
+        const requestedSessionId = searchParams.get("sessionId");
+        if (!requestedSessionId) {
+            return { ok: false, status: 403, error: "shared session route requires a session id" };
+        }
+        if (requestedSessionId !== actor.shareSessionId) {
+            return { ok: false, status: 403, error: "shared guest cannot access another session" };
+        }
+        return { ok: true };
+    }
+    return { ok: false, status: 403, error: "shared guests can only read shared session output" };
+}

package/dist/runtime-core/exchange-derived.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeExchange } from "./exchange-store.js";
+export declare function deriveRuntimeExchangeIndexes(exchange: RuntimeExchange): RuntimeExchange;

package/dist/runtime-core/exchange-derived.js

@@ -0,0 +1,153 @@
+function unique(values) {
+    return [...new Set(values.map((value) => value?.trim()).filter(Boolean))];
+}
+function handoffActionFromMessages(messages) {
+    const lifecycleMessage = [...messages]
+        .reverse()
+        .find((message) => message.metadata?.handoffAction === "accepted" || message.metadata?.handoffAction === "completed");
+    return {
+        action: lifecycleMessage?.metadata?.handoffAction,
+        actor: lifecycleMessage?.from,
+    };
+}
+function handoffFromThread(thread, messages) {
+    if (thread.kind !== "handoff")
+        return undefined;
+    const recipients = unique(thread.waitingOn?.length ? thread.waitingOn : thread.participants.filter((id) => id !== thread.createdBy));
+    if (recipients.length === 0)
+        return undefined;
+    const lifecycle = handoffActionFromMessages(messages);
+    const status = lifecycle.action === "completed"
+        ? "completed"
+        : lifecycle.action === "accepted"
+            ? "accepted"
+            : thread.status === "done"
+                ? "completed"
+                : thread.status === "abandoned"
+                    ? "cancelled"
+                    : "waiting";
+    return {
+        id: `handoff:${thread.id}`,
+        threadId: thread.id,
+        status,
+        from: thread.createdBy,
+        to: recipients,
+        acceptedBy: lifecycle.action === "accepted" ? lifecycle.actor : thread.status === "open" ? thread.owner : undefined,
+        completedBy: lifecycle.action === "completed" ? lifecycle.actor : thread.status === "done" ? thread.owner : undefined,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+    };
+}
+function reviewFromTask(task) {
+    if (task.type !== "review")
+        return undefined;
+    return {
+        id: `review:${task.id}`,
+        taskId: task.id,
+        reviewOf: task.reviewOf,
+        reviewer: task.assignedTo ?? task.assignee,
+        status: task.reviewStatus ?? "pending",
+        feedback: task.reviewFeedback ?? task.result,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+    };
+}
+function waitsFromThread(thread) {
+    const waitingOn = unique(thread.waitingOn ?? []);
+    if (waitingOn.length === 0)
+        return [];
+    return [
+        {
+            id: `wait:thread:${thread.id}`,
+            status: thread.status === "done" || thread.status === "abandoned" ? "satisfied" : "waiting",
+            subjectKind: "thread",
+            subjectId: thread.id,
+            waitingOn,
+            owner: thread.owner,
+            createdAt: thread.createdAt,
+            updatedAt: thread.updatedAt,
+            resolvedAt: thread.status === "done" || thread.status === "abandoned" ? thread.updatedAt : undefined,
+        },
+    ];
+}
+function waitsFromTask(task) {
+    const waitingOn = unique([
+        task.status === "blocked" ? task.assignedBy : undefined,
+        task.status === "assigned" || task.status === "pending" || task.status === "in_progress"
+            ? (task.assignedTo ?? task.assignee)
+            : undefined,
+    ]);
+    if (waitingOn.length === 0)
+        return [];
+    return [
+        {
+            id: `wait:task:${task.id}`,
+            status: task.status === "done" || task.status === "failed" ? "satisfied" : "waiting",
+            subjectKind: "task",
+            subjectId: task.id,
+            waitingOn,
+            owner: task.assignedBy,
+            createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
+            resolvedAt: task.status === "done" || task.status === "failed" ? task.updatedAt : undefined,
+        },
+    ];
+}
+function inboxFromThread(thread) {
+    const participants = unique([...(thread.unreadBy ?? []), ...(thread.waitingOn ?? [])]);
+    return participants.map((participantId) => {
+        const waiting = (thread.waitingOn ?? []).includes(participantId);
+        return {
+            id: `inbox:${participantId}:thread:${thread.id}`,
+            participantId,
+            subjectKind: "thread",
+            subjectId: thread.id,
+            state: thread.status === "blocked" ? "blocked" : waiting ? "waiting" : "unread",
+            urgency: (waiting ? 10 : 0) + ((thread.unreadBy ?? []).includes(participantId) ? 3 : 0),
+            updatedAt: thread.updatedAt,
+        };
+    });
+}
+function inboxFromTask(task) {
+    const participants = unique([
+        task.status === "blocked" ? task.assignedBy : undefined,
+        task.status !== "done" && task.status !== "failed" ? (task.assignedTo ?? task.assignee) : undefined,
+    ]);
+    return participants.map((participantId) => ({
+        id: `inbox:${participantId}:task:${task.id}`,
+        participantId,
+        subjectKind: "task",
+        subjectId: task.id,
+        state: task.status === "blocked" ? "blocked" : task.status === "done" ? "done" : "waiting",
+        urgency: task.status === "blocked" ? 12 : task.type === "review" ? 8 : 6,
+        updatedAt: task.updatedAt,
+    }));
+}
+function preserveAcknowledgedInbox(nextEntries, previousEntries) {
+    const previousById = new Map(previousEntries.map((entry) => [entry.id, entry]));
+    return nextEntries.map((entry) => {
+        const previous = previousById.get(entry.id);
+        if (previous?.state === "done" && previous.updatedAt === entry.updatedAt) {
+            return { ...entry, state: "done" };
+        }
+        return entry;
+    });
+}
+export function deriveRuntimeExchangeIndexes(exchange) {
+    const messagesByThread = new Map();
+    for (const message of exchange.messages) {
+        const existing = messagesByThread.get(message.threadId) ?? [];
+        existing.push(message);
+        messagesByThread.set(message.threadId, existing);
+    }
+    const nextInbox = [...exchange.threads.flatMap(inboxFromThread), ...exchange.tasks.flatMap(inboxFromTask)];
+    return {
+        ...exchange,
+        handoffs: exchange.threads
+            .map((thread) => handoffFromThread(thread, messagesByThread.get(thread.id) ?? []))
+            .filter((handoff) => Boolean(handoff)),
+        reviews: exchange.tasks.map(reviewFromTask).filter((review) => Boolean(review)),
+        waits: [...exchange.threads.flatMap(waitsFromThread), ...exchange.tasks.flatMap(waitsFromTask)],
+        inbox: preserveAcknowledgedInbox(nextInbox, exchange.inbox),
+    };
+}

package/dist/runtime-core/exchange-import.d.ts

@@ -0,0 +1,24 @@
+import type { AttachmentRecord } from "../attachment-store.js";
+import type { Task } from "../tasks.js";
+import type { OrchestrationMessage, OrchestrationThread } from "../threads.js";
+import { type RuntimeExchange } from "./exchange-store.js";
+export interface RuntimeExchangeLegacySnapshot {
+    threads?: OrchestrationThread[];
+    messages?: OrchestrationMessage[];
+    tasks?: Task[];
+    planPaths?: string[];
+    historyPaths?: string[];
+    contextPaths?: string[];
+    recordingPaths?: string[];
+    statusPaths?: string[];
+    attachments?: AttachmentRecord[];
+    now?: string;
+}
+export declare function buildRuntimeExchangeFromLegacySnapshot(input?: RuntimeExchangeLegacySnapshot): RuntimeExchange;
+export declare function importRuntimeExchangeFromLegacyFiles(input?: {
+    now?: string;
+    additionalHistoryPaths?: string[];
+    additionalContextPaths?: string[];
+    additionalRecordingPaths?: string[];
+    additionalStatusPaths?: string[];
+}): RuntimeExchange;

package/dist/runtime-core/exchange-import.js

@@ -0,0 +1,317 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import { getAttachmentsDir, getContextDir, getHistoryDir, getPlansDir, getRecordingsDir, getStatusDir, getTasksDir, getThreadsDir, } from "../paths.js";
+import { emptyRuntimeExchange, } from "./exchange-store.js";
+function unique(values) {
+    return [...new Set(values.map((value) => value?.trim()).filter(Boolean))];
+}
+function safeJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function listFiles(dir, predicate) {
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter(predicate)
+            .map((name) => join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function listNestedFiles(dir, predicate) {
+    if (!existsSync(dir))
+        return [];
+    const paths = [];
+    try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                paths.push(...listNestedFiles(path, predicate));
+            }
+            else if (predicate(entry.name)) {
+                paths.push(path);
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return paths;
+}
+function readLegacyThreads() {
+    return listFiles(getThreadsDir(), (name) => name.endsWith(".json"))
+        .map((path) => safeJson(path))
+        .filter((thread) => Boolean(thread));
+}
+function readLegacyMessages(threadIds) {
+    return threadIds.flatMap((threadId) => {
+        const path = join(getThreadsDir(), `${threadId}.jsonl`);
+        if (!existsSync(path))
+            return [];
+        try {
+            return readFileSync(path, "utf8")
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return undefined;
+                }
+            })
+                .filter((message) => Boolean(message));
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function readLegacyTasks() {
+    return listFiles(getTasksDir(), (name) => name.endsWith(".json"))
+        .map((path) => safeJson(path))
+        .filter((task) => Boolean(task));
+}
+function readLegacyAttachments() {
+    return listFiles(getAttachmentsDir(), (name) => name.endsWith(".json"))
+        .map((path) => safeJson(path))
+        .filter((attachment) => Boolean(attachment));
+}
+function toExchangeThread(thread) {
+    return {
+        id: thread.id,
+        title: thread.title,
+        kind: thread.kind,
+        status: thread.status,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        createdBy: thread.createdBy,
+        participants: thread.participants,
+        owner: thread.owner,
+        waitingOn: thread.waitingOn,
+        worktreePath: thread.worktreePath,
+        taskId: thread.taskId,
+        relatedPlanIds: thread.relatedPlanIds,
+        lastMessageId: thread.lastMessageId,
+        unreadBy: thread.unreadBy,
+        tags: thread.tags,
+    };
+}
+function toExchangeMessage(message) {
+    return {
+        id: message.id,
+        threadId: message.threadId,
+        ts: message.ts,
+        from: message.from,
+        to: message.to,
+        kind: message.kind,
+        body: message.body,
+        taskId: message.taskId,
+        planId: message.planId,
+        metadata: message.metadata,
+        deliveredTo: message.deliveredTo,
+        deliveredAt: message.deliveredAt,
+    };
+}
+function normalizeReviewStatus(status) {
+    const normalized = String(status ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/[-\s]+/g, "_");
+    if (normalized === "approved" || normalized === "approve")
+        return "approved";
+    if (normalized === "changes_requested" || normalized === "request_changes")
+        return "changes_requested";
+    if (normalized === "pending")
+        return "pending";
+    return undefined;
+}
+function toExchangeTask(task) {
+    return {
+        id: task.id,
+        status: task.status,
+        assignedBy: task.assignedBy,
+        assignedTo: task.assignedTo,
+        assignee: task.assignee,
+        assigner: task.assigner,
+        threadId: task.threadId,
+        tool: task.tool,
+        description: task.description,
+        prompt: task.prompt,
+        result: task.result,
+        error: task.error,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        notifiedAt: task.notifiedAt,
+        type: task.type,
+        reviewStatus: normalizeReviewStatus(task.reviewStatus),
+        reviewFeedback: task.reviewFeedback,
+        diff: task.diff,
+        iteration: task.iteration,
+        reviewOf: task.reviewOf,
+    };
+}
+function buildHandoff(thread) {
+    if (thread.kind !== "handoff")
+        return undefined;
+    const recipients = unique(thread.waitingOn?.length ? thread.waitingOn : thread.participants.filter((id) => id !== thread.createdBy));
+    if (recipients.length === 0)
+        return undefined;
+    return {
+        id: `handoff:${thread.id}`,
+        threadId: thread.id,
+        status: thread.status === "done" ? "completed" : thread.status === "abandoned" ? "cancelled" : "waiting",
+        from: thread.createdBy,
+        to: recipients,
+        acceptedBy: thread.status === "open" ? thread.owner : undefined,
+        completedBy: thread.status === "done" ? thread.owner : undefined,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+    };
+}
+function buildReview(task) {
+    if (task.type !== "review")
+        return undefined;
+    return {
+        id: `review:${task.id}`,
+        taskId: task.id,
+        reviewOf: task.reviewOf,
+        reviewer: task.assignedTo ?? task.assignee,
+        status: normalizeReviewStatus(task.reviewStatus) ?? "pending",
+        feedback: task.reviewFeedback ?? task.result,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+    };
+}
+function buildThreadWait(thread) {
+    const waitingOn = unique(thread.waitingOn ?? []);
+    if (waitingOn.length === 0)
+        return undefined;
+    return {
+        id: `wait:thread:${thread.id}`,
+        status: thread.status === "done" || thread.status === "abandoned" ? "satisfied" : "waiting",
+        subjectKind: "thread",
+        subjectId: thread.id,
+        waitingOn,
+        owner: thread.owner,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        resolvedAt: thread.status === "done" || thread.status === "abandoned" ? thread.updatedAt : undefined,
+    };
+}
+function buildInboxEntries(thread) {
+    const participants = unique([...(thread.unreadBy ?? []), ...(thread.waitingOn ?? [])]);
+    return participants.map((participantId) => {
+        const waiting = (thread.waitingOn ?? []).includes(participantId);
+        return {
+            id: `inbox:${participantId}:thread:${thread.id}`,
+            participantId,
+            subjectKind: "thread",
+            subjectId: thread.id,
+            state: thread.status === "blocked" ? "blocked" : waiting ? "waiting" : "unread",
+            urgency: (waiting ? 10 : 0) + ((thread.unreadBy ?? []).includes(participantId) ? 3 : 0),
+            updatedAt: thread.updatedAt,
+        };
+    });
+}
+function planRefFromPath(path, now) {
+    const sessionId = basename(path).replace(/\.md$/, "");
+    return {
+        id: `plan:${sessionId}`,
+        path,
+        ownerSessionId: sessionId,
+        title: sessionId,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function continuityKindForPath(path) {
+    const normalized = path.replaceAll("\\", "/");
+    if (normalized.includes("/recordings/"))
+        return "recording";
+    if (normalized.includes("/status/"))
+        return "status";
+    if (normalized.includes("/history/"))
+        return "history";
+    return "context";
+}
+function continuityRefFromPath(path, now) {
+    const kind = continuityKindForPath(path);
+    const file = basename(path);
+    const sessionId = file.replace(/\.(jsonl|md|txt)$/, "");
+    return {
+        id: `${kind}:${sessionId}:${file}`,
+        kind,
+        path,
+        sessionId,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function attachmentRefFromRecord(record) {
+    return {
+        id: record.id,
+        path: record.contentPath,
+        contentUrl: `/attachments/${record.id}/content`,
+        mediaType: record.mimeType,
+        createdAt: record.createdAt,
+        updatedAt: record.createdAt,
+    };
+}
+export function buildRuntimeExchangeFromLegacySnapshot(input = {}) {
+    const now = input.now ?? new Date().toISOString();
+    const exchange = emptyRuntimeExchange(now);
+    const threads = input.threads ?? [];
+    const tasks = input.tasks ?? [];
+    exchange.threads = threads.map(toExchangeThread);
+    exchange.messages = (input.messages ?? []).map(toExchangeMessage);
+    exchange.tasks = tasks.map(toExchangeTask);
+    exchange.handoffs = threads
+        .map(buildHandoff)
+        .filter((handoff) => Boolean(handoff));
+    exchange.reviews = tasks.map(buildReview).filter((review) => Boolean(review));
+    exchange.waits = threads.map(buildThreadWait).filter((wait) => Boolean(wait));
+    exchange.inbox = threads.flatMap(buildInboxEntries);
+    exchange.planRefs = (input.planPaths ?? []).map((path) => planRefFromPath(path, now));
+    exchange.continuityRefs = [
+        ...(input.historyPaths ?? []),
+        ...(input.contextPaths ?? []),
+        ...(input.recordingPaths ?? []),
+        ...(input.statusPaths ?? []),
+    ].map((path) => continuityRefFromPath(path, now));
+    exchange.attachmentRefs = (input.attachments ?? []).map(attachmentRefFromRecord);
+    return exchange;
+}
+export function importRuntimeExchangeFromLegacyFiles(input = {}) {
+    const now = input.now ?? new Date().toISOString();
+    const threads = readLegacyThreads();
+    return buildRuntimeExchangeFromLegacySnapshot({
+        now,
+        threads,
+        messages: readLegacyMessages(threads.map((thread) => thread.id)),
+        tasks: readLegacyTasks(),
+        planPaths: listFiles(getPlansDir(), (name) => name.endsWith(".md")),
+        historyPaths: [
+            ...listFiles(getHistoryDir(), (name) => name.endsWith(".jsonl")),
+            ...(input.additionalHistoryPaths ?? []),
+        ],
+        contextPaths: [
+            ...listNestedFiles(getContextDir(), (name) => name.endsWith(".md") || name.endsWith(".jsonl")),
+            ...(input.additionalContextPaths ?? []),
+        ],
+        recordingPaths: [
+            ...listFiles(getRecordingsDir(), (name) => name.endsWith(".txt") || name.endsWith(".log")),
+            ...(input.additionalRecordingPaths ?? []),
+        ],
+        statusPaths: [...listFiles(getStatusDir(), (name) => name.endsWith(".md")), ...(input.additionalStatusPaths ?? [])],
+        attachments: readLegacyAttachments(),
+    });
+}