RectslBoxToolsSmokeTest.kt

    @JvmStatic
    fun main(args: Array<String>) {
        startRunloopDaemon()

        val document = freshSession("rectsl-box-tools")
        val docKey = document.absolutePath
        File(document, "macros").mkdirs()
        File(document, "macros/rectsl_box_tools.yaml").writeText(buildTranscript())

        val failures = mutableListOf<String>()
        fun check(cond: Boolean, message: String) {
            if (!cond) failures.add(message)
            println((if (cond) "ok   " else "FAIL ") + message)
        }

        try {
            val run = OperationTranscript.runMacro(document.absolutePath, "rectsl_box_tools")
            println("run.success=${run.success} applied=${run.applied} output lines=${run.output.size}")
            run.output.forEach { println("  [${it.kind}] ${it.uid}: ${stripHtml(it.html)}") }
            check(run.success, "transcript run succeeded")
            check(run.output.none { it.kind == "error" || it.kind == "err" }, "no error-kind box output")

            val checkTool = DocumentToolRegistry.get(docKey, "rectsl.check")
            check(checkTool != null, "rectsl.check registered via registerRectslStudioTools() in box code")
            check(DocumentToolRegistry.get(docKey, "rectsl.run") != null, "rectsl.run registered")
            if (checkTool == null) { report(failures); return }

            val box: Box = checkTool.box
            val ctx = ToolExecutionContext(dynamicTools = DocumentToolRegistry.toolsFor(docKey))
            val registry = ToolRegistry()

            // --- rectsl.check: good vs. bad source ---
            val good = registry.executeByName(
                ctx, "rectsl.check",
                aiToolMapper.writeValueAsString(mapOf("source" to GOOD_SOURCE))
            )
            val goodJson = aiToolMapper.writeValueAsString(good)
            check(goodJson.contains("compiles cleanly"),
                "rectsl.check accepts a valid program" + if (goodJson.contains("compiles cleanly")) "" else " (got $goodJson)")
            val bad = registry.executeByName(
                ctx, "rectsl.check",
                aiToolMapper.writeValueAsString(mapOf("source" to "arra 1 2 totally-not-rectsl"))
            )
            check(bad is BoxToolError && bad.messages.isNotEmpty(),
                "rectsl.check returns diagnostics for a bad program")

            // --- {{ }} escape reads the box's live ki-var (prewarmed off the runloop) ---
            val escapes = runBlocking {
                withContext(box.ki.compilationDispatcher) { prewarmRectSLEscapes(ESCAPE_SOURCE, box.ki) }
            }
            check(escapes.isNotEmpty(), "{{ boxScale }} escape compiled against the box's engine")
            val escapeValue = escapes.values.first().invoke(RectEscapeContext(0.0, 1.0, 0.0, 0.0, 0.0, 0.0))
            check((escapeValue as? Number)?.toDouble() == 3.0,
                "escape {{ boxScale }} reads the box's live ki-var (=3.0), got $escapeValue")

            // --- image-return primitive: base64 stays out of the JSON output ---
            box.aiTool("img.test") {
                describe("Return a tiny fixed image.")
                action { image("data:image/png;base64,QUJDREVG", "a test image") }
            }
            val imgCtx = ToolExecutionContext(dynamicTools = DocumentToolRegistry.toolsFor(docKey))
            val imgResult = registry.executeByName(imgCtx, "img.test", "{}")
            check(imgResult is BoxToolImages && imgResult.imageDataUrls.size == 1,
                "image() returns a BoxToolImages carrying the data URL")
            val imgJson = aiToolMapper.writeValueAsString(imgResult)
            check(imgJson.contains("\"count\":1") && !imgJson.contains("QUJDREVG"),
                "image data URL is JsonIgnored in the tool output (only count/note serialized)")

            // --- rectsl.run without a renderer: graceful structured error (GPU path runs in a live doc) ---
            val runResult = registry.executeByName(
                imgCtx, "rectsl.run",
                aiToolMapper.writeValueAsString(mapOf("source" to GOOD_SOURCE))
            )
            check(runResult is BoxToolError,
                "rectsl.run degrades to a tool error when no Field 4 renderer is in context")
        } catch (t: Throwable) {
            failures.add("harness threw ${t.javaClass.simpleName}: ${t.message}")
            t.printStackTrace(System.err)
        } finally {
            thisSessionInfo.remove()
        }

        report(failures)
    }

    private fun report(failures: List<String>) {
        if (failures.isNotEmpty()) {
            System.err.println("RectslBoxToolsSmokeTest FAILED with ${failures.size} problem(s):")
            failures.forEach { System.err.println("  - $it") }
            exitProcess(1)
        }
        println("RectslBoxToolsSmokeTest ok")
        exitProcess(0)
    }

    private fun freshSession(name: String): File {
        thisSessionInfo.remove()
        val workspace = Files.createTempDirectory("afield-$name").toFile()
        workspace.deleteOnExit()
        val document = File(workspace, "doc").also { it.mkdirs() }
        File(document, SavingContext.METADATA_EDN).writeText("{:version 2 :boxes []}\n")
        val root = Box("root")
        val session = SessionInformation(
            filename = document.absolutePath,
            documentName = document.name,
            boxes = ConcurrentHashMap(),
            root = root,
            ephemeral = true,
        )
        root.inside = session
        session.boxes[root.id] = root
        thisSessionInfo.set(session)
        return document
    }

    private fun startRunloopDaemon() {
        val t = Thread({ afield.runtime.lifecycle.Runloop.runLoop.start() }, "rectsl-box-tools-harness-runloop")
        t.isDaemon = true
        t.start()
        val deadline = System.currentTimeMillis() + 30_000
        while (afield.runtime.lifecycle.Runloop.runLoop.frame < 1L) {
            check(System.currentTimeMillis() < deadline) { "runloop did not start within 30s" }
            Thread.sleep(20)
        }
        println("RectslBoxToolsSmokeTest: runloop up (frame=${afield.runtime.lifecycle.Runloop.runLoop.frame})")
    }

    private fun stripHtml(html: String): String =
        html.replace(Regex("<[^>]+>"), " ").replace("&lt;", "<").replace("&gt;", ">").trim()
}