heyio 0.40.0 → 0.42.0

package/dist/api/logout.test.js

@@ -0,0 +1,129 @@
+/**
+ * Integration tests for Logout API endpoint (#325).
+ * Tests POST /api/logout endpoint for sign-out functionality.
+ */
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import express from "express";
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function req(method, port, path, headers, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const options = {
+            hostname: "127.0.0.1",
+            port,
+            path,
+            method,
+            headers: {
+                ...headers,
+                ...(payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}),
+            },
+        };
+        const r = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 0, body: data ? JSON.parse(data) : {} });
+                }
+                catch {
+                    resolve({ status: res.statusCode ?? 0, body: data });
+                }
+            });
+        });
+        r.on("error", reject);
+        if (payload)
+            r.write(payload);
+        r.end();
+    });
+}
+// ── Server Setup ──────────────────────────────────────────────────────────────
+function createTestServer() {
+    const app = express();
+    app.use(express.json());
+    // Mock auth middleware (simulates requireAuth)
+    app.use((req, res, next) => {
+        const token = req.headers.authorization?.startsWith("Bearer ")
+            ? req.headers.authorization.slice(7)
+            : undefined;
+        // If token is explicitly "invalid", fail auth
+        if (token === "invalid") {
+            res.status(401).json({ error: "Invalid or expired token" });
+            return;
+        }
+        // Otherwise, pass through (mock valid auth)
+        next();
+    });
+    // Logout endpoint
+    app.post("/api/logout", (req, res) => {
+        try {
+            // Extract token from Authorization header for potential future token revocation
+            const authHeader = req.headers.authorization;
+            const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : undefined;
+            if (!token) {
+                res.status(401).json({ error: "Missing authorization token" });
+                return;
+            }
+            // Token invalidation approach:
+            // Supabase JWT tokens are short-lived (1 hour by default). Since we don't maintain
+            // a token blacklist, logout on the client side (clearing localStorage) is sufficient.
+            // In a production system with token revocation, the token would be added to a blacklist here.
+            // For now, we simply confirm the logout and rely on client-side token removal.
+            res.json({ status: "logged_out" });
+        }
+        catch (e) {
+            console.error("Error during logout:", e);
+            res.status(500).json({ error: "Logout failed" });
+        }
+    });
+    return app;
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("Logout API Endpoint", () => {
+    let server;
+    let port;
+    before(() => {
+        const app = createTestServer();
+        server = app.listen(0);
+        port = server.address().port;
+    });
+    after(() => {
+        server.close();
+    });
+    describe("POST /api/logout", () => {
+        it("returns 200 with logged_out status on successful logout", async () => {
+            const { status, body } = await req("POST", port, "/api/logout", {
+                Authorization: "Bearer valid-token-12345",
+            });
+            assert.equal(status, 200);
+            assert.equal(body.status, "logged_out");
+        });
+        it("returns 401 when no Authorization header is provided", async () => {
+            const { status, body } = await req("POST", port, "/api/logout");
+            assert.equal(status, 401);
+            assert.ok(body.error.includes("Missing"));
+        });
+        it("returns 401 when Authorization header is invalid", async () => {
+            const { status, body } = await req("POST", port, "/api/logout", {
+                Authorization: "Bearer invalid",
+            });
+            assert.equal(status, 401);
+            assert.ok(body.error);
+        });
+        it("accepts Bearer token format", async () => {
+            const { status } = await req("POST", port, "/api/logout", {
+                Authorization: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+            });
+            assert.equal(status, 200);
+        });
+        it("returns error for malformed Authorization header", async () => {
+            const { status } = await req("POST", port, "/api/logout", {
+                Authorization: "NotBearer token",
+            });
+            // NotBearer does not start with "Bearer " prefix, so validation fails
+            assert.equal(status, 401);
+        });
+    });
+});
+//# sourceMappingURL=logout.test.js.map

package/dist/api/server.js

@@ -19,7 +19,7 @@ import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { getScheduleRuns } from "../store/schedule-runs.js";
 import { createFeedEntry, listFeedEntries, listFeedSquads, countUnreadFeedEntries, markFeedEntryRead, markAllFeedEntriesRead, deleteFeedEntry, markFeedEntriesRead, deleteFeedEntries } from "../store/feed.js";
-import { listPages, readPage } from "../wiki/fs.js";
+import { listPages, readPage, writePage, deletePage, assertPagePath } from "../wiki/fs.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -70,6 +70,28 @@ export async function startApiServer() {
     });
     // Apply auth middleware — all routes below require a valid JWT
     api.use(requireAuth);
