@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/workspace-upload-service.js

@@ -0,0 +1,240 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { parseComposerAttachmentUpload, validComposerAttachmentName } from '../util/node-operation-parsers.js';
+import { preflightWorkspaceUpload, workspaceUploadTemporaryName } from '../workspace.js';
+const CHUNK_BYTES = 512 * 1024;
+const TTL_MS = 60 * 60_000;
+const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+export class WorkspaceUploadService {
+    state;
+    onCompleted;
+    constructor(state, onCompleted) {
+        this.state = state;
+        this.onCompleted = onCompleted;
+    }
+    async preflight(workspace, input) {
+        if ((input.directory !== undefined && typeof input.directory !== 'string') ||
+            !Array.isArray(input.files) ||
+            input.files.length === 0 ||
+            input.files.some((file) => !plain(file) || typeof file.name !== 'string'))
+            throw new Error('UPLOAD_INVALID');
+        const seen = new Set();
+        return Promise.all(input.files.map(async (file) => {
+            const name = file.name;
+            if (seen.has(name))
+                return { name, status: 'INVALID_NAME', path: null };
+            seen.add(name);
+            const target = await preflightWorkspaceUpload(workspace.path, typeof input.directory === 'string' ? input.directory : '.', name);
+            return { name, status: target.status, path: target.path || null };
+        }));
+    }
+    async create(workspace, input) {
+        const attachment = parseComposerAttachmentUpload(input);
+        if ((input.directory !== undefined && typeof input.directory !== 'string') ||
+            typeof input.name !== 'string' ||
+            !Number.isSafeInteger(input.size) ||
+            input.size < 0 ||
+            typeof input.overwrite !== 'boolean' ||
+            (attachment !== undefined && input.directory !== undefined))
+            throw new Error('UPLOAD_INVALID');
+        if (attachment !== undefined &&
+            (!validComposerAttachmentName(input.name) ||
+                input.size > MAX_ATTACHMENT_BYTES ||
+                this.state.composerAttachments.has(attachment.id) ||
+                [...this.state.uploads.values()].some((upload) => upload.composerAttachment?.id === attachment.id)))
+            throw new Error('COMPOSER_ATTACHMENT_INVALID');
+        const target = attachment === undefined
+            ? await preflightWorkspaceUpload(workspace.path, typeof input.directory === 'string' ? input.directory : '.', input.name)
+            : await this.attachmentTarget(workspace.path, attachment.id, input.name);
+        if (target.status === 'INVALID_NAME')
+            throw new Error('UPLOAD_NAME_INVALID');
+        if (target.status === 'EXISTS_DIRECTORY')
+            throw new Error('UPLOAD_TARGET_DIRECTORY');
+        if (target.status === 'EXISTS_FILE' && !input.overwrite)
+            throw new Error('UPLOAD_TARGET_EXISTS');
+        if ([...this.state.uploads.values()].some((upload) => upload.workspaceId === workspace.id && upload.targetPath === target.absolutePath))
+            throw new Error('UPLOAD_TARGET_BUSY');
+        const id = randomUUID();
+        const temporaryPath = resolve(dirname(target.absolutePath), workspaceUploadTemporaryName(id));
+        const handle = await open(temporaryPath, 'wx');
+        const timer = setTimeout(() => {
+            const upload = this.state.uploads.get(id);
+            if (upload !== undefined)
+                void this.remove(upload);
+        }, TTL_MS);
+        const upload = {
+            id,
+            workspaceId: workspace.id,
+            path: target.path,
+            targetPath: target.absolutePath,
+            temporaryPath,
+            size: input.size,
+            overwrite: input.overwrite,
+            ...(attachment === undefined ? {} : { composerAttachment: attachment }),
+            handle,
+            receivedBytes: 0,
+            timer
+        };
+        this.state.uploads.set(id, upload);
+        return this.status(id);
+    }
+    async write(input) {
+        if (typeof input.uploadId !== 'string' ||
+            !Number.isSafeInteger(input.offset) ||
+            input.offset < 0 ||
+            typeof input.dataBase64 !== 'string')
+            throw new Error('UPLOAD_CHUNK_INVALID');
+        const upload = this.require(input.uploadId);
+        if (input.offset !== upload.receivedBytes)
+            throw new Error('UPLOAD_OFFSET_INVALID');
+        const bytes = Buffer.from(input.dataBase64, 'base64');
+        if (bytes.length === 0 || bytes.length > CHUNK_BYTES)
+            throw new Error('UPLOAD_CHUNK_INVALID');
+        if (upload.receivedBytes + bytes.length > upload.size)
+            throw new Error('UPLOAD_SIZE_INVALID');
+        const result = await upload.handle.write(bytes, 0, bytes.length, upload.receivedBytes);
+        if (result.bytesWritten !== bytes.length)
+            throw new Error('UPLOAD_WRITE_FAILED');
+        upload.receivedBytes += bytes.length;
+        return this.status(upload.id);
+    }
+    status(uploadId) {
+        const upload = this.require(uploadId);
+        return {
+            uploadId: upload.id,
+            path: upload.path,
+            receivedBytes: upload.receivedBytes,
+            size: upload.size
+        };
+    }
+    async complete(uploadId) {
+        const upload = this.require(uploadId);
+        if (upload.receivedBytes !== upload.size)
+            throw new Error('UPLOAD_INCOMPLETE');
+        await upload.handle.sync();
+        await upload.handle.close();
+        const existing = await lstat(upload.targetPath).catch((error) => error.code === 'ENOENT' ? undefined : Promise.reject(error));
+        if (existing?.isSymbolicLink())
+            throw new Error('FILE_PATH_ESCAPE');
+        if (existing !== undefined && (!existing.isFile() || !upload.overwrite))
+            throw new Error('UPLOAD_TARGET_EXISTS');
+        try {
+            await rename(upload.temporaryPath, upload.targetPath);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            if (!upload.overwrite)
+                throw new Error('UPLOAD_TARGET_EXISTS');
+            await rm(upload.targetPath, { force: false });
+            await rename(upload.temporaryPath, upload.targetPath);
+        }
+        clearTimeout(upload.timer);
+        this.state.uploads.delete(upload.id);
+        this.onCompleted(upload.workspaceId);
+        if (upload.composerAttachment !== undefined)
+            this.state.composerAttachments.set(upload.composerAttachment.id, {
+                id: upload.composerAttachment.id,
+                workspaceId: upload.workspaceId,
+                path: upload.path,
+                targetPath: upload.targetPath,
+                name: upload.composerAttachment.name,
+                mime: upload.composerAttachment.mime,
+                size: upload.size
+            });
+        return {
+            uploadId: upload.id,
+            path: upload.path,
+            receivedBytes: upload.receivedBytes,
+            size: upload.size
+        };
+    }
+    async cancel(uploadId) {
+        if (typeof uploadId !== 'string')
+            throw new Error('UPLOAD_NOT_FOUND');
+        const active = this.state.uploads.get(uploadId);
+        if (active !== undefined)
+            return this.remove(active);
+        const attachment = this.state.composerAttachments.get(uploadId);
+        if (attachment === undefined)
+            throw new Error('UPLOAD_NOT_FOUND');
+        this.state.composerAttachments.delete(uploadId);
+        await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+    }
+    async resolve(workspaceId, ids) {
+        return Promise.all(ids.map(async (id) => {
+            const stored = this.state.composerAttachments.get(id);
+            if (stored === undefined || stored.workspaceId !== workspaceId)
+                throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
+            const metadata = await lstat(stored.targetPath).catch(() => undefined);
+            if (metadata === undefined ||
+                metadata.isSymbolicLink() ||
+                !metadata.isFile() ||
+                metadata.size !== stored.size)
+                throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
+            const bytes = await readFile(stored.targetPath);
+            return {
+                attachment: {
+                    name: stored.name,
+                    mime: stored.mime,
+                    dataBase64: bytes.toString('base64')
+                },
+                path: stored.path
+            };
+        }));
+    }
+    async shutdown() {
+        await Promise.allSettled([...this.state.uploads.values()].map((upload) => this.remove(upload)));
+        for (const attachment of this.state.composerAttachments.values())
+            await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+        this.state.composerAttachments.clear();
+    }
+    require(id) {
+        if (typeof id !== 'string')
+            throw new Error('UPLOAD_NOT_FOUND');
+        const upload = this.state.uploads.get(id);
+        if (upload === undefined)
+            throw new Error('UPLOAD_NOT_FOUND');
+        return upload;
+    }
+    async remove(upload) {
+        this.state.uploads.delete(upload.id);
+        clearTimeout(upload.timer);
+        await upload.handle.close().catch(() => undefined);
+        await rm(upload.temporaryPath, { force: true }).catch(() => undefined);
+        if (upload.composerAttachment !== undefined)
+            await rm(dirname(upload.targetPath), { recursive: true, force: true }).catch(() => undefined);
+    }
+    async attachmentTarget(workspacePath, id, name) {
+        const mar = resolve(workspacePath, '.mar');
+        await mkdir(mar, { recursive: true, mode: 0o700 });
+        await safeDirectory(mar);
+        const temp = join(mar, 'temp-files');
+        await mkdir(temp, { recursive: true, mode: 0o700 });
+        await safeDirectory(temp);
+        const directory = join(temp, id);
+        try {
+            await mkdir(directory, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                throw new Error('COMPOSER_ATTACHMENT_INVALID');
+            throw error;
+        }
+        await safeDirectory(directory);
+        return {
+            path: `.mar/temp-files/${id}/${name}`,
+            absolutePath: join(directory, name),
+            status: 'READY'
+        };
+    }
+}
+async function safeDirectory(path) {
+    const value = await lstat(path);
+    if (!value.isDirectory() || value.isSymbolicLink())
+        throw new Error('COMPOSER_ATTACHMENT_DIRECTORY_INVALID');
+}
+function plain(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/service/workspace-watch-service.d.ts

@@ -0,0 +1,18 @@
+import { WorkspaceDomainState, type WorkspaceWatch } from './workspace-domain-state.js';
+export declare class WorkspaceWatchService {
+    private readonly state;
+    private readonly onSessionWatchRequired;
+    private readonly onSessionWatchUnused;
+    constructor(state: WorkspaceDomainState, onSessionWatchRequired: (workspaceId: string) => void, onSessionWatchUnused: (workspaceId: string) => void);
+    parseTopics(input: Record<string, unknown>): WorkspaceWatch['topics'];
+    key(input: Record<string, unknown>): string;
+    sessionHash(input: Record<string, unknown>): string;
+    create(workspaceId: string, watchId: string, sessionHash: string, topics: WorkspaceWatch['topics']): WorkspaceWatch;
+    renew(workspaceId: string, key: string): WorkspaceWatch | undefined;
+    remove(workspaceId: string, key: string): void;
+    clear(workspaceId: string): void;
+    clearAll(): void;
+    nextRevision(workspaceId: string): number;
+    topicActive(workspaceId: string, topic: 'files' | 'changes' | 'sessions'): boolean;
+    private expiryTimer;
+}

package/dist/service/workspace-watch-service.js

@@ -0,0 +1,120 @@
+const WATCH_TTL_MS = 45_000;
+export class WorkspaceWatchService {
+    state;
+    onSessionWatchRequired;
+    onSessionWatchUnused;
+    constructor(state, onSessionWatchRequired, onSessionWatchUnused) {
+        this.state = state;
+        this.onSessionWatchRequired = onSessionWatchRequired;
+        this.onSessionWatchUnused = onSessionWatchUnused;
+    }
+    parseTopics(input) {
+        if (!plain(input.topics))
+            throw new Error('WORKSPACE_WATCH_INVALID');
+        const sessions = input.topics.sessions === true;
+        const changes = input.topics.changes === true;
+        const rawFiles = input.topics.files;
+        let files;
+        if (rawFiles !== undefined) {
+            if (!plain(rawFiles) || typeof rawFiles.path !== 'string')
+                throw new Error('WORKSPACE_WATCH_INVALID');
+            if ((rawFiles.cursor !== undefined && typeof rawFiles.cursor !== 'string') ||
+                (rawFiles.limit !== undefined &&
+                    (typeof rawFiles.limit !== 'number' ||
+                        !Number.isInteger(rawFiles.limit) ||
+                        rawFiles.limit < 1 ||
+                        rawFiles.limit > 200)))
+                throw new Error('WORKSPACE_WATCH_INVALID');
+            files = {
+                path: rawFiles.path,
+                ...(typeof rawFiles.cursor === 'string' ? { cursor: rawFiles.cursor } : {}),
+                ...(typeof rawFiles.limit === 'number' ? { limit: rawFiles.limit } : {})
+            };
+        }
+        if (!sessions && !changes && files === undefined)
+            throw new Error('WORKSPACE_WATCH_INVALID');
+        return { sessions, changes, files };
+    }
+    key(input) {
+        return `${this.sessionHash(input)}:${input.watchId}`;
+    }
+    sessionHash(input) {
+        return typeof input.__workspaceWatchSessionHash === 'string'
+            ? input.__workspaceWatchSessionHash
+            : 'local-test';
+    }
+    create(workspaceId, watchId, sessionHash, topics) {
+        const key = `${sessionHash}:${watchId}`;
+        this.remove(workspaceId, key);
+        const watch = {
+            workspaceId,
+            watchId,
+            sessionHash,
+            expiresAt: Date.now() + WATCH_TTL_MS,
+            topics,
+            timer: undefined
+        };
+        watch.timer = this.expiryTimer(workspaceId, key);
+        const watches = this.state.watches.get(workspaceId) ?? new Map();
+        watches.set(key, watch);
+        this.state.watches.set(workspaceId, watches);
+        if (topics.sessions)
+            this.onSessionWatchRequired(workspaceId);
+        return watch;
+    }
+    renew(workspaceId, key) {
+        const watch = this.state.watches.get(workspaceId)?.get(key);
+        if (watch === undefined || watch.expiresAt <= Date.now()) {
+            this.remove(workspaceId, key);
+            return undefined;
+        }
+        clearTimeout(watch.timer);
+        watch.expiresAt = Date.now() + WATCH_TTL_MS;
+        watch.timer = this.expiryTimer(workspaceId, key);
+        return watch;
+    }
+    remove(workspaceId, key) {
+        const watches = this.state.watches.get(workspaceId);
+        const watch = watches?.get(key);
+        if (watch === undefined)
+            return;
+        clearTimeout(watch.timer);
+        watches?.delete(key);
+        if (watches?.size === 0)
+            this.state.watches.delete(workspaceId);
+        if (!this.topicActive(workspaceId, 'sessions'))
+            this.onSessionWatchUnused(workspaceId);
+    }
+    clear(workspaceId) {
+        const watches = this.state.watches.get(workspaceId);
+        if (watches !== undefined)
+            for (const watch of watches.values())
+                clearTimeout(watch.timer);
+        this.state.watches.delete(workspaceId);
+        this.state.watchRevisions.delete(workspaceId);
+        this.onSessionWatchUnused(workspaceId);
+    }
+    clearAll() {
+        for (const watches of this.state.watches.values())
+            for (const watch of watches.values())
+                clearTimeout(watch.timer);
+        this.state.watches.clear();
+        this.state.watchRevisions.clear();
+    }
+    nextRevision(workspaceId) {
+        const revision = (this.state.watchRevisions.get(workspaceId) ?? 0) + 1;
+        this.state.watchRevisions.set(workspaceId, revision);
+        return revision;
+    }
+    topicActive(workspaceId, topic) {
+        return [...(this.state.watches.get(workspaceId)?.values() ?? [])].some((watch) => topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic]);
+    }
+    expiryTimer(workspaceId, key) {
+        const timer = setTimeout(() => this.remove(workspaceId, key), WATCH_TTL_MS);
+        timer.unref();
+        return timer;
+    }
+}
+function plain(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/service/workspace-workbench-service.d.ts

@@ -0,0 +1,47 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeWorkspace } from '../database.js';
+import { NodeRuntimeState } from '../runtime-state.js';
+import { WorkspaceChangeService } from './workspace-change-service.js';
+import { WorkspaceFileService } from './workspace-file-service.js';
+import { WorkspaceUploadService } from './workspace-upload-service.js';
+import { WorkspaceWatchService } from './workspace-watch-service.js';
+export interface WorkspaceWorkbenchServiceOptions {
+    readonly requireWorkspace: (workspaceId: unknown) => NodeWorkspace;
+    readonly runtime: NodeRuntimeState;
+    readonly watch: WorkspaceWatchService;
+    readonly files: WorkspaceFileService;
+    readonly uploads: WorkspaceUploadService;
+    readonly changes: WorkspaceChangeService;
+    readonly listSessions: (workspaceId: string) => Promise<unknown>;
+    readonly invalidate: (workspaceId: string) => void;
+}
+export declare class WorkspaceWorkbenchService {
+    private readonly options;
+    private readonly contentSearch;
+    constructor(options: WorkspaceWorkbenchServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private activity;
+    private watch;
+    private unwatch;
+    private listFiles;
+    private readFile;
+    private searchFiles;
+    private mutateFile;
+    private searchContent;
+    private preflight;
+    private createUpload;
+    private writeUpload;
+    private completeUpload;
+    private cancelUpload;
+    private currentChanges;
+    private changeDiff;
+    private restoreChange;
+    private gitRepository;
+    private refs;
+    private gitRefs;
+    private gitHistory;
+    private gitCommitFiles;
+    private gitCommitFileDiff;
+    private diff;
+    private gitWorkspace;
+}

package/dist/service/workspace-workbench-service.js

@@ -0,0 +1,223 @@
+import { listGitHistoryRefs, readGitHistory, readGitHistoryFileDiff, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, restoreCurrentChange } from '../workspace.js';
+import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
+export class WorkspaceWorkbenchService {
+    options;
+    contentSearch;
+    constructor(options) {
+        this.options = options;
+        this.contentSearch = new WorkspaceContentSearchService(options.files);
+    }
+    operations() {
+        return {
+            'workspace.activity.read': (data) => this.activity(record(data)),
+            'workspace.watch': (data) => this.watch(record(data)),
+            'workspace.unwatch': (data) => this.unwatch(record(data)),
+            'workspace.files.list': (data) => this.listFiles(record(data)),
+            'workspace.file.read': (data) => this.readFile(record(data)),
+            'workspace.files.search': (data) => this.searchFiles(record(data)),
+            'workspace.files.mutate': (data) => this.mutateFile(record(data)),
+            'workspace.content.search': (data) => this.searchContent(record(data)),
+            'workspace.files.upload.preflight': (data) => this.preflight(record(data)),
+            'workspace.files.upload.create': (data) => this.createUpload(record(data)),
+            'workspace.files.upload.chunk': (data) => this.writeUpload(record(data)),
+            'workspace.files.upload.status': (data) => ({
+                upload: this.options.uploads.status(record(data).uploadId)
+            }),
+            'workspace.files.upload.complete': (data) => this.completeUpload(record(data)),
+            'workspace.files.upload.cancel': (data) => this.cancelUpload(record(data)),
+            'workspace.changes.current': (data) => this.currentChanges(record(data)),
+            'workspace.change.diff': (data) => this.changeDiff(record(data)),
+            'workspace.change.restore': (data) => this.restoreChange(record(data)),
+            'workspace.git.refs.list': (data) => this.gitRefs(record(data)),
+            'workspace.git.history.list': (data) => this.gitHistory(record(data)),
+            'workspace.git.commit.files': (data) => this.gitCommitFiles(record(data)),
+            'workspace.git.commit.file.diff': (data) => this.gitCommitFileDiff(record(data)),
+            'workspace.diff': (data) => this.diff(record(data))
+        };
+    }
+    activity(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            (input.cursor !== undefined && typeof input.cursor !== 'string') ||
+            (input.limit !== undefined &&
+                (!Number.isInteger(input.limit) ||
+                    input.limit < 1 ||
+                    input.limit > 500)))
+            throw new Error('EVENT_CURSOR_INVALID');
+        return this.options.runtime.listWorkspaceActivity({
+            workspaceId: input.workspaceId,
+            ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
+            ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
+        });
+    }
+    async watch(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            typeof input.watchId !== 'string' ||
+            !/^[A-Za-z0-9_-]{8,128}$/.test(input.watchId) ||
+            (input.mode !== 'initial' && input.mode !== 'renew'))
+            throw new Error('WORKSPACE_WATCH_INVALID');
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        if (input.mode === 'renew') {
+            const watch = this.options.watch.renew(workspace.id, this.options.watch.key(input));
+            if (watch === undefined)
+                throw new Error('WORKSPACE_WATCH_NOT_FOUND');
+            return { renewed: true };
+        }
+        const topics = this.options.watch.parseTopics(input);
+        const snapshot = {};
+        if (topics.sessions)
+            snapshot.sessions = await this.options.listSessions(workspace.id);
+        if (topics.files !== undefined)
+            snapshot.files = { files: await this.options.files.list(workspace, topics.files) };
+        if (topics.changes)
+            snapshot.changes =
+                workspace.kind === 'GIT_WORKSPACE' ? await this.options.changes.current(workspace) : null;
+        if (topics.files !== undefined || topics.changes)
+            await this.options.files.index(workspace).observe();
+        const watch = this.options.watch.create(workspace.id, input.watchId, this.options.watch.sessionHash(input), topics);
+        return { watch: { expiresAt: watch.expiresAt }, snapshot };
+    }
+    unwatch(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            typeof input.watchId !== 'string' ||
+            !/^[A-Za-z0-9_-]{8,128}$/.test(input.watchId))
+            throw new Error('WORKSPACE_WATCH_INVALID');
+        this.options.watch.remove(input.workspaceId, this.options.watch.key(input));
+        return { stopped: true };
+    }
+    async listFiles(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { files: await this.options.files.list(workspace, input) };
+    }
+    async readFile(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { file: await this.options.files.read(workspace, input) };
+    }
+    async searchFiles(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { files: await this.options.files.search(workspace, input) };
+    }
+    async mutateFile(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { file: await this.options.files.mutate(workspace, input) };
+    }
+    async searchContent(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { search: await this.contentSearch.search(workspace, input) };
+    }
+    async preflight(input) {
+        return {
+            uploads: await this.options.uploads.preflight(this.options.requireWorkspace(input.workspaceId), input)
+        };
+    }
+    async createUpload(input) {
+        return {
+            upload: await this.options.uploads.create(this.options.requireWorkspace(input.workspaceId), input)
+        };
+    }
+    async writeUpload(input) {
+        return { upload: await this.options.uploads.write(input) };
+    }
+    async completeUpload(input) {
+        return { upload: await this.options.uploads.complete(input.uploadId) };
+    }
+    async cancelUpload(input) {
+        await this.options.uploads.cancel(input.uploadId);
+        return { cancelled: true };
+    }
+    async currentChanges(input) {
+        return this.options.changes.current(this.options.requireWorkspace(input.workspaceId));
+    }
+    async changeDiff(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            typeof input.path !== 'string' ||
+            (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string'))
+            throw new Error('GIT_DIFF_INVALID');
+        const workspace = this.gitWorkspace(input.workspaceId);
+        const repository = await resolveGitRepository(workspace.path, input.repositoryPath ?? '');
+        return { diff: await readCurrentChangeDiff(repository, input.path) };
+    }
+    async restoreChange(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            typeof input.path !== 'string' ||
+            (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string') ||
+            (input.state !== 'STAGED' && input.state !== 'UNSTAGED' && input.state !== 'UNTRACKED'))
+            throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
+        const workspace = this.gitWorkspace(input.workspaceId);
+        if (this.options.runtime.hasActiveWorkspaceLease(workspace.id))
+            throw new Error('WORKSPACE_BUSY');
+        const repository = await resolveGitRepository(workspace.path, input.repositoryPath ?? '');
+        await restoreCurrentChange(repository, input.path, input.state);
+        this.options.invalidate(workspace.id);
+        return { restored: true };
+    }
+    async gitRepository(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string'))
+            throw new Error('GIT_REPOSITORY_INVALID');
+        const workspace = this.gitWorkspace(input.workspaceId);
+        return resolveGitRepository(workspace.path, input.repositoryPath ?? '');
+    }
+    refs(input) {
+        if (input.refs === undefined)
+            return undefined;
+        if (!Array.isArray(input.refs) ||
+            input.refs.length > 128 ||
+            input.refs.some((ref) => typeof ref !== 'string'))
+            throw new Error('GIT_HISTORY_REF_INVALID');
+        return input.refs;
+    }
+    async gitRefs(input) {
+        return { refs: await listGitHistoryRefs(await this.gitRepository(input)) };
+    }
+    async gitHistory(input) {
+        const refs = this.refs(input);
+        if (input.cursor !== undefined && typeof input.cursor !== 'string')
+            throw new Error('GIT_HISTORY_CURSOR_INVALID');
+        if (input.limit !== undefined &&
+            (typeof input.limit !== 'number' ||
+                !Number.isInteger(input.limit) ||
+                input.limit < 1 ||
+                input.limit > 100))
+            throw new Error('GIT_HISTORY_LIMIT_INVALID');
+        return readGitHistory(await this.gitRepository(input), {
+            ...(refs === undefined ? {} : { refs }),
+            ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
+            ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
+        });
+    }
+    async gitCommitFiles(input) {
+        if (typeof input.commit !== 'string')
+            throw new Error('GIT_HISTORY_COMMIT_INVALID');
+        return {
+            files: await readGitHistoryFiles(await this.gitRepository(input), input.commit, this.refs(input))
+        };
+    }
+    async gitCommitFileDiff(input) {
+        if (typeof input.commit !== 'string' ||
+            typeof input.path !== 'string' ||
+            (input.previousPath !== undefined && typeof input.previousPath !== 'string'))
+            throw new Error('GIT_DIFF_INVALID');
+        return {
+            diff: await readGitHistoryFileDiff(await this.gitRepository(input), input.commit, input.path, this.refs(input), input.previousPath)
+        };
+    }
+    async diff(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            typeof input.fromRef !== 'string' ||
+            typeof input.toRef !== 'string')
+            throw new Error('GIT_DIFF_INVALID');
+        const workspace = this.gitWorkspace(input.workspaceId);
+        return { diff: await readRestrictedDiff(workspace.path, input.fromRef, input.toRef) };
+    }
+    gitWorkspace(workspaceId) {
+        const workspace = this.options.requireWorkspace(workspaceId);
+        if (workspace.kind !== 'GIT_WORKSPACE')
+            throw new Error('WORKSPACE_NOT_GIT');
+        return workspace;
+    }
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}

