@agent-spaces/server 0.1.0

package/dist/agents/reviewer-agent.js

@@ -0,0 +1,169 @@
+/**
+ * Reviewer Agent reviews completed task output.
+ */
+import * as agentService from '../services/agent.js';
+import * as taskService from '../services/task.js';
+import * as issueService from '../services/issue.js';
+import * as channelService from '../services/channel.js';
+import { createAgentRuntime } from '../adapters/agent-runtime.js';
+import { createIssueFunctionTools } from '../services/builtin-tools.js';
+import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
+import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+export async function runReviewer(workspaceId, taskId, issueId, taskResult, ctx) {
+    const issue = issueService.getById(workspaceId, issueId);
+    if (!issue) {
+        console.warn(`[reviewer] issue not found workspaceId=${workspaceId} issueId=${issueId} taskId=${taskId}`);
+        return;
+    }
+    const reviewerPreset = findIssueMemberAgent(workspaceId, issue, 'reviewer');
+    if (!reviewerPreset) {
+        console.warn(`[reviewer] no reviewer member found workspaceId=${workspaceId} issueId=${issueId} channelId=${issue.channelId} taskId=${taskId}`);
+        const currentTask = taskService.getById(workspaceId, taskId);
+        const doneTask = taskService.updateStatus(workspaceId, taskId, 'done', { result: taskResult });
+        ctx.broadcast('task.status_changed', { taskId, from: currentTask?.status ?? 'running', to: 'done' });
+        if (doneTask)
+            ctx.broadcast('task.updated', doneTask);
+        return;
+    }
+    const reviewer = agentService.getOrCreateSessionForConfig(workspaceId, reviewerPreset);
+    ctx.broadcast('agent.started', reviewer);
+    const currentTask = taskService.getById(workspaceId, taskId);
+    const reviewingTask = taskService.updateStatus(workspaceId, taskId, 'reviewing', { result: taskResult });
+    ctx.broadcast('task.status_changed', { taskId, from: currentTask?.status ?? 'running', to: 'reviewing' });
+    if (reviewingTask)
+        ctx.broadcast('task.updated', reviewingTask);
+    const reviewerFromStatus = reviewer.status;
+    agentService.updateStatus(workspaceId, reviewer.id, 'active');
+    issueService.addAgent(workspaceId, issueId, reviewerPreset.id);
+    ctx.broadcast('agent.status_changed', { agentId: reviewer.id, from: reviewerFromStatus, to: 'active' });
+    ctx.broadcast('agent.output', {
+        agentId: reviewer.id,
+        data: `Reviewing task: ${taskId}`,
+    });
+    const startTime = Date.now();
+    const progress = createIssueAgentProgress(workspaceId, issue, reviewerPreset, reviewer.id, {
+        runtime: reviewerPreset.runtimeKind,
+        model: reviewerPreset.modelId,
+        taskId,
+        phase: 'reviewer',
+    });
+    const reviewerWorkingDir = agentService.resolveWorkingDir(workspaceId, reviewerPreset);
+    const reviewerTracker = createIssueAgentProgressTracker({
+        workspaceId,
+        issue,
+        progress,
+        agentSessionId: reviewer.id,
+        workspaceRoot: reviewerWorkingDir,
+        onOutput: (line) => {
+            ctx.broadcast('agent.output', { agentId: reviewer.id, data: line });
+        },
+    });
+    // Use runtime to review.
+    const runtime = createAgentRuntime({
+        kind: reviewerPreset.runtimeKind,
+        provider: reviewerPreset.modelProvider,
+        model: reviewerPreset.modelId,
+        apiKey: reviewerPreset.apiKey,
+        baseURL: reviewerPreset.apiBase,
+        ...getThinkingRuntimeConfig(reviewerPreset),
+    });
+    const reviewResult = await runtime.execute(buildReviewerPrompt(issue, taskId, taskResult, reviewerWorkingDir), reviewerWorkingDir, {
+        maxTurns: 100,
+        mcpServers: agentService.getMcpServers(reviewerPreset.mcps),
+        functionTools: createReviewerIssueTools(workspaceId, issue, reviewerPreset),
+        skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, reviewerPreset), reviewerPreset.skills),
+        configDir: agentService.getAgentConfigDir(workspaceId, reviewerPreset),
+        sandboxDirs: reviewerPreset.sandboxDirs,
+        onEvent: reviewerTracker.handleEvent,
+    });
+    if (reviewerTracker.output.length === 0) {
+        for (const line of reviewResult.output) {
+            reviewerTracker.output.push(line);
+            ctx.broadcast('agent.output', { agentId: reviewer.id, data: line });
+        }
+    }
+    completeIssueAgentProgress(workspaceId, issue, progress, reviewResult.summary, reviewerTracker.output, {
+        runtime: reviewerPreset.runtimeKind,
+        model: reviewerPreset.modelId,
+        duration: Date.now() - startTime,
+        messageStatus: reviewResult.success ? 'completed' : 'error',
+        parts: reviewerTracker.buildParts({
+            sessionId: reviewer.id,
+            workspaceRoot: reviewerWorkingDir,
+            model: reviewerPreset.modelId,
+            usage: reviewResult.usage,
+            success: reviewResult.success,
+            error: reviewResult.error,
+        }),
+    });
+    // Mock: always approve for now
+    const approved = true;
+    agentService.complete(workspaceId, reviewer.id, undefined, {
+        runtime: reviewerPreset.runtimeKind,
+        model: reviewerPreset.modelId,
+        summary: reviewResult.summary,
+        output: reviewerTracker.output.length ? reviewerTracker.output : reviewResult.output,
+        durationMs: Date.now() - startTime,
+        usage: reviewResult.usage,
+        costUsd: reviewResult.costUsd,
+    });
+    ctx.broadcast('agent.completed', {
+        agentId: reviewer.id,
+        result: { success: true, summary: approved ? 'Approved' : 'Changes requested', artifacts: [] },
+    });
+    if (approved) {
+        const doneTask = taskService.updateStatus(workspaceId, taskId, 'done', { result: taskResult });
+        ctx.broadcast('task.status_changed', { taskId, from: 'reviewing', to: 'done' });
+        if (doneTask)
+            ctx.broadcast('task.updated', doneTask);
+        ctx.broadcast('agent.output', {
+            agentId: reviewer.id,
+            data: `Task ${taskId} approved.`,
+        });
+    }
+    else {
+        const failedTask = taskService.updateStatus(workspaceId, taskId, 'failed', {
+            result: { ...taskResult, error: 'Changes requested by reviewer' },
+        });
+        ctx.broadcast('task.status_changed', { taskId, from: 'reviewing', to: 'failed' });
+        if (failedTask)
+            ctx.broadcast('task.updated', failedTask);
+        const changedIssue = issueService.updateStatus(workspaceId, issueId, 'changes_requested');
+        ctx.broadcast('issue.status_changed', { issueId, from: 'in_progress', to: 'changes_requested' });
+        if (changedIssue)
+            ctx.broadcast('issue.updated', changedIssue);
+    }
+}
+function findIssueMemberAgent(workspaceId, issue, role) {
+    const channel = channelService.getChannel(workspaceId, issue.channelId);
+    if (!channel)
+        return null;
+    return agentService.findEnabledPresetByRoleInMembers(workspaceId, channel.members, role);
+}
+function buildReviewerPrompt(issue, taskId, taskResult, workingDir) {
+    return [
+        'Before reviewing, call ViewCurrentChannelIssue with the current channel id to load the latest shared issue context and comments.',
+        `The current workspace working directory is: ${workingDir}`,
+        'Review files under this working directory. Treat deliverables outside it, especially in /tmp, as misplaced unless the task explicitly asked for temporary output.',
+        'For Bash commands that inspect files under this working directory, prefer relative paths instead of absolute paths.',
+        '',
+        'Current issue:',
+        `- Issue id: ${issue.id}`,
+        `- Channel id: ${issue.channelId}`,
+        `- Title: ${issue.title}`,
+        '',
+        'Task result to review:',
+        `- Task id: ${taskId}`,
+        `- Success: ${taskResult.success}`,
+        `- Summary: ${taskResult.summary}`,
+        taskResult.error ? `- Error: ${taskResult.error}` : '',
+    ].filter(Boolean).join('\n');
+}
+function createReviewerIssueTools(workspaceId, issue, preset) {
+    const channel = channelService.getChannel(workspaceId, issue.channelId);
+    return createIssueFunctionTools(workspaceId, channel, {
+        senderId: preset.id,
+        senderRole: preset.role,
+    }, ['ViewCurrentChannelIssue', 'AddCurrentChannelComment']);
+}
+//# sourceMappingURL=reviewer-agent.js.map

