@iblai/data-layer 1.21.0 → 1.23.0

package/dist/src/features/virtual-machine/constants.d.ts

@@ -0,0 +1,63 @@
+import { SERVICES } from '@data-layer/constants';
+export declare const VIRTUAL_MACHINE_REDUCER_PATH = "virtualMachineApiSlice";
+export declare const VIRTUAL_MACHINE_QUERY_KEYS: {
+    readonly NETWORK_POLICIES: "VirtualMachineNetworkPolicies";
+    readonly SECRETS: "VirtualMachineSecrets";
+};
+export declare const VIRTUAL_MACHINE_ENDPOINTS: {
+    /** GET (list) / POST (create) / PATCH (update by `id`) / DELETE (by `id`). */
+    NETWORK_POLICIES: {
+        service: SERVICES;
+        path: (org: string) => string;
+    };
+    /** GET (list) / POST (create) / PATCH (update by `env_var`) / DELETE (by `env_var`). */
+    SECRETS: {
+        service: SERVICES;
+        path: (org: string) => string;
+    };
+};
+/**
+ * RBAC permission names the backend checks on each endpoint. Listed for
+ * reference — the UI gates on the list call's 403 rather than on these.
+ */
+export declare const VIRTUAL_MACHINE_PERMISSIONS: {
+    readonly NETWORK_POLICIES: {
+        readonly LIST: "Ibl.Mentor/VirtualMachineNetworkPolicies/list";
+        readonly WRITE: "Ibl.Mentor/VirtualMachineNetworkPolicies/write";
+        readonly DELETE: "Ibl.Mentor/VirtualMachineNetworkPolicies/delete";
+    };
+    readonly SECRETS: {
+        readonly LIST: "Ibl.Mentor/VirtualMachineSecrets/list";
+        readonly WRITE: "Ibl.Mentor/VirtualMachineSecrets/write";
+        readonly DELETE: "Ibl.Mentor/VirtualMachineSecrets/delete";
+    };
+};
+/** Egress profiles, in the order the UI lists them. `none` is the default. */
+export declare const VIRTUAL_MACHINE_EGRESS_PROFILES: readonly ["none", "registries", "public", "custom"];
+/**
+ * Fast client-side check for a `host:port` entry. The backend is authoritative
+ * (it also rejects wildcards, schemes, paths and the reserved hosts below), so
+ * its message is always surfaced when it disagrees.
+ */
+export declare const VIRTUAL_MACHINE_HOST_PORT_PATTERN: RegExp;
+/** Hostnames the backend refuses in any allowlist. */
+export declare const VIRTUAL_MACHINE_REJECTED_HOSTS: readonly ["localhost", "metadata", "metadata.google.internal", "instance-data", "instance-data.ec2.internal"];
+/** Hostname suffixes the backend refuses in any allowlist. */
+export declare const VIRTUAL_MACHINE_REJECTED_HOST_SUFFIXES: readonly [".local", ".internal", ".localhost"];
+/** `env_var` of a VM secret: a POSIX-style environment variable name. */
+export declare const VIRTUAL_MACHINE_ENV_VAR_PATTERN: RegExp;
+/** A network policy holds between 1 and 100 hosts. */
+export declare const VIRTUAL_MACHINE_MAX_POLICY_HOSTS = 100;
+/** An agent may bind at most 20 VM secrets. */
+export declare const VIRTUAL_MACHINE_MAX_SECRETS_PER_MENTOR = 20;
+/** A pasted secret value must be at least this long. */
+export declare const VIRTUAL_MACHINE_SECRET_VALUE_MIN_LENGTH = 8;
+/**
+ * Default VM runtime billing: charged to the chatting user's credits, prorated
+ * per second. The rate is configurable per org, so the UI presents these as
+ * the default rather than the org's actual rate.
+ */
+export declare const VIRTUAL_MACHINE_DEFAULT_BILLING: {
+    readonly usd: 1;
+    readonly minutes: 10;
+};

package/dist/src/features/virtual-machine/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-slice';
+export * from './constants';
+export * from './types';
+export * from './utils';

package/dist/src/features/virtual-machine/types.d.ts

