@xtrape/capsule-contracts-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,295 @@
+# @xtrape/capsule-contracts-node
+
+> TypeScript contracts and Zod schemas for Xtrape Capsule and Opstage wire
+> protocols.
+
+[![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/contracts/overview)
+
+`@xtrape/capsule-contracts-node` is the shared TypeScript contract package for
+Opstage CE, Agent SDKs, and Capsule Service integrations. It exports Zod
+schemas, inferred TypeScript types, enum values, ID helpers, pagination helpers,
+and protocol error helpers for the Agent/Admin/System wire contracts.
+
+> **Package status:** Xtrape Capsule is currently in **Public Review** before
+> the `v0.1.0 Public Preview` release. This package is prepared for npm
+> publication 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-contracts-node@public-review
+```
+
+The current Public Review version may change before `v0.1.0`.
+
+For this repository itself:
+
+```bash
+pnpm install
+pnpm build
+```
+
+## What is Included
+
+The package currently exports:
+
+- Zod itself as `z` for consumers that want one compatible Zod instance.
+- Status enum arrays and types: `AgentStatus`, `CapsuleServiceStatus`,
+  `HealthStatus`, `CommandStatus`, `DangerLevel`, `AuditActorType`,
+  `AuditResult`, `TokenStatus`.
+- Admin schemas: users, sessions, registration token requests/responses.
+- Agent schemas: registration, heartbeat, service report, command result.
+- Capsule Service schemas: manifest, health, config, action, service detail.
+- Command schemas: create command, command detail, command result.
+- Audit and dashboard schemas.
+- System health/version schemas.
+- Helpers: `newId`, `parseSort`, `paginate`, `HttpError`, `ListQueryBase`.
+
+## Validate Agent Registration
+
+```ts
+import { RegisterAgentRequestSchema } from "@xtrape/capsule-contracts-node";
+
+const request = RegisterAgentRequestSchema.parse(input);
+
+// request.registrationToken starts with opstage_reg_
+// request.agent.mode is embedded
+```
+
+Lowercase aliases are also exported for backend compatibility:
+
+```ts
+import { registerAgentRequestSchema } from "@xtrape/capsule-contracts-node";
+
+const request = registerAgentRequestSchema.parse(input);
+```
+
+## Validate Service Report
+
+```ts
+import { ServiceReportRequestSchema } from "@xtrape/capsule-contracts-node";
+
+const report = ServiceReportRequestSchema.parse({
+  services: [
+    {
+      code: "hello-capsule",
+      name: "Hello Capsule",
+      version: "0.1.0",
+      runtime: "nodejs",
+      manifest: {
+        kind: "CapsuleService",
+        schemaVersion: "1.0",
+        code: "hello-capsule",
+        name: "Hello Capsule",
+        version: "0.1.0",
+        runtime: "nodejs",
+        agentMode: "embedded",
+      },
+    },
+  ],
+});
+```
+
+## Validate Health Report
+
+```ts
+import { HealthReportInputSchema } from "@xtrape/capsule-contracts-node";
+
+const health = HealthReportInputSchema.parse({
+  status: "UP",
+  message: "ok",
+  details: { uptimeSeconds: 123 },
+});
+```
+
+Allowed health statuses are:
+
+```ts
+import { HealthStatus } from "@xtrape/capsule-contracts-node";
+
+console.log(HealthStatus); // ["UP", "DEGRADED", "DOWN", "UNKNOWN"]
+```
+
+`HealthStatus` is the protocol-level status reported by Agents and Capsule
+Services:
+
+- `UP`
+- `DEGRADED`
+- `DOWN`
+- `UNKNOWN`
+
+Opstage may derive an operator-facing `effectiveStatus` such as:
+
+- `HEALTHY`
+- `UNHEALTHY`
+- `STALE`
+- `OFFLINE`
+
+## Validate Config and Action Definitions
+
+```ts
+import {
+  ConfigItemInputSchema,
+  ActionDefinitionInputSchema,
+} from "@xtrape/capsule-contracts-node";
+
+const config = ConfigItemInputSchema.parse({
+  key: "UPSTREAM_BASE_URL",
+  type: "string",
+  sensitive: false,
+  valuePreview: "https://api.example.test",
+});
+
+const action = ActionDefinitionInputSchema.parse({
+  name: "reload-cache",
+  label: "Reload Cache",
+  dangerLevel: "MEDIUM",
+  requiresConfirmation: true,
+});
+```
+
+## Validate Action Prepare Result
+
+Action prepare responses are delivered as successful Command Results. The
+SDK/backend convention is:
+
+```ts
+import { ReportCommandResultRequestSchema } from "@xtrape/capsule-contracts-node";
+
+const prepareResult = ReportCommandResultRequestSchema.parse({
+  success: true,
+  data: {
+    action: { name: "echo", label: "Echo", dangerLevel: "LOW" },
+    inputSchema: {
+      type: "object",
+      properties: { message: { type: "string", default: "hello" } },
+    },
+    initialPayload: { message: "hello" },
+    currentState: { service: "ready" },
+  },
+});
+```
+
+## Validate Command Result
+
+```ts
+import { ReportCommandResultRequestSchema } from "@xtrape/capsule-contracts-node";
+
+const result = ReportCommandResultRequestSchema.parse({
+  success: true,
+  message: "Done",
+  data: { count: 1 },
+  startedAt: new Date().toISOString(),
+  finishedAt: new Date().toISOString(),
+});
+```
+
+Failed results should include an operator-safe message and structured error:
+
+```ts
+ReportCommandResultRequestSchema.parse({
+  success: false,
+  message: "Provider challenge page detected.",
+  error: {
+    code: "ACTION_FAILED",
+    retryable: false,
+  },
+});
+```
+
+## Error Codes
+
+The `ErrorCode` export contains protocol-level error code constants currently
+used by CE and SDKs:
+
+```ts
+import { ErrorCode } from "@xtrape/capsule-contracts-node";
+
+throw new Error(ErrorCode.VALIDATION_FAILED);
+```
+
+Currently exported codes include:
+
+- `INTERNAL_ERROR`
+- `VALIDATION_FAILED`
+- `UNAUTHORIZED`
+- `FORBIDDEN`
+- `NOT_FOUND`
+- `CONFLICT`
+- `CSRF_INVALID`
+- `ACTION_REQUIRES_CONFIRMATION`
+- `COMMAND_EXPIRED`
+- `TOKEN_REVOKED`
+- `TOKEN_EXPIRED`
+- `AGENT_REVOKED`
+- `AGENT_DISABLED`
+
+See the OpenAPI contract and docs site for endpoint-specific errors.
+
+## ID Helpers
+
+```ts
+import { newId } from "@xtrape/capsule-contracts-node";
+
+const commandId = newId("cmd_");
+```
+
+Supported prefixes include `wks_`, `usr_`, `agt_`, `tok_`, `svc_`, `hlr_`,
+`cfg_`, `act_`, `cmd_`, `crs_`, and `aud_`.
+
+## List Helpers
+
+```ts
+import {
+  ListQueryBase,
+  parseSort,
+  paginate,
+} from "@xtrape/capsule-contracts-node";
+
+const query = ListQueryBase.parse({ page: "1", pageSize: "20" });
+const sort = parseSort("-createdAt", ["createdAt", "name"]);
+const response = paginate(items, query.page, query.pageSize, total);
+```
+
+## Used By
+
+- [`xtrape-capsule-ce`](https://github.com/xtrape-com/xtrape-capsule-ce) —
+  Opstage CE backend validation and protocol handling.
+- [`xtrape-capsule-agent-node`](https://github.com/xtrape-com/xtrape-capsule-agent-node)
+  — Node embedded Agent SDK request/response types.
+- Capsule Service implementations that want local validation before reporting to
+  Opstage.
+
+## Compatibility
+
+| Package                                | Compatible with                          |
+| -------------------------------------- | ---------------------------------------- |
+| `@xtrape/capsule-contracts-node@0.1.x` | Opstage CE `0.1.x` and Agent SDK `0.1.x` |
+
+During Public Review and Public Preview, keep CE, Agent SDK, and Contracts on
+matching minor versions. The wire protocol may still evolve before `v1.0`.
+
+## Documentation
+
+- Contracts overview: https://xtrape-com.github.io/xtrape-capsule-site/contracts/overview
+- Manifest contract: https://xtrape-com.github.io/xtrape-capsule-site/contracts/manifest
+- Health contract: https://xtrape-com.github.io/xtrape-capsule-site/contracts/health
+- Actions contract: https://xtrape-com.github.io/xtrape-capsule-site/contracts/actions
+- Errors: https://xtrape-com.github.io/xtrape-capsule-site/contracts/errors
+- Opstage CE: https://xtrape-com.github.io/xtrape-capsule-site/opstage-ce/overview
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for schema change workflow and PR
+checks. See [SECURITY.md](./SECURITY.md) for vulnerability reporting and
+contract validation 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,271 @@
+"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, {
+  ActionDefinitionInputSchema: () => ActionDefinitionInputSchema,
+  ActionDefinitionSchema: () => ActionDefinitionSchema,
+  AdminLoginRequestSchema: () => AdminLoginRequestSchema,
+  AdminSessionSchema: () => AdminSessionSchema,
+  AgentHeartbeatRequestSchema: () => AgentHeartbeatRequestSchema,
+  AgentHeartbeatResponseSchema: () => AgentHeartbeatResponseSchema,
+  AgentSchema: () => AgentSchema,
+  AgentStatus: () => AgentStatus,
+  AgentStatusSchema: () => AgentStatusSchema,
+  AnyJson: () => AnyJson,
+  AuditActorType: () => AuditActorType,
+  AuditEventSchema: () => AuditEventSchema,
+  AuditResult: () => AuditResult,
+  CapsuleManifestSchema: () => CapsuleManifestSchema,
+  CapsuleServiceDetailSchema: () => CapsuleServiceDetailSchema,
+  CapsuleServiceSchema: () => CapsuleServiceSchema,
+  CapsuleServiceStatus: () => CapsuleServiceStatus,
+  CapsuleServiceStatusSchema: () => CapsuleServiceStatusSchema,
+  CommandDetailSchema: () => CommandDetailSchema,
+  CommandResultSchema: () => CommandResultSchema,
+  CommandSchema: () => CommandSchema,
+  CommandStatus: () => CommandStatus,
+  CommandStatusSchema: () => CommandStatusSchema,
+  ConfigItemInputSchema: () => ConfigItemInputSchema,
+  ConfigItemSchema: () => ConfigItemSchema,
+  CreateActionCommandRequestSchema: () => CreateActionCommandRequestSchema,
+  CreateRegistrationTokenRequestSchema: () => CreateRegistrationTokenRequestSchema,
+  CreateRegistrationTokenResponseSchema: () => CreateRegistrationTokenResponseSchema,
+  DangerLevel: () => DangerLevel,
+  DangerLevelSchema: () => DangerLevelSchema,
+  DashboardSummarySchema: () => DashboardSummarySchema,
+  ErrorCode: () => ErrorCode,
+  HealthReportInputSchema: () => HealthReportInputSchema,
+  HealthReportSchema: () => HealthReportSchema,
+  HealthStatus: () => HealthStatus,
+  HealthStatusSchema: () => HealthStatusSchema,
+  HttpError: () => HttpError,
+  ListQueryBase: () => ListQueryBase,
+  RegisterAgentRequestSchema: () => RegisterAgentRequestSchema,
+  RegisterAgentResponseSchema: () => RegisterAgentResponseSchema,
+  RegistrationTokenSchema: () => RegistrationTokenSchema,
+  ReportCommandResultRequestSchema: () => ReportCommandResultRequestSchema,
+  ReportedServiceSchema: () => ReportedServiceSchema,
+  ServiceReportRequestSchema: () => ServiceReportRequestSchema,
+  SystemHealthSchema: () => SystemHealthSchema,
+  SystemVersionSchema: () => SystemVersionSchema,
+  TokenStatus: () => TokenStatus,
+  UserRole: () => UserRole,
+  UserSchema: () => UserSchema,
+  actionDefinitionInputSchema: () => actionDefinitionInputSchema,
+  adminLoginRequestSchema: () => adminLoginRequestSchema,
+  agentHeartbeatRequestSchema: () => agentHeartbeatRequestSchema,
+  configItemInputSchema: () => configItemInputSchema,
+  createActionCommandRequestSchema: () => createActionCommandRequestSchema,
+  createRegistrationTokenRequestSchema: () => createRegistrationTokenRequestSchema,
+  createUserRequestSchema: () => createUserRequestSchema,
+  healthReportInputSchema: () => healthReportInputSchema,
+  idPrefixes: () => idPrefixes,
+  newId: () => newId,
+  paginate: () => paginate,
+  parseSort: () => parseSort,
+  registerAgentRequestSchema: () => registerAgentRequestSchema,
+  reportCommandResultRequestSchema: () => reportCommandResultRequestSchema,
+  reportedServiceSchema: () => reportedServiceSchema,
+  resetUserPasswordRequestSchema: () => resetUserPasswordRequestSchema,
+  serviceReportRequestSchema: () => serviceReportRequestSchema,
+  updateUserRequestSchema: () => updateUserRequestSchema,
+  z: () => import_zod.z
+});
+module.exports = __toCommonJS(index_exports);
+var import_nanoid = require("nanoid");
+var import_zod = require("zod");
+var AgentStatus = ["PENDING", "ONLINE", "OFFLINE", "DISABLED", "REVOKED"];
+var CapsuleServiceStatus = ["UNKNOWN", "HEALTHY", "UNHEALTHY", "STALE", "OFFLINE"];
+var HealthStatus = ["UP", "DEGRADED", "DOWN", "UNKNOWN"];
+var CommandStatus = ["PENDING", "RUNNING", "SUCCEEDED", "FAILED", "EXPIRED", "CANCELLED"];
+var DangerLevel = ["LOW", "MEDIUM", "HIGH"];
+var AuditActorType = ["USER", "AGENT", "SYSTEM"];
+var AuditResult = ["SUCCESS", "FAILURE"];
+var TokenStatus = ["ACTIVE", "REVOKED", "EXPIRED", "USED"];
+var ErrorCode = {
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  CONFLICT: "CONFLICT",
+  CSRF_INVALID: "CSRF_INVALID",
+  ACTION_REQUIRES_CONFIRMATION: "ACTION_REQUIRES_CONFIRMATION",
+  COMMAND_EXPIRED: "COMMAND_EXPIRED",
+  TOKEN_REVOKED: "TOKEN_REVOKED",
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  AGENT_REVOKED: "AGENT_REVOKED",
+  AGENT_DISABLED: "AGENT_DISABLED"
+};
+var idPrefixes = ["wks_", "usr_", "agt_", "tok_", "svc_", "hlr_", "cfg_", "act_", "cmd_", "crs_", "aud_"];
+var NANO = (0, import_nanoid.customAlphabet)("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-", 21);
+function newId(prefix) {
+  return `${prefix}${NANO()}`;
+}
+var AnyJson = import_zod.z.record(import_zod.z.any());
+var AgentStatusSchema = import_zod.z.enum(AgentStatus);
+var CapsuleServiceStatusSchema = import_zod.z.enum(CapsuleServiceStatus);
+var HealthStatusSchema = import_zod.z.enum(HealthStatus);
+var CommandStatusSchema = import_zod.z.enum(CommandStatus);
+var DangerLevelSchema = import_zod.z.enum(DangerLevel).default("LOW");
+var UserSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("usr_"), username: import_zod.z.string(), displayName: import_zod.z.string().nullable().optional(), createdAt: import_zod.z.string(), updatedAt: import_zod.z.string() });
+var UserRole = import_zod.z.enum(["owner", "operator", "viewer"]);
+var createUserRequestSchema = import_zod.z.object({ username: import_zod.z.string().min(1), password: import_zod.z.string().min(12), displayName: import_zod.z.string().optional(), role: UserRole.default("viewer") });
+var updateUserRequestSchema = import_zod.z.object({ displayName: import_zod.z.string().optional(), role: UserRole.optional(), status: import_zod.z.enum(["ACTIVE", "DISABLED"]).optional() });
+var resetUserPasswordRequestSchema = import_zod.z.object({ password: import_zod.z.string().min(12) });
+var AdminLoginRequestSchema = import_zod.z.object({ username: import_zod.z.string().min(1), password: import_zod.z.string().min(1) });
+var adminLoginRequestSchema = AdminLoginRequestSchema;
+var AdminSessionSchema = import_zod.z.object({ user: UserSchema, csrfToken: import_zod.z.string(), expiresAt: import_zod.z.string() });
+var AgentSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("agt_"), code: import_zod.z.string(), name: import_zod.z.string().nullable().optional(), mode: import_zod.z.enum(["embedded", "sidecar", "external"]), runtime: import_zod.z.string().nullable().optional(), status: AgentStatusSchema, lastHeartbeatAt: import_zod.z.string().nullable().optional(), createdAt: import_zod.z.string(), updatedAt: import_zod.z.string() });
+var RegistrationTokenSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("tok_"), name: import_zod.z.string(), status: import_zod.z.enum(TokenStatus), expiresAt: import_zod.z.string().nullable().optional(), usedAt: import_zod.z.string().nullable().optional(), createdAt: import_zod.z.string() });
+var CreateRegistrationTokenRequestSchema = import_zod.z.object({ name: import_zod.z.string().default("Default registration token").optional(), expiresInSeconds: import_zod.z.number().int().min(60).optional() });
+var createRegistrationTokenRequestSchema = CreateRegistrationTokenRequestSchema;
+var CreateRegistrationTokenResponseSchema = RegistrationTokenSchema.extend({ rawToken: import_zod.z.string().startsWith("opstage_reg_") });
+var CapsuleManifestSchema = import_zod.z.object({ kind: import_zod.z.literal("CapsuleService"), schemaVersion: import_zod.z.string().default("1.0").optional(), code: import_zod.z.string().min(1), name: import_zod.z.string().min(1), description: import_zod.z.string().optional(), version: import_zod.z.string().min(1), runtime: import_zod.z.enum(["nodejs", "java", "python", "go", "other"]), agentMode: import_zod.z.enum(["embedded", "sidecar", "external"]), capabilities: import_zod.z.array(import_zod.z.string()).optional(), labels: import_zod.z.record(import_zod.z.string()).optional() }).passthrough();
+var HealthReportInputSchema = import_zod.z.object({ status: HealthStatusSchema, message: import_zod.z.string().optional(), details: AnyJson.optional() });
+var healthReportInputSchema = HealthReportInputSchema;
+var ConfigItemInputSchema = import_zod.z.object({ key: import_zod.z.string(), label: import_zod.z.string().optional(), type: import_zod.z.string(), source: import_zod.z.string().optional(), editable: import_zod.z.boolean().optional(), sensitive: import_zod.z.boolean().optional(), valuePreview: import_zod.z.string().optional(), defaultValue: import_zod.z.string().optional(), secretRef: import_zod.z.string().optional() });
+var configItemInputSchema = ConfigItemInputSchema;
+var ActionDefinitionInputSchema = import_zod.z.object({ name: import_zod.z.string(), label: import_zod.z.string(), description: import_zod.z.string().optional(), dangerLevel: import_zod.z.enum(DangerLevel).default("LOW").optional(), requiresConfirmation: import_zod.z.boolean().optional(), category: import_zod.z.string().optional(), order: import_zod.z.number().int().optional(), inputSchema: AnyJson.optional(), outputSchema: AnyJson.optional(), timeoutSeconds: import_zod.z.number().int().positive().optional() });
+var actionDefinitionInputSchema = ActionDefinitionInputSchema;
+var ReportedServiceSchema = import_zod.z.object({ code: import_zod.z.string().min(1).max(80), name: import_zod.z.string().min(1).max(200), description: import_zod.z.string().max(2e3).optional(), version: import_zod.z.string().max(80).optional(), runtime: import_zod.z.string().optional(), manifest: AnyJson, health: HealthReportInputSchema.optional(), configs: import_zod.z.array(ConfigItemInputSchema).optional(), actions: import_zod.z.array(ActionDefinitionInputSchema).optional() });
+var reportedServiceSchema = ReportedServiceSchema;
+var ServiceReportRequestSchema = import_zod.z.object({ services: import_zod.z.array(ReportedServiceSchema).min(1) });
+var serviceReportRequestSchema = ServiceReportRequestSchema;
+var RegisterAgentRequestSchema = import_zod.z.object({ registrationToken: import_zod.z.string().startsWith("opstage_reg_"), agent: import_zod.z.object({ code: import_zod.z.string(), name: import_zod.z.string().optional(), mode: import_zod.z.literal("embedded"), runtime: import_zod.z.string().optional() }), service: ReportedServiceSchema.optional() });
+var registerAgentRequestSchema = RegisterAgentRequestSchema;
+var RegisterAgentResponseSchema = import_zod.z.object({ agentId: import_zod.z.string().startsWith("agt_"), agentToken: import_zod.z.string().startsWith("opstage_agent_"), heartbeatIntervalSeconds: import_zod.z.number().int(), commandPollIntervalSeconds: import_zod.z.number().int() });
+var AgentHeartbeatResponseSchema = import_zod.z.object({ heartbeatIntervalSeconds: import_zod.z.number().int(), commandPollIntervalSeconds: import_zod.z.number().int() });
+var AgentHeartbeatRequestSchema = import_zod.z.object({ serviceId: import_zod.z.string().startsWith("svc_").optional(), health: HealthReportInputSchema.optional() });
+var agentHeartbeatRequestSchema = AgentHeartbeatRequestSchema;
+var CapsuleServiceSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("svc_"), agentId: import_zod.z.string().startsWith("agt_").optional(), code: import_zod.z.string(), name: import_zod.z.string(), description: import_zod.z.string().nullable().optional(), version: import_zod.z.string().nullable().optional(), runtime: import_zod.z.string().nullable().optional(), status: CapsuleServiceStatusSchema, healthStatus: HealthStatusSchema.optional(), lastReportedAt: import_zod.z.string().nullable().optional(), lastHealthAt: import_zod.z.string().nullable().optional(), createdAt: import_zod.z.string(), updatedAt: import_zod.z.string() });
+var HealthReportSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("hlr_"), serviceId: import_zod.z.string().startsWith("svc_"), agentId: import_zod.z.string().startsWith("agt_").optional(), status: HealthStatusSchema, message: import_zod.z.string().nullable().optional(), details: AnyJson.optional(), reportedAt: import_zod.z.string() });
+var ConfigItemSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("cfg_"), serviceId: import_zod.z.string().startsWith("svc_"), key: import_zod.z.string(), label: import_zod.z.string().nullable().optional(), type: import_zod.z.string(), source: import_zod.z.string().nullable().optional(), editable: import_zod.z.boolean().default(false), sensitive: import_zod.z.boolean(), valuePreview: import_zod.z.string().nullable().optional(), defaultValue: import_zod.z.string().nullable().optional(), secretRef: import_zod.z.string().nullable().optional() });
+var ActionDefinitionSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("act_"), serviceId: import_zod.z.string().startsWith("svc_"), name: import_zod.z.string(), label: import_zod.z.string(), description: import_zod.z.string().nullable().optional(), dangerLevel: import_zod.z.enum(DangerLevel), requiresConfirmation: import_zod.z.boolean(), category: import_zod.z.string().optional(), order: import_zod.z.number().int().optional(), inputSchema: AnyJson.optional(), outputSchema: AnyJson.optional(), timeoutSeconds: import_zod.z.number().int().optional() });
+var CapsuleServiceDetailSchema = CapsuleServiceSchema.extend({ manifest: AnyJson.optional(), health: HealthReportSchema.nullable().optional(), configs: import_zod.z.array(ConfigItemSchema).optional(), actions: import_zod.z.array(ActionDefinitionSchema).optional() });
+var CreateActionCommandRequestSchema = import_zod.z.object({ payload: AnyJson.optional(), confirmation: import_zod.z.boolean().optional() });
+var createActionCommandRequestSchema = CreateActionCommandRequestSchema;
+var CommandSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("cmd_"), agentId: import_zod.z.string().startsWith("agt_"), serviceId: import_zod.z.string().startsWith("svc_"), type: import_zod.z.enum(["ACTION_PREPARE", "ACTION_EXECUTE", "ACTION"]), actionName: import_zod.z.string(), status: CommandStatusSchema, payload: AnyJson.optional(), createdByUserId: import_zod.z.string().startsWith("usr_").nullable().optional(), createdAt: import_zod.z.string(), startedAt: import_zod.z.string().nullable().optional(), completedAt: import_zod.z.string().nullable().optional(), expiresAt: import_zod.z.string().nullable().optional() });
+var ReportCommandResultRequestSchema = import_zod.z.object({ success: import_zod.z.boolean(), message: import_zod.z.string().optional(), data: AnyJson.optional(), error: AnyJson.optional(), startedAt: import_zod.z.string().optional(), finishedAt: import_zod.z.string().optional() });
+var reportCommandResultRequestSchema = ReportCommandResultRequestSchema;
+var CommandResultSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("crs_"), commandId: import_zod.z.string().startsWith("cmd_"), success: import_zod.z.boolean(), message: import_zod.z.string().nullable().optional(), data: AnyJson.optional(), error: AnyJson.optional(), reportedAt: import_zod.z.string() });
+var CommandDetailSchema = CommandSchema.extend({ result: CommandResultSchema.nullable().optional() });
+var AuditEventSchema = import_zod.z.object({ id: import_zod.z.string().startsWith("aud_"), actorType: import_zod.z.enum(AuditActorType), actorId: import_zod.z.string().nullable().optional(), action: import_zod.z.string(), targetType: import_zod.z.string().nullable().optional(), targetId: import_zod.z.string().nullable().optional(), result: import_zod.z.enum(AuditResult), message: import_zod.z.string().nullable().optional(), metadata: AnyJson.optional(), createdAt: import_zod.z.string() });
+var DashboardSummarySchema = import_zod.z.object({ agentCounts: import_zod.z.record(import_zod.z.number().int()), serviceCounts: import_zod.z.record(import_zod.z.number().int()), commandCounts: import_zod.z.record(import_zod.z.number().int()), recentCommands: import_zod.z.array(CommandSchema).optional(), recentAuditEvents: import_zod.z.array(AuditEventSchema).optional() });
+var SystemHealthSchema = import_zod.z.object({ status: import_zod.z.enum(["UP", "DEGRADED", "DOWN"]), timestamp: import_zod.z.string(), version: import_zod.z.string(), edition: import_zod.z.literal("ce"), database: import_zod.z.object({ status: import_zod.z.enum(["UP", "DEGRADED", "DOWN"]), kind: import_zod.z.enum(["sqlite", "postgres", "mysql"]).optional(), latencyMs: import_zod.z.number().int().optional() }), uptimeSeconds: import_zod.z.number().int().optional() });
+var SystemVersionSchema = import_zod.z.object({ version: import_zod.z.string(), edition: import_zod.z.literal("ce"), commit: import_zod.z.string().optional(), buildTime: import_zod.z.string().optional() });
+var ListQueryBase = import_zod.z.object({ page: import_zod.z.coerce.number().int().min(1).default(1), pageSize: import_zod.z.coerce.number().int().min(1).max(100).default(20), sort: import_zod.z.string().optional() });
+var HttpError = class extends Error {
+  constructor(httpStatus, code, publicMessage, details) {
+    super(publicMessage);
+    this.httpStatus = httpStatus;
+    this.code = code;
+    this.publicMessage = publicMessage;
+    this.details = details;
+  }
+  httpStatus;
+  code;
+  publicMessage;
+  details;
+};
+function parseSort(value, allowed) {
+  if (!value) return [];
+  return value.split(",").filter(Boolean).map((raw) => {
+    const desc = raw.startsWith("-");
+    const field = desc ? raw.slice(1) : raw;
+    if (!allowed.includes(field)) throw new HttpError(422, "VALIDATION_FAILED", `Unknown sort field: ${field}`);
+    return { field, direction: desc ? "desc" : "asc" };
+  });
+}
+function paginate(items, page, pageSize, total) {
+  return { data: items, pagination: { page, pageSize, total } };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionDefinitionInputSchema,
+  ActionDefinitionSchema,
+  AdminLoginRequestSchema,
+  AdminSessionSchema,
+  AgentHeartbeatRequestSchema,
+  AgentHeartbeatResponseSchema,
+  AgentSchema,
+  AgentStatus,
+  AgentStatusSchema,
+  AnyJson,
+  AuditActorType,
+  AuditEventSchema,
+  AuditResult,
+  CapsuleManifestSchema,
+  CapsuleServiceDetailSchema,
+  CapsuleServiceSchema,
+  CapsuleServiceStatus,
+  CapsuleServiceStatusSchema,
+  CommandDetailSchema,
+  CommandResultSchema,
+  CommandSchema,
+  CommandStatus,
+  CommandStatusSchema,
+  ConfigItemInputSchema,
+  ConfigItemSchema,
+  CreateActionCommandRequestSchema,
+  CreateRegistrationTokenRequestSchema,
+  CreateRegistrationTokenResponseSchema,
+  DangerLevel,
+  DangerLevelSchema,
+  DashboardSummarySchema,
+  ErrorCode,
+  HealthReportInputSchema,
+  HealthReportSchema,
+  HealthStatus,
+  HealthStatusSchema,
+  HttpError,
+  ListQueryBase,
+  RegisterAgentRequestSchema,
+  RegisterAgentResponseSchema,
+  RegistrationTokenSchema,
+  ReportCommandResultRequestSchema,
+  ReportedServiceSchema,
+  ServiceReportRequestSchema,
+  SystemHealthSchema,
+  SystemVersionSchema,
+  TokenStatus,
+  UserRole,
+  UserSchema,
+  actionDefinitionInputSchema,
+  adminLoginRequestSchema,
+  agentHeartbeatRequestSchema,
+  configItemInputSchema,
+  createActionCommandRequestSchema,
+  createRegistrationTokenRequestSchema,
+  createUserRequestSchema,
+  healthReportInputSchema,
+  idPrefixes,
+  newId,
+  paginate,
+  parseSort,
+  registerAgentRequestSchema,
+  reportCommandResultRequestSchema,
+  reportedServiceSchema,
+  resetUserPasswordRequestSchema,
+  serviceReportRequestSchema,
+  updateUserRequestSchema,
+  z
+});