heyiam 0.3.0 → 0.3.2

package/dist/routes/github.js

@@ -0,0 +1,254 @@
+// Express router for the GitHub Pages publish target (Phase 5).
+//
+// All routes are authenticated via the existing `getAuthToken` Bearer
+// pattern — the GitHub access token itself lives in the OS keychain via
+// `cli/src/github.ts` and is NEVER returned to the client.
+import { Router } from 'express';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { getAuthToken } from '../auth.js';
+import { requestDeviceCode, pollForTokenOnce, storeToken, loadToken, deleteToken, listRepos, getAuthenticatedUser, pushSiteToRepo, enablePages, pollPagesBuild, GitHubError, } from '../github.js';
+import { getDefaultTemplate, getPortfolioProfile, hashPortfolioProfile, updatePortfolioPublishTarget, } from '../settings.js';
+import { generatePortfolioSite } from '../export.js';
+import { buildPortfolioRenderData } from './portfolio-render-data.js';
+import { buildProjectDetail } from './context.js';
+import { invalidatePortfolioPreviewCache } from './preview.js';
+const GITHUB_TARGET = 'github';
+function authError(res) {
+    res.status(401).json({
+        error: { code: 'UNAUTHENTICATED', message: 'Authentication required' },
+    });
+}
+function handleGitHubError(res, err, fallbackCode) {
+    if (err instanceof GitHubError) {
+        const status = err.code === 'KEYCHAIN_UNAVAILABLE' ? 503
+            : err.code === 'NO_TOKEN' ? 401
+                : err.status && err.status >= 400 && err.status < 600 ? err.status
+                    : 500;
+        res.status(status).json({
+            error: { code: err.code, message: err.message },
+        });
+        return;
+    }
+    res.status(500).json({
+        error: { code: fallbackCode, message: err.message },
+    });
+}
+export function createGithubRouter(ctx) {
+    const router = Router();
+    // ── Device-flow kickoff ────────────────────────────────────────────
+    router.post('/api/github/device-code', async (_req, res) => {
+        if (!getAuthToken()) {
+            authError(res);
+            return;
+        }
+        try {
+            // Scope rationale: public_repo is the minimum needed to push portfolio
+            // sites to user-owned public repos and enable Pages on them. We do NOT
+            // request the broader 'repo' scope — portfolios are inherently public,
+            // and narrowing the scope shrinks the blast radius if a user is ever
+            // phished using this app's client_id (RFC 8628 client_ids are public).
+            // If users ever request private-repo support, expand to ['repo'] then.
+            const body = await requestDeviceCode(['public_repo']);
+            res.json({
+                device_code: body.device_code,
+                user_code: body.user_code,
+                verification_uri: body.verification_uri,
+                expires_in: body.expires_in,
+                interval: body.interval,
+            });
+        }
+        catch (err) {
+            handleGitHubError(res, err, 'DEVICE_CODE_FAILED');
+        }
+    });
+    // ── Device-flow single-poll + keychain write ─────────────────────
+    // Returns immediately in ALL cases — no blocking loop.
+    // The frontend is responsible for calling this on an interval.
+    router.post('/api/github/poll-token', async (req, res) => {
+        if (!getAuthToken()) {
+            authError(res);
+            return;
+        }
+        const { device_code: deviceCode } = (req.body ?? {});
+        if (typeof deviceCode !== 'string' || deviceCode.length === 0) {
+            res.status(400).json({
+                error: { code: 'INVALID_DEVICE_CODE', message: 'device_code is required' },
+            });
+            return;
+        }
+        try {
+            const result = await pollForTokenOnce(deviceCode);
+            if (result.status === 'success') {
+                await storeToken(result.access_token);
+                const user = await getAuthenticatedUser(result.access_token);
+                res.json({
+                    status: 'success',
+                    account: { login: user.login, name: user.name, avatarUrl: user.avatar_url },
+                });
+                return;
+            }
+            // pending / expired / denied — return status directly, no token in response.
+            res.json({ status: result.status });
+        }
+        catch (err) {
+            handleGitHubError(res, err, 'TOKEN_POLL_FAILED');
+        }
+    });
+    // ── Connected account (GET + DELETE) ──────────────────────────────
+    router.get('/api/github/account', async (_req, res) => {
+        if (!getAuthToken()) {
+            authError(res);
+            return;
+        }
+        try {
+            const token = await loadToken();
+            if (!token) {
+                res.json({ account: null });
+                return;
+            }
+            const user = await getAuthenticatedUser(token);
+            res.json({
+                account: { login: user.login, name: user.name, avatarUrl: user.avatar_url },
+            });
+        }
+        catch (err) {
+            handleGitHubError(res, err, 'GITHUB_API_FAILED');
+        }
+    });
+    router.delete('/api/github/account', async (_req, res) => {
+        if (!getAuthToken()) {
+            authError(res);
+            return;
+        }
+        try {
+            await deleteToken();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            handleGitHubError(res, err, 'KEYCHAIN_UNAVAILABLE');
+        }
+    });
+    // ── Repo list ─────────────────────────────────────────────────────
+    router.get('/api/github/repos', async (_req, res) => {
+        if (!getAuthToken()) {
+            authError(res);
+            return;
+        }
+        try {
+            const token = await loadToken();
+            if (!token) {
+                res.status(401).json({
+                    error: { code: 'NO_GITHUB_TOKEN', message: 'GitHub account not connected' },
+                });
+                return;
+            }
+            const repos = await listRepos(token);
+            res.json({ repos });
+        }
+        catch (err) {
+            handleGitHubError(res, err, 'GITHUB_API_FAILED');
+        }
+    });
+    // ── Publish: render portfolio -> push to repo -> enable Pages ─────
+    router.post('/api/github/publish', async (req, res) => {
+        const auth = getAuthToken();
+        if (!auth) {
+            authError(res);
+            return;
+        }
+        const { owner, repo, branch } = (req.body ?? {});
+        if (typeof owner !== 'string' || owner.length === 0
+            || typeof repo !== 'string' || repo.length === 0) {
+            res.status(400).json({
+                error: { code: 'INVALID_TARGET', message: 'owner and repo are required strings' },
+            });
+            return;
+        }
+        const branchName = typeof branch === 'string' && branch.length > 0 ? branch : 'gh-pages';
+        let tempDir = null;
+        try {
+            const token = await loadToken();
+            if (!token) {
+                res.status(401).json({
+                    error: { code: 'NO_GITHUB_TOKEN', message: 'GitHub account not connected' },
+                });
+                return;
+            }
+            // Build portfolio site into a temp directory.
+            const templateName = getDefaultTemplate() || 'editorial';
+            const { renderData } = await buildPortfolioRenderData(ctx, auth);
+            const rawProjects = await ctx.getProjects();
+            const projectInputs = [];
+            for (const rawProj of rawProjects) {
+                try {
+                    const detail = buildProjectDetail(ctx.db, rawProj);
+                    const cache = detail.enhanceCache ?? {
+                        fingerprint: 'gh-publish',
+                        enhancedAt: new Date().toISOString(),
+                        selectedSessionIds: detail.sessions.map((s) => s.id),
+                        result: { narrative: '', arc: [], skills: [], timeline: [], questions: [] },
+                    };
+                    const proj = detail.project;
+                    projectInputs.push({
+                        dirName: rawProj.dirName,
+                        cache,
+                        sessions: detail.sessions,
+                        opts: {
+                            totalFilesChanged: proj.totalFiles,
+                            totalAgentDurationMinutes: proj.totalAgentDuration,
+                            totalInputTokens: proj.totalInputTokens,
+                            totalOutputTokens: proj.totalOutputTokens,
+                        },
+                    });
+                }
+                catch (projErr) {
+                    console.warn(`[github-publish] skipping project ${rawProj.dirName}:`, projErr.message);
+                }
+            }
+            tempDir = mkdtempSync(join(tmpdir(), 'heyiam-gh-'));
+            await generatePortfolioSite(renderData, projectInputs, tempDir, templateName);
+            await pushSiteToRepo({
+                token, owner, repo, branch: branchName, sourceDir: tempDir,
+            });
+            await enablePages({ token, owner, repo, branch: branchName });
+            await pollPagesBuild({ token, owner, repo });
+            const url = `https://${owner}.github.io/${repo}/`;
+            const publishedAt = new Date().toISOString();
+            const profile = getPortfolioProfile();
+            const hash = hashPortfolioProfile(profile);
+            updatePortfolioPublishTarget(GITHUB_TARGET, {
+                lastPublishedAt: publishedAt,
+                lastPublishedProfileHash: hash,
+                lastPublishedProfile: profile,
+                config: { owner, repo, branch: branchName },
+                url,
+                lastError: undefined,
+                lastErrorAt: undefined,
+            });
+            invalidatePortfolioPreviewCache();
+            res.json({ ok: true, url, publishedAt, hash });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            try {
+                updatePortfolioPublishTarget(GITHUB_TARGET, {
+                    lastError: message,
+                    lastErrorAt: new Date().toISOString(),
+                });
+            }
+            catch { /* do not mask original error */ }
+            handleGitHubError(res, err, 'GITHUB_PUBLISH_FAILED');
+        }
+        finally {
+            if (tempDir) {
+                try {
+                    rmSync(tempDir, { recursive: true, force: true });
+                }
+                catch { /* best effort */ }
+            }
+        }
+    });
+    return router;
+}