+    // Auth: Logout endpoint
+    api.post("/logout", (req, res) => {
+        try {
+            // Extract token from Authorization header for potential future token revocation
+            const authHeader = req.headers.authorization;
+            const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : undefined;
+            if (!token) {
+                res.status(401).json({ error: "Missing authorization token" });
+                return;
+            }
+            // Token invalidation approach:
+            // Supabase JWT tokens are short-lived (1 hour by default). Since we don't maintain
+            // a token blacklist, logout on the client side (clearing localStorage) is sufficient.
+            // In a production system with token revocation, the token would be added to a blacklist here.
+            // For now, we simply confirm the logout and rely on client-side token removal.
+            res.json({ status: "logged_out" });
+        }
+        catch (e) {
+            console.error("Error during logout:", e);
+            res.status(500).json({ error: "Logout failed" });
+        }
+    });
     // Skills read endpoints
     api.get("/skills", (_req, res) => {
         try {
@@ -958,7 +980,7 @@ export async function startApiServer() {
     });
     api.get("/wiki/*path", (req, res) => {
         try {
-            const pagePath = Array.isArray(req.params.path) ? req.params.path[0] : req.params.path;
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
             if (!pagePath) {
                 res.status(400).json({ error: "Missing page path" });
                 return;
@@ -975,6 +997,100 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to read wiki page" });
         }
     });
+    // Create a new wiki page
+    api.post("/wiki", (req, res) => {
+        try {
+            const { path: pagePath, content } = req.body;
+            if (!pagePath || typeof pagePath !== "string") {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            if (content === undefined || typeof content !== "string") {
+                res.status(400).json({ error: "Missing page content" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            if (readPage(pagePath) !== undefined) {
+                res.status(409).json({ error: "Page already exists" });
+                return;
+            }
+            writePage(pagePath, content);
+            res.status(201).json({ path: pagePath, content });
+        }
+        catch (e) {
+            console.error("Error creating wiki page:", e);
+            res.status(500).json({ error: "Failed to create wiki page" });
+        }
+    });
+    // Update an existing wiki page
+    api.put("/wiki/*path", (req, res) => {
+        try {
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+            if (!pagePath) {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            const { content } = req.body;
+            if (content === undefined || typeof content !== "string") {
+                res.status(400).json({ error: "Missing page content" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            if (readPage(pagePath) === undefined) {
+                res.status(404).json({ error: "Page not found" });
+                return;
+            }
+            writePage(pagePath, content);
+            res.json({ path: pagePath, content });
+        }
+        catch (e) {
+            console.error("Error updating wiki page:", e);
+            res.status(500).json({ error: "Failed to update wiki page" });
+        }
+    });
+    // Delete a wiki page
+    api.delete("/wiki/*path", (req, res) => {
+        try {
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+            if (!pagePath) {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            const deleted = deletePage(pagePath);
+            if (!deleted) {
+                res.status(404).json({ error: "Page not found" });
+                return;
+            }
+            res.status(204).send();
+        }
+        catch (e) {
+            console.error("Error deleting wiki page:", e);
+            res.status(500).json({ error: "Failed to delete wiki page" });
+        }
+    });
+    // Get available wiki categories
+    api.get("/wiki-categories", (_req, res) => {
+        res.json({ categories: ["preferences", "projects", "people", "general", "squads"] });
+    });
     // Mount API at /api (for frontend)
     app.use("/api", api);
     // Serve Vue frontend if built assets exist (before backward-compat API mount)

package/dist/api/wiki.test.js

@@ -0,0 +1,283 @@
+/**
+ * Integration tests for Wiki API endpoints (#312).
+ * Tests POST, PUT, DELETE endpoints for wiki pages.
+ */
+import { describe, it, before, after, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import express from "express";
+import { listPages, readPage, writePage, deletePage, assertPagePath, ensureWikiStructure, } from "../wiki/fs.js";
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function req(method, port, path, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const options = {
+            hostname: "127.0.0.1",
+            port,
+            path,
+            method,
+            headers: {
+                ...(payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}),
+            },
+        };
+        const r = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 0, body: data ? JSON.parse(data) : {} });
+                }
+                catch {
+                    resolve({ status: res.statusCode ?? 0, body: data });
+                }
+            });
+        });
+        r.on("error", reject);
+        if (payload)
+            r.write(payload);
+        r.end();
+    });
+}
+// ── Server Setup ──────────────────────────────────────────────────────────────
+function createTestServer() {
+    const app = express();
+    app.use(express.json());
+    // Wiki list
+    app.get("/api/wiki", (_req, res) => {
+        try {
+            const pages = listPages();
+            const result = pages.map((pagePath) => {
+                const pageContent = readPage(pagePath);
+                const title = pageContent?.match(/^#\s+(.+)/m)?.[1]?.trim() ?? pagePath;
+                return { path: pagePath, title };
+            });
+            res.json({ pages: result });
+        }
+        catch (e) {
+            res.status(500).json({ error: "Failed to list wiki pages" });
+        }
+    });
+    // Wiki read
+    app.get("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        const pageContent = readPage(pagePath);
+        if (pageContent === undefined) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        res.json({ path: pagePath, content: pageContent });
+    });
+    // Wiki create
+    app.post("/api/wiki", (req, res) => {
+        const { path: pagePath, content } = req.body;
+        if (!pagePath || typeof pagePath !== "string") {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        if (content === undefined || typeof content !== "string") {
+            res.status(400).json({ error: "Missing page content" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        if (readPage(pagePath) !== undefined) {
+            res.status(409).json({ error: "Page already exists" });
+            return;
+        }
+        writePage(pagePath, content);
+        res.status(201).json({ path: pagePath, content });
+    });
+    // Wiki update
+    app.put("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        const { content } = req.body;
+        if (content === undefined || typeof content !== "string") {
+            res.status(400).json({ error: "Missing page content" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        if (readPage(pagePath) === undefined) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        writePage(pagePath, content);
+        res.json({ path: pagePath, content });
+    });
+    // Wiki delete
+    app.delete("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        const deleted = deletePage(pagePath);
+        if (!deleted) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        res.status(204).send();
+    });
+    // Wiki categories
+    app.get("/api/wiki-categories", (_req, res) => {
+        res.json({ categories: ["preferences", "projects", "people", "general", "squads"] });
+    });
+    return app;
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("Wiki API Endpoints", () => {
+    let server;
+    let port;
+    const testPagePath = `pages/general/test-wiki-api-${Date.now()}.md`;
+    before(() => {
+        ensureWikiStructure();
+        const app = createTestServer();
+        server = app.listen(0);
+        port = server.address().port;
+    });
+    after(() => {
+        server.close();
+        // Clean up test page if exists
+        try {
+            deletePage(testPagePath);
+        }
+        catch { /* ignore */ }
+    });
+    afterEach(() => {
+        // Clean up test page after each test
+        try {
+            deletePage(testPagePath);
+        }
+        catch { /* ignore */ }
+    });
+    describe("GET /api/wiki", () => {
+        it("returns list of wiki pages", async () => {
+            const { status, body } = await req("GET", port, "/api/wiki");
+            assert.equal(status, 200);
+            assert.ok(Array.isArray(body.pages));
+        });
+    });
+    describe("GET /api/wiki-categories", () => {
+        it("returns available categories", async () => {
+            const { status, body } = await req("GET", port, "/api/wiki-categories");
+            assert.equal(status, 200);
+            const categories = body.categories;
+            assert.ok(categories.includes("general"));
+            assert.ok(categories.includes("projects"));
+            assert.ok(categories.includes("preferences"));
+        });
+    });
+    describe("POST /api/wiki", () => {
+        it("creates a new wiki page", async () => {
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+                content: "# Test Page\n\nThis is a test.",
+            });
+            assert.equal(status, 201);
+            assert.equal(body.path, testPagePath);
+            // Verify it was created
+            const page = readPage(testPagePath);
+            assert.ok(page?.includes("# Test Page"));
+        });
+        it("returns 409 if page already exists", async () => {
+            writePage(testPagePath, "# Existing");
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+                content: "# New Content",
+            });
+            assert.equal(status, 409);
+            assert.equal(body.error, "Page already exists");
+        });
+        it("returns 400 for missing path", async () => {
+            const { status } = await req("POST", port, "/api/wiki", {
+                content: "# Test",
+            });
+            assert.equal(status, 400);
+        });
+        it("returns 400 for missing content", async () => {
+            const { status } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+            });
+            assert.equal(status, 400);
+        });
+        it("returns 400 for invalid path (not under pages/)", async () => {
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: "invalid/path.md",
+                content: "# Test",
+            });
+            assert.equal(status, 400);
+            assert.ok(body.error.includes("pages/"));
+        });
+    });
+    describe("PUT /api/wiki/*path", () => {
+        it("updates an existing wiki page", async () => {
+            writePage(testPagePath, "# Original Content");
+            const { status, body } = await req("PUT", port, `/api/wiki/${testPagePath}`, {
+                content: "# Updated Content\n\nNew text here.",
+            });
+            assert.equal(status, 200);
+            assert.equal(body.path, testPagePath);
+            // Verify it was updated
+            const page = readPage(testPagePath);
+            assert.ok(page?.includes("Updated Content"));
+        });
+        it("returns 404 if page does not exist", async () => {
+            const { status, body } = await req("PUT", port, `/api/wiki/${testPagePath}`, {
+                content: "# New Content",
+            });
+            assert.equal(status, 404);
+            assert.equal(body.error, "Page not found");
+        });
+        it("returns 400 for missing content", async () => {
+            writePage(testPagePath, "# Original");
+            const { status } = await req("PUT", port, `/api/wiki/${testPagePath}`, {});
+            assert.equal(status, 400);
+        });
+    });
+    describe("DELETE /api/wiki/*path", () => {
+        it("deletes an existing wiki page", async () => {
+            writePage(testPagePath, "# To Delete");
+            const { status } = await req("DELETE", port, `/api/wiki/${testPagePath}`);
+            assert.equal(status, 204);
+            // Verify it was deleted
+            const page = readPage(testPagePath);
+            assert.equal(page, undefined);
+        });
+        it("returns 404 if page does not exist", async () => {
+            const { status, body } = await req("DELETE", port, `/api/wiki/${testPagePath}`);
+            assert.equal(status, 404);
+            assert.equal(body.error, "Page not found");
+        });
+        it("returns 400 for invalid path", async () => {
+            const { status, body } = await req("DELETE", port, "/api/wiki/invalid-path.md");
+            assert.equal(status, 400);
+            assert.ok(body.error.includes("pages/"));
+        });
+    });
+});
+//# sourceMappingURL=wiki.test.js.map

package/dist/copilot/skills.js

@@ -310,4 +310,76 @@ export async function searchSkillsRegistry(query) {
         return [];
     }
 }
