@rynx-ai/server 0.1.0

package/dist/channel-manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Runtime manager for mounted channel instances in the single-process control
+ * plane. Holds live channel handles keyed by instance id and can start / stop /
+ * reload a single instance without restarting the daemon — the seam the web
+ * control page drives.
+ *
+ * Shared pieces (host/conversationRuntime/codex session store) are injected once
+ * and reused across instances; only the per-instance {@link ChannelContext}
+ * fields (instanceId / options / defaultAgent) differ, so two Lark bots get
+ * distinct credentials + state while sharing one agent runtime.
+ */
+import type { AgentCapabilities, AgentSessionStore, AppConfig, ChannelInstanceDescriptor, ConversationRuntime, SessionBus, SessionLogStore, SessionRegistry } from "@rynx-ai/core";
+export interface ChannelInstanceStatus {
+    instanceId: string;
+    type: string;
+    running: boolean;
+    agent?: string;
+    /** Connection state from the channel, or null when it exposes no status. */
+    connected: boolean | null;
+    lastError?: string | null;
+    lastEventAt?: string | null;
+}
+export interface ChannelManagerOptions {
+    config: AppConfig;
+    conversationRuntime: ConversationRuntime;
+    capabilities: AgentCapabilities;
+    sessionStore: AgentSessionStore;
+    /** Durable canonical session log, shared across instances (absent ⇒ no
+     *  persistence). */
+    sessionLog?: SessionLogStore;
+    /** Shared canonical session event bus (one instance ⇒ cross-channel fan-out). */
+    sessionBus?: SessionBus;
+    /** Unified machine-session registry, shared across instances; channels register
+     *  their sessions' identity rows here so the control plane lists them. */
+    sessionRegistry?: SessionRegistry;
+    /** Source of truth for current instance descriptors (daemon reads config). */
+    loadInstances: () => Promise<ChannelInstanceDescriptor[]>;
+    log?: (line: string) => void;
+}
+export declare class ChannelManager {
+    private readonly opts;
+    private readonly mounted;
+    constructor(opts: ChannelManagerOptions);
+    /** Mount + start every enabled instance from `loadInstances`. */
+    startAll(): Promise<void>;
+    /** Stop every mounted instance (on server close). */
+    stopAll(): Promise<void>;
+    /** Live status of currently-mounted instances. */
+    list(): ChannelInstanceStatus[];
+    isRunning(instanceId: string): boolean;
+    /** Start one instance by id (re-reads descriptors). No-op if already running. */
+    startInstance(instanceId: string): Promise<void>;
+    /** Stop + unmount one instance. No-op if not running. */
+    stopInstance(instanceId: string): Promise<void>;
+    /** Stop then start, picking up edited options/agent. */
+    reloadInstance(instanceId: string): Promise<void>;
+    private mountAndStart;
+    private buildContext;
+    private log;
+}

package/dist/channel-manager.js

