nexus-agentd 0.1.8 → 0.2.0

package/nexus-agentd.example.json

@@ -1,47 +1,40 @@
-{
-  "initialized": false,
-  "listen": {
-    "host": "0.0.0.0",
-    "port": 8787
-  },
-  "workspaceRoots": [
-    "/data/repos"
-  ],
-  "apiKeys": [],
-  "maxRequestBytes": 1048576,
-  "maxAttachmentBytes": 33554432,
-  "artifactStoragePath": "./artifacts",
-  "maxArtifactBytes": 536870912,
-  "maxArtifactStorageBytes": 4294967296,
-  "maxPublishedArtifacts": 4096,
-  "maxConcurrentArtifactPublishes": 4,
-  "artifactTtlMs": 86400000,
-  "requestTimeoutMs": 30000,
-  "promptTimeoutMs": 1800000,
-  "cleanupIntervalMs": 60000,
-  "maxSessions": 64,
-  "maxSseConnections": 128,
-  "maxConnections": 256,
-  "sessionTtlMs": 86400000,
-  "agents": {
-    "codex": {
-      "protocol": "acp",
-      "driver": "codex",
-      "name": "Codex",
-      "instructions": "如果外部工具需要用户选择、确认或支付，请使用宿主的用户输入机制并保持任务等待；不要只输出普通文本问题。",
-      "command": "codex-acp",
-      "workspace": "/data/repos/project",
-      "permissionPolicy": "ask"
-    },
-    "research": {
-      "protocol": "a2a",
-      "name": "Research Agent",
-      "agentCardUrl": "http://192.168.1.20:8080/.well-known/agent-card.json",
-      "preferredTransport": "auto",
-      "auth": {
-        "type": "none"
-      },
-      "timeoutMs": 60000
-    }
-  }
-}
+{
+  "initialized": false,
+  "listen": {
+    "host": "0.0.0.0",
+    "port": 8787
+  },
+  "workspaceRoots": [
+    "/data/repos"
+  ],
+  "apiKeys": [],
+  "maxRequestBytes": 1048576,
+  "maxAttachmentBytes": 33554432,
+  "requestTimeoutMs": 30000,
+  "promptTimeoutMs": 1800000,
+  "cleanupIntervalMs": 60000,
+  "maxSessions": 64,
+  "maxSseConnections": 128,
+  "maxConnections": 256,
+  "sessionTtlMs": 86400000,
+  "agents": {
+    "codex": {
+      "protocol": "acp",
+      "driver": "codex",
+      "name": "Codex",
+      "command": "codex-acp",
+      "workspace": "/data/repos/project",
+      "permissionPolicy": "ask"
+    },
+    "research": {
+      "protocol": "a2a",
+      "name": "Research Agent",
+      "agentCardUrl": "http://192.168.1.20:8080/.well-known/agent-card.json",
+      "preferredTransport": "auto",
+      "auth": {
+        "type": "none"
+      },
+      "timeoutMs": 60000
+    }
+  }
+}

package/package.json

