@shipeasy/openapi 1.5.0 → 1.6.0

package/dist/resources/index.js

@@ -2355,6 +2355,166 @@ function alertRulesClient(t) {
   };
 }
 
+// src/resources/metrics.ts
+var BASE7 = "/api/admin/metrics";
+function metricsClient(t) {
+  async function list() {
+    return t.request("GET", BASE7);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((m) => m.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((m) => m.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1) throw new ApiError(`Metric id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((m) => m.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(`Metric name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
+    throw new ApiError(`Metric '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    get: (id) => t.request("GET", `${BASE7}/${id}`),
+    create: (input) => t.request("POST", BASE7, input),
+    delete: (id) => t.request("DELETE", `${BASE7}/${id}`)
+  };
+}
+
+// src/resources/events.ts
+var BASE8 = "/api/admin/events";
+function eventsClient(t) {
+  async function list() {
+    return t.request("GET", BASE8);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((e) => e.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((e) => e.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1) throw new ApiError(`Event id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((e) => e.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(`Event name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
+    throw new ApiError(`Event '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    get: (id) => t.request("GET", `${BASE8}/${id}`),
+    create: (input) => t.request("POST", BASE8, input),
+    update: (id, input) => t.request("PATCH", `${BASE8}/${id}`, input),
+    approve: (id, input = {}) => t.request("POST", `${BASE8}/${id}/approve`, input),
+    delete: (id) => t.request("DELETE", `${BASE8}/${id}`)
+  };
+}
+
+// src/resources/ops.ts
+var FEEDBACK = "/api/admin/feedback";
+var NOTIFY = "/api/admin/notifications";
+var CREATE_PATH = {
+  bug: "/api/admin/bugs",
+  feature_request: "/api/admin/feature-requests"
+};
+function itemPath(handle) {
+  return `${FEEDBACK}/${encodeURIComponent(handle)}`;
+}
+function opsClient(t) {
+  return {
+    list: (query = {}) => {
+      const q = {};
+      if (query.type) q.type = query.type;
+      if (query.status) q.status = query.status;
+      if (query.limit !== void 0) q.limit = String(query.limit);
+      return t.request("GET", FEEDBACK, void 0, q);
+    },
+    get: (handle) => t.request("GET", itemPath(handle)),
+    create: ({ type, ...body }) => t.request("POST", CREATE_PATH[type], body),
+    update: (handle, input) => t.request("PATCH", itemPath(handle), input),
+    linkPr: (handle, input) => t.request("POST", `${itemPath(handle)}/link-pr`, input),
+    notify: (input) => t.request("POST", NOTIFY, {
+      title: input.title,
+      summary: input.summary,
+      steps: input.steps ?? [],
+      ...input.href ? { href: input.href } : {},
+      ...input.dedupeKey ? { dedupeKey: input.dedupeKey } : {}
+    }),
+    channels: () => t.request("GET", "/api/admin/slack/channels")
+  };
+}
+
+// src/resources/projects.ts
+var BASE9 = "/api/admin/projects";
+function projectsClient(t) {
+  return {
+    upsert: (input) => t.request("POST", `${BASE9}/upsert`, {
+      domain: input.domain,
+      ...input.name ? { name: input.name } : {}
+    }),
+    current: () => t.request("GET", `${BASE9}/current`)
+  };
+}
+
+// src/resources/i18n.ts
+var PROFILES = "/api/admin/i18n/profiles";
+var KEYS = "/api/admin/i18n/keys";
+var DRAFTS = "/api/admin/i18n/drafts";
+function i18nClient(t) {
+  async function listProfiles() {
+    return t.request("GET", PROFILES);
+  }
+  async function resolveProfile(name) {
+    const all = await listProfiles();
+    const found = all.find((p) => p.name === name);
+    if (!found)
+      throw new ApiError(
+        `Profile '${name}' not found. Existing: ${all.map((p) => p.name).join(", ") || "(none)"}`,
+        404
+      );
+    return found;
+  }
+  async function listKeys(query = {}) {
+    const q = {};
+    if (query.profile_id) q.profile_id = query.profile_id;
+    if (query.prefix) q.prefix = query.prefix;
+    if (query.limit !== void 0) q.limit = String(query.limit);
+    const res = await t.request("GET", KEYS, void 0, q);
+    return Array.isArray(res) ? res : res.keys;
+  }
+  function updateKey(id, input) {
+    return t.request("PUT", `${KEYS}/${id}`, input);
+  }
+  return {
+    listProfiles,
+    resolveProfile,
+    listKeys,
+    updateKey,
+    createProfile: (input) => t.request("POST", PROFILES, input),
+    pushKeys: (input) => t.request("POST", KEYS, input),
+    updateKeyByName: async (profileId, key, input) => {
+      const rows = await listKeys({ profile_id: profileId, prefix: key, limit: 500 });
+      const match = rows.find((k) => k.key === key);
+      if (!match)
+        throw new ApiError(`Key '${key}' not found in profile. Add it first with i18n push.`, 404);
+      return updateKey(match.id, input);
+    },
+    listDrafts: () => t.request("GET", DRAFTS),
+    publish: (profileId, input) => t.request("POST", `${PROFILES}/${profileId}/publish`, { chunk: input.chunk ?? "default" })
+  };
+}
+
+// src/resources/attributes.ts
+var BASE10 = "/api/admin/attributes";
+function attributesClient(t) {
+  return {
+    list: () => t.request("GET", BASE10)
+  };
+}
+
 // src/resources/index.ts
 function createAdminClient(transport) {
   return {
@@ -2364,7 +2524,13 @@ function createAdminClient(transport) {
     configs: configsClient(transport),
     universes: universesClient(transport),
     killswitches: killswitchesClient(transport),
-    alertRules: alertRulesClient(transport)
+    alertRules: alertRulesClient(transport),
+    metrics: metricsClient(transport),
+    events: eventsClient(transport),
+    ops: opsClient(transport),
+    projects: projectsClient(transport),
+    i18n: i18nClient(transport),
+    attributes: attributesClient(transport)
   };
 }
 var RESOURCE_REGISTRY = [
@@ -2377,15 +2543,21 @@ var RESOURCE_REGISTRY = [
 export {
   RESOURCE_REGISTRY,
   alertRulesClient,
+  attributesClient,
   configsClient,
   configsResource,
   createAdminClient,
+  eventsClient,
   experimentsClient,
   experimentsResource,
   gatesClient,
   gatesResource,
+  i18nClient,
   killswitchesClient,
   killswitchesResource,
+  metricsClient,
+  opsClient,
+  projectsClient,
   universesClient,
   universesResource
 };

package/dist/resources/metrics.d.ts

@@ -0,0 +1,54 @@
+import { Transport } from '../transport.js';
+
+/**
+ * Metric definitions — the event-backed queries that power tracking dashboards
+ * and experiment success/guardrail metrics. A metric pins one event, one
+ * aggregation, and (for sum/avg) a value path, expressed as the metric query
+ * DSL or its typed IR form.
+ *
+ * The admin endpoint accepts either `query` (the DSL string) or `query_ir`
+ * (the typed IR). The CLI's vendored DSL parser turns `--query` into IR
+ * client-side for an early error; the server validates either form, so the
+ * registry op can pass `query` straight through and stay worker-safe (no
+ * parser bundled into the shared registry).
+ */
+interface Metric {
+    id: string;
+    name: string;
+    folder: string | null;
+    eventName: string;
+    aggregation: string;
+    valuePath: string | null;
+    queryIr?: unknown;
+    [key: string]: unknown;
+}
+interface MetricCreateInput {
+    name: string;
+    event_name: string;
+    folder?: string | null;
+    winsorize_pct?: number;
+    min_detectable_effect?: number | null;
+    /** Metric query DSL string, e.g. `sum(purchase, amount)`. */
+    query?: string;
+    /** Typed IR form (alternative to `query`). */
+    query_ir?: unknown;
+}
+interface MetricsClient {
+    /** Every metric in the project (the list endpoint is not paginated). */
+    list(): Promise<Metric[]>;
+    /** Fetch one metric by its full id. */
+    get(id: string): Promise<Metric>;
+    /** Resolve by exact id, unique id-prefix, or exact (unique) name. */
+    resolve(idOrName: string): Promise<Metric>;
+    create(input: MetricCreateInput): Promise<{
+        id: string;
+        name: string;
+    }>;
+    /** Soft-delete (the user-facing verb is `archive`). */
+    delete(id: string): Promise<{
+        ok: true;
+    }>;
+}
+declare function metricsClient(t: Transport): MetricsClient;
+
+export { type Metric, type MetricCreateInput, type MetricsClient, metricsClient };

package/dist/resources/metrics.js

@@ -0,0 +1,40 @@
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/resources/metrics.ts
+var BASE = "/api/admin/metrics";
+function metricsClient(t) {
+  async function list() {
+    return t.request("GET", BASE);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((m) => m.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((m) => m.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1) throw new ApiError(`Metric id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((m) => m.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(`Metric name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
+    throw new ApiError(`Metric '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    get: (id) => t.request("GET", `${BASE}/${id}`),
+    create: (input) => t.request("POST", BASE, input),
+    delete: (id) => t.request("DELETE", `${BASE}/${id}`)
+  };
+}
+export {
+  metricsClient
+};

package/dist/resources/ops.d.ts

@@ -0,0 +1,88 @@
+import { Transport } from '../transport.js';
+
+/**
+ * Operational queue — the unified feedback table of bug reports, feature
+ * requests, and auto-filed error/alert tickets, over `/api/admin/feedback`.
+ * One resource covers list/get/create/update/link-pr plus the `notify`
+ * escalation bell (`/api/admin/notifications`) and the Slack channel reader
+ * (`/api/admin/slack/channels`) used to resolve alert-rule targets.
+ *
+ * Item handles are either the per-project number (`7`) or the full id; the
+ * admin API resolves either, so callers pass the handle straight through.
+ */
+type OpsType = "bug" | "feature_request" | "error" | "alert";
+type OpsStatus = "open" | "triaged" | "in_progress" | "ready_for_qa" | "resolved" | "wont_fix";
+type OpsPriority = "nice_to_have" | "medium" | "high" | "critical";
+interface OpsItem {
+    id: string;
+    number: number | null;
+    type: string;
+    title: string;
+    status: string;
+    priority: string | null;
+    sourceRef?: string | null;
+    createdAt: string;
+    [key: string]: unknown;
+}
+interface OpsListQuery {
+    type?: OpsType | "all";
+    status?: OpsStatus | "all";
+    limit?: number;
+}
+interface OpsCreateInput {
+    /** Only `bug` / `feature_request` are user-fileable; error/alert are auto-filed. */
+    type: "bug" | "feature_request";
+    title: string;
+    body?: string;
+    priority?: OpsPriority;
+    stepsToReproduce?: string;
+    pageUrl?: string;
+}
+interface OpsUpdateInput {
+    status?: OpsStatus;
+    priority?: OpsPriority;
+}
+interface OpsNotifyInput {
+    title: string;
+    summary: string;
+    steps?: string[];
+    href?: string;
+    dedupeKey?: string;
+}
+interface SlackChannel {
+    id: string;
+    name: string;
+    isPrivate?: boolean;
+}
+interface SlackChannelsResponse {
+    connected: boolean;
+    channels: SlackChannel[];
+}
+interface OpsClient {
+    list(query?: OpsListQuery): Promise<OpsItem[]>;
+    get(handle: string): Promise<OpsItem>;
+    /** File a bug or feature request. Fires project connectors (GitHub/Slack). */
+    create(input: OpsCreateInput): Promise<{
+        id: string;
+        number?: number | null;
+    }>;
+    update(handle: string, input: OpsUpdateInput): Promise<{
+        id: string;
+    }>;
+    linkPr(handle: string, input: {
+        prNumber: number | null;
+        prUrl?: string;
+    }): Promise<{
+        id: string;
+    }>;
+    /** Raise a 'needs your attention' bell notification (create-only, idempotent on dedupeKey). */
+    notify(input: OpsNotifyInput): Promise<{
+        dedupeKey: string;
+        dispatched: boolean;
+    }>;
+    /** The project's Slack channels — used to resolve alert-rule `--slack-channel`. */
+    channels(): Promise<SlackChannelsResponse>;
+}
+declare function opsClient(t: Transport): OpsClient;
+
+export { type OpsClient, type OpsCreateInput, type OpsItem, type OpsListQuery, type OpsNotifyInput, type OpsPriority, type OpsStatus, type OpsType, type OpsUpdateInput, type SlackChannel, type SlackChannelsResponse, opsClient };

package/dist/resources/ops.js

@@ -0,0 +1,36 @@
+// src/resources/ops.ts
+var FEEDBACK = "/api/admin/feedback";
+var NOTIFY = "/api/admin/notifications";
+var CREATE_PATH = {
+  bug: "/api/admin/bugs",
+  feature_request: "/api/admin/feature-requests"
+};
+function itemPath(handle) {
+  return `${FEEDBACK}/${encodeURIComponent(handle)}`;
+}
+function opsClient(t) {
+  return {
+    list: (query = {}) => {
+      const q = {};
+      if (query.type) q.type = query.type;
+      if (query.status) q.status = query.status;
+      if (query.limit !== void 0) q.limit = String(query.limit);
+      return t.request("GET", FEEDBACK, void 0, q);
+    },
+    get: (handle) => t.request("GET", itemPath(handle)),
+    create: ({ type, ...body }) => t.request("POST", CREATE_PATH[type], body),
+    update: (handle, input) => t.request("PATCH", itemPath(handle), input),
+    linkPr: (handle, input) => t.request("POST", `${itemPath(handle)}/link-pr`, input),
+    notify: (input) => t.request("POST", NOTIFY, {
+      title: input.title,
+      summary: input.summary,
+      steps: input.steps ?? [],
+      ...input.href ? { href: input.href } : {},
+      ...input.dedupeKey ? { dedupeKey: input.dedupeKey } : {}
+    }),
+    channels: () => t.request("GET", "/api/admin/slack/channels")
+  };
+}
+export {
+  opsClient
+};

package/dist/resources/projects.d.ts

@@ -0,0 +1,54 @@
+import { Transport } from '../transport.js';
+
+/**
+ * Projects — find-or-create by domain (`upsert`) and the auth-resolved current
+ * project (`current`). The `.shipeasy` write that `bind`/`upsert --bind`
+ * performs is a CONSUMER side-effect layered on top of these calls (it touches
+ * the filesystem); it never lives in the resource, so this stays worker-safe.
+ */
+interface UpsertResult {
+    id: string;
+    name: string;
+    domain: string | null;
+    owner_email: string;
+    created: boolean;
+}
+/**
+ * The project the caller's auth header resolves to. The server reads the
+ * project from the credential — there is no id parameter — so `current` works
+ * with nothing but the session, which is what makes a registry-driven `whoami`
+ * possible.
+ */
+interface CurrentProject {
+    id: string;
+    name: string;
+    domain: string | null;
+    ownerEmail: string;
+    plan: "free" | "paid";
+    status: "active" | "inactive";
+    subscriptionStatus: string;
+    billingInterval: "monthly" | "annual";
+    currentPeriodEnd: string | null;
+    trialEndsAt: string | null;
+    cancelAtPeriodEnd: number;
+    moduleTranslations: boolean | number;
+    moduleConfigs: boolean | number;
+    moduleGates: boolean | number;
+    moduleExperiments: boolean | number;
+    moduleFeedback: boolean | number;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface ProjectsClient {
+    /** Find-or-create a project by domain (idempotent). */
+    upsert(input: {
+        domain: string;
+        name?: string;
+    }): Promise<UpsertResult>;
+    /** The project the auth header resolves to (no id needed). */
+    current(): Promise<CurrentProject>;
+}
+declare function projectsClient(t: Transport): ProjectsClient;
+
+export { type CurrentProject, type ProjectsClient, type UpsertResult, projectsClient };

package/dist/resources/projects.js

@@ -0,0 +1,14 @@
+// src/resources/projects.ts
+var BASE = "/api/admin/projects";
+function projectsClient(t) {
+  return {
+    upsert: (input) => t.request("POST", `${BASE}/upsert`, {
+      domain: input.domain,
+      ...input.name ? { name: input.name } : {}
+    }),
+    current: () => t.request("GET", `${BASE}/current`)
+  };
+}
+export {
+  projectsClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipeasy/openapi",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Shipeasy admin OpenAPI spec + typed client. Single source of truth for endpoint paths, request/response shapes, and the resource registry consumed by @shipeasy/cli and @shipeasy/mcp.",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,6 +26,10 @@
       "types": "./dist/schemas/*.d.ts",
       "default": "./dist/schemas/*.js"
     },
+    "./operations": {
+      "types": "./dist/operations/index.d.ts",
+      "default": "./dist/operations/index.js"
+    },
     "./transport": {
       "types": "./dist/transport.d.ts",
       "default": "./dist/transport.js"
@@ -33,6 +37,10 @@
     "./pagination": {
       "types": "./dist/pagination.d.ts",
       "default": "./dist/pagination.js"
+    },
+    "./node-context": {
+      "types": "./dist/node-context.d.ts",
+      "default": "./dist/node-context.js"
     }
   },
   "files": [
@@ -49,6 +57,7 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
+    "@types/node": "^20.19.39",
     "openapi-types": "^12.1.3",
     "tsup": "^8.3.0",
     "tsx": "^4.21.0",