@hivemagnus/ardent-studio 0.0.0-stage → 0.1.0

package/dist/agents/operations.js

@@ -0,0 +1,93 @@
+// Relays Magnus New Agent operations to the project that started them. Magnus runs the
+// operation (profile, identity, HiveMem, model, skills, start, ready probe); Studio only mirrors
+// its step receipts as `agent.operation.updated` events, from Magnus's operation stream, or by
+// polling when the stream fails. Running operations are picked up again after a restart.
+import { setTimeout as delay } from 'node:timers/promises';
+import { agentOperationSchema } from '../clients/magnus.js';
+/** An operation as the browser sees it. */
+export function operationView(record, operation) {
+    return {
+        id: record.id, agent_ref: record.agent_ref, project_id: record.project_id, role_key: record.role_key,
+        kind: operation?.kind ?? 'deploy', status: operation?.status ?? record.status,
+        steps: (operation?.steps ?? []).map(step => ({ name: step.name, status: step.status, started_at: step.startedAt, finished_at: step.finishedAt, receipt: step.receipt, error: step.error })),
+        error: operation?.error ?? null, attempts: operation?.attempts ?? 0, created_by: record.created_by,
+        created_at: record.created_at, updated_at: operation?.updatedAt ?? record.updated_at, completed_at: operation?.completedAt ?? null,
+    };
+}
+export class OperationRelay {
+    store;
+    magnus;
+    logger;
+    options;
+    running = new Map();
+    stopped = false;
+    constructor(store, magnus, logger, options = {}) {
+        this.store = store;
+        this.magnus = magnus;
+        this.logger = logger;
+        this.options = options;
+    }
+    start() {
+        this.stopped = false;
+        for (const record of this.store.agents.runningOperations())
+            this.follow(record.id);
+    }
+    async stop() {
+        this.stopped = true;
+        for (const controller of this.running.values())
+            controller.abort();
+        this.running.clear();
+    }
+    follow(id) {
+        if (this.stopped || this.running.has(id))
+            return;
+        const controller = new AbortController();
+        this.running.set(id, controller);
+        void this.run(id, controller.signal).catch(error => this.logger.warn('Agent operation relay stopped', { operation_id: id, error: error instanceof Error ? error.message.slice(0, 200) : 'unknown' }))
+            .finally(() => { if (this.running.get(id) === controller)
+            this.running.delete(id); });
+    }
+    /** Store and publish Magnus's view of an operation. True once it has finished. */
+    apply(id, operation) {
+        const record = this.store.agents.operation(id);
+        if (!record)
+            return true;
+        this.store.tx(() => {
+            if (!this.store.agents.updateOperation(id, operation.status, operation))
+                return;
+            const updated = this.store.agents.operation(id);
+            if (updated.project_id)
+                this.store.emit(updated.project_id, 'agent.operation.updated', { operation: operationView(updated, operation) });
+        });
+        const finished = operation.status !== 'running';
+        if (finished)
+            this.options.onFinished?.(operation);
+        return finished;
+    }
+    async run(id, signal) {
+        let polls = 0;
+        while (!signal.aborted && polls < (this.options.maxPolls ?? 720)) {
+            try {
+                for await (const message of this.magnus.streamAgentOperation(id, { signal })) {
+                    if (message.event !== 'operation' && message.event !== 'done')
+                        continue;
+                    const parsed = agentOperationSchema.safeParse(JSON.parse(message.data));
+                    if (parsed.success && this.apply(id, parsed.data))
+                        return;
+                }
+            }
+            catch {
+                if (signal.aborted)
+                    return;
+            }
+            // The stream ended or failed before the operation finished: read it, then try again.
+            try {
+                if (this.apply(id, await this.magnus.agentOperation(id, { signal })))
+                    return;
+            }
+            catch { /* Magnus unreachable: keep the last known state and retry. */ }
+            polls++;
+            await delay(this.options.pollMs ?? 5_000, undefined, { signal }).catch(() => undefined);
+        }
+    }
+}

