@xtrape/capsule-agent-node 0.1.0-public-review.0

package/LICENSE

@@ -0,0 +1,48 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on the Work and for which editorial revisions, annotations, elaborations, or other modifications represent an original work of authorship.
+
+"Contribution" shall mean any work of authorship intentionally submitted to Licensor for inclusion in the Work by the copyright owner or authorized representative.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor grants You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor grants You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, use, sell, offer to sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works in any medium, with or without modifications, provided that You meet the following conditions:
+
+(a) You must give recipients a copy of this License; and
+(b) You must cause modified files to carry prominent notices; and
+(c) You must retain copyright, patent, trademark, and attribution notices; and
+(d) If the Work includes a NOTICE file, any Derivative Works that You distribute must include a readable copy of attribution notices from that NOTICE file.
+
+5. Submission of Contributions. Unless explicitly stated otherwise, any Contribution submitted for inclusion in the Work shall be under the terms of this License.
+
+6. Trademarks. This License does not grant permission to use trade names, trademarks, service marks, or product names of the Licensor.
+
+7. Disclaimer of Warranty. Unless required by law or agreed to in writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
+
+8. Limitation of Liability. In no event shall any Contributor be liable for damages arising from use of the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work, You may offer support, warranty, or other liability obligations only on Your own behalf.
+
+END OF TERMS AND CONDITIONS

package/NOTICE

@@ -0,0 +1,4 @@
+Opstage CE
+Copyright 2026 Xtrape Capsule contributors
+
+This product includes software developed by the Xtrape Capsule contributors.

package/README.md

