@t4h.framework/dev 0.14.2 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @t4h.framework/dev
 
+## 0.16.0
+
+### Minor Changes
+
+- [#151](https://github.com/tech4humans-brasil/framework/pull/151) [`d44eb5e`](https://github.com/tech4humans-brasil/framework/commit/d44eb5e1797f523612c9e2f560b0bb583ab8688f) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - host owns panel config and run rejection lives in output
+
+### Patch Changes
+
+- Updated dependencies [[`d44eb5e`](https://github.com/tech4humans-brasil/framework/commit/d44eb5e1797f523612c9e2f560b0bb583ab8688f)]:
+  - @t4h.framework/vite-panel-plugin@0.2.0
+
+## 0.15.0
+
+### Minor Changes
+
+- [#145](https://github.com/tech4humans-brasil/framework/pull/145) [`09724c3`](https://github.com/tech4humans-brasil/framework/commit/09724c3f0bb573d55b94495835362e7b66bc570e) Thanks [@gusteycamargo](https://github.com/gusteycamargo)! - Replaces the interactive REPL of `framework dev` with an HTTP dev server: Hono routes workflow (`POST /projects/:projectId/workflows/:workflowId/runs` answers `201 { id }`, `PATCH .../runs/:runId/activities/:activityId` advances a pending async activity), mandatory workflow authorization resolved from the app/workflow `Authorization` manifest, `/_dev` routes for tooling (manifest, runs, waiting activities, env, SSE events) and Vite in middleware mode for a UI. Workflow runs now live in an in-memory SQLite database inside the app process, the ORM dev claim stores its rows in `db.sqlite` instead of rewriting `db.json` on every change, child workflows run in parallel, and `framework dev` gains `--port` (`PORT`) and `--host`. `DevServer` and `isWorkflowWaiting` are gone; use `Server`.
+
+### Patch Changes
+
+- Updated dependencies [[`a3696b4`](https://github.com/tech4humans-brasil/framework/commit/a3696b48b48598eda9e51c53538a6086abe36018), [`a3696b4`](https://github.com/tech4humans-brasil/framework/commit/a3696b48b48598eda9e51c53538a6086abe36018), [`45182d4`](https://github.com/tech4humans-brasil/framework/commit/45182d4a27c86353747646aa9b70a39bc4c56610)]:
+  - @t4h.framework/vite-panel-plugin@0.1.0
+  - @t4h.framework/http@0.4.4
+  - @t4h.framework/oidc@0.5.0
+
 ## 0.14.2
 
 ### Patch Changes

package/README.md

@@ -1,35 +1,38 @@
 # @t4h.framework/dev
 
-Local development runtime for [T4H Framework](https://github.com/tech4humans-brasil/framework) apps. Watches your project, compiles TypeScript, loads your `App`, and executes workflows with in-memory claim implementations — no external infrastructure required.
+Local development runtime for [T4H Framework](https://github.com/tech4humans-brasil/framework) apps. Watches your project, compiles TypeScript, loads your `App` in a child process and exposes it over HTTP with the same routes as the production runtime — no external infrastructure required.
 
 ## What it does
 
 When you run `framework dev` (via `@t4h.framework/cli`), this package powers the experience behind the scenes:
 
 1. **TypeScript watch** — compiles your app on every change.
-2. **App process** — forks a child Node process that loads your compiled `App`.
-3. **JSON-RPC over IPC** — the parent process drives workflows, env vars, and async activity advancement through a typed RPC layer.
-4. **Dev claims** — provides local implementations for ORM, HTTP, file system, cache, SMTP, and more.
+2. **App process** — forks a child Node process that loads your compiled `App` and runs the workflow engine on an in-memory SQLite database.
+3. **HTTP server** — a [Hono](https://hono.dev) app that exposes your workflows (create runs, advance pending activities), enforces the workflow authorization and adds `/_dev` routes for tooling.
+4. **Vite** — a Vite dev server in middleware mode serves the built-in panel and anything else that is not an API route.
+5. **Dev claims** — provides local implementations for ORM, HTTP, file system, cache, SMTP, and more.
 
 ```mermaid
 flowchart TB
-  subgraph parent ["Parent process (DevServer)"]
+  subgraph parent ["Parent process (Server)"]
     Watch["TypeScript watch"]
-    RPCClient["JSON-RPC client"]
-    Watch -->|"build success"| Fork
-    Fork["fork()"]
-    Fork --> RPCClient
+    HTTP["Hono (/projects, /_dev)"]
+    Vite["Vite middlewares (UI)"]
+    Auth["Workflow authorization"]
+    Watch -->|"build success"| Fork["AppProcess.up()"]
+    HTTP --> Auth
   end
 
   subgraph child ["Child process (app-process worker)"]
     App["User App"]
-    RPCServer["JSON-RPC server"]
+    Engine["Workflow engine + SQLite :memory:"]
     Claims["Dev claims"]
-    App --> RPCServer
+    App --> Engine
     Claims --> App
   end
 
-  RPCClient <-->|"IPC / JSON-RPC"| RPCServer
+  Fork --> App
+  HTTP <-->|"IPC / JSON-RPC"| Engine
 ```
 
 ## Installation
@@ -76,13 +79,17 @@ Then run:
 yarn dev
 ```
 
+The server listens right away and prints the routes of every workflow once the first build finishes.
+
 ### Options
 
-| Flag | Description | Default |
-|------|-------------|---------|
-| `--entrypoint <path>` | Path to the project's `package.json` | `./package.json` |
-| `-e, --env <KEY=VALUE>` | Environment variable (repeatable) | — |
-| `--env-file-if-exists <path>` | Load variables from a `.env` file if it exists | — |
+| Flag                          | Description                                                                                                                          | Default          |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ---------------- |
+| `--entrypoint <path>`         | Path to the project's `package.json`                                                                                                 | `./package.json` |
+| `-e, --env <KEY=VALUE>`       | Environment variable (repeatable)                                                                                                    | —                |
+| `--env-file-if-exists <path>` | Load variables from a `.env` file if it exists                                                                                       | —                |
+| `-p, --port <port>`           | HTTP port (also `PORT`); when something already answers on it, on any address of `--host`, the next free port up is taken and logged | `3000`           |
+| `--host <host>`               | HTTP host                                                                                                                            | `localhost`      |
 
 Example with env vars:
 
@@ -90,60 +97,107 @@ Example with env vars:
 framework dev --entrypoint ./package.json -e API_KEY=secret -e DB_HOST=localhost
 ```
 
-## Programmatic usage
+## HTTP routes
+
+The dev server has no tenants and a single live version (the last build), so the routes carry only the project and the workflow. `projectId` must match your `App` id.
+
+| Method  | Route                                                                           | Authorization | Response                   |
+| ------- | ------------------------------------------------------------------------------- | ------------- | -------------------------- |
+| `GET`   | `/projects/:projectId/manifest.json`                                            | no            | `200` the app manifest     |
+| `POST`  | `/projects/:projectId/workflows/:workflowId/runs`                               | yes           | `201 { "id": "<run id>" }` |
+| `PATCH` | `/projects/:projectId/workflows/:workflowId/runs/:runId/activities/:activityId` | yes           | `200 { id, type, status }` |
+
+The `POST` body is the workflow input, validated against the workflow schema (`400` with the validation errors). The `PATCH` body is `{ "payload": ... }`, validated against the pending async activity schema (`400 Payload is invalid`, `400 AsyncActivity is not pending`). Errors use the NestJS shape `{ statusCode, message, error }`; `503` means the app process is still starting.
+
+```bash
+curl -X POST http://localhost:3000/projects/my-app/workflows/my-workflow/runs \
+  -H 'content-type: application/json' \
+  -H 'x-signature: <hmac>' \
+  -d '{ "userId": "123" }'
+```
+
+### Authorization
+
+Every `/projects` route requires an authorization: the workflow `authorization` wins over the app one, its manifest `pathToModule` is imported and its default export receives the manifest `context` templated with the request (`<< headers.x-signature >>`, `<< rawBody >>`, `<< body.id >>`, `<< params.projectId >>`, `<< query.token >>`). A falsy result or a thrown error answers `401`. A workflow without any authorization is refused when the manifest arrives (the server emits `error`) and answers `500` if reached.
+
+`pathToModule` may be `@t4h.framework/hmac/authorize`, `@t4h.framework/jwks/authorize`, `@t4h.framework/oidc/authorize`, an absolute path, a path relative to the project or a `file://` URL.
+
+### Dev routes (no authorization)
 
-You can embed `DevServer` in your own tooling instead of using the interactive CLI:
+| Method | Route                                                                                                               | Description                                                                                                                     |
+| ------ | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `GET`  | `/_dev/manifest`                                                                                                    | App manifest                                                                                                                    |
+| `GET`  | `/_dev/state`                                                                                                       | `{ state: 'idle' \| 'starting' \| 'ready' \| 'exited' }`                                                                        |
+| `GET`  | `/_dev/runs?status=&workflow=&id=&parentRun=&parentActivity=&rootOnly=&createdAfter=&createdBefore=&limit=&offset=` | `{ count, runs }` newest first; `id` is a prefix, `rootOnly=true` hides child runs, `createdAfter`/`createdBefore` are ISO 8601 |
+| `GET`  | `/_dev/runs/:id`                                                                                                    | Run with `input` and `output`; a rejected run carries its reason as `output` (framework tagged JSON)                            |
+| `GET`  | `/_dev/activities/waiting`                                                                                          | Async activities waiting for an advance                                                                                         |
+| `POST` | `/_dev/workflows/:workflowId/runs`                                                                                  | Starts a run without authorization; body is the input, answers `201 { id }`                                                     |
+| `POST` | `/_dev/activities/:activityId/advance`                                                                              | Advances a pending async activity without authorization; body is `{ payload }`                                                  |
+| `GET`  | `/_dev/events`                                                                                                      | SSE: `manifest`, `build:status`, `build:fail`, `app:exit`, `run:created`, `run:updated`                                         |
+
+`run:created` and `run:updated` carry the run summary (the same object `/_dev/runs` lists); updates of one run are coalesced, so a tick that writes several rows produces one event.
+
+Everything else is handed to Vite, which serves the panel that ships with this package: open the base URL to browse the workflows and start runs from their schema, follow runs live with the execution trace of each one (activities as a waterfall, child runs nested, input, output, duration, logs, the activity that failed) and advance waiting activities. Plugins from the project's `vite.config.*` (or `vite.plugins`) are served by the same Vite.
+
+## State
+
+Workflow runs, activities, pending async activities and logs live in an in-memory SQLite database (`node:sqlite`) inside the app process. Every successful build forks a fresh process, so **a rebuild resets all runs, timers and pending activities**; the `manifest` SSE event tells a UI to reload. There is no durability, queue or resume in the dev server by design.
+
+Sync activities run inline, `sleep` and other timers use `setTimeout`, and child workflows started with `startWorkflow` / `startWorkflowMany` run in parallel.
+
+The ORM claim is the exception: its rows live in `db.sqlite` next to your `package.json` and survive rebuilds and restarts (add it to `.gitignore`). Delete the file to start over. The previous `db.json` is no longer read.
+
+## Programmatic usage
 
 ```typescript
-import { DevServer } from '@t4h.framework/dev'
-
-const devServer = new DevServer(
-  {
-    entrypoint: './package.json',
-    env: { API_KEY: 'secret' },
-  },
-  manifest => {
-    console.log('App loaded:', manifest.workflows.map(w => w.id))
-  },
-)
-
-await devServer.start()
-
-const result = await devServer.runWorkflow('my-workflow/v1', {
-  userId: '123',
-  amount: 100,
+import { Server } from '@t4h.framework/dev'
+
+const server = new Server({
+  entrypoint: './package.json',
+  env: { API_KEY: 'secret' },
+  port: 3000,
+  host: 'localhost',
+  vite: { plugins: [myPanelPlugin()] },
+})
+
+server.on('manifest', manifest => {
+  console.log(
+    'App ready:',
+    manifest.workflows.map(workflow => workflow.id),
+  )
 })
 
-await devServer.setEnv('API_KEY', 'new-value')
-const env = await devServer.listEnv()
+const address = await server.up()
+
+console.log(address.url)
 
-const pending = await devServer.listWaitingAsyncActivities()
-await devServer.advanceAsyncActivity(pending[0].id, { approved: true })
+await server.down()
 ```
 
-### DevServer API
+### Server API
+
+| Member     | Description                                                                                                                                              |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `up()`     | Starts HTTP + Vite, then the TypeScript watch; resolves with `{ host, port, url }`. `port` is the one actually bound: a port already in use moves it up. |
+| `down()`   | Stops the watch, the app process, Vite and the HTTP server.                                                                                              |
+| `manifest` | Current app manifest or `null`.                                                                                                                          |
+| `address`  | Listening address (throws before `up()`).                                                                                                                |
+| events     | `manifest`, `build:status`, `build:fail`, `app:exit`, `run:created`, `run:updated`, `error`.                                                             |
 
-| Method | Description |
-|--------|-------------|
-| `start()` | Resolves project paths, starts TypeScript watch, and boots the app process on first successful build. |
-| `runWorkflow(id, input)` | Runs a workflow by id with the given input. |
-| `setEnv(name, value)` | Sets an environment variable in the running app process. |
-| `listEnv()` | Returns all environment variables. |
-| `listWaitingAsyncActivities()` | Lists async activities waiting for manual advancement. |
-| `advanceAsyncActivity(id, payload)` | Advances a pending async activity with the given payload. |
+`vite: false` disables Vite; `vite.root` / `vite.configFile` point at another Vite project. The server logs the listening URL, build output and the routes of every workflow through `logger` (default `console`, `false` to silence). A manifest with a workflow that has no authorization (and no app default) emits `error` with a `WorkflowAuthorizationMissingError`; `framework dev` exits with code 1 in that case.
 
 ## Dev claims
 
 In production, claims are fulfilled by the runtime (database connections, real HTTP clients, etc.). During local development, `@t4h.framework/dev` registers in-memory substitutes:
 
-| Claim | Dev implementation |
-|-------|-------------------|
-| `ORMClaim` | In-memory database |
-| `HttpClientRequestClaim` | Real HTTP via `undici` |
-| `FileSystemClaim` | Local file system with dev binary codec |
-| `SmtpSendEmailClaim` | Captures emails in memory (no delivery) |
-| `CacheClaim` | In-memory cache |
-| `WorkflowClaim` | Runs workflows through the local workflow engine |
+| Claim                    | Dev implementation                                                                                                       |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
+| `ORMClaim`               | SQLite file `db.sqlite` in the project directory; `where` keeps the Mongo-like semantics (`$like`, `$ilike`, `$or`, ...) |
+| `HttpClientRequestClaim` | Real HTTP via `undici`                                                                                                   |
+| `FileSystemClaim`        | Local file system with dev binary codec                                                                                  |
+| `SmtpSendEmailClaim`     | Captures emails in memory (no delivery)                                                                                  |
+| `CacheClaim`             | In-memory cache                                                                                                          |
+| `WorkflowClaim`          | Runs workflows through the local workflow engine                                                                         |
 
 Import the full claim registry:
 
@@ -164,7 +218,7 @@ import {
 
 ## Requirements
 
-- Node.js >= 22
+- Node.js >= 22.13 (`node:sqlite`)
 - A T4H Framework `App` exported from your project's entry point (`default` or named `app` export)
 
 ## License

package/dist/AppProcess.d.ts

@@ -0,0 +1,36 @@
+import { fork } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import type { App } from '@t4h.framework/core';
+export type AppManifest = ReturnType<App['toManifest']>;
+export type AppProcessState = 'idle' | 'starting' | 'ready' | 'exited';
+export declare class AppProcessNotReadyError extends Error {
+    readonly name = "AppProcessNotReadyError";
+}
+export interface AppProcessOptions {
+    workerPath?: string;
+    readyTimeoutInMs?: number;
+    killTimeoutInMs?: number;
+    fork?: typeof fork;
+}
+export declare class AppProcess extends EventEmitter {
+    private readonly workerPath;
+    private readonly readyTimeoutInMs;
+    private readonly killTimeoutInMs;
+    private readonly forkProcess;
+    private readonly server;
+    private child;
+    private client;
+    private ready;
+    private currentManifest;
+    private currentState;
+    constructor({ workerPath, readyTimeoutInMs, killTimeoutInMs, fork: forkProcess, }?: AppProcessOptions);
+    get manifest(): AppManifest | null;
+    get state(): AppProcessState;
+    up(entrypoint: string, env: Record<string, string>): Promise<AppManifest>;
+    down(): Promise<void>;
+    private kill;
+    whenReady(): Promise<AppManifest>;
+    call<T = any>(method: string, ...params: any[]): Promise<T>;
+    private onManifest;
+    private onExit;
+}

package/dist/AppProcess.js

@@ -0,0 +1,126 @@
+import { fork } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import path from 'node:path';
+import { styleText } from 'node:util';
+import Type from 'typebox';
+import { APP_KILL_TIMEOUT_IN_MS, APP_READY_TIMEOUT_IN_MS, WORKFLOW_RUN_EVENTS, } from './constants/server.js';
+import { JSONRPCClient } from './models/JSONRPCClient.js';
+import { JSONRPCServer, JSONRPCServerMethod } from './models/JSONRPCServer.js';
+export class AppProcessNotReadyError extends Error {
+    name = 'AppProcessNotReadyError';
+}
+export class AppProcess extends EventEmitter {
+    workerPath;
+    readyTimeoutInMs;
+    killTimeoutInMs;
+    forkProcess;
+    server;
+    child = null;
+    client = null;
+    ready = null;
+    currentManifest = null;
+    currentState = 'idle';
+    constructor({ workerPath = path.join(import.meta.dirname, 'workers', 'app-process.js'), readyTimeoutInMs = APP_READY_TIMEOUT_IN_MS, killTimeoutInMs = APP_KILL_TIMEOUT_IN_MS, fork: forkProcess = fork, } = {}) {
+        super();
+        this.workerPath = workerPath;
+        this.readyTimeoutInMs = readyTimeoutInMs;
+        this.killTimeoutInMs = killTimeoutInMs;
+        this.forkProcess = forkProcess;
+        this.server = new JSONRPCServer([
+            new JSONRPCServerMethod('manifest', { schema: [Type.Any()] }, (manifest) => this.onManifest(manifest)),
+            ...WORKFLOW_RUN_EVENTS.map(event => new JSONRPCServerMethod(event, { schema: [Type.Any()] }, (payload) => void this.emit(event, payload))),
+        ], message => {
+            this.child?.send(message);
+        });
+    }
+    get manifest() {
+        return this.currentManifest;
+    }
+    get state() {
+        return this.currentState;
+    }
+    async up(entrypoint, env) {
+        const previous = this.child;
+        this.child = null;
+        this.client?.rejectPending(new AppProcessNotReadyError('App process is restarting'));
+        this.client = null;
+        this.ready = Promise.withResolvers();
+        this.ready.promise.catch(() => { });
+        this.currentState = 'starting';
+        await this.kill(previous);
+        const child = this.forkProcess(this.workerPath, [
+            entrypoint,
+            ...Object.entries(env).map(([name, value]) => `${name}=${value}`),
+        ], { stdio: ['ignore', 'inherit', 'inherit', 'ipc'] });
+        const client = new JSONRPCClient(message => {
+            child.send(message);
+        });
+        this.child = child;
+        this.client = client;
+        child.on('message', message => Promise.all([this.server.handle(message), client.handle(message)]).catch(error => {
+            console.error(styleText('red', '[AppProcess] failed to handle message:', {
+                stream: process.stderr,
+            }), error);
+        }));
+        child.on('exit', code => this.onExit(child, code));
+        return this.whenReady();
+    }
+    async down() {
+        await this.kill(this.child);
+    }
+    async kill(child) {
+        if (!child)
+            return;
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        await new Promise(resolve => {
+            const timer = setTimeout(() => child.kill('SIGKILL'), this.killTimeoutInMs);
+            child.once('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            child.kill();
+        });
+    }
+    whenReady() {
+        if (this.currentState === 'ready' && this.currentManifest)
+            return Promise.resolve(this.currentManifest);
+        if (this.currentState !== 'starting' || !this.ready)
+            return Promise.reject(new AppProcessNotReadyError('App process is not running'));
+        const { promise } = this.ready;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new AppProcessNotReadyError(`App process did not become ready in ${this.readyTimeoutInMs}ms`)), this.readyTimeoutInMs);
+            promise.then(manifest => {
+                clearTimeout(timer);
+                resolve(manifest);
+            }, error => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    async call(method, ...params) {
+        await this.whenReady();
+        if (!this.client)
+            throw new AppProcessNotReadyError('App process is not running');
+        return this.client.call(method, ...params);
+    }
+    onManifest(manifest) {
+        this.currentManifest = manifest;
+        this.currentState = 'ready';
+        this.ready?.resolve(manifest);
+        this.emit('manifest', manifest);
+    }
+    onExit(child, code) {
+        if (this.child !== child)
+            return;
+        const error = new AppProcessNotReadyError(`App process exited with code ${code}`);
+        this.child = null;
+        this.currentState = 'exited';
+        this.client?.rejectPending(error);
+        this.client = null;
+        this.ready?.reject(error);
+        this.emit('exit', code);
+    }
+}
+//# sourceMappingURL=AppProcess.js.map

package/dist/AppProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppProcess.js","sourceRoot":"","sources":["../src/AppProcess.ts"],"names":[],"mappings":"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"}

package/dist/Server.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'node:events';
+import type { PluginOption } from 'vite';
+import { type AppManifest } from './AppProcess.js';
+export interface ServerViteOptions {
+    root?: string;
+    configFile?: string | false;
+    plugins?: PluginOption[];
+}
+export type ServerLogger = Pick<Console, 'log' | 'error'>;
+export interface ServerOptions {
+    entrypoint: string;
+    env: Record<string, string>;
+    port?: number;
+    host?: string;
+    vite?: ServerViteOptions | false;
+    logger?: ServerLogger | false;
+}
+export interface ServerAddress {
+    host: string;
+    port: number;
+    url: string;
+}
+export declare class Server extends EventEmitter {
+    private readonly options;
+    private readonly appProcess;
+    private readonly logger;
+    private routes;
+    private tsBuildWatcher;
+    private httpServer;
+    private vite;
+    private currentAddress;
+    private packageJsonPath;
+    private outDir;
+    constructor(options: ServerOptions);
+    get manifest(): AppManifest | null;
+    get address(): ServerAddress;
+    up(): Promise<ServerAddress>;
+    down(): Promise<void>;
+    private onTsBuildSuccess;
+    private createVite;
+}