+/**
+ * Update a skill's metadata (name and/or description).
+ * Rewrites the SKILL.md file with the updated frontmatter while preserving content.
+ * Throws if the skill doesn't exist.
+ */
+export function updateSkill(slug, updates) {
+    const skillDir = join(SKILLS_DIR, slug);
+    if (!existsSync(skillDir)) {
+        throw new Error(`Skill not found: ${slug}`);
+    }
+    const skillMdPath = join(skillDir, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+        throw new Error(`SKILL.md not found for skill: ${slug}`);
+    }
+    const currentContent = readFileSync(skillMdPath, "utf-8");
+    const { name: currentName, description: currentDescription } = parseSkillMd(currentContent);
+    // Use provided updates or fall back to current values
+    const newName = updates.name ?? currentName;
+    const newDescription = updates.description ?? currentDescription;
+    // Rebuild SKILL.md with new metadata
+    // Keep everything after the description intact (preserve any extra content)
+    const lines = currentContent.split(/\r?\n/);
+    const newLines = [];
+    // Add the new heading
+    newLines.push(`# ${newName}`);
+    newLines.push("");
+    // Add the new description
+    if (newDescription) {
+        newLines.push(newDescription);
+        newLines.push("");
+    }
+    // Find where the original description ends and append the rest
+    let foundHeading = false;
+    let skippedDescription = false;
+    let blankLinesSeen = 0;
+    for (const line of lines) {
+        if (!foundHeading) {
+            if (line.match(/^#\s+(.+)/)) {
+                foundHeading = true;
+            }
+            continue;
+        }
+        if (!skippedDescription) {
+            if (line.trim() === "") {
+                blankLinesSeen++;
+                if (blankLinesSeen >= 2) {
+                    skippedDescription = true;
+                }
+            }
+            else {
+                blankLinesSeen = 0;
+            }
+            continue;
+        }
+        // We're past the description now
+        newLines.push(line);
+    }
+    const newContent = newLines.join("\n");
+    writeFileSync(skillMdPath, newContent, "utf-8");
+    return {
+        name: newName,
+        slug,
+        description: newDescription,
+        path: skillDir,
+    };
+}
+/**
+ * Delete a skill (alias for removeSkill for consistency with other store modules).
+ */
+export function deleteSkill(slug) {
+    return removeSkill(slug);
+}
 //# sourceMappingURL=skills.js.map