@@ -1,52 +1,52 @@
-{
-  "name": "nexus-agentd",
-  "version": "0.1.8",
-  "description": "Local Nexus Gateway daemon that exposes allowlisted Coding Agents through HTTP/SSE and ACP",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "nexus-agentd": "dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "nexus-agentd.example.json",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "author": "lumia1998",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lumia1998/nexus-gateway.git"
-  },
-  "bugs": {
-    "url": "https://github.com/lumia1998/nexus-gateway/issues"
-  },
-  "homepage": "https://github.com/lumia1998/nexus-gateway#readme",
-  "keywords": [
-    "agent-client-protocol",
-    "acp",
-    "agent",
-    "gateway",
-    "coding-agent"
-  ],
-  "scripts": {
-    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx --test test/*.test.ts",
-    "prepack": "npm run build"
-  },
-  "dependencies": {
-    "@a2a-js/sdk": "^1.0.1",
-    "@agentclientprotocol/sdk": "1.3.0",
-    "zod": "^3.25.76"
-  },
-  "devDependencies": {
-    "@types/node": "^20.14.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.6.0"
-  },
-  "license": "MIT"
-}
+{
+  "name": "nexus-agentd",
+  "version": "0.2.0",
+  "description": "Local Nexus Gateway daemon that exposes allowlisted Coding Agents through HTTP/SSE and ACP",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "nexus-agentd": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "nexus-agentd.example.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "author": "lumia1998",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lumia1998/nexus-gateway.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lumia1998/nexus-gateway/issues"
+  },
+  "homepage": "https://github.com/lumia1998/nexus-gateway#readme",
+  "keywords": [
+    "agent-client-protocol",
+    "acp",
+    "agent",
+    "gateway",
+    "coding-agent"
+  ],
+  "scripts": {
+    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@a2a-js/sdk": "^1.0.1",
+    "@agentclientprotocol/sdk": "1.3.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.6.0"
+  },
+  "license": "MIT"
+}

package/dist/agent-instructions.d.ts

@@ -1,11 +0,0 @@
-export declare const MAX_AGENT_INSTRUCTIONS_CHARS: number;
-/**
- * Baseline guidance for Agents running behind Agent Nexus.
- *
- * This is delivered as the first prompt because ACP and A2A do not expose a
- * portable system-message field across all supported Agent implementations.
- */
-export declare const DEFAULT_AGENT_INSTRUCTIONS: string;
-export declare function normalizeAgentInstructions(value: unknown, field?: string): string | undefined;
-export declare function buildAgentInstructions(custom?: string): string;
-export declare function composeInitialAgentPrompt(instructions: string, userMessage: string): string;

package/dist/agent-instructions.js

@@ -1,44 +0,0 @@
-export const MAX_AGENT_INSTRUCTIONS_CHARS = 32 * 1024;
-/**
- * Baseline guidance for Agents running behind Agent Nexus.
- *
- * This is delivered as the first prompt because ACP and A2A do not expose a
- * portable system-message field across all supported Agent implementations.
- */
-export const DEFAULT_AGENT_INSTRUCTIONS = [
-    'You are running behind the Agent Nexus conversational host.',
-    'When an external tool or operation needs the user to choose, confirm, authorize, pay, or provide more information before it can continue:',
-    '1. Do not present the task as completed.',
-    '2. Use the host\'s native user-input, elicitation, or permission request mechanism when available; do not only print a normal-text question and stop.',
-    '3. Include a concise prompt and structured options when the mechanism supports them. For payment, include the payment URL and stable order metadata.',
-    '4. After the user replies, validate the result with the upstream tool. Never treat a message such as "payment completed" as proof that payment succeeded.',
-    'Only finish the task after the external operation has actually completed.'
-].join('\n');
-export function normalizeAgentInstructions(value, field = 'instructions') {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== 'string')
-        throw new Error(`${field} must be a string`);
-    const text = value.trim();
-    if (text.length > MAX_AGENT_INSTRUCTIONS_CHARS) {
-        throw new Error(`${field} must be at most ${MAX_AGENT_INSTRUCTIONS_CHARS} characters`);
-    }
-    return text || undefined;
-}
-export function buildAgentInstructions(custom) {
-    const extra = normalizeAgentInstructions(custom);
-    return extra
-        ? `${DEFAULT_AGENT_INSTRUCTIONS}\n\nAdditional agent-specific instructions:\n${extra}`
-        : DEFAULT_AGENT_INSTRUCTIONS;
-}
-export function composeInitialAgentPrompt(instructions, userMessage) {
-    return [
-        '<agent-nexus-host-instructions>',
-        instructions,
-        '</agent-nexus-host-instructions>',
-        '',
-        '<user-request>',
-        userMessage,
-        '</user-request>'
-    ].join('\n');
-}

package/dist/artifact-store.d.ts

