@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/apps/daemon/dist/gateway/store.d.ts

@@ -0,0 +1,92 @@
+import type { GatewayChannelInput, GatewayChannelDomain, GatewayChannelPublic, GatewayChannelType, GatewayDestination, GatewayEventPayload, GatewayInboundMode, GatewayLastDeliveredMessage, GatewayLastMessageRef, GatewayProcessingReactionConfig } from "../../../../packages/shared/dist/index.js";
+export type GatewayChannelConfig = {
+    id: string;
+    type: GatewayChannelType;
+    enabled: boolean;
+    domain?: GatewayChannelDomain;
+    appId?: string;
+    appSecret?: string;
+    inboundMode: GatewayInboundMode;
+    processingReaction: GatewayProcessingReactionConfig;
+    targetMachineId?: string;
+    targetSessionId?: string;
+    targetCwd?: string;
+    defaultAgent: string;
+    defaultModel?: string;
+    allowAnySender?: boolean;
+    allowedChatIds?: string[];
+    allowedSenderIds?: string[];
+    localToken?: string;
+    localSecret?: string;
+    lastError?: string;
+    lastReceived?: GatewayLastMessageRef;
+    lastAdmitted?: GatewayLastMessageRef;
+    lastReplied?: GatewayLastMessageRef;
+    lastDeliveredMessage?: GatewayLastDeliveredMessage;
+    createdAt: string;
+    updatedAt: string;
+};
+export type GatewayConversationMapping = {
+    channelId: string;
+    externalConversationId: string;
+    sessionId: string;
+    createRequestId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type GatewayQueuedMessage = {
+    channelId: string;
+    externalConversationId: string;
+    externalMessageId: string;
+    sessionId: string;
+    requestId: string;
+    turnId: string;
+    text: string;
+    destination?: GatewayDestination;
+    senderPlatformUserId?: string;
+    senderDisplayName?: string;
+    queuedAt: string;
+    updatedAt: string;
+};
+export type GatewayPendingReply = {
+    channelId: string;
+    externalConversationId: string;
+    externalMessageId: string;
+    sessionId: string;
+    requestId: string;
+    turnId: string;
+    deliveryId: string;
+    destination?: GatewayDestination;
+    payload?: GatewayEventPayload;
+    status: "pending" | "delivered";
+    attempts: number;
+    platformMessageId?: string;
+    lastError?: string;
+    nextAttemptAt?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type GatewayReplyHistory = {
+    channelId: string;
+    externalConversationId: string;
+    externalMessageId: string;
+    sessionId?: string;
+    requestId?: string;
+    turnId?: string;
+    deliveryId: string;
+    platformMessageId?: string;
+    repliedAt: string;
+};
+export type GatewayStore = {
+    version: 1;
+    channels: GatewayChannelConfig[];
+    mappings: GatewayConversationMapping[];
+    queue: GatewayQueuedMessage[];
+    pendingReplies: GatewayPendingReply[];
+    replyHistory: GatewayReplyHistory[];
+};
+export declare function readGatewayStore(): Promise<GatewayStore>;
+export declare function updateGatewayStore(update: (store: GatewayStore) => GatewayStore | Promise<GatewayStore>): Promise<GatewayStore>;
+export declare function publicGatewayChannel(channel: GatewayChannelConfig, listening?: boolean): GatewayChannelPublic;
+export declare function upsertGatewayChannel(current: GatewayStore, input: GatewayChannelInput, defaultMachineId: string): GatewayStore;
+export {};

package/apps/daemon/dist/gateway/store.js

@@ -0,0 +1,268 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { configDir, gatewayStorePath } from "../paths.js";
+function emptyGatewayStore() {
+    return { version: 1, channels: [], mappings: [], queue: [], pendingReplies: [], replyHistory: [] };
+}
+export async function readGatewayStore() {
+    let store;
+    try {
+        const parsed = JSON.parse(await fs.readFile(gatewayStorePath, "utf8"));
+        if (parsed.version !== 1 || !Array.isArray(parsed.channels) || !Array.isArray(parsed.mappings))
+            return await mergeLegacyGatewayStore(emptyGatewayStore());
+        store = {
+            version: 1,
+            channels: parsed.channels.map(normalizeGatewayChannel),
+            mappings: parsed.mappings,
+            queue: Array.isArray(parsed.queue) ? parsed.queue : [],
+            pendingReplies: Array.isArray(parsed.pendingReplies) ? parsed.pendingReplies : [],
+            replyHistory: Array.isArray(parsed.replyHistory) ? parsed.replyHistory : [],
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return await mergeLegacyGatewayStore(emptyGatewayStore());
+        throw error;
+    }
+    return await mergeLegacyGatewayStore(store);
+}
+async function writeGatewayStore(store) {
+    await fs.mkdir(configDir, { recursive: true });
+    const tmpPath = `${gatewayStorePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tmpPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(tmpPath, gatewayStorePath);
+    await fs.chmod(gatewayStorePath, 0o600);
+}
+let gatewayStoreUpdateChain = Promise.resolve();
+export async function updateGatewayStore(update) {
+    const run = gatewayStoreUpdateChain.then(async () => {
+        const current = await readGatewayStore();
+        const next = await update(current);
+        await writeGatewayStore(next);
+        return next;
+    });
+    gatewayStoreUpdateChain = run.catch(() => undefined);
+    return await run;
+}
+export function publicGatewayChannel(channel, listening = false) {
+    return {
+        id: channel.id,
+        type: channel.type,
+        enabled: channel.enabled,
+        domain: channel.domain,
+        inboundMode: channel.inboundMode,
+        processingReaction: channel.processingReaction,
+        targetMachineId: channel.targetMachineId,
+        targetSessionId: channel.targetSessionId,
+        targetCwd: channel.targetCwd,
+        defaultAgent: channel.defaultAgent,
+        defaultModel: channel.defaultModel,
+        allowAnySender: channel.allowAnySender,
+        allowedChatIds: channel.allowedChatIds,
+        allowedSenderIds: channel.allowedSenderIds,
+        hasAppId: Boolean(channel.appId),
+        hasAppSecret: Boolean(channel.appSecret),
+        hasLocalToken: Boolean(channel.localToken),
+        hasLocalSecret: Boolean(channel.localSecret),
+        listening,
+        lastError: channel.lastError,
+        lastReceived: channel.lastReceived,
+        lastAdmitted: channel.lastAdmitted,
+        lastReplied: channel.lastReplied,
+        lastDeliveredMessage: channel.lastDeliveredMessage,
+        createdAt: channel.createdAt,
+        updatedAt: channel.updatedAt,
+    };
+}
+export function upsertGatewayChannel(current, input, defaultMachineId) {
+    const id = input.id ?? input.type;
+    const existing = current.channels.find((channel) => channel.id === id);
+    const now = new Date().toISOString();
+    const channel = {
+        ...(existing ?? { createdAt: now }),
+        id,
+        type: input.type,
+        enabled: input.enabled ?? existing?.enabled ?? true,
+        domain: input.domain ?? existing?.domain ?? "feishu",
+        appId: input.appId ?? existing?.appId,
+        appSecret: input.appSecret ?? existing?.appSecret,
+        inboundMode: input.inboundMode ?? existing?.inboundMode ?? "mention",
+        processingReaction: {
+            enabled: input.processingReaction?.enabled ?? existing?.processingReaction?.enabled ?? true,
+            emojiType: input.processingReaction?.emojiType ?? existing?.processingReaction?.emojiType ?? "Typing",
+        },
+        targetMachineId: input.targetMachineId ?? existing?.targetMachineId ?? defaultMachineId,
+        targetSessionId: input.targetSessionId ?? existing?.targetSessionId,
+        targetCwd: input.targetCwd ?? existing?.targetCwd,
+        defaultAgent: input.defaultAgent ?? existing?.defaultAgent ?? "codex",
+        defaultModel: input.defaultModel ?? existing?.defaultModel,
+        allowAnySender: input.allowAnySender ?? existing?.allowAnySender ?? true,
+        allowedChatIds: input.allowedChatIds ?? existing?.allowedChatIds,
+        allowedSenderIds: input.allowedSenderIds ?? existing?.allowedSenderIds,
+        localToken: input.type === "lark" ? undefined : input.localToken ?? existing?.localToken,
+        localSecret: input.type === "lark" ? undefined : input.localSecret ?? existing?.localSecret,
+        lastError: existing?.lastError,
+        lastReceived: existing?.lastReceived,
+        lastAdmitted: existing?.lastAdmitted,
+        lastReplied: existing?.lastReplied,
+        lastDeliveredMessage: existing?.lastDeliveredMessage,
+        updatedAt: now,
+    };
+    return {
+        ...current,
+        channels: [channel, ...current.channels.filter((item) => item.id !== id)],
+    };
+}
+function normalizeGatewayChannel(channel) {
+    return {
+        ...channel,
+        localToken: channel.type === "lark" ? undefined : channel.localToken,
+        localSecret: channel.type === "lark" ? undefined : channel.localSecret,
+        inboundMode: channel.inboundMode ?? "mention",
+        processingReaction: channel.processingReaction ?? { enabled: true, emojiType: "Typing" },
+        allowAnySender: channel.allowAnySender ?? true,
+        allowedChatIds: Array.isArray(channel.allowedChatIds) ? channel.allowedChatIds.filter(Boolean) : undefined,
+        allowedSenderIds: Array.isArray(channel.allowedSenderIds) ? channel.allowedSenderIds.filter(Boolean) : undefined,
+    };
+}
+async function mergeLegacyGatewayStore(store) {
+    const legacy = await readLegacyGatewayStore();
+    if (!legacy)
+        return store;
+    let changed = false;
+    let channels = store.channels;
+    for (const legacyChannel of legacy.channels) {
+        if (channels.some((channel) => channel.id === legacyChannel.id))
+            continue;
+        if (channels.some((channel) => channel.type === "lark" && channel.enabled && channel.appId === legacyChannel.appId))
+            continue;
+        channels = [legacyChannel, ...channels];
+        changed = true;
+    }
+    const channelIds = new Set(channels.map((channel) => channel.id));
+    let mappings = store.mappings;
+    for (const legacyMapping of legacy.mappings) {
+        if (!channelIds.has(legacyMapping.channelId))
+            continue;
+        if (mappings.some((mapping) => mapping.channelId === legacyMapping.channelId
+            && mapping.externalConversationId === legacyMapping.externalConversationId))
+            continue;
+        mappings = [legacyMapping, ...mappings];
+        changed = true;
+    }
+    if (!changed)
+        return store;
+    const next = { ...store, channels, mappings };
+    await writeGatewayStore(next);
+    return next;
+}
+async function readLegacyGatewayStore() {
+    const legacyConfig = await readJsonFile(path.join(configDir, "gateways.json"));
+    const legacyGateways = Array.isArray(legacyConfig?.gateways) ? legacyConfig.gateways : [];
+    if (legacyGateways.length === 0)
+        return undefined;
+    const legacyState = await readJsonFile(path.join(configDir, "gateway-state.json"));
+    const legacyBindings = Array.isArray(legacyState?.bindings) ? legacyState.bindings : [];
+    const channels = legacyGateways
+        .map(legacyChannelFromRecord)
+        .filter((channel) => Boolean(channel));
+    const channelIds = new Set(channels.map((channel) => channel.id));
+    const mappings = legacyBindings
+        .map(legacyMappingFromRecord)
+        .filter((mapping) => mapping !== undefined && channelIds.has(mapping.channelId));
+    return channels.length > 0 || mappings.length > 0 ? { channels, mappings } : undefined;
+}
+async function readJsonFile(filePath) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function legacyChannelFromRecord(value) {
+    const record = isRecord(value) ? value : undefined;
+    if (!record)
+        return undefined;
+    const platform = stringField(record, "platform");
+    if (platform !== "feishu" && platform !== "lark")
+        return undefined;
+    const id = stringField(record, "id");
+    if (!id)
+        return undefined;
+    const identities = Array.isArray(record.identities) ? record.identities.filter(isRecord) : [];
+    const allowedSenderIds = uniqueStrings(identities.map((identity) => stringField(identity, "platformUserId")));
+    const allowAnySender = booleanField(record, "allowAllUsers") ?? allowedSenderIds.length === 0;
+    const createdAt = legacyIsoDate(record.createdAt);
+    const updatedAt = legacyIsoDate(record.updatedAt, createdAt);
+    return normalizeGatewayChannel({
+        id,
+        type: "lark",
+        enabled: booleanField(record, "enabled") ?? true,
+        domain: gatewayDomain(stringField(record, "domain") ?? platform),
+        appId: stringField(record, "appId"),
+        appSecret: stringField(record, "appSecret"),
+        inboundMode: booleanField(record, "requireMention") === false ? "all" : "mention",
+        processingReaction: { enabled: true, emojiType: "Typing" },
+        targetCwd: stringField(record, "defaultCwd"),
+        defaultAgent: stringField(record, "defaultAgent") ?? "codex",
+        allowAnySender,
+        allowedSenderIds: allowAnySender ? undefined : allowedSenderIds,
+        createdAt,
+        updatedAt,
+    });
+}
+function legacyMappingFromRecord(value) {
+    const record = isRecord(value) ? value : undefined;
+    if (!record)
+        return undefined;
+    const channelId = stringField(record, "gatewayId");
+    const platformChatId = stringField(record, "platformChatId");
+    const sessionId = stringField(record, "sessionId");
+    if (!channelId || !platformChatId || !sessionId)
+        return undefined;
+    const contextKind = stringField(record, "contextKind");
+    const contextKey = stringField(record, "contextKey");
+    const externalConversationId = contextKind === "thread" && contextKey
+        ? `${platformChatId}:thread:${contextKey}`
+        : `${platformChatId}:main`;
+    const createdAt = legacyIsoDate(record.createdAt);
+    return {
+        channelId,
+        externalConversationId,
+        sessionId,
+        createRequestId: stableLegacyGatewayId("gw_create", channelId, externalConversationId),
+        createdAt,
+        updatedAt: legacyIsoDate(record.updatedAt, createdAt),
+    };
+}
+function stableLegacyGatewayId(prefix, ...parts) {
+    return `${prefix}_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 32)}`;
+}
+function gatewayDomain(value) {
+    return value === "lark" ? "lark" : "feishu";
+}
+function legacyIsoDate(value, fallback = new Date().toISOString()) {
+    const numeric = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    const date = Number.isFinite(numeric) ? new Date(numeric) : new Date(fallback);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : new Date().toISOString();
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value))));
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function booleanField(record, key) {
+    const value = record[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=store.js.map

package/apps/daemon/dist/memory/handler.d.ts

@@ -0,0 +1,7 @@
+import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+type MemoryCommand = Extract<MachineCommand, {
+    type: "machine:memory";
+}>;
+export declare function handleMemoryCommand(ws: WebSocket, config: DaemonConfig, command: MemoryCommand): Promise<void>;
+export {};

package/apps/daemon/dist/memory/handler.js

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+import { decryptJson, encryptJson } from "../../../../packages/shared/dist/index.js";
+import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
+import { applyMemoryDocumentSnapshot, ensureMemoryFiles, memoryDocumentSnapshots, memoryOverview, promoteMemory, readMemoryFile, searchMemory, writeMemory, } from "./manager.js";
+export async function handleMemoryCommand(ws, config, command) {
+    if (!claimCommandRequest(ws, command.requestId))
+        return;
+    const result = await executeMemoryCommand(config, command);
+    await sendCommandResponse(ws, {
+        type: "machine:memoryResult",
+        requestId: command.requestId,
+        machineId: config.machineId,
+        result,
+    });
+}
+async function executeMemoryCommand(config, command) {
+    const projectKey = command.projectKey ?? command.write?.projectKey ?? command.promote?.projectKey;
+    if (!projectKey)
+        throw new Error("memory projectKey is required");
+    if (command.action === "overview" || command.action === "status") {
+        return { action: command.action, overview: await memoryOverview(projectKey, command.mode ?? "readonly"), mode: command.mode ?? "readonly" };
+    }
+    if (command.action === "read") {
+        if (!command.path)
+            throw new Error("memory read requires path");
+        const read = await readMemoryFile(projectKey, command.path);
+        return { action: "read", ...read };
+    }
+    if (command.action === "search") {
+        const query = command.query ?? "";
+        const results = query.trim() ? await searchMemory(projectKey, query, command.limit ?? 5) : [];
+        return { action: "search", results };
+    }
+    if (command.action === "reindex") {
+        await ensureMemoryFiles(projectKey);
+        return { action: "reindex", overview: await memoryOverview(projectKey, command.mode ?? "readonly") };
+    }
+    if (command.action === "write") {
+        if (!command.write)
+            throw new Error("memory write requires write payload");
+        const written = await writeMemory(command.write);
+        return { action: "write", written, path: written.path, layer: written.layer };
+    }
+    if (command.action === "promote") {
+        if (!command.promote)
+            throw new Error("memory promote requires promote payload");
+        const promoted = await promoteMemory(command.promote);
+        return { action: "promote", promoted, written: promoted, path: promoted.path, layer: promoted.layer };
+    }
+    if (command.action === "sync") {
+        const conflicts = await syncMemoryDocuments(config, projectKey);
+        return { action: "sync", overview: await memoryOverview(projectKey, command.mode ?? "readonly"), conflicts, syncedAt: new Date().toISOString() };
+    }
+    throw new Error(`Unsupported memory action: ${command.action}`);
+}
+async function syncMemoryDocuments(config, projectKey) {
+    const conflicts = [];
+    const remote = await fetch(`${config.relayUrl}/api/machine/memory-documents?projectKey=${encodeURIComponent(projectKey)}`, {
+        headers: { authorization: `Bearer ${config.machineToken}` },
+    });
+    if (remote.ok) {
+        const body = await remote.json();
+        for (const document of body.documents ?? []) {
+            if (!document.encryptedDocument)
+                continue;
+            const payload = await decryptJson(config.accountSecret, document.encryptedDocument);
+            if (typeof payload.path === "string" && typeof payload.content === "string" && isMemoryLayer(payload.layer)) {
+                const applied = await applyMemoryDocumentSnapshot(projectKey, payload);
+                if (applied.conflict)
+                    conflicts.push(applied.conflict);
+            }
+        }
+    }
+    for (const snapshot of await memoryDocumentSnapshots(projectKey)) {
+        const encryptedDocument = await encryptJson(config.accountSecret, `memory-doc:${projectKey}:${snapshot.path}`, {
+            path: snapshot.path,
+            layer: snapshot.layer,
+            content: snapshot.content,
+            updatedAt: snapshot.summary.updatedAt,
+            contentHash: snapshot.summary.contentHash,
+        });
+        const response = await fetch(`${config.relayUrl}/api/machine/memory-documents`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${config.machineToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                id: memoryDocumentId(projectKey, snapshot.path),
+                projectKey,
+                encryptedDocument,
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`memory document sync failed: ${response.status}`);
+    }
+    return conflicts;
+}
+function memoryDocumentId(projectKey, path) {
+    return `memdoc_${createHash("sha256").update(`${projectKey}\0${path}`).digest("base64url").slice(0, 32)}`;
+}
+function isMemoryLayer(value) {
+    return value === "user" || value === "curated" || value === "daily";
+}
+//# sourceMappingURL=handler.js.map

package/apps/daemon/dist/memory/manager.d.ts

@@ -0,0 +1,44 @@
+import type { MemoryCitation, MemoryFileSummary, MemoryLayer, MemoryMode, MemoryOverview, MemoryPromoteInput, MemorySearchResult, MemorySyncConflict, MemoryTurnOptions, MemoryWriteInput } from "../../../../packages/shared/dist/index.js";
+export type PreparedMemoryContext = {
+    text: string;
+    used: MemorySearchResult[];
+    options: MemoryTurnOptions;
+};
+export declare function memoryOverview(projectKey: string, mode?: MemoryMode): Promise<MemoryOverview>;
+export declare function readMemoryFile(projectKey: string, requestedPath: string): Promise<{
+    path: string;
+    layer: MemoryLayer;
+    content: string;
+    citations: MemoryCitation[];
+}>;
+export declare function writeMemory(input: MemoryWriteInput): Promise<MemoryFileSummary>;
+export declare function searchMemory(projectKey: string, query: string, limit?: number, options?: {
+    includeDaily?: boolean;
+}): Promise<MemorySearchResult[]>;
+export declare function prepareMemoryContext(options: MemoryTurnOptions, promptText: string): Promise<PreparedMemoryContext>;
+export declare function writeTurnMemory(options: MemoryTurnOptions | undefined, input: {
+    promptText: string;
+    outputPreview: string;
+    requestId: string;
+    turnId: string;
+    status: string;
+}): Promise<MemoryFileSummary | undefined>;
+export declare function maybePromoteMemory(options: MemoryTurnOptions | undefined, promptText: string): Promise<MemoryFileSummary | undefined>;
+export declare function promoteMemory(input: MemoryPromoteInput): Promise<MemoryFileSummary>;
+export declare function ensureMemoryFiles(projectKey: string): Promise<void>;
+export declare function memoryDocumentSnapshots(projectKey: string): Promise<Array<{
+    path: string;
+    layer: MemoryLayer;
+    content: string;
+    summary: MemoryFileSummary;
+}>>;
+export declare function applyMemoryDocumentSnapshot(projectKey: string, snapshot: {
+    path: string;
+    layer: MemoryLayer;
+    content: string;
+    updatedAt?: string;
+    contentHash?: string;
+}): Promise<{
+    summary: MemoryFileSummary;
+    conflict?: MemorySyncConflict;
+}>;