package/dist/routes/index.js

@@ -2,6 +2,7 @@ export { createRouteContext } from './context.js';
 export { createProjectsRouter } from './projects.js';
 export { createEnhanceRouter } from './enhance.js';
 export { createPublishRouter } from './publish.js';
+export { createDeleteRouter } from './delete.js';
 export { createSearchRouter } from './search.js';
 export { createSessionsRouter } from './sessions.js';
 export { createArchiveRouter } from './archive.js';
@@ -10,3 +11,4 @@ export { createSettingsRouter } from './settings.js';
 export { createExportRouter } from './export.js';
 export { createPreviewRouter } from './preview.js';
 export { createDashboardRouter } from './dashboard.js';
+export { createGithubRouter } from './github.js';

package/dist/routes/portfolio-render-data.js

@@ -0,0 +1,160 @@
+import { getPortfolioProfile, loadProjectEnhanceResult } from '../settings.js';
+import { getSessionsByProject, getAllProjectStats } from '../db.js';
+import { displayNameFromDir } from '../sync.js';
+import { toSlug } from '../format-utils.js';
+/**
+ * Assemble the `PortfolioRenderData` payload from local project data.
+ *
+ * Shared between:
+ *  - `POST /api/portfolio/upload` (Phase 2, hosted heyi.am publish)
+ *  - `POST /api/portfolio/export` (Phase 4, static folder export)
+ *
+ * Mirrors the preview route's assembly logic. Projects that fail to load are
+ * silently skipped — the portfolio still publishes with whatever succeeds.
+ */
+export async function buildPortfolioRenderData(ctx, auth) {
+    const profile = getPortfolioProfile();
+    const allRawProjects = await ctx.getProjects();
+    // Build a recency map from DB stats so the default-when-empty branch of
+    // applyPortfolioProjectFilter can rank projects by "user's most recent
+    // work" (latest non-subagent session start_time).
+    const recencyByDir = new Map();
+    try {
+        for (const s of getAllProjectStats(ctx.db)) {
+            recencyByDir.set(s.projectDir, s.latestDate || '');
+        }
+    }
+    catch { /* DB may be empty on first run; default branch will fall back */ }
+    const rawProjects = applyPortfolioProjectFilter(allRawProjects, profile.projectsOnPortfolio, { getRecency: (p) => recencyByDir.get(p.dirName) });
+    const portfolioProjects = [];
+    const projectCaches = new Map();
+    let totalDuration = 0;
+    let totalAgentDuration = 0;
+    let totalLoc = 0;
+    let totalSessions = 0;
+    for (const rawProj of rawProjects) {
+        try {
+            const proj = await ctx.getProjectWithStats(rawProj);
+            const cached = loadProjectEnhanceResult(rawProj.dirName);
+            const projDuration = proj.totalDuration || 0;
+            const projAgentDuration = proj.totalAgentDuration || 0;
+            const projLoc = proj.totalLoc || 0;
+            const projSessions = proj.sessionCount || 0;
+            totalDuration += projDuration;
+            totalAgentDuration += projAgentDuration;
+            totalLoc += projLoc;
+            totalSessions += projSessions;
+            const title = cached?.title
+                || proj.name || displayNameFromDir(rawProj.dirName);
+            const dbSessions = getSessionsByProject(ctx.db, rawProj.dirName);
+            const sessionActivity = dbSessions
+                .filter((s) => !s.is_subagent)
+                .map((s) => ({
+                date: s.start_time || '',
+                loc: (s.loc_added || 0) + (s.loc_removed || 0),
+                durationMinutes: s.duration_minutes || 0,
+            }));
+            portfolioProjects.push({
+                slug: toSlug(title),
+                title,
+                narrative: cached?.result?.narrative || proj.description || '',
+                totalSessions: projSessions,
+                totalLoc: projLoc,
+                totalDurationMinutes: projDuration,
+                totalAgentDurationMinutes: projAgentDuration,
+                totalFilesChanged: proj.totalFiles || 0,
+                skills: cached?.result?.skills || proj.skills || [],
+                publishedCount: 0,
+                sessions: sessionActivity,
+            });
+            projectCaches.set(rawProj.dirName, { dirName: rawProj.dirName, cache: cached });
+        }
+        catch { /* skip projects that fail */ }
+    }
+    const renderData = {
+        user: {
+            username: auth.username,
+            accent: profile.accent || '#084471',
+            displayName: profile.displayName || '',
+            bio: profile.bio || '',
+            location: profile.location || '',
+            status: 'active',
+            email: profile.email,
+            phone: profile.phone,
+            photoUrl: profile.photoBase64 || undefined,
+            linkedinUrl: profile.linkedinUrl,
+            githubUrl: profile.githubUrl,
+            twitterHandle: profile.twitterHandle,
+            websiteUrl: profile.websiteUrl,
+            resumeUrl: profile.resumeBase64 ? '#' : undefined,
+        },
+        projects: portfolioProjects,
+        totalDurationMinutes: totalDuration,
+        totalAgentDurationMinutes: totalAgentDuration || undefined,
+        totalLoc,
+        totalSessions,
+    };
+    return { renderData, projectCaches, filteredProjects: rawProjects };
+}
+/**
+ * Apply the user-curated `projectsOnPortfolio` list to a raw project list.
+ *
+ * Pure function — no I/O. Lives here so it can be unit-tested without
+ * standing up a RouteContext.
+ *
+ * Semantics:
+ *  - Empty/missing list: default to the `defaultLimit` (3) most recently
+ *    active projects, ranked by `getRecency` (descending). If fewer than
+ *    `defaultLimit` projects exist, return all of them. If `getRecency` is
+ *    not provided, falls back to reverse-alphabetic order on `dirName`
+ *    (an unfortunate fallback — callers should provide a real recency
+ *    accessor).
+ *  - Non-empty list:
+ *    - Filter out projects whose entry has `included === false`.
+ *    - Sort the remaining matched projects by `order` ascending.
+ *    - Projects present in the source list but missing from the curated
+ *      list (e.g. newly imported since the user last edited) are appended
+ *      at the end in source order, treated as `included: true`.
+ *
+ * NOTE: The default-when-empty branch is duplicated in
+ * `cli/app/src/components/PortfolioWorkspace.tsx` (HydratePortfolioStore)
+ * because the frontend bundler does not reach into `cli/src/`. Keep the
+ * two implementations in sync.
+ */
+export const PORTFOLIO_DEFAULT_PROJECT_LIMIT = 3;
+export function applyPortfolioProjectFilter(projects, curated, options = {}) {
+    if (!curated || curated.length === 0) {
+        const limit = options.defaultLimit ?? PORTFOLIO_DEFAULT_PROJECT_LIMIT;
+        if (projects.length <= limit)
+            return projects;
+        const getRecency = options.getRecency;
+        const ranked = projects.slice().sort((a, b) => {
+            if (getRecency) {
+                const ra = getRecency(a) || '';
+                const rb = getRecency(b) || '';
+                if (ra !== rb)
+                    return rb.localeCompare(ra); // descending
+            }
+            // Fallback / tiebreaker: reverse-alphabetic on dirName.
+            return b.dirName.localeCompare(a.dirName);
+        });
+        return ranked.slice(0, limit);
+    }
+    const byId = new Map();
+    for (const entry of curated)
+        byId.set(entry.projectId, entry);
+    const matched = [];
+    const unmatched = [];
+    for (const proj of projects) {
+        const entry = byId.get(proj.dirName);
+        if (!entry) {
+            unmatched.push(proj);
+            continue;
+        }
+        if (entry.included === false)
+            continue;
+        matched.push({ proj, order: entry.order });
+    }
+    matched.sort((a, b) => a.order - b.order);
+    return [...matched.map((m) => m.proj), ...unmatched];
+}