@@ -0,0 +1,319 @@
+# @xtrape/capsule-agent-node
+
+> Node.js embedded Agent SDK for connecting Capsule Services to Opstage.
+
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE)
+[![Status: Public Review](https://img.shields.io/badge/status-Public%20Review-orange.svg)](https://xtrape-com.github.io/xtrape-capsule-site/)
+[![Docs](https://img.shields.io/badge/docs-xtrape--capsule--site-blue.svg)](https://xtrape-com.github.io/xtrape-capsule-site/agents/node-embedded-agent)
+
+`@xtrape/capsule-agent-node` embeds an Opstage Agent inside a Node.js service.
+The Agent registers with Opstage CE, persists its Agent token, sends heartbeats,
+reports service metadata, exposes configs and health, and polls Commands for
+operator-triggered Actions.
+
+> **Package status:** Xtrape Capsule is currently in **Public Review** before
+> the `v0.1.0 Public Preview` release. This package is published under the
+> `public-review` dist-tag. APIs, contracts, deployment instructions, and SDK
+> interfaces may still change.
+
+## Install
+
+During Public Review, install the prerelease package with:
+
+```bash
+pnpm add @xtrape/capsule-agent-node@public-review
+```
+
+The current Public Review version may change before `v0.1.0`.
+
+For this repository itself:
+
+```bash
+pnpm install
+pnpm build
+```
+
+## Minimal Example
+
+This example matches the current SDK API: create a `CapsuleAgent`, configure
+providers with `.health()` / `.configs()`, register Actions with `.action()`,
+then call `start()`.
+
+```ts
+import { CapsuleAgent } from "@xtrape/capsule-agent-node";
+
+const agent = new CapsuleAgent({
+  backendUrl: process.env.OPSTAGE_BACKEND_URL ?? "http://localhost:8080",
+  registrationToken: process.env.OPSTAGE_REGISTRATION_TOKEN,
+  tokenStore: { file: "./data/agent-token.txt" },
+  service: {
+    code: "hello-capsule",
+    name: "Hello Capsule",
+    version: "0.1.0",
+    runtime: "nodejs",
+    description: "Minimal Capsule Service example",
+  },
+});
+
+agent.health(() => ({
+  status: "UP",
+  message: "ok",
+  details: {
+    uptimeSeconds: Math.floor(process.uptime()),
+  },
+}));
+
+agent.configs(() => [
+  {
+    key: "HELLO_MODE",
+    label: "Hello mode",
+    type: "string",
+    editable: false,
+    sensitive: false,
+    valuePreview: process.env.HELLO_MODE ?? "default",
+  },
+]);
+
+agent.action({
+  name: "echo",
+  label: "Echo",
+  description: "Return the submitted message.",
+  dangerLevel: "LOW",
+  requiresConfirmation: false,
+  inputSchema: {
+    type: "object",
+    required: ["message"],
+    properties: {
+      message: { type: "string", default: "hello" },
+    },
+  },
+  prepare: () => ({
+    initialPayload: { message: "hello" },
+    currentState: { service: "ready" },
+  }),
+  handler: async (payload) => ({
+    success: true,
+    data: { echo: payload.message },
+  }),
+});
+
+await agent.start();
+```
+
+## How Registration Works
+
+1. An operator creates a single-use Registration Token in Opstage CE.
+2. The service starts with `registrationToken` and calls the Agent registration
+   API.
+3. Opstage returns an Agent ID and Agent token.
+4. The SDK stores the issued credentials in `tokenStore.file` as `<agentId>:<agentToken>`.
+5. Future restarts reuse the stored Agent token; the Registration Token is not
+   needed again.
+
+If the token file is lost or the Agent is revoked, create a new Registration
+Token and restart the service with it.
+
+## Service Manifest
+
+The `service` option describes the Capsule Service reported to Opstage:
+
+```ts
+service: {
+  code: "hello-capsule",          // stable unique service code
+  name: "Hello Capsule",         // operator-facing display name
+  description: "...",            // optional
+  version: "0.1.0",              // service version
+  runtime: "nodejs",             // nodejs | java | python | go | other
+  manifest: { labels: { team: "ai" } }, // optional passthrough metadata
+}
+```
+
+The SDK wraps this as a `CapsuleService` manifest with `kind: "CapsuleService"`,
+`schemaVersion: "1.0"`, and `agentMode: "embedded"`.
+
+## Health Reporting
+
+Use `.health(provider)` to report protocol-level health:
+
+```ts
+agent.health(async () => ({
+  status: "UP", // UP | DEGRADED | DOWN | UNKNOWN
+  message: "queue healthy",
+  details: { queueDepth: 0 },
+}));
+```
+
+The provider runs for heartbeats and service reports. Do not include secrets in
+`details`.
+
+Agent health providers return protocol-level `HealthStatus` values: `UP`,
+`DEGRADED`, `DOWN`, `UNKNOWN`.
+
+Opstage may derive an operator-facing `effectiveStatus`: `HEALTHY`, `UNHEALTHY`,
+`STALE`, `OFFLINE`.
+
+## Config Reporting
+
+Use `.configs(provider)` to report observed config metadata:
+
+```ts
+agent.configs(() => [
+  {
+    key: "UPSTREAM_BASE_URL",
+    type: "string",
+    sensitive: false,
+    editable: false,
+    valuePreview: process.env.UPSTREAM_BASE_URL,
+  },
+  {
+    key: "UPSTREAM_API_KEY",
+    type: "secret",
+    sensitive: true,
+    editable: false,
+    valuePreview: "[REDACTED]",
+    secretRef: "env://UPSTREAM_API_KEY",
+  },
+]);
+```
+
+Configs are reported to Opstage for visibility; the current CE flow does not
+push config values from Opstage into the service.
+
+## Actions
+
+Use `.action()` to expose an operator-triggerable operation:
+
+```ts
+agent.action({
+  name: "reload-cache",
+  label: "Reload Cache",
+  dangerLevel: "MEDIUM",
+  requiresConfirmation: true,
+  timeoutSeconds: 30,
+  handler: async () => {
+    await reloadCache();
+    return { success: true, message: "Cache reloaded." };
+  },
+});
+```
+
+Action metadata is published in the service report. The SDK intentionally strips
+runtime-only handler functions before reporting the Action Catalog.
+
+## Action Prepare / Execute
+
+Opstage uses two Command types for actions:
+
+1. `ACTION_PREPARE` — created when the UI opens an Action panel. The SDK calls
+   `prepare()` if present and returns dynamic form metadata such as
+   `inputSchema`, `initialPayload`, and `currentState`.
+2. `ACTION_EXECUTE` — created when the operator confirms the Action. The SDK
+   calls `handler(payload)` and reports the result.
+
+If an Action has no `prepare` handler, the SDK returns a default prepare payload
+based on the action metadata and `inputSchema` defaults.
+
+## Command Polling
+
+The embedded Agent starts three loops by default:
+
+| Loop           |    Default | Purpose                            |
+| -------------- | ---------: | ---------------------------------- |
+| Heartbeat      | 30 seconds | Agent liveness and latest health   |
+| Service report | 60 seconds | Manifest, configs, actions, health |
+| Command poll   |  5 seconds | Fetch and execute pending Commands |
+
+You can override intervals:
+
+```ts
+new CapsuleAgent({
+  // ...
+  intervals: {
+    heartbeatMs: 30_000,
+    serviceReportMs: 60_000,
+    commandPollMs: 5_000,
+  },
+});
+```
+
+For tests, set `autoStartLoops: false` and call `start()` to perform one
+registration/report/heartbeat/poll cycle.
+
+## Token Storage
+
+The default token store is file-based via `FileTokenStore`. Store the token file
+in a private data directory:
+
+```ts
+new CapsuleAgent({
+  // ...
+  tokenStore: { file: "./data/agent-token.txt" },
+});
+```
+
+Security recommendations:
+
+- chmod the containing directory so only the service user can read it;
+- never commit token files;
+- rotate by revoking the Agent in Opstage and registering a new one;
+- prefer secret managers for production wrappers when available.
+
+## Security Notes
+
+- Registration Tokens are single-use bootstrap credentials.
+- Agent Tokens are long-lived bearer tokens; treat them as secrets.
+- Actions are remote operational capabilities. Use `dangerLevel`,
+  `requiresConfirmation`, and server-side validation in handlers.
+- Do not report raw passwords, API keys, cookies, OTPs, browser storage, or
+  session files through health/config/action results.
+- Logs are redacted by the SDK where possible, but service handlers remain
+  responsible for avoiding secret leakage.
+
+## API Reference
+
+Main exports:
+
+- `CapsuleAgent`
+- `FileTokenStore`
+- `AgentApiClient`
+- `AgentApiError`
+- SDK option and provider types from `types.ts`
+
+Core methods:
+
+| Method                      | Description                                                   |
+| --------------------------- | ------------------------------------------------------------- |
+| `new CapsuleAgent(options)` | Creates the embedded Agent.                                   |
+| `.health(provider)`         | Registers a health provider.                                  |
+| `.configs(provider)`        | Registers a config provider.                                  |
+| `.action(action)`           | Registers an operator Action.                                 |
+| `.start()`                  | Registers if needed, reports service state, and starts loops. |
+| `.stop()`                   | Stops background loops.                                       |
+| `.runHealth()`              | Runs the configured health provider.                          |
+
+## Version Compatibility
+
+| Package                            | Compatible with                                               |
+| ---------------------------------- | ------------------------------------------------------------- |
+| `@xtrape/capsule-agent-node@0.1.x` | Opstage CE `0.1.x` and `@xtrape/capsule-contracts-node@0.1.x` |
+
+Use matching minor versions across CE, Agent SDK, and Contracts during Public
+Review and Public Preview. The wire protocol may still change before `v1.0`.
+
+## Documentation
+
+- Site: https://xtrape-com.github.io/xtrape-capsule-site/
+- Node embedded Agent guide: https://xtrape-com.github.io/xtrape-capsule-site/agents/node-embedded-agent
+- Action model: https://xtrape-com.github.io/xtrape-capsule-site/agents/action-model
+- Opstage CE: https://xtrape-com.github.io/xtrape-capsule-site/opstage-ce/overview
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for development workflow and PR checks.
+See [SECURITY.md](./SECURITY.md) for vulnerability reporting and token/action
+safety guidance.
+
+## License
+
+Apache-2.0. "Xtrape", "Xtrape Capsule", and "Opstage" are trademarks of their
+respective owners; the open-source license does not grant trademark rights.

package/dist/index.cjs

@@ -0,0 +1,293 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentApiClient: () => AgentApiClient,
+  AgentApiError: () => AgentApiError,
+  CapsuleAgent: () => CapsuleAgent,
+  FileTokenStore: () => FileTokenStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/errors.ts
+var AgentApiError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+  status;
+  body;
+};
+
+// src/client/agent-api-client.ts
+var AgentApiClient = class {
+  constructor(backendUrl) {
+    this.backendUrl = backendUrl;
+  }
+  backendUrl;
+  url(path) {
+    return new URL(path, this.backendUrl).toString();
+  }
+  async request(path, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("content-type", "application/json");
+    if (init.token) headers.set("authorization", `Bearer ${init.token}`);
+    const res = await fetch(this.url(path), { ...init, headers });
+    const text = await res.text();
+    const body = text ? JSON.parse(text) : void 0;
+    if (!res.ok) throw new AgentApiError(res.status, body?.error?.message ?? res.statusText, body);
+    return body?.data ?? body;
+  }
+  register(req) {
+    return this.request("/api/agents/register", { method: "POST", body: JSON.stringify(req) });
+  }
+  heartbeat(agentId, token, req) {
+    return this.request(`/api/agents/${agentId}/heartbeat`, { method: "POST", token, body: JSON.stringify(req) });
+  }
+  reportServices(agentId, token, req) {
+    return this.request(`/api/agents/${agentId}/services/report`, { method: "POST", token, body: JSON.stringify(req) });
+  }
+  pollCommands(agentId, token) {
+    return this.request(`/api/agents/${agentId}/commands`, { method: "GET", token });
+  }
+  reportResult(agentId, token, commandId, req) {
+    return this.request(`/api/agents/${agentId}/commands/${commandId}/result`, { method: "POST", token, body: JSON.stringify(req) });
+  }
+};
+
+// src/token-store/file-token-store.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var FileTokenStore = class {
+  constructor(filePath = "./data/agent-token.json") {
+    this.filePath = filePath;
+  }
+  filePath;
+  async load() {
+    try {
+      const parsed = JSON.parse(await (0, import_promises.readFile)(this.filePath, "utf8"));
+      if (typeof parsed.agentId === "string" && typeof parsed.agentToken === "string") return `${parsed.agentId}:${parsed.agentToken}`;
+      return typeof parsed.agentToken === "string" ? parsed.agentToken : null;
+    } catch (e) {
+      if (e?.code === "ENOENT") return null;
+      throw e;
+    }
+  }
+  async save(token) {
+    const [agentId, agentToken] = token.includes(":") ? token.split(":", 2) : [void 0, token];
+    await (0, import_promises.mkdir)((0, import_node_path.dirname)(this.filePath), { recursive: true });
+    await (0, import_promises.writeFile)(this.filePath, JSON.stringify({ ...agentId ? { agentId } : {}, agentToken, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), { mode: 384 });
+    try {
+      await (0, import_promises.chmod)(this.filePath, 384);
+    } catch {
+    }
+  }
+  async clear() {
+    await (0, import_promises.rm)(this.filePath, { force: true });
+  }
+};
+
+// src/security/redaction.ts
+function redact(value) {
+  if (typeof value === "string") return value.replace(/opstage_(reg|agent)_[A-Za-z0-9_-]+/g, "opstage_$1_[REDACTED]");
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(redact);
+  return Object.fromEntries(Object.entries(value).map(([k, v]) => [/token|secret|password|authorization/i.test(k) ? [k, "[REDACTED]"] : [k, redact(v)]]));
+}
+
+// src/capsule-agent.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var CapsuleAgent = class {
+  constructor(options) {
+    this.options = options;
+    this.client = new AgentApiClient(options.backendUrl);
+    this.store = new FileTokenStore(options.tokenStore?.file);
+    this.logger = options.logger ?? console;
+  }
+  options;
+  client;
+  store;
+  logger;
+  agentId;
+  token;
+  stopped = true;
+  timers = [];
+  healthProvider = () => ({ status: "UNKNOWN" });
+  configProvider = () => [];
+  actions = /* @__PURE__ */ new Map();
+  health(provider) {
+    this.healthProvider = provider;
+    return this;
+  }
+  configs(provider) {
+    this.configProvider = provider;
+    return this;
+  }
+  action(action) {
+    this.actions.set(action.name, action);
+    return this;
+  }
+  async start() {
+    this.stopped = false;
+    try {
+      await this.ensureRegistered();
+      await this.reportService();
+      await this.heartbeat();
+      await this.pollOnce();
+    } catch (e) {
+      this.log("error", "agent start failed", e);
+      if (this.options.failOnStartError) throw e;
+    }
+    if (this.options.autoStartLoops !== false) {
+      this.loop("heartbeat", this.options.intervals?.heartbeatMs ?? (this.options.heartbeatIntervalSeconds ?? 30) * 1e3, () => this.heartbeat());
+      this.loop("service-report", this.options.intervals?.serviceReportMs ?? 6e4, () => this.reportService());
+      this.loop("command-poll", this.options.intervals?.commandPollMs ?? (this.options.commandPollIntervalSeconds ?? 5) * 1e3, () => this.pollOnce());
+    }
+  }
+  async stop() {
+    this.stopped = true;
+    for (const t of this.timers) clearInterval(t);
+    this.timers = [];
+  }
+  loop(name, ms, fn) {
+    const t = setInterval(async () => {
+      if (this.stopped) return;
+      try {
+        await fn();
+      } catch (e) {
+        this.log("warn", `${name} failed`, e);
+      }
+    }, ms);
+    this.timers.push(t);
+  }
+  async ensureRegistered() {
+    const stored = await this.store.load();
+    if (stored) {
+      const [agentId, token] = stored.includes(":") ? stored.split(":", 2) : [void 0, stored];
+      this.agentId = agentId;
+      this.token = token;
+      if (this.agentId) return;
+    }
+    if (!this.options.registrationToken) throw new Error("OPSTAGE registration token is required for first registration");
+    const agent = this.options.agent ?? { code: this.options.service.code, name: this.options.service.name, runtime: this.options.service.runtime };
+    const res = await this.retry(() => this.client.register({ registrationToken: this.options.registrationToken, agent: { code: agent.code, name: agent.name, mode: "embedded", runtime: agent.runtime ?? "nodejs" }, service: this.serviceSnapshot() }));
+    this.agentId = res.agentId;
+    this.token = res.agentToken;
+    await this.store.save(`${this.agentId}:${this.token}`);
+    this.log("info", `registered agent ${this.agentId}`);
+  }
+  serviceSnapshot() {
+    const manifest = { kind: "CapsuleService", schemaVersion: "1.0", code: this.options.service.code, name: this.options.service.name, description: this.options.service.description, version: this.options.service.version, runtime: this.options.service.runtime, agentMode: "embedded", ...this.options.service.manifest ?? {} };
+    return { code: this.options.service.code, name: this.options.service.name, description: this.options.service.description, version: this.options.service.version, runtime: this.options.service.runtime, manifest, actions: [...this.actions.values()].map(({ handler, prepare, inputSchema, outputSchema, ...a }) => a) };
+  }
+  async runHealth() {
+    return this.healthProvider();
+  }
+  async reportService() {
+    if (!this.agentId || !this.token) return;
+    const [health, configs] = await Promise.all([this.runHealth(), this.configProvider()]);
+    const svc = { ...this.serviceSnapshot(), health, configs };
+    await this.retry(() => this.client.reportServices(this.agentId, this.token, { services: [svc] }));
+  }
+  async heartbeat() {
+    if (!this.agentId || !this.token) return;
+    const health = await this.runHealth();
+    await this.retry(() => this.client.heartbeat(this.agentId, this.token, { health }));
+  }
+  async pollOnce() {
+    if (!this.agentId || !this.token) return;
+    const commands = await this.retry(() => this.client.pollCommands(this.agentId, this.token));
+    for (const c of commands) await this.execute(c);
+  }
+  async execute(command) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const action = this.actions.get(command.actionName);
+    if (!action) {
+      await this.client.reportResult(this.agentId, this.token, command.id, { success: false, message: `No handler registered for action ${command.actionName}`, error: { code: "ACTION_HANDLER_NOT_FOUND" }, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      return;
+    }
+    try {
+      if (command.type === "ACTION_PREPARE") {
+        const out2 = action.prepare ? await Promise.resolve(action.prepare()) : this.defaultPrepare(action);
+        await this.client.reportResult(this.agentId, this.token, command.id, { success: true, data: out2, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        return;
+      }
+      const out = await this.withTimeout(Promise.resolve(action.handler(command.payload ?? {})), action.timeoutSeconds);
+      const result = out;
+      const success = result.success !== false;
+      await this.client.reportResult(this.agentId, this.token, command.id, { success, message: result.message, data: result.data ?? (success ? out : void 0), error: result.error, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch (e) {
+      await this.client.reportResult(this.agentId, this.token, command.id, { success: false, message: e?.message ?? "Action failed", error: { code: "ACTION_FAILED", message: e?.message ?? String(e) }, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  }
+  defaultPrepare(action) {
+    const { handler: _handler, prepare: _prepare, ...meta } = action;
+    return { action: meta, initialPayload: this.initialPayloadFromSchema(action.inputSchema), currentState: {} };
+  }
+  initialPayloadFromSchema(schema) {
+    const props = schema && typeof schema === "object" && !Array.isArray(schema) ? schema.properties : void 0;
+    if (!props || typeof props !== "object" || Array.isArray(props)) return {};
+    return Object.fromEntries(Object.entries(props).map(([k, m]) => {
+      if (m.default !== void 0) return [k, m.default];
+      if (m.type === "number" || m.type === "integer") return [k, 0];
+      if (m.type === "boolean") return [k, false];
+      if (m.type === "array") return [k, []];
+      if (m.type === "object") return [k, {}];
+      return [k, ""];
+    }));
+  }
+  async withTimeout(p, seconds) {
+    if (!seconds) return p;
+    let t;
+    const timeout = new Promise((_, rej) => {
+      t = setTimeout(() => rej(new Error("Action timed out")), seconds * 1e3);
+    });
+    try {
+      return await Promise.race([p, timeout]);
+    } finally {
+      clearTimeout(t);
+    }
+  }
+  async retry(fn, attempts = 5) {
+    let last;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await fn();
+      } catch (e) {
+        last = e;
+        if (e instanceof AgentApiError && e.status < 500) throw e;
+        await sleep(Math.min(1e3 * 2 ** i, 15e3));
+      }
+    }
+    throw last;
+  }
+  log(level, msg, obj) {
+    this.logger[level](msg, obj ? redact(obj) : void 0);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentApiClient,
+  AgentApiError,
+  CapsuleAgent,
+  FileTokenStore
+});

package/dist/index.d.cts

@@ -0,0 +1,139 @@
+import { HealthReportInput, ConfigItemInput, ActionDefinitionInput, ReportedService, RegisterAgentRequest, AgentHeartbeatRequest, ServiceReportRequest, ReportCommandResultRequest } from '@xtrape/capsule-contracts-node';
+
+type AgentMode = "embedded";
+type ActionHandler = (payload: Record<string, unknown>) => Promise<{
+    success?: boolean;
+    message?: string;
+    data?: Record<string, unknown>;
+    error?: Record<string, unknown>;
+} | Record<string, unknown>>;
+type ActionPrepareHandler = () => Promise<{
+    action?: Record<string, unknown>;
+    initialPayload?: Record<string, unknown>;
+    currentState?: Record<string, unknown>;
+} | Record<string, unknown>> | {
+    action?: Record<string, unknown>;
+    initialPayload?: Record<string, unknown>;
+    currentState?: Record<string, unknown>;
+} | Record<string, unknown>;
+interface CapsuleAgentOptions {
+    backendUrl: string;
+    registrationToken?: string;
+    tokenStore?: {
+        file?: string;
+    };
+    agent?: {
+        code: string;
+        name?: string;
+        runtime?: string;
+    };
+    service: {
+        code: string;
+        name: string;
+        description?: string;
+        version: string;
+        runtime: "nodejs" | "java" | "python" | "go" | "other";
+        manifest?: Record<string, unknown>;
+    };
+    intervals?: {
+        heartbeatMs?: number;
+        commandPollMs?: number;
+        serviceReportMs?: number;
+    };
+    heartbeatIntervalSeconds?: number;
+    commandPollIntervalSeconds?: number;
+    autoStartLoops?: boolean;
+    logger?: Pick<Console, "debug" | "info" | "warn" | "error">;
+    failOnStartError?: boolean;
+}
+type HealthProvider = () => Promise<HealthReportInput> | HealthReportInput;
+type ConfigProvider = () => Promise<ConfigItemInput[]> | ConfigItemInput[];
+interface RegisteredAction extends ActionDefinitionInput {
+    handler: ActionHandler;
+    prepare?: ActionPrepareHandler;
+}
+interface TokenStore {
+    load(): Promise<string | null>;
+    save(token: string): Promise<void>;
+    clear(): Promise<void>;
+}
+type ServiceSnapshot = ReportedService;
+
+declare class CapsuleAgent {
+    private readonly options;
+    private readonly client;
+    private readonly store;
+    private readonly logger;
+    private agentId?;
+    private token?;
+    private stopped;
+    private timers;
+    private healthProvider;
+    private configProvider;
+    private actions;
+    constructor(options: CapsuleAgentOptions);
+    health(provider: HealthProvider): this;
+    configs(provider: ConfigProvider): this;
+    action(action: RegisteredAction): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private loop;
+    private ensureRegistered;
+    private serviceSnapshot;
+    runHealth(): Promise<HealthReportInput>;
+    private reportService;
+    private heartbeat;
+    private pollOnce;
+    private execute;
+    private defaultPrepare;
+    private initialPayloadFromSchema;
+    private withTimeout;
+    private retry;
+    private log;
+}
+
+declare class FileTokenStore implements TokenStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): Promise<string | null>;
+    save(token: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+declare class AgentApiClient {
+    private readonly backendUrl;
+    constructor(backendUrl: string);
+    private url;
+    private request;
+    register(req: RegisterAgentRequest): Promise<{
+        agentId: string;
+        agentToken: string;
+        heartbeatIntervalSeconds: number;
+        commandPollIntervalSeconds: number;
+    }>;
+    heartbeat(agentId: string, token: string, req: AgentHeartbeatRequest): Promise<unknown>;
+    reportServices(agentId: string, token: string, req: ServiceReportRequest): Promise<unknown>;
+    pollCommands(agentId: string, token: string): Promise<{
+        type: "ACTION_PREPARE" | "ACTION_EXECUTE" | "ACTION";
+        id: string;
+        createdAt: string;
+        status: "PENDING" | "RUNNING" | "SUCCEEDED" | "FAILED" | "EXPIRED" | "CANCELLED";
+        agentId: string;
+        serviceId: string;
+        actionName: string;
+        expiresAt?: string | null | undefined;
+        payload?: Record<string, any> | undefined;
+        createdByUserId?: string | null | undefined;
+        startedAt?: string | null | undefined;
+        completedAt?: string | null | undefined;
+    }[]>;
+    reportResult(agentId: string, token: string, commandId: string, req: ReportCommandResultRequest): Promise<unknown>;
+}
+
+declare class AgentApiError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+
+export { type ActionHandler, type ActionPrepareHandler, AgentApiClient, AgentApiError, type AgentMode, CapsuleAgent, type CapsuleAgentOptions, type ConfigProvider, FileTokenStore, type HealthProvider, type RegisteredAction, type ServiceSnapshot, type TokenStore };

package/dist/index.d.ts

@@ -0,0 +1,139 @@
+import { HealthReportInput, ConfigItemInput, ActionDefinitionInput, ReportedService, RegisterAgentRequest, AgentHeartbeatRequest, ServiceReportRequest, ReportCommandResultRequest } from '@xtrape/capsule-contracts-node';
+
+type AgentMode = "embedded";
+type ActionHandler = (payload: Record<string, unknown>) => Promise<{
+    success?: boolean;
+    message?: string;
+    data?: Record<string, unknown>;
+    error?: Record<string, unknown>;
+} | Record<string, unknown>>;
+type ActionPrepareHandler = () => Promise<{
+    action?: Record<string, unknown>;
+    initialPayload?: Record<string, unknown>;
+    currentState?: Record<string, unknown>;
+} | Record<string, unknown>> | {
+    action?: Record<string, unknown>;
+    initialPayload?: Record<string, unknown>;
+    currentState?: Record<string, unknown>;
+} | Record<string, unknown>;
+interface CapsuleAgentOptions {
+    backendUrl: string;
+    registrationToken?: string;
+    tokenStore?: {
+        file?: string;
+    };
+    agent?: {
+        code: string;
+        name?: string;
+        runtime?: string;
+    };
+    service: {
+        code: string;
+        name: string;
+        description?: string;
+        version: string;
+        runtime: "nodejs" | "java" | "python" | "go" | "other";
+        manifest?: Record<string, unknown>;
+    };
+    intervals?: {
+        heartbeatMs?: number;
+        commandPollMs?: number;
+        serviceReportMs?: number;
+    };
+    heartbeatIntervalSeconds?: number;
+    commandPollIntervalSeconds?: number;
+    autoStartLoops?: boolean;
+    logger?: Pick<Console, "debug" | "info" | "warn" | "error">;
+    failOnStartError?: boolean;
+}
+type HealthProvider = () => Promise<HealthReportInput> | HealthReportInput;
+type ConfigProvider = () => Promise<ConfigItemInput[]> | ConfigItemInput[];
+interface RegisteredAction extends ActionDefinitionInput {
+    handler: ActionHandler;
+    prepare?: ActionPrepareHandler;
+}
+interface TokenStore {
+    load(): Promise<string | null>;
+    save(token: string): Promise<void>;
+    clear(): Promise<void>;
+}
+type ServiceSnapshot = ReportedService;
+
+declare class CapsuleAgent {
+    private readonly options;
+    private readonly client;
+    private readonly store;
+    private readonly logger;
+    private agentId?;
+    private token?;
+    private stopped;
+    private timers;
+    private healthProvider;
+    private configProvider;
+    private actions;
+    constructor(options: CapsuleAgentOptions);
+    health(provider: HealthProvider): this;
+    configs(provider: ConfigProvider): this;
+    action(action: RegisteredAction): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private loop;
+    private ensureRegistered;
+    private serviceSnapshot;
+    runHealth(): Promise<HealthReportInput>;
+    private reportService;
+    private heartbeat;
+    private pollOnce;
+    private execute;
+    private defaultPrepare;
+    private initialPayloadFromSchema;
+    private withTimeout;
+    private retry;
+    private log;
+}
+
+declare class FileTokenStore implements TokenStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): Promise<string | null>;
+    save(token: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+declare class AgentApiClient {
+    private readonly backendUrl;
+    constructor(backendUrl: string);
+    private url;
+    private request;
+    register(req: RegisterAgentRequest): Promise<{
+        agentId: string;
+        agentToken: string;
+        heartbeatIntervalSeconds: number;
+        commandPollIntervalSeconds: number;
+    }>;
+    heartbeat(agentId: string, token: string, req: AgentHeartbeatRequest): Promise<unknown>;
+    reportServices(agentId: string, token: string, req: ServiceReportRequest): Promise<unknown>;
+    pollCommands(agentId: string, token: string): Promise<{
+        type: "ACTION_PREPARE" | "ACTION_EXECUTE" | "ACTION";
+        id: string;
+        createdAt: string;
+        status: "PENDING" | "RUNNING" | "SUCCEEDED" | "FAILED" | "EXPIRED" | "CANCELLED";
+        agentId: string;
+        serviceId: string;
+        actionName: string;
+        expiresAt?: string | null | undefined;
+        payload?: Record<string, any> | undefined;
+        createdByUserId?: string | null | undefined;
+        startedAt?: string | null | undefined;
+        completedAt?: string | null | undefined;
+    }[]>;
+    reportResult(agentId: string, token: string, commandId: string, req: ReportCommandResultRequest): Promise<unknown>;
+}
+
+declare class AgentApiError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+
+export { type ActionHandler, type ActionPrepareHandler, AgentApiClient, AgentApiError, type AgentMode, CapsuleAgent, type CapsuleAgentOptions, type ConfigProvider, FileTokenStore, type HealthProvider, type RegisteredAction, type ServiceSnapshot, type TokenStore };

package/dist/index.js

@@ -0,0 +1,263 @@
+// src/client/errors.ts
+var AgentApiError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+  status;
+  body;
+};
+
+// src/client/agent-api-client.ts
+var AgentApiClient = class {
+  constructor(backendUrl) {
+    this.backendUrl = backendUrl;
+  }
+  backendUrl;
+  url(path) {
+    return new URL(path, this.backendUrl).toString();
+  }
+  async request(path, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("content-type", "application/json");
+    if (init.token) headers.set("authorization", `Bearer ${init.token}`);
+    const res = await fetch(this.url(path), { ...init, headers });
+    const text = await res.text();
+    const body = text ? JSON.parse(text) : void 0;
+    if (!res.ok) throw new AgentApiError(res.status, body?.error?.message ?? res.statusText, body);
+    return body?.data ?? body;
+  }
+  register(req) {
+    return this.request("/api/agents/register", { method: "POST", body: JSON.stringify(req) });
+  }
+  heartbeat(agentId, token, req) {
+    return this.request(`/api/agents/${agentId}/heartbeat`, { method: "POST", token, body: JSON.stringify(req) });
+  }
+  reportServices(agentId, token, req) {
+    return this.request(`/api/agents/${agentId}/services/report`, { method: "POST", token, body: JSON.stringify(req) });
+  }
+  pollCommands(agentId, token) {
+    return this.request(`/api/agents/${agentId}/commands`, { method: "GET", token });
+  }
+  reportResult(agentId, token, commandId, req) {
+    return this.request(`/api/agents/${agentId}/commands/${commandId}/result`, { method: "POST", token, body: JSON.stringify(req) });
+  }
+};
+
+// src/token-store/file-token-store.ts
+import { mkdir, readFile, rm, writeFile, chmod } from "fs/promises";
+import { dirname } from "path";
+var FileTokenStore = class {
+  constructor(filePath = "./data/agent-token.json") {
+    this.filePath = filePath;
+  }
+  filePath;
+  async load() {
+    try {
+      const parsed = JSON.parse(await readFile(this.filePath, "utf8"));
+      if (typeof parsed.agentId === "string" && typeof parsed.agentToken === "string") return `${parsed.agentId}:${parsed.agentToken}`;
+      return typeof parsed.agentToken === "string" ? parsed.agentToken : null;
+    } catch (e) {
+      if (e?.code === "ENOENT") return null;
+      throw e;
+    }
+  }
+  async save(token) {
+    const [agentId, agentToken] = token.includes(":") ? token.split(":", 2) : [void 0, token];
+    await mkdir(dirname(this.filePath), { recursive: true });
+    await writeFile(this.filePath, JSON.stringify({ ...agentId ? { agentId } : {}, agentToken, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), { mode: 384 });
+    try {
+      await chmod(this.filePath, 384);
+    } catch {
+    }
+  }
+  async clear() {
+    await rm(this.filePath, { force: true });
+  }
+};
+
+// src/security/redaction.ts
+function redact(value) {
+  if (typeof value === "string") return value.replace(/opstage_(reg|agent)_[A-Za-z0-9_-]+/g, "opstage_$1_[REDACTED]");
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(redact);
+  return Object.fromEntries(Object.entries(value).map(([k, v]) => [/token|secret|password|authorization/i.test(k) ? [k, "[REDACTED]"] : [k, redact(v)]]));
+}
+
+// src/capsule-agent.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var CapsuleAgent = class {
+  constructor(options) {
+    this.options = options;
+    this.client = new AgentApiClient(options.backendUrl);
+    this.store = new FileTokenStore(options.tokenStore?.file);
+    this.logger = options.logger ?? console;
+  }
+  options;
+  client;
+  store;
+  logger;
+  agentId;
+  token;
+  stopped = true;
+  timers = [];
+  healthProvider = () => ({ status: "UNKNOWN" });
+  configProvider = () => [];
+  actions = /* @__PURE__ */ new Map();
+  health(provider) {
+    this.healthProvider = provider;
+    return this;
+  }
+  configs(provider) {
+    this.configProvider = provider;
+    return this;
+  }
+  action(action) {
+    this.actions.set(action.name, action);
+    return this;
+  }
+  async start() {
+    this.stopped = false;
+    try {
+      await this.ensureRegistered();
+      await this.reportService();
+      await this.heartbeat();
+      await this.pollOnce();
+    } catch (e) {
+      this.log("error", "agent start failed", e);
+      if (this.options.failOnStartError) throw e;
+    }
+    if (this.options.autoStartLoops !== false) {
+      this.loop("heartbeat", this.options.intervals?.heartbeatMs ?? (this.options.heartbeatIntervalSeconds ?? 30) * 1e3, () => this.heartbeat());
+      this.loop("service-report", this.options.intervals?.serviceReportMs ?? 6e4, () => this.reportService());
+      this.loop("command-poll", this.options.intervals?.commandPollMs ?? (this.options.commandPollIntervalSeconds ?? 5) * 1e3, () => this.pollOnce());
+    }
+  }
+  async stop() {
+    this.stopped = true;
+    for (const t of this.timers) clearInterval(t);
+    this.timers = [];
+  }
+  loop(name, ms, fn) {
+    const t = setInterval(async () => {
+      if (this.stopped) return;
+      try {
+        await fn();
+      } catch (e) {
+        this.log("warn", `${name} failed`, e);
+      }
+    }, ms);
+    this.timers.push(t);
+  }
+  async ensureRegistered() {
+    const stored = await this.store.load();
+    if (stored) {
+      const [agentId, token] = stored.includes(":") ? stored.split(":", 2) : [void 0, stored];
+      this.agentId = agentId;
+      this.token = token;
+      if (this.agentId) return;
+    }
+    if (!this.options.registrationToken) throw new Error("OPSTAGE registration token is required for first registration");
+    const agent = this.options.agent ?? { code: this.options.service.code, name: this.options.service.name, runtime: this.options.service.runtime };
+    const res = await this.retry(() => this.client.register({ registrationToken: this.options.registrationToken, agent: { code: agent.code, name: agent.name, mode: "embedded", runtime: agent.runtime ?? "nodejs" }, service: this.serviceSnapshot() }));
+    this.agentId = res.agentId;
+    this.token = res.agentToken;
+    await this.store.save(`${this.agentId}:${this.token}`);
+    this.log("info", `registered agent ${this.agentId}`);
+  }
+  serviceSnapshot() {
+    const manifest = { kind: "CapsuleService", schemaVersion: "1.0", code: this.options.service.code, name: this.options.service.name, description: this.options.service.description, version: this.options.service.version, runtime: this.options.service.runtime, agentMode: "embedded", ...this.options.service.manifest ?? {} };
+    return { code: this.options.service.code, name: this.options.service.name, description: this.options.service.description, version: this.options.service.version, runtime: this.options.service.runtime, manifest, actions: [...this.actions.values()].map(({ handler, prepare, inputSchema, outputSchema, ...a }) => a) };
+  }
+  async runHealth() {
+    return this.healthProvider();
+  }
+  async reportService() {
+    if (!this.agentId || !this.token) return;
+    const [health, configs] = await Promise.all([this.runHealth(), this.configProvider()]);
+    const svc = { ...this.serviceSnapshot(), health, configs };
+    await this.retry(() => this.client.reportServices(this.agentId, this.token, { services: [svc] }));
+  }
+  async heartbeat() {
+    if (!this.agentId || !this.token) return;
+    const health = await this.runHealth();
+    await this.retry(() => this.client.heartbeat(this.agentId, this.token, { health }));
+  }
+  async pollOnce() {
+    if (!this.agentId || !this.token) return;
+    const commands = await this.retry(() => this.client.pollCommands(this.agentId, this.token));
+    for (const c of commands) await this.execute(c);
+  }
+  async execute(command) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const action = this.actions.get(command.actionName);
+    if (!action) {
+      await this.client.reportResult(this.agentId, this.token, command.id, { success: false, message: `No handler registered for action ${command.actionName}`, error: { code: "ACTION_HANDLER_NOT_FOUND" }, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      return;
+    }
+    try {
+      if (command.type === "ACTION_PREPARE") {
+        const out2 = action.prepare ? await Promise.resolve(action.prepare()) : this.defaultPrepare(action);
+        await this.client.reportResult(this.agentId, this.token, command.id, { success: true, data: out2, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        return;
+      }
+      const out = await this.withTimeout(Promise.resolve(action.handler(command.payload ?? {})), action.timeoutSeconds);
+      const result = out;
+      const success = result.success !== false;
+      await this.client.reportResult(this.agentId, this.token, command.id, { success, message: result.message, data: result.data ?? (success ? out : void 0), error: result.error, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch (e) {
+      await this.client.reportResult(this.agentId, this.token, command.id, { success: false, message: e?.message ?? "Action failed", error: { code: "ACTION_FAILED", message: e?.message ?? String(e) }, startedAt, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  }
+  defaultPrepare(action) {
+    const { handler: _handler, prepare: _prepare, ...meta } = action;
+    return { action: meta, initialPayload: this.initialPayloadFromSchema(action.inputSchema), currentState: {} };
+  }
+  initialPayloadFromSchema(schema) {
+    const props = schema && typeof schema === "object" && !Array.isArray(schema) ? schema.properties : void 0;
+    if (!props || typeof props !== "object" || Array.isArray(props)) return {};
+    return Object.fromEntries(Object.entries(props).map(([k, m]) => {
+      if (m.default !== void 0) return [k, m.default];
+      if (m.type === "number" || m.type === "integer") return [k, 0];
+      if (m.type === "boolean") return [k, false];
+      if (m.type === "array") return [k, []];
+      if (m.type === "object") return [k, {}];
+      return [k, ""];
+    }));
+  }
+  async withTimeout(p, seconds) {
+    if (!seconds) return p;
+    let t;
+    const timeout = new Promise((_, rej) => {
+      t = setTimeout(() => rej(new Error("Action timed out")), seconds * 1e3);
+    });
+    try {
+      return await Promise.race([p, timeout]);
+    } finally {
+      clearTimeout(t);
+    }
+  }
+  async retry(fn, attempts = 5) {
+    let last;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await fn();
+      } catch (e) {
+        last = e;
+        if (e instanceof AgentApiError && e.status < 500) throw e;
+        await sleep(Math.min(1e3 * 2 ** i, 15e3));
+      }
+    }
+    throw last;
+  }
+  log(level, msg, obj) {
+    this.logger[level](msg, obj ? redact(obj) : void 0);
+  }
+};
+export {
+  AgentApiClient,
+  AgentApiError,
+  CapsuleAgent,
+  FileTokenStore
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@xtrape/capsule-agent-node",
+  "version": "0.1.0-public-review.0",
+  "description": "Node.js Agent SDK for embedding Capsule Services into the Opstage governance loop.",
+  "keywords": [
+    "xtrape",
+    "capsule",
+    "opstage",
+    "agent-sdk",
+    "automation",
+    "control-plane"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xtrape-com/xtrape-capsule-agent-node.git"
+  },
+  "homepage": "https://github.com/xtrape-com/xtrape-capsule-agent-node#readme",
+  "bugs": {
+    "url": "https://github.com/xtrape-com/xtrape-capsule-agent-node/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "prepack": "pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@xtrape/capsule-contracts-node": "^0.1.0-public-review.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.9",
+    "@types/node": "^22.10.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "license": "Apache-2.0"
+}