@kin-tio/cli 0.6.0

package/dist/src/supervisor.js

@@ -0,0 +1,212 @@
+import { createAdaptorServer } from '@hono/node-server';
+import { createApp } from './app.js';
+import { createRuntime } from './runtime.js';
+export class KintioSupervisor {
+    #config;
+    #logger;
+    #runtimeFactory;
+    #onFatal;
+    #runtime;
+    #runtimeIngressStopped = false;
+    #runtimeAbort;
+    #runtimeClose;
+    #server;
+    #httpClosing;
+    #state = 'idle';
+    #ingressOpen = false;
+    #starting;
+    #closing;
+    #aborting;
+    constructor({ config, logger = console, runtime, onFatal = (error) => logger.error(`[supervisor] fatal channel error: ${error.message}`), }) {
+        this.#config = config;
+        this.#logger = logger;
+        this.#runtimeFactory = runtime
+            ? async () => runtime
+            : () => createRuntime({ config, logger });
+        this.#onFatal = onFatal;
+    }
+    get state() {
+        return this.#state;
+    }
+    start() {
+        if (this.#starting &&
+            (this.#state === 'starting' || this.#state === 'running'))
+            return this.#starting;
+        if (this.#state !== 'idle') {
+            return Promise.reject(new Error(`Kintio supervisor cannot start from ${this.#state}`));
+        }
+        this.#state = 'starting';
+        this.#starting = (async () => {
+            let startupErrorListener;
+            try {
+                const runtime = await this.#runtimeFactory();
+                this.#runtime = runtime;
+                this.#assertStarting();
+                const app = createApp({
+                    config: this.#config,
+                    logger: this.#logger,
+                    messageProcessor: runtime.messageProcessor,
+                    acceptIngress: () => this.#ingressOpen,
+                });
+                const server = createAdaptorServer({ fetch: app.fetch });
+                this.#server = server;
+                let rejectChannelFailure;
+                const channelFailure = new Promise((_resolve, reject) => {
+                    rejectChannelFailure = reject;
+                });
+                startupErrorListener = (error) => rejectChannelFailure(error);
+                server.on('error', startupErrorListener);
+                const port = await Promise.race([
+                    this.#listen(server),
+                    channelFailure,
+                ]);
+                this.#assertStarting();
+                await Promise.race([runtime.start(), channelFailure]);
+                this.#assertStarting();
+                this.#ingressOpen = true;
+                this.#state = 'running';
+                server.on('error', (error) => this.#fatal(error));
+                server.off('error', startupErrorListener);
+                startupErrorListener = undefined;
+                this.#logger.info(`Hono server is listening on port ${port}`);
+                return Object.freeze({ port });
+            }
+            catch (error) {
+                this.#ingressOpen = false;
+                if (this.#state === 'starting')
+                    this.#state = 'failed';
+                try {
+                    await this.#cleanupFailedStart();
+                }
+                finally {
+                    if (startupErrorListener && this.#server) {
+                        this.#server.off('error', startupErrorListener);
+                    }
+                }
+                throw error;
+            }
+        })();
+        return this.#starting;
+    }
+    close() {
+        if (this.#closing)
+            return this.#closing;
+        if (this.#state === 'closed')
+            return Promise.resolve();
+        if (this.#state === 'aborted') {
+            return Promise.reject(new Error('Process-aborted supervisor requires process exit'));
+        }
+        this.#state = 'closing';
+        this.#ingressOpen = false;
+        this.#stopRuntimeIngress();
+        this.#closing = (async () => {
+            await this.#starting?.catch(() => undefined);
+            try {
+                await this.#closeRuntime();
+            }
+            finally {
+                await this.#closeHttp(false).catch(() => undefined);
+                if (!this.#aborting)
+                    this.#state = 'closed';
+            }
+        })();
+        return this.#closing;
+    }
+    abortForExit() {
+        if (this.#aborting)
+            return this.#aborting;
+        if (this.#state === 'closed')
+            return Promise.resolve();
+        this.#state = 'closing';
+        this.#ingressOpen = false;
+        this.#stopRuntimeIngress();
+        this.#aborting = (async () => {
+            try {
+                await Promise.all([
+                    this.#abortRuntime(),
+                    this.#closeHttp(true).catch(() => undefined),
+                ]);
+            }
+            finally {
+                this.#state = 'aborted';
+            }
+        })();
+        return this.#aborting;
+    }
+    #assertStarting() {
+        if (this.#state !== 'starting') {
+            throw new Error('Kintio supervisor startup was cancelled');
+        }
+    }
+    #listen(server) {
+        return new Promise((resolve, reject) => {
+            server.listen(this.#config.port, '0.0.0.0', () => {
+                const address = server.address();
+                if (!address || typeof address === 'string') {
+                    reject(new Error('Hono listener has no TCP address'));
+                    return;
+                }
+                resolve(address.port);
+            });
+        });
+    }
+    #fatal(error) {
+        if (this.#state !== 'running')
+            return;
+        this.#state = 'failed';
+        this.#ingressOpen = false;
+        void this.abortForExit().catch((abortError) => {
+            this.#logger.error(`[supervisor] fatal cleanup failed: ${abortError instanceof Error ? abortError.message : String(abortError)}`);
+        });
+        try {
+            this.#onFatal(error);
+        }
+        catch (hookError) {
+            this.#logger.error(`[supervisor] fatal hook failed: ${hookError instanceof Error ? hookError.message : String(hookError)}`);
+        }
+    }
+    async #cleanupFailedStart() {
+        this.#stopRuntimeIngress();
+        try {
+            await this.#abortRuntime();
+        }
+        finally {
+            await this.#closeRuntime().catch(() => undefined);
+            await this.#closeHttp(true).catch(() => undefined);
+        }
+    }
+    #stopRuntimeIngress() {
+        if (this.#runtimeIngressStopped)
+            return;
+        if (!this.#runtime)
+            return;
+        this.#runtimeIngressStopped = true;
+        this.#runtime.stopAccepting();
+    }
+    #abortRuntime() {
+        const runtime = this.#runtime;
+        if (!runtime)
+            return Promise.resolve();
+        this.#runtimeAbort ||= runtime.abort();
+        return this.#runtimeAbort;
+    }
+    #closeRuntime() {
+        this.#runtimeClose ||= this.#runtime?.close() || Promise.resolve();
+        return this.#runtimeClose;
+    }
+    async #closeHttp(force) {
+        const server = this.#server;
+        if (!server)
+            return;
+        if (!this.#httpClosing && server.listening) {
+            this.#httpClosing = new Promise((resolve, reject) => {
+                server.close((error) => error ? reject(error) : resolve());
+            });
+        }
+        if (force) {
+            server
+                .closeAllConnections?.();
+        }
+        await this.#httpClosing;
+    }
+}

