Fix h2 headers

Author: slimslenderslacks

dev/catalog.clj

@@ -6,7 +6,10 @@
    [medley.core :as medley]
    prompts))
 
-(prompts/get-prompts {:prompts (fs/file "prompts/examples/mcp-memory.md")})
+(try
+  (prompts/get-prompts {:prompts (fs/file "prompts/chrome.md")})
+  (catch Throwable t
+    (println t)))
 
 (defn f->prompt [f]
   (prompts/get-prompts {:prompts f}))

docs/content/tools/docs/running_containers.md

@@ -0,0 +1,26 @@
+
+* default is to run synchronously without stdin and in terminal model
+* image is mandatory
+    * default is to try to pull image every time it runs 
+* always binds docker-lsp volume (does not bind prompts volume - that's only for the server)
+* if server is running with a host-dir, that host-dir will bind with /volume
+* there will pretty much always be a mounted /thread volume but see below
+* volumes is also an optional parameter in the container definition
+* workingdir (parameter is called workdir) is either set in the definition or defaults to /project
+* /var/run/docker.sock is always mounted
+
+# parameters
+
+* volumes (list of strings)  supports interpolation         optional
+* command (list of strings)  supports interpolation         optional
+* workdir (string)           supports interpolation         optional
+* stdin (keys content, file) supports interpolation         optional
+* entrypoint (string)        does NOT suport interpolation  optional
+* image (string)             does not support interpolation mandatory
+
+# interpolation
+
+* has a filter called `|into` that will take a parameter list and _spread_ it into a string list
+* `volumes` `command` `workdir` `stdin.content` and `stdin.file` all support interpoloation
+* `image` and `entrypoint` do not support interpolation
+

prompts/chrome.md

@@ -52,6 +52,9 @@ tools:
         - url
     container:
       image: zenika/alpine-chrome
+      background: true
+      ports:
+        - "9222:9222"
       command:
         - "--no-sandbox" 
         - "--remote-debugging-address=0.0.0.0"
@@ -68,33 +71,33 @@ You have `curl` and `websocat` available to you to control the browser and to an
 
 If you don't see the browser running, use the chrome tool to start it. Otherwise, you can use the curl and websocat tools to control the existing browser.
 
-**Verify the server is running**
+## Verify the server is running
 
 Use curl to get the websocket url and make sure the server is running. If it isn't start it with the chrome tool. You can be easily overwhelmed when using curl to get html. Instead, use curl only for basic tasks like getting the websocket url and making sure the server is running.
 
+When you get a websocket url back, change localhost to be host.docker.internal
+
 Examples:
 
 ```sh
 # Get the websocket url
-curl -X PUT -sg http://localhost:9222/json/new 
+curl -X PUT -H "HOST: localhost:9222" -sg http://host.docker.internal:9222/json/new 
 
 # Navigate to a page
 
 $MESSAGE='Page.navigate {"url":"https://www.docker.com"}' # This format works with --jsonrpc where the first word is the method name and the rest is the arguments.
 
-$MESSAGE | websocat -n1 --jsonrpc --jsonrpc-omit-jsonrpc ws://localhost:9222/devtools/page/<PAGE_ID>
+$MESSAGE | websocat -n1 --jsonrpc --jsonrpc-omit-jsonrpc ws://host.docker.internal:9222/devtools/page/<PAGE_ID>
 
 {"id":2,"result":{"frameId":"A331E56CCB8615EB4FCB720425A82259","loaderId":"EF5AAD19F2F8BB27FAF55F94FFB27DF9"}}
 ```
 
 For more complex tasks, use websocat to send and receive messages to the browser. This can be used to execute javascript, navigate to a page, or screenshot the page.
 
-**Cleanup**
+## Cleanup
 
 It is important that when you are done with your page, you close it. This is important because the browser could continue to run even after you close the websocket connection.
 
 The following is the question you are trying to answer:
 
-# prompt user
-
-What is the url for the docker logo?
+What is the url for the docker logo?

prompts/examples/explain_dockerfile.md

@@ -36,7 +36,7 @@ This tool can explain a pre-provided Dockerfile but it can also fetch the Docker
 
 ## content
 
-Start by fetching the Dockerfile located at the path {{path}}.
+Start by fetching the Dockerfile located at the path {{path}} using the cat_file tool.
 
 After fetching the Dockerfile contents, explain the Dockerfile line by line.
 

src/docker.clj

@@ -112,7 +112,8 @@
 ;; Tty wraps the process in a pseudo terminal
 {:StdinOnce true
  :OpenStdin true}
-(defn create-container [{:keys [image entrypoint workdir command host-dir env thread-id opts mounts volumes] :or {opts {:Tty true}}}]
+(defn create-container [{:keys [image entrypoint workdir command host-dir env thread-id opts mounts volumes ports] 
+                         :or {opts {:Tty true}}}]
   (let [payload (json/generate-string
                  (merge
                   {:Image image}
@@ -121,13 +122,17 @@
                                        (map (fn [[k v]] (format "%s=%s" (name k) v)))
                                        (into []))})
                   {:HostConfig
-                   {:Binds
-                    (concat ["docker-lsp:/docker-lsp"
-                             "/var/run/docker.sock:/var/run/docker.sock"]
-                            (when host-dir [(format "%s:/project:rw" host-dir)])
-                            (when thread-id [(format "%s:/thread:rw" thread-id)])
-                            (or volumes mounts))}
+                   (merge
+                     {:Binds
+                      (concat ["docker-lsp:/docker-lsp"
+                               "/var/run/docker.sock:/var/run/docker.sock"]
+                              (when host-dir [(format "%s:/project:rw" host-dir)])
+                              (when thread-id [(format "%s:/thread:rw" thread-id)])
+                              (or volumes mounts))}
+                     (when ports 
+                       {:PortBindings {"9222/tcp" [{:HostPort "9222"}]}}))
                    :WorkingDir (or workdir "/project")}
+                  (when ports {:ExposedPorts {"9222/tcp" {}}})
                   (when entrypoint {:Entrypoint entrypoint})
                   (when command {:Cmd command})))
         ascii-payload (String. (.getBytes payload "ASCII"))]
@@ -234,8 +239,19 @@
 (def pull (comp (status? 200 "pull-image") pull-image))
 (def images (comp ->json list-images))
 
+(defn- add-latest [image]
+  (let [[_ tag] (re-find #".*(:.*)$" image)]
+    (if tag
+      image
+      (str image ":latest"))))
+
+(comment
+  (add-latest "vonwig/go-linguist")
+  (add-latest "blah/what:tag"))
+
 (defn- -pull [m]
   (pull (merge m
+               {:image (add-latest (:image m))}
                {:serveraddress "https://index.docker.io/v1/"}
                (when (and (:user m)
                           (or (:jwt m) (:pat m)))
@@ -305,7 +321,8 @@
      (fn []
        (kill-container x)
        (delete x)))
-    {:done :running}))
+    {:done :running
+     :pty-output (str "started up Ts" (:image m))}))
 
 (defn run-function
   "run container function with no stdin, and no streaming output"

src/docker/main.clj

@@ -145,6 +145,8 @@
                     (fn [m]
                       (update-in m [:prompts] (fn [coll] (remove (fn [{:keys [type]}] (= type (second args))) coll))))))
     "run" (fn []
+            (logger/setup (jsonrpc.server/->TimbreLogger))
+
             (let [[in send]
                   (let [[[w c] in] (user-loop/create-pipe)]
                     [in (fn []

src/jsonrpc/db.clj

@@ -94,7 +94,6 @@
 (defn update-prompt 
   "update the db with new markdown prompt content being dynamically registered"
   [opts s content]
-  (logger/info (format "update prompt %s with content %s" s content))
   (let [m (prompts/get-prompts
            (assoc opts :prompt-content content))]
     (swap! db* (fn [db] 

src/jsonrpc/server.clj

@@ -286,11 +286,20 @@
       (apply log-wrapper-fn log-args)
       (recur))))
 
+(defn decide-log-path []
+  (let [prompts-dir (fs/file "/prompts")]
+    (if (fs/exists? prompts-dir)
+      (do
+        (fs/create-dirs (fs/file prompts-dir "log"))
+        (fs/file prompts-dir "log/docker-mcp-server.out"))
+      (do
+        (fs/create-dirs (fs/file "./log"))
+        (fs/file "./log/docker-mcp-server.out")))))
+
 (defrecord TimbreLogger []
   logger/ILogger
   (setup [this]
-    (fs/create-dirs (fs/file "/prompts" "log"))
-    (let [log-path (str (fs/file "/prompts/log/docker-mcp-server.out"))]
+    (let [log-path (str (decide-log-path))]
       (timbre/merge-config! {:middleware [#(assoc % :hostname_ "")]
                              :appenders {:println {:enabled? false}
                                          :spit (appenders/spit-appender {:fname log-path})}})

src/markdown.clj

@@ -4,7 +4,6 @@
    [clj-yaml.core :as clj-yaml]
    [clojure.core.async :as async]
    [clojure.edn :as edn]
-   [clojure.pprint :refer [pprint]]
    [clojure.string :as string]
    [clojure.zip :as zip]
    [docker]
@@ -85,6 +84,11 @@
 (defn atx-heading-section? [node]
   (= "atx_heading" (first node)))
 
+(defn atx-heading-1? [node]
+  (and
+   (= "atx_heading" (first node))
+   (= "atx_h1_marker" (-> node (nth 2) first))))
+
 (defn remove-section-content [content s node]
   (if (and (list? node) (= "atx_heading" (first node)))
     (string/replace s (from-range (nth node 1) content) "")
@@ -99,19 +103,40 @@
 (defn section-content [content node]
   (from-range (nth node 1) content))
 
-(defn h1-prompt-content [content node]
+(defn h1-prompt-content
+  " params
+      node is a top-level h1 prompt node"
+  [content node]
   (merge
    (-> node (nth 2) (nth 3) (nth 1) (from-range content) (parse-h1))
-   (if (some section? node)
+   (if (->> node
+            (filter list?)
+            (some (partial description-section? content)))
      ;; prompt is broken up with real sections
      (merge
-      {:content (->> node
-                     (filter list?)
-                     (filter (complement (partial description-section? content)))
-                     #_(filter (complement atx-heading-section?))
-                     (map (partial section-content content))
-                     (apply str)
-                     (string/trim))}
+      {:content (let [top-level-content-nodes
+                      (->> node
+                           (filter list?)
+                           (filter (complement (partial description-section? content)))
+                           (filter (complement atx-heading-1?)))
+                      first-heading-node
+                      (->> top-level-content-nodes
+                           (filter section?)
+                           first
+                           (seq)
+                           (filter atx-heading-section?)
+                           first)
+                      prompt-content
+                      (->> top-level-content-nodes
+                           (map (partial section-content content))
+                           (apply str))]
+                  (string/trim
+                    (string/replace 
+                      prompt-content  
+                      (if first-heading-node
+                        (from-range (nth first-heading-node 1) content)
+                        "")
+                      "")))}
       (when-let [description (some->> node
                                       (filter section?)
                                       (filter (partial description-section? content))

src/schema.clj

@@ -52,20 +52,31 @@
 (s/def ::container-response (s/keys :req-un [::pty-output ::exit-code ::info ::done]
                                     :opt-un [::timeout ::kill-container]))
 
+;; -- tool parameters --
+(s/def :tool/parameters any?)
+
+;; -- container tools --
+(s/def :container/image string?)
+(s/def :container/command (s/coll-of string?))
+(s/def :container/stdin any?)
+(s/def :container/volumes (s/coll-of string?))
+(s/def :container/entrypoint string?)
+(s/def :container/workdir string?)
+(s/def :tool/container (s/keys :req-un [:container/image]
+                               :opt-un [:container/stdin :container/command :container/volumes :container/entrypoint :container/workdir]))
+
 ;; -- Spec definitions for Tools --
 (s/def ::github-ref (s/and string? #(string/starts-with? % "github:")))
 (s/def :prompt/ref ::github-ref)
 (s/def :prompt/prompt (s/or :github-ref ::github-ref :relative-path string?))
 (s/def :tool/name string?)
-(s/def :docker/type #{"prompt" "container"})
+(s/def :docker/type #{"prompt"})
 (s/def :tool/description string?)
 (s/def ::prompt-tool (s/keys :req-un [:tool/name :tool/description :docker/type]
                              :opt-un [:tool/parameters :prompt/prompt :prompt/ref]))
 (s/def ::container-tool (s/keys :req-un [:tool/name :tool/description :tool/container]
                                 :opt-un [:tool/parameters]))
-(s/def ::placeholder-tool (s/keys :req-un [:tool/name :tool/description]
-                                  :opt-un [:tool/parameters]))
-(s/def :tool/function (s/or :container ::container-tool :prompt ::prompt-tool :placeholder ::placeholder-tool))
+(s/def :tool/function (s/or :container ::container-tool :prompt ::prompt-tool))
 (s/def :tool/type #{"function"})
 (s/def ::tool (s/keys :req-un [:tool/type :tool/function]))
 (s/def ::tools (s/coll-of ::tool))