attune-sdk 0.4.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 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. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such 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, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to 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 such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 David Culbreth
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,355 @@
+# attune-sdk - Node.js SDK for Attune Actions and Sensors
+
+A lightweight TypeScript package providing boilerplate for writing [Attune](https://github.com/attune-system/attune) actions and sensors.
+
+Version 0.4.0 is compatible with Attune 0.4.0 and its OpenAPI 0.4.0 contract.
+
+## Installation
+
+```bash
+npm install attune-sdk
+```
+
+## Writing Actions
+
+Actions receive parameters as JSON on stdin and output results as JSON on stdout.
+This package handles all of that:
+
+```typescript
+import { runAction } from "attune-sdk";
+
+function main(params: { name: string; count?: number }) {
+  return { greeting: `Hello, ${params.name}!`.repeat(params.count ?? 1) };
+}
+
+runAction(main);
+```
+
+Your function receives the full params object parsed from stdin JSON.
+
+### Accessing Execution Context
+
+The context is a module-level singleton available anywhere after import:
+
+```typescript
+import { context, runAction } from "attune-sdk";
+
+function main(params: { url: string; method?: string }) {
+  return { action: context.actionRef, exec_id: context.executionId };
+}
+
+runAction(main);
+```
+
+### Using the Generated API Client
+
+The SDK ships a fully typed API client generated from the Attune OpenAPI spec.
+Both `context` (actions) and `sensorContext` (sensors) expose a `.client`
+property that is pre-configured with the execution-scoped API token:
+
+```typescript
+import { context, runAction } from "attune-sdk";
+import { listPacks, getExecution } from "attune-sdk/api_client";
+
+async function main(params: { executionId: number }) {
+  // Use the pre-authenticated client from context
+  const packs = await listPacks({ client: context.client });
+  const exec = await getExecution({
+    client: context.client,
+    path: { id: params.executionId },
+  });
+  return { packs: packs.data, execution: exec.data };
+}
+
+runAction(main);
+```
+
+The client is also available in sensor context:
+
+```typescript
+import { sensorContext } from "attune-sdk";
+import { listSensors } from "attune-sdk/api_client";
+
+const sensors = await listSensors({ client: sensorContext.client });
+```
+
+You can also create a standalone client instance for custom configurations:
+
+```typescript
+import { createClient } from "attune-sdk";
+
+const client = createClient({
+  baseUrl: "http://localhost:8080",
+  headers: { Authorization: "Bearer my-token" },
+});
+```
+
+Generated operations take a single options object. Path, query, and JSON body
+values remain separate:
+
+```typescript
+import {
+  createEvent,
+  createKey,
+  deleteKey,
+  getKey,
+  installPack,
+  updateKey,
+} from "attune-sdk/api_client";
+
+const created = await createKey({
+  client,
+  body: {
+    local_ref: "deploy_token",
+    owner_type: "pack",
+    owner_pack_ref: "deployments",
+    name: "Deployment token",
+    value: "secret",
+    encrypted: true,
+  },
+});
+if (!created.data) throw new Error("Key creation failed");
+
+// Attune constructs the canonical ref. Responses also retain the local ref.
+const { ref, local_ref } = created.data.data;
+const key = await getKey({ client, path: { ref } });
+await updateKey({ client, path: { ref }, body: { name: "Production deployment token" } });
+await deleteKey({ client, path: { ref } });
+
+await installPack({
+  client,
+  body: { source: "https://github.com/example/pack.git", no_registry: true },
+});
+await createEvent({
+  client,
+  body: { trigger_ref: "monitor.alert", payload: { severity: "high" } },
+});
+```
+
+Key creation requires `local_ref` and `owner_type`. For identity, pack, action,
+and sensor scopes, pass the matching textual owner field:
+`owner_identity_login`, `owner_pack_ref`, `owner_action_ref`, or
+`owner_sensor_ref`. Do not send `ref`; the server generates the canonical value.
+Use that canonical `ref` for get, update, and delete. `getKey` decrypts the value
+according to the caller's permission and has no decrypt query parameter.
+
+### Legacy HTTP Client
+
+A simpler HTTP client is also available for ad-hoc requests:
+
+```typescript
+import { AttuneClient } from "attune-sdk/client";
+
+const client = new AttuneClient(); // reads ATTUNE_API_URL and ATTUNE_API_TOKEN from env
+const data = await client.get("/api/v1/artifacts", { params: { execution: "42" } });
+await client.post("/api/v1/artifacts/1/versions/file", { json: { created_by: "my_action" } });
+```
+
+## Writing Sensors
+
+Sensors are long-running processes that emit events. The SDK provides rule
+lifecycle management, signal handling (SIGINT/SIGTERM), and notifier WebSocket
+delivery for managed rule updates out of the box.
+
+The sensor context is a module-level singleton, accessible anywhere:
+
+```typescript
+import { sensorContext } from "attune-sdk";
+
+console.log(sensorContext.sensorRef);
+console.log(sensorContext.apiUrl);
+console.log(sensorContext.notifierWsUrl);
+console.log(sensorContext.config); // explicitly supplied ATTUNE_SENSOR_CONFIG_* vars
+```
+
+Managed sensors bootstrap their active rules from `ATTUNE_SENSOR_TRIGGERS`, then
+listen for live rule lifecycle updates from `ATTUNE_NOTIFIER_WS_URL` using the
+current `ATTUNE_API_TOKEN`. When `ATTUNE_SENSOR_TRIGGER_TYPES` is available, the
+SDK subscribes to every declared trigger type; older runtimes fall back to the
+trigger refs in the active-rule snapshot. Non-loopback plaintext `ws://` URLs
+are rejected unless `ATTUNE_ALLOW_INSECURE_NOTIFIER_WS=true` is explicitly set.
+
+The managed runtime renews sensor credentials by restarting the process. The
+SDK does not refresh tokens or write token-state files.
+
+Persisted sensor `config` is not injected into managed child processes. Put
+rule-specific values in trigger parameters. `sensorContext.config` contains
+only `ATTUNE_SENSOR_CONFIG_*` variables explicitly supplied by a custom runtime
+or process launcher; do not use plain environment variables for secrets.
+
+### Polling Sensor (`PollingSensor`)
+
+One interval timer per active rule:
+
+```typescript
+import { PollingSensor, runSensor, RuleState } from "attune-sdk";
+
+class TemperatureSensor extends PollingSensor {
+  interval = 5000; // ms
+
+  async poll(rule: RuleState) {
+    const device = (rule.triggerParams.device as string) ?? "/dev/temp0";
+    const temp = readTemperature(device);
+    if (temp > 100) {
+      await this.emit({ temperature: temp, alert: true }, { rule });
+    }
+  }
+}
+
+runSensor(TemperatureSensor);
+```
+
+Passing `{ rule }` targets that numeric rule ID by default and sends
+`trigger_instance_id: "rule_<id>"`. Use `{ rule, targetRule: false }` only when
+the event should be broadcast to every matching rule for the trigger. Targeted
+emission rejects non-positive, fractional, or unsafe JavaScript integer IDs.
+
+`interval` and `poll_interval` trigger parameters are milliseconds;
+`interval_seconds` is converted from seconds to milliseconds. Invalid,
+non-positive, non-finite, or unsupported timer delays fall back to the class
+`interval`.
+
+### Async Polling (`AsyncPollingSensor`)
+
+One async loop per active rule (ideal for I/O-bound checks):
+
+```typescript
+import { AsyncPollingSensor, runSensor, RuleState } from "attune-sdk";
+
+class ApiSensor extends AsyncPollingSensor {
+  interval = 10000; // ms
+
+  async poll(rule: RuleState) {
+    const url = rule.triggerParams.url as string;
+    const resp = await fetch(url);
+    if (resp.status >= 500) {
+      await this.emit({ url, status: resp.status }, { rule });
+    }
+  }
+}
+
+runSensor(ApiSensor);
+```
+
+### Custom Event Loops (`Sensor` base class)
+
+For non-polling sensors, override `run()`:
+
+```typescript
+import { Sensor, runSensor } from "attune-sdk";
+import { watch } from "fs";
+
+class FileWatchSensor extends Sensor {
+  async run() {
+    const path = typeof this.config.watch_path === "string"
+      ? this.config.watch_path
+      : "/var/log/app.log";
+    const watcher = watch(path, () => {
+      void this.emit({ path, event: "change" });
+    });
+    while (!this.isShuttingDown) {
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+    watcher.close();
+  }
+}
+
+runSensor(FileWatchSensor);
+```
+
+### Rule Lifecycle Hooks
+
+All sensor classes support rule lifecycle hooks that fire when the platform
+creates, enables, disables, deletes, or updates a rule:
+
+```typescript
+class StatefulSensor extends PollingSensor {
+  onRuleCreated(rule: RuleState) {
+    this.logger.info(`Rule created: ${rule.ruleRef}`);
+  }
+
+  onRuleEnabled(rule: RuleState) {
+    // Previously disabled rule re-enabled
+  }
+
+  onRuleDisabled(rule: RuleState) {
+    // Rule disabled — pause per-rule work
+  }
+
+  onRuleDeleted(rule: RuleState) {
+    // Rule permanently removed — free resources
+  }
+
+  onRuleUpdated(rule: RuleState, oldParams: Record<string, unknown>) {
+    this.logger.info(`Rule updated: ${JSON.stringify(oldParams)} → ${JSON.stringify(rule.triggerParams)}`);
+  }
+}
+```
+
+## Environment Variables
+
+### Actions
+
+| Variable | Description |
+|----------|-------------|
+| `ATTUNE_ACTION` | Action reference (e.g., `mypack.deploy`) |
+| `ATTUNE_PACK_REF` | Pack reference |
+| `ATTUNE_EXEC_ID` | Execution database ID |
+| `ATTUNE_API_URL` | API base URL |
+| `ATTUNE_API_TOKEN` | Execution-scoped API token (optional) |
+| `ATTUNE_ARTIFACTS_DIR` | Shared artifact volume path |
+| `ATTUNE_RUNTIME_ENVS_DIR` | Runtime environments root |
+| `ATTUNE_RULE` | Rule reference (if rule-triggered) |
+| `ATTUNE_TRIGGER` | Trigger reference (if event-triggered) |
+
+### Sensors
+
+| Variable | Description |
+|----------|-------------|
+| `ATTUNE_SENSOR_REF` | Sensor reference |
+| `ATTUNE_SENSOR_ID` | Sensor database ID |
+| `ATTUNE_PACK_REF` | Pack reference |
+| `ATTUNE_API_URL` | API base URL |
+| `ATTUNE_API_TOKEN` | Sensor-scoped API token |
+| `ATTUNE_NOTIFIER_WS_URL` | Notifier WebSocket URL for live managed-rule updates |
+| `ATTUNE_ALLOW_INSECURE_NOTIFIER_WS` | Allow non-loopback plaintext `ws://` only on a trusted development network (default: `false`) |
+| `ATTUNE_SENSOR_TRIGGER_TYPES` | JSON array of every trigger ref declared by the sensor, used for complete notifier subscriptions |
+| `ATTUNE_SENSOR_TRIGGERS` | Bootstrap JSON array of managed rule bindings |
+| `ATTUNE_ARTIFACTS_DIR` | Shared artifact volume path |
+| `ATTUNE_LOG_LEVEL` | Log verbosity |
+| `ATTUNE_LOG_FORMAT` | Runtime-selected log format |
+
+Legacy `ATTUNE_MQ_URL` and `ATTUNE_MQ_EXCHANGE` values may also be present, but
+this package does not depend on `amqplib`; managed lifecycle delivery uses the
+notifier WebSocket.
+
+## Development
+
+```bash
+cd js-attune-sdk
+npm install
+npm run build
+npm test
+```
+
+### Regenerating the API Client
+
+The generated client lives in `src/api_client/` and is checked into the repo so
+pack developers don't need to generate it themselves. To regenerate after API
+changes:
+
+```bash
+# From a running API (default: localhost:8080)
+npm run generate-client
+
+# From a local spec file
+./scripts/generate-client.sh /path/to/openapi.json
+
+# Verify checked-in output against ../attune/web/openapi.json without replacing it
+npm run generate-client:check
+
+# From a custom API URL
+ATTUNE_API_URL=http://my-host:8080 npm run generate-client
+```
+
+This requires `@hey-api/openapi-ts` (included as a dev dependency).

package/dist/action.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Action runner — handles stdin parameter parsing, output formatting, and error handling.
+ *
+ * Usage:
+ *   import { runAction } from "attune-sdk";
+ *
+ *   function main(params: { name: string; count?: number }) {
+ *     return { greeting: `Hello, ${params.name}!`.repeat(params.count ?? 1) };
+ *   }
+ *
+ *   runAction(main);
+ *
+ * Exit codes:
+ * - 0: success (result is written to stdout as JSON)
+ * - 1: failure (error details written to stdout as JSON with `success: false`)
+ */
+export type ActionFn<TParams extends Record<string, unknown> = Record<string, unknown>> = (params: TParams) => unknown | Promise<unknown>;
+/** Read action parameters from stdin (JSON format). */
+export declare function readParams(): Promise<Record<string, unknown>>;
+/** Write a JSON result to stdout. */
+export declare function emitResult(payload: unknown): void;
+/** Write a JSON error to stdout. */
+export declare function emitError(message: string, details?: unknown): void;
+export interface RunActionOptions {
+    /** If true (default), uncaught exceptions are caught and reported as JSON errors. */
+    catchExceptions?: boolean;
+}
+/**
+ * Run an action entrypoint with automatic parameter parsing and output handling.
+ *
+ * The entrypoint function receives the full params object parsed from stdin JSON.
+ */
+export declare function runAction<TParams extends Record<string, unknown>>(entrypoint: ActionFn<TParams>, options?: RunActionOptions): Promise<void>;
+//# sourceMappingURL=action.d.ts.map

package/dist/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,QAAQ,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACpF,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAElD,uDAAuD;AACvD,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQnE;AAED,qCAAqC;AACrC,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEjD;AAED,oCAAoC;AACpC,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAMlE;AAED,MAAM,WAAW,gBAAgB;IAC/B,qFAAqF;IACrF,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,EAC7B,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/action.js

@@ -0,0 +1,62 @@
+/**
+ * Action runner — handles stdin parameter parsing, output formatting, and error handling.
+ *
+ * Usage:
+ *   import { runAction } from "attune-sdk";
+ *
+ *   function main(params: { name: string; count?: number }) {
+ *     return { greeting: `Hello, ${params.name}!`.repeat(params.count ?? 1) };
+ *   }
+ *
+ *   runAction(main);
+ *
+ * Exit codes:
+ * - 0: success (result is written to stdout as JSON)
+ * - 1: failure (error details written to stdout as JSON with `success: false`)
+ */
+/** Read action parameters from stdin (JSON format). */
+export async function readParams() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf-8"));
+    }
+    const raw = chunks.join("").trim();
+    if (!raw)
+        return {};
+    return JSON.parse(raw);
+}
+/** Write a JSON result to stdout. */
+export function emitResult(payload) {
+    console.log(JSON.stringify(payload));
+}
+/** Write a JSON error to stdout. */
+export function emitError(message, details) {
+    const payload = { success: false, error: message };
+    if (details !== undefined) {
+        payload.details = details;
+    }
+    console.log(JSON.stringify(payload));
+}
+/**
+ * Run an action entrypoint with automatic parameter parsing and output handling.
+ *
+ * The entrypoint function receives the full params object parsed from stdin JSON.
+ */
+export async function runAction(entrypoint, options = {}) {
+    const { catchExceptions = true } = options;
+    try {
+        const params = await readParams();
+        const result = await entrypoint(params);
+        emitResult(result ?? {});
+        process.exit(0);
+    }
+    catch (err) {
+        if (!catchExceptions)
+            throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        const details = err instanceof Error && process.stderr.isTTY ? err.stack : undefined;
+        emitError(message, details);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=action.js.map

package/dist/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,uDAAuD;AACvD,MAAM,CAAC,KAAK,UAAU,UAAU;IAC9B,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,KAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;IACvF,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACnC,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IACpB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,UAAU,CAAC,OAAgB;IACzC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,oCAAoC;AACpC,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,OAAiB;IAC1D,MAAM,OAAO,GAA4B,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC5E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC;IAC5B,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;AACvC,CAAC;AAOD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,UAA6B,EAC7B,UAA4B,EAAE;IAE9B,MAAM,EAAE,eAAe,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;IAE3C,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,UAAU,EAAa,CAAC;QAC7C,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,CAAC;QACxC,UAAU,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;QACzB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACtB,IAAI,CAAC,eAAe;YAAE,MAAM,GAAG,CAAC;QAChC,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;QACrF,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC5B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC"}

package/dist/api_client/client/client.gen.d.ts

@@ -0,0 +1,3 @@
+import type { Client, Config } from './types.gen';
+export declare const createClient: (config?: Config) => Client;
+//# sourceMappingURL=client.gen.d.ts.map

package/dist/api_client/client/client.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.gen.d.ts","sourceRoot":"","sources":["../../../src/api_client/client/client.gen.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAA0C,MAAM,aAAa,CAAC;AAgB1F,eAAO,MAAM,YAAY,GAAI,SAAQ,MAAW,KAAG,MA+PlD,CAAC"}