@straiffi/archon 1.4.6 → 1.4.8

package/dist/server/index.js

@@ -10,7 +10,7 @@ import { adjectives, animals, uniqueNamesGenerator } from 'unique-names-generato
 import db from './db.js';
 import { deleteChatSession, getChatSession, listChatSessions, updateChatSessionMode } from './lib/chats.js';
 import { deleteSpecSession, getCreatedTicketIdsForSnapshot, getSpecSession, getSpecSnapshot, listSpecSessions } from './lib/specs.js';
-import { createChatAttachment, createSpecAttachment, deleteChatAttachment, deleteSpecSessionAttachment, getChatAttachmentById, getChatAttachmentForSession, getChatAttachmentLinkedMessageId, getSpecAttachmentForSession, getSpecAttachmentLinkedMessageId, MAX_CHAT_ATTACHMENTS_PER_TURN, MAX_CHAT_ATTACHMENT_SIZE_BYTES, MAX_SPEC_ATTACHMENTS_PER_TURN, MAX_SPEC_ATTACHMENT_SIZE_BYTES, readChatAttachmentContent, readSpecAttachmentContent, validateImageAttachment, } from './lib/attachments.js';
+import { createChatAttachment, createSpecAttachment, getAttachmentById, deleteChatAttachment, deleteSpecSessionAttachment, getChatAttachmentForSession, getChatAttachmentLinkedMessageId, getSpecAttachmentForSession, getSpecAttachmentLinkedMessageId, MAX_CHAT_ATTACHMENTS_PER_TURN, MAX_CHAT_ATTACHMENT_SIZE_BYTES, MAX_SPEC_ATTACHMENTS_PER_TURN, MAX_SPEC_ATTACHMENT_SIZE_BYTES, readChatAttachmentContent, readSpecAttachmentContent, validateImageAttachment, } from './lib/attachments.js';
 import { createProjectChatSession, resolveChatMode, resolveChatTool, stopProjectChatSessionResponse, submitProjectChatSessionMessage, } from './lib/chatOperations.js';
 import { createProjectSpecSession, deleteProjectSpecSession, stopProjectSpecSessionResponse, submitProjectSpecSessionMessage, updateProjectSpecSessionMode, } from './lib/specOperations.js';
 import { buildProjectSpecReviewRevisionDraft, getProjectSpecReviewFindings, startProjectSpecReview, stopProjectSpecReview, } from './lib/specReviewOperations.js';
@@ -49,8 +49,11 @@ import { shutdownRealtimeServer } from './lib/shutdown.js';
 import { resolveClientBuildPaths, shouldServeClientApp, STATIC_CLIENT_DIRECTORY_OPTIONS, STATIC_CLIENT_INDEX_OPTIONS, } from './lib/staticClient.js';
 import { deleteIntegrationConnection, getGitHubConnectionConfig, getJiraConnectionConfig, listIntegrationConnections, upsertIntegrationConnection, } from './lib/integrations/index.js';
 import { createGitHubPullRequest, createOrFindGitHubPullRequest, findOpenGitHubPullRequest, findOpenGitHubPullRequestByHeadBranch, getGitHubPullRequestComments, getGitHubPullRequestReviews, getGitHubPullRequest, GitHubApiError, hasGitHubRemoteBranch, resolveGitHubRepository, validateGitHubConnection, } from './lib/integrations/github.js';
