@tequila99/githuman 0.11.2 → 0.12.0

package/dist/server/services/artifact-authorization.service.js

@@ -0,0 +1,174 @@
+import { Value } from '@sinclair/typebox/value';
+import { ArtifactAuthorizationApproveBody } from "../../shared/artifacts/schemas.js";
+import { randomUUID } from 'node:crypto';
+import { canonicalJson } from "../../shared/utils/canonical-json.js";
+import { sha256Hex } from "../utils/hash.js";
+import { artifactUserActor } from "../utils/artifact-actor.js";
+import { ForbiddenError } from "../errors/http.js";
+import { ArtifactConflictError, ArtifactNotFoundError } from "../errors/artifacts.js";
+// Grants expire with the confirmed proposal and never survive this runtime.
+const AUTHORIZATION_TTL_MS = 15 * 60_000;
+export class ArtifactAuthorizationService {
+    pending = new Map();
+    grants = new Map();
+    repository;
+    now;
+    check;
+    live;
+    changed;
+    constructor(repository, now, check, live, changed) {
+        this.repository = repository;
+        this.now = now;
+        this.check = check;
+        this.live = live;
+        this.changed = changed;
+    }
+    request(action, sessionId) {
+        if (!this.live(sessionId)) {
+            throw new ForbiddenError('Action session is unavailable.');
+        }
+        for (const [id, value] of this.pending) {
+            if (value.expiresAt <= this.now() || !this.live(value.sessionId)) {
+                this.pending.delete(id);
+            }
+        }
+        for (const [id, value] of this.grants) {
+            if (value.expiresAt <= this.now() ||
+                !this.live(value.sessionId) ||
+                this.repository.consumed(id)) {
+                this.grants.delete(id);
+            }
+        }
+        if (this.pending.size >= 100 || this.grants.size >= 1000) {
+            throw new ArtifactConflictError('Too many pending actions or authorizations.');
+        }
+        const binding = this.check(action);
+        const value = {
+            id: randomUUID(),
+            action: structuredClone(action),
+            sessionId,
+            ...binding,
+            expiresAt: this.now() + AUTHORIZATION_TTL_MS
+        };
+        this.pending.set(value.id, value);
+        this.changed();
+        return structuredClone(value);
+    }
+    list() {
+        return [...this.pending.values()]
+            .filter(value => value.expiresAt > this.now() && this.live(value.sessionId))
+            .map(value => structuredClone(value));
+    }
+    approve(id, request) {
+        if (request.method !== 'POST' ||
+            request.routeOptions.url !== '/api/artifact-actions/:id/approve') {
+            throw new ForbiddenError('Structured user confirmation is required.');
+        }
+        const user = artifactUserActor(request);
+        if (!Value.Check(ArtifactAuthorizationApproveBody, request.body)) {
+            throw new ForbiddenError('Structured confirmation is invalid.');
+        }
+        const sourceUserRequestId = request.body.sourceUserRequestId;
+        const pending = this.pending.get(id);
+        if (!pending) {
+            const previous = [...this.grants.values()].find(value => value.pendingActionId === id &&
+                value.sourceUserRequestId === sourceUserRequestId &&
+                canonicalJson(value.user) === canonicalJson(user));
+            if (!previous)
+                throw new ArtifactNotFoundError();
+            this.assert(previous.id, previous.sessionId, previous.action);
+            return { authorizationId: previous.id, expiresAt: previous.expiresAt };
+        }
+        if (pending.expiresAt <= this.now() || !this.live(pending.sessionId)) {
+            throw new ForbiddenError('Pending action expired or was revoked.');
+        }
+        const current = this.check(pending.action);
+        if (canonicalJson(current) !==
+            canonicalJson({
+                actionDigest: pending.actionDigest,
+                manifestDigest: pending.manifestDigest
+            })) {
+            throw new ArtifactConflictError('Pending action is stale.');
+        }
+        const grant = {
+            ...pending,
+            pendingActionId: id,
+            id: randomUUID(),
+            user,
+            sourceUserRequestId
+        };
+        this.repository.appendAuthorization(grant.id, grant);
+        this.grants.set(grant.id, grant);
+        this.pending.delete(id);
+        this.changed();
+        return { authorizationId: grant.id, expiresAt: grant.expiresAt };
+    }
+    assert(id, sessionId, action) {
+        const grant = this.grants.get(id);
+        if (!grant ||
+            grant.sessionId !== sessionId ||
+            grant.expiresAt <= this.now() ||
+            !this.live(sessionId) ||
+            this.repository.consumed(id)) {
+            throw new ForbiddenError('Authorization is missing, expired, consumed or belongs to another session.');
+        }
+        const current = this.check(action);
+        if (canonicalJson(action) !== canonicalJson(grant.action) ||
+            current.actionDigest !== grant.actionDigest ||
+            current.manifestDigest !== grant.manifestDigest) {
+            throw new ArtifactConflictError('Authorization is stale or has the wrong scope.');
+        }
+        return grant;
+    }
+    describe(id) {
+        const pending = this.pending.get(id);
+        const grant = pending
+            ? undefined
+            : [...this.grants.values()].find(value => value.pendingActionId === id);
+        const value = pending ?? grant;
+        if (!value ||
+            value.expiresAt <= this.now() ||
+            !this.live(value.sessionId)) {
+            throw new ArtifactNotFoundError();
+        }
+        return {
+            pending: grant ? { ...grant, id: grant.pendingActionId } : value,
+            phase: grant
+                ? this.repository.consumed(grant.id)
+                    ? 'consumed'
+                    : 'authorized'
+                : 'pending',
+            authorizationId: grant?.id ?? null
+        };
+    }
+    status(id, sessionId) {
+        const value = this.describe(id);
+        if (value.pending.sessionId !== sessionId)
+            throw new ArtifactNotFoundError();
+        return {
+            id,
+            state: value.phase,
+            authorizationId: value.authorizationId,
+            expiresAt: value.pending.expiresAt
+        };
+    }
+    consume(id) {
+        this.repository.authorizationEvent(id, 'consumed', { at: this.now() });
+    }
+    revoke(id) {
+        const grant = [...this.grants.values()].find(value => value.pendingActionId === id);
+        if (grant) {
+            this.grants.delete(grant.id);
+            this.repository.authorizationEvent(grant.id, 'revoked', {
+                at: this.now()
+            });
+        }
+        this.grants.delete(id);
+        this.pending.delete(id);
+        this.repository.authorizationEvent(id, 'revoked', { at: this.now() });
+        this.changed();
+    }
+}
+export function artifactActionDigest(action) {
+    return sha256Hex(canonicalJson(action));
+}