@@ -0,0 +1,106 @@
+export class ChannelManager {
+    opts;
+    mounted = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Mount + start every enabled instance from `loadInstances`. */
+    async startAll() {
+        const instances = await this.opts.loadInstances();
+        for (const descriptor of instances) {
+            await this.mountAndStart(descriptor);
+        }
+    }
+    /** Stop every mounted instance (on server close). */
+    async stopAll() {
+        const ids = [...this.mounted.keys()];
+        await Promise.all(ids.map((id) => this.stopInstance(id)));
+    }
+    /** Live status of currently-mounted instances. */
+    list() {
+        return [...this.mounted.values()].map(({ descriptor, channel }) => {
+            const status = channel.getStatus?.();
+            return {
+                instanceId: descriptor.instanceId,
+                type: descriptor.type,
+                running: true,
+                agent: descriptor.agent,
+                connected: status ? status.connected : null,
+                lastError: status?.lastError ?? null,
+                lastEventAt: status?.lastEventAt ?? null,
+            };
+        });
+    }
+    isRunning(instanceId) {
+        return this.mounted.has(instanceId);
+    }
+    /** Start one instance by id (re-reads descriptors). No-op if already running. */
+    async startInstance(instanceId) {
+        if (this.mounted.has(instanceId))
+            return;
+        const descriptor = (await this.opts.loadInstances()).find((instance) => instance.instanceId === instanceId);
+        if (!descriptor) {
+            throw new Error(`channel instance "${instanceId}" is not enabled/configured`);
+        }
+        await this.mountAndStart(descriptor);
+    }
+    /** Stop + unmount one instance. No-op if not running. */
+    async stopInstance(instanceId) {
+        const entry = this.mounted.get(instanceId);
+        if (!entry)
+            return;
+        this.mounted.delete(instanceId);
+        try {
+            await entry.channel.stop();
+        }
+        catch (error) {
+            this.log(`instance "${instanceId}" stop failed: ${messageOf(error)}`);
+        }
+    }
+    /** Stop then start, picking up edited options/agent. */
+    async reloadInstance(instanceId) {
+        await this.stopInstance(instanceId);
+        // Only restart if it's still enabled/configured (disable ⇒ stays stopped).
+        const descriptor = (await this.opts.loadInstances()).find((instance) => instance.instanceId === instanceId);
+        if (descriptor) {
+            await this.mountAndStart(descriptor);
+        }
+    }
+    async mountAndStart(descriptor) {
+        let channel;
+        try {
+            channel = descriptor.factory(this.buildContext(descriptor));
+        }
+        catch (error) {
+            this.log(`instance "${descriptor.instanceId}" construct failed: ${messageOf(error)}`);
+            return;
+        }
+        this.mounted.set(descriptor.instanceId, { descriptor, channel });
+        try {
+            await channel.start();
+        }
+        catch (error) {
+            this.log(`instance "${descriptor.instanceId}" start failed: ${messageOf(error)}`);
+        }
+    }
+    buildContext(descriptor) {
+        return {
+            config: this.opts.config,
+            conversationRuntime: this.opts.conversationRuntime,
+            capabilities: this.opts.capabilities,
+            sessionStore: this.opts.sessionStore,
+            sessionLog: this.opts.sessionLog,
+            sessionBus: this.opts.sessionBus,
+            sessionRegistry: this.opts.sessionRegistry,
+            instanceId: descriptor.instanceId,
+            options: descriptor.options,
+            defaultAgent: descriptor.agent,
+        };
+    }
+    log(line) {
+        (this.opts.log ?? ((message) => console.error(message)))(line);
+    }
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/control-api.d.ts

@@ -0,0 +1,188 @@
+import Router from "@koa/router";
+import { type AgentSpec, type AuthMaterial, type ConversationRuntime, type MachineSessionRecord, type AgentRuntimeId, type SessionBus, type SessionLogStore, type SkillInstallRecipe } from "@rynx-ai/core";
+import type { ControlChannel, ControlChannelType, ControlInstanceConfig, ControlAgentSummary, SkillSummary, SkillDetail } from "@rynx-ai/protocol/control";
+import type { CodexSessionStore, InjectOutcome } from "@rynx-ai/runtime";
+import type { ChannelManager } from "./channel-manager.js";
+export interface ControlEmulatorDeps {
+    doctor(): Promise<unknown>;
+    devices(): Promise<unknown[]>;
+    active(): Promise<unknown | null>;
+    /** One device's attached session, for session-scoped `active` resolution. */
+    deviceSession?(input: {
+        device: string;
+    }): Promise<unknown | null>;
+    attach(device?: string): Promise<unknown>;
+    tap(input: {
+        x: number;
+        y: number;
+        device?: string;
+    }): Promise<unknown>;
+    type(input: {
+        text: string;
+        device?: string;
+        mode?: string;
+    }): Promise<unknown>;
+    button(input: {
+        name?: string;
+        device?: string;
+    }): Promise<unknown>;
+    rotate(input: {
+        orientation: string;
+        device?: string;
+    }): Promise<unknown>;
+    launch(input: {
+        appId: string;
+        device?: string;
+    }): Promise<unknown>;
+    gesture(input: {
+        points: unknown[];
+        device?: string;
+    }): Promise<unknown>;
+    exec(input: {
+        command: string;
+        device?: string;
+    }): Promise<unknown>;
+    screenshot(input: {
+        device?: string;
+        out?: string;
+    }): Promise<unknown>;
+    frame?(input: {
+        device?: string;
+    }): Promise<{
+        ok: true;
+        backend: "ios" | "android";
+        device: string;
+        contentType: "image/png";
+        data: Buffer;
+    }>;
+    video?(input: {
+        device?: string;
+    }): Promise<{
+        ok: true;
+        backend: "ios" | "android";
+        device: string;
+        contentType: "video/h264";
+        stream: NodeJS.ReadableStream;
+        stop(): void;
+    }>;
+    liveTouch?(input: {
+        device?: string;
+    }): Promise<{
+        ok: true;
+        backend: "ios" | "android";
+        device: string;
+        send(point: {
+            type: "begin" | "move" | "end";
+            x: number;
+            y: number;
+        }): void;
+        close(): void;
+    }>;
+    readScreenshotFile?(input: {
+        file: string;
+    }): Promise<{
+        file: string;
+        contentType: "image/png";
+        data: Buffer;
+    } | null>;
+    kill(input: {
+        device?: string;
+    }): Promise<unknown>;
+    shutdown(input: {
+        device?: string;
+    }): Promise<unknown>;
+}
+export interface ControlPlaneDeps {
+    listChannelTypes(): ControlChannelType[];
+    listChannels(): ControlChannel[];
+    createChannel(input: {
+        name: string;
+        type: string;
+        options?: Record<string, unknown>;
+    }): {
+        id: string;
+    };
+    setChannel(id: string, patch: {
+        name?: string;
+        options?: Record<string, unknown>;
+    }): void;
+    removeChannel(id: string): void;
+    /** Run a channel type's authorize flow; resolves with the options to persist. */
+    authorizeChannel(type: string, emit: (material: AuthMaterial) => void, signal: AbortSignal): Promise<Record<string, unknown>>;
+    listInstancesConfig(): ControlInstanceConfig[];
+    createInstance(input: {
+        channelId: string;
+        agent?: string;
+    }): {
+        id: string;
+    };
+    setInstance(id: string, patch: {
+        agent?: string;
+        enabled?: boolean;
+    }): void;
+    removeInstance(id: string): void;
+    listAgents(): Promise<ControlAgentSummary[]>;
+    getAgent(name: string): Promise<unknown | null>;
+    /** Validate + persist an agent spec; throws on a schema violation (→ 400). */
+    writeAgent(name: string, spec: Record<string, unknown>): void;
+    removeAgent(name: string): boolean;
+    /** List skills installed in the daemon's global catalog (with install provenance). */
+    listSkills(): Promise<SkillSummary[]>;
+    /** One skill's metadata + its file tree, or null if not in the catalog. */
+    getSkill(name: string): Promise<SkillDetail | null>;
+    /** Read one text file inside a catalog skill (path-confined, size-capped). */
+    readSkillFile(name: string, path: string): Promise<{
+        path: string;
+        content: string;
+    }>;
+    /** Install per a full `SkillInstallRecipe` (the same object recorded in the
+     *  skill's receipt); returns the new catalog. */
+    installSkill(recipe: SkillInstallRecipe): Promise<{
+        name: string;
+        description: string;
+    }[]>;
+    /** Remove a catalog skill by name. */
+    removeSkill(name: string): Promise<boolean>;
+    tailLogs(instanceId: string | undefined, lines: number): Promise<string>;
+    emulator?: ControlEmulatorDeps;
+    listSessionMetas(): StoredSessionMeta[];
+    getSessionMeta(id: string): StoredSessionMeta | undefined;
+    createSessionMeta(meta: StoredSessionMeta): void;
+    setSessionTitle(id: string, title: string): void;
+    removeSessionMeta(id: string): void;
+}
+/** Persisted meta for an agent session — the unified machine-session record.
+ *  Runtime `status` is held separately by the server (idle after a restart);
+ *  transcripts persist via {@link SessionLogStore}. */
+export type StoredSessionMeta = MachineSessionRecord;
+export declare function createControlRouter(opts: {
+    manager: ChannelManager;
+    deps: ControlPlaneDeps;
+    /** Present ⇒ the control plane can run agent sessions (see `/api/sessions`). */
+    runtime?: ConversationRuntime;
+    sessionBus?: SessionBus;
+    sessionLog?: SessionLogStore;
+    /** Used to stop a session's runner on close, resolve interactive approvals,
+     *  and (codex-native live mode) bring up + inject into a session's forwarder. */
+    runnerManager?: {
+        stopRunner(localThreadId: string): void;
+        resolveApproval?(localThreadId: string, approvalId: string, decision: "acceptForSession" | "accept" | "decline" | "cancel"): void;
+        ensureLiveSession?(localThreadId: string, opts?: {
+            cwd?: string;
+            cols?: number;
+            rows?: number;
+            runtime?: AgentRuntimeId;
+            agentName?: string;
+            agentSpec?: AgentSpec;
+        }): Promise<boolean>;
+        injectMessage?(localThreadId: string, text: string): Promise<InjectOutcome>;
+        interruptLiveSession?(localThreadId: string): Promise<boolean>;
+    };
+    /** Global codex/claude session store. Lets the control plane resume a
+     *  non-console session on its original runtime/model/cwd binding. */
+    sessionStore?: CodexSessionStore;
+}): Router;
+/** Derive a one-line session title from the first user message: collapse
+ *  whitespace, trim, and truncate to `limit` chars + an ellipsis (omnigent's
+ *  rule — no LLM call). */
+export declare function synthesizeSessionTitle(message: string, limit?: number): string;