package/dist/auth/links.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { type ArdentStudioPermission } from '../shared/browser.js';
+export declare class IdentityLinkError extends Error {
+    name: string;
+}
+declare const linkSchema: z.ZodObject<{
+    issuer: z.ZodURL;
+    subject: z.ZodString;
+    localUserId: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "ardentstudio:projects:read": "ardentstudio:projects:read";
+        "ardentstudio:projects:write": "ardentstudio:projects:write";
+        "ardentstudio:templates:read": "ardentstudio:templates:read";
+        "ardentstudio:templates:write": "ardentstudio:templates:write";
+        "ardentstudio:review:write": "ardentstudio:review:write";
+        "ardentstudio:agents:admin": "ardentstudio:agents:admin";
+    }>>>;
+}, z.core.$strict>;
+export type IdentityLink = z.infer<typeof linkSchema>;
+/** Parse ARDENT_STUDIO_OATHWEAVE_IDENTITIES_JSON. Throws on anything malformed or ambiguous. */
+export declare function parseIdentityLinks(raw: string): IdentityLink[];
+/** The one link for a verified person, or undefined when there is none or the links are ambiguous. */
+export declare function linkFor(links: readonly IdentityLink[], issuer: string, subject: string): IdentityLink | undefined;
+/** Token permissions narrowed by the link's ceiling. Unknown permission strings are dropped. */
+export declare function effectivePermissions(link: IdentityLink, tokenPermissions: readonly string[]): ArdentStudioPermission[];
+export {};

package/dist/auth/links.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { ARDENT_STUDIO_PERMISSIONS, permissionSchema } from '../shared/browser.js';
+export class IdentityLinkError extends Error {
+    name = 'IdentityLinkError';
+}
+const linkSchema = z.object({
+    issuer: z.url(),
+    subject: z.string().min(1).max(256),
+    /** The Studio user this person acts as; recorded on every record and audit row. */
+    localUserId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._@:-]{0,127}$/)
+        .refine(value => value !== 'system' && !value.startsWith('service:'), 'localUserId must not name the system or a service actor'),
+    displayName: z.string().trim().min(1).max(120).optional(),
+    /** A ceiling: the token's permissions grant only within it. Absent means every Studio permission. */
+    permissions: z.array(permissionSchema).max(ARDENT_STUDIO_PERMISSIONS.length).optional(),
+}).strict();
+/** Parse ARDENT_STUDIO_OATHWEAVE_IDENTITIES_JSON. Throws on anything malformed or ambiguous. */
+export function parseIdentityLinks(raw) {
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        throw new IdentityLinkError('must be valid JSON');
+    }
+    const parsed = z.array(linkSchema).max(10_000).safeParse(json);
+    if (!parsed.success)
+        throw new IdentityLinkError('must be a JSON array of {issuer, subject, localUserId, displayName?, permissions?}');
+    const seen = new Set();
+    for (const link of parsed.data) {
+        const key = JSON.stringify([link.issuer, link.subject]);
+        if (seen.has(key))
+            throw new IdentityLinkError('links must be unique per issuer and subject');
+        seen.add(key);
+    }
+    return parsed.data;
+}
+/** The one link for a verified person, or undefined when there is none or the links are ambiguous. */
+export function linkFor(links, issuer, subject) {
+    const matches = links.filter(link => link.issuer === issuer && link.subject === subject);
+    return matches.length === 1 ? matches[0] : undefined;
+}
+/** Token permissions narrowed by the link's ceiling. Unknown permission strings are dropped. */
+export function effectivePermissions(link, tokenPermissions) {
+    const ceiling = new Set(link.permissions ?? ARDENT_STUDIO_PERMISSIONS);
+    return ARDENT_STUDIO_PERMISSIONS.filter(permission => ceiling.has(permission) && tokenPermissions.includes(permission));
+}

package/dist/auth/oathweave.d.ts

