@t4h.framework/dev 0.0.0-experimental-5535fb8-124ed92bbb5f8ca2e9fd

package/.ai/skills/framework-dev/SKILL.md

@@ -0,0 +1,346 @@
+---
+name: framework-dev
+description: >-
+  Local development runtime for T4H Framework apps via @t4h.framework/dev:
+  DevServer (TypeScript watch, forked app process, JSON-RPC IPC), dev claim
+  providers (ORM, HTTP, FS, cache, SMTP, workflow engine), workflow runs, env
+  vars, and async activity advancement. Use when implementing or debugging
+  framework dev, embedding DevServer, importing @t4h.framework/dev/build for
+  tsBuild/tsBuildWatch/upApp, wiring dev claims in tests, isWorkflowWaiting,
+  findClaimByConstructor, db.json ORM persistence, or understanding how
+  framework dev / framework build work under @t4h.framework/cli.
+---
+
+# @t4h.framework/dev
+
+Local development runtime for [T4H Framework](https://github.com/tech4humans-brasil/framework) apps. Watches TypeScript, compiles the project, forks a child process that loads the user's `App`, and runs workflows with in-memory or local claim implementations — no external runtime infrastructure.
+
+| Import | Purpose |
+|--------|---------|
+| `@t4h.framework/dev` | `DevServer`, `claims`, dev claim classes, `findClaimByConstructor`, `isWorkflowWaiting` |
+| `@t4h.framework/dev/build` | `tsBuild`, `tsBuildWatch`, `upApp`, path resolvers, `mkdirOutDirProjectFromTsConfigPathAndJsonPackagePath` |
+
+Node `>=22`. ESM (`"type": "module"`). Authoritative docs: `packages/dev/README.md` and source under `packages/dev/src/`.
+
+Interactive CLI (`framework dev`, `framework build`) lives in **`@t4h.framework/cli`** — see `packages/cli/.ai/skills/framework-cli/SKILL.md` for flags and menus. This skill covers the **dev package API and behavior**.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart TB
+  subgraph parent ["Parent (DevServer)"]
+    Watch["tsBuildWatch"]
+    RPCClient["JSON-RPC client"]
+    Watch -->|"onSuccess"| Fork
+    Fork["fork(app-process)"]
+    Fork --> RPCClient
+  end
+
+  subgraph child ["Child (app-process worker)"]
+    App["User App via upApp"]
+    RPCServer["JSON-RPC server"]
+    Claims["claims registry"]
+    App --> RPCServer
+    Claims --> App
+  end
+
+  RPCClient <-->|"IPC messages"| RPCServer
+```
+
+1. **Parent** — `DevServer.start()` resolves paths, creates a temp out dir, starts `tsBuildWatch`.
+2. **On successful compile** — kills prior child, forks `src/workers/app-process.js` with compiled entry URL and `NAME=value` env args.
+3. **Child** — `upApp(entrypoint)` loads `App`, registers RPC handlers from `DevServerJsonRpc`, notifies parent with `manifest`.
+4. **Parent drives** — workflows, env, async advancement via `JSONRPCClient.call(...)`.
+
+Rebuild on file change restarts the child (CLI aborts in-flight prompts on manifest reload).
+
+---
+
+## App project requirements
+
+| Requirement | Detail |
+|-------------|--------|
+| `package.json` `main` | Non-empty string (compiled JS path relative to `dist/`) |
+| `tsconfig.json` | Beside `package.json` (`resolveTsconfigFromPackageJsonPath`) |
+| App export | `default` instance of `App` **or** named `app` (`upApp` throws `App not found` otherwise) |
+| Peer deps | Match app imports: `@t4h.framework/core`, `cache`, `fs`, `http`, `orm`, `smtp`, `runtime-claims` |
+
+Typical app script (via CLI):
+
+```json
+{
+  "main": "main.js",
+  "scripts": {
+    "dev": "framework dev --env-file-if-exists=.env"
+  },
+  "devDependencies": {
+    "@t4h.framework/cli": "workspace:^"
+  }
+}
+```
+
+Install dev package directly only for **programmatic** embedding:
+
+```bash
+yarn add -D @t4h.framework/dev
+```
+
+---
+
+## DevServer (programmatic)
+
+```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',
+})
+
+await devServer.setEnv('API_KEY', 'new-value')
+const env = await devServer.listEnv()
+
+const pending = await devServer.listWaitingAsyncActivities()
+await devServer.advanceAsyncActivity(pending[0].id, { approved: true })
+```
+
+### `DevServerConfig`
+
+| Field | Type | Role |
+|-------|------|------|
+| `entrypoint` | `string` | Path to `package.json` or directory containing it |
+| `env` | `Record<string, string>` | Initial env passed to child as `NAME=value` argv |
+
+### Methods
+
+| Method | RPC / behavior |
+|--------|----------------|
+| `start()` | Resolve paths, temp out dir, `tsBuildWatch`; fork child on first successful build |
+| `runWorkflow(workflowId, input)` | `workflow.run` |
+| `setEnv(name, value)` | `env.set` |
+| `listEnv()` | `env.list` → `Record<string, string>` |
+| `listWaitingAsyncActivities()` | `workflow.async-activities.waiting.list` |
+| `advanceAsyncActivity(id, payload)` | `workflow.async-activities.advance` |
+
+Compile overrides in `DevServer` (same as `framework build`): `outDir: <temp>/dist`, `sourceMap: true`, `declaration: false`.
+
+---
+
+## Workflow run results
+
+`BuildWorkflowRunResultService.build(run)` shapes RPC results:
+
+| Run state | Returned value |
+|-----------|----------------|
+| `fulfilled` | `run.output` |
+| `rejected` | `{ error: run.rejectedReason }` |
+| pending async activity | `{ isWaiting: true, id: string }` (activity id) |
+| otherwise | `{ isWaiting: false }` |
+
+Detect waiting results in tooling:
+
+```typescript
+import { isWorkflowWaiting } from '@t4h.framework/dev'
+
+if (isWorkflowWaiting(result)) {
+  console.log(`Paused; advance activity id: ${result.id}`)
+}
+```
+
+The CLI uses this for the same guidance after **Run workflow**.
+
+---
+
+## JSON-RPC surface (child handlers)
+
+Defined in `src/transport/DevServerJsonRpc.ts`:
+
+| Method | Params | Behavior |
+|--------|--------|----------|
+| `workflow.run` | `workflowId`, `input` | Create run, `nextTick`, return built result |
+| `workflow.async-activities.advance` | `id`, `payload` | Advance pending async activity |
+| `workflow.async-activities.waiting.list` | — | Pending activities with `id`, `workflowId`, optional `schema` |
+| `env.set` | `name`, `value` | Update child env `Map` (scoped via `Env.run`) |
+| `env.list` | — | `Object.fromEntries(env)` |
+
+Parent receives `manifest` notification from child (`app.toManifest()`, workflow ids default to `:index` when missing).
+
+---
+
+## Build pipeline (`@t4h.framework/dev/build`)
+
+Used by `framework build` and internally by `DevServer`. Mirror imports from `packages/cli/src/commands/build/build.ts`:
+
+```typescript
+import path from 'node:path'
+import {
+  mkdirOutDirProjectFromTsConfigPathAndJsonPackagePath,
+  resolvePackageJsonPath,
+  resolveTsconfigFromPackageJsonPath,
+  tsBuild,
+  upApp,
+} from '@t4h.framework/dev/build'
+```
+
+### Steps (`framework build`)
+
+1. `resolvePackageJsonPath(entrypoint)` — file or directory; throws if missing.
+2. `resolveTsconfigFromPackageJsonPath` — `<packageDir>/tsconfig.json` must exist.
+3. `mkdirOutDirProjectFromTsConfigPathAndJsonPackagePath` — creates `<tsconfigDir>/.temp/<random>/`, copies `package.json`; may `process.send({ type: 'outDir', data })` when IPC parent exists.
+4. `tsBuild(tsconfigPath, { outDir: join(outDir, 'dist'), sourceMap: true, declaration: false, declarationMap: false })` — returns `{ ok, diagnostics, parsed }`; throw on `!ok`.
+5. `Env.run(env, () => upApp(join(outDir, 'dist', packageJson.main)))` then `app.toManifest()` → `manifest.json` in out dir.
+
+### `tsBuild` vs `tsBuildWatch`
+
+| Function | Use |
+|----------|-----|
+| `tsBuild` | One-shot compile (`framework build`) |
+| `tsBuildWatch` | Watch mode with `onSuccess`, `onFail`, `onStatus`; returns `{ close() }` watcher |
+
+### `upApp(appPath)`
+
+```typescript
+const module = await import(appPath)
+if (module.default instanceof App) return module.default
+if (module.app instanceof App) return module.app
+throw new Error('App not found')
+```
+
+Tests: `src/tools/__tests__/up-app.spec.ts`.
+
+---
+
+## Dev claims
+
+Registry: `export const claims` in `src/claims.ts` (`ClaimProvider[]` for `App` / `WorkflowTesting`).
+
+```typescript
+import { claims, findClaimByConstructor } from '@t4h.framework/dev'
+import { DevHttpClientRequestClaim } from '@t4h.framework/dev'
+
+const httpClaim = findClaimByConstructor(DevHttpClientRequestClaim)
+```
+
+| Claim constructor | Dev class | Behavior (from source) |
+|-------------------|-----------|------------------------|
+| `ORMClaim` | `DevORMClaim` | In-memory DB persisted to **`db.json`** in `process.cwd()` |
+| `HttpClientRequestClaim` | `DevHttpClientRequestClaim` | Real HTTP via **`undici`** (`request`, redirects) |
+| `FileSystemClaim` | `DevFileSystemClaim` | Local FS; writes under temp dir; `DevFileBinary` codec |
+| `SmtpSendEmailClaim` | `DevSmtpSendEmailClaim` | **`nodemailer`** transport from `connectionString` URL |
+| `WorkflowClaim` | `DevWorkflowClaim` | Local workflow runs via `WorkflowRunFacade` (nested `startWorkflow`) |
+| `CacheClaim` | `DevCacheClaim` | In-memory `Map` (process lifetime) |
+| `SftpClaim` | `DevSftpClaim` | Real SFTP via **`ssh2-sftp-client`** |
+| `GetActivityUniqueIdentifierClaim` | `DevGetActivityUniqueIdentifierClaim` | Dev identifiers |
+| `GetWorkflowUniqueIdentifierClaim` | `DevGetWorkflowUniqueIdentifierClaim` | Dev identifiers |
+| `GetProjectUniqueIdentifierClaim` | `DevGetProjectUniqueIdentifierClaim` | Dev identifiers |
+| `GetProjectVersionUniqueIdentifierClaim` | `DevGetProjectVersionUniqueIdentifierClaim` | Dev identifiers |
+| `GetProjectVersionWorkflowUniqueIdentifierClaim` | `DevGetProjectVersionWorkflowUniqueIdentifierClaim` | Dev identifiers |
+
+Exported claim classes (main entry): see `src/index.ts` — not every registry entry has a dedicated public export; use `claims` or `findClaimByConstructor` for tests.
+
+`DevWorkflowClaim.start` requires `workflow.id`; supports parent run context via `RuntimeContextService`.
+
+---
+
+## Testing with dev claims
+
+Prefer `@t4h.framework/core/testing` (`WorkflowTesting`) for unit tests. For integration-style tests that need real dev claim behavior:
+
+```typescript
+import { claims, DevHttpClientRequestClaim, findClaimByConstructor } from '@t4h.framework/dev'
+import { WorkflowTesting } from '@t4h.framework/core/testing'
+
+const httpClaim = findClaimByConstructor(DevHttpClientRequestClaim)
+vi.spyOn(httpClaim, 'request')
+
+await WorkflowTesting.run(MyWorkflow, input, { claims })
+```
+
+Pattern referenced in commented `examples/basic/src/workflows/__tests__/simple.spec.ts`.
+
+RPC handler tests: `src/transport/__tests__/DevServerJsonRpc.spec.ts`. Result shaping: `src/services/__tests__/BuildWorkflowRunResult.service.spec.ts`. Async fixtures: `src/__tests__/fixtures.ts` (`TestAsyncActivity` with `pending` / `advance`).
+
+---
+
+## Package layout (for contributors)
+
+```
+packages/dev/src/
+├── DevServer.ts              # Parent orchestration
+├── claims.ts                 # ClaimProvider registry
+├── workers/app-process.ts    # Child entry (fork target)
+├── transport/DevServerJsonRpc.ts
+├── tools/                    # build, watch, upApp, resolvers
+├── models/claims/            # Dev*Claim implementations
+├── services/                 # WorkflowRunFacade, BuildWorkflowRunResult, …
+├── use-cases/                # CreateWorkflowRun, async advance, …
+└── repositories/             # In-memory workflow run stores
+```
+
+Develop the package:
+
+```bash
+cd packages/dev
+yarn build
+yarn test           # vitest
+yarn check-types
+```
+
+`vitest.setup.ts` loads `reflect-metadata` (pleroma DI).
+
+---
+
+## Common mistakes (do not invent APIs)
+
+| Mistake | Reality |
+|---------|---------|
+| Export plain object instead of `App` | `upApp` throws `App not found` |
+| Missing `tsconfig.json` next to `package.json` | `resolveTsconfigFromPackageJsonPath` throws |
+| Missing or non-string `package.json` `main` | `DevServer` / build throw |
+| Expecting SMTP captured in memory | `DevSmtpSendEmailClaim` sends via nodemailer using the activity connection string |
+| Expecting mock HTTP in dev | `DevHttpClientRequestClaim` performs real outbound HTTP |
+| ORM data lost between runs | Data lives in **`db.json`** under cwd (deleted only if you remove the file) |
+| Wrong waiting-result shape | Use `isWorkflowWaiting` — checks `isWaiting === true` and string `id` |
+| Import build tools from main entry | Use `@t4h.framework/dev/build` for `tsBuild`, `upApp`, resolvers |
+| Assume all JSON Schema types in CLI prompts | CLI only handles `object`, `string`, `number` (see framework-cli skill) |
+| Add RPC methods without updating both sides | Parent `DevServer` client calls must match child `handlers` in `DevServerJsonRpc.ts` |
+
+---
+
+## Quick reference
+
+```bash
+# Via CLI (requires @t4h.framework/cli)
+framework dev --entrypoint ./package.json -e API_KEY=secret
+framework dev --env-file-if-exists=.env
+framework build --entrypoint ./package.json -e MY_VAR=value
+```
+
+```typescript
+// Programmatic dev loop
+import { DevServer, isWorkflowWaiting } from '@t4h.framework/dev'
+
+// Build-only tooling
+import { tsBuild, upApp } from '@t4h.framework/dev/build'
+
+// Test / custom App wiring
+import { claims, findClaimByConstructor, DevORMClaim } from '@t4h.framework/dev'
+```
+
+For CLI menus, publish IPC, and binary relaunch behavior, use **`framework-cli`** skill. For workflow/activity authoring, use **`framework-core`** skill.

package/README.md

@@ -0,0 +1,172 @@
+# @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.
+
+## 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.
+
+```mermaid
+flowchart TB
+  subgraph parent ["Parent process (DevServer)"]
+    Watch["TypeScript watch"]
+    RPCClient["JSON-RPC client"]
+    Watch -->|"build success"| Fork
+    Fork["fork()"]
+    Fork --> RPCClient
+  end
+
+  subgraph child ["Child process (app-process worker)"]
+    App["User App"]
+    RPCServer["JSON-RPC server"]
+    Claims["Dev claims"]
+    App --> RPCServer
+    Claims --> App
+  end
+
+  RPCClient <-->|"IPC / JSON-RPC"| RPCServer
+```
+
+## Installation
+
+This package is typically consumed as a dependency of `@t4h.framework/cli`:
+
+```bash
+yarn add -D @t4h.framework/cli
+```
+
+To use it programmatically:
+
+```bash
+yarn add -D @t4h.framework/dev
+```
+
+### Peer dependencies
+
+`@t4h.framework/dev` requires the same framework packages your app uses:
+
+- `@t4h.framework/core`
+- `@t4h.framework/cache`
+- `@t4h.framework/fs`
+- `@t4h.framework/http`
+- `@t4h.framework/orm`
+- `@t4h.framework/smtp`
+- `@t4h.framework/runtime-claims`
+
+## CLI usage
+
+Add a dev script to your project's `package.json`:
+
+```json
+{
+  "scripts": {
+    "dev": "framework dev"
+  }
+}
+```
+
+Then run:
+
+```bash
+yarn dev
+```
+
+### 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 | — |
+
+Example with env vars:
+
+```bash
+framework dev --entrypoint ./package.json -e API_KEY=secret -e DB_HOST=localhost
+```
+
+## Programmatic usage
+
+You can embed `DevServer` in your own tooling instead of using the interactive CLI:
+
+```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,
+})
+
+await devServer.setEnv('API_KEY', 'new-value')
+const env = await devServer.listEnv()
+
+const pending = await devServer.listWaitingAsyncActivities()
+await devServer.advanceAsyncActivity(pending[0].id, { approved: true })
+```
+
+### DevServer API
+
+| 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. |
+
+## 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 |
+
+Import the full claim registry:
+
+```typescript
+import { claims } from '@t4h.framework/dev'
+```
+
+Or import individual claim classes:
+
+```typescript
+import {
+  DevORMClaim,
+  DevHttpClientRequestClaim,
+  DevFileSystemClaim,
+  findClaimByConstructor,
+} from '@t4h.framework/dev'
+```
+
+## Requirements
+
+- Node.js >= 22
+- A T4H Framework `App` exported from your project's entry point (`default` or named `app` export)
+
+## License
+
+MIT

package/dist/DevServer.d.ts

@@ -0,0 +1,24 @@
+import type { App } from '@t4h.framework/core';
+export interface DevServerConfig {
+    entrypoint: string;
+    env: Record<string, string>;
+}
+export declare class DevServer {
+    private readonly config;
+    private readonly onAppManifest;
+    private tsBuildWatcher;
+    private packageJsonPath;
+    private tsConfigPath;
+    private outDir;
+    private app;
+    private jsonRpcServer;
+    private jsonRpcClient;
+    constructor(config: DevServerConfig, onAppManifest: (manifest: ReturnType<App['toManifest']>) => void);
+    start(): Promise<void>;
+    protected onTsBuildSuccess(): Promise<void>;
+    runWorkflow(workflowId: string, input: any): Promise<any>;
+    setEnv(name: string, value: string): Promise<any>;
+    listEnv(): Promise<any>;
+    listWaitingAsyncActivities(): Promise<any>;
+    advanceAsyncActivity(id: string, payload: unknown): Promise<any>;
+}

package/dist/DevServer.js

@@ -0,0 +1,87 @@
+import { ChildProcess, fork } from 'node:child_process';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import Type from 'typebox';
+import { JSONRPCClient } from './models/JSONRPCClient.js';
+import { JSONRPCServer, JSONRPCServerMethod } from './models/JSONRPCServer.js';
+import { mkdirOutDirProjectFromTsConfigPathAndJsonPackagePath } from './tools/mkdir-out-dir-project-from-ts-config-path-and-json-package-path.js';
+import { resolvePackageJsonPath } from './tools/resolve-package-json-path.js';
+import { resolveTsconfigFromPackageJsonPath } from './tools/resolve-tsconfig-path-from-package-json-path.js';
+import { tsBuildWatch } from './tools/ts-build-watch.js';
+export class DevServer {
+    config;
+    onAppManifest;
+    tsBuildWatcher;
+    packageJsonPath;
+    tsConfigPath;
+    outDir;
+    app;
+    jsonRpcServer;
+    jsonRpcClient;
+    constructor(config, onAppManifest) {
+        this.config = config;
+        this.onAppManifest = onAppManifest;
+        this.jsonRpcServer = new JSONRPCServer([
+            new JSONRPCServerMethod('manifest', { schema: [Type.Any()] }, manifest => this.onAppManifest(manifest)),
+        ], message => {
+            this.app?.send(message);
+        });
+        this.jsonRpcClient = new JSONRPCClient(message => {
+            this.app?.send(message);
+        });
+    }
+    async start() {
+        this.packageJsonPath = await resolvePackageJsonPath(this.config.entrypoint);
+        this.tsConfigPath = await resolveTsconfigFromPackageJsonPath(this.packageJsonPath);
+        this.outDir = await mkdirOutDirProjectFromTsConfigPathAndJsonPackagePath(this.tsConfigPath, this.packageJsonPath);
+        this.tsBuildWatcher = tsBuildWatch(this.tsConfigPath, {
+            outDir: path.join(this.outDir, 'dist'),
+            sourceMap: true,
+            declaration: false,
+            declarationMap: false,
+        }, {
+            onSuccess: () => this.onTsBuildSuccess(),
+            onFail(diagnostics) {
+                console.error('[DevServer] ts build failed:', diagnostics);
+            },
+            onStatus(status) {
+                console.log('[DevServer] ts build status:', status);
+            },
+        });
+    }
+    async onTsBuildSuccess() {
+        if (this.app) {
+            this.app.kill();
+        }
+        const { default: packageJson } = await import(this.packageJsonPath, {
+            with: { type: 'json' },
+        });
+        if (typeof packageJson.main !== 'string')
+            throw new Error('Main is not a string');
+        const entrypoint = pathToFileURL(path.join(this.outDir, 'dist', packageJson.main)).href;
+        this.app = fork(path.join(import.meta.dirname, 'workers', 'app-process.js'), [
+            entrypoint,
+            ...Object.entries(this.config.env).map(([name, value]) => `${name}=${value}`),
+        ], { stdio: ['ignore', 'inherit', 'inherit', 'ipc'] });
+        this.app.on('message', message => Promise.all([
+            this.jsonRpcServer.handle(message),
+            this.jsonRpcClient.handle(message),
+        ]));
+    }
+    async runWorkflow(workflowId, input) {
+        return await this.jsonRpcClient.call('workflow.run', workflowId, input);
+    }
+    async setEnv(name, value) {
+        return await this.jsonRpcClient.call('env.set', name, value);
+    }
+    async listEnv() {
+        return await this.jsonRpcClient.call('env.list');
+    }
+    async listWaitingAsyncActivities() {
+        return await this.jsonRpcClient.call('workflow.async-activities.waiting.list');
+    }
+    async advanceAsyncActivity(id, payload) {
+        return await this.jsonRpcClient.call('workflow.async-activities.advance', id, payload);
+    }
+}
+//# sourceMappingURL=DevServer.js.map

package/dist/DevServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevServer.js","sourceRoot":"","sources":["../src/DevServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAGxC,OAAO,IAAI,MAAM,SAAS,CAAA;AAE1B,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AACzD,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAC9E,OAAO,EAAE,oDAAoD,EAAE,MAAM,4EAA4E,CAAA;AACjJ,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAA;AAC7E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yDAAyD,CAAA;AAC5G,OAAO,EAAE,YAAY,EAAuB,MAAM,2BAA2B,CAAA;AAO7E,MAAM,OAAO,SAAS;IAUD;IACA;IAVX,cAAc,CAAiB;IAC/B,eAAe,CAAS;IACxB,YAAY,CAAS;IACrB,MAAM,CAAS;IACf,GAAG,CAAe;IAClB,aAAa,CAAgB;IAC7B,aAAa,CAAgB;IAErC,YACmB,MAAuB,EACvB,aAER;QAHQ,WAAM,GAAN,MAAM,CAAiB;QACvB,kBAAa,GAAb,aAAa,CAErB;QAET,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CACpC;YACE,IAAI,mBAAmB,CACrB,UAAU,EACV,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAU,EAAE,EACjC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CACzC;SACF,EACD,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;QACzB,CAAC,CACF,CAAA;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC,OAAO,CAAC,EAAE;YAC/C,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;QACzB,CAAC,CAAC,CAAA;IACJ,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,eAAe,GAAG,MAAM,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAE3E,IAAI,CAAC,YAAY,GAAG,MAAM,kCAAkC,CAC1D,IAAI,CAAC,eAAe,CACrB,CAAA;QAED,IAAI,CAAC,MAAM,GAAG,MAAM,oDAAoD,CACtE,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,eAAe,CACrB,CAAA;QAED,IAAI,CAAC,cAAc,GAAG,YAAY,CAChC,IAAI,CAAC,YAAY,EACjB;YACE,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;YACtC,SAAS,EAAE,IAAI;YACf,WAAW,EAAE,KAAK;YAClB,cAAc,EAAE,KAAK;SACtB,EACD;YACE,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACxC,MAAM,CAAC,WAAW;gBAChB,OAAO,CAAC,KAAK,CAAC,8BAA8B,EAAE,WAAW,CAAC,CAAA;YAC5D,CAAC;YACD,QAAQ,CAAC,MAAM;gBACb,OAAO,CAAC,GAAG,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAAA;YACrD,CAAC;SACF,CACF,CAAA;IACH,CAAC;IAES,KAAK,CAAC,gBAAgB;QAC9B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAA;QACjB,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE;YAClE,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;SACvB,CAAC,CAAA;QAEF,IAAI,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ;YACtC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;QAEzC,MAAM,UAAU,GAAG,aAAa,CAC9B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,IAAI,CAAC,CACjD,CAAC,IAAI,CAAA;QAEN,IAAI,CAAC,GAAG,GAAG,IAAI,CACb,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,gBAAgB,CAAC,EAC3D;YACE,UAAU;YACV,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CACpC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CACtC;SACF,EACD,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,CACnD,CAAA;QAED,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAC/B,OAAO,CAAC,GAAG,CAAC;YACV,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC;YAClC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC;SACnC,CAAC,CACH,CAAA;IACH,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,UAAkB,EAAE,KAAU;QACrD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,cAAc,EAAE,UAAU,EAAE,KAAK,CAAC,CAAA;IACzE,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,IAAY,EAAE,KAAa;QAC7C,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,CAAA;IAC9D,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;IAClD,CAAC;IAEM,KAAK,CAAC,0BAA0B;QACrC,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAClC,wCAAwC,CACzC,CAAA;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAAC,EAAU,EAAE,OAAgB;QAC5D,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAClC,mCAAmC,EACnC,EAAE,EACF,OAAO,CACR,CAAA;IACH,CAAC;CACF"}

package/dist/__tests__/fixtures.d.ts

@@ -0,0 +1,57 @@
+import { AsyncActivity, SyncActivity } from '@t4h.framework/core';
+import Type from 'typebox';
+export declare class TestSyncActivity extends SyncActivity<[
+], {
+    value: string;
+}, {
+    result: string;
+}, {
+    result: string;
+}> {
+    toInput(): {
+        value: string;
+    };
+    run(input: {
+        value: string;
+    }): {
+        result: string;
+    };
+    toOutput(output: {
+        result: string;
+    }): {
+        result: string;
+    };
+}
+declare const TestAsyncSchema: Type.TObject<{
+    approved: Type.TBoolean;
+}>;
+export declare class TestAsyncActivity extends AsyncActivity<[
+], {
+    value: string;
+}, {
+    approved: boolean;
+}, {
+    approved: boolean;
+}, {
+    requestId: string;
+}, typeof TestAsyncSchema> {
+    toInput(): {
+        value: string;
+    };
+    bootstrap(): import("@t4h.framework/core").AsyncActivityResultPending<{
+        requestId: string;
+    }, Type.TObject<{
+        approved: Type.TBoolean;
+    }>>;
+    advance(payload: {
+        approved: boolean;
+    }): import("@t4h.framework/core").AsyncActivityResultFulfilled<{
+        approved: boolean;
+    } | undefined>;
+    toOutput(output: {
+        approved: boolean;
+    }): {
+        approved: boolean;
+    };
+}
+export {};