Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { useEffect, useMemo, useReducer, useRef } from 'react';
import { shortClaudeModelName } from '../utils/formatters';
import toast from '../components/ui/Toast';
import * as api from '../services/api';
import { processScreenshotUploads, processAttachmentUploads } from '../services/apiMedia';
import { isCompositeProviderId } from '../utils/providerRef';
import {
effortSurvivingModel,
isCliProvider,
isCodexSubscriptionProvider,
isProcessProvider,
isTuiProvider,
resolveProviderModelOptions,
MODEL_SOURCE,
seedModelEffort,
} from '../utils/providers';
import { reviewerModelsFromDefaults, reviewerEffortsFromDefaults } from '../lib/reviewerModels';
import { PORTOS_APP_ID } from '../lib/appIdentity';
import { safeReadJsonStorage, safeReadStorage, safeRemoveStorage, safeWriteJsonStorage, safeWriteStorage } from '../lib/safeStorage';
import {
DEFAULT_PR_COMPLETION,
DEFAULT_REVIEWERS,
DEFAULT_REVIEW_STOP_MODE,
} from '../components/cos/constants.js';
import useAssignableInstances from './useAssignableInstances.js';
import { useInstanceFeatures } from './useInstanceFeatures.js';
import useReviewerModelOptions from './useReviewerModelOptions.js';
const TASK_DESCRIPTION_DRAFT_KEY = 'portos-cos-task-description-draft';
const QUICK_TEMPLATES_EXPANDED_KEY = 'portos-cos-quick-templates-expanded';
export const LAST_TARGET_APP_KEY = 'portos-cos-last-target-app';
const INVALID_DRAFT = Symbol('invalid task description draft');
const REVIEW_PICKER_TO_PAYLOAD_KEY = {
reviewers: 'reviewers',
usernames: 'usernames',
optionalReviewers: 'optionalReviewers',
reviewerMaxRounds: 'reviewerMaxRounds',
reviewerModels: 'reviewerModels',
reviewerEfforts: 'reviewerEfforts',
stopMode: 'reviewStopMode',
reviewerApplies: 'reviewerApplies',
};
const reviewOverridePayload = (reviewOverrides) => Object.fromEntries(
Object.entries(REVIEW_PICKER_TO_PAYLOAD_KEY)
.filter(([pickerKey]) => reviewOverrides[pickerKey] !== undefined)
.map(([pickerKey, payloadKey]) => [payloadKey, reviewOverrides[pickerKey]]),
);
const readLastTargetApp = () => safeReadStorage(LAST_TARGET_APP_KEY) || '';
const readTaskDescriptionDraft = (defaultApp) => {
const lastApp = readLastTargetApp();
const fallbackApp = defaultApp || lastApp;
const raw = safeReadStorage(TASK_DESCRIPTION_DRAFT_KEY);
if (raw === null) return { description: '', app: fallbackApp };
const draft = safeReadJsonStorage(TASK_DESCRIPTION_DRAFT_KEY, INVALID_DRAFT);
if (draft === INVALID_DRAFT) return { description: raw, app: fallbackApp };
if (typeof draft === 'string') return { description: draft, app: fallbackApp };
if (!draft || typeof draft !== 'object' || Array.isArray(draft)) return { description: '', app: fallbackApp };
return {
description: typeof draft.description === 'string' ? draft.description : '',
app: typeof draft.app === 'string' && draft.app ? draft.app : fallbackApp,
};
};
const readQuickTemplatesExpanded = (fallback) => {
const stored = safeReadStorage(QUICK_TEMPLATES_EXPANDED_KEY);
if (stored === 'true') return true;
if (stored === 'false') return false;
return fallback;
};
const createReviewDefaults = () => ({
reviewers: [...DEFAULT_REVIEWERS],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
reviewerModels: {},
reviewerEfforts: {},
stopMode: DEFAULT_REVIEW_STOP_MODE,
reviewerApplies: false,
});
const createOrchestrationProfile = () => ({
architect: { provider: '', model: '', effort: '' },
implementer: { provider: '', model: '', effort: '' },
reviewer: { provider: '', model: '', effort: '' },
});
const soleSelectableModel = (provider, selectedModel = '') => {
const models = resolveProviderModelOptions(provider, selectedModel).models;
return models.length === 1 ? models[0] : '';
};
const runShapeDefaultsPatch = (selectedApp) => {
if (selectedApp?.isGitRepo === false) return { useWorktree: false, openPR: false, prCompletion: DEFAULT_PR_COMPLETION };
const worktreeOptOut = selectedApp?.defaultUseWorktree === false;
const defaultOpenPR = selectedApp?.defaultOpenPR ?? !worktreeOptOut;
return {
useWorktree: (selectedApp?.defaultUseWorktree ?? true) || defaultOpenPR,
openPR: defaultOpenPR,
prCompletion: selectedApp?.defaultPrCompletion || DEFAULT_PR_COMPLETION,
};
};
const appDefaultsPatch = (selectedApp) => ({
createJiraTicket: !!selectedApp?.jira?.enabled,
...runShapeDefaultsPatch(selectedApp),
});
const templateProfile = (profile) => ({
architect: {
provider: profile?.architect?.provider || '',
model: profile?.architect?.model || '',
effort: profile?.architect?.effort || '',
},
implementer: {
provider: profile?.implementer?.provider || '',
model: profile?.implementer?.model || '',
effort: profile?.implementer?.effort || '',
},
reviewer: {
provider: profile?.reviewer?.provider || '',
model: profile?.reviewer?.model || '',
effort: profile?.reviewer?.effort || '',
},
});
export function createTaskAddFormState({ initialDraft, defaultApp = '', apps, queueFirst = false, defaultExpanded = false }) {
return {
newTask: {
description: initialDraft.description,
model: '',
provider: '',
effort: '',
temperature: '',
thinking: '',
app: apps?.some((app) => app.id === initialDraft.app) ? initialDraft.app : (defaultApp || initialDraft.app),
},
addToTop: false,
enhancePrompt: false,
isEnhancing: false,
useWorktree: true,
whenDone: 'leave-uncommitted',
openPR: true,
simplify: true,
planOnly: false,
issueTarget: 'upstream',
issueTargets: { appId: null, value: null },
worktreeChangesExpected: undefined,
prCompletion: DEFAULT_PR_COMPLETION,
reviewDefaults: createReviewDefaults(),
reviewOverrides: {},
reviewerCliInstalled: {},
providerReviewUnsupported: {},
targetInstanceId: '',
createJiraTicket: false,
screenshots: [],
attachments: [],
templates: [],
showTemplates: readQuickTemplatesExpanded(queueFirst),
expanded: defaultExpanded,
configurationOpen: false,
templateNameInput: '',
showTemplateSave: false,
isSubmitting: false,
slashdoCommand: '',
orchestrationMode: 'direct',
orchestrationProfiles: [],
selectedProfileId: '',
orchestrationProfile: createOrchestrationProfile(),
resolvedWorkTracker: { appId: null, tracker: null },
};
}
export function taskAddFormReducer(state, action) {
if (action.type === 'patch') {
const patch = typeof action.patch === 'function' ? action.patch(state) : action.patch;
return { ...state, ...patch };
}
if (action.type === 'task') {
const patch = typeof action.patch === 'function' ? action.patch(state.newTask) : action.patch;
return { ...state, newTask: { ...state.newTask, ...patch } };
}
return state;
}
export default function useTaskAddForm({
providers,
providersLoaded = true,
apps,
onTaskAdded,
defaultExpanded = false,
defaultApp = '',
queueFirst = false,
}) {
const initialDraftRef = useRef(null);
if (initialDraftRef.current === null) initialDraftRef.current = readTaskDescriptionDraft(defaultApp);
const initialDraft = initialDraftRef.current;
const pendingDraftAppRef = useRef(Boolean(initialDraft.app) && !apps?.length);
const [state, dispatch] = useReducer(
taskAddFormReducer,
{ initialDraft, defaultApp, apps, queueFirst, defaultExpanded },
createTaskAddFormState,
);
const setField = (field, value) => dispatch({ type: 'patch', patch: { [field]: value } });
const setTaskField = (field, value) => dispatch({ type: 'task', patch: { [field]: value } });
const { instances: assignableInstances, isFederated } = useAssignableInstances();
const { isFeatureEnabled } = useInstanceFeatures();
const quickTemplatesEnabled = isFeatureEnabled('cos-task-templates');
const reviewerModelOptions = useReviewerModelOptions();
const submittingRef = useRef(false);
const descriptionRef = useRef(null);
const templateAppChangeRef = useRef(false);
const showTemplatesInitialized = useRef(false);
useEffect(() => {
api.getOrchestrationProfiles?.({ silent: true })
?.then((res) => {
const list = Array.isArray(res) ? res : res?.profiles || [];
dispatch({ type: 'patch', patch: { orchestrationProfiles: list } });
})
?.catch(() => {});
}, []);
useEffect(() => {
if (state.newTask.description) {
safeWriteJsonStorage(TASK_DESCRIPTION_DRAFT_KEY, {
description: state.newTask.description,
app: state.newTask.app || null,
});
} else {
safeRemoveStorage(TASK_DESCRIPTION_DRAFT_KEY);
}
}, [state.newTask.app, state.newTask.description]);
useEffect(() => {
if (!pendingDraftAppRef.current || !apps?.length) return;
pendingDraftAppRef.current = false;
if (apps.some((app) => app.id === initialDraft.app)) {
dispatch({ type: 'task', patch: { app: initialDraft.app } });
}
}, [apps, initialDraft.app]);
const handleAppChange = (app) => {
pendingDraftAppRef.current = false;
safeWriteStorage(LAST_TARGET_APP_KEY, app || '');
dispatch({ type: 'task', patch: { app } });
};
useEffect(() => {
if (!state.newTask.app || !apps?.length || apps.some((app) => app.id === state.newTask.app)) return;
dispatch({ type: 'task', patch: { app: defaultApp } });
}, [apps, defaultApp, state.newTask.app]);
useEffect(() => {
if (!quickTemplatesEnabled) {
dispatch({ type: 'patch', patch: { templates: [], showTemplateSave: false } });
return undefined;
}
let active = true;
api.getCosPopularTemplates(8)
.then((data) => {
if (active) dispatch({ type: 'patch', patch: { templates: data?.templates || [] } });
})
.catch(() => {
if (active) dispatch({ type: 'patch', patch: { templates: [] } });
});
return () => { active = false; };
}, [quickTemplatesEnabled]);
useEffect(() => {
if (!showTemplatesInitialized.current) {
showTemplatesInitialized.current = true;
return;
}
safeWriteStorage(QUICK_TEMPLATES_EXPANDED_KEY, String(state.showTemplates));
}, [state.showTemplates]);
useEffect(() => {
let cancelled = false;
api.getCodeReviewDefaults({ silent: true })
.then((d) => {
if (cancelled || !d) return;
dispatch({
type: 'patch',
patch: {
reviewDefaults: {
reviewers: Array.isArray(d.reviewers) && d.reviewers.length ? d.reviewers : DEFAULT_REVIEWERS,
usernames: Array.isArray(d.usernames) ? d.usernames : [],
optionalReviewers: Array.isArray(d.optionalReviewers) ? d.optionalReviewers : [],
reviewerMaxRounds: d.reviewerMaxRounds && typeof d.reviewerMaxRounds === 'object' && !Array.isArray(d.reviewerMaxRounds) ? d.reviewerMaxRounds : {},
reviewerModels: reviewerModelsFromDefaults(d),
reviewerEfforts: reviewerEffortsFromDefaults(d),
stopMode: d.stopMode || DEFAULT_REVIEW_STOP_MODE,
reviewerApplies: d.reviewerApplies === true,
},
reviewerCliInstalled: d.installed && typeof d.installed === 'object' && !Array.isArray(d.installed) ? d.installed : {},
providerReviewUnsupported: d.providerReviewUnsupported && typeof d.providerReviewUnsupported === 'object' && !Array.isArray(d.providerReviewUnsupported) ? d.providerReviewUnsupported : {},
},
});
})
.catch(() => {});
return () => { cancelled = true; };
}, []);
const enabledProviders = useMemo(
() => providers?.filter((provider) => provider.enabled && isProcessProvider(provider)) || [],
[providers],
);
const apiOnlyProviders = useMemo(() => {
const enabled = providers?.filter((provider) => provider.enabled) || [];
return enabled.length > 0 && enabledProviders.length === 0;
}, [providers, enabledProviders]);
useEffect(() => {
if (!providersLoaded) return;
if (isCompositeProviderId(state.newTask.provider)) return;
if (state.newTask.provider && !enabledProviders.some((provider) => provider.id === state.newTask.provider)) {
dispatch({ type: 'task', patch: { provider: '', model: '', effort: '', temperature: '', thinking: '' } });
}
}, [enabledProviders, state.newTask.provider, providersLoaded]);
const selectedApp = useMemo(
() => apps?.find((app) => app.id === state.newTask.app),
[apps, state.newTask.app],
);
const appHasJira = selectedApp?.jira?.enabled;
const selectedAppId = selectedApp?.id || PORTOS_APP_ID;
useEffect(() => {
const configuredTracker = selectedApp?.workTracker;
const appId = selectedApp?.id || PORTOS_APP_ID;
if (selectedApp && configuredTracker && configuredTracker !== 'auto') {
dispatch({ type: 'patch', patch: { resolvedWorkTracker: { appId, tracker: configuredTracker } } });
return undefined;
}
dispatch({ type: 'patch', patch: { resolvedWorkTracker: { appId, tracker: null } } });
let cancelled = false;
Promise.resolve(api.getAppWorkTracker(appId, { silent: true }))
.then((info) => {
if (!cancelled) dispatch({ type: 'patch', patch: { resolvedWorkTracker: { appId, tracker: info?.resolved || null } } });
})
.catch(() => {
if (!cancelled) dispatch({ type: 'patch', patch: { resolvedWorkTracker: { appId, tracker: null } } });
});
return () => { cancelled = true; };
}, [selectedApp?.id, selectedApp?.workTracker]);
const planOnlyTrackerStatus = useMemo(() => {
const configuredTracker = selectedApp?.workTracker;
const tracker = configuredTracker && configuredTracker !== 'auto'
? configuredTracker
: state.resolvedWorkTracker.appId === (selectedApp?.id || PORTOS_APP_ID) ? state.resolvedWorkTracker.tracker : null;
if (!tracker) return 'pending';
return tracker === 'github' || tracker === 'gitlab' ? 'supported' : 'unsupported';
}, [state.resolvedWorkTracker, selectedApp]);
const planOnlySupported = planOnlyTrackerStatus === 'supported';
useEffect(() => {
const appId = selectedApp?.id || PORTOS_APP_ID;
if (!state.planOnly || !planOnlySupported) {
dispatch({ type: 'patch', patch: { issueTargets: { appId, value: null } } });
return undefined;
}
let cancelled = false;
dispatch({ type: 'patch', patch: { issueTargets: { appId, value: null } } });
Promise.resolve(api.getAppRepositorySources(appId, { silent: true }))
.then((status) => {
if (cancelled) return;
const value = status?.issueTargets || null;
dispatch({ type: 'patch', patch: { issueTargets: { appId, value }, issueTarget: value?.default || 'upstream' } });
})
.catch(() => {
if (!cancelled) dispatch({ type: 'patch', patch: { issueTargets: { appId, value: null } } });
});
return () => { cancelled = true; };
}, [state.planOnly, planOnlySupported, selectedApp?.id]);
useEffect(() => {
if (planOnlyTrackerStatus !== 'unsupported' || !state.planOnly) return;
dispatch({
type: 'patch',
patch: {
planOnly: false,
...(state.slashdoCommand === 'plan-task' ? { slashdoCommand: '', worktreeChangesExpected: undefined } : {}),
},
});
}, [state.planOnly, planOnlyTrackerStatus, state.slashdoCommand]);
const appDefaultsSig = useMemo(
() => selectedApp
? `${selectedApp.id}|${String(selectedApp.defaultOpenPR)}|${selectedApp.defaultPrCompletion || DEFAULT_PR_COMPLETION}|${String(selectedApp.defaultUseWorktree)}|${String(selectedApp.isGitRepo)}|${!!selectedApp.jira?.enabled}`
: `none:${state.newTask.app || ''}`,
[selectedApp, state.newTask.app],
);
useEffect(() => {
if (templateAppChangeRef.current) {
templateAppChangeRef.current = false;
return;
}
if (state.planOnly) {
dispatch({ type: 'patch', patch: { createJiraTicket: false, useWorktree: false, openPR: false, simplify: false } });
return;
}
dispatch({ type: 'patch', patch: appDefaultsPatch(selectedApp) });
}, [appDefaultsSig]);
const selectedProvider = providers?.find((provider) => provider.id === state.newTask.provider);
const { models: availableModels, source: modelSource, unlistedSelection } = resolveProviderModelOptions(selectedProvider, state.newTask.model);
const soleAvailableModel = availableModels.length === 1 ? availableModels[0] : '';
const selectedModelOrSole = state.newTask.model || soleAvailableModel;
useEffect(() => {
if (!soleAvailableModel) return;
dispatch({
type: 'task',
patch: (task) => {
if (!task.provider || task.model === soleAvailableModel || task.model) return task;
return {
...task,
model: soleAvailableModel,
effort: effortSurvivingModel(selectedProvider, soleAvailableModel, task.effort),
};
},
});
}, [soleAvailableModel, selectedProvider]);
const modelOptions = useMemo(() => availableModels.map((id) => ({
id,
name: unlistedSelection && id === state.newTask.model
? `${id} (${modelSource === MODEL_SOURCE.account ? 'not in account catalog' : 'no longer offered by this provider'})`
: shortClaudeModelName(id),
})), [availableModels, unlistedSelection, modelSource, state.newTask.model]);
const modelSourceNote = (() => {
if (!isCodexSubscriptionProvider(selectedProvider)) return '';
if (modelSource === MODEL_SOURCE.account) return 'Models your signed-in ChatGPT account can run.';
if (modelSource === MODEL_SOURCE.accountEmpty) return 'Your signed-in ChatGPT account exposes no models.';
return 'Showing PortOS’s bundled list — the signed-in ChatGPT account catalog has not been loaded.';
})();
const providerModelNote = (() => {
if (!selectedProvider) return '';
if (modelSource === MODEL_SOURCE.accountEmpty) return 'Your signed-in account exposes no models.';
if (isTuiProvider(selectedProvider)) return `${selectedProvider.name} runs in an attachable terminal UI session.`;
if (isCliProvider(selectedProvider)) return `${selectedProvider.name} uses its CLI configured default model.`;
return 'No models are configured. PortOS will use the provider default.';
})();
const handleSelectOrchestrationProfile = (profileId) => {
const found = state.orchestrationProfiles.find((profile) => profile.id === profileId);
dispatch({
type: 'patch',
patch: {
selectedProfileId: profileId,
...(found?.profile ? { orchestrationProfile: templateProfile(found.profile) } : {}),
},
});
};
const updateOrchestrationRoleField = (roleKey, field, value) => {
dispatch({
type: 'patch',
patch: (current) => {
const roleData = current.orchestrationProfile[roleKey] || {};
const updatedRole = { ...roleData, [field]: value };
if (field === 'provider') {
const provider = providers?.find((item) => item.id === value);
const sole = soleSelectableModel(provider);
updatedRole.model = sole;
updatedRole.effort = sole ? effortSurvivingModel(provider, sole, '') : '';
} else if (field === 'model') {
const provider = providers?.find((item) => item.id === roleData.provider);
updatedRole.effort = effortSurvivingModel(provider, value, roleData.effort);
}
return { orchestrationProfile: { ...current.orchestrationProfile, [roleKey]: updatedRole } };
},
});
};
const handleProviderChange = (providerId) => {
const model = soleSelectableModel(providers?.find((provider) => provider.id === providerId));
dispatch({ type: 'task', patch: { provider: providerId, model, effort: '', temperature: '', thinking: '' } });
};
const handlePlanOnlyChange = (enabled) => {
if (enabled && !planOnlySupported) return;
if (enabled) {
dispatch({
type: 'patch',
patch: {
planOnly: true,
slashdoCommand: 'plan-task',
createJiraTicket: false,
useWorktree: false,
openPR: false,
simplify: false,
worktreeChangesExpected: false,
},
});
return;
}
dispatch({
type: 'patch',
patch: state.slashdoCommand === 'plan-task'
? { planOnly: false, ...runShapeDefaultsPatch(selectedApp), simplify: true, worktreeChangesExpected: undefined }
: { planOnly: false },
});
};
const applyTemplate = async (template) => {
if (template.app) {
pendingDraftAppRef.current = false;
safeWriteStorage(LAST_TARGET_APP_KEY, template.app);
}
const seeded = seedModelEffort(
providers?.find((provider) => provider.id === template.provider),
template.model,
template.effort,
);
const nextTask = {
...state.newTask,
description: template.description,
...(template.app ? { app: template.app } : {}),
...(template.provider ? { provider: template.provider, model: seeded.model, effort: seeded.effort } : {}),
};
const templatePlanOnly = template.slashdoCommand === 'plan-task';
const patch = {
newTask: nextTask,
slashdoCommand: template.slashdoCommand || '',
planOnly: templatePlanOnly,
worktreeChangesExpected: template.settings?.worktreeChangesExpected,
};
if (state.planOnly && !templatePlanOnly) {
Object.assign(patch, runShapeDefaultsPatch(selectedApp), { simplify: true });
}
if (template.app && template.app !== state.newTask.app) templateAppChangeRef.current = true;
if (template.settings && typeof template.settings === 'object') {
if (template.settings.useWorktree !== undefined) patch.useWorktree = template.settings.useWorktree;
if (template.settings.openPR !== undefined) patch.openPR = template.settings.openPR;
if (template.settings.simplify !== undefined) patch.simplify = template.settings.simplify;
}
if (templatePlanOnly) {
Object.assign(patch, {
createJiraTicket: false,
useWorktree: false,
openPR: false,
simplify: false,
worktreeChangesExpected: false,
});
}
dispatch({ type: 'patch', patch });
descriptionRef.current?.focus();
const usageRecorded = await api.applyCosTaskTemplate(template.id, { silent: true })
.then(() => true)
.catch((error) => {
console.warn(`⚠️ Template usage not recorded for ${template.id}: ${error?.message || error}`);
toast.warning('Template applied locally, but usage could not be recorded');
return false;
});
if (usageRecorded) toast.success(`Template applied: ${template.name}`);
};
const saveAsTemplate = async () => {
if (!state.newTask.description.trim()) {
toast.error('Enter a task description first');
return;
}
if (!state.showTemplateSave) {
setField('templateNameInput', state.newTask.description.substring(0, 40));
setField('showTemplateSave', true);
return;
}
if (!state.templateNameInput.trim()) {
toast.error('Template name is required');
return;
}
const result = await api.createCosTaskTemplate({
name: state.templateNameInput.trim(),
description: state.newTask.description,
provider: state.newTask.provider,
model: state.newTask.model || soleAvailableModel,
effort: state.newTask.effort,
app: state.newTask.app,
...(state.planOnly ? {
slashdoCommand: 'plan-task',
settings: {
useWorktree: false,
openPR: false,
simplify: false,
worktreeChangesExpected: false,
},
} : {}),
}, { silent: true }).catch((error) => {
toast.error(error.message);
return null;
});
if (result?.success) {
toast.success('Template saved');
setField('showTemplateSave', false);
setField('templateNameInput', '');
api.getCosPopularTemplates(8)
.then((data) => dispatch({ type: 'patch', patch: { templates: data?.templates || [] } }))
.catch((error) => console.warn(`⚠️ Template refresh failed: ${error?.message || error}`));
}
};
const deleteTemplate = async (templateId, event) => {
event.stopPropagation();
const result = await api.deleteCosTaskTemplate(templateId, { silent: true }).catch((error) => {
toast.error(error.message);
return null;
});
if (result?.success) {
dispatch({ type: 'patch', patch: (current) => ({ templates: current.templates.filter((template) => template.id !== templateId) }) });
}
};
const handleFileSelect = async (event) => {
await processScreenshotUploads(event.target.files, {
onSuccess: (fileInfo) => dispatch({ type: 'patch', patch: (current) => ({ screenshots: [...current.screenshots, fileInfo] }) }),
onError: (message) => toast.error(message),
});
};
const removeScreenshot = (id) => {
dispatch({ type: 'patch', patch: (current) => ({ screenshots: current.screenshots.filter((screenshot) => screenshot.id !== id) }) });
};
const handleAttachmentSelect = async (event) => {
await processAttachmentUploads(event.target.files, {
onSuccess: (fileInfo) => dispatch({ type: 'patch', patch: (current) => ({ attachments: [...current.attachments, fileInfo] }) }),
onError: (message) => toast.error(message),
});
};
const removeAttachment = (id) => {
dispatch({ type: 'patch', patch: (current) => ({ attachments: current.attachments.filter((attachment) => attachment.id !== id) }) });
};
const handleAddTask = async () => {
if (submittingRef.current) return;
if (!state.newTask.description.trim()) {
toast.error('Description is required');
return;
}
submittingRef.current = true;
dispatch({ type: 'patch', patch: { isSubmitting: true } });
let finalDescription = state.newTask.description;
if (state.enhancePrompt) {
dispatch({ type: 'patch', patch: { isEnhancing: true } });
const enhanceResult = await api.enhanceCosTaskPrompt({ description: state.newTask.description }).catch((error) => {
toast('Enhancement failed, using original description', { icon: '⚠️' });
console.warn(`⚠️ Task enhancement failed: ${error.message}`);
return null;
});
if (enhanceResult?.enhancedDescription?.trim()) {
finalDescription = enhanceResult.enhancedDescription;
toast.success('Prompt enhanced');
} else if (enhanceResult) {
toast('Enhancement returned empty result, using original', { icon: '⚠️' });
}
dispatch({ type: 'patch', patch: { isEnhancing: false } });
}
const result = await api.addCosTask({
description: finalDescription,
model: selectedModelOrSole || undefined,
provider: state.newTask.provider || undefined,
effort: state.newTask.effort || undefined,
orchestrationMode: state.orchestrationMode === 'orchestrated' ? 'orchestrated' : undefined,
orchestrationProfile: state.orchestrationMode === 'orchestrated' ? state.orchestrationProfile : undefined,
temperature: state.newTask.temperature === '' ? undefined : Number(state.newTask.temperature),
thinking: state.newTask.thinking === '' ? undefined : state.newTask.thinking === 'true',
app: state.newTask.app || undefined,
targetInstanceId: state.targetInstanceId || undefined,
planOnly: state.planOnly,
issueTarget: state.planOnly ? state.issueTarget : undefined,
slashdoCommand: state.planOnly ? 'plan-task' : (state.slashdoCommand || undefined),
slashdoArgs: state.planOnly ? '--yes' : undefined,
createJiraTicket: state.planOnly ? false : state.createJiraTicket,
useWorktree: state.planOnly ? false : state.useWorktree,
whenDone: state.planOnly || state.useWorktree ? undefined : state.whenDone,
openPR: state.planOnly ? false : state.useWorktree && state.openPR,
simplify: state.planOnly ? false : state.simplify,
...(state.planOnly
? { worktreeChangesExpected: false }
: state.worktreeChangesExpected !== undefined ? { worktreeChangesExpected: state.worktreeChangesExpected } : {}),
prCompletion: !state.planOnly && state.useWorktree && state.openPR ? state.prCompletion : undefined,
...(!state.planOnly && state.openPR && state.prCompletion === 'review-then-merge' ? reviewOverridePayload(state.reviewOverrides) : {}),
screenshots: state.screenshots.length > 0 ? state.screenshots.map((screenshot) => screenshot.path) : undefined,
attachments: state.attachments.length > 0 ? state.attachments.map((attachment) => ({
filename: attachment.filename,
originalName: attachment.originalName,
path: attachment.path,
size: attachment.size,
mimeType: attachment.mimeType,
})) : undefined,
position: state.addToTop ? 'top' : 'bottom',
}, { silent: true }).catch((error) => {
toast.error(error.message || 'Failed to add task');
return null;
});
submittingRef.current = false;
dispatch({ type: 'patch', patch: { isSubmitting: false, isEnhancing: false } });
if (!result) return;
if (state.newTask.app !== undefined && state.newTask.app !== null) {
safeWriteStorage(LAST_TARGET_APP_KEY, state.newTask.app || '');
}
dispatch({
type: 'patch',
patch: {
newTask: { ...state.newTask, description: '' },
slashdoCommand: state.planOnly ? 'plan-task' : '',
worktreeChangesExpected: state.planOnly ? false : undefined,
screenshots: [],
attachments: [],
},
});
safeRemoveStorage(TASK_DESCRIPTION_DRAFT_KEY);
toast.success('Task added');
onTaskAdded?.(result, { position: state.addToTop ? 'top' : 'bottom' });
};
const handleDescriptionKeyDown = (event) => {
if (event.key !== 'Enter' || event.shiftKey || event.repeat || state.isSubmitting
|| event.nativeEvent?.isComposing || event.nativeEvent?.keyCode === 229) return;
event.preventDefault();
handleAddTask();
};
return {
state,
apps,
providersLoaded,
setField,
setTaskField,
handleAppChange,
handleProviderChange,
handlePlanOnlyChange,
handleSelectOrchestrationProfile,
updateOrchestrationRoleField,
applyTemplate,
saveAsTemplate,
deleteTemplate,
handleFileSelect,
removeScreenshot,
handleAttachmentSelect,
removeAttachment,
handleAddTask,
handleDescriptionKeyDown,
descriptionRef,
assignableInstances,
isFederated,
quickTemplatesEnabled,
reviewerModelOptions,
enabledProviders,
apiOnlyProviders,
selectedApp,
selectedAppId,
appHasJira,
selectedProvider,
availableModels,
modelSource,
unlistedSelection,
soleAvailableModel,
selectedModelOrSole,
modelOptions,
modelSourceNote,
providerModelNote,
planOnlyTrackerStatus,
planOnlySupported,
issueTargets: state.issueTargets,
};
}