@vdoninja/ninja-p2p 0.1.1 → 0.1.2

package/dist/agent-state.d.ts

@@ -0,0 +1,167 @@
+import { type AgentAsk, type AgentProfile, type FileTransferKind, type MessageEnvelope, type MessageType, type SharedFolderSummary } from "./protocol.js";
+import type { SharedFolderConfig } from "./shared-folders.js";
+export type AgentSessionState = {
+    room: string;
+    streamId: string;
+    name: string;
+    role: string;
+    stateDir: string;
+    pid: number;
+    connected: boolean;
+    skills: string[];
+    topics: string[];
+    agentProfile: AgentProfile | null;
+    sharedFolders: SharedFolderConfig[];
+    startedAt: number;
+    updatedAt: number;
+};
+export type QueuedAgentAction = {
+    id: string;
+    createdAt: number;
+    kind: "chat";
+    text: string;
+} | {
+    id: string;
+    createdAt: number;
+    kind: "dm";
+    target: string;
+    text: string;
+} | {
+    id: string;
+    createdAt: number;
+    kind: "send_file";
+    target: string;
+    filePath: string;
+    transferKind: FileTransferKind;
+} | {
+    id: string;
+    createdAt: number;
+    kind: "command";
+    target: string;
+    command: string;
+    args?: unknown;
+} | {
+    id: string;
+    createdAt: number;
+    kind: "response";
+    target: string;
+    requestId: string;
+    result?: unknown;
+    error?: string;
+} | {
+    id: string;
+    createdAt: number;
+    kind: "event";
+    topic: string;
+    eventKind: string;
+    data?: unknown;
+} | {
+    id: string;
+    createdAt: number;
+    kind: "status";
+    status: string;
+    detail?: string;
+};
+export type QueuedAgentActionInput = {
+    kind: "chat";
+    text: string;
+} | {
+    kind: "dm";
+    target: string;
+    text: string;
+} | {
+    kind: "send_file";
+    target: string;
+    filePath: string;
+    transferKind: FileTransferKind;
+} | {
+    kind: "command";
+    target: string;
+    command: string;
+    args?: unknown;
+} | {
+    kind: "response";
+    target: string;
+    requestId: string;
+    result?: unknown;
+    error?: string;
+} | {
+    kind: "event";
+    topic: string;
+    eventKind: string;
+    data?: unknown;
+} | {
+    kind: "status";
+    status: string;
+    detail?: string;
+};
+export type InboxMessage = {
+    envelope: MessageEnvelope;
+    receivedAt: number;
+    path: string;
+};
+export type PeerInboxSummary = {
+    streamId: string;
+    name: string;
+    role: string;
+    connected: boolean;
+    status: string;
+    statusDetail: string;
+    summary: string | null;
+    can: string[];
+    asks: AgentAsk[];
+    shares: SharedFolderSummary[];
+};
+export type InboxSummary = {
+    connected: boolean;
+    pending: number;
+    queued: number;
+    room: string | null;
+    streamId: string | null;
+    stale: boolean;
+    peersKnown: number;
+    peersConnected: number;
+    senders: Array<{
+        streamId: string;
+        name: string;
+        count: number;
+    }>;
+    types: Array<{
+        type: string;
+        count: number;
+    }>;
+    commands: Array<{
+        name: string;
+        count: number;
+    }>;
+    events: Array<{
+        kind: string;
+        count: number;
+    }>;
+    peers: PeerInboxSummary[];
+};
+type StatePaths = {
+    stateDir: string;
+    inboxDir: string;
+    archiveDir: string;
+    outboxDir: string;
+    sessionFile: string;
+    peersFile: string;
+};
+export declare function ensureAgentState(stateDir: string): StatePaths;
+export declare function writeAgentSession(stateDir: string, session: AgentSessionState): void;
+export declare function readAgentSession(stateDir: string): AgentSessionState | null;
+export declare function writePeersSnapshot(stateDir: string, peers: unknown): void;
+export declare function readPeersSnapshot(stateDir: string): unknown;
+export declare function queueAgentAction(stateDir: string, action: QueuedAgentActionInput): QueuedAgentAction;
+export declare function listQueuedAgentActions(stateDir: string): Array<{
+    action: QueuedAgentAction;
+    path: string;
+}>;
+export declare function removeQueuedAgentAction(filePath: string): void;
+export declare function storeInboxMessage(stateDir: string, envelope: MessageEnvelope): InboxMessage;
+export declare function listInboxMessages(stateDir: string): InboxMessage[];
+export declare function takeInboxMessages(stateDir: string, count?: number, peek?: boolean): InboxMessage[];
+export declare function getInboxSummary(stateDir: string): InboxSummary;
+export declare function isInboxWorthy(type: MessageType): boolean;
+export {};