@@ -1,41 +0,0 @@
-import { type FileHandle } from 'node:fs/promises';
-import { type Readable } from 'node:stream';
-import type { AgentdPublishedFile } from './types.js';
-interface StoredArtifact extends AgentdPublishedFile {
-    filePath: string;
-    handle?: FileHandle;
-}
-export declare class ArtifactStoreError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}
-export declare class GatewayArtifactStore {
-    private readonly directory;
-    private readonly ttlMs;
-    private readonly maxBytes;
-    private readonly maxStorageBytes;
-    private readonly maxFiles;
-    private readonly maxConcurrentPublishes;
-    private readonly byCacheKey;
-    private cleanupTimer?;
-    private capacityQueue;
-    private activePublishes;
-    private reservedBytes;
-    private reservedFiles;
-    constructor(directory: string, ttlMs: number, maxBytes: number, maxStorageBytes?: number, maxFiles?: number, maxConcurrentPublishes?: number);
-    startCleanup(intervalMs?: number): void;
-    stopCleanup(): void;
-    publishFile(filePath: string, preferredName?: string, mediaType?: string): Promise<AgentdPublishedFile>;
-    publishHandle(handle: FileHandle, preferredName: string, mediaType?: string): Promise<AgentdPublishedFile>;
-    publishBytes(bytes: Uint8Array, preferredName: string, mediaType?: string, cacheKey?: string): Promise<AgentdPublishedFile>;
-    publishStream(input: Readable, preferredName: string, mediaType?: string, declaredSize?: number, cacheKey?: string): Promise<AgentdPublishedFile>;
-    open(id: string, expiresInput: string, requestedName: string): Promise<StoredArtifact>;
-    cleanup(): Promise<void>;
-    private ensureDirectory;
-    private isAvailable;
-    private reserveCapacity;
-    private storageUsage;
-}
-export declare function contentDisposition(name: string): string;
-export declare function mediaTypeForName(name: string): string;
-export {};

package/dist/artifact-store.js

