688 lines
29 KiB
TypeScript
688 lines
29 KiB
TypeScript
import express, { type Application, type Request, type Response } from 'express';
|
||
import { mkdirSync, writeFileSync } from 'fs';
|
||
import { join } from 'path';
|
||
import { Repository, localTaskRepoName } from '../db/repository.js';
|
||
import type { BrowserSessionRepo } from '../db/browser-session-repo.js';
|
||
import { logger } from '../logger.js';
|
||
import { resolveJobScheduling } from '../scheduling.js';
|
||
import { parseTaskId, validateCreateTaskBody, validateCommentBody, validateFeedbackBody } from './validation.js';
|
||
import { getLocalWorkspacePath, checkTaskOwnership, canViewTask } from './local-api-helpers.js';
|
||
import { jobEventBus, type JobStreamEvent } from './job-events.js';
|
||
|
||
export interface LocalTasksApiOptions {
|
||
repo: Repository;
|
||
worktreeDir?: string;
|
||
generateTitle?: (body: string) => Promise<string>;
|
||
selectPiece?: (body: string, fileNames: string[], userId?: string) => Promise<string>;
|
||
/**
|
||
* Server-side validator for piece names accepted by the
|
||
* /continue endpoint. Returns true if the piece is loadable.
|
||
* When unset, /continue rejects all requests with 500 (misconfiguration).
|
||
*
|
||
* `ownerId` is the task owner's user id; when provided the implementation
|
||
* MUST also check the owner's per-user piece dir so that user-custom pieces
|
||
* are accepted (matching the resolution order the worker uses at run time).
|
||
*/
|
||
pieceExists?: (name: string, ownerId?: string) => boolean;
|
||
/**
|
||
* Optional. When set, accepting browserSessionProfileId on task create
|
||
* verifies the profile belongs to the requesting user. Without it, the
|
||
* field is silently dropped (legacy / no-auth deployments).
|
||
*/
|
||
sessRepo?: BrowserSessionRepo;
|
||
/**
|
||
* Optional. Returns the current upload size limit (MB) for task creation
|
||
* and comment posting. Called per request so config changes take effect
|
||
* without a server restart. Clamped to [1, 1000] MB. Default: 50.
|
||
*/
|
||
getMaxUploadMb?: () => number;
|
||
/**
|
||
* Whether the auth subsystem is wired. When `false` (no-auth single-user
|
||
* deployment) requests carry no `req.user`, so new tasks/jobs are registered
|
||
* under the stable `local` owner instead of NULL — keeping per-task
|
||
* reflection / visibility lookups (which key on owner_id) consistent with the
|
||
* rest of the no-auth path. Defaults to `true` (owner stays req.user.id).
|
||
*/
|
||
authActive?: boolean;
|
||
}
|
||
|
||
export function mountLocalTasksApi(app: Application, opts: LocalTasksApiOptions): void {
|
||
const { repo, worktreeDir, sessRepo } = opts;
|
||
// No-auth single-user mode: register new tasks/jobs under the 'local' owner
|
||
// (the same namespace pieces/memory/reflection use) rather than letting the
|
||
// missing req.user fall through to a NULL owner. In auth mode this is
|
||
// undefined, so `req.user.id ?? noAuthOwner` keeps the real owner.
|
||
const noAuthOwner: string | undefined = (opts.authActive ?? true) ? undefined : 'local';
|
||
|
||
const resolveUploadLimit = (): string => {
|
||
const raw = opts.getMaxUploadMb?.() ?? 50;
|
||
const mb = Number.isFinite(raw) ? Math.max(1, Math.min(1000, Math.floor(raw))) : 50;
|
||
return `${mb}mb`;
|
||
};
|
||
const dynamicJson = () => (req: Request, res: Response, next: express.NextFunction) =>
|
||
express.json({ limit: resolveUploadLimit() })(req, res, next);
|
||
|
||
app.get('/api/local/tasks', async (req: Request, res: Response) => {
|
||
try {
|
||
const viewer = req.user as Express.User | undefined;
|
||
const tasks = await repo.listLocalTasks(viewer ? { viewer } : {});
|
||
res.json({ tasks });
|
||
} catch (err) {
|
||
logger.error(`Local tasks list API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to fetch local tasks' });
|
||
}
|
||
});
|
||
|
||
app.post('/api/local/tasks', dynamicJson(), async (req: Request, res: Response) => {
|
||
try {
|
||
const validation = validateCreateTaskBody(req.body);
|
||
if (!validation.valid) {
|
||
res.status(400).json({ error: validation.error });
|
||
return;
|
||
}
|
||
const body = validation.data;
|
||
|
||
// Visibility extraction + validation
|
||
const rawVisibility = req.body?.visibility ?? 'private';
|
||
if (!['private', 'org', 'public'].includes(rawVisibility)) {
|
||
res.status(400).json({ error: 'invalid visibility' });
|
||
return;
|
||
}
|
||
const visibility = rawVisibility as 'private' | 'org' | 'public';
|
||
const rawScopeOrgId = req.body?.visibilityScopeOrgId;
|
||
const visibilityScopeOrgId: string | null =
|
||
typeof rawScopeOrgId === 'string' && rawScopeOrgId.length > 0 ? rawScopeOrgId : null;
|
||
if (visibility === 'org') {
|
||
const orgIds = (req.user as Express.User | undefined)?.orgIds ?? [];
|
||
if (!visibilityScopeOrgId || !orgIds.includes(visibilityScopeOrgId)) {
|
||
res.status(400).json({ error: 'visibility_scope_org_id must be one of your orgs' });
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Optional browser session profile binding. Owner-scoped check
|
||
// (sessRepo.getProfileById enforces owner_id = req.user.id) prevents
|
||
// user A from binding user B's profile to their task.
|
||
let browserSessionProfileId: number | null = null;
|
||
const rawProfileId = req.body?.browserSessionProfileId;
|
||
if (rawProfileId !== undefined && rawProfileId !== null && rawProfileId !== '') {
|
||
const n = Number(rawProfileId);
|
||
if (!Number.isInteger(n) || n <= 0) {
|
||
res.status(400).json({ error: 'browserSessionProfileId must be a positive integer' });
|
||
return;
|
||
}
|
||
if (sessRepo) {
|
||
const userId = (req.user as Express.User | undefined)?.id;
|
||
if (!userId) {
|
||
res.status(400).json({ error: 'browserSessionProfileId requires an authenticated user' });
|
||
return;
|
||
}
|
||
const owned = sessRepo.getProfileById(n, userId);
|
||
if (!owned) {
|
||
res.status(400).json({ error: 'browser session profile not found or not owned by you' });
|
||
return;
|
||
}
|
||
}
|
||
browserSessionProfileId = n;
|
||
}
|
||
|
||
let taskTitle = (body.title ?? '').trim();
|
||
const rawPiece = (body.piece ?? 'auto').trim();
|
||
const attachmentNames = (body.attachments ?? []).map((a: { name?: string }) => a.name).filter(Boolean) as string[];
|
||
|
||
// タイトル生成と piece 分類を並列実行
|
||
const [generatedTitle, autoSelectedPiece] = await Promise.all([
|
||
// タイトル生成
|
||
(!taskTitle && opts.generateTitle)
|
||
? Promise.race([
|
||
opts.generateTitle(body.body.trim()),
|
||
new Promise<string>((_, reject) => setTimeout(() => reject(new Error('timeout')), 8000)),
|
||
]).catch((e: unknown) => { logger.warn(`Title generation failed: ${e}`); return ''; })
|
||
: Promise.resolve(''),
|
||
// piece 分類（'auto' の場合のみ）; userId を渡し per-user カタログを使用
|
||
(rawPiece === 'auto' && opts.selectPiece)
|
||
? opts.selectPiece(body.body.trim(), attachmentNames, (req.user as Express.User | undefined)?.id).catch((e: unknown) => { logger.warn(`Piece classification failed: ${e}`); return 'chat'; })
|
||
: Promise.resolve(rawPiece),
|
||
]);
|
||
|
||
if (!taskTitle) {
|
||
taskTitle = generatedTitle || body.body.trim().slice(0, 40).replace(/\n/g, ' ');
|
||
}
|
||
const piece = autoSelectedPiece;
|
||
const profile = body.profile ?? 'auto';
|
||
const outputFormat = body.outputFormat ?? 'markdown';
|
||
const askPolicy = body.askPolicy ?? 'low';
|
||
const priority = body.priority ?? 'medium';
|
||
const scheduling = resolveJobScheduling({
|
||
role: profile,
|
||
pieceName: piece,
|
||
instruction: body.body.trim(),
|
||
});
|
||
|
||
// Per-task options (e.g. { mcpDisabled, skillsDisabled })
|
||
const rawOptions = req.body?.options;
|
||
const taskOptions: Record<string, unknown> =
|
||
rawOptions && typeof rawOptions === 'object' && !Array.isArray(rawOptions)
|
||
? rawOptions as Record<string, unknown>
|
||
: {};
|
||
|
||
const task = await repo.createLocalTask({
|
||
title: taskTitle,
|
||
body: body.body.trim(),
|
||
pieceName: piece,
|
||
profile,
|
||
outputFormat,
|
||
askPolicy,
|
||
priority,
|
||
ownerId: req.user?.id ?? noAuthOwner,
|
||
visibility,
|
||
visibilityScopeOrgId: visibility === 'org' ? visibilityScopeOrgId : null,
|
||
browserSessionProfileId,
|
||
options: taskOptions,
|
||
});
|
||
|
||
const workspacePath = getLocalWorkspacePath(worktreeDir, task.id);
|
||
mkdirSync(join(workspacePath, 'input'), { recursive: true });
|
||
mkdirSync(join(workspacePath, 'output'), { recursive: true });
|
||
mkdirSync(join(workspacePath, 'logs'), { recursive: true });
|
||
await repo.updateLocalTask(task.id, { workspacePath });
|
||
|
||
for (const att of body.attachments ?? []) {
|
||
if (!att.name || !att.contentBase64) continue;
|
||
const safeName = att.name.replace(/[\\/]/g, '_');
|
||
writeFileSync(join(workspacePath, 'input', safeName), Buffer.from(att.contentBase64, 'base64'));
|
||
}
|
||
|
||
await repo.addLocalTaskComment(task.id, 'user', body.body.trim(), 'request');
|
||
|
||
const metadataBlock = [
|
||
'---',
|
||
`ui_profile: ${scheduling.role}`,
|
||
`ui_output_format: ${outputFormat}`,
|
||
`ui_ask_policy: ${askPolicy}`,
|
||
`ui_priority: ${priority}`,
|
||
'---',
|
||
].join('\n');
|
||
const instruction = `${taskTitle}\n\n${body.body.trim()}\n\n${metadataBlock}`.trim();
|
||
// Merge task options into job payload so the worker can read them at runtime.
|
||
const hasOptions = Object.keys(taskOptions).length > 0;
|
||
const job = await repo.createJob({
|
||
repo: localTaskRepoName(task.id),
|
||
issueNumber: task.id,
|
||
instruction,
|
||
pieceName: piece,
|
||
role: scheduling.role,
|
||
ownerId: task.ownerId,
|
||
visibility: task.visibility,
|
||
visibilityScopeOrgId: task.visibilityScopeOrgId,
|
||
browserSessionProfileId: task.browserSessionProfileId ?? null,
|
||
payload: hasOptions ? JSON.stringify({ options: taskOptions }) : undefined,
|
||
});
|
||
await repo.addAuditLog(job.id, 'job_queued_local_create', 'local-ui', { taskId: task.id });
|
||
|
||
if (rawPiece === 'auto') {
|
||
await repo.addAuditLog(job.id, 'piece_auto_selected', 'piece-classifier', {
|
||
selectedPiece: piece,
|
||
});
|
||
}
|
||
|
||
const created = await repo.getLocalTask(task.id);
|
||
res.status(201).json({ task: created, jobId: job.id });
|
||
} catch (err) {
|
||
logger.error(`Create local task API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to create local task' });
|
||
}
|
||
});
|
||
|
||
app.get('/api/local/tasks/:taskId', async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!canViewTask(req, res, task)) return;
|
||
res.json({ task });
|
||
} catch (err) {
|
||
logger.error(`Local task detail API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to fetch local task' });
|
||
}
|
||
});
|
||
|
||
app.put('/api/local/tasks/:taskId/feedback', express.json(), async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const validation = validateFeedbackBody(req.body);
|
||
if (!validation.valid) {
|
||
res.status(400).json({ error: validation.error });
|
||
return;
|
||
}
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
await repo.updateFeedback(taskId, validation.data);
|
||
const updated = await repo.getLocalTask(taskId);
|
||
res.json({ task: updated });
|
||
} catch (err) {
|
||
logger.error(`Local task feedback API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to update feedback' });
|
||
}
|
||
});
|
||
|
||
app.put('/api/local/tasks/:taskId/mission', express.json(), async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
|
||
// Partial-replace: only string fields are written. Anything else
|
||
// (null, undefined, non-string) is treated as "leave unchanged".
|
||
// To clear a field, send an empty string.
|
||
const body = (req.body ?? {}) as Record<string, unknown>;
|
||
const patch: Record<string, string> = {};
|
||
for (const key of ['goal', 'done', 'open', 'clarifications'] as const) {
|
||
const v = body[key];
|
||
if (typeof v === 'string') patch[key] = v;
|
||
}
|
||
if (Object.keys(patch).length === 0) {
|
||
res.status(400).json({ error: 'No mission fields provided. Send goal, done, open, or clarifications as strings.' });
|
||
return;
|
||
}
|
||
const merged = await repo.updateMissionBrief(taskId, patch);
|
||
res.json({ missionBrief: merged });
|
||
} catch (err) {
|
||
logger.error(`Local task mission API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to update mission brief' });
|
||
}
|
||
});
|
||
|
||
app.get('/api/local/tasks/:taskId/comments', async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!canViewTask(req, res, task)) return;
|
||
const comments = await repo.listLocalTaskComments(taskId);
|
||
res.json({ comments });
|
||
} catch (err) {
|
||
logger.error(`Local task comments API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to fetch local task comments' });
|
||
}
|
||
});
|
||
|
||
app.post('/api/local/tasks/:taskId/comments', dynamicJson(), async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const commentValidation = validateCommentBody(req.body);
|
||
if (!commentValidation.valid) {
|
||
res.status(400).json({ error: commentValidation.error });
|
||
return;
|
||
}
|
||
const { body, author, attachments } = commentValidation;
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
|
||
// Save attachments to input/
|
||
if (attachments && attachments.length > 0 && task?.workspacePath) {
|
||
const inputDir = join(task.workspacePath, 'input');
|
||
mkdirSync(inputDir, { recursive: true });
|
||
for (const att of attachments) {
|
||
if (!att.name || !att.contentBase64) continue;
|
||
const safeName = att.name.replace(/[\\/]/g, '_');
|
||
writeFileSync(join(inputDir, safeName), Buffer.from(att.contentBase64, 'base64'));
|
||
}
|
||
}
|
||
|
||
const prevJob = await repo.getLatestJobForIssue(localTaskRepoName(taskId), taskId);
|
||
|
||
// running / dispatching / waiting_subtasks 中: コメント保存のみ（agent-loop が注入する）
|
||
const isActive = prevJob && (prevJob.status === 'running' || prevJob.status === 'dispatching' || prevJob.status === 'waiting_subtasks');
|
||
const commentKind = isActive ? 'interjection' : 'comment';
|
||
const comment = await repo.addLocalTaskComment(taskId, author, body, commentKind);
|
||
|
||
if (isActive) {
|
||
logger.info(`[local-tasks-api] interjection: comment ${comment.id} saved for ${prevJob!.status} job ${prevJob!.id} on task ${taskId}`);
|
||
res.status(201).json({ comment, jobId: prevJob!.id, interjection: true });
|
||
return;
|
||
}
|
||
|
||
const askCount = prevJob?.status === 'waiting_human' ? prevJob.askCount : 0;
|
||
const resumeMovement = prevJob?.status === 'waiting_human' ? prevJob.resumeMovement : null;
|
||
|
||
// Build instruction with attachment info
|
||
const savedFileNames = (attachments ?? [])
|
||
.filter(att => att.name && att.contentBase64)
|
||
.map(att => att.name.replace(/[\\/]/g, '_'));
|
||
const instruction = savedFileNames.length > 0
|
||
? `${body}\n\n添付ファイル（input/ に保存済み）: ${savedFileNames.join(', ')}`
|
||
: body;
|
||
|
||
const job = await repo.createJob({
|
||
repo: localTaskRepoName(taskId),
|
||
issueNumber: taskId,
|
||
instruction,
|
||
pieceName: task!.pieceName,
|
||
askCount,
|
||
resumeMovement,
|
||
role: prevJob?.requiredRole,
|
||
ownerId: task!.ownerId,
|
||
visibility: task!.visibility,
|
||
visibilityScopeOrgId: task!.visibilityScopeOrgId,
|
||
browserSessionProfileId: task!.browserSessionProfileId ?? null,
|
||
});
|
||
await repo.addAuditLog(job.id, 'job_queued_local_comment', author, { taskId });
|
||
|
||
res.status(201).json({ comment, jobId: job.id });
|
||
} catch (err) {
|
||
logger.error(`Local task comment create API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to post local task comment' });
|
||
}
|
||
});
|
||
|
||
app.patch('/api/local/tasks/:taskId', express.json(), async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) { res.status(400).json({ error: 'Invalid task ID' }); return; }
|
||
const task = await repo.getLocalTask(taskId, { viewer: req.user as Express.User | undefined });
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
|
||
const updates: { visibility?: 'private' | 'org' | 'public'; visibilityScopeOrgId?: string | null } = {};
|
||
if (req.body.visibility !== undefined) {
|
||
const v = req.body.visibility;
|
||
if (!['private', 'org', 'public'].includes(v)) {
|
||
res.status(400).json({ error: 'invalid visibility' }); return;
|
||
}
|
||
updates.visibility = v;
|
||
}
|
||
if (req.body.visibilityScopeOrgId !== undefined) {
|
||
updates.visibilityScopeOrgId = req.body.visibilityScopeOrgId ?? null;
|
||
}
|
||
if (updates.visibility === 'org') {
|
||
const orgIds = (req.user as Express.User | undefined)?.orgIds ?? [];
|
||
const scopeId = updates.visibilityScopeOrgId ?? task!.visibilityScopeOrgId ?? null;
|
||
if (!scopeId || !orgIds.includes(scopeId)) {
|
||
res.status(400).json({ error: 'visibility_scope_org_id must be one of your orgs' }); return;
|
||
}
|
||
updates.visibilityScopeOrgId = scopeId;
|
||
}
|
||
if (updates.visibility && updates.visibility !== 'org') {
|
||
updates.visibilityScopeOrgId = null;
|
||
}
|
||
await repo.updateLocalTask(taskId, updates);
|
||
const refreshed = await repo.getLocalTask(taskId, { viewer: req.user as Express.User | undefined });
|
||
if ((updates.visibility !== undefined || updates.visibilityScopeOrgId !== undefined) && refreshed) {
|
||
await repo.updateJobsVisibilityForTask(taskId, {
|
||
visibility: refreshed.visibility ?? 'private',
|
||
visibilityScopeOrgId: refreshed.visibilityScopeOrgId ?? null,
|
||
});
|
||
}
|
||
res.json({ task: refreshed });
|
||
} catch (err) {
|
||
logger.error(`Patch local task API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to update task' });
|
||
}
|
||
});
|
||
|
||
app.delete('/api/local/tasks/:taskId', async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const task = await repo.getLocalTask(taskId, { viewer: req.user as Express.User | undefined });
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
await repo.deleteLocalTask(taskId);
|
||
res.json({ ok: true });
|
||
} catch (err) {
|
||
const message = err instanceof Error ? err.message : String(err);
|
||
if (message.includes('has an active job')) {
|
||
res.status(409).json({ error: 'Cannot delete task with running jobs' });
|
||
return;
|
||
}
|
||
logger.error(`Delete local task API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to delete local task' });
|
||
}
|
||
});
|
||
|
||
app.post('/api/local/tasks/:taskId/cancel', async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
const latestJob = await repo.getLatestJobForIssue(localTaskRepoName(taskId), taskId);
|
||
if (!latestJob || !['running', 'dispatching'].includes(latestJob.status)) {
|
||
res.status(404).json({ error: 'No running job found' });
|
||
return;
|
||
}
|
||
const cancelled = repo.requestJobCancel(latestJob.id);
|
||
if (!cancelled) {
|
||
res.status(409).json({ error: 'Job is no longer running' });
|
||
return;
|
||
}
|
||
await repo.addAuditLog(latestJob.id, 'job_cancel_requested', 'local-ui', { taskId });
|
||
logger.info(`Cancel requested for job ${latestJob.id} (task ${taskId})`);
|
||
res.json({ ok: true, jobId: latestJob.id });
|
||
} catch (err) {
|
||
logger.error(`Cancel local task API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to cancel task' });
|
||
}
|
||
});
|
||
|
||
app.post('/api/local/tasks/:taskId/continue', express.json(), async (req: Request, res: Response) => {
|
||
try {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) {
|
||
res.status(400).json({ error: 'Invalid task ID' });
|
||
return;
|
||
}
|
||
|
||
const piece = typeof req.body?.piece === 'string' ? req.body.piece.trim() : '';
|
||
const instruction = typeof req.body?.instruction === 'string' ? req.body.instruction : '';
|
||
if (!piece) {
|
||
res.status(400).json({ error: 'piece_required' });
|
||
return;
|
||
}
|
||
if (!instruction.trim()) {
|
||
res.status(400).json({ error: 'instruction_required' });
|
||
return;
|
||
}
|
||
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : undefined);
|
||
if (!checkTaskOwnership(req, res, task)) return;
|
||
|
||
// Piece existence check (server-side; UI dropdown is best-effort).
|
||
if (!opts.pieceExists) {
|
||
logger.error('[local-tasks-api] /continue invoked but pieceExists option not configured');
|
||
res.status(500).json({ error: 'piece_validation_unavailable' });
|
||
return;
|
||
}
|
||
if (!opts.pieceExists(piece, task?.ownerId ?? undefined)) {
|
||
res.status(400).json({ error: 'piece_not_found', piece });
|
||
return;
|
||
}
|
||
|
||
const prevJob = await repo.getLatestJobForIssue(localTaskRepoName(taskId), taskId);
|
||
if (!prevJob) {
|
||
res.status(409).json({ error: 'no_previous_job' });
|
||
return;
|
||
}
|
||
// jobs.status CHECK には 'aborted' が無い (worker が abort 結果を 'failed' に集約するため)。
|
||
// 'waiting_subtasks' は子 job 待機の中間状態で、そこから別 piece に切り替えると孤立するので除外。
|
||
const TERMINAL: ReadonlyArray<string> = ['succeeded', 'failed', 'waiting_human', 'cancelled'];
|
||
if (!TERMINAL.includes(prevJob.status)) {
|
||
res.status(409).json({ error: 'job_in_progress', currentStatus: prevJob.status });
|
||
return;
|
||
}
|
||
|
||
const job = await repo.createJob({
|
||
repo: localTaskRepoName(taskId),
|
||
issueNumber: taskId,
|
||
instruction: instruction.trim(),
|
||
pieceName: piece,
|
||
continuedFromJobId: prevJob.id,
|
||
ownerId: task!.ownerId,
|
||
role: prevJob.requiredRole,
|
||
visibility: task!.visibility,
|
||
visibilityScopeOrgId: task!.visibilityScopeOrgId,
|
||
browserSessionProfileId: task!.browserSessionProfileId ?? null,
|
||
});
|
||
|
||
await repo.updateLocalTask(taskId, { pieceName: piece });
|
||
|
||
// Surface the handoff in the timeline so the user (and the LLM, when
|
||
// it later inspects task comments) can see when piece switches happened.
|
||
await repo.addLocalTaskComment(
|
||
taskId,
|
||
'system',
|
||
`🔄 Continued: piece="${prevJob.pieceName}" → piece="${piece}"`,
|
||
'handoff',
|
||
);
|
||
|
||
await repo.addAuditLog(job.id, 'job_queued_local_continue', 'local-ui', {
|
||
taskId,
|
||
fromPiece: prevJob.pieceName,
|
||
toPiece: piece,
|
||
prevJobId: prevJob.id,
|
||
});
|
||
|
||
res.status(201).json({ jobId: job.id });
|
||
} catch (err) {
|
||
logger.error(`Local task continue API error: ${err}`);
|
||
res.status(500).json({ error: 'Failed to continue task' });
|
||
}
|
||
});
|
||
|
||
// ── SSE stream: real-time job events ──────────────────────────────────────
|
||
app.get('/api/local/tasks/:taskId/stream', async (req: Request, res: Response) => {
|
||
const taskId = parseTaskId(req.params.taskId);
|
||
if (taskId === null) { res.status(400).json({ error: 'invalid taskId' }); return; }
|
||
|
||
try {
|
||
const viewer = req.user as Express.User | undefined;
|
||
const task = await repo.getLocalTask(taskId, viewer ? { viewer } : {});
|
||
if (!task) { res.status(404).json({ error: 'task not found' }); return; }
|
||
|
||
const runningJob = task.latestJob;
|
||
if (!runningJob || (runningJob.status !== 'running' && runningJob.status !== 'dispatching')) {
|
||
res.status(204).end();
|
||
return;
|
||
}
|
||
const jobId = runningJob.id;
|
||
|
||
res.setHeader('Content-Type', 'text/event-stream');
|
||
res.setHeader('Cache-Control', 'no-store');
|
||
res.setHeader('Connection', 'keep-alive');
|
||
res.setHeader('X-Accel-Buffering', 'no');
|
||
res.flushHeaders();
|
||
|
||
// Text delta batching (50ms flush)
|
||
let textBuf = '';
|
||
let flushTimer: ReturnType<typeof setTimeout> | null = null;
|
||
const TEXT_FLUSH_MS = 50;
|
||
|
||
// Tool-call argument delta batching, keyed by callId (50ms flush).
|
||
const toolBuf = new Map<string, { name: string; chunk: string }>();
|
||
let toolFlushTimer: ReturnType<typeof setTimeout> | null = null;
|
||
|
||
const flushText = () => {
|
||
if (textBuf) {
|
||
const data = JSON.stringify({ type: 'text_delta', text: textBuf });
|
||
res.write(`data: ${data}\n\n`);
|
||
textBuf = '';
|
||
}
|
||
flushTimer = null;
|
||
};
|
||
|
||
const flushToolDeltas = () => {
|
||
for (const [callId, { name, chunk }] of toolBuf) {
|
||
if (res.writableEnded) break;
|
||
res.write(`data: ${JSON.stringify({ type: 'tool_use_delta', callId, name, chunk })}\n\n`);
|
||
}
|
||
toolBuf.clear();
|
||
toolFlushTimer = null;
|
||
};
|
||
|
||
const handler = (event: JobStreamEvent) => {
|
||
if (res.writableEnded) return;
|
||
if (event.type === 'text') {
|
||
textBuf += event.text ?? '';
|
||
if (!flushTimer) flushTimer = setTimeout(flushText, TEXT_FLUSH_MS);
|
||
return;
|
||
}
|
||
if (event.type === 'tool_use_delta') {
|
||
const callId = event.callId ?? '';
|
||
// chunk is a full snapshot of args-so-far; keep the LATEST per
|
||
// callId (replace, not append) so each flush sends the newest
|
||
// complete prefix. Coalesces many snapshots into one per 50ms.
|
||
toolBuf.set(callId, {
|
||
name: event.name ?? toolBuf.get(callId)?.name ?? '',
|
||
chunk: event.chunk ?? '',
|
||
});
|
||
if (!toolFlushTimer) toolFlushTimer = setTimeout(flushToolDeltas, TEXT_FLUSH_MS);
|
||
return;
|
||
}
|
||
// Flush pending text + tool deltas before non-streaming events
|
||
if (textBuf) flushText();
|
||
if (toolBuf.size) flushToolDeltas();
|
||
if (event.type === 'prompt_progress') {
|
||
const effective = (event.processed ?? 0) - (event.cache ?? 0);
|
||
const effectiveTotal = (event.total ?? 0) - (event.cache ?? 0);
|
||
const percent = effectiveTotal > 0 ? Math.round(effective / effectiveTotal * 100) : 0;
|
||
res.write(`data: ${JSON.stringify({ type: 'prompt_progress', percent, processed: event.processed, total: event.total, cache: event.cache, timeMs: event.timeMs })}\n\n`);
|
||
} else if (event.type === 'done') {
|
||
res.write(`data: ${JSON.stringify({ type: 'done' })}\n\n`);
|
||
cleanup();
|
||
res.end();
|
||
} else {
|
||
res.write(`data: ${JSON.stringify(event)}\n\n`);
|
||
}
|
||
};
|
||
|
||
// Heartbeat to keep connection alive
|
||
const heartbeat = setInterval(() => {
|
||
if (!res.writableEnded) res.write(': heartbeat\n\n');
|
||
}, 15_000);
|
||
|
||
const cleanup = () => {
|
||
jobEventBus.offJob(jobId, handler);
|
||
clearInterval(heartbeat);
|
||
if (flushTimer) { clearTimeout(flushTimer); flushText(); }
|
||
if (toolFlushTimer) { clearTimeout(toolFlushTimer); flushToolDeltas(); }
|
||
};
|
||
|
||
jobEventBus.onJob(jobId, handler);
|
||
req.on('close', cleanup);
|
||
} catch (err) {
|
||
logger.error(`Local task stream API error: ${err}`);
|
||
if (!res.headersSent) res.status(500).json({ error: 'stream failed' });
|
||
}
|
||
});
|
||
}
|