refactor: package code organization wave 11 (#2333)
## Summary Wave 11 of package code organization (continues #2328 / wave 10), after syncing main into the wave10 stack. ### Peels | New module | Parent | |---|---| | `app/api/event-source.ts` | resilient `EventSource` reconnect + pagehide cleanup | | `app/api/chat.ts` | chat sessions / rooms / streaming | | `app/api/projects.ts` | multi-project management client | | `app/api/agents.ts` | agent CRUD / soul / memory | | `app/api/workflows.ts` | workflow definition client | | `app/api/scheduling.ts` | automations + routines | | `app/api/ai-text.ts` | text refine / import translate / subtasks | | `app/api/ai-sessions.ts` | AI / planning session client + `startKeepAlive` | | `app/api/research.ts` | research + evals client | | `task-store/branch-and-pr-entities.ts` | rename of `remaining-ops-6` | Public paths stay stable via `legacy.ts` re-exports (`app/api.ts` → `legacy`). ### LOC - `legacy.ts` ~8921 → ~5670 ### Shims - `legacy.ts` → peels above (delete-when: dashboard imports domain modules) - `remaining-ops-6` → `branch-and-pr-entities` (rename complete) ## Test plan - [x] eslint on peeled API modules + legacy - [x] dashboard app typecheck (`app/api/*` clean) - [x] core typecheck - [x] `plugin-setup-api` tests - [ ] CI merge gate <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * Expanded dashboard APIs for agents, AI sessions, chat rooms/sessions, research runs, projects, workflows, routines/automations, and scheduling. * Added AI text refinement/translation, planning title regeneration, and streamed subtask breakdown with task creation. * Introduced resilient server-sent-events streaming for chat and other live updates. * Added workflow export/import and workflow design support, plus scripts and workflow configuration controls. * Added research export and ability to attach research outputs to tasks. * **Enhancements** * Missions support clearing an auto-merge override back to project defaults. * Subtasks can now include an optional priority when creating tasks. <!-- end of auto-generated comment: release notes by coderabbit.ai -->
This commit is contained in:
gsxdsm
@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
|
||||
import {
|
||||
claimNextToolFailureRetryImpl,
|
||||
markToolFailureRetryExhaustedAuditImpl,
|
||||
} from "../task-store/remaining-ops-6.js";
|
||||
} from "../task-store/branch-and-pr-entities.js";
|
||||
|
||||
describe("executor tool-failure retry compatibility backend (FN-7996)", () => {
|
||||
it("preserves legacy terminal parking when no PostgreSQL claim store is available", async () => {
|
||||
|
||||
@@ -23,7 +23,7 @@ import {
|
||||
type SharedPgTaskStoreHarness,
|
||||
} from "../../__test-utils__/pg-test-harness.js";
|
||||
import type { AsyncDataLayer } from "../../postgres/data-layer.js";
|
||||
import { getWorkflowSettingsProjectIdImpl } from "../../task-store/remaining-ops-6.js";
|
||||
import { getWorkflowSettingsProjectIdImpl } from "../../task-store/branch-and-pr-entities.js";
|
||||
import { resolveEffectiveSettingsById } from "../../workflow-settings-resolver.js";
|
||||
import type { TaskStore } from "../../store.js";
|
||||
import * as schema from "../../postgres/schema/index.js";
|
||||
|
||||
@@ -99,11 +99,11 @@ import { pgRowToTaskRow as pgRowToTaskRowExternal, rowToTask as rowToTaskExterna
|
||||
import { moveTaskImpl, handoffToReviewImpl, moveTaskInternalImpl } from "./task-store/moves.js";
|
||||
import { recordGoalCitationsImpl, insertTaskWithFtsRecoveryImpl2, assertTaskIdAvailableImpl, atomicWriteTaskJsonImpl2, createTaskWithDistributedReservationImpl, toStoredWorkflowStepImpl, ensureWorkflowStepForTemplateImpl, resolveEnabledWorkflowStepsImpl, setTaskBranchGroupImpl, getTaskColumnsImpl, prepareWorkflowMovePolicyPreflightImpl, updateTaskCustomFieldsImpl, listWorkflowPromptOverridesForProjectImpl, listWorkflowWorkItemsForTaskImpl, listDueWorkflowWorkItemsImpl, rewriteBlockedByResidueDependentsForRemovalImpl, getAllDocumentsImpl, deleteWorkflowStepImpl, toWorkflowDefinitionImpl, materializeDefaultWorkflowStepsImpl, reconcileTaskCustomFieldsForSchemaImpl, getTaskMovedCountsByDayImpl, getGoalStoreImpl, upsertTaskCommitAssociationImpl } from "./task-store/remaining-ops-4.js";
|
||||
import { applyLegacyWorkflowStepOverridesImpl, archiveDbImpl, assertNoDependencyCycleImpl, atomicCreateTaskJsonImpl, buildActiveTaskDependencyLookupImpl, buildArchivedAgentLogFieldsImpl, buildTaskIdIntegrityFallbackReportImpl, createBranchGroupImpl, dbImpl, detectAndCacheTaskIdIntegrityReportImpl, findLiveDependentsImpl, findLiveLineageChildrenImpl, getLegacyWorkflowStepSnapshotImpl, getMalformedTaskMetadataReasonImpl, getMergeQueuedTaskIdsAsyncImpl, insertRunAuditEventRowImpl, insertTaskImpl, invokeTaskCreatedHookImpl, isTaskArchivedImpl, isTaskIdPresentInArchivedTasksTableImpl, logTaskCreateConflictImpl, maybeResolveTombstonedTaskIdImpl, mergeTaskIdIntegrityReportsImpl, optionalGroupIdSetImpl, patchTaskRowInTransactionImpl, readConfigFastImpl, readConfigImpl, readPromptForArchiveImpl, readTaskFromDbImpl, reconcileDistributedTaskIdStateOnOpenImpl, recordActivityFromListenerImpl, recordDependencyCycleRejectedAuditImpl, refreshTaskIdIntegrityReportImpl, resolveLocalNodeIdForTaskAllocationImpl, runTaskFtsWriteWithRecoveryImpl, scanAndRecordCitationsImpl, taskIdExistsAnywhereImpl, throwSoftDeletedWriteBlockedImpl, toBuiltInWorkflowStepImpl, trackDeferredTaskCreatedWorkImpl, upsertTaskImpl, withConfigLockImpl, withTaskLockImpl, withWorktreeAllocationLockImpl } from "./task-store/remaining-ops-5.js";
|
||||
import { claimNextToolFailureRetryImpl, createTaskVerificationRequestImpl, claimTaskVerificationRequestImpl, finishTaskVerificationRequestImpl, clearNearDuplicateReferencesToFailSoftImpl, clearWorkflowRunStepInstancesAsyncImpl, clearWorkflowRunStepInstancesImpl, computeMovedSettingsTargetWorkflowIdsImpl, ensureBranchGroupForSourceImpl, ensurePrEntityForSourceImpl, findRecentTasksByContentFingerprintImpl, getActiveMergingTaskImpl, getActivePrEntityBySourceImpl, getBranchGroupByBranchNameImpl, getBranchGroupBySourceImpl, getBranchGroupImpl, getBranchProgressByTaskImpl, getMutationsForRunImpl, getPrEntityByNumberImpl, getPrEntityImpl, getPrThreadStateImpl, getTasksByAssignedAgentImpl, getWorkflowPromptOverridesAsyncImpl, getWorkflowSettingValuesAsyncImpl, getWorkflowSettingValuesImpl, getWorkflowSettingsProjectIdImpl, getWorkflowWorkItemImpl, insertCompletionHandoffWorkflowWorkAuditImpl, listActivePrEntitiesImpl, listBranchGroupsImpl, listPrThreadStatesImpl, listTasksByBranchGroupImpl, listWorkflowSettingValuesForProjectImpl, loadWorkflowRunBranchesImpl, loadWorkflowRunStepInstancesAsyncImpl, loadWorkflowRunStepInstancesImpl, markToolFailureRetryExhaustedAuditImpl, mergeCustomFieldPatchImpl, normalizeMergeRequestStateImpl, normalizeWorkflowWorkItemKindImpl, normalizeWorkflowWorkItemStateImpl, parseWorkflowPromptOverrideJsonImpl, recordPrThreadOutcomeImpl, resetAllStepsToPendingImpl, resetPromptCheckboxesImpl, resolveWorkflowMoveActorImpl, resolveWorkflowSettingDeclarationsImpl, saveWorkflowRunStepInstanceAsyncImpl, saveWorkflowRunStepInstanceImpl, transitionMergeRequestStateImpl, transitionWorkflowWorkItemSyncImpl, updateTaskImpl, updateWorkflowPromptOverridesImpl, upsertMergeRequestRecordImpl, workflowStateForMergeRequestStateImpl } from "./task-store/remaining-ops-6.js";
|
||||
import { claimNextToolFailureRetryImpl, createTaskVerificationRequestImpl, claimTaskVerificationRequestImpl, finishTaskVerificationRequestImpl, clearNearDuplicateReferencesToFailSoftImpl, clearWorkflowRunStepInstancesAsyncImpl, clearWorkflowRunStepInstancesImpl, computeMovedSettingsTargetWorkflowIdsImpl, ensureBranchGroupForSourceImpl, ensurePrEntityForSourceImpl, findRecentTasksByContentFingerprintImpl, getActiveMergingTaskImpl, getActivePrEntityBySourceImpl, getBranchGroupByBranchNameImpl, getBranchGroupBySourceImpl, getBranchGroupImpl, getBranchProgressByTaskImpl, getMutationsForRunImpl, getPrEntityByNumberImpl, getPrEntityImpl, getPrThreadStateImpl, getTasksByAssignedAgentImpl, getWorkflowPromptOverridesAsyncImpl, getWorkflowSettingValuesAsyncImpl, getWorkflowSettingValuesImpl, getWorkflowSettingsProjectIdImpl, getWorkflowWorkItemImpl, insertCompletionHandoffWorkflowWorkAuditImpl, listActivePrEntitiesImpl, listBranchGroupsImpl, listPrThreadStatesImpl, listTasksByBranchGroupImpl, listWorkflowSettingValuesForProjectImpl, loadWorkflowRunBranchesImpl, loadWorkflowRunStepInstancesAsyncImpl, loadWorkflowRunStepInstancesImpl, markToolFailureRetryExhaustedAuditImpl, mergeCustomFieldPatchImpl, normalizeMergeRequestStateImpl, normalizeWorkflowWorkItemKindImpl, normalizeWorkflowWorkItemStateImpl, parseWorkflowPromptOverrideJsonImpl, recordPrThreadOutcomeImpl, resetAllStepsToPendingImpl, resetPromptCheckboxesImpl, resolveWorkflowMoveActorImpl, resolveWorkflowSettingDeclarationsImpl, saveWorkflowRunStepInstanceAsyncImpl, saveWorkflowRunStepInstanceImpl, transitionMergeRequestStateImpl, transitionWorkflowWorkItemSyncImpl, updateTaskImpl, updateWorkflowPromptOverridesImpl, upsertMergeRequestRecordImpl, workflowStateForMergeRequestStateImpl } from "./task-store/branch-and-pr-entities.js";
|
||||
import { addPrInfoImpl, addSteeringCommentImpl, archiveAllDoneImpl, cleanupStaleMergeQueueRowsImpl, clearCompletionHandoffAcceptedMarkerImpl, clearDoneTransientFieldsImpl, clearStaleExecutionStartBranchReferencesImpl, computeWorkflowColumnsGraduationReportImpl, deleteTaskCommentImpl, deleteTaskDocumentImpl, emitUsageEventImpl, enqueueMergeQueueImpl, getAgentLogCountImpl, getAgentLogsImpl, getArtifactImpl, getArtifactsImpl, getAttachmentImpl, getCompletionHandoffAcceptedMarkerImpl, getTaskDocumentImpl, getTaskDocumentRevisionsImpl, getTaskDocumentsImpl, insertArtifactRowImpl, linkGithubIssueImpl, listWorkflowWorkItemsForTaskSyncImpl, moveToDoneImpl, parseDependenciesFromPromptImpl, parseFileScopeFromPromptImpl, parseStepsFromPromptImpl, peekMergeQueueHeadImpl, peekMergeQueueImpl, readPreArchiveColumnFromTaskFileImpl, recordPluginActivationImpl, recordRunAuditEventBackendImpl, removePrInfoByNumberImpl, resolvePrimaryPrInfoImpl, resolveUnarchiveTargetColumnImpl, rewriteLineageChildrenForRemovalImpl, runGitCommandImpl, stopWatchingImpl, syncAgentTaskLinkOnReassignmentImpl, updateArtifactImpl, updateGithubTrackingImpl, updatePrInfoByNumberImpl, updateTaskCommentImpl, upsertPrInfoByNumberImpl, writeArtifactDataImpl } from "./task-store/remaining-ops-7.js";
|
||||
import { approveCliAutonomyImpl, approveWorkflowCliCommandImpl, cleanupOrphanedMaterializedStepsImpl, consumePluginGateVerdictsImpl, getAgentLogsByTimeRangeImpl, getDatabaseHealthImpl, getDistributedTaskIdAllocatorImpl, getExperimentSessionStoreImpl, getInReviewDurationEventsImpl, getMissionStoreImpl, getIdeationStoreImpl, getPluginStoreImpl, getSecretsStoreImpl, getSettingsSyncImpl, getTaskMergedTaskIdsImpl, getTaskWorkflowSelectionImpl, getImportTranslationImpl, recordImportTranslationImpl, pruneImportTranslationsImpl, type ImportTranslationCacheKey, type ImportTranslationCacheEntry, getVerificationCacheHitImpl, getWorkflowDefinitionImpl, healthCheckImpl, importLegacyAgentLogsOnceImpl, insertWorkflowDefinitionSyncImpl, isCliAutonomyApprovedImpl, isPluginInstalledImpl, isWorkflowCliCommandApprovedImpl, listWorkflowDefinitionsImpl, materializeExplicitWorkflowStepsImpl, materializeWorkflowStepsImpl, migrateActiveArchivedTasksToArchiveDbImpl, migrateLegacyArchiveEntriesToArchiveDbImpl, nextWorkflowDefinitionIdImpl, occupantsByColumnForWorkflowImpl, parseWorkflowLayoutImpl, pruneAgentLogFilesImpl, purgeTaskWorkflowSelectionRowsImpl, readAllWorkflowDefinitionsImpl, readRawProjectSettingsImpl, recordPluginGateVerdictImpl, recordVerificationCachePassImpl, removeMaterializedSelectionImpl, resolvePluginWorkflowStepImpl, resolveTaskWorkflowIrSyncImpl, revokeCliAutonomyImpl, selectTaskWorkflowAndReconcileImpl, writeTaskWorkflowSelectionImpl, getTaskWorkflowSelectionAsyncImpl, } from "./task-store/workflow-definitions.js";
|
||||
import { getTaskCommitAssociationsByLineageIdImpl, replaceLegacyTaskCommitAssociationsImpl } from "./task-store/task-commit-associations.js";
|
||||
import { findRecentTasksBySourceParentTaskIdImpl } from "./task-store/remaining-ops-6.js";
|
||||
import { findRecentTasksBySourceParentTaskIdImpl } from "./task-store/branch-and-pr-entities.js";
|
||||
import { addTaskCommentImpl, applyBuiltInPromptOverridesSyncImpl, areAllDependenciesDoneImpl, artifactStoredNameImpl, assertWorkflowIrTraitsValidImpl, clearActivityLogImpl, clearTaskWorkflowSelectionImpl, deleteTaskByIdImpl, getDefaultWorkflowIdImpl, getInsightStoreImpl, getMergeQueuedTaskIdsImpl, getMergeRequestRecordImpl, getMergeRequestRecordAsyncImpl, getResearchStoreImpl, getTaskIdFromDirImpl, getTodoStoreImpl, getWorkflowWorkItemByIdentityImpl, hasActiveTaskImpl, invalidateConfigCacheAfterMigrationImpl, isTaskIdConflictErrorImpl, listLegacyAutoMergeStampCandidatesImpl, readTaskRowFromDbImpl, recordBranchGroupMemberLandedImpl, refreshDatabaseHealthImpl, resolveEffectiveWorkflowIdSyncImpl, resolveTaskCustomFieldDefsSyncImpl, resolveWorkflowBypassGuardsImpl, serializeConfigForDiskImpl, setPluginWorkflowStepTemplatesImpl, shouldSkipWorkflowMovePoliciesImpl, suppressWatcherImpl, upsertTaskWithFtsRecoveryImpl } from "./task-store/task-store-helpers.js";
|
||||
import { getTaskSelectClauseImpl2, createTaskPersistSerializationContextImpl, getTaskPersistValuesImpl, getTaskPatchDescriptorsImpl, normalizeTaskFromDiskImpl, writeTaskJsonFileImpl, rowToPrEntityImpl, generatePrEntityIdImpl, readTaskForMoveImpl, rowToMergeQueueEntryImpl, rowToMergeRequestRecordImpl, rowToCompletionHandoffMarkerImpl, rowToWorkflowWorkItemImpl, rowToRunAuditEventImpl } from "./task-store/task-row-mappers.js";
|
||||
import { getTaskSelectClauseWithActivityLogLimitImpl, getChangedTaskColumnsImpl, getSoftDeletedWriteConflictImpl, readTaskJsonImpl, writeConfigImpl, _maybeAutoArchiveSameAgentDuplicateBackendImpl, updateBranchGroupImpl, updatePrEntityImpl, listTasksForGithubTrackingReconcileImpl, listTasksForGitlabTrackingReconcileImpl, renewCheckoutLeaseImpl, updateTaskAtomicImpl, getWorkflowPromptOverridesImpl, updateWorkflowSettingValuesImpl, rollbackConfigurationImpl, cancelActiveWorkflowWorkItemsForTaskImpl, setCompletionHandoffAcceptedMarkerImpl, reconcileLegacyAutoMergeStampsImpl, recoverExpiredMergeQueueLeasesImpl, rewriteDependentsForRemovalImpl, cleanupBranchForTaskImpl, addAttachmentImpl, deleteAttachmentImpl, registerArtifactImpl, updatePrInfoImpl, unlinkGithubIssueImpl, cleanupArchivedTasksImpl, generatePromptFromArchiveEntryImpl, listWorkflowOccupantTaskIdsImpl, evacuateCustomColumnsToLegacyImpl, listApprovedCliAutonomyAdaptersImpl, closeImpl, getActivityLogImpl } from "./task-store/remaining-ops-2.js";
|
||||
@@ -1216,7 +1216,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
|
||||
): Promise<Task> {
|
||||
return updateTaskImpl(this, id, updates, runContext);
|
||||
}
|
||||
async claimNextToolFailureRetry(taskId: string, expectedCursor: number, maxRetries: number): Promise<import("./task-store/remaining-ops-6.js").ToolFailureRetryClaim> {
|
||||
async claimNextToolFailureRetry(taskId: string, expectedCursor: number, maxRetries: number): Promise<import("./task-store/branch-and-pr-entities.js").ToolFailureRetryClaim> {
|
||||
return claimNextToolFailureRetryImpl(this, taskId, expectedCursor, maxRetries);
|
||||
}
|
||||
async markToolFailureRetryExhaustedAudit(taskId: string): Promise<boolean> {
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
/**
|
||||
* remaining-ops-6 operations.
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Domain rename from branch-and-pr-entities: branch groups, PR entities, and PR thread state.
|
||||
*
|
||||
* FNXC:StoreModularization 2026-06-25-00:00:
|
||||
* Extracted from the monolithic packages/core/src/store.ts as a pure
|
||||
265
packages/dashboard/app/api/agents.ts
Normal file
265
packages/dashboard/app/api/agents.ts
Normal file
@@ -0,0 +1,265 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Agent CRUD / soul / memory client API peeled from legacy.ts.
|
||||
*/
|
||||
import type {
|
||||
Agent,
|
||||
AgentDetail,
|
||||
AgentCapability,
|
||||
AgentState,
|
||||
AgentHeartbeatEvent,
|
||||
AgentHeartbeatRun,
|
||||
AgentCreateInput,
|
||||
AgentUpdateInput,
|
||||
AgentTaskSession,
|
||||
AgentStats,
|
||||
HeartbeatInvocationSource,
|
||||
OrgTreeNode,
|
||||
AgentReflection,
|
||||
AgentPerformanceSummary,
|
||||
ReflectionTrigger,
|
||||
AgentBudgetStatus,
|
||||
AgentLogEntry,
|
||||
} from "@fusion/core";
|
||||
import type { MemoryFileInfo } from "./memory.js";
|
||||
export type { Agent, AgentDetail, AgentCapability, AgentState, AgentHeartbeatEvent, AgentHeartbeatRun, AgentCreateInput, AgentUpdateInput, AgentTaskSession, AgentStats, HeartbeatInvocationSource, OrgTreeNode, AgentReflection, AgentPerformanceSummary, ReflectionTrigger, AgentBudgetStatus, AgentLogEntry };
|
||||
import { api, buildApiUrl } from "./client.js";
|
||||
import type { FetchOptions } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { withTokenHeader } from "../auth";
|
||||
import { dedupe } from "./dedupe.js";
|
||||
|
||||
// ── Agent API ────────────────────────────────────────────────────────────
|
||||
|
||||
export interface AgentPromptSizePoint {
|
||||
runId: string;
|
||||
createdAt: string;
|
||||
systemChars: number;
|
||||
execChars: number;
|
||||
totalChars: number;
|
||||
}
|
||||
|
||||
/** Fetch workspace sub-repos for a project */
|
||||
export function fetchWorkspaceRepos(projectId?: string): Promise<{ repos: string[] }> {
|
||||
return api<{ repos: string[] }>(withProjectId("/git/workspace-repos", projectId));
|
||||
}
|
||||
|
||||
/** Fetch all agents, optionally filtered by state or role */
|
||||
export function fetchAgents(
|
||||
filter?: { state?: AgentState; role?: AgentCapability; includeEphemeral?: boolean },
|
||||
projectId?: string,
|
||||
options?: FetchOptions,
|
||||
): Promise<Agent[]> {
|
||||
const params = new URLSearchParams();
|
||||
if (filter?.state) params.set("state", filter.state);
|
||||
if (filter?.role) params.set("role", filter.role);
|
||||
if (filter?.includeEphemeral === true) params.set("includeEphemeral", "true");
|
||||
if (projectId) params.set("projectId", projectId);
|
||||
const query = params.size > 0 ? `?${params.toString()}` : "";
|
||||
const path = `/agents${query}`;
|
||||
return dedupe(path, () => api<Agent[]>(path), options);
|
||||
}
|
||||
|
||||
/** Fetch a single agent with heartbeat history */
|
||||
export function fetchAgent(agentId: string, projectId?: string): Promise<AgentDetail> {
|
||||
return api<AgentDetail>(withProjectId(`/agents/${encodeURIComponent(agentId)}`, projectId));
|
||||
}
|
||||
|
||||
/** Create a new agent */
|
||||
export function createAgent(input: AgentCreateInput, projectId?: string): Promise<Agent> {
|
||||
return api<Agent>(withProjectId("/agents", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Update an agent */
|
||||
export function updateAgent(agentId: string, updates: AgentUpdateInput, projectId?: string): Promise<Agent> {
|
||||
return api<Agent>(withProjectId(`/agents/${encodeURIComponent(agentId)}`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
/** Upload an agent avatar image. */
|
||||
export async function uploadAgentAvatar(agentId: string, file: File, projectId?: string): Promise<Agent> {
|
||||
const formData = new FormData();
|
||||
formData.append("file", file);
|
||||
const res = await fetch(buildApiUrl(withProjectId(`/agents/${encodeURIComponent(agentId)}/avatar`, projectId)), {
|
||||
method: "POST",
|
||||
headers: withTokenHeader(),
|
||||
body: formData,
|
||||
});
|
||||
const data = await res.json();
|
||||
if (!res.ok) {
|
||||
throw new Error((data as { error?: string }).error || "Avatar upload failed");
|
||||
}
|
||||
return data as Agent;
|
||||
}
|
||||
|
||||
/** Delete an agent avatar image. */
|
||||
export function deleteAgentAvatar(agentId: string, projectId?: string): Promise<Agent> {
|
||||
return api<Agent>(withProjectId(`/agents/${encodeURIComponent(agentId)}/avatar`, projectId), {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
/** Backfill an existing agent onto the default heartbeat procedure file. */
|
||||
export function upgradeAgentHeartbeatProcedure(
|
||||
agentId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ agent: Agent; heartbeatProcedurePath: string; procedureFileSeeded: boolean }> {
|
||||
return api(
|
||||
withProjectId(`/agents/${encodeURIComponent(agentId)}/upgrade-heartbeat-procedure`, projectId),
|
||||
{ method: "POST" },
|
||||
);
|
||||
}
|
||||
|
||||
/** Update agent custom instructions */
|
||||
export function updateAgentInstructions(
|
||||
agentId: string,
|
||||
instructions: { instructionsPath?: string; instructionsText?: string },
|
||||
projectId?: string,
|
||||
): Promise<Agent> {
|
||||
return api<Agent>(withProjectId(`/agents/${encodeURIComponent(agentId)}/instructions`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(instructions),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch agent soul/personality text */
|
||||
export function fetchAgentSoul(agentId: string, projectId?: string): Promise<{ soul: string | null }> {
|
||||
return api<{ soul: string | null }>(withProjectId(`/agents/${encodeURIComponent(agentId)}/soul`, projectId));
|
||||
}
|
||||
|
||||
/** Update agent soul/personality text */
|
||||
export function updateAgentSoul(agentId: string, soul: string, projectId?: string): Promise<Agent> {
|
||||
return api<Agent>(withProjectId(`/agents/${encodeURIComponent(agentId)}/soul`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify({ soul }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch per-agent memory text */
|
||||
export function fetchAgentMemory(agentId: string, projectId?: string): Promise<{ memory: string | null }> {
|
||||
return api<{ memory: string | null }>(withProjectId(`/agents/${encodeURIComponent(agentId)}/memory`, projectId));
|
||||
}
|
||||
|
||||
/** Update per-agent memory text */
|
||||
export function updateAgentMemory(agentId: string, memory: string, projectId?: string): Promise<Agent> {
|
||||
return api<Agent>(withProjectId(`/agents/${encodeURIComponent(agentId)}/memory`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify({ memory }),
|
||||
});
|
||||
}
|
||||
|
||||
/** List file-based memory entries for a specific agent */
|
||||
export function fetchAgentMemoryFiles(agentId: string, projectId?: string): Promise<{ files: MemoryFileInfo[] }> {
|
||||
return api<{ files: MemoryFileInfo[] }>(withProjectId(`/agents/${encodeURIComponent(agentId)}/memory/files`, projectId));
|
||||
}
|
||||
|
||||
/** Read one file-based memory entry for a specific agent */
|
||||
export function fetchAgentMemoryFile(agentId: string, path: string, projectId?: string): Promise<{ path: string; content: string }> {
|
||||
const query = `path=${encodeURIComponent(path)}`;
|
||||
return api<{ path: string; content: string }>(withProjectId(`/agents/${encodeURIComponent(agentId)}/memory/file?${query}`, projectId));
|
||||
}
|
||||
|
||||
/** Save one file-based memory entry for a specific agent */
|
||||
export function saveAgentMemoryFile(agentId: string, path: string, content: string, projectId?: string): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(withProjectId(`/agents/${encodeURIComponent(agentId)}/memory/file`, projectId), {
|
||||
method: "PUT",
|
||||
body: JSON.stringify({ path, content }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Update an agent's state */
|
||||
export function updateAgentState(agentId: string, state: AgentState, projectId?: string): Promise<Agent> {
|
||||
return api<Agent>(withProjectId(`/agents/${encodeURIComponent(agentId)}/state`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ state }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Delete an agent */
|
||||
export function deleteAgent(agentId: string, projectId?: string): Promise<void> {
|
||||
return api<void>(withProjectId(`/agents/${encodeURIComponent(agentId)}`, projectId), {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
/** Record a heartbeat for an agent */
|
||||
export function recordAgentHeartbeat(
|
||||
agentId: string,
|
||||
status: "ok" | "missed" | "recovered" = "ok",
|
||||
projectId?: string,
|
||||
): Promise<AgentHeartbeatEvent> {
|
||||
return api<AgentHeartbeatEvent>(withProjectId(`/agents/${encodeURIComponent(agentId)}/heartbeat`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ status }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch heartbeat history for an agent */
|
||||
export function fetchAgentHeartbeats(agentId: string, limit?: number, projectId?: string): Promise<AgentHeartbeatEvent[]> {
|
||||
const params = new URLSearchParams();
|
||||
if (limit !== undefined) params.set("limit", String(limit));
|
||||
if (projectId) params.set("projectId", projectId);
|
||||
const query = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<AgentHeartbeatEvent[]>(`/agents/${encodeURIComponent(agentId)}/heartbeats${query}`);
|
||||
}
|
||||
|
||||
/** Fetch heartbeat runs for an agent */
|
||||
export function fetchAgentRuns(agentId: string, limit?: number, projectId?: string): Promise<AgentHeartbeatRun[]> {
|
||||
const params = new URLSearchParams();
|
||||
if (limit !== undefined) params.set("limit", String(limit));
|
||||
if (projectId) params.set("projectId", projectId);
|
||||
const query = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<AgentHeartbeatRun[]>(`/agents/${encodeURIComponent(agentId)}/runs${query}`);
|
||||
}
|
||||
|
||||
/** Fetch a single heartbeat run detail */
|
||||
export function fetchAgentRunDetail(agentId: string, runId: string, projectId?: string): Promise<AgentHeartbeatRun> {
|
||||
return api<AgentHeartbeatRun>(withProjectId(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}`, projectId));
|
||||
}
|
||||
|
||||
/** Fetch agent logs for a specific run's time window */
|
||||
export function fetchAgentRunLogs(agentId: string, runId: string, projectId?: string): Promise<AgentLogEntry[]> {
|
||||
return api<AgentLogEntry[]>(withProjectId(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/logs`, projectId));
|
||||
}
|
||||
|
||||
/** Fetch recent prompt size points for an agent */
|
||||
export function fetchAgentPromptSizes(agentId: string, limit?: number, projectId?: string): Promise<AgentPromptSizePoint[]> {
|
||||
const params = new URLSearchParams();
|
||||
if (limit !== undefined) params.set("limit", String(limit));
|
||||
if (projectId) params.set("projectId", projectId);
|
||||
const query = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<AgentPromptSizePoint[]>(`/agents/${encodeURIComponent(agentId)}/prompt-sizes${query}`);
|
||||
}
|
||||
|
||||
/** Manually start a heartbeat run for an agent */
|
||||
export function startAgentRun(
|
||||
agentId: string,
|
||||
projectId?: string,
|
||||
options?: { source?: HeartbeatInvocationSource; triggerDetail?: string },
|
||||
): Promise<AgentHeartbeatRun> {
|
||||
const source = options?.source ?? "manual";
|
||||
const triggerDetail = options?.triggerDetail ?? "Agent activated via dashboard";
|
||||
return api<AgentHeartbeatRun>(withProjectId(`/agents/${encodeURIComponent(agentId)}/runs`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ source, triggerDetail }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Stop an active heartbeat run for an agent */
|
||||
export function stopAgentRun(
|
||||
agentId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ ok: boolean; runId?: string; message?: string }> {
|
||||
return api<{ ok: boolean; runId?: string; message?: string }>(
|
||||
withProjectId(`/agents/${encodeURIComponent(agentId)}/runs/stop`, projectId),
|
||||
{
|
||||
method: "POST",
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
308
packages/dashboard/app/api/ai-sessions.ts
Normal file
308
packages/dashboard/app/api/ai-sessions.ts
Normal file
@@ -0,0 +1,308 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* AI / planning session client API peeled from legacy.ts.
|
||||
*/
|
||||
import type { PlanningQuestion, ThinkingLevel } from "@fusion/core";
|
||||
import { api, buildApiUrl, ApiRequestError, looksLikeHtml } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { withTokenHeader } from "../auth";
|
||||
|
||||
// ── AI Sessions ────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Needs-attention variants for a CLI agent session (CLI Agent Executor, U11).
|
||||
* Each carries pinned banner copy + action verbs:
|
||||
* - userExited → Advance / Retry / Cancel task
|
||||
* - authFailed → Re-authenticate / Retry
|
||||
* - resume-exhausted → Relaunch fresh / Cancel task
|
||||
*/
|
||||
export type CliNeedsAttentionVariant = "userExited" | "authFailed" | "resume-exhausted";
|
||||
|
||||
export interface AiSessionSummary {
|
||||
id: string;
|
||||
type:
|
||||
| "planning"
|
||||
| "subtask"
|
||||
| "mission_interview"
|
||||
| "milestone_interview"
|
||||
| "slice_interview"
|
||||
| "cli-agent";
|
||||
status:
|
||||
| "draft"
|
||||
| "generating"
|
||||
| "awaiting_input"
|
||||
| "complete"
|
||||
| "error"
|
||||
| "waiting_on_input"
|
||||
| "needs_attention";
|
||||
/** For cli-agent sessions: which needs-attention variant (drives pinned copy/actions). */
|
||||
cliVariant?: CliNeedsAttentionVariant;
|
||||
/** Underlying CLI session id, for action wiring (confirm-advance / re-auth / etc.). */
|
||||
cliSessionId?: string;
|
||||
title: string;
|
||||
/** Server-derived preview of the in-progress initialPlan; only set for draft planning sessions. */
|
||||
preview?: string;
|
||||
projectId: string | null;
|
||||
updatedAt: string;
|
||||
archived?: boolean;
|
||||
}
|
||||
|
||||
export interface ConversationHistoryEntry {
|
||||
question?: PlanningQuestion;
|
||||
response?: Record<string, unknown>;
|
||||
thinkingOutput?: string;
|
||||
}
|
||||
|
||||
export interface AiSessionDetail extends AiSessionSummary {
|
||||
inputPayload: string;
|
||||
conversationHistory: string;
|
||||
currentQuestion: string | null;
|
||||
result: string | null;
|
||||
thinkingOutput: string;
|
||||
error: string | null;
|
||||
createdAt: string;
|
||||
}
|
||||
|
||||
export function parseConversationHistory(raw: string): ConversationHistoryEntry[] {
|
||||
if (!raw) return [];
|
||||
|
||||
try {
|
||||
const parsed = JSON.parse(raw);
|
||||
return Array.isArray(parsed) ? parsed : [];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
FNXC:AiSessions 2026-07-19-12:30:
|
||||
fetchAiSessions / fetchAiSession intentionally soft-fail to [] / null instead of
|
||||
throwing via api(). Session pickers and multi-tab planners poll these endpoints and
|
||||
prefer an empty/missing surface over error banners when auth blips or the engine is
|
||||
momentarily unavailable — diverges from archive/ping helpers that must surface failures.
|
||||
*/
|
||||
export async function fetchAiSessions(
|
||||
projectId?: string,
|
||||
options?: { includeCompleted?: boolean; includeArchived?: boolean; type?: AiSessionSummary["type"] },
|
||||
): Promise<AiSessionSummary[]> {
|
||||
const search = new URLSearchParams();
|
||||
if (projectId) search.set("projectId", projectId);
|
||||
if (options?.includeCompleted) search.set("includeCompleted", "1");
|
||||
if (options?.includeArchived) search.set("includeArchived", "1");
|
||||
if (options?.type) search.set("type", options.type);
|
||||
const qs = search.toString();
|
||||
const res = await fetch(buildApiUrl(`/ai-sessions${qs ? `?${qs}` : ""}`), {
|
||||
headers: withTokenHeader(),
|
||||
});
|
||||
if (!res.ok) return [];
|
||||
const data = await res.json();
|
||||
return data.sessions ?? [];
|
||||
}
|
||||
|
||||
export async function archiveAiSession(id: string): Promise<void> {
|
||||
return api<void>(`/ai-sessions/${encodeURIComponent(id)}/archive`, {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
export async function unarchiveAiSession(id: string): Promise<void> {
|
||||
return api<void>(`/ai-sessions/${encodeURIComponent(id)}/unarchive`, {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
/** Soft-fail companion to fetchAiSessions — see FNXC:AiSessions above. */
|
||||
export async function fetchAiSession(id: string): Promise<AiSessionDetail | null> {
|
||||
const res = await fetch(buildApiUrl(`/ai-sessions/${encodeURIComponent(id)}`), {
|
||||
headers: withTokenHeader(),
|
||||
});
|
||||
if (!res.ok) return null;
|
||||
return res.json();
|
||||
}
|
||||
|
||||
/*
|
||||
FNXC:PlanningMultiTab 2026-07-14-00:00:
|
||||
acquireSessionLock / releaseSessionLock / forceAcquireSessionLock were removed with the rest of
|
||||
the per-tab session lock; their routes no longer exist. AI interview sessions are multi-tab —
|
||||
the persisted session row is the shared source of truth and any tab may read and interact.
|
||||
*/
|
||||
|
||||
export async function deleteAiSession(id: string): Promise<void> {
|
||||
const url = buildApiUrl(`/ai-sessions/${encodeURIComponent(id)}`);
|
||||
const res = await fetch(url, {
|
||||
method: "DELETE",
|
||||
headers: withTokenHeader(),
|
||||
});
|
||||
|
||||
if (res.ok || res.status === 404) {
|
||||
return;
|
||||
}
|
||||
|
||||
const contentType = res.headers.get("content-type") ?? "";
|
||||
const bodyText = await res.text();
|
||||
const isJson = contentType.includes("application/json");
|
||||
const isHtml = contentType.includes("text/html") || looksLikeHtml(bodyText);
|
||||
|
||||
if (isHtml) {
|
||||
throw new Error(
|
||||
`API returned HTML instead of JSON for ${url}. ` +
|
||||
`The endpoint may not be properly configured. (${res.status} ${res.statusText})`
|
||||
);
|
||||
}
|
||||
|
||||
if (!isJson) {
|
||||
const preview = bodyText.length > 160 ? `${bodyText.slice(0, 160)}...` : bodyText;
|
||||
throw new Error(
|
||||
`API returned ${contentType || "an unknown content type"} instead of JSON for ${url}. ` +
|
||||
`(${res.status} ${res.statusText})${preview ? ` Response: ${preview}` : ""}`
|
||||
);
|
||||
}
|
||||
|
||||
let data: unknown;
|
||||
try {
|
||||
data = bodyText ? JSON.parse(bodyText) : null;
|
||||
} catch {
|
||||
throw new Error(`API returned invalid JSON for ${url}. (${res.status} ${res.statusText})`);
|
||||
}
|
||||
|
||||
const payload = data as { error?: string; details?: Record<string, unknown> } | null;
|
||||
throw new ApiRequestError(
|
||||
payload?.error || `Request failed for ${url}: ${res.status} ${res.statusText}`,
|
||||
res.status,
|
||||
payload?.details,
|
||||
);
|
||||
}
|
||||
|
||||
export function pingSession(sessionId: string, projectId?: string): Promise<{ ok: boolean }> {
|
||||
return api<{ ok: boolean }>(withProjectId(`/ai-sessions/${encodeURIComponent(sessionId)}/ping`, projectId), {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
export function updatePlanningSessionDraft(
|
||||
sessionId: string,
|
||||
draft: { initialPlan: string; modelProvider?: string; modelId?: string; thinkingLevel?: ThinkingLevel },
|
||||
projectId?: string,
|
||||
): Promise<{ ok: boolean }> {
|
||||
return api<{ ok: boolean }>(withProjectId(`/ai-sessions/${encodeURIComponent(sessionId)}/draft`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(draft),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Ask the server to (re)generate the sidebar title for a draft planning
|
||||
* session from its persisted initialPlan. Server-side is idempotent and
|
||||
* a no-op once the session has been started, so callers can fire-and-
|
||||
* forget on textarea blur and modal close.
|
||||
*/
|
||||
export function summarizePlanningDraftTitle(
|
||||
sessionId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ title: string | null }> {
|
||||
return api<{ title: string | null }>(
|
||||
withProjectId(`/planning/${encodeURIComponent(sessionId)}/summarize-draft-title`, projectId),
|
||||
{ method: "POST" },
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* FNXC:CodeOrganization 2026-07-18-14:00:
|
||||
* Preserve legacy `messaging` imports while implementations live in messaging.ts.
|
||||
*/
|
||||
export {
|
||||
addAgentRating,
|
||||
createProposedTask,
|
||||
decideApproval,
|
||||
deleteAgentRating,
|
||||
deleteMessage,
|
||||
fetchAgentBudgetStatus,
|
||||
fetchAgentMailbox,
|
||||
fetchAgentPerformance,
|
||||
fetchAgentRatingSummary,
|
||||
fetchAgentRatings,
|
||||
fetchAgentReflection,
|
||||
fetchAgentReflections,
|
||||
fetchAllAgentMailbox,
|
||||
fetchApprovalDetail,
|
||||
fetchApprovals,
|
||||
fetchConversation,
|
||||
fetchInbox,
|
||||
fetchMessage,
|
||||
fetchOutbox,
|
||||
fetchUnreadCount,
|
||||
markAllMessagesRead,
|
||||
markMessageRead,
|
||||
resetAgentBudget,
|
||||
sendMessage,
|
||||
triggerAgentReflection,
|
||||
} from "./messaging.js";
|
||||
export type {
|
||||
AgentMailboxResponse,
|
||||
AllAgentsMailboxResponse,
|
||||
ApprovalListResponse,
|
||||
ApprovalRequestDetail,
|
||||
ApprovalRequestSummary,
|
||||
InboxResponse,
|
||||
MarkAllReadResponse,
|
||||
OutboxResponse,
|
||||
SendMessageInput,
|
||||
UnreadCountResponse,
|
||||
} from "./messaging.js";
|
||||
|
||||
/*
|
||||
* FNXC:CodeOrganization 2026-07-18-14:00:
|
||||
* Preserve legacy `plugins-and-skills` imports while implementations live in plugins-and-skills.ts.
|
||||
*/
|
||||
export {
|
||||
disablePlugin,
|
||||
enablePlugin,
|
||||
fetchDiscoveredSkills,
|
||||
fetchPluginDashboardViews,
|
||||
fetchPluginDetail,
|
||||
fetchPluginRegistry,
|
||||
fetchPluginRuntimes,
|
||||
fetchPluginSettings,
|
||||
fetchPluginSetupStatus,
|
||||
fetchPluginUiContributions,
|
||||
fetchPluginUiSlots,
|
||||
fetchPlugins,
|
||||
fetchSkillContent,
|
||||
fetchSkillFileContent,
|
||||
fetchSkillsCatalog,
|
||||
installPlugin,
|
||||
installPluginSetup,
|
||||
installSkill,
|
||||
reloadPlugin,
|
||||
rescanPlugin,
|
||||
toggleExecutionSkill,
|
||||
uninstallPlugin,
|
||||
updatePlugin,
|
||||
updatePluginSettings,
|
||||
} from "./plugins-and-skills.js";
|
||||
export type {
|
||||
PluginDashboardViewEntry,
|
||||
PluginRuntimeInfo,
|
||||
PluginSetupStatusResponse,
|
||||
PluginUiContributionEntry,
|
||||
PluginUiSlotEntry,
|
||||
RegistryPluginEntry,
|
||||
} from "./plugins-and-skills.js";
|
||||
|
||||
export function startKeepAlive(
|
||||
sessionId: string,
|
||||
projectId?: string,
|
||||
intervalMs = 25_000,
|
||||
): { stop: () => void } {
|
||||
const timer = setInterval(() => {
|
||||
void pingSession(sessionId, projectId).catch(() => {
|
||||
// Best-effort keepalive: ignore failures so streams remain active.
|
||||
});
|
||||
}, intervalMs);
|
||||
|
||||
return {
|
||||
stop: () => {
|
||||
clearInterval(timer);
|
||||
},
|
||||
};
|
||||
}
|
||||
376
packages/dashboard/app/api/ai-text.ts
Normal file
376
packages/dashboard/app/api/ai-text.ts
Normal file
@@ -0,0 +1,376 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* AI text refinement / import translation client API peeled from legacy.ts.
|
||||
*/
|
||||
import type { Task, TaskPriority } from "@fusion/core";
|
||||
import { api, buildApiUrl } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { createResilientEventSource } from "./event-source.js";
|
||||
import type { StreamConnectionState } from "./event-source.js";
|
||||
import { startKeepAlive } from "./ai-sessions.js";
|
||||
|
||||
export interface SubtaskItem {
|
||||
id: string;
|
||||
title: string;
|
||||
description: string;
|
||||
suggestedSize: "S" | "M" | "L";
|
||||
priority?: TaskPriority;
|
||||
dependsOn: string[];
|
||||
}
|
||||
|
||||
export interface PlanningSubtaskDraft {
|
||||
id: string;
|
||||
title?: string;
|
||||
description?: string;
|
||||
suggestedSize?: "S" | "M" | "L";
|
||||
priority?: TaskPriority;
|
||||
dependsOn?: string[];
|
||||
}
|
||||
|
||||
// ── AI Text Refinement API ────────────────────────────────────────────
|
||||
|
||||
/** Refinement types for AI text refinement */
|
||||
export type RefinementType = "clarify" | "add-details" | "expand" | "simplify";
|
||||
|
||||
/** Response from text refinement endpoint */
|
||||
export interface RefineTextResponse {
|
||||
refined: string;
|
||||
}
|
||||
|
||||
export interface DraftGoalDescriptionResponse {
|
||||
description: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Refine task description text using AI.
|
||||
* @param text - The text to refine (1-2000 characters)
|
||||
* @param type - The refinement type: clarify, add-details, expand, or simplify
|
||||
* @param projectId - Optional project ID for scoped settings resolution
|
||||
* @returns The refined text
|
||||
* @throws Error with message for rate limit (429), invalid type (422), validation (400), or server errors
|
||||
*/
|
||||
export async function refineText(text: string, type: RefinementType, projectId?: string): Promise<string> {
|
||||
const response = await api<RefineTextResponse>(withProjectId("/ai/refine-text", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ text, type }),
|
||||
});
|
||||
return response.refined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Error messages for refineText failures (to use with toast notifications).
|
||||
*/
|
||||
export const REFINE_ERROR_MESSAGES = {
|
||||
/** Rate limit exceeded (429) */
|
||||
RATE_LIMIT: "Too many refinement requests. Please wait an hour.",
|
||||
/** Invalid refinement type (422) */
|
||||
INVALID_TYPE: "Invalid refinement option selected.",
|
||||
/** Network or server errors */
|
||||
NETWORK: "Failed to refine text. Please try again.",
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Get user-friendly error message for a refineText error.
|
||||
* @param error - The error thrown by refineText
|
||||
* @returns A user-friendly error message suitable for toast display
|
||||
*/
|
||||
export function getRefineErrorMessage(error: unknown): string {
|
||||
if (!(error instanceof Error)) {
|
||||
return REFINE_ERROR_MESSAGES.NETWORK;
|
||||
}
|
||||
|
||||
const message = error.message.toLowerCase();
|
||||
|
||||
// Rate limit errors (429)
|
||||
if (message.includes("rate limit") || message.includes("429")) {
|
||||
return REFINE_ERROR_MESSAGES.RATE_LIMIT;
|
||||
}
|
||||
|
||||
// Invalid type errors (422)
|
||||
if (message.includes("invalid") && message.includes("type")) {
|
||||
return REFINE_ERROR_MESSAGES.INVALID_TYPE;
|
||||
}
|
||||
|
||||
// Validation errors (400) - pass through from backend
|
||||
if (
|
||||
message.startsWith("text must") ||
|
||||
message.startsWith("title must") ||
|
||||
message.includes("text is required") ||
|
||||
message.includes("type is required") ||
|
||||
message.includes("title is required")
|
||||
) {
|
||||
return error.message;
|
||||
}
|
||||
|
||||
// Default network/server error
|
||||
return REFINE_ERROR_MESSAGES.NETWORK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Draft a goal description using AI from a goal title.
|
||||
* @param title - The goal title to expand into a draft description
|
||||
* @param projectId - Optional project ID for scoped settings resolution
|
||||
* @returns The drafted goal description
|
||||
* @throws Error with message for rate limit (429), validation (400), or server errors
|
||||
*/
|
||||
export async function draftGoalDescription(title: string, projectId?: string): Promise<string> {
|
||||
const response = await api<DraftGoalDescriptionResponse>(withProjectId("/ai/draft-goal-description", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ title }),
|
||||
});
|
||||
return response.description;
|
||||
}
|
||||
|
||||
/*
|
||||
FNXC:GitHubImportTranslate 2026-07-14-12:00:
|
||||
Client for POST /api/ai/translate-text — used by the GitHub/GitLab import preview when issue/PR prose is not the dashboard language.
|
||||
Structured title+body fields keep markdown import content intact; shares the AI-helper rate-limit budget with refine/draft.
|
||||
*/
|
||||
export interface TranslateImportFields {
|
||||
title?: string;
|
||||
body?: string;
|
||||
}
|
||||
|
||||
export interface TranslateImportContentResponse {
|
||||
fields: TranslateImportFields;
|
||||
}
|
||||
|
||||
/**
|
||||
* Translate import-preview title/body into the dashboard locale via AI.
|
||||
* @param fields - Original title and/or body
|
||||
* @param targetLocale - Active dashboard locale
|
||||
* @param projectId - Optional project scope for settings/MCP
|
||||
* @param sourceLocale - Optional detection hint for the model
|
||||
*/
|
||||
export async function translateImportContent(
|
||||
fields: TranslateImportFields,
|
||||
targetLocale: string,
|
||||
projectId?: string,
|
||||
sourceLocale?: string,
|
||||
): Promise<TranslateImportFields> {
|
||||
const response = await api<TranslateImportContentResponse>(
|
||||
withProjectId("/ai/translate-text", projectId),
|
||||
{
|
||||
method: "POST",
|
||||
body: JSON.stringify({
|
||||
fields,
|
||||
targetLocale,
|
||||
...(sourceLocale ? { sourceLocale } : {}),
|
||||
}),
|
||||
},
|
||||
);
|
||||
return response.fields;
|
||||
}
|
||||
|
||||
/*
|
||||
FNXC:GitHubImportTranslate 2026-07-15-09:30:
|
||||
Auto-translate the visible import list in ONE request. The server reads through its durable cache, so a repeat load of the same repo returns instantly and bills nothing; the same cache is what the import path reads, so an imported task carries the translation shown here.
|
||||
The server enforces the auto-translate setting and the 50-issue cap itself and echoes `enabled`/`capped` back, so the client never has to duplicate that policy.
|
||||
*/
|
||||
export interface AutoTranslateImportItem {
|
||||
number: number;
|
||||
title: string;
|
||||
body: string | null;
|
||||
state?: "open" | "closed";
|
||||
}
|
||||
|
||||
export interface AutoTranslateImportResponse {
|
||||
translations: Record<number, { title: string; body: string }>;
|
||||
enabled: boolean;
|
||||
targetLocale: string | null;
|
||||
/** True when more foreign issues existed than the per-load cap. */
|
||||
capped: boolean;
|
||||
}
|
||||
|
||||
export async function autoTranslateImportIssues(
|
||||
owner: string,
|
||||
repo: string,
|
||||
items: AutoTranslateImportItem[],
|
||||
targetLocale: string,
|
||||
projectId?: string,
|
||||
): Promise<AutoTranslateImportResponse> {
|
||||
return api<AutoTranslateImportResponse>(
|
||||
withProjectId("/github/issues/auto-translate", projectId),
|
||||
{
|
||||
method: "POST",
|
||||
body: JSON.stringify({ owner, repo, items, targetLocale }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** User-facing error copy for translateImportContent failures (toast/banner). */
|
||||
export const TRANSLATE_ERROR_MESSAGES = {
|
||||
RATE_LIMIT: "Too many translation requests. Please wait an hour.",
|
||||
NETWORK: "Failed to translate content. Please try again.",
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Map a translateImportContent error to banner-safe copy.
|
||||
*/
|
||||
export function getTranslateErrorMessage(error: unknown): string {
|
||||
if (!(error instanceof Error)) {
|
||||
return TRANSLATE_ERROR_MESSAGES.NETWORK;
|
||||
}
|
||||
|
||||
const message = error.message.toLowerCase();
|
||||
if (message.includes("rate limit") || message.includes("429")) {
|
||||
return TRANSLATE_ERROR_MESSAGES.RATE_LIMIT;
|
||||
}
|
||||
if (
|
||||
message.startsWith("fields") ||
|
||||
message.startsWith("text to translate") ||
|
||||
message.startsWith("targetlocale") ||
|
||||
message.includes("targetlocale must") ||
|
||||
message.includes("sourceLocale must")
|
||||
) {
|
||||
return error.message;
|
||||
}
|
||||
return TRANSLATE_ERROR_MESSAGES.NETWORK;
|
||||
}
|
||||
|
||||
export function startSubtaskBreakdown(description: string, projectId?: string): Promise<{ sessionId: string }> {
|
||||
return api<{ sessionId: string }>(withProjectId("/subtasks/start-streaming", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ description }),
|
||||
});
|
||||
}
|
||||
|
||||
export function retrySubtaskSession(
|
||||
sessionId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ success: boolean; sessionId: string }> {
|
||||
return api<{ success: boolean; sessionId: string }>(
|
||||
withProjectId(`/subtasks/${encodeURIComponent(sessionId)}/retry`, projectId),
|
||||
{ method: "POST" },
|
||||
);
|
||||
}
|
||||
|
||||
export function getSubtaskStreamUrl(sessionId: string, projectId?: string): string {
|
||||
return buildApiUrl(withProjectId(`/subtasks/${encodeURIComponent(sessionId)}/stream`, projectId));
|
||||
}
|
||||
|
||||
export function connectSubtaskStream(
|
||||
sessionId: string,
|
||||
projectId: string | undefined,
|
||||
handlers: {
|
||||
onThinking?: (data: string) => void;
|
||||
onSubtasks?: (data: SubtaskItem[]) => void;
|
||||
onError?: (data: string) => void;
|
||||
onComplete?: () => void;
|
||||
onConnectionStateChange?: (state: StreamConnectionState) => void;
|
||||
},
|
||||
options?: { maxReconnectAttempts?: number },
|
||||
): { close: () => void; isConnected: () => boolean } {
|
||||
let keepAlive: { stop: () => void } | null = null;
|
||||
let connection: { close: () => void; isConnected: () => boolean } | null = null;
|
||||
|
||||
const stopKeepAlive = () => {
|
||||
keepAlive?.stop();
|
||||
keepAlive = null;
|
||||
};
|
||||
|
||||
const resilient = createResilientEventSource(
|
||||
getSubtaskStreamUrl(sessionId, projectId),
|
||||
{
|
||||
onOpen: () => {
|
||||
stopKeepAlive();
|
||||
keepAlive = startKeepAlive(sessionId, projectId);
|
||||
},
|
||||
events: {
|
||||
thinking: (event) => {
|
||||
try {
|
||||
handlers.onThinking?.(JSON.parse(event.data));
|
||||
} catch {
|
||||
handlers.onThinking?.(event.data);
|
||||
}
|
||||
},
|
||||
subtasks: (event) => {
|
||||
try {
|
||||
handlers.onSubtasks?.(JSON.parse(event.data) as SubtaskItem[]);
|
||||
} catch (err) {
|
||||
console.error("[subtasks] Failed to parse subtasks event:", err);
|
||||
}
|
||||
},
|
||||
error: (event) => {
|
||||
try {
|
||||
const parsedData = JSON.parse(event.data);
|
||||
const errorMessage = typeof parsedData === "string" && parsedData.length > 0 ? parsedData : null;
|
||||
handlers.onError?.(errorMessage || "Stream error");
|
||||
} catch {
|
||||
handlers.onError?.("Stream error");
|
||||
}
|
||||
connection?.close();
|
||||
},
|
||||
complete: () => {
|
||||
handlers.onComplete?.();
|
||||
connection?.close();
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
maxReconnectAttempts: options?.maxReconnectAttempts,
|
||||
onConnectionStateChange: handlers.onConnectionStateChange,
|
||||
onFatalError: (message) => {
|
||||
stopKeepAlive();
|
||||
handlers.onError?.(message);
|
||||
},
|
||||
},
|
||||
);
|
||||
|
||||
connection = {
|
||||
close: () => {
|
||||
stopKeepAlive();
|
||||
resilient.close();
|
||||
},
|
||||
isConnected: resilient.isConnected,
|
||||
};
|
||||
|
||||
return connection;
|
||||
}
|
||||
|
||||
export function createTasksFromBreakdown(
|
||||
sessionId: string,
|
||||
subtasks: SubtaskItem[],
|
||||
parentTaskId?: string,
|
||||
projectId?: string,
|
||||
options?: {
|
||||
branch?: string;
|
||||
baseBranch?: string;
|
||||
branchSelection?: {
|
||||
mode: "project-default" | "auto-new" | "existing" | "custom-new";
|
||||
branchName?: string;
|
||||
baseBranch?: string;
|
||||
};
|
||||
branchAssignment?: { mode: "shared" | "per-task-derived" };
|
||||
workflowId?: string | null;
|
||||
},
|
||||
): Promise<{ tasks: Task[]; parentTaskClosed?: boolean }> {
|
||||
return api<{ tasks: Task[]; parentTaskClosed?: boolean }>(withProjectId("/subtasks/create-tasks", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({
|
||||
sessionId,
|
||||
parentTaskId,
|
||||
...(options?.branch !== undefined ? { branch: options.branch } : {}),
|
||||
...(options?.baseBranch !== undefined ? { baseBranch: options.baseBranch } : {}),
|
||||
...(options?.branchSelection ? { branchSelection: options.branchSelection } : {}),
|
||||
...(options?.branchAssignment ? { branchAssignment: options.branchAssignment } : {}),
|
||||
...(options?.workflowId !== undefined ? { workflowId: options.workflowId } : {}),
|
||||
subtasks: subtasks.map((subtask) => ({
|
||||
tempId: subtask.id,
|
||||
title: subtask.title,
|
||||
description: subtask.description,
|
||||
size: subtask.suggestedSize,
|
||||
...(subtask.priority !== undefined ? { priority: subtask.priority } : {}),
|
||||
dependsOn: subtask.dependsOn,
|
||||
})),
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
export function cancelSubtaskBreakdown(sessionId: string, projectId?: string): Promise<void> {
|
||||
return api<void>(withProjectId("/subtasks/cancel", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ sessionId }),
|
||||
});
|
||||
}
|
||||
|
||||
985
packages/dashboard/app/api/chat.ts
Normal file
985
packages/dashboard/app/api/chat.ts
Normal file
@@ -0,0 +1,985 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Chat sessions / rooms / streaming client API peeled from legacy.ts.
|
||||
*/
|
||||
import type {
|
||||
ChatAttachment,
|
||||
ChatMessage,
|
||||
ChatRoom,
|
||||
ChatRoomMember,
|
||||
ChatRoomMessage,
|
||||
EnrichedChatSession,
|
||||
} from "@fusion/core";
|
||||
import { api, buildApiUrl } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { withTokenHeader } from "../auth";
|
||||
import type { StreamConnectionState } from "./event-source.js";
|
||||
|
||||
// ── Chat API ─────────────────────────────────────────────────────────────────
|
||||
|
||||
// EnrichedChatSession is imported from @fusion/core above
|
||||
|
||||
export interface ChatSessionListResponse {
|
||||
sessions: EnrichedChatSession[];
|
||||
}
|
||||
|
||||
export interface ChatSessionResponse {
|
||||
session: EnrichedChatSession;
|
||||
}
|
||||
|
||||
export interface ChatMessageListResponse {
|
||||
messages: ChatMessage[];
|
||||
}
|
||||
|
||||
export interface TaskPlannerChatSessionInput {
|
||||
modelProvider?: string;
|
||||
modelId?: string;
|
||||
}
|
||||
|
||||
export interface ChatRoomListResponse {
|
||||
rooms: ChatRoom[];
|
||||
}
|
||||
|
||||
export interface ChatRoomResponse {
|
||||
room: ChatRoom;
|
||||
members?: ChatRoomMember[];
|
||||
}
|
||||
|
||||
export interface ChatRoomMembersResponse {
|
||||
members: ChatRoomMember[];
|
||||
}
|
||||
|
||||
export interface ChatRoomMessageListResponse {
|
||||
messages: ChatRoomMessage[];
|
||||
}
|
||||
|
||||
export interface ChatRoomMessageResponse {
|
||||
message: ChatRoomMessage;
|
||||
}
|
||||
|
||||
/**
|
||||
* FNXC:ChatSearch 2026-07-07-00:00:
|
||||
* `q`/`titleOnly` mirror the server's GET /chat/sessions content-search params (see
|
||||
* register-chat-routes.ts). `q` triggers server-side message-content search; `titleOnly=true`
|
||||
* (or omitting `q`) preserves the pre-existing client-side title/agent-only filtering.
|
||||
*/
|
||||
export interface FetchChatSessionsOptions {
|
||||
status?: string;
|
||||
q?: string;
|
||||
titleOnly?: boolean;
|
||||
}
|
||||
|
||||
/** Fetch all chat sessions for a project */
|
||||
export function fetchChatSessions(
|
||||
projectId?: string,
|
||||
status?: string,
|
||||
options?: FetchChatSessionsOptions,
|
||||
): Promise<ChatSessionListResponse> {
|
||||
const search = new URLSearchParams();
|
||||
if (projectId) search.set("projectId", projectId);
|
||||
const resolvedStatus = options?.status ?? status;
|
||||
if (resolvedStatus) search.set("status", resolvedStatus);
|
||||
if (options?.q && options.q.trim()) search.set("q", options.q.trim());
|
||||
if (options?.titleOnly) search.set("titleOnly", "true");
|
||||
const qs = search.toString();
|
||||
return api<ChatSessionListResponse>(`/chat/sessions${qs ? `?${qs}` : ""}`);
|
||||
}
|
||||
|
||||
export interface ChatSessionResumeLookupInput {
|
||||
agentId: string;
|
||||
modelProvider?: string;
|
||||
modelId?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch the most relevant active session for chat resume semantics.
|
||||
* Returns at most one session for the provided target.
|
||||
*/
|
||||
export async function fetchResumeChatSession(
|
||||
input: ChatSessionResumeLookupInput,
|
||||
projectId?: string,
|
||||
): Promise<{ session: EnrichedChatSession | null }> {
|
||||
const normalizedAgentId = input.agentId.trim();
|
||||
if (!normalizedAgentId) {
|
||||
throw new Error("agentId is required");
|
||||
}
|
||||
|
||||
const normalizedProvider = input.modelProvider?.trim();
|
||||
const normalizedModelId = input.modelId?.trim();
|
||||
|
||||
if ((normalizedProvider && !normalizedModelId) || (!normalizedProvider && normalizedModelId)) {
|
||||
throw new Error("Both modelProvider and modelId must be provided together, or neither should be provided");
|
||||
}
|
||||
|
||||
const search = new URLSearchParams();
|
||||
search.set("lookup", "resume");
|
||||
search.set("agentId", normalizedAgentId);
|
||||
if (projectId) search.set("projectId", projectId);
|
||||
if (normalizedProvider && normalizedModelId) {
|
||||
search.set("modelProvider", normalizedProvider);
|
||||
search.set("modelId", normalizedModelId);
|
||||
}
|
||||
|
||||
const data = await api<ChatSessionListResponse>(`/chat/sessions?${search.toString()}`);
|
||||
return { session: data.sessions[0] ?? null };
|
||||
}
|
||||
|
||||
/** Create a new chat session */
|
||||
export function createChatSession(
|
||||
input: { agentId: string; title?: string; modelProvider?: string; modelId?: string; thinkingLevel?: string },
|
||||
projectId?: string,
|
||||
): Promise<ChatSessionResponse> {
|
||||
return api<ChatSessionResponse>(withProjectId("/chat/sessions", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch a single chat session */
|
||||
export function fetchChatSession(id: string, projectId?: string): Promise<ChatSessionResponse> {
|
||||
return api<ChatSessionResponse>(withProjectId(`/chat/sessions/${encodeURIComponent(id)}`, projectId));
|
||||
}
|
||||
|
||||
function normalizeTaskPlannerChatInput(taskId: string, input: TaskPlannerChatSessionInput = {}) {
|
||||
const normalizedTaskId = taskId.trim();
|
||||
if (!normalizedTaskId) {
|
||||
throw new Error("taskId is required");
|
||||
}
|
||||
const normalizedProvider = input.modelProvider?.trim();
|
||||
const normalizedModelId = input.modelId?.trim();
|
||||
if ((normalizedProvider && !normalizedModelId) || (!normalizedProvider && normalizedModelId)) {
|
||||
throw new Error("Both modelProvider and modelId must be provided together, or neither should be provided");
|
||||
}
|
||||
return { normalizedTaskId, normalizedProvider, normalizedModelId };
|
||||
}
|
||||
|
||||
export function fetchTaskPlannerChatSession(
|
||||
taskId: string,
|
||||
input: TaskPlannerChatSessionInput = {},
|
||||
projectId?: string,
|
||||
): Promise<{ session: EnrichedChatSession | null }> {
|
||||
const { normalizedTaskId, normalizedProvider, normalizedModelId } = normalizeTaskPlannerChatInput(taskId, input);
|
||||
|
||||
/*
|
||||
FNXC:TaskDetailPlannerChat 2026-06-30-18:20:
|
||||
Task-detail planner chats are task-local but no longer pre-created by opening the Chat tab. Use lookup-only resume here so global Chat history only receives planner sessions after an explicit user message creates one.
|
||||
*/
|
||||
return fetchResumeChatSession({
|
||||
agentId: `task-planner:${normalizedTaskId}`,
|
||||
...(normalizedProvider && normalizedModelId ? { modelProvider: normalizedProvider, modelId: normalizedModelId } : {}),
|
||||
}, projectId);
|
||||
}
|
||||
|
||||
export function ensureTaskPlannerChatSession(
|
||||
taskId: string,
|
||||
input: TaskPlannerChatSessionInput = {},
|
||||
projectId?: string,
|
||||
): Promise<ChatSessionResponse> {
|
||||
const { normalizedTaskId, normalizedProvider, normalizedModelId } = normalizeTaskPlannerChatInput(taskId, input);
|
||||
|
||||
/*
|
||||
FNXC:TaskDetailPlannerChat 2026-06-30-22:30:
|
||||
Task planner chat uses a task-scoped session seam instead of the generic agent-chat creator so it can bind the conversation to the task and planning model without requiring a real executor/reviewer agent or turning the message into steering.
|
||||
|
||||
FNXC:TaskDetailPlannerChat 2026-06-30-18:20:
|
||||
This mutating helper is reserved for explicit user sends (composer, starter prompts, and planner-question answers). Tab activation must call fetchTaskPlannerChatSession instead so empty task-detail visits do not create chat history.
|
||||
*/
|
||||
return api<ChatSessionResponse>(
|
||||
withProjectId(`/chat/task-planner/${encodeURIComponent(normalizedTaskId)}/session`, projectId),
|
||||
{
|
||||
method: "POST",
|
||||
body: JSON.stringify({
|
||||
...(normalizedProvider && normalizedModelId ? { modelProvider: normalizedProvider, modelId: normalizedModelId } : {}),
|
||||
}),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Update a chat session (title, status, thinkingLevel, model, or agent target) */
|
||||
export function updateChatSession(
|
||||
id: string,
|
||||
updates: {
|
||||
title?: string | null;
|
||||
status?: string;
|
||||
modelProvider?: string | null;
|
||||
modelId?: string | null;
|
||||
agentId?: string;
|
||||
thinkingLevel?: string | null;
|
||||
pinned?: boolean;
|
||||
},
|
||||
projectId?: string,
|
||||
): Promise<ChatSessionResponse> {
|
||||
return api<ChatSessionResponse>(withProjectId(`/chat/sessions/${encodeURIComponent(id)}`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
/** Delete a chat session */
|
||||
export function deleteChatSession(id: string, projectId?: string): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(withProjectId(`/chat/sessions/${encodeURIComponent(id)}`, projectId), {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch messages for a chat session */
|
||||
export function fetchChatMessages(
|
||||
sessionId: string,
|
||||
opts?: { limit?: number; offset?: number; before?: string; order?: "asc" | "desc" },
|
||||
projectId?: string,
|
||||
): Promise<ChatMessageListResponse> {
|
||||
const search = new URLSearchParams();
|
||||
if (opts?.limit !== undefined) search.set("limit", String(opts.limit));
|
||||
if (opts?.offset !== undefined) search.set("offset", String(opts.offset));
|
||||
if (opts?.before) search.set("before", opts.before);
|
||||
if (opts?.order) search.set("order", opts.order);
|
||||
const qs = search.toString();
|
||||
return api<ChatMessageListResponse>(
|
||||
withProjectId(`/chat/sessions/${encodeURIComponent(sessionId)}/messages${qs ? `?${qs}` : ""}`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
/** Delete a specific message from a chat session */
|
||||
export function deleteChatMessage(
|
||||
sessionId: string,
|
||||
messageId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(
|
||||
withProjectId(`/chat/sessions/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(messageId)}`, projectId),
|
||||
{
|
||||
method: "DELETE",
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* FNXC:ChatMessageEdit 2026-07-07-09:00:
|
||||
* Edit an earlier user message in a direct (model-loop) chat session. Truncates the persisted
|
||||
* transcript from (and including) the target message onward AND rewinds the pi session context
|
||||
* server-side, so the returned `retained` list is the surviving pre-edit history. Does NOT
|
||||
* trigger regeneration — the caller resends the edited content via the existing streaming send.
|
||||
*/
|
||||
export function editChatMessage(
|
||||
sessionId: string,
|
||||
messageId: string,
|
||||
content: string,
|
||||
projectId?: string,
|
||||
): Promise<{ retained: ChatMessage[] }> {
|
||||
return api<{ retained: ChatMessage[] }>(
|
||||
withProjectId(`/chat/sessions/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(messageId)}`, projectId),
|
||||
{
|
||||
method: "PATCH",
|
||||
body: JSON.stringify({ content }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
export function fetchChatRooms(
|
||||
options: { status?: string; agentId?: string } = {},
|
||||
projectId?: string,
|
||||
): Promise<ChatRoomListResponse> {
|
||||
const search = new URLSearchParams();
|
||||
if (projectId) search.set("projectId", projectId);
|
||||
if (options.status) search.set("status", options.status);
|
||||
if (options.agentId) search.set("agentId", options.agentId);
|
||||
const qs = search.toString();
|
||||
return api<ChatRoomListResponse>(`/chat/rooms${qs ? `?${qs}` : ""}`);
|
||||
}
|
||||
|
||||
export function fetchChatRoom(id: string, projectId?: string): Promise<ChatRoomResponse> {
|
||||
return api<ChatRoomResponse>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}`, projectId));
|
||||
}
|
||||
|
||||
export function createChatRoom(
|
||||
input: { name: string; description?: string | null; createdBy?: string | null; memberAgentIds?: string[]; thinkingLevel?: string | null },
|
||||
projectId?: string,
|
||||
): Promise<ChatRoomResponse> {
|
||||
const body = { ...input, ...(projectId ? { projectId } : {}) };
|
||||
return api<ChatRoomResponse>(withProjectId("/chat/rooms", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
}
|
||||
|
||||
export function updateChatRoom(
|
||||
id: string,
|
||||
updates: { name?: string; description?: string | null; status?: "active" | "archived"; thinkingLevel?: string | null },
|
||||
projectId?: string,
|
||||
): Promise<{ room: ChatRoom }> {
|
||||
return api<{ room: ChatRoom }>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
export function deleteChatRoom(id: string, projectId?: string): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}`, projectId), {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
export function fetchChatRoomMembers(id: string, projectId?: string): Promise<ChatRoomMembersResponse> {
|
||||
return api<ChatRoomMembersResponse>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}/members`, projectId));
|
||||
}
|
||||
|
||||
export function addChatRoomMember(
|
||||
id: string,
|
||||
input: { agentId: string; role?: "owner" | "member" },
|
||||
projectId?: string,
|
||||
): Promise<{ member: ChatRoomMember }> {
|
||||
return api<{ member: ChatRoomMember }>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}/members`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
export function removeChatRoomMember(id: string, agentId: string, projectId?: string): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(
|
||||
withProjectId(`/chat/rooms/${encodeURIComponent(id)}/members/${encodeURIComponent(agentId)}`, projectId),
|
||||
{ method: "DELETE" },
|
||||
);
|
||||
}
|
||||
|
||||
export function fetchChatRoomMessages(
|
||||
id: string,
|
||||
opts?: { limit?: number; offset?: number; before?: string; order?: "asc" | "desc" },
|
||||
projectId?: string,
|
||||
): Promise<ChatRoomMessageListResponse> {
|
||||
const search = new URLSearchParams();
|
||||
if (opts?.limit !== undefined) search.set("limit", String(opts.limit));
|
||||
if (opts?.offset !== undefined) search.set("offset", String(opts.offset));
|
||||
if (opts?.before) search.set("before", opts.before);
|
||||
if (opts?.order) search.set("order", opts.order);
|
||||
const qs = search.toString();
|
||||
return api<ChatRoomMessageListResponse>(
|
||||
withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages${qs ? `?${qs}` : ""}`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
export async function uploadChatRoomAttachment(
|
||||
roomId: string,
|
||||
file: File,
|
||||
projectId?: string,
|
||||
): Promise<{ attachment: ChatAttachment }> {
|
||||
const formData = new FormData();
|
||||
formData.append("file", file);
|
||||
const res = await fetch(buildApiUrl(withProjectId(`/chat/rooms/${encodeURIComponent(roomId)}/attachments`, projectId)), {
|
||||
method: "POST",
|
||||
headers: withTokenHeader(),
|
||||
body: formData,
|
||||
});
|
||||
const data = await res.json();
|
||||
if (!res.ok) throw new Error((data as { error?: string }).error || "Upload failed");
|
||||
return data as { attachment: ChatAttachment };
|
||||
}
|
||||
|
||||
export function attachmentBaseUrlForRoom(roomId: string, projectId?: string): string {
|
||||
return buildApiUrl(withProjectId(`/chat/rooms/${encodeURIComponent(roomId)}/attachments/`, projectId));
|
||||
}
|
||||
|
||||
export function postChatRoomMessage(
|
||||
id: string,
|
||||
input: { content: string; senderAgentId?: null; mentions?: string[]; attachments?: ChatAttachment[] },
|
||||
projectId?: string,
|
||||
): Promise<ChatRoomMessageResponse> {
|
||||
return api<ChatRoomMessageResponse>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
export function deleteChatRoomMessage(
|
||||
id: string,
|
||||
messageId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(
|
||||
withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages/${encodeURIComponent(messageId)}`, projectId),
|
||||
{ method: "DELETE" },
|
||||
);
|
||||
}
|
||||
|
||||
export function clearChatRoomMessages(
|
||||
id: string,
|
||||
projectId?: string,
|
||||
): Promise<{ success: boolean; deletedCount: number }> {
|
||||
return api<{ success: boolean; deletedCount: number }>(
|
||||
withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages`, projectId),
|
||||
{ method: "DELETE" },
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Room POST /messages in FN-3808 is persist-only (201 JSON response).
|
||||
* Do not add streamChatRoomResponse until FN-3810 introduces AI invocation/streaming.
|
||||
*/
|
||||
|
||||
/** Cancel an in-flight chat generation. */
|
||||
export function cancelChatResponse(
|
||||
sessionId: string,
|
||||
projectId?: string,
|
||||
): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>(
|
||||
withProjectId(`/chat/sessions/${encodeURIComponent(sessionId)}/cancel`, projectId),
|
||||
{
|
||||
method: "POST",
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Send a chat message and receive the AI response via SSE streaming.
|
||||
*
|
||||
* The backend exposes `POST /api/chat/sessions/:id/messages` which returns an SSE
|
||||
* stream (not JSON). Events: `thinking`, `text`, `fallback`, `done`, `error`.
|
||||
*
|
||||
* Since `EventSource` only supports GET requests, this function uses `fetch()`
|
||||
* with a ReadableStream to parse SSE events from the POST response body.
|
||||
* When attachments are provided, the request body is sent as multipart form data;
|
||||
* otherwise it uses the existing JSON payload path.
|
||||
*/
|
||||
export interface ChatFailureReference {
|
||||
kind: string;
|
||||
id: string;
|
||||
label?: string;
|
||||
}
|
||||
|
||||
export interface ChatFailureInfo {
|
||||
summary: string;
|
||||
errorClass?: string;
|
||||
code?: string;
|
||||
detail?: string;
|
||||
reference?: ChatFailureReference;
|
||||
}
|
||||
|
||||
function extractChatFailureInfo(value: unknown): ChatFailureInfo | null {
|
||||
if (!value || typeof value !== "object") {
|
||||
return null;
|
||||
}
|
||||
|
||||
const record = value as Record<string, unknown>;
|
||||
const summary = typeof record.summary === "string" ? record.summary.trim() : "";
|
||||
if (!summary) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const reference = (() => {
|
||||
const rawReference = record.reference;
|
||||
if (!rawReference || typeof rawReference !== "object") {
|
||||
return undefined;
|
||||
}
|
||||
const referenceRecord = rawReference as Record<string, unknown>;
|
||||
const kind = typeof referenceRecord.kind === "string" ? referenceRecord.kind.trim() : "";
|
||||
const id = typeof referenceRecord.id === "string" ? referenceRecord.id.trim() : "";
|
||||
if (!kind || !id) {
|
||||
return undefined;
|
||||
}
|
||||
return {
|
||||
kind,
|
||||
id,
|
||||
...(typeof referenceRecord.label === "string" && referenceRecord.label.trim()
|
||||
? { label: referenceRecord.label.trim() }
|
||||
: {}),
|
||||
} satisfies ChatFailureReference;
|
||||
})();
|
||||
|
||||
return {
|
||||
summary,
|
||||
...(typeof record.errorClass === "string" && record.errorClass.trim()
|
||||
? { errorClass: record.errorClass.trim() }
|
||||
: {}),
|
||||
...(typeof record.code === "string" && record.code.trim()
|
||||
? { code: record.code.trim() }
|
||||
: {}),
|
||||
...(typeof record.detail === "string" && record.detail.trim()
|
||||
? { detail: record.detail.trim() }
|
||||
: {}),
|
||||
...(reference ? { reference } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
function parseChatErrorPayload(rawData: string): string | ChatFailureInfo {
|
||||
try {
|
||||
const parsed = JSON.parse(rawData);
|
||||
const structured = extractChatFailureInfo(parsed);
|
||||
if (structured) {
|
||||
return structured;
|
||||
}
|
||||
if (parsed && typeof parsed === "object" && typeof (parsed as { message?: unknown }).message === "string") {
|
||||
return (parsed as { message: string }).message;
|
||||
}
|
||||
return typeof parsed === "string" ? parsed : rawData || "Stream error";
|
||||
} catch {
|
||||
return rawData || "Stream error";
|
||||
}
|
||||
}
|
||||
|
||||
export interface ChatStreamErrorMeta {
|
||||
/** True once the POST stream was accepted and the server started an SSE response. */
|
||||
requestAccepted: boolean;
|
||||
/** True when the error came from an SSE event rather than the initial HTTP response. */
|
||||
receivedStreamEvent: boolean;
|
||||
}
|
||||
|
||||
export interface ChatStreamHandlers {
|
||||
onThinking?: (data: string) => void;
|
||||
onText?: (data: string) => void;
|
||||
onToolStart?: (data: { toolName: string; args?: Record<string, unknown> }) => void;
|
||||
onToolEnd?: (data: { toolName: string; isError: boolean; result?: unknown }) => void;
|
||||
onFallback?: (data: { primaryModel: string; fallbackModel: string; triggerPoint: "session-creation" | "prompt-time" }) => void;
|
||||
onDone?: (data: { messageId: string; message?: ChatMessage }) => void;
|
||||
onError?: (data: string | ChatFailureInfo, meta?: ChatStreamErrorMeta) => void;
|
||||
onConnectionStateChange?: (state: StreamConnectionState) => void;
|
||||
}
|
||||
|
||||
export function streamChatResponse(
|
||||
sessionId: string,
|
||||
content: string,
|
||||
handlers: ChatStreamHandlers,
|
||||
attachments?: File[],
|
||||
projectId?: string,
|
||||
options?: { maxReconnectAttempts?: number; firstEventTimeoutMs?: number; taskId?: string },
|
||||
): { close: () => void; isConnected: () => boolean } {
|
||||
const url = buildApiUrl(withProjectId(`/chat/sessions/${encodeURIComponent(sessionId)}/messages`, projectId));
|
||||
|
||||
const abortController = new AbortController();
|
||||
let closedByUser = false;
|
||||
let terminated = false;
|
||||
let requestAccepted = false;
|
||||
let receivedStreamEvent = false;
|
||||
const firstEventTimeoutMs = Math.max(1_000, options?.firstEventTimeoutMs ?? 60_000);
|
||||
let firstEventTimer: ReturnType<typeof setTimeout> | null = null;
|
||||
|
||||
const clearFirstEventTimer = (): void => {
|
||||
if (firstEventTimer) {
|
||||
clearTimeout(firstEventTimer);
|
||||
firstEventTimer = null;
|
||||
}
|
||||
};
|
||||
|
||||
const markFirstEventReceived = (): void => {
|
||||
if (receivedStreamEvent) {
|
||||
return;
|
||||
}
|
||||
receivedStreamEvent = true;
|
||||
clearFirstEventTimer();
|
||||
};
|
||||
|
||||
const dispatchEvent = (eventName: string, rawData: string): void => {
|
||||
if (!eventName) {
|
||||
return;
|
||||
}
|
||||
|
||||
markFirstEventReceived();
|
||||
|
||||
switch (eventName) {
|
||||
case "thinking":
|
||||
try {
|
||||
handlers.onThinking?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
handlers.onThinking?.(rawData);
|
||||
}
|
||||
break;
|
||||
case "text":
|
||||
try {
|
||||
handlers.onText?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
handlers.onText?.(rawData);
|
||||
}
|
||||
break;
|
||||
case "tool_start":
|
||||
try {
|
||||
handlers.onToolStart?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
// skip malformed event
|
||||
}
|
||||
break;
|
||||
case "tool_end":
|
||||
try {
|
||||
handlers.onToolEnd?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
// skip malformed event
|
||||
}
|
||||
break;
|
||||
case "fallback":
|
||||
try {
|
||||
handlers.onFallback?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
// skip malformed event
|
||||
}
|
||||
break;
|
||||
case "done":
|
||||
terminated = true;
|
||||
try {
|
||||
const parsed = JSON.parse(rawData) as { messageId?: unknown; message?: unknown };
|
||||
handlers.onDone?.({
|
||||
messageId: typeof parsed.messageId === "string" ? parsed.messageId : "",
|
||||
...(parsed.message && typeof parsed.message === "object" ? { message: parsed.message as ChatMessage } : {}),
|
||||
});
|
||||
} catch {
|
||||
handlers.onDone?.({ messageId: "" });
|
||||
}
|
||||
break;
|
||||
case "error":
|
||||
terminated = true;
|
||||
handlers.onError?.(parseChatErrorPayload(rawData), { requestAccepted: true, receivedStreamEvent: true });
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
// Start streaming via POST
|
||||
(async () => {
|
||||
try {
|
||||
const hasAttachments = Array.isArray(attachments) && attachments.length > 0;
|
||||
const body = hasAttachments
|
||||
? (() => {
|
||||
const formData = new FormData();
|
||||
formData.append("content", content);
|
||||
if (options?.taskId) formData.append("taskId", options.taskId);
|
||||
attachments.forEach((file) => formData.append("attachments", file));
|
||||
return formData;
|
||||
})()
|
||||
: JSON.stringify({ content, ...(options?.taskId ? { taskId: options.taskId } : {}) });
|
||||
|
||||
const res = await fetch(url, {
|
||||
method: "POST",
|
||||
headers: hasAttachments ? withTokenHeader() : withTokenHeader({ "Content-Type": "application/json" }),
|
||||
body,
|
||||
signal: abortController.signal,
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
const errorBody = await res.text();
|
||||
let errorMsg = `Request failed: ${res.status}`;
|
||||
try {
|
||||
const parsed = JSON.parse(errorBody);
|
||||
errorMsg = parsed.error || errorMsg;
|
||||
} catch { /* use default */ }
|
||||
handlers.onError?.(errorMsg, { requestAccepted: false, receivedStreamEvent: false });
|
||||
return;
|
||||
}
|
||||
|
||||
if (!res.body) {
|
||||
handlers.onError?.("No response body", { requestAccepted: true, receivedStreamEvent: false });
|
||||
return;
|
||||
}
|
||||
|
||||
requestAccepted = true;
|
||||
handlers.onConnectionStateChange?.("connected");
|
||||
firstEventTimer = setTimeout(() => {
|
||||
if (terminated || closedByUser || receivedStreamEvent) {
|
||||
return;
|
||||
}
|
||||
/*
|
||||
FNXC:ChatReliability 2026-07-04-00:00:
|
||||
Accepted chat requests can keep generating after the dashboard has not yet seen the first SSE event. Treat this timer as a non-terminal wait marker so the UI stays in-progress and can reconcile late persisted output instead of showing a false Response failed bubble.
|
||||
*/
|
||||
firstEventTimer = null;
|
||||
}, firstEventTimeoutMs);
|
||||
|
||||
const reader = res.body.getReader();
|
||||
const decoder = new TextDecoder();
|
||||
let buffer = "";
|
||||
let currentEvent = "";
|
||||
let currentDataLines: string[] = [];
|
||||
|
||||
// POST-based chat responses still speak SSE, so parser state must persist
|
||||
// across ReadableStream chunks. Networks can split `event:` and `data:`
|
||||
// lines arbitrarily, and resetting state per-read drops assistant output.
|
||||
const processLines = (chunk: string, flushPendingEvent = false): void => {
|
||||
buffer += chunk;
|
||||
const lines = buffer.split("\n");
|
||||
buffer = lines.pop() || "";
|
||||
|
||||
// At stream end, flush any remaining buffered line so complete trailing
|
||||
// events are parsed even when the payload has no final newline.
|
||||
if (flushPendingEvent && buffer.length > 0) {
|
||||
lines.push(buffer);
|
||||
buffer = "";
|
||||
}
|
||||
|
||||
for (const rawLine of lines) {
|
||||
const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
|
||||
|
||||
if (line.startsWith("event:")) {
|
||||
currentEvent = line.slice(6).trim();
|
||||
} else if (line.startsWith("data:")) {
|
||||
const value = line.slice(5);
|
||||
// Strip only the optional SSE protocol delimiter-space after `data:`.
|
||||
// Payload whitespace (including JSON-string leading spaces) must stay verbatim.
|
||||
currentDataLines.push(value.startsWith(" ") ? value.slice(1) : value);
|
||||
} else if (line === "") {
|
||||
const currentData = currentDataLines.join("\n");
|
||||
dispatchEvent(currentEvent, currentData);
|
||||
currentEvent = "";
|
||||
currentDataLines = [];
|
||||
}
|
||||
}
|
||||
|
||||
// Flush any pending event/data at stream end.
|
||||
// Only dispatch if we have both a valid event type and accumulated data.
|
||||
if (flushPendingEvent && currentEvent && currentDataLines.length > 0) {
|
||||
const trailingData = currentDataLines.join("\n");
|
||||
dispatchEvent(currentEvent, trailingData);
|
||||
currentEvent = "";
|
||||
currentDataLines = [];
|
||||
}
|
||||
};
|
||||
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) {
|
||||
processLines(decoder.decode(), true);
|
||||
break;
|
||||
}
|
||||
|
||||
processLines(decoder.decode(value, { stream: true }));
|
||||
}
|
||||
|
||||
const hasUndispatchedTrailingFragment =
|
||||
buffer.length > 0 || currentEvent.length > 0 || currentDataLines.length > 0;
|
||||
|
||||
// Server closed the stream without emitting a terminal `done` or `error`
|
||||
// SSE event (common on flaky mobile networks, proxy idle-kill, or
|
||||
// backgrounded tabs). Surface as an error so the client unwinds
|
||||
// streaming state instead of getting stuck with isStreaming=true.
|
||||
// Ignore dangling partial fragments at EOF: those indicate a truncated
|
||||
// trailing event that should be dropped rather than surfaced as transport
|
||||
// failure.
|
||||
if (!terminated && !closedByUser && !hasUndispatchedTrailingFragment) {
|
||||
handlers.onError?.("Connection closed unexpectedly", { requestAccepted, receivedStreamEvent });
|
||||
}
|
||||
clearFirstEventTimer();
|
||||
} catch (err: unknown) {
|
||||
if (err instanceof DOMException && err.name === "AbortError") {
|
||||
if (!closedByUser && !terminated) {
|
||||
handlers.onError?.("Connection aborted", { requestAccepted, receivedStreamEvent });
|
||||
}
|
||||
clearFirstEventTimer();
|
||||
return;
|
||||
}
|
||||
if (closedByUser) {
|
||||
clearFirstEventTimer();
|
||||
return;
|
||||
}
|
||||
clearFirstEventTimer();
|
||||
handlers.onError?.(err instanceof Error ? err.message : "Connection error", { requestAccepted, receivedStreamEvent });
|
||||
}
|
||||
})();
|
||||
|
||||
return {
|
||||
close: () => {
|
||||
closedByUser = true;
|
||||
clearFirstEventTimer();
|
||||
abortController.abort();
|
||||
},
|
||||
isConnected: () => !closedByUser,
|
||||
};
|
||||
}
|
||||
|
||||
export function attachChatStream(
|
||||
sessionId: string,
|
||||
handlers: ChatStreamHandlers,
|
||||
projectId?: string,
|
||||
options?: { lastEventId?: number },
|
||||
): { close: () => void; isConnected: () => boolean } {
|
||||
const url = buildApiUrl(withProjectId(`/chat/sessions/${encodeURIComponent(sessionId)}/stream`, projectId));
|
||||
const abortController = new AbortController();
|
||||
let closedByUser = false;
|
||||
let terminated = false;
|
||||
|
||||
const dispatchEvent = (eventName: string, rawData: string): void => {
|
||||
if (!eventName) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch (eventName) {
|
||||
case "thinking":
|
||||
try {
|
||||
handlers.onThinking?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
handlers.onThinking?.(rawData);
|
||||
}
|
||||
break;
|
||||
case "text":
|
||||
try {
|
||||
handlers.onText?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
handlers.onText?.(rawData);
|
||||
}
|
||||
break;
|
||||
case "tool_start":
|
||||
try {
|
||||
handlers.onToolStart?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
// skip malformed event
|
||||
}
|
||||
break;
|
||||
case "tool_end":
|
||||
try {
|
||||
handlers.onToolEnd?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
// skip malformed event
|
||||
}
|
||||
break;
|
||||
case "fallback":
|
||||
try {
|
||||
handlers.onFallback?.(JSON.parse(rawData));
|
||||
} catch {
|
||||
// skip malformed event
|
||||
}
|
||||
break;
|
||||
case "done":
|
||||
terminated = true;
|
||||
try {
|
||||
const parsed = JSON.parse(rawData) as { messageId?: unknown; message?: unknown };
|
||||
handlers.onDone?.({
|
||||
messageId: typeof parsed.messageId === "string" ? parsed.messageId : "",
|
||||
...(parsed.message && typeof parsed.message === "object" ? { message: parsed.message as ChatMessage } : {}),
|
||||
});
|
||||
} catch {
|
||||
handlers.onDone?.({ messageId: "" });
|
||||
}
|
||||
break;
|
||||
case "error":
|
||||
terminated = true;
|
||||
handlers.onError?.(parseChatErrorPayload(rawData));
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
(async () => {
|
||||
try {
|
||||
const requestHeaders = new Headers(withTokenHeader() as HeadersInit);
|
||||
if (typeof options?.lastEventId === "number") {
|
||||
requestHeaders.set("Last-Event-ID", String(options.lastEventId));
|
||||
}
|
||||
|
||||
const res = await fetch(url, {
|
||||
method: "GET",
|
||||
headers: requestHeaders,
|
||||
signal: abortController.signal,
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
const errorBody = await res.text();
|
||||
let errorMsg = `Request failed: ${res.status}`;
|
||||
try {
|
||||
const parsed = JSON.parse(errorBody);
|
||||
errorMsg = parsed.error || errorMsg;
|
||||
} catch { /* use default */ }
|
||||
handlers.onError?.(errorMsg);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!res.body) {
|
||||
handlers.onError?.("No response body");
|
||||
return;
|
||||
}
|
||||
|
||||
handlers.onConnectionStateChange?.("connected");
|
||||
|
||||
const reader = res.body.getReader();
|
||||
const decoder = new TextDecoder();
|
||||
let buffer = "";
|
||||
let currentEvent = "";
|
||||
let currentDataLines: string[] = [];
|
||||
|
||||
const processLines = (chunk: string, flushPendingEvent = false): void => {
|
||||
buffer += chunk;
|
||||
const lines = buffer.split("\n");
|
||||
buffer = lines.pop() || "";
|
||||
|
||||
if (flushPendingEvent && buffer.length > 0) {
|
||||
lines.push(buffer);
|
||||
buffer = "";
|
||||
}
|
||||
|
||||
for (const rawLine of lines) {
|
||||
const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
|
||||
|
||||
if (line.startsWith("event:")) {
|
||||
currentEvent = line.slice(6).trim();
|
||||
} else if (line.startsWith("data:")) {
|
||||
const value = line.slice(5);
|
||||
// Strip only the optional SSE protocol delimiter-space after `data:`.
|
||||
// Payload whitespace (including JSON-string leading spaces) must stay verbatim.
|
||||
currentDataLines.push(value.startsWith(" ") ? value.slice(1) : value);
|
||||
} else if (line === "") {
|
||||
const currentData = currentDataLines.join("\n");
|
||||
dispatchEvent(currentEvent, currentData);
|
||||
currentEvent = "";
|
||||
currentDataLines = [];
|
||||
}
|
||||
}
|
||||
|
||||
if (flushPendingEvent && currentEvent && currentDataLines.length > 0) {
|
||||
const trailingData = currentDataLines.join("\n");
|
||||
dispatchEvent(currentEvent, trailingData);
|
||||
currentEvent = "";
|
||||
currentDataLines = [];
|
||||
}
|
||||
};
|
||||
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) {
|
||||
processLines(decoder.decode(), true);
|
||||
break;
|
||||
}
|
||||
|
||||
processLines(decoder.decode(value, { stream: true }));
|
||||
}
|
||||
|
||||
const hasUndispatchedTrailingFragment =
|
||||
buffer.length > 0 || currentEvent.length > 0 || currentDataLines.length > 0;
|
||||
|
||||
if (!terminated && !closedByUser && !hasUndispatchedTrailingFragment) {
|
||||
return;
|
||||
}
|
||||
} catch (err: unknown) {
|
||||
if (err instanceof DOMException && err.name === "AbortError") {
|
||||
if (!closedByUser && !terminated) {
|
||||
handlers.onError?.("Connection aborted");
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (closedByUser) {
|
||||
return;
|
||||
}
|
||||
handlers.onError?.(err instanceof Error ? err.message : "Connection error");
|
||||
}
|
||||
})();
|
||||
|
||||
return {
|
||||
close: () => {
|
||||
closedByUser = true;
|
||||
abortController.abort();
|
||||
},
|
||||
isConnected: () => !closedByUser,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* FNXC:CodeOrganization 2026-07-18-14:00:
|
||||
* Preserve legacy `insights` imports while implementations live in insights.ts.
|
||||
*/
|
||||
export {
|
||||
archiveInsight,
|
||||
deleteInsight,
|
||||
dismissInsight,
|
||||
fetchInsight,
|
||||
fetchInsightRun,
|
||||
fetchInsightRuns,
|
||||
fetchInsights,
|
||||
getInsightCreateTaskData,
|
||||
triggerInsightRun,
|
||||
unarchiveInsight,
|
||||
updateInsight,
|
||||
} from "./insights.js";
|
||||
export type {
|
||||
InsightsListResponse,
|
||||
RunsListResponse,
|
||||
} from "./insights.js";
|
||||
|
||||
159
packages/dashboard/app/api/event-source.ts
Normal file
159
packages/dashboard/app/api/event-source.ts
Normal file
@@ -0,0 +1,159 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Resilient EventSource client peeled from legacy.ts for shared SSE reconnect semantics.
|
||||
*/
|
||||
import { appendTokenQuery } from "../auth";
|
||||
|
||||
export type StreamConnectionState = "connected" | "reconnecting";
|
||||
|
||||
// Track every live createResilientEventSource instance so we can close their
|
||||
// underlying EventSource sockets on page unload. Without this, Chrome holds
|
||||
// the HTTP/1.1 sockets open in its keep-alive pool across refreshes, exhausts
|
||||
// its 6-per-origin limit after ~3 refreshes, and every new fetch stalls —
|
||||
// leaving the dashboard frozen on "Initializing...". sse-bus.ts has its own
|
||||
// handler; this one covers the parallel EventSource path in api.ts.
|
||||
const activeResilientEventSources = new Set<{ close: () => void }>();
|
||||
if (typeof window !== "undefined") {
|
||||
const closeAll = () => {
|
||||
for (const handle of Array.from(activeResilientEventSources)) {
|
||||
try { handle.close(); } catch { /* best effort */ }
|
||||
}
|
||||
};
|
||||
window.addEventListener("pagehide", closeAll);
|
||||
window.addEventListener("beforeunload", closeAll);
|
||||
}
|
||||
|
||||
export interface ResilientEventSourceOptions {
|
||||
maxReconnectAttempts?: number;
|
||||
onConnectionStateChange?: (state: StreamConnectionState) => void;
|
||||
onFatalError?: (message: string) => void;
|
||||
}
|
||||
|
||||
export interface ResilientEventHandlers {
|
||||
onOpen?: () => void;
|
||||
onMessage?: (event: MessageEvent) => void;
|
||||
events?: Record<string, (event: MessageEvent) => void>;
|
||||
}
|
||||
|
||||
function appendLastEventId(url: string, lastEventId: number | null): string {
|
||||
if (lastEventId === null || lastEventId <= 0) {
|
||||
return url;
|
||||
}
|
||||
|
||||
const separator = url.includes("?") ? "&" : "?";
|
||||
return `${url}${separator}lastEventId=${encodeURIComponent(String(lastEventId))}`;
|
||||
}
|
||||
|
||||
export function createResilientEventSource(
|
||||
url: string,
|
||||
handlers: ResilientEventHandlers,
|
||||
options: ResilientEventSourceOptions = {},
|
||||
): { close: () => void; isConnected: () => boolean } {
|
||||
const maxReconnectAttempts = options.maxReconnectAttempts ?? 10;
|
||||
let eventSource: EventSource | null = null;
|
||||
let closedByUser = false;
|
||||
let reconnectAttempts = 0;
|
||||
let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
|
||||
let lastSeenEventId: number | null = null;
|
||||
let reconnectingNotified = false;
|
||||
|
||||
const shouldDispatch = (event: MessageEvent): boolean => {
|
||||
const rawId = event.lastEventId;
|
||||
if (!rawId) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const parsedId = Number.parseInt(rawId, 10);
|
||||
if (!Number.isFinite(parsedId)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (lastSeenEventId !== null && parsedId <= lastSeenEventId) {
|
||||
return false;
|
||||
}
|
||||
|
||||
lastSeenEventId = parsedId;
|
||||
return true;
|
||||
};
|
||||
|
||||
const connect = (): void => {
|
||||
if (closedByUser) return;
|
||||
|
||||
const nextUrl = appendLastEventId(url, lastSeenEventId);
|
||||
// EventSource can't set headers — carry the bearer token via `fn_token=`.
|
||||
const source = new EventSource(appendTokenQuery(nextUrl));
|
||||
eventSource = source;
|
||||
|
||||
source.onopen = () => {
|
||||
reconnectAttempts = 0;
|
||||
reconnectingNotified = false;
|
||||
options.onConnectionStateChange?.("connected");
|
||||
handlers.onOpen?.();
|
||||
};
|
||||
|
||||
source.onmessage = (event) => {
|
||||
const messageEvent = event as MessageEvent;
|
||||
if (!shouldDispatch(messageEvent)) return;
|
||||
handlers.onMessage?.(messageEvent);
|
||||
};
|
||||
|
||||
for (const [eventName, handler] of Object.entries(handlers.events ?? {})) {
|
||||
source.addEventListener(eventName, (event: Event) => {
|
||||
const messageEvent = event as MessageEvent;
|
||||
if (!shouldDispatch(messageEvent)) return;
|
||||
handler(messageEvent);
|
||||
});
|
||||
}
|
||||
|
||||
source.onerror = () => {
|
||||
if (closedByUser || eventSource !== source) return;
|
||||
|
||||
const readyState = source.readyState;
|
||||
if (readyState === EventSource.CONNECTING) {
|
||||
if (!reconnectingNotified) {
|
||||
reconnectingNotified = true;
|
||||
options.onConnectionStateChange?.("reconnecting");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
source.close();
|
||||
if (eventSource === source) {
|
||||
eventSource = null;
|
||||
}
|
||||
|
||||
if (reconnectAttempts >= maxReconnectAttempts) {
|
||||
options.onFatalError?.("Connection lost");
|
||||
return;
|
||||
}
|
||||
|
||||
reconnectingNotified = true;
|
||||
options.onConnectionStateChange?.("reconnecting");
|
||||
reconnectAttempts += 1;
|
||||
|
||||
const delayMs = Math.min(1000 * 2 ** (reconnectAttempts - 1), 30000);
|
||||
reconnectTimer = setTimeout(() => {
|
||||
reconnectTimer = null;
|
||||
connect();
|
||||
}, delayMs);
|
||||
};
|
||||
};
|
||||
|
||||
connect();
|
||||
|
||||
const handle = {
|
||||
close: () => {
|
||||
closedByUser = true;
|
||||
if (reconnectTimer) {
|
||||
clearTimeout(reconnectTimer);
|
||||
reconnectTimer = null;
|
||||
}
|
||||
eventSource?.close();
|
||||
activeResilientEventSources.delete(handle);
|
||||
},
|
||||
isConnected: () => !closedByUser && eventSource?.readyState === EventSource.OPEN,
|
||||
};
|
||||
activeResilientEventSources.add(handle);
|
||||
return handle;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -47,6 +47,12 @@ export interface Mission {
|
||||
status: MissionStatus;
|
||||
interviewState: "not_started" | "in_progress" | "completed" | "needs_update";
|
||||
autoAdvance?: boolean;
|
||||
/**
|
||||
* FNXC:MissionAutoMerge 2026-07-19-12:30:
|
||||
* Mission-level auto-merge override (create/update payloads + list/detail responses).
|
||||
* `null` clears an explicit override back to project default on PATCH.
|
||||
*/
|
||||
autoMerge?: boolean | null;
|
||||
/** When true, enable autopilot monitoring system for this mission */
|
||||
autopilotEnabled?: boolean;
|
||||
/** Current autopilot runtime state */
|
||||
@@ -148,7 +154,7 @@ export function fetchMission(missionId: string, projectId?: string): Promise<Mis
|
||||
}
|
||||
|
||||
/** Update mission */
|
||||
export function updateMission(missionId: string, updates: Partial<Mission> & { autoMerge?: boolean | null }, projectId?: string): Promise<Mission> {
|
||||
export function updateMission(missionId: string, updates: Partial<Mission>, projectId?: string): Promise<Mission> {
|
||||
return api<Mission>(withProjectId(`/missions/${encodeURIComponent(missionId)}`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
|
||||
903
packages/dashboard/app/api/projects.ts
Normal file
903
packages/dashboard/app/api/projects.ts
Normal file
@@ -0,0 +1,903 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Multi-project management client API peeled from legacy.ts.
|
||||
*/
|
||||
import type {
|
||||
NodeConfig,
|
||||
NodeStatus,
|
||||
MeshClusterSnapshot,
|
||||
SystemMetrics,
|
||||
DiscoveryConfig,
|
||||
DockerNodeConfig,
|
||||
ManagedDockerNodeInput,
|
||||
DockerHostConfig,
|
||||
DockerResourceSizing,
|
||||
DockerVolumeMount,
|
||||
DockerExtraCli,
|
||||
DockerNodeStatus,
|
||||
ProjectNodePathMapping,
|
||||
ActivityEventType,
|
||||
Task,
|
||||
} from "@fusion/core";
|
||||
import { api, proxyApi } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { getAuthToken } from "../auth";
|
||||
import { dedupe } from "./dedupe.js";
|
||||
|
||||
// ── Project Management API (Multi-Project Support) ───────────────────────
|
||||
|
||||
/** Project information returned by project endpoints */
|
||||
export interface ProjectInfo {
|
||||
id: string;
|
||||
name: string;
|
||||
path: string;
|
||||
status: "active" | "paused" | "errored" | "initializing";
|
||||
isolationMode: "in-process" | "child-process";
|
||||
nodeId?: string;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
lastActivityAt?: string;
|
||||
}
|
||||
|
||||
/** Project health metrics */
|
||||
export interface CodebaseMetrics {
|
||||
tokenEstimate: number;
|
||||
sourceFileCount: number;
|
||||
sourceByteCount: number;
|
||||
diskBytes: number;
|
||||
diskFileCount: number;
|
||||
method: string;
|
||||
truncated: boolean;
|
||||
}
|
||||
|
||||
export interface ProjectHealth {
|
||||
projectId: string;
|
||||
status: "active" | "paused" | "errored" | "initializing";
|
||||
activeTaskCount: number;
|
||||
inFlightAgentCount: number;
|
||||
lastActivityAt?: string;
|
||||
lastErrorAt?: string;
|
||||
lastErrorMessage?: string;
|
||||
totalTasksCompleted: number;
|
||||
totalTasksFailed: number;
|
||||
averageTaskDurationMs?: number;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Executor state values.
|
||||
*
|
||||
* FNXC:EngineControls 2026-06-22-00:00:
|
||||
* A globally stopped AI engine (`globalPause`) is an operator action, not idleness; the footer must expose it as "Stopped" in error red with the stop-rectangle icon.
|
||||
*/
|
||||
export type ExecutorState = "idle" | "running" | "paused" | "stopped";
|
||||
|
||||
/** Aggregated executor statistics for the status bar.
|
||||
*
|
||||
* Counts (runningTaskCount, blockedTaskCount, queuedTaskCount, inReviewCount, stuckTaskCount)
|
||||
* are derived client-side from the same tasks array shared with the board, ensuring
|
||||
* the footer counts always match the active work states displayed on screen. Queued covers
|
||||
* todo plus planning/triage work; Done is intentionally not exposed unless a footer Done
|
||||
* segment is added.
|
||||
* The API returns settings-based values (globalPause, enginePaused, maxConcurrent) and
|
||||
* lastActivityAt from the activity log.
|
||||
*
|
||||
* The executorState is derived from:
|
||||
* - "stopped": globalPause is true
|
||||
* - "idle": (enginePaused is true AND runningTaskCount is 0) OR not paused with nothing running
|
||||
* - "paused": enginePaused is true AND runningTaskCount > 0
|
||||
* - "running": globalPause is false AND enginePaused is false AND runningTaskCount > 0
|
||||
*/
|
||||
export interface ExecutorStats {
|
||||
/** Number of tasks currently in "in-progress" column */
|
||||
runningTaskCount: number;
|
||||
/** Number of tasks with blockedBy field set (waiting on file overlap) */
|
||||
blockedTaskCount: number;
|
||||
/** Number of "in-progress" tasks with no activity for > 10 minutes */
|
||||
stuckTaskCount: number;
|
||||
/** Number of tasks in "todo" plus planning/triage work states */
|
||||
queuedTaskCount: number;
|
||||
/** Number of tasks in "in-review" column */
|
||||
inReviewCount: number;
|
||||
/** Derived executor state: "idle", "running", "paused", or "stopped" */
|
||||
executorState: ExecutorState;
|
||||
/** Maximum concurrent tasks allowed from settings */
|
||||
maxConcurrent: number;
|
||||
/** ISO timestamp of most recent task event from activity log */
|
||||
lastActivityAt?: string;
|
||||
}
|
||||
|
||||
/** Unified activity feed entry */
|
||||
export interface ActivityFeedEntry {
|
||||
id: string;
|
||||
timestamp: string;
|
||||
type: ActivityEventType;
|
||||
projectId: string;
|
||||
projectName: string;
|
||||
taskId?: string;
|
||||
taskTitle?: string;
|
||||
details: string;
|
||||
metadata?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
/** Input for creating a new project */
|
||||
export interface ProjectCreateInput {
|
||||
name: string;
|
||||
path: string;
|
||||
isolationMode?: "in-process" | "child-process";
|
||||
nodeId?: string;
|
||||
gitSetupMode?: "existing" | "init" | "clone";
|
||||
cloneUrl?: string;
|
||||
workspaceMode?: boolean;
|
||||
taskPrefix?: string;
|
||||
/** Confirmed "create anyway without a git repo" when git is missing on the host (never valid for clone mode). */
|
||||
skipGitInit?: boolean;
|
||||
}
|
||||
|
||||
export type DockerNodeConfigInfo = DockerNodeConfig;
|
||||
export type { DockerNodeConfig };
|
||||
|
||||
/** Node information returned by node endpoints */
|
||||
export interface NodeInfo {
|
||||
id: NodeConfig["id"];
|
||||
name: NodeConfig["name"];
|
||||
type: NodeConfig["type"];
|
||||
url?: NodeConfig["url"];
|
||||
apiKey?: NodeConfig["apiKey"];
|
||||
status: NodeStatus;
|
||||
capabilities?: NodeConfig["capabilities"];
|
||||
maxConcurrent: NodeConfig["maxConcurrent"];
|
||||
createdAt: NodeConfig["createdAt"];
|
||||
updatedAt: NodeConfig["updatedAt"];
|
||||
dockerConfig?: DockerNodeConfigInfo;
|
||||
}
|
||||
|
||||
/** Managed Docker node information returned by docker node endpoints */
|
||||
export interface DockerNodeInfo {
|
||||
id: string;
|
||||
nodeId: string | null;
|
||||
name: string;
|
||||
nodeType: "docker-managed";
|
||||
imageName: string;
|
||||
imageTag: string;
|
||||
containerId: string | null;
|
||||
status: DockerNodeStatus;
|
||||
hostConfig: DockerHostConfig;
|
||||
envVars: Record<string, string>;
|
||||
volumeMounts: DockerVolumeMount[];
|
||||
resourceSizing: DockerResourceSizing;
|
||||
extraClis: DockerExtraCli[];
|
||||
persistentStorage: boolean;
|
||||
reachableUrl: string | null;
|
||||
apiKey: string | null;
|
||||
errorMessage: string | null;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface ManagedDockerNodeInfo {
|
||||
id: string;
|
||||
nodeId?: string;
|
||||
name: string;
|
||||
containerId?: string;
|
||||
status: string;
|
||||
hostConfig: {
|
||||
type: "local" | "remote";
|
||||
host?: string;
|
||||
context?: string;
|
||||
tlsOptions?: Record<string, unknown>;
|
||||
};
|
||||
envVars: Record<string, string>;
|
||||
reachableUrl?: string;
|
||||
imageName: string;
|
||||
imageTag: string;
|
||||
volumeMounts: Array<{ hostPath: string; containerPath: string; readOnly?: boolean }>;
|
||||
persistentStorage: boolean;
|
||||
resourceSizing?: { cpuLimit?: string; memoryLimit?: string };
|
||||
errorMessage?: string;
|
||||
linkedNode?: NodeInfo;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface ContainerStatusInfo {
|
||||
running: boolean;
|
||||
status: string;
|
||||
startedAt?: string;
|
||||
finishedAt?: string;
|
||||
exitCode?: number;
|
||||
error?: string;
|
||||
ports?: Record<string, string>;
|
||||
}
|
||||
|
||||
/** Node discovered over local network mDNS/DNS-SD */
|
||||
export interface DiscoveredNodeInfo {
|
||||
name: string;
|
||||
host: string;
|
||||
port: number;
|
||||
nodeType: "local" | "remote";
|
||||
nodeId?: string;
|
||||
discoveredAt: string;
|
||||
lastSeenAt: string;
|
||||
}
|
||||
|
||||
/** Input for creating a new node */
|
||||
export interface NodeCreateInput {
|
||||
name: string;
|
||||
type: "local" | "remote";
|
||||
url?: string;
|
||||
apiKey?: string;
|
||||
maxConcurrent?: number;
|
||||
dockerConfig?: DockerNodeConfigInfo;
|
||||
}
|
||||
|
||||
/** Input for assigning a project path for a specific node during onboarding. */
|
||||
export interface NodeProjectMappingInput {
|
||||
projectId: string;
|
||||
path: string;
|
||||
}
|
||||
|
||||
export interface RemoteNodeDiscoveredProject {
|
||||
id: string;
|
||||
name: string;
|
||||
path: string;
|
||||
status: "active" | "paused" | "errored" | "initializing";
|
||||
isolationMode: "in-process" | "child-process";
|
||||
}
|
||||
|
||||
export interface RemoteNodeProjectDiscoveryResult {
|
||||
projects: RemoteNodeDiscoveredProject[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Node onboarding payload used by dashboard UI.
|
||||
*
|
||||
* `projectMappings` is intentionally separate from `ProjectInfo.path` and `projects.nodeId`.
|
||||
* It captures node-specific filesystem paths for selected existing projects.
|
||||
*/
|
||||
export interface NodeOnboardingInput extends NodeCreateInput {
|
||||
projectMappings: NodeProjectMappingInput[];
|
||||
}
|
||||
|
||||
/** Input for updating an existing node */
|
||||
export type NodeUpdateInput = Partial<Pick<NodeCreateInput, "name" | "type" | "url" | "apiKey" | "maxConcurrent" | "dockerConfig">> & {
|
||||
status?: NodeStatus;
|
||||
capabilities?: string[];
|
||||
};
|
||||
|
||||
/** Result from a node health check */
|
||||
export interface NodeHealthCheckResult {
|
||||
nodeId: string;
|
||||
status: NodeStatus;
|
||||
responseTimeMs?: number;
|
||||
error?: string;
|
||||
checkedAt: string;
|
||||
}
|
||||
|
||||
/** Runtime metrics for a node */
|
||||
export interface NodeMetrics {
|
||||
nodeId: string;
|
||||
activeTaskCount: number;
|
||||
inFlightAgentCount: number;
|
||||
uptimeMs: number;
|
||||
lastActivityAt?: string;
|
||||
}
|
||||
|
||||
/** Options for fetching activity feed */
|
||||
export interface FeedOptions {
|
||||
limit?: number;
|
||||
since?: string;
|
||||
projectId?: string;
|
||||
type?: ActivityFeedEntry["type"];
|
||||
}
|
||||
|
||||
/** Global concurrency state across all projects */
|
||||
export interface GlobalConcurrencyState {
|
||||
globalMaxConcurrent: number;
|
||||
currentlyActive: number;
|
||||
queuedCount: number;
|
||||
projectsActive: Record<string, number>;
|
||||
}
|
||||
|
||||
/** First run status response */
|
||||
export interface FirstRunStatus {
|
||||
hasProjects: boolean;
|
||||
singleProjectPath: string | null;
|
||||
}
|
||||
|
||||
/** Setup state for first-run wizard */
|
||||
export interface SetupState {
|
||||
/** The first-run state: fresh-install, setup-wizard, normal-operation */
|
||||
state: "fresh-install" | "setup-wizard" | "normal-operation";
|
||||
/** Projects detected on the filesystem (not yet registered) */
|
||||
detectedProjects: Array<{
|
||||
path: string;
|
||||
name: string;
|
||||
hasDb: boolean;
|
||||
}>;
|
||||
/** Whether the central database exists */
|
||||
hasCentralDb: boolean;
|
||||
/** Projects already registered in the central database */
|
||||
registeredProjects: Array<{
|
||||
id: string;
|
||||
name: string;
|
||||
path: string;
|
||||
}>;
|
||||
}
|
||||
|
||||
/** Input for completing setup */
|
||||
export interface CompleteSetupInput {
|
||||
projects: Array<{
|
||||
path: string;
|
||||
name: string;
|
||||
isolationMode?: "in-process" | "child-process";
|
||||
}>;
|
||||
}
|
||||
|
||||
/** Result of completing setup */
|
||||
export interface CompleteSetupResult {
|
||||
success: boolean;
|
||||
projectsRegistered: string[];
|
||||
errors: string[];
|
||||
}
|
||||
|
||||
/** Fetch all registered projects */
|
||||
export function fetchProjects(): Promise<ProjectInfo[]> {
|
||||
return api<ProjectInfo[]>("/projects");
|
||||
}
|
||||
|
||||
/** Dashboard-facing mapping contract for project availability on nodes. */
|
||||
export interface ProjectNodeAvailability {
|
||||
nodeId: string;
|
||||
nodeName?: string;
|
||||
path: string;
|
||||
available: boolean;
|
||||
}
|
||||
|
||||
/** Project info with source node metadata (added by server for remote projects). */
|
||||
export interface ProjectInfoWithSource extends ProjectInfo {
|
||||
/** Name of the source node (added by server for remote projects). */
|
||||
_sourceNodeName?: string;
|
||||
/** Normalized per-node project mappings for dashboard UI. */
|
||||
nodeMappings?: ProjectNodeAvailability[];
|
||||
/** Compatibility fields accepted from in-flight server rollouts. */
|
||||
projectNodeMappings?: ProjectNodeAvailability[];
|
||||
pathMappings?: ProjectNodeAvailability[];
|
||||
}
|
||||
|
||||
export function hasNodeMappingsSupport(project: ProjectInfoWithSource): boolean {
|
||||
return Array.isArray(project.nodeMappings)
|
||||
|| Array.isArray(project.projectNodeMappings)
|
||||
|| Array.isArray(project.pathMappings);
|
||||
}
|
||||
|
||||
/** Fetch all registered projects from all nodes (local + remote) */
|
||||
export function fetchProjectsAcrossNodes(): Promise<ProjectInfoWithSource[]> {
|
||||
return dedupe("/projects/across-nodes", () => api<ProjectInfoWithSource[]>("/projects/across-nodes"));
|
||||
}
|
||||
|
||||
/** Fetch all registered nodes */
|
||||
export function fetchNodes(): Promise<NodeInfo[]> {
|
||||
return dedupe("/nodes", () => api<NodeInfo[]>("/nodes"));
|
||||
}
|
||||
|
||||
/** Fetch discovery runtime status and active config. */
|
||||
export function fetchDiscoveryStatus(): Promise<{ active: boolean; config: DiscoveryConfig | null }> {
|
||||
return api<{ active: boolean; config: DiscoveryConfig | null }>("/discovery/status");
|
||||
}
|
||||
|
||||
/** Fetch all managed Docker nodes */
|
||||
export function listManagedDockerNodes(): Promise<DockerNodeInfo[]> {
|
||||
return api<DockerNodeInfo[]>("/docker-nodes");
|
||||
}
|
||||
|
||||
export function fetchManagedDockerNodes(): Promise<ManagedDockerNodeInfo[]> {
|
||||
return api<ManagedDockerNodeInfo[]>("/docker/nodes");
|
||||
}
|
||||
|
||||
export function fetchManagedDockerNode(id: string): Promise<ManagedDockerNodeInfo> {
|
||||
return api<ManagedDockerNodeInfo>(`/docker/nodes/${encodeURIComponent(id)}`);
|
||||
}
|
||||
|
||||
export function fetchManagedDockerNodeContainerStatus(id: string): Promise<ContainerStatusInfo> {
|
||||
return api<ContainerStatusInfo>(`/docker/nodes/${encodeURIComponent(id)}/container-status`);
|
||||
}
|
||||
|
||||
export function fetchDockerNodeLogs(id: string, options?: { tail?: number }): Promise<{ logs: string }> {
|
||||
const params = new URLSearchParams();
|
||||
if (typeof options?.tail === "number") {
|
||||
params.set("tail", String(options.tail));
|
||||
}
|
||||
const suffix = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<{ logs: string }>(`/docker/nodes/${encodeURIComponent(id)}/logs${suffix}`);
|
||||
}
|
||||
|
||||
/** Create a managed Docker node */
|
||||
export function createManagedDockerNode(input: ManagedDockerNodeInput): Promise<DockerNodeInfo> {
|
||||
return api<DockerNodeInfo>("/docker-nodes", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Start local-network discovery service. */
|
||||
export function startDiscovery(input?: {
|
||||
broadcast?: boolean;
|
||||
listen?: boolean;
|
||||
port?: number;
|
||||
}): Promise<{ success: boolean; config: DiscoveryConfig }> {
|
||||
return api<{ success: boolean; config: DiscoveryConfig }>("/discovery/start", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input ?? {}),
|
||||
});
|
||||
}
|
||||
|
||||
/** Stop local-network discovery service. */
|
||||
export function stopDiscovery(): Promise<{ success: boolean }> {
|
||||
return api<{ success: boolean }>("/discovery/stop", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch currently discovered nodes from mDNS/DNS-SD. */
|
||||
export function fetchDiscoveredNodes(): Promise<DiscoveredNodeInfo[]> {
|
||||
return api<DiscoveredNodeInfo[]>("/discovery/nodes");
|
||||
}
|
||||
|
||||
/** Register a discovered node into the central node registry. */
|
||||
export function connectDiscoveredNode(input: {
|
||||
name: string;
|
||||
host: string;
|
||||
port: number;
|
||||
apiKey?: string;
|
||||
}): Promise<NodeInfo> {
|
||||
return api<NodeInfo>("/discovery/connect", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Register a new node */
|
||||
export function registerNode(input: NodeCreateInput): Promise<NodeInfo> {
|
||||
return api<NodeInfo>("/nodes", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Discover projects from a remote node before registering it. */
|
||||
export function discoverRemoteNodeProjects(input: { url: string; apiKey?: string }): Promise<RemoteNodeProjectDiscoveryResult> {
|
||||
return api<RemoteNodeProjectDiscoveryResult>("/nodes/discover-projects", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch a single node by ID */
|
||||
export function fetchNode(id: string): Promise<NodeInfo> {
|
||||
return api<NodeInfo>(`/nodes/${encodeURIComponent(id)}`);
|
||||
}
|
||||
|
||||
/** Fetch all project path mappings for a node */
|
||||
export function fetchNodePathMappings(nodeId: string): Promise<ProjectNodePathMapping[]> {
|
||||
return api<ProjectNodePathMapping[]>(`/nodes/${encodeURIComponent(nodeId)}/path-mappings`);
|
||||
}
|
||||
|
||||
/** Update an existing node */
|
||||
export function updateNode(id: string, updates: NodeUpdateInput): Promise<NodeInfo> {
|
||||
return api<NodeInfo>(`/nodes/${encodeURIComponent(id)}`, {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch sanitized docker config for a node */
|
||||
export function fetchDockerNodeConfig(nodeId: string): Promise<DockerNodeConfigInfo | null> {
|
||||
return api<DockerNodeConfigInfo | null>(`/nodes/${encodeURIComponent(nodeId)}/docker-config`);
|
||||
}
|
||||
|
||||
/** Replace full docker config for a node */
|
||||
export function replaceDockerNodeConfig(nodeId: string, config: DockerNodeConfig): Promise<DockerNodeConfigInfo> {
|
||||
return api<DockerNodeConfigInfo>(`/nodes/${encodeURIComponent(nodeId)}/docker-config`, {
|
||||
method: "PUT",
|
||||
body: JSON.stringify(config),
|
||||
});
|
||||
}
|
||||
|
||||
/** Patch docker config for a node */
|
||||
export function updateDockerNodeConfig(nodeId: string, config: Partial<DockerNodeConfig>): Promise<DockerNodeConfigInfo> {
|
||||
return api<DockerNodeConfigInfo>(`/nodes/${encodeURIComponent(nodeId)}/docker-config`, {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(config),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch docker config diff status for a node */
|
||||
export function fetchDockerConfigDiff(nodeId: string): Promise<{
|
||||
persistedVersion: number;
|
||||
deployedVersion: number | null;
|
||||
needsRecreate: boolean;
|
||||
}> {
|
||||
return api<{ persistedVersion: number; deployedVersion: number | null; needsRecreate: boolean }>(
|
||||
`/nodes/${encodeURIComponent(nodeId)}/docker-config/diff`,
|
||||
);
|
||||
}
|
||||
|
||||
/** Unregister a node */
|
||||
export function unregisterNode(id: string): Promise<void> {
|
||||
return api<void>(`/nodes/${encodeURIComponent(id)}`, {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
/** Trigger a node health check */
|
||||
export async function checkNodeHealth(id: string): Promise<NodeHealthCheckResult> {
|
||||
const result = await api<Partial<NodeHealthCheckResult> & { status: NodeStatus }>(`/nodes/${encodeURIComponent(id)}/health-check`, {
|
||||
method: "POST",
|
||||
});
|
||||
|
||||
return {
|
||||
nodeId: result.nodeId ?? id,
|
||||
status: result.status,
|
||||
responseTimeMs: result.responseTimeMs,
|
||||
error: result.error,
|
||||
checkedAt: result.checkedAt ?? new Date().toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
/** Fetch runtime metrics for a node */
|
||||
export async function fetchNodeMetrics(id: string): Promise<SystemMetrics | null> {
|
||||
return api<SystemMetrics | null>(`/nodes/${encodeURIComponent(id)}/metrics`);
|
||||
}
|
||||
|
||||
/** Fetch full mesh topology state (all nodes with their metrics and known peers) */
|
||||
export async function fetchMeshState(): Promise<MeshClusterSnapshot> {
|
||||
return api<MeshClusterSnapshot>("/mesh/state");
|
||||
}
|
||||
|
||||
/*
|
||||
* FNXC:MeshSharedPg 2026-06-25-00:00:
|
||||
* With the mesh on shared PostgreSQL, the dashboard needs to surface which
|
||||
* engines are actively connected to the shared DB, their in-flight tasks, and
|
||||
* heartbeat status. GET /api/mesh/engines joins the local engineManager with
|
||||
* the central node registry and per-project health. The shape matches the
|
||||
* MeshTopology `engines` prop (MeshEngineStatus) so the dashboard can render it
|
||||
* without transformation.
|
||||
*/
|
||||
export interface MeshEnginesResponse {
|
||||
collectedAt: string;
|
||||
backend: string;
|
||||
engines: MeshEngineStatusApi[];
|
||||
}
|
||||
|
||||
/** Per-engine status entry returned by GET /api/mesh/engines. Mirrors MeshEngineStatus. */
|
||||
export interface MeshEngineStatusApi {
|
||||
projectId: string;
|
||||
projectName?: string;
|
||||
projectPath?: string;
|
||||
workingDirectory?: string;
|
||||
runtimeStatus: string;
|
||||
inFlightTasks: number;
|
||||
activeAgents: number;
|
||||
lastActivityAt?: string;
|
||||
memoryBytes?: number;
|
||||
nodeId?: string;
|
||||
}
|
||||
|
||||
/** Fetch active engine connections reading from shared PG (GET /api/mesh/engines). */
|
||||
export async function fetchMeshEngines(): Promise<MeshEnginesResponse> {
|
||||
return api<MeshEnginesResponse>("/mesh/engines");
|
||||
}
|
||||
|
||||
/** Browse directory entries for the directory picker */
|
||||
export interface BrowseDirectoryResult {
|
||||
currentPath: string;
|
||||
parentPath: string | null;
|
||||
entries: Array<{ name: string; path: string; hasChildren: boolean }>;
|
||||
}
|
||||
|
||||
export function browseDirectory(
|
||||
path?: string,
|
||||
showHidden?: boolean,
|
||||
nodeId?: string,
|
||||
localNodeId?: string,
|
||||
): Promise<BrowseDirectoryResult> {
|
||||
const effectiveNodeId = nodeId && nodeId !== localNodeId ? nodeId : undefined;
|
||||
const params = new URLSearchParams();
|
||||
if (path) params.set("path", path);
|
||||
if (showHidden) params.set("showHidden", "true");
|
||||
if (effectiveNodeId) params.set("nodeId", effectiveNodeId);
|
||||
const token = getAuthToken();
|
||||
if (token) {
|
||||
params.set("fn_token", token);
|
||||
}
|
||||
const qs = params.toString();
|
||||
const fullPath = `/browse-directory${qs ? `?${qs}` : ""}`;
|
||||
return api<BrowseDirectoryResult>(fullPath);
|
||||
}
|
||||
|
||||
/** Create a new directory */
|
||||
export function createDirectory(path: string): Promise<{ success: true; path: string }> {
|
||||
return api<{ success: true; path: string }>("/create-directory", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ path }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Register a new project */
|
||||
export function registerProject(input: ProjectCreateInput): Promise<ProjectInfo> {
|
||||
return api<ProjectInfo>("/projects", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
/** Detect git sub-repos in a directory (workspace mode detection) */
|
||||
export function detectWorkspace(path: string): Promise<{ repos: string[]; isWorkspace: boolean }> {
|
||||
return api<{ repos: string[]; isWorkspace: boolean }>("/projects/detect-workspace", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ path }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Unregister a project */
|
||||
export function unregisterProject(id: string): Promise<void> {
|
||||
return api<void>(`/projects/${encodeURIComponent(id)}`, {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch all per-node path mappings for a project */
|
||||
export function fetchProjectPathMappings(projectId: string): Promise<ProjectNodePathMapping[]> {
|
||||
return api<ProjectNodePathMapping[]>(`/projects/${encodeURIComponent(projectId)}/path-mappings`);
|
||||
}
|
||||
|
||||
/** Fetch a single project-node path mapping */
|
||||
export function fetchProjectPathMapping(projectId: string, nodeId: string): Promise<ProjectNodePathMapping> {
|
||||
return api<ProjectNodePathMapping>(
|
||||
`/projects/${encodeURIComponent(projectId)}/path-mappings/${encodeURIComponent(nodeId)}`,
|
||||
);
|
||||
}
|
||||
|
||||
/** Create or update a project-node path mapping */
|
||||
export function upsertProjectPathMapping(
|
||||
projectId: string,
|
||||
nodeId: string,
|
||||
path: string,
|
||||
): Promise<ProjectNodePathMapping> {
|
||||
return api<ProjectNodePathMapping>(
|
||||
`/projects/${encodeURIComponent(projectId)}/path-mappings/${encodeURIComponent(nodeId)}`,
|
||||
{
|
||||
method: "PUT",
|
||||
body: JSON.stringify({ path }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Remove a project-node path mapping */
|
||||
export function removeProjectPathMapping(projectId: string, nodeId: string): Promise<void> {
|
||||
return api<void>(
|
||||
`/projects/${encodeURIComponent(projectId)}/path-mappings/${encodeURIComponent(nodeId)}`,
|
||||
{
|
||||
method: "DELETE",
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Fetch health metrics for a specific project */
|
||||
export function fetchProjectHealth(id: string): Promise<ProjectHealth> {
|
||||
return api<ProjectHealth>(`/projects/${encodeURIComponent(id)}/health`);
|
||||
}
|
||||
|
||||
export function fetchCodebaseMetrics(id: string): Promise<CodebaseMetrics> {
|
||||
return api<CodebaseMetrics>(`/projects/${encodeURIComponent(id)}/codebase-metrics`);
|
||||
}
|
||||
|
||||
/** Fetch executor statistics for the status bar.
|
||||
*
|
||||
* Returns settings-based values and lastActivityAt.
|
||||
* Counts are derived client-side from the tasks array.
|
||||
*/
|
||||
export function fetchExecutorStats(projectId?: string): Promise<{
|
||||
globalPause: boolean;
|
||||
enginePaused: boolean;
|
||||
maxConcurrent: number;
|
||||
lastActivityAt?: string;
|
||||
}> {
|
||||
const path = withProjectId("/executor/stats", projectId);
|
||||
return dedupe(path, () => api<{
|
||||
globalPause: boolean;
|
||||
enginePaused: boolean;
|
||||
maxConcurrent: number;
|
||||
lastActivityAt?: string;
|
||||
}>(path));
|
||||
}
|
||||
|
||||
export interface SystemStatsSnapshot {
|
||||
rss: number;
|
||||
heapUsed: number;
|
||||
heapTotal: number;
|
||||
heapLimit: number;
|
||||
external: number;
|
||||
arrayBuffers: number;
|
||||
// Null until at least two samples are available to compute process CPU delta.
|
||||
cpuPercent: number | null;
|
||||
loadAvg: [number, number, number];
|
||||
cpuCount: number;
|
||||
systemTotalMem: number;
|
||||
systemFreeMem: number;
|
||||
pid: number;
|
||||
nodeVersion: string;
|
||||
platform: string;
|
||||
}
|
||||
|
||||
export interface TaskStatsSnapshot {
|
||||
total: number;
|
||||
byColumn: Record<string, number>;
|
||||
active: number;
|
||||
agents: {
|
||||
idle: number;
|
||||
active: number;
|
||||
running: number;
|
||||
error: number;
|
||||
};
|
||||
}
|
||||
|
||||
export interface SystemStatsResponse {
|
||||
systemStats: SystemStatsSnapshot;
|
||||
taskStats: TaskStatsSnapshot;
|
||||
vitestProcessCount?: number;
|
||||
vitestLastAutoKillAt?: string | null;
|
||||
}
|
||||
|
||||
export interface KillVitestResponse {
|
||||
killed: number;
|
||||
pids: number[];
|
||||
}
|
||||
|
||||
export interface GithubSourceIssueClosedAtBackfillResult {
|
||||
scanned: number;
|
||||
filled: number;
|
||||
skipped: number;
|
||||
errors: number;
|
||||
hasMore: boolean;
|
||||
}
|
||||
|
||||
/*
|
||||
FNXC:CommandCenter 2026-06-21-00:00:
|
||||
The Command Center System area keeps the direct local /system-stats client and uses the explicit /nodes/:id/system-stats route for selected remote nodes so authenticated node proxying stays server-side and local project scoping is not forwarded across nodes.
|
||||
*/
|
||||
export function fetchSystemStats(projectId?: string): Promise<SystemStatsResponse> {
|
||||
return api<SystemStatsResponse>(withProjectId("/system-stats", projectId));
|
||||
}
|
||||
|
||||
export function fetchNodeSystemStats(nodeId: string, projectId?: string): Promise<SystemStatsResponse> {
|
||||
return api<SystemStatsResponse>(withProjectId(`/nodes/${encodeURIComponent(nodeId)}/system-stats`, projectId));
|
||||
}
|
||||
|
||||
export function killVitestProcesses(projectId?: string, nodeId?: string, localNodeId?: string): Promise<KillVitestResponse> {
|
||||
return proxyApi<KillVitestResponse>(withProjectId("/kill-vitest", projectId), {
|
||||
method: "POST",
|
||||
nodeId,
|
||||
localNodeId,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* FNXC:GithubSourceIssueBackfill 2026-06-18-19:20:
|
||||
* Thin client for the FN-6674 manual source-issue closed-at backfill endpoint. Callers own bounded pagination until `hasMore === false`; this helper keeps the GitHub lookup in the explicit operator action path and out of analytics/render-time data loading.
|
||||
*/
|
||||
export function apiBackfillGithubSourceIssueClosedAt(
|
||||
options: { offset?: number; limit?: number } = {},
|
||||
projectId?: string,
|
||||
): Promise<GithubSourceIssueClosedAtBackfillResult> {
|
||||
return api<GithubSourceIssueClosedAtBackfillResult>(
|
||||
withProjectId("/git/github/backfill-source-issue-closed-at", projectId),
|
||||
{
|
||||
method: "POST",
|
||||
body: JSON.stringify({ offset: options.offset, limit: options.limit }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Fetch unified activity feed */
|
||||
export function fetchActivityFeed(options?: FeedOptions): Promise<ActivityFeedEntry[]> {
|
||||
const params = new URLSearchParams();
|
||||
if (options?.limit !== undefined) params.set("limit", String(options.limit));
|
||||
if (options?.since) params.set("since", options.since);
|
||||
if (options?.projectId) params.set("projectId", options.projectId);
|
||||
if (options?.type) params.set("type", options.type);
|
||||
|
||||
const query = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<ActivityFeedEntry[]>(`/activity-feed${query}`);
|
||||
}
|
||||
|
||||
/** Pause a project */
|
||||
export function pauseProject(id: string): Promise<ProjectInfo> {
|
||||
return api<ProjectInfo>(`/projects/${encodeURIComponent(id)}/pause`, {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
/** Resume a paused project */
|
||||
export function resumeProject(id: string): Promise<ProjectInfo> {
|
||||
return api<ProjectInfo>(`/projects/${encodeURIComponent(id)}/resume`, {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch first run status to detect if user needs setup wizard */
|
||||
export function fetchFirstRunStatus(): Promise<FirstRunStatus> {
|
||||
return api<FirstRunStatus>("/first-run-status");
|
||||
}
|
||||
|
||||
/** Fetch detailed setup state including detected projects */
|
||||
export function fetchSetupState(): Promise<SetupState> {
|
||||
return api<SetupState>("/setup-state");
|
||||
}
|
||||
|
||||
/** Complete first-run setup by registering projects */
|
||||
export function completeSetup(input: CompleteSetupInput): Promise<CompleteSetupResult> {
|
||||
return api<CompleteSetupResult>("/complete-setup", {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch global concurrency state */
|
||||
export function fetchGlobalConcurrency(): Promise<GlobalConcurrencyState> {
|
||||
return api<GlobalConcurrencyState>("/global-concurrency");
|
||||
}
|
||||
|
||||
/** Update the system-wide concurrency limit shared across all projects. */
|
||||
export function updateGlobalConcurrency(input: {
|
||||
globalMaxConcurrent: number;
|
||||
}): Promise<GlobalConcurrencyState> {
|
||||
return api<GlobalConcurrencyState>("/global-concurrency", {
|
||||
method: "PUT",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch tasks for a specific project */
|
||||
export function fetchProjectTasks(projectId: string, limit?: number, offset?: number): Promise<Task[]> {
|
||||
const params = new URLSearchParams();
|
||||
params.set("projectId", projectId);
|
||||
if (limit !== undefined) params.set("limit", String(limit));
|
||||
if (offset !== undefined) params.set("offset", String(offset));
|
||||
return api<Task[]>(`/tasks?${params.toString()}`);
|
||||
}
|
||||
|
||||
/** Fetch project-specific config */
|
||||
export function fetchProjectConfig(projectId: string): Promise<{ maxConcurrent: number; rootDir: string }> {
|
||||
return api<{ maxConcurrent: number; rootDir: string }>(`/projects/${encodeURIComponent(projectId)}/config`);
|
||||
}
|
||||
|
||||
/** Detected project information */
|
||||
export interface DetectedProject {
|
||||
path: string;
|
||||
suggestedName: string;
|
||||
existing: boolean;
|
||||
}
|
||||
|
||||
/** Detect projects in a base path */
|
||||
export function detectProjects(basePath?: string): Promise<{ projects: DetectedProject[] }> {
|
||||
return api<{ projects: DetectedProject[] }>("/projects/detect", {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ basePath }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Fetch a single project by ID */
|
||||
export function fetchProject(id: string): Promise<ProjectInfo> {
|
||||
return api<ProjectInfo>(`/projects/${encodeURIComponent(id)}`);
|
||||
}
|
||||
|
||||
/** Update an existing project */
|
||||
export function updateProject(id: string, updates: Partial<ProjectInfo>): Promise<ProjectInfo> {
|
||||
return api<ProjectInfo>(`/projects/${encodeURIComponent(id)}`, {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
226
packages/dashboard/app/api/research.ts
Normal file
226
packages/dashboard/app/api/research.ts
Normal file
@@ -0,0 +1,226 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Research + evals client API peeled from legacy.ts.
|
||||
*/
|
||||
import type {
|
||||
EvalRun,
|
||||
EvalTaskResult,
|
||||
ResearchRunStatus,
|
||||
Task,
|
||||
} from "@fusion/core";
|
||||
import type {
|
||||
ResearchAvailability,
|
||||
ResearchRunDetail,
|
||||
ResearchRunsResponse,
|
||||
ResearchRunResponse,
|
||||
ResearchProviderOption,
|
||||
} from "../research-types";
|
||||
import { api, ApiRequestError } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
|
||||
// ── Research API ────────────────────────────────────────────────────────────
|
||||
|
||||
export interface EvalsListOptions {
|
||||
q?: string;
|
||||
runId?: string;
|
||||
scoreMin?: number;
|
||||
scoreMax?: number;
|
||||
limit?: number;
|
||||
offset?: number;
|
||||
}
|
||||
|
||||
export function listEvals(options: EvalsListOptions = {}, projectId?: string): Promise<{ results: EvalTaskResult[]; count: number }> {
|
||||
const params = new URLSearchParams();
|
||||
if (options.q) params.set("q", options.q);
|
||||
if (options.runId) params.set("runId", options.runId);
|
||||
if (options.scoreMin !== undefined) params.set("scoreMin", String(options.scoreMin));
|
||||
if (options.scoreMax !== undefined) params.set("scoreMax", String(options.scoreMax));
|
||||
if (options.limit !== undefined) params.set("limit", String(options.limit));
|
||||
if (options.offset !== undefined) params.set("offset", String(options.offset));
|
||||
const suffix = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<{ results: EvalTaskResult[]; count: number }>(withProjectId(`/evals${suffix}`, projectId));
|
||||
}
|
||||
|
||||
export function getEval(id: string, projectId?: string): Promise<{ result: EvalTaskResult }> {
|
||||
return api<{ result: EvalTaskResult }>(withProjectId(`/evals/${encodeURIComponent(id)}`, projectId));
|
||||
}
|
||||
|
||||
export function listEvalRuns(projectId?: string): Promise<{ runs: EvalRun[] }> {
|
||||
return api<{ runs: EvalRun[] }>(withProjectId("/evals/runs", projectId));
|
||||
}
|
||||
|
||||
export interface CreateResearchRunInput {
|
||||
query: string;
|
||||
providers: ResearchProviderOption[];
|
||||
githubRepo?: string;
|
||||
githubIssueNumber?: number;
|
||||
includeLocalDocs?: boolean;
|
||||
enableSynthesis?: boolean;
|
||||
maxResults?: number;
|
||||
depth?: "shallow" | "normal" | "deep";
|
||||
}
|
||||
|
||||
export function listResearchRuns(
|
||||
options: { q?: string; status?: ResearchRunStatus; limit?: number } = {},
|
||||
projectId?: string,
|
||||
): Promise<ResearchRunsResponse> {
|
||||
const params = new URLSearchParams();
|
||||
if (options.q) params.set("q", options.q);
|
||||
if (options.status) params.set("status", options.status);
|
||||
if (options.limit !== undefined) params.set("limit", String(options.limit));
|
||||
const suffix = params.size > 0 ? `?${params.toString()}` : "";
|
||||
return api<ResearchRunsResponse>(withProjectId(`/research/runs${suffix}`, projectId));
|
||||
}
|
||||
|
||||
export function createResearchRun(input: CreateResearchRunInput, projectId?: string): Promise<ResearchRunResponse> {
|
||||
return api<ResearchRunResponse>(withProjectId("/research/runs", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
export function getResearchRun(id: string, projectId?: string): Promise<ResearchRunResponse> {
|
||||
return api<ResearchRunResponse>(withProjectId(`/research/runs/${encodeURIComponent(id)}`, projectId));
|
||||
}
|
||||
|
||||
export type ResearchActionErrorCode =
|
||||
| "FEATURE_DISABLED"
|
||||
| "MISSING_CREDENTIALS"
|
||||
| "PROVIDER_UNAVAILABLE"
|
||||
| "RATE_LIMITED"
|
||||
| "PROVIDER_TIMEOUT"
|
||||
| "RUN_CANCELLED"
|
||||
| "RETRY_EXHAUSTED"
|
||||
| "INVALID_TRANSITION"
|
||||
| "NON_RETRYABLE_PROVIDER_ERROR"
|
||||
| "INTERNAL_ERROR";
|
||||
|
||||
export interface ResearchActionError extends ApiRequestError {
|
||||
researchCode: ResearchActionErrorCode;
|
||||
setupHint?: string;
|
||||
retryable?: boolean;
|
||||
}
|
||||
|
||||
function asResearchActionError(error: unknown): never {
|
||||
if (error instanceof ApiRequestError) {
|
||||
const codeCandidate = error.details?.code;
|
||||
const code = typeof codeCandidate === "string" ? codeCandidate : "INTERNAL_ERROR";
|
||||
const setupHint = typeof error.details?.setupHint === "string" ? error.details.setupHint : undefined;
|
||||
const retryable = typeof error.details?.retryable === "boolean" ? error.details.retryable : undefined;
|
||||
const enriched = error as ResearchActionError;
|
||||
enriched.researchCode = code as ResearchActionErrorCode;
|
||||
enriched.setupHint = setupHint;
|
||||
enriched.retryable = retryable;
|
||||
throw enriched;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
export async function cancelResearchRun(id: string, projectId?: string): Promise<{ run: ResearchRunDetail }> {
|
||||
try {
|
||||
return await api<{ run: ResearchRunDetail }>(withProjectId(`/research/runs/${encodeURIComponent(id)}/cancel`, projectId), {
|
||||
method: "POST",
|
||||
});
|
||||
} catch (error) {
|
||||
asResearchActionError(error);
|
||||
}
|
||||
}
|
||||
|
||||
export async function retryResearchRun(id: string, projectId?: string): Promise<{ run: ResearchRunDetail }> {
|
||||
try {
|
||||
return await api<{ run: ResearchRunDetail }>(withProjectId(`/research/runs/${encodeURIComponent(id)}/retry`, projectId), {
|
||||
method: "POST",
|
||||
});
|
||||
} catch (error) {
|
||||
asResearchActionError(error);
|
||||
}
|
||||
}
|
||||
|
||||
export function exportResearchRun(
|
||||
id: string,
|
||||
format: "markdown" | "json" | "html",
|
||||
projectId?: string,
|
||||
): Promise<{ format: string; content: string; filename: string }> {
|
||||
return api<{ format: string; content: string; filename: string }>(
|
||||
withProjectId(`/research/runs/${encodeURIComponent(id)}/export?format=${encodeURIComponent(format)}`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
export function createTaskFromResearchRun(
|
||||
id: string,
|
||||
input: { findingId?: string; title?: string; description?: string; priority?: "low" | "normal" | "high" | "urgent"; attachExport?: boolean },
|
||||
projectId?: string,
|
||||
): Promise<{ task: Task; documentKey: string; attachmentFilename?: string }> {
|
||||
const findingId = input.findingId ?? "finding-1";
|
||||
return api<{ task: Task; documentKey: string; attachmentFilename?: string }>(
|
||||
withProjectId(`/research/runs/${encodeURIComponent(id)}/findings/${encodeURIComponent(findingId)}/task`, projectId),
|
||||
{
|
||||
method: "POST",
|
||||
body: JSON.stringify({
|
||||
title: input.title,
|
||||
description: input.description,
|
||||
priority: input.priority,
|
||||
attachExport: input.attachExport,
|
||||
}),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
export function attachResearchRunToTask(
|
||||
id: string,
|
||||
input: { findingId?: string; taskId: string; attachExport?: boolean },
|
||||
projectId?: string,
|
||||
): Promise<{ taskId: string; documentKey: string; revision: number; attachmentFilename?: string }> {
|
||||
const findingId = input.findingId ?? "finding-1";
|
||||
return api<{ taskId: string; documentKey: string; revision: number; attachmentFilename?: string }>(
|
||||
withProjectId(
|
||||
`/research/runs/${encodeURIComponent(id)}/findings/${encodeURIComponent(findingId)}/tasks/${encodeURIComponent(input.taskId)}/enrich`,
|
||||
projectId,
|
||||
),
|
||||
{
|
||||
method: "POST",
|
||||
body: JSON.stringify({
|
||||
attachExport: input.attachExport,
|
||||
}),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
export function getResearchAvailability(projectId?: string): Promise<ResearchAvailability> {
|
||||
return listResearchRuns({}, projectId).then((response) => response.availability);
|
||||
}
|
||||
|
||||
export interface ResearchStatsResponse {
|
||||
total: number;
|
||||
byStatus: Record<ResearchRunStatus, number>;
|
||||
}
|
||||
|
||||
export function getResearchStats(projectId?: string): Promise<ResearchStatsResponse> {
|
||||
return api<ResearchStatsResponse>(withProjectId("/research/stats", projectId));
|
||||
}
|
||||
|
||||
/*
|
||||
* FNXC:CodeOrganization 2026-07-18-14:00:
|
||||
* Preserve legacy `system-panel` imports while implementations live in system-panel.ts.
|
||||
*/
|
||||
export {
|
||||
fetchCurrentSystemRebuild,
|
||||
fetchSystemInfo,
|
||||
fetchSystemLogs,
|
||||
promoteResearchFinding,
|
||||
reloadAllSystemPlugins,
|
||||
requestSystemRestart,
|
||||
restartAllSystemAgents,
|
||||
restartSystemEngines,
|
||||
startFnBinaryLinkLocal,
|
||||
startFnBinaryUseGlobal,
|
||||
startSystemRebuild,
|
||||
} from "./system-panel.js";
|
||||
export type {
|
||||
ResearchFindingPromotionInput,
|
||||
SystemInfoResponse,
|
||||
SystemLogEntryDto,
|
||||
SystemRebuildJobLine,
|
||||
SystemRebuildJobSnapshot,
|
||||
} from "./system-panel.js";
|
||||
|
||||
257
packages/dashboard/app/api/scheduling.ts
Normal file
257
packages/dashboard/app/api/scheduling.ts
Normal file
@@ -0,0 +1,257 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Automations and routines client API peeled from legacy.ts.
|
||||
*/
|
||||
import type {
|
||||
ScheduledTask,
|
||||
ScheduledTaskCreateInput,
|
||||
ScheduledTaskUpdateInput,
|
||||
AutomationRunResult,
|
||||
Routine,
|
||||
RoutineCreateInput,
|
||||
RoutineUpdateInput,
|
||||
RoutineExecutionResult,
|
||||
ActivityEventType,
|
||||
ActivityLogEntry,
|
||||
WorkflowStep,
|
||||
WorkflowStepResult,
|
||||
} from "@fusion/core";
|
||||
import { api } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { createResilientEventSource } from "./event-source.js";
|
||||
import type { StreamConnectionState } from "./event-source.js";
|
||||
|
||||
// ── Automation / Scheduled Tasks ──────────────────────────────────
|
||||
|
||||
/**
|
||||
* Options for scheduling scope (global vs project-scoped automations/routines).
|
||||
* When scope is "project", projectId must be provided.
|
||||
*/
|
||||
export type SchedulingScopeOptions = {
|
||||
/** Scope for scheduling operations: "global" or "project". Defaults to "project" on the server. */
|
||||
scope?: "global" | "project";
|
||||
/** Project ID required when scope is "project". */
|
||||
projectId?: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Build URL suffix with scope and projectId query params.
|
||||
* Mirrors the backend's parseScopeParam logic: scope goes in query param.
|
||||
*/
|
||||
function withSchedulingScope(path: string, options?: SchedulingScopeOptions): string {
|
||||
const params = new URLSearchParams();
|
||||
if (options?.scope) {
|
||||
params.set("scope", options.scope);
|
||||
}
|
||||
if (options?.projectId) {
|
||||
params.set("projectId", options.projectId);
|
||||
}
|
||||
const suffix = params.toString();
|
||||
if (!suffix) return path;
|
||||
return `${path}?${suffix}`;
|
||||
}
|
||||
|
||||
/** Response from the manual run trigger endpoint. */
|
||||
export interface AutomationRunResponse {
|
||||
schedule: ScheduledTask;
|
||||
result: AutomationRunResult;
|
||||
}
|
||||
|
||||
export function fetchAutomations(options?: SchedulingScopeOptions): Promise<ScheduledTask[]> {
|
||||
return api<ScheduledTask[]>(withSchedulingScope("/automations", options));
|
||||
}
|
||||
|
||||
export function fetchAutomation(id: string, options?: SchedulingScopeOptions): Promise<ScheduledTask> {
|
||||
return api<ScheduledTask>(withSchedulingScope(`/automations/${id}`, options));
|
||||
}
|
||||
|
||||
export function createAutomation(input: ScheduledTaskCreateInput, options?: SchedulingScopeOptions): Promise<ScheduledTask> {
|
||||
// Forward all input fields including scope metadata (scope may be set on input or in options)
|
||||
return api<ScheduledTask>(withSchedulingScope("/automations", options), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
export function updateAutomation(id: string, updates: ScheduledTaskUpdateInput, options?: SchedulingScopeOptions): Promise<ScheduledTask> {
|
||||
// Forward all update fields including scope metadata
|
||||
return api<ScheduledTask>(withSchedulingScope(`/automations/${id}`, options), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteAutomation(id: string, options?: SchedulingScopeOptions): Promise<void> {
|
||||
await api(withSchedulingScope(`/automations/${id}`, options), {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
export function runAutomation(id: string, options?: SchedulingScopeOptions): Promise<AutomationRunResponse> {
|
||||
return api<AutomationRunResponse>(withSchedulingScope(`/automations/${id}/run`, options), {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
export function toggleAutomation(id: string, options?: SchedulingScopeOptions): Promise<ScheduledTask> {
|
||||
return api<ScheduledTask>(withSchedulingScope(`/automations/${id}/toggle`, options), {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
export function reorderAutomationSteps(id: string, stepIds: string[], options?: SchedulingScopeOptions): Promise<ScheduledTask> {
|
||||
return api<ScheduledTask>(withSchedulingScope(`/automations/${id}/steps/reorder`, options), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ stepIds }),
|
||||
});
|
||||
}
|
||||
|
||||
// ── Routines API ────────────────────────────────────────────────
|
||||
|
||||
export interface RoutineRunResponse {
|
||||
routine: Routine;
|
||||
result: RoutineExecutionResult;
|
||||
liveRunId?: string;
|
||||
}
|
||||
|
||||
export type RoutineRunStreamEvent =
|
||||
| { type: "run"; runId?: string; scheduleId?: string; status?: string }
|
||||
| { type: "step"; runId?: string; stepIndex?: number; stepId?: string; stepName?: string; stepType?: string; status?: string; success?: boolean; error?: string }
|
||||
| { type: "output"; runId?: string; text?: string }
|
||||
| { type: "tool"; runId?: string; status?: string; name?: string; args?: unknown; isError?: boolean; result?: unknown }
|
||||
| { type: "complete"; runId?: string; result?: RoutineExecutionResult }
|
||||
| { type: "error"; runId?: string; message?: string; result?: RoutineExecutionResult };
|
||||
|
||||
export interface RoutineRunStreamHandlers {
|
||||
onEvent: (event: RoutineRunStreamEvent) => void;
|
||||
onConnectionStateChange?: (state: StreamConnectionState) => void;
|
||||
onFatalError?: (message: string) => void;
|
||||
}
|
||||
|
||||
export function fetchRoutines(options?: SchedulingScopeOptions): Promise<Routine[]> {
|
||||
return api<Routine[]>(withSchedulingScope("/routines", options));
|
||||
}
|
||||
|
||||
export function fetchRoutine(id: string, options?: SchedulingScopeOptions): Promise<Routine> {
|
||||
return api<Routine>(withSchedulingScope(`/routines/${id}`, options));
|
||||
}
|
||||
|
||||
export function createRoutine(input: RoutineCreateInput, options?: SchedulingScopeOptions): Promise<Routine> {
|
||||
// Forward all input fields including scope metadata
|
||||
return api<Routine>(withSchedulingScope("/routines", options), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
export function updateRoutine(id: string, updates: RoutineUpdateInput, options?: SchedulingScopeOptions): Promise<Routine> {
|
||||
// Forward all update fields including scope metadata
|
||||
return api<Routine>(withSchedulingScope(`/routines/${id}`, options), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
export async function deleteRoutine(id: string, options?: SchedulingScopeOptions): Promise<void> {
|
||||
await api(withSchedulingScope(`/routines/${id}`, options), {
|
||||
method: "DELETE",
|
||||
});
|
||||
}
|
||||
|
||||
export function runRoutine(id: string, options?: SchedulingScopeOptions): Promise<RoutineRunResponse> {
|
||||
return api<RoutineRunResponse>(withSchedulingScope(`/routines/${id}/trigger`, options), {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
export function streamRoutineRun(id: string, handlers: RoutineRunStreamHandlers, options?: SchedulingScopeOptions & { runId?: string }) {
|
||||
const baseUrl = withSchedulingScope(`/routines/${id}/run/stream`, options);
|
||||
const separator = baseUrl.includes("?") ? "&" : "?";
|
||||
const url = options?.runId ? `${baseUrl}${separator}runId=${encodeURIComponent(options.runId)}` : baseUrl;
|
||||
const parse = (type: RoutineRunStreamEvent["type"], event: MessageEvent) => {
|
||||
let data: Record<string, unknown> = {};
|
||||
try {
|
||||
data = event.data ? JSON.parse(event.data) : {};
|
||||
} catch {
|
||||
data = { message: event.data };
|
||||
}
|
||||
handlers.onEvent({ type, ...data } as RoutineRunStreamEvent);
|
||||
};
|
||||
return createResilientEventSource(
|
||||
url,
|
||||
{
|
||||
events: {
|
||||
run: (event) => parse("run", event),
|
||||
step: (event) => parse("step", event),
|
||||
output: (event) => parse("output", event),
|
||||
tool: (event) => parse("tool", event),
|
||||
complete: (event) => parse("complete", event),
|
||||
error: (event) => parse("error", event),
|
||||
},
|
||||
},
|
||||
{
|
||||
maxReconnectAttempts: 2,
|
||||
onConnectionStateChange: handlers.onConnectionStateChange,
|
||||
onFatalError: handlers.onFatalError,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
export function fetchRoutineRuns(id: string, options?: SchedulingScopeOptions): Promise<RoutineExecutionResult[]> {
|
||||
return api<RoutineExecutionResult[]>(withSchedulingScope(`/routines/${id}/runs`, options));
|
||||
}
|
||||
|
||||
export function triggerRoutineWebhook(id: string, payload?: Record<string, unknown>, options?: SchedulingScopeOptions): Promise<RoutineRunResponse> {
|
||||
return api<RoutineRunResponse>(withSchedulingScope(`/routines/${id}/webhook`, options), {
|
||||
method: "POST",
|
||||
body: payload ? JSON.stringify(payload) : undefined,
|
||||
});
|
||||
}
|
||||
|
||||
// ── Activity Log API ────────────────────────────────────────────
|
||||
|
||||
/** Re-export ActivityLogEntry type from core for convenience */
|
||||
export type { ActivityLogEntry, ActivityEventType } from "@fusion/core";
|
||||
|
||||
/** Fetch activity log entries */
|
||||
export function fetchActivityLog(options?: { limit?: number; since?: string; type?: ActivityEventType; projectId?: string }): Promise<ActivityLogEntry[]> {
|
||||
const search = new URLSearchParams();
|
||||
if (options?.limit !== undefined) search.set("limit", String(options.limit));
|
||||
if (options?.since !== undefined) search.set("since", options.since);
|
||||
if (options?.type !== undefined) search.set("type", options.type);
|
||||
if (options?.projectId) search.set("projectId", options.projectId);
|
||||
const suffix = search.size > 0 ? `?${search.toString()}` : "";
|
||||
return api<ActivityLogEntry[]>(`/activity${suffix}`);
|
||||
}
|
||||
|
||||
/** Clear all activity log entries */
|
||||
export function clearActivityLog(projectId?: string): Promise<{ success: boolean }> {
|
||||
const path = withProjectId("/activity", projectId);
|
||||
return api<{ success: boolean }>(path, { method: "DELETE" });
|
||||
}
|
||||
|
||||
// ── Workflow Steps ─────────────────────────────────────────────────────
|
||||
|
||||
/*
|
||||
FNXC:WorkflowStepCRUD 2026-06-25-00:00:
|
||||
U5 removed the legacy `/workflow-steps` CRUD/REST surface (GET list, POST create,
|
||||
PATCH update, DELETE, refine) along with its Settings management UI. The client
|
||||
mutation helpers (`createWorkflowStep`/`updateWorkflowStep`/`deleteWorkflowStep`/
|
||||
`refineWorkflowStepPrompt`/`createWorkflowStepFromTemplate`) had no remaining callers
|
||||
and were deleted. `fetchWorkflowSteps` is retained as a stable, no-network shim
|
||||
returning `[]`: its only remaining consumers are the plugin dashboard context's
|
||||
`workflowSteps` field and the WorkflowResultsTab option list, both of which now source
|
||||
step state from the graph (optional-group nodes) — the legacy definition list no longer
|
||||
exists. Removing the field outright is graph-native U3 plumbing work, out of scope here.
|
||||
*/
|
||||
/** Legacy workflow-step definition list (removed in U5). Resolves to an empty list:
|
||||
* built-in/custom step definitions are now graph optional-group nodes, not DB rows. */
|
||||
export function fetchWorkflowSteps(_projectId?: string): Promise<WorkflowStep[]> {
|
||||
return Promise.resolve([]);
|
||||
}
|
||||
|
||||
/** Fetch workflow step results for a task */
|
||||
export function fetchWorkflowResults(taskId: string, projectId?: string): Promise<WorkflowStepResult[]> {
|
||||
return api<WorkflowStepResult[]>(withProjectId(`/tasks/${encodeURIComponent(taskId)}/workflow-results`, projectId));
|
||||
}
|
||||
|
||||
396
packages/dashboard/app/api/workflows.ts
Normal file
396
packages/dashboard/app/api/workflows.ts
Normal file
@@ -0,0 +1,396 @@
|
||||
/**
|
||||
* FNXC:CodeOrganization 2026-07-19-12:00:
|
||||
* Workflow definition client API peeled from legacy.ts.
|
||||
*/
|
||||
import { api } from "./client.js";
|
||||
import type { FetchOptions } from "./client.js";
|
||||
import { withProjectId } from "./health.js";
|
||||
import { dedupe } from "./dedupe.js";
|
||||
import { notifyWorkflowSettingValuesUpdated } from "../utils/workflowSettingValuesEvents.js";
|
||||
|
||||
// ── Workflow definitions (graph-authored custom workflows) ───────────────
|
||||
|
||||
export type {
|
||||
WorkflowDefinition,
|
||||
WorkflowDefinitionInput,
|
||||
WorkflowDefinitionUpdate,
|
||||
WorkflowIr,
|
||||
} from "@fusion/core";
|
||||
|
||||
/** List all workflow definitions for the project. */
|
||||
export function fetchWorkflows(projectId?: string, options?: { includeDisabledBuiltins?: boolean } & FetchOptions): Promise<import("@fusion/core").WorkflowDefinition[]> {
|
||||
const query = options?.includeDisabledBuiltins ? "?includeDisabledBuiltins=true" : "";
|
||||
const path = withProjectId(`/workflows${query}`, projectId);
|
||||
return dedupe(path, () => api<import("@fusion/core").WorkflowDefinition[]>(path), options);
|
||||
}
|
||||
|
||||
/** A trait catalog entry as returned by GET /api/traits (U10). Mirrors the
|
||||
* registry's TraitDefinition projection (flags + hook descriptors + schema). */
|
||||
export interface TraitCatalogEntry {
|
||||
id: string;
|
||||
name: string;
|
||||
description?: string;
|
||||
builtin: boolean;
|
||||
flags: import("@fusion/core").TraitFlags;
|
||||
hooks?: import("@fusion/core").TraitHookDescriptors;
|
||||
configSchema?: import("@fusion/core").TraitConfigSchema;
|
||||
}
|
||||
|
||||
/** Fetch the trait catalog (built-ins + registered plugin traits) for the
|
||||
* workflow editor's trait picker. Registry-backed, read-only, session-scoped. */
|
||||
export function fetchTraits(projectId?: string): Promise<TraitCatalogEntry[]> {
|
||||
const path = withProjectId("/traits", projectId);
|
||||
return dedupe(path, () =>
|
||||
api<{ traits: TraitCatalogEntry[] }>(path).then((res) => res.traits),
|
||||
);
|
||||
}
|
||||
|
||||
/** Fetch the step-parser id catalog (built-ins + registered plugin parsers) for
|
||||
* the parse-steps node inspector (KTD-12). Registry-backed, read-only,
|
||||
* session-scoped. Mirrors fetchTraits. */
|
||||
export function fetchStepParsers(projectId?: string): Promise<string[]> {
|
||||
const path = withProjectId("/step-parsers", projectId);
|
||||
return dedupe(path, () =>
|
||||
api<{ parsers: Array<{ id: string }> }>(path).then((res) => res.parsers.map((p) => p.id)),
|
||||
);
|
||||
}
|
||||
|
||||
/** Fetch a single workflow definition. */
|
||||
export function fetchWorkflow(id: string, projectId?: string): Promise<import("@fusion/core").WorkflowDefinition> {
|
||||
return api<import("@fusion/core").WorkflowDefinition>(withProjectId(`/workflows/${encodeURIComponent(id)}`, projectId));
|
||||
}
|
||||
|
||||
/** Fetch resolved optional step declarations for a workflow. */
|
||||
export function fetchWorkflowOptionalSteps(
|
||||
workflowId: string,
|
||||
projectId?: string,
|
||||
): Promise<import("@fusion/core").ResolvedWorkflowOptionalStep[]> {
|
||||
return api<import("@fusion/core").ResolvedWorkflowOptionalStep[]>(
|
||||
withProjectId(`/workflows/${encodeURIComponent(workflowId)}/optional-steps`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
/** Create a workflow definition. */
|
||||
export function createWorkflow(
|
||||
input: import("@fusion/core").WorkflowDefinitionInput,
|
||||
projectId?: string,
|
||||
): Promise<import("@fusion/core").WorkflowDefinition> {
|
||||
return api<import("@fusion/core").WorkflowDefinition>(withProjectId("/workflows", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
});
|
||||
}
|
||||
|
||||
/** Update a workflow definition (partial). */
|
||||
export function updateWorkflow(
|
||||
id: string,
|
||||
updates: import("@fusion/core").WorkflowDefinitionUpdate,
|
||||
projectId?: string,
|
||||
): Promise<import("@fusion/core").WorkflowDefinition> {
|
||||
return api<import("@fusion/core").WorkflowDefinition>(withProjectId(`/workflows/${encodeURIComponent(id)}`, projectId), {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(updates),
|
||||
});
|
||||
}
|
||||
|
||||
/** Delete a workflow definition. */
|
||||
export function deleteWorkflow(id: string, projectId?: string): Promise<void> {
|
||||
return api<void>(withProjectId(`/workflows/${encodeURIComponent(id)}`, projectId), { method: "DELETE" });
|
||||
}
|
||||
|
||||
/** The per-`(workflowId, project)` setting-value payload returned by the
|
||||
* workflow setting-value endpoints (U6/R5): the raw `stored` map, the
|
||||
* `effective` map (stored ?? declaration default, drop-on-orphan), and the
|
||||
* `orphaned` stored entries that no longer validate against the declarations. */
|
||||
export interface WorkflowSettingValuesPayload {
|
||||
stored: Record<string, unknown>;
|
||||
effective: Record<string, unknown>;
|
||||
orphaned: Array<{ id: string; value: unknown }>;
|
||||
}
|
||||
|
||||
/** Per-project workflow prompt override payload. `defaults` is the shipped prompt
|
||||
* by node id, `stored` is the persisted override map, and `effective` is the
|
||||
* prompt text the editor/executor sees after stored-over-default resolution. */
|
||||
export interface WorkflowPromptOverridesPayload {
|
||||
stored: Record<string, string>;
|
||||
effective: Record<string, string>;
|
||||
defaults: Record<string, string>;
|
||||
}
|
||||
|
||||
/** Read the setting VALUES (stored/effective/orphaned) for a workflow in the
|
||||
* current project context (U6). The project is bound server-side to the
|
||||
* scoped store. */
|
||||
export function fetchWorkflowSettingValues(
|
||||
id: string,
|
||||
projectId?: string,
|
||||
): Promise<WorkflowSettingValuesPayload> {
|
||||
return api<WorkflowSettingValuesPayload>(
|
||||
withProjectId(`/workflows/${encodeURIComponent(id)}/setting-values`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
/** Write setting VALUES for a workflow in the current project context (U6). The
|
||||
* `values` map is validated against the named workflow's declarations; a `null`
|
||||
* value deletes that key. A typed rejection surfaces as an ApiRequestError with
|
||||
* `status: 400` and `details.rejections: WorkflowSettingRejection[]`. */
|
||||
export async function updateWorkflowSettingValues(
|
||||
id: string,
|
||||
values: Record<string, unknown>,
|
||||
projectId?: string,
|
||||
): Promise<WorkflowSettingValuesPayload> {
|
||||
const payload = await api<WorkflowSettingValuesPayload>(
|
||||
withProjectId(`/workflows/${encodeURIComponent(id)}/setting-values`, projectId),
|
||||
{
|
||||
method: "PATCH",
|
||||
body: JSON.stringify({ values }),
|
||||
},
|
||||
);
|
||||
if (Object.prototype.hasOwnProperty.call(values, "plannerOversightLevel")) {
|
||||
notifyWorkflowSettingValuesUpdated(id, projectId);
|
||||
}
|
||||
return payload;
|
||||
}
|
||||
|
||||
/** Read per-node prompt overrides for a workflow in the current project context. */
|
||||
export function fetchWorkflowPromptOverrides(
|
||||
id: string,
|
||||
projectId?: string,
|
||||
): Promise<WorkflowPromptOverridesPayload> {
|
||||
return api<WorkflowPromptOverridesPayload>(
|
||||
withProjectId(`/workflows/${encodeURIComponent(id)}/prompt-overrides`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
/** Patch per-node prompt overrides. Null, empty, and whitespace values reset to the shipped default. */
|
||||
export function updateWorkflowPromptOverrides(
|
||||
id: string,
|
||||
overrides: Record<string, string | null>,
|
||||
projectId?: string,
|
||||
): Promise<WorkflowPromptOverridesPayload> {
|
||||
return api<WorkflowPromptOverridesPayload>(
|
||||
withProjectId(`/workflows/${encodeURIComponent(id)}/prompt-overrides`, projectId),
|
||||
{
|
||||
method: "PATCH",
|
||||
body: JSON.stringify({ overrides }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** A workflow export envelope (U5/R9/KTD-5). `schemaVersion` is the SERVER's
|
||||
* schema version at export time — the import route version-gates against it
|
||||
* (the app build aliases @fusion/core to types-only, so the value can only come
|
||||
* from the server, never an app-side core import).
|
||||
*
|
||||
* FNXC:WorkflowPortability 2026-06-30-00:00:
|
||||
* Dashboard downloads must carry project-scoped setting values and prompt overrides with the workflow graph so the same shared API path supports portable desktop and mobile Workflow Editor imports.
|
||||
*/
|
||||
export interface WorkflowExportEnvelope {
|
||||
fusionWorkflowExport: 1;
|
||||
schemaVersion: number;
|
||||
kind: import("@fusion/core").WorkflowDefinition["kind"];
|
||||
name: string;
|
||||
description: string;
|
||||
ir: import("@fusion/core").WorkflowIr;
|
||||
layout: import("@fusion/core").WorkflowDefinition["layout"];
|
||||
settingValues: Record<string, unknown>;
|
||||
promptOverrides: Record<string, string>;
|
||||
}
|
||||
|
||||
/** Fetch a workflow's export envelope and trigger a browser download as
|
||||
* `<name>.workflow.json` (U5/R9). Built-ins are exportable too. Mirrors the
|
||||
* SettingsModal export pattern (Blob + createObjectURL + a.download). */
|
||||
export async function exportWorkflow(id: string, projectId?: string): Promise<WorkflowExportEnvelope> {
|
||||
const envelope = await api<WorkflowExportEnvelope>(
|
||||
withProjectId(`/workflows/${encodeURIComponent(id)}/export`, projectId),
|
||||
);
|
||||
const safeName = (envelope.name || "workflow").replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "workflow";
|
||||
const blob = new Blob([JSON.stringify(envelope, null, 2)], { type: "application/json" });
|
||||
const url = URL.createObjectURL(blob);
|
||||
const link = document.createElement("a");
|
||||
link.href = url;
|
||||
link.download = `${safeName}.workflow.json`;
|
||||
document.body.appendChild(link);
|
||||
link.click();
|
||||
document.body.removeChild(link);
|
||||
URL.revokeObjectURL(url);
|
||||
return envelope;
|
||||
}
|
||||
|
||||
/** Result of POST /api/workflows/import (U5/R10). `strippedApprovalFlags` is set
|
||||
* when `cliSkipApproval`/`autoApprove` were removed from any node config at the
|
||||
* trust boundary; `warnings` lists non-blocking issues (e.g. unknown scriptName). */
|
||||
export interface ImportWorkflowResult {
|
||||
workflow: import("@fusion/core").WorkflowDefinition;
|
||||
strippedApprovalFlags: boolean;
|
||||
warnings: string[];
|
||||
settingValues: Record<string, unknown>;
|
||||
promptOverrides: Record<string, string>;
|
||||
}
|
||||
|
||||
/** Import a workflow export envelope (U5/R10). The server is the sole validator;
|
||||
* validation failures reject with an ApiError carrying the server message. */
|
||||
export function importWorkflow(
|
||||
envelope: unknown,
|
||||
projectId?: string,
|
||||
): Promise<ImportWorkflowResult> {
|
||||
return api<ImportWorkflowResult>(withProjectId("/workflows/import", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(envelope),
|
||||
});
|
||||
}
|
||||
|
||||
// FNXC:WorkflowStepCRUD 2026-06-26-14:00: U7c removed migrateLegacyWorkflowSteps and
|
||||
// MigrateLegacyStepsResult along with the legacy workflow_steps table and its route.
|
||||
|
||||
/** Result of POST /api/workflows/design (U10/R11). The server validates the
|
||||
* AI-produced IR (parseWorkflowIr) and strips trust-escalating flags
|
||||
* (`strippedApprovalFlags`). Persists nothing — the client decides what to do
|
||||
* with the returned graph. */
|
||||
export interface DesignWorkflowResult {
|
||||
ir: import("@fusion/core").WorkflowIr;
|
||||
layout: import("@fusion/core").WorkflowDefinition["layout"];
|
||||
strippedApprovalFlags: boolean;
|
||||
}
|
||||
|
||||
/** Design a workflow from a natural-language prompt (U10/R11). When `workflowId`
|
||||
* is supplied the route reads that workflow's persisted IR server-side and folds
|
||||
* it into the prompt as the base graph (the client never posts IR). An optional
|
||||
* AbortSignal cancels the in-flight request. Validation failures reject with an
|
||||
* ApiError carrying the server message; 429 on rate limit. */
|
||||
export function designWorkflow(
|
||||
input: { prompt: string; workflowId?: string },
|
||||
projectId?: string,
|
||||
signal?: AbortSignal,
|
||||
): Promise<DesignWorkflowResult> {
|
||||
return api<DesignWorkflowResult>(withProjectId("/workflows/design", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify(input),
|
||||
signal,
|
||||
});
|
||||
}
|
||||
|
||||
/** Read the workflow currently selected for a task. */
|
||||
export function fetchTaskWorkflow(taskId: string, projectId?: string): Promise<{ workflowId: string | null; enabledWorkflowSteps?: string[] | null }> {
|
||||
return api<{ workflowId: string | null; enabledWorkflowSteps?: string[] | null }>(
|
||||
withProjectId(`/tasks/${encodeURIComponent(taskId)}/workflow`, projectId),
|
||||
);
|
||||
}
|
||||
|
||||
/** Select (or clear, with null) a workflow for a task. Returns the resulting
|
||||
* enabled step ids so callers can reflect the change without a refetch. */
|
||||
export function selectTaskWorkflow(
|
||||
taskId: string,
|
||||
workflowId: string | null,
|
||||
projectId?: string,
|
||||
): Promise<{
|
||||
workflowId: string | null;
|
||||
enabledWorkflowSteps: string[];
|
||||
// U5 (R20): present (flag ON) when the switch re-homed the card; `preserved`
|
||||
// false means the card moved columns and the board needs a refresh.
|
||||
reconciliation?: { preserved: boolean; fromColumn: string; toColumn: string };
|
||||
}> {
|
||||
return api<{
|
||||
workflowId: string | null;
|
||||
enabledWorkflowSteps: string[];
|
||||
reconciliation?: { preserved: boolean; fromColumn: string; toColumn: string };
|
||||
}>(
|
||||
withProjectId(`/tasks/${encodeURIComponent(taskId)}/workflow`, projectId),
|
||||
{
|
||||
method: "PUT",
|
||||
body: JSON.stringify({ workflowId }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Approve the raw CLI command a task is paused on, and resume it. */
|
||||
export function approveTaskWorkflowCli(taskId: string, projectId?: string): Promise<{ approved: string }> {
|
||||
return api<{ approved: string }>(withProjectId(`/tasks/${encodeURIComponent(taskId)}/workflow/approve-cli`, projectId), {
|
||||
method: "POST",
|
||||
});
|
||||
}
|
||||
|
||||
/** Submit the user's answer to an await-input node and resume the task. */
|
||||
export function submitTaskWorkflowInput(taskId: string, text: string, projectId?: string): Promise<{ ok: true }> {
|
||||
return api<{ ok: true }>(withProjectId(`/tasks/${encodeURIComponent(taskId)}/workflow/input`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ text }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Read the project default workflow. */
|
||||
export function fetchProjectDefaultWorkflow(projectId?: string): Promise<{ workflowId: string | null }> {
|
||||
return api<{ workflowId: string | null }>(withProjectId("/project/default-workflow", projectId));
|
||||
}
|
||||
|
||||
/** Set (or clear, with null) the project default workflow. */
|
||||
export function setProjectDefaultWorkflow(
|
||||
workflowId: string | null,
|
||||
projectId?: string,
|
||||
): Promise<{ workflowId: string | null }> {
|
||||
return api<{ workflowId: string | null }>(withProjectId("/project/default-workflow", projectId), {
|
||||
method: "PUT",
|
||||
body: JSON.stringify({ workflowId }),
|
||||
});
|
||||
}
|
||||
|
||||
// ── Workflow Step Templates ──────────────────────────────────────────────
|
||||
|
||||
/** Re-export WorkflowStepTemplate type from core */
|
||||
export type { WorkflowStepTemplate } from "@fusion/core";
|
||||
|
||||
/** Fetch the workflow step templates that feed the editor palette. The built-in
|
||||
* built-in step-template catalog was deleted in U6, so this now returns only
|
||||
* plugin-contributed templates. */
|
||||
export function fetchWorkflowStepTemplates(): Promise<{ templates: import("@fusion/core").WorkflowStepTemplate[] }> {
|
||||
return api<{ templates: import("@fusion/core").WorkflowStepTemplate[] }>("/workflow-step-templates");
|
||||
}
|
||||
|
||||
/** Fetch plugin-contributed workflow step templates */
|
||||
export function fetchPluginWorkflowStepTemplates(): Promise<{
|
||||
templates: Array<{ pluginId: string; template: import("@fusion/core").WorkflowStepTemplate }>;
|
||||
}> {
|
||||
return api<{
|
||||
templates: Array<{ pluginId: string; template: import("@fusion/core").WorkflowStepTemplate }>;
|
||||
}>("/plugin-workflow-step-templates");
|
||||
}
|
||||
|
||||
// ── Scripts API ────────────────────────────────────────────────────────
|
||||
|
||||
/** Script entry returned from the API */
|
||||
export interface ScriptEntry {
|
||||
name: string;
|
||||
command: string;
|
||||
}
|
||||
|
||||
/** Result of running a script via POST /api/scripts/:name/run */
|
||||
export interface ScriptRunResult {
|
||||
sessionId: string;
|
||||
command: string;
|
||||
}
|
||||
|
||||
/** Fetch all saved scripts from project settings */
|
||||
export function fetchScripts(projectId?: string): Promise<Record<string, string>> {
|
||||
return api<Record<string, string>>(withProjectId("/scripts", projectId));
|
||||
}
|
||||
|
||||
/** Add or update a script */
|
||||
export function addScript(name: string, command: string, projectId?: string): Promise<ScriptEntry> {
|
||||
return api<ScriptEntry>(withProjectId("/scripts", projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ name, command }),
|
||||
});
|
||||
}
|
||||
|
||||
/** Remove a script by name */
|
||||
export function removeScript(name: string, projectId?: string): Promise<void> {
|
||||
return api<void>(withProjectId(`/scripts/${encodeURIComponent(name)}`, projectId), { method: "DELETE" });
|
||||
}
|
||||
|
||||
/** Run a saved script by name */
|
||||
export function runScript(name: string, args?: string[], projectId?: string): Promise<ScriptRunResult> {
|
||||
return api<ScriptRunResult>(withProjectId(`/scripts/${encodeURIComponent(name)}/run`, projectId), {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ args }),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -357,7 +357,7 @@ const EMPTY_FEATURE_FORM: FeatureFormData = {
|
||||
status: "defined",
|
||||
};
|
||||
|
||||
function missionAutoMergeOverride(autoMerge?: boolean): MissionAutoMergeOverride {
|
||||
function missionAutoMergeOverride(autoMerge?: boolean | null): MissionAutoMergeOverride {
|
||||
return autoMerge === true ? "on" : autoMerge === false ? "off" : "inherit";
|
||||
}
|
||||
|
||||
|
||||
@@ -58,8 +58,13 @@ export interface Mission {
|
||||
};
|
||||
status: MissionStatus;
|
||||
interviewState: "not_started" | "in_progress" | "completed" | "needs_update";
|
||||
/** Mission-level auto-merge override for linked task branches. */
|
||||
autoMerge?: boolean;
|
||||
/**
|
||||
* FNXC:MissionAutoMerge 2026-07-19-12:30:
|
||||
* Mission-level auto-merge override for linked task branches.
|
||||
* `null` clears an explicit override back to project default on PATCH.
|
||||
* Keep in sync with app/api/missions.ts Mission.autoMerge.
|
||||
*/
|
||||
autoMerge?: boolean | null;
|
||||
autoAdvance?: boolean;
|
||||
autopilotEnabled?: boolean;
|
||||
autopilotState?: AutopilotState;
|
||||
|
||||
@@ -223,7 +223,12 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
|
||||
try {
|
||||
const { sessionId, subtasks, parentTaskId, branch, baseBranch, branchSelection, branchAssignment, workflowId } = req.body as {
|
||||
sessionId?: string;
|
||||
subtasks?: Array<{ tempId: string; title: string; description: string; size?: "S" | "M" | "L"; dependsOn?: string[] }>;
|
||||
/*
|
||||
FNXC:SubtaskPriority 2026-07-19-12:30:
|
||||
Accept optional priority from SubtaskItem so breakdown create-tasks preserves
|
||||
stream-assigned prioritization (client maps subtask.priority onto this field).
|
||||
*/
|
||||
subtasks?: Array<{ tempId: string; title: string; description: string; size?: "S" | "M" | "L"; priority?: string; dependsOn?: string[] }>;
|
||||
parentTaskId?: string;
|
||||
branch?: unknown;
|
||||
baseBranch?: unknown;
|
||||
@@ -320,10 +325,14 @@ export function registerPlanningSubtaskRoutes(ctx: ApiRoutesContext, deps: Plann
|
||||
column resolution. Omitting `column` lets the store resolve intake for the
|
||||
selected-or-default workflow (byte-identical "triage" for builtin:coding).
|
||||
*/
|
||||
const priority = typeof item.priority === "string" && (TASK_PRIORITIES as readonly string[]).includes(item.priority)
|
||||
? (item.priority as TaskPriority)
|
||||
: undefined;
|
||||
const { task, wasDuplicate } = await createAgentTask(scopedStore, {
|
||||
title: item.title.trim(),
|
||||
description: typeof item.description === "string" ? item.description.trim() : item.title.trim(),
|
||||
dependencies: undefined,
|
||||
...(priority !== undefined ? { priority } : {}),
|
||||
// Inherit parent's model settings if available
|
||||
modelProvider: parentTask?.modelProvider,
|
||||
modelId: parentTask?.modelId,
|
||||
|
||||
@@ -5,57 +5,58 @@
|
||||
"packages/cli/src/commands/__tests__/task.test.ts": 3638,
|
||||
"packages/cli/src/commands/dashboard-tui/app.tsx": 4674,
|
||||
"packages/cli/src/commands/dashboard.ts": 3699,
|
||||
"packages/cli/src/commands/task.ts": 2366,
|
||||
"packages/cli/src/commands/task.ts": 2372,
|
||||
"packages/cli/src/extension.ts": 5687,
|
||||
"packages/core/src/__tests__/postgres/schema-applier.test.ts": 2133,
|
||||
"packages/core/src/agent-store.ts": 3484,
|
||||
"packages/core/src/async-mission-store-queries.ts": 2093,
|
||||
"packages/core/src/central-core.ts": 4486,
|
||||
"packages/core/src/index.gate.ts": 2228,
|
||||
"packages/core/src/index.ts": 2512,
|
||||
"packages/core/src/index.gate.ts": 2230,
|
||||
"packages/core/src/index.ts": 2537,
|
||||
"packages/core/src/mission-store.ts": 4369,
|
||||
"packages/core/src/postgres/schema/project.ts": 2155,
|
||||
"packages/core/src/postgres/sqlite-migrator.ts": 2112,
|
||||
"packages/core/src/store.ts": 2746,
|
||||
"packages/core/src/types.ts": 6165,
|
||||
"packages/dashboard/app/App.tsx": 2059,
|
||||
"packages/dashboard/app/api/legacy.ts": 8913,
|
||||
"packages/core/src/postgres/schema/project.ts": 2209,
|
||||
"packages/core/src/postgres/sqlite-migrator.ts": 2254,
|
||||
"packages/core/src/store.ts": 2781,
|
||||
"packages/core/src/types.ts": 6249,
|
||||
"packages/dashboard/app/App.tsx": 2104,
|
||||
"packages/dashboard/app/api/legacy.ts": 5667,
|
||||
"packages/dashboard/app/components/AgentDetailView.tsx": 5567,
|
||||
"packages/dashboard/app/components/AgentsView.tsx": 2254,
|
||||
"packages/dashboard/app/components/ChatView.tsx": 4020,
|
||||
"packages/dashboard/app/components/ChatView.tsx": 4024,
|
||||
"packages/dashboard/app/components/GitHubImportModal.tsx": 2481,
|
||||
"packages/dashboard/app/components/GitManagerModal.tsx": 3560,
|
||||
"packages/dashboard/app/components/ListView.tsx": 3118,
|
||||
"packages/dashboard/app/components/MissionManager.tsx": 5140,
|
||||
"packages/dashboard/app/components/MissionManager.tsx": 5149,
|
||||
"packages/dashboard/app/components/ModelOnboardingModal.tsx": 3594,
|
||||
"packages/dashboard/app/components/PlanningModeModal.tsx": 4012,
|
||||
"packages/dashboard/app/components/PlanningModeModal.tsx": 3880,
|
||||
"packages/dashboard/app/components/QuickEntryBox.tsx": 2562,
|
||||
"packages/dashboard/app/components/SettingsModal.tsx": 5002,
|
||||
"packages/dashboard/app/components/SettingsModal.tsx": 5019,
|
||||
"packages/dashboard/app/components/TaskCard.tsx": 3818,
|
||||
"packages/dashboard/app/components/TaskDetailModal.tsx": 6509,
|
||||
"packages/dashboard/app/components/TaskDetailModal.tsx": 6522,
|
||||
"packages/dashboard/app/components/TerminalModal.tsx": 3322,
|
||||
"packages/dashboard/app/components/WorkflowNodeEditor.tsx": 5685,
|
||||
"packages/dashboard/app/components/__tests__/AgentsView.test.tsx": 2854,
|
||||
"packages/dashboard/app/components/__tests__/App.test.tsx": 4640,
|
||||
"packages/dashboard/app/components/__tests__/App.test.tsx": 4660,
|
||||
"packages/dashboard/app/components/__tests__/Board.test.tsx": 2107,
|
||||
"packages/dashboard/app/components/__tests__/ChatView.mobile.test.tsx": 2436,
|
||||
"packages/dashboard/app/components/__tests__/GitHubImportModal.test.tsx": 3171,
|
||||
"packages/dashboard/app/components/__tests__/GitManagerModal.test.tsx": 3790,
|
||||
"packages/dashboard/app/components/__tests__/ListView.test.tsx": 5380,
|
||||
"packages/dashboard/app/components/__tests__/MailboxView.test.tsx": 2600,
|
||||
"packages/dashboard/app/components/__tests__/MailboxView.test.tsx": 2609,
|
||||
"packages/dashboard/app/components/__tests__/ModelOnboardingModal.test.tsx": 5146,
|
||||
"packages/dashboard/app/components/__tests__/NewTaskModal.test.tsx": 2081,
|
||||
"packages/dashboard/app/components/__tests__/PlanningModeModal.planning-flow.test.tsx": 4537,
|
||||
"packages/dashboard/app/components/__tests__/PlanningModeModal.planning-flow.test.tsx": 4103,
|
||||
"packages/dashboard/app/components/__tests__/QuickEntryBox.test.tsx": 5433,
|
||||
"packages/dashboard/app/components/__tests__/SettingsModal.general.test.tsx": 2021,
|
||||
"packages/dashboard/app/components/__tests__/SettingsModal.general.test.tsx": 2058,
|
||||
"packages/dashboard/app/components/__tests__/TaskCard.test.tsx": 7548,
|
||||
"packages/dashboard/app/components/__tests__/TaskChatTab.test.tsx": 3141,
|
||||
"packages/dashboard/app/components/__tests__/TaskChatTab.test.tsx": 3175,
|
||||
"packages/dashboard/app/components/__tests__/TaskDetailModal.inline-editing-and-integrations.test.tsx": 3438,
|
||||
"packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx": 2821,
|
||||
"packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx": 2042,
|
||||
"packages/dashboard/app/components/__tests__/TerminalModal.test.tsx": 9176,
|
||||
"packages/dashboard/app/components/__tests__/UsageIndicator.test.tsx": 2931,
|
||||
"packages/dashboard/app/components/__tests__/WorkflowNodeEditor.test.tsx": 4353,
|
||||
"packages/dashboard/app/components/__tests__/WorkflowResultsTab.test.tsx": 2062,
|
||||
"packages/dashboard/app/components/__tests__/WorkflowResultsTab.test.tsx": 2206,
|
||||
"packages/dashboard/app/components/__tests__/workflow-flow-mapping.test.ts": 2458,
|
||||
"packages/dashboard/app/hooks/__tests__/useChat.test.ts": 5376,
|
||||
"packages/dashboard/app/hooks/__tests__/useTasks.test.ts": 3766,
|
||||
@@ -68,41 +69,41 @@
|
||||
"packages/dashboard/src/__tests__/routes-planning.test.ts": 5271,
|
||||
"packages/dashboard/src/__tests__/routes-tasks.test.ts": 3024,
|
||||
"packages/dashboard/src/__tests__/usage.test.ts": 5261,
|
||||
"packages/dashboard/src/chat.ts": 3069,
|
||||
"packages/dashboard/src/github.ts": 4877,
|
||||
"packages/dashboard/src/chat.ts": 3124,
|
||||
"packages/dashboard/src/github.ts": 4984,
|
||||
"packages/dashboard/src/mission-routes.ts": 3909,
|
||||
"packages/dashboard/src/planning.ts": 3625,
|
||||
"packages/dashboard/src/planning.ts": 3322,
|
||||
"packages/dashboard/src/routes.ts": 5629,
|
||||
"packages/dashboard/src/routes/register-git-github.ts": 6342,
|
||||
"packages/dashboard/src/routes/register-settings-memory-routes.ts": 2403,
|
||||
"packages/dashboard/src/routes/register-task-workflow-routes.ts": 5490,
|
||||
"packages/dashboard/src/routes/register-task-workflow-routes.ts": 5530,
|
||||
"packages/dashboard/src/server.ts": 2862,
|
||||
"packages/dashboard/src/usage.ts": 2398,
|
||||
"packages/engine/src/__tests__/cron-runner.test.ts": 2334,
|
||||
"packages/engine/src/__tests__/executor-prompt.test.ts": 2716,
|
||||
"packages/engine/src/__tests__/executor-worktree.test.ts": 2723,
|
||||
"packages/engine/src/__tests__/heartbeat-executor.test.ts": 4462,
|
||||
"packages/engine/src/__tests__/executor-worktree.test.ts": 2757,
|
||||
"packages/engine/src/__tests__/heartbeat-executor.test.ts": 4466,
|
||||
"packages/engine/src/__tests__/heartbeat-scheduler.test.ts": 3327,
|
||||
"packages/engine/src/__tests__/merger-merge-lifecycle.test.ts": 3697,
|
||||
"packages/engine/src/__tests__/merger-verification.test.ts": 3177,
|
||||
"packages/engine/src/__tests__/mission-execution-loop.test.ts": 2984,
|
||||
"packages/engine/src/__tests__/pi-create-fn-agent.test.ts": 3148,
|
||||
"packages/engine/src/__tests__/pi-create-fn-agent.test.ts": 3167,
|
||||
"packages/engine/src/__tests__/project-engine.test.ts": 3691,
|
||||
"packages/engine/src/__tests__/restart.integration.test.ts": 2022,
|
||||
"packages/engine/src/__tests__/self-healing.test.ts": 11692,
|
||||
"packages/engine/src/__tests__/step-session-executor.test.ts": 3226,
|
||||
"packages/engine/src/__tests__/triage.test.ts": 7398,
|
||||
"packages/engine/src/__tests__/triage.test.ts": 7714,
|
||||
"packages/engine/src/agent-heartbeat.ts": 5370,
|
||||
"packages/engine/src/agent-tools.ts": 5258,
|
||||
"packages/engine/src/executor.ts": 20123,
|
||||
"packages/engine/src/agent-tools.ts": 5295,
|
||||
"packages/engine/src/executor.ts": 20200,
|
||||
"packages/engine/src/merger-ai.ts": 2401,
|
||||
"packages/engine/src/merger.ts": 11208,
|
||||
"packages/engine/src/pi.ts": 2814,
|
||||
"packages/engine/src/pi.ts": 2815,
|
||||
"packages/engine/src/project-engine.ts": 5410,
|
||||
"packages/engine/src/scheduler.ts": 3399,
|
||||
"packages/engine/src/self-healing.ts": 12399,
|
||||
"packages/engine/src/triage.ts": 3602,
|
||||
"packages/engine/src/self-healing.ts": 12509,
|
||||
"packages/engine/src/triage.ts": 3817,
|
||||
"packages/pi-claude-cli/src/__tests__/provider.test.ts": 2028,
|
||||
"plugins/fusion-plugin-roadmap/src/dashboard/RoadmapsView.tsx": 2583,
|
||||
"scripts/__tests__/test-changed.test.mjs": 2116
|
||||
"scripts/__tests__/test-changed.test.mjs": 2134
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user