astrid-runtime/sdk-js

Features

• Capsule Authoring SDKs - Provides a typed JavaScript and TypeScript toolkit for authoring capsules with filesystem, networking, messaging, storage and identity modules exposed through decorators.
• TypeScript Runtime Extension SDKs - Provides a typed JavaScript and TypeScript API for writing capsules that target the same host contract as the native Rust toolkit.
• Sandboxed Capsule Authoring APIs - Offers a typed API organized by module for files, networking, messaging, storage, web requests, hooks, and identity, with decorators for tools and lifecycle handlers.
• WebAssembly Capsule Development - Lets authors write capsule logic in TypeScript with decorators and compile it into WebAssembly components that run alongside natively built capsules.
• Host Service Bindings - Exposes filesystem, networking, process, storage, identity, and messaging modules that map onto one host contract shared with the native toolkit.
• Sandboxed Plugin Runtimes - Supports writing sandboxed extensions that run inside a host runtime and reach host resources only through a typed, controlled service surface.
• Plugin Compilation to WebAssembly - Type-checks source, bundles it into a single module, and converts it into a portable WebAssembly component through an automated pipeline.
• WebAssembly Build Systems - Runs a pipeline that type-checks TypeScript, bundles it into one module and converts it into a WebAssembly component ready to load.
• Key-Value Stores - Provides shared key-value storage with schema-versioned migrations, atomic compare-and-swap updates, and paginated key listing.
• Component Archive Packaging - Packs the compiled component with its manifest and interface definitions into a single compressed archive automatically.
• Background Process Offloading - Launches persistent background processes that outlive the caller and can be reconnected by saved id to read logs, send input, signal, or stop.
• JSON Message Exchanges - Generates message, tool-call, and stream-event types from one shared contract so both ends of an exchange use identical shapes.
• Outbound HTTP Requests - Sends outbound HTTP requests that return standard response objects, with request controls, response metadata, and a fluent builder.
• TCP and UDP Socket Interfaces - Offers outbound HTTP requests, TCP and UDP sockets, and DNS lookups so capsules can talk to remote services.
• Decorator-Based Declarations - Uses decorators on classes and methods to declare tools, commands, hooks, interceptors, and install, upgrade, and startup entry points.
• WebAssembly Component Models - Runs a type checker, a bundler, and a component tool in sequence to turn source code into a loadable WebAssembly component.
• Request-Reply Patterns - Implements request-reply messaging over asynchronous channels, using unique ids and timeouts to match each reply to its request.
• Host Service Bindings - Provides typed modules for files, networking, processes, storage, and messaging that map onto one shared host interface also implemented by a native toolkit.
• Sandboxed Plugin Runtime Clients - Ships a client-side library that sandboxed capsules use to call host services through a contract shared with the native Rust toolkit.
• Typed Message Processing - Exchanges messages, tool calls, and stream events using generated shared types plus request-reply messaging with unique ids and timeouts.
• Class Decorators - Uses class and method decorators to declare tools, commands, hooks, interceptors, and install, upgrade, and startup entry points.
• Shared Message Contracts - Generates message, tool-call and stream-event types from one shared contract file so both sides of an exchange use identical definitions.

Star history