nock-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{nock_cli-0.3.0 → nock_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nock-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: Open models that live on your machine: code, video and a coding agent, offline.
 Author: NockAI
 License-Expression: Apache-2.0

{nock_cli-0.3.0 → nock_cli-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nock-cli"
-version = "0.3.0"
+version = "0.3.1"
 description = "Open models that live on your machine: code, video and a coding agent, offline."
 readme = "README.md"
 requires-python = ">=3.9"

{nock_cli-0.3.0 → nock_cli-0.3.1}/src/nock_cli/__init__.py

@@ -1,3 +1,3 @@
 """Nock CLI: open models that live on your machine."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{nock_cli-0.3.0 → nock_cli-0.3.1}/src/nock_cli/serve.py

@@ -1,181 +1,195 @@
-"""`nock serve`: one local, OpenAI-compatible address for every installed skill.
-
-Editors and tools point at http://127.0.0.1:8080/v1 and choose a model by name. The right llama-server starts on
-first use; only one model is in memory at a time, so asking for another one swaps them. Everything stays on this
-machine: it binds to 127.0.0.1, and refuses requests from websites (a page you visit could otherwise call it).
-"""
-
-import json
-import threading
-import urllib.error
-import urllib.request
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-
-from nock_cli import __version__
-from nock_cli.code import SYSTEM_PROMPT as CODER_SYSTEM_PROMPT
-
-DEFAULT_PORT = 8080
-MODEL_NAMES = {"nock-coder": "coder", "nock-video": "video", "nock-agent": "agent"}
-SYSTEM_PROMPTS = {"coder": CODER_SYSTEM_PROMPT}  # same answers as `nock code`, unless the app sends its own
-MAX_BODY_BYTES = 64 * 1024 * 1024  # room for many video frames as images
-UPSTREAM_TIMEOUT = 1800
-LOCAL_HOSTS = ("127.0.0.1", "localhost", "[::1]")
-
-
-def is_local_host(value):
-  """True for 127.0.0.1, localhost and [::1], with or without a port."""
-  if not value:
-    return False
-  value = value.split("://", 1)[-1].split("/", 1)[0].lower()
-  host = value if value.startswith("[") and value.endswith("]") else value.rsplit(":", 1)[0] if ":" in value else value
-  return host in LOCAL_HOSTS
-
-
-def allowed_request(headers):
-  """Blocks other websites (Origin) and DNS rebinding (Host). Apps and scripts send no Origin and pass."""
-  if not is_local_host(headers.get("Host")):
-    return False
-  origin = headers.get("Origin")
-  return origin is None or is_local_host(origin)
-
-
-def prepare_body(body, skill):
-  """Adds the skill's system prompt when the app sent none. The app's other settings pass through unchanged."""
-  prompt = SYSTEM_PROMPTS.get(skill)
-  messages = body.get("messages")
-  if prompt and isinstance(messages, list) and not any(isinstance(m, dict) and m.get("role") == "system" for m in messages):
-    body = {**body, "messages": [{"role": "system", "content": prompt}, *messages]}
-  return body
-
-
-class ModelRouter:
-  """Keeps at most one llama-server running. `starters` maps a skill to a function returning an unstarted server."""
-
-  def __init__(self, starters):
-    self.starters = starters
-    self.lock = threading.Lock()  # held for a whole request: one answer at a time, and no swap in the middle
-    self.current_skill = None
-    self.current_server = None
-
-  def load(self, skill):
-    """Call with the lock held. Returns the running server for this skill."""
-    if self.current_skill != skill:
-      self.stop()
-      server = self.starters[skill]()
-      server.__enter__()
-      self.current_skill, self.current_server = skill, server
-    return self.current_server
-
-  def stop(self):
-    if self.current_server:
-      self.current_server.__exit__(None, None, None)
-    self.current_skill, self.current_server = None, None
-
-
-def make_handler(router):
-  class Handler(BaseHTTPRequestHandler):
-    server_version = f"nock/{__version__}"
-    protocol_version = "HTTP/1.1"
-
-    def log_message(self, *args):
-      pass  # questions and answers are never logged
-
-    def send_json(self, status, payload):
-      data = json.dumps(payload).encode()
-      self.send_response(status)
-      self.send_header("Content-Type", "application/json")
-      self.send_header("Content-Length", str(len(data)))
-      self.end_headers()
-      self.wfile.write(data)
-
-    def send_error_json(self, status, message):
-      self.send_json(status, {"error": {"message": message, "type": "nock_error"}})
-
-    def do_OPTIONS(self):
-      # No CORS headers: a browser's preflight from a website fails here.
-      self.send_response(403)
-      self.send_header("Content-Length", "0")
-      self.end_headers()
-
-    def do_GET(self):
-      if not allowed_request(self.headers):
-        return self.send_error_json(403, "Requests from websites are not allowed.")
-      if self.path == "/health":
-        return self.send_json(200, {"status": "ok", "loaded": router.current_skill})
-      if self.path == "/v1/models":
-        names = [name for name, skill in MODEL_NAMES.items() if skill in router.starters]
-        return self.send_json(200, {"object": "list", "data": [{"id": name, "object": "model", "owned_by": "nockai"} for name in names]})
-      self.send_error_json(404, "Not found. Try /v1/models or /v1/chat/completions.")
-
-    def do_POST(self):
-      if not allowed_request(self.headers):
-        return self.send_error_json(403, "Requests from websites are not allowed.")
-      if self.path != "/v1/chat/completions":
-        return self.send_error_json(404, "Only /v1/chat/completions is available.")
-      length = int(self.headers.get("Content-Length") or 0)
-      if length > MAX_BODY_BYTES:
-        return self.send_error_json(413, "Request is too large.")
-      try:
-        body = json.loads(self.rfile.read(length) or b"{}")
-      except ValueError:
-        return self.send_error_json(400, "The request body is not valid JSON.")
-      skill = MODEL_NAMES.get(body.get("model"))
-      if not skill:
-        return self.send_error_json(400, f"Unknown model. Use one of: {', '.join(MODEL_NAMES)}.")
-      if skill not in router.starters:
-        return self.send_error_json(404, f"{body['model']} is not installed. Run: nock add {skill}")
-      with router.lock:
-        try:
-          server = router.load(skill)
-        except Exception as error:
-          router.stop()
-          return self.send_error_json(503, f"Could not start {body['model']}: {error}")
-        self.forward(server.url, prepare_body(body, skill))
-
-    def forward(self, upstream_url, body):
-      request = urllib.request.Request(f"{upstream_url}/v1/chat/completions", data=json.dumps(body).encode(),
-                                       headers={"Content-Type": "application/json"})
-      try:
-        upstream = urllib.request.urlopen(request, timeout=UPSTREAM_TIMEOUT)
-      except urllib.error.HTTPError as error:
-        upstream = error  # the engine's own error, passed on with its status
-      except OSError as error:
-        return self.send_error_json(502, f"The engine did not answer: {error}")
-      with upstream:
-        self.send_response(upstream.status)
-        self.send_header("Content-Type", upstream.headers.get("Content-Type", "application/json"))
-        # Chunked so streamed answers reach the app word by word.
-        self.send_header("Transfer-Encoding", "chunked")
-        self.end_headers()
-        while True:
-          chunk = upstream.read1(65536)
-          if not chunk:
-            break
-          self.wfile.write(f"{len(chunk):X}\r\n".encode() + chunk + b"\r\n")
-          self.wfile.flush()
-        self.wfile.write(b"0\r\n\r\n")
-
-  return Handler
-
-
-def create_server(starters, port=DEFAULT_PORT):
-  router = ModelRouter(starters)
-  httpd = ThreadingHTTPServer(("127.0.0.1", port), make_handler(router))
-  return httpd, router
-
-
-def run(starters, port=DEFAULT_PORT):
-  try:
-    httpd, router = create_server(starters, port)
-  except OSError:
-    raise ValueError(f"Port {port} is already in use. Try: nock serve --port {port + 1}")
-  print(f"nock serve: http://127.0.0.1:{port}/v1  (this machine only)")
-  print(f"Models: {', '.join(name for name, skill in MODEL_NAMES.items() if skill in starters)}")
-  print("In your app: base URL as above, any API key, model as listed. Ctrl+C to stop.")
-  try:
-    httpd.serve_forever()
-  except KeyboardInterrupt:
-    pass
-  finally:
-    router.stop()
-    httpd.server_close()
+"""`nock serve`: one local, OpenAI-compatible address for every installed skill.
+
+Editors and tools point at http://127.0.0.1:8080/v1 and choose a model by name. The right llama-server starts on
+first use; only one model is in memory at a time, so asking for another one swaps them. Everything stays on this
+machine: it binds to 127.0.0.1, and refuses requests from websites (a page you visit could otherwise call it).
+"""
+
+import json
+import sys
+import threading
+import urllib.error
+import urllib.request
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from nock_cli import __version__
+from nock_cli.code import SYSTEM_PROMPT as CODER_SYSTEM_PROMPT
+
+DEFAULT_PORT = 8080
+MODEL_NAMES = {"nock-coder": "coder", "nock-video": "video", "nock-agent": "agent"}
+SYSTEM_PROMPTS = {"coder": CODER_SYSTEM_PROMPT}  # same answers as `nock code`, unless the app sends its own
+MAX_BODY_BYTES = 64 * 1024 * 1024  # room for many video frames as images
+UPSTREAM_TIMEOUT = 1800
+LOCAL_HOSTS = ("127.0.0.1", "localhost", "[::1]")
+
+
+def is_local_host(value):
+  """True for 127.0.0.1, localhost and [::1], with or without a port."""
+  if not value:
+    return False
+  value = value.split("://", 1)[-1].split("/", 1)[0].lower()
+  host = value if value.startswith("[") and value.endswith("]") else value.rsplit(":", 1)[0] if ":" in value else value
+  return host in LOCAL_HOSTS
+
+
+def allowed_request(headers):
+  """Blocks other websites (Origin) and DNS rebinding (Host). Apps and scripts send no Origin and pass."""
+  if not is_local_host(headers.get("Host")):
+    return False
+  origin = headers.get("Origin")
+  return origin is None or is_local_host(origin)
+
+
+def prepare_body(body, skill):
+  """Adds the skill's system prompt when the app sent none. The app's other settings pass through unchanged."""
+  prompt = SYSTEM_PROMPTS.get(skill)
+  messages = body.get("messages")
+  if prompt and isinstance(messages, list) and not any(isinstance(m, dict) and m.get("role") == "system" for m in messages):
+    body = {**body, "messages": [{"role": "system", "content": prompt}, *messages]}
+  return body
+
+
+class ModelRouter:
+  """Keeps at most one llama-server running. `starters` maps a skill to a function returning an unstarted server."""
+
+  def __init__(self, starters):
+    self.starters = starters
+    self.lock = threading.Lock()  # held for a whole request: one answer at a time, and no swap in the middle
+    self.current_skill = None
+    self.current_server = None
+
+  def load(self, skill):
+    """Call with the lock held. Returns the running server for this skill."""
+    if self.current_skill != skill:
+      self.stop()
+      server = self.starters[skill]()
+      server.__enter__()
+      self.current_skill, self.current_server = skill, server
+    return self.current_server
+
+  def stop(self):
+    if self.current_server:
+      self.current_server.__exit__(None, None, None)
+    self.current_skill, self.current_server = None, None
+
+
+def make_handler(router):
+  class Handler(BaseHTTPRequestHandler):
+    server_version = f"nock/{__version__}"
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, *args):
+      pass  # questions and answers are never logged
+
+    def send_json(self, status, payload):
+      data = json.dumps(payload).encode()
+      self.send_response(status)
+      self.send_header("Content-Type", "application/json")
+      self.send_header("Content-Length", str(len(data)))
+      self.end_headers()
+      self.wfile.write(data)
+
+    def send_error_json(self, status, message):
+      self.send_json(status, {"error": {"message": message, "type": "nock_error"}})
+
+    def do_OPTIONS(self):
+      # No CORS headers: a browser's preflight from a website fails here.
+      self.send_response(403)
+      self.send_header("Content-Length", "0")
+      self.end_headers()
+
+    def do_GET(self):
+      if not allowed_request(self.headers):
+        return self.send_error_json(403, "Requests from websites are not allowed.")
+      if self.path == "/health":
+        return self.send_json(200, {"status": "ok", "loaded": router.current_skill})
+      if self.path == "/v1/models":
+        names = [name for name, skill in MODEL_NAMES.items() if skill in router.starters]
+        return self.send_json(200, {"object": "list", "data": [{"id": name, "object": "model", "owned_by": "nockai"} for name in names]})
+      self.send_error_json(404, "Not found. Try /v1/models or /v1/chat/completions.")
+
+    def do_POST(self):
+      if not allowed_request(self.headers):
+        return self.send_error_json(403, "Requests from websites are not allowed.")
+      if self.path != "/v1/chat/completions":
+        return self.send_error_json(404, "Only /v1/chat/completions is available.")
+      length = int(self.headers.get("Content-Length") or 0)
+      if length > MAX_BODY_BYTES:
+        return self.send_error_json(413, "Request is too large.")
+      try:
+        body = json.loads(self.rfile.read(length) or b"{}")
+      except ValueError:
+        return self.send_error_json(400, "The request body is not valid JSON.")
+      skill = MODEL_NAMES.get(body.get("model"))
+      if not skill:
+        return self.send_error_json(400, f"Unknown model. Use one of: {', '.join(MODEL_NAMES)}.")
+      if skill not in router.starters:
+        return self.send_error_json(404, f"{body['model']} is not installed. Run: nock add {skill}")
+      with router.lock:
+        try:
+          server = router.load(skill)
+        except Exception as error:
+          router.stop()
+          return self.send_error_json(503, f"Could not start {body['model']}: {error}")
+        self.forward(server.url, prepare_body(body, skill))
+
+    def forward(self, upstream_url, body):
+      request = urllib.request.Request(f"{upstream_url}/v1/chat/completions", data=json.dumps(body).encode(),
+                                       headers={"Content-Type": "application/json"})
+      try:
+        upstream = urllib.request.urlopen(request, timeout=UPSTREAM_TIMEOUT)
+      except urllib.error.HTTPError as error:
+        upstream = error  # the engine's own error, passed on with its status
+      except OSError as error:
+        return self.send_error_json(502, f"The engine did not answer: {error}")
+      try:
+        with upstream:
+          self.send_response(upstream.status)
+          self.send_header("Content-Type", upstream.headers.get("Content-Type", "application/json"))
+          # Chunked so streamed answers reach the app word by word.
+          self.send_header("Transfer-Encoding", "chunked")
+          self.end_headers()
+          while True:
+            chunk = upstream.read1(65536)
+            if not chunk:
+              break
+            self.wfile.write(f"{len(chunk):X}\r\n".encode() + chunk + b"\r\n")
+            self.wfile.flush()
+          self.wfile.write(b"0\r\n\r\n")
+      except ConnectionError:
+        self.close_connection = True  # the app hung up (a stop button, for example); closing `upstream` ends the answer
+
+  return Handler
+
+
+class QuietServer(ThreadingHTTPServer):
+  """Apps hanging up is normal, so it prints nothing. Other errors still print."""
+
+  daemon_threads = True
+
+  def handle_error(self, request, client_address):
+    if not isinstance(sys.exc_info()[1], ConnectionError):
+      super().handle_error(request, client_address)
+
+
+def create_server(starters, port=DEFAULT_PORT):
+  router = ModelRouter(starters)
+  httpd = QuietServer(("127.0.0.1", port), make_handler(router))
+  return httpd, router
+
+
+def run(starters, port=DEFAULT_PORT):
+  try:
+    httpd, router = create_server(starters, port)
+  except OSError:
+    raise ValueError(f"Port {port} is already in use. Try: nock serve --port {port + 1}")
+  print(f"nock serve: http://127.0.0.1:{port}/v1  (this machine only)")
+  print(f"Models: {', '.join(name for name, skill in MODEL_NAMES.items() if skill in starters)}")
+  print("In your app: base URL as above, any API key, model as listed. Ctrl+C to stop.")
+  try:
+    httpd.serve_forever()
+  except KeyboardInterrupt:
+    pass
+  finally:
+    router.stop()
+    httpd.server_close()

{nock_cli-0.3.0 → nock_cli-0.3.1}/src/nock_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nock-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: Open models that live on your machine: code, video and a coding agent, offline.
 Author: NockAI
 License-Expression: Apache-2.0