package/dist/server/services/artifact-definition.service.js

@@ -0,0 +1,96 @@
+import { Value } from '@sinclair/typebox/value';
+import { ArtifactActorSchema } from "../../shared/artifacts/schemas.js";
+import { canonicalJson } from "../../shared/utils/canonical-json.js";
+import { ArtifactConflictError, ArtifactInputError, ArtifactNotFoundError } from "../errors/artifacts.js";
+import { sha256Hex } from "../utils/hash.js";
+import { artifactPage } from "../utils/artifact-page.js";
+export function assertDefinitionInput(schema, value) {
+    if (!Value.Check(schema, value)) {
+        throw new ArtifactInputError('Invalid definition input.');
+    }
+}
+export class ArtifactDefinitionService {
+    options;
+    kind;
+    constructor(options, kind) {
+        this.options = options;
+        this.kind = kind;
+    }
+    get(id) {
+        const result = this.options.repository.get(this.kind, id);
+        if (!result)
+            throw new ArtifactNotFoundError();
+        return result;
+    }
+    list(limit = 50, cursor, search = '') {
+        const needle = search.trim().toLocaleLowerCase();
+        return this.options.catalog.readSnapshot(() => artifactPage(this.matching(needle), {
+            storeId: this.options.catalog.storeId,
+            epoch: this.options.catalog.epoch(),
+            // The cursor carries the search text, so a cursor cannot cross searches.
+            query: needle ? `${this.kind}:search:${needle}` : this.kind,
+            limit,
+            cursor
+        }));
+    }
+    matching(needle) {
+        const items = this.options.repository.all(this.kind);
+        if (!needle)
+            return items;
+        return items.filter(item => {
+            const name = 'title' in item ? item.title : item.label;
+            return `${name} ${item.id}`.toLocaleLowerCase().includes(needle);
+        });
+    }
+    history(id) {
+        this.get(id);
+        return this.options.repository.history(this.kind, id);
+    }
+    historyPage(id, limit = 50, cursor) {
+        return this.options.catalog.readSnapshot(() => artifactPage(this.history(id), {
+            storeId: this.options.catalog.storeId,
+            epoch: this.options.catalog.epoch(),
+            query: `${this.kind}:history:${id}`,
+            limit,
+            cursor
+        }));
+    }
+    mutate(requestId, payload, actor, run) {
+        return this.command(requestId, payload, actor, () => {
+            const result = run();
+            this.options.repository.append(this.kind, result, requestId, actor, new Date((this.options.now ?? Date.now)()).toISOString());
+            this.options.catalog.recordChange(this.kind, result.id, requestId);
+            return result;
+        });
+    }
+    command(requestId, payload, actor, run) {
+        const command = this.commandWithReplay(requestId, payload, actor, run);
+        this.options.onChange();
+        return command.result;
+    }
+    commandWithReplay(requestId, payload, actor, run) {
+        if (typeof requestId !== 'string' ||
+            !requestId.length ||
+            requestId.length > 128) {
+            throw new ArtifactInputError('Invalid request identifier.');
+        }
+        assertDefinitionInput(ArtifactActorSchema, actor);
+        const hash = sha256Hex(canonicalJson({ kind: this.kind, payload, actor }));
+        return this.options.catalog.transaction(() => {
+            const replay = this.options.repository.replay(requestId, hash);
+            if (replay)
+                return { result: replay.result, replayed: true };
+            const created = run();
+            this.options.repository.record(requestId, hash, created);
+            return { result: created, replayed: false };
+        });
+    }
+    assertVersion(actual, expected) {
+        if (!Number.isSafeInteger(expected) || expected < 1) {
+            throw new ArtifactInputError('Invalid expected version.');
+        }
+        if (actual !== expected) {
+            throw new ArtifactConflictError('Definition version changed.');
+        }
+    }
+}

