piclaw 0.0.19 → 0.0.21

package/.output/server/node_modules/compressjs/lib/Util.js

@@ -0,0 +1,324 @@
+/* Some basic utilities, used in a number of places. */
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define(['./freeze','./Stream'],function(freeze, Stream) {
+    var Util = Object.create(null);
+
+    var EOF = Stream.EOF;
+
+    /* Take a buffer, array, or stream, and return an input stream. */
+    Util.coerceInputStream = function(input, forceRead) {
+        if (!('readByte' in input)) {
+            var buffer = input;
+            input = new Stream();
+            input.size = buffer.length;
+            input.pos = 0;
+            input.readByte = function() {
+                if (this.pos >= this.size) { return EOF; }
+                return buffer[this.pos++];
+            };
+            input.read = function(buf, bufOffset, length) {
+                var bytesRead = 0;
+                while (bytesRead < length && this.pos < buffer.length) {
+                    buf[bufOffset++] = buffer[this.pos++];
+                    bytesRead++;
+                }
+                return bytesRead;
+            };
+            input.seek = function(pos) { this.pos = pos; };
+            input.tell = function() { return this.pos; };
+            input.eof = function() { return this.pos >= buffer.length; };
+        } else if (forceRead && !('read' in input)) {
+            // wrap input if it doesn't implement read
+            var s = input;
+            input = new Stream();
+            input.readByte = function() {
+                var ch = s.readByte();
+                if (ch === EOF) { this._eof = true; }
+                return ch;
+            };
+            if ('size' in s) { input.size = s.size; }
+            if ('seek' in s) {
+                input.seek = function(pos) {
+                    s.seek(pos); // may throw if s doesn't implement seek
+                    this._eof = false;
+                };
+            }
+            if ('tell' in s) {
+                input.tell = s.tell.bind(s);
+            }
+        }
+        return input;
+    };
+
+    var BufferStream = function(buffer, resizeOk) {
+        this.buffer = buffer;
+        this.resizeOk = resizeOk;
+        this.pos = 0;
+    };
+    BufferStream.prototype = Object.create(Stream.prototype);
+    BufferStream.prototype.writeByte = function(_byte) {
+        if (this.resizeOk && this.pos >= this.buffer.length) {
+            var newBuffer = Util.makeU8Buffer(this.buffer.length * 2);
+            newBuffer.set(this.buffer);
+            this.buffer = newBuffer;
+        }
+        this.buffer[this.pos++] = _byte;
+    };
+    BufferStream.prototype.getBuffer = function() {
+        // trim buffer if needed
+        if (this.pos !== this.buffer.length) {
+            if (!this.resizeOk)
+                throw new TypeError('outputsize does not match decoded input');
+            var newBuffer = Util.makeU8Buffer(this.pos);
+            newBuffer.set(this.buffer.subarray(0, this.pos));
+            this.buffer = newBuffer;
+        }
+        return this.buffer;
+    };
+
+    /* Take a stream (or not) and an (optional) size, and return an
+     * output stream.  Return an object with a 'retval' field equal to
+     * the output stream (if that was given) or else a pointer at the
+     * internal Uint8Array/buffer/array; and a 'stream' field equal to
+     * an output stream to use.
+     */
+    Util.coerceOutputStream = function(output, size) {
+        var r = { stream: output, retval: output };
+        if (output) {
+            if (typeof(output)==='object' && 'writeByte' in output) {
+                return r; /* leave output alone */
+            } else if (typeof(size) === 'number') {
+                console.assert(size >= 0);
+                r.stream = new BufferStream(Util.makeU8Buffer(size), false);
+            } else { // output is a buffer
+                r.stream = new BufferStream(output, false);
+            }
+        } else {
+            r.stream = new BufferStream(Util.makeU8Buffer(16384), true);
+        }
+        Object.defineProperty(r, 'retval', {
+            get: r.stream.getBuffer.bind(r.stream)
+        });
+        return r;
+    };
+
+    Util.compressFileHelper = function(magic, guts, suppressFinalByte) {
+        return function(inStream, outStream, props) {
+            inStream = Util.coerceInputStream(inStream);
+            var o = Util.coerceOutputStream(outStream, outStream);
+            outStream = o.stream;
+
+            // write the magic number to identify this file type
+            // (it better be ASCII, we're not doing utf-8 conversion)
+            var i;
+            for (i=0; i<magic.length; i++) {
+                outStream.writeByte(magic.charCodeAt(i));
+            }
+
+            // if we know the size, write it
+            var fileSize;
+            if ('size' in inStream && inStream.size >= 0) {
+                fileSize = inStream.size;
+            } else {
+                fileSize = -1; // size unknown
+            }
+            if (suppressFinalByte) {
+                var tmpOutput = Util.coerceOutputStream([]);
+                Util.writeUnsignedNumber(tmpOutput.stream, fileSize + 1);
+                tmpOutput = tmpOutput.retval;
+                for (i=0; i<tmpOutput.length-1; i++) {
+                    outStream.writeByte(tmpOutput[i]);
+                }
+                suppressFinalByte = tmpOutput[tmpOutput.length-1];
+            } else {
+                Util.writeUnsignedNumber(outStream, fileSize + 1);
+            }
+
+            // call the guts to do the real compression
+            guts(inStream, outStream, fileSize, props, suppressFinalByte);
+
+            return o.retval;
+        };
+    };
+    Util.decompressFileHelper = function(magic, guts) {
+        return function(inStream, outStream) {
+            inStream = Util.coerceInputStream(inStream);
+
+            // read the magic number to confirm this file type
+            // (it better be ASCII, we're not doing utf-8 conversion)
+            var i;
+            for (i=0; i<magic.length; i++) {
+                if (magic.charCodeAt(i) !== inStream.readByte()) {
+                    throw new Error("Bad magic");
+                }
+            }
+
+            // read the file size & create an appropriate output stream/buffer
+            var fileSize = Util.readUnsignedNumber(inStream) - 1;
+            var o = Util.coerceOutputStream(outStream, fileSize);
+            outStream = o.stream;
+
+            // call the guts to do the real decompression
+            guts(inStream, outStream, fileSize);
+
+            return o.retval;
+        };
+    };
+    // a helper for simple self-test of model encode
+    Util.compressWithModel = function(inStream, fileSize, model) {
+        var inSize = 0;
+        while (inSize !== fileSize) {
+            var ch = inStream.readByte();
+            if (ch === EOF) {
+                model.encode(256); // end of stream;
+                break;
+            }
+            model.encode(ch);
+            inSize++;
+        }
+    };
+    // a helper for simple self-test of model decode
+    Util.decompressWithModel = function(outStream, fileSize, model) {
+        var outSize = 0;
+        while (outSize !== fileSize) {
+            var ch = model.decode();
+            if (ch === 256) {
+                break; // end of stream;
+            }
+            outStream.writeByte(ch);
+            outSize++;
+        }
+    };
+
+    /** Write a number using a self-delimiting big-endian encoding. */
+    Util.writeUnsignedNumber = function(output, n) {
+        console.assert(n >= 0);
+        var bytes = [], i;
+        do {
+            bytes.push(n & 0x7F);
+            // use division instead of shift to allow encoding numbers up to
+            // 2^53
+            n = Math.floor( n / 128 );
+        } while (n !== 0);
+        bytes[0] |= 0x80; // mark end of encoding.
+        for (i=bytes.length-1; i>=0; i--) {
+            output.writeByte(bytes[i]); // write in big-endian order
+        }
+        return output;
+    };
+
+    /** Read a number using a self-delimiting big-endian encoding. */
+    Util.readUnsignedNumber = function(input) {
+        var n = 0, c;
+        while (true) {
+            c = input.readByte();
+            if (c&0x80) { n += (c&0x7F); break; }
+            // using + and * instead of << allows decoding numbers up to 2^53
+            n = (n + c) * 128;
+        }
+        return n;
+    };
+
+    // Compatibility thunks for Buffer/TypedArray constructors.
+
+    var zerofill = function(a) {
+        for (var i = 0, len = a.length; i < len; i++) {
+            a[i] = 0;
+        }
+        return a;
+    };
+
+    var fallbackarray = function(size) {
+        return zerofill(new Array(size));
+    };
+
+    // Node 0.11.6 - 0.11.10ish don't properly zero fill typed arrays.
+    // See https://github.com/joyent/node/issues/6664
+    // Try to detect and workaround the bug.
+    var ensureZeroed = function id(a) { return a; };
+    if ((typeof(process) !== 'undefined') &&
+        Array.prototype.some.call(new Uint32Array(128), function(x) {
+            return x !== 0;
+        })) {
+        //console.warn('Working around broken TypedArray');
+        ensureZeroed = zerofill;
+    }
+
+    /** Portable 8-bit unsigned buffer. */
+    Util.makeU8Buffer = (typeof(Uint8Array) !== 'undefined') ? function(size) {
+        // Uint8Array ought to be  automatically zero-filled
+        return ensureZeroed(new Uint8Array(size));
+    } : (typeof(Buffer) !== 'undefined') ? function(size) {
+        var b = new Buffer(size);
+        b.fill(0);
+        return b;
+    } : fallbackarray;
+
+    /** Portable 16-bit unsigned buffer. */
+    Util.makeU16Buffer = (typeof(Uint16Array) !== 'undefined') ? function(size) {
+        // Uint16Array ought to be  automatically zero-filled
+        return ensureZeroed(new Uint16Array(size));
+    } : fallbackarray;
+
+    /** Portable 32-bit unsigned buffer. */
+    Util.makeU32Buffer = (typeof(Uint32Array) !== 'undefined') ? function(size) {
+        // Uint32Array ought to be  automatically zero-filled
+        return ensureZeroed(new Uint32Array(size));
+    } : fallbackarray;
+
+    /** Portable 32-bit signed buffer. */
+    Util.makeS32Buffer = (typeof(Int32Array) !== 'undefined') ? function(size) {
+        // Int32Array ought to be  automatically zero-filled
+        return ensureZeroed(new Int32Array(size));
+    } : fallbackarray;
+
+    Util.arraycopy = function(dst, src) {
+        console.assert(dst.length >= src.length);
+        for (var i = 0, len = src.length; i < len ; i++) {
+            dst[i] = src[i];
+        }
+        return dst;
+    };
+
+    /** Highest bit set in a byte. */
+    var bytemsb = [
+        0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 /* 256 */
+    ];
+    console.assert(bytemsb.length===0x100);
+    /** Find last set (most significant bit).
+     *  @return the last bit set in the argument.
+     *          <code>fls(0)==0</code> and <code>fls(1)==1</code>. */
+    var fls = Util.fls = function(v) {
+        console.assert(v>=0);
+        if (v > 0xFFFFFFFF) { // use floating-point mojo
+            return 32 + fls(Math.floor(v / 0x100000000));
+        }
+        if ( (v & 0xFFFF0000) !== 0) {
+            if ( (v & 0xFF000000) !== 0) {
+                return 24 + bytemsb[(v>>>24) & 0xFF];
+            } else {
+                return 16 + bytemsb[v>>>16];
+            }
+        } else if ( (v & 0x0000FF00) !== 0) {
+            return 8 + bytemsb[v>>>8];
+        } else {
+            return bytemsb[v];
+        }
+    };
+    /** Returns ceil(log2(n)) */
+    Util.log2c = function(v) {
+        return (v===0)?-1:fls(v-1);
+    };
+
+    return freeze(Util); // ensure constants are recognized as such.
+});