-import { importJiraIssue, JiraApiError, validateJiraConnection } from './lib/integrations/jira.js';
-import { importGitHubIssue } from './lib/integrations/github-issues.js';
+import { importJiraIssue, JiraApiError, prepareJiraIssueImport, validateJiraConnection } from './lib/integrations/jira.js';
+import { importGitHubIssue, prepareGitHubIssueImport } from './lib/integrations/github-issues.js';
+import { buildImportedIssueSessionTitle, importProviderHostedIssueImages } from './lib/integrations/importedIssueImages.js';
+import { dispatchGitHubWorkflow, getGitHubWorkflowDispatchConfig, getGitHubWorkflowRun, getGitHubWorkflowRunJobs, listGitHubWorkflows, listGitHubWorkflowRuns, } from './lib/integrations/githubActions.js';
+import { clearAllGitHubActionsSessions, getActiveTrackedRunCount, getTrackedGitHubActionsRuns, trackGitHubActionsRun, } from './lib/integrations/githubActionsSessions.js';
 import { PlanningReferenceError, resolveExternalPlanningDescription } from './lib/integrations/planning.js';
 import { refreshIfNeeded as refreshAssignedIssues, clearCachedAssignedIssues } from './lib/integrations/assignedIssuesCache.js';
 import { buildCommitMessagePrompt, normalizeGeneratedCommitMessage } from './lib/commitMessage.js';