package/dist/service.js

@@ -6,13 +6,13 @@ export function systemdUnit(executable, configPath, entrypoint, writablePaths =
         ...(entrypoint === undefined ? [] : [escapeSystemd(entrypoint)])
     ].join(' ');
     const readWritePaths = writablePaths.map((path) => escapeSystemd(resolve(path))).join(' ');
-    return `[Unit]\nDescription=MyAgentRoam Node\nAfter=network-online.target\n\n[Service]\nType=simple\nUser=mar-node\nNoNewPrivileges=true\nPrivateTmp=true\nProtectSystem=strict\n${readWritePaths.length === 0 ? '' : `ReadWritePaths=${readWritePaths}\n`}ExecStart=${command} run --config ${escapeSystemd(configPath)}\nRestart=on-failure\n\n[Install]\nWantedBy=multi-user.target\n`;
+    return `[Unit]\nDescription=MyAgentRoam Node\nAfter=network-online.target\n\n[Service]\nType=simple\nUser=mar-node\nNoNewPrivileges=true\nPrivateTmp=true\nProtectSystem=strict\n${readWritePaths.length === 0 ? '' : `ReadWritePaths=${readWritePaths}\n`}ExecStart=${command} supervise --config ${escapeSystemd(configPath)}\nRestart=on-failure\n\n[Install]\nWantedBy=multi-user.target\n`;
 }
 export function windowsServiceDefinition(executable, configPath, entrypoint) {
     return JSON.stringify({
         serviceName: 'MyAgentRoamNode',
         displayName: 'MyAgentRoam Node',
-        binaryPath: `"${executable}"${entrypoint === undefined ? '' : ` "${entrypoint}"`} run --config "${configPath}"`,
+        binaryPath: `"${executable}"${entrypoint === undefined ? '' : ` "${entrypoint}"`} supervise --config "${configPath}"`,
         startType: 'auto',
         account: 'LocalService'
     }, undefined, 2);
@@ -36,4 +36,3 @@ export async function removeServiceDefinition(outputPath) {
 function escapeSystemd(value) {
     return JSON.stringify(value);
 }
-//# sourceMappingURL=service.js.map

package/dist/storage.js

@@ -30,4 +30,3 @@ async function existingParent(path) {
         current = parent;
     }
 }
-//# sourceMappingURL=storage.js.map