package/dist/src/types.js

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

package/dist/src/version.js

@@ -0,0 +1 @@
+export const KINTIO_VERSION = '0.6.0';

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@kin-tio/cli",
+  "version": "0.6.0",
+  "license": "Apache-2.0",
+  "author": "XIE YU",
+  "packageManager": "pnpm@10.34.5",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "description": "Connect chat channels to an Agent you control",
+  "bin": {
+    "kintio": "bin/kintio.js"
+  },
+  "files": [
+    "bin/kintio.js",
+    "dist",
+    "assets/ilink-login-card.png",
+    "codex-workspace/.agents/skills/wechat-kf-reply-sop/SKILL.md",
+    ".env.example",
+    "README.md",
+    "README.zh-CN.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Gkxie/kintio.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Gkxie/kintio/issues"
+  },
+  "homepage": "https://github.com/Gkxie/kintio#readme",
+  "keywords": [
+    "chat",
+    "im",
+    "ai-agent",
+    "codex",
+    "mcp"
+  ],
+  "scripts": {
+    "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "dev": "node --watch index.ts",
+    "start": "pnpm run build && node dist/index.js",
+    "test": "vitest run",
+    "prepack": "pnpm run build"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@hono/node-server": "^2.0.12",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "cross-spawn": "7.0.6",
+    "hono": "^4.13.5",
+    "pngjs": "5.0.0",
+    "qrcode": "1.5.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "6.0.6",
+    "@types/node": "24.13.3",
+    "@types/pngjs": "^6.0.5",
+    "@types/qrcode": "1.5.6",
+    "@vitest/coverage-v8": "4.1.11",
+    "knip": "6.32.2",
+    "typescript": "^7.0.2",
+    "vitest": "4.1.11"
+  }
+}