@cydm/happy-elves 0.1.0-beta.83 → 0.1.0-beta.84

package/apps/cli/dist/commands/lib/args.js

@@ -52,6 +52,8 @@ const valueFlags = new Set([
     "runtime-session",
     "shell",
     "actions",
+    "allow-chat",
+    "allow-sender",
     "expires-in",
     "format",
     "loops",

package/apps/cli/dist/commands/lib/usage.js

@@ -108,7 +108,7 @@ session stars, recent sessions, pinned workspaces, and current project defaults.
 `,
     gateway: `Usage:
   happy-elves gateway enable [<channelId>] --channel lark --machine <machineId> (--cwd <cwd> | --session <sessionId>) [--agent codex] [--model <model>] --json
-  happy-elves gateway enable lark-main --channel lark --machine <machineId> (--cwd <cwd> | --session <sessionId>) --app-id <appId> --app-secret-stdin [--domain feishu|lark] [--inbound mention|all] --json
+  happy-elves gateway enable lark-main --channel lark --machine <machineId> (--cwd <cwd> | --session <sessionId>) --app-id <appId> --app-secret-stdin [--domain feishu|lark] [--inbound mention|all] (--allow-any-sender | --allow-chat <id[,id]> | --allow-sender <id[,id]>) --json
   happy-elves gateway disable [<channelId>] [--machine <machineId>] --json
   happy-elves gateway status [--machine <machineId>] [--include-debug] [--json]
   happy-elves gateway test [<channelId>] [--machine <machineId>] --conversation <externalConversationId> --message-id <externalMessageId> --text <prompt> --json
@@ -116,6 +116,7 @@ session stars, recent sessions, pinned workspaces, and current project defaults.
 
 Gateway v1 official Feishu/Lark path is daemon-backed SDK long connection.
 App secrets are read from stdin and stored only in the target daemon config.
+Lark/Feishu product gateways require an explicit inbound sender/chat policy.
 gateway serve is kept for fake/local debugging only; lark-cli is not a product dependency.
 `,
     memory: `Usage:

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.83",
+  "version": "0.1.0-beta.84",
   "private": true,
   "type": "module"
 }

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

@@ -1,14 +1,17 @@
+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 emptyGatewayStore();
-        return {
+            return await mergeLegacyGatewayStore(emptyGatewayStore());
+        store = {
             version: 1,
             channels: parsed.channels.map(normalizeGatewayChannel),
             mappings: parsed.mappings,
@@ -19,9 +22,10 @@ export async function readGatewayStore() {
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return emptyGatewayStore();
+            return await mergeLegacyGatewayStore(emptyGatewayStore());
         throw error;
     }
+    return await mergeLegacyGatewayStore(store);
 }
 async function writeGatewayStore(store) {
     await fs.mkdir(configDir, { recursive: true });
@@ -122,4 +126,143 @@ function normalizeGatewayChannel(channel) {
         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/session/events.d.ts

@@ -25,7 +25,7 @@ export type HistoricalSessionHead = {
     lastTurnId: string;
     basis: SessionHeadAdvanceBasis;
 };
-export declare function latestCompletedHistoricalHead(sessionId: string, events: RuntimeHistoricalEvent[], input?: {
+export declare function latestCompletedHistoricalHead(sessionId: string, events: RuntimeHistoricalEvent[], _input?: {
     preferTailBasisForExistingEvents?: boolean;
     previousTotalEvents?: number;
     tailStartIndex?: number;

package/apps/daemon/dist/session/events.js

@@ -100,7 +100,7 @@ function transcriptHead(events) {
     }
     return events.at(-1)?.turnId ? { currentHead: events.at(-1)?.turnId, lastTurnId: events.at(-1)?.turnId } : {};
 }
-export function latestCompletedHistoricalHead(sessionId, events, input = {}) {
+export function latestCompletedHistoricalHead(sessionId, events, _input = {}) {
     for (let index = events.length - 1; index >= 0; index -= 1) {
         const event = events[index];
         if (!event || event.payload.type !== "done" || event.payload.status !== "completed")

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.83",
+  "version": "0.1.0-beta.84",
   "private": true,
   "type": "module"
 }

package/apps/relay/dist/db.js

@@ -291,6 +291,9 @@ export function initDb(db) {
     ensureColumn(db, "relay_admissions", "finished_at", "INTEGER");
     ensureColumn(db, "relay_admissions", "terminal_status", "TEXT");
     ensureColumn(db, "relay_admissions", "last_error_code", "TEXT");
+    ensureColumn(db, "relay_dispatch_outbox", "message", "TEXT");
+    ensureColumn(db, "relay_dispatch_outbox", "command_type", "TEXT");
+    ensureColumn(db, "relay_dispatch_outbox", "delivered_at", "INTEGER");
     ensureColumn(db, "tokens", "device_name", "TEXT");
     ensureColumn(db, "tokens", "revoked_at", "INTEGER");
     ensureColumn(db, "tokens", "expires_at", "INTEGER");
@@ -312,6 +315,7 @@ export function initDb(db) {
       WHERE message_id IS NOT NULL;
   `);
     repairHistoricalEventTimestamps(db);
+    backfillRelayDispatchOutboxCommandType(db);
     restoreDurableSessionClaims(db);
 }
 export function pruneRelayRetention(db, now, config) {
@@ -323,11 +327,13 @@ export function pruneRelayRetention(db, now, config) {
     }
 }
 function ensureColumn(db, table, column, definition) {
-    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
-    if (!rows.some((row) => row.name === column)) {
+    if (!tableColumnNames(db, table).has(column)) {
         db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
     }
 }
+function tableColumnNames(db, table) {
+    return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name));
+}
 function restoreDurableSessionClaims(db) {
     db.prepare(`INSERT OR IGNORE INTO relay_session_claims
      (account_id, session_id, request_id, machine_id, turn_id, command_type, state, created_at, updated_at)
@@ -393,6 +399,38 @@ function repairHistoricalEventTimestamps(db) {
         throw error;
     }
 }
+function backfillRelayDispatchOutboxCommandType(db) {
+    const columns = tableColumnNames(db, "relay_dispatch_outbox");
+    if (columns.has("command_json")) {
+        db.prepare("UPDATE relay_dispatch_outbox SET message = command_json WHERE (message IS NULL OR message = '') AND command_json IS NOT NULL AND command_json != ''").run();
+    }
+    const rows = db
+        .prepare("SELECT rowid, message FROM relay_dispatch_outbox WHERE command_type IS NULL OR command_type = ''")
+        .all();
+    if (rows.length === 0)
+        return;
+    const update = db.prepare("UPDATE relay_dispatch_outbox SET command_type = ? WHERE rowid = ?");
+    db.exec("BEGIN");
+    try {
+        for (const row of rows) {
+            update.run(commandTypeFromOutboxMessage(row.message ?? ""), row.rowid);
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+function commandTypeFromOutboxMessage(message) {
+    try {
+        const parsed = JSON.parse(message);
+        return typeof parsed.type === "string" && parsed.type.trim() ? parsed.type : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
 function uuidV7TimestampMs(value) {
     if (!value)
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.83",
+  "version": "0.1.0-beta.84",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {
@@ -28,6 +28,7 @@
   "dependencies": {
     "@fastify/cors": "^11.1.0",
     "@fastify/websocket": "^11.0.2",
+    "@larksuiteoapi/node-sdk": "^1.72.0",
     "@noble/ciphers": "^2.2.0",
     "@noble/hashes": "^2.2.0",
     "acpx": "^0.13.0",