@@ -0,0 +1,163 @@
+import { VIRTUAL_MACHINE_EGRESS_PROFILES } from './constants';
+/**
+ * How much network the agent's VM gets:
+ * - `none` — nothing (default)
+ * - `registries` — PyPI, npm, apt and apk only
+ * - `public` — any public host; private networks, localhost and cloud metadata stay blocked
+ * - `custom` — only the hosts in the bound network policy
+ */
+export type VirtualMachineEgress = (typeof VIRTUAL_MACHINE_EGRESS_PROFILES)[number];
+export interface VirtualMachineNetworkPolicy {
+    id: number;
+    /** Unique within the org, max 255 characters. */
+    name: string;
+    /** 1–100 `host:port` entries. IP addresses are allowed (except reserved ranges). */
+    allowed_hosts: string[];
+    /** May be blank. */
+    description: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface VirtualMachineNetworkPolicyCreateRequest {
+    name: string;
+    allowed_hosts: string[];
+    description?: string;
+}
+/** `id` identifies the policy; send only the fields that change. `allowed_hosts` replaces the whole list. */
+export interface VirtualMachineNetworkPolicyUpdateRequest {
+    id: number;
+    name?: string;
+    allowed_hosts?: string[];
+    description?: string;
+}
+export interface ListVirtualMachineNetworkPoliciesArgs {
+    org: string;
+}
+export interface CreateVirtualMachineNetworkPolicyArgs {
+    org: string;
+    body: VirtualMachineNetworkPolicyCreateRequest;
+}
+export interface UpdateVirtualMachineNetworkPolicyArgs {
+    org: string;
+    body: VirtualMachineNetworkPolicyUpdateRequest;
+}
+export interface DeleteVirtualMachineNetworkPolicyArgs {
+    org: string;
+    id: number;
+}
+/**
+ * A secret as the list endpoint returns it. No endpoint ever returns the
+ * value, not even masked.
+ */
+export interface VirtualMachineSecret {
+    /** Used when binding the secret to an agent. */
+    id: number;
+    /** Display name, max 255 characters. */
+    name: string;
+    /**
+     * The environment variable the agent uses (e.g. `ACME_KEY`). Unique within
+     * the org and the key for PATCH and DELETE; it cannot be renamed.
+     */
+    env_var: string;
+    /** The only hosts the real value is ever sent to. Hostnames only, no IPs. */
+    allow_hosts: string[];
+    /** Set when the value is read from an integration credential at run time. */
+    source_credential_id: number | null;
+    /** The credential field the value is read from; `""` for a stored value. */
+    source_field: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Create with **either** `value` (a pasted key, min 8 characters) **or**
+ * `source_credential_id` + `source_field` (read from an integration
+ * credential at run time), never both.
+ */
+export interface VirtualMachineSecretCreateRequest {
+    name: string;
+    env_var: string;
+    allow_hosts: string[];
+    value?: string;
+    source_credential_id?: number;
+    source_field?: string;
+}
+/**
+ * `env_var` identifies the secret; send only the fields that change. Sending
+ * `value` switches it to a stored value and drops any credential link; sending
+ * `source_credential_id` + `source_field` switches it to a credential and
+ * discards the stored value; sending neither leaves the value unchanged.
+ */
+export interface VirtualMachineSecretUpdateRequest {
+    env_var: string;
+    name?: string;
+    allow_hosts?: string[];
+    value?: string;
+    source_credential_id?: number;
+    source_field?: string;
+}
+export interface ListVirtualMachineSecretsArgs {
+    org: string;
+}
+export interface CreateVirtualMachineSecretArgs {
+    org: string;
+    body: VirtualMachineSecretCreateRequest;
+}
+export interface UpdateVirtualMachineSecretArgs {
+    org: string;
+    body: VirtualMachineSecretUpdateRequest;
+}
+export interface DeleteVirtualMachineSecretArgs {
+    org: string;
+    envVar: string;
+}
+/** The bound policy as embedded in the mentor-settings response. */
+export interface MentorVirtualMachineNetworkPolicyRef {
+    id: number;
+    name: string;
+    allowed_hosts: string[];
+}
+/** A bound secret as embedded in the mentor-settings response. */
+export interface MentorVirtualMachineSecretRef {
+    id: number;
+    name: string;
+    env_var: string;
+    allow_hosts: string[];
+    source_credential_id: number | null;
+}
+export interface MentorVirtualMachineSettings {
+    enable_virtual_machine: boolean;
+    virtual_machine_egress: VirtualMachineEgress;
+    /** `null` when no policy is bound. */
+    virtual_machine_network_policy: MentorVirtualMachineNetworkPolicyRef | null;
+    /** `[]` when no secrets are bound. */
+    virtual_machine_secrets: MentorVirtualMachineSecretRef[];
+}
+/** PUT keys — the endpoint is a partial update, so send only what changes. */
+export interface MentorVirtualMachineSettingsUpdate {
+    enable_virtual_machine?: boolean;
+    virtual_machine_egress?: VirtualMachineEgress;
+    /** The policy used under `custom`; `null` clears it. */
+    virtual_machine_network_policy_id?: number | null;
+    /** Replaces the full set of bound secrets; `[]` unbinds all. Max 20. */
+    virtual_machine_secret_ids?: number[];
+}
+/** Field → messages, e.g. `{ allowed_hosts: ["'x' must be 'host:port'…"] }`. */
+export type VirtualMachineApiFieldErrors = Record<string, string[]>;
+/** Every 400 from these endpoints: `error` is either field errors or a plain message. */
+export interface VirtualMachineApiErrorBody {
+    error: string | VirtualMachineApiFieldErrors;
+}
+/** A 400 body normalised for display: a form-level message and/or per-field messages. */
+export interface VirtualMachineApiError {
+    status?: number;
+    /** Form-level message (a plain-string `error`, or `non_field_errors`). */
+    message: string | null;
+    fieldErrors: VirtualMachineApiFieldErrors;
+}
+/** Why a `host:port` entry failed the client-side check. */
+export type VirtualMachineHostPortIssue = 'format' | 'port' | 'rejected_host' | 'ip_not_allowed';
+/** Hosts a bound secret needs that the bound network policy does not allow. */
+export interface VirtualMachineUncoveredSecretHosts {
+    envVar: string;
+    hosts: string[];
+}

package/dist/src/features/virtual-machine/utils.d.ts

@@ -0,0 +1,55 @@
+import type { VirtualMachineApiError, VirtualMachineEgress, VirtualMachineHostPortIssue, VirtualMachineUncoveredSecretHosts } from './types';
+/**
+ * Normalise a `host:port` entry the way the backend stores it: trimmed and
+ * lowercased.
+ */
+export declare function normalizeHostPort(value: string): string;
+/** Split a pasted or typed string into candidate `host:port` entries. */
+export declare function splitHostPortInput(value: string): string[];
+/** Whether the host part is an IPv4 literal (the `host:port` grammar admits no IPv6). */
+export declare function isIpAddressHost(host: string): boolean;
+/**
+ * IPv4 literals the backend refuses even where IPs are allowed: loopback,
+ * link-local, multicast, reserved and the unspecified address.
+ */
+export declare function isRejectedIpAddress(host: string): boolean;
+/** Whether the backend refuses this hostname outright (localhost, metadata, `.internal`, …). */
+export declare function isRejectedHostname(host: string): boolean;
+/**
+ * Client-side check of one `host:port` entry, returning why it fails or `null`
+ * when it looks valid. Network policies accept IP addresses; VM secrets do
+ * not (`allowIpAddresses: false`, the default). The backend remains
+ * authoritative, so always show its message when it rejects an entry.
+ */
+export declare function validateHostPort(value: string, options?: {
+    allowIpAddresses?: boolean;
+}): VirtualMachineHostPortIssue | null;
+/** Convenience wrapper around {@link validateHostPort}. */
+export declare function isValidHostPort(value: string, options?: {
+    allowIpAddresses?: boolean;
+}): boolean;
+/** HTTP status of an RTK Query error, if it carries one. */
+export declare function getVirtualMachineErrorStatus(error: unknown): number | undefined;
+/**
+ * Normalise a virtual-machine endpoint error for display. Every 400 has the
+ * form `{ error }`, where `error` is either a plain string (shown as a
+ * form-level message) or an object of field → messages (shown next to the
+ * matching field). `non_field_errors` is folded into the form-level message.
+ * Other shapes (`detail`, a bare string body) fall back to a message too.
+ */
+export declare function getVirtualMachineApiError(error: unknown): VirtualMachineApiError;
+/**
+ * Agent ids named by the "bound to mentors" delete error, e.g.
+ * `"This network policy is bound to mentors; move them off it first: ['<uuid>', '<uuid>']"`.
+ */
+export declare function extractBoundMentorIds(message: string | null | undefined): string[];
+/** Whether an egress profile lets the VM reach hosts at all (and so may carry secrets). */
+export declare function isVirtualMachineEgressNetworked(egress: VirtualMachineEgress | undefined): boolean;
+/**
+ * Under the `custom` profile every host a bound secret is sent to must be in
+ * the network policy. Returns, per secret, the hosts the policy is missing.
+ */
+export declare function findUncoveredSecretHosts(secrets: ReadonlyArray<{
+    env_var: string;
+    allow_hosts: string[];
+}>, allowedHosts: ReadonlyArray<string>): VirtualMachineUncoveredSecretHosts[];

package/dist/src/index.d.ts

@@ -148,6 +148,10 @@ export * from './features/user-llm-usage/constants';
 export * from './features/user-llm-usage/types';
 export * from './features/user-llm-usage/utils';
 export * from './features/user-llm-usage/hooks';
+export * from './features/virtual-machine/api-slice';
+export * from './features/virtual-machine/constants';
+export * from './features/virtual-machine/types';
+export * from './features/virtual-machine/utils';
 export * from './reducers';
 export * from './utils';
 export type { CustomQueryArgs } from './features/utils';

package/dist/tests/features/virtual-machine/api-slice.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/features/virtual-machine/constants.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/features/virtual-machine/utils.test.d.ts

@@ -0,0 +1 @@
+export {};