@aria-cli/cli 1.0.57 → 1.0.59

package/dist/headless/operations/message.js

@@ -1,279 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { OutboundMessageSchema } from "@aria-cli/tools";
-import { failureResult, successResult } from "./utils.js";
-function parseSendArgs(input) {
-    const trimmed = input.trim();
-    if (!trimmed) {
-        return null;
-    }
-    const separatorIndex = trimmed.indexOf(" ");
-    if (separatorIndex <= 0) {
-        return null;
-    }
-    const recipient = trimmed.slice(0, separatorIndex).trim();
-    const content = trimmed.slice(separatorIndex + 1).trim();
-    if (!recipient || !content) {
-        return null;
-    }
-    return { recipient, content };
-}
-function normalizePeerLabel(peer) {
-    return peer.displayNameSnapshot?.trim() || peer.nodeId;
-}
-function normalizeAttachedClientLabel(client) {
-    return client.displayLabel.trim() || client.clientId;
-}
-function formatAttachedClientLabel(client) {
-    const displayLabel = normalizeAttachedClientLabel(client);
-    return displayLabel === client.clientId
-        ? client.clientId
-        : `${displayLabel} (${client.clientId})`;
-}
-/**
- * Parse @peer/arion or @peer#client syntax.
- *
- * Examples:
- *   "@vm1"              → { peer: "vm1" }
- *   "@vm1/CodeReviewer" → { peer: "vm1", arion: "CodeReviewer" }
- *   "@vm1#my-tui"       → { peer: "vm1", client: "my-tui" }
- *   "vm1/ARIA"          → { peer: "vm1", arion: "ARIA" }
- */
-function parseMention(ref) {
-    const cleaned = ref.trim().replace(/^@/, "");
-    // Check for client addressing: peer#client
-    const hashIdx = cleaned.indexOf("#");
-    if (hashIdx > 0) {
-        return {
-            peer: cleaned.slice(0, hashIdx),
-            client: cleaned.slice(hashIdx + 1) || undefined,
-        };
-    }
-    // Check for arion addressing: peer/arion
-    const slashIdx = cleaned.indexOf("/");
-    if (slashIdx > 0) {
-        return {
-            peer: cleaned.slice(0, slashIdx),
-            arion: cleaned.slice(slashIdx + 1) || undefined,
-        };
-    }
-    return { peer: cleaned };
-}
-function resolveRecipient(peers, peerRef) {
-    // Strip @prefix for @mention support
-    const { peer: normalizedRef } = parseMention(peerRef);
-    const exactNodeId = peers.find((peer) => peer.nodeId.toLowerCase() === normalizedRef);
-    if (exactNodeId) {
-        return exactNodeId;
-    }
-    const displayMatches = peers.filter((peer) => normalizePeerLabel(peer).toLowerCase() === normalizedRef);
-    if (displayMatches.length === 1) {
-        return displayMatches[0];
-    }
-    return null;
-}
-function hasAmbiguousRecipient(peers, peerRef) {
-    const normalizedRef = peerRef.trim().toLowerCase().replace(/^@/, "");
-    return (peers.filter((peer) => normalizePeerLabel(peer).toLowerCase() === normalizedRef).length > 1);
-}
-function resolveAttachedClient(clients, clientRef) {
-    const normalizedRef = clientRef.trim().toLowerCase().replace(/^@/, "");
-    return clients.find((client) => client.clientId.toLowerCase() === normalizedRef) ?? null;
-}
-function resolveAttachedClientDisplayLabel(clients, clientRef) {
-    const normalizedRef = clientRef.trim().toLowerCase();
-    return (clients.find((client) => normalizeAttachedClientLabel(client).toLowerCase() === normalizedRef) ?? null);
-}
-function buildPeerOutboundMessage(input) {
-    const metadata = {};
-    if (input.targetArion)
-        metadata.targetArion = input.targetArion;
-    if (input.targetClient)
-        metadata.targetClient = input.targetClient;
-    const hasMetadata = Object.keys(metadata).length > 0;
-    return {
-        rawMessage: {
-            version: 1,
-            id: `headless-send-${randomUUID()}`,
-            sender: {
-                id: input.senderNodeId,
-                name: input.senderName,
-                type: "arion",
-            },
-            recipient: {
-                id: input.recipient.nodeId,
-                name: normalizePeerLabel(input.recipient),
-                type: "peer",
-            },
-            type: "message",
-            content: input.content,
-            timestamp: Date.now(),
-            priority: 2,
-            ...(hasMetadata ? { metadata } : {}),
-        },
-        to: input.recipient.nodeId,
-        type: "message",
-        content: input.content,
-        priority: 2,
-        ...(hasMetadata ? { metadata } : {}),
-    };
-}
-function buildClientOutboundMessage(input) {
-    return {
-        rawMessage: {
-            version: 1,
-            id: `headless-send-${randomUUID()}`,
-            sender: {
-                id: input.senderNodeId,
-                name: input.senderName,
-                type: "arion",
-            },
-            recipient: {
-                id: input.recipient.clientId,
-                name: normalizeAttachedClientLabel(input.recipient),
-                type: "client",
-            },
-            type: "message",
-            content: input.content,
-            timestamp: Date.now(),
-            priority: 2,
-        },
-        recipientInbox: {
-            kind: "client",
-            clientId: input.recipient.clientId,
-        },
-        type: "message",
-        content: input.content,
-        priority: 2,
-    };
-}
-async function resolveStructuredMessage(ctx, input) {
-    const parsed = typeof input.args === "string" && input.args.trim().length > 0
-        ? parseSendArgs(input.args)
-        : input.recipient && input.content
-            ? { recipient: input.recipient, content: input.content }
-            : null;
-    if (!parsed) {
-        return {
-            ok: false,
-            code: "MESSAGE_SEND_FAILED",
-            message: "Usage: /send <peer-name|node-id|client-id> <message>",
-        };
-    }
-    const [peers, attachedClients, runtimeStatus] = await Promise.all([
-        ctx.localControl.listPeers(),
-        ctx.localControl.listAttachedClients(),
-        ctx.localControl.getRuntimeStatus(),
-    ]);
-    const senderName = input.senderName?.trim() || "ARIA";
-    const attachedClient = resolveAttachedClient(attachedClients, parsed.recipient);
-    if (attachedClient) {
-        if (attachedClient.self) {
-            return {
-                ok: false,
-                code: "MESSAGE_SEND_FAILED",
-                message: "Cannot send a same-home message to yourself.",
-            };
-        }
-        return {
-            ok: true,
-            outbound: buildClientOutboundMessage({
-                senderNodeId: runtimeStatus.nodeId,
-                senderName,
-                recipient: attachedClient,
-                content: parsed.content,
-            }),
-            message: `Sent message to ${formatAttachedClientLabel(attachedClient)}.`,
-        };
-    }
-    if (hasAmbiguousRecipient(peers, parsed.recipient)) {
-        return {
-            ok: false,
-            code: "MESSAGE_SEND_FAILED",
-            message: `Multiple peers match "${parsed.recipient}". Use the nodeId instead.`,
-        };
-    }
-    const recipient = resolveRecipient(peers, parsed.recipient);
-    if (!recipient) {
-        const matchedClientByLabel = resolveAttachedClientDisplayLabel(attachedClients, parsed.recipient);
-        if (matchedClientByLabel) {
-            return {
-                ok: false,
-                code: "MESSAGE_SEND_FAILED",
-                message: `Same-home clients require the exact clientId. Use /clients to choose ${formatAttachedClientLabel(matchedClientByLabel)}.`,
-            };
-        }
-        return {
-            ok: false,
-            code: "MESSAGE_SEND_FAILED",
-            message: `Recipient "${parsed.recipient}" not found.`,
-        };
-    }
-    const mention = parseMention(parsed.recipient);
-    const targetLabel = mention.arion
-        ? `${normalizePeerLabel(recipient)}/${mention.arion}`
-        : mention.client
-            ? `${normalizePeerLabel(recipient)}#${mention.client}`
-            : normalizePeerLabel(recipient);
-    return {
-        ok: true,
-        outbound: buildPeerOutboundMessage({
-            senderNodeId: runtimeStatus.nodeId,
-            senderName,
-            recipient,
-            content: parsed.content,
-            targetArion: mention.arion,
-            targetClient: mention.client,
-        }),
-        message: `Sent message to ${targetLabel}.`,
-    };
-}
-function toDeliveryMessage(receipt, fallback) {
-    if (receipt.deliveryState === "queued_for_route") {
-        return fallback.replace(/^Sent/, "Queued");
-    }
-    if (receipt.deliveryState === "dispatching") {
-        return `${fallback.slice(0, -1)}; awaiting acknowledgement.`;
-    }
-    if (receipt.delivered) {
-        return fallback.replace(/^Sent/, "Delivered");
-    }
-    return fallback;
-}
-export function createMessageOperationHandlers(ctx) {
-    return {
-        "message.send": async function* (requestId, input) {
-            const outbound = OutboundMessageSchema.safeParse(input);
-            if (outbound.success) {
-                yield successResult(requestId, "message.send", {
-                    receipt: await ctx.localControl.sendDurable(outbound.data),
-                });
-                return;
-            }
-            const hasStructuredProjectionInput = input &&
-                typeof input === "object" &&
-                (typeof input.args === "string" ||
-                    typeof input.recipient === "string" ||
-                    typeof input.content === "string");
-            if (!hasStructuredProjectionInput) {
-                yield failureResult(requestId, "message.send", "INVALID_INPUT", "Invalid input for message.send");
-                return;
-            }
-            const resolved = await resolveStructuredMessage(ctx, input);
-            if (!resolved.ok) {
-                yield failureResult(requestId, "message.send", resolved.code, resolved.message);
-                return;
-            }
-            const receipt = await ctx.localControl.sendDurable(resolved.outbound);
-            yield successResult(requestId, "message.send", {
-                receipt,
-                message: toDeliveryMessage(receipt, resolved.message),
-            });
-        },
-        "message.inbox.list": async function* (requestId, input) {
-            yield successResult(requestId, "message.inbox.list", {
-                events: await ctx.localControl.listInbox(input),
-            });
-        },
-    };
-}
-//# sourceMappingURL=message.js.map

