[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_255":256,"_257":258},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":16,"_17":18,"_38":-7,"_125":-5,"_19":126,"_127":128,"_129":130,"_131":132,"_133":134,"_21":135,"_136":-5,"_137":138,"_139":24,"_140":141,"_142":87,"_143":-5,"_144":-5,"_145":146},"routes/_app.x.$handle.$name.branch.$branch.history_.$",{"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":26,"_27":28,"_29":24,"_30":-5},"handle","alexaiexperiments","name","todoist-webhook","branchName","fixnoremovalrecurrence","path","descriptionParser.ts","project",{"_32":75,"_13":14,"_36":76,"_65":-5,"_77":24,"_78":79,"_80":79,"_81":82,"_83":-5,"_30":71,"_84":85,"_86":87,"_88":-5,"_89":-5,"_90":26,"_40":41,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":96,"_97":96,"_98":99,"_100":99,"_101":99,"_102":96,"_103":96,"_51":104,"_105":106,"_107":108,"_109":24},"file",{"_66":67,"_13":18,"_68":69,"_70":24,"_74":-5},"isDirectory",false,"page",0,"history",[31],"hasNext","userId",{"_32":33,"_34":35,"_36":37,"_38":39,"_40":41,"_42":-5,"_43":44,"_45":-5,"_46":-5,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":52,"_21":53,"_54":-5,"_55":56,"_57":-5,"_58":-5,"_59":60},"id","5fb9f54e-f9ed-4de9-ba9c-978452df094d","branchId","e25ca62a-3ff8-4461-be1d-c278ba563a31","createdAt",["D",1787403612111],"version",1,"orgId","019f95b4-236c-7362-a248-36bfd5d26630","parentId","incomingCommitId","d5ce9f98-e5db-4820-8bd9-0e958a28822f","aiChatMessageId","aiChatThreadId","aiChatThreadUserId","aiChatThreadTitle","source","clientLabel","user",{"_32":71,"_40":41,"_11":12,"_72":73},{"_66":67,"_13":18,"_68":69,"_70":24},"pull","merge",{"_34":62,"_13":63,"_38":64,"_65":-5},"revert","multiple","commits",[61],{"_32":33,"_34":35,"_36":37,"_38":39,"_40":41,"_42":-5,"_43":44,"_45":-5,"_46":-5,"_47":-5,"_48":-5,"_49":-5,"_50":-5,"_51":52,"_21":53,"_54":-5,"_55":56,"_57":-5},"d5c6d970-01f8-476c-8131-97a3f2dfda37","main",100,"deletedAt","fileId","01a0298e-afc3-751f-bbf5-1eae5f939795","fileType","script","deleted","e18335fe-6041-4f4c-bba1-4a304afb2a2c","avatar","https://avatars.githubusercontent.com/u/184514375?v=4","deletedAtVersion","0334be82-201a-42b6-9fc5-d568200d551d",["D",1785014870875],"legacyEnvVars","privacy","public","httpPrivacy","description","","imageUrl","pinnedFileId","b07ce340-886f-11f1-9e2e-1607ee4eb77e","pinPreview",true,"pinMigrated","screenshotVersion","likeCount","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_11":12,"_124":73},"org",{"_11":12,"_119":120,"_72":73,"_30":71,"_121":122,"_123":24},"branch",{"_38":110,"_13":16,"_32":35,"_111":75,"_112":62,"_113":64,"_114":79,"_115":75,"_116":41,"_117":14,"_118":12},"isOwned",4,"projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","Croitor Emanuel-Alexandru","tier","free","canRestrictVals","profileImageUrl","adoptOrgId",{"_32":75,"_13":14,"_36":251,"_65":-5,"_77":24,"_78":79,"_80":79,"_81":82,"_83":-5,"_30":71,"_84":85,"_86":87,"_88":-5,"_89":-5,"_90":26,"_40":41,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":96,"_97":96,"_98":99,"_100":99,"_101":99,"_102":96,"_103":96,"_51":252,"_105":253,"_107":254,"_109":24},"tree",[171,172,173,174,175,176,177,178,179,180],"files",[171,172,173,174,175,176,177,178,179,180],"counts",{"_159":26,"_160":161,"_162":26,"_163":164,"_165":166},"contents",[],{"_32":152,"_34":35,"_66":67,"_13":18,"_153":154,"_68":69,"_38":26,"_42":-5,"_36":155,"_156":39,"_157":-5,"_17":158},"upstreamProject","upstreamBranch",{"_32":62,"_36":147,"_148":149,"_13":63,"_111":75,"_38":64,"_112":-5,"_113":-5,"_150":151,"_65":-5,"_109":24,"_78":79,"_118":12,"_40":41,"_117":14},"emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},["D",1785014870879],"updatedAt",["D",1787405197546],"lockfileKey","1787405221143-esm.town_v_alexaiexperiments_todoist-webhook@100-main","eb7f3529-a495-4a39-8932-befc01c1b1d9","content","// descriptionParser.ts\n// Direct port of the Python parse_description() function: separates the\n// GCal Event ID header from the user's actual description text, and cleans\n// up stacked/orphaned headers left behind by older formatting bugs.\n\nexport interface ParsedDescription {\n eventId: string | null;\n cleanDescription: string;\n}\n\nconst FULL_HEADER_PATTERN =\n /^🚨 (?:\\d{1,2}\\s+[A-Za-z]{3}|\\d{2}-\\d{2}-\\d{4}) 🚨\\s+GCal Event Id = ([a-zA-Z0-9_]+)\\s+---\\s*/u;\nconst ORPHANED_ID_PATTERN = /^GCal Event Id = ([a-zA-Z0-9_]+)\\s+---\\s*/u;\nconst OLD_HEADER_PATTERN =\n /^🚨 (?:\\d{1,2}\\s+[A-Za-z]{3}|\\d{2}-\\d{2}-\\d{4}) 🚨\\s*(?:---\\s*)?/u;\n\nexport function parseDescription(desc: string): ParsedDescription {\n if (!desc) return { eventId: null, cleanDescription: \"\" };\n\n let eventId: string | null = null;\n let cleanDesc = desc.trim();\n\n while (true) {\n let match = cleanDesc.match(FULL_HEADER_PATTERN);\n if (match) {\n if (!eventId) eventId = match[1];\n cleanDesc = cleanDesc.slice(match[0].length).trim();\n continue;\n }\n\n match = cleanDesc.match(ORPHANED_ID_PATTERN);\n if (match) {\n if (!eventId) eventId = match[1];\n cleanDesc = cleanDesc.slice(match[0].length).trim();\n continue;\n }\n\n match = cleanDesc.match(OLD_HEADER_PATTERN);\n if (match) {\n cleanDesc = cleanDesc.slice(match[0].length).trim();\n continue;\n }\n\n break;\n }\n\n return { eventId, cleanDescription: cleanDesc };\n}",["D",1787403612111],"branchVersion","label",[18],"pulls","branches",2,"forks","envVars",{"_167":169,"_170":26},"connections",{"_167":26,"_168":26},"count","unfilledCount",7,"emptyCount",{"_32":244,"_13":245,"_66":246,"_42":-5,"_34":35,"_156":110,"_184":87,"_36":247,"_38":161,"_68":69,"_153":248,"_70":24,"_157":-5,"_188":249,"_17":250},{"_32":237,"_13":238,"_66":239,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":240,"_38":26,"_68":69,"_153":241,"_70":24,"_157":-5,"_188":242,"_17":243},{"_32":230,"_13":231,"_66":232,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":233,"_38":26,"_68":69,"_153":234,"_70":24,"_157":-5,"_188":235,"_17":236},{"_32":152,"_13":18,"_66":67,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":227,"_38":26,"_68":69,"_153":154,"_70":24,"_157":-5,"_188":228,"_17":229},{"_32":220,"_13":221,"_66":222,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":223,"_38":26,"_68":69,"_153":224,"_70":24,"_157":-5,"_188":225,"_17":226},{"_32":213,"_13":214,"_66":215,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":216,"_38":26,"_68":69,"_153":217,"_70":24,"_157":-5,"_188":218,"_17":219},{"_32":206,"_13":207,"_66":208,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":209,"_38":26,"_68":69,"_153":210,"_70":24,"_157":-5,"_188":211,"_17":212},{"_32":198,"_13":199,"_66":200,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":201,"_38":26,"_68":202,"_153":203,"_70":24,"_157":-5,"_188":204,"_17":205},{"_32":191,"_13":192,"_66":193,"_42":-5,"_34":35,"_156":110,"_184":87,"_36":194,"_38":161,"_68":69,"_153":195,"_70":24,"_157":-5,"_188":196,"_17":197},{"_32":181,"_13":182,"_66":183,"_42":-5,"_34":35,"_156":39,"_184":87,"_36":185,"_38":26,"_68":186,"_153":187,"_70":24,"_157":-5,"_188":189,"_17":190},"dbd8da98-a31e-4cb1-8cb0-45cf7d810468","webhook.ts","01a0298e-afc3-751f-bbf5-36a37c2c140d","latest",["D",1787403612111],"http","// webhook.ts -- set this file's trigger to HTTP in the Val Town UI.\n//\n// Routes:\n// POST /webhook/todoist real-time trigger, verified via Todoist's HMAC signature\n// GET /health lightweight uptime check\n// GET / plain status text\n//\n// On a qualifying event this handler can run up to two independent\n// automations:\n// - the execute-label rescan (automation.ts), on the same event set as\n// before\n// - the instant emoji classification (emoji-automation.ts), only when\n// the task in the payload carries the literal \"{emoji}\" marker\n\nimport { runAutomationSafely } from \"./automation.ts\";\nimport {\n EMOJI_MARKER,\n processInstantEmojiClassification,\n} from \"./emoji-automation.ts\";\n\n// Events that can affect which tasks carry EXECUTE_LABEL or need a due-date rollover.\nconst EXECUTE_LABEL_EVENTS = new Set([\n \"item:added\",\n \"item:updated\",\n \"item:uncompleted\",\n]);\n\n// Events on which it's worth checking a task's content for the {emoji} marker.\nconst EMOJI_MARKER_EVENTS = new Set([\"item:added\", \"item:updated\"]);\n\nasync function verifyTodoistSignature(\n rawBody: string,\n signatureHeader: string | null,\n): Promise {\n const clientSecret = Deno.env.get(\"TODOIST_CLIENT_SECRET\");\n if (!clientSecret || !signatureHeader) return false;\n\n const key = await crypto.subtle.importKey(\n \"raw\",\n new TextEncoder().encode(clientSecret),\n { name: \"HMAC\", hash: \"SHA-256\" },\n false,\n [\"sign\"],\n );\n const signature = await crypto.subtle.sign(\n \"HMAC\",\n key,\n new TextEncoder().encode(rawBody),\n );\n const bytes = new Uint8Array(signature);\n let binary = \"\";\n for (const b of bytes) binary += String.fromCharCode(b);\n const computed = btoa(binary);\n\n if (computed.length !== signatureHeader.length) return false;\n let diff = 0;\n for (let i = 0; i < computed.length; i++) {\n diff |= computed.charCodeAt(i) ^ signatureHeader.charCodeAt(i);\n }\n return diff === 0;\n}\n\nexport default async function (req: Request): Promise {\n const url = new URL(req.url);\n\n if (req.method === \"GET\" && url.pathname === \"/health\") {\n return Response.json({\n status: \"ok\",\n time: new Date().toLocaleString(\"en-US\", {\n timeZone: \"Europe/Bucharest\",\n }),\n });\n }\n\n if (req.method === \"GET\" && url.pathname === \"/\") {\n return new Response(\"Todoist Processor is running.\");\n }\n\n if (req.method === \"POST\" && url.pathname === \"/webhook/todoist\") {\n const rawBody = await req.text();\n const signature = req.headers.get(\"X-Todoist-Hmac-SHA256\");\n\n if (!Deno.env.get(\"TODOIST_CLIENT_SECRET\")) {\n console.error(\n \"Webhook: rejected, TODOIST_CLIENT_SECRET is not configured.\",\n );\n return Response.json({ error: \"Server misconfiguration\" }, {\n status: 500,\n });\n }\n\n if (!(await verifyTodoistSignature(rawBody, signature))) {\n console.warn(\n \"Webhook: rejected request with invalid or missing HMAC signature.\",\n );\n return Response.json({ error: \"Invalid signature\" }, { status: 401 });\n }\n\n let payload: Record;\n try {\n payload = rawBody ? JSON.parse(rawBody) : {};\n } catch {\n console.warn(\"Webhook: rejected request with unparsable JSON body.\");\n return Response.json({ error: \"Invalid JSON\" }, { status: 400 });\n }\n\n const eventName = (payload.event_name as string) || \"unknown\";\n const eventData = payload.event_data as\n | Record\n | undefined;\n console.log(\n `Webhook received: event_name=${eventName}` +\n (eventData\n ? `, task_id=${eventData.id ?? \"?\"}, content=${\n JSON.stringify(eventData.content ?? \"?\")\n }`\n : \"\"),\n );\n\n const isExecuteLabelEvent = EXECUTE_LABEL_EVENTS.has(eventName);\n const isEmojiMarkerEvent = EMOJI_MARKER_EVENTS.has(eventName) &&\n typeof eventData?.content === \"string\" &&\n (eventData.content as string).includes(EMOJI_MARKER);\n\n if (!isExecuteLabelEvent && !isEmojiMarkerEvent) {\n console.log(`Webhook: ignoring irrelevant event '${eventName}'.`);\n return Response.json({ status: \"ignored\", event_name: eventName });\n }\n\n const results: Record = { event_name: eventName };\n\n if (isExecuteLabelEvent) {\n results.execute_label = await runAutomationSafely(`webhook:${eventName}`);\n }\n\n if (isEmojiMarkerEvent) {\n const taskId = eventData?.id != null ? String(eventData.id) : \"\";\n results.emoji = taskId\n ? await processInstantEmojiClassification(taskId)\n : { status: \"error\", message: \"Webhook payload missing task id.\" };\n }\n\n return Response.json(results);\n }\n\n return Response.json({ error: \"Not found\" }, { status: 404 });\n}","children",[],[182],"75816928-1d85-44b7-94d5-796b1e7e3008","todoist.ts","01a0298e-afc3-751f-bbf5-3373af2d4862",["D",1787405198266],"// todoist.ts\n// Thin fetch-based client for the Todoist REST API (api/v1).\n// https://developer.todoist.com/api/v1/\n//\n// Deliberately dependency-free: no npm SDK, just fetch + the env token.\n// Covers what's needed for both automations:\n// - \"execute 🌥\" auto-scheduling: GET /tasks (literal `label` match,\n// cursor-paginated) and POST /tasks/{id} to update a due date.\n// - emoji classification: GET /tasks with no filter (all active tasks,\n// used to both find candidates and resolve parent_id chains for the\n// checklist-exclusion check in-memory), GET /tasks/{id} (single task,\n// used by the instant webhook path, including its own parent lookups),\n// and POST /tasks/{id} to prepend the classified emoji to content.\n\nconst TODOIST_BASE = \"https://api.todoist.com/api/v1\";\n\nfunction authHeaders(): HeadersInit {\n const token = Deno.env.get(\"TODOIST_API_TOKEN\");\n if (!token) throw new Error(\"TODOIST_API_TOKEN is not set.\");\n return { Authorization: `Bearer ${token}` };\n}\n\nexport interface TodoistDue {\n date: string; // \"YYYY-MM-DD\" or a full ISO datetime string\n is_recurring?: boolean;\n string?: string;\n timezone?: string | null;\n lang?: string;\n}\n\nexport interface TodoistTask {\n id: string;\n content: string;\n due: TodoistDue | null;\n /** Direct parent task id, or null/absent for a top-level task -- used\n * to walk up the ancestor chain for the 📋-checklist exclusion check. */\n parent_id?: string | null;\n [key: string]: unknown;\n}\n\ninterface PaginatedResponse {\n results: T[];\n next_cursor: string | null;\n}\n\nasync function paginate(\n path: string,\n params: Record,\n): Promise {\n const items: T[] = [];\n let cursor: string | null = null;\n\n do {\n const url = new URL(`${TODOIST_BASE}${path}`);\n for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);\n url.searchParams.set(\"limit\", \"200\");\n if (cursor) url.searchParams.set(\"cursor\", cursor);\n\n const res = await fetch(url.toString(), { headers: authHeaders() });\n if (!res.ok) {\n throw new Error(\n `Todoist GET ${path} failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as PaginatedResponse;\n items.push(...data.results);\n cursor = data.next_cursor;\n } while (cursor);\n\n return items;\n}\n\n/** Mirrors get_tasks(label=...) -- a literal match against a label name, not the filter DSL. */\nexport async function getTasksByLabel(label: string): Promise {\n return paginate(\"/tasks\", { label });\n}\n\n/** All active tasks visible to this token, across every project -- no filter applied.\n * Used by the emoji sweep, which needs to look at everything to find tasks\n * still missing a category label. */\nexport async function getAllActiveTasks(): Promise {\n return paginate(\"/tasks\", {});\n}\n\n/** Fetches a single task fresh from the API. Used by the instant webhook\n * path so it acts on the task's current state rather than trusting a\n * webhook payload snapshot that may be stale or incomplete. */\nexport async function getTask(taskId: string): Promise {\n const res = await fetch(`${TODOIST_BASE}/tasks/${taskId}`, {\n headers: authHeaders(),\n });\n if (!res.ok) {\n throw new Error(\n `Todoist GET /tasks/${taskId} failed: ${res.status} ${await res.text()}`,\n );\n }\n return (await res.json()) as TodoistTask;\n}\n\nexport interface TaskUpdateFields {\n due_date?: string;\n content?: string;\n}\n\n// --- Recurrence-preserving due date update (Sync API) --------------------\n//\n// The REST convenience endpoint's `due_date`/`due_string` fields always go\n// through Todoist's NLP date parser, which re-derives the WHOLE `due`\n// object from a string. For a recurring task that means either wiping the\n// recurrence entirely (`due_date`) or, more subtly, refusing to place the\n// concrete date on a day that doesn't satisfy the recurrence pattern (e.g.\n// \"every friday\" can't be parsed as due on a Wednesday).\n//\n// The Todoist web/mobile apps don't hit that limitation because dragging a\n// recurring task to \"Today\" doesn't go through the parser at all -- it\n// writes `due.date` directly while leaving `due.string`/`is_recurring`\n// untouched, so the concrete due date and the recurrence rule are allowed\n// to disagree. Confirmed by fetching a real task after using the UI's\n// \"Today\" shortcut on a recurring task:\n// \"due\": {\n// \"date\": \"2026-08-22T16:00:00\", <- moved to today, original time kept\n// \"string\": \"every fri at 4pm\", <- untouched\n// \"is_recurring\": true, <- untouched\n// \"timezone\": null, \"lang\": \"en\"\n// }\n//\n// item_update on the Sync API is the only way to replicate that: unlike\n// the REST endpoint, its `due` argument is applied as a literal object\n// (see https://developer.todoist.com/api/v1/ -- item_update example uses\n// due:{string:...}, but the object accepts the same shape items are\n// returned with -- date/string/is_recurring/timezone/lang -- since that's\n// the same underlying representation used to both read and write items,\n// projects, and PVODs throughout the Sync API).\n\nconst TODOIST_SYNC_URL = `${TODOIST_BASE}/sync`;\n\ninterface SyncCommandError {\n error_tag?: string;\n error_code?: number;\n error: string;\n http_code?: number;\n}\n\ninterface SyncResponse {\n sync_status: Record;\n}\n\n/**\n * Updates a task's `due` object directly via the Sync API's item_update\n * command, bypassing the NLP date parser entirely. Pass the task's\n * existing due.string/is_recurring/timezone/lang through unchanged and\n * only vary `date`, to move a recurring task's due date without touching\n * its recurrence -- exactly what the Todoist UI does under the hood.\n */\nexport async function updateTaskDueRaw(\n taskId: string,\n due: TodoistDue,\n): Promise {\n const uuid = crypto.randomUUID();\n const body = new URLSearchParams({\n commands: JSON.stringify([\n { type: \"item_update\", uuid, args: { id: taskId, due } },\n ]),\n });\n\n console.log(\n `[todoist] sync item_update task=${taskId} due=${JSON.stringify(due)}`,\n );\n\n const res = await fetch(TODOIST_SYNC_URL, {\n method: \"POST\",\n headers: {\n ...authHeaders(),\n \"Content-Type\": \"application/x-www-form-urlencoded\",\n },\n body,\n });\n\n const rawText = await res.text();\n console.log(\n `[todoist] sync item_update task=${taskId} -> ${res.status} ${rawText}`,\n );\n\n if (!res.ok) {\n throw new Error(\n `Todoist sync item_update for task ${taskId} failed: ${res.status} ${rawText}`,\n );\n }\n\n let parsed: SyncResponse;\n try {\n parsed = JSON.parse(rawText) as SyncResponse;\n } catch {\n throw new Error(\n `Todoist sync item_update for task ${taskId}: could not parse response body.`,\n );\n }\n\n const status = parsed.sync_status?.[uuid];\n if (status !== \"ok\") {\n throw new Error(\n `Todoist sync item_update for task ${taskId} failed: ${\n JSON.stringify(status)\n }`,\n );\n }\n}\n\nexport async function updateTask(\n taskId: string,\n fields: TaskUpdateFields,\n): Promise {\n console.log(\n `[todoist] POST /tasks/${taskId} body=${JSON.stringify(fields)}`,\n );\n\n const res = await fetch(`${TODOIST_BASE}/tasks/${taskId}`, {\n method: \"POST\",\n headers: {\n ...authHeaders(),\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify(fields),\n });\n\n const rawText = await res.text();\n console.log(`[todoist] POST /tasks/${taskId} -> ${res.status} ${rawText}`);\n\n if (!res.ok) {\n throw new Error(\n `Todoist update task ${taskId} failed: ${res.status} ${rawText}`,\n );\n }\n\n // The endpoint is documented to echo back the updated task. Some Todoist\n // API versions have returned 204 No Content for updates instead, so this\n // stays defensive rather than assuming a body is always present.\n if (!rawText) return {} as TodoistTask;\n try {\n return JSON.parse(rawText) as TodoistTask;\n } catch {\n console.warn(\n `[todoist] Could not parse JSON response for task ${taskId} update.`,\n );\n return {} as TodoistTask;\n }\n}",[],[192],"3c28aac3-b96f-475c-89f1-dbe39638c2ed","sweep.ts","01a0298e-afc3-751f-bbf5-2d5545efa7de",["D",1787403612111],"interval","// sweep.ts -- set this file's trigger to Cron in the Val Town UI, interval: every 15 minutes.\n//\n// Safety net: catches any webhook delivery Todoist failed to make, and\n// guarantees the \"execute 🌥\" 9 PM rollover happens even on a day with zero\n// Todoist activity. 15 minutes is the fastest interval the free plan allows.\n\nimport { runAutomationSafely } from \"./automation.ts\";\nimport { runEmojiSweepSafely } from \"./emoji-automation.ts\";\n\nexport default async function (interval: Interval) {\n console.log(\n `Cron sweep starting. Last run: ${\n interval.lastRunAt?.toISOString() ?? \"never\"\n }`,\n );\n const result = await runAutomationSafely(\"cron\");\n console.log(\"Cron sweep result:\", JSON.stringify(result));\n\n const emojiResult = await runEmojiSweepSafely(\"cron\");\n console.log(\"Cron emoji sweep result:\", JSON.stringify(emojiResult));\n}",[],[199],"396e56fa-6d8d-4764-a273-4cb7e612baec","gemini.ts","01a0298e-afc3-751f-bbf5-2b748874437f",["D",1787403612111],"// gemini.ts\n//\n// Dependency-free Gemini REST client (mirrors the style of todoist.ts --\n// no SDK, just fetch). This file knows nothing about Todoist or emoji\n// categories; it only knows how to call generateContent with a given\n// model + key and how to retry across a configured list of models/keys.\n// classifier.ts builds the actual classification prompt on top of this.\n//\n// Retry/cycling behaviour (per spec):\n// 1. Try the current model with key #1.\n// 2. On ANY failure (network error, non-2xx response, or the caller's\n// parseResponse callback rejecting the content as invalid) retry the\n// SAME model with the next key.\n// 3. Once every key has failed for a model, move to the next model and\n// start again from key #1.\n// 4. If every model x key combination fails, throw GeminiExhaustedError\n// with the full attempt log -- callers should surface this rather\n// than swallow it.\n//\n// Timing note: Val Town's free-plan execution timeout is 1 minute per val\n// run (see https://www.val.town/limits), and both the cron sweep and the\n// webhook handler share that ceiling. classifier.ts requests\n// thinkingLevel \"medium\" (see below), which adds real latency on top of\n// a plain non-thinking call -- FETCH_TIMEOUT_MS is set generously enough\n// to let that finish normally rather than falsely timing out a\n// legitimately-in-progress response. In practice, actual failures (bad\n// key, rate limit, quota) return fast because auth/quota checks happen\n// before the model starts reasoning, so a realistic retry chain is much\n// faster than the worst case. But if you configure many keys and Gemini\n// is genuinely hanging (not erroring) on most of them, a full exhaustion\n// chain can still exceed the 60s ceiling -- that's a platform limit this\n// file can't route around. Upgrading to Pro (10 min execution timeout)\n// removes the pressure if that scenario matters to you.\n//\n// Model note: Gemini 3-series models are explicitly tuned around the\n// default temperature of 1.0 -- Google's own docs warn that forcing it\n// lower \"may lead to unexpected behavior, such as looping or degraded\n// performance.\" So unlike a lot of older classification-prompt advice,\n// this file does NOT default temperature to 0; it leaves it unset\n// unless a caller explicitly opts in.\n\nconst GEMINI_BASE = \"https://generativelanguage.googleapis.com/v1beta\";\n\nconst DEFAULT_MODEL_PRIORITY = [\"gemini-3.6-flash\", \"gemini-3.5-flash\"];\n\nconst FETCH_TIMEOUT_MS = 12_000; // per attempt -- generous enough for medium-thinking on a small batch\nconst BASE_BACKOFF_MS = 200;\nconst MAX_BACKOFF_MS = 800;\n\nexport interface GeminiConfig {\n /** Ordered priority list, e.g. [\"gemini-3.6-flash\", \"gemini-3.5-flash\"]. */\n models: string[];\n /** Keys to cycle through, in order, for whichever model is currently active. */\n apiKeys: string[];\n}\n\nexport type ThinkingLevel = \"minimal\" | \"low\" | \"medium\" | \"high\";\n\nexport interface GeminiCallOptions {\n systemInstruction?: string;\n /** Gemini generationConfig.responseSchema -- pass together with responseMimeType. */\n responseSchema?: unknown;\n /** Gemini generationConfig.responseMimeType, e.g. \"application/json\" for a schema-constrained object/array. */\n responseMimeType?: string;\n /** Left unset by default -- see the \"Model note\" above on why this file doesn't default to 0. */\n temperature?: number;\n maxOutputTokens?: number;\n /** generationConfig.thinkingConfig.thinkingLevel. \"medium\" is supported on\n * Flash-tier Gemini 3 models per ai.google.dev/gemini-api/docs/gemini-3.\n * Do not combine with the legacy thinkingBudget field -- Gemini returns\n * a 400 if both are present. */\n thinkingLevel?: ThinkingLevel;\n}\n\nexport interface GeminiAttemptFailure {\n model: string;\n keyIndex: number; // 0-based\n status?: number;\n message: string;\n}\n\nexport class GeminiExhaustedError extends Error {\n attempts: GeminiAttemptFailure[];\n constructor(attempts: GeminiAttemptFailure[]) {\n const detail = attempts\n .map((a) => `${a.model} key#${a.keyIndex + 1}${a.status ? ` (${a.status})` : \"\"}: ${a.message}`)\n .join(\"; \");\n super(`All Gemini models/keys exhausted after ${attempts.length} attempt(s): ${detail}`);\n this.name = \"GeminiExhaustedError\";\n this.attempts = attempts;\n }\n}\n\n/** Reads GEMINI_API_KEYS (comma-separated) and, optionally, GEMINI_MODELS\n * (comma-separated, overrides the built-in priority order) from the\n * environment. Keeping the keys/model order in env vars rather than\n * hardcoded arrays means adding a key or reordering models is a Val Town\n * environment-variable edit, not a code change. */\nexport function loadGeminiConfigFromEnv(): GeminiConfig {\n const keysRaw = Deno.env.get(\"GEMINI_API_KEYS\") ?? \"\";\n const apiKeys = keysRaw.split(\",\").map((k) => k.trim()).filter(Boolean);\n\n const modelsRaw = Deno.env.get(\"GEMINI_MODELS\");\n const models = modelsRaw\n ? modelsRaw.split(\",\").map((m) => m.trim()).filter(Boolean)\n : DEFAULT_MODEL_PRIORITY;\n\n return { apiKeys, models };\n}\n\nfunction sleep(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nasync function callOnce(\n model: string,\n apiKey: string,\n prompt: string,\n options: GeminiCallOptions,\n): Promise {\n const generationConfig: Record = {\n maxOutputTokens: options.maxOutputTokens ?? 200,\n };\n if (options.temperature !== undefined) {\n generationConfig.temperature = options.temperature;\n }\n if (options.responseMimeType) {\n generationConfig.responseMimeType = options.responseMimeType;\n }\n if (options.responseSchema) {\n generationConfig.responseSchema = options.responseSchema;\n }\n if (options.thinkingLevel) {\n generationConfig.thinkingConfig = { thinkingLevel: options.thinkingLevel };\n }\n\n const body: Record = {\n contents: [{ role: \"user\", parts: [{ text: prompt }] }],\n generationConfig,\n };\n if (options.systemInstruction) {\n body.systemInstruction = { parts: [{ text: options.systemInstruction }] };\n }\n\n let res: Response;\n try {\n res = await fetch(`${GEMINI_BASE}/models/${model}:generateContent`, {\n method: \"POST\",\n headers: {\n \"Content-Type\": \"application/json\",\n \"x-goog-api-key\": apiKey,\n },\n body: JSON.stringify(body),\n signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),\n });\n } catch (e) {\n throw new Error(`network error calling ${model}: ${e instanceof Error ? e.message : e}`);\n }\n\n const rawText = await res.text();\n\n if (!res.ok) {\n const err = new Error(`${model} responded ${res.status}: ${rawText.slice(0, 300)}`);\n (err as Error & { status?: number }).status = res.status;\n throw err;\n }\n\n let data: {\n candidates?: { content?: { parts?: { text?: string }[] } }[];\n };\n try {\n data = JSON.parse(rawText);\n } catch {\n throw new Error(`${model} returned unparsable JSON`);\n }\n\n const text = data.candidates?.[0]?.content?.parts?.[0]?.text;\n if (typeof text !== \"string\" || !text.trim()) {\n throw new Error(`${model} returned an empty/unexpected response shape`);\n }\n return text.trim();\n}\n\n/**\n * Calls Gemini with the model x key retry/cycling described above.\n * `parseResponse` both parses AND validates the raw text -- throwing\n * inside it (e.g. because the model didn't return one of the expected\n * values) is treated exactly like a transport failure and advances to\n * the next key/model, so callers get one retry loop that covers both\n * \"Gemini errored\" and \"Gemini answered but the answer was garbage\".\n */\nexport async function callGeminiWithRetry(\n config: GeminiConfig,\n prompt: string,\n parseResponse: (rawText: string) => T,\n options: GeminiCallOptions = {},\n): Promise {\n if (config.models.length === 0) {\n throw new Error(\"GeminiConfig.models is empty -- set GEMINI_MODELS or check DEFAULT_MODEL_PRIORITY.\");\n }\n if (config.apiKeys.length === 0) {\n throw new Error(\"GeminiConfig.apiKeys is empty -- set GEMINI_API_KEYS in the environment.\");\n }\n\n const attempts: GeminiAttemptFailure[] = [];\n let attemptNumber = 0;\n\n for (const model of config.models) {\n for (let keyIndex = 0; keyIndex < config.apiKeys.length; keyIndex++) {\n if (attemptNumber > 0) {\n const backoff = Math.min(BASE_BACKOFF_MS * 2 ** (attemptNumber - 1), MAX_BACKOFF_MS);\n await sleep(backoff);\n }\n attemptNumber++;\n\n const apiKey = config.apiKeys[keyIndex];\n try {\n const rawText = await callOnce(model, apiKey, prompt, options);\n return parseResponse(rawText);\n } catch (e) {\n const status = (e as Error & { status?: number })?.status;\n const message = e instanceof Error ? e.message : String(e);\n attempts.push({ model, keyIndex, status, message });\n console.warn(\n `[gemini] ${model} key#${keyIndex + 1} failed${status ? ` (${status})` : \"\"}: ${message}`,\n );\n }\n }\n }\n\n throw new GeminiExhaustedError(attempts);\n}",[],[207],"d3ea95a5-e51c-4ae2-9606-565167480ac2","gcal.ts","01a0298e-afc3-751f-bbf5-26f4efa2e4f6",["D",1787403612111],"// gcal.ts\n// Minimal Google Calendar client authenticated with a service-account JWT,\n// signed using the Web Crypto API (crypto.subtle) instead of the googleapis\n// or google-auth-library npm packages. This keeps the val dependency-free --\n// nothing here depends on an npm package's Deno/Pyodide compatibility.\n\nconst CALENDAR_SCOPE = \"https://www.googleapis.com/auth/calendar.events\";\nconst TOKEN_URL = \"https://oauth2.googleapis.com/token\";\n\nfunction base64url(bytes: ArrayBuffer | Uint8Array): string {\n const arr = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);\n let str = \"\";\n for (const b of arr) str += String.fromCharCode(b);\n return btoa(str).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\nfunction pemToArrayBuffer(pem: string): ArrayBuffer {\n const clean = pem\n .replace(/-----BEGIN PRIVATE KEY-----/, \"\")\n .replace(/-----END PRIVATE KEY-----/, \"\")\n .replace(/\\s/g, \"\");\n const binary = atob(clean);\n const bytes = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);\n return bytes.buffer;\n}\n\ninterface ServiceAccount {\n client_email: string;\n private_key: string;\n}\n\nfunction loadServiceAccount(): ServiceAccount {\n const json = Deno.env.get(\"GOOGLE_CREDENTIALS_JSON\");\n if (!json) throw new Error(\"GOOGLE_CREDENTIALS_JSON is not set.\");\n return JSON.parse(json) as ServiceAccount;\n}\n\nasync function getAccessToken(): Promise {\n const sa = loadServiceAccount();\n const now = Math.floor(Date.now() / 1000);\n\n const header = { alg: \"RS256\", typ: \"JWT\" };\n const claims = {\n iss: sa.client_email,\n scope: CALENDAR_SCOPE,\n aud: TOKEN_URL,\n iat: now,\n exp: now + 3600,\n };\n\n const encoder = new TextEncoder();\n const signingInput = `${base64url(encoder.encode(JSON.stringify(header)))}.` +\n `${base64url(encoder.encode(JSON.stringify(claims)))}`;\n\n const key = await crypto.subtle.importKey(\n \"pkcs8\",\n pemToArrayBuffer(sa.private_key),\n { name: \"RSASSA-PKCS1-v1_5\", hash: \"SHA-256\" },\n false,\n [\"sign\"],\n );\n\n const signature = await crypto.subtle.sign(\n \"RSASSA-PKCS1-v1_5\",\n key,\n encoder.encode(signingInput),\n );\n\n const jwt = `${signingInput}.${base64url(signature)}`;\n\n const res = await fetch(TOKEN_URL, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n body: new URLSearchParams({\n grant_type: \"urn:ietf:params:oauth:grant-type:jwt-bearer\",\n assertion: jwt,\n }),\n });\n\n if (!res.ok) {\n throw new Error(\n `Google token exchange failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as { access_token: string };\n return data.access_token;\n}\n\nfunction calendarId(): string {\n return Deno.env.get(\"GCAL_CALENDAR_ID\") || \"primary\";\n}\n\nexport function formatIsoDate(d: Date): string {\n const y = d.getUTCFullYear();\n const m = String(d.getUTCMonth() + 1).padStart(2, \"0\");\n const day = String(d.getUTCDate()).padStart(2, \"0\");\n return `${y}-${m}-${day}`;\n}\n\nfunction addDays(d: Date, days: number): Date {\n return new Date(d.getTime() + days * 24 * 60 * 60 * 1000);\n}\n\nfunction eventBody(taskName: string, deadlineDate: Date) {\n return {\n summary: `🚨 ${taskName}`,\n start: { date: formatIsoDate(deadlineDate), timeZone: \"Europe/Bucharest\" },\n end: {\n date: formatIsoDate(addDays(deadlineDate, 1)),\n timeZone: \"Europe/Bucharest\",\n },\n colorId: \"11\", // Tomato / Deep Red\n };\n}\n\ninterface GcalHttpError extends Error {\n status?: number;\n}\n\nexport async function createGcalEvent(\n taskName: string,\n deadlineDate: Date,\n): Promise {\n const token = await getAccessToken();\n const res = await fetch(\n `https://www.googleapis.com/calendar/v3/calendars/${\n encodeURIComponent(calendarId())\n }/events`,\n {\n method: \"POST\",\n headers: {\n Authorization: `Bearer ${token}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify(eventBody(taskName, deadlineDate)),\n },\n );\n if (!res.ok) {\n throw new Error(\n `GCal create event failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as { id: string };\n return data.id;\n}\n\nexport async function updateGcalEvent(\n eventId: string,\n taskName: string,\n deadlineDate: Date,\n): Promise {\n const token = await getAccessToken();\n const res = await fetch(\n `https://www.googleapis.com/calendar/v3/calendars/${\n encodeURIComponent(calendarId())\n }/events/${encodeURIComponent(eventId)}`,\n {\n method: \"PUT\",\n headers: {\n Authorization: `Bearer ${token}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify(eventBody(taskName, deadlineDate)),\n },\n );\n if (!res.ok) {\n const err: GcalHttpError = new Error(\n `GCal update event failed: ${res.status} ${await res.text()}`,\n );\n err.status = res.status;\n throw err;\n }\n}\n\nexport async function deleteGcalEvent(eventId: string): Promise {\n const token = await getAccessToken();\n const res = await fetch(\n `https://www.googleapis.com/calendar/v3/calendars/${\n encodeURIComponent(calendarId())\n }/events/${encodeURIComponent(eventId)}`,\n { method: \"DELETE\", headers: { Authorization: `Bearer ${token}` } },\n );\n // 404/410 mean it's already gone -- safe to ignore, mirrors the Python original.\n if (!res.ok && res.status !== 404 && res.status !== 410) {\n throw new Error(\n `GCal delete event failed: ${res.status} ${await res.text()}`,\n );\n }\n}",[],[214],"4c50d196-bc43-4ae9-b1b7-a22636849a00","emoji-automation.ts","01a0298e-afc3-751f-bbf5-2240fc785b55",["D",1787403612111],"// emoji-automation.ts\n//\n// Automation #2: classify every task's content into exactly one of the\n// CATEGORIES (categories.ts) using Gemini (classifier.ts / gemini.ts) and\n// prepend the result to the task's own content (e.g. \"Fix login bug\" ->\n// \"⚒️ Fix login bug\") -- no Todoist label involved.\n//\n// Two entry points share the same classify-then-update step\n// (classifyBatch) so the retry/apply logic only exists once:\n//\n// - processEmojiSweep() / runEmojiSweepSafely(): the cron batch path.\n// Finds every task missing a category emoji, excludes anything under\n// a 📋 checklist, and works through a bounded number of them per\n// tick in batches of BATCH_SIZE (see below).\n// - processInstantEmojiClassification(taskId): the webhook path. Fires\n// when a task is saved with the literal \"{emoji}\" marker in its\n// content, so on-the-spot testing doesn't require waiting for the\n// next cron tick. Calls the exact same classifyBatch with a batch of\n// one. Saving \"{emoji_all}\" instead runs the full sweep on demand.\n//\n// Locking: the cron sweep is wrapped in its own blob lock (same\n// mechanism as automation.ts's execute-label lock, different key) to\n// stop two overlapping cron ticks from re-scanning the same backlog. The\n// instant webhook path deliberately does NOT take that lock -- it only\n// ever touches the one task named in the webhook payload, so the worst\n// case of a rare overlap with an in-flight sweep is a duplicate\n// (harmless, idempotent-ish -- see computeNewContent) classification of\n// that task, and the whole point of the marker is fast, unblocked\n// feedback while testing.\n\nimport {\n getAllActiveTasks,\n getTask,\n TodoistTask,\n updateTask,\n} from \"./todoist.ts\";\nimport {\n CATEGORY_EMOJIS,\n hasEmojiPrefix,\n hasUncompletablePrefix,\n isChecklistRoot,\n stripUncompletablePrefix,\n} from \"./categories.ts\";\nimport { classifyTasksBatch } from \"./classifier.ts\";\nimport { loadGeminiConfigFromEnv } from \"./gemini.ts\";\nimport { AutomationResult, withBlobLock } from \"./automation.ts\";\n\n// Test markers, accepted with either single or double braces because both\n// get typed in practice ({{emoji}} is the natural thing to write, and\n// stripping only the inner {emoji} used to leave a stray \"{}\" behind).\n// {emoji} -> classify just this task, now\n// {emoji_all} -> run the whole cron sweep now, across every task\nexport const EMOJI_MARKER = \"{emoji}\";\nexport const EMOJI_ALL_MARKER = \"{emoji_all}\";\n\nconst EMOJI_MARKER_RE = /\\{{1,2}\\s*emoji\\s*\\}{1,2}/i;\nconst EMOJI_ALL_MARKER_RE = /\\{{1,2}\\s*emoji_all\\s*\\}{1,2}/i;\nconst ANY_MARKER_RE = /\\{{1,2}\\s*emoji(_all)?\\s*\\}{1,2}/i;\nconst ANY_MARKER_GLOBAL_RE = new RegExp(ANY_MARKER_RE.source, \"gi\");\n\nexport function hasEmojiMarker(content: string): boolean {\n return EMOJI_MARKER_RE.test(content);\n}\n\nexport function hasEmojiAllMarker(content: string): boolean {\n return EMOJI_ALL_MARKER_RE.test(content);\n}\n\nfunction stripMarkers(content: string): string {\n if (!ANY_MARKER_RE.test(content)) return content;\n return content.replace(ANY_MARKER_GLOBAL_RE, \"\").replace(/\\s{2,}/g, \" \")\n .trim();\n}\n\n/** Strips any category emoji this automation may have already prepended\n * (defense against double-prefixing if the sweep and an instant\n * classification ever race on the same task -- see the file header). */\nfunction stripAnyExistingCategoryPrefix(content: string): string {\n const trimmed = content.trimStart();\n for (const emoji of CATEGORY_EMOJIS) {\n if (trimmed.startsWith(emoji)) return trimmed.slice(emoji.length).trim();\n }\n return trimmed;\n}\n\nfunction computeNewContent(originalContent: string, emoji: string): string {\n // \"* \" has to stay in first position or Todoist stops treating the task\n // as uncompletable, so the emoji goes after it, not before it.\n const prefix = hasUncompletablePrefix(originalContent) ? \"* \" : \"\";\n const body = stripAnyExistingCategoryPrefix(\n stripMarkers(stripUncompletablePrefix(originalContent)),\n );\n // Guard a task whose *entire* content was the marker (e.g. a bare\n // \"{emoji}\" test task): don't leave the task blank, just the emoji.\n return body ? `${prefix}${emoji} ${body}` : `${prefix}${emoji}`;\n}\n\nasync function applyClassification(\n task: TodoistTask,\n emoji: string,\n): Promise {\n await updateTask(task.id, {\n content: computeNewContent(task.content, emoji),\n });\n}\n\n// --- Checklist-root exclusion --------------------------------------------\n//\n// A task whose content starts with 📋, or that is a child/grandchild/...\n// of one, is reference material (a checklist), not actionable work --\n// it and its whole subtree are skipped. `lookupParent` abstracts over\n// how a parent task is found so the cron sweep (which already has every\n// active task in memory) can do this with zero extra API calls, while\n// the webhook path (which only has the one task) can look parents up\n// live, one at a time.\n\nconst MAX_ANCESTOR_DEPTH = 10;\n\nexport async function isUnderChecklistRoot(\n task: TodoistTask,\n lookupParent: (\n parentId: string,\n ) => TodoistTask | undefined | Promise,\n maxDepth = MAX_ANCESTOR_DEPTH,\n): Promise {\n let parentId = task.parent_id ?? undefined;\n for (let depth = 0; depth < maxDepth && parentId; depth++) {\n const parent = await lookupParent(parentId);\n if (!parent) return false; // can't resolve further -- fail open, don't block classification\n if (isChecklistRoot(parent.content)) return true;\n parentId = parent.parent_id ?? undefined;\n }\n return false;\n}\n\n// --- Shared classify-and-apply step --------------------------------------\n\nexport interface ClassifyOutcome {\n taskId: string;\n emoji: string;\n}\n\nexport interface ClassifyBatchResult {\n applied: ClassifyOutcome[];\n failed: { taskId: string; error: string }[];\n}\n\n/**\n * The one function both the cron sweep and the instant webhook path call:\n * classifies `tasks` (up to BATCH_SIZE of them) in a single Gemini call\n * and applies each result to Todoist. A batch of one task -- exactly\n * what the webhook path passes -- works the same way as a batch of five.\n */\nexport async function classifyBatch(\n tasks: TodoistTask[],\n): Promise {\n const applied: ClassifyOutcome[] = [];\n const failed: { taskId: string; error: string }[] = [];\n if (tasks.length === 0) return { applied, failed };\n\n const config = loadGeminiConfigFromEnv();\n const inputs = tasks.map((t) => ({\n id: t.id,\n content: stripMarkers(stripUncompletablePrefix(t.content)),\n }));\n\n let results: Map;\n try {\n results = await classifyTasksBatch(inputs, config);\n } catch (e) {\n // Whole batch failed (Gemini exhausted, or the response never came\n // back complete/valid after every retry) -- every task in it stays\n // unclassified and will be picked up again on the next sweep/trigger.\n const message = e instanceof Error ? e.message : String(e);\n console.error(\n `[emoji] Batch classification failed for ${tasks.length} task(s): ${message}`,\n );\n for (const t of tasks) failed.push({ taskId: t.id, error: message });\n return { applied, failed };\n }\n\n for (const task of tasks) {\n const emoji = results.get(task.id);\n if (!emoji) {\n // Shouldn't happen -- classifyTasksBatch only resolves once every\n // requested id has a valid emoji -- but never trust silently.\n failed.push({\n taskId: task.id,\n error: \"Gemini response omitted this task id\",\n });\n continue;\n }\n try {\n await applyClassification(task, emoji);\n applied.push({ taskId: task.id, emoji });\n } catch (e) {\n failed.push({\n taskId: task.id,\n error: e instanceof Error ? e.message : String(e),\n });\n }\n }\n\n return { applied, failed };\n}\n\nfunction chunk(items: T[], size: number): T[][] {\n const chunks: T[][] = [];\n for (let i = 0; i < items.length; i += size) {\n chunks.push(items.slice(i, i + size));\n }\n return chunks;\n}\n\nasync function forEachWithConcurrency(\n items: T[],\n limit: number,\n fn: (item: T) => Promise,\n): Promise {\n let nextIndex = 0;\n async function worker() {\n while (true) {\n const i = nextIndex++;\n if (i >= items.length) return;\n await fn(items[i]);\n }\n }\n const workers = Array.from({ length: Math.min(limit, items.length) }, worker);\n await Promise.all(workers);\n}\n\n// --- Cron path: batch sweep ---------------------------------------------\n//\n// Batch size of 5 per your spec. Val Town's free-plan execution timeout\n// is 1 minute per run (shared with whatever else runs in the same cron\n// tick -- see gemini.ts's header comment on timing), so this caps how\n// many batches one tick will attempt; anything past the cap rolls over\n// to the next 15-minute tick automatically (the sweep re-scans\n// everything, so nothing gets lost, just deferred).\n\nconst BATCH_SIZE = 5;\nconst MAX_BATCHES_PER_SWEEP = 2;\nconst SWEEP_BATCH_CONCURRENCY = 2;\n\nexport async function processEmojiSweep(): Promise {\n let allTasks: TodoistTask[];\n try {\n allTasks = await getAllActiveTasks();\n } catch (e) {\n console.error(\"Failed to fetch tasks for emoji sweep:\", e);\n return { status: \"error\", message: `Failed to fetch tasks: ${e}` };\n }\n\n const taskById = new Map(allTasks.map((t) => [t.id, t] as const));\n\n const needsClassification: TodoistTask[] = [];\n let checklistSkipped = 0;\n for (const task of allTasks) {\n if (hasEmojiPrefix(task.content)) continue;\n if (await isUnderChecklistRoot(task, (id) => taskById.get(id))) {\n checklistSkipped++;\n continue;\n }\n needsClassification.push(task);\n }\n\n const allBatches = chunk(needsClassification, BATCH_SIZE);\n const batches = allBatches.slice(0, MAX_BATCHES_PER_SWEEP);\n const processedCount = batches.reduce((n, b) => n + b.length, 0);\n const deferred = needsClassification.length - processedCount;\n\n let updatedCount = 0;\n let errorCount = 0;\n const log: string[] = [];\n const errors: string[] = [];\n\n await forEachWithConcurrency(\n batches,\n SWEEP_BATCH_CONCURRENCY,\n async (batch) => {\n const { applied, failed } = await classifyBatch(batch);\n for (const a of applied) {\n updatedCount++;\n const msg = `Task ${a.taskId} prefixed ${a.emoji}`;\n log.push(msg);\n console.log(`[emoji] ${msg}`);\n }\n for (const f of failed) {\n errorCount++;\n const msg = `Failed to classify task ${f.taskId}: ${f.error}`;\n errors.push(msg);\n console.error(`[emoji] ${msg}`);\n }\n },\n );\n\n return {\n status: \"success\",\n found: needsClassification.length,\n checklist_skipped: checklistSkipped,\n processed: processedCount,\n deferred,\n updated: updatedCount,\n failed: errorCount,\n log,\n errors,\n };\n}\n\nconst EMOJI_LOCK_KEY = \"todoist-processor:emoji-lock\";\nconst EMOJI_LOCK_TTL_MS = 3 * 60 * 1000; // see automation.ts's withBlobLock doc comment\n\nexport async function runEmojiSweepSafely(\n trigger: string,\n): Promise {\n return withBlobLock({\n lockKey: EMOJI_LOCK_KEY,\n ttlMs: EMOJI_LOCK_TTL_MS,\n trigger,\n run: processEmojiSweep,\n });\n}\n\n// --- Webhook path: instant single-task classification -------------------\n\n/**\n * Re-fetches `taskId` (rather than trusting the webhook payload, which\n * may be stale or a partial snapshot) and, if it still carries the\n * {emoji} marker and isn't excluded (already classified, or a checklist\n * item), runs it through the same classifyBatch as the sweep, as a batch\n * of one. Not lock-guarded -- see the file header for why that's fine.\n */\nexport async function processInstantEmojiClassification(\n taskId: string,\n): Promise {\n let task: TodoistTask;\n try {\n task = await getTask(taskId);\n } catch (e) {\n console.error(\n `Failed to fetch task ${taskId} for instant classification:`,\n e,\n );\n return { status: \"error\", message: `Failed to fetch task ${taskId}: ${e}` };\n }\n\n if (!hasEmojiMarker(task.content)) {\n // Re-fetched content no longer has the marker (already handled by a\n // prior delivery, or edited again before we got to it) -- no-op.\n return { status: \"skipped\", message: \"Marker no longer present on task.\" };\n }\n if (hasEmojiPrefix(task.content)) {\n return { status: \"skipped\", message: \"Task already starts with an emoji.\" };\n }\n\n const lookupParent = async (id: string): Promise => {\n try {\n return await getTask(id);\n } catch {\n return undefined;\n }\n };\n if (await isUnderChecklistRoot(task, lookupParent)) {\n return {\n status: \"skipped\",\n message:\n \"Task is under a 📋 checklist -- reference item, not classified.\",\n };\n }\n\n const { applied, failed } = await classifyBatch([task]);\n if (applied.length > 0) {\n console.log(\n `[emoji] Instant classification: task ${applied[0].taskId} prefixed ${\n applied[0].emoji\n }`,\n );\n return { status: \"success\", ...applied[0] };\n }\n const failure = failed[0];\n console.error(\n `[emoji] Instant classification failed for task ${taskId}: ${failure?.error}`,\n );\n return { status: \"error\", message: failure?.error ?? \"unknown error\" };\n}",[],[221],["D",1787403612111],[],[18],"267f27a7-9d19-4b3b-83a0-9a35321e240c","classifier.ts","01a0298e-afc3-751f-bbf5-18b97992b6e9",["D",1787403612111],"// classifier.ts\n//\n// Domain glue: turns a batch of tasks' text content into category emoji\n// (categories.ts) using Gemini (gemini.ts). Knows nothing about Todoist\n// task objects, the {emoji} marker, or checklist exclusion -- just\n// \"given these id+content pairs, which emoji does each get\".\n//\n// Batched by design: one Gemini call classifies up to BATCH_SIZE tasks\n// (see emoji-automation.ts) at once, and the model is asked to answer\n// with id + emoji only -- never asked to echo back task content, so a\n// batch's output is a handful of short JSON objects rather than a\n// restatement of everything it was given.\n\nimport { CATEGORIES, CATEGORY_EMOJIS } from \"./categories.ts\";\nimport { callGeminiWithRetry, GeminiConfig } from \"./gemini.ts\";\n\nconst VALID_EMOJIS = CATEGORIES.map((c) => c.emoji);\n\nconst SYSTEM_INSTRUCTION =\n \"You are a strict classifier for a personal to-do list. For each task \" +\n \"given, choose exactly one category and output only its emoji -- never \" +\n \"the category name, never the task content, never any explanation. \" +\n \"If a task is genuinely ambiguous, pick the closest match rather than \" +\n \"omitting it.\";\n\nfunction buildBatchPrompt(tasks: { id: string; content: string }[]): string {\n const categoryLines = CATEGORIES\n .map((c) => `- \"${c.emoji}\" -- ${c.name}: ${c.description}`)\n .join(\"\\n\");\n const taskLines = tasks\n .map((t) => `- id=\"${t.id}\" content=${JSON.stringify(t.content)}`)\n .join(\"\\n\");\n\n return (\n `Categories:\\n${categoryLines}\\n\\n` +\n `Classify each task below into exactly one category. Respond with a ` +\n `JSON array with one object per task: {\"id\": , \"emoji\": }.\\n\\n` +\n `Tasks:\\n${taskLines}`\n );\n}\n\ninterface RawBatchItem {\n id?: unknown;\n emoji?: unknown;\n}\n\n/** Throws (rather than returning a partial result) if the response isn't\n * a clean JSON array, if any item's emoji isn't one of the 13 valid\n * category emoji, or if any requested id is missing from the response.\n * callGeminiWithRetry treats a thrown error here exactly like a\n * transport failure and moves on to the next key/model -- so an\n * incomplete-but-otherwise-valid-looking answer gets a real retry\n * rather than silently shipping partial results. */\nfunction parseBatchResponse(\n rawText: string,\n requestedIds: Set,\n): Map {\n let parsed: unknown;\n try {\n parsed = JSON.parse(rawText);\n } catch {\n throw new Error(\n `batch response was not valid JSON: ${rawText.slice(0, 200)}`,\n );\n }\n if (!Array.isArray(parsed)) {\n throw new Error(\n `batch response was not a JSON array: ${rawText.slice(0, 200)}`,\n );\n }\n\n const result = new Map();\n for (const raw of parsed as RawBatchItem[]) {\n if (typeof raw !== \"object\" || raw === null) continue;\n const { id, emoji } = raw;\n if (typeof id !== \"string\" || typeof emoji !== \"string\") continue;\n if (!requestedIds.has(id)) continue; // ignore ids we didn't ask about\n if (!CATEGORY_EMOJIS.has(emoji)) {\n throw new Error(\n `task ${id}: unrecognized emoji in batch response: ${\n JSON.stringify(emoji)\n }`,\n );\n }\n result.set(id, emoji);\n }\n\n const missing = [...requestedIds].filter((id) => !result.has(id));\n if (missing.length > 0) {\n throw new Error(\n `batch response missing ${missing.length}/${requestedIds.size} requested id(s): ${\n missing.join(\", \")\n }`,\n );\n }\n\n return result;\n}\n\n/**\n * Classifies a batch of up to a few tasks in a single Gemini call,\n * returning a map from task id to category emoji. Retries across every\n * configured model x key combination (see gemini.ts) if the call fails\n * OR if the response comes back incomplete/invalid. Works identically\n * for a \"batch\" of one, which is what the instant webhook path uses --\n * see emoji-automation.ts's classifyBatch, the single shared entry point\n * both the cron sweep and the webhook handler call into.\n */\nexport async function classifyTasksBatch(\n tasks: { id: string; content: string }[],\n config: GeminiConfig,\n): Promise> {\n const prompt = buildBatchPrompt(tasks);\n const requestedIds = new Set(tasks.map((t) => t.id));\n // Generous relative to actual need (each item is ~30-40 tokens of JSON)\n // so a full batch's visible output is never the bottleneck.\n const maxOutputTokens = 100 + 100 * tasks.length;\n\n return await callGeminiWithRetry(\n config,\n prompt,\n (rawText) => parseBatchResponse(rawText, requestedIds),\n {\n systemInstruction: SYSTEM_INSTRUCTION,\n responseMimeType: \"application/json\",\n responseSchema: {\n type: \"array\",\n items: {\n type: \"object\",\n properties: {\n id: { type: \"string\" },\n emoji: { type: \"string\", enum: VALID_EMOJIS },\n },\n required: [\"id\", \"emoji\"],\n propertyOrdering: [\"id\", \"emoji\"],\n },\n },\n thinkingLevel: \"medium\",\n maxOutputTokens,\n },\n );\n}",[],[231],"3bef3810-1e90-412e-b358-36f8b33c4b9b","categories.ts","01a0298e-afc3-751f-bbf5-1447f08a8c2b",["D",1787403612111],"// categories.ts\n//\n// The fixed set of top-level categories every task's content gets\n// classified into. `emoji` is the *exact* character(s) prepended to a\n// task's content and checked for to know a task has already been\n// classified. These must match your intent character-for-character\n// (including invisible variation-selector bytes some of these emoji\n// carry) -- if classification or detection ever looks like it's\n// misbehaving, diffing these against what you actually typed is the\n// first thing to check.\n//\n// NOTE: two categories carry a secondary tagging scheme in the source\n// spec that this file does NOT turn into anything extra:\n// - Action is meant to be paired with an energy tag (Deep Work 🔥,\n// Supervision/AI ⚡, or Grunt Work 🧊)\n// - Logistics' description mentions a 🚚 + 🗺️ split\n// The classifier only ever prepends one of the `emoji` values below.\n// Say the word if you'd like the energy sub-tags classified and applied\n// too.\n\nexport interface Category {\n name: string;\n emoji: string; // exact emoji character(s) prepended to task content\n description: string;\n}\n\nexport const CATEGORIES: Category[] = [\n {\n name: \"Action\",\n emoji: \"⚒️\",\n description:\n \"The Work. General execution -- the default for a concrete, doable task.\",\n },\n {\n name: \"JIRA\",\n emoji: \"🎟️\",\n description:\n \"Work Tickets. Technical tasks synced from the professional JIRA project.\",\n },\n {\n name: \"Experiments\",\n emoji: \"🧪\",\n description:\n 'Research Lab. Sandbox testing, hypotheses, \"discovery\" coding.',\n },\n {\n name: \"Evaluate\",\n emoji: \"⚖️\",\n // The source spec gave no elaboration beyond the name for this one --\n // filled in with a minimal, literal reading. Tighten this if\n // classification confuses it with Analysis.\n description: \"Weighing options or making a decision between alternatives.\",\n },\n {\n name: \"Analysis\",\n emoji: \"🧐\",\n description:\n \"Deep Dive. Investigative searching, sourcing, documenting complex info.\",\n },\n {\n name: \"Input\",\n emoji: \"📖\",\n description: \"Consumption. Reading articles, books, documentation.\",\n },\n {\n name: \"Output\",\n emoji: \"✍🏼\",\n description: \"Expression. Writing emails, essays, logs, research drafts.\",\n },\n {\n name: \"Sync\",\n emoji: \"📞\",\n description:\n \"Communicate. Meetings, calls, high-priority outbound messages.\",\n },\n {\n name: \"Logistics\",\n emoji: \"🧭\",\n description:\n \"Navigation. Trip planning, reservations, errand coordination.\",\n },\n {\n name: \"Admin\",\n emoji: \"⚙️\",\n description: \"Maintenance. Digital plumbing, backups, file management.\",\n },\n {\n name: \"Framework\",\n emoji: \"🏗️\",\n description:\n \"Architecture. Structural, uncompletable tasks that hold projects together.\",\n },\n {\n name: \"Milestone\",\n emoji: \"⛳\",\n description: \"Objectives. High-level goals or progress markers.\",\n },\n {\n name: \"Seed\",\n emoji: \"🌱\",\n // Added per your message; \"Seed\" is my best-guess name for this one --\n // rename freely if you had a different word in mind.\n description:\n \"Future Projects. An early-stage idea or seed not yet ready to act on.\",\n },\n];\n\nexport const CATEGORY_EMOJIS: Set = new Set(\n CATEGORIES.map((c) => c.emoji),\n);\n\n/** Manually-applied marker for a checklist/reference task -- NOT one of the\n * 13 classification categories, and never written by this automation.\n * A task under a 📋-prefixed ancestor (or prefixed with 📋 itself) is\n * treated as reference material and skipped entirely. */\nexport const CHECKLIST_ROOT_EMOJI = \"📋\";\n\n/** Todoist marks a task uncompletable with a literal \"* \" at the very\n * start of its content. That's formatting, not text, so every prefix\n * check below looks past it -- and anything this automation writes back\n * has to keep it in first position or the task becomes completable. */\nconst UNCOMPLETABLE_PREFIX_RE = /^\\*\\s+/;\n\nexport function stripUncompletablePrefix(content: string): string {\n return content.trimStart().replace(UNCOMPLETABLE_PREFIX_RE, \"\").trimStart();\n}\n\nexport function hasUncompletablePrefix(content: string): boolean {\n return UNCOMPLETABLE_PREFIX_RE.test(content.trimStart());\n}\n\n/** Deliberately matches ANY emoji, not just the category set: a task that\n * already opens with an emoji was labelled by hand (possibly with one\n * outside this list on purpose) and must be left exactly as it is. */\nconst LEADING_EMOJI_RE = /^\\p{Extended_Pictographic}/u;\n\n/** True if `content` already opens with an emoji of any kind -- meaning it\n * is already classified, hand-tagged, or a 📋 reference container, and in\n * all three cases must not be touched. */\nexport function hasEmojiPrefix(content: string): boolean {\n return LEADING_EMOJI_RE.test(stripUncompletablePrefix(content));\n}\n\n/** True if `content` is a 📋 checklist container. */\nexport function isChecklistRoot(content: string): boolean {\n return stripUncompletablePrefix(content).startsWith(CHECKLIST_ROOT_EMOJI);\n}",[],[238],"c91f67eb-557f-40c8-a8ef-d64f491970b0","automation.ts","01a0298e-afc3-751f-bbf5-13b8f526b515",["D",1787405198266],"// automation.ts\n//\n// Automation #1: auto-schedule any task carrying the \"execute 🌥\" label\n// to be due today (before 9 PM Bucharest time) or tomorrow (from 9 PM\n// onward). runAutomationSafely() wraps it behind a blob-backed lock so a\n// webhook firing at the same moment as the cron backup can never double-\n// process the same tasks. (A plain in-memory lock wouldn't be reliable\n// here: unlike a single gunicorn worker, Val Town may run concurrent\n// invocations on separate isolates that don't share memory, so the lock\n// has to live in shared storage instead.)\n//\n// The locking mechanism (withBlobLock) is generalized below so the emoji\n// classification automation (emoji-automation.ts) can reuse it without\n// duplicating the acquire/release/TTL logic -- see that file for the\n// second lock instance.\n//\n// --- Recurrence preservation -------------------------------------------\n//\n// Todoist's `due_date` field always REPLACES `due` with a fixed,\n// non-recurring date -- there's no \"just move the date\" option on it. So\n// naively calling updateTask(id, { due_date }) on a recurring task (e.g.\n// \"every 3 days\", \"every friday at 16:00\") silently strips its\n// recurrence forever.\n//\n// The fix: for recurring tasks, write `due.date` directly via the Sync\n// API's item_update command (updateTaskDueRaw in todoist.ts), leaving\n// `due.string`/`is_recurring`/`timezone`/`lang` untouched. This is exactly\n// what the Todoist UI itself does when you drag a recurring task to\n// \"Today\" -- confirmed by inspecting a real task after doing so: `date`\n// moved, `string` (\"every fri at 4pm\") stayed put, `is_recurring` stayed\n// true. The concrete due date and the recurrence rule are independent\n// fields and are allowed to disagree; only the NLP-string update path\n// (due_string) enforces agreement between them. Since updateTaskDueRaw\n// skips the NLP parser entirely, this works uniformly for both\n// interval-based rules (\"every 3 days\") and day/date-anchored ones\n// (\"every friday at 4pm\") -- unlike an earlier version of this fix that\n// went through due_string, which could not place \"every friday\" on a\n// Wednesday.\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport {\n getTasksByLabel,\n TodoistDue,\n TodoistTask,\n updateTask,\n updateTaskDueRaw,\n} from \"./todoist.ts\";\n\nexport const EXECUTE_LABEL = \"execute 🌥\";\nconst ROLLOVER_HOUR = 21; // 9 PM local time\n\nexport type AutomationResult = Record;\n\n// --- Timezone helpers -------------------------------------------------\n\n/** Returns { year, month, day, hour } for `date`, as observed in Europe/Bucharest. */\nfunction getBucharestParts(date: Date) {\n const fmt = new Intl.DateTimeFormat(\"en-GB\", {\n timeZone: \"Europe/Bucharest\",\n year: \"numeric\",\n month: \"2-digit\",\n day: \"2-digit\",\n hour: \"2-digit\",\n hourCycle: \"h23\",\n });\n const parts = fmt.formatToParts(date);\n const map: Record = {};\n for (const p of parts) map[p.type] = p.value;\n return {\n year: parseInt(map.year, 10),\n month: parseInt(map.month, 10),\n day: parseInt(map.day, 10),\n hour: parseInt(map.hour, 10),\n };\n}\n\nfunction ymdToUtcDate(y: number, m: number, d: number): Date {\n return new Date(Date.UTC(y, m - 1, d));\n}\n\nfunction formatIsoDate(d: Date): string {\n const y = d.getUTCFullYear();\n const m = String(d.getUTCMonth() + 1).padStart(2, \"0\");\n const day = String(d.getUTCDate()).padStart(2, \"0\");\n return `${y}-${m}-${day}`;\n}\n\n/**\n * Returns the date that any task carrying EXECUTE_LABEL should be due on.\n * Before ROLLOVER_HOUR (9 PM) Bucharest time -> today. From ROLLOVER_HOUR\n * onward -> tomorrow. Cron triggers always run in UTC, so this recomputes\n * the real local hour on every call rather than trusting when the caller\n * happened to run -- correct across DST changes with zero extra config.\n */\nexport function getTargetDueDate(now: Date = new Date()): Date {\n const parts = getBucharestParts(now);\n let target = ymdToUtcDate(parts.year, parts.month, parts.day);\n if (parts.hour >= ROLLOVER_HOUR) {\n target = new Date(target.getTime() + 24 * 60 * 60 * 1000);\n }\n return target;\n}\n\nfunction extractDueDateStr(task: TodoistTask): string | null {\n if (!task.due || !task.due.date) return null;\n return task.due.date.split(\"T\")[0];\n}\n\n/**\n * Given a recurring task's existing due.date (e.g. \"2026-08-19\" for an\n * all-day task, or \"2026-08-22T16:00:00\" for a timed one), returns a new\n * due.date on targetDateStr, preserving the original time-of-day (if any)\n * unchanged. Used to move only the concrete due date while due.string /\n * is_recurring are passed through untouched by the caller.\n */\nexport function buildRecurringDueDate(\n originalDueDate: string,\n targetDateStr: string,\n): string {\n const tIndex = originalDueDate.indexOf(\"T\");\n if (tIndex === -1) return targetDateStr;\n const timePart = originalDueDate.slice(tIndex); // e.g. \"T16:00:00\"\n return `${targetDateStr}${timePart}`;\n}\n\n// --- Automation: \"execute 🌥\" auto-scheduling --------------------------\n\nexport async function processExecuteTodayLabel(): Promise {\n const targetDate = getTargetDueDate();\n const targetDateStr = formatIsoDate(targetDate);\n\n let updatedCount = 0;\n let alreadyCorrectCount = 0;\n let errorCount = 0;\n const errors: string[] = [];\n const logLines: string[] = [];\n\n let matchingTasks: TodoistTask[];\n try {\n matchingTasks = await getTasksByLabel(EXECUTE_LABEL);\n } catch (e) {\n console.error(\"Failed to fetch tasks for execute-label processing:\", e);\n return { status: \"error\", message: `Failed to fetch tasks: ${e}` };\n }\n\n for (const task of matchingTasks) {\n const currentDueStr = extractDueDateStr(task);\n if (currentDueStr === targetDateStr) {\n alreadyCorrectCount++;\n continue;\n }\n\n try {\n const isRecurring = task.due?.is_recurring === true;\n let logDetail: string;\n\n if (isRecurring && task.due) {\n const newDate = buildRecurringDueDate(task.due.date, targetDateStr);\n const newDue: TodoistDue = {\n ...task.due,\n date: newDate,\n };\n await updateTaskDueRaw(task.id, newDue);\n logDetail =\n `due.date='${newDate}' (recurrence '${task.due.string}' preserved)`;\n } else {\n await updateTask(task.id, { due_date: targetDateStr });\n logDetail = `due_date=${targetDateStr}`;\n }\n\n updatedCount++;\n const msg = `Task ${task.id} ('${task.content}') updated: ${logDetail}`;\n logLines.push(msg);\n console.log(`[${EXECUTE_LABEL}] ${msg}`);\n } catch (e) {\n errorCount++;\n errors.push(`Failed to update task ${task.id}: ${e}`);\n console.error(`[${EXECUTE_LABEL}] Failed to update task ${task.id}:`, e);\n }\n }\n\n return {\n status: \"success\",\n target_date: targetDateStr,\n found: matchingTasks.length,\n updated: updatedCount,\n already_correct: alreadyCorrectCount,\n failed: errorCount,\n log: logLines,\n errors,\n };\n}\n\n// --- Orchestration ------------------------------------------------------\n\nexport async function runAutomation(): Promise {\n return await processExecuteTodayLabel();\n}\n\n// --- Shared blob-backed lock ---------------------------------------------\n//\n// Generalized so any automation can get the same crash-safe locking\n// without reimplementing it: a plain in-memory lock isn't reliable here\n// since Val Town may run concurrent invocations on isolates that don't\n// share memory. TTL is a stale-lock safety valve for a run that crashes\n// (or gets killed by Val Town's execution timeout) mid-way; 3 minutes\n// gives a comfortable 3x margin over the free plan's 1-minute execution\n// ceiling (see https://www.val.town/limits) while still self-healing\n// quickly if a lock is ever left stuck.\n\nexport interface WithBlobLockOptions {\n lockKey: string;\n ttlMs: number;\n trigger: string;\n run: () => Promise;\n}\n\ninterface LockState {\n lockedAt: number;\n trigger: string;\n}\n\nexport async function withBlobLock(\n { lockKey, ttlMs, trigger, run }: WithBlobLockOptions,\n): Promise {\n const existing = (await blob.getJSON(lockKey)) as LockState | undefined;\n const now = Date.now();\n\n if (existing && now - existing.lockedAt < ttlMs) {\n console.warn(\n `Automation run skipped (lock=${lockKey}, trigger=${trigger}): another run is in progress.`,\n );\n return {\n status: \"skipped\",\n trigger,\n message: \"An automation run was already in progress.\",\n };\n }\n\n await blob.setJSON(lockKey, { lockedAt: now, trigger } satisfies LockState);\n\n try {\n console.log(\n `Automation run started (lock=${lockKey}, trigger=${trigger}).`,\n );\n const result = await run();\n result.trigger = trigger;\n console.log(\n `Automation run finished (lock=${lockKey}, trigger=${trigger}).`,\n );\n return result;\n } catch (e) {\n console.error(\n `Automation run failed unexpectedly (lock=${lockKey}, trigger=${trigger}):`,\n e,\n );\n return { status: \"error\", trigger, message: String(e) };\n } finally {\n await blob.delete(lockKey);\n }\n}\n\nconst LOCK_KEY = \"todoist-processor:automation-lock\";\nconst LOCK_TTL_MS = 3 * 60 * 1000;\n\nexport async function runAutomationSafely(\n trigger: string,\n): Promise {\n return withBlobLock({\n lockKey: LOCK_KEY,\n ttlMs: LOCK_TTL_MS,\n trigger,\n run: runAutomation,\n });\n}",[],[245],["D",1785014870875],{"_11":12,"_124":73},{"_11":12,"_119":120,"_72":73,"_30":71,"_121":122,"_123":24},{"_38":110,"_13":16,"_32":35,"_111":75,"_112":62,"_113":64,"_114":79,"_115":75,"_116":41,"_117":14,"_118":12},"ctx",{"_51":-5,"_144":288,"_289":290,"_291":292,"_293":24,"_294":24,"_295":24,"_296":87,"_297":-5,"_298":-7,"_299":-7,"_300":26,"_301":24,"_302":24,"_303":-5,"_304":24,"_305":24,"_306":24,"_307":-5},"ENV",{"_259":260,"_261":262,"_263":63,"_264":265,"_266":267,"_268":269,"_270":271,"_272":273,"_274":275,"_276":277,"_278":279,"_280":281,"_282":283,"_284":285,"_286":287},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · descriptionParser.ts