package/dist/agents/scheduler-agent.js

@@ -0,0 +1,52 @@
+/**
+ * Scheduler Agent — periodically checks for unfinished issues and wakes the Planner.
+ */
+import * as issueService from '../services/issue.js';
+import * as workspaceService from '../services/workspace.js';
+import { hasActiveIssueAutomation, runIssueAutomation } from './issue-agent-runner.js';
+import { retryErrorIssues } from '../services/issue-retry.js';
+const CHECK_INTERVAL = 10 * 60 * 1000; // 10m
+const timers = new Map();
+export function startScheduler(workspaceId, ctx) {
+    if (timers.has(workspaceId)) {
+        console.log(`[scheduler:${workspaceId}] already running, skip`);
+        return;
+    }
+    console.log(`[scheduler:${workspaceId}] started (interval=${CHECK_INTERVAL}ms)`);
+    const tick = async () => {
+        // 检查 workspace 是否关闭了自动处理
+        const workspace = workspaceService.getById(workspaceId);
+        if (workspace && workspace.autoProcessIssues === false) {
+            console.log(`[scheduler:${workspaceId}] auto-processing disabled for this workspace, skip`);
+            return;
+        }
+        await retryErrorIssues(workspaceId, ctx);
+        const allIssues = issueService.list(workspaceId);
+        const unfinished = allIssues.filter((i) => i.status === 'draft' || i.status === 'changes_requested');
+        if (unfinished.length === 0) {
+            console.log(`[scheduler:${workspaceId}] tick: no unfinished issues (total=${allIssues.length})`);
+            return;
+        }
+        console.log(`[scheduler:${workspaceId}] tick: ${unfinished.length} unfinished issue(s):`, unfinished.map((i) => ({ id: i.id, title: i.title, status: i.status })));
+        if (hasActiveIssueAutomation(workspaceId)) {
+            console.log(`[scheduler:${workspaceId}] issue automation already active, waiting`);
+            return;
+        }
+        const nextIssue = unfinished[0];
+        console.log(`[scheduler:${workspaceId}] running automation for issue "${nextIssue.title}" (${nextIssue.id})`);
+        runIssueAutomation(workspaceId, nextIssue.id, ctx).catch((err) => {
+            console.error(`[scheduler:${workspaceId}] issue automation error for issue ${nextIssue.id}:`, err);
+        });
+    };
+    timers.set(workspaceId, setInterval(tick, CHECK_INTERVAL));
+    tick();
+}
+export function stopScheduler(workspaceId) {
+    const timer = timers.get(workspaceId);
+    if (timer) {
+        clearInterval(timer);
+        timers.delete(workspaceId);
+        console.log(`[scheduler:${workspaceId}] stopped`);
+    }
+}
+//# sourceMappingURL=scheduler-agent.js.map

