@agent-spaces/server 0.2.9 → 0.3.1

package/dist/services/builtin-tools.js

@@ -6,6 +6,17 @@ import * as taskService from './task.js';
 import * as agentService from './agent.js';
 import * as commandService from './command.js';
 import * as commandProcessManager from './command-process-manager.js';
+const issueStatuses = [
+    'draft',
+    'planned',
+    'in_progress',
+    'review_pending',
+    'changes_requested',
+    'approved',
+    'completed',
+    'archived',
+    'error',
+];
 const currentChannelInputSchema = {
     type: 'object',
     properties: {
@@ -32,6 +43,11 @@ const createIssueInputSchema = {
             type: 'string',
             description: 'Issue description to create for the current channel.',
         },
+        status: {
+            type: 'string',
+            enum: issueStatuses,
+            description: 'Issue status to create. Use completed when creating a finished issue report. Defaults to draft.',
+        },
     },
     required: ['channelId', 'title'],
     additionalProperties: false,
@@ -51,6 +67,32 @@ const addCommentInputSchema = {
     required: ['channelId', 'content'],
     additionalProperties: false,
 };
+const readTerminalOutputInputSchema = {
+    type: 'object',
+    properties: {
+        workspaceId: {
+            type: 'string',
+            description: 'Optional workspace ID. If omitted, the current workspace is used.',
+        },
+        sessionId: {
+            type: 'string',
+            description: 'Terminal session ID to read.',
+        },
+        offset: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Number of newest lines to skip before reading. Defaults to 0.',
+        },
+        limit: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 1000,
+            description: 'Maximum number of lines to read. Defaults to 100.',
+        },
+    },
+    required: ['sessionId'],
+    additionalProperties: false,
+};
 export function createIssueFunctionTools(workspaceId, channel, actor, allowedTools) {
     if (!channel)
         return [];
@@ -94,9 +136,10 @@ function createCurrentChannelIssue(workspaceId, channel, input) {
         throw new Error(`Current channel already has a bound issue: ${currentChannel.issueId}`);
     const title = typeof data.title === 'string' ? data.title.trim() : '';
     const description = typeof data.description === 'string' ? data.description.trim() : '';
+    const status = parseIssueStatus(data.status);
     if (!title)
         throw new Error('title is required.');
-    const issue = issueService.createForChannel(workspaceId, currentChannel.id, { title, description });
+    const issue = issueService.createForChannel(workspaceId, currentChannel.id, { title, description, status });
     if (!issue)
         throw new Error(`Current channel not found: ${currentChannel.id}`);
     channel.issueId = issue.id;
@@ -104,6 +147,14 @@ function createCurrentChannelIssue(workspaceId, channel, input) {
     channel.name = title;
     return issue;
 }
+function parseIssueStatus(status) {
+    if (status === undefined)
+        return undefined;
+    if (typeof status !== 'string' || !issueStatuses.includes(status)) {
+        throw new Error(`status must be one of: ${issueStatuses.join(', ')}.`);
+    }
+    return status;
+}
 function viewCurrentChannelIssue(workspaceId, channel, input) {
     assertCurrentChannelId(channel, input);
     const issue = getBoundIssue(workspaceId, channel);
@@ -185,6 +236,21 @@ function assertCurrentChannelId(channel, input) {
 }
 export function createCommandFunctionTools(workspaceId) {
     return [
+        {
+            name: 'ReadTerminalOutput',
+            description: 'Read paginated terminal output by terminal session ID. Defaults to the newest 100 lines.',
+            inputSchema: readTerminalOutputInputSchema,
+            annotations: { readOnly: true, openWorld: false },
+            execute: async (input) => {
+                const data = input;
+                if (data.workspaceId && data.workspaceId !== workspaceId)
+                    throw new Error('workspaceId mismatch');
+                return commandProcessManager.readTerminalOutput(workspaceId, data.sessionId, {
+                    offset: data.offset,
+                    limit: data.limit,
+                });
+            },
+        },
         {
             name: 'ListQuickCommands',
             description: 'List all quick commands for the workspace with running status.',

package/dist/services/channel.js

@@ -53,6 +53,8 @@ export function updateChannel(workspaceId, channelId, data) {
         channels[idx].draft = data.draft;
     if (Object.hasOwn(data, 'todos'))
         channels[idx].todos = data.todos;
+    if (Object.hasOwn(data, 'archived'))
+        channels[idx].archived = data.archived;
     writeJsonFile(channelsPath(workspaceId), channels);
     return channels[idx];
 }

package/dist/services/command-process-manager.js

@@ -1,3 +1,6 @@
+// packages/server/src/services/command-process-manager.ts
+import { statSync } from 'node:fs';
+import { dirname } from 'node:path';
 import * as ptyService from './pty.js';
 import * as commandService from './command.js';
 import { getWorkspace } from '../storage/workspace-store.js';
@@ -15,7 +18,14 @@ export function runCommand(workspaceId, commandId) {
     if (!command)
         throw new Error('Command not found');
     const workspace = getWorkspace(workspaceId);
-    const cwd = command.cwd || workspace?.boundDirs[0] || process.env.HOME || '/tmp';
+    const rawCwd = command.cwd || workspace?.boundDirs[0] || process.env.HOME || process.env.USERPROFILE || (process.platform === 'win32' ? process.env.SYSTEMROOT || 'C:\\' : '/tmp');
+    let cwd;
+    try {
+        cwd = statSync(rawCwd).isFile() ? dirname(rawCwd) : rawCwd;
+    }
+    catch {
+        cwd = rawCwd;
+    }
     const shell = command.shell;
     const env = command.env;
     console.log(`[command] runCommand: workspace=${workspaceId} command=${commandId} cwd=${cwd} shell=${shell} cmd=${command.command}`);
@@ -121,6 +131,9 @@ export function getCommandProcesses(workspaceId) {
     }
     return result;
 }
+export function readTerminalOutput(workspaceId, sessionId, options) {
+    return ptyService.readSessionOutput(workspaceId, sessionId, options);
+}
 export function cleanup(workspaceId) {
     for (const [commandId, cmdProcess] of processes) {
         if (cmdProcess.workspaceId === workspaceId) {

package/dist/services/file.js

@@ -1,6 +1,7 @@
-import { readdir, stat, readFile, writeFile, mkdir, rm } from 'node:fs/promises';
-import { join, resolve, relative, isAbsolute } from 'node:path';
+import { readdir, stat, readFile, writeFile, mkdir, rm, rename as fsRename } from 'node:fs/promises';
+import { join, resolve, relative, isAbsolute, dirname } from 'node:path';
 import { getWorkspace } from '../storage/workspace-store.js';
+import { createGitignoreFilter } from './gitignore.js';
 const IGNORED_DIRS = new Set(['.git', 'node_modules', '.next', '.DS_Store']);
 export function resolvePath(workspace, relPath) {
     const base = resolve(workspace.boundDirs[0]);
@@ -10,25 +11,33 @@ export function resolvePath(workspace, relPath) {
         return null;
     return abs;
 }
-export async function readTree(workspace, relPath = '') {
+export async function readTree(workspace, relPath = '', depth = Infinity) {
     const dirPath = resolvePath(workspace, relPath);
     if (!dirPath)
         return [];
-    const entries = await readdir(dirPath, { withFileTypes: true });
+    const baseDir = resolve(workspace.boundDirs[0]);
+    const ig = await createGitignoreFilter(baseDir);
+    try {
+        var entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
     const nodes = [];
     for (const entry of entries) {
         if (IGNORED_DIRS.has(entry.name))
             continue;
         const fullPath = join(dirPath, entry.name);
         const entryRelPath = relPath ? `${relPath}/${entry.name}` : entry.name;
+        const isIgnored = ig.isIgnored(entryRelPath, entry.name, entry.isDirectory());
         const s = await stat(fullPath);
         if (entry.isDirectory()) {
-            const children = await readTree(workspace, entryRelPath);
             nodes.push({
                 name: entry.name,
                 path: entryRelPath,
                 type: 'directory',
-                children,
+                ignored: isIgnored || undefined,
+                children: depth > 1 ? await readTree(workspace, entryRelPath, depth - 1) : undefined,
             });
         }
         else {
@@ -36,6 +45,7 @@ export async function readTree(workspace, relPath = '') {
                 name: entry.name,
                 path: entryRelPath,
                 type: 'file',
+                ignored: isIgnored || undefined,
                 size: s.size,
                 modifiedAt: s.mtime.toISOString(),
             });
@@ -85,5 +95,75 @@ export async function deletePath(workspace, relPath) {
         return false;
     }
 }
+export async function writeFileBinary(workspace, relPath, buffer) {
+    const abs = resolvePath(workspace, relPath);
+    if (!abs)
+        return false;
+    try {
+        await mkdir(join(abs, '..'), { recursive: true });
+        await writeFile(abs, buffer);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function importFromUrl(workspace, url, targetDir) {
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        const buffer = Buffer.from(await res.arrayBuffer());
+        const urlPath = new URL(url).pathname;
+        const filename = decodeURIComponent(urlPath.split('/').pop() || 'downloaded-file');
+        const relPath = targetDir ? `${targetDir}/${filename}` : filename;
+        const ok = await writeFileBinary(workspace, relPath, buffer);
+        return ok ? relPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function importFromAbsPath(workspace, absPath, targetDir) {
+    try {
+        const content = await readFile(absPath);
+        const filename = absPath.split(/[/\\]/).pop() || 'imported-file';
+        const relPath = targetDir ? `${targetDir}/${filename}` : filename;
+        const ok = await writeFileBinary(workspace, relPath, content);
+        return ok ? relPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function renamePath(workspace, oldRelPath, newRelPath) {
+    const oldAbs = resolvePath(workspace, oldRelPath);
+    const newAbs = resolvePath(workspace, newRelPath);
+    if (!oldAbs || !newAbs)
+        return false;
+    try {
+        await mkdir(dirname(newAbs), { recursive: true });
+        await fsRename(oldAbs, newAbs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function copyPath(workspace, srcRelPath, destRelPath) {
+    const srcAbs = resolvePath(workspace, srcRelPath);
+    const destAbs = resolvePath(workspace, destRelPath);
+    if (!srcAbs || !destAbs)
+        return false;
+    try {
+        const { cp } = await import('node:fs/promises');
+        await mkdir(dirname(destAbs), { recursive: true });
+        await cp(srcAbs, destAbs, { recursive: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export { getWorkspace };
 //# sourceMappingURL=file.js.map

package/dist/services/gitignore.js

@@ -0,0 +1,65 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const cache = new Map();
+function matchPattern(pattern, name) {
+    if (pattern.startsWith('*.')) {
+        return name.endsWith(pattern.slice(1));
+    }
+    if (pattern.startsWith('*.') && pattern.includes('/')) {
+        return name.endsWith(pattern.split('/').pop());
+    }
+    if (pattern.includes('*')) {
+        const re = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+        return re.test(name);
+    }
+    return name === pattern;
+}
+export async function createGitignoreFilter(rootDir) {
+    const gitignorePath = join(rootDir, '.gitignore');
+    let mtime = 0;
+    try {
+        const { stat } = await import('node:fs/promises');
+        mtime = (await stat(gitignorePath)).mtimeMs;
+    }
+    catch {
+        // no .gitignore
+    }
+    const cached = cache.get(rootDir);
+    if (cached && cached.mtime === mtime)
+        return cached.filter;
+    let patterns = [];
+    try {
+        const content = await readFile(gitignorePath, 'utf-8');
+        patterns = content.split('\n')
+            .map(l => l.trim())
+            .filter(l => l && !l.startsWith('#'))
+            .map(raw => {
+            const negated = raw.startsWith('!');
+            let p = negated ? raw.slice(1) : raw;
+            const dirOnly = p.endsWith('/');
+            if (dirOnly)
+                p = p.slice(0, -1);
+            // extract the last segment for name matching
+            const namePart = p.includes('/') ? p.split('/').filter(Boolean).pop() : p;
+            return { raw: namePart, dirOnly, negated, fullPath: p };
+        });
+    }
+    catch {
+        // no .gitignore
+    }
+    const filter = {
+        isIgnored(relPath, name, isDir) {
+            for (const p of patterns) {
+                if (p.dirOnly && !isDir)
+                    continue;
+                if (matchPattern(p.raw, name) || matchPattern(p.fullPath, relPath)) {
+                    return !p.negated;
+                }
+            }
+            return false;
+        },
+    };
+    cache.set(rootDir, { mtime, filter });
+    return filter;
+}
+//# sourceMappingURL=gitignore.js.map

package/dist/services/issue-retry.js

@@ -38,9 +38,10 @@ export async function retryIssue(workspaceId, issueId, ctx, options = {}) {
         ctx.broadcast('issue.updated', paused);
         return { issue: paused, retried: false, reason: 'issue retry limit reached' };
     }
+    const RETRYABLE_STATUSES = ['failed', 'running', 'reviewing', 'retrying', 'waiting_review'];
     const issueTasks = taskService.list(workspaceId, issueId);
     for (const task of issueTasks) {
-        if (task.status !== 'failed')
+        if (!RETRYABLE_STATUSES.includes(task.status))
             continue;
         const reset = taskService.resetForRetry(workspaceId, task.id, { resetRetryCount: true });
         if (!reset)

package/dist/services/issue.js

@@ -59,7 +59,7 @@ export function create(workspaceId, input) {
         channelId: channel.id,
         title: input.title,
         description: input.description,
-        status: 'draft',
+        status: input.status ?? 'draft',
         tasks: [],
         members: input.members || [],
         workflowId: input.workflowId,
@@ -83,7 +83,7 @@ export function createForChannel(workspaceId, channelId, input) {
         channelId,
         title: input.title,
         description: input.description,
-        status: 'draft',
+        status: input.status ?? 'draft',
         tasks: [],
         members: [],
         retryCount: 0,

package/dist/services/notification-hub/bot-agent.js

@@ -4,6 +4,7 @@ import { createAgentRuntime } from '../../adapters/agent-runtime.js';
 import { getThinkingRuntimeConfig } from '../llm-model-config.js';
 import { runIssueAutomation } from '../../agents/issue-agent-runner.js';
 import { publishWorkspaceEvent } from './events.js';
+import { prependPersistentAgentContext } from '../persistent-agent-context.js';
 export function getConfiguredBotAgent(workspaceId) {
     const workspace = workspaceService.getById(workspaceId);
     const botAgentId = workspace?.notificationSettings?.botAgentId;
@@ -25,8 +26,15 @@ export async function runBotAgent(workspaceId, preset, message) {
         ...getThinkingRuntimeConfig(preset),
     });
     const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
+    const workspace = workspaceService.getById(workspaceId);
     try {
-        const result = await runtime.execute(buildBotPrompt(message), workingDir, {
+        const result = await runtime.execute(prependPersistentAgentContext(buildBotPrompt(message), {
+            workspaceId,
+            workingDir,
+            boundDirs: workspace?.boundDirs,
+            includeWorkspacePrompt: false,
+            excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
+        }), workingDir, {
             maxTurns: 20,
             mcpServers: agentService.getMcpServers(preset.mcps),
             skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, preset), preset.skills),

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