@@ -2066,7 +2069,7 @@ app.post('/projects/:id/chat-sessions/:sessionId/attachments', (req, res) => {
         }
         catch (uploadError) {
             for (const attachmentId of createdAttachmentIds) {
-                const attachment = getChatAttachmentById(attachmentId);
+                const attachment = getAttachmentById(attachmentId);
                 if (!attachment) {
                     continue;
                 }
@@ -2351,7 +2354,7 @@ app.post('/projects/:id/spec-sessions/:sessionId/attachments', (req, res) => {
         }
         catch (uploadError) {
             for (const attachmentId of createdAttachmentIds) {
-                const attachment = getChatAttachmentById(attachmentId);
+                const attachment = getAttachmentById(attachmentId);
                 if (!attachment) {
                     continue;
                 }
@@ -3578,6 +3581,76 @@ app.get('/integrations', (req, res) => {
     }
     return res.json({ connections: listIntegrationConnections(result.project.id) });
 });
+const NOOP_BROADCASTER = {
+    emit: () => undefined,
+};
+const buildSpecImportSessionPayload = (payload, draft) => {
+    return {
+        tool: payload?.tool,
+        mode: payload?.mode,
+        model: payload?.model,
+        variant: payload?.variant,
+        skills: payload?.skills,
+        title: buildImportedIssueSessionTitle(draft),
+        external_source: draft.external_source,
+    };
+};
+const prepareSpecImportResponse = async ({ projectId, payload, preparedDraft, importOptions, broadcaster, }) => {
+    const draft = {
+        title: preparedDraft.title,
+        description: preparedDraft.description,
+        external_source: preparedDraft.external_source,
+    };
+    const imported = await importProviderHostedIssueImages({
+        ...importOptions,
+        draft,
+        imageCandidates: preparedDraft.image_candidates,
+    });
+    if (imported.importedImages.length === 0) {
+        return {
+            draft,
+            prompt_text: imported.promptText,
+            external_source: draft.external_source,
+            spec_session: null,
+            imported_attachments: [],
+            import_notice: imported.notice,
+        };
+    }
+    const createResult = createProjectSpecSession({
+        projectId,
+        payload: buildSpecImportSessionPayload(payload, draft),
+        broadcaster: NOOP_BROADCASTER,
+    });
+    if (!createResult.ok) {
+        throw new HttpError(createResult.status, createResult.error);
+    }
+    if (!createResult.value) {
+        throw new Error('Unable to create the imported spec session.');
+    }
+    const specSession = createResult.value;
+    try {
+        const importedAttachments = imported.importedImages.map(image => createSpecAttachment({
+            specSessionId: specSession.id,
+            originalName: image.originalName,
+            mimeType: image.mimeType,
+            buffer: image.buffer,
+            projectId,
+        }));
+        broadcaster.emit('spec-session:created', specSession);
+        return {
+            draft,
+            prompt_text: imported.promptText,
+            external_source: draft.external_source,
+            spec_session: specSession,
+            imported_attachments: importedAttachments,
+            import_notice: imported.notice,
+        };
+    }
+    catch (error) {
+        deleteSpecSession(specSession.id);
+        throw error;
+    }
+};
 app.post('/integrations/github/connect', async (req, res) => {
     const result = getRequiredProject(req);
     if ('error' in result) {
@@ -3749,6 +3822,77 @@ app.post('/integrations/jira/resolve/issue', async (req, res) => {
         return res.status(500).json({ error: getErrorMessage(error) || 'Unable to import the Jira issue.' });
     }
 });
+app.post('/integrations/jira/prepare-spec-import', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const jiraConfig = getJiraConnectionConfig(result.project.id);
+    if (!jiraConfig) {
+        return res.status(400).json({ error: 'Jira is not connected for this project.' });
+    }
+    const issue = asTrimmedString(req.body?.issue);
+    if (!issue) {
+        return res.status(400).json({ error: 'issue is required' });
+    }
+    try {
+        const prepared = await prepareJiraIssueImport(jiraConfig, issue);
+        const response = await prepareSpecImportResponse({
+            projectId: result.project.id,
+            payload: req.body,
+            preparedDraft: prepared,
+            importOptions: { provider: 'jira', config: jiraConfig },
+            broadcaster: io,
+        });
+        return res.json(response);
+    }
+    catch (error) {
+        console.warn(`[integrations] jira spec import failed project=${result.project.id} issue=${issue}`, error);
+        if (error instanceof JiraApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        if (error instanceof HttpError) {
+            return res.status(error.status).json({ error: error.message });
+        }
+        return res.status(500).json({ error: getErrorMessage(error) || 'Unable to prepare the Jira issue for spec import.' });
+    }
+});
+app.post('/integrations/jira/prepare/spec-import', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const jiraConfig = getJiraConnectionConfig(result.project.id);
+    if (!jiraConfig) {
+        return res.status(400).json({ error: 'Jira is not connected for this project.' });
+    }
+    const issue = asTrimmedString(req.body?.issue);
+    if (!issue) {
+        return res.status(400).json({ error: 'issue is required' });
+    }
+    console.info(`[integrations] jira prepare spec import project=${result.project.id} issue=${issue}`);
+    try {
+        const prepared = await prepareJiraIssueImport(jiraConfig, issue);
+        const response = await prepareSpecImportResponse({
+            projectId: result.project.id,
+            payload: req.body,
+            preparedDraft: prepared,
+            importOptions: { provider: 'jira', config: jiraConfig },
+            broadcaster: io,
+        });
+        return res.json(response);
+    }
+    catch (error) {
+        console.warn(`[integrations] jira prepare spec import failed project=${result.project.id} issue=${issue}`, error);
+        if (error instanceof JiraApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        if (error instanceof HttpError) {
+            return res.status(error.status).json({ error: error.message });
+        }
+        return res.status(500).json({ error: getErrorMessage(error) || 'Unable to prepare the Jira issue for spec import.' });
+    }
+});
 app.post('/integrations/github/resolve/issue', async (req, res) => {
     const result = getRequiredProject(req);
     if ('error' in result) {
@@ -3778,6 +3922,265 @@ app.post('/integrations/github/resolve/issue', async (req, res) => {
         return res.status(500).json({ error: getErrorMessage(error) || 'Unable to import the GitHub issue.' });
     }
 });
+app.post('/integrations/github/prepare-spec-import', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    const issue = asTrimmedString(req.body?.issue);
+    if (!issue) {
+        return res.status(400).json({ error: 'issue is required' });
+    }
+    try {
+        const prepared = await prepareGitHubIssueImport(githubConfig, issue);
+        const response = await prepareSpecImportResponse({
+            projectId: result.project.id,
+            payload: req.body,
+            preparedDraft: prepared,
+            importOptions: { provider: 'github', config: githubConfig },
+            broadcaster: io,
+        });
+        return res.json(response);
+    }
+    catch (error) {
+        console.warn(`[integrations] github spec import failed project=${result.project.id} issue=${issue}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        if (error instanceof HttpError) {
+            return res.status(error.status).json({ error: error.message });
+        }
+        return res.status(500).json({ error: getErrorMessage(error) || 'Unable to prepare the GitHub issue for spec import.' });
+    }
+});
+app.post('/integrations/github/prepare/spec-import', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    const issue = asTrimmedString(req.body?.issue);
+    if (!issue) {
+        return res.status(400).json({ error: 'issue is required' });
+    }
+    console.info(`[integrations] github prepare spec import project=${result.project.id} issue=${issue}`);
+    try {
+        const prepared = await prepareGitHubIssueImport(githubConfig, issue);
+        const response = await prepareSpecImportResponse({
+            projectId: result.project.id,
+            payload: req.body,
+            preparedDraft: prepared,
+            importOptions: { provider: 'github', config: githubConfig },
+            broadcaster: io,
+        });
+        return res.json(response);
+    }
+    catch (error) {
+        console.warn(`[integrations] github prepare spec import failed project=${result.project.id} issue=${issue}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        if (error instanceof HttpError) {
+            return res.status(error.status).json({ error: error.message });
+        }
+        return res.status(500).json({ error: getErrorMessage(error) || 'Unable to prepare the GitHub issue for spec import.' });
+    }
+});
+app.get('/integrations/github/actions/workflows', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    try {
+        const workflows = await listGitHubWorkflows(githubConfig);
+        return res.json({ workflows });
+    }
+    catch (error) {
+        console.warn(`[integrations] github actions workflows failed project=${result.project.id}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        return res.status(502).json({ error: 'Unable to load GitHub Actions workflows right now.' });
+    }
+});
+app.get('/integrations/github/actions/workflows/:id/inputs', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    const workflowIdParam = asTrimmedString(req.params.id);
+    const workflowPath = asTrimmedString(req.query.path);
+    if (!workflowPath) {
+        return res.status(400).json({ error: 'path query parameter is required' });
+    }
+    try {
+        const workflows = await listGitHubWorkflows(githubConfig);
+        const workflow = workflows.find(candidate => String(candidate.id) === workflowIdParam);
+        if (!workflow) {
+            return res.status(404).json({ error: 'GitHub Actions workflow not found.' });
+        }
+        const dispatchConfig = await getGitHubWorkflowDispatchConfig(githubConfig, workflowPath);
+        return res.json({ inputs: dispatchConfig.inputs, dispatchable: dispatchConfig.dispatchable });
+    }
+    catch (error) {
+        console.warn(`[integrations] github actions inputs failed project=${result.project.id} workflow=${workflowIdParam}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        return res.status(502).json({ error: 'Unable to load the workflow inputs right now.' });
+    }
+});
+app.post('/integrations/github/actions/workflows/:id/dispatch', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    const workflowIdParam = asTrimmedString(req.params.id);
+    const workflowId = Number(workflowIdParam);
+    if (!workflowId || !Number.isFinite(workflowId)) {
+        return res.status(400).json({ error: 'workflow id must be a number' });
+    }
+    const ref = asTrimmedString(req.body?.ref);
+    if (!ref) {
+        return res.status(400).json({ error: 'ref is required' });
+    }
+    const rawInputs = req.body?.inputs;
+    const inputs = {};
+    if (rawInputs && typeof rawInputs === 'object' && !Array.isArray(rawInputs)) {
+        for (const [key, value] of Object.entries(rawInputs)) {
+            if (typeof value === 'string' || typeof value === 'boolean') {
+                inputs[key] = value;
+            }
+            else if (typeof value === 'number') {
+                inputs[key] = String(value);
+            }
+        }
+    }
+    console.info(`[integrations] github actions dispatch project=${result.project.id} workflow=${workflowId} ref=${ref}`);
+    try {
+        const dispatchedAt = Date.now();
+        await dispatchGitHubWorkflow(githubConfig, workflowId, { ref, inputs });
+        const trackedRun = trackGitHubActionsRun({
+            io,
+            projectId: result.project.id,
+            workflowId,
+            config: githubConfig,
+            dispatchedAt,
+        });
+        return res.status(202).json({ tracking_key: trackedRun.tracking_key, dispatched: true });
+    }
+    catch (error) {
+        console.warn(`[integrations] github actions dispatch failed project=${result.project.id} workflow=${workflowId}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        return res.status(502).json({ error: 'Unable to dispatch the workflow right now.' });
+    }
+});
+app.get('/integrations/github/actions/runs', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    try {
+        const [recentRuns, trackedRuns] = await Promise.all([
+            listGitHubWorkflowRuns(githubConfig).catch(error => {
+                console.warn(`[integrations] github actions runs list failed project=${result.project.id}`, error);
+                return [];
+            }),
+            Promise.resolve(getTrackedGitHubActionsRuns(result.project.id)),
+        ]);
+        const trackedByRunId = new Map();
+        for (const tracked of trackedRuns) {
+            if (tracked.run) {
+                trackedByRunId.set(tracked.run.id, tracked);
+            }
+        }
+        const recentById = new Map(recentRuns.map(run => [run.id, run]));
+        const mergedRecent = recentRuns.map(run => trackedByRunId.get(run.id)?.run ?? run);
+        const trackedOnly = trackedRuns
+            .map(tracked => tracked.run)
+            .filter((run) => Boolean(run) && !recentById.has(run.id));
+        const seenRunIds = new Set();
+        const runs = [...trackedOnly, ...mergedRecent].filter(run => {
+            if (seenRunIds.has(run.id)) {
+                return false;
+            }
+            seenRunIds.add(run.id);
+            return true;
+        });
+        return res.json({ runs, tracked_runs: trackedRuns });
+    }
+    catch (error) {
+        console.warn(`[integrations] github actions runs failed project=${result.project.id}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        return res.status(502).json({ error: 'Unable to load GitHub Actions runs right now.' });
+    }
+});
+app.get('/integrations/github/actions/active-count', (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    return res.json({ activeCount: getActiveTrackedRunCount(result.project.id) });
+});
+app.get('/integrations/github/actions/runs/:id', async (req, res) => {
+    const result = getRequiredProject(req);
+    if ('error' in result) {
+        return res.status(400).json({ error: result.error });
+    }
+    const githubConfig = getGitHubConnectionConfig(result.project.id);
+    if (!githubConfig) {
+        return res.status(400).json({ error: 'GitHub is not connected for this project.' });
+    }
+    const runId = Number(asTrimmedString(req.params.id));
+    if (!runId || !Number.isFinite(runId)) {
+        return res.status(400).json({ error: 'run id must be a number' });
+    }
+    try {
+        const [run, jobs] = await Promise.all([
+            getGitHubWorkflowRun(githubConfig, runId),
+            getGitHubWorkflowRunJobs(githubConfig, runId),
+        ]);
+        return res.json({ run: { ...run, jobs } });
+    }
+    catch (error) {
+        console.warn(`[integrations] github actions run failed project=${result.project.id} run=${runId}`, error);
+        if (error instanceof GitHubApiError) {
+            return res.status(error.status).json({ error: error.publicMessage });
+        }
+        return res.status(502).json({ error: 'Unable to load the GitHub Actions run right now.' });
+    }
+});
 const ASSIGNED_ISSUES_CACHE_TTL_MS = 60 * 1000;
 app.get('/integrations/assigned', async (req, res) => {
     const result = getRequiredProject(req);
@@ -6052,6 +6455,7 @@ export const startServer = ({ port = DEFAULT_PORT, host } = {}) => {
 export const shutdownServer = async (signal) => {
     await stopMobileAccess();
     await clearAllTestSessions(io);
+    await clearAllGitHubActionsSessions();
     await shutdownRealtimeServer({
         signal,
         io,