@oh-my-pi/pi-mom 0.1.0

package/docs/v86.md

@@ -0,0 +1,319 @@
+# v86 Sandbox Evaluation
+
+v86 is an x86 emulator written in JavaScript/WebAssembly that can run Linux in the browser or Node.js. This document details our evaluation for using it as a sandboxed execution environment.
+
+## Overview
+
+- **What it is**: x86 PC emulator (32-bit, Pentium 4 level)
+- **How it works**: Translates machine code to WebAssembly at runtime
+- **Guest OS**: Alpine Linux 3.21 (32-bit x86)
+- **Available packages**: Node.js 22, Python 3.12, git, curl, etc. (full Alpine repos)
+
+## Key Findings
+
+### What Works
+
+| Feature | Status | Notes |
+|---------|--------|-------|
+| Outbound TCP | ✅ | HTTP, HTTPS, TLS all work |
+| Outbound UDP | ✅ | DNS queries work |
+| WebSocket client | ✅ | Can connect to external WebSocket servers |
+| File I/O | ✅ | 9p filesystem for host<->guest file exchange |
+| State save/restore | ✅ | ~80-100MB state files, instant resume |
+| Package persistence | ✅ | Installed packages persist in saved state |
+| npm install | ✅ | Works (outbound HTTPS) |
+| git clone | ✅ | Works (outbound HTTPS) |
+
+### What Doesn't Work
+
+| Feature | Status | Notes |
+|---------|--------|-------|
+| Inbound connections | ❌ | VM is behind NAT (10.0.2.x), needs port forwarding |
+| ICMP ping | ❌ | Userspace network stack limitation |
+| 64-bit | ❌ | v86 only emulates 32-bit x86 |
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                      Host (Node.js)                      │
+│                                                          │
+│  ┌──────────────┐     ┌─────────────────────────────┐   │
+│  │ rootlessRelay│◄───►│           v86               │   │
+│  │  (WebSocket) │     │  ┌─────────────────────┐    │   │
+│  │              │     │  │   Alpine Linux      │    │   │
+│  │  - DHCP      │     │  │   - Node.js 22      │    │   │
+│  │  - DNS proxy │     │  │   - Python 3.12     │    │   │
+│  │  - NAT       │     │  │   - etc.            │    │   │
+│  └──────────────┘     │  └─────────────────────┘    │   │
+│         │             │            │                 │   │
+│         │             │     9p filesystem            │   │
+│         ▼             │            │                 │   │
+│    Internet           │            ▼                 │   │
+│                       │     Host filesystem          │   │
+│                       └─────────────────────────────┘   │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Components & Sizes
+
+| Component | Size | Purpose |
+|-----------|------|---------|
+| v86.wasm | ~2 MB | x86 emulator |
+| libv86.mjs | ~330 KB | JavaScript runtime |
+| seabios.bin | ~128 KB | BIOS |
+| vgabios.bin | ~36 KB | VGA BIOS |
+| Alpine rootfs | ~57 MB | Compressed filesystem (loaded on-demand) |
+| alpine-fs.json | ~160 KB | Filesystem index |
+| rootlessRelay | ~75 KB | Network relay |
+| **Total** | **~60 MB** | Without saved state |
+| Saved state | ~80-100 MB | Optional, for instant resume |
+
+## Installation
+
+```bash
+npm install v86 ws
+```
+
+## Building the Alpine Image
+
+v86 provides Docker tooling to build the Alpine image:
+
+```bash
+git clone https://github.com/copy/v86.git
+cd v86/tools/docker/alpine
+
+# Edit Dockerfile to add packages:
+# ENV ADDPKGS=nodejs,npm,python3,git,curl
+
+./build.sh
+```
+
+This creates:
+- `images/alpine-fs.json` - Filesystem index
+- `images/alpine-rootfs-flat/` - Compressed file chunks
+
+## Network Relay Setup
+
+v86 needs a network relay for TCP/UDP connectivity. We use rootlessRelay:
+
+```bash
+git clone https://github.com/obegron/rootlessRelay.git
+cd rootlessRelay
+npm install
+```
+
+### Required Patches for Host Access
+
+To allow the VM to connect to host services via the gateway IP (10.0.2.2), apply these patches to `relay.js`:
+
+**Patch 1: Disable reverse TCP handling for gateway (line ~684)**
+```javascript
+// Change:
+if (protocol === 6 && dstIP === GATEWAY_IP) {
+  this.handleReverseTCP(ipPacket);
+  return;
+}
+
+// To:
+if (false && protocol === 6 && dstIP === GATEWAY_IP) { // PATCHED
+  this.handleReverseTCP(ipPacket);
+  return;
+}
+```
+
+**Patch 2: Redirect gateway TCP to localhost (line ~792)**
+```javascript
+// Change:
+const socket = net.connect(dstPort, dstIP, () => {
+
+// To:
+const actualDstIP = dstIP === GATEWAY_IP ? "127.0.0.1" : dstIP;
+const socket = net.connect(dstPort, actualDstIP, () => {
+```
+
+**Patch 3: Redirect gateway UDP to localhost (lines ~1431 and ~1449)**
+```javascript
+// Change:
+this.udpSocket.send(payload, dstPort, dstIP, (err) => {
+
+// To:
+const actualUdpDstIP = dstIP === GATEWAY_IP ? "127.0.0.1" : dstIP;
+this.udpSocket.send(payload, dstPort, actualUdpDstIP, (err) => {
+```
+
+### Starting the Relay
+
+```bash
+ENABLE_WSS=false LOG_LEVEL=1 node relay.js
+# Listens on ws://127.0.0.1:8086/
+```
+
+## Basic Usage
+
+```javascript
+import { V86 } from "v86";
+import path from "node:path";
+
+const emulator = new V86({
+    wasm_path: path.join(__dirname, "node_modules/v86/build/v86.wasm"),
+    bios: { url: path.join(__dirname, "bios/seabios.bin") },
+    vga_bios: { url: path.join(__dirname, "bios/vgabios.bin") },
+    filesystem: {
+        basefs: path.join(__dirname, "images/alpine-fs.json"),
+        baseurl: path.join(__dirname, "images/alpine-rootfs-flat/"),
+    },
+    autostart: true,
+    memory_size: 512 * 1024 * 1024,
+    bzimage_initrd_from_filesystem: true,
+    cmdline: "rw root=host9p rootfstype=9p rootflags=trans=virtio,cache=loose modules=virtio_pci tsc=reliable console=ttyS0",
+    net_device: {
+        type: "virtio",
+        relay_url: "ws://127.0.0.1:8086/",
+    },
+});
+
+// Capture output
+emulator.add_listener("serial0-output-byte", (byte) => {
+    process.stdout.write(String.fromCharCode(byte));
+});
+
+// Send commands
+emulator.serial0_send("echo hello\n");
+```
+
+## Communication Methods
+
+### 1. Serial Console (stdin/stdout)
+
+```javascript
+// Send command
+emulator.serial0_send("ls -la\n");
+
+// Receive output
+let output = "";
+emulator.add_listener("serial0-output-byte", (byte) => {
+    output += String.fromCharCode(byte);
+});
+```
+
+### 2. 9p Filesystem (file I/O)
+
+```javascript
+// Write file to VM
+const data = new TextEncoder().encode("#!/bin/sh\necho hello\n");
+await emulator.create_file("/tmp/script.sh", data);
+
+// Read file from VM
+const result = await emulator.read_file("/tmp/output.txt");
+console.log(new TextDecoder().decode(result));
+```
+
+### 3. Network (TCP to host services)
+
+From inside the VM, connect to `10.0.2.2:PORT` to reach `localhost:PORT` on the host (requires patched relay).
+
+```bash
+# Inside VM
+wget http://10.0.2.2:8080/  # Connects to host's localhost:8080
+```
+
+## State Save/Restore
+
+```javascript
+// Save state (includes all installed packages, files, etc.)
+const state = await emulator.save_state();
+fs.writeFileSync("vm-state.bin", Buffer.from(state));
+
+// Restore state (instant resume, ~2 seconds)
+const stateBuffer = fs.readFileSync("vm-state.bin");
+await emulator.restore_state(stateBuffer.buffer);
+```
+
+## Network Setup Inside VM
+
+After boot, run these commands to enable networking:
+
+```bash
+modprobe virtio-net
+ip link set eth0 up
+udhcpc -i eth0
+```
+
+Or as a one-liner:
+```bash
+modprobe virtio-net && ip link set eth0 up && udhcpc -i eth0
+```
+
+The VM will get IP `10.0.2.15` (or similar) via DHCP from the relay.
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Cold boot | ~20-25 seconds |
+| State restore | ~2-3 seconds |
+| Memory usage | ~512 MB (configurable) |
+
+## Typical Workflow for Mom
+
+1. **First run**:
+   - Start rootlessRelay
+   - Boot v86 with Alpine (~25s)
+   - Setup network
+   - Install needed packages (`apk add nodejs npm python3 git`)
+   - Save state
+
+2. **Subsequent runs**:
+   - Start rootlessRelay
+   - Restore saved state (~2s)
+   - Ready to execute commands
+
+3. **Command execution**:
+   - Send commands via `serial0_send()`
+   - Capture output via `serial0-output-byte` listener
+   - Exchange files via 9p filesystem
+
+## Alternative: fetch Backend (No Relay Needed)
+
+For HTTP-only networking, v86 has a built-in `fetch` backend:
+
+```javascript
+net_device: {
+    type: "virtio",
+    relay_url: "fetch",
+}
+```
+
+This uses the browser/Node.js `fetch()` API for HTTP requests. Limitations:
+- Only HTTP/HTTPS (no raw TCP/UDP)
+- No WebSocket
+- Host access via `http://<port>.external` (e.g., `http://8080.external`)
+
+## Files Reference
+
+After building, you need these files:
+
+```
+project/
+├── node_modules/v86/build/
+│   ├── v86.wasm
+│   └── libv86.mjs
+├── bios/
+│   ├── seabios.bin
+│   └── vgabios.bin
+├── images/
+│   ├── alpine-fs.json
+│   └── alpine-rootfs-flat/
+│       └── *.bin.zst (many files)
+└── rootlessRelay/
+    └── relay.js (patched)
+```
+
+## Resources
+
+- [v86 GitHub](https://github.com/copy/v86)
+- [v86 Networking Docs](https://github.com/copy/v86/blob/master/docs/networking.md)
+- [v86 Alpine Setup](https://github.com/copy/v86/tree/master/tools/docker/alpine)
+- [rootlessRelay](https://github.com/obegron/rootlessRelay)
+- [v86 npm package](https://www.npmjs.com/package/v86)

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@oh-my-pi/pi-mom",
+	"version": "0.1.0",
+	"description": "Slack bot that delegates messages to the omp coding agent",
+	"type": "module",
+	"bin": {
+		"mom": "src/main.ts"
+	},
+	"scripts": {
+		"prepublishOnly": "echo 'Publishing bun-native package'"
+	},
+	"dependencies": {
+		"@anthropic-ai/sandbox-runtime": "^0.0.16",
+		"@oh-my-pi/pi-agent-core": "0.1.0",
+		"@oh-my-pi/pi-ai": "0.1.0",
+		"@oh-my-pi/pi-coding-agent": "0.1.0",
+		"@sinclair/typebox": "^0.34.0",
+		"@slack/socket-mode": "^2.0.0",
+		"@slack/web-api": "^7.0.0",
+		"async-mutex": "^0.5.0",
+		"chalk": "^5.6.2",
+		"croner": "^9.1.0",
+		"diff": "^8.0.2"
+	},
+	"devDependencies": {
+		"@types/diff": "^7.0.2",
+		"@types/node": "^24.3.0"
+	},
+	"keywords": [
+		"slack",
+		"bot",
+		"ai",
+		"agent"
+	],
+	"author": "Mario Zechner",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/can1357/oh-my-pi.git",
+		"directory": "packages/mom"
+	},
+	"engines": {
+		"bun": ">=1.0.0"
+	}
+}

package/scripts/migrate-timestamps.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env npx tsx
+/**
+ * Migrate log.jsonl timestamps from milliseconds to Slack format (seconds.microseconds)
+ * 
+ * Usage: npx tsx scripts/migrate-timestamps.ts <data-dir>
+ * Example: npx tsx scripts/migrate-timestamps.ts ./data
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+function isMillisecondTimestamp(ts: string): boolean {
+	// Slack timestamps are seconds.microseconds, like "1764279530.533489"
+	// Millisecond timestamps are just big numbers, like "1764279320398"
+	// 
+	// Key insight: 
+	// - Slack ts from 2025: ~1.7 billion (10 digits before decimal)
+	// - Millisecond ts from 2025: ~1.7 trillion (13 digits)
+	
+	// If it has a decimal and the integer part is < 10^12, it's Slack format
+	if (ts.includes(".")) {
+		const intPart = parseInt(ts.split(".")[0], 10);
+		return intPart > 1e12; // Unlikely to have decimal AND be millis, but check anyway
+	}
+	
+	// No decimal - check if it's too big to be seconds
+	const num = parseInt(ts, 10);
+	return num > 1e12; // If > 1 trillion, it's milliseconds
+}
+
+function convertToSlackTs(msTs: string): string {
+	const ms = parseInt(msTs, 10);
+	const seconds = Math.floor(ms / 1000);
+	const micros = (ms % 1000) * 1000;
+	return `${seconds}.${micros.toString().padStart(6, "0")}`;
+}
+
+function migrateFile(filePath: string): { total: number; migrated: number } {
+	const content = readFileSync(filePath, "utf-8");
+	const lines = content.split("\n").filter(Boolean);
+	
+	let migrated = 0;
+	const newLines: string[] = [];
+	
+	for (const line of lines) {
+		try {
+			const msg = JSON.parse(line);
+			if (msg.ts && isMillisecondTimestamp(msg.ts)) {
+				const oldTs = msg.ts;
+				msg.ts = convertToSlackTs(msg.ts);
+				console.log(`  Converted: ${oldTs} -> ${msg.ts}`);
+				migrated++;
+			}
+			newLines.push(JSON.stringify(msg));
+		} catch (e) {
+			// Keep malformed lines as-is
+			console.log(`  Warning: Could not parse line: ${line.substring(0, 50)}...`);
+			newLines.push(line);
+		}
+	}
+	
+	if (migrated > 0) {
+		writeFileSync(filePath, newLines.join("\n") + "\n", "utf-8");
+	}
+	
+	return { total: lines.length, migrated };
+}
+
+function findLogFiles(dir: string): string[] {
+	const logFiles: string[] = [];
+	
+	if (!existsSync(dir)) {
+		console.error(`Directory not found: ${dir}`);
+		return [];
+	}
+	
+	const entries = readdirSync(dir);
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const stat = statSync(fullPath);
+		
+		if (stat.isDirectory()) {
+			// Check for log.jsonl in subdirectory
+			const logPath = join(fullPath, "log.jsonl");
+			if (existsSync(logPath)) {
+				logFiles.push(logPath);
+			}
+		}
+	}
+	
+	return logFiles;
+}
+
+// Main
+const dataDir = process.argv[2];
+if (!dataDir) {
+	console.error("Usage: npx tsx scripts/migrate-timestamps.ts <data-dir>");
+	console.error("Example: npx tsx scripts/migrate-timestamps.ts ./data");
+	process.exit(1);
+}
+
+console.log(`Scanning for log.jsonl files in: ${dataDir}\n`);
+
+const logFiles = findLogFiles(dataDir);
+if (logFiles.length === 0) {
+	console.log("No log.jsonl files found.");
+	process.exit(0);
+}
+
+let totalMigrated = 0;
+let totalMessages = 0;
+
+for (const logFile of logFiles) {
+	console.log(`Processing: ${logFile}`);
+	const { total, migrated } = migrateFile(logFile);
+	totalMessages += total;
+	totalMigrated += migrated;
+	console.log(`  ${migrated}/${total} messages migrated\n`);
+}
+
+console.log(`Done! Migrated ${totalMigrated}/${totalMessages} total messages across ${logFiles.length} files.`);