milhouse 1.0.1

package/dist/ui/server.js

@@ -0,0 +1,369 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import express from "express";
+import { resolveDefaultWorkdir, resolveStateBaseDir } from "../src/paths.js";
+function readArtifacts(stateDir) {
+    const snapshot = {};
+    const planLog = path.join(stateDir, "plan_out.log");
+    const buildLog = path.join(stateDir, "build_out.log");
+    const planFile = path.join(stateDir, "IMPLEMENTATION_PLAN.md");
+    const threadFile = path.join(stateDir, "thread_id");
+    if (fs.existsSync(planLog))
+        snapshot.planLog = fs.readFileSync(planLog, "utf8");
+    if (fs.existsSync(buildLog))
+        snapshot.buildLog = fs.readFileSync(buildLog, "utf8");
+    if (fs.existsSync(planFile))
+        snapshot.planFile = fs.readFileSync(planFile, "utf8");
+    if (fs.existsSync(threadFile))
+        snapshot.threadId = fs.readFileSync(threadFile, "utf8").trim();
+    return snapshot;
+}
+function resolveLoopRunner(runtimeRoot) {
+    const jsPath = path.join(runtimeRoot, "src", "loop-runner.js");
+    if (fs.existsSync(jsPath)) {
+        return { command: process.execPath, args: [jsPath] };
+    }
+    const tsPath = path.join(runtimeRoot, "src", "loop-runner.ts");
+    if (fs.existsSync(tsPath)) {
+        const bin = process.platform === "win32" ? "tsx.cmd" : "tsx";
+        const tsxPath = path.join(runtimeRoot, "node_modules", ".bin", bin);
+        if (fs.existsSync(tsxPath)) {
+            return { command: tsxPath, args: [tsPath] };
+        }
+    }
+    throw new Error("Loop runner not found (expected dist build output).");
+}
+function createServerContext(options) {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const runtimeRoot = path.resolve(__dirname, "..");
+    const defaultWorkdir = options.defaultWorkdir ?? resolveDefaultWorkdir();
+    const stateBaseDir = options.stateBaseDir ?? resolveStateBaseDir();
+    fs.mkdirSync(stateBaseDir, { recursive: true });
+    const sessionsFile = path.join(stateBaseDir, "sessions.json");
+    const loopRunner = resolveLoopRunner(runtimeRoot);
+    const app = express();
+    app.use(express.json({ limit: "1mb" }));
+    app.use(express.static(path.join(__dirname, "public")));
+    const clients = [];
+    let child = null;
+    let currentSession = null;
+    let logBuffer = [];
+    function broadcast(line) {
+        logBuffer.push(line);
+        const payload = `data: ${line}\n\n`;
+        clients.forEach((c) => c.res.write(payload));
+    }
+    function saveSessions(update) {
+        let sessions = [];
+        if (fs.existsSync(sessionsFile)) {
+            try {
+                sessions = JSON.parse(fs.readFileSync(sessionsFile, "utf8"));
+            }
+            catch {
+                sessions = [];
+            }
+        }
+        const next = update(sessions);
+        fs.writeFileSync(sessionsFile, JSON.stringify(next, null, 2));
+    }
+    function normalizeWorkdir(input) {
+        if (!input)
+            return defaultWorkdir;
+        return path.isAbsolute(input) ? input : path.resolve(defaultWorkdir, input);
+    }
+    function startSession(goal, maxIterations, workdirInput, createIfMissing) {
+        if (child) {
+            throw new Error("A run is already in progress");
+        }
+        let workdir = normalizeWorkdir(workdirInput);
+        if (!fs.existsSync(workdir)) {
+            if (createIfMissing) {
+                fs.mkdirSync(workdir, { recursive: true });
+            }
+            else {
+                throw new Error(`Workdir not found: ${workdir}`);
+            }
+        }
+        const stateDir = path.join(stateBaseDir, Buffer.from(workdir).toString("base64url"));
+        fs.mkdirSync(stateDir, { recursive: true });
+        logBuffer = [];
+        const id = randomUUID();
+        const startedAt = new Date().toISOString();
+        currentSession = {
+            id,
+            goal,
+            maxIterations,
+            workdir,
+            stateDir,
+            startedAt,
+            status: "running",
+        };
+        saveSessions((sessions) => [...sessions, currentSession]);
+        const args = [
+            ...loopRunner.args,
+            "--goal",
+            goal,
+            "--max-iterations",
+            String(maxIterations),
+            "--workdir",
+            workdir,
+            "--state-dir",
+            stateDir,
+        ];
+        child = spawn(loopRunner.command, args, {
+            cwd: runtimeRoot,
+            env: process.env,
+        });
+        child.stdout.on("data", (data) => {
+            const lines = data.toString().split(/\r?\n/).filter(Boolean);
+            lines.forEach((l) => {
+                broadcast(l);
+                const threadMatch = l.match(/thread:\s*([0-9a-zA-Z-]+)/);
+                if (threadMatch && currentSession)
+                    currentSession.threadId = threadMatch[1];
+            });
+        });
+        child.stderr.on("data", (data) => {
+            data
+                .toString()
+                .split(/\r?\n/)
+                .filter(Boolean)
+                .forEach((l) => broadcast(`[stderr] ${l}`));
+        });
+        child.on("exit", (code, signal) => {
+            broadcast(`[exit] code=${code ?? "null"} signal=${signal ?? "null"}`);
+            if (currentSession) {
+                currentSession.status = code === 0 ? "succeeded" : signal === "SIGTERM" ? "stopped" : "failed";
+                currentSession.endedAt = new Date().toISOString();
+                saveSessions((sessions) => sessions.map((s) => (s.id === currentSession.id ? currentSession : s)));
+            }
+            child = null;
+        });
+    }
+    function stopSession() {
+        if (child) {
+            child.kill();
+        }
+    }
+    async function browseFolder(defaultPath) {
+        return await new Promise((resolve, reject) => {
+            const isWindows = process.platform === "win32";
+            const isMac = process.platform === "darwin";
+            const isLinux = process.platform === "linux";
+            if (isWindows) {
+                const initialDirectory = defaultPath?.trim() ? defaultPath.replace(/'/g, "''") : "";
+                const script = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+public static class User32 {
+  [DllImport("user32.dll")]
+  public static extern bool SetForegroundWindow(IntPtr hWnd);
+}
+"@
+
+$topForm = New-Object System.Windows.Forms.Form
+$topForm.TopMost = $true
+$topForm.ShowInTaskbar = $false
+$topForm.FormBorderStyle = 'FixedToolWindow'
+$topForm.StartPosition = 'Manual'
+$topForm.Location = New-Object System.Drawing.Point(-32000, -32000)
+$topForm.Size = New-Object System.Drawing.Size(1, 1)
+$topForm.Opacity = 0
+$topForm.Show()
+$topForm.Activate()
+$topForm.BringToFront()
+$topForm.Focus()
+[User32]::SetForegroundWindow($topForm.Handle) | Out-Null
+[System.Windows.Forms.Application]::DoEvents()
+
+$dlg = New-Object System.Windows.Forms.OpenFileDialog
+$dlg.Title = 'Select project folder'
+$dlg.ValidateNames = $false
+$dlg.CheckFileExists = $false
+$dlg.CheckPathExists = $true
+$dlg.FileName = 'Select Folder'
+${initialDirectory ? `$dlg.InitialDirectory = '${initialDirectory}'` : ""}
+
+$result = $dlg.ShowDialog($topForm)
+if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
+  Write-Output (Split-Path -Parent $dlg.FileName)
+}
+$topForm.Close()
+`;
+                const encoded = Buffer.from(script, "utf16le").toString("base64");
+                const ps = spawn("powershell", ["-NoProfile", "-STA", "-EncodedCommand", encoded]);
+                let out = "";
+                ps.stdout.on("data", (d) => (out += d.toString()));
+                ps.stderr.on("data", (d) => broadcast(`[browse stderr] ${d.toString().trim()}`));
+                ps.on("error", (err) => reject(err));
+                ps.on("exit", (code) => {
+                    const trimmed = out.trim();
+                    if (code === 0 && trimmed) {
+                        resolve(trimmed);
+                    }
+                    else {
+                        reject(new Error("Folder selection cancelled or failed"));
+                    }
+                });
+                return;
+            }
+            if (isMac) {
+                const osa = spawn("osascript", [
+                    "-e",
+                    'set p to POSIX path of (choose folder with prompt "Select project folder")',
+                ]);
+                let out = "";
+                osa.stdout.on("data", (d) => (out += d.toString()));
+                osa.stderr.on("data", (d) => broadcast(`[browse stderr] ${d.toString().trim()}`));
+                osa.on("error", (err) => reject(err));
+                osa.on("exit", (code) => {
+                    const trimmed = out.trim();
+                    if (code === 0 && trimmed) {
+                        resolve(trimmed);
+                    }
+                    else {
+                        reject(new Error("Folder selection cancelled or failed"));
+                    }
+                });
+                return;
+            }
+            if (isLinux) {
+                const run = (command, args, onMissing) => {
+                    const proc = spawn(command, args);
+                    let out = "";
+                    proc.stdout.on("data", (d) => (out += d.toString()));
+                    proc.stderr.on("data", (d) => broadcast(`[browse stderr] ${d.toString().trim()}`));
+                    proc.on("error", (err) => {
+                        if (err.code === "ENOENT")
+                            onMissing();
+                        else
+                            reject(err);
+                    });
+                    proc.on("exit", (code) => {
+                        const trimmed = out.trim();
+                        if (code === 0 && trimmed)
+                            resolve(trimmed);
+                        else
+                            reject(new Error("Folder selection cancelled or failed"));
+                    });
+                };
+                run("zenity", [
+                    "--file-selection",
+                    "--directory",
+                    "--title=Select project folder",
+                    ...(defaultPath?.trim() ? [`--filename=${defaultPath}`] : []),
+                ], () => run("kdialog", ["--getexistingdirectory", defaultPath?.trim() ? defaultPath : ".", "--title", "Select project folder"], () => reject(new Error("Folder picker not available (install zenity or kdialog, or enter the path manually)."))));
+                return;
+            }
+            reject(new Error("Folder picker not supported on this OS"));
+        });
+    }
+    async function handleBrowse(req, res) {
+        try {
+            const path = await browseFolder(req.body?.defaultPath);
+            res.json({ path });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    }
+    app.get("/api/events", (req, res) => {
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        const id = randomUUID();
+        clients.push({ id, res });
+        logBuffer.forEach((line) => res.write(`data: ${line}\n\n`));
+        req.on("close", () => {
+            const idx = clients.findIndex((c) => c.id === id);
+            if (idx >= 0)
+                clients.splice(idx, 1);
+        });
+    });
+    app.get("/api/status", (_req, res) => {
+        res.json({
+            running: Boolean(child),
+            session: currentSession,
+            artifacts: currentSession ? readArtifacts(currentSession.stateDir) : {},
+        });
+    });
+    app.get("/api/sessions", (_req, res) => {
+        let sessions = [];
+        if (fs.existsSync(sessionsFile)) {
+            try {
+                sessions = JSON.parse(fs.readFileSync(sessionsFile, "utf8"));
+            }
+            catch {
+                sessions = [];
+            }
+        }
+        res.json({ sessions });
+    });
+    app.post("/api/start", (req, res) => {
+        const { goal, maxIterations = 0, workdir = defaultWorkdir, createIfMissing = true } = req.body || {};
+        if (!goal || typeof goal !== "string") {
+            return res.status(400).json({ error: "goal is required" });
+        }
+        try {
+            startSession(goal, Number(maxIterations) || 0, workdir, Boolean(createIfMissing));
+            res.json({ ok: true, session: currentSession });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.post("/api/stop", (_req, res) => {
+        stopSession();
+        res.json({ ok: true });
+    });
+    app.get("/api/artifacts", (_req, res) => {
+        if (!currentSession)
+            return res.json({});
+        res.json(readArtifacts(currentSession.stateDir));
+    });
+    app.post("/api/browse", handleBrowse);
+    app.get("/api/browse", handleBrowse);
+    return { app, stop: stopSession };
+}
+function listenOnce(app, host, port) {
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, host, () => resolve(server));
+        server.on("error", (err) => reject(err));
+    });
+}
+export async function startServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const preferredPort = options.port ?? (process.env.PORT ? Number(process.env.PORT) : 4173);
+    const ctx = createServerContext(options);
+    let server;
+    try {
+        server = await listenOnce(ctx.app, host, preferredPort);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "EADDRINUSE" && preferredPort !== 0) {
+            server = await listenOnce(ctx.app, host, 0);
+        }
+        else {
+            throw err;
+        }
+    }
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : preferredPort;
+    const url = `http://${host}:${port}`;
+    const close = async () => {
+        ctx.stop();
+        await new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        });
+    };
+    return { url, host, port, close };
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "milhouse",
+  "version": "1.0.1",
+  "description": "Milhouse Van Houten - Local CLI + web UI for running autonomous Codex AI agent loops",
+  "bin": {
+    "milhouse": "dist/src/cli.js"
+  },
+  "main": "dist/src/cli.js",
+  "files": [
+    "dist/**",
+    "prompts/**",
+    "README.md",
+    "AGENTS.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc && node scripts/copy-assets.mjs",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/src/cli.js",
+    "ui": "npm run build --silent && node dist/src/cli.js ui",
+    "codex": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "codex",
+    "ai",
+    "automation",
+    "agent",
+    "openai",
+    "web-ui",
+    "loop-runner"
+  ],
+  "author": "Milhouse Van Houten",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ordinalOS/Milhouse-Van-Houten.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ordinalOS/Milhouse-Van-Houten/issues"
+  },
+  "homepage": "https://github.com/ordinalOS/Milhouse-Van-Houten",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@openai/codex-sdk": "^0.80.0",
+    "env-paths": "^3.0.0",
+    "express": "^5.2.1",
+    "figlet": "^1.8.0",
+    "open": "^10.2.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/figlet": "^1.7.0",
+    "@types/node": "^25.0.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/prompts/build.md

@@ -0,0 +1,11 @@
+Build for goal: {{GOAL}}
+
+Plan file: {{PLAN_PATH}}
+
+You are the builder. Follow the plan at {{PLAN_PATH}}:
+- Pick the top unchecked item and complete it fully (no placeholders).
+- Make direct edits to the repo under `workdir`.
+- Run any obvious quick checks for touched stack (skip if none are applicable).
+- Update {{PLAN_PATH}}: mark done items `- [x]`, add new `- [ ]` if needed, keep priorities. End with `STATUS: DONE` if nothing remains, else `STATUS: READY`.
+
+Keep `AGENTS.md` operational only; no diaries.

package/prompts/plan.md

@@ -0,0 +1,11 @@
+Plan for goal: {{GOAL}}
+
+Plan file: {{PLAN_PATH}}
+
+You are the planner. Ignore any existing plan content and write a fresh `IMPLEMENTATION_PLAN.md` with:
+- A 1–2 sentence scope summary for the goal.
+- A prioritized checklist with `- [ ]` items (or `- [x]` if something is already done).
+- Keep tasks concise and concrete (code files or assets to touch).
+- End with a status line: `STATUS: READY` if work remains, `STATUS: DONE` if nothing to do.
+
+Do not implement code. Write the plan to {{PLAN_PATH}}. Output only the new plan content.