@rcrsr/rill-agent-http 0.19.0 → 0.21.0

package/dist/index.d.ts

@@ -2,6 +2,36 @@
 
 import { Hono } from 'hono';
 
+export interface RillHarnessLogger {
+	info(...args: unknown[]): void;
+	warn(...args: unknown[]): void;
+	error(...args: unknown[]): void;
+}
+export interface RillCompiledPackage {
+	readonly mount: string;
+	readonly buildOutput: {
+		readonly outputPath: string;
+	};
+}
+export interface RillServeContext {
+	readonly config: Record<string, unknown>;
+	readonly logger: RillHarnessLogger;
+	readonly packages: readonly RillCompiledPackage[];
+	readonly requestedMount: string | undefined;
+	readonly args: readonly string[];
+	readonly onShutdown: (handler: () => void | Promise<void>) => void;
+	readonly onSourceChange: (handler: () => void | Promise<void>) => void;
+}
+export interface RillPostBuildContext {
+	readonly outputDir: string;
+	readonly packages: readonly RillCompiledPackage[];
+	readonly logger: RillHarnessLogger;
+}
+export interface RillHarness {
+	readonly name: string;
+	readonly postBuild?: (ctx: RillPostBuildContext) => Promise<void>;
+	readonly serve?: (ctx: RillServeContext) => Promise<number>;
+}
 export interface HandlerDescription {
 	readonly name: string;
 	readonly description?: string | undefined;
@@ -12,6 +42,17 @@ export interface HandlerDescription {
 		readonly description?: string | undefined;
 		readonly defaultValue?: unknown;
 	}>;
+	/**
+	 * Handler return type annotation, formatted with the same grammar as
+	 * parameter type strings (e.g. `stream(dict(content: string)):string`).
+	 * Undefined when the handler closure has no `:T` annotation, or when the
+	 * rill-build emitting the handler is too old to expose the field.
+	 */
+	readonly returnType?: string | undefined;
+}
+export interface InitContext {
+	readonly globalVars?: Record<string, string> | undefined;
+	readonly ahiResolver?: ((agentName: string, request: RunRequest) => Promise<RunResponse>) | undefined;
 }
 export interface RunRequest {
 	readonly params?: Record<string, unknown> | undefined;
@@ -21,13 +62,25 @@ export interface RunContext {
 	readonly sessionVars?: Record<string, string> | undefined;
 	readonly onLog?: ((message: string) => void) | undefined;
 	readonly onChunk?: ((chunk: unknown) => Promise<void>) | undefined;
+	readonly signal?: AbortSignal | undefined;
 }
 export interface RunResponse {
 	readonly state: "completed" | "error";
 	readonly result: unknown;
 	readonly streamed?: boolean | undefined;
 }
+export interface AgentHandler {
+	describe(): HandlerDescription | null;
+	init(context?: InitContext): Promise<void>;
+	execute(request?: RunRequest, context?: RunContext): Promise<RunResponse>;
+	dispose(): Promise<void>;
+}
+export interface AgentManifest {
+	readonly defaultAgent: string;
+	readonly agents: ReadonlyMap<string, AgentHandler>;
+}
 export interface AgentRouter {
+	readonly manifest: AgentManifest;
 	run(agentName: string, request: RunRequest, context?: RunContext): Promise<RunResponse>;
 	describe(agentName: string): HandlerDescription | null;
 	agents(): string[];
@@ -48,5 +101,16 @@ export interface HttpHarness {
  *   POST /run               — execute the default agent
  */
 export declare function httpHarness(router: AgentRouter): HttpHarness;
+/**
+ * Default export consumed by the rill CLI (`rill install --replace`,
+ * `rill run`) when this package is declared as a bundle harness. `serve`
+ * assembles a router from the bundle's compiled packages and hosts it over the
+ * HTTP harness on `config.port` (default 3000).
+ */
+declare const harness: RillHarness;
+
+export {
+	harness as default,
+};
 
 export {};

package/dist/index.js

@@ -1,7 +1,14 @@
 // src/index.ts
-import { validateParams, routerErrorToStatus } from "@rcrsr/rill-agent";
+import {
+  validateParams,
+  routerErrorToStatus,
+  createRouter,
+  assembleManifest
+} from "@rcrsr/rill-agent";
 
 // ../../shared/hono-kit/src/index.ts
+import { existsSync } from "fs";
+import path from "path";
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
 function assertJsonObject(parsed) {
@@ -17,23 +24,67 @@ function createHarnessLifecycle(options) {
     if (server !== void 0) {
       throw new Error("Server is already listening");
     }
-    return new Promise((resolve) => {
-      server = serve({ fetch: app.fetch, port }, () => {
-        options?.serverTweaks?.(server);
+    return new Promise((resolve, reject) => {
+      const started = serve({ fetch: app.fetch, port }, () => {
+        started.off("error", onError);
+        options?.serverTweaks?.(started);
         resolve();
       });
+      function onError(err) {
+        server = void 0;
+        reject(err);
+      }
+      started.once("error", onError);
+      server = started;
     });
   }
   async function close() {
-    if (server !== void 0) {
-      server.close();
-      server = void 0;
+    if (server === void 0) return;
+    const current = server;
+    server = void 0;
+    if ("closeAllConnections" in current) {
+      current.closeAllConnections();
     }
+    await new Promise((resolve, reject) => {
+      current.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
   }
   return { app, listen, close };
 }
+function compiledPackageEntries(ctx) {
+  return ctx.packages.map((p) => ({
+    name: p.mount,
+    dir: p.buildOutput.outputPath
+  }));
+}
+function readHarnessPort(config, fallback) {
+  const p = config["port"];
+  if (typeof p === "number" && Number.isInteger(p)) return p;
+  if (typeof p === "string" && /^\d+$/.test(p)) return Number(p);
+  return fallback;
+}
+function assertCompiledHandlers(ctx) {
+  for (const pkg of ctx.packages) {
+    const handlerPath = path.join(pkg.buildOutput.outputPath, "handler.js");
+    if (!existsSync(handlerPath)) {
+      throw new Error(`missing handler file: ${handlerPath}`);
+    }
+  }
+}
+async function runRillServe(ctx, start) {
+  const handle = await start(compiledPackageEntries(ctx));
+  ctx.onShutdown(async () => {
+    await handle.close();
+  });
+  return new Promise(() => {
+  });
+}
 
 // src/index.ts
+var HARNESS_NAME = "@rcrsr/rill-agent-http";
 function httpHarness(router) {
   const lifecycle = createHarnessLifecycle();
   const { app } = lifecycle;
@@ -46,8 +97,7 @@ function httpHarness(router) {
     }));
     return c.json({ agents });
   });
-  app.post("/agents/:name/run", async (c) => {
-    const name = c.req.param("name");
+  async function handleRun(c, name) {
     let body;
     try {
       const parsed = await c.req.json();
@@ -55,14 +105,32 @@ function httpHarness(router) {
     } catch {
       return c.json({ error: "Request body must be a JSON object" }, 400);
     }
-    const params = body["params"] ?? {};
+    let params;
+    try {
+      params = body["params"] === void 0 ? {} : assertJsonObject(body["params"]);
+    } catch {
+      return c.json({ error: 'Parameter "params" must be a JSON object' }, 400);
+    }
     const validationError = validateParams(params, name, router);
     if (validationError !== null) {
       return c.json({ error: validationError }, 400);
     }
+    const rawTimeout = body["timeout"];
+    let timeout;
+    if (rawTimeout !== void 0) {
+      if (typeof rawTimeout !== "number" || !Number.isFinite(rawTimeout) || rawTimeout <= 0) {
+        return c.json(
+          {
+            error: 'Parameter "timeout" must be a finite number greater than 0'
+          },
+          400
+        );
+      }
+      timeout = rawTimeout;
+    }
     const request = {
       params,
-      ...typeof body["timeout"] === "number" ? { timeout: body["timeout"] } : {}
+      ...timeout !== void 0 ? { timeout } : {}
     };
     try {
       const response = await router.run(name, request);
@@ -72,38 +140,30 @@ function httpHarness(router) {
       const message = err instanceof Error ? err.message : String(err);
       return c.json({ error: message }, status);
     }
-  });
-  app.post("/run", async (c) => {
-    let body;
-    try {
-      const parsed = await c.req.json();
-      body = assertJsonObject(parsed);
-    } catch {
-      return c.json({ error: "Request body must be a JSON object" }, 400);
-    }
-    const params = body["params"] ?? {};
-    const defaultName = router.defaultAgent();
-    const validationError = validateParams(params, defaultName, router);
-    if (validationError !== null) {
-      return c.json({ error: validationError }, 400);
-    }
-    const request = {
-      params,
-      ...typeof body["timeout"] === "number" ? { timeout: body["timeout"] } : {}
-    };
-    try {
-      const response = await router.run("", request);
-      return c.json(response);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return c.json({ error: message }, 500);
-    }
-  });
+  }
+  app.post("/agents/:name/run", (c) => handleRun(c, c.req.param("name")));
+  app.post("/run", (c) => handleRun(c, ""));
   async function listen(port = 3e3) {
     return lifecycle.listen(port);
   }
   return { listen, close: lifecycle.close, app };
 }
+var harness = {
+  name: HARNESS_NAME,
+  postBuild: async (ctx) => {
+    assertCompiledHandlers(ctx);
+  },
+  serve: (ctx) => runRillServe(ctx, async (entries) => {
+    const router = await createRouter(await assembleManifest(entries));
+    const server = httpHarness(router);
+    const port = readHarnessPort(ctx.config, 3e3);
+    await server.listen(port);
+    ctx.logger.info(`[${HARNESS_NAME}] listening on :${port}`);
+    return server;
+  })
+};
+var index_default = harness;
 export {
+  index_default as default,
   httpHarness
 };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@rcrsr/rill-agent-http",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "rill agent HTTP harness — Hono-based HTTP server wrapping AgentRouter",
   "license": "MIT",
   "author": "Andre Bremer",
   "type": "module",
+  "rill": {
+    "role": "harness"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -12,14 +15,14 @@
     }
   },
   "dependencies": {
-    "@hono/node-server": "^2.0.1",
-    "hono": "^4.12.16",
-    "@rcrsr/rill-agent": "~0.19.0"
+    "@hono/node-server": "^2.1.1",
+    "@rcrsr/rill-agent": "~0.21.0",
+    "hono": "^4.13.7"
   },
   "devDependencies": {
+    "@rcrsr/rill-agent-hono-kit": "^0.21.0",
     "dts-bundle-generator": "^9.5.1",
-    "tsup": "^8.5.0",
-    "@rcrsr/rill-agent-hono-kit": "^0.19.0"
+    "tsup": "^8.5.1"
   },
   "files": [
     "dist"
@@ -36,7 +39,7 @@
     "build": "tsup && dts-bundle-generator --config dts-bundle-generator.config.cjs && node -e \"const fs=require('fs');const walk=(d)=>fs.readdirSync(d,{withFileTypes:true}).flatMap(e=>e.isDirectory()?walk(d+'/'+e.name):[d+'/'+e.name]);const hits=walk('dist').filter(f=>fs.readFileSync(f,'utf8').includes('@rcrsr/rill-agent-hono-kit'));if(hits.length){console.error('hono-kit leak in dist:',hits);process.exit(1);}\"",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint --config ../../../eslint.config.js src/",
+    "lint": "oxlint --config ../../../.oxlintrc.json src/ tests/",
     "check": "pnpm run build && pnpm run test && pnpm run lint"
   }
 }