@cydm/happy-elves 0.1.0-beta.54 → 0.1.0-beta.55

package/apps/cli/dist/commands/app.js

@@ -4,6 +4,7 @@ import { handleAccount } from "./account.js";
 import { handleCollect } from "./collect.js";
 import { handleConfig } from "./config.js";
 import { handleDaemon } from "./daemon.js";
+import { handleGateway } from "./gateway.js";
 import { handleLoop } from "./loop.js";
 import { handleMachine } from "./machine.js";
 import { handleOrchestrator } from "./orchestrator.js";
@@ -24,6 +25,7 @@ const domainHandlers = [
     handleDaemon,
     handleRelay,
     handleMachine,
+    handleGateway,
     handleOrchestrator,
     handleSession,
     handleSkill,
@@ -31,7 +33,8 @@ const domainHandlers = [
     handleCollect,
 ];
 export async function main() {
-    const argv = process.argv.slice(2);
+    const rawArgv = process.argv.slice(2);
+    const argv = rawArgv[0] === "--" ? rawArgv.slice(1) : rawArgv;
     const [domain] = argv;
     if (!domain)
         usage();

package/apps/cli/dist/commands/gateway.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleGateway({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/gateway.js

@@ -0,0 +1,534 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CliError, configDir, ok, parseCsvFlag, randomId, requirePositional, requireString, wantsJson, } from "./lib/index.js";
+const defaultGatewayInboundMode = "mention";
+const defaultGatewayProcessingReaction = {
+    enabled: true,
+    emojiType: "Typing",
+};
+const gatewayConfigPath = path.join(configDir, "gateways.json");
+const gatewayStatePath = path.join(configDir, "gateway-state.json");
+export async function handleGateway({ domain, action, positional, flags }) {
+    if (domain !== "gateway")
+        return false;
+    if (action === "list") {
+        const store = await readGatewayStore();
+        if (!wantsJson(flags)) {
+            if (store.gateways.length === 0) {
+                console.log("No local gateways.");
+                return true;
+            }
+            for (const gateway of store.gateways) {
+                const destination = gateway.defaultDestination ? ` chat:${gateway.defaultDestination.platformChatId}` : "";
+                console.log(`${gateway.id}  ${gateway.enabled ? "enabled" : "disabled"}  ${gateway.platform}  inbound:${gateway.inboundMode}  agent:${gateway.defaultAgent}${destination}`);
+            }
+            return true;
+        }
+        ok("gateway.list", { gateways: store.gateways.map(publicGateway) });
+        return true;
+    }
+    if (action === "create") {
+        const platform = platformFlag(flags);
+        const store = await readGatewayStore();
+        const now = Date.now();
+        const id = stringFlag(flags, "id") ?? randomId("gw");
+        if (store.gateways.some((gateway) => gateway.id === id)) {
+            throw new CliError(`Gateway already exists: ${id}`, "GATEWAY_EXISTS");
+        }
+        const defaultChatId = stringFlag(flags, "default-chat-id");
+        const gateway = {
+            id,
+            platform,
+            name: stringFlag(flags, "name") ?? `${platform} gateway`,
+            enabled: enabledFlag(flags, false),
+            defaultAgent: stringFlag(flags, "default-agent") ?? stringFlag(flags, "agent") ?? "codex",
+            defaultCwd: stringFlag(flags, "default-cwd") ?? stringFlag(flags, "cwd") ?? process.cwd(),
+            ...(defaultChatId ? { defaultDestination: { platformChatId: defaultChatId, contextKind: "main" } } : {}),
+            inboundMode: inboundModeFlag(flags, defaultGatewayInboundMode),
+            processingReaction: processingReactionFromFlags(flags, defaultGatewayProcessingReaction),
+            allowAllUsers: flags["allow-all-users"] === true,
+            identities: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        await writeGatewayStore({ version: 1, gateways: [...store.gateways, gateway] });
+        if (!wantsJson(flags)) {
+            console.log(`Created local gateway ${gateway.id} (${gateway.platform}) at ${gatewayConfigPath}`);
+            console.log(`Set platform secret: happy-elves gateway secret set ${gateway.id} --platform ${gateway.platform} ...`);
+            return true;
+        }
+        ok("gateway.create", { gateway: publicGateway(gateway), path: gatewayConfigPath });
+        return true;
+    }
+    if (action === "status") {
+        const gatewayId = requirePositional(positional[0], "gatewayId");
+        const store = await readGatewayStore();
+        const gateway = requireGateway(store, gatewayId);
+        const state = await readGatewayState();
+        const bindings = state.bindings?.filter((binding) => isRecord(binding) && binding.gatewayId === gatewayId) ?? [];
+        const queue = state.queue?.filter((item) => isRecord(item) && item.gatewayId === gatewayId) ?? [];
+        if (!wantsJson(flags)) {
+            console.log(`${gateway.id}  ${gateway.enabled ? "enabled" : "disabled"}  ${gateway.platform}`);
+            console.log(`config: ${gatewayConfigPath}`);
+            console.log(`secret: ${gateway.appSecret ? "set" : "missing"}`);
+            console.log(`inbound: ${gateway.inboundMode}`);
+            console.log(`reaction: ${gateway.processingReaction.enabled ? gateway.processingReaction.emojiType : "disabled"}`);
+            console.log(`default: ${gateway.defaultAgent} ${gateway.defaultCwd}`);
+            if (gateway.defaultDestination)
+                console.log(`default chat: ${gateway.defaultDestination.platformChatId}`);
+            console.log(`identities: ${gateway.identities.length}`);
+            console.log(`bindings: ${bindings.length}`);
+            console.log(`queued inbound: ${queue.length}`);
+            return true;
+        }
+        ok("gateway.status", { gateway: publicGateway(gateway), bindings, queueLength: queue.length, statePath: gatewayStatePath });
+        return true;
+    }
+    if (action === "secret" && positional[0] === "set") {
+        const gatewayId = requirePositional(positional[1], "gatewayId");
+        const platform = platformFlag(flags);
+        const store = await readGatewayStore();
+        const now = Date.now();
+        const existing = store.gateways.find((gateway) => gateway.id === gatewayId);
+        const gateway = {
+            ...(existing ?? {
+                id: gatewayId,
+                platform,
+                name: `${platform} gateway`,
+                defaultAgent: "codex",
+                defaultCwd: process.cwd(),
+                inboundMode: defaultGatewayInboundMode,
+                processingReaction: { ...defaultGatewayProcessingReaction },
+                identities: [],
+                createdAt: now,
+            }),
+            platform,
+            enabled: enabledFlag(flags, existing?.enabled ?? false),
+            ...(platform === "feishu" ? {
+                appId: requireString(flags, "app-id"),
+                appSecret: appSecretFlag(flags),
+                domain: domainFlag(flags),
+            } : {}),
+            updatedAt: now,
+        };
+        await writeGatewayStore({ version: 1, gateways: [...store.gateways.filter((item) => item.id !== gatewayId), gateway] });
+        if (!wantsJson(flags)) {
+            console.log(`Saved local gateway secret for ${gatewayId} at ${gatewayConfigPath}`);
+            return true;
+        }
+        ok("gateway.secret.set", { gatewayId, platform, path: gatewayConfigPath, enabled: gateway.enabled, hasAppSecret: Boolean(gateway.appSecret) });
+        return true;
+    }
+    if (action === "config" && positional[0] === "set") {
+        const gatewayId = requirePositional(positional[1], "gatewayId");
+        const store = await readGatewayStore();
+        const gateway = requireGateway(store, gatewayId);
+        const updated = applyGatewayConfigFlags(gateway, flags);
+        await writeGatewayStore({ version: 1, gateways: store.gateways.map((item) => item.id === gatewayId ? updated : item) });
+        if (!wantsJson(flags)) {
+            console.log(`Updated local gateway ${gatewayId} at ${gatewayConfigPath}`);
+            return true;
+        }
+        ok("gateway.config.set", { gateway: publicGateway(updated), path: gatewayConfigPath });
+        return true;
+    }
+    if (action === "identity" && positional[0] === "allow") {
+        const gatewayId = requirePositional(positional[1], "gatewayId");
+        const platformUserId = stringFlag(flags, "platform-user") ?? stringFlag(flags, "user");
+        if (!platformUserId)
+            throw new CliError("Missing --platform-user <id>", "MISSING_ARGUMENT");
+        const store = await readGatewayStore();
+        const gateway = requireGateway(store, gatewayId);
+        const allowedActions = parseCsvFlag(flags.actions) ?? ["session.create", "session.run"];
+        const allowedSessions = parseCsvFlag(flags.sessions);
+        const grant = {
+            platformUserId,
+            ...(stringFlag(flags, "display-name") ? { displayName: stringFlag(flags, "display-name") } : {}),
+            allowedActions,
+            ...(allowedSessions ? { allowedSessions } : {}),
+        };
+        const updated = {
+            ...gateway,
+            identities: [...gateway.identities.filter((identity) => identity.platformUserId !== platformUserId), grant],
+            updatedAt: Date.now(),
+        };
+        await writeGatewayStore({ version: 1, gateways: store.gateways.map((item) => item.id === gatewayId ? updated : item) });
+        if (!wantsJson(flags)) {
+            console.log(`Allowed ${platformUserId} on local gateway ${gatewayId}`);
+            return true;
+        }
+        ok("gateway.identity.allow", { gateway: publicGateway(updated), identity: grant });
+        return true;
+    }
+    if (action === "identity" && positional[0] === "remove") {
+        const gatewayId = requirePositional(positional[1], "gatewayId");
+        const platformUserId = stringFlag(flags, "platform-user") ?? stringFlag(flags, "user");
+        if (!platformUserId)
+            throw new CliError("Missing --platform-user <id>", "MISSING_ARGUMENT");
+        const store = await readGatewayStore();
+        const gateway = requireGateway(store, gatewayId);
+        const updated = {
+            ...gateway,
+            identities: gateway.identities.filter((identity) => identity.platformUserId !== platformUserId),
+            updatedAt: Date.now(),
+        };
+        await writeGatewayStore({ version: 1, gateways: store.gateways.map((item) => item.id === gatewayId ? updated : item) });
+        if (!wantsJson(flags)) {
+            console.log(`Removed ${platformUserId} from local gateway ${gatewayId}`);
+            return true;
+        }
+        ok("gateway.identity.remove", { gateway: publicGateway(updated), removedPlatformUserId: platformUserId });
+        return true;
+    }
+    if (action === "binding" && positional[0] === "list") {
+        const gatewayId = requirePositional(positional[1], "gatewayId");
+        const store = await readGatewayStore();
+        requireGateway(store, gatewayId);
+        const state = await readGatewayState();
+        const bindings = gatewayBindings(state, gatewayId);
+        if (!wantsJson(flags)) {
+            if (bindings.length === 0) {
+                console.log(`No bindings for local gateway ${gatewayId}.`);
+                return true;
+            }
+            for (const binding of bindings) {
+                const thread = binding.contextKind === "thread" ? ` thread:${stringFlag(binding, "contextKey") ?? ""}` : "";
+                const last = stringFlag(binding, "lastPlatformMessageId") ? ` last:${stringFlag(binding, "lastPlatformMessageId")}` : "";
+                console.log(`${stringFlag(binding, "sessionId") ?? "(missing-session)"}  chat:${stringFlag(binding, "platformChatId") ?? "(missing-chat)"}${thread}  agent:${stringFlag(binding, "agent") ?? "codex"}  cwd:${stringFlag(binding, "cwd") ?? ""}${last}`);
+            }
+            return true;
+        }
+        ok("gateway.binding.list", { gatewayId, bindings, statePath: gatewayStatePath });
+        return true;
+    }
+    if (action === "binding" && positional[0] === "clear") {
+        const gatewayId = requirePositional(positional[1], "gatewayId");
+        const store = await readGatewayStore();
+        requireGateway(store, gatewayId);
+        const state = await readGatewayState();
+        const filter = {
+            ...(stringFlag(flags, "chat-id") ? { chatId: stringFlag(flags, "chat-id") } : {}),
+            ...(stringFlag(flags, "thread-id") ? { threadId: stringFlag(flags, "thread-id") } : {}),
+            ...(stringFlag(flags, "session") ? { sessionId: stringFlag(flags, "session") } : {}),
+        };
+        const bindings = Array.isArray(state.bindings) ? state.bindings : [];
+        const removedBindings = bindings.filter((binding) => bindingMatchesFilter(binding, gatewayId, filter));
+        const removedConversationKeys = new Set(removedBindings.flatMap((binding) => bindingConversationKey(binding) ?? []));
+        const queue = Array.isArray(state.queue) ? state.queue : [];
+        const nextState = {
+            ...state,
+            bindings: bindings.filter((binding) => !bindingMatchesFilter(binding, gatewayId, filter)),
+            queue: queue.filter((item) => !queueMatchesConversation(item, gatewayId, removedConversationKeys) && !queueMatchesFilter(item, gatewayId, filter)),
+        };
+        const removedQueuedInbound = queue.length - (Array.isArray(nextState.queue) ? nextState.queue.length : 0);
+        await writeGatewayState(nextState);
+        if (!wantsJson(flags)) {
+            console.log(`Cleared ${removedBindings.length} binding(s) and ${removedQueuedInbound} queued inbound message(s) for local gateway ${gatewayId}`);
+            return true;
+        }
+        ok("gateway.binding.clear", { gatewayId, removedBindings: removedBindings.length, removedQueuedInbound, statePath: gatewayStatePath });
+        return true;
+    }
+    return false;
+}
+async function readGatewayStore() {
+    try {
+        const parsed = JSON.parse(await fs.readFile(gatewayConfigPath, "utf8"));
+        return {
+            version: 1,
+            gateways: Array.isArray(parsed.gateways) ? parsed.gateways.flatMap(normalizeGateway) : [],
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, gateways: [] };
+        throw error;
+    }
+}
+async function writeGatewayStore(store) {
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(gatewayConfigPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    await fs.chmod(gatewayConfigPath, 0o600);
+}
+async function readGatewayState() {
+    try {
+        return JSON.parse(await fs.readFile(gatewayStatePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, bindings: [], queue: [], processedEvents: [] };
+        throw error;
+    }
+}
+async function writeGatewayState(state) {
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(gatewayStatePath, `${JSON.stringify({ ...state, version: 1 }, null, 2)}\n`, { mode: 0o600 });
+    await fs.chmod(gatewayStatePath, 0o600);
+}
+function applyGatewayConfigFlags(gateway, flags) {
+    const next = {
+        ...gateway,
+        enabled: enabledFlag(flags, gateway.enabled),
+        inboundMode: inboundModeFlag(flags, gateway.inboundMode),
+        processingReaction: processingReactionFromFlags(flags, gateway.processingReaction),
+        defaultAgent: stringFlag(flags, "default-agent") ?? stringFlag(flags, "agent") ?? gateway.defaultAgent,
+        defaultCwd: stringFlag(flags, "default-cwd") ?? stringFlag(flags, "cwd") ?? gateway.defaultCwd,
+        allowAllUsers: allowAllUsersFlag(flags, gateway.allowAllUsers === true),
+        updatedAt: Date.now(),
+    };
+    const defaultChatId = stringFlag(flags, "default-chat-id");
+    if (flags["clear-default-chat"] === true && defaultChatId) {
+        throw new CliError("Use only one of --default-chat-id or --clear-default-chat", "INVALID_ARGUMENT");
+    }
+    if (flags["clear-default-chat"] === true) {
+        delete next.defaultDestination;
+    }
+    else if (defaultChatId) {
+        next.defaultDestination = { platformChatId: defaultChatId, contextKind: "main" };
+    }
+    return next;
+}
+function normalizeGateway(value) {
+    if (!isRecord(value))
+        return [];
+    const id = stringFlag(value, "id") ?? stringFlag(value, "gatewayId");
+    if (!id)
+        return [];
+    const platform = value.platform === "fake" ? "fake" : value.platform === "feishu" ? "feishu" : undefined;
+    if (!platform)
+        return [];
+    const now = Date.now();
+    const defaultChatId = stringFlag(value, "defaultChatId");
+    const defaultDestination = normalizeDestination(value.defaultDestination)
+        ?? (defaultChatId ? { platformChatId: defaultChatId, contextKind: "main" } : undefined);
+    const inboundMode = normalizeInboundMode(value.inboundMode) ?? legacyInboundMode(value) ?? defaultGatewayInboundMode;
+    return [{
+            id,
+            platform,
+            name: stringFlag(value, "name") ?? `${platform} gateway`,
+            enabled: value.enabled === true,
+            defaultAgent: stringFlag(value, "defaultAgent") ?? "codex",
+            defaultCwd: typeof value.defaultCwd === "string" ? value.defaultCwd : "",
+            ...(defaultDestination ? { defaultDestination } : {}),
+            inboundMode,
+            processingReaction: normalizeProcessingReaction(value.processingReaction),
+            allowAllUsers: value.allowAllUsers === true,
+            ...(stringFlag(value, "appId") ? { appId: stringFlag(value, "appId") } : {}),
+            ...(stringFlag(value, "appSecret") ? { appSecret: stringFlag(value, "appSecret") } : {}),
+            ...(value.domain === "lark" ? { domain: "lark" } : { domain: "feishu" }),
+            identities: Array.isArray(value.identities) ? value.identities.flatMap(normalizeIdentity) : [],
+            createdAt: typeof value.createdAt === "number" ? value.createdAt : now,
+            updatedAt: typeof value.updatedAt === "number" ? value.updatedAt : now,
+        }];
+}
+function normalizeInboundMode(value) {
+    return value === "all" || value === "mention" ? value : undefined;
+}
+function legacyInboundMode(record) {
+    if (!Object.hasOwn(record, "requireMention"))
+        return undefined;
+    return record.requireMention === true ? "mention" : "all";
+}
+function normalizeProcessingReaction(value) {
+    if (!isRecord(value))
+        return { ...defaultGatewayProcessingReaction };
+    return {
+        enabled: value.enabled !== false,
+        emojiType: stringFlag(value, "emojiType") ?? defaultGatewayProcessingReaction.emojiType,
+    };
+}
+function normalizeIdentity(value) {
+    if (!isRecord(value))
+        return [];
+    const platformUserId = stringFlag(value, "platformUserId");
+    if (!platformUserId)
+        return [];
+    const allowedActions = Array.isArray(value.allowedActions)
+        ? value.allowedActions.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : ["session.create", "session.run"];
+    const allowedSessions = Array.isArray(value.allowedSessions)
+        ? value.allowedSessions.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : undefined;
+    return [{
+            platformUserId,
+            ...(stringFlag(value, "displayName") ? { displayName: stringFlag(value, "displayName") } : {}),
+            allowedActions,
+            ...(allowedSessions && allowedSessions.length > 0 ? { allowedSessions } : {}),
+        }];
+}
+function normalizeDestination(value) {
+    if (!isRecord(value))
+        return undefined;
+    const platformChatId = stringFlag(value, "platformChatId");
+    if (!platformChatId)
+        return undefined;
+    const contextKind = value.contextKind === "thread" ? "thread" : "main";
+    const replyToMessageId = stringFlag(value, "replyToMessageId");
+    if (contextKind === "thread") {
+        const contextKey = stringFlag(value, "contextKey");
+        if (!contextKey)
+            return undefined;
+        return {
+            platformChatId,
+            contextKind,
+            contextKey,
+            ...(replyToMessageId ? { replyToMessageId } : {}),
+        };
+    }
+    return {
+        platformChatId,
+        contextKind,
+        ...(replyToMessageId ? { replyToMessageId } : {}),
+    };
+}
+function publicGateway(gateway) {
+    const { appSecret: _appSecret, ...publicFields } = gateway;
+    return { ...publicFields, hasAppSecret: Boolean(gateway.appSecret) };
+}
+function requireGateway(store, gatewayId) {
+    const gateway = store.gateways.find((item) => item.id === gatewayId);
+    if (!gateway)
+        throw new CliError(`Gateway not found: ${gatewayId}`, "GATEWAY_NOT_FOUND");
+    return gateway;
+}
+function platformFlag(flags) {
+    const platform = flags.platform;
+    if (platform === "feishu" || platform === "fake")
+        return platform;
+    throw new CliError("Missing or invalid --platform <feishu|fake>", "INVALID_ARGUMENT");
+}
+function domainFlag(flags) {
+    const domain = flags.domain;
+    if (domain === undefined || domain === false)
+        return "feishu";
+    if (domain === "feishu" || domain === "lark")
+        return domain;
+    throw new CliError("Invalid --domain <feishu|lark>", "INVALID_ARGUMENT");
+}
+function enabledFlag(flags, fallback) {
+    if (flags.enabled === true && flags.disabled === true) {
+        throw new CliError("Use only one of --enabled or --disabled", "INVALID_ARGUMENT");
+    }
+    if (flags.enabled === true)
+        return true;
+    if (flags.disabled === true)
+        return false;
+    return fallback;
+}
+function allowAllUsersFlag(flags, fallback) {
+    if (flags["allow-all-users"] === true && flags["deny-all-users"] === true) {
+        throw new CliError("Use only one of --allow-all-users or --deny-all-users", "INVALID_ARGUMENT");
+    }
+    if (flags["allow-all-users"] === true)
+        return true;
+    if (flags["deny-all-users"] === true)
+        return false;
+    return fallback;
+}
+function inboundModeFlag(flags, fallback) {
+    const explicit = stringFlag(flags, "inbound-mode");
+    const aliases = [
+        ...(flags["require-mention"] === true ? ["mention"] : []),
+        ...(flags["respond-all"] === true ? ["all"] : []),
+    ];
+    if (aliases.length > 1)
+        throw new CliError("Use only one of --require-mention or --respond-all", "INVALID_ARGUMENT");
+    if (explicit) {
+        const mode = normalizeInboundMode(explicit);
+        if (!mode)
+            throw new CliError("Invalid --inbound-mode <mention|all>", "INVALID_ARGUMENT");
+        if (aliases.length === 1 && aliases[0] !== mode) {
+            throw new CliError("Conflicting inbound mode flags", "INVALID_ARGUMENT");
+        }
+        return mode;
+    }
+    return aliases[0] ?? fallback;
+}
+function processingReactionFromFlags(flags, fallback) {
+    if (flags["reaction-enabled"] === true && flags["reaction-disabled"] === true) {
+        throw new CliError("Use only one of --reaction-enabled or --reaction-disabled", "INVALID_ARGUMENT");
+    }
+    return {
+        enabled: flags["reaction-enabled"] === true ? true : flags["reaction-disabled"] === true ? false : fallback.enabled,
+        emojiType: stringFlag(flags, "reaction-emoji") ?? fallback.emojiType,
+    };
+}
+function appSecretFlag(flags) {
+    const direct = stringFlag(flags, "app-secret");
+    const envName = stringFlag(flags, "app-secret-env");
+    if (direct && envName)
+        throw new CliError("Use only one of --app-secret or --app-secret-env", "INVALID_ARGUMENT");
+    if (direct)
+        return direct;
+    if (envName) {
+        const value = process.env[envName];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+        throw new CliError(`Environment variable is empty or missing: ${envName}`, "MISSING_ARGUMENT");
+    }
+    return requireString(flags, "app-secret");
+}
+function stringFlag(flags, key) {
+    const value = flags[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function gatewayBindings(state, gatewayId) {
+    return (Array.isArray(state.bindings) ? state.bindings : [])
+        .filter((binding) => isRecord(binding) && binding.gatewayId === gatewayId);
+}
+function bindingMatchesFilter(value, gatewayId, filter) {
+    if (!isRecord(value) || value.gatewayId !== gatewayId)
+        return false;
+    if (filter.chatId && value.platformChatId !== filter.chatId)
+        return false;
+    if (filter.threadId && (value.contextKind !== "thread" || value.contextKey !== filter.threadId))
+        return false;
+    if (filter.sessionId && value.sessionId !== filter.sessionId)
+        return false;
+    return true;
+}
+function bindingConversationKey(value) {
+    if (!isRecord(value))
+        return undefined;
+    const platformChatId = stringFlag(value, "platformChatId");
+    const contextKind = value.contextKind === "thread" ? "thread" : "main";
+    const contextKey = contextKind === "thread" ? stringFlag(value, "contextKey") : "";
+    if (!platformChatId || (contextKind === "thread" && !contextKey))
+        return undefined;
+    return `${platformChatId}:${contextKind}:${contextKey}`;
+}
+function queueMatchesConversation(value, gatewayId, conversationKeys) {
+    if (conversationKeys.size === 0 || !isRecord(value) || value.gatewayId !== gatewayId)
+        return false;
+    const destination = isRecord(value.destination) ? value.destination : undefined;
+    if (!destination)
+        return false;
+    const platformChatId = stringFlag(destination, "platformChatId");
+    const contextKind = destination.contextKind === "thread" ? "thread" : "main";
+    const contextKey = contextKind === "thread" ? stringFlag(destination, "contextKey") : "";
+    if (!platformChatId || (contextKind === "thread" && !contextKey))
+        return false;
+    return conversationKeys.has(`${platformChatId}:${contextKind}:${contextKey}`);
+}
+function queueMatchesFilter(value, gatewayId, filter) {
+    if (!isRecord(value) || value.gatewayId !== gatewayId)
+        return false;
+    if (filter.sessionId)
+        return false;
+    const destination = isRecord(value.destination) ? value.destination : undefined;
+    if (!destination)
+        return false;
+    const platformChatId = stringFlag(destination, "platformChatId");
+    const contextKind = destination.contextKind === "thread" ? "thread" : "main";
+    const contextKey = contextKind === "thread" ? stringFlag(destination, "contextKey") : "";
+    if (!platformChatId || (contextKind === "thread" && !contextKey))
+        return false;
+    if (filter.chatId && platformChatId !== filter.chatId)
+        return false;
+    if (filter.threadId && (contextKind !== "thread" || contextKey !== filter.threadId))
+        return false;
+    return true;
+}

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

@@ -2,13 +2,27 @@ import { parseFlags as parseSharedFlags } from "../../../../../packages/shared/d
 import { CliError } from "../../errors.js";
 const valueFlags = new Set([
     "agent",
+    "app-id",
+    "app-secret",
+    "app-secret-env",
     "code",
     "controller",
+    "context-turn",
     "cwd",
+    "chat-id",
+    "default-agent",
+    "default-chat-id",
+    "default-cwd",
+    "default-machine",
     "device-id",
     "device-name",
+    "display-name",
+    "domain",
     "from",
     "host",
+    "host-machine",
+    "id",
+    "inbound-mode",
     "invite-secret",
     "join-url-base",
     "limit",
@@ -19,12 +33,15 @@ const valueFlags = new Set([
     "model",
     "output",
     "path",
+    "platform",
+    "platform-user",
     "port",
     "permission",
     "permission-mode",
     "prompt",
     "prompt-file",
     "query",
+    "reaction-emoji",
     "request-id",
     "every",
     "reason",
@@ -39,6 +56,7 @@ const valueFlags = new Set([
     "loops",
     "machines",
     "messages",
+    "session",
     "sessions",
     "secret",
     "since",
@@ -48,6 +66,7 @@ const valueFlags = new Set([
     "tags",
     "text",
     "text-file",
+    "thread-id",
     "timeout",
     "timeout-ms",
     "thought-level",
@@ -63,8 +82,14 @@ const valueFlags = new Set([
 ]);
 const booleanFlags = new Set([
     "all",
+    "allow-all-users",
+    "clear-default-chat",
+    "deny-all-users",
     "detach",
+    "disabled",
+    "enabled",
     "force",
+    "full-context",
     "help",
     "h",
     "include-output",
@@ -75,12 +100,16 @@ const booleanFlags = new Set([
     "no-open",
     "no-wait",
     "repair-head",
+    "reaction-disabled",
+    "reaction-enabled",
+    "require-mention",
+    "respond-all",
     "summary",
     "verbose",
     "wait",
 ]);
 const knownFlags = new Set([...valueFlags, ...booleanFlags]);
-const dashPrefixedValueFlags = new Set(["secret"]);
+const dashPrefixedValueFlags = new Set(["app-secret", "secret"]);
 export function parseCliFlags(argv) {
     const parsed = parseSharedFlags(argv, { valueFlags, dashPrefixedValueFlags });
     const unknown = Object.keys(parsed.flags).filter((flag) => !knownFlags.has(flag));

package/apps/cli/dist/commands/lib/orchestrator.d.ts

@@ -1,7 +1,6 @@
 import type { SessionSnapshot } from "../../../../../packages/shared/dist/index.js";
 import type { OrchestrationSummary } from "./types.js";
 import type { TurnSummary } from "./session-output.js";
-export declare const ORCHESTRATOR_CONTRACT_VERSION = 1;
 export type OrchestratorStatus = "idle" | "inProgress" | "completed" | "needsInput" | "blocked" | "failed" | "cancelled" | "offline" | "closed";
 export type OrchestratorRequestRecord = {
     turnId: string;

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

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 import { CliError } from "../../errors.js";
-export const ORCHESTRATOR_CONTRACT_VERSION = 1;
 export function promptSha256(text) {
     return createHash("sha256").update(text, "utf8").digest("hex");
 }