@aryacode/dsh-local-llm 0.0.0-stage → 0.8.2

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Local LLM",
+    "description": "AryaStrata engine controls with the local NInfer Qwen3.8 dense model for AryaAI."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "本地 LLM",
+    "description": "AryaStrata 引擎控制，以及本地 NInfer（Qwen3.8 稠密模型）界面。"
+  }
+}

package/package.json

@@ -1,6 +1,73 @@
-{
-  "name": "@aryacode/dsh-local-llm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@aryacode/dsh-local-llm",
+  "version": "0.8.2",
+  "description": "AryaStrata engine controls with the local NInfer Qwen3.8 dense model for AryaAI",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "prebuild": "node scripts/theme.mjs",
+    "test": "node --test tests/*.test.mjs",
+    "test:ui": "node tests/control-center-ui.mjs"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-host-webserver": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm-pi-ai": "^0.2.0-rc.2",
+    "@types/node": "^22.10.0",
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "tsdown": "^0.22.14",
+    "typescript": "^5.6.0"
+  },
+  "files": [
+    "icon.svg",
+    "locale/*.json",
+    "lib/index.js",
+    "lib/index.d.ts",
+    "lib/client.js",
+    "lib/client.js.map",
+    "lib/openai-completions-*.js",
+    "lib/event-stream-*.js",
+    "cordis.patch.yml",
+    "blue.png",
+    "README.md",
+    "LEGACY-CONTROL-CENTER.md",
+    "scripts/freetoken-control.py",
+    "scripts/ninfer-control.py"
+  ],
+  "dependencies": {
+    "@earendil-works/pi-ai": "^0.87.1",
+    "saxes": "^6.0.0",
+    "systeminformation": "5.33.15"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-llm-pi-ai": "^0.2.0-rc.2"
+  },
+  "icon": "./icon.svg"
+}

package/scripts/freetoken-control.py

@@ -0,0 +1,82 @@
+"""Own one FreeToken process group inside WSL; refuse unrelated processes."""
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+directory = Path(sys.argv[1])
+action = sys.argv[2]
+request = json.load(sys.stdin)
+directory.mkdir(parents=True, exist_ok=True)
+owner_file = directory / 'owner.json'
+log_file = directory / 'server.log'
+
+def identity(pid):
+    try:
+        fields = Path('/proc/' + str(pid) + '/stat').read_text().rsplit(')', 1)[1].split()
+        return None if fields[0] == 'Z' else fields[19]
+    except (FileNotFoundError, ProcessLookupError):
+        return None
+
+def owner():
+    if not owner_file.exists():
+        return None
+    record = json.loads(owner_file.read_text())
+    return record if identity(record['pid']) == record['started'] else None
+
+def stop():
+    record = owner()
+    if record:
+        os.killpg(record['pid'], signal.SIGTERM)
+        deadline = time.monotonic() + 20
+        while identity(record['pid']) is not None and time.monotonic() < deadline:
+            time.sleep(.2)
+        if identity(record['pid']) == record['started']:
+            os.killpg(record['pid'], signal.SIGKILL)
+            deadline = time.monotonic() + 5
+            while identity(record['pid']) is not None and time.monotonic() < deadline:
+                time.sleep(.1)
+            if identity(record['pid']) is not None:
+                raise RuntimeError('FreeToken has not stopped yet.')
+        owner_file.unlink(missing_ok=True)
+
+if action == 'status':
+    record = owner()
+    print(json.dumps({'owned': bool(record), 'pid': record['pid'] if record else None}))
+elif action == 'logs':
+    if log_file.exists():
+        with log_file.open('rb') as stream:
+            stream.seek(max(0, log_file.stat().st_size - 16000))
+            text = stream.read().decode(errors='replace')
+    else:
+        text = ''
+    print(json.dumps({'text': text}))
+elif action == 'stop':
+    stop()
+    print(json.dumps({'ok': True, 'detail': 'FreeToken stopped.'}))
+elif action == 'start':
+    if owner():
+        raise RuntimeError('FreeToken is already running.')
+    args = [request['runtime'] + '/bin/ft', 'serve', '--model-path', request['modelPath'],
+            '--served-model-name', request['alias'], '--host', '127.0.0.1', '--port', str(request['port']),
+            '--max-seq-len-override', str(request['context']), '--max-running-requests', '1',
+            '--max-prefill-length', str(request['prefill']), '--memory-ratio', str(request['memoryRatio']),
+            '--moe-strategy', request['strategy'], '--moe-cpu-threads', str(request['threads']),
+            '--moe-cpu-layers', 'auto', '--moe-cache-auto', '--kv-reserve-tokens', str(request['context']),
+            '--nvfp4-backend', 'triton', '--expert-load', 'serial',
+            '--mm-encoder-weights', 'host', '--image-max-tokens', '1024']
+    if not request['vision']:
+        args += ['--mm-disable', 'vision']
+    with log_file.open('ab', buffering=0) as log:
+        process = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=log, stderr=log,
+                                   start_new_session=True, cwd=directory)
+    started = identity(process.pid)
+    if started is None:
+        raise RuntimeError('FreeToken exited during launch; inspect its logs.')
+    owner_file.write_text(json.dumps({'pid': process.pid, 'started': started}))
+    print(json.dumps({'ok': True, 'detail': 'FreeToken is loading. Check server status.', 'pid': process.pid}))
+else:
+    raise ValueError('Unsupported FreeToken operation.')