package/dist/agent-state.js

@@ -0,0 +1,304 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { createMessageId, } from "./protocol.js";
+const SESSION_FILE = "session.json";
+const PEERS_FILE = "peers.json";
+export function ensureAgentState(stateDir) {
+    const resolved = path.resolve(stateDir);
+    const paths = {
+        stateDir: resolved,
+        inboxDir: path.join(resolved, "inbox"),
+        archiveDir: path.join(resolved, "archive"),
+        outboxDir: path.join(resolved, "outbox"),
+        sessionFile: path.join(resolved, SESSION_FILE),
+        peersFile: path.join(resolved, PEERS_FILE),
+    };
+    mkdirSync(paths.stateDir, { recursive: true });
+    mkdirSync(paths.inboxDir, { recursive: true });
+    mkdirSync(paths.archiveDir, { recursive: true });
+    mkdirSync(paths.outboxDir, { recursive: true });
+    return paths;
+}
+export function writeAgentSession(stateDir, session) {
+    const paths = ensureAgentState(stateDir);
+    writeJsonAtomic(paths.sessionFile, session);
+}
+export function readAgentSession(stateDir) {
+    const paths = ensureAgentState(stateDir);
+    return readJsonFile(paths.sessionFile);
+}
+export function writePeersSnapshot(stateDir, peers) {
+    const paths = ensureAgentState(stateDir);
+    writeJsonAtomic(paths.peersFile, peers);
+}
+export function readPeersSnapshot(stateDir) {
+    const paths = ensureAgentState(stateDir);
+    return readJsonFile(paths.peersFile) ?? [];
+}
+export function queueAgentAction(stateDir, action) {
+    const paths = ensureAgentState(stateDir);
+    const queued = {
+        ...action,
+        id: createMessageId(),
+        createdAt: Date.now(),
+    };
+    const filename = `${queued.createdAt}_${queued.id}.json`;
+    writeJsonAtomic(path.join(paths.outboxDir, filename), queued);
+    return queued;
+}
+export function listQueuedAgentActions(stateDir) {
+    const paths = ensureAgentState(stateDir);
+    const entries = listJsonFiles(paths.outboxDir);
+    return entries
+        .map((file) => {
+        const action = readJsonFile(file);
+        return action ? { action, path: file } : null;
+    })
+        .filter((item) => item !== null)
+        .sort((a, b) => a.action.createdAt - b.action.createdAt);
+}
+export function removeQueuedAgentAction(filePath) {
+    if (existsSync(filePath)) {
+        rmSync(filePath, { force: true });
+    }
+}
+export function storeInboxMessage(stateDir, envelope) {
+    const paths = ensureAgentState(stateDir);
+    const filename = `${envelope.ts}_${envelope.id}.json`;
+    const filePath = path.join(paths.inboxDir, filename);
+    const record = {
+        envelope,
+        receivedAt: Date.now(),
+    };
+    if (!existsSync(filePath)) {
+        writeJsonAtomic(filePath, record);
+    }
+    return {
+        envelope,
+        receivedAt: record.receivedAt,
+        path: filePath,
+    };
+}
+export function listInboxMessages(stateDir) {
+    const paths = ensureAgentState(stateDir);
+    return listJsonFiles(paths.inboxDir)
+        .map((file) => {
+        const item = readJsonFile(file);
+        return item ? { ...item, path: file } : null;
+    })
+        .filter((item) => item !== null)
+        .sort((a, b) => a.envelope.ts - b.envelope.ts);
+}
+export function takeInboxMessages(stateDir, count = 20, peek = false) {
+    const paths = ensureAgentState(stateDir);
+    const items = listInboxMessages(stateDir).slice(0, count);
+    if (!peek) {
+        for (const item of items) {
+            const target = path.join(paths.archiveDir, path.basename(item.path));
+            renameSync(item.path, target);
+            item.path = target;
+        }
+    }
+    return items;
+}
+export function getInboxSummary(stateDir) {
+    const paths = ensureAgentState(stateDir);
+    const session = readJsonFile(paths.sessionFile);
+    const messages = listInboxMessages(stateDir);
+    const queued = listQueuedAgentActions(stateDir).length;
+    const peers = normalizePeers(readJsonFile(paths.peersFile) ?? []);
+    const senders = new Map();
+    const types = new Map();
+    const commands = new Map();
+    const events = new Map();
+    for (const item of messages) {
+        const key = item.envelope.from.streamId;
+        const sender = senders.get(key) ?? {
+            streamId: item.envelope.from.streamId,
+            name: item.envelope.from.name,
+            count: 0,
+        };
+        sender.count += 1;
+        senders.set(key, sender);
+        types.set(item.envelope.type, (types.get(item.envelope.type) ?? 0) + 1);
+        if (item.envelope.type === "command") {
+            const commandName = getStringField(item.envelope.payload, "command");
+            if (commandName) {
+                commands.set(commandName, (commands.get(commandName) ?? 0) + 1);
+            }
+        }
+        if (item.envelope.type === "event") {
+            const eventKind = getStringField(item.envelope.payload, "kind");
+            if (eventKind) {
+                events.set(eventKind, (events.get(eventKind) ?? 0) + 1);
+            }
+        }
+    }
+    const updatedAt = session?.updatedAt ?? 0;
+    const stale = updatedAt > 0 ? Date.now() - updatedAt > 20_000 : true;
+    return {
+        connected: session?.connected === true && !stale,
+        pending: messages.length,
+        queued,
+        room: session?.room ?? null,
+        streamId: session?.streamId ?? null,
+        stale,
+        peersKnown: peers.length,
+        peersConnected: peers.filter((peer) => peer.connected).length,
+        senders: [...senders.values()].sort((a, b) => b.count - a.count),
+        types: sortTypeCounts(types),
+        commands: sortCommandCounts(commands),
+        events: sortEventCounts(events),
+        peers,
+    };
+}
+export function isInboxWorthy(type) {
+    return ![
+        "announce",
+        "skill_update",
+        "ping",
+        "pong",
+        "history_request",
+        "file_offer",
+        "file_chunk",
+        "file_complete",
+        "file_ack",
+    ].includes(type);
+}
+function listJsonFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => path.join(dir, name))
+        .sort();
+}
+function readJsonFile(filePath) {
+    try {
+        const raw = readFileSync(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonAtomic(filePath, data) {
+    const tmp = `${filePath}.${createMessageId()}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    renameSync(tmp, filePath);
+}
+function getStringField(payload, key) {
+    if (typeof payload !== "object" || payload === null)
+        return null;
+    const value = payload[key];
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function sortTypeCounts(map) {
+    return [...map.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([type, count]) => ({ type, count }));
+}
+function sortCommandCounts(map) {
+    return [...map.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([name, count]) => ({ name, count }));
+}
+function sortEventCounts(map) {
+    return [...map.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([kind, count]) => ({ kind, count }));
+}
+function normalizePeers(peers) {
+    return peers
+        .map((peer) => normalizePeer(peer))
+        .filter((peer) => peer !== null)
+        .sort((a, b) => Number(b.connected) - Number(a.connected) || a.streamId.localeCompare(b.streamId));
+}
+function normalizePeer(peer) {
+    if (typeof peer !== "object" || peer === null)
+        return null;
+    const data = peer;
+    const streamId = getStringLike(data.streamId);
+    if (!streamId)
+        return null;
+    const agentProfile = (typeof data.agentProfile === "object" && data.agentProfile !== null)
+        ? data.agentProfile
+        : null;
+    return {
+        streamId,
+        name: getStringLike(data.name) ?? streamId,
+        role: getStringLike(data.role) ?? "unknown",
+        connected: data.connected === true,
+        status: getStringLike(data.status) ?? "unknown",
+        statusDetail: getStringLike(data.statusDetail) ?? "",
+        summary: getStringLike(agentProfile?.summary) ?? null,
+        can: normalizeStringArray(agentProfile?.can),
+        asks: normalizeAgentAsks(agentProfile?.asks),
+        shares: normalizeSharedFolders(agentProfile?.shares),
+    };
+}
+function normalizeAgentAsks(value) {
+    if (!Array.isArray(value))
+        return [];
+    const asks = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const ask = item;
+        const name = getStringLike(ask.name);
+        if (!name)
+            continue;
+        const key = name.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const normalized = {
+            name,
+            description: getStringLike(ask.description) ?? `${name} command`,
+        };
+        const via = getStringLike(ask.via);
+        if (via === "command" || via === "chat" || via === "event") {
+            normalized.via = via;
+        }
+        const example = getStringLike(ask.example);
+        if (example)
+            normalized.example = example;
+        asks.push(normalized);
+    }
+    return asks;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value
+            .map((item) => getStringLike(item))
+            .filter((item) => Boolean(item)))];
+}
+function normalizeSharedFolders(value) {
+    if (!Array.isArray(value))
+        return [];
+    const shares = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const share = item;
+        const name = getStringLike(share.name);
+        if (!name)
+            continue;
+        const key = name.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const normalized = { name };
+        const description = getStringLike(share.description);
+        if (description)
+            normalized.description = description;
+        shares.push(normalized);
+    }
+    return shares;
+}
+function getStringLike(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/dist/cli-lib.d.ts

@@ -0,0 +1,132 @@
+import { type AgentProfile } from "./protocol.js";
+import { type SharedFolderConfig } from "./shared-folders.js";
+export type CliCommonOptions = {
+    room: string;
+    streamId: string;
+    name: string;
+    role: string;
+    password: string | false;
+    waitMs: number;
+    stateDir: string | null;
+    agentProfile?: AgentProfile;
+    sharedFolders: SharedFolderConfig[];
+};
+export type SkillRuntime = "claude" | "codex";
+export type CliCommand = {
+    kind: "help";
+} | {
+    kind: "menu";
+    options: CliCommonOptions;
+} | {
+    kind: "install-skill";
+    runtime: SkillRuntime;
+} | {
+    kind: "start";
+    options: CliCommonOptions;
+} | {
+    kind: "stop";
+    stateDir: string;
+} | {
+    kind: "status";
+    stateDir: string;
+} | {
+    kind: "room";
+    stateDir: string;
+} | {
+    kind: "agent";
+    options: CliCommonOptions;
+} | {
+    kind: "notify";
+    stateDir: string;
+} | {
+    kind: "read";
+    stateDir: string;
+    take: number;
+    peek: boolean;
+} | {
+    kind: "connect";
+    options: CliCommonOptions;
+} | {
+    kind: "chat";
+    options: CliCommonOptions;
+    text: string;
+} | {
+    kind: "dm";
+    options: CliCommonOptions;
+    target: string;
+    text: string;
+} | {
+    kind: "send-file";
+    options: CliCommonOptions;
+    target: string;
+    filePath: string;
+} | {
+    kind: "send-image";
+    options: CliCommonOptions;
+    target: string;
+    filePath: string;
+} | {
+    kind: "shares";
+    options: CliCommonOptions;
+    target: string;
+} | {
+    kind: "list-files";
+    options: CliCommonOptions;
+    target: string;
+    share: string;
+    folderPath: string;
+} | {
+    kind: "get-file";
+    options: CliCommonOptions;
+    target: string;
+    share: string;
+    filePath: string;
+} | {
+    kind: "command";
+    options: CliCommonOptions;
+    target: string;
+    command: string;
+    args: unknown;
+} | {
+    kind: "respond";
+    options: CliCommonOptions;
+    target: string;
+    requestId: string;
+    result: unknown;
+    error?: string;
+} | {
+    kind: "event";
+    options: CliCommonOptions;
+    topic: string;
+    eventKind: string;
+    data: unknown;
+} | {
+    kind: "task";
+    options: CliCommonOptions;
+    target: string;
+    request: string;
+} | {
+    kind: "review";
+    options: CliCommonOptions;
+    target: string;
+    request: string;
+} | {
+    kind: "plan";
+    options: CliCommonOptions;
+    target: string;
+    request: string;
+} | {
+    kind: "approve";
+    options: CliCommonOptions;
+    target: string;
+    request: string;
+};
+export declare function helpText(): string;
+export declare function parseCliArgs(argv: string[], env?: NodeJS.ProcessEnv): CliCommand;
+export declare function defaultStreamId(name: string): string;
+export declare function defaultNameForRuntime(runtime: string | undefined): string;
+export declare function defaultStreamIdForRuntime(name: string, runtime: string | undefined): string;
+export declare function parseJsonMaybe(value: string): unknown;
+export declare function getSkillInstallTarget(runtime: SkillRuntime, env?: NodeJS.ProcessEnv): string;
+export declare function getSkillInstallTargets(runtime: SkillRuntime, env?: NodeJS.ProcessEnv): string[];
+export declare function getDefaultStateDir(streamId: string, env?: NodeJS.ProcessEnv): string;