@@ -0,0 +1,46 @@
+import { type JWTVerifyGetKey } from 'jose';
+import { type ArdentStudioPermission } from '../shared/browser.js';
+import { type IdentityLink } from './links.js';
+export interface OathweaveOptions {
+    issuer: string;
+    jwksUrl: string;
+    userinfoUrl: string;
+    audience?: string;
+}
+export interface OathweaveIdentity {
+    subject: string;
+    issuer: string;
+    sessionId: string;
+    permissions: string[];
+    displayName: string;
+    issuedAt: number;
+    expiresAt: number;
+}
+export type OathweaveVerifier = (token: string) => Promise<OathweaveIdentity>;
+/** A verified, linked caller. */
+export interface Principal {
+    userId: string;
+    subject: string;
+    issuer: string;
+    displayName: string;
+    permissions: ArdentStudioPermission[];
+    /** Token expiry in epoch seconds. Streams close at this time. */
+    expiresAt: number;
+}
+/** The token is valid but its subject has no explicit link, so the person has no Studio access. */
+export declare class AccessDenied extends Error {
+    name: string;
+}
+/** How long a userinfo answer is reused, measured from when the request started. */
+export declare const SESSION_CACHE_TTL_MS = 10000;
+/** How often an open stream re-checks its token. */
+export declare const STREAM_RECHECK_MS = 5000;
+export declare function isHttpsEndpoint(value: string): boolean;
+export declare function createOathweaveVerifier(options: OathweaveOptions, overrides?: {
+    keys?: JWTVerifyGetKey;
+    fetch?: typeof fetch;
+    now?: () => number;
+}): OathweaveVerifier;
+export type Authenticator = (token: string) => Promise<Principal>;
+/** Verify a bearer token and map it through its one explicit identity link. */
+export declare function createAuthenticator(verify: OathweaveVerifier, links: readonly IdentityLink[]): Authenticator;

package/dist/auth/oathweave.js

@@ -0,0 +1,123 @@
+// Oathweave resource-token verification for ArdentStudio, following the suite pattern
+// (Magnus and HiveMem): RS256 only, exact issuer and audience, at most fifteen minutes,
+// USER actor with a session, and an online session check through userinfo. Failure is closed.
+import { createHash } from 'node:crypto';
+import { createRemoteJWKSet, customFetch, jwtVerify } from 'jose';
+import { ARDENT_STUDIO_AUDIENCE } from '../shared/browser.js';
+import { effectivePermissions, linkFor } from './links.js';
+/** The token is valid but its subject has no explicit link, so the person has no Studio access. */
+export class AccessDenied extends Error {
+    name = 'AccessDenied';
+}
+/** How long a userinfo answer is reused, measured from when the request started. */
+export const SESSION_CACHE_TTL_MS = 10_000;
+/** How often an open stream re-checks its token. */
+export const STREAM_RECHECK_MS = 5_000;
+const FAILED_CHECK_TTL_MS = 2_000;
+const SESSION_CACHE_MAX = 5_000;
+const REQUEST_TIMEOUT_MS = 3_000;
+export function isHttpsEndpoint(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && !url.username && !url.password && !url.hash;
+    }
+    catch {
+        return false;
+    }
+}
+export function createOathweaveVerifier(options, overrides = {}) {
+    for (const value of [options.issuer, options.jwksUrl, options.userinfoUrl]) {
+        if (!isHttpsEndpoint(value))
+            throw new Error('Oathweave endpoints require verified HTTPS');
+    }
+    const audience = options.audience ?? ARDENT_STUDIO_AUDIENCE;
+    const request = overrides.fetch ?? ((input, init) => fetch(input, init));
+    const now = overrides.now ?? (() => Date.now());
+    const keys = overrides.keys ?? createRemoteJWKSet(new URL(options.jwksUrl), {
+        [customFetch]: (url, init) => request(url, { ...init, redirect: 'error', signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) }),
+    });
+    // Holds only tokens whose signature verified, so garbage can neither fill it nor reach userinfo.
+    const sessions = new Map();
+    async function fetchDisplayName(token, subject) {
+        const result = await request(options.userinfoUrl, {
+            headers: { Authorization: `Bearer ${token}` },
+            redirect: 'error',
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!result.ok)
+            throw new Error('Identity session is inactive');
+        const user = await result.json();
+        if (!user || typeof user !== 'object' || user.sub !== subject)
+            throw new Error('Identity subject mismatch');
+        return 'name' in user && typeof user.name === 'string' && user.name ? user.name : subject;
+    }
+    function sessionCheck(token, subject) {
+        const key = createHash('sha256').update(token).digest('hex');
+        const startedAt = now();
+        const current = sessions.get(key);
+        if (current && startedAt < current.expiresAt)
+            return current.displayName;
+        sessions.delete(key);
+        if (sessions.size >= SESSION_CACHE_MAX) {
+            for (const [entryKey, entry] of sessions)
+                if (entry.expiresAt <= startedAt)
+                    sessions.delete(entryKey);
+            if (sessions.size >= SESSION_CACHE_MAX)
+                sessions.delete(sessions.keys().next().value);
+        }
+        const check = { expiresAt: startedAt + SESSION_CACHE_TTL_MS, displayName: fetchDisplayName(token, subject) };
+        check.displayName.catch(() => { check.expiresAt = Math.min(check.expiresAt, now() + FAILED_CHECK_TTL_MS); });
+        sessions.set(key, check);
+        return check.displayName;
+    }
+    return async (token) => {
+        const { payload } = await jwtVerify(token, keys, {
+            algorithms: ['RS256'],
+            issuer: options.issuer,
+            audience,
+            requiredClaims: ['sub', 'iat', 'exp', 'jti'],
+            maxTokenAge: '15m',
+            currentDate: new Date(now()),
+        });
+        if (payload.aud !== audience || typeof payload.iat !== 'number' || typeof payload.exp !== 'number'
+            || payload.exp <= payload.iat || payload.exp - payload.iat > 900) {
+            throw new Error('Invalid resource token audience or lifetime');
+        }
+        const claims = payload;
+        if (claims['actorType'] !== 'USER'
+            || typeof payload.sub !== 'string' || !payload.sub
+            || typeof payload.jti !== 'string' || !payload.jti
+            || typeof claims['sessionId'] !== 'string' || !claims['sessionId']
+            || typeof claims['clientId'] !== 'string'
+            || !Array.isArray(claims['permissions']) || !claims['permissions'].every(value => typeof value === 'string')) {
+            throw new Error('Invalid resource identity');
+        }
+        const displayName = await sessionCheck(token, payload.sub);
+        return {
+            subject: payload.sub,
+            issuer: options.issuer,
+            sessionId: claims['sessionId'],
+            permissions: claims['permissions'],
+            displayName,
+            issuedAt: payload.iat,
+            expiresAt: payload.exp,
+        };
+    };
+}
+/** Verify a bearer token and map it through its one explicit identity link. */
+export function createAuthenticator(verify, links) {
+    return async (token) => {
+        const identity = await verify(token);
+        const link = linkFor(links, identity.issuer, identity.subject);
+        if (!link)
+            throw new AccessDenied('An explicit unique account link is required');
+        return {
+            userId: link.localUserId,
+            subject: identity.subject,
+            issuer: identity.issuer,
+            displayName: link.displayName ?? identity.displayName,
+            permissions: effectivePermissions(link, identity.permissions),
+            expiresAt: identity.expiresAt,
+        };
+    };
+}

