@juppytt/fws 0.1.0

package/src/server/routes/people.ts

@@ -0,0 +1,239 @@
+import { Router, type Request, type Response } from 'express';
+import { getStore } from '../../store/index.js';
+import { generateId, generateEtag } from '../../util/id.js';
+
+export function peopleRoutes(): Router {
+  const r = Router();
+  const PREFIX = '/v1';
+
+  // Google API uses :action suffix (e.g., people/123:deleteContact)
+  // Express can't parse these naturally, so we use wildcard routes
+
+  // === People / Contacts ===
+
+  // CREATE contact
+  r.post(`${PREFIX}/people:createContact`, (req, res) => {
+    const store = getStore();
+    const id = `c${generateId(8)}`;
+    const resourceName = `people/${id}`;
+    const person = { resourceName, etag: generateEtag(), ...req.body };
+    store.people.contacts[resourceName] = person;
+    res.json(person);
+  });
+
+  // BATCH CREATE contacts
+  r.post(`${PREFIX}/people:batchCreateContacts`, (req, res) => {
+    const store = getStore();
+    const contacts = req.body.contacts || [];
+    const createdPeople = contacts.map((c: any) => {
+      const id = `c${generateId(8)}`;
+      const resourceName = `people/${id}`;
+      const person = { resourceName, etag: generateEtag(), ...c.contactPerson };
+      store.people.contacts[resourceName] = person;
+      return { httpStatusCode: 200, person };
+    });
+    res.json({ createdPeople });
+  });
+
+  // BATCH UPDATE contacts
+  r.post(`${PREFIX}/people:batchUpdateContacts`, (req, res) => {
+    const store = getStore();
+    const contacts = req.body.contacts || {};
+    const updateResult: Record<string, any> = {};
+    for (const [resourceName, body] of Object.entries(contacts) as [string, any][]) {
+      const person = store.people.contacts[resourceName];
+      if (person) {
+        Object.assign(person, body, { resourceName });
+        person.etag = generateEtag();
+        updateResult[resourceName] = { httpStatusCode: 200, person };
+      }
+    }
+    res.json({ updateResult });
+  });
+
+  // BATCH DELETE contacts
+  r.post(`${PREFIX}/people:batchDeleteContacts`, (req, res) => {
+    const store = getStore();
+    const resourceNames: string[] = req.body.resourceNames || [];
+    for (const rn of resourceNames) {
+      delete store.people.contacts[rn];
+    }
+    res.json({});
+  });
+
+  // BATCH GET people
+  r.get(`${PREFIX}/people:batchGet`, (req, res) => {
+    const resourceNames = (Array.isArray(req.query.resourceNames) ? req.query.resourceNames : [req.query.resourceNames]) as string[];
+    const store = getStore();
+    const responses = resourceNames.filter(Boolean).map(rn => {
+      const person = store.people.contacts[rn];
+      return person ? { httpStatusCode: 200, person } : { httpStatusCode: 404 };
+    });
+    res.json({ responses });
+  });
+
+  // SEARCH contacts
+  r.get(`${PREFIX}/people:searchContacts`, (req, res) => {
+    const query = (req.query.query as string || '').toLowerCase();
+    const store = getStore();
+    const results = Object.values(store.people.contacts).filter(p => {
+      const name = p.names?.[0]?.displayName?.toLowerCase() || '';
+      const email = p.emailAddresses?.[0]?.value?.toLowerCase() || '';
+      return name.includes(query) || email.includes(query);
+    });
+    res.json({ results: results.map(person => ({ person })) });
+  });
+
+  // LIST directory people
+  r.get(`${PREFIX}/people:listDirectoryPeople`, (_req, res) => {
+    res.json({ people: Object.values(getStore().people.contacts) });
+  });
+
+  // SEARCH directory people
+  r.get(`${PREFIX}/people:searchDirectoryPeople`, (req, res) => {
+    const query = (req.query.query as string || '').toLowerCase();
+    const people = Object.values(getStore().people.contacts).filter(p => {
+      const name = p.names?.[0]?.displayName?.toLowerCase() || '';
+      const email = p.emailAddresses?.[0]?.value?.toLowerCase() || '';
+      return name.includes(query) || email.includes(query);
+    });
+    res.json({ people });
+  });
+
+  // LIST connections
+  r.get(`${PREFIX}/people/me/connections`, (_req, res) => {
+    const connections = Object.values(getStore().people.contacts);
+    res.json({ connections, totalPeople: connections.length, totalItems: connections.length });
+  });
+
+  // GET person (must be after :action routes)
+  r.get(`${PREFIX}/people/:peopleId`, (req, res) => {
+    const resourceName = `people/${req.params.peopleId}`;
+    const person = getStore().people.contacts[resourceName];
+    if (!person) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    res.json(person);
+  });
+
+  // UPDATE contact — matches people/123:updateContact
+  r.patch(`${PREFIX}/people/:rest`, (req, res) => {
+    const peopleId = req.params.rest.replace(/:.*$/, '');
+    const resourceName = `people/${peopleId}`;
+    const store = getStore();
+    const person = store.people.contacts[resourceName];
+    if (!person) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    Object.assign(person, req.body, { resourceName });
+    person.etag = generateEtag();
+    res.json(person);
+  });
+
+  // DELETE contact — matches people/123:deleteContact
+  r.delete(`${PREFIX}/people/:rest`, (req, res) => {
+    const peopleId = req.params.rest.replace(/:.*$/, '');
+    const resourceName = `people/${peopleId}`;
+    const store = getStore();
+    if (!store.people.contacts[resourceName]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    delete store.people.contacts[resourceName];
+    res.status(204).send();
+  });
+
+  // === Other Contacts ===
+
+  r.get(`${PREFIX}/otherContacts`, (_req, res) => {
+    res.json({ otherContacts: [], totalSize: 0 });
+  });
+
+  r.get(`${PREFIX}/otherContacts:search`, (_req, res) => {
+    res.json({ results: [] });
+  });
+
+  r.post(`${PREFIX}/otherContacts/:rest`, (_req, res) => {
+    res.json({ resourceName: `people/copied`, etag: generateEtag() });
+  });
+
+  // === Contact Groups ===
+
+  r.get(`${PREFIX}/contactGroups:batchGet`, (req, res) => {
+    const resourceNames = (Array.isArray(req.query.resourceNames) ? req.query.resourceNames : [req.query.resourceNames]) as string[];
+    const store = getStore();
+    const responses = resourceNames.filter(Boolean).map(rn => store.people.contactGroups[rn]).filter(Boolean);
+    res.json({ responses });
+  });
+
+  r.get(`${PREFIX}/contactGroups`, (_req, res) => {
+    const groups = Object.values(getStore().people.contactGroups);
+    res.json({ contactGroups: groups, totalItems: groups.length });
+  });
+
+  r.post(`${PREFIX}/contactGroups`, (req, res) => {
+    const store = getStore();
+    const id = generateId(8);
+    const rn = `contactGroups/${id}`;
+    const group = {
+      resourceName: rn,
+      etag: generateEtag(),
+      name: req.body.contactGroup?.name || 'Untitled',
+      groupType: 'USER_CONTACT_GROUP' as const,
+      memberCount: 0,
+    };
+    store.people.contactGroups[rn] = group;
+    res.json(group);
+  });
+
+  r.get(`${PREFIX}/contactGroups/:id`, (req, res) => {
+    const rn = `contactGroups/${req.params.id}`;
+    const group = getStore().people.contactGroups[rn];
+    if (!group) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    res.json(group);
+  });
+
+  r.put(`${PREFIX}/contactGroups/:id`, (req, res) => {
+    const rn = `contactGroups/${req.params.id}`;
+    const store = getStore();
+    const group = store.people.contactGroups[rn];
+    if (!group) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    if (req.body.contactGroup?.name) group.name = req.body.contactGroup.name;
+    group.etag = generateEtag();
+    res.json(group);
+  });
+
+  r.delete(`${PREFIX}/contactGroups/:id`, (req, res) => {
+    const rn = `contactGroups/${req.params.id}`;
+    const store = getStore();
+    if (!store.people.contactGroups[rn]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    delete store.people.contactGroups[rn];
+    res.status(204).send();
+  });
+
+  // MODIFY members
+  r.post(`${PREFIX}/contactGroups/:id/members:modify`, (req, res) => {
+    const rn = `contactGroups/${req.params.id}`;
+    const store = getStore();
+    const group = store.people.contactGroups[rn];
+    if (!group) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    const toAdd: string[] = req.body.resourceNamesToAdd || [];
+    const toRemove: string[] = req.body.resourceNamesToRemove || [];
+    if (!group.memberResourceNames) group.memberResourceNames = [];
+    group.memberResourceNames = group.memberResourceNames.filter(m => !toRemove.includes(m));
+    for (const m of toAdd) {
+      if (!group.memberResourceNames.includes(m)) group.memberResourceNames.push(m);
+    }
+    group.memberCount = group.memberResourceNames.length;
+    res.json({ notFoundResourceNames: [] });
+  });
+
+  return r;
+}

package/src/server/routes/sheets.ts

@@ -0,0 +1,242 @@
+import { Router } from 'express';
+import { getStore } from '../../store/index.js';
+import { generateId } from '../../util/id.js';
+
+export function sheetsRoutes(): Router {
+  const r = Router();
+  const PREFIX = '/v4/spreadsheets';
+
+  // In-memory cell values: key = "spreadsheetId:sheetTitle" -> string[][]
+  const cellValues: Record<string, string[][]> = {};
+
+  function getValues(spreadsheetId: string, sheetTitle: string): string[][] {
+    const key = `${spreadsheetId}::${sheetTitle}`; // double colon to avoid key collision
+    if (!cellValues[key]) cellValues[key] = [];
+    return cellValues[key];
+  }
+
+  function setCell(grid: string[][], row: number, col: number, value: string): void {
+    while (grid.length <= row) grid.push([]);
+    while (grid[row].length <= col) grid[row].push('');
+    grid[row][col] = value;
+  }
+
+  function parseRange(range: string): { sheet: string; startRow: number; startCol: number; endRow: number; endCol: number } {
+    let sheet = 'Sheet1';
+    let cellRange = range;
+    if (range.includes('!')) {
+      const parts = range.split('!');
+      sheet = parts[0].replace(/^'|'$/g, '');
+      cellRange = parts[1];
+    }
+    const colToNum = (c: string) => {
+      let n = 0;
+      for (const ch of c.toUpperCase()) n = n * 26 + ch.charCodeAt(0) - 64;
+      return n - 1;
+    };
+    const parseCell = (cell: string) => {
+      const m = cell.match(/^([A-Za-z]+)(\d+)$/);
+      if (!m) return { row: 0, col: 0 };
+      return { row: parseInt(m[2]) - 1, col: colToNum(m[1]) };
+    };
+    const parts = cellRange.split(':');
+    const start = parseCell(parts[0]);
+    const end = parts[1] ? parseCell(parts[1]) : start;
+    return { sheet, startRow: start.row, startCol: start.col, endRow: end.row, endCol: end.col };
+  }
+
+  // Helper to extract spreadsheetId from params that may include :action suffix
+  function ssId(raw: string): string {
+    return raw.replace(/:.*$/, '');
+  }
+
+  // CREATE spreadsheet
+  r.post(PREFIX, (req, res) => {
+    const store = getStore();
+    const id = generateId();
+    const ss = {
+      spreadsheetId: id,
+      properties: {
+        title: req.body.properties?.title || 'Untitled',
+        locale: req.body.properties?.locale || 'en_US',
+        timeZone: req.body.properties?.timeZone || 'UTC',
+      },
+      sheets: req.body.sheets || [{
+        properties: { sheetId: 0, title: 'Sheet1', index: 0, sheetType: 'GRID', gridProperties: { rowCount: 1000, columnCount: 26 } },
+      }],
+      spreadsheetUrl: `https://docs.google.com/spreadsheets/d/${id}/edit`,
+    };
+    store.sheets.spreadsheets[id] = ss;
+    res.json(ss);
+  });
+
+  // GET spreadsheet
+  r.get(`${PREFIX}/:spreadsheetId`, (req, res) => {
+    const ss = getStore().sheets.spreadsheets[req.params.spreadsheetId];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+    res.json(ss);
+  });
+
+  // BATCH UPDATE — matches :batchUpdate suffix via wildcard
+  r.post(`${PREFIX}/:rest`, (req, res, next) => {
+    if (!req.params.rest.includes(':batchUpdate')) return next();
+    const id = ssId(req.params.rest);
+    const ss = getStore().sheets.spreadsheets[id];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+    const replies = (req.body.requests || []).map(() => ({}));
+    res.json({ spreadsheetId: ss.spreadsheetId, replies });
+  });
+
+  // GET values
+  r.get(`${PREFIX}/:spreadsheetId/values/:range`, (req, res) => {
+    const ss = getStore().sheets.spreadsheets[req.params.spreadsheetId];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+    const parsed = parseRange(req.params.range);
+    const grid = getValues(req.params.spreadsheetId, parsed.sheet);
+    const values: string[][] = [];
+    for (let r = parsed.startRow; r <= parsed.endRow; r++) {
+      const row: string[] = [];
+      for (let c = parsed.startCol; c <= parsed.endCol; c++) {
+        row.push(grid[r]?.[c] || '');
+      }
+      values.push(row);
+    }
+    res.json({ range: req.params.range, majorDimension: 'ROWS', values });
+  });
+
+  // UPDATE values (PUT)
+  r.put(`${PREFIX}/:spreadsheetId/values/:range`, (req, res) => {
+    const ss = getStore().sheets.spreadsheets[req.params.spreadsheetId];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+    const parsed = parseRange(req.params.range);
+    const grid = getValues(req.params.spreadsheetId, parsed.sheet);
+    const values: string[][] = req.body.values || [];
+    let updatedCells = 0;
+    for (let ri = 0; ri < values.length; ri++) {
+      for (let ci = 0; ci < values[ri].length; ci++) {
+        setCell(grid, parsed.startRow + ri, parsed.startCol + ci, values[ri][ci]);
+        updatedCells++;
+      }
+    }
+    res.json({
+      spreadsheetId: req.params.spreadsheetId,
+      updatedRange: req.params.range,
+      updatedRows: values.length,
+      updatedColumns: values[0]?.length || 0,
+      updatedCells,
+    });
+  });
+
+  // APPEND, CLEAR, BATCH GET, BATCH UPDATE, BATCH CLEAR — match via wildcard
+  // These use :action suffix on the range or spreadsheetId
+
+  // Handle /spreadsheets/:id/values/:range:append
+  r.post(`${PREFIX}/:spreadsheetId/values/:rest`, (req, res) => {
+    const ss = getStore().sheets.spreadsheets[req.params.spreadsheetId];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+
+    const rest = req.params.rest;
+
+    if (rest.includes(':append')) {
+      const range = rest.replace(/:append$/, '');
+      const parsed = parseRange(range);
+      const grid = getValues(req.params.spreadsheetId, parsed.sheet);
+      const values: string[][] = req.body.values || [];
+      const startRow = grid.length;
+      let updatedCells = 0;
+      for (let ri = 0; ri < values.length; ri++) {
+        for (let ci = 0; ci < values[ri].length; ci++) {
+          setCell(grid, startRow + ri, parsed.startCol + ci, values[ri][ci]);
+          updatedCells++;
+        }
+      }
+      return res.json({
+        spreadsheetId: req.params.spreadsheetId,
+        updates: { updatedRange: range, updatedRows: values.length, updatedColumns: values[0]?.length || 0, updatedCells },
+      });
+    }
+
+    if (rest.includes(':clear')) {
+      const range = rest.replace(/:clear$/, '');
+      const parsed = parseRange(range);
+      const grid = getValues(req.params.spreadsheetId, parsed.sheet);
+      for (let r = parsed.startRow; r <= parsed.endRow && r < grid.length; r++) {
+        for (let c = parsed.startCol; c <= parsed.endCol && grid[r] && c < grid[r].length; c++) {
+          grid[r][c] = '';
+        }
+      }
+      return res.json({ spreadsheetId: req.params.spreadsheetId, clearedRange: range });
+    }
+
+    if (rest === ':batchUpdate' || rest === ':batchClear') {
+      return res.json({ spreadsheetId: req.params.spreadsheetId, responses: [] });
+    }
+
+    res.status(404).json({ error: { code: 404, message: 'Not found', status: 'NOT_FOUND' } });
+  });
+
+  // BATCH GET values — /spreadsheets/:id/values:batchGet
+  r.get(`${PREFIX}/:rest`, (req, res, next) => {
+    if (!req.params.rest.includes('/values:batchGet') && !req.params.rest.includes('/values:batchGet')) {
+      // Check if it matches the pattern spreadsheetId/values:batchGet
+      const match = req.path.match(/\/v4\/spreadsheets\/([^/]+)\/values:batchGet/);
+      if (!match) return next();
+    }
+    const match = req.path.match(/\/v4\/spreadsheets\/([^/]+)\/values/);
+    if (!match) return next();
+    const spreadsheetId = match[1];
+    const ss = getStore().sheets.spreadsheets[spreadsheetId];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+    const ranges = (Array.isArray(req.query.ranges) ? req.query.ranges : [req.query.ranges]) as string[];
+    const valueRanges = ranges.filter(Boolean).map(range => {
+      const parsed = parseRange(range);
+      const grid = getValues(spreadsheetId, parsed.sheet);
+      const values: string[][] = [];
+      for (let r = parsed.startRow; r <= parsed.endRow; r++) {
+        const row: string[] = [];
+        for (let c = parsed.startCol; c <= parsed.endCol; c++) {
+          row.push(grid[r]?.[c] || '');
+        }
+        values.push(row);
+      }
+      return { range, majorDimension: 'ROWS', values };
+    });
+    res.json({ spreadsheetId, valueRanges });
+  });
+
+  // COPY sheet — /spreadsheets/:id/sheets/:sheetId:copyTo
+  r.post(`${PREFIX}/:spreadsheetId/sheets/:rest`, (req, res) => {
+    const ss = getStore().sheets.spreadsheets[req.params.spreadsheetId];
+    if (!ss) {
+      return res.status(404).json({ error: { code: 404, message: 'Spreadsheet not found.', status: 'NOT_FOUND' } });
+    }
+    const sheetId = parseInt(req.params.rest.replace(/:.*$/, ''));
+    const destId = req.body.destinationSpreadsheetId;
+    const destSs = getStore().sheets.spreadsheets[destId];
+    if (!destSs) {
+      return res.status(404).json({ error: { code: 404, message: 'Destination not found.', status: 'NOT_FOUND' } });
+    }
+    const sourceSheet = ss.sheets.find(s => s.properties.sheetId === sheetId);
+    if (!sourceSheet) {
+      return res.status(404).json({ error: { code: 404, message: 'Sheet not found.', status: 'NOT_FOUND' } });
+    }
+    const newSheetId = destSs.sheets.length;
+    const copy = { ...sourceSheet, properties: { ...sourceSheet.properties, sheetId: newSheetId, index: destSs.sheets.length } };
+    destSs.sheets.push(copy);
+    res.json(copy.properties);
+  });
+
+  return r;
+}

package/src/server/routes/tasks.ts

@@ -0,0 +1,191 @@
+import { Router } from 'express';
+import { getStore } from '../../store/index.js';
+import { generateId } from '../../util/id.js';
+
+export function tasksRoutes(): Router {
+  const r = Router();
+  const PREFIX = '/tasks/v1';
+
+  // === Task Lists ===
+
+  r.get(`${PREFIX}/users/@me/lists`, (_req, res) => {
+    const items = Object.values(getStore().tasks.taskLists);
+    res.json({ kind: 'tasks#taskLists', items });
+  });
+
+  r.get(`${PREFIX}/users/@me/lists/:tasklist`, (req, res) => {
+    const tl = getStore().tasks.taskLists[req.params.tasklist];
+    if (!tl) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    res.json(tl);
+  });
+
+  r.post(`${PREFIX}/users/@me/lists`, (req, res) => {
+    const store = getStore();
+    const id = generateId();
+    const tl = {
+      kind: 'tasks#taskList' as const,
+      id,
+      title: req.body.title || 'Untitled',
+      updated: new Date().toISOString(),
+      selfLink: '',
+    };
+    store.tasks.taskLists[id] = tl;
+    store.tasks.tasks[id] = {};
+    res.json(tl);
+  });
+
+  r.patch(`${PREFIX}/users/@me/lists/:tasklist`, (req, res) => {
+    const store = getStore();
+    const tl = store.tasks.taskLists[req.params.tasklist];
+    if (!tl) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    Object.assign(tl, req.body, { id: tl.id, kind: tl.kind });
+    tl.updated = new Date().toISOString();
+    res.json(tl);
+  });
+
+  r.put(`${PREFIX}/users/@me/lists/:tasklist`, (req, res) => {
+    const store = getStore();
+    if (!store.tasks.taskLists[req.params.tasklist]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    store.tasks.taskLists[req.params.tasklist] = {
+      kind: 'tasks#taskList',
+      ...req.body,
+      id: req.params.tasklist,
+      updated: new Date().toISOString(),
+    };
+    res.json(store.tasks.taskLists[req.params.tasklist]);
+  });
+
+  r.delete(`${PREFIX}/users/@me/lists/:tasklist`, (req, res) => {
+    const store = getStore();
+    if (!store.tasks.taskLists[req.params.tasklist]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    delete store.tasks.taskLists[req.params.tasklist];
+    delete store.tasks.tasks[req.params.tasklist];
+    res.status(204).send();
+  });
+
+  // === Tasks ===
+
+  r.get(`${PREFIX}/lists/:tasklist/tasks`, (req, res) => {
+    const store = getStore();
+    const tasksMap = store.tasks.tasks[req.params.tasklist];
+    if (!tasksMap) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    let items = Object.values(tasksMap);
+    // Filter completed
+    if (req.query.showCompleted === 'false') {
+      items = items.filter(t => t.status !== 'completed');
+    }
+    items.sort((a, b) => a.position.localeCompare(b.position));
+    res.json({ kind: 'tasks#tasks', items });
+  });
+
+  r.get(`${PREFIX}/lists/:tasklist/tasks/:task`, (req, res) => {
+    const task = getStore().tasks.tasks[req.params.tasklist]?.[req.params.task];
+    if (!task) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    res.json(task);
+  });
+
+  r.post(`${PREFIX}/lists/:tasklist/tasks`, (req, res) => {
+    const store = getStore();
+    if (!store.tasks.tasks[req.params.tasklist]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    const id = generateId();
+    const existing = Object.values(store.tasks.tasks[req.params.tasklist]);
+    const maxPos = existing.length > 0
+      ? Math.max(...existing.map(t => parseInt(t.position) || 0))
+      : 0;
+    const task = {
+      kind: 'tasks#task' as const,
+      id,
+      title: req.body.title || '',
+      updated: new Date().toISOString(),
+      selfLink: '',
+      status: (req.body.status || 'needsAction') as 'needsAction',
+      due: req.body.due,
+      notes: req.body.notes,
+      parent: req.body.parent,
+      position: String(maxPos + 1).padStart(20, '0'),
+    };
+    store.tasks.tasks[req.params.tasklist][id] = task;
+    res.json(task);
+  });
+
+  r.patch(`${PREFIX}/lists/:tasklist/tasks/:task`, (req, res) => {
+    const store = getStore();
+    const task = store.tasks.tasks[req.params.tasklist]?.[req.params.task];
+    if (!task) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    Object.assign(task, req.body, { id: task.id, kind: task.kind });
+    task.updated = new Date().toISOString();
+    if (req.body.status === 'completed' && !task.completed) {
+      task.completed = new Date().toISOString();
+    }
+    res.json(task);
+  });
+
+  r.put(`${PREFIX}/lists/:tasklist/tasks/:task`, (req, res) => {
+    const store = getStore();
+    if (!store.tasks.tasks[req.params.tasklist]?.[req.params.task]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    const task = {
+      kind: 'tasks#task' as const,
+      ...req.body,
+      id: req.params.task,
+      updated: new Date().toISOString(),
+    };
+    store.tasks.tasks[req.params.tasklist][req.params.task] = task;
+    res.json(task);
+  });
+
+  r.delete(`${PREFIX}/lists/:tasklist/tasks/:task`, (req, res) => {
+    const store = getStore();
+    if (!store.tasks.tasks[req.params.tasklist]?.[req.params.task]) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    delete store.tasks.tasks[req.params.tasklist][req.params.task];
+    res.status(204).send();
+  });
+
+  // MOVE task
+  r.post(`${PREFIX}/lists/:tasklist/tasks/:task/move`, (req, res) => {
+    const store = getStore();
+    const task = store.tasks.tasks[req.params.tasklist]?.[req.params.task];
+    if (!task) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    if (req.query.parent) task.parent = req.query.parent as string;
+    task.updated = new Date().toISOString();
+    res.json(task);
+  });
+
+  // CLEAR completed tasks
+  r.post(`${PREFIX}/lists/:tasklist/clear`, (req, res) => {
+    const store = getStore();
+    const tasksMap = store.tasks.tasks[req.params.tasklist];
+    if (!tasksMap) {
+      return res.status(404).json({ error: { code: 404, message: 'Not Found', status: 'NOT_FOUND' } });
+    }
+    for (const [id, task] of Object.entries(tasksMap)) {
+      if (task.status === 'completed') {
+        delete tasksMap[id];
+      }
+    }
+    res.status(204).send();
+  });
+
+  return r;
+}

package/src/store/index.ts

@@ -0,0 +1,24 @@
+import type { FwsStore } from './types.js';
+import { createSeedStore } from './seed.js';
+
+let store: FwsStore = createSeedStore();
+
+export function getStore(): FwsStore {
+  return store;
+}
+
+export function resetStore(): void {
+  store = createSeedStore();
+}
+
+export function loadStore(data: FwsStore): void {
+  store = data;
+}
+
+export function serializeStore(): string {
+  return JSON.stringify(store, null, 2);
+}
+
+export function deserializeStore(json: string): FwsStore {
+  return JSON.parse(json) as FwsStore;
+}