@agent-spaces/server 0.3.0 → 0.3.2

package/dist/services/persistent-agent-context.js

@@ -0,0 +1,155 @@
+import { existsSync, realpathSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { readWorkspacePrompt } from './workspace-prompt.js';
+const INSTRUCTION_FILENAMES = ['CLAUDE.md', 'claude.md', 'AGENTS.md', 'agents.md'];
+const MAX_FILE_CHARS = 48_000;
+const MAX_TOTAL_CHARS = 120_000;
+export function prependPersistentAgentContext(prompt, options) {
+    const context = buildPersistentAgentContext(options);
+    if (!context)
+        return prompt;
+    return `${context}\n\n${prompt}`;
+}
+export function buildPersistentAgentContext(options) {
+    const sections = [];
+    const instructionContext = buildInstructionFileContext(options.workingDir, options.boundDirs, {
+        excludeNativeClaudeMd: options.excludeNativeClaudeMd,
+    });
+    if (instructionContext)
+        sections.push(instructionContext);
+    if (options.includeWorkspacePrompt !== false) {
+        const workspacePrompt = readWorkspacePrompt(options.workspaceId).trim();
+        if (workspacePrompt) {
+            sections.push([
+                'Workspace prompt:',
+                workspacePrompt,
+            ].join('\n'));
+        }
+    }
+    return sections.join('\n\n');
+}
+function buildInstructionFileContext(workingDir, boundDirs, options = {}) {
+    const files = collectInstructionFiles(workingDir, boundDirs, options);
+    if (files.length === 0)
+        return '';
+    const lines = [
+        'Persistent agent instructions:',
+        'The following CLAUDE.md and AGENTS.md files were auto-loaded. Earlier files are lower priority; later files are closer to the current working directory and take precedence.',
+    ];
+    let usedChars = 0;
+    for (const file of files) {
+        if (usedChars >= MAX_TOTAL_CHARS) {
+            lines.push('', '[Additional instruction files omitted because the persistent context budget was reached.]');
+            break;
+        }
+        const remaining = MAX_TOTAL_CHARS - usedChars;
+        const content = truncateForBudget(file.content, Math.min(MAX_FILE_CHARS, remaining));
+        usedChars += content.length;
+        lines.push('', `--- ${file.label} ---`, content);
+    }
+    return lines.join('\n').trim();
+}
+function collectInstructionFiles(workingDir, boundDirs, options = {}) {
+    const cwd = resolve(workingDir || process.cwd());
+    const seen = new Set();
+    const files = [];
+    const filenames = getInstructionFilenames(options);
+    for (const globalPath of globalInstructionPaths(options)) {
+        addInstructionFile(files, seen, globalPath, compactPath(globalPath));
+    }
+    for (const dir of ancestorDirs(cwd, resolveInstructionRoot(cwd, boundDirs))) {
+        for (const filename of filenames) {
+            const fullPath = join(dir, filename);
+            addInstructionFile(files, seen, fullPath, relativeOrAbsolute(cwd, fullPath));
+        }
+    }
+    return files;
+}
+function globalInstructionPaths(options) {
+    const claudeDir = join(homedir(), '.claude');
+    return getInstructionFilenames(options).map((filename) => join(claudeDir, filename));
+}
+function getInstructionFilenames(options) {
+    if (!options.excludeNativeClaudeMd)
+        return INSTRUCTION_FILENAMES;
+    return INSTRUCTION_FILENAMES.filter((filename) => filename !== 'CLAUDE.md');
+}
+function resolveInstructionRoot(cwd, boundDirs) {
+    const roots = (boundDirs ?? [])
+        .map((dir) => safeResolve(dir))
+        .filter((dir) => Boolean(dir))
+        .filter((dir) => isPathWithin(cwd, dir))
+        .sort((a, b) => a.length - b.length);
+    if (roots.length > 0)
+        return roots[0];
+    return findNearestProjectRoot(cwd);
+}
+function findNearestProjectRoot(cwd) {
+    let current = cwd;
+    while (true) {
+        if (existsSync(join(current, '.git')) || existsSync(join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return cwd;
+        current = parent;
+    }
+}
+function ancestorDirs(cwd, root) {
+    const dirs = [];
+    let current = cwd;
+    while (true) {
+        dirs.push(current);
+        if (current === root)
+            break;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return dirs.reverse();
+}
+function addInstructionFile(files, seen, path, label) {
+    if (!existsSync(path))
+        return;
+    const stat = statSync(path);
+    if (!stat.isFile())
+        return;
+    const realPath = realpathSync(path);
+    if (seen.has(realPath))
+        return;
+    seen.add(realPath);
+    files.push({
+        path: realPath,
+        label,
+        content: readFileSync(path, 'utf-8').trim(),
+    });
+}
+function truncateForBudget(content, maxChars) {
+    if (content.length <= maxChars)
+        return content;
+    const suffix = '\n\n[Instruction file truncated because the persistent context budget was reached.]';
+    return `${content.slice(0, Math.max(0, maxChars - suffix.length)).trimEnd()}${suffix}`;
+}
+function safeResolve(path) {
+    if (!path.trim())
+        return null;
+    return resolve(isAbsolute(path) ? path : join(process.cwd(), path));
+}
+function isPathWithin(path, root) {
+    const rel = relative(root, path);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+function relativeOrAbsolute(fromDir, path) {
+    const rel = relative(fromDir, path);
+    if (!rel.startsWith('..') && !isAbsolute(rel))
+        return rel || path;
+    return path;
+}
+function compactPath(path) {
+    const home = homedir();
+    return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+//# sourceMappingURL=persistent-agent-context.js.map

package/dist/services/pty.js

@@ -1,6 +1,7 @@
 import pty from 'node-pty';
 import { v4 as uuid } from 'uuid';
-const MAX_BUFFER_LINES = 100;
+const MAX_BUFFER_LINES = 1000;
+const DEFAULT_READ_LIMIT = 100;
 const sessions = new Map();
 export function createSession(workspaceId, cwd, onOutput, onExit, shell, env) {
     const id = uuid();
@@ -19,12 +20,13 @@ export function createSession(workspaceId, cwd, onOutput, onExit, shell, env) {
         cwd,
         env: ptyEnv,
     });
-    const session = { id, pty: ptyProcess, workspaceId, cwd, buffer: [] };
+    const session = { id, pty: ptyProcess, workspaceId, cwd, buffer: [], output: '' };
     ptyProcess.onData((data) => {
         session.buffer.push(data);
         if (session.buffer.length > MAX_BUFFER_LINES) {
             session.buffer = session.buffer.slice(-MAX_BUFFER_LINES);
         }
+        session.output = trimOutputLines(session.output + data, MAX_BUFFER_LINES);
         onOutput(id, data);
     });
     ptyProcess.onExit(({ exitCode }) => onExit(id, exitCode ?? 0));
@@ -64,4 +66,47 @@ export function getSessionsByWorkspace(workspaceId) {
     }
     return result;
 }
+export function readSessionOutput(workspaceId, sessionId, options = {}) {
+    const session = sessions.get(sessionId);
+    if (!session || session.workspaceId !== workspaceId) {
+        throw new Error(`Terminal session not found: ${sessionId}`);
+    }
+    const lines = normalizeOutput(session.output).split('\n');
+    const totalLines = lines.length === 1 && lines[0] === '' ? 0 : lines.length;
+    const limit = normalizePositiveInteger(options.limit, DEFAULT_READ_LIMIT);
+    const offset = normalizeNonNegativeInteger(options.offset);
+    const start = Math.max(totalLines - offset - limit, 0);
+    const end = Math.max(totalLines - offset, 0);
+    const page = totalLines === 0 ? [] : lines.slice(start, end);
+    return {
+        sessionId,
+        offset,
+        limit,
+        totalLines,
+        lines: page,
+        text: page.join('\n'),
+    };
+}
+function normalizeOutput(output) {
+    return stripAnsi(output).replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n$/, '');
+}
+function trimOutputLines(output, maxLines) {
+    const lines = output.split(/\r\n|\n|\r/);
+    if (lines.length <= maxLines)
+        return output;
+    return lines.slice(-maxLines).join('\n');
+}
+function normalizePositiveInteger(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.min(MAX_BUFFER_LINES, Math.max(1, Math.floor(value)));
+}
+function normalizeNonNegativeInteger(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.floor(value));
+}
+function stripAnsi(value) {
+    return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g, '');
+}
 //# sourceMappingURL=pty.js.map

package/dist/services/search.js

@@ -3,6 +3,7 @@ import { execSync } from 'node:child_process';
 import { readdir, stat, readFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { resolvePath } from './file.js';
+import { createGitignoreFilter } from './gitignore.js';
 const IGNORED_DIRS = new Set(['.git', 'node_modules', '.next', '.DS_Store', '__pycache__', '.turbo', 'dist', 'build', '.cache']);
 const BINARY_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.woff', '.woff2', '.ttf', '.eot', '.mp3', '.mp4', '.zip', '.tar', '.gz', '.wasm']);
 const MAX_FILE_SIZE = 1024 * 1024; // 1MB
@@ -80,6 +81,7 @@ async function searchWithNodeJs(basePath, options) {
     catch {
         return [];
     }
+    const ig = await createGitignoreFilter(basePath);
     async function walk(dir) {
         if (results.length >= maxResults)
             return;
@@ -90,6 +92,9 @@ async function searchWithNodeJs(basePath, options) {
             if (IGNORED_DIRS.has(entry.name))
                 continue;
             const fullPath = join(dir, entry.name);
+            const relPath = relative(basePath, fullPath);
+            if (ig.isIgnored(relPath, entry.name, entry.isDirectory()))
+                continue;
             if (entry.isDirectory()) {
                 await walk(fullPath);
             }
@@ -134,7 +139,7 @@ async function searchWithNodeJs(basePath, options) {
     return results;
 }
 // --- file name search ---
-async function walkForFiles(dir, query, results, basePath, limit) {
+async function walkForFiles(dir, query, results, basePath, limit, ig) {
     if (results.length >= limit)
         return;
     const entries = await readdir(dir, { withFileTypes: true });
@@ -145,6 +150,8 @@ async function walkForFiles(dir, query, results, basePath, limit) {
             continue;
         const fullPath = join(dir, entry.name);
         const relPath = relative(basePath, fullPath);
+        if (ig.isIgnored(relPath, entry.name, entry.isDirectory()))
+            continue;
         if (entry.name.toLowerCase().includes(query.toLowerCase())) {
             results.push({
                 path: relPath,
@@ -153,7 +160,7 @@ async function walkForFiles(dir, query, results, basePath, limit) {
             });
         }
         if (entry.isDirectory()) {
-            await walkForFiles(fullPath, query, results, basePath, limit);
+            await walkForFiles(fullPath, query, results, basePath, limit, ig);
         }
     }
 }
@@ -174,8 +181,9 @@ export async function searchFiles(workspace, query) {
     const basePath = resolvePath(workspace, '');
     if (!basePath)
         return [];
+    const ig = await createGitignoreFilter(basePath);
     const results = [];
-    await walkForFiles(basePath, query, results, basePath, 100);
+    await walkForFiles(basePath, query, results, basePath, 100, ig);
     return results;
 }
 export async function getDirectoryFiles(basePath, dir, extensions, maxFiles, maxSize) {

package/dist/services/speech-recognition/base.js

@@ -0,0 +1,3 @@
+export class SpeechRecognitionProviderBase {
+}
+//# sourceMappingURL=base.js.map

package/dist/services/speech-recognition/index.js

@@ -0,0 +1,16 @@
+import { SpeechRecognitionProviderBase } from './base.js';
+import { TencentSpeechProvider } from './tencent.js';
+const providers = [
+    new TencentSpeechProvider(),
+];
+function getProvider(provider) {
+    const p = providers.find(p => p.provider === provider);
+    if (!p)
+        throw new Error(`Unknown speech recognition provider: ${provider}`);
+    return p;
+}
+export async function createSpeechSession(config) {
+    return getProvider(config.provider).createSession(config);
+}
+export { SpeechRecognitionProviderBase };
+//# sourceMappingURL=index.js.map

package/dist/services/speech-recognition/tencent.js

@@ -0,0 +1,117 @@
+import { randomUUID } from 'node:crypto';
+import { createHmac } from 'node:crypto';
+import WebSocket from 'ws';
+import { SpeechRecognitionProviderBase } from './base.js';
+export class TencentSpeechProvider extends SpeechRecognitionProviderBase {
+    provider = 'tencent';
+    async createSession(config) {
+        const { appId, secretId, secretKey } = this.extractCredentials(config);
+        const voiceId = randomUUID();
+        const timestamp = Math.floor(Date.now() / 1000);
+        const expired = timestamp + 86400;
+        const nonce = Math.floor(Math.random() * 100000000);
+        const params = {
+            secretid: secretId,
+            timestamp: String(timestamp),
+            expired: String(expired),
+            nonce: String(nonce),
+            engine_model_type: '16k_zh',
+            voice_id: voiceId,
+            voice_format: '1', // PCM
+            needvad: '1',
+            filter_dirty: '1',
+            filter_modal: '1',
+            filter_punc: '1',
+        };
+        const signature = this.generateSignature(appId, params, secretKey);
+        params.signature = signature;
+        const url = `wss://asr.cloud.tencent.com/asr/v2/${appId}?${new URLSearchParams(params).toString()}`;
+        console.log('[tencent-asr] connecting to Tencent ASR, appId:', appId);
+        const ws = new WebSocket(url);
+        const resultCallbacks = [];
+        const errorCallbacks = [];
+        const closeCallbacks = [];
+        return new Promise((resolve, reject) => {
+            const handshakeTimeout = setTimeout(() => {
+                ws.close();
+                reject(new Error('Tencent ASR handshake timeout'));
+            }, 10000);
+            ws.on('open', () => {
+                console.log('[tencent-asr] WebSocket opened, waiting for handshake...');
+            });
+            ws.on('message', (data) => {
+                clearTimeout(handshakeTimeout);
+                const msg = JSON.parse(data.toString());
+                console.log('[tencent-asr] message:', JSON.stringify(msg).slice(0, 200));
+                if (msg.code !== 0) {
+                    const err = new Error(`Tencent ASR error [${msg.code}]: ${msg.message}`);
+                    errorCallbacks.forEach(cb => cb(err));
+                    ws.close();
+                    return;
+                }
+                if (msg.final === 1) {
+                    closeCallbacks.forEach(cb => cb());
+                    ws.close();
+                    return;
+                }
+                if (msg.result) {
+                    const result = {
+                        text: msg.result.voice_text_str,
+                        isFinal: msg.result.slice_type === 2,
+                        sliceType: msg.result.slice_type,
+                    };
+                    resultCallbacks.forEach(cb => cb(result));
+                }
+            });
+            ws.on('error', (err) => {
+                clearTimeout(handshakeTimeout);
+                console.error('[tencent-asr] WebSocket error:', err.message);
+                errorCallbacks.forEach(cb => cb(err));
+            });
+            ws.on('close', () => {
+                clearTimeout(handshakeTimeout);
+                console.log('[tencent-asr] WebSocket closed');
+                closeCallbacks.forEach(cb => cb());
+            });
+            // Wait for first message (handshake confirmation) to resolve
+            ws.once('message', (data) => {
+                clearTimeout(handshakeTimeout);
+                const msg = JSON.parse(data.toString());
+                console.log('[tencent-asr] handshake response:', JSON.stringify(msg).slice(0, 200));
+                if (msg.code !== 0) {
+                    reject(new Error(`Tencent ASR handshake failed [${msg.code}]: ${msg.message}`));
+                    return;
+                }
+                resolve({
+                    sendAudio: (data) => {
+                        if (ws.readyState === WebSocket.OPEN)
+                            ws.send(data);
+                    },
+                    end: () => {
+                        if (ws.readyState === WebSocket.OPEN)
+                            ws.send(JSON.stringify({ type: 'end' }));
+                    },
+                    onResult: (cb) => resultCallbacks.push(cb),
+                    onError: (cb) => errorCallbacks.push(cb),
+                    onClose: (cb) => closeCallbacks.push(cb),
+                });
+            });
+        });
+    }
+    extractCredentials(config) {
+        const { appId, secretId, secretKey } = config.credentials;
+        if (!appId || !secretId || !secretKey) {
+            throw new Error('Tencent speech recognition requires appId, secretId, and secretKey');
+        }
+        return { appId, secretId, secretKey };
+    }
+    generateSignature(appId, params, secretKey) {
+        const sortedKeys = Object.keys(params).sort();
+        const queryString = sortedKeys.map(k => `${k}=${params[k]}`).join('&');
+        const signStr = `asr.cloud.tencent.com/asr/v2/${appId}?${queryString}`;
+        const hmac = createHmac('sha1', secretKey);
+        hmac.update(signStr);
+        return hmac.digest('base64');
+    }
+}
+//# sourceMappingURL=tencent.js.map

package/dist/storage/iframe-bookmarks-store.js

@@ -0,0 +1,46 @@
+import { join } from 'node:path';
+import { readJsonFile, writeJsonFile, ensureDir, getDataDir } from './json-store.js';
+function filePath() {
+    const dir = join(getDataDir());
+    ensureDir(dir);
+    return join(dir, 'iframe-bookmarks.json');
+}
+export function listBookmarks() {
+    return readJsonFile(filePath()) ?? [];
+}
+export function addBookmark(data) {
+    const bookmarks = listBookmarks();
+    const bookmark = {
+        id: `bm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        title: data.title.trim(),
+        url: data.url.trim(),
+        size: data.size || 'full',
+        createdAt: new Date().toISOString(),
+    };
+    bookmarks.push(bookmark);
+    writeJsonFile(filePath(), bookmarks);
+    return bookmark;
+}
+export function updateBookmark(id, data) {
+    const bookmarks = listBookmarks();
+    const idx = bookmarks.findIndex((b) => b.id === id);
+    if (idx === -1)
+        return null;
+    if (data.title !== undefined)
+        bookmarks[idx].title = data.title.trim();
+    if (data.url !== undefined)
+        bookmarks[idx].url = data.url.trim();
+    if (data.size !== undefined)
+        bookmarks[idx].size = data.size;
+    writeJsonFile(filePath(), bookmarks);
+    return bookmarks[idx];
+}
+export function removeBookmark(id) {
+    const bookmarks = listBookmarks();
+    const next = bookmarks.filter((b) => b.id !== id);
+    if (next.length === bookmarks.length)
+        return false;
+    writeJsonFile(filePath(), next);
+    return true;
+}
+//# sourceMappingURL=iframe-bookmarks-store.js.map

package/dist/storage/speech-recognition-store.js

@@ -0,0 +1,61 @@
+import { readJsonFile, writeJsonFile, getDataDir } from './json-store.js';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+const FILE = () => join(getDataDir(), 'speech-recognition.json');
+function load() {
+    return readJsonFile(FILE()) ?? [];
+}
+function save(items) {
+    writeJsonFile(FILE(), items);
+}
+export function listSpeechConfigs() {
+    return load();
+}
+export function getSpeechConfig(id) {
+    return load().find(c => c.id === id);
+}
+export function getDefaultSpeechConfig() {
+    const items = load();
+    return items.find(c => c.enabled !== false) ?? undefined;
+}
+export function createSpeechConfig(input) {
+    const items = load();
+    const now = new Date().toISOString();
+    const item = {
+        id: randomUUID(),
+        provider: input.provider,
+        label: input.label || input.provider,
+        enabled: true,
+        credentials: input.credentials,
+        createdAt: now,
+        updatedAt: now,
+    };
+    items.push(item);
+    save(items);
+    return item;
+}
+export function updateSpeechConfig(id, patch) {
+    const items = load();
+    const idx = items.findIndex(c => c.id === id);
+    if (idx === -1)
+        return undefined;
+    if (patch.label !== undefined)
+        items[idx].label = patch.label;
+    if (patch.credentials !== undefined)
+        items[idx].credentials = patch.credentials;
+    if (patch.enabled !== undefined)
+        items[idx].enabled = patch.enabled;
+    items[idx].updatedAt = new Date().toISOString();
+    save(items);
+    return items[idx];
+}
+export function deleteSpeechConfig(id) {
+    const items = load();
+    const idx = items.findIndex(c => c.id === id);
+    if (idx === -1)
+        return false;
+    items.splice(idx, 1);
+    save(items);
+    return true;
+}
+//# sourceMappingURL=speech-recognition-store.js.map