tunnel binary files

.gitignore

@@ -1,3 +1,4 @@
+data/
 # dependencies (bun install)
 node_modules
 

app/nose/bin/cat.ts

@@ -9,11 +9,11 @@ import { NOSE_WWW } from "app/src/config"
 import { isBinaryFile } from "app/src/utils"
 import { highlight } from "../lib/highlight"
 import { projectName, projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default async function (path: string) {
     const project = projectName()
-    const root = getState("cwd") || projectDir()
+    const root = sessionGet("cwd") || projectDir()
 
     let files: string[] = []
 

app/nose/bin/cd.ts

@@ -3,14 +3,14 @@
 import { dirname, resolve, isAbsolute } from "path"
 import { statSync } from "fs"
 import { projectDir } from "@/project"
-import { getState, setState } from "@/session"
+import { sessionGet, sessionSet } from "@/session"
 
 export default async function (path?: string) {
   const root = projectDir()
-  const cwd = getState("cwd") || root
+  const cwd = sessionGet("cwd") || root
 
   if (!path || path.trim() === "") {
-    setState("cwd", root)
+    sessionSet("cwd", root)
     return
   }
 
@@ -21,7 +21,7 @@ export default async function (path?: string) {
     if (cwd !== root) {
       const parent = dirname(cwd)
       if (parent.startsWith(root)) {
-        setState("cwd", parent)
+        sessionSet("cwd", parent)
       }
     }
     return
@@ -35,7 +35,7 @@ export default async function (path?: string) {
   try {
     const stat = statSync(target)
     if (stat.isDirectory()) {
-      setState("cwd", target)
+      sessionSet("cwd", target)
       return
     }
   } catch {

app/nose/bin/edit.tsx

@@ -8,11 +8,11 @@ import { NOSE_WWW } from "app/src/config"
 import { isBinaryFile } from "app/src/utils"
 import { countChar } from "app/src/shared/utils"
 import { projectName, projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default async function (path: string) {
   const project = projectName()
-  const root = getState("cwd") || projectDir()
+  const root = sessionGet("cwd") || projectDir()
 
   let files: string[] = []
 

app/nose/bin/load.ts

@@ -1,10 +1,10 @@
 // Load a project so you can work on it.
 
 import { apps } from "app/src/webapp"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default function (project: string) {
-    const state = getState()
+    const state = sessionGet()
     if (!project) throw `usage: load <project name>`
 
     if (state && apps().includes(project)) {

app/nose/bin/ls.tsx

@@ -3,11 +3,11 @@
 import { readdirSync } from "fs"
 import { NOSE_WWW } from "app/src/config"
 import { projectName, projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default function () {
     const project = projectName()
-    const root = getState("cwd") || projectDir()
+    const root = sessionGet("cwd") || projectDir()
 
     let files: string[] = []
 

app/nose/bin/mkdir.ts

@@ -6,12 +6,12 @@ import { mkdirSync } from "fs"
 import { join } from "path"
 import { projectDir } from "@/project"
 import { readdirSync } from "fs"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default async function (path: string) {
   if (path.endsWith("/")) path = path.slice(0, path.length - 1)
 
-  const root = getState("cwd") || projectDir()
+  const root = sessionGet("cwd") || projectDir()
   for (const file of readdirSync(root, { withFileTypes: true }))
     if (file.name === path) throw `${path} exists`
 

app/nose/bin/project.ts

@@ -1,9 +1,9 @@
 // Print the currently loaded project.
 
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default function () {
-    const state = getState()
+    const state = sessionGet()
     if (!state) return { error: "no state" }
 
     return state?.project || "none"

app/nose/bin/projects.tsx

@@ -1,10 +1,10 @@
 // Show the projects on this NOSEputer.
 
 import { apps } from "app/src/webapp"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default function () {
-    const state = getState()
+    const state = sessionGet()
     if (!state) return { error: "no state" }
 
     return <>

app/nose/bin/pwd.ts

@@ -2,9 +2,9 @@
 
 import { dirname } from "path"
 import { projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default async function () {
   const root = projectDir()
-  return (getState("cwd") || root).replace(dirname(root), "")
+  return (sessionGet("cwd") || root).replace(dirname(root), "")
 }

app/nose/bin/rm.ts

@@ -3,13 +3,13 @@
 import { unlinkSync, readdirSync } from "fs"
 import { join } from "path"
 import { projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default function (path: string) {
   let target = ""
   if (path.endsWith("/")) path = path.slice(0, path.length - 1)
 
-  const root = getState("cwd") || projectDir()
+  const root = sessionGet("cwd") || projectDir()
   for (const file of readdirSync(root, { withFileTypes: true }))
     if (file.name === path) {
       if (file.isDirectory())

app/nose/bin/rmdir.ts

@@ -3,13 +3,13 @@
 import { rmdirSync, readdirSync } from "fs"
 import { join } from "path"
 import { projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default function (path: string) {
   let target = ""
   if (path.endsWith("/")) path = path.slice(0, path.length - 1)
 
-  const root = getState("cwd") || projectDir()
+  const root = sessionGet("cwd") || projectDir()
   for (const file of readdirSync(root, { withFileTypes: true }))
     if (file.name === path) {
       if (file.isFile())

app/nose/bin/share.ts

@@ -3,11 +3,12 @@
 import { apps } from "app/src/webapp"
 import { connectSneaker, sneakers, sneakerUrl } from "app/src/sneaker"
 
-export default async function (app: string, subdomain = "") {
+export default async function (app: string) {
   if (!app) {
     let out = `usage: share <app> [subdomain]`
     const apps = sneakers()
     if (apps.length) {
+      out += "\n\nUse `unshare` to stop sharing an app."
       out += "\n\nsharing\n" + apps.map(app => {
         const url = sneakerUrl(app)
         return `${app}: <a href="${url}">${url}</a>`
@@ -20,6 +21,6 @@ export default async function (app: string, subdomain = "") {
     return { error: `${app} not found` }
   }
 
-  const url = sneakerUrl(await connectSneaker(app, subdomain))
+  const url = sneakerUrl(await connectSneaker(app))
   return { html: `<a href="${url}">${url}</a>` }
 }

app/nose/bin/state.ts

@@ -0,0 +1,6 @@
+import { NOSE_DATA } from "@/config"
+import { join } from "path"
+
+export default async function () {
+  return JSON.parse(await Bun.file(join(NOSE_DATA, "state.json")).text())
+}

app/nose/bin/touch.ts

@@ -3,12 +3,12 @@
 import { join } from "path"
 import { readdirSync } from "fs"
 import { projectDir } from "@/project"
-import { getState } from "@/session"
+import { sessionGet } from "@/session"
 
 export default async function (path: string) {
   if (path.endsWith("/")) path = path.slice(0, path.length - 1)
 
-  const root = getState("cwd") || projectDir()
+  const root = sessionGet("cwd") || projectDir()
   for (const file of readdirSync(root, { withFileTypes: true }))
     if (file.name === path) throw `${path} exists`
 

app/src/config.ts

@@ -10,5 +10,7 @@ export const NOSE_DIR = resolve("..")
 export const NOSE_BIN = join(NOSE_DIR, "bin")
 export const NOSE_WWW = join(NOSE_DIR, "www")
 
+export const NOSE_DATA = resolve("./data")
+
 export const NOSE_STARTED = Date.now()
 export const GIT_SHA = (await $`git rev-parse HEAD`.text()).trim()

app/src/mutex.ts

@@ -0,0 +1,27 @@
+////
+// Simple mutex for concurrent file writes
+
+export class Mutex {
+  private queue: (() => void)[] = []
+  private locked = false
+
+  async lock(): Promise<() => void> {
+    return new Promise(resolve => {
+      const unlock = () => {
+        const next = this.queue.shift()
+        if (next) {
+          next()
+        } else {
+          this.locked = false
+        }
+      }
+
+      if (this.locked) {
+        this.queue.push(() => resolve(unlock))
+      } else {
+        this.locked = true
+        resolve(unlock)
+      }
+    })
+  }
+}

app/src/project.ts

@@ -2,11 +2,11 @@
 // Helpers for working with projects in the CLI.
 
 import { readdirSync, type Dirent } from "fs"
-import { getState } from "./session"
+import { sessionGet } from "./session"
 import { appDir } from "./webapp"
 
 export function projectName(): string {
-  const state = getState()
+  const state = sessionGet()
   if (!state) throw "no state"
 
   const project = state.project

app/src/server.tsx

@@ -7,17 +7,17 @@ import { prettyJSON } from "hono/pretty-json"
 import color from "kleur"
 
 import type { Message } from "./shared/types"
-import { NOSE_ICON, NOSE_BIN, NOSE_WWW } from "./config"
+import { NOSE_ICON, NOSE_BIN, NOSE_WWW, NOSE_DATA } from "./config"
 import { transpile, isFile, tilde } from "./utils"
 import { serveApp } from "./webapp"
 import { initDNS } from "./dns"
-import { commands, commandSource, commandPath } from "./commands"
+import { commands, commandPath } from "./commands"
 import { send, addWebsocket, removeWebsocket, closeWebsockets } from "./websocket"
 
 import { Layout } from "./html/layout"
 import { Terminal } from "./html/terminal"
 import { dispatchMessage } from "./dispatch"
-import "./sneaker"
+import { initSneakers, disconnectSneakers } from "./sneaker"
 
 //
 // Hono setup
@@ -129,6 +129,7 @@ if (process.env.BUN_HOT) {
     // @ts-ignore
     globalThis.__hot_reload_cleanup = () => {
         closeWebsockets()
+        disconnectSneakers()
     }
 
     for (const sig of ["SIGINT", "SIGTERM"] as const) {
@@ -138,19 +139,27 @@ if (process.env.BUN_HOT) {
             process.exit(0)
         })
     }
-} else {
-    initDNS()
 }
 
+//
+// production mode 
+//
+
+if (process.env.NODE_ENV === "production") {
+    initDNS()
+}
 
 //
 // server start
 //
 
 console.log(color.cyan(NOSE_ICON))
+console.log(color.blue("NOSE_DATA:"), color.yellow(tilde(NOSE_DATA)))
 console.log(color.blue("NOSE_BIN:"), color.yellow(tilde(NOSE_BIN)))
 console.log(color.blue("NOSE_WWW:"), color.yellow(tilde(NOSE_WWW)))
 
+initSneakers()
+
 export default {
     port: process.env.PORT || 3000,
     hostname: "0.0.0.0",

app/src/session.ts

@@ -15,7 +15,7 @@ export type Session = {
 const g = globalThis as typeof globalThis & { __thread?: AsyncLocalStorage<Session> }
 export const ALS = g.__thread ??= new AsyncLocalStorage<Session>()
 
-export function getState(key?: keyof Session): Session | any | undefined {
+export function sessionGet(key?: keyof Session): Session | any | undefined {
     const store = ALS.getStore()
     if (!store) return
 
@@ -24,7 +24,7 @@ export function getState(key?: keyof Session): Session | any | undefined {
     return store
 }
 
-export function setState(key: keyof Session, value: any) {
+export function sessionSet(key: keyof Session, value: any) {
     const store = ALS.getStore()
     if (!store) return
     store[key] = value

app/src/shell.ts

@@ -83,5 +83,5 @@ function errorMessage(error: Error | any): string {
 }
 
 function isJSX(obj: any): boolean {
-    return 'tag' in obj && 'props' in obj && 'children' in obj
+    return typeof obj === 'object' && 'tag' in obj && 'props' in obj && 'children' in obj
 }

app/src/sneaker.ts

@@ -3,12 +3,15 @@
 // with the public internet. It requires a sneaker server, usually hosted by us.
 
 import nose from "./server"
+import { clearState, setState, getState } from "app/src/state"
 
 const SNEAKER_URL = "nose.space"
 const SNEAKER_TLS = true
 // const SNEAKER_URL = "localhost:3100"
 // const SNEAKER_TLS = false
 
+const PREFIX = "sneaker:"
+
 type Connection = {
     subdomain: string
     ws: any
@@ -16,6 +19,19 @@ type Connection = {
 }
 const conns: Record<string, Connection> = {}
 
+export function initSneakers() {
+    const state = getState()
+    if (!state) return
+
+    for (const key in state) {
+        if (key.startsWith(PREFIX)) {
+            const app = key.replace(PREFIX, "")
+            console.log("sharing", app, state[key])
+            connectSneaker(app, state[key])
+        }
+    }
+}
+
 export function sneakerUrl(appOrSubdomain: string): string {
     let conn = conns[appOrSubdomain]
     if (!conn) {
@@ -29,7 +45,6 @@ export function sneakerUrl(appOrSubdomain: string): string {
             return "none"
     }
 
-
     let url = "http" + (SNEAKER_TLS ? "s" : "") + "://"
     url += conn.subdomain + "." + SNEAKER_URL
 
@@ -40,10 +55,19 @@ export function sneakers(): string[] {
     return Object.keys(conns)
 }
 
-export function disconnectSneaker(app: string): boolean {
+export async function disconnectSneakers() {
+    for (const app in conns) {
+        const conn = conns[app]!
+        conn.close = true
+        conn.ws.close()
+    }
+}
+
+export async function disconnectSneaker(app: string): Promise<boolean> {
     if (!sneakers().includes(app) || !conns[app])
         return false
 
+    await clearState(`${PREFIX}${app}`)
     conns[app].close = true
     conns[app].ws.close()
 
@@ -60,6 +84,8 @@ export async function connectSneaker(app: string, subdomain = ""): Promise<strin
     if (subdomain) url += `&subdomain=${subdomain}`
 
     const ws = new WebSocket(url)
+    ws.binaryType = 'arraybuffer'
+
     let resolve: (v: string) => void
     let promise = new Promise<string>(res => resolve = res)
 
@@ -76,6 +102,7 @@ export async function connectSneaker(app: string, subdomain = ""): Promise<strin
 
         if (msg.subdomain) {
             conns[app] = { subdomain: msg.subdomain, ws, close: false }
+            await setState(`${PREFIX}${app}`, msg.subdomain)
             subdomain = msg.subdomain
             resolve(msg.subdomain)
             return
@@ -90,25 +117,57 @@ export async function connectSneaker(app: string, subdomain = ""): Promise<strin
 
             const res = await nose.fetch(req)
 
-            const body = await res.text()
             const headers: Record<string, string> = {}
             res.headers.forEach((v, k) => (headers[k] = v))
 
-            ws.send(JSON.stringify({
+            const contentType = res.headers.get('content-type') || ''
-                id: msg.id,
+            const isBinary = isBinaryContentType(contentType)
-                status: res.status,
+
-                headers,
+            let body: string | ArrayBuffer
-                body,
+            let responseData: any
-            }))
+
+            if (isBinary) {
+                const arrayBuffer = await res.arrayBuffer()
+                const base64 = Buffer.from(arrayBuffer).toString('base64')
+
+                responseData = {
+                    id: msg.id,
+                    status: res.status,
+                    headers,
+                    body: base64,
+                    isBinary: true
+                }
+            } else {
+                body = await res.text()
+
+                responseData = {
+                    id: msg.id,
+                    status: res.status,
+                    headers,
+                    body,
+                    isBinary: false
+                }
+            }
+
+            ws.send(JSON.stringify(responseData))
         } catch (err: any) {
             ws.send(JSON.stringify({
                 id: msg.id,
                 status: 500,
                 headers: { "content-type": "text/plain" },
                 body: "error: " + err.message,
+                isBinary: false
             }))
         }
     }
 
     return promise
-}
+}
+
+function isBinaryContentType(contentType: string): boolean {
+    const binaryTypes = [
+        'image/', 'audio/', 'video/', 'application/octet-stream',
+        'application/pdf', 'application/zip', 'font/'
+    ]
+    return binaryTypes.some(type => contentType.startsWith(type))
+}

app/src/state.ts

@@ -0,0 +1,42 @@
+////
+// Server state, shared by all sessions.
+
+import { join } from "path"
+import { readFileSync } from "fs"
+import { NOSE_DATA } from "./config"
+import { Mutex } from "./mutex"
+
+const statePath = join(NOSE_DATA, "state.json")
+const mutex = new Mutex()
+
+export function getState(key?: string): any {
+  return key ? readState()?.[key] : readState()
+}
+
+export async function setState(key: string, value: any) {
+  const state = readState()
+  state[key] = value
+  await saveState(state)
+}
+
+export async function clearState(key: string) {
+  await setState(key, undefined)
+}
+
+async function saveState(newState: any) {
+  const unlock = await mutex.lock()
+  try {
+    await Bun.write(statePath, JSON.stringify(newState, null, 2))
+  } finally {
+    unlock()
+  }
+}
+
+function readState(): Record<string, any> {
+  try {
+    return JSON.parse(readFileSync(statePath, 'utf8'))
+  } catch (e: any) {
+    if (e.code === "ENOENT") return {}
+    throw e
+  }
+}

app/src/stream.ts

@@ -1,5 +1,5 @@
 import { send as sendWs } from "./websocket"
-import { getState } from "./session"
+import { sessionGet } from "./session"
 import { processExecOutput } from "./shell"
 import type { Child } from "hono/jsx"
 import type { CommandOutput, Message } from "./shared/types"
@@ -9,7 +9,7 @@ type StreamFns = { replace: StreamFn, append: StreamFn }
 type StreamParamFn = (fns: StreamFns) => Promise<void>
 
 export async function stream(initOrFn: StreamParamFn | string | any, fn?: StreamParamFn) {
-  const state = getState()
+  const state = sessionGet()
   if (!state) throw "stream() called outside runCommand()"
 
   let error = false