@mokei/host-protocol 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024-present Paul Le Cam and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# Mokei Host protocol
+
+## Installation
+
+```sh
+npm install @mokei/host-protocol
+```

package/lib/index.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Mokei Host protocol.
+ *
+ * ## Installation
+ *
+ * ```sh
+ * npm install @mokei/host-protocol
+ * ```
+ *
+ * @module host-protocol
+ */
+import type { AnyClientMessageOf, AnyServerMessageOf } from '@enkaku/protocol';
+import type { FromSchema } from '@enkaku/schema';
+export declare const DEFAULT_SOCKET_PATH: string;
+export declare const hostEventMetaSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly contextID: {
+            readonly type: "string";
+        };
+        readonly eventID: {
+            readonly type: "string";
+        };
+        readonly time: {
+            readonly type: "integer";
+        };
+    };
+    readonly required: readonly ["contextID", "eventID", "time"];
+    readonly additionalProperties: false;
+};
+export type HostEventMeta = FromSchema<typeof hostEventMetaSchema>;
+export declare const hostEventSchema: {
+    readonly anyOf: readonly [{
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly const: "context:start";
+            };
+            readonly meta: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly contextID: {
+                        readonly type: "string";
+                    };
+                    readonly eventID: {
+                        readonly type: "string";
+                    };
+                    readonly time: {
+                        readonly type: "integer";
+                    };
+                };
+                readonly required: readonly ["contextID", "eventID", "time"];
+                readonly additionalProperties: false;
+            };
+            readonly data: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly transport: {
+                        readonly type: "string";
+                        readonly const: "stdio";
+                    };
+                    readonly command: {
+                        readonly type: "string";
+                    };
+                    readonly args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly required: readonly ["transport", "command", "args"];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly required: readonly ["type", "meta", "data"];
+        readonly additionalProperties: false;
+    }, {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly const: "context:stop";
+            };
+            readonly meta: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly contextID: {
+                        readonly type: "string";
+                    };
+                    readonly eventID: {
+                        readonly type: "string";
+                    };
+                    readonly time: {
+                        readonly type: "integer";
+                    };
+                };
+                readonly required: readonly ["contextID", "eventID", "time"];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly required: readonly ["type", "meta"];
+        readonly additionalProperties: false;
+    }, {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly const: "context:message";
+            };
+            readonly meta: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly contextID: {
+                        readonly type: "string";
+                    };
+                    readonly eventID: {
+                        readonly type: "string";
+                    };
+                    readonly time: {
+                        readonly type: "integer";
+                    };
+                };
+                readonly required: readonly ["contextID", "eventID", "time"];
+                readonly additionalProperties: false;
+            };
+            readonly data: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly from: {
+                        readonly type: "string";
+                        readonly enum: readonly ["client", "server"];
+                    };
+                    readonly message: {
+                        readonly type: "object";
+                    };
+                };
+                readonly required: readonly ["from", "message"];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly required: readonly ["type", "meta", "data"];
+        readonly additionalProperties: false;
+    }];
+};
+export type HostEvent = FromSchema<typeof hostEventSchema>;
+export declare const activeContextInfoSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly startedTime: {
+            readonly type: "integer";
+        };
+    };
+    readonly required: readonly ["startedTime"];
+};
+export type ActiveContextInfo = FromSchema<typeof activeContextInfoSchema>;
+export declare const hostInfoResultSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly activeContexts: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly startedTime: {
+                        readonly type: "integer";
+                    };
+                };
+                readonly required: readonly ["startedTime"];
+            };
+        };
+        readonly startedTime: {
+            readonly type: "integer";
+        };
+    };
+    readonly required: readonly ["activeContexts", "startedTime"];
+    readonly additionalProperties: false;
+};
+export type HostInfoResult = FromSchema<typeof hostInfoResultSchema>;
+export declare const protocol: {
+    readonly events: {
+        readonly type: "stream";
+        readonly receive: {
+            readonly type: "object";
+        };
+    };
+    readonly info: {
+        readonly type: "request";
+        readonly result: {
+            readonly type: "object";
+            readonly properties: {
+                readonly activeContexts: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly startedTime: {
+                                readonly type: "integer";
+                            };
+                        };
+                        readonly required: readonly ["startedTime"];
+                    };
+                };
+                readonly startedTime: {
+                    readonly type: "integer";
+                };
+            };
+            readonly required: readonly ["activeContexts", "startedTime"];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly shutdown: {
+        readonly type: "request";
+    };
+    readonly spawn: {
+        readonly type: "channel";
+        readonly param: {
+            readonly type: "object";
+            readonly properties: {
+                readonly command: {
+                    readonly type: "string";
+                };
+                readonly args: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly required: readonly ["command"];
+            readonly additionalProperties: false;
+        };
+        readonly send: {
+            readonly type: "object";
+        };
+        readonly receive: {
+            readonly type: "object";
+        };
+    };
+};
+export type Protocol = typeof protocol;
+export type ClientMessage = AnyClientMessageOf<Protocol>;
+export type ServerMessage = AnyServerMessageOf<Protocol>;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAsB,MAAM,kBAAkB,CAAA;AAClG,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,gBAAgB,CAAA;AAExD,eAAO,MAAM,mBAAmB,QAAwC,CAAA;AAExE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;CASL,CAAA;AAC3B,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAElE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDD,CAAA;AAC3B,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,eAAO,MAAM,uBAAuB;;;;;;;;CAMT,CAAA;AAC3B,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;CAWN,CAAA;AAC3B,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BkB,CAAA;AACvC,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAA;AAEtC,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAA;AACxD,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAA"}