package/dist/headless/operations/model.js

@@ -1,100 +0,0 @@
-import { failureResult, successResult, unsupportedWhenMissing } from "./utils.js";
-export function createModelOperationHandlers(ctx) {
-    const localControl = ctx.localControl;
-    if (localControl) {
-        return {
-            "model.list": async function* (requestId, input) {
-                const lc = localControl;
-                const providers = Array.isArray(input.providers)
-                    ? (input.providers ?? [])
-                        .filter((value) => typeof value === "string" && value.trim().length > 0)
-                        .map((value) => value.trim())
-                    : undefined;
-                const snapshot = await lc.getModelSnapshot();
-                yield successResult(requestId, "model.list", {
-                    models: snapshot.models,
-                    currentModel: snapshot.currentModel,
-                    lastRefreshAt: snapshot.lastRefreshAt,
-                    stale: snapshot.stale,
-                    refreshInFlight: snapshot.refreshInFlight,
-                    providerStatuses: snapshot.providerStatuses,
-                });
-            },
-            "model.set": async function* (requestId, input) {
-                const lc = localControl;
-                const model = input.model?.trim();
-                if (!model) {
-                    yield failureResult(requestId, "model.set", "MODEL_SET_FAILED", "model.set requires a model");
-                    return;
-                }
-                const snapshot = await lc.setCurrentModel(model);
-                const selected = snapshot.models.find((entry) => typeof entry.shortName === "string" &&
-                    typeof entry.id === "string" &&
-                    (entry.shortName.toLowerCase() === (snapshot.currentModel ?? model).toLowerCase() ||
-                        entry.id.toLowerCase() === (snapshot.currentModel ?? model).toLowerCase()));
-                yield successResult(requestId, "model.set", {
-                    currentModel: snapshot.currentModel ?? model,
-                    tier: selected?.tier,
-                    lastRefreshAt: snapshot.lastRefreshAt,
-                    stale: snapshot.stale,
-                    refreshInFlight: snapshot.refreshInFlight,
-                    providerStatuses: snapshot.providerStatuses,
-                });
-            },
-            "model.refresh": async function* (requestId, input) {
-                const lc = localControl;
-                const providers = Array.isArray(input.providers)
-                    ? (input.providers ?? [])
-                        .filter((value) => typeof value === "string" && value.trim().length > 0)
-                        .map((value) => value.trim())
-                    : undefined;
-                const snapshot = await lc.refreshModelSnapshot(providers?.length ? { providers } : undefined);
-                yield successResult(requestId, "model.refresh", {
-                    models: snapshot.models,
-                    currentModel: snapshot.currentModel,
-                    lastRefreshAt: snapshot.lastRefreshAt,
-                    stale: snapshot.stale,
-                    refreshInFlight: snapshot.refreshInFlight,
-                    providerStatuses: snapshot.providerStatuses,
-                });
-            },
-        };
-    }
-    const discovery = ctx.modelDiscovery;
-    if (!discovery?.listAvailable || !discovery.refresh || !discovery.setCurrentModel) {
-        return {
-            "model.list": unsupportedWhenMissing("modelDiscovery", "model.list"),
-            "model.set": unsupportedWhenMissing("modelDiscovery", "model.set"),
-            "model.refresh": unsupportedWhenMissing("modelDiscovery", "model.refresh"),
-        };
-    }
-    return {
-        "model.list": async function* (requestId) {
-            const listAvailable = discovery.listAvailable;
-            yield successResult(requestId, "model.list", {
-                models: await listAvailable(),
-                currentModel: await discovery.getCurrentModel?.(),
-            });
-        },
-        "model.set": async function* (requestId, input) {
-            const setCurrentModel = discovery.setCurrentModel;
-            const model = input.model?.trim();
-            if (!model) {
-                yield failureResult(requestId, "model.set", "MODEL_SET_FAILED", "model.set requires a model");
-                return;
-            }
-            const result = await setCurrentModel(model);
-            yield successResult(requestId, "model.set", {
-                currentModel: model,
-                ...(result && typeof result === "object" ? result : {}),
-            });
-        },
-        "model.refresh": async function* (requestId) {
-            const refresh = discovery.refresh;
-            yield successResult(requestId, "model.refresh", {
-                models: await refresh(true),
-            });
-        },
-    };
-}
-//# sourceMappingURL=model.js.map