package/.output/server/node_modules/compressjs/lib/freeze.js

@@ -0,0 +1,14 @@
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define([],function(){
+  'use strict';
+
+  // Object.freeze(), or a thunk if that method is not present in this
+  // JavaScript environment.
+
+  if (Object.freeze) {
+    return Object.freeze;
+  } else {
+    return function(o) { return o; };
+  }
+
+});

package/.output/server/node_modules/compressjs/main.js

@@ -0,0 +1,29 @@
+if (typeof define !== 'function') { var define = require('amdefine')(module); }
+define(['./lib/freeze','./lib/BitStream','./lib/Stream','./lib/BWT','./lib/Context1Model','./lib/DefSumModel','./lib/FenwickModel','./lib/MTFModel','./lib/NoModel','./lib/Huffman','./lib/RangeCoder','./lib/BWTC','./lib/Bzip2','./lib/Dmc','./lib/Lzjb','./lib/LzjbR','./lib/Lzp3','./lib/PPM','./lib/Simple'], function(freeze,BitStream,Stream,BWT,Context1Model,DefSumModel,FenwickModel,MTFModel,NoModel,Huffman,RangeCoder,BWTC,Bzip2,Dmc,Lzjb,LzjbR,Lzp3,PPM,Simple) {
+    'use strict';
+    return freeze({
+        version: "0.0.1",
+        // APIs
+        BitStream: BitStream,
+        Stream: Stream,
+        // transforms
+        BWT: BWT,
+        // models and coder
+        Context1Model: Context1Model,
+        DefSumModel: DefSumModel,
+        FenwickModel: FenwickModel,
+        MTFModel: MTFModel,
+        NoModel: NoModel,
+        Huffman: Huffman,
+        RangeCoder: RangeCoder,
+        // compression methods
+        BWTC: BWTC,
+        Bzip2: Bzip2,
+        Dmc: Dmc,
+        Lzjb: Lzjb,
+        LzjbR: LzjbR,
+        Lzp3: Lzp3,
+        PPM: PPM,
+        Simple: Simple
+    });
+});