package/dist/routes/preview.js

@@ -12,7 +12,8 @@ import { buildSessionRenderData, buildProjectRenderData } from '../render/build-
 import { buildAgentSummary } from './context.js';
 import { displayNameFromDir } from '../sync.js';
 import { toSlug } from '../format-utils.js';
-import { getSessionsByProject } from '../db.js';
+import { getSessionsByProject, getAllProjectStats } from '../db.js';
+import { applyPortfolioProjectFilter } from './portfolio-render-data.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /**
  * In-memory cache for expensive buildProjectPreviewData calls.
@@ -25,6 +26,36 @@ const PREVIEW_CACHE_TTL = 30_000;
 /** Clear the preview data cache. Exported for testing. */
 export function clearPreviewCache() {
     previewDataCache.clear();
+    portfolioPreviewCache.clear();
+}
+/**
+ * In-memory cache for the rendered /preview/portfolio HTML response.
+ * Keyed by the literal string 'portfolio' (CLI is single-user). Cached value
+ * is the full HTML body that the route would otherwise re-render on every
+ * iframe reload from the React PreviewPane.
+ *
+ * TTL: 30 seconds. Invalidated explicitly on profile save, portfolio
+ * publish, and project mutations via invalidatePortfolioPreviewCache().
+ */
+// Cache key is `portfolio:<templateName>` so previewing the user's data
+// through alternate templates (template browser "My data" toggle) does not
+// poison the default-template entry.
+const portfolioPreviewCache = new Map();
+const PORTFOLIO_PREVIEW_CACHE_TTL = 30_000;
+function portfolioCacheKey(templateName) {
+    return `portfolio:${templateName}`;
+}
+/**
+ * Invalidate the cached /preview/portfolio HTML. Call this from any route
+ * that mutates state visible in the portfolio render: profile save,
+ * portfolio publish, project enhance-save, screenshot capture/delete, etc.
+ */
+export function invalidatePortfolioPreviewCache() {
+    portfolioPreviewCache.clear();
+}
+/** Test helper: read current cache entry without mutating. */
+export function _getPortfolioPreviewCacheEntry(templateName = 'editorial') {
+    return portfolioPreviewCache.get(portfolioCacheKey(templateName));
 }
 /**
  * Build project render data and enhance result from a project parameter.
@@ -132,7 +163,7 @@ async function buildProjectPreviewData(ctx, projectParam, queryOverrides) {
     const projAny = proj;
     const rawName = projAny.name || displayNameFromDir(projAny.dirName);
     const title = cached?.title || rawName;
-    const slug = toSlug(rawName);
+    const slug = toSlug(title);
     // Metadata from enhance cache (set in sidebar), with query overrides taking priority
     const cachedAny = cached;
     const metaRepoUrl = queryOverrides?.repoUrl || cachedAny?.repoUrl;
@@ -183,7 +214,21 @@ export function createPreviewRouter(ctx) {
             res.status(404).send('Template not found');
             return;
         }
-        const page = req.query.page || 'project';
+        // Allowlist page to prevent path traversal via ?page=../../etc/passwd
+        // in the path.resolve() call below.
+        const VALID_PREVIEW_PAGES = ['portfolio', 'project', 'session'];
+        const rawPage = req.query.page === undefined ? 'project' : req.query.page;
+        if (typeof rawPage !== 'string' ||
+            !VALID_PREVIEW_PAGES.includes(rawPage)) {
+            res.status(400).json({
+                error: {
+                    code: 'INVALID_PAGE',
+                    message: 'page must be one of: portfolio, project, session',
+                },
+            });
+            return;
+        }
+        const page = rawPage;
         // 1. Try static mockup HTML (instant, from docs/mockups/)
         const mockupPath = path.resolve(__dirname, '..', '..', '..', 'docs', 'mockups', name, `${page}.html`);
         if (existsSync(mockupPath)) {
@@ -283,6 +328,8 @@ body { overflow: auto !important; min-height: auto !important; }
                 const { unlinkSync } = require('node:fs');
                 unlinkSync(filePath);
             }
+            // Portfolio listing shows project screenshots — bust the cache.
+            invalidatePortfolioPreviewCache();
             res.json({ ok: true });
         }
         catch {
@@ -465,14 +512,37 @@ body { overflow: auto !important; min-height: auto !important; }
             res.status(500).json({ error: 'Session render failed' });
         }
     });
-    // Portfolio preview -- serves full standalone HTML page with real user data
-    router.get('/preview/portfolio', async (_req, res) => {
+    // Portfolio preview -- serves full standalone HTML page with real user data.
+    // Cached for PORTFOLIO_PREVIEW_CACHE_TTL ms; the React PreviewPane reloads
+    // the iframe on every keystroke (post-debounce), and re-rendering every
+    // project's Liquid template on each hit is expensive.
+    router.get('/preview/portfolio', async (req, res) => {
+        // Optional template override (?template=:name) lets the template browser
+        // preview real user data through any template without changing the saved
+        // default. Falls back to the user's default when missing or invalid.
+        const templateOverride = typeof req.query.template === 'string' ? req.query.template : undefined;
+        const templateName = (templateOverride && isValidTemplate(templateOverride))
+            ? templateOverride
+            : (getDefaultTemplate() || 'editorial');
+        const cacheKey = portfolioCacheKey(templateName);
+        const cached = portfolioPreviewCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now()) {
+            res.type('html').send(cached.html);
+            return;
+        }
         try {
             const profile = getPortfolioProfile();
             const auth = getAuthToken();
-            const templateName = getDefaultTemplate() || 'editorial';
-            // Build portfolio projects from real project data
-            const rawProjects = await ctx.getProjects();
+            // Build portfolio projects from real project data, filtered by user curation
+            const allRawProjects = await ctx.getProjects();
+            const recencyByDir = new Map();
+            try {
+                for (const s of getAllProjectStats(ctx.db)) {
+                    recencyByDir.set(s.projectDir, s.latestDate || '');
+                }
+            }
+            catch { /* DB may be empty on first run */ }
+            const rawProjects = applyPortfolioProjectFilter(allRawProjects, profile.projectsOnPortfolio, { getRecency: (p) => recencyByDir.get(p.dirName) });
             const portfolioProjects = [];
             let totalDuration = 0;
             let totalAgentDuration = 0;
