@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/directory-sync/index.js

@@ -0,0 +1,98 @@
+import { randomUUID } from "node:crypto";
+import { VersionedCollection } from "./internal/versioned-collection.js";
+/** Daemon-global latest-state sequence owner for the active app directory. */
+export class DirectorySyncService {
+    constructor(generation = randomUUID()) {
+        this.projects = new VersionedCollection({
+            getId: (project) => project.projectId,
+        });
+        this.workspaces = new VersionedCollection({
+            getId: (workspace) => workspace.id,
+        });
+        this.agents = new VersionedCollection({
+            getId: (entry) => entry.agent.id,
+        });
+        this.generation = generation;
+    }
+    synchronizeProjects(snapshot, cursor) {
+        this.projects.replaceAll(snapshot);
+        const read = this.read(this.projects, cursor);
+        return {
+            projects: read.values.map(({ seq, value }) => ({ ...value, syncSeq: seq })),
+            sync: this.metadata(read),
+        };
+    }
+    synchronizeWorkspaces(snapshot, cursor) {
+        this.workspaces.replaceAll(snapshot);
+        const read = this.read(this.workspaces, cursor);
+        return {
+            entries: read.values.map(({ seq, value }) => ({ ...value, syncSeq: seq })),
+            emptyProjects: [],
+            pageInfo: { nextCursor: null, prevCursor: null, hasMore: false },
+            sync: this.metadata(read),
+        };
+    }
+    synchronizeAgents(snapshot, cursor) {
+        this.agents.replaceAll(snapshot);
+        const read = this.read(this.agents, cursor);
+        return {
+            entries: read.values.map(({ seq, value }) => ({ ...value, syncSeq: seq })),
+            pageInfo: { nextCursor: null, prevCursor: null, hasMore: false },
+            sync: this.metadata(read),
+        };
+    }
+    sequenceProjectUpdate(update, includeSequence) {
+        if (update.kind === "upsert") {
+            this.projects.replace(update.project);
+        }
+        else {
+            this.projects.remove(update.projectId);
+        }
+        const id = update.kind === "upsert" ? update.project.projectId : update.projectId;
+        return this.withVersion(update, includeSequence, this.version(this.projects, id));
+    }
+    sequenceWorkspaceUpdate(payload, value, id, includeSequence) {
+        if (value) {
+            this.workspaces.replace(value);
+        }
+        else {
+            this.workspaces.remove(id);
+        }
+        return this.withVersion(payload, includeSequence, this.version(this.workspaces, id));
+    }
+    sequenceAgentUpdate(payload, value, id, includeSequence) {
+        if (value) {
+            this.agents.replace(value);
+        }
+        else {
+            this.agents.remove(id);
+        }
+        return this.withVersion(payload, includeSequence, this.version(this.agents, id));
+    }
+    metadata(read) {
+        return {
+            generation: this.generation,
+            headSeq: read.headSeq,
+            mode: read.mode,
+            ...(read.reason ? { reason: read.reason } : {}),
+            removals: read.removals,
+        };
+    }
+    withVersion(payload, includeSequence, version) {
+        return version && includeSequence ? { ...payload, ...version } : payload;
+    }
+    read(collection, cursor) {
+        if (cursor.generation !== this.generation) {
+            return collection.readSnapshot(cursor.generation === undefined ? "no_cursor" : "generation_changed");
+        }
+        if (cursor.afterSeq === undefined) {
+            return collection.readSnapshot("no_cursor");
+        }
+        return collection.readAfter(cursor.afterSeq);
+    }
+    version(collection, id) {
+        const seq = collection.sequenceFor(id);
+        return seq === null ? null : { generation: this.generation, seq };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/directory-sync/internal/versioned-collection.d.ts

@@ -0,0 +1,56 @@
+export interface VersionedValue<T> {
+    seq: number;
+    value: T;
+}
+export interface VersionedRemoval {
+    id: string;
+    seq: number;
+}
+export interface CollectionRead<T> {
+    mode: "changes" | "snapshot";
+    reason?: "no_cursor" | "generation_changed" | "cursor_expired";
+    headSeq: number;
+    values: VersionedValue<T>[];
+    removals: VersionedRemoval[];
+}
+export type PublishedChange<T> = {
+    kind: "upsert";
+    seq: number;
+    value: T;
+} | {
+    kind: "remove";
+    seq: number;
+    id: string;
+};
+interface VersionedCollectionOptions<T> {
+    getId(value: T): string;
+    fingerprint?(value: T): string;
+    maxTombstones?: number;
+}
+/** Owns latest-state sequencing for one directory entity type. */
+export declare class VersionedCollection<T> {
+    private readonly valuesById;
+    private readonly tombstonesById;
+    private readonly getId;
+    private readonly fingerprint;
+    private readonly maxTombstones;
+    private expiredThroughSeq;
+    private nextSeq;
+    constructor(options: VersionedCollectionOptions<T>);
+    get headSeq(): number;
+    sequenceFor(id: string): number | null;
+    replace(value: T): Extract<PublishedChange<T>, {
+        kind: "upsert";
+    }> | null;
+    remove(id: string): Extract<PublishedChange<T>, {
+        kind: "remove";
+    }> | null;
+    replaceAll(values: Iterable<T>): void;
+    readSnapshot(reason?: "no_cursor" | "generation_changed" | "cursor_expired"): CollectionRead<T>;
+    readAfter(afterSeq: number): CollectionRead<T>;
+    private advance;
+    private sortedValues;
+    private trimTombstones;
+}
+export {};
+//# sourceMappingURL=versioned-collection.d.ts.map

package/dist/server/server/directory-sync/internal/versioned-collection.js

@@ -0,0 +1,94 @@
+/** Owns latest-state sequencing for one directory entity type. */
+export class VersionedCollection {
+    constructor(options) {
+        this.valuesById = new Map();
+        this.tombstonesById = new Map();
+        this.expiredThroughSeq = 0;
+        this.nextSeq = 0;
+        this.getId = options.getId;
+        this.fingerprint = options.fingerprint ?? ((value) => JSON.stringify(value));
+        this.maxTombstones = options.maxTombstones ?? 5000;
+    }
+    get headSeq() {
+        return this.nextSeq;
+    }
+    sequenceFor(id) {
+        return this.valuesById.get(id)?.seq ?? this.tombstonesById.get(id) ?? null;
+    }
+    replace(value) {
+        const id = this.getId(value);
+        const fingerprint = this.fingerprint(value);
+        const previous = this.valuesById.get(id);
+        if (previous?.fingerprint === fingerprint)
+            return null;
+        const seq = this.advance();
+        this.valuesById.set(id, { seq, fingerprint, value });
+        this.tombstonesById.delete(id);
+        return { kind: "upsert", seq, value };
+    }
+    remove(id) {
+        if (!this.valuesById.has(id) && this.tombstonesById.has(id))
+            return null;
+        if (!this.valuesById.delete(id) && !this.tombstonesById.has(id))
+            return null;
+        const seq = this.advance();
+        this.tombstonesById.delete(id);
+        this.tombstonesById.set(id, seq);
+        this.trimTombstones();
+        return { kind: "remove", seq, id };
+    }
+    replaceAll(values) {
+        const retainedIds = new Set();
+        for (const value of values) {
+            const id = this.getId(value);
+            retainedIds.add(id);
+            this.replace(value);
+        }
+        for (const id of this.valuesById.keys()) {
+            if (!retainedIds.has(id))
+                this.remove(id);
+        }
+    }
+    readSnapshot(reason = "no_cursor") {
+        return {
+            mode: "snapshot",
+            reason,
+            headSeq: this.headSeq,
+            values: this.sortedValues(),
+            removals: [],
+        };
+    }
+    readAfter(afterSeq) {
+        if (afterSeq < this.expiredThroughSeq || afterSeq > this.headSeq) {
+            return this.readSnapshot("cursor_expired");
+        }
+        return {
+            mode: "changes",
+            headSeq: this.headSeq,
+            values: this.sortedValues().filter((entry) => entry.seq > afterSeq),
+            removals: Array.from(this.tombstonesById, ([id, seq]) => ({ id, seq }))
+                .filter((entry) => entry.seq > afterSeq)
+                .sort((left, right) => left.seq - right.seq || left.id.localeCompare(right.id)),
+        };
+    }
+    advance() {
+        this.nextSeq += 1;
+        return this.nextSeq;
+    }
+    sortedValues() {
+        return Array.from(this.valuesById.values())
+            .map(({ seq, value }) => ({ seq, value }))
+            .sort((left, right) => left.seq - right.seq || this.getId(left.value).localeCompare(this.getId(right.value)));
+    }
+    trimTombstones() {
+        while (this.tombstonesById.size > this.maxTombstones) {
+            const oldest = this.tombstonesById.entries().next().value;
+            if (!oldest)
+                return;
+            const [id, seq] = oldest;
+            this.tombstonesById.delete(id);
+            this.expiredThroughSeq = Math.max(this.expiredThroughSeq, seq);
+        }
+    }
+}
+//# sourceMappingURL=versioned-collection.js.map

package/dist/server/server/exports.d.ts

@@ -0,0 +1,24 @@
+export { createPaseoDaemon, type PaseoDaemon, type PaseoDaemonConfig } from "./bootstrap.js";
+export { loadConfig, type CliConfigOverrides } from "./config.js";
+export { resolvePaseoHome } from "./paseo-home.js";
+export { getOrCreateServerId } from "./server-id.js";
+export { createRootLogger, type LogLevel, type LogFormat } from "./logger.js";
+export { loadPersistedConfig, savePersistedConfig, type PersistedConfig, } from "./persisted-config.js";
+export { hashDaemonPassword, isBearerTokenValid } from "./auth.js";
+export { generateLocalPairingOffer, type LocalPairingOffer } from "./pairing-offer.js";
+export { ConnectionOfferSchema, decodeOfferFragmentPayload, parseConnectionOfferFromUrl, type ConnectionOffer, } from "@camerontaylor/paseo-protocol/connection-offer";
+export { buildRelayWebSocketUrl } from "@camerontaylor/paseo-protocol/daemon-endpoints";
+export { buildDaemonWebSocketUrl, deriveLabelFromEndpoint, normalizeHostPort, parseConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "@camerontaylor/paseo-protocol/daemon-endpoints";
+export { PARENT_AGENT_ID_LABEL } from "@camerontaylor/paseo-protocol/agent-labels";
+export { DirectTcpHostConnectionSchema, type DirectTcpHostConnection, type NormalizedDirectTcpHostConnection, } from "@camerontaylor/paseo-protocol/host-connection-schema";
+export { ensureLocalSpeechModels, listLocalSpeechModels, type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId, } from "./speech/providers/local/models.js";
+export { applySherpaLoaderEnv, resolveSherpaLoaderEnv, sherpaLoaderEnvKey, sherpaPlatformArch, sherpaPlatformPackageName, type SherpaLoaderEnvKey, type SherpaLoaderEnvResolution, } from "./speech/providers/local/sherpa/sherpa-runtime-env.js";
+export { type ProviderOverride, type ProviderProfileModel, } from "./agent/provider-launch-config.js";
+export { findExecutable } from "../executable-resolution/executable-resolution.js";
+export { execCommand, spawnProcess } from "../utils/spawn.js";
+export { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, type AgentProviderDefinition, } from "@camerontaylor/paseo-protocol/provider-manifest";
+export type { AgentMode, AgentUsage, AgentCapabilityFlags, AgentPermissionRequest, AgentTimelineItem, ProviderSnapshotEntry, } from "./agent/agent-sdk-types.js";
+export { curateAgentActivity } from "./agent/activity-curator.js";
+export { getStructuredAgentResponse, StructuredAgentResponseError, StructuredAgentFallbackError, DEFAULT_STRUCTURED_GENERATION_PROVIDERS, generateStructuredAgentResponseWithFallback, type AgentCaller, type JsonSchema, type StructuredGenerationAttempt, type StructuredGenerationProvider, type StructuredAgentGenerationOptions, type StructuredAgentGenerationWithFallbackOptions, type StructuredAgentResponseOptions, } from "./agent/agent-response-loop.js";
+export type { AgentSnapshotPayload, AgentStreamEventPayload, AgentStreamMessage, } from "@camerontaylor/paseo-protocol/messages";
+//# sourceMappingURL=exports.d.ts.map

package/dist/server/server/exports.js

@@ -0,0 +1,24 @@
+// CLI exports for @getpaseo/server
+export { createPaseoDaemon } from "./bootstrap.js";
+export { loadConfig } from "./config.js";
+export { resolvePaseoHome } from "./paseo-home.js";
+export { getOrCreateServerId } from "./server-id.js";
+export { createRootLogger } from "./logger.js";
+export { loadPersistedConfig, savePersistedConfig, } from "./persisted-config.js";
+export { hashDaemonPassword, isBearerTokenValid } from "./auth.js";
+export { generateLocalPairingOffer } from "./pairing-offer.js";
+export { ConnectionOfferSchema, decodeOfferFragmentPayload, parseConnectionOfferFromUrl, } from "@camerontaylor/paseo-protocol/connection-offer";
+export { buildRelayWebSocketUrl } from "@camerontaylor/paseo-protocol/daemon-endpoints";
+export { buildDaemonWebSocketUrl, deriveLabelFromEndpoint, normalizeHostPort, parseConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "@camerontaylor/paseo-protocol/daemon-endpoints";
+export { PARENT_AGENT_ID_LABEL } from "@camerontaylor/paseo-protocol/agent-labels";
+export { DirectTcpHostConnectionSchema, } from "@camerontaylor/paseo-protocol/host-connection-schema";
+export { ensureLocalSpeechModels, listLocalSpeechModels, } from "./speech/providers/local/models.js";
+export { applySherpaLoaderEnv, resolveSherpaLoaderEnv, sherpaLoaderEnvKey, sherpaPlatformArch, sherpaPlatformPackageName, } from "./speech/providers/local/sherpa/sherpa-runtime-env.js";
+export { findExecutable } from "../executable-resolution/executable-resolution.js";
+export { execCommand, spawnProcess } from "../utils/spawn.js";
+// Provider manifest (source of truth for provider definitions)
+export { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, } from "@camerontaylor/paseo-protocol/provider-manifest";
+// Agent activity curator for CLI logs
+export { curateAgentActivity } from "./agent/activity-curator.js";
+export { getStructuredAgentResponse, StructuredAgentResponseError, StructuredAgentFallbackError, DEFAULT_STRUCTURED_GENERATION_PROVIDERS, generateStructuredAgentResponseWithFallback, } from "./agent/agent-response-loop.js";
+//# sourceMappingURL=exports.js.map

package/dist/server/server/file-download/token-store.d.ts

@@ -0,0 +1,24 @@
+export interface DownloadTokenEntry {
+    token: string;
+    path: string;
+    absolutePath: string;
+    fileName: string;
+    mimeType: string;
+    size: number;
+    expiresAt: number;
+}
+interface DownloadTokenStoreOptions {
+    ttlMs: number;
+    now?: () => number;
+}
+export declare class DownloadTokenStore {
+    private readonly ttlMs;
+    private readonly now;
+    private readonly tokens;
+    constructor(options: DownloadTokenStoreOptions);
+    issueToken(input: Omit<DownloadTokenEntry, "token" | "expiresAt">): DownloadTokenEntry;
+    consumeToken(token: string): DownloadTokenEntry | null;
+    private pruneExpired;
+}
+export {};
+//# sourceMappingURL=token-store.d.ts.map

package/dist/server/server/file-download/token-store.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+export class DownloadTokenStore {
+    constructor(options) {
+        this.tokens = new Map();
+        this.ttlMs = options.ttlMs;
+        this.now = options.now ?? (() => Date.now());
+    }
+    issueToken(input) {
+        this.pruneExpired();
+        const token = randomUUID();
+        const expiresAt = this.now() + this.ttlMs;
+        const entry = {
+            ...input,
+            token,
+            expiresAt,
+        };
+        this.tokens.set(token, entry);
+        return entry;
+    }
+    consumeToken(token) {
+        const entry = this.tokens.get(token);
+        if (!entry) {
+            return null;
+        }
+        this.tokens.delete(token);
+        if (entry.expiresAt <= this.now()) {
+            return null;
+        }
+        return entry;
+    }
+    pruneExpired() {
+        const now = this.now();
+        for (const [token, entry] of this.tokens) {
+            if (entry.expiresAt <= now) {
+                this.tokens.delete(token);
+            }
+        }
+    }
+}
+//# sourceMappingURL=token-store.js.map

package/dist/server/server/file-explorer/observer.d.ts

@@ -0,0 +1,32 @@
+import type { FileVersion } from "@camerontaylor/paseo-protocol/messages";
+interface FileWatch {
+    close(): void;
+}
+export interface FileObserverDependencies {
+    watchDirectory(directory: string, onChange: (filename: string | null) => void, onError: () => void): FileWatch;
+    setTimeout(callback: () => void | Promise<void>, delayMs: number): ReturnType<typeof setTimeout>;
+    clearTimeout(handle: ReturnType<typeof setTimeout>): void;
+    setInterval(callback: () => void | Promise<void>, delayMs: number): ReturnType<typeof setInterval>;
+    clearInterval(handle: ReturnType<typeof setInterval>): void;
+}
+export declare class FileObserver {
+    private readonly dependencies;
+    private readonly observed;
+    constructor(dependencies?: FileObserverDependencies);
+    subscribe(input: {
+        cwd: string;
+        path: string;
+    }, listener: (version: FileVersion) => void): Promise<{
+        initial: FileVersion;
+        unsubscribe: () => void;
+    }>;
+    dispose(): void;
+    private startWatching;
+    private useFallback;
+    private scheduleRestat;
+    private restate;
+    private stopWatching;
+}
+export declare const workspaceFileObserver: FileObserver;
+export {};
+//# sourceMappingURL=observer.d.ts.map

package/dist/server/server/file-explorer/observer.js

@@ -0,0 +1,130 @@
+import { watch } from "node:fs";
+import path from "node:path";
+import { getExplorerFileVersion, resolveExplorerFilePath } from "./service.js";
+const nodeDependencies = {
+    watchDirectory(directory, onChange, onError) {
+        const watcher = watch(directory, (_event, filename) => {
+            onChange(filename === null ? null : filename.toString());
+        });
+        watcher.on("error", onError);
+        return watcher;
+    },
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+};
+export class FileObserver {
+    constructor(dependencies = nodeDependencies) {
+        this.observed = new Map();
+        this.dependencies = dependencies;
+    }
+    async subscribe(input, listener) {
+        const target = await resolveExplorerFilePath({ root: input.cwd, relativePath: input.path });
+        let observed = this.observed.get(target);
+        if (!observed) {
+            const initial = await getExplorerFileVersion({ root: input.cwd, relativePath: input.path });
+            observed = this.observed.get(target);
+            if (!observed) {
+                observed = {
+                    cwd: input.cwd,
+                    path: input.path,
+                    basename: path.basename(target),
+                    listeners: new Map(),
+                    fingerprint: fingerprint(initial),
+                    watcher: null,
+                    debounce: null,
+                    fallback: null,
+                };
+                this.observed.set(target, observed);
+                this.startWatching(target, path.dirname(target), observed);
+            }
+        }
+        const initial = await getExplorerFileVersion({
+            root: input.cwd,
+            relativePath: input.path,
+        });
+        observed.listeners.set(listener, { cwd: initial.cwd, path: initial.path });
+        observed.fingerprint = fingerprint(initial);
+        let active = true;
+        return {
+            initial,
+            unsubscribe: () => {
+                if (!active)
+                    return;
+                active = false;
+                observed?.listeners.delete(listener);
+                if (observed && observed.listeners.size === 0) {
+                    this.stopWatching(observed);
+                    this.observed.delete(target);
+                }
+            },
+        };
+    }
+    dispose() {
+        for (const observed of this.observed.values()) {
+            this.stopWatching(observed);
+        }
+        this.observed.clear();
+    }
+    startWatching(target, directory, observed) {
+        try {
+            observed.watcher = this.dependencies.watchDirectory(directory, (filename) => {
+                if (filename === null || filename === observed.basename) {
+                    this.scheduleRestat(target, observed);
+                }
+            }, () => this.useFallback(target, observed));
+        }
+        catch {
+            this.useFallback(target, observed);
+        }
+    }
+    useFallback(target, observed) {
+        observed.watcher?.close();
+        observed.watcher = null;
+        if (observed.fallback)
+            return;
+        observed.fallback = this.dependencies.setInterval(() => this.restate(target, observed), 5000);
+    }
+    scheduleRestat(target, observed) {
+        if (observed.debounce) {
+            this.dependencies.clearTimeout(observed.debounce);
+        }
+        observed.debounce = this.dependencies.setTimeout(() => {
+            observed.debounce = null;
+            return this.restate(target, observed);
+        }, 50);
+    }
+    async restate(target, observed) {
+        if (this.observed.get(target) !== observed)
+            return;
+        const version = await getExplorerFileVersion({
+            root: observed.cwd,
+            relativePath: observed.path,
+        });
+        const nextFingerprint = fingerprint(version);
+        if (nextFingerprint === observed.fingerprint)
+            return;
+        observed.fingerprint = nextFingerprint;
+        for (const [listener, identity] of observed.listeners) {
+            listener({ ...version, ...identity });
+        }
+    }
+    stopWatching(observed) {
+        observed.watcher?.close();
+        if (observed.debounce)
+            this.dependencies.clearTimeout(observed.debounce);
+        if (observed.fallback)
+            this.dependencies.clearInterval(observed.fallback);
+        observed.watcher = null;
+        observed.debounce = null;
+        observed.fallback = null;
+    }
+}
+function fingerprint(version) {
+    if (version.status !== "ready")
+        return version.status;
+    return `${version.status}:${version.revision ?? `${version.size}:${version.modifiedAt}`}`;
+}
+export const workspaceFileObserver = new FileObserver();
+//# sourceMappingURL=observer.js.map

package/dist/server/server/file-explorer/service.d.ts

@@ -0,0 +1,125 @@
+export type ExplorerEntryKind = "file" | "directory";
+export type ExplorerFileKind = "text" | "image" | "binary";
+export type ExplorerEncoding = "utf-8" | "base64" | "none";
+export interface ListDirectoryParams {
+    root: string;
+    relativePath?: string;
+}
+export interface ReadFileParams {
+    root: string;
+    relativePath: string;
+}
+export interface WriteFileParams extends ReadFileParams {
+    content: string;
+    expectedModifiedAt: string;
+    expectedRevision?: string;
+}
+export type ExplorerFileVersion = {
+    status: "ready";
+    cwd: string;
+    path: string;
+    size: number;
+    modifiedAt: string;
+    revision: string;
+} | {
+    status: "missing";
+    cwd: string;
+    path: string;
+} | {
+    status: "error";
+    cwd: string;
+    path: string;
+    error: string;
+};
+export type ExplorerFileWriteResult = {
+    status: "written";
+    modifiedAt: string;
+    size: number;
+    revision: string;
+} | {
+    status: "conflict";
+    version: ExplorerFileVersion;
+} | {
+    status: "error";
+    error: string;
+};
+export interface FileExplorerEntry {
+    name: string;
+    path: string;
+    kind: ExplorerEntryKind;
+    size: number;
+    modifiedAt: string;
+}
+export interface FileExplorerDirectory {
+    path: string;
+    entries: FileExplorerEntry[];
+}
+export interface FileExplorerFile {
+    path: string;
+    kind: ExplorerFileKind;
+    encoding: ExplorerEncoding;
+    content?: string;
+    mimeType?: string;
+    size: number;
+    modifiedAt: string;
+    revision: string;
+}
+export interface FileExplorerFileBytes {
+    path: string;
+    kind: ExplorerFileKind;
+    encoding: "utf-8" | "binary";
+    bytes: Uint8Array;
+    mimeType: string;
+    size: number;
+    modifiedAt: string;
+    revision: string;
+}
+export interface FileExplorerFileStream {
+    path: string;
+    kind: ExplorerFileKind;
+    encoding: "utf-8" | "binary";
+    mimeType: string;
+    size: number;
+    modifiedAt: string;
+    revision: string;
+    chunks: AsyncIterable<Uint8Array>;
+}
+export declare const FILE_EXPLORER_STREAM_CHUNK_BYTES: number;
+export declare const MAX_EDITABLE_FILE_BYTES: number;
+export declare function listDirectoryEntries({ root, relativePath, }: ListDirectoryParams): Promise<FileExplorerDirectory>;
+export declare function readExplorerFile({ root, relativePath, }: ReadFileParams): Promise<FileExplorerFile>;
+export declare function readExplorerFileBytes({ root, relativePath, }: ReadFileParams): Promise<FileExplorerFileBytes>;
+export declare function streamExplorerFile({ root, relativePath }: ReadFileParams, consume: (file: FileExplorerFileStream) => Promise<void>): Promise<void>;
+export declare function getExplorerFileVersion({ root, relativePath, }: ReadFileParams): Promise<ExplorerFileVersion>;
+export declare function resolveExplorerFilePath({ root, relativePath, }: ReadFileParams): Promise<string>;
+export declare function writeExplorerFile({ root, relativePath, content, expectedModifiedAt, expectedRevision, }: WriteFileParams): Promise<ExplorerFileWriteResult>;
+export declare function getDownloadableFileInfo({ root, relativePath }: ReadFileParams): Promise<{
+    path: string;
+    absolutePath: string;
+    fileName: string;
+    mimeType: string;
+    size: number;
+}>;
+export interface ExplorerCreateEntryParams {
+    root: string;
+    parentPath: string;
+    name: string;
+    kind: ExplorerEntryKind;
+}
+export interface ExplorerRenameEntryParams {
+    root: string;
+    relativePath: string;
+    name: string;
+}
+export type ExplorerEntryMutationResult = {
+    status: "ok";
+    path: string;
+} | {
+    status: "error";
+    error: string;
+};
+export declare function createExplorerEntry({ root, parentPath, name, kind, }: ExplorerCreateEntryParams): Promise<ExplorerEntryMutationResult>;
+export declare function duplicateExplorerEntry({ root, relativePath, }: ReadFileParams): Promise<ExplorerEntryMutationResult>;
+export declare function renameExplorerEntry({ root, relativePath, name, }: ExplorerRenameEntryParams): Promise<ExplorerEntryMutationResult>;
+export declare function deleteExplorerEntry({ root, relativePath, }: ReadFileParams): Promise<ExplorerEntryMutationResult>;
+//# sourceMappingURL=service.d.ts.map