package/dist/headless/operations/peer.js

@@ -1,56 +0,0 @@
-import { successResult } from "./utils.js";
-export function createPeerOperationHandlers(ctx) {
-    return {
-        "peer.list": async function* (requestId) {
-            yield successResult(requestId, "peer.list", {
-                peers: await ctx.localControl.listPeers(),
-            });
-        },
-        "peer.list_nearby": async function* (requestId) {
-            yield successResult(requestId, "peer.list_nearby", {
-                peers: await ctx.localControl.listNearbyPeers(),
-            });
-        },
-        "peer.pending.list": async function* (requestId) {
-            yield successResult(requestId, "peer.pending.list", {
-                requests: await ctx.localControl.listPendingPairRequests(),
-            });
-        },
-        "peer.pending.respond": async function* (requestId, input) {
-            yield successResult(requestId, "peer.pending.respond", {
-                response: await ctx.localControl.respondToPairRequest(input),
-            });
-        },
-        "peer.invite": async function* (requestId, input) {
-            yield successResult(requestId, "peer.invite", {
-                invite: await ctx.localControl.createInvite(input),
-            });
-        },
-        "peer.connect": async function* (requestId, input) {
-            yield successResult(requestId, "peer.connect", {
-                invite: await ctx.localControl.invitePeer(input),
-            });
-        },
-        "peer.accept_invite": async function* (requestId, input) {
-            yield successResult(requestId, "peer.accept_invite", {
-                accepted: await ctx.localControl.acceptInviteToken(input),
-            });
-        },
-        "peer.direct_pair": async function* (requestId, input) {
-            yield successResult(requestId, "peer.direct_pair", {
-                pair: await ctx.localControl.directPair(input),
-            });
-        },
-        "peer.repair": async function* (requestId, input) {
-            yield successResult(requestId, "peer.repair", {
-                repair: await ctx.localControl.repairPeer(input),
-            });
-        },
-        "peer.revoke": async function* (requestId, input) {
-            yield successResult(requestId, "peer.revoke", {
-                revoke: await ctx.localControl.revokePeer(input),
-            });
-        },
-    };
-}
-//# sourceMappingURL=peer.js.map