@@ -502,7 +572,7 @@ body { overflow: auto !important; min-height: auto !important; }
                         durationMinutes: s.duration_minutes || 0,
                     }));
                     portfolioProjects.push({
-                        slug: toSlug(rawProj.dirName),
+                        slug: toSlug(title),
                         title,
                         narrative: cached?.result?.narrative || proj.description || '',
                         totalSessions: projSessions,
@@ -543,7 +613,12 @@ body { overflow: auto !important; min-height: auto !important; }
                 totalSessions,
             };
             const bodyHtml = renderPortfolioHtml(renderData, templateName);
-            res.type('html').send(ctx.buildPreviewPage(renderData.user.displayName ? `${renderData.user.displayName}'s Portfolio` : 'Portfolio Preview', bodyHtml, 'PREVIEW — this is how your portfolio will appear on heyi.am', templateName));
+            const fullHtml = ctx.buildPreviewPage(renderData.user.displayName ? `${renderData.user.displayName}'s Portfolio` : 'Portfolio Preview', bodyHtml, undefined, templateName);
+            portfolioPreviewCache.set(cacheKey, {
+                html: fullHtml,
+                expiresAt: Date.now() + PORTFOLIO_PREVIEW_CACHE_TTL,
+            });
+            res.type('html').send(fullHtml);
         }
         catch (err) {
             console.error('[portfolio-preview] Error:', err.message);

package/dist/routes/projects.js

@@ -1,6 +1,8 @@
 import { Router } from 'express';
 import { statSync } from 'node:fs';
+import { loadProjectEnhanceResult, saveProjectEnhanceResult } from '../settings.js';
 import { requireProject, buildSessionList, buildProjectDetail } from './context.js';
+import { invalidatePortfolioPreviewCache } from './preview.js';
 export function createProjectsRouter(ctx) {
     const router = Router();
     router.get('/api/projects', async (_req, res) => {
@@ -173,12 +175,55 @@ export function createProjectsRouter(ctx) {
             res.status(500).json({ error: { code: 'GIT_REMOTE_FAILED', message: err.message } });
         }
     });
-    // ── Boundaries ────────────────────────────────────────────────
-    router.get('/api/projects/:project/boundaries', (_req, res) => {
-        res.json({ selectedSessionIds: [], skippedSessions: [] });
+    // ── Boundaries — manage which sessions belong to a project ───
+    router.get('/api/projects/:project/boundaries', async (req, res) => {
+        try {
+            const project = String(req.params.project);
+            const proj = await requireProject(ctx, project, res);
+            if (!proj)
+                return;
+            const cache = loadProjectEnhanceResult(proj.dirName);
+            const allSessionIds = proj.sessions
+                .filter((s) => !s.isSubagent)
+                .map((s) => s.sessionId);
+            res.json({
+                selectedSessionIds: cache?.selectedSessionIds ?? [],
+                allSessionIds,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: { code: 'BOUNDARIES_FAILED', message: err.message } });
+        }
     });
-    router.put('/api/projects/:project/boundaries', (_req, res) => {
-        res.json({ ok: true });
+    router.put('/api/projects/:project/boundaries', async (req, res) => {
+        try {
+            const project = String(req.params.project);
+            const proj = await requireProject(ctx, project, res);
+            if (!proj)
+                return;
+            const { selectedSessionIds } = req.body;
+            if (!Array.isArray(selectedSessionIds) || selectedSessionIds.length === 0) {
+                res.status(400).json({ error: { code: 'INVALID_INPUT', message: 'selectedSessionIds must be a non-empty array' } });
+                return;
+            }
+            const allIds = new Set(proj.sessions.map((s) => s.sessionId));
+            const invalid = selectedSessionIds.filter((id) => !allIds.has(id));
+            if (invalid.length > 0) {
+                res.status(400).json({ error: { code: 'INVALID_SESSION_IDS', message: `Unknown session IDs: ${invalid.join(', ')}` } });
+                return;
+            }
+            const cache = loadProjectEnhanceResult(proj.dirName);
+            if (!cache) {
+                res.status(400).json({ error: { code: 'NO_CACHE', message: 'Project must be enhanced before managing sessions' } });
+                return;
+            }
+            saveProjectEnhanceResult(proj.dirName, selectedSessionIds, cache.result, undefined, { title: cache.title, repoUrl: cache.repoUrl, projectUrl: cache.projectUrl, screenshotBase64: cache.screenshotBase64 });
+            invalidatePortfolioPreviewCache();
+            res.json({ ok: true, selectedSessionIds });
+        }
+        catch (err) {
+            res.status(500).json({ error: { code: 'BOUNDARIES_FAILED', message: err.message } });
+        }
     });
     return router;
 }