@agent-spaces/server 0.3.0 → 0.3.2

package/dist/services/agent.js

@@ -9,6 +9,7 @@ import { listChannels, updateChannel } from './channel.js';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
 import { extractUsageFromOutput } from '../storage/usage.js';
 const DEFAULT_AGENT_ROLE = 'agent';
+export const AGENT_GENERATOR_PRESET_ID = 'agent-generator';
 const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
 const ANTHROPIC_BRIDGE_PROVIDERS = [
@@ -24,11 +25,15 @@ export function isValidRole(role) {
 export function listTemplates() {
     const root = getGlobalAgentTemplatesDir();
     if (!existsSync(root))
-        return [];
-    return readdirSync(root, { withFileTypes: true })
+        return [getDefaultAgentGeneratorPreset()];
+    const templates = readdirSync(root, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => readAgentTemplate(entry.name))
         .filter((template) => Boolean(template));
+    if (!templates.some((template) => template.id === AGENT_GENERATOR_PRESET_ID)) {
+        templates.unshift(getDefaultAgentGeneratorPreset());
+    }
+    return templates;
 }
 export async function testConnection(workspaceId, data) {
     if (workspaceId) {
@@ -509,21 +514,57 @@ function ensureWorkspaceAgentCopy(preset, agentspaceDir) {
 }
 export function readAgentTemplate(agentId) {
     const filePath = join(getGlobalAgentTemplateDir(agentId), 'agent.json');
-    if (!existsSync(filePath))
-        return null;
+    if (!existsSync(filePath)) {
+        return agentId === AGENT_GENERATOR_PRESET_ID ? getDefaultAgentGeneratorPreset() : null;
+    }
     try {
         return JSON.parse(readFileSync(filePath, 'utf-8'));
     }
     catch {
-        return null;
+        return agentId === AGENT_GENERATOR_PRESET_ID ? getDefaultAgentGeneratorPreset() : null;
     }
 }
+function getDefaultAgentGeneratorPreset() {
+    return {
+        id: AGENT_GENERATOR_PRESET_ID,
+        name: 'Agent Generator',
+        role: 'agent',
+        description: '根据提示词生成其他 Agent 的名称、描述和 Markdown 系统提示。',
+        runtimeKind: 'claude-code',
+        modelProvider: undefined,
+        modelId: '',
+        apiBase: '',
+        apiKey: '',
+        workingDir: '',
+        mcps: {},
+        skills: [],
+        tools: [],
+        systemPrompt: [
+            '# Role',
+            'You are an Agent Spaces agent designer.',
+            '',
+            '# Responsibilities',
+            '- Convert user requirements into production-ready Agent preset metadata.',
+            '- Return only valid JSON with name, description, and systemPrompt.',
+            '- Write the systemPrompt in clear Markdown with role, responsibilities, workflow, constraints, and output expectations.',
+            '',
+            '# Constraints',
+            '- Do not include Markdown code fences around JSON.',
+            '- Keep names concise and descriptions practical.',
+        ].join('\n'),
+        temperature: 0.2,
+        maxTokens: 4096,
+        enabled: true,
+    };
+}
 function sanitizeMarkdownFilename(name) {
     const raw = basename(name).replace(/\.md$/i, '');
     const safe = raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'skill';
     return `${safe}.md`;
 }
 export function deletePreset(workspaceId, presetId) {
+    if (presetId === AGENT_GENERATOR_PRESET_ID)
+        return false;
     const ws = getWorkspace(workspaceId);
     if (!ws)
         return null;
@@ -611,6 +652,8 @@ export function updateGlobalPreset(presetId, data) {
     return updated;
 }
 export function deleteGlobalPreset(presetId) {
+    if (presetId === AGENT_GENERATOR_PRESET_ID)
+        return false;
     const templateDir = getGlobalAgentTemplateDir(presetId);
     if (!existsSync(templateDir))
         return false;

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

@@ -4,7 +4,14 @@ import * as channelService from '../services/channel.js';
 import * as taskService from '../services/task.js';
 function ensureChannel(workspaceId, issue) {
     ensureRetryDefaults(workspaceId, issue);
-    const channelMembers = issue.members || [];
+    const existingChannel = issue.channelId ? channelService.getChannel(workspaceId, issue.channelId) : undefined;
+    const issueMembers = issue.members || [];
+    const fallbackChannelMembers = existingChannel?.members ?? [];
+    const channelMembers = issueMembers.length > 0 ? issueMembers : fallbackChannelMembers;
+    if (issueMembers.length === 0 && fallbackChannelMembers.length > 0) {
+        issue.members = [...fallbackChannelMembers];
+        updateIssue(issue);
+    }
     if (issue.channelId) {
         channelService.updateChannel(workspaceId, issue.channelId, { type: 'issue', issueId: issue.id, members: channelMembers });
         return;
@@ -59,7 +66,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,
@@ -77,15 +84,16 @@ export function createForChannel(workspaceId, channelId, input) {
         return null;
     const now = new Date().toISOString();
     const issueId = uuid();
+    const issueMembers = input.members ?? channel.members ?? [];
     const issue = {
         id: issueId,
         workspaceId,
         channelId,
         title: input.title,
         description: input.description,
-        status: 'draft',
+        status: input.status ?? 'draft',
         tasks: [],
-        members: [],
+        members: [...issueMembers],
         retryCount: 0,
         maxRetries: 3,
         createdAt: now,
@@ -96,6 +104,7 @@ export function createForChannel(workspaceId, channelId, input) {
         name: input.title,
         type: 'issue',
         issueId,
+        members: issueMembers,
     });
     return issue;
 }

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),