package/scripts/ninfer-control.py

@@ -0,0 +1,120 @@
+"""Manage one identified NInfer process group without Docker or shell commands."""
+import json
+import errno
+import os
+import signal
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def identity(pid):
+    try:
+        fields = Path(f'/proc/{pid}/stat').read_text().rsplit(')', 1)[1].split()
+        return None if fields[0] == 'Z' else fields[19]
+    except (FileNotFoundError, ProcessLookupError):
+        return None
+
+
+def owned_record(owner_file, binary):
+    if not owner_file.exists():
+        return None
+    record = json.loads(owner_file.read_text())
+    pid = record['pid']
+    if not isinstance(pid, int) or pid <= 1 or identity(pid) != record['started']:
+        return None
+    try:
+        executable = Path(f'/proc/{pid}/exe').resolve(strict=True)
+        args = Path(f'/proc/{pid}/cmdline').read_bytes().split(b'\0')
+        expected = [arg.encode() for arg in record['args']]
+        matches = executable == binary.resolve() and args[:-1] == expected and os.getpgid(pid) == pid
+    except (FileNotFoundError, ProcessLookupError):
+        return None
+    if not matches:
+        raise RuntimeError('NInfer process identity changed; no process was stopped.')
+    return record
+
+
+def stop(owner_file, binary):
+    record = owned_record(owner_file, binary)
+    if not record:
+        return
+    os.killpg(record['pid'], signal.SIGTERM)
+    deadline = time.monotonic() + 20
+    while owned_record(owner_file, binary) and time.monotonic() < deadline:
+        time.sleep(.1)
+    if owned_record(owner_file, binary):
+        os.killpg(record['pid'], signal.SIGKILL)
+        deadline = time.monotonic() + 5
+        while owned_record(owner_file, binary) and time.monotonic() < deadline:
+            time.sleep(.1)
+        if owned_record(owner_file, binary):
+            raise RuntimeError('NInfer has not stopped yet.')
+    owner_file.unlink(missing_ok=True)
+
+
+def ensure_port_available(port):
+    with socket.socket() as probe:
+        probe.settimeout(1)
+        result = probe.connect_ex(('127.0.0.1', port))
+        if result != errno.ECONNREFUSED:
+            raise RuntimeError('NInfer port has a listener or could not be checked; no server was stopped.')
+
+
+def main():
+    directory, action = Path(sys.argv[1]), sys.argv[2]
+    request = json.load(sys.stdin)
+    directory.mkdir(parents=True, exist_ok=True)
+    binary = Path(request['binary'])
+    owner_file = directory / 'wsl-owner.json'
+    log_file = directory / 'wsl-server.log'
+    record = owned_record(owner_file, binary)
+    if action == 'status':
+        print(json.dumps({'owned': bool(record), 'pid': record['pid'] if record else None,
+                          'available': binary.is_file() and os.access(binary, os.X_OK)}))
+    elif action == 'logs':
+        text = ''
+        if log_file.exists():
+            with log_file.open('rb') as stream:
+                stream.seek(max(0, log_file.stat().st_size - 16000))
+                text = stream.read().decode(errors='replace')
+        print(json.dumps({'text': text}))
+    elif action == 'stop':
+        stop(owner_file, binary)
+        print(json.dumps({'ok': True, 'detail': 'NInfer stopped.'}))
+    elif action == 'start':
+        if record:
+            print(json.dumps({'ok': True, 'detail': 'NInfer is already started.'}))
+            return
+        if not binary.is_file() or not os.access(binary, os.X_OK):
+            raise RuntimeError('NInfer binary is unavailable. Finish the WSL build first.')
+        ensure_port_available(request['port'])
+        args = [str(binary), request['artifact'], '--host', '127.0.0.1', '--port', str(request['port']),
+                '--max-context', str(request['context']), '--kv-capacity', str(request['context']),
+                '--kv-dtype', 'rk4v4-e8', '--max-concurrency', '1', '--max-pending-requests', '16',
+                '--prefill-chunk', str(request['prefill']), '--host-kv-mib', str(request['hostKvMiB']),
+                '--default-max-tokens', str(request.get('outputTokens', 8192)),
+                '--spec', 'mtp', '--draft-tokens', str(request['draftTokens']), '--lm-head-draft',
+                '--ngram', request['ngram'], '--preserve-thinking']
+        if request['vision']:
+            args.append('--vision')
+        environment = dict(os.environ)
+        environment['LD_LIBRARY_PATH'] = request['libraryPath']
+        with log_file.open('ab', buffering=0) as log:
+            process = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=log, stderr=log,
+                                       start_new_session=True, cwd=directory, env=environment)
+        started = identity(process.pid)
+        if started is None:
+            raise RuntimeError('NInfer exited during launch; inspect its logs.')
+        marker = owner_file.with_suffix('.tmp')
+        marker.write_text(json.dumps({'pid': process.pid, 'started': started, 'args': args}))
+        marker.replace(owner_file)
+        print(json.dumps({'ok': True, 'detail': 'NInfer is loading in WSL. Check readiness and logs.', 'pid': process.pid}))
+    else:
+        raise ValueError('Unsupported NInfer operation.')
+
+
+if __name__ == '__main__':
+    main()