@agentbean/daemon 0.1.34 → 0.2.0

package/dist/apps/daemon-next/src/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/apps/daemon-next/src/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runDaemonNextCli } from './cli.js';
+runDaemonNextCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

package/dist/apps/daemon-next/src/cli.d.ts

@@ -0,0 +1,26 @@
+import { type DaemonProtocolSocket } from './index.js';
+interface SocketIoClientLike {
+    connected: boolean;
+    connect(): void;
+    disconnect(): void;
+    emitWithAck(event: string, payload: unknown): Promise<unknown>;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+}
+export interface DaemonNextCliConfig {
+    serverUrl: string;
+    teamId: string;
+    ownerId: string;
+    machineId?: string;
+    profileId: string;
+    hostname: string;
+    fallbackPrefix: string;
+}
+export interface ParseDaemonNextCliConfigInput {
+    argv?: string[];
+    env?: NodeJS.ProcessEnv;
+    hostname?: string;
+}
+export declare function parseDaemonNextCliConfig(input?: ParseDaemonNextCliConfigInput): DaemonNextCliConfig;
+export declare function createSocketIoDaemonSocket(socket: SocketIoClientLike): DaemonProtocolSocket;
+export declare function runDaemonNextCli(config?: DaemonNextCliConfig): Promise<void>;
+export {};

package/dist/apps/daemon-next/src/cli.js

@@ -0,0 +1,124 @@
+import { hostname as readHostname } from 'node:os';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createBuiltinScanProvider } from './scanner.js';
+import { createCommandExecutor } from './executor.js';
+import { createDaemonProtocolClient } from './index.js';
+export function parseDaemonNextCliConfig(input = {}) {
+    const argv = input.argv ?? process.argv.slice(2);
+    const env = input.env ?? process.env;
+    const args = parseArgs(argv);
+    const teamId = args['team-id'] ?? env.AGENTBEAN_NEXT_TEAM_ID;
+    const ownerId = args['owner-id'] ?? env.AGENTBEAN_NEXT_OWNER_ID;
+    if (!teamId) {
+        throw new Error('AGENTBEAN_NEXT_TEAM_ID or --team-id is required');
+    }
+    if (!ownerId) {
+        throw new Error('AGENTBEAN_NEXT_OWNER_ID or --owner-id is required');
+    }
+    return {
+        serverUrl: trimTrailingSlash(args['server-url'] ?? env.AGENTBEAN_NEXT_SERVER_URL ?? 'http://127.0.0.1:4000'),
+        teamId,
+        ownerId,
+        machineId: args['machine-id'] ?? env.AGENTBEAN_NEXT_MACHINE_ID,
+        profileId: args['profile-id'] ?? env.AGENTBEAN_NEXT_PROFILE_ID ?? 'default',
+        hostname: args.hostname ?? env.AGENTBEAN_NEXT_HOSTNAME ?? input.hostname ?? readHostname(),
+        fallbackPrefix: args['fallback-prefix'] ?? env.AGENTBEAN_NEXT_FALLBACK_PREFIX ?? 'daemon-next:',
+    };
+}
+export function createSocketIoDaemonSocket(socket) {
+    return {
+        emitWithAck(event, payload) {
+            return socket.emitWithAck(event, payload);
+        },
+        on(event, handler) {
+            socket.on(event, (payload) => {
+                void handler(payload);
+            });
+        },
+        onReconnect(handler) {
+            let hasConnected = socket.connected;
+            socket.on('connect', () => {
+                if (!hasConnected) {
+                    hasConnected = true;
+                    return;
+                }
+                void handler();
+            });
+        },
+    };
+}
+export async function runDaemonNextCli(config = parseDaemonNextCliConfig()) {
+    const socket = await connectSocketIoClient(config.serverUrl);
+    const snapshot = await createBuiltinScanProvider()();
+    const device = {
+        teamId: config.teamId,
+        ownerId: config.ownerId,
+        machineId: config.machineId,
+        profileId: config.profileId,
+        hostname: config.hostname,
+    };
+    await createDaemonProtocolClient({
+        socket: createSocketIoDaemonSocket(socket),
+        executor: createCommandExecutor({ fallbackPrefix: config.fallbackPrefix }),
+        device,
+        runtimes: snapshot.runtimes,
+        agents: snapshot.agents,
+        scan: createBuiltinScanProvider(),
+    }).start();
+}
+async function connectSocketIoClient(serverUrl) {
+    const { io } = loadSocketIoClient();
+    const socket = io(`${trimTrailingSlash(serverUrl)}/agent`, {
+        autoConnect: false,
+        reconnection: true,
+        reconnectionDelay: 1000,
+        transports: ['websocket', 'polling'],
+    });
+    await new Promise((resolve, reject) => {
+        socket.on('connect', () => resolve());
+        socket.on('connect_error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        socket.connect();
+    });
+    return socket;
+}
+function loadSocketIoClient() {
+    const requireUrls = [
+        new URL('../../../../package.json', import.meta.url),
+        new URL('../../../../../server/package.json', import.meta.url),
+        new URL('../../server/package.json', import.meta.url),
+        new URL('../package.json', import.meta.url),
+        pathToFileURL(join(process.cwd(), 'apps/server/package.json')),
+        pathToFileURL(join(process.cwd(), 'apps/daemon-next/package.json')),
+    ];
+    for (const requireUrl of requireUrls) {
+        try {
+            return createRequire(requireUrl)('socket.io-client');
+        }
+        catch {
+            // Try the next known repository layout.
+        }
+    }
+    throw new Error('socket.io-client is not installed; run npm ci in apps/server or provide a workspace install');
+}
+function parseArgs(argv) {
+    const parsed = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg?.startsWith('--')) {
+            continue;
+        }
+        const key = arg.slice(2);
+        const value = argv[index + 1];
+        if (!value || value.startsWith('--')) {
+            throw new Error(`Missing value for --${key}`);
+        }
+        parsed[key] = value;
+        index += 1;
+    }
+    return parsed;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, '');
+}

