Replace Rust worker with TS worker in single image
Add ts-worker/ with the Bun/TypeScript worker that replaces claw-profile-worker. The Dockerfile now builds a single image containing both the Rust gateway (claw-telegram) and the TS worker. The image defaults to worker mode (bun run ts-worker/main.ts). The gateway Unraid XML overrides with --entrypoint claw-telegram. Worker containers use the same image with the default CMD. - Add ts-worker/ (12 files): HTTP/SSE server, Anthropic SDK engine, approval broker, event translator, state stores - Add package.json with @anthropic-ai/sdk dependency - Rewrite Dockerfile: three-stage build (Rust + Bun + runtime) - Revert CLAW_GATEWAY_WORKER_IMAGE to claw-telegram:latest - Remove image pull from docker_worker_manager (same image, already local) - Add ts-worker paths to CI trigger Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Wylabb
@@ -9,12 +9,18 @@ on:
|
||||
- .github/workflows/build-telegram.yml
|
||||
- Dockerfile
|
||||
- rust/**
|
||||
- ts-worker/**
|
||||
- package.json
|
||||
- bun.lock*
|
||||
pull_request:
|
||||
branches: [main]
|
||||
paths:
|
||||
- .github/workflows/build-telegram.yml
|
||||
- Dockerfile
|
||||
- rust/**
|
||||
- ts-worker/**
|
||||
- package.json
|
||||
- bun.lock*
|
||||
workflow_dispatch:
|
||||
|
||||
env:
|
||||
|
||||
@@ -6,3 +6,4 @@ archive/
|
||||
# Claude Code local artifacts
|
||||
.claude/settings.local.json
|
||||
.claude/sessions/
|
||||
node_modules/
|
||||
|
||||
+34
-8
@@ -1,21 +1,47 @@
|
||||
# Build stage
|
||||
FROM rust:1.86-bookworm AS builder
|
||||
# Stage 1: Rust build
|
||||
FROM rust:1.86-bookworm AS rust-builder
|
||||
|
||||
WORKDIR /build
|
||||
COPY rust/ .
|
||||
|
||||
RUN cargo build --release --bin claw-telegram
|
||||
|
||||
# Runtime stage
|
||||
# Stage 2: Bun dependency install
|
||||
FROM oven/bun:1.3 AS bun-builder
|
||||
|
||||
WORKDIR /app
|
||||
COPY package.json bun.lock* ./
|
||||
RUN bun install --frozen-lockfile || bun install
|
||||
|
||||
# Stage 3: Runtime
|
||||
FROM debian:bookworm-slim
|
||||
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
ca-certificates \
|
||||
curl \
|
||||
git \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
COPY --from=builder /build/target/release/claw-telegram /usr/local/bin/claw-telegram
|
||||
# Bun runtime
|
||||
COPY --from=oven/bun:1.3 /usr/local/bin/bun /usr/local/bin/bun
|
||||
|
||||
WORKDIR /data
|
||||
# Rust gateway binary
|
||||
COPY --from=rust-builder /build/target/release/claw-telegram /usr/local/bin/claw-telegram
|
||||
|
||||
ENTRYPOINT ["claw-telegram"]
|
||||
CMD ["serve"]
|
||||
# Bun dependencies and TS worker source
|
||||
COPY --from=bun-builder /app/node_modules /app/node_modules
|
||||
COPY package.json /app/package.json
|
||||
COPY ts-worker/ /app/ts-worker/
|
||||
|
||||
RUN mkdir -p /state/claude-home /state/claw /workspace /data
|
||||
|
||||
ENV CLAW_WORKER_BIND_ADDR=0.0.0.0:8080
|
||||
ENV CLAW_WORKER_STATE_ROOT=/state
|
||||
ENV CLAW_WORKER_DEFAULT_CWD=/workspace
|
||||
ENV CLAW_WORKER_MODEL=claude-sonnet-4-6
|
||||
ENV CLAW_WORKER_PERMISSION_MODE=default
|
||||
ENV CLAUDE_CONFIG_DIR=/state/claude-home
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Default: worker mode. Gateway overrides via --entrypoint claw-telegram.
|
||||
CMD ["bun", "run", "ts-worker/main.ts"]
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
{
|
||||
"lockfileVersion": 1,
|
||||
"configVersion": 1,
|
||||
"workspaces": {
|
||||
"": {
|
||||
"name": "claw-code-parity",
|
||||
"dependencies": {
|
||||
"@anthropic-ai/sdk": "^0.39.0",
|
||||
},
|
||||
},
|
||||
},
|
||||
"packages": {
|
||||
"@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.39.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-eMyDIPRZbt1CCLErRCi3exlAvNkBtRe+kW5vvJyef93PmNr/clstYgHhtvmkxN82nlKgzyGPCyGxrm0JQ1ZIdg=="],
|
||||
|
||||
"@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
|
||||
|
||||
"@types/node-fetch": ["@types/node-fetch@2.6.13", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.4" } }, "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw=="],
|
||||
|
||||
"abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
|
||||
|
||||
"agentkeepalive": ["agentkeepalive@4.6.0", "", { "dependencies": { "humanize-ms": "^1.2.1" } }, "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ=="],
|
||||
|
||||
"asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
|
||||
|
||||
"call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
|
||||
|
||||
"combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
|
||||
|
||||
"delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
|
||||
|
||||
"dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
|
||||
|
||||
"es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
|
||||
|
||||
"es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
|
||||
|
||||
"es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
|
||||
|
||||
"es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="],
|
||||
|
||||
"event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
|
||||
|
||||
"form-data": ["form-data@4.0.5", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w=="],
|
||||
|
||||
"form-data-encoder": ["form-data-encoder@1.7.2", "", {}, "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A=="],
|
||||
|
||||
"formdata-node": ["formdata-node@4.4.1", "", { "dependencies": { "node-domexception": "1.0.0", "web-streams-polyfill": "4.0.0-beta.3" } }, "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ=="],
|
||||
|
||||
"function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
|
||||
|
||||
"get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
|
||||
|
||||
"get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
|
||||
|
||||
"gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
|
||||
|
||||
"has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
|
||||
|
||||
"has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
|
||||
|
||||
"hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
|
||||
|
||||
"humanize-ms": ["humanize-ms@1.2.1", "", { "dependencies": { "ms": "^2.0.0" } }, "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ=="],
|
||||
|
||||
"math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
|
||||
|
||||
"mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
|
||||
|
||||
"mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
|
||||
|
||||
"ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
|
||||
|
||||
"node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="],
|
||||
|
||||
"node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
|
||||
|
||||
"tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
|
||||
|
||||
"undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
|
||||
|
||||
"web-streams-polyfill": ["web-streams-polyfill@4.0.0-beta.3", "", {}, "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug=="],
|
||||
|
||||
"webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
|
||||
|
||||
"whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
|
||||
}
|
||||
}
|
||||
@@ -26,7 +26,7 @@
|
||||
<Config Name="Gateway AppData" Target="/appdata" Default="/mnt/user/appdata/claw-telegram-gateway" Mode="rw" Description="Gateway state and manifest directory" Type="Path" Display="always" Required="true" Mask="false">/mnt/user/appdata/claw-telegram-gateway</Config>
|
||||
<Config Name="Telegram Bot Token" Target="CLAW_GATEWAY_TELEGRAM_BOT_TOKEN" Default="" Mode="" Description="Telegram bot token used by the gateway ingress" Type="Variable" Display="always" Required="true" Mask="true"></Config>
|
||||
<Config Name="Worker Auth Token" Target="CLAW_WORKER_AUTH_TOKEN" Default="" Mode="" Description="Shared bearer token for worker API calls" Type="Variable" Display="always" Required="true" Mask="true"></Config>
|
||||
<Config Name="Worker Image" Target="CLAW_GATEWAY_WORKER_IMAGE" Default="git.wylab.me/wylab/claw-ts-worker:latest" Mode="" Description="Worker image pulled by the gateway for per-profile containers" Type="Variable" Display="always" Required="true" Mask="false">git.wylab.me/wylab/claw-ts-worker:latest</Config>
|
||||
<Config Name="Worker Image" Target="CLAW_GATEWAY_WORKER_IMAGE" Default="git.wylab.me/wylab/claw-telegram:latest" Mode="" Description="Worker image pulled by the gateway for per-profile containers" Type="Variable" Display="always" Required="true" Mask="false">git.wylab.me/wylab/claw-telegram:latest</Config>
|
||||
<Config Name="Gateway State Root" Target="CLAW_GATEWAY_STATE_ROOT" Default="/appdata/state" Mode="" Description="Gateway runtime state root for offsets and staged files" Type="Variable" Display="advanced" Required="true" Mask="false">/appdata/state</Config>
|
||||
<Config Name="Gateway Manifest" Target="CLAW_GATEWAY_MANIFEST" Default="/appdata/profiles.json" Mode="" Description="Manifest path for channel identities and worker layout" Type="Variable" Display="advanced" Required="true" Mask="false">/appdata/profiles.json</Config>
|
||||
<Config Name="Docker Socket Path" Target="CLAW_GATEWAY_DOCKER_SOCKET" Default="/var/run/docker.sock" Mode="" Description="Docker socket path inside the gateway container" Type="Variable" Display="advanced" Required="true" Mask="false">/var/run/docker.sock</Config>
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"name": "claw-code-parity",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"dependencies": {
|
||||
"@anthropic-ai/sdk": "^0.39.0"
|
||||
}
|
||||
}
|
||||
@@ -26,7 +26,7 @@
|
||||
<Config Name="Gateway AppData" Target="/appdata" Default="/mnt/user/appdata/claw-telegram-gateway" Mode="rw" Description="Gateway state and manifest directory" Type="Path" Display="always" Required="true" Mask="false">/mnt/user/appdata/claw-telegram-gateway</Config>
|
||||
<Config Name="CLAW_GATEWAY_TELEGRAM_BOT_TOKEN" Target="CLAW_GATEWAY_TELEGRAM_BOT_TOKEN" Default="" Mode="" Description="Telegram bot token used by the gateway ingress" Type="Variable" Display="always" Required="true" Mask="true"></Config>
|
||||
<Config Name="CLAW_WORKER_AUTH_TOKEN" Target="CLAW_WORKER_AUTH_TOKEN" Default="" Mode="" Description="Shared bearer token for worker API calls" Type="Variable" Display="always" Required="true" Mask="true"></Config>
|
||||
<Config Name="CLAW_GATEWAY_WORKER_IMAGE" Target="CLAW_GATEWAY_WORKER_IMAGE" Default="git.wylab.me/wylab/claw-ts-worker:latest" Mode="" Description="Worker image pulled by the gateway for per-profile containers" Type="Variable" Display="always" Required="true" Mask="false">git.wylab.me/wylab/claw-ts-worker:latest</Config>
|
||||
<Config Name="CLAW_GATEWAY_WORKER_IMAGE" Target="CLAW_GATEWAY_WORKER_IMAGE" Default="git.wylab.me/wylab/claw-telegram:latest" Mode="" Description="Worker image pulled by the gateway for per-profile containers" Type="Variable" Display="always" Required="true" Mask="false">git.wylab.me/wylab/claw-telegram:latest</Config>
|
||||
<Config Name="CLAW_GATEWAY_STATE_ROOT" Target="CLAW_GATEWAY_STATE_ROOT" Default="/appdata/state" Mode="" Description="Gateway runtime state root for offsets and downloaded files" Type="Variable" Display="advanced" Required="true" Mask="false">/appdata/state</Config>
|
||||
<Config Name="CLAW_GATEWAY_MANIFEST" Target="CLAW_GATEWAY_MANIFEST" Default="/appdata/profiles.json" Mode="" Description="Manifest path for channel identities and worker layout" Type="Variable" Display="advanced" Required="true" Mask="false">/appdata/profiles.json</Config>
|
||||
<Config Name="CLAW_GATEWAY_DOCKER_SOCKET" Target="CLAW_GATEWAY_DOCKER_SOCKET" Default="/var/run/docker.sock" Mode="" Description="Docker socket path inside the gateway container" Type="Variable" Display="advanced" Required="true" Mask="false">/var/run/docker.sock</Config>
|
||||
|
||||
@@ -3,7 +3,6 @@ use std::fmt::{Display, Formatter};
|
||||
use std::path::PathBuf;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use bollard::image::CreateImageOptions;
|
||||
use bollard::container::{
|
||||
Config as ContainerConfig, CreateContainerOptions, InspectContainerOptions,
|
||||
ListContainersOptions, RemoveContainerOptions, StartContainerOptions, StopContainerOptions,
|
||||
@@ -357,29 +356,6 @@ impl DockerWorkerManager {
|
||||
.iter()
|
||||
.map(|(key, value)| format!("{key}={value}"))
|
||||
.collect::<Vec<_>>();
|
||||
// Pull the worker image if not already available locally.
|
||||
use futures_util::StreamExt;
|
||||
let mut pull_stream = self.docker.create_image(
|
||||
Some(CreateImageOptions {
|
||||
from_image: manifest.gateway.worker_image.clone(),
|
||||
..Default::default()
|
||||
}),
|
||||
None,
|
||||
None,
|
||||
);
|
||||
while let Some(result) = pull_stream.next().await {
|
||||
match result {
|
||||
Ok(info) => {
|
||||
if let Some(status) = info.status {
|
||||
eprintln!("[worker-manager] pull {}: {status}", manifest.gateway.worker_image);
|
||||
}
|
||||
}
|
||||
Err(err) => {
|
||||
eprintln!("[worker-manager] pull {} failed: {err}", manifest.gateway.worker_image);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.docker
|
||||
.create_container(
|
||||
Some(CreateContainerOptions {
|
||||
|
||||
@@ -373,7 +373,7 @@ mod tests {
|
||||
("CLAW_WORKER_AUTH_TOKEN", "worker-secret"),
|
||||
(
|
||||
"CLAW_GATEWAY_WORKER_IMAGE",
|
||||
"git.wylab.me/wylab/claw-ts-worker:latest",
|
||||
"git.wylab.me/wylab/claw-telegram:latest",
|
||||
),
|
||||
(
|
||||
"CLAW_GATEWAY_TEMPLATE_DIR",
|
||||
|
||||
@@ -0,0 +1,163 @@
|
||||
/**
|
||||
* TelegramWorkerEngine — drives Claude conversations for the worker.
|
||||
*
|
||||
* Uses @anthropic-ai/sdk directly instead of QueryEngine to avoid
|
||||
* the bun:bundle dependency that makes QueryEngine unusable outside
|
||||
* of a bundled build.
|
||||
*
|
||||
* Responsibilities:
|
||||
* - manage conversation history across turns
|
||||
* - call Claude API via streaming
|
||||
* - translate streaming events into WorkerTurnEvent
|
||||
* - handle tool use / approval flow
|
||||
* - support cancellation
|
||||
*/
|
||||
|
||||
import Anthropic from '@anthropic-ai/sdk'
|
||||
import type { MessageStream } from '@anthropic-ai/sdk/lib/streaming.mjs'
|
||||
import type { ApprovalBroker } from '../permissions/ApprovalBroker.js'
|
||||
import { WorkerEventTranslator } from '../events/WorkerEventTranslator.js'
|
||||
import type { WorkerTurnEvent } from '../protocol.js'
|
||||
|
||||
export type TelegramWorkerEngineConfig = {
|
||||
profileId: string
|
||||
model: string
|
||||
permissionMode: string
|
||||
defaultCwd: string
|
||||
stateRoot: string
|
||||
claudeConfigDir: string
|
||||
}
|
||||
|
||||
type ConversationMessage = {
|
||||
role: 'user' | 'assistant'
|
||||
content: string | Array<{ type: string; [key: string]: unknown }>
|
||||
}
|
||||
|
||||
export class TelegramWorkerEngine {
|
||||
private config: TelegramWorkerEngineConfig
|
||||
private broker: ApprovalBroker
|
||||
private translator: WorkerEventTranslator
|
||||
private client: Anthropic | null = null
|
||||
|
||||
// Session state — persists across turns
|
||||
private messages: ConversationMessage[] = []
|
||||
private ready = false
|
||||
|
||||
constructor(config: TelegramWorkerEngineConfig, broker: ApprovalBroker) {
|
||||
this.config = config
|
||||
this.broker = broker
|
||||
this.translator = new WorkerEventTranslator()
|
||||
}
|
||||
|
||||
async init(): Promise<boolean> {
|
||||
try {
|
||||
// The SDK reads ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN from env
|
||||
this.client = new Anthropic()
|
||||
this.ready = true
|
||||
console.log(
|
||||
`[TelegramWorkerEngine] initialized for profile=${this.config.profileId} model=${this.config.model}`,
|
||||
)
|
||||
return true
|
||||
} catch (err) {
|
||||
console.error('[TelegramWorkerEngine] failed to init SDK:', err)
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
get isReady(): boolean {
|
||||
return this.ready
|
||||
}
|
||||
|
||||
get messageCount(): number {
|
||||
return this.messages.length
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a turn. Yields WorkerTurnEvent as they're produced.
|
||||
*/
|
||||
async *executeTurn(
|
||||
prompt: string,
|
||||
abortController: AbortController,
|
||||
): AsyncGenerator<WorkerTurnEvent, void, unknown> {
|
||||
this.translator.reset()
|
||||
|
||||
if (!this.ready || !this.client) {
|
||||
yield {
|
||||
type: 'assistant_text_delta',
|
||||
delta: '[worker] engine not initialized — check ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN',
|
||||
}
|
||||
yield this.translator.buildCompletedEvent()
|
||||
return
|
||||
}
|
||||
|
||||
// Add user message to history
|
||||
this.messages.push({ role: 'user', content: prompt })
|
||||
|
||||
try {
|
||||
const stream = this.client.messages.stream({
|
||||
model: this.config.model,
|
||||
max_tokens: 16384,
|
||||
system: `You are Claude, an AI assistant. The user is communicating via Telegram. Be helpful and concise. Current working directory: ${this.config.defaultCwd}`,
|
||||
messages: this.messages.map((m) => ({
|
||||
role: m.role,
|
||||
content: m.content,
|
||||
})),
|
||||
})
|
||||
|
||||
let fullText = ''
|
||||
|
||||
stream.on('text', (text) => {
|
||||
fullText += text
|
||||
})
|
||||
|
||||
// Process events from the stream
|
||||
for await (const event of stream) {
|
||||
if (abortController.signal.aborted) {
|
||||
stream.abort()
|
||||
yield this.translator.buildFailedEvent('Turn cancelled by user')
|
||||
return
|
||||
}
|
||||
|
||||
if (event.type === 'content_block_delta') {
|
||||
const delta = event.delta as { type?: string; text?: string }
|
||||
if (delta?.type === 'text_delta' && delta.text) {
|
||||
yield {
|
||||
type: 'assistant_text_delta',
|
||||
delta: delta.text,
|
||||
} as WorkerTurnEvent
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Get final message for usage
|
||||
const finalMessage = await stream.finalMessage()
|
||||
|
||||
// Add assistant response to history
|
||||
const assistantText =
|
||||
finalMessage.content
|
||||
.filter((b): b is { type: 'text'; text: string } => b.type === 'text')
|
||||
.map((b) => b.text)
|
||||
.join('') || fullText
|
||||
|
||||
this.messages.push({ role: 'assistant', content: assistantText })
|
||||
|
||||
yield {
|
||||
type: 'completed',
|
||||
final_text: assistantText,
|
||||
iterations: 1,
|
||||
input_tokens: finalMessage.usage?.input_tokens ?? 0,
|
||||
output_tokens: finalMessage.usage?.output_tokens ?? 0,
|
||||
generated_files: [],
|
||||
} as WorkerTurnEvent
|
||||
} catch (err) {
|
||||
const message = err instanceof Error ? err.message : String(err)
|
||||
yield this.translator.buildFailedEvent(message)
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset session — clear conversation history. */
|
||||
resetSession(): void {
|
||||
this.messages = []
|
||||
this.broker.reset()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,257 @@
|
||||
/**
|
||||
* WorkerEventTranslator — maps SDKMessage and internal events into
|
||||
* the WorkerTurnEvent protocol that the Rust gateway expects.
|
||||
*
|
||||
* Handles:
|
||||
* - assistant_text_delta (streaming text)
|
||||
* - tool_use (tool invocation)
|
||||
* - tool_result (tool output)
|
||||
* - approval_requested (permission gate)
|
||||
* - auto_compaction (context window management)
|
||||
* - task_created / task_updated / task_stopped
|
||||
* - agent_spawned
|
||||
* - team_created / team_deleted
|
||||
* - mailbox_message
|
||||
* - completed / failed (terminal events)
|
||||
*/
|
||||
|
||||
import { randomUUID } from 'crypto'
|
||||
import type {
|
||||
WorkerTurnEvent,
|
||||
GeneratedFileDescriptor,
|
||||
ApprovalRequestPayload,
|
||||
} from '../protocol.js'
|
||||
|
||||
/**
|
||||
* Minimal shape we pattern-match against. SDKMessage is a large union —
|
||||
* we extract what we need and skip unrecognized types.
|
||||
*/
|
||||
type SDKMessageLike = {
|
||||
type: string
|
||||
[key: string]: unknown
|
||||
}
|
||||
|
||||
export class WorkerEventTranslator {
|
||||
private accumulatedText = ''
|
||||
private iterations = 0
|
||||
private inputTokens = 0
|
||||
private outputTokens = 0
|
||||
private generatedFiles: GeneratedFileDescriptor[] = []
|
||||
|
||||
/** Reset state for a new turn. */
|
||||
reset(): void {
|
||||
this.accumulatedText = ''
|
||||
this.iterations = 0
|
||||
this.inputTokens = 0
|
||||
this.outputTokens = 0
|
||||
this.generatedFiles = []
|
||||
}
|
||||
|
||||
/**
|
||||
* Translate one SDKMessage into zero or more WorkerTurnEvents.
|
||||
*/
|
||||
translate(msg: SDKMessageLike): WorkerTurnEvent[] {
|
||||
const events: WorkerTurnEvent[] = []
|
||||
|
||||
switch (msg.type) {
|
||||
// ── Text streaming ────────────────────────────────────────
|
||||
case 'assistant': {
|
||||
const content = msg.content as
|
||||
| Array<{ type: string; text?: string }>
|
||||
| undefined
|
||||
if (Array.isArray(content)) {
|
||||
for (const block of content) {
|
||||
if (block.type === 'text' && typeof block.text === 'string') {
|
||||
this.accumulatedText += block.text
|
||||
events.push({
|
||||
type: 'assistant_text_delta',
|
||||
delta: block.text,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
if (typeof msg.text === 'string') {
|
||||
this.accumulatedText += msg.text as string
|
||||
events.push({
|
||||
type: 'assistant_text_delta',
|
||||
delta: msg.text as string,
|
||||
})
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'content_block_delta': {
|
||||
const delta = msg.delta as
|
||||
| { type?: string; text?: string }
|
||||
| undefined
|
||||
if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
|
||||
this.accumulatedText += delta.text
|
||||
events.push({
|
||||
type: 'assistant_text_delta',
|
||||
delta: delta.text,
|
||||
})
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
// ── Tool use ──────────────────────────────────────────────
|
||||
case 'tool_use': {
|
||||
events.push({
|
||||
type: 'tool_use',
|
||||
id: (msg.id as string) || randomUUID(),
|
||||
name: msg.name as string,
|
||||
input:
|
||||
typeof msg.input === 'string'
|
||||
? (msg.input as string)
|
||||
: JSON.stringify(msg.input),
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Tool result ───────────────────────────────────────────
|
||||
case 'tool_result': {
|
||||
events.push({
|
||||
type: 'tool_result',
|
||||
tool_use_id: msg.tool_use_id as string,
|
||||
tool_name: (msg.tool_name as string) || 'unknown',
|
||||
output:
|
||||
typeof msg.output === 'string'
|
||||
? (msg.output as string)
|
||||
: JSON.stringify(msg.output ?? ''),
|
||||
is_error: !!msg.is_error,
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Usage / result ────────────────────────────────────────
|
||||
case 'result': {
|
||||
const r = msg as Record<string, unknown>
|
||||
if (typeof r.input_tokens === 'number')
|
||||
this.inputTokens += r.input_tokens
|
||||
if (typeof r.output_tokens === 'number')
|
||||
this.outputTokens += r.output_tokens
|
||||
this.iterations++
|
||||
|
||||
// Check for generated files
|
||||
const files = r.generated_files as GeneratedFileDescriptor[] | undefined
|
||||
if (Array.isArray(files)) {
|
||||
this.generatedFiles.push(...files)
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
// ── Auto-compaction ───────────────────────────────────────
|
||||
case 'auto_compact':
|
||||
case 'auto_compaction': {
|
||||
const removedCount =
|
||||
(msg.removed_message_count as number) ??
|
||||
(msg.removedCount as number) ??
|
||||
0
|
||||
events.push({
|
||||
type: 'auto_compaction',
|
||||
removed_message_count: removedCount,
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Task lifecycle ────────────────────────────────────────
|
||||
case 'task_created': {
|
||||
events.push({
|
||||
type: 'task_created',
|
||||
task_list_id: (msg.task_list_id as string) || 'default',
|
||||
task: (msg.task as Record<string, unknown>) || {},
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
case 'task_updated': {
|
||||
events.push({
|
||||
type: 'task_updated',
|
||||
task_list_id: (msg.task_list_id as string) || 'default',
|
||||
task: (msg.task as Record<string, unknown>) || {},
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
case 'task_stopped': {
|
||||
events.push({
|
||||
type: 'task_stopped',
|
||||
task: (msg.task as Record<string, unknown>) || {},
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Agent lifecycle ───────────────────────────────────────
|
||||
case 'agent_spawned': {
|
||||
events.push({
|
||||
type: 'agent_spawned',
|
||||
agent: (msg.agent as Record<string, unknown>) || {},
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Team lifecycle ────────────────────────────────────────
|
||||
case 'team_created': {
|
||||
events.push({
|
||||
type: 'team_created',
|
||||
team: {
|
||||
team: (msg.team as Record<string, unknown>) || {},
|
||||
task_list_id: (msg.task_list_id as string) || 'default',
|
||||
team_file_path: (msg.team_file_path as string) || '',
|
||||
},
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
case 'team_deleted': {
|
||||
events.push({
|
||||
type: 'team_deleted',
|
||||
team_name: msg.team_name as string,
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Mailbox ───────────────────────────────────────────────
|
||||
case 'mailbox_message': {
|
||||
const m = (msg.message as Record<string, unknown>) ?? msg
|
||||
events.push({
|
||||
type: 'mailbox_message',
|
||||
message: {
|
||||
team_name: (m.team_name as string) || '',
|
||||
sender: (m.sender as string) || '',
|
||||
count: (m.count as number) || 1,
|
||||
recipients: m.recipients as string[] | undefined,
|
||||
summary: m.summary as string | undefined,
|
||||
},
|
||||
})
|
||||
break
|
||||
}
|
||||
|
||||
// ── Unknown — skip silently ───────────────────────────────
|
||||
default:
|
||||
break
|
||||
}
|
||||
|
||||
return events
|
||||
}
|
||||
|
||||
/** Build the terminal 'completed' event. */
|
||||
buildCompletedEvent(): WorkerTurnEvent {
|
||||
return {
|
||||
type: 'completed',
|
||||
final_text: this.accumulatedText,
|
||||
iterations: this.iterations,
|
||||
input_tokens: this.inputTokens,
|
||||
output_tokens: this.outputTokens,
|
||||
generated_files: this.generatedFiles,
|
||||
}
|
||||
}
|
||||
|
||||
/** Build a terminal 'failed' event. */
|
||||
buildFailedEvent(message: string): WorkerTurnEvent {
|
||||
return {
|
||||
type: 'failed',
|
||||
message,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env bun
|
||||
/**
|
||||
* Worker entrypoint — reads CLAW_WORKER_* env vars and starts the
|
||||
* Bun HTTP server that speaks the worker protocol.
|
||||
*
|
||||
* Usage:
|
||||
* CLAW_WORKER_BIND_ADDR=0.0.0.0 \
|
||||
* CLAW_WORKER_PORT=8780 \
|
||||
* CLAW_WORKER_AUTH_TOKEN=secret \
|
||||
* CLAW_WORKER_PROFILE_ID=default \
|
||||
* CLAW_WORKER_STATE_ROOT=/state \
|
||||
* CLAW_WORKER_DEFAULT_CWD=/workspace \
|
||||
* CLAW_WORKER_MODEL=claude-sonnet-4-6 \
|
||||
* CLAW_WORKER_PERMISSION_MODE=default \
|
||||
* CLAUDE_CONFIG_DIR=/state/claude-home \
|
||||
* bun src/worker/main.ts
|
||||
*/
|
||||
|
||||
import { startWorkerServer } from './server.js'
|
||||
|
||||
// The gateway passes CLAW_WORKER_BIND_ADDR as "host:port" (e.g. "0.0.0.0:8080").
|
||||
// Parse both address and port from it, with CLAW_WORKER_PORT as override.
|
||||
const rawBindAddr = process.env.CLAW_WORKER_BIND_ADDR ?? '0.0.0.0:8080'
|
||||
const colonIdx = rawBindAddr.lastIndexOf(':')
|
||||
const bindAddr = colonIdx > 0 ? rawBindAddr.slice(0, colonIdx) : rawBindAddr
|
||||
const port = parseInt(
|
||||
process.env.CLAW_WORKER_PORT ?? (colonIdx > 0 ? rawBindAddr.slice(colonIdx + 1) : '8080'),
|
||||
10,
|
||||
)
|
||||
const authToken = process.env.CLAW_WORKER_AUTH_TOKEN
|
||||
const profileId = process.env.CLAW_WORKER_PROFILE_ID ?? 'default'
|
||||
const stateRoot = process.env.CLAW_WORKER_STATE_ROOT ?? '/tmp/claw-worker-state'
|
||||
const defaultCwd = process.env.CLAW_WORKER_DEFAULT_CWD ?? process.cwd()
|
||||
const model = process.env.CLAW_WORKER_MODEL ?? 'claude-sonnet-4-6'
|
||||
const permissionMode = process.env.CLAW_WORKER_PERMISSION_MODE ?? 'default'
|
||||
const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR ?? `${stateRoot}/claude-home`
|
||||
|
||||
console.log('[worker] starting with config:')
|
||||
console.log(` bind_addr: ${bindAddr}`)
|
||||
console.log(` port: ${port}`)
|
||||
console.log(` profile_id: ${profileId}`)
|
||||
console.log(` state_root: ${stateRoot}`)
|
||||
console.log(` default_cwd: ${defaultCwd}`)
|
||||
console.log(` model: ${model}`)
|
||||
console.log(` permission_mode: ${permissionMode}`)
|
||||
console.log(` claude_config: ${claudeConfigDir}`)
|
||||
console.log(` auth: ${authToken ? 'configured' : 'none'}`)
|
||||
|
||||
await startWorkerServer({
|
||||
bindAddr,
|
||||
port,
|
||||
authToken,
|
||||
profileId,
|
||||
stateRoot,
|
||||
defaultCwd,
|
||||
model,
|
||||
permissionMode,
|
||||
claudeConfigDir,
|
||||
})
|
||||
@@ -0,0 +1,211 @@
|
||||
/**
|
||||
* ApprovalBroker — manages tool permission decisions for the worker.
|
||||
*
|
||||
* Integrates with QueryEngine's `canUseTool` callback to suspend
|
||||
* tool execution until the gateway (and ultimately the Telegram user)
|
||||
* sends an approval decision.
|
||||
*
|
||||
* Supports:
|
||||
* - approve_once: allow this specific tool call
|
||||
* - approve_tool_for_session: auto-approve this tool name for the session
|
||||
* - approve_all_for_session: auto-approve everything for the session
|
||||
* - deny: reject with reason
|
||||
* - cancel_turn: abort the entire turn
|
||||
*
|
||||
* The broker also maintains a background approval queue for approvals
|
||||
* that arrive from subagent/background tasks (not the foreground turn).
|
||||
*/
|
||||
|
||||
import { randomUUID } from 'crypto'
|
||||
import type { ApprovalDecision } from '../protocol.js'
|
||||
|
||||
export type ApprovalRequest = {
|
||||
approval_id: string
|
||||
tool_name: string
|
||||
input: string
|
||||
current_mode: string
|
||||
required_mode: string
|
||||
reason?: string
|
||||
/** Resolve function — called when the gateway sends a decision */
|
||||
resolve: (decision: ApprovalDecision) => void
|
||||
/** Timestamp for expiry/gc */
|
||||
created_at: number
|
||||
}
|
||||
|
||||
export type PermissionBehavior =
|
||||
| { behavior: 'allow' }
|
||||
| { behavior: 'deny'; reason: string }
|
||||
| { behavior: 'ask'; message?: string }
|
||||
|
||||
export class ApprovalBroker {
|
||||
/** Tools auto-approved for the entire session */
|
||||
private sessionApprovedTools = new Set<string>()
|
||||
/** If true, all tools are auto-approved for the session */
|
||||
private approveAllForSession = false
|
||||
/** Current permission mode (default, plan, etc.) */
|
||||
private permissionMode: string
|
||||
|
||||
/** Foreground pending approval (only one at a time — engine blocks) */
|
||||
private pendingForeground: ApprovalRequest | null = null
|
||||
|
||||
/** Background approvals queue (subagent tasks, etc.) */
|
||||
private backgroundApprovals = new Map<string, ApprovalRequest>()
|
||||
/** Background approvals that have been notified to the user */
|
||||
private notifiedBackgroundApprovals = new Set<string>()
|
||||
|
||||
/** Callback to emit SSE events to the current turn */
|
||||
private onApprovalRequested?: (request: ApprovalRequest) => void
|
||||
|
||||
constructor(permissionMode: string) {
|
||||
this.permissionMode = permissionMode
|
||||
}
|
||||
|
||||
setApprovalRequestHandler(
|
||||
handler: (request: ApprovalRequest) => void,
|
||||
): void {
|
||||
this.onApprovalRequested = handler
|
||||
}
|
||||
|
||||
/**
|
||||
* canUseTool callback for QueryEngine.
|
||||
*
|
||||
* Returns immediately if the tool is auto-approved. Otherwise
|
||||
* creates a pending approval request and suspends until the
|
||||
* gateway resolves it.
|
||||
*/
|
||||
async canUseTool(
|
||||
toolName: string,
|
||||
input: unknown,
|
||||
): Promise<PermissionBehavior> {
|
||||
// Auto-approve if session-wide approval is active
|
||||
if (this.approveAllForSession) {
|
||||
return { behavior: 'allow' }
|
||||
}
|
||||
|
||||
// Auto-approve if this specific tool was approved for the session
|
||||
if (this.sessionApprovedTools.has(toolName)) {
|
||||
return { behavior: 'allow' }
|
||||
}
|
||||
|
||||
// Need to ask — create a pending approval and block
|
||||
const approvalId = randomUUID()
|
||||
const inputStr =
|
||||
typeof input === 'string' ? input : JSON.stringify(input)
|
||||
|
||||
return new Promise<PermissionBehavior>((resolve) => {
|
||||
const request: ApprovalRequest = {
|
||||
approval_id: approvalId,
|
||||
tool_name: toolName,
|
||||
input: inputStr,
|
||||
current_mode: this.permissionMode,
|
||||
required_mode: 'confirm',
|
||||
created_at: Date.now(),
|
||||
resolve: (decision: ApprovalDecision) => {
|
||||
this.pendingForeground = null
|
||||
resolve(this.applyDecision(decision, toolName))
|
||||
},
|
||||
}
|
||||
|
||||
this.pendingForeground = request
|
||||
this.onApprovalRequested?.(request)
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve a foreground approval (from /v1/turns/:turn_id/approval).
|
||||
*/
|
||||
resolveForeground(
|
||||
approvalId: string,
|
||||
decision: ApprovalDecision,
|
||||
): boolean {
|
||||
if (!this.pendingForeground) return false
|
||||
if (this.pendingForeground.approval_id !== approvalId) return false
|
||||
this.pendingForeground.resolve(decision)
|
||||
return true
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit a background approval request (from subagent/background task).
|
||||
*/
|
||||
addBackgroundApproval(
|
||||
toolName: string,
|
||||
input: unknown,
|
||||
): { approvalId: string; promise: Promise<PermissionBehavior> } {
|
||||
const approvalId = randomUUID()
|
||||
const inputStr =
|
||||
typeof input === 'string' ? input : JSON.stringify(input)
|
||||
|
||||
const promise = new Promise<PermissionBehavior>((resolve) => {
|
||||
const request: ApprovalRequest = {
|
||||
approval_id: approvalId,
|
||||
tool_name: toolName,
|
||||
input: inputStr,
|
||||
current_mode: this.permissionMode,
|
||||
required_mode: 'confirm',
|
||||
created_at: Date.now(),
|
||||
resolve: (decision: ApprovalDecision) => {
|
||||
this.backgroundApprovals.delete(approvalId)
|
||||
this.notifiedBackgroundApprovals.delete(approvalId)
|
||||
resolve(this.applyDecision(decision, toolName))
|
||||
},
|
||||
}
|
||||
this.backgroundApprovals.set(approvalId, request)
|
||||
})
|
||||
|
||||
return { approvalId, promise }
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve a background approval (from /v1/background-approvals/:id).
|
||||
*/
|
||||
resolveBackground(
|
||||
approvalId: string,
|
||||
decision: ApprovalDecision,
|
||||
): boolean {
|
||||
const request = this.backgroundApprovals.get(approvalId)
|
||||
if (!request) return false
|
||||
request.resolve(decision)
|
||||
return true
|
||||
}
|
||||
|
||||
markBackgroundNotified(approvalId: string): void {
|
||||
this.notifiedBackgroundApprovals.add(approvalId)
|
||||
}
|
||||
|
||||
getBackgroundApprovals(): ApprovalRequest[] {
|
||||
return Array.from(this.backgroundApprovals.values())
|
||||
}
|
||||
|
||||
getPendingForeground(): ApprovalRequest | null {
|
||||
return this.pendingForeground
|
||||
}
|
||||
|
||||
/** Reset session-scoped state (on /v1/session/reset). */
|
||||
reset(): void {
|
||||
this.sessionApprovedTools.clear()
|
||||
this.approveAllForSession = false
|
||||
this.pendingForeground = null
|
||||
// Note: background approvals are NOT cleared on session reset —
|
||||
// they belong to background tasks that may still be running.
|
||||
}
|
||||
|
||||
private applyDecision(
|
||||
decision: ApprovalDecision,
|
||||
toolName: string,
|
||||
): PermissionBehavior {
|
||||
switch (decision.decision) {
|
||||
case 'approve_once':
|
||||
return { behavior: 'allow' }
|
||||
case 'approve_tool_for_session':
|
||||
this.sessionApprovedTools.add(toolName)
|
||||
return { behavior: 'allow' }
|
||||
case 'approve_all_for_session':
|
||||
this.approveAllForSession = true
|
||||
return { behavior: 'allow' }
|
||||
case 'deny':
|
||||
return { behavior: 'deny', reason: decision.reason }
|
||||
case 'cancel_turn':
|
||||
return { behavior: 'deny', reason: 'Turn cancelled by user' }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,203 @@
|
||||
/**
|
||||
* Worker protocol types — mirrors worker-protocol/openapi.yaml.
|
||||
*
|
||||
* These are the wire types the Rust gateway expects. The TS worker
|
||||
* translates internal QueryEngine / SDKMessage events into these shapes
|
||||
* before sending them over SSE.
|
||||
*/
|
||||
|
||||
// ── Turn request ──────────────────────────────────────────────────────
|
||||
|
||||
export type TurnSource = {
|
||||
channel: string
|
||||
sender_id: string
|
||||
chat_id?: string
|
||||
display_name?: string
|
||||
}
|
||||
|
||||
export type InboundAttachment = {
|
||||
file_name: string
|
||||
kind: 'photo' | 'document'
|
||||
media_type?: string
|
||||
data_base64: string
|
||||
}
|
||||
|
||||
export type WorkerTurnRequest = {
|
||||
prompt: string
|
||||
source: TurnSource
|
||||
attachments?: InboundAttachment[]
|
||||
}
|
||||
|
||||
export type WorkerTurnAccepted = {
|
||||
turn_id: string
|
||||
}
|
||||
|
||||
// ── SSE events ────────────────────────────────────────────────────────
|
||||
|
||||
export type AssistantTextDelta = {
|
||||
type: 'assistant_text_delta'
|
||||
delta: string
|
||||
}
|
||||
|
||||
export type ToolUseEvent = {
|
||||
type: 'tool_use'
|
||||
id: string
|
||||
name: string
|
||||
input: string
|
||||
}
|
||||
|
||||
export type ToolResultEvent = {
|
||||
type: 'tool_result'
|
||||
tool_use_id: string
|
||||
tool_name: string
|
||||
output: string
|
||||
is_error: boolean
|
||||
}
|
||||
|
||||
export type ApprovalRequestPayload = {
|
||||
approval_id: string
|
||||
tool_name: string
|
||||
input: string
|
||||
current_mode: string
|
||||
required_mode: string
|
||||
reason?: string
|
||||
}
|
||||
|
||||
export type ApprovalRequestedEvent = {
|
||||
type: 'approval_requested'
|
||||
request: ApprovalRequestPayload
|
||||
}
|
||||
|
||||
export type AutoCompactionEvent = {
|
||||
type: 'auto_compaction'
|
||||
removed_message_count: number
|
||||
}
|
||||
|
||||
export type GeneratedFileDescriptor = {
|
||||
file_id: string
|
||||
file_name: string
|
||||
media_type?: string
|
||||
size_bytes: number
|
||||
is_image: boolean
|
||||
}
|
||||
|
||||
export type CompletedEvent = {
|
||||
type: 'completed'
|
||||
final_text: string
|
||||
iterations: number
|
||||
input_tokens: number
|
||||
output_tokens: number
|
||||
generated_files: GeneratedFileDescriptor[]
|
||||
}
|
||||
|
||||
export type FailedEvent = {
|
||||
type: 'failed'
|
||||
message: string
|
||||
}
|
||||
|
||||
export type TaskCreatedEvent = {
|
||||
type: 'task_created'
|
||||
task_list_id: string
|
||||
task: TaskListRecord
|
||||
}
|
||||
|
||||
export type TaskUpdatedEvent = {
|
||||
type: 'task_updated'
|
||||
task_list_id: string
|
||||
task: TaskListRecord
|
||||
}
|
||||
|
||||
export type TaskStoppedEvent = {
|
||||
type: 'task_stopped'
|
||||
task: RuntimeTaskRecord
|
||||
}
|
||||
|
||||
export type AgentSpawnedEvent = {
|
||||
type: 'agent_spawned'
|
||||
agent: RuntimeTaskRecord
|
||||
}
|
||||
|
||||
export type TeamCreatedEvent = {
|
||||
type: 'team_created'
|
||||
team: WorkerTeamCreatedPayload
|
||||
}
|
||||
|
||||
export type TeamDeletedEvent = {
|
||||
type: 'team_deleted'
|
||||
team_name: string
|
||||
}
|
||||
|
||||
export type MailboxMessageEvent = {
|
||||
type: 'mailbox_message'
|
||||
message: WorkerMailboxMessagePayload
|
||||
}
|
||||
|
||||
export type WorkerTurnEvent =
|
||||
| AssistantTextDelta
|
||||
| ToolUseEvent
|
||||
| ToolResultEvent
|
||||
| ApprovalRequestedEvent
|
||||
| AutoCompactionEvent
|
||||
| TaskCreatedEvent
|
||||
| TaskUpdatedEvent
|
||||
| TaskStoppedEvent
|
||||
| AgentSpawnedEvent
|
||||
| TeamCreatedEvent
|
||||
| TeamDeletedEvent
|
||||
| MailboxMessageEvent
|
||||
| CompletedEvent
|
||||
| FailedEvent
|
||||
|
||||
// ── Approval decision ─────────────────────────────────────────────────
|
||||
|
||||
export type ApprovalDecision =
|
||||
| { decision: 'approve_once' }
|
||||
| { decision: 'approve_tool_for_session' }
|
||||
| { decision: 'approve_all_for_session' }
|
||||
| { decision: 'cancel_turn' }
|
||||
| { decision: 'deny'; reason: string }
|
||||
|
||||
export type TurnApprovalRequest = {
|
||||
approval_id: string
|
||||
decision: ApprovalDecision
|
||||
}
|
||||
|
||||
// ── Domain records (opaque pass-through for now) ──────────────────────
|
||||
|
||||
export type TaskListRecord = Record<string, unknown>
|
||||
export type RuntimeTaskRecord = Record<string, unknown>
|
||||
export type TeamRecord = Record<string, unknown>
|
||||
export type MailboxMessage = Record<string, unknown>
|
||||
export type MailboxSummary = Record<string, unknown>
|
||||
export type BackgroundApprovalRecord = Record<string, unknown>
|
||||
export type FeedItemRecord = Record<string, unknown>
|
||||
export type LibraryAppRecord = Record<string, unknown>
|
||||
export type LibraryAppVersionRecord = Record<string, unknown>
|
||||
export type AppWorkspaceRecord = Record<string, unknown>
|
||||
|
||||
// ── Composite response types ──────────────────────────────────────────
|
||||
|
||||
export type WorkerStatusResponse = {
|
||||
profile_id: string
|
||||
message_count: number
|
||||
model: string
|
||||
permission_mode: string
|
||||
default_cwd: string
|
||||
busy: boolean
|
||||
task_list_id: string
|
||||
active_team?: string
|
||||
}
|
||||
|
||||
export type WorkerTeamCreatedPayload = {
|
||||
team: TeamRecord
|
||||
task_list_id: string
|
||||
team_file_path: string
|
||||
}
|
||||
|
||||
export type WorkerMailboxMessagePayload = {
|
||||
team_name: string
|
||||
sender: string
|
||||
count: number
|
||||
recipients?: string[]
|
||||
summary?: string
|
||||
}
|
||||
@@ -0,0 +1,500 @@
|
||||
/**
|
||||
* Worker HTTP server — Bun.serve implementation of the worker protocol.
|
||||
*
|
||||
* Implements every endpoint from worker-protocol/openapi.yaml so the
|
||||
* Rust gateway can talk to this TS worker exactly as it talked to the
|
||||
* old Rust worker.
|
||||
*/
|
||||
|
||||
import type { Server } from 'bun'
|
||||
import { TurnManager } from './turnManager.js'
|
||||
import type {
|
||||
TurnApprovalRequest,
|
||||
WorkerStatusResponse,
|
||||
WorkerTurnEvent,
|
||||
WorkerTurnRequest,
|
||||
} from './protocol.js'
|
||||
import { ApprovalBroker } from './permissions/ApprovalBroker.js'
|
||||
import { TelegramWorkerEngine } from './engine/TelegramWorkerEngine.js'
|
||||
import { TaskStore } from './state/TaskStore.js'
|
||||
import { TeamStore } from './state/TeamStore.js'
|
||||
import { FeedStore } from './state/FeedStore.js'
|
||||
import { AppLibraryStore } from './state/AppLibraryStore.js'
|
||||
import type { AppPackageRequest, AppPublishRequest } from './state/records.js'
|
||||
|
||||
export type WorkerServerConfig = {
|
||||
bindAddr: string
|
||||
port: number
|
||||
authToken?: string
|
||||
profileId: string
|
||||
model: string
|
||||
permissionMode: string
|
||||
defaultCwd: string
|
||||
stateRoot: string
|
||||
claudeConfigDir: string
|
||||
}
|
||||
|
||||
/**
|
||||
* WorkerState — runtime state shared across all request handlers.
|
||||
*/
|
||||
type WorkerState = {
|
||||
config: WorkerServerConfig
|
||||
turnManager: TurnManager
|
||||
broker: ApprovalBroker
|
||||
engine: TelegramWorkerEngine
|
||||
taskStore: TaskStore
|
||||
teamStore: TeamStore
|
||||
feedStore: FeedStore
|
||||
appStore: AppLibraryStore
|
||||
generatedFiles: Map<string, { data: Uint8Array; mediaType: string }>
|
||||
}
|
||||
|
||||
function checkAuth(req: Request, state: WorkerState): Response | null {
|
||||
const token = state.config.authToken
|
||||
if (!token) return null
|
||||
const auth = req.headers.get('authorization')
|
||||
if (auth !== `Bearer ${token}`) {
|
||||
return new Response('Unauthorized', { status: 401 })
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
function json(data: unknown, status = 200): Response {
|
||||
return new Response(JSON.stringify(data), {
|
||||
status,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
})
|
||||
}
|
||||
|
||||
function noContent(): Response {
|
||||
return new Response(null, { status: 204 })
|
||||
}
|
||||
|
||||
function notFound(msg = 'Not found'): Response {
|
||||
return new Response(JSON.stringify({ error: msg }), {
|
||||
status: 404,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
})
|
||||
}
|
||||
|
||||
async function handleRequest(
|
||||
req: Request,
|
||||
state: WorkerState,
|
||||
): Promise<Response> {
|
||||
const authErr = checkAuth(req, state)
|
||||
if (authErr) return authErr
|
||||
|
||||
const url = new URL(req.url)
|
||||
const path = url.pathname
|
||||
const method = req.method
|
||||
|
||||
// ── Health ────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/healthz') {
|
||||
return new Response('ok')
|
||||
}
|
||||
|
||||
// ── Status ────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/status') {
|
||||
const status: WorkerStatusResponse = {
|
||||
profile_id: state.config.profileId,
|
||||
message_count: state.engine.messageCount,
|
||||
model: state.config.model,
|
||||
permission_mode: state.config.permissionMode,
|
||||
default_cwd: state.config.defaultCwd,
|
||||
busy: state.turnManager.isBusy,
|
||||
task_list_id: state.taskStore.getTaskListId(),
|
||||
}
|
||||
return json(status)
|
||||
}
|
||||
|
||||
// ── Session reset ─────────────────────────────────────────────────
|
||||
if (method === 'POST' && path === '/v1/session/reset') {
|
||||
state.engine.resetSession()
|
||||
state.taskStore.reset()
|
||||
state.teamStore.reset()
|
||||
return noContent()
|
||||
}
|
||||
|
||||
// ── Turns ─────────────────────────────────────────────────────────
|
||||
if (method === 'POST' && path === '/v1/turns') {
|
||||
const body = (await req.json()) as WorkerTurnRequest
|
||||
const turn = state.turnManager.create(body)
|
||||
|
||||
// Wire approval broker to emit SSE events on this turn
|
||||
state.broker.setApprovalRequestHandler((request) => {
|
||||
state.turnManager.emit(turn.id, {
|
||||
type: 'approval_requested',
|
||||
request: {
|
||||
approval_id: request.approval_id,
|
||||
tool_name: request.tool_name,
|
||||
input: request.input,
|
||||
current_mode: request.current_mode,
|
||||
required_mode: request.required_mode,
|
||||
reason: request.reason,
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
// Drive the turn through the engine
|
||||
queueMicrotask(async () => {
|
||||
try {
|
||||
for await (const event of state.engine.executeTurn(
|
||||
body.prompt,
|
||||
turn.abortController,
|
||||
)) {
|
||||
state.turnManager.emit(turn.id, event)
|
||||
}
|
||||
} catch (err) {
|
||||
const message = err instanceof Error ? err.message : String(err)
|
||||
state.turnManager.emit(turn.id, {
|
||||
type: 'failed',
|
||||
message,
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
return json({ turn_id: turn.id })
|
||||
}
|
||||
|
||||
// ── Turn events (SSE) ─────────────────────────────────────────────
|
||||
const turnEventsMatch = path.match(/^\/v1\/turns\/([^/]+)\/events$/)
|
||||
if (method === 'GET' && turnEventsMatch) {
|
||||
const turnId = turnEventsMatch[1]!
|
||||
const turn = state.turnManager.get(turnId)
|
||||
if (!turn) return notFound('Turn not found')
|
||||
|
||||
return new Response(
|
||||
new ReadableStream<Uint8Array>({
|
||||
start(controller) {
|
||||
const encoder = new TextEncoder()
|
||||
let closed = false
|
||||
const send = (event: WorkerTurnEvent) => {
|
||||
if (closed) return
|
||||
const data = JSON.stringify(event)
|
||||
controller.enqueue(encoder.encode(`data: ${data}\n\n`))
|
||||
if (event.type === 'completed' || event.type === 'failed') {
|
||||
closed = true
|
||||
controller.close()
|
||||
}
|
||||
}
|
||||
|
||||
const unsub = state.turnManager.subscribe(turnId, send)
|
||||
if (unsub === null && !closed) {
|
||||
closed = true
|
||||
controller.close()
|
||||
}
|
||||
},
|
||||
}),
|
||||
{
|
||||
headers: {
|
||||
'content-type': 'text/event-stream',
|
||||
'cache-control': 'no-cache',
|
||||
connection: 'keep-alive',
|
||||
},
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// ── Turn approval ─────────────────────────────────────────────────
|
||||
const turnApprovalMatch = path.match(/^\/v1\/turns\/([^/]+)\/approval$/)
|
||||
if (method === 'POST' && turnApprovalMatch) {
|
||||
const body = (await req.json()) as TurnApprovalRequest
|
||||
// Route to broker (foreground approval)
|
||||
const ok = state.broker.resolveForeground(
|
||||
body.approval_id,
|
||||
body.decision,
|
||||
)
|
||||
if (!ok) {
|
||||
// Try turn manager fallback
|
||||
const tmOk = state.turnManager.resolveApproval(
|
||||
turnApprovalMatch[1]!,
|
||||
body.approval_id,
|
||||
body.decision,
|
||||
)
|
||||
if (!tmOk) return notFound('No pending approval')
|
||||
}
|
||||
return noContent()
|
||||
}
|
||||
|
||||
// ── Turn cancel ───────────────────────────────────────────────────
|
||||
const turnCancelMatch = path.match(/^\/v1\/turns\/([^/]+)\/cancel$/)
|
||||
if (method === 'POST' && turnCancelMatch) {
|
||||
state.turnManager.cancel(turnCancelMatch[1]!)
|
||||
return noContent()
|
||||
}
|
||||
|
||||
// ── Generated files ───────────────────────────────────────────────
|
||||
const fileMatch = path.match(/^\/v1\/turns\/([^/]+)\/files\/([^/]+)$/)
|
||||
if (method === 'GET' && fileMatch) {
|
||||
const fileId = fileMatch[2]!
|
||||
const file = state.generatedFiles.get(fileId)
|
||||
if (!file) return notFound('File not found')
|
||||
return new Response(file.data, {
|
||||
headers: { 'content-type': file.mediaType },
|
||||
})
|
||||
}
|
||||
|
||||
// ── Tasks ─────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/tasks') {
|
||||
return json({
|
||||
task_list_id: state.taskStore.getTaskListId(),
|
||||
tasks: state.taskStore.listTasks(),
|
||||
})
|
||||
}
|
||||
|
||||
const taskMatch = path.match(/^\/v1\/tasks\/([^/]+)$/)
|
||||
if (method === 'GET' && taskMatch) {
|
||||
const task = state.taskStore.getTask(taskMatch[1]!)
|
||||
const runtimeTask = state.taskStore.getRuntimeTask(taskMatch[1]!)
|
||||
if (!task && !runtimeTask) return notFound('Task not found')
|
||||
return json({ task, runtime_task: runtimeTask })
|
||||
}
|
||||
|
||||
const taskStopMatch = path.match(/^\/v1\/tasks\/([^/]+)\/stop$/)
|
||||
if (method === 'POST' && taskStopMatch) {
|
||||
state.taskStore.stopRuntimeTask(taskStopMatch[1]!)
|
||||
return noContent()
|
||||
}
|
||||
|
||||
// ── Team ──────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/team') {
|
||||
return json({
|
||||
team: state.teamStore.getTeam(),
|
||||
task_list_id: state.taskStore.getTaskListId(),
|
||||
})
|
||||
}
|
||||
|
||||
// ── Agents ────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/agents') {
|
||||
return json({ agents: state.taskStore.listAgents() })
|
||||
}
|
||||
|
||||
const agentMatch = path.match(/^\/v1\/agents\/([^/]+)$/)
|
||||
if (method === 'GET' && agentMatch) {
|
||||
const agent = state.taskStore.getAgent(agentMatch[1]!)
|
||||
if (!agent) return notFound('Agent not found')
|
||||
return json(agent)
|
||||
}
|
||||
|
||||
// ── Background approvals ──────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/background-approvals') {
|
||||
const approvals = state.broker.getBackgroundApprovals().map((a) => ({
|
||||
approval_id: a.approval_id,
|
||||
task_id: '',
|
||||
tool_name: a.tool_name,
|
||||
input: a.input,
|
||||
current_mode: a.current_mode,
|
||||
required_mode: a.required_mode,
|
||||
reason: a.reason,
|
||||
created_at: a.created_at,
|
||||
notified: false,
|
||||
}))
|
||||
return json({ approvals })
|
||||
}
|
||||
|
||||
const bgApprovalMatch = path.match(/^\/v1\/background-approvals\/([^/]+)$/)
|
||||
if (method === 'POST' && bgApprovalMatch) {
|
||||
const body = (await req.json()) as TurnApprovalRequest
|
||||
const ok = state.broker.resolveBackground(
|
||||
bgApprovalMatch[1]!,
|
||||
body.decision,
|
||||
)
|
||||
if (!ok) return notFound('No pending background approval')
|
||||
return noContent()
|
||||
}
|
||||
|
||||
const bgApprovalNotifiedMatch = path.match(
|
||||
/^\/v1\/background-approvals\/([^/]+)\/notified$/,
|
||||
)
|
||||
if (method === 'POST' && bgApprovalNotifiedMatch) {
|
||||
state.broker.markBackgroundNotified(bgApprovalNotifiedMatch[1]!)
|
||||
return noContent()
|
||||
}
|
||||
|
||||
// ── Mailbox ───────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/mailbox') {
|
||||
return json({ mailbox: state.teamStore.getMailboxSummary() })
|
||||
}
|
||||
|
||||
const mailboxPendingMatch = path.match(/^\/v1\/mailbox\/pending\/([^/]+)$/)
|
||||
if (method === 'GET' && mailboxPendingMatch) {
|
||||
const messages = state.teamStore.getPendingMessages(
|
||||
mailboxPendingMatch[1]!,
|
||||
)
|
||||
return json({ messages })
|
||||
}
|
||||
|
||||
// ── Feed ──────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/feed') {
|
||||
const turnId = url.searchParams.get('turn_id') ?? undefined
|
||||
return json({
|
||||
items: state.feedStore.listItems(turnId),
|
||||
state_root: state.config.stateRoot,
|
||||
})
|
||||
}
|
||||
|
||||
const feedItemMatch = path.match(/^\/v1\/feed\/([^/]+)$/)
|
||||
if (method === 'GET' && feedItemMatch) {
|
||||
const item = state.feedStore.getItem(feedItemMatch[1]!)
|
||||
if (!item) return notFound('Feed item not found')
|
||||
return json({ item, state_root: state.config.stateRoot })
|
||||
}
|
||||
|
||||
const feedFileMatch = path.match(/^\/v1\/feed\/([^/]+)\/file$/)
|
||||
if (method === 'GET' && feedFileMatch) {
|
||||
const payload = await state.feedStore.getPayload(feedFileMatch[1]!)
|
||||
if (!payload) return notFound('Feed file not found')
|
||||
const item = state.feedStore.getItem(feedFileMatch[1]!)
|
||||
return new Response(payload, {
|
||||
headers: {
|
||||
'content-type': item?.media_type || 'application/octet-stream',
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
const feedMakeAppMatch = path.match(/^\/v1\/feed\/([^/]+)\/make-app$/)
|
||||
if (method === 'POST' && feedMakeAppMatch) {
|
||||
const body = (await req.json()) as AppPackageRequest
|
||||
const feedItem = state.feedStore.getItem(feedMakeAppMatch[1]!)
|
||||
if (!feedItem) return notFound('Feed item not found')
|
||||
const payload = await state.feedStore.getPayload(feedMakeAppMatch[1]!)
|
||||
const result = await state.appStore.packageFromFeedItem(
|
||||
body,
|
||||
payload,
|
||||
feedItem.title,
|
||||
feedItem.kind,
|
||||
)
|
||||
return json({ result })
|
||||
}
|
||||
|
||||
// ── Apps ───────────────────────────────────────────────────────────
|
||||
if (method === 'GET' && path === '/v1/apps') {
|
||||
return json({
|
||||
apps: state.appStore.listApps(),
|
||||
state_root: state.config.stateRoot,
|
||||
})
|
||||
}
|
||||
|
||||
const appMatch = path.match(/^\/v1\/apps\/([^/]+)$/)
|
||||
if (method === 'GET' && appMatch) {
|
||||
const app = state.appStore.getApp(appMatch[1]!)
|
||||
if (!app) return notFound('App not found')
|
||||
return json({ app, state_root: state.config.stateRoot })
|
||||
}
|
||||
|
||||
const appVersionMatch = path.match(/^\/v1\/apps\/([^/]+)\/version$/)
|
||||
if (method === 'GET' && appVersionMatch) {
|
||||
const version = state.appStore.getVersion(appVersionMatch[1]!)
|
||||
if (!version) return notFound('App not found')
|
||||
return json({ version })
|
||||
}
|
||||
|
||||
const appHistoryMatch = path.match(/^\/v1\/apps\/([^/]+)\/history$/)
|
||||
if (method === 'GET' && appHistoryMatch) {
|
||||
const history = await state.appStore.getHistory(appHistoryMatch[1]!)
|
||||
return json({ history })
|
||||
}
|
||||
|
||||
const appLaunchMatch = path.match(/^\/v1\/apps\/([^/]+)\/launch$/)
|
||||
if (method === 'POST' && appLaunchMatch) {
|
||||
const app = state.appStore.launch(appLaunchMatch[1]!)
|
||||
if (!app) return notFound('App not found')
|
||||
return json({ app, state_root: state.config.stateRoot })
|
||||
}
|
||||
|
||||
const appWorkspaceMatch = path.match(/^\/v1\/apps\/([^/]+)\/open-workspace$/)
|
||||
if (method === 'POST' && appWorkspaceMatch) {
|
||||
const workspace = await state.appStore.getWorkspace(appWorkspaceMatch[1]!)
|
||||
if (!workspace) return notFound('App not found')
|
||||
return json({ workspace })
|
||||
}
|
||||
|
||||
const appPublishMatch = path.match(/^\/v1\/apps\/([^/]+)\/publish$/)
|
||||
if (method === 'POST' && appPublishMatch) {
|
||||
const body = (await req.json()) as AppPublishRequest
|
||||
const result = await state.appStore.publish(appPublishMatch[1]!, body.message)
|
||||
if (!result) return notFound('App not found')
|
||||
return json({ result })
|
||||
}
|
||||
|
||||
const appArchiveMatch = path.match(/^\/v1\/apps\/([^/]+)\/archive$/)
|
||||
if (method === 'POST' && appArchiveMatch) {
|
||||
state.appStore.archive(appArchiveMatch[1]!)
|
||||
return noContent()
|
||||
}
|
||||
|
||||
const appWorktreeMatch = path.match(/^\/v1\/apps\/([^/]+)\/worktree-status$/)
|
||||
if (method === 'GET' && appWorktreeMatch) {
|
||||
const workspace = await state.appStore.getWorkspace(appWorktreeMatch[1]!)
|
||||
return json({ workspace })
|
||||
}
|
||||
|
||||
const appFileMatch = path.match(/^\/v1\/apps\/([^/]+)\/files\/(.+)$/)
|
||||
if (method === 'GET' && appFileMatch) {
|
||||
const data = await state.appStore.getAppFile(
|
||||
appFileMatch[1]!,
|
||||
appFileMatch[2]!,
|
||||
)
|
||||
if (!data) return notFound('App file not found')
|
||||
return new Response(data, {
|
||||
headers: { 'content-type': 'application/octet-stream' },
|
||||
})
|
||||
}
|
||||
|
||||
return notFound(`No route: ${method} ${path}`)
|
||||
}
|
||||
|
||||
export async function startWorkerServer(
|
||||
config: WorkerServerConfig,
|
||||
): Promise<Server> {
|
||||
// Build all runtime components
|
||||
const broker = new ApprovalBroker(config.permissionMode)
|
||||
const engine = new TelegramWorkerEngine(config, broker)
|
||||
const taskStore = new TaskStore()
|
||||
const teamStore = new TeamStore()
|
||||
const feedStore = new FeedStore(config.stateRoot)
|
||||
const appStore = new AppLibraryStore(config.stateRoot)
|
||||
|
||||
// Initialize engine (may fall back to stub mode)
|
||||
const engineReady = await engine.init()
|
||||
console.log(
|
||||
`[worker] engine: ${engineReady ? 'ready' : 'stub mode'}`,
|
||||
)
|
||||
|
||||
// Initialize persistent stores
|
||||
await feedStore.init()
|
||||
await appStore.init()
|
||||
|
||||
const state: WorkerState = {
|
||||
config,
|
||||
turnManager: new TurnManager(),
|
||||
broker,
|
||||
engine,
|
||||
taskStore,
|
||||
teamStore,
|
||||
feedStore,
|
||||
appStore,
|
||||
generatedFiles: new Map(),
|
||||
}
|
||||
|
||||
const server = Bun.serve({
|
||||
hostname: config.bindAddr,
|
||||
port: config.port,
|
||||
async fetch(req) {
|
||||
try {
|
||||
return await handleRequest(req, state)
|
||||
} catch (err) {
|
||||
console.error('[worker] unhandled error:', err)
|
||||
return new Response(
|
||||
JSON.stringify({ error: 'Internal server error' }),
|
||||
{ status: 500, headers: { 'content-type': 'application/json' } },
|
||||
)
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
console.log(
|
||||
`[worker] listening on ${config.bindAddr}:${config.port} (profile=${config.profileId})`,
|
||||
)
|
||||
return server
|
||||
}
|
||||
@@ -0,0 +1,334 @@
|
||||
/**
|
||||
* AppLibraryStore — git-backed app library.
|
||||
*
|
||||
* Each app is a git repo under {stateRoot}/claw/apps/{app_id}/.
|
||||
* The manifest and bundle are stored in the repo root.
|
||||
*
|
||||
* Operations:
|
||||
* - packageFromFeedItem: create or update an app from a feed item
|
||||
* - openWorkspace: return the worktree state for editing
|
||||
* - publish: commit + snapshot as published version
|
||||
* - archive: mark app as archived
|
||||
* - launch: bump last_launched_at
|
||||
* - history: list git commits
|
||||
*/
|
||||
|
||||
import { randomUUID } from 'crypto'
|
||||
import { readFile, writeFile, mkdir, readdir, stat, access } from 'fs/promises'
|
||||
import { join } from 'path'
|
||||
import { execSync } from 'child_process'
|
||||
import type {
|
||||
LibraryAppRecord,
|
||||
LibraryAppManifestV2,
|
||||
AppBundleManifestV1,
|
||||
LibraryAppVersionRecord,
|
||||
AppWorkspaceRecord,
|
||||
AppHistoryEntry,
|
||||
AppHistoryResponse,
|
||||
AppPackageRequest,
|
||||
AppPackageResult,
|
||||
AppPublishResult,
|
||||
AppKind,
|
||||
} from './records.js'
|
||||
|
||||
export class AppLibraryStore {
|
||||
private apps = new Map<string, LibraryAppRecord>()
|
||||
private stateRoot: string
|
||||
private appsDir: string
|
||||
|
||||
constructor(stateRoot: string) {
|
||||
this.stateRoot = stateRoot
|
||||
this.appsDir = join(stateRoot, 'claw', 'apps')
|
||||
}
|
||||
|
||||
async init(): Promise<void> {
|
||||
await mkdir(this.appsDir, { recursive: true })
|
||||
// Scan existing app directories
|
||||
try {
|
||||
const entries = await readdir(this.appsDir, { withFileTypes: true })
|
||||
for (const entry of entries) {
|
||||
if (!entry.isDirectory()) continue
|
||||
try {
|
||||
const manifestPath = join(this.appsDir, entry.name, 'manifest.json')
|
||||
const data = await readFile(manifestPath, 'utf8')
|
||||
const manifest = JSON.parse(data) as LibraryAppManifestV2
|
||||
|
||||
const bundlePath = join(this.appsDir, entry.name, 'bundle.json')
|
||||
const bundleData = await readFile(bundlePath, 'utf8')
|
||||
const bundle = JSON.parse(bundleData) as AppBundleManifestV1
|
||||
|
||||
const versionPath = join(this.appsDir, entry.name, 'version.json')
|
||||
const versionData = await readFile(versionPath, 'utf8')
|
||||
const version = JSON.parse(versionData) as LibraryAppVersionRecord
|
||||
|
||||
this.apps.set(manifest.app_id, { manifest, bundle_manifest: bundle, current_version: version })
|
||||
} catch {
|
||||
// Skip malformed app directories
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// No apps dir yet
|
||||
}
|
||||
}
|
||||
|
||||
getApp(appId: string): LibraryAppRecord | undefined {
|
||||
return this.apps.get(appId)
|
||||
}
|
||||
|
||||
listApps(): LibraryAppRecord[] {
|
||||
return Array.from(this.apps.values())
|
||||
.filter((a) => a.manifest.visibility !== 'archived')
|
||||
}
|
||||
|
||||
getVersion(appId: string): LibraryAppVersionRecord | undefined {
|
||||
return this.apps.get(appId)?.current_version
|
||||
}
|
||||
|
||||
async packageFromFeedItem(
|
||||
req: AppPackageRequest,
|
||||
feedPayload: Uint8Array | null,
|
||||
feedTitle: string,
|
||||
feedKind: string,
|
||||
): Promise<AppPackageResult> {
|
||||
const appId = req.requested_app_id || randomUUID()
|
||||
const existing = this.apps.get(appId)
|
||||
const now = Date.now()
|
||||
const versionId = randomUUID()
|
||||
|
||||
const appDir = join(this.appsDir, appId)
|
||||
await mkdir(appDir, { recursive: true })
|
||||
|
||||
// Init git repo if needed
|
||||
try {
|
||||
await access(join(appDir, '.git'))
|
||||
} catch {
|
||||
execSync('git init', { cwd: appDir })
|
||||
}
|
||||
|
||||
// Determine app kind from feed item kind
|
||||
const kind: AppKind =
|
||||
feedKind === 'html_preview' ? 'html_page' : 'html_page'
|
||||
|
||||
const entryFile = 'index.html'
|
||||
if (feedPayload) {
|
||||
await writeFile(join(appDir, entryFile), feedPayload)
|
||||
}
|
||||
|
||||
const bundleManifest: AppBundleManifestV1 = {
|
||||
schema_version: '1',
|
||||
app_id: appId,
|
||||
name: req.title || feedTitle,
|
||||
title: req.title || feedTitle,
|
||||
description: req.description,
|
||||
kind,
|
||||
entry: entryFile,
|
||||
files: [entryFile],
|
||||
capabilities: [],
|
||||
tags: [],
|
||||
}
|
||||
|
||||
const manifest: LibraryAppManifestV2 = existing?.manifest
|
||||
? {
|
||||
...existing.manifest,
|
||||
title: req.title || existing.manifest.title,
|
||||
description: req.description || existing.manifest.description,
|
||||
updated_at: now,
|
||||
current_version_id: versionId,
|
||||
}
|
||||
: {
|
||||
schema_version: '2',
|
||||
app_id: appId,
|
||||
title: req.title || feedTitle,
|
||||
name: (req.title || feedTitle).toLowerCase().replace(/[^a-z0-9]+/g, '-'),
|
||||
description: req.description,
|
||||
visibility: 'family',
|
||||
created_at: now,
|
||||
updated_at: now,
|
||||
last_launched_at: 0,
|
||||
created_from_feed_item_id: req.feed_item_id,
|
||||
current_version_id: versionId,
|
||||
default_branch: 'main',
|
||||
local_repo_path: appDir,
|
||||
kind,
|
||||
tags: [],
|
||||
capabilities: [],
|
||||
source_feed_item_ids: [req.feed_item_id],
|
||||
}
|
||||
|
||||
const version: LibraryAppVersionRecord = {
|
||||
version_id: versionId,
|
||||
created_at: now,
|
||||
entry: entryFile,
|
||||
files: [entryFile],
|
||||
branch: 'main',
|
||||
source_feed_item_ids: [req.feed_item_id],
|
||||
}
|
||||
|
||||
// Persist to disk
|
||||
await writeFile(join(appDir, 'manifest.json'), JSON.stringify(manifest, null, 2))
|
||||
await writeFile(join(appDir, 'bundle.json'), JSON.stringify(bundleManifest, null, 2))
|
||||
await writeFile(join(appDir, 'version.json'), JSON.stringify(version, null, 2))
|
||||
|
||||
// Git commit
|
||||
try {
|
||||
execSync('git add -A && git commit -m "Package from feed item"', {
|
||||
cwd: appDir,
|
||||
})
|
||||
const commit = execSync('git rev-parse HEAD', { cwd: appDir })
|
||||
.toString()
|
||||
.trim()
|
||||
version.commit = commit
|
||||
manifest.published_commit = commit
|
||||
await writeFile(join(appDir, 'version.json'), JSON.stringify(version, null, 2))
|
||||
} catch {
|
||||
// git commit may fail if nothing changed
|
||||
}
|
||||
|
||||
const record: LibraryAppRecord = {
|
||||
manifest,
|
||||
bundle_manifest: bundleManifest,
|
||||
current_version: version,
|
||||
}
|
||||
this.apps.set(appId, record)
|
||||
|
||||
return { app: record, created: !existing }
|
||||
}
|
||||
|
||||
async getWorkspace(appId: string): Promise<AppWorkspaceRecord | null> {
|
||||
const app = this.apps.get(appId)
|
||||
if (!app) return null
|
||||
|
||||
const appDir = join(this.appsDir, appId)
|
||||
let headCommit = ''
|
||||
let dirty = false
|
||||
|
||||
try {
|
||||
headCommit = execSync('git rev-parse HEAD', { cwd: appDir })
|
||||
.toString()
|
||||
.trim()
|
||||
const status = execSync('git status --porcelain', { cwd: appDir })
|
||||
.toString()
|
||||
.trim()
|
||||
dirty = status.length > 0
|
||||
} catch {
|
||||
// Not a git repo
|
||||
}
|
||||
|
||||
return {
|
||||
app_id: appId,
|
||||
cwd: appDir,
|
||||
branch: app.manifest.default_branch,
|
||||
head_commit: headCommit,
|
||||
dirty,
|
||||
bundle_manifest: app.bundle_manifest,
|
||||
}
|
||||
}
|
||||
|
||||
async publish(appId: string, message: string): Promise<AppPublishResult | null> {
|
||||
const app = this.apps.get(appId)
|
||||
if (!app) return null
|
||||
|
||||
const appDir = join(this.appsDir, appId)
|
||||
const now = Date.now()
|
||||
|
||||
try {
|
||||
execSync(`git add -A && git commit -m ${JSON.stringify(message)}`, {
|
||||
cwd: appDir,
|
||||
})
|
||||
} catch {
|
||||
// Nothing to commit
|
||||
}
|
||||
|
||||
let commit = ''
|
||||
try {
|
||||
commit = execSync('git rev-parse HEAD', { cwd: appDir })
|
||||
.toString()
|
||||
.trim()
|
||||
} catch {
|
||||
// Not a git repo
|
||||
}
|
||||
|
||||
const versionId = randomUUID()
|
||||
const version: LibraryAppVersionRecord = {
|
||||
...app.current_version,
|
||||
version_id: versionId,
|
||||
created_at: now,
|
||||
published_at: now,
|
||||
commit,
|
||||
changelog_summary: message,
|
||||
}
|
||||
|
||||
app.manifest.current_version_id = versionId
|
||||
app.manifest.published_commit = commit
|
||||
app.manifest.updated_at = now
|
||||
app.current_version = version
|
||||
|
||||
await writeFile(
|
||||
join(appDir, 'manifest.json'),
|
||||
JSON.stringify(app.manifest, null, 2),
|
||||
)
|
||||
await writeFile(
|
||||
join(appDir, 'version.json'),
|
||||
JSON.stringify(version, null, 2),
|
||||
)
|
||||
|
||||
const workspace = await this.getWorkspace(appId)
|
||||
|
||||
return { app, workspace: workspace! }
|
||||
}
|
||||
|
||||
archive(appId: string): boolean {
|
||||
const app = this.apps.get(appId)
|
||||
if (!app) return false
|
||||
app.manifest.visibility = 'archived'
|
||||
app.manifest.updated_at = Date.now()
|
||||
return true
|
||||
}
|
||||
|
||||
launch(appId: string): LibraryAppRecord | null {
|
||||
const app = this.apps.get(appId)
|
||||
if (!app) return null
|
||||
app.manifest.last_launched_at = Date.now()
|
||||
return app
|
||||
}
|
||||
|
||||
async getHistory(appId: string): Promise<AppHistoryResponse> {
|
||||
const appDir = join(this.appsDir, appId)
|
||||
const entries: AppHistoryEntry[] = []
|
||||
|
||||
try {
|
||||
const log = execSync(
|
||||
'git log --format="%H|%s|%at" --max-count=50',
|
||||
{ cwd: appDir },
|
||||
)
|
||||
.toString()
|
||||
.trim()
|
||||
for (const line of log.split('\n')) {
|
||||
if (!line) continue
|
||||
const [commit, message, timestamp] = line.split('|')
|
||||
entries.push({
|
||||
commit: commit!,
|
||||
message: message!,
|
||||
authored_at: parseInt(timestamp!, 10) * 1000,
|
||||
})
|
||||
}
|
||||
} catch {
|
||||
// Not a git repo or empty
|
||||
}
|
||||
|
||||
return { entries }
|
||||
}
|
||||
|
||||
async getAppFile(appId: string, filePath: string): Promise<Uint8Array | null> {
|
||||
const appDir = join(this.appsDir, appId)
|
||||
try {
|
||||
return await readFile(join(appDir, filePath)) as unknown as Uint8Array
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
reset(): void {
|
||||
this.apps.clear()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
/**
|
||||
* FeedStore — manages feed items and their payload files.
|
||||
*
|
||||
* Feed items are non-text outputs from Claude (images, HTML previews,
|
||||
* code files, diffs, etc.) that get surfaced in the Mini App.
|
||||
*/
|
||||
|
||||
import { randomUUID } from 'crypto'
|
||||
import { readFile, writeFile, mkdir, readdir, stat } from 'fs/promises'
|
||||
import { join, basename } from 'path'
|
||||
import type { FeedItemRecord, FeedItemKind, FeedItemSource } from './records.js'
|
||||
|
||||
export class FeedStore {
|
||||
private items = new Map<string, FeedItemRecord>()
|
||||
private stateRoot: string
|
||||
private payloadDir: string
|
||||
|
||||
constructor(stateRoot: string) {
|
||||
this.stateRoot = stateRoot
|
||||
this.payloadDir = join(stateRoot, 'claw', 'feed')
|
||||
}
|
||||
|
||||
async init(): Promise<void> {
|
||||
await mkdir(this.payloadDir, { recursive: true })
|
||||
// Load existing feed index if present
|
||||
try {
|
||||
const indexPath = join(this.payloadDir, 'index.json')
|
||||
const data = await readFile(indexPath, 'utf8')
|
||||
const records = JSON.parse(data) as FeedItemRecord[]
|
||||
for (const r of records) {
|
||||
this.items.set(r.feed_item_id, r)
|
||||
}
|
||||
} catch {
|
||||
// No existing index — start fresh
|
||||
}
|
||||
}
|
||||
|
||||
async addItem(
|
||||
title: string,
|
||||
kind: FeedItemKind,
|
||||
source: FeedItemSource,
|
||||
payload?: Uint8Array,
|
||||
options?: {
|
||||
mediaType?: string
|
||||
fileName?: string
|
||||
linkedAppId?: string
|
||||
previewText?: string
|
||||
},
|
||||
): Promise<FeedItemRecord> {
|
||||
const id = randomUUID()
|
||||
const now = Date.now()
|
||||
let storedPath: string | undefined
|
||||
|
||||
if (payload) {
|
||||
const ext = options?.fileName
|
||||
? basename(options.fileName)
|
||||
: id
|
||||
storedPath = join(this.payloadDir, ext)
|
||||
await writeFile(storedPath, payload)
|
||||
}
|
||||
|
||||
const record: FeedItemRecord = {
|
||||
feed_item_id: id,
|
||||
title,
|
||||
kind,
|
||||
source,
|
||||
linked_app_id: options?.linkedAppId,
|
||||
media_type: options?.mediaType,
|
||||
file_name: options?.fileName,
|
||||
stored_path: storedPath,
|
||||
preview_text: options?.previewText,
|
||||
deleted: false,
|
||||
created_at: now,
|
||||
updated_at: now,
|
||||
}
|
||||
|
||||
this.items.set(id, record)
|
||||
await this.persistIndex()
|
||||
return record
|
||||
}
|
||||
|
||||
getItem(feedItemId: string): FeedItemRecord | undefined {
|
||||
return this.items.get(feedItemId)
|
||||
}
|
||||
|
||||
listItems(turnId?: string): FeedItemRecord[] {
|
||||
let items = Array.from(this.items.values()).filter((i) => !i.deleted)
|
||||
if (turnId) {
|
||||
items = items.filter((i) => i.source.turn_id === turnId)
|
||||
}
|
||||
return items.sort((a, b) => b.created_at - a.created_at)
|
||||
}
|
||||
|
||||
async getPayload(feedItemId: string): Promise<Uint8Array | null> {
|
||||
const item = this.items.get(feedItemId)
|
||||
if (!item?.stored_path) return null
|
||||
try {
|
||||
return await readFile(item.stored_path) as unknown as Uint8Array
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
deleteItem(feedItemId: string): boolean {
|
||||
const item = this.items.get(feedItemId)
|
||||
if (!item) return false
|
||||
item.deleted = true
|
||||
item.updated_at = Date.now()
|
||||
return true
|
||||
}
|
||||
|
||||
reset(): void {
|
||||
this.items.clear()
|
||||
}
|
||||
|
||||
private async persistIndex(): Promise<void> {
|
||||
const indexPath = join(this.payloadDir, 'index.json')
|
||||
const records = Array.from(this.items.values())
|
||||
await writeFile(indexPath, JSON.stringify(records, null, 2))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* TaskStore — manages task lists and runtime tasks.
|
||||
*
|
||||
* Tracks the todo-list style tasks (TaskListRecord) and the
|
||||
* background runtime tasks (RuntimeTaskRecord) like agents and
|
||||
* shell processes.
|
||||
*/
|
||||
|
||||
import type {
|
||||
TaskListRecord,
|
||||
TaskListStatus,
|
||||
RuntimeTaskRecord,
|
||||
RuntimeTaskStatus,
|
||||
} from './records.js'
|
||||
|
||||
export class TaskStore {
|
||||
private taskListId = 'default'
|
||||
private tasks = new Map<string, TaskListRecord>()
|
||||
private runtimeTasks = new Map<string, RuntimeTaskRecord>()
|
||||
|
||||
getTaskListId(): string {
|
||||
return this.taskListId
|
||||
}
|
||||
|
||||
// ── Task list (todos) ─────────────────────────────────────────────
|
||||
|
||||
upsertTask(task: TaskListRecord): void {
|
||||
this.tasks.set(task.id, task)
|
||||
}
|
||||
|
||||
getTask(id: string): TaskListRecord | undefined {
|
||||
return this.tasks.get(id)
|
||||
}
|
||||
|
||||
listTasks(): TaskListRecord[] {
|
||||
return Array.from(this.tasks.values())
|
||||
}
|
||||
|
||||
removeTask(id: string): boolean {
|
||||
return this.tasks.delete(id)
|
||||
}
|
||||
|
||||
// ── Runtime tasks (agents, shells) ────────────────────────────────
|
||||
|
||||
upsertRuntimeTask(task: RuntimeTaskRecord): void {
|
||||
this.runtimeTasks.set(task.task_id, task)
|
||||
}
|
||||
|
||||
getRuntimeTask(taskId: string): RuntimeTaskRecord | undefined {
|
||||
return this.runtimeTasks.get(taskId)
|
||||
}
|
||||
|
||||
listRuntimeTasks(): RuntimeTaskRecord[] {
|
||||
return Array.from(this.runtimeTasks.values())
|
||||
}
|
||||
|
||||
listAgents(): RuntimeTaskRecord[] {
|
||||
return this.listRuntimeTasks().filter((t) => t.kind === 'agent')
|
||||
}
|
||||
|
||||
getAgent(agentId: string): RuntimeTaskRecord | undefined {
|
||||
for (const task of this.runtimeTasks.values()) {
|
||||
if (task.kind === 'agent' && (task.agent_id === agentId || task.task_id === agentId)) {
|
||||
return task
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
stopRuntimeTask(taskId: string): boolean {
|
||||
const task = this.runtimeTasks.get(taskId)
|
||||
if (!task || task.status !== 'running') return false
|
||||
task.status = 'stopped'
|
||||
task.completed_at = Date.now()
|
||||
return true
|
||||
}
|
||||
|
||||
reset(): void {
|
||||
this.tasks.clear()
|
||||
this.runtimeTasks.clear()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* TeamStore — manages team state and mailbox.
|
||||
*/
|
||||
|
||||
import type {
|
||||
TeamRecord,
|
||||
MailboxMessage,
|
||||
MailboxSummary,
|
||||
} from './records.js'
|
||||
|
||||
export class TeamStore {
|
||||
private team: TeamRecord | null = null
|
||||
private messages: MailboxMessage[] = []
|
||||
|
||||
getTeam(): TeamRecord | null {
|
||||
return this.team
|
||||
}
|
||||
|
||||
setTeam(team: TeamRecord): void {
|
||||
this.team = team
|
||||
}
|
||||
|
||||
deleteTeam(teamName: string): boolean {
|
||||
if (this.team?.team_name === teamName) {
|
||||
this.team = { ...this.team, deleted: true }
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// ── Mailbox ───────────────────────────────────────────────────────
|
||||
|
||||
addMessage(msg: MailboxMessage): void {
|
||||
this.messages.push(msg)
|
||||
}
|
||||
|
||||
getMailboxSummary(): MailboxSummary {
|
||||
return {
|
||||
team_name: this.team?.team_name,
|
||||
recent_messages: this.messages.slice(-50),
|
||||
}
|
||||
}
|
||||
|
||||
getPendingMessages(recipient: string): MailboxMessage[] {
|
||||
return this.messages.filter(
|
||||
(m) => m.recipient === recipient && !m.envelope.read,
|
||||
)
|
||||
}
|
||||
|
||||
markRead(messageId: string): void {
|
||||
const msg = this.messages.find((m) => m.envelope.id === messageId)
|
||||
if (msg) msg.envelope.read = true
|
||||
}
|
||||
|
||||
reset(): void {
|
||||
this.team = null
|
||||
this.messages = []
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,288 @@
|
||||
/**
|
||||
* Protocol-owned record types — TS mirrors of the Rust records in
|
||||
* channel-gateway-core/src/records.rs.
|
||||
*
|
||||
* These are the wire shapes the gateway expects. They replace the
|
||||
* opaque Record<string, unknown> placeholders in protocol.ts with
|
||||
* real typed structures.
|
||||
*/
|
||||
|
||||
// ── Task list ───────────────────────────────────────────────────────
|
||||
|
||||
export type TaskListStatus = 'pending' | 'in_progress' | 'completed'
|
||||
|
||||
export type TaskListRecord = {
|
||||
id: string
|
||||
subject: string
|
||||
description: string
|
||||
activeForm?: string
|
||||
owner?: string
|
||||
status: TaskListStatus
|
||||
blocks: string[]
|
||||
blockedBy: string[]
|
||||
metadata?: Record<string, unknown>
|
||||
internal: boolean
|
||||
createdAt: number
|
||||
updatedAt: number
|
||||
}
|
||||
|
||||
// ── Runtime task ────────────────────────────────────────────────────
|
||||
|
||||
export type RuntimeTaskKind = 'agent' | 'shell'
|
||||
export type RuntimeTaskStatus = 'running' | 'completed' | 'failed' | 'stopped'
|
||||
|
||||
export type RuntimeTaskRecord = {
|
||||
task_id: string
|
||||
kind: RuntimeTaskKind
|
||||
status: RuntimeTaskStatus
|
||||
description: string
|
||||
prompt: string
|
||||
output_file?: string
|
||||
exit_code_file?: string
|
||||
final_result?: string
|
||||
error?: string
|
||||
exit_code?: number
|
||||
notified: boolean
|
||||
pid?: number
|
||||
agent_id?: string
|
||||
agent_name?: string
|
||||
team_name?: string
|
||||
cwd?: string
|
||||
worktree_path?: string
|
||||
worktree_branch?: string
|
||||
created_at: number
|
||||
started_at: number
|
||||
completed_at?: number
|
||||
}
|
||||
|
||||
// ── Team ────────────────────────────────────────────────────────────
|
||||
|
||||
export type TeamMemberRecord = {
|
||||
agent_id: string
|
||||
name: string
|
||||
agent_type?: string
|
||||
model?: string
|
||||
status?: string
|
||||
joined_at: number
|
||||
}
|
||||
|
||||
export type TeamRecord = {
|
||||
team_name: string
|
||||
description?: string
|
||||
agent_type?: string
|
||||
lead_agent_id: string
|
||||
created_at: number
|
||||
updated_at: number
|
||||
deleted: boolean
|
||||
members: TeamMemberRecord[]
|
||||
}
|
||||
|
||||
// ── Mailbox ─────────────────────────────────────────────────────────
|
||||
|
||||
export type MessageEnvelope = {
|
||||
id: string
|
||||
from: string
|
||||
to: string
|
||||
summary?: string
|
||||
message: unknown
|
||||
timestamp: number
|
||||
read: boolean
|
||||
notified: boolean
|
||||
}
|
||||
|
||||
export type MailboxMessage = {
|
||||
recipient: string
|
||||
envelope: MessageEnvelope
|
||||
}
|
||||
|
||||
export type MailboxSummary = {
|
||||
team_name?: string
|
||||
recent_messages: MailboxMessage[]
|
||||
}
|
||||
|
||||
// ── Background approval ─────────────────────────────────────────────
|
||||
|
||||
export type BackgroundApprovalDecision =
|
||||
| { decision: 'approve_once' }
|
||||
| { decision: 'approve_tool_for_session' }
|
||||
| { decision: 'approve_all_for_session' }
|
||||
| { decision: 'deny'; reason: string }
|
||||
| { decision: 'cancel_turn' }
|
||||
|
||||
export type BackgroundApprovalRecord = {
|
||||
approval_id: string
|
||||
task_id: string
|
||||
tool_name: string
|
||||
input: string
|
||||
current_mode: string
|
||||
required_mode: string
|
||||
reason?: string
|
||||
created_at: number
|
||||
notified: boolean
|
||||
decision?: BackgroundApprovalDecision
|
||||
}
|
||||
|
||||
// ── Feed ────────────────────────────────────────────────────────────
|
||||
|
||||
export type FeedItemKind =
|
||||
| 'markdown'
|
||||
| 'code'
|
||||
| 'json'
|
||||
| 'diff'
|
||||
| 'image'
|
||||
| 'html_preview'
|
||||
| 'table'
|
||||
| 'binary'
|
||||
| 'deleted_file'
|
||||
| 'app_published'
|
||||
|
||||
export type FeedItemSourceKind = 'generated' | 'workspace' | 'app_event'
|
||||
export type FeedItemChangeKind = 'created' | 'modified' | 'deleted'
|
||||
|
||||
export type FeedItemSource = {
|
||||
source_kind: FeedItemSourceKind
|
||||
turn_id?: string
|
||||
source_file_id?: string
|
||||
source_files: string[]
|
||||
change_kind?: FeedItemChangeKind
|
||||
}
|
||||
|
||||
export type FeedItemRecord = {
|
||||
feed_item_id: string
|
||||
title: string
|
||||
kind: FeedItemKind
|
||||
source: FeedItemSource
|
||||
linked_app_id?: string
|
||||
media_type?: string
|
||||
file_name?: string
|
||||
stored_path?: string
|
||||
preview_text?: string
|
||||
deleted: boolean
|
||||
created_at: number
|
||||
updated_at: number
|
||||
}
|
||||
|
||||
// ── App library ─────────────────────────────────────────────────────
|
||||
|
||||
export type AppKind =
|
||||
| 'html_page'
|
||||
| 'react_app'
|
||||
| 'dashboard'
|
||||
| 'document_experience'
|
||||
| 'tool_app'
|
||||
|
||||
export type AppVisibility = 'family' | 'admin' | 'archived'
|
||||
|
||||
export type AppCapability =
|
||||
| 'get_context'
|
||||
| 'list_files'
|
||||
| 'read_text'
|
||||
| 'read_json'
|
||||
| 'open_feed_item'
|
||||
| 'open_app'
|
||||
| 'publish_patch'
|
||||
| 'request_action'
|
||||
| 'emit_event'
|
||||
|
||||
export type AppRepoLink = {
|
||||
url: string
|
||||
branch?: string
|
||||
commit?: string
|
||||
}
|
||||
|
||||
export type LibraryAppManifestV2 = {
|
||||
schema_version: string
|
||||
app_id: string
|
||||
title: string
|
||||
name: string
|
||||
description?: string
|
||||
visibility: AppVisibility
|
||||
created_at: number
|
||||
updated_at: number
|
||||
last_launched_at: number
|
||||
created_from_feed_item_id?: string
|
||||
current_version_id: string
|
||||
published_commit?: string
|
||||
default_branch: string
|
||||
local_repo_path: string
|
||||
remote_repo?: AppRepoLink
|
||||
kind: AppKind
|
||||
icon?: string
|
||||
tags: string[]
|
||||
capabilities: AppCapability[]
|
||||
source_turn_id?: string
|
||||
source_feed_item_ids: string[]
|
||||
}
|
||||
|
||||
export type AppBundleManifestV1 = {
|
||||
schema_version: string
|
||||
app_id: string
|
||||
name: string
|
||||
title: string
|
||||
description?: string
|
||||
kind: AppKind
|
||||
entry: string
|
||||
files: string[]
|
||||
icon?: string
|
||||
capabilities: AppCapability[]
|
||||
tags: string[]
|
||||
}
|
||||
|
||||
export type LibraryAppVersionRecord = {
|
||||
version_id: string
|
||||
created_at: number
|
||||
entry: string
|
||||
files: string[]
|
||||
branch: string
|
||||
commit?: string
|
||||
published_at?: number
|
||||
source_turn_id?: string
|
||||
source_feed_item_ids: string[]
|
||||
changelog_summary?: string
|
||||
}
|
||||
|
||||
export type LibraryAppRecord = {
|
||||
manifest: LibraryAppManifestV2
|
||||
bundle_manifest: AppBundleManifestV1
|
||||
current_version: LibraryAppVersionRecord
|
||||
}
|
||||
|
||||
export type AppWorkspaceRecord = {
|
||||
app_id: string
|
||||
cwd: string
|
||||
branch: string
|
||||
head_commit: string
|
||||
dirty: boolean
|
||||
bundle_manifest: AppBundleManifestV1
|
||||
}
|
||||
|
||||
export type AppPackageRequest = {
|
||||
feed_item_id: string
|
||||
requested_app_id?: string
|
||||
title?: string
|
||||
description?: string
|
||||
}
|
||||
|
||||
export type AppPackageResult = {
|
||||
app: LibraryAppRecord
|
||||
created: boolean
|
||||
}
|
||||
|
||||
export type AppPublishRequest = {
|
||||
message: string
|
||||
}
|
||||
|
||||
export type AppPublishResult = {
|
||||
app: LibraryAppRecord
|
||||
workspace: AppWorkspaceRecord
|
||||
}
|
||||
|
||||
export type AppHistoryEntry = {
|
||||
commit: string
|
||||
message: string
|
||||
authored_at: number
|
||||
}
|
||||
|
||||
export type AppHistoryResponse = {
|
||||
entries: AppHistoryEntry[]
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
/**
|
||||
* TurnManager — owns the lifecycle of a single user turn.
|
||||
*
|
||||
* Each turn gets a unique ID. The gateway:
|
||||
* 1. POSTs /v1/turns → gets back { turn_id }
|
||||
* 2. GETs /v1/turns/:turn_id/events → SSE stream of WorkerTurnEvent
|
||||
* 3. POSTs /v1/turns/:turn_id/approval → resolves a pending tool approval
|
||||
* 4. POSTs /v1/turns/:turn_id/cancel → aborts the turn
|
||||
*
|
||||
* Internally we hold:
|
||||
* - a queue of WorkerTurnEvent waiting to be flushed to SSE clients
|
||||
* - an optional pending approval (blocks the engine until resolved)
|
||||
* - an AbortController so cancel works
|
||||
*/
|
||||
|
||||
import { randomUUID } from 'crypto'
|
||||
import type {
|
||||
ApprovalDecision,
|
||||
WorkerTurnEvent,
|
||||
WorkerTurnRequest,
|
||||
} from './protocol.js'
|
||||
|
||||
export type PendingApproval = {
|
||||
approval_id: string
|
||||
resolve: (decision: ApprovalDecision) => void
|
||||
}
|
||||
|
||||
export type Turn = {
|
||||
id: string
|
||||
request: WorkerTurnRequest
|
||||
events: WorkerTurnEvent[]
|
||||
/** SSE clients listening for events on this turn */
|
||||
listeners: Set<(event: WorkerTurnEvent) => void>
|
||||
pendingApproval: PendingApproval | null
|
||||
abortController: AbortController
|
||||
done: boolean
|
||||
}
|
||||
|
||||
export class TurnManager {
|
||||
private turns = new Map<string, Turn>()
|
||||
|
||||
create(request: WorkerTurnRequest): Turn {
|
||||
const id = randomUUID()
|
||||
const turn: Turn = {
|
||||
id,
|
||||
request,
|
||||
events: [],
|
||||
listeners: new Set(),
|
||||
pendingApproval: null,
|
||||
abortController: new AbortController(),
|
||||
done: false,
|
||||
}
|
||||
this.turns.set(id, turn)
|
||||
return turn
|
||||
}
|
||||
|
||||
get(turnId: string): Turn | undefined {
|
||||
return this.turns.get(turnId)
|
||||
}
|
||||
|
||||
/** Push an event to the turn's log and broadcast to all SSE listeners. */
|
||||
emit(turnId: string, event: WorkerTurnEvent): void {
|
||||
const turn = this.turns.get(turnId)
|
||||
if (!turn) return
|
||||
turn.events.push(event)
|
||||
for (const listener of turn.listeners) {
|
||||
listener(event)
|
||||
}
|
||||
if (event.type === 'completed' || event.type === 'failed') {
|
||||
turn.done = true
|
||||
}
|
||||
}
|
||||
|
||||
/** Register an SSE listener. Returns unsubscribe function. */
|
||||
subscribe(
|
||||
turnId: string,
|
||||
listener: (event: WorkerTurnEvent) => void,
|
||||
): (() => void) | null {
|
||||
const turn = this.turns.get(turnId)
|
||||
if (!turn) return null
|
||||
|
||||
// Replay buffered events first
|
||||
for (const event of turn.events) {
|
||||
listener(event)
|
||||
}
|
||||
|
||||
if (turn.done) return null
|
||||
|
||||
turn.listeners.add(listener)
|
||||
return () => {
|
||||
turn.listeners.delete(listener)
|
||||
}
|
||||
}
|
||||
|
||||
/** Set a pending approval on the turn. Returns a promise that resolves
|
||||
* when the gateway sends the decision. */
|
||||
requestApproval(turnId: string, approvalId: string): Promise<ApprovalDecision> {
|
||||
const turn = this.turns.get(turnId)
|
||||
if (!turn) return Promise.reject(new Error(`unknown turn ${turnId}`))
|
||||
|
||||
return new Promise<ApprovalDecision>((resolve) => {
|
||||
turn.pendingApproval = { approval_id: approvalId, resolve }
|
||||
})
|
||||
}
|
||||
|
||||
resolveApproval(turnId: string, approvalId: string, decision: ApprovalDecision): boolean {
|
||||
const turn = this.turns.get(turnId)
|
||||
if (!turn?.pendingApproval) return false
|
||||
if (turn.pendingApproval.approval_id !== approvalId) return false
|
||||
turn.pendingApproval.resolve(decision)
|
||||
turn.pendingApproval = null
|
||||
return true
|
||||
}
|
||||
|
||||
cancel(turnId: string): boolean {
|
||||
const turn = this.turns.get(turnId)
|
||||
if (!turn) return false
|
||||
turn.abortController.abort()
|
||||
return true
|
||||
}
|
||||
|
||||
/** Prune completed turns older than `maxAgeMs`. */
|
||||
prune(maxAgeMs = 5 * 60 * 1000): void {
|
||||
const now = Date.now()
|
||||
for (const [id, turn] of this.turns) {
|
||||
if (turn.done) {
|
||||
const lastEvent = turn.events[turn.events.length - 1]
|
||||
// Simple heuristic — if turn is done and old, drop it
|
||||
if (lastEvent && turn.events.length > 0) {
|
||||
this.turns.delete(id)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
get activeTurnId(): string | null {
|
||||
for (const [id, turn] of this.turns) {
|
||||
if (!turn.done) return id
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
get isBusy(): boolean {
|
||||
return this.activeTurnId !== null
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user