package/dist/server/services/artifact-export.service.js

@@ -0,0 +1,44 @@
+import { Readable } from 'node:stream';
+// Bound allocation independently of the total number of metadata versions.
+const HISTORY_PAGE_SIZE = 50;
+export class ArtifactExportService {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    original(id) {
+        return this.storage.catalog.readSnapshot(() => this.storage.readVerifiedFile(id));
+    }
+    metadataHistory(id) {
+        const storage = this.storage;
+        const snapshot = storage.catalog.readSnapshot(() => {
+            const snapshotSeq = storage.catalog.eventSequence();
+            storage.catalog.assertExportHistory(id, snapshotSeq);
+            return {
+                formatVersion: 1,
+                storeId: storage.storeId,
+                artifactId: id,
+                snapshotSeq,
+                storeEpoch: storage.catalog.epoch(),
+                artifact: storage.get(id)
+            };
+        });
+        async function* chunks() {
+            yield JSON.stringify(snapshot).slice(0, -1) + ',"history":[';
+            let afterSeq = 0;
+            let first = true;
+            for (;;) {
+                const page = storage.catalog.exportHistory(id, afterSeq, snapshot.snapshotSeq, HISTORY_PAGE_SIZE);
+                if (!page.length)
+                    break;
+                for (const event of page) {
+                    yield (first ? '' : ',') + JSON.stringify(event);
+                    first = false;
+                    afterSeq = event.seq;
+                }
+            }
+            yield ']}';
+        }
+        return Readable.from(chunks(), { objectMode: false });
+    }
+}