package/lib/index.js

@@ -0,0 +1,198 @@
+/**
+ * Mokei Host protocol.
+ *
+ * ## Installation
+ *
+ * ```sh
+ * npm install @mokei/host-protocol
+ * ```
+ *
+ * @module host-protocol
+ */ import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const DEFAULT_SOCKET_PATH = join(homedir(), '.mokei-daemon.sock');
+export const hostEventMetaSchema = {
+    type: 'object',
+    properties: {
+        contextID: {
+            type: 'string'
+        },
+        eventID: {
+            type: 'string'
+        },
+        time: {
+            type: 'integer'
+        }
+    },
+    required: [
+        'contextID',
+        'eventID',
+        'time'
+    ],
+    additionalProperties: false
+};
+export const hostEventSchema = {
+    anyOf: [
+        {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    const: 'context:start'
+                },
+                meta: hostEventMetaSchema,
+                data: {
+                    type: 'object',
+                    properties: {
+                        transport: {
+                            type: 'string',
+                            const: 'stdio'
+                        },
+                        command: {
+                            type: 'string'
+                        },
+                        args: {
+                            type: 'array',
+                            items: {
+                                type: 'string'
+                            }
+                        }
+                    },
+                    required: [
+                        'transport',
+                        'command',
+                        'args'
+                    ],
+                    additionalProperties: false
+                }
+            },
+            required: [
+                'type',
+                'meta',
+                'data'
+            ],
+            additionalProperties: false
+        },
+        {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    const: 'context:stop'
+                },
+                meta: hostEventMetaSchema
+            },
+            required: [
+                'type',
+                'meta'
+            ],
+            additionalProperties: false
+        },
+        {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    const: 'context:message'
+                },
+                meta: hostEventMetaSchema,
+                data: {
+                    type: 'object',
+                    properties: {
+                        from: {
+                            type: 'string',
+                            enum: [
+                                'client',
+                                'server'
+                            ]
+                        },
+                        message: {
+                            type: 'object'
+                        }
+                    },
+                    required: [
+                        'from',
+                        'message'
+                    ],
+                    additionalProperties: false
+                }
+            },
+            required: [
+                'type',
+                'meta',
+                'data'
+            ],
+            additionalProperties: false
+        }
+    ]
+};
+export const activeContextInfoSchema = {
+    type: 'object',
+    properties: {
+        startedTime: {
+            type: 'integer'
+        }
+    },
+    required: [
+        'startedTime'
+    ]
+};
+export const hostInfoResultSchema = {
+    type: 'object',
+    properties: {
+        activeContexts: {
+            type: 'object',
+            additionalProperties: activeContextInfoSchema
+        },
+        startedTime: {
+            type: 'integer'
+        }
+    },
+    required: [
+        'activeContexts',
+        'startedTime'
+    ],
+    additionalProperties: false
+};
+export const protocol = {
+    events: {
+        type: 'stream',
+        receive: {
+            type: 'object'
+        }
+    },
+    info: {
+        type: 'request',
+        result: hostInfoResultSchema
+    },
+    shutdown: {
+        type: 'request'
+    },
+    spawn: {
+        type: 'channel',
+        param: {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string'
+                },
+                args: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            },
+            required: [
+                'command'
+            ],
+            additionalProperties: false
+        },
+        send: {
+            type: 'object'
+        },
+        receive: {
+            type: 'object'
+        }
+    }
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mokei/host-protocol",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Mokei Host protocol",
+  "keywords": [
+    "model",
+    "context",
+    "protocol",
+    "mcp",
+    "llm",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TairuFramework/mokei",
+    "directory": "packages/host-protocol"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/*"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@enkaku/protocol": "^0.10.0",
+    "@enkaku/schema": "^0.10.0"
+  },
+  "scripts": {
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:types:ci": "tsc --emitDeclarationOnly --skipLibCheck --declarationMap false",
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test:types": "tsc --noEmit",
+    "test:unit": "node --experimental-vm-modules ../../node_modules/jest/bin/jest.js",
+    "test": "pnpm run test:types && pnpm run test:unit"
+  }
+}