package/dist/blobs/store.d.ts

@@ -0,0 +1,45 @@
+import type { Readable } from 'node:stream';
+import type { Db } from '../db/database.js';
+import type { Clock } from '../db/json.js';
+export declare class BlobTooLargeError extends Error {
+    readonly limit: number;
+    name: string;
+    constructor(limit: number);
+}
+export declare class BlobIntegrityError extends Error {
+    name: string;
+}
+export interface BlobRecord {
+    sha256: string;
+    size: number;
+    mime: string;
+    path: string;
+    created_at: string;
+}
+export declare class BlobStore {
+    private readonly db;
+    readonly maxBytes: number;
+    private readonly clock;
+    readonly root: string;
+    private readonly tmp;
+    constructor(db: Db, dataDir: string, maxBytes: number, clock: Clock);
+    /** Remove temp files a crash left behind. Recorded blobs are never touched. */
+    recoverPartialWrites(): number;
+    relativePath(sha256: string): string;
+    get(sha256: string): BlobRecord | undefined;
+    putBytes(bytes: Uint8Array, mime: string, expectedSha256?: string): Promise<BlobRecord>;
+    /** Stream bytes into the store. Throws BlobTooLargeError past the cap and BlobIntegrityError on a digest mismatch. */
+    put(source: AsyncIterable<Uint8Array> | Readable, mime: string, expectedSha256?: string): Promise<BlobRecord>;
+    /** A read stream for a recorded blob, or undefined when it is not recorded. */
+    open(sha256: string): {
+        record: BlobRecord;
+        stream: Readable;
+    } | undefined;
+    readBytes(sha256: string): Promise<Uint8Array>;
+    /** A small recorded blob as UTF-8 text, verified against its address. */
+    readTextSync(sha256: string): string;
+    /** Re-hash a recorded blob. */
+    verify(sha256: string): Promise<boolean>;
+    private fileMatches;
+    private syncDirectory;
+}

