@tequila99/githuman 0.11.0 → 0.12.0

package/dist/server/services/agent/session-registry.js

@@ -1,3 +1,8 @@
+import { randomBytes } from 'node:crypto';
+import { ARTIFACT_MCP_SERVER_NAME, ARTIFACT_AGENT_BEARER_PATTERN, ARTIFACT_AGENT_KEY_BYTES, ARTIFACT_AGENT_KEY_ENV, ARTIFACT_AGENT_URL_ENV } from "../../../shared/artifacts/mcp-constants.js";
+import { fileURLToPath } from 'node:url';
+import { sha256Hex } from "../../utils/hash.js";
+import { ForbiddenError } from "../../errors/http.js";
 import { UnknownAgentPresetError, TooManyAgentSessionsError } from "../../errors/agents.js";
 import { MAX_AGENT_SESSIONS } from "../../../shared/agents/constants.js";
 import { uniqueChatName } from "../../../shared/agents/chat-names.js";
@@ -7,13 +12,61 @@ export function createSessionRegistry(options) {
     const sessions = new Map();
     const unsubscribeSession = new Map();
     const listeners = new Set();
+    const keys = new Map();
+    const sessionKeys = new Map();
+    const deviceReleases = new Map();
+    const requests = new Map();
     let lastEventId = 0;
+    function revoke(id) {
+        const key = sessionKeys.get(id);
+        if (key)
+            keys.delete(key);
+        sessionKeys.delete(id);
+        deviceReleases.get(id)?.();
+        deviceReleases.delete(id);
+        for (const close of requests.get(id) ?? [])
+            close();
+        requests.delete(id);
+    }
+    function mcpServers(id) {
+        const url = options.artifactUrl?.();
+        if (!url)
+            return [];
+        if (sessions.get(id)?.status === 'closed') {
+            throw new ForbiddenError('Agent session is closed.');
+        }
+        // One live key per session: a second call replaces the first.
+        const previous = sessionKeys.get(id);
+        if (previous)
+            keys.delete(previous);
+        const key = randomBytes(ARTIFACT_AGENT_KEY_BYTES).toString('hex');
+        const hash = sha256Hex(key);
+        keys.set(hash, id);
+        sessionKeys.set(id, hash);
+        const extension = import.meta.url.endsWith('.ts') ? 'ts' : 'js';
+        return [
+            {
+                name: ARTIFACT_MCP_SERVER_NAME,
+                command: process.execPath,
+                args: [
+                    fileURLToPath(new URL(`../../../cli/index.${extension}`, import.meta.url)),
+                    'mcp',
+                    '--stdio'
+                ],
+                env: [
+                    { name: ARTIFACT_AGENT_URL_ENV, value: url },
+                    { name: ARTIFACT_AGENT_KEY_ENV, value: key }
+                ]
+            }
+        ];
+    }
     function broadcast(message) {
         for (const listener of listeners) {
             listener(message);
         }
     }
     function drop(id) {
+        revoke(id);
         unsubscribeSession.get(id)?.();
         unsubscribeSession.delete(id);
         sessions.delete(id);
@@ -27,8 +80,40 @@ export function createSessionRegistry(options) {
         }
     }
     return {
+        authenticateArtifactKey(authorization) {
+            options.connections?.recheck();
+            if (!authorization ||
+                !ARTIFACT_AGENT_BEARER_PATTERN.test(authorization)) {
+                return undefined;
+            }
+            const id = keys.get(sha256Hex(authorization.slice(7)));
+            if (!id || sessions.get(id)?.status === 'closed')
+                return undefined;
+            return id;
+        },
+        trackArtifactRequest(id, close) {
+            let pending = requests.get(id);
+            if (!pending) {
+                pending = new Set();
+                requests.set(id, pending);
+            }
+            pending.add(close);
+            let released = false;
+            // A response fires both finish and close, so the second call must do nothing.
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                pending.delete(close);
+                if (pending.size === 0 && requests.get(id) === pending) {
+                    requests.delete(id);
+                }
+            };
+        },
+        notifyTasksChanged: () => broadcast({ type: 'sessions' }),
+        notifyArtifactActionsChanged: () => broadcast({ type: 'artifact-actions' }),
         listPresets: () => options.presets.map(describePreset),
-        create(presetId, reviewId, name) {
+        create(presetId, reviewId, name, deviceId, permissionPolicy, kind) {
             const preset = options.presets.find(p => p.id === presetId);
             if (!preset) {
                 throw new UnknownAgentPresetError(`Unknown agent "${presetId}"`);
@@ -38,10 +123,17 @@ export function createSessionRegistry(options) {
             }
             const session = new AgentSession({
                 preset,
+                permissionPolicy,
+                mcpServers,
                 // Open chats are told apart by name: a taken one gets "(1)", "(2)", …
                 name: uniqueChatName(name?.trim() || preset.title, [...sessions.values()].map(s => s.name)),
                 cwd: options.repositoryPath,
                 reviewId,
+                ...(kind === undefined ? {} : { kind }),
+                ...(options.taskIds ? { taskIds: options.taskIds } : {}),
+                ...(options.taskAssignment
+                    ? { taskAssignment: options.taskAssignment }
+                    : {}),
                 nextEventId: () => ++lastEventId,
                 ...(options.bufferLimit === undefined
                     ? {}
@@ -49,17 +141,29 @@ export function createSessionRegistry(options) {
             });
             sessions.set(session.id, session);
             unsubscribeSession.set(session.id, session.onEvent(envelope => {
+                if (envelope.event.type === 'status' &&
+                    envelope.event.status === 'closed') {
+                    revoke(session.id);
+                }
                 broadcast({
                     type: 'event',
                     envelope: { ...envelope, sessionId: session.id }
                 });
             }));
+            if (deviceId !== undefined) {
+                const release = options.connections?.trackDevice(deviceId, () => session.close());
+                if (!release) {
+                    session.close();
+                    return session;
+                }
+                deviceReleases.set(session.id, release);
+            }
             broadcast({ type: 'sessions' });
             void session.start();
             return session;
         },
         get: id => sessions.get(id),
-        list: () => [...sessions.values()].map(s => s.info()),
+        list: () => [...sessions.values()].map(session => session.info()),
         close(id) {
             const session = sessions.get(id);
             if (!session) {

package/dist/server/services/agent/turn-task-context.js

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

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 });
+    }
+}