@bassfish/cli 0.1.0

package/dist/domain.d.ts

@@ -0,0 +1,393 @@
+export declare class BassfishError extends Error {
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(code: string, message: string, details?: unknown);
+}
+export declare function requireThat(condition: unknown, code: string, message: string): asserts condition;
+export interface Actor {
+    projectId: string;
+    identityId: string;
+    instanceId: string;
+    name: string;
+}
+export interface Project {
+    id: string;
+    commonDir: string;
+    recovering: boolean;
+}
+export interface Identity {
+    id: string;
+    projectId: string;
+    name: string;
+}
+export interface Instance {
+    id: string;
+    projectId: string;
+    identityId: string;
+    handle: string;
+    epoch: string;
+    active: boolean;
+    lastSeen: number;
+}
+export type ContentResourceType = 'thread' | 'note';
+export type ResourceType = ContentResourceType | 'project';
+export interface Resource {
+    id: string;
+    projectId: string;
+    type: ResourceType;
+    fence: string;
+    queueSequence: string;
+    present: boolean;
+}
+export type FloorState = 'QUEUED' | 'READY' | 'OFFERED' | 'HELD' | 'COMMITTING' | 'COMMITTED' | 'RELEASED' | 'EXPIRED' | 'CANCELLED' | 'FAILED';
+export interface FloorRequest {
+    id: string;
+    projectId: string;
+    resourceId: string;
+    resourceType: ResourceType;
+    identityId: string;
+    instanceId: string;
+    sequence: string;
+    state: FloorState;
+    createdAt: number;
+    queueUntil: number;
+    reconnectUntil?: number;
+    offerId?: string;
+    claimBy?: number;
+    floorId?: string;
+    fence?: string;
+    baseRevision?: string;
+    snapshotCommit?: string;
+    expiresAt?: number;
+    finishedAt?: number;
+    result?: StorageResult;
+    purpose?: 'snapshot' | 'export' | 'search' | 'restore';
+    deliveryMode: 'ticket' | 'task';
+    updatedAt: number;
+}
+export type TaskStatus = 'working' | 'completed' | 'failed' | 'cancelled';
+export interface DurableTask {
+    id: string;
+    projectId: string;
+    identityId: string;
+    requestId: string;
+    status: TaskStatus;
+    statusMessage?: string;
+    createdAt: number;
+    updatedAt: number;
+    discardAt: number;
+    result?: Record<string, unknown>;
+    error?: {
+        code: number;
+        message: string;
+        data?: Record<string, unknown>;
+    };
+}
+export interface PendingCommit {
+    id: string;
+    projectId: string;
+    resourceId: string;
+    resourceType: ResourceType;
+    floorRequestId?: string;
+    startingHead: string;
+    kind: string;
+    actor: Actor;
+}
+export interface ControlState {
+    projects: Record<string, Project>;
+    identities: Record<string, Identity>;
+    instances: Record<string, Instance>;
+    resources: Record<string, Resource>;
+    requests: Record<string, FloorRequest>;
+    pending: Record<string, PendingCommit>;
+    tasks: Record<string, DurableTask>;
+    wallClockHighWaterMs: number;
+}
+export interface ControlStore {
+    view<T>(fn: (state: ControlState) => T): T;
+    update<T>(fn: (state: ControlState) => T): T;
+    close(): void;
+}
+export interface Clock {
+    now(): number;
+    wallNow(): number;
+    discontinuity(): boolean;
+}
+export type ThreadState = 'active' | 'archived' | 'deleted';
+export interface Thread {
+    id: string;
+    title: string;
+    description: string;
+    state: ThreadState;
+    revision: string;
+    headSequence: string;
+    creator: string;
+    createdAt: string;
+}
+export type NoteState = 'active' | 'archived' | 'deleted';
+export type LinkTargetType = 'note' | 'thread' | 'message';
+export interface ResourceLink {
+    targetType: LinkTargetType;
+    targetId: string;
+}
+export interface Note {
+    id: string;
+    path: string;
+    title: string;
+    body: string;
+    labels: string[];
+    kind: string | null;
+    state: NoteState;
+    revision: string;
+    creator: string;
+    creatorName: string;
+    lastEditor: string;
+    lastEditorName: string;
+    createdAt: string;
+    updatedAt: string;
+    links: ResourceLink[];
+}
+export interface Message {
+    id: string;
+    threadId: string;
+    sequence: string;
+    identityId: string;
+    name: string;
+    instanceId: string;
+    createdAt: string;
+    body: string;
+    retracted?: boolean;
+}
+export interface Snapshot {
+    resourceType: 'thread';
+    thread: Thread;
+    commit: string;
+    messages: Message[];
+    truncated: boolean;
+    nextBefore: string | null;
+}
+export interface NotePage {
+    text: string;
+    startLine: number;
+    endLine: number;
+    startByte: number;
+    endByte: number;
+    truncated: boolean;
+    nextCursor: string | null;
+}
+export interface NoteSnapshot {
+    resourceType: 'note';
+    note: Note;
+    commit: string;
+    page: NotePage;
+}
+export type ResourceSnapshot = Snapshot | NoteSnapshot;
+export type ThreadMutation = {
+    kind: 'appendMessage';
+    body: string;
+} | {
+    kind: 'renameThread';
+    title: string;
+} | {
+    kind: 'setThreadDescription';
+    description: string;
+} | {
+    kind: 'archiveThread';
+} | {
+    kind: 'activateThread';
+} | {
+    kind: 'deleteThread';
+} | {
+    kind: 'retractMessage';
+    messageId: string;
+} | {
+    kind: 'reinstateMessage';
+    messageId: string;
+} | {
+    kind: 'restoreThreadRevision';
+    targetRevision: string;
+};
+export type NoteMutation = {
+    kind: 'replaceNoteBody';
+    body: string;
+} | {
+    kind: 'patchNoteBody';
+    patch: string;
+} | {
+    kind: 'appendNoteBody';
+    body: string;
+} | {
+    kind: 'prependNoteBody';
+    body: string;
+} | {
+    kind: 'moveNote';
+    path: string;
+} | {
+    kind: 'setNoteMetadata';
+    title?: string;
+    labels?: string[];
+    noteKind?: string | null;
+} | {
+    kind: 'setLinks';
+    links: ResourceLink[];
+} | {
+    kind: 'archiveNote';
+} | {
+    kind: 'deleteNote';
+} | {
+    kind: 'activateNote';
+} | {
+    kind: 'replaceNoteText';
+    find: string;
+    replace: string;
+    expectedOccurrences: number;
+} | {
+    kind: 'upsertNoteSection';
+    headingPath: string[];
+    body: string;
+    occurrence?: number;
+    createIfMissing: boolean;
+} | {
+    kind: 'batchNote';
+    mutations: Exclude<NoteMutation, {
+        kind: 'batchNote';
+    }>[];
+};
+export type Mutation = ThreadMutation | NoteMutation;
+export interface ThreadWriteOperation {
+    id: string;
+    actor: Actor;
+    resourceId: string;
+    at: string;
+    resourceType: 'thread';
+    thread: Thread;
+    mutation: ThreadMutation | {
+        kind: 'createThread';
+    };
+    visibilityChanges?: {
+        messageId: string;
+        visible: boolean;
+    }[];
+}
+export interface NoteWriteOperation {
+    id: string;
+    actor: Actor;
+    resourceId: string;
+    at: string;
+    resourceType: 'note';
+    note: Note;
+    mutation: NoteMutation | {
+        kind: 'createNote';
+    };
+}
+export type WriteOperation = ThreadWriteOperation | NoteWriteOperation;
+export interface MutationResult {
+    resourceId: string;
+    previousRevision: string;
+    revision: string;
+    doltCommit: string;
+    messageId?: string;
+    sequence?: string;
+}
+export interface HistoryEntry {
+    operationId: string;
+    kind: string;
+    actorIdentityId: string;
+    actorName: string;
+    instanceId: string;
+    createdAt: string;
+    reason: string | null;
+    beforeRevision: string;
+    afterRevision: string;
+    doltCommit: string;
+}
+export interface MessageVisibility {
+    messageId: string;
+    threadId: string;
+    visible: boolean;
+    threadRevision: string;
+    operationId: string;
+    createdAt: string;
+}
+export interface ProjectSnapshot {
+    commit: string;
+    threads: Thread[];
+    messages: Message[];
+    notes: Note[];
+    visibility: MessageVisibility[];
+}
+export interface ProjectHistoryEntry {
+    operationId: string;
+    kind: string;
+    actorIdentityId: string;
+    actorName: string;
+    instanceId: string;
+    createdAt: string;
+    doltCommit: string;
+}
+export interface ProjectRestoreChange {
+    resourceType: ContentResourceType;
+    resourceId: string;
+    action: 'create' | 'update' | 'delete';
+    beforeRevision: string;
+    afterRevision: string;
+}
+export interface ProjectRestoreResult {
+    operationId: string;
+    targetCommit: string;
+    previousCommit: string;
+    doltCommit: string;
+    changes: ProjectRestoreChange[];
+}
+export interface ProjectRestoreOperation {
+    id: string;
+    actor: Actor;
+    resourceId: string;
+    resourceType: 'project';
+    at: string;
+    mutation: {
+        kind: 'restoreSnapshot';
+        targetCommit: string;
+    };
+    target: ProjectSnapshot;
+    current: ProjectSnapshot;
+    changes: ProjectRestoreChange[];
+}
+export type StorageResult = MutationResult | ProjectRestoreResult;
+export type Resolution = {
+    state: 'committed';
+    result: StorageResult;
+} | {
+    state: 'absent';
+} | {
+    state: 'unknown';
+};
+export interface ContentStore {
+    ensureProject(projectId: string): Promise<void>;
+    head(projectId: string): Promise<string>;
+    listThreads(projectId: string): Promise<Thread[]>;
+    listNotes(projectId: string): Promise<Note[]>;
+    resourceType(projectId: string, resourceId: string): Promise<ContentResourceType>;
+    snapshot(projectId: string, resourceId: string, limit: number, before?: string, at?: string): Promise<Snapshot>;
+    noteSnapshot(projectId: string, resourceId: string, cursor?: string, at?: string): Promise<NoteSnapshot>;
+    history(projectId: string, resourceType: ContentResourceType, resourceId: string): Promise<HistoryEntry[]>;
+    commitAtRevision(projectId: string, resourceType: ContentResourceType, resourceId: string, revision: string): Promise<string>;
+    projectSnapshot(projectId: string, at?: string): Promise<ProjectSnapshot>;
+    projectHistory(projectId: string): Promise<ProjectHistoryEntry[]>;
+    maxRevision(projectId: string, resourceType: ContentResourceType, resourceId: string): Promise<string>;
+    maxSequence(projectId: string, threadId: string): Promise<string>;
+    historicalNotes(projectId: string, at: string): Promise<HistoricalNote[]>;
+    write(operation: WriteOperation | ProjectRestoreOperation): Promise<StorageResult>;
+    resolve(pending: PendingCommit): Promise<Resolution>;
+    close(): Promise<void>;
+}
+export interface HistoricalNote {
+    note: Note;
+    doltCommit: string;
+    changedAt: string;
+}
+export declare const activeStates: FloorState[];
+export declare const reservedStates: FloorState[];
+export declare const increment: (value: string) => string;
+export declare function prepareMutation(thread: Thread, mutation: ThreadMutation): Thread;
+export declare function notePage(body: string, cursor?: string, maxLines?: number, maxBytes?: number): NotePage;