package/dist/blobs/store.js

@@ -0,0 +1,159 @@
+// Content-addressed blob store under <data>/blobs/aa/bb/<sha256>. Writes go to a temp file,
+// are fsynced and renamed into place, and the stored file is hashed again before it is
+// recorded, so a recorded blob always matches its address.
+import { createHash, randomBytes } from 'node:crypto';
+import { createReadStream, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { open, rename, rm, stat, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+export class BlobTooLargeError extends Error {
+    limit;
+    name = 'BlobTooLargeError';
+    constructor(limit) {
+        super(`Blob exceeds the ${limit}-byte limit`);
+        this.limit = limit;
+    }
+}
+export class BlobIntegrityError extends Error {
+    name = 'BlobIntegrityError';
+}
+const SHA = /^[a-f0-9]{64}$/;
+export class BlobStore {
+    db;
+    maxBytes;
+    clock;
+    root;
+    tmp;
+    constructor(db, dataDir, maxBytes, clock) {
+        this.db = db;
+        this.maxBytes = maxBytes;
+        this.clock = clock;
+        this.root = join(dataDir, 'blobs');
+        this.tmp = join(this.root, 'tmp');
+        mkdirSync(this.tmp, { recursive: true, mode: 0o700 });
+    }
+    /** Remove temp files a crash left behind. Recorded blobs are never touched. */
+    recoverPartialWrites() {
+        let removed = 0;
+        for (const name of readdirSync(this.tmp)) {
+            rmSync(join(this.tmp, name), { force: true });
+            removed++;
+        }
+        return removed;
+    }
+    relativePath(sha256) {
+        return join(sha256.slice(0, 2), sha256.slice(2, 4), sha256);
+    }
+    get(sha256) {
+        if (!SHA.test(sha256))
+            return undefined;
+        return this.db.prepare('SELECT * FROM blobs WHERE sha256 = ?').get(sha256);
+    }
+    async putBytes(bytes, mime, expectedSha256) {
+        return this.put((async function* () { yield bytes; })(), mime, expectedSha256);
+    }
+    /** Stream bytes into the store. Throws BlobTooLargeError past the cap and BlobIntegrityError on a digest mismatch. */
+    async put(source, mime, expectedSha256) {
+        if (expectedSha256 !== undefined && !SHA.test(expectedSha256))
+            throw new BlobIntegrityError('Expected digest is not a SHA-256 hex string');
+        const temp = join(this.tmp, `${randomBytes(12).toString('hex')}.part`);
+        const hash = createHash('sha256');
+        let size = 0;
+        const handle = await open(temp, 'wx', 0o600);
+        try {
+            try {
+                for await (const chunk of source) {
+                    size += chunk.byteLength;
+                    if (size > this.maxBytes)
+                        throw new BlobTooLargeError(this.maxBytes);
+                    hash.update(chunk);
+                    await handle.write(chunk);
+                }
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            const sha256 = hash.digest('hex');
+            if (expectedSha256 !== undefined && sha256 !== expectedSha256)
+                throw new BlobIntegrityError('Content does not match the expected SHA-256');
+            const relative = this.relativePath(sha256);
+            const target = join(this.root, relative);
+            const existing = this.get(sha256);
+            if (existing && await this.fileMatches(target, sha256, size)) {
+                await rm(temp, { force: true });
+                return existing;
+            }
+            await mkdir(join(this.root, sha256.slice(0, 2), sha256.slice(2, 4)), { recursive: true, mode: 0o700 });
+            await rename(temp, target);
+            await this.syncDirectory(join(this.root, sha256.slice(0, 2), sha256.slice(2, 4)));
+            if (!await this.fileMatches(target, sha256, size)) {
+                await rm(target, { force: true });
+                throw new BlobIntegrityError('Stored blob failed verification');
+            }
+            const record = { sha256, size, mime, path: relative, created_at: this.clock.now().toISOString() };
+            this.db.prepare('INSERT INTO blobs (sha256, size, mime, path, created_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT (sha256) DO NOTHING')
+                .run(record.sha256, record.size, record.mime, record.path, record.created_at);
+            return this.get(sha256) ?? record;
+        }
+        catch (error) {
+            await rm(temp, { force: true });
+            throw error;
+        }
+    }
+    /** A read stream for a recorded blob, or undefined when it is not recorded. */
+    open(sha256) {
+        const record = this.get(sha256);
+        if (!record)
+            return undefined;
+        return { record, stream: createReadStream(join(this.root, record.path)) };
+    }
+    async readBytes(sha256) {
+        const opened = this.open(sha256);
+        if (!opened)
+            throw new BlobIntegrityError('Blob is not recorded');
+        const chunks = [];
+        for await (const chunk of opened.stream)
+            chunks.push(chunk);
+        const bytes = Buffer.concat(chunks);
+        if (createHash('sha256').update(bytes).digest('hex') !== sha256)
+            throw new BlobIntegrityError('Stored blob does not match its address');
+        return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    /** A small recorded blob as UTF-8 text, verified against its address. */
+    readTextSync(sha256) {
+        const record = this.get(sha256);
+        if (!record)
+            throw new BlobIntegrityError('Blob is not recorded');
+        const bytes = readFileSync(join(this.root, record.path));
+        if (createHash('sha256').update(bytes).digest('hex') !== sha256)
+            throw new BlobIntegrityError('Stored blob does not match its address');
+        return new TextDecoder('utf-8', { fatal: false }).decode(bytes);
+    }
+    /** Re-hash a recorded blob. */
+    async verify(sha256) {
+        const record = this.get(sha256);
+        return record ? this.fileMatches(join(this.root, record.path), sha256, record.size) : false;
+    }
+    async fileMatches(path, sha256, size) {
+        try {
+            if ((await stat(path)).size !== size)
+                return false;
+            const hash = createHash('sha256');
+            for await (const chunk of createReadStream(path))
+                hash.update(chunk);
+            return hash.digest('hex') === sha256;
+        }
+        catch {
+            return false;
+        }
+    }
+    async syncDirectory(path) {
+        const handle = await open(path, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}

package/dist/clients/chattermost.d.ts

@@ -0,0 +1,16 @@
+export declare class ChatterMostError extends Error {
+    name: string;
+}
+export interface Announcement {
+    /** Plain text or Markdown, kept short. */
+    text: string;
+    /** A link back to the Studio page this announcement is about. */
+    link?: string | undefined;
+}
+export declare const ANNOUNCEMENT_USERNAME = "Ardent Project Studio";
+export declare class ChatterMostClient {
+    private readonly webhookUrl;
+    private readonly request;
+    constructor(webhookUrl: string, fetcher?: typeof fetch);
+    announce(announcement: Announcement): Promise<void>;
+}

package/dist/clients/chattermost.js

@@ -0,0 +1,36 @@
+// Optional one-way announcements through a ChatterMost incoming webhook. Posts are labelled as
+// coming from Ardent Project Studio and link back; nothing is ever read back from ChatterMost.
+// The webhook URL contains its secret, so it is never logged or returned.
+export class ChatterMostError extends Error {
+    name = 'ChatterMostError';
+}
+export const ANNOUNCEMENT_USERNAME = 'Ardent Project Studio';
+export class ChatterMostClient {
+    webhookUrl;
+    request;
+    constructor(webhookUrl, fetcher) {
+        this.webhookUrl = webhookUrl;
+        this.request = fetcher ?? ((input, init) => fetch(input, init));
+    }
+    async announce(announcement) {
+        const text = `${announcement.text.trim().slice(0, 3_500)}${announcement.link ? `\n${announcement.link}` : ''}`;
+        if (!text.trim())
+            throw new ChatterMostError('An announcement needs text');
+        let response;
+        try {
+            response = await this.request(this.webhookUrl, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ text, username: ANNOUNCEMENT_USERNAME }),
+                redirect: 'error',
+                signal: AbortSignal.timeout(10_000),
+            });
+        }
+        catch (error) {
+            throw new ChatterMostError(`ChatterMost webhook request failed (${error instanceof Error ? error.name : 'error'})`);
+        }
+        await response.body?.cancel();
+        if (!response.ok)
+            throw new ChatterMostError(`ChatterMost webhook answered HTTP ${response.status}`);
+    }
+}