package/.output/server/node_modules/compressjs/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "compressjs",
+  "version": "1.0.3",
+  "author": "C. Scott Ananian",
+  "description": "pure JavaScript de/compression (bzip2, etc) for node.js, volo, and the browser.",
+  "keywords": [
+    "bzip2",
+    "compression",
+    "decompression"
+  ],
+  "main": "main",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cscott/compressjs.git"
+  },
+  "license": "GPL",
+  "bin": {
+    "compressjs": "./bin/compressjs"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "amdefine": "~1.0.0",
+    "commander": "~2.8.1"
+  },
+  "devDependencies": {
+    "mocha": "~2.2.5"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "amd": {},
+  "volo": {}
+}

package/.output/server/package.json

@@ -5,8 +5,9 @@
   "private": true,
   "dependencies": {
     "@mongodb-js/zstd": "7.0.0",
+    "amdefine": "1.0.1",
+    "compressjs": "1.0.3",
     "node-pty": "1.2.0-beta.11",
-    "tslib": "2.8.1",
     "undici": "7.22.0"
   }
 }

package/README.md

@@ -81,6 +81,7 @@ Each group/chat has its own:
 - workspace folder
 - persisted memory + session state
 - model + thinking settings
+- optional persona/soul (custom role injected into system prompt)
 
 Trigger behavior is configurable:
 
