@@ -658,4 +852,102 @@ function MembersPage({ members, onAdd, onUpdate, onDelete }){
)
}
+// ── My Tasks (cross-project view) ──
+const PRI_COLOR_MT = { high: '#ef4444', medium: '#f59e0b', low: '#10b981' }
+
+function MyTasksView({ projects, allMembers, onSelectProject }) {
+ const [memberId, setMemberId] = useState(allMembers[0]?.id || '')
+ const [filter, setFilter] = useState('all')
+
+ const member = allMembers.find(m => m.id === memberId)
+
+ // Collect tasks across all projects for this member
+ const taskItems = []
+ projects.forEach(proj => {
+ proj.tasks.forEach(t => {
+ if (memberId && t.assignedTo !== memberId) return
+ taskItems.push({ task: t, project: proj })
+ })
+ })
+
+ const filtered = filter === 'all' ? taskItems : taskItems.filter(i => i.task.status === filter)
+ const todayNow = new Date()
+
+ const groups = {
+ overdue: filtered.filter(i => i.task.dueDate && new Date(i.task.dueDate) < todayNow && i.task.status !== 'done'),
+ inProgress: filtered.filter(i => i.task.status === 'in-progress'),
+ todo: filtered.filter(i => i.task.status === 'todo' && !(i.task.dueDate && new Date(i.task.dueDate) < todayNow)),
+ done: filtered.filter(i => i.task.status === 'done'),
+ }
+
+ const renderItem = ({ task: t, project: proj }) => (
+
onSelectProject(proj.id)}
+ style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '9px 13px', background: '#0d0d1a', border: '1px solid #1e2030', borderRadius: 8, marginBottom: 5, cursor: 'pointer' }}
+ onMouseEnter={e => e.currentTarget.style.borderColor = '#2d3148'}
+ onMouseLeave={e => e.currentTarget.style.borderColor = '#1e2030'}
+ >
+
+
+
{t.title}
+
+ {proj.name}
+ {t.priority}
+ {t.dueDate && {fmt(t.dueDate)}}
+ {t.recurrence && t.recurrence !== 'none' && 🔁 {t.recurrence}}
+
+
+ {t.estimatedHours > 0 &&
{t.estimatedHours}h}
+
+ )
+
+ const Section = ({ label, color, items }) => items.length === 0 ? null : (
+
+
{label} · {items.length}
+ {items.map(renderItem)}
+
+ )
+
+ return (
+
+
+ ✅ My Tasks
+ {taskItems.length} total across {projects.length} project{projects.length !== 1 ? 's' : ''}
+
+
+ {/* Member picker */}
+ {allMembers.length > 0 && (
+
+ Showing tasks for:
+
+
+ )}
+
+ {/* Status filter */}
+
+ {['all','todo','in-progress','done'].map(s => (
+
+ ))}
+
+
+ {filtered.length === 0 && (
+
+ {memberId ? 'No tasks assigned to this member.' : 'No tasks found.'}
+
+ )}
+
+
+
+
+ {(filter === 'all' || filter === 'done') &&
}
+
+ )
+}
+
export default App
diff --git a/frontend/src/api.js b/frontend/src/api.js
index 7fb17e5..89f6fbc 100644
--- a/frontend/src/api.js
+++ b/frontend/src/api.js
@@ -1,17 +1,156 @@
-const BASE = (typeof window !== 'undefined' && window.ENV && window.ENV.API_URL) || import.meta.env.VITE_API_URL || 'http://localhost:4000/api'
-const h = { 'Content-Type': 'application/json' }
-const json = r => { if (!r.ok) throw new Error(r.status); return r.json() }
+const API_URL_STORAGE_KEY = 'project_hub_api_url'
+const DEFAULT_API_URL = 'http://localhost:4000/api'
+
+let cachedBaseUrl = null
+
+const normalizeApiUrl = (value) => {
+ if (!value || typeof value !== 'string') return null
+ const trimmed = value.trim().replace(/\/+$/, '')
+ if (!trimmed) return null
+ if (!/^https?:\/\//i.test(trimmed)) return null
+ return /\/api$/i.test(trimmed) ? trimmed : `${trimmed}/api`
+}
+
+const getEnvApiUrl = () => {
+ if (typeof window !== 'undefined' && window.ENV?.API_URL) return window.ENV.API_URL
+ return import.meta.env.VITE_API_URL || DEFAULT_API_URL
+}
+
+const getStoredApiUrl = () => {
+ if (typeof window === 'undefined') return null
+ try {
+ return localStorage.getItem(API_URL_STORAGE_KEY)
+ } catch {
+ return null
+ }
+}
+
+const getWriteApiKey = () => {
+ if (typeof window !== 'undefined' && window.ENV?.API_KEY) return window.ENV.API_KEY
+ return import.meta.env.VITE_WRITE_API_KEY || ''
+}
+
+const parseResponse = async (response) => {
+ if (!response.ok) {
+ const body = await response.text().catch(() => '')
+ throw new Error(body || String(response.status))
+ }
+
+ if (response.status === 204) return null
+ const contentType = response.headers.get('content-type') || ''
+ if (!contentType.includes('application/json')) return null
+ return response.json()
+}
+
+const getSyncBaseUrl = () => {
+ if (cachedBaseUrl) return cachedBaseUrl
+ const candidate = normalizeApiUrl(getStoredApiUrl()) || normalizeApiUrl(getEnvApiUrl()) || DEFAULT_API_URL
+ cachedBaseUrl = candidate
+ return cachedBaseUrl
+}
+
+const getBaseUrl = async () => {
+ if (cachedBaseUrl) return cachedBaseUrl
+
+ let runtimeUrl = null
+ if (typeof window !== 'undefined' && window.app?.getAPIUrl) {
+ runtimeUrl = await window.app.getAPIUrl().catch(() => null)
+ }
+
+ cachedBaseUrl =
+ normalizeApiUrl(runtimeUrl) ||
+ normalizeApiUrl(getStoredApiUrl()) ||
+ normalizeApiUrl(getEnvApiUrl()) ||
+ DEFAULT_API_URL
+
+ return cachedBaseUrl
+}
+
+const request = async (path, { method = 'GET', body, write = false, formData = false } = {}) => {
+ const base = await getBaseUrl()
+ const headers = {}
+
+ if (!formData) headers['Content-Type'] = 'application/json'
+ if (write) {
+ const key = getWriteApiKey()
+ if (key) headers['x-api-key'] = key
+ }
+
+ const options = { method, headers }
+ if (body !== undefined) options.body = formData ? body : JSON.stringify(body)
+
+ const response = await fetch(`${base}${path}`, options)
+ return parseResponse(response)
+}
+
+const toAbsoluteUrl = (maybeRelativeUrl) => {
+ if (!maybeRelativeUrl) return ''
+ if (/^https?:\/\//i.test(maybeRelativeUrl)) return maybeRelativeUrl
+ const root = getSyncBaseUrl().replace(/\/api$/i, '')
+ const suffix = maybeRelativeUrl.startsWith('/') ? maybeRelativeUrl : `/${maybeRelativeUrl}`
+ return `${root}${suffix}`
+}
export const api = {
+ getApiUrl: () => getBaseUrl(),
+ setApiUrl: async (url) => {
+ const normalized = normalizeApiUrl(url)
+ if (!normalized) throw new Error('API URL must be http(s) and non-empty')
+
+ if (typeof window !== 'undefined') {
+ try { localStorage.setItem(API_URL_STORAGE_KEY, normalized) } catch {}
+ if (window.app?.setAPIUrl) await window.app.setAPIUrl(normalized)
+ }
+
+ cachedBaseUrl = normalized
+ return normalized
+ },
+ toAbsoluteUrl,
+
// Members
- getMembers: () => fetch(`${BASE}/members`).then(json),
- addMember: d => fetch(`${BASE}/members`, { method: 'POST', headers: h, body: JSON.stringify(d) }).then(json),
- updateMember: (id, d) => fetch(`${BASE}/members/${id}`, { method: 'PUT', headers: h, body: JSON.stringify(d) }).then(json),
- deleteMember: id => fetch(`${BASE}/members/${id}`, { method: 'DELETE' }),
+ getMembers: () => request('/members'),
+ addMember: d => request('/members', { method: 'POST', body: d, write: true }),
+ updateMember: (id, d) => request(`/members/${id}`, { method: 'PUT', body: d, write: true }),
+ deleteMember: id => request(`/members/${id}`, { method: 'DELETE', write: true }),
// Projects
- getProjects: () => fetch(`${BASE}/projects`).then(json),
- createProject: d => fetch(`${BASE}/projects`, { method: 'POST', headers: h, body: JSON.stringify(d) }).then(json),
- updateProject: (id,d) => fetch(`${BASE}/projects/${id}`, { method: 'PUT', headers: h, body: JSON.stringify(d) }),
- deleteProject: id => fetch(`${BASE}/projects/${id}`, { method: 'DELETE' }),
+ getProjects: () => request('/projects'),
+ createProject: d => request('/projects', { method: 'POST', body: d, write: true }),
+ updateProject: (id, d) => request(`/projects/${id}`, { method: 'PUT', body: d, write: true }),
+ deleteProject: id => request(`/projects/${id}`, { method: 'DELETE', write: true }),
+
+ // Project members
+ assignMemberToProject: (projectId, memberId) =>
+ request(`/projects/${projectId}/members/${memberId}`, { method: 'POST', write: true }),
+
+ // Tasks
+ getTasks: projectId => request(`/projects/${projectId}/tasks`),
+ createTask: (projectId, data) => request(`/projects/${projectId}/tasks`, { method: 'POST', body: data, write: true }),
+ updateTask: (projectId, taskId, data) =>
+ request(`/projects/${projectId}/tasks/${taskId}`, { method: 'PUT', body: data, write: true }),
+ deleteTask: (projectId, taskId) => request(`/projects/${projectId}/tasks/${taskId}`, { method: 'DELETE', write: true }),
+
+ // Attachments
+ uploadAttachment: (projectId, taskId, file) => {
+ const fd = new FormData()
+ fd.append('file', file)
+ return request(`/projects/${projectId}/tasks/${taskId}/attachments`, {
+ method: 'POST',
+ body: fd,
+ formData: true,
+ write: true,
+ })
+ },
+ deleteAttachment: (projectId, taskId, attachmentId) =>
+ request(`/projects/${projectId}/tasks/${taskId}/attachments/${attachmentId}`, { method: 'DELETE', write: true }),
+
+ // Invites
+ createInvite: (projectId, email) =>
+ request(`/projects/${projectId}/invites`, { method: 'POST', body: { email }, write: true }),
+ getInvite: token => request(`/invites/${token}`),
+ acceptInvite: (token, data) => request(`/invites/${token}/accept`, { method: 'POST', body: data }),
+
+ // Notify (test webhook/email)
+ notify: (projectId, subject, text) =>
+ request(`/projects/${projectId}/notify`, { method: 'POST', body: { subject, text }, write: true }),
}
diff --git a/frontend/src/components/BurndownChart.jsx b/frontend/src/components/BurndownChart.jsx
new file mode 100644
index 0000000..0e96778
--- /dev/null
+++ b/frontend/src/components/BurndownChart.jsx
@@ -0,0 +1,173 @@
+import React, { useMemo } from 'react'
+
+const SVG_W = 480
+const SVG_H = 220
+const PAD = { top: 16, right: 20, bottom: 36, left: 40 }
+const CW = SVG_W - PAD.left - PAD.right
+const CH = SVG_H - PAD.top - PAD.bottom
+
+const addDays = (d, n) => { const r = new Date(d); r.setDate(r.getDate() + n); return r }
+const dayStr = d => d.toISOString().slice(0, 10)
+
+export default function BurndownChart({ project }) {
+ const { tasks, startDate: pStart, dueDate: pEnd } = project
+ const today = new Date(); today.setHours(0, 0, 0, 0)
+
+ const start = pStart ? new Date(pStart) : (() => {
+ const dates = tasks.filter(t => t.dueDate).map(t => new Date(t.dueDate))
+ return dates.length ? new Date(Math.min(...dates)) : today
+ })()
+ start.setHours(0, 0, 0, 0)
+
+ const end = pEnd ? new Date(pEnd) : (() => {
+ const dates = tasks.filter(t => t.dueDate).map(t => new Date(t.dueDate))
+ return dates.length ? addDays(new Date(Math.max(...dates)), 1) : addDays(today, 14)
+ })()
+ end.setHours(0, 0, 0, 0)
+
+ const total = tasks.length
+ const done = tasks.filter(t => t.status === 'done').length
+ const open = total - done
+
+ const spanDays = Math.max(Math.round((end - start) / 86400000), 1)
+ const daysLeft = Math.max(Math.round((end - today) / 86400000), 0)
+ const elapsed = Math.round((today - start) / 86400000)
+
+ // Ideal burndown: linear from (0, total) to (spanDays, 0)
+ const idealLine = total > 0
+ ? [[0, total], [spanDays, 0]].map(([d, v]) => [
+ PAD.left + (d / spanDays) * CW,
+ PAD.top + (1 - v / total) * CH,
+ ])
+ : []
+
+ // Actual: we only know current state, so we draw from (0, total) → (elapsed, open)
+ // This gives a useful snapshot even without historical data
+ const actualPoints = total > 0 ? [
+ [PAD.left, PAD.top],
+ [PAD.left + Math.min(elapsed, spanDays) / spanDays * CW, PAD.top + (1 - open / total) * CH],
+ ] : []
+
+ const todayX = PAD.left + Math.min(elapsed, spanDays) / spanDays * CW
+
+ // Y axis ticks (0%, 25%, 50%, 75%, 100%)
+ const yTicks = [0, 0.25, 0.5, 0.75, 1].map(frac => ({
+ y: PAD.top + (1 - frac) * CH,
+ label: Math.round(frac * total),
+ }))
+
+ // X axis ticks — start / mid / end
+ const xTicks = [0, 0.5, 1].map(frac => {
+ const d = addDays(start, Math.round(frac * spanDays))
+ return { x: PAD.left + frac * CW, label: d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }) }
+ })
+
+ const toPoints = pts => pts.map(([x, y]) => `${x},${y}`).join(' ')
+
+ const behind = total > 0 && elapsed > 0 && open > (total * (1 - elapsed / spanDays))
+
+ const stats = [
+ { label: 'Total', value: total, color: '#64748b' },
+ { label: 'Done', value: done, color: '#10b981' },
+ { label: 'Open', value: open, color: '#f59e0b' },
+ { label: 'Days left',value: daysLeft, color: daysLeft <= 3 ? '#ef4444' : '#818cf8' },
+ ]
+
+ if (total === 0) {
+ return (
+
+ Add tasks to generate the burndown chart.
+
+ )
+ }
+
+ return (
+
+ {/* Stats row */}
+
+ {stats.map(s => (
+
+
{s.value}
+
{s.label}
+
+ ))}
+
+
+ {behind && (
+
+ ⚠ Behind schedule — ideal remaining at this point: {Math.round(total * (1 - elapsed / spanDays))} tasks
+
+ )}
+
+ {/* SVG chart */}
+
+
+ {/* Legend */}
+
+
+
+ Ideal
+
+
+
+ Actual
+
+
+ Snapshot as of today — historical data recorded over time
+
+
+
+ )
+}
diff --git a/frontend/src/components/CalendarView.jsx b/frontend/src/components/CalendarView.jsx
new file mode 100644
index 0000000..c42e33a
--- /dev/null
+++ b/frontend/src/components/CalendarView.jsx
@@ -0,0 +1,147 @@
+import React, { useState } from 'react'
+
+const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+const MONTHS = ['January','February','March','April','May','June','July','August','September','October','November','December']
+
+const PRI_COLOR = { high: '#ef4444', medium: '#f59e0b', low: '#10b981' }
+const STATUS_DOT = { todo: '#3d4166', 'in-progress': '#f59e0b', done: '#10b981' }
+
+const isoDate = d => `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`
+
+export default function CalendarView({ project, onEditTask }) {
+ const today = new Date()
+ const [year, setYear] = useState(today.getFullYear())
+ const [month, setMonth] = useState(today.getMonth())
+
+ const prevMonth = () => { if (month === 0) { setYear(y => y-1); setMonth(11) } else setMonth(m => m-1) }
+ const nextMonth = () => { if (month === 11) { setYear(y => y+1); setMonth(0) } else setMonth(m => m+1) }
+
+ // Build a map of dateString → items
+ const itemMap = {}
+ const push = (dateStr, item) => { if (!itemMap[dateStr]) itemMap[dateStr] = []; itemMap[dateStr].push(item) }
+
+ project.tasks.forEach(t => {
+ if (!t.dueDate) return
+ const d = new Date(t.dueDate); d.setHours(0,0,0,0)
+ push(isoDate(d), { type: 'task', data: t })
+ })
+ project.milestones.forEach(m => {
+ if (!m.date) return
+ const d = new Date(m.date); d.setHours(0,0,0,0)
+ push(isoDate(d), { type: 'milestone', data: m })
+ })
+
+ // Build calendar grid
+ const firstDay = new Date(year, month, 1).getDay()
+ const daysInMonth = new Date(year, month + 1, 0).getDate()
+ const cells = []
+ for (let i = 0; i < firstDay; i++) cells.push(null)
+ for (let d = 1; d <= daysInMonth; d++) cells.push(d)
+ // Pad to full weeks
+ while (cells.length % 7 !== 0) cells.push(null)
+
+ const todayStr = isoDate(today)
+
+ const MAX_VISIBLE = 3
+
+ return (
+
+ {/* Header */}
+
+
+
{MONTHS[month]} {year}
+
+
+
+ {/* Day headers */}
+
+ {DAYS.map(d => (
+
{d}
+ ))}
+
+
+ {/* Grid */}
+
+ {cells.map((day, idx) => {
+ if (!day) return
+
+ const dateStr = `${year}-${String(month+1).padStart(2,'0')}-${String(day).padStart(2,'0')}`
+ const items = itemMap[dateStr] || []
+ const isToday = dateStr === todayStr
+ const visible = items.slice(0, MAX_VISIBLE)
+ const overflow = items.length - MAX_VISIBLE
+
+ return (
+
+ {/* Day number */}
+
+ {day}
+
+
+ {/* Items */}
+ {visible.map((item, i) => (
+ item.type === 'task' ? (
+
onEditTask && onEditTask(item.data)}
+ style={{
+ fontSize: 10, lineHeight: '14px',
+ background: '#0a0a18',
+ borderLeft: `2px solid ${PRI_COLOR[item.data.priority] || '#475569'}`,
+ borderRadius: '0 3px 3px 0',
+ padding: '2px 4px',
+ color: item.data.status === 'done' ? '#475569' : '#94a3b8',
+ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+ cursor: 'pointer',
+ textDecoration: item.data.status === 'done' ? 'line-through' : 'none',
+ }}
+ title={item.data.title}
+ >
+
+ {item.data.title}
+
+ ) : (
+
+ ◆ {item.data.title}
+
+ )
+ ))}
+
+ {overflow > 0 && (
+
+{overflow} more
+ )}
+
+ )
+ })}
+
+
+ {/* Legend */}
+
+ {[['High priority','#ef4444'],['Medium','#f59e0b'],['Low','#10b981']].map(([l, c]) => (
+
+ {l}
+
+ ))}
+
+ ◆ Milestone
+
+
+
+ )
+}
diff --git a/frontend/src/components/GanttView.jsx b/frontend/src/components/GanttView.jsx
new file mode 100644
index 0000000..456308b
--- /dev/null
+++ b/frontend/src/components/GanttView.jsx
@@ -0,0 +1,231 @@
+import React, { useMemo, useRef, useState } from 'react'
+
+const ROW_H = 34
+const HEAD_H = 52
+const LEFT_W = 200
+const DAY_W = 28
+const PAD_DAYS = 3
+
+const STATUS_COLOR = {
+ todo: '#3d4166',
+ 'in-progress': '#f59e0b',
+ done: '#10b981',
+}
+const PRI_COLOR = { high: '#ef4444', medium: '#f59e0b', low: '#10b981' }
+
+const addDays = (d, n) => { const r = new Date(d); r.setDate(r.getDate() + n); return r }
+const diffDays = (a, b) => Math.round((b - a) / 86400000)
+const fmt = d => d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+
+export default function GanttView({ project }) {
+ const svgRef = useRef(null)
+ const [tooltip, setTooltip] = useState(null)
+
+ const { tasks, milestones } = project
+
+ // Compute timeline bounds -----------------------------------------
+ const dates = []
+ const today = new Date(); today.setHours(0, 0, 0, 0)
+
+ if (project.startDate) dates.push(new Date(project.startDate))
+ if (project.dueDate) dates.push(new Date(project.dueDate))
+ tasks.forEach(t => {
+ if (t.startDate) dates.push(new Date(t.startDate))
+ if (t.dueDate) dates.push(new Date(t.dueDate))
+ })
+ milestones.forEach(m => { if (m.date) dates.push(new Date(m.date)) })
+ dates.push(today)
+
+ if (dates.length === 0) {
+ return
Add tasks with due dates to see the Gantt chart.
+ }
+
+ const rawStart = new Date(Math.min(...dates))
+ const rawEnd = new Date(Math.max(...dates))
+ rawStart.setHours(0, 0, 0, 0)
+ rawEnd.setHours(0, 0, 0, 0)
+
+ const start = addDays(rawStart, -PAD_DAYS)
+ const end = addDays(rawEnd, PAD_DAYS + 1)
+ const totalDays = diffDays(start, end)
+
+ const SVG_W = LEFT_W + totalDays * DAY_W
+ const taskRows = tasks.filter(t => t.dueDate)
+ const msRows = milestones.filter(m => m.date)
+ const SVG_H = HEAD_H + (taskRows.length + msRows.length) * ROW_H + 10
+
+ const dayX = date => LEFT_W + diffDays(start, date) * DAY_W
+ const todayX = dayX(today)
+
+ // Build month tick marks
+ const months = []
+ const cur = new Date(start)
+ cur.setDate(1)
+ while (cur <= end) {
+ months.push({ label: cur.toLocaleDateString('en-US', { month: 'short', year: '2-digit' }), x: dayX(cur) })
+ cur.setMonth(cur.getMonth() + 1)
+ }
+
+ // Week ticks (only if span ≤ 120 days)
+ const weekTicks = []
+ if (totalDays <= 120) {
+ const w = new Date(start)
+ while (w <= end) {
+ weekTicks.push(dayX(w))
+ w.setDate(w.getDate() + 7)
+ }
+ }
+
+ return (
+
+
+
+ {/* Tooltip */}
+ {tooltip && (
+
+
{tooltip.t.title}
+
Status: {tooltip.t.status}
+ {tooltip.t.dueDate &&
Due: {new Date(tooltip.t.dueDate).toLocaleDateString()}
}
+ {tooltip.t.estimatedHours &&
Est: {tooltip.t.estimatedHours}h
}
+
+ )}
+
+ {taskRows.length === 0 && msRows.length === 0 && (
+
+ Add tasks or milestones with dates to see the Gantt chart.
+
+ )}
+
+ )
+}
diff --git a/package.json b/package.json
index 041301f..799152c 100644
--- a/package.json
+++ b/package.json
@@ -4,10 +4,36 @@
"main": "main.js",
"scripts": {
"start": "electron .",
- "build": "electron-builder"
+ "build": "electron-builder",
+ "build:desktop": "npm run build:renderer && npm run sync:dist && npm run build",
+ "build:renderer": "npm run build --prefix frontend",
+ "sync:dist": "rm -rf dist && mkdir -p dist && cp -R frontend/dist/* dist/",
+ "test:wiring": "node scripts/wiring-smoke-test.cjs",
+ "test:persistence": "node scripts/persistence-self-test.cjs",
+ "test:persistence:restart": "node scripts/persistence-self-test.cjs --restart-backend",
+ "build:verified": "npm run test:persistence && npm run build",
+ "build:verified:restart": "npm run test:persistence:restart && npm run build",
+ "release:verified": "npm run test:persistence && npm run build:renderer && npm run sync:dist && npm run build",
+ "release:verified:restart": "npm run test:persistence:restart && npm run build:renderer && npm run sync:dist && npm run build"
+ },
+ "build": {
+ "appId": "com.projecthub.app",
+ "productName": "Project Hub",
+ "directories": {
+ "output": "releases"
+ },
+ "mac": {
+ "identity": null,
+ "hardenedRuntime": false,
+ "target": [
+ { "target": "dmg", "arch": ["arm64"] }
+ ]
+ },
+ "afterSign": "scripts/adhoc-sign.js"
},
"dependencies": {
"electron": "^30.0.0",
"electron-builder": "^24.0.0"
}
}
+
diff --git a/scripts/adhoc-sign.js b/scripts/adhoc-sign.js
new file mode 100644
index 0000000..f8bca86
--- /dev/null
+++ b/scripts/adhoc-sign.js
@@ -0,0 +1,15 @@
+// Post-build hook: ad-hoc sign the .app bundle so macOS 14+ will open it
+// without requiring an Apple Developer certificate.
+const { execSync } = require('child_process');
+const path = require('path');
+
+exports.default = async function (context) {
+ const appPath = path.join(
+ context.appOutDir,
+ `${context.packager.appInfo.productFilename}.app`,
+ );
+ console.log(`Ad-hoc signing: ${appPath}`);
+ execSync(`xattr -cr "${appPath}"`);
+ execSync(`codesign --force --deep --sign - "${appPath}"`);
+ console.log('Ad-hoc signing complete.');
+};
diff --git a/scripts/persistence-self-test.cjs b/scripts/persistence-self-test.cjs
new file mode 100644
index 0000000..d3b9856
--- /dev/null
+++ b/scripts/persistence-self-test.cjs
@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+
+const args = new Set(process.argv.slice(2));
+if (args.has('--help') || args.has('-h')) {
+ console.log('Project Hub persistence self-test');
+ console.log('');
+ console.log('Usage:');
+ console.log(' node scripts/persistence-self-test.cjs [--restart-backend]');
+ console.log('');
+ console.log('Environment:');
+ console.log(' API_BASE default: http://localhost:4000/api');
+ console.log(' WRITE_API_KEY optional x-api-key for write endpoints');
+ process.exit(0);
+}
+
+const API_BASE = process.env.API_BASE || 'http://localhost:4000/api';
+const HEALTH_URL = API_BASE.replace(/\/api\/?$/, '') + '/health';
+const WRITE_API_KEY = process.env.WRITE_API_KEY || '';
+const SHOULD_RESTART = args.has('--restart-backend');
+
+const marker = `selftest-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+const state = {
+ memberId: null,
+ projectId: null,
+ taskId: null,
+};
+
+function log(msg) {
+ console.log(`[persistence-test] ${msg}`);
+}
+
+async function sleep(ms) {
+ await new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function request(path, options = {}) {
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), options.timeoutMs || 10000);
+
+ const headers = {
+ ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+ ...(WRITE_API_KEY ? { 'x-api-key': WRITE_API_KEY } : {}),
+ ...(options.headers || {}),
+ };
+
+ const response = await fetch(`${API_BASE}${path}`, {
+ method: options.method || 'GET',
+ headers,
+ body: options.body ? JSON.stringify(options.body) : undefined,
+ signal: controller.signal,
+ }).finally(() => clearTimeout(timeout));
+
+ const text = await response.text();
+ let parsed = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+
+ if (!response.ok) {
+ const details = parsed ? JSON.stringify(parsed) : text;
+ throw new Error(`${response.status} ${response.statusText}${details ? `: ${details}` : ''}`);
+ }
+
+ return parsed;
+}
+
+async function waitForHealth(maxSeconds = 30) {
+ const start = Date.now();
+ while ((Date.now() - start) / 1000 < maxSeconds) {
+ try {
+ const response = await fetch(HEALTH_URL, { signal: AbortSignal.timeout(3000) });
+ if (response.ok) return;
+ } catch {
+ // Keep polling.
+ }
+ await sleep(1000);
+ }
+ throw new Error(`Health check failed after ${maxSeconds}s at ${HEALTH_URL}`);
+}
+
+function restartBackendContainer() {
+ log('Restarting backend via docker compose...');
+ execSync('docker compose restart backend', { stdio: 'inherit' });
+}
+
+async function cleanup() {
+ if (state.projectId) {
+ try {
+ await request(`/projects/${state.projectId}`, { method: 'DELETE' });
+ log(`Cleanup: deleted project ${state.projectId}`);
+ } catch (e) {
+ log(`Cleanup warning: failed to delete project ${state.projectId}: ${e.message}`);
+ }
+ }
+
+ if (state.memberId) {
+ try {
+ await request(`/members/${state.memberId}`, { method: 'DELETE' });
+ log(`Cleanup: deleted member ${state.memberId}`);
+ } catch (e) {
+ log(`Cleanup warning: failed to delete member ${state.memberId}: ${e.message}`);
+ }
+ }
+}
+
+async function run() {
+ log(`Using API base ${API_BASE}`);
+ await waitForHealth();
+ log('Health check passed.');
+
+ const member = await request('/members', {
+ method: 'POST',
+ body: {
+ name: `Self Test ${marker}`,
+ role: 'QA Bot',
+ initials: 'ST',
+ email: `${marker}@local.test`,
+ },
+ });
+ state.memberId = member.id;
+ log(`Created member ${state.memberId}`);
+
+ const project = await request('/projects', {
+ method: 'POST',
+ body: {
+ name: `Persistence ${marker}`,
+ description: 'Automated persistence verification',
+ status: 'active',
+ color: '#10b981',
+ startDate: new Date().toISOString().slice(0, 10),
+ dueDate: new Date(Date.now() + 86400000).toISOString().slice(0, 10),
+ members: [],
+ tasks: [],
+ milestones: [],
+ },
+ });
+ state.projectId = project.id;
+ log(`Created project ${state.projectId}`);
+
+ await request(`/projects/${state.projectId}/members/${state.memberId}`, { method: 'POST' });
+ log(`Assigned member ${state.memberId} to project ${state.projectId}`);
+
+ const task = await request(`/projects/${state.projectId}/tasks`, {
+ method: 'POST',
+ body: {
+ title: `Task ${marker}`,
+ description: 'Persistence check task',
+ memberId: state.memberId,
+ },
+ });
+ state.taskId = task.id;
+ log(`Created task ${state.taskId}`);
+
+ if (SHOULD_RESTART) {
+ restartBackendContainer();
+ await waitForHealth(45);
+ log('Backend is healthy after restart.');
+ }
+
+ const projects = await request('/projects');
+ const persistedProject = projects.find(p => p.id === state.projectId);
+ if (!persistedProject) {
+ throw new Error(`Persisted project not found after verification step: ${state.projectId}`);
+ }
+
+ const tasks = await request(`/projects/${state.projectId}/tasks`);
+ const persistedTask = tasks.find(t => t.id === state.taskId);
+ if (!persistedTask) {
+ throw new Error(`Persisted task not found after verification step: ${state.taskId}`);
+ }
+
+ log('Persistence verified: project and task were read back successfully.');
+ await cleanup();
+ log('PASS');
+}
+
+run().catch(async err => {
+ console.error(`[persistence-test] FAIL: ${err.message}`);
+ await cleanup();
+ process.exit(1);
+});
diff --git a/scripts/wiring-smoke-test.cjs b/scripts/wiring-smoke-test.cjs
new file mode 100644
index 0000000..ab36da1
--- /dev/null
+++ b/scripts/wiring-smoke-test.cjs
@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+const API_BASE = process.env.API_BASE || 'http://localhost:4000/api';
+const HEALTH_URL = API_BASE.replace(/\/api\/?$/, '') + '/health';
+const WRITE_API_KEY = process.env.WRITE_API_KEY || '';
+
+const marker = `wiring-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+const state = {
+ memberId: null,
+ projectId: null,
+ taskId: null,
+ inviteToken: null,
+};
+
+function log(message) {
+ console.log(`[wiring-test] ${message}`);
+}
+
+async function sleep(ms) {
+ await new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitForHealth(maxSeconds = 30) {
+ const started = Date.now();
+ while ((Date.now() - started) / 1000 < maxSeconds) {
+ try {
+ const response = await fetch(HEALTH_URL, { signal: AbortSignal.timeout(3000) });
+ if (response.ok) return;
+ } catch {
+ // keep polling
+ }
+ await sleep(1000);
+ }
+ throw new Error(`Backend not healthy at ${HEALTH_URL} after ${maxSeconds}s`);
+}
+
+async function request(path, options = {}) {
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), options.timeoutMs || 10000);
+ const headers = {
+ ...(options.body || options.formData ? {} : {}),
+ ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+ ...(options.write && WRITE_API_KEY ? { 'x-api-key': WRITE_API_KEY } : {}),
+ ...(options.headers || {}),
+ };
+
+ const response = await fetch(`${API_BASE}${path}`, {
+ method: options.method || 'GET',
+ headers,
+ body: options.formData || (options.body ? JSON.stringify(options.body) : undefined),
+ signal: controller.signal,
+ }).finally(() => clearTimeout(timeout));
+
+ const text = await response.text();
+ let parsed = null;
+ try {
+ parsed = text ? JSON.parse(text) : null;
+ } catch {
+ parsed = null;
+ }
+
+ if (!response.ok) {
+ const details = parsed ? JSON.stringify(parsed) : text;
+ throw new Error(`${response.status} ${response.statusText}${details ? `: ${details}` : ''}`);
+ }
+
+ return parsed;
+}
+
+async function cleanup() {
+ if (state.projectId) {
+ try {
+ await request(`/projects/${state.projectId}`, { method: 'DELETE', write: true });
+ log(`Cleanup: deleted project ${state.projectId}`);
+ } catch (err) {
+ log(`Cleanup warning: project delete failed: ${err.message}`);
+ }
+ }
+
+ if (state.memberId) {
+ try {
+ await request(`/members/${state.memberId}`, { method: 'DELETE', write: true });
+ log(`Cleanup: deleted member ${state.memberId}`);
+ } catch (err) {
+ log(`Cleanup warning: member delete failed: ${err.message}`);
+ }
+ }
+}
+
+async function run() {
+ log(`Using API base ${API_BASE}`);
+ await waitForHealth();
+ log('Health check passed');
+
+ const member = await request('/members', {
+ method: 'POST',
+ write: true,
+ body: {
+ name: `Wiring Member ${marker}`,
+ role: 'QA Bot',
+ email: `${marker}@local.test`,
+ },
+ });
+ state.memberId = member.id;
+ log(`Created member ${state.memberId}`);
+
+ const project = await request('/projects', {
+ method: 'POST',
+ write: true,
+ body: {
+ name: `Wiring Project ${marker}`,
+ description: 'Wiring smoke test',
+ status: 'active',
+ color: '#6366f1',
+ members: [],
+ tasks: [],
+ milestones: [],
+ },
+ });
+ state.projectId = project.id;
+ log(`Created project ${state.projectId}`);
+
+ const assigned = await request(`/projects/${state.projectId}/members/${state.memberId}`, {
+ method: 'POST',
+ write: true,
+ });
+ if (!Array.isArray(assigned.members) || !assigned.members.some(m => m.id === state.memberId)) {
+ throw new Error('Assigned member missing from project.members');
+ }
+ log('Assigned member to project');
+
+ const task = await request(`/projects/${state.projectId}/tasks`, {
+ method: 'POST',
+ write: true,
+ body: {
+ title: `Wiring Task ${marker}`,
+ description: 'Task route check',
+ assignedTo: state.memberId,
+ status: 'todo',
+ priority: 'medium',
+ },
+ });
+ state.taskId = task.id;
+ log(`Created task ${state.taskId}`);
+
+ const updatedTask = await request(`/projects/${state.projectId}/tasks/${state.taskId}`, {
+ method: 'PUT',
+ write: true,
+ body: { status: 'done' },
+ });
+ if (updatedTask.status !== 'done') {
+ throw new Error('Task update did not persist expected status');
+ }
+ log('Updated task status to done');
+
+ const invite = await request(`/projects/${state.projectId}/invites`, {
+ method: 'POST',
+ write: true,
+ body: { email: `${marker}.invite@local.test` },
+ });
+ state.inviteToken = invite.token;
+ log('Created invite token');
+
+ await request(`/invites/${state.inviteToken}`);
+ await request(`/invites/${state.inviteToken}/accept`, {
+ method: 'POST',
+ body: { name: `Invitee ${marker}`, role: 'Collaborator', email: `${marker}.invite@local.test` },
+ });
+ log('Invite get/accept flow passed');
+
+ await request(`/projects/${state.projectId}/tasks/${state.taskId}`, {
+ method: 'DELETE',
+ write: true,
+ });
+ log('Deleted task');
+
+ const tasksAfterDelete = await request(`/projects/${state.projectId}/tasks`);
+ if (tasksAfterDelete.some(t => t.id === state.taskId)) {
+ throw new Error('Task still present after delete');
+ }
+
+ log('PASS');
+ await cleanup();
+}
+
+run().catch(async err => {
+ console.error(`[wiring-test] FAIL: ${err.message}`);
+ await cleanup();
+ process.exit(1);
+});