package/dist/headless/operations/run.js

@@ -1,24 +0,0 @@
-export function createRunOperationHandlers(orchestrator) {
-    return {
-        "run.start": async function* (requestId, input, context) {
-            yield* orchestrator.start(requestId, input, context?.signal);
-        },
-        "run.resume": async function* (requestId, input, context) {
-            yield* orchestrator.resume(requestId, input, context?.signal);
-        },
-        "run.abort": async function* (requestId, input, context) {
-            yield* orchestrator.abort(requestId, input, context?.activeRunController);
-        },
-        "interaction.respond": async function* (requestId, input, context) {
-            const response = input && typeof input === "object" && "kind" in input
-                ? input
-                : {
-                    kind: "interaction.respond",
-                    requestId,
-                    ...input,
-                };
-            yield* orchestrator.respond(response, context?.signal);
-        },
-    };
-}
-//# sourceMappingURL=run.js.map

package/dist/headless/operations/session.js

@@ -1,90 +0,0 @@
-import { failureResult, successResult } from "./utils.js";
-function toHeadlessSessionSummary(summary) {
-    return {
-        ...summary,
-        createdAt: summary.createdAt.toISOString(),
-        updatedAt: summary.updatedAt.toISOString(),
-        ...(summary.completedAt ? { completedAt: summary.completedAt.toISOString() } : {}),
-    };
-}
-function normalizeSessionId(input) {
-    const raw = input.sessionId;
-    return typeof raw === "string" ? raw.trim() : "";
-}
-export function buildSessionListResult(requestId, sessionLedger, input) {
-    const args = input;
-    const sessions = typeof args.query === "string" && args.query.trim().length > 0
-        ? sessionLedger.searchSessionSummaries(args.query, args.limit ?? 20, args.offset ?? 0)
-        : sessionLedger.listSessions(args.limit ?? 20, args.offset ?? 0);
-    return successResult(requestId, "session.list", {
-        sessions: sessions.map(toHeadlessSessionSummary),
-    });
-}
-export function buildSessionReadResult(requestId, sessionLedger, input) {
-    const sessionId = normalizeSessionId(input);
-    if (!sessionId) {
-        return failureResult(requestId, "session.read", "SESSION_READ_FAILED", "session.read requires a sessionId");
-    }
-    const resolvedId = sessionLedger.findSessionByPrefix(sessionId) ?? sessionId;
-    const session = sessionLedger.loadSessionMessages(resolvedId);
-    if (!session) {
-        return failureResult(requestId, "session.read", "SESSION_NOT_FOUND", `Session ${sessionId} not found`);
-    }
-    return successResult(requestId, "session.read", { session });
-}
-export function buildSessionLoadResult(requestId, sessionLedger, input) {
-    const sessionId = normalizeSessionId(input);
-    if (!sessionId) {
-        return failureResult(requestId, "session.load", "SESSION_LOAD_FAILED", "session.load requires a sessionId");
-    }
-    const resolvedId = sessionLedger.findSessionByPrefix(sessionId) ?? sessionId;
-    const loaded = sessionLedger.loadSession(resolvedId);
-    if (!loaded) {
-        return failureResult(requestId, "session.load", "SESSION_NOT_FOUND", `Session ${sessionId} not found`);
-    }
-    return successResult(requestId, "session.load", {
-        session: loaded.session,
-        loaded: true,
-        ...(loaded.runtimeState ? { runtimeState: loaded.runtimeState } : {}),
-        ...(loaded.pendingInteraction ? { pendingInteraction: loaded.pendingInteraction } : {}),
-    });
-}
-export function buildSessionForkResult(requestId, sessionLedger, input) {
-    const args = input;
-    const sessionId = typeof args.sessionId === "string" ? args.sessionId.trim() : "";
-    if (!sessionId) {
-        return failureResult(requestId, "session.fork", "SESSION_FORK_FAILED", "session.fork requires a sessionId");
-    }
-    const resolvedId = sessionLedger.findSessionByPrefix(sessionId) ?? sessionId;
-    try {
-        const result = sessionLedger.forkSession(resolvedId, {
-            messageLimit: args.messageLimit,
-        });
-        return successResult(requestId, "session.fork", {
-            newSessionId: result.newSessionId,
-            sourceSessionId: result.sourceSessionId,
-            messagesCopied: result.messagesCopied,
-            title: result.title,
-        });
-    }
-    catch (error) {
-        return failureResult(requestId, "session.fork", "SESSION_NOT_FOUND", error.message);
-    }
-}
-export function createSessionOperationHandlers(ctx) {
-    return {
-        "session.list": async function* (requestId, input) {
-            yield buildSessionListResult(requestId, ctx.sessionLedger, input);
-        },
-        "session.read": async function* (requestId, input) {
-            yield buildSessionReadResult(requestId, ctx.sessionLedger, input);
-        },
-        "session.load": async function* (requestId, input) {
-            yield buildSessionLoadResult(requestId, ctx.sessionLedger, input);
-        },
-        "session.fork": async function* (requestId, input) {
-            yield buildSessionForkResult(requestId, ctx.sessionLedger, input);
-        },
-    };
-}
-//# sourceMappingURL=session.js.map