package/dist/apps/daemon-next/src/executor.d.ts

@@ -0,0 +1,6 @@
+import type { StubExecutor } from './index.js';
+export interface CommandExecutorOptions {
+    fallbackPrefix?: string;
+    timeoutMs?: number;
+}
+export declare function createCommandExecutor(options?: CommandExecutorOptions): StubExecutor;

package/dist/apps/daemon-next/src/executor.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+export function createCommandExecutor(options = {}) {
+    const fallbackPrefix = options.fallbackPrefix ?? 'daemon-next:';
+    const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
+    return async (request) => {
+        if (!request.customAgent?.command) {
+            return `${fallbackPrefix}${request.prompt}`;
+        }
+        return runCustomAgentCommand(request, timeoutMs);
+    };
+}
+async function runCustomAgentCommand(request, timeoutMs) {
+    const customAgent = request.customAgent;
+    if (!customAgent?.command) {
+        throw new Error('custom agent command is required');
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(customAgent.command, customAgent.args ?? [], {
+            cwd: customAgent.cwd,
+            env: { ...process.env, ...(customAgent.env ?? {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new Error(`custom agent command timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout.trimEnd());
+                return;
+            }
+            reject(new Error(stderr.trim() || `custom agent command exited with code ${code ?? 'unknown'}`));
+        });
+        child.stdin.end(request.prompt);
+    });
+}

package/dist/apps/daemon-next/src/index.d.ts

@@ -0,0 +1,60 @@
+import { type AgentCategory, type DispatchCustomAgentDto } from '../../../packages/contracts/src/index.js';
+export { createBuiltinScanProvider, scanBuiltinRuntimeAgents } from './scanner.js';
+export type { BuiltinScannerOptions } from './scanner.js';
+export { createCommandExecutor } from './executor.js';
+export type { CommandExecutorOptions } from './executor.js';
+export interface DaemonProtocolSocket {
+    emitWithAck(event: string, payload: unknown): Promise<unknown>;
+    on(event: string, handler: (payload: unknown) => Promise<void>): void;
+    onReconnect?(handler: () => Promise<void>): void;
+}
+export type StubExecutor = (request: DispatchRequestPayload) => Promise<string>;
+export interface DaemonDeviceConfig {
+    teamId: string;
+    ownerId: string;
+    machineId?: string;
+    profileId?: string;
+    hostname?: string;
+}
+export interface DaemonRuntimeReport {
+    adapterKind: string;
+    name: string;
+    command?: string;
+    cwd?: string;
+    version?: string;
+    installed?: boolean;
+}
+export interface DaemonAgentReport {
+    name: string;
+    adapterKind: string;
+    category: AgentCategory;
+    gatewayInstanceKey?: string;
+}
+export interface DaemonScanSnapshot {
+    runtimes: DaemonRuntimeReport[];
+    agents: DaemonAgentReport[];
+}
+export type DaemonScanProvider = () => Promise<DaemonScanSnapshot>;
+export interface DispatchRequestPayload {
+    id: string;
+    teamId: string;
+    channelId: string;
+    messageId: string;
+    agentId: string;
+    deviceId?: string;
+    requestId: string;
+    prompt: string;
+    customAgent?: DispatchCustomAgentDto | null;
+}
+export interface CreateDaemonProtocolClientInput {
+    socket: DaemonProtocolSocket;
+    executor: StubExecutor;
+    device: DaemonDeviceConfig;
+    runtimes: DaemonRuntimeReport[];
+    agents: DaemonAgentReport[];
+    scan?: DaemonScanProvider;
+}
+export interface DaemonProtocolClient {
+    start(): Promise<void>;
+}
+export declare function createDaemonProtocolClient(input: CreateDaemonProtocolClientInput): DaemonProtocolClient;

package/dist/apps/daemon-next/src/index.js

@@ -0,0 +1,87 @@
+import { AGENT_EVENTS } from '../../../packages/contracts/src/index.js';
+export { createBuiltinScanProvider, scanBuiltinRuntimeAgents } from './scanner.js';
+export { createCommandExecutor } from './executor.js';
+export function createDaemonProtocolClient(input) {
+    const { socket, executor, device, runtimes, agents, scan } = input;
+    return {
+        async start() {
+            let currentDeviceId = await announceDeviceSnapshot(socket, device, runtimes, agents);
+            socket.onReconnect?.(async () => {
+                currentDeviceId = await announceDeviceSnapshot(socket, device, runtimes, agents);
+            });
+            socket.on(AGENT_EVENTS.device.scanRequested, async (payload) => {
+                const request = readScanRequest(payload);
+                if (request.deviceId !== currentDeviceId) {
+                    return;
+                }
+                const snapshot = scan ? await scan() : { runtimes, agents };
+                await reportDeviceSnapshot(socket, device.teamId, currentDeviceId, snapshot.runtimes, snapshot.agents);
+            });
+            socket.on(AGENT_EVENTS.dispatch.request, async (payload) => {
+                const request = payload;
+                try {
+                    const body = await executor(request);
+                    await socket.emitWithAck(AGENT_EVENTS.dispatch.result, {
+                        dispatchId: request.id,
+                        agentId: request.agentId,
+                        body,
+                    });
+                }
+                catch (error) {
+                    await socket.emitWithAck(AGENT_EVENTS.dispatch.error, {
+                        dispatchId: request.id,
+                        agentId: request.agentId,
+                        error: readErrorMessage(error),
+                    });
+                }
+            });
+        },
+    };
+}
+async function announceDeviceSnapshot(socket, device, runtimes, agents) {
+    const helloAck = await socket.emitWithAck(AGENT_EVENTS.device.hello, device);
+    const deviceId = readAckDeviceId(helloAck);
+    await reportDeviceSnapshot(socket, device.teamId, deviceId, runtimes, agents);
+    return deviceId;
+}
+async function reportDeviceSnapshot(socket, teamId, deviceId, runtimes, agents) {
+    await socket.emitWithAck(AGENT_EVENTS.device.runtimes, {
+        teamId,
+        deviceId,
+        runtimes,
+    });
+    await socket.emitWithAck(AGENT_EVENTS.agent.registerBatch, {
+        teamId,
+        deviceId,
+        agents,
+    });
+}
+function readScanRequest(payload) {
+    if (!payload || typeof payload !== 'object') {
+        throw new Error('device:scan-requested payload missing request');
+    }
+    const request = payload;
+    if (typeof request.requestId !== 'string' || typeof request.deviceId !== 'string') {
+        throw new Error('device:scan-requested payload missing request id or device id');
+    }
+    return { requestId: request.requestId, deviceId: request.deviceId };
+}
+function readAckDeviceId(ack) {
+    if (!ack || typeof ack !== 'object') {
+        throw new Error('device:hello ack missing device');
+    }
+    const device = ack.device;
+    if (!device || typeof device.id !== 'string') {
+        throw new Error('device:hello ack missing device id');
+    }
+    return device.id;
+}
+function readErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    if (typeof error === 'string' && error) {
+        return error;
+    }
+    return 'Dispatch executor failed';
+}

package/dist/apps/daemon-next/src/scanner.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonScanProvider, DaemonScanSnapshot } from './index.js';
+interface RuntimeSpec {
+    bin: string;
+    name: string;
+    adapterKind: string;
+    candidates?: string[];
+}
+export interface BuiltinScannerOptions {
+    envPath?: string;
+    homeDir?: string;
+    findExecutable?: (bin: string, candidates: string[]) => Promise<string | null>;
+}
+export declare function createBuiltinScanProvider(options?: BuiltinScannerOptions): DaemonScanProvider;
+export declare function scanBuiltinRuntimeAgents(options?: BuiltinScannerOptions, specs?: RuntimeSpec[]): Promise<DaemonScanSnapshot>;
+export {};

package/dist/apps/daemon-next/src/scanner.js

@@ -0,0 +1,94 @@
+import { accessSync, constants, existsSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+export function createBuiltinScanProvider(options = {}) {
+    return () => scanBuiltinRuntimeAgents(options);
+}
+export async function scanBuiltinRuntimeAgents(options = {}, specs = defaultRuntimeSpecs(options.homeDir ?? homedir())) {
+    const findExecutable = options.findExecutable ?? ((bin, candidates) => findExecutableOnPath(bin, candidates, options));
+    const runtimes = [];
+    for (const spec of specs) {
+        const command = await findExecutable(spec.bin, spec.candidates ?? []);
+        const installed = command !== null;
+        runtimes.push({
+            adapterKind: spec.adapterKind,
+            name: spec.name,
+            command: command ?? undefined,
+            cwd: command ? dirname(command) : undefined,
+            installed,
+        });
+    }
+    return { runtimes, agents: [] };
+}
+function defaultRuntimeSpecs(home) {
+    return [
+        {
+            bin: 'claude',
+            name: 'Claude Code',
+            adapterKind: 'claude-code',
+            candidates: claudeCandidates(home),
+        },
+        {
+            bin: 'codex',
+            name: 'Codex CLI',
+            adapterKind: 'codex',
+        },
+        {
+            bin: 'gemini',
+            name: 'Gemini CLI',
+            adapterKind: 'gemini',
+        },
+    ];
+}
+async function findExecutableOnPath(bin, candidates, options) {
+    for (const candidate of candidates) {
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    for (const directory of pathEntries(options)) {
+        const candidate = join(directory, bin);
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function pathEntries(options) {
+    const home = options.homeDir ?? homedir();
+    return [
+        ...(options.envPath ?? process.env.PATH ?? '').split(':').filter(Boolean),
+        '/usr/local/bin',
+        '/opt/homebrew/bin',
+        join(home, '.local/bin'),
+        join(home, '.bun/bin'),
+        join(home, '.npm-global/bin'),
+        join(home, '.asdf/shims'),
+        join(home, '.local/share/mise/shims'),
+    ];
+}
+function claudeCandidates(home) {
+    return [
+        join(home, '.local/share/claude-latest/current/claude'),
+        join(home, '.local/share/claude/current/claude'),
+        '/opt/homebrew/lib/node_modules/@anthropic-ai/claude-code/cli.js',
+        '/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js',
+    ];
+}
+function isExecutableFile(path) {
+    try {
+        return existsSync(path) && statSync(path).isFile() && isExecutable(path);
+    }
+    catch {
+        return false;
+    }
+}
+function isExecutable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/packages/contracts/src/agent.d.ts

@@ -0,0 +1,69 @@
+import type { ID, UnixMs } from './common.js';
+export declare const ADAPTER_KINDS: readonly ["codex", "claude-code", "gemini", "kimi-cli", "hermes", "openclaw"];
+export type AdapterKind = (typeof ADAPTER_KINDS)[number];
+export declare const AGENT_CATEGORIES: readonly ["executor-hosted", "agentos-hosted"];
+export type AgentCategory = (typeof AGENT_CATEGORIES)[number];
+export declare const AGENT_SOURCES: readonly ["custom", "self-register", "scanned"];
+export type AgentSource = (typeof AGENT_SOURCES)[number];
+export declare const AGENT_STATUSES: readonly ["connecting", "online", "busy", "offline", "error"];
+export type AgentStatus = (typeof AGENT_STATUSES)[number];
+export interface RuntimeDto {
+    id: ID;
+    deviceId: ID;
+    adapterKind: AdapterKind;
+    name: string;
+    installed: boolean;
+    command?: string;
+    cwd?: string;
+    normalizedCommandKey?: string;
+    normalizedCwdKey?: string;
+    version?: string;
+    lastSeenAt?: UnixMs;
+}
+export interface AgentDto {
+    id: ID;
+    primaryTeamId: ID;
+    visibleTeamIds: ID[];
+    name: string;
+    adapterKind: AdapterKind;
+    category: AgentCategory;
+    source: AgentSource;
+    status: AgentStatus;
+    ownerId?: ID;
+    deviceId?: ID;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    envKeys?: string[];
+    description?: string;
+    lastSeenAt?: UnixMs;
+    lastError?: string;
+}
+export interface DiscoveredAgentDto {
+    deviceId: ID;
+    teamId: ID;
+    adapterKind: AdapterKind;
+    name: string;
+    category: AgentCategory;
+    source: 'scanned' | 'self-register';
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    gatewayId?: string;
+    gatewayName?: string;
+    gatewayInstanceKey?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateAgentCommandDto {
+    userId: ID;
+    teamId: ID;
+    deviceId: ID;
+    runtimeId?: ID;
+    name: string;
+    description?: string;
+    adapterKind?: AdapterKind;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}

package/dist/packages/contracts/src/agent.js

@@ -0,0 +1,4 @@
+export const ADAPTER_KINDS = ['codex', 'claude-code', 'gemini', 'kimi-cli', 'hermes', 'openclaw'];
+export const AGENT_CATEGORIES = ['executor-hosted', 'agentos-hosted'];
+export const AGENT_SOURCES = ['custom', 'self-register', 'scanned'];
+export const AGENT_STATUSES = ['connecting', 'online', 'busy', 'offline', 'error'];

package/dist/packages/contracts/src/auth.d.ts

@@ -0,0 +1,20 @@
+import type { ID } from './common.js';
+export type UserRole = 'user' | 'admin';
+export type TeamMemberRole = 'owner' | 'admin' | 'member';
+export interface UserDto {
+    id: ID;
+    username: string;
+    role: UserRole;
+    displayName?: string;
+    avatarUrl?: string;
+    primaryTeamId?: ID;
+}
+export interface HumanMemberDto {
+    id: ID;
+    teamId: ID;
+    userId: ID;
+    username: string;
+    role: TeamMemberRole;
+    displayName?: string;
+    avatarUrl?: string;
+}

package/dist/packages/contracts/src/auth.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/contracts/src/channel.d.ts

@@ -0,0 +1,58 @@
+import type { ID, UnixMs } from './common.js';
+import type { AgentDto } from './agent.js';
+import type { HumanMemberDto } from './auth.js';
+export type ChannelKind = 'channel' | 'direct';
+export type ChannelVisibility = 'public' | 'private';
+export interface ChannelDto {
+    id: ID;
+    teamId: ID;
+    kind: ChannelKind;
+    name: string;
+    visibility: ChannelVisibility;
+    title?: string;
+    createdBy?: ID;
+    createdAt: UnixMs;
+    updatedAt?: UnixMs;
+}
+export interface CreateChannelCommandDto {
+    userId: ID;
+    teamId: ID;
+    name: string;
+    title?: string;
+    visibility: ChannelVisibility;
+    humanMemberIds?: ID[];
+    agentMemberIds?: ID[];
+}
+export interface UpdateChannelCommandDto {
+    userId: ID;
+    teamId: ID;
+    channelId: ID;
+    name?: string;
+    title?: string;
+    visibility?: ChannelVisibility;
+    humanMemberIds?: ID[];
+    agentMemberIds?: ID[];
+}
+export interface ChannelHumanMemberCommandDto {
+    userId: ID;
+    teamId: ID;
+    channelId: ID;
+    memberUserId: ID;
+}
+export interface ChannelAgentMemberCommandDto {
+    userId: ID;
+    teamId: ID;
+    channelId: ID;
+    agentId: ID;
+}
+export interface ListChannelMembersCommandDto {
+    userId: ID;
+    teamId: ID;
+    channelId: ID;
+}
+export interface ChannelMembersDto {
+    humanMemberIds: ID[];
+    agentMemberIds: ID[];
+    humans: HumanMemberDto[];
+    agents: AgentDto[];
+}

package/dist/packages/contracts/src/channel.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/contracts/src/common.d.ts

@@ -0,0 +1,17 @@
+export type ID = string;
+export type UnixMs = number;
+export declare const ERROR_CODES: readonly ["BAD_REQUEST", "UNAUTHENTICATED", "FORBIDDEN", "NOT_FOUND", "CONFLICT", "VALIDATION_ERROR", "DEVICE_OFFLINE", "AGENT_OFFLINE", "DISPATCH_TIMEOUT", "INTERNAL_ERROR"];
+export type ErrorCode = (typeof ERROR_CODES)[number];
+export type SuccessAck<T extends object = Record<string, never>> = {
+    ok: true;
+} & T;
+export interface FailureAck {
+    ok: false;
+    error: ErrorCode;
+    message?: string;
+    details?: Record<string, unknown>;
+}
+export type Ack<T extends object = Record<string, never>> = SuccessAck<T> | FailureAck;
+export declare function isErrorCode(value: string): value is ErrorCode;
+export declare function makeSuccess<T extends object = Record<string, never>>(payload?: T): SuccessAck<T>;
+export declare function makeFailure(error: ErrorCode, message?: string, details?: Record<string, unknown>): FailureAck;