@astrale-domains/shell 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/integrations/user-invitation/request-user-invitation.d.ts

@@ -0,0 +1,8 @@
+import type { InviteRequest } from './invite-user-request.js';
+export declare const enrollment: import("@astrale-os/sdk/integration").IntegrationDefinition<"shell.enrollment", {
+    invite: import("@astrale-os/sdk/integration").IntegrationOperation<InviteRequest, {
+        invitationId: string;
+        user: string;
+        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+    }>;
+}>;

package/dist/integrations/user-invitation/request-user-invitation.js

@@ -0,0 +1,9 @@
+import { defineIntegration } from '@astrale-os/sdk/integration';
+export const enrollment = defineIntegration({
+    id: 'shell.enrollment',
+    operations: {
+        invite: defineIntegration.operation({
+            replay: ({ requestId }) => ({ kind: 'keyed', source: 'input', key: requestId }),
+        }),
+    },
+});

package/dist/mutations/group/index.js

@@ -1,2 +1 @@
-export { assignLocalGroupMembership, assignGroupMembership, unassignGroupMembership, } from './membership.js';
-//# sourceMappingURL=index.js.map
+export { setGroupMembership } from './set-group-membership.js';

package/dist/mutations/group/set-group-membership.js

@@ -0,0 +1,29 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const setGroupMembership = defineMutation()((domain) => ({
+    id: 'shell.group.membership.set',
+    build(input, mutation) {
+        mutation.expect.query(input.current.endpoints);
+        mutation.expect.query(input.current.guard);
+        const endpoints = { source: input.member, target: input.group };
+        const changes = [
+            { class: domain.classes.member_of_group, current: input.current.membership },
+            { class: domain.dependencies.kernel.classes.extends_with, current: input.current.authority },
+        ];
+        for (const edge of changes) {
+            if (edge.current === input.present)
+                continue;
+            if (input.present)
+                mutation.createEdge({ class: edge.class, ...endpoints });
+            else
+                mutation.deleteEdge({ class: edge.class, ...endpoints });
+        }
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => {
+        if (failure.outcomeKnown &&
+            failure.code !== 'MUTATION_PRECONDITION_FAILED' &&
+            failure.code !== 'MUTATION_CONFLICT')
+            throw failure;
+        return { ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown };
+    },
+}));

package/dist/providers/admin-enrollment/create-admin-enrollment-provider.js

@@ -0,0 +1,78 @@
+import { TransportError } from '@astrale-os/sdk/client';
+import { defineProvider } from '@astrale-os/sdk/integration';
+import { z } from 'zod';
+import { enrollment, InvitationRequestFailure } from '../../integrations/user-invitation/index.js';
+import { decodeAdminInvitationResponse } from './decode-admin-invitation-response.js';
+import { readReply } from './read-enrollment-response.js';
+// Environment is a representation boundary, unlike already-admitted handler input.
+const configuration = z.object({ ENROLLMENT_INGRESS_URL: z.string().url() });
+export function enrollmentProvider(environment) {
+    const input = configuration.parse(environment);
+    const endpoint = new URL(input.ENROLLMENT_INGRESS_URL);
+    if (endpoint.protocol !== 'https:' ||
+        endpoint.username ||
+        endpoint.password ||
+        endpoint.hash ||
+        endpoint.search) {
+        throw new TypeError('Enrollment ingress must be an HTTPS URL without credentials, query or hash.');
+    }
+    const audience = endpoint.href;
+    return defineProvider(enrollment, {
+        async invite(input, execution) {
+            if (execution.auth === undefined)
+                throw new Error('Authenticated Shell invocation required.');
+            // Mint per attempt, using only the current invocation's Domain-self identity.
+            const credential = await execution.auth.mint({ audience, ttlSeconds: 60 });
+            execution.signal.throwIfAborted();
+            const remaining = execution.deadline - Date.now();
+            if (remaining <= 0) {
+                throw TransportError.invocation('Enrollment deadline exceeded.', {
+                    phase: 'timeout',
+                    delivery: 'not-sent',
+                });
+            }
+            // No automatic HTTP retry. A timeout after send has an unknown effect.
+            const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(remaining)]);
+            const response = await fetch(audience, {
+                method: 'POST',
+                // Workers reject redirect:error before sending. Manual preserves the refusal:
+                // every 3xx is rejected below, without forwarding the proof to its Location.
+                redirect: 'manual',
+                headers: {
+                    Authorization: `Bearer ${credential}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'Idempotency-Key': input.requestId,
+                },
+                body: JSON.stringify(input),
+                signal,
+            }).catch((cause) => {
+                if (!(cause instanceof TypeError) && !(cause instanceof DOMException))
+                    throw cause;
+                throw TransportError.invocation('Admin enrollment transport failed.', {
+                    phase: signal.aborted ? 'timeout' : 'unknown',
+                    delivery: 'unknown',
+                });
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                if (response.status === 409)
+                    throw new InvitationRequestFailure('INVITATION_CONFLICT');
+                if (response.status === 400 || response.status === 422) {
+                    throw new InvitationRequestFailure('INVITATION_REJECTED');
+                }
+                // Shell admission already happened. A refused service credential is not a new
+                // authorization decision about the caller, and no upstream body is exposed.
+                throw TransportError.invocation('Admin enrollment request was not completed.', {
+                    phase: 'receive',
+                    delivery: 'unknown',
+                });
+            }
+            const result = decodeAdminInvitationResponse(await readReply(response));
+            if (result.requestId !== input.requestId || result.user !== input.user) {
+                throw new TypeError('Admin enrollment response does not match the request.');
+            }
+            return { invitationId: result.invitationId, user: result.user, state: result.state };
+        },
+    });
+}

package/dist/providers/admin-enrollment/decode-admin-invitation-response.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+// Codec du JSON HTTP entrant ; la valeur admise satisfait le contrat de l'Integration.
+const httpReply = z.object({
+    requestId: z.string().min(1),
+    invitationId: z.string().min(1),
+    user: z.string().min(1),
+    state: z.enum([
+        'pending',
+        'accepted',
+        'registering',
+        'registered',
+        'completed',
+        'cancelled',
+        'expired',
+        'failed',
+    ]),
+});
+export function decodeAdminInvitationResponse(value) {
+    return httpReply.parse(value);
+}

package/dist/providers/admin-enrollment/index.js

@@ -0,0 +1 @@
+export { enrollmentProvider } from './create-admin-enrollment-provider.js';

package/dist/providers/admin-enrollment/read-enrollment-response.js

@@ -0,0 +1,34 @@
+export async function readReply(response) {
+    if (!response.headers.get('content-type')?.toLowerCase().startsWith('application/json')) {
+        await response.body?.cancel();
+        throw new TypeError('Expected a JSON enrollment response.');
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new TypeError('Missing enrollment response body.');
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > 16384) {
+                await reader.cancel();
+                throw new TypeError('Enrollment response exceeds 16 KiB.');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+}

package/dist/queries/application/index.js

@@ -1,3 +1 @@
-export { observeApplicationAssociation, } from './association.js';
-export { observeApplicationPresence, resolveShellApplication } from './identity.js';
-//# sourceMappingURL=index.js.map
+export { readInstalledEntrypoints } from './read-installed-entrypoints.js';

package/dist/queries/application/read-installed-entrypoints.js

@@ -0,0 +1,44 @@
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+const VIEW_MEMBER = /^view\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/**
+ * Every installed Domain entrypoint this authority can read, in origin order. The `of_domain`
+ * locator of a View that has an outgoing `entrypoint` Edge names that View (`view.<name>`), and its
+ * target is the Domain, whose Node carries the origin and the display name.
+ */
+export const readInstalledEntrypoints = defineQuery()((domain) => {
+    const kernel = domain.dependencies.kernel.classes;
+    return {
+        id: 'shell.application.entrypoints',
+        page: { size: 200 },
+        pagination: { maximumPages: 50 },
+        build: () => {
+            const located = Query.from({ edges: [kernel.of_domain] });
+            return located
+                .expand({ from: located.source, via: [kernel.entrypoint], direction: 'outgoing' })
+                .select({
+                kind: 'edges',
+                binding: located.edge,
+                projection: { edge: 'value', source: 'reference', target: 'value' },
+            });
+        },
+        project(pages) {
+            const entries = [];
+            for (const page of pages) {
+                for (const item of queryResult.edgeItems(page, 'Installed entrypoints')) {
+                    if (item.edge.kind !== 'value' || item.target.kind !== 'value') {
+                        throw new TypeError('Installed entrypoint is not a complete value.');
+                    }
+                    const member = VIEW_MEMBER.exec(String(item.edge.value.props[kernel.of_domain.properties.member.key]));
+                    const props = item.target.value.props;
+                    const origin = props[kernel.Domain.properties.origin.key];
+                    const name = props[kernel.Domain.properties.name.key];
+                    if (member === null || typeof origin !== 'string' || typeof name !== 'string') {
+                        throw new TypeError('Installed entrypoint has no View, origin, or name.');
+                    }
+                    entries.push({ origin, name, view: `${origin}:view.${member[1]}` });
+                }
+            }
+            return entries.sort((left, right) => left.origin.localeCompare(right.origin));
+        },
+    };
+});

package/dist/queries/group/index.js

@@ -1,3 +1,2 @@
-export { resolveShellAdministratorGroup } from './identity.js';
-export { observeGroupMembership, } from './membership.js';
-//# sourceMappingURL=index.js.map
+export { readGroupMembership, } from './read-group-membership.js';
+export { readGroupMembershipEndpoints } from './read-group-membership-endpoints.js';

package/dist/queries/group/read-group-membership-endpoints.js

@@ -0,0 +1,18 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+export const readGroupMembershipEndpoints = defineQuery()(() => ({
+    id: 'shell.group.membership.endpoints',
+    page: { size: 2 },
+    pagination: { maximumPages: 2 },
+    build: ({ member, group }) => Query.from({ nodes: [Path.id(member), Path.id(group)] }).select({
+        kind: 'nodes',
+        projection: { kind: 'reference' },
+    }),
+    project(pages, input, { ast, complete }) {
+        const ids = queryResult.completeNodeIds(pages, 'Shell membership endpoints');
+        return {
+            visible: ids.includes(input.member) && ids.includes(input.group),
+            guard: { query: ast, equals: complete },
+        };
+    },
+}));

package/dist/queries/group/read-group-membership.js

@@ -0,0 +1,35 @@
+import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
+export const readGroupMembership = defineQuery()((domain) => ({
+    id: 'shell.group.membership.read',
+    build({ member, group }) {
+        const edges = Query.from({
+            edges: [domain.classes.member_of_group, domain.dependencies.kernel.classes.extends_with],
+        });
+        return edges
+            .filter({ binding: edges.source, predicate: { kind: 'identity.equal', identity: member } })
+            .filter({ binding: edges.target, predicate: { kind: 'identity.equal', identity: group } })
+            .select({
+            kind: 'edges',
+            projection: { edge: 'value', source: 'reference', target: 'reference' },
+        });
+    },
+    pagination: { maximumPages: 4 },
+    project(pages, _input, { ast, complete }) {
+        let membership = false;
+        let authority = false;
+        for (const page of pages) {
+            for (const item of queryResult.edgeItems(page, 'Shell group membership')) {
+                if (item.edge.kind !== 'value')
+                    throw new TypeError('Expected an Edge value.');
+                if (item.edge.value.class === domain.classes.member_of_group.key)
+                    membership = true;
+                else if (item.edge.value.class === domain.dependencies.kernel.classes.extends_with.key) {
+                    authority = true;
+                }
+                else
+                    throw new TypeError('Unexpected Edge Class.');
+            }
+        }
+        return { membership, authority, guard: { query: ast, equals: complete } };
+    },
+}));