package/dist/headless/operations/system.js

@@ -1,19 +0,0 @@
-import { successResult, unsupportedWhenMissing } from "./utils.js";
-export function createSystemOperationHandlers(ctx) {
-    const system = ctx.system;
-    if (!system?.restart || !system.terminalSetup) {
-        return {
-            "system.restart": unsupportedWhenMissing("system", "system.restart"),
-            "system.terminal_setup": unsupportedWhenMissing("system", "system.terminal_setup"),
-        };
-    }
-    return {
-        "system.restart": async function* (requestId, input) {
-            yield successResult(requestId, "system.restart", await system.restart(input));
-        },
-        "system.terminal_setup": async function* (requestId) {
-            yield successResult(requestId, "system.terminal_setup", await system.terminalSetup());
-        },
-    };
-}
-//# sourceMappingURL=system.js.map

package/dist/headless/operations/utils.js

@@ -1,35 +0,0 @@
-import { HEADLESS_OPERATION_SCHEMAS } from "@aria-cli/tools";
-export function successResult(requestId, op, result) {
-    const parsed = HEADLESS_OPERATION_SCHEMAS[op].result.safeParse(result);
-    if (!parsed.success) {
-        throw new Error(`Invalid headless result for ${op}: ${parsed.error.issues
-            .map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`)
-            .join("; ")}`);
-    }
-    return {
-        kind: "result",
-        requestId,
-        op,
-        ok: true,
-        result: parsed.data,
-    };
-}
-export function failureResult(requestId, op, code, message, details) {
-    return {
-        kind: "result",
-        requestId,
-        op,
-        ok: false,
-        error: {
-            code,
-            message,
-            ...(details ? { details } : {}),
-        },
-    };
-}
-export function unsupportedWhenMissing(serviceName, op) {
-    return async function* (requestId) {
-        yield failureResult(requestId, op, "MISSING_SERVICE", `Kernel service ${serviceName} is not configured for ${op}.`);
-    };
-}
-//# sourceMappingURL=utils.js.map