@@ -97,6 +98,7 @@ Every agent session comes with built-in tools:
 - **Browser** — open, navigate, and manage browser tabs in the admin UI
 - **Notes** — markdown notes organized by category for persistent knowledge
 - **Notify** — send push notifications (ntfy.sh) with priority, tags, and actions
+- **Message** — inter-group messaging lets agents communicate across groups
 
 ### 🤖 Serious agent controls
 
@@ -133,7 +135,7 @@ Per-chat command controls include:
 - Real PTY terminal sessions in the dashboard
 - Sessions survive window close/reopen
 - Label sync + reconnect across views
-- Optional virtual/sandbox-style terminal mode
+- Sandboxed virtual terminal mode (powered by [just-bash](https://justbash.dev/))
 
 ### ⏰ Scheduler + automation hooks
 
@@ -141,6 +143,12 @@ Per-chat command controls include:
 - Attach tasks to specific chat groups
 - Automated prompts executed by the right agent context
 
+### 🖼️ Image attachments
+
+- Send images in chat via file picker, clipboard paste, or drag-and-drop
+- Thumbnail previews in compose area
+- Telegram inbound photo/document support
+
 ### 📲 External channels + notifications
 
 - Telegram bot integration (DMs + groups)
@@ -188,6 +196,7 @@ Per-chat command controls include:
 - [Modern Monaco](https://github.com/esm-dev/modern-monaco) — code editor
 - [Visual JSON](https://github.com/vercel-labs/visual-json) — schema-aware JSON editor
 - [Xterm.js](https://github.com/xtermjs/xterm.js) and [node-pty](https://github.com/microsoft/node-pty) — terminal
+- [just-bash](https://justbash.dev/) — sandboxed bash for virtual terminal
 - [Geist](https://vercel.com/font) — typography (Sans, Mono, Pixel)
 - [Iconify](https://github.com/iconify/iconify) — icons
 

package/lib/index.d.mts

@@ -0,0 +1 @@
+export * from "../src/server/entry.ts";

package/lib/index.mjs

@@ -0,0 +1 @@
+export * from "../.output/server/index.mjs";

package/lib/piclaw.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { ansi, isPortOpen, checkSqlite, printBanner, openBrowser } from "./utils.mjs";
+
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+  if (warning.name === "ExperimentalWarning") return;
+  console.warn(warning);
+});
+
+const { values } = parseArgs({
+  options: {
+    help: { type: "boolean", short: "h", default: false },
+    "no-open": { type: "boolean", default: false },
+    "no-kiosk": { type: "boolean", default: false },
+    port: { type: "string", short: "p" },
+  },
+  strict: false,
+});
+
+if (values.help) {
+  _printHelp();
+}
+
+const [subCmd, ...args] = process.argv.slice(2).filter((a) => !a.startsWith("-"));
+if (subCmd === "device") {
+  await _handleDeviceCommand(...args);
+}
+
+const port = Number(values.port || process.env.PORT || 3737);
+const isWebContainer = process.env.SHELL === "/bin/jsh" || !!process.versions?.webcontainer;
+
+let serverUrl;
+if (!isWebContainer && (await isPortOpen(port))) {
+  serverUrl = `http://localhost:${port}`;
+  console.log(`\x1b[32m✔ PiClaw already running on ${serverUrl}\x1b[0m\n`);
+} else {
+  serverUrl = await _startServer(port, isWebContainer);
+}
+
+if (serverUrl && !values["no-open"] && !isWebContainer) {
+  openBrowser(serverUrl, { kiosk: !values["no-kiosk"] });
+}
+
+// --- internal helpers ---
+
+function _printHelp() {
+  const { bold, dim, cyan } = ansi;
+  console.log(`${bold("piclaw")} ${dim("— multi-channel chat bot orchestrator")}
+
+${bold("Usage:")} ${cyan("piclaw")} [options]
+       ${cyan("piclaw")} device approve|revoke <device-id>
+
+${bold("Options:")}
+  ${cyan("-p, --port")}  Port to listen on ${dim("(default: 3737, env: PORT)")}
+  ${cyan("--no-open")}   Do not open the browser on start
+  ${cyan("--no-kiosk")}  Disable kiosk mode ${dim("(fullscreen chromeless)")}
+  ${cyan("-h, --help")}  Show this help message
+
+${bold("Commands:")}
+  ${cyan("device approve <id>")}  Approve a pending device
+  ${cyan("device revoke <id>")}   Revoke an approved device`);
+  process.exit(0);
+}
+
+async function _handleDeviceCommand(action, deviceId) {
+  if (!["approve", "revoke"].includes(action) || !deviceId) {
+    console.error("Usage: piclaw device approve|revoke <device-id>");
+    process.exit(1);
+  }
+  const { approveDevice, revokeDevice } = await import("../.output/server/index.mjs");
+  const fn = action === "approve" ? approveDevice : revokeDevice;
+  const result = await fn(deviceId);
+  if (!result) {
+    console.error(`\x1b[31m✖ Device ${deviceId} not found or already ${action}d.\x1b[0m`);
+    process.exit(1);
+  }
+  console.log(`\x1b[32m✔ Device ${action}d: ${deviceId}\x1b[0m`);
+  process.exit(0);
+}
+
+async function _startServer(port, isWebContainer) {
+  const startTime = performance.now();
+
+  console.log(
+    "\x1b[33m⚠ This project is in private beta. Use at your own risk.\n  Feedback → https://pi0.io\x1b[0m\n",
+  );
+
+  if (!("Bun" in globalThis) && !isWebContainer) {
+    checkSqlite();
+  }
+
+  process.env.PORT = String(port);
+
+  const { startServer } = await import("./index.mjs");
+  const server = await startServer();
+
+  printBanner(server.url, startTime);
+  return server.url;
+}

package/lib/utils.mjs

@@ -0,0 +1,96 @@
+import { createConnection } from "node:net";
+
+export const ansi = {
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+export function isPortOpen(port) {
+  return new Promise((resolve) => {
+    const conn = createConnection({ port });
+    conn.once("connect", () => {
+      conn.destroy();
+      resolve(true);
+    });
+    conn.once("error", () => resolve(false));
+  });
+}
+
+export async function checkSqlite() {
+  let hasSqlite = false;
+  try {
+    await import("node:sqlite");
+    hasSqlite = true;
+  } catch {}
+  if (!hasSqlite) {
+    try {
+      (await import("node:module")).createRequire(import.meta.url)("sqlite3");
+      hasSqlite = true;
+    } catch {}
+  }
+  if (!hasSqlite) {
+    console.error(
+      `\x1b[31m✖ No SQLite backend available.\x1b[0m\n\n` +
+        `  PiClaw requires \x1b[1m\x1b[36mnode:sqlite\x1b[0m (Node.js ≥ v22.5.0) or \x1b[1m\x1b[36msqlite3\x1b[0m.\n\n` +
+        `  Current Node.js: \x1b[33m${process.version}\x1b[0m\n` +
+        `  Fix: upgrade Node.js.`,
+    );
+    process.exit(1);
+  }
+}
+
+export async function printBanner(serverUrl, startTime) {
+  const { bold, dim, cyan } = ansi;
+  const elapsed = ((performance.now() - startTime) / 1000).toFixed(1);
+
+  const parsed = new URL(serverUrl);
+  const isWildcard = parsed.hostname === "0.0.0.0" || parsed.hostname === "::";
+
+  let lines = `\n  ${bold("PiClaw")} ${dim(`ready in ${elapsed}s`)}\n\n`;
+  if (isWildcard) {
+    parsed.hostname = "localhost";
+    lines += `  ${cyan("➜")}  ${bold("Local:")}     ${cyan(parsed.href)}\n`;
+    const { hostname, networkInterfaces } = await import("node:os");
+    const host = hostname();
+    if (host) {
+      parsed.hostname = host;
+      lines += `  ${cyan("➜")}  ${bold("Network:")}   ${cyan(parsed.href)}\n`;
+    }
+    for (const addrs of Object.values(networkInterfaces())) {
+      for (const addr of addrs) {
+        if (addr.internal || addr.family !== "IPv4") continue;
+        parsed.hostname = addr.address;
+        lines += `  ${cyan("➜")}  ${bold("Network:")}   ${cyan(parsed.href)}\n`;
+      }
+    }
+  } else {
+    lines += `  ${cyan("➜")}  ${bold("Local:")}     ${cyan(serverUrl)}\n`;
+  }
+
+  console.log(lines);
+}
+
+export async function openBrowser(serverUrl, { kiosk = true } = {}) {
+  const { exec } = await import("node:child_process");
+  const url = new URL(serverUrl);
+  if (["::", "127.0.0.1", "localhost"].includes(url.hostname)) {
+    url.hostname = "piclaw.localhost";
+  }
+  const href = url.href;
+  const kioskFlag = kiosk ? " --kiosk" : "";
+  const platform = process.platform;
+  if (platform === "darwin") {
+    exec(
+      `open -na "Google Chrome" --args --app="${href}"${kioskFlag} || open -na "Safari" "${href}"`,
+    );
+  } else if (platform === "win32") {
+    exec(`start chrome --app="${href}"${kioskFlag} || start msedge --app="${href}"${kioskFlag}`);
+  } else {
+    const tmpDir = `\${XDG_RUNTIME_DIR:-/tmp}/piclaw-chrome`;
+    const chromeFlags = `--user-data-dir="${tmpDir}" --no-first-run --no-default-browser-check${kioskFlag} --app="${href}"`;
+    exec(
+      `google-chrome-stable ${chromeFlags} 2>/dev/null || google-chrome ${chromeFlags} 2>/dev/null || chromium ${chromeFlags} 2>/dev/null || xdg-open "${href}"`,
+    );
+  }
+}