@@ -1,340 +0,0 @@
-import { createHash, randomBytes, randomUUID } from 'node:crypto';
-import { createWriteStream } from 'node:fs';
-import { chmod, mkdir, open, readdir, rename, rm, stat } from 'node:fs/promises';
-import path from 'node:path';
-import { Transform } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-export class ArtifactStoreError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}
-export class GatewayArtifactStore {
-    directory;
-    ttlMs;
-    maxBytes;
-    maxStorageBytes;
-    maxFiles;
-    maxConcurrentPublishes;
-    byCacheKey = new Map();
-    cleanupTimer;
-    capacityQueue = Promise.resolve();
-    activePublishes = 0;
-    reservedBytes = 0;
-    reservedFiles = 0;
-    constructor(directory, ttlMs, maxBytes, maxStorageBytes = Math.max(maxBytes, 4 * 1024 * 1024 * 1024), maxFiles = 4096, maxConcurrentPublishes = 4) {
-        this.directory = directory;
-        this.ttlMs = ttlMs;
-        this.maxBytes = maxBytes;
-        this.maxStorageBytes = maxStorageBytes;
-        this.maxFiles = maxFiles;
-        this.maxConcurrentPublishes = maxConcurrentPublishes;
-    }
-    startCleanup(intervalMs = Math.min(this.ttlMs, 60 * 60 * 1000)) {
-        if (this.cleanupTimer)
-            return;
-        void this.cleanup().catch((error) => {
-            console.error(`[nexus-agentd] initial artifact cleanup failed: ${errorMessage(error)}`);
-        });
-        this.cleanupTimer = setInterval(() => {
-            void this.cleanup().catch((error) => {
-                console.error(`[nexus-agentd] artifact cleanup failed: ${errorMessage(error)}`);
-            });
-        }, Math.max(60_000, intervalMs));
-        this.cleanupTimer.unref?.();
-    }
-    stopCleanup() {
-        if (this.cleanupTimer)
-            clearInterval(this.cleanupTimer);
-        this.cleanupTimer = undefined;
-    }
-    async publishFile(filePath, preferredName, mediaType) {
-        const handle = await open(filePath, 'r');
-        try {
-            return await this.publishHandle(handle, preferredName || path.basename(filePath), mediaType);
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    async publishHandle(handle, preferredName, mediaType) {
-        const details = await handle.stat();
-        if (!details.isFile())
-            throw new ArtifactStoreError(400, 'Only regular files can be published');
-        if (details.size > this.maxBytes)
-            throw new ArtifactStoreError(413, 'File exceeds the publish size limit');
-        return this.publishStream(handle.createReadStream({ autoClose: false }), preferredName, mediaType, details.size);
-    }
-    async publishBytes(bytes, preferredName, mediaType, cacheKey) {
-        if (bytes.byteLength > this.maxBytes) {
-            throw new ArtifactStoreError(413, 'File exceeds the publish size limit');
-        }
-        const { Readable } = await import('node:stream');
-        return this.publishStream(Readable.from([bytes]), preferredName, mediaType, bytes.byteLength, cacheKey);
-    }
-    async publishStream(input, preferredName, mediaType, declaredSize, cacheKey) {
-        if (declaredSize !== undefined && declaredSize > this.maxBytes) {
-            throw new ArtifactStoreError(413, 'File exceeds the publish size limit');
-        }
-        await this.ensureDirectory();
-        const releaseCapacity = await this.reserveCapacity(declaredSize ?? this.maxBytes);
-        const name = safeFilename(preferredName);
-        const temporary = path.join(this.directory, `.upload-${randomUUID()}`);
-        const hash = createHash('sha256');
-        let size = 0;
-        const meter = new Transform({
-            transform: (chunk, _encoding, callback) => {
-                size += chunk.length;
-                if (size > this.maxBytes) {
-                    callback(new ArtifactStoreError(413, 'File exceeds the publish size limit'));
-                    return;
-                }
-                hash.update(chunk);
-                callback(null, chunk);
-            }
-        });
-        try {
-            await pipeline(input, meter, createWriteStream(temporary, { flags: 'wx', mode: 0o600 }));
-            const sha256 = hash.digest('hex');
-            const cacheId = cacheKey ? `${cacheKey}\0${sha256}` : undefined;
-            const existing = cacheId ? this.byCacheKey.get(cacheId) : undefined;
-            if (existing && (await this.isAvailable(existing))) {
-                await rm(temporary, { force: true });
-                return publicView(existing);
-            }
-            const id = randomBytes(32).toString('hex');
-            const expiresAt = Date.now() + this.ttlMs;
-            const filePath = path.join(this.directory, storedFilename(id, expiresAt, name));
-            await rename(temporary, filePath);
-            const stored = {
-                id,
-                name,
-                url: artifactUrl(id, expiresAt, name),
-                size,
-                mediaType: mediaType || mediaTypeForName(name),
-                sha256,
-                expiresAt,
-                filePath
-            };
-            if (cacheId)
-                this.byCacheKey.set(cacheId, stored);
-            return publicView(stored);
-        }
-        catch (error) {
-            await rm(temporary, { force: true }).catch(() => undefined);
-            throw error;
-        }
-        finally {
-            releaseCapacity();
-        }
-    }
-    async open(id, expiresInput, requestedName) {
-        if (!/^[a-f0-9]{64}$/.test(id))
-            throw new ArtifactStoreError(404, 'Artifact not found');
-        const expiresAt = Number(expiresInput);
-        if (!Number.isSafeInteger(expiresAt) || expiresAt <= Date.now()) {
-            throw new ArtifactStoreError(404, 'Artifact not found');
-        }
-        const name = safeFilename(requestedName);
-        if (name !== requestedName)
-            throw new ArtifactStoreError(404, 'Artifact not found');
-        const filePath = path.join(this.directory, storedFilename(id, expiresAt, name));
-        let handle;
-        try {
-            handle = await open(filePath, 'r');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new ArtifactStoreError(404, 'Artifact not found');
-            }
-            throw error;
-        }
-        let details;
-        try {
-            details = await handle.stat();
-        }
-        catch (error) {
-            await handle.close();
-            throw error;
-        }
-        if (!details.isFile()) {
-            await handle.close();
-            throw new ArtifactStoreError(404, 'Artifact not found');
-        }
-        return {
-            id,
-            name,
-            url: artifactUrl(id, expiresAt, name),
-            size: details.size,
-            mediaType: mediaTypeForName(name),
-            sha256: '',
-            expiresAt,
-            filePath,
-            handle
-        };
-    }
-    async cleanup() {
-        await this.ensureDirectory();
-        const now = Date.now();
-        const names = await readdir(this.directory);
-        await Promise.all(names.map(async (name) => {
-            const filePath = path.join(this.directory, name);
-            try {
-                const parsed = parseStoredFilename(name);
-                if (parsed?.expiresAt !== undefined && parsed.expiresAt <= now) {
-                    await rm(filePath, { force: true });
-                    return;
-                }
-                if (name.startsWith('.upload-')) {
-                    const details = await stat(filePath);
-                    if (details.mtimeMs + Math.max(this.ttlMs, 60 * 60 * 1000) <= now) {
-                        await rm(filePath, { force: true });
-                    }
-                }
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-            }
-        }));
-        for (const [cacheId, artifact] of this.byCacheKey) {
-            if (artifact.expiresAt <= now)
-                this.byCacheKey.delete(cacheId);
-        }
-    }
-    async ensureDirectory() {
-        await mkdir(this.directory, { recursive: true, mode: 0o700 });
-        if (process.platform !== 'win32')
-            await chmod(this.directory, 0o700);
-    }
-    async isAvailable(artifact) {
-        if (artifact.expiresAt <= Date.now())
-            return false;
-        try {
-            const details = await stat(artifact.filePath);
-            return details.isFile();
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return false;
-            throw error;
-        }
-    }
-    async reserveCapacity(expectedBytes) {
-        let unlock;
-        const previous = this.capacityQueue;
-        this.capacityQueue = new Promise((resolve) => {
-            unlock = resolve;
-        });
-        await previous;
-        try {
-            if (this.activePublishes >= this.maxConcurrentPublishes) {
-                throw new ArtifactStoreError(429, 'Artifact publish concurrency limit reached');
-            }
-            const usage = await this.storageUsage();
-            if (usage.bytes + this.reservedBytes + expectedBytes > this.maxStorageBytes) {
-                throw new ArtifactStoreError(507, 'Artifact storage capacity reached');
-            }
-            if (usage.files + this.reservedFiles + 1 > this.maxFiles) {
-                throw new ArtifactStoreError(507, 'Artifact file count limit reached');
-            }
-            this.activePublishes += 1;
-            this.reservedBytes += expectedBytes;
-            this.reservedFiles += 1;
-        }
-        finally {
-            unlock();
-        }
-        let released = false;
-        return () => {
-            if (released)
-                return;
-            released = true;
-            this.activePublishes = Math.max(0, this.activePublishes - 1);
-            this.reservedBytes = Math.max(0, this.reservedBytes - expectedBytes);
-            this.reservedFiles = Math.max(0, this.reservedFiles - 1);
-        };
-    }
-    async storageUsage() {
-        await this.ensureDirectory();
-        const now = Date.now();
-        let bytes = 0;
-        let files = 0;
-        for (const name of await readdir(this.directory)) {
-            const parsed = parseStoredFilename(name);
-            if (parsed?.expiresAt !== undefined && parsed.expiresAt <= now) {
-                await rm(path.join(this.directory, name), { force: true });
-                continue;
-            }
-            try {
-                const details = await stat(path.join(this.directory, name));
-                if (!details.isFile())
-                    continue;
-                bytes += details.size;
-                files += 1;
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-            }
-        }
-        return { bytes, files };
-    }
-}
-export function contentDisposition(name) {
-    const ascii = name.replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_');
-    return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(name)}`;
-}
-export function mediaTypeForName(name) {
-    const types = {
-        '.avif': 'image/avif',
-        '.csv': 'text/csv; charset=utf-8',
-        '.gif': 'image/gif',
-        '.html': 'text/html; charset=utf-8',
-        '.jpeg': 'image/jpeg',
-        '.jpg': 'image/jpeg',
-        '.json': 'application/json; charset=utf-8',
-        '.md': 'text/markdown; charset=utf-8',
-        '.mp3': 'audio/mpeg',
-        '.mp4': 'video/mp4',
-        '.ogg': 'audio/ogg',
-        '.pdf': 'application/pdf',
-        '.png': 'image/png',
-        '.svg': 'image/svg+xml',
-        '.txt': 'text/plain; charset=utf-8',
-        '.wav': 'audio/wav',
-        '.webm': 'video/webm',
-        '.webp': 'image/webp',
-        '.zip': 'application/zip'
-    };
-    return types[path.extname(name).toLowerCase()] || 'application/octet-stream';
-}
-function artifactUrl(id, expiresAt, name) {
-    return `/v1/artifacts/${id}/${expiresAt}/${encodeURIComponent(name)}`;
-}
-function storedFilename(id, expiresAt, name) {
-    return `${id}-${expiresAt}-${name}`;
-}
-function parseStoredFilename(value) {
-    const match = /^([a-f0-9]{64})-(\d+)-(.+)$/.exec(value);
-    if (!match)
-        return undefined;
-    const expiresAt = Number(match[2]);
-    if (!Number.isSafeInteger(expiresAt))
-        return undefined;
-    return { id: match[1], expiresAt, name: match[3] };
-}
-function safeFilename(value) {
-    const basename = path.basename(String(value || 'artifact').replace(/\\/g, '/'));
-    const safe = basename.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_').trim().slice(0, 180);
-    return safe || 'artifact';
-}
-function publicView(value) {
-    const { filePath: _filePath, handle: _handle, ...result } = value;
-    return result;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/workspace-files.d.ts

@@ -1,48 +0,0 @@
-import { type FileHandle } from 'node:fs/promises';
-import { type Readable } from 'node:stream';
-import type { AgentdFileEntryView, AgentdFileRootView } from './types.js';
-export declare class WorkspaceFileError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}
-export declare class WorkspaceFiles {
-    private readonly configuredRoots;
-    private readonly maxWriteBytes;
-    constructor(configuredRoots: () => string[], maxWriteBytes: number);
-    roots(): Promise<AgentdFileRootView[]>;
-    adminRoot(id: string): Promise<string>;
-    sessionRoot(workspace?: string): Promise<string>;
-    list(root: string, relative?: string): Promise<{
-        path: string;
-        entries: AgentdFileEntryView[];
-    }>;
-    open(root: string, relative: string): Promise<{
-        handle: FileHandle;
-        filePath: string;
-        name: string;
-        size: number;
-    }>;
-    publishable(root: string, input: string): Promise<{
-        handle: FileHandle;
-        filePath: string;
-        name: string;
-        size: number;
-    }>;
-    write(root: string, relative: string, input: Readable, declaredSize?: number): Promise<{
-        path: string;
-        size: number;
-    }>;
-    createDirectory(root: string, relative: string): Promise<{
-        path: string;
-    }>;
-    move(root: string, source: string, destination: string): Promise<{
-        path: string;
-        destination: string;
-    }>;
-    remove(root: string, relative: string): Promise<{
-        path: string;
-    }>;
-    private existing;
-    private writable;
-}
-export declare function workspaceRootId(root: string): string;