heyiam 0.2.29 → 0.3.1

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];
+}