package/dist/app.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import { config as loadDotenv } from 'dotenv';
+loadDotenv();
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'node:http';
+import { WebSocketServer } from 'ws';
+import { existsSync, mkdirSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import workspaceRouter from './routes/workspace.js';
+import fileRouter from './routes/file.js';
+import channelRouter from './routes/channel.js';
+import issueRouter from './routes/issue.js';
+import agentRouter from './routes/agent.js';
+import taskRouter from './routes/task.js';
+import gitRouter from './routes/git.js';
+import llmRouter from './routes/llm.js';
+import authRouter from './routes/auth.js';
+import folderRouter from './routes/folder.js';
+import { authMiddleware, verifyToken } from './middleware/auth.js';
+import { handleConnection } from './ws/handler.js';
+import { startScheduler, stopScheduler } from './agents/scheduler-agent.js';
+import { recoverRunningWorkOnStartup } from './services/issue-retry.js';
+import { startPersistedNotificationServices } from './services/notification-hub/index.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PORT = parseInt(process.env.PORT || '3100', 10);
+const IS_PROD = process.env.NODE_ENV === 'production';
+const resolveRuntimeDir = (name) => {
+    const currentDir = join(__dirname, name);
+    if (existsSync(currentDir))
+        return currentDir;
+    return join(__dirname, '..', name);
+};
+const app = express();
+app.use(cors());
+app.use(express.json({ limit: '50mb' }));
+app.use('/api', authMiddleware);
+// Serve static files from public/
+const publicDir = resolveRuntimeDir('public');
+app.use('/public', express.static(publicDir));
+app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+app.use('/api/auth', authRouter);
+// Avatar upload
+app.post('/api/upload/avatar', async (req, res) => {
+    const { dataUrl, filename } = req.body;
+    if (!dataUrl || !dataUrl.startsWith('data:')) {
+        res.status(400).json({ error: 'Invalid dataUrl' });
+        return;
+    }
+    const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+    if (!match) {
+        res.status(400).json({ error: 'Invalid base64 data' });
+        return;
+    }
+    const [, mime, base64] = match;
+    const ext = mime === 'image/png' ? 'png' : mime === 'image/webp' ? 'webp' : 'jpg';
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const name = filename ? `${id}-${filename.replace(/[^a-zA-Z0-9._-]/g, '_')}` : `${id}.${ext}`;
+    const avatarsDir = join(publicDir, 'avatars');
+    if (!existsSync(avatarsDir))
+        mkdirSync(avatarsDir, { recursive: true });
+    await writeFile(join(avatarsDir, name), Buffer.from(base64, 'base64'));
+    res.json({ url: `/static/avatars/${name}` });
+});
+app.use('/api/workspaces', workspaceRouter);
+app.use('/api/workspaces/:id/files', fileRouter);
+app.use('/api/workspaces/:id/channels', channelRouter);
+app.use('/api/workspaces/:id/issues', issueRouter);
+app.use('/api/workspaces/:id/agents', agentRouter);
+app.use('/api/workspaces/:id/tasks', taskRouter);
+app.use('/api/workspaces/:id/git', gitRouter);
+app.use('/api/agents', agentRouter);
+app.use('/api', llmRouter);
+app.use('/api/folder', folderRouter);
+// Serve static web frontend in production (after API routes, before catch-all)
+if (IS_PROD) {
+    const webDir = resolveRuntimeDir('web');
+    if (existsSync(webDir)) {
+        // /static/* -> public/* (avatar URLs etc.)
+        app.use('/static', express.static(publicDir));
+        // web static assets (_next, monaco, etc.)
+        app.use(express.static(webDir));
+        // SPA fallback: serve correct HTML for each route
+        const indexHtml = join(webDir, 'index.html');
+        const workspaceHtml = join(webDir, 'workspace', '_.html');
+        // /workspace/* -> workspace SPA page
+        if (existsSync(workspaceHtml)) {
+            app.get('/workspace/:id', (_req, res) => {
+                res.sendFile(workspaceHtml);
+            });
+        }
+        // Everything else -> root index.html
+        app.use((_req, res) => {
+            res.sendFile(indexHtml);
+        });
+        console.log(`[server] serving web frontend from ${webDir}`);
+    }
+    else {
+        console.warn('[server] web frontend not found at', webDir, '- run \`pnpm build\` first');
+    }
+}
+const server = createServer(app);
+const wss = new WebSocketServer({ server, path: '/ws' });
+wss.on('connection', (ws, req) => {
+    const url = new URL(req.url || '', `http://localhost:${PORT}`);
+    const workspaceId = url.searchParams.get('workspaceId');
+    if (!workspaceId) {
+        ws.close(4001, 'workspaceId required');
+        return;
+    }
+    const token = url.searchParams.get('token');
+    if (!verifyToken(token)) {
+        ws.close(4003, 'Unauthorized');
+        return;
+    }
+    handleConnection(ws, workspaceId);
+});
+const HOST = process.env.HOST || '0.0.0.0';
+server.listen(PORT, HOST, () => {
+    console.log(`[server] listening on http://${HOST}:${PORT}`);
+    console.log(`[server] websocket on ws://${HOST}:${PORT}/ws?workspaceId=...`);
+    recoverRunningWorkOnStartup();
+    startPersistedNotificationServices().catch((err) => {
+        console.error('[notification] failed to restore persisted services:', err);
+    });
+});
+// Start scheduler for all workspaces (lazy: started on first WS connection)
+export { startScheduler, stopScheduler };
+//# sourceMappingURL=app.js.map

package/dist/hooks/agent-hooks.js

@@ -0,0 +1,19 @@
+/**
+ * Agent hooks: chain executor completion to reviewer processing.
+ */
+import { runReviewer } from '../agents/reviewer-agent.js';
+/**
+ * Hook: executor complete triggers reviewer.
+ * This is the core hook in the agent orchestration pipeline.
+ */
+export async function onExecutorComplete(workspaceId, taskId, issueId, result, ctx) {
+    console.log(`[hook:onExecutorComplete] entered workspaceId=${workspaceId} taskId=${taskId} issueId=${issueId} success=${result.success} summary=${JSON.stringify(result.summary)}`);
+    if (!result.success) {
+        console.warn(`[hook:onExecutorComplete] task ${taskId} failed: ${result.error}`);
+        return;
+    }
+    console.log(`[hook:onExecutorComplete] triggering reviewer taskId=${taskId} issueId=${issueId}`);
+    await runReviewer(workspaceId, taskId, issueId, result, ctx);
+    console.log(`[hook:onExecutorComplete] reviewer completed taskId=${taskId} issueId=${issueId}`);
+}
+//# sourceMappingURL=agent-hooks.js.map

package/dist/install.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+cd "$(dirname "$0")"
+
+cat > .npmrc <<'EOF'
+shamefully-hoist=true
+strict-peer-dependencies=false
+only-built-dependencies[]=node-pty
+only-built-dependencies[]=protobufjs
+EOF
+
+node <<'NODE'
+const fs = require('node:fs');
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+pkg.pnpm ??= {};
+pkg.pnpm.overrides = {
+  '@codeany/open-agent-sdk>zod': '3.25.76',
+  '@codeany/open-agent-sdk>zod-to-json-schema': '3.24.6',
+};
+pkg.pnpm.onlyBuiltDependencies = ['node-pty', 'protobufjs'];
+pkg.pnpm.supportedArchitectures = {
+  os: ['current'],
+  cpu: ['current'],
+  libc: ['current'],
+};
+fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+NODE
+
+if ! command -v pnpm >/dev/null 2>&1; then
+  corepack enable
+fi
+
+pnpm_cmd=(corepack pnpm@10.17.1)
+
+rm -rf node_modules pnpm-lock.yaml
+"${pnpm_cmd[@]}" install --prod --ignore-scripts
+"${pnpm_cmd[@]}" rebuild node-pty protobufjs
+
+if find node_modules/.pnpm -maxdepth 1 -name 'zod-to-json-schema@3.25.2_zod@3.23.0' | grep -q .; then
+  echo "Bad zod peer resolution remains: zod-to-json-schema@3.25.2_zod@3.23.0" >&2
+  exit 1
+fi
+
+"${pnpm_cmd[@]}" ignored-builds
+if find node_modules/.pnpm -maxdepth 1 \( -name '@openai+codex@*-darwin-*' -o -name '@openai+codex@*-win32-*' -o -name '@anthropic-ai+claude-agent-sdk-darwin-*' -o -name '@anthropic-ai+claude-agent-sdk-win32-*' \) | grep -q .; then
+  echo "Unexpected non-Linux agent platform package was installed" >&2
+  exit 1
+fi
+
+node <<'NODE'
+const packagesByPlatform = {
+  'darwin-arm64': '@anthropic-ai/claude-agent-sdk-darwin-arm64',
+  'darwin-x64': '@anthropic-ai/claude-agent-sdk-darwin-x64',
+  'linux-arm64-glibc': '@anthropic-ai/claude-agent-sdk-linux-arm64',
+  'linux-arm64-musl': '@anthropic-ai/claude-agent-sdk-linux-arm64-musl',
+  'linux-x64-glibc': '@anthropic-ai/claude-agent-sdk-linux-x64',
+  'linux-x64-musl': '@anthropic-ai/claude-agent-sdk-linux-x64-musl',
+  'win32-arm64': '@anthropic-ai/claude-agent-sdk-win32-arm64',
+  'win32-x64': '@anthropic-ai/claude-agent-sdk-win32-x64',
+};
+
+const libc = process.platform === 'linux'
+  ? (process.report?.getReport?.().header?.glibcVersionRuntime ? 'glibc' : 'musl')
+  : undefined;
+const key = [process.platform, process.arch, libc].filter(Boolean).join('-');
+const claudePackage = packagesByPlatform[key];
+
+Promise.resolve()
+  .then(() => import('zod-to-json-schema'))
+  .then(() => import('@codeany/open-agent-sdk'))
+  .then(() => require('node-pty'))
+  .then(() => {
+    if (!claudePackage) return;
+    require.resolve(claudePackage + '/claude');
+  })
+  .then(() => console.log('install verification ok'))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+NODE
+
+echo "Install complete. Start with: npm run start"

package/dist/middleware/auth.js

@@ -0,0 +1,19 @@
+import { getSecret } from '../services/auth-store.js';
+export function authMiddleware(req, res, next) {
+    const secret = getSecret();
+    const openPaths = ['/api/health', '/api/auth/login', '/api/auth/check'];
+    if (openPaths.includes(req.path))
+        return next();
+    const auth = req.headers.authorization;
+    const token = auth?.startsWith('Bearer ') ? auth.slice(7) : '';
+    if (token !== secret) {
+        res.status(401).json({ error: 'Unauthorized' });
+        return;
+    }
+    next();
+}
+export function verifyToken(token) {
+    const secret = getSecret();
+    return (token ?? '') === secret;
+}
+//# sourceMappingURL=auth.js.map

package/dist/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@agent-spaces/server",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "app.js",
+  "packageManager": "pnpm@10.17.1",
+  "scripts": {
+    "start": "NODE_ENV=production node app.js",
+    "setup": "bash ./install.sh"
+  },
+  "dependencies": {
+    "@agent-spaces/shared": "file:./shared",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
+    "@codeany/open-agent-sdk": "^0.2.1",
+    "@larksuiteoapi/node-sdk": "^1.62.1",
+    "@openai/codex-sdk": "^0.128.0",
+    "cors": "^2.8.5",
+    "dotenv": "^17.4.2",
+    "express": "^5.1.0",
+    "node-pty": "^1.1.0",
+    "simple-git": "^3.36.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.2",
+    "zod": "^4.0.0"
+  },
+  "pnpm": {
+    "overrides": {
+      "@codeany/open-agent-sdk>zod": "3.25.76",
+      "@codeany/open-agent-sdk>zod-to-json-schema": "3.24.6"
+    },
+    "onlyBuiltDependencies": [
+      "node-pty",
+      "protobufjs"
+    ],
+    "supportedArchitectures": {
+      "os": [
+        "current"
+      ],
+      "cpu": [
+        "current"
+      ],
+      "libc": [
+        "current"
+      ]
+    }
+  }
+}