package/dist/domain.js

@@ -0,0 +1,75 @@
+export class BassfishError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'BassfishError';
+    }
+}
+export function requireThat(condition, code, message) {
+    if (!condition)
+        throw new BassfishError(code, message);
+}
+export const activeStates = ['QUEUED', 'READY', 'OFFERED', 'HELD', 'COMMITTING'];
+export const reservedStates = ['READY', 'OFFERED', 'HELD', 'COMMITTING'];
+export const increment = (value) => (BigInt(value) + 1n).toString();
+export function prepareMutation(thread, mutation) {
+    const next = { ...thread, revision: increment(thread.revision) };
+    switch (mutation.kind) {
+        case 'appendMessage':
+            requireThat(thread.state === 'active', 'RESOURCE_ARCHIVED', 'Restore the thread before appending.');
+            next.headSequence = increment(thread.headSequence);
+            break;
+        case 'renameThread':
+            requireThat(thread.title !== mutation.title, 'NO_CHANGE', 'The title is unchanged.');
+            next.title = mutation.title;
+            break;
+        case 'setThreadDescription':
+            requireThat(thread.description !== mutation.description, 'NO_CHANGE', 'The description is unchanged.');
+            next.description = mutation.description;
+            break;
+        case 'archiveThread':
+            requireThat(thread.state === 'active', 'NO_CHANGE', 'Only an active thread can be archived.');
+            next.state = 'archived';
+            break;
+        case 'activateThread':
+            requireThat(thread.state !== 'active', 'NO_CHANGE', 'The thread is already active.');
+            next.state = 'active';
+            break;
+        case 'deleteThread':
+            requireThat(thread.state !== 'deleted', 'NO_CHANGE', 'The thread is already deleted.');
+            next.state = 'deleted';
+            break;
+        case 'retractMessage':
+        case 'reinstateMessage':
+        case 'restoreThreadRevision':
+            break;
+    }
+    return next;
+}
+export function notePage(body, cursor, maxLines = 200, maxBytes = 32 * 1024) {
+    let startByte = 0;
+    if (cursor !== undefined) {
+        requireThat(/^(0|[1-9][0-9]*)$/.test(cursor), 'INVALID_CURSOR', 'The note cursor is invalid.');
+        startByte = Number(cursor);
+    }
+    const bytes = Buffer.from(body, 'utf8');
+    requireThat(startByte >= 0 && startByte <= bytes.length, 'INVALID_CURSOR', 'The note cursor is outside the body.');
+    let endByte = Math.min(bytes.length, startByte + maxBytes);
+    while (endByte > startByte && (bytes[endByte] ?? 0) >= 0x80 && (bytes[endByte] ?? 0) < 0xc0)
+        endByte--;
+    const prefix = bytes.subarray(0, startByte).toString('utf8');
+    const candidate = bytes.subarray(startByte, endByte).toString('utf8');
+    const lines = candidate.split('\n');
+    if (lines.length > maxLines) {
+        const limited = lines.slice(0, maxLines).join('\n') + '\n';
+        endByte = startByte + Buffer.byteLength(limited);
+    }
+    const text = bytes.subarray(startByte, endByte).toString('utf8');
+    const startLine = prefix.split('\n').length;
+    const endLine = startLine + Math.max(0, text.split('\n').length - 1);
+    return { text, startLine, endLine, startByte, endByte, truncated: endByte < bytes.length, nextCursor: endByte < bytes.length ? String(endByte) : null };
+}
+//# sourceMappingURL=domain.js.map

package/dist/domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.js","sourceRoot":"","sources":["../src/domain.ts"],"names":[],"mappings":"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"}

package/dist/export.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectSnapshot } from './domain.js';
+export declare function exportProject(dataDir: string, projectId: string, snapshot: ProjectSnapshot): Promise<{
+    path: string;
+    bytes: number;
+    sha256: string;
+    snapshotCommit: string;
+}>;

package/dist/export.js

@@ -0,0 +1,37 @@
+import { createHash } from 'node:crypto';
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { strToU8, zipSync } from 'fflate';
+const stable = (value) => JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item)
+    ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item, 2) + '\n';
+const fixed = new Date(1980, 1, 1, 0, 0, 0, 0);
+export async function exportProject(dataDir, projectId, snapshot) {
+    const files = {};
+    const add = (path, value) => { files[path] = [strToU8(value), { mtime: fixed, level: 0 }]; };
+    for (const note of snapshot.notes) {
+        const { body, ...metadata } = note;
+        add(`notes/${note.id}.json`, stable(metadata));
+        add(`notes/${note.id}.md`, body);
+    }
+    for (const thread of snapshot.threads) {
+        const messages = snapshot.messages.filter(message => message.threadId === thread.id);
+        const visibility = snapshot.visibility.filter(item => item.threadId === thread.id);
+        add(`threads/${thread.id}.json`, stable({ thread, messages, visibility }));
+        const latest = new Map();
+        for (const item of visibility)
+            latest.set(item.messageId, item.visible);
+        add(`threads/${thread.id}.md`, `# ${thread.title}\n\n${messages.map(message => latest.get(message.id) === false ? `> [Message ${message.sequence} retracted]` : `**${message.name}:** ${message.body}`).join('\n\n')}\n`);
+    }
+    const inventory = Object.keys(files).sort().map(path => ({ path, sha256: createHash('sha256').update(files[path][0]).digest('hex') }));
+    add('manifest.json', stable({ schemaVersion: 1, projectId, snapshotCommit: snapshot.commit, inventory }));
+    const archive = zipSync(Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))));
+    const sha256 = createHash('sha256').update(archive).digest('hex');
+    const directory = join(dataDir, 'exports');
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const path = join(directory, `${projectId}-${snapshot.commit.slice(0, 12)}.zip`);
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, archive, { mode: 0o600 });
+    await rename(temporary, path);
+    return { path, bytes: archive.byteLength, sha256, snapshotCommit: snapshot.commit };
+}
+//# sourceMappingURL=export.js.map

package/dist/export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.js","sourceRoot":"","sources":["../src/export.ts"],"names":[],"mappings":"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"}

package/dist/ipc.d.ts

@@ -0,0 +1,14 @@
+import type { Server, Socket } from 'node:net';
+export type RpcHandler = (method: string, params: unknown, signal: AbortSignal, socket: Socket) => Promise<unknown>;
+export declare function listenRpc(path: string, handler: RpcHandler, disconnected: (socket: Socket) => void): Promise<{
+    server: Server;
+    close: () => Promise<void>;
+}>;
+export declare class RpcClient {
+    readonly socket: Socket;
+    private readonly requests;
+    private constructor();
+    static connect(path: string): Promise<RpcClient>;
+    call<T = unknown>(method: string, params?: unknown, signal?: AbortSignal): Promise<T>;
+    close(): void;
+}

package/dist/ipc.js

@@ -0,0 +1,125 @@
+import { createConnection, createServer } from 'node:net';
+import { randomUUID } from 'node:crypto';
+import { BassfishError } from './domain.js';
+import { z } from 'zod';
+const requestSchema = z.object({ id: z.string().min(1).max(100), method: z.string().min(1).max(100), params: z.unknown().optional() }).strict();
+const maximumFrame = 2_000_000;
+function frames(socket, receive) {
+    let buffer = '';
+    socket.setEncoding('utf8');
+    socket.on('data', data => {
+        buffer += data;
+        if (Buffer.byteLength(buffer) > maximumFrame) {
+            socket.destroy(new Error('IPC frame limit exceeded'));
+            return;
+        }
+        let newline;
+        while ((newline = buffer.indexOf('\n')) >= 0) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            try {
+                receive(JSON.parse(line));
+            }
+            catch {
+                socket.destroy(new Error('Invalid IPC frame'));
+                return;
+            }
+        }
+    });
+}
+export async function listenRpc(path, handler, disconnected) {
+    const sockets = new Set();
+    const jobs = new Set();
+    const server = createServer(socket => {
+        sockets.add(socket);
+        const running = new Map();
+        socket.on('error', () => { });
+        socket.on('close', () => { for (const controller of running.values())
+            controller.abort(); sockets.delete(socket); disconnected(socket); });
+        frames(socket, frame => {
+            const parsed = requestSchema.safeParse(frame);
+            if (!parsed.success) {
+                socket.destroy();
+                return;
+            }
+            const request = parsed.data;
+            if (request.method === '$cancel') {
+                const p = request.params;
+                if (typeof p?.id === 'string')
+                    running.get(p.id)?.abort();
+                return;
+            }
+            if (running.has(request.id)) {
+                socket.destroy();
+                return;
+            }
+            const controller = new AbortController();
+            running.set(request.id, controller);
+            const job = handler(request.method, request.params, controller.signal, socket).then(result => {
+                if (!socket.destroyed)
+                    socket.write(JSON.stringify({ id: request.id, result }) + '\n');
+            }, error => {
+                const failure = error instanceof BassfishError ? error : new BassfishError('INTERNAL_ERROR', 'The backend operation failed; inspect daemon health.');
+                if (!socket.destroyed)
+                    socket.write(JSON.stringify({ id: request.id, error: { code: failure.code, message: failure.message } }) + '\n');
+            }).finally(() => { running.delete(request.id); jobs.delete(job); });
+            jobs.add(job);
+        });
+    });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(path, resolve); });
+    return { server, close: async () => { for (const socket of sockets)
+            socket.destroy(); await new Promise(resolve => server.close(() => resolve())); await Promise.allSettled([...jobs]); } };
+}
+export class RpcClient {
+    socket;
+    requests = new Map();
+    constructor(socket) {
+        this.socket = socket;
+        frames(socket, raw => {
+            const reply = raw;
+            const request = this.requests.get(reply.id);
+            if (!request)
+                return;
+            this.requests.delete(reply.id);
+            if (reply.error)
+                request.reject(new BassfishError(reply.error.code, reply.error.message));
+            else
+                request.resolve(reply.result);
+        });
+        const failed = () => { for (const r of this.requests.values())
+            r.reject(new BassfishError('OUTCOME_UNKNOWN', 'The connection closed. No request was retried; inspect its outcome before writing again.')); this.requests.clear(); };
+        socket.on('error', failed);
+        socket.on('close', failed);
+    }
+    static async connect(path) {
+        const socket = createConnection(path);
+        await new Promise((resolve, reject) => { socket.once('connect', resolve); socket.once('error', reject); });
+        return new RpcClient(socket);
+    }
+    async call(method, params = {}, signal) {
+        if (signal?.aborted)
+            throw new BassfishError('CANCELLED', 'Request was cancelled before submission.');
+        if (this.socket.destroyed)
+            throw new BassfishError('CONNECTION_CLOSED', 'Reconnect explicitly before submitting a new operation.');
+        const id = randomUUID();
+        const abort = () => { if (!this.socket.destroyed)
+            this.socket.write(JSON.stringify({ id: randomUUID(), method: '$cancel', params: { id } }) + '\n'); };
+        const timer = setTimeout(() => {
+            this.requests.get(id)?.reject(new BassfishError('OUTCOME_UNKNOWN', 'The response deadline elapsed. No operation was retried; inspect current state.'));
+            this.requests.delete(id);
+        }, 35_000);
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+            return await new Promise((resolve, reject) => {
+                this.requests.set(id, { resolve: value => resolve(value), reject });
+                this.socket.write(JSON.stringify({ id, method, params }) + '\n');
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+        }
+    }
+    close() { this.socket.end(); }
+}
+//# sourceMappingURL=ipc.js.map