package/dist/routes/agent.js

@@ -0,0 +1,87 @@
+import { Router } from 'express';
+import * as agentService from '../services/agent.js';
+const router = Router({ mergeParams: true });
+router.get('/usage/dashboard', (req, res) => {
+    const days = Number(req.query.days ?? 30);
+    res.json(agentService.usageDashboard(Number.isFinite(days) ? days : 30));
+});
+router.get('/presets', (req, res) => {
+    const presets = agentService.listPresets(req.params.id);
+    if (!presets) {
+        res.status(404).json({ error: 'workspace not found' });
+        return;
+    }
+    res.json(presets);
+});
+router.post('/presets', (req, res) => {
+    const preset = agentService.createPreset(req.params.id, req.body);
+    if (!preset) {
+        res.status(404).json({ error: 'workspace not found' });
+        return;
+    }
+    res.status(201).json(preset);
+});
+router.post('/presets/test-connection', async (req, res) => {
+    const result = await agentService.testConnection(req.params.id, req.body);
+    if (!result) {
+        res.status(404).json({ error: 'workspace not found' });
+        return;
+    }
+    res.status(result.success ? 200 : 400).json(result);
+});
+router.put('/presets/:presetId', (req, res) => {
+    const preset = agentService.updatePreset(req.params.id, req.params.presetId, req.body);
+    if (!preset) {
+        res.status(404).json({ error: 'agent preset not found' });
+        return;
+    }
+    res.json(preset);
+});
+router.delete('/presets/:presetId', (req, res) => {
+    const deleted = agentService.deletePreset(req.params.id, req.params.presetId);
+    if (deleted === null) {
+        res.status(404).json({ error: 'workspace not found' });
+        return;
+    }
+    if (!deleted) {
+        res.status(404).json({ error: 'agent preset not found' });
+        return;
+    }
+    res.status(204).end();
+});
+router.get('/', (req, res) => {
+    const sessions = agentService.list(req.params.id);
+    res.json(sessions);
+});
+router.post('/start', (req, res) => {
+    const { role, issueId } = req.body;
+    if (!role) {
+        res.status(400).json({ error: 'role is required' });
+        return;
+    }
+    const validRoles = ['scheduler', 'planner', 'executor', 'reviewer', 'custom', 'bot'];
+    if (!validRoles.includes(role)) {
+        res.status(400).json({ error: `invalid role: ${role}` });
+        return;
+    }
+    const session = agentService.create(req.params.id, role);
+    res.status(201).json(session);
+});
+router.post('/:agentId/stop', (req, res) => {
+    const session = agentService.complete(req.params.id, req.params.agentId);
+    if (!session) {
+        res.status(404).json({ error: 'agent session not found' });
+        return;
+    }
+    res.json(session);
+});
+router.get('/:agentId', (req, res) => {
+    const session = agentService.getById(req.params.id, req.params.agentId);
+    if (!session) {
+        res.status(404).json({ error: 'agent session not found' });
+        return;
+    }
+    res.json(session);
+});
+export default router;
+//# sourceMappingURL=agent.js.map

package/dist/routes/auth.js

@@ -0,0 +1,30 @@
+import { Router } from 'express';
+import { getSecret, setSecret } from '../services/auth-store.js';
+const router = Router();
+router.post('/login', (req, res) => {
+    const { secret } = req.body;
+    const currentSecret = getSecret();
+    if ((secret ?? '') !== currentSecret) {
+        res.status(403).json({ error: 'Invalid secret' });
+        return;
+    }
+    res.json({ ok: true, token: currentSecret });
+});
+router.get('/check', (req, res) => {
+    const currentSecret = getSecret();
+    const auth = req.headers.authorization;
+    const token = auth?.startsWith('Bearer ') ? auth.slice(7) : '';
+    res.json({ authenticated: token === currentSecret, secretSet: currentSecret !== '' });
+});
+router.post('/change-secret', (req, res) => {
+    const { newSecret, currentToken } = req.body;
+    const currentSecret = getSecret();
+    if ((currentToken ?? '') !== currentSecret) {
+        res.status(403).json({ error: 'Unauthorized' });
+        return;
+    }
+    setSecret(newSecret ?? '');
+    res.json({ ok: true });
+});
+export default router;
+//# sourceMappingURL=auth.js.map