@sulala/agent-os 0.1.23 → 0.1.25

package/dist/index.js

@@ -19606,6 +19606,29 @@ function createTokenRequestTool(skillId, toolId, baseUrl, description) {
 init_config();
 var SYSTEM_SKILL_IDS = new Set(["memory"]);
 var DEFAULT_SYSTEM_SKILL_IDS = ["memory", "date", "fetch", "jq", "file-search"];
+var SULALA_META_FILE = ".sulala-meta.json";
+async function readSkillMeta(skillDir, subEntries) {
+  if (!subEntries.includes(SULALA_META_FILE))
+    return null;
+  try {
+    const raw = await readFile5(join6(skillDir, SULALA_META_FILE), "utf-8");
+    const data = JSON.parse(raw);
+    return typeof data.version === "string" && data.version.trim() !== "" ? { version: data.version.trim() } : null;
+  } catch {
+    return null;
+  }
+}
+async function writeSkillMeta(skillId, meta) {
+  const skillDir = join6(getSkillsDir(), skillId);
+  const payload = {};
+  if (meta.version?.trim())
+    payload.version = meta.version.trim();
+  if (meta.source?.trim())
+    payload.source = meta.source.trim();
+  if (Object.keys(payload).length === 0)
+    return;
+  await writeFile3(join6(skillDir, SULALA_META_FILE), JSON.stringify(payload, null, 0), "utf-8");
+}
 async function loadSkill(name) {
   const dir = join6(getSkillsDir(), name);
   let entries;
@@ -19848,10 +19871,14 @@ async function listSkills() {
       continue;
     const skillName = doc.name ?? name;
     const requiredEnv = await getRequiredEnvForSkill(skillDir, subEntries, doc);
+    const docVersion = doc.version?.trim() || undefined;
+    const meta = await readSkillMeta(skillDir, subEntries);
+    const version = docVersion ?? meta?.version;
     results.push({
       id: name,
       name: skillName,
       description: doc.description,
+      version,
       tools: (doc.tools ?? []).map((t) => ({ id: t.id, description: t.description })),
       required_env: requiredEnv.length ? requiredEnv : undefined,
       system: SYSTEM_SKILL_IDS.has(name)
@@ -19921,7 +19948,7 @@ async function installSystemSkills() {
   }
   return { installed };
 }
-async function installSkillFromUrl(url, explicitId) {
+async function installSkillFromUrl(url, explicitId, meta) {
   const urlLower = url.toLowerCase();
   const isStoreSkillContentUrl = urlLower.includes("/api/sulalahub/skills/") && !urlLower.includes("/download") && !urlLower.endsWith(".zip");
   const headers = isStoreSkillContentUrl ? { Accept: "application/zip" } : {};
@@ -19936,31 +19963,35 @@ async function installSkillFromUrl(url, explicitId) {
   const tmpDir = join6(tmpdir(), `agent-os-skill-${Date.now()}`);
   await mkdir3(tmpDir, { recursive: true });
   try {
+    let destId;
     if (isZip) {
       const zipPath = join6(tmpDir, "archive.zip");
       await writeFile3(zipPath, new Uint8Array(buf));
-      const proc2 = Bun.spawn({ cmd: ["unzip", "-q", "-o", zipPath, "-d", tmpDir], stdout: "ignore", stderr: "pipe" });
-      const exit2 = await proc2.exited;
-      if (exit2 !== 0) {
-        const err = await new Response(proc2.stderr).text();
+      const proc = Bun.spawn({ cmd: ["unzip", "-q", "-o", zipPath, "-d", tmpDir], stdout: "ignore", stderr: "pipe" });
+      const exit = await proc.exited;
+      if (exit !== 0) {
+        const err = await new Response(proc.stderr).text();
         throw new Error(`unzip failed: ${err}`);
       }
-      const { id: id2, sourcePath: sourcePath2 } = await chooseSkillRootFromExtract(tmpDir, "archive.zip");
-      const destId2 = explicitId != null && explicitId.trim() !== "" ? slugToSkillId(explicitId) : id2;
-      await cp(sourcePath2, join6(skillsDir, destId2), { recursive: true });
-      return { id: destId2 };
-    }
-    const tarPath = join6(tmpDir, "archive.tar.gz");
-    await writeFile3(tarPath, new Uint8Array(buf));
-    const proc = Bun.spawn({ cmd: ["tar", "-xzf", tarPath, "-C", tmpDir], stdout: "ignore", stderr: "pipe" });
-    const exit = await proc.exited;
-    if (exit !== 0) {
-      const err = await new Response(proc.stderr).text();
-      throw new Error(`tar extract failed: ${err}`);
-    }
-    const { id, sourcePath } = await chooseSkillRootFromExtract(tmpDir, "archive.tar.gz");
-    const destId = explicitId != null && explicitId.trim() !== "" ? slugToSkillId(explicitId) : id;
-    await cp(sourcePath, join6(skillsDir, destId), { recursive: true });
+      const { id, sourcePath } = await chooseSkillRootFromExtract(tmpDir, "archive.zip");
+      destId = explicitId != null && explicitId.trim() !== "" ? slugToSkillId(explicitId) : id;
+      await cp(sourcePath, join6(skillsDir, destId), { recursive: true });
+    } else {
+      const tarPath = join6(tmpDir, "archive.tar.gz");
+      await writeFile3(tarPath, new Uint8Array(buf));
+      const proc = Bun.spawn({ cmd: ["tar", "-xzf", tarPath, "-C", tmpDir], stdout: "ignore", stderr: "pipe" });
+      const exit = await proc.exited;
+      if (exit !== 0) {
+        const err = await new Response(proc.stderr).text();
+        throw new Error(`tar extract failed: ${err}`);
+      }
+      const { id, sourcePath } = await chooseSkillRootFromExtract(tmpDir, "archive.tar.gz");
+      destId = explicitId != null && explicitId.trim() !== "" ? slugToSkillId(explicitId) : id;
+      await cp(sourcePath, join6(skillsDir, destId), { recursive: true });
+    }
+    if (meta?.version?.trim() || meta?.source?.trim()) {
+      await writeSkillMeta(destId, { version: meta.version, source: meta.source ?? (explicitId ? "hub" : undefined) });
+    }
     return { id: destId };
   } finally {
     await rm(tmpDir, { recursive: true, force: true });
@@ -26537,8 +26568,8 @@ function formatLLMErrorForUser(err) {
 }
 function runAgentInner(options) {
   return (async () => {
-    const { task, agent, conversationHistory = [] } = options;
-    const maxTurns = agent.limits?.max_turns ?? 10;
+    const { task, agent, conversationHistory = [], maxTurnsOverride } = options;
+    const maxTurns = maxTurnsOverride ?? agent.limits?.max_turns ?? 10;
     const maxTokens = agent.limits?.max_tokens;
     await ensureWorkspace(agent.id);
     await loadSkillsForAgent(agent);
@@ -26772,8 +26803,8 @@ async function runAgent(options) {
   return runAgentInner(options);
 }
 async function runAgentStream(options, onEvent) {
-  const { task, agent, conversationHistory = [] } = options;
-  const maxTurns = agent.limits?.max_turns ?? 10;
+  const { task, agent, conversationHistory = [], maxTurnsOverride } = options;
+  const maxTurns = maxTurnsOverride ?? agent.limits?.max_turns ?? 10;
   const maxTokens = agent.limits?.max_tokens;
   await ensureWorkspace(agent.id);
   await loadSkillsForAgent(agent);
@@ -27214,45 +27245,88 @@ import { readFile as readFile8, appendFile as appendFile2, mkdir as mkdir6 } fro
 import { join as join10 } from "path";
 
 // src/core/graphs.ts
-import { readFile as readFile7, readdir as readdir4, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { readFile as readFile7, readdir as readdir4, writeFile as writeFile4, mkdir as mkdir5, copyFile, unlink as unlink2 } from "fs/promises";
 import { join as join9 } from "path";
+import { existsSync as existsSync3 } from "fs";
 var DEFAULT_GRAPHS_DIR = join9(process.env.HOME || process.env.USERPROFILE || "~", ".agent-os", "graphs");
 function getGraphsDir() {
   return process.env.AGENT_OS_GRAPHS_DIR || DEFAULT_GRAPHS_DIR;
 }
+function getSeedGraphsDir() {
+  if (process.env.AGENT_OS_SEED_GRAPHS_DIR)
+    return process.env.AGENT_OS_SEED_GRAPHS_DIR;
+  const fromDist = join9(import.meta.dir, "..", "data", "graphs");
+  const fromSrc = join9(import.meta.dir, "..", "..", "data", "graphs");
+  if (existsSync3(fromDist))
+    return fromDist;
+  if (existsSync3(fromSrc))
+    return fromSrc;
+  return join9(process.cwd(), "data", "graphs");
+}
 async function listGraphs() {
   const dir = getGraphsDir();
+  let entries;
   try {
-    const entries = await readdir4(dir);
-    const summaries = [];
-    for (const name of entries) {
-      if (name.endsWith(".json")) {
-        const id = name.replace(/\.graph\.json$/, "").replace(/\.json$/, "");
-        if (id)
-          summaries.push({ id });
+    entries = await readdir4(dir);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+    entries = [];
+  }
+  if (entries.length === 0) {
+    const seedDir = getSeedGraphsDir();
+    try {
+      const seedEntries = await readdir4(seedDir);
+      await mkdir5(dir, { recursive: true });
+      for (const name of seedEntries) {
+        if (name.endsWith(".json")) {
+          await copyFile(join9(seedDir, name), join9(dir, name));
+        }
       }
+      entries = await readdir4(dir);
+    } catch {}
+  }
+  const summaries = [];
+  for (const name of entries) {
+    if (name.endsWith(".json")) {
+      const id = name.replace(/\.graph\.json$/, "").replace(/\.json$/, "");
+      if (id)
+        summaries.push({ id });
     }
-    return summaries;
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return [];
-    throw err;
   }
+  return summaries;
 }
 async function loadGraph(id) {
   const dir = getGraphsDir();
   try {
-    const entries = await readdir4(dir);
+    let entries;
+    try {
+      entries = await readdir4(dir);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      entries = [];
+    }
     const file = entries.find((name) => name === `${id}.json` || name === `${id}.graph.json`);
-    if (!file)
+    if (file) {
+      const raw = await readFile7(join9(dir, file), "utf-8");
+      const parsed = JSON.parse(raw);
+      validateGraph(parsed);
+      return parsed;
+    }
+    const seedDir = getSeedGraphsDir();
+    const seedFile = `${id}.json`;
+    try {
+      const raw = await readFile7(join9(seedDir, seedFile), "utf-8");
+      const parsed = JSON.parse(raw);
+      validateGraph(parsed);
+      await mkdir5(dir, { recursive: true });
+      await writeFile4(join9(dir, seedFile), raw, "utf-8");
+      return parsed;
+    } catch {
       return null;
-    const raw = await readFile7(join9(dir, file), "utf-8");
-    const parsed = JSON.parse(raw);
-    validateGraph(parsed);
-    return parsed;
+    }
   } catch (err) {
-    if (err.code === "ENOENT")
-      return null;
     console.error("[graphs] Failed to load graph:", err);
     return null;
   }
@@ -27264,6 +27338,22 @@ async function saveGraph(graph) {
   const path = join9(dir, `${graph.id}.json`);
   await writeFile4(path, JSON.stringify(graph, null, 2), "utf-8");
 }
+async function deleteGraph(id) {
+  if (!id || typeof id !== "string")
+    throw new Error("Graph id required");
+  const dir = getGraphsDir();
+  let entries;
+  try {
+    entries = await readdir4(dir);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+    return;
+  }
+  const file = entries.find((name) => name === `${id}.json` || name === `${id}.graph.json`);
+  if (file)
+    await unlink2(join9(dir, file));
+}
 function validateGraph(graph) {
   if (!graph || typeof graph !== "object") {
     throw new Error("Graph must be an object");
@@ -27278,6 +27368,7 @@ function validateGraph(graph) {
     throw new Error("Graph.edges must be an array");
   }
 }
+var DEFAULT_GRAPH_MAX_TURNS_PER_NODE = 5;
 function topologicalLevels(graph) {
   const nodes = graph.nodes.map((n) => n.id);
   const incoming = new Map;
@@ -27330,7 +27421,7 @@ function getPredecessors(graph) {
   return pred;
 }
 async function runGraph(options) {
-  const { graph, input } = options;
+  const { graph, input, max_turns_per_node = DEFAULT_GRAPH_MAX_TURNS_PER_NODE } = options;
   const levels = topologicalLevels(graph);
   const predecessors = getPredecessors(graph);
   const outputs = new Map;
@@ -27355,7 +27446,11 @@ async function runGraph(options) {
       const taskInput = preds.length === 0 ? input : preds.map((p) => outputs.get(p) ?? "").filter(Boolean).join(`
 
 `) || input;
-      const result = await runAgent({ agent, task: taskInput });
+      const result = await runAgent({
+        agent,
+        task: taskInput,
+        maxTurnsOverride: max_turns_per_node
+      });
       outputs.set(node.id, result.output || "");
       return {
         node_id: node.id,
@@ -27378,7 +27473,7 @@ async function runGraph(options) {
   };
 }
 async function runGraphStream(options, onEvent) {
-  const { graph, input } = options;
+  const { graph, input, max_turns_per_node = DEFAULT_GRAPH_MAX_TURNS_PER_NODE } = options;
   const levels = topologicalLevels(graph);
   const predecessors = getPredecessors(graph);
   const outputs = new Map;
@@ -27404,7 +27499,11 @@ async function runGraphStream(options, onEvent) {
         const taskInput = preds.length === 0 ? input : preds.map((p) => outputs.get(p) ?? "").filter(Boolean).join(`
 
 `) || input;
-        const result = await runAgent({ agent, task: taskInput });
+        const result = await runAgent({
+          agent,
+          task: taskInput,
+          maxTurnsOverride: max_turns_per_node
+        });
         outputs.set(node.id, result.output || "");
         const payload = {
           node_id: node.id,
@@ -27858,8 +27957,10 @@ async function handleSkillInstall(req) {
     return jsonResponse({ error: "Provide path or url" }, 400);
   }
   const slug = typeof body.slug === "string" && body.slug.trim() !== "" ? body.slug.trim() : undefined;
+  const version2 = typeof body.version === "string" && body.version.trim() !== "" ? body.version.trim() : undefined;
+  const meta = version2 || slug ? { version: version2, source: slug ? "hub" : undefined } : undefined;
   try {
-    const result = hasPath ? await installSkillFromPath(body.path.trim()) : await installSkillFromUrl(body.url.trim(), slug);
+    const result = hasPath ? await installSkillFromPath(body.path.trim()) : await installSkillFromUrl(body.url.trim(), slug, meta);
     return jsonResponse({ skill: result }, 201);
   } catch (err) {
     const msg = errorMessage(err);
@@ -29099,14 +29200,14 @@ async function loadPlugins() {
 // src/server.ts
 init_config();
 import { join as join13, dirname as dirname2, resolve as resolve4 } from "path";
-import { mkdirSync, existsSync as existsSync3 } from "fs";
+import { mkdirSync, existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir7 } from "fs/promises";
 var PORT = parseInt(process.env.PORT ?? "3010", 10);
 var DASHBOARD_DIST = (() => {
   const root = join13(import.meta.dir, "..");
   const a = resolve4(join13(root, "dashboard-dist"));
   const b = resolve4(join13(root, "dashboard", "dist"));
-  if (existsSync3(a) && existsSync3(join13(a, "index.html")))
+  if (existsSync4(a) && existsSync4(join13(a, "index.html")))
     return a;
   return b;
 })();
@@ -29198,7 +29299,7 @@ function broadcastEvent(event) {
   }
 }
 function serveDashboard(pathname) {
-  if (!existsSync3(DASHBOARD_DIST) || !existsSync3(join13(DASHBOARD_DIST, "index.html"))) {
+  if (!existsSync4(DASHBOARD_DIST) || !existsSync4(join13(DASHBOARD_DIST, "index.html"))) {
     return null;
   }
   const decoded = decodeURIComponent(pathname);
@@ -29207,7 +29308,7 @@ function serveDashboard(pathname) {
   }
   const subpath = decoded === "/" ? "index.html" : decoded.slice(1);
   const filePath = join13(DASHBOARD_DIST, subpath);
-  if (existsSync3(filePath)) {
+  if (existsSync4(filePath)) {
     const file = Bun.file(filePath);
     const ext = subpath.split(".").pop() ?? "";
     const mime = {
@@ -29228,7 +29329,7 @@ function serveDashboard(pathname) {
     });
   }
   const indexPath = join13(DASHBOARD_DIST, "index.html");
-  if (existsSync3(indexPath)) {
+  if (existsSync4(indexPath)) {
     return new Response(Bun.file(indexPath), {
       headers: { "Content-Type": "text/html" }
     });
@@ -29448,6 +29549,16 @@ function createRoutes() {
           const msg = e instanceof Error ? e.message : String(e);
           return jsonResponse({ error: msg }, 400);
         }
+      },
+      DELETE: async (req) => {
+        const id = decodeURIComponent(req.params.id);
+        try {
+          await deleteGraph(id);
+          return Response.json({ ok: true }, { headers: CORS_HEADERS });
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          return jsonResponse({ error: msg }, 400);
+        }
       }
     },
     "/api/memory/write": {
@@ -29668,7 +29779,7 @@ async function startServer() {
   await loadPlugins();
   await seedAgentsIfEmpty();
   const dashboardSecret = await getDashboardSecret();
-  const dashboardMissing = !existsSync3(DASHBOARD_DIST) || !existsSync3(join13(DASHBOARD_DIST, "index.html"));
+  const dashboardMissing = !existsSync4(DASHBOARD_DIST) || !existsSync4(join13(DASHBOARD_DIST, "index.html"));
   if (dashboardMissing) {
     console.warn(`[sulala] Dashboard not found at ${DASHBOARD_DIST}. From package root run: cd dashboard && npm run build. If using a global install, reinstall: bun install -g @sulala/agent-os@latest`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sulala/agent-os",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "publishConfig": {
     "access": "public"
   },

package/data/skills/gmail/SKILL.md

@@ -1,55 +0,0 @@
----
-name: gmail
-description: Send email via Gmail using your connected account. Uses Sulala Portal for the access token; includes a script to send email from the command line or automation. Requires the Sulala Portal skill for token. Use when the user wants to send email, compose mail, or automate Gmail sending.
-metadata:
-  sulala:
-    requires:
-      skills:
-        - sulala-portal
----
-
-# Gmail (Sulala Portal)
-
-Send email using your **Gmail account connected in the Sulala Portal**. This skill provides a **script**; use the **exec** tool to run it. No static send-email code in the loader; the skill is script + docs like YouTube Shorts automation.
-
-## Overview
-
-1. **Get an access token** from the Portal (list connections, then `POST connections/{connection_id}/use` for Gmail).
-2. **Send email** by running the script via **exec** (see below).
-
-## Getting the token (Portal)
-
-- **Tool**: `sulala-portal_request`
-- **List connections**: `GET` path `connections` (filter by `provider === "gmail"` in the response).
-- **Get token**: `POST` path `connections/{id}/use`. Use the connection’s `connection_id` from the list (e.g. `conn_gmail_...`). If you get 404, use `connection_id` in the path instead of `id`. Response: `{ connectionId, provider, accessToken, scopes }`.
-
-## Sending email (use exec tool + script — preferred)
-
-Use the **exec** tool to run the skill script. No need to build RFC 2822 or base64url by hand.
-
-1. Get **accessToken** from the Portal (`sulala-portal_request`: list connections, then `POST connections/{connection_id}/use` with the Gmail connection’s `connection_id`).
-2. Call **exec** with:
-   - **skill_id**: `"gmail"` (so the command runs in this skill’s directory).
-   - **command**: `python3 scripts/send_email.py --token "<accessToken>" --to "recipient@example.com" --subject "Subject line" --body "Email body text."`
-
-Example exec call:
-
-```json
-{
-  "skill_id": "gmail",
-  "command": "python3 scripts/send_email.py --token \"<paste accessToken from Portal>\" --to \"sai.ko@mothernode.com\" --subject \"test title\" --body \"test body\""
-}
-```
-
-- **Token**: from `POST connections/{connection_id}/use` (see above).
-- **To**, **Subject**, **Body**: recipient email, subject line, and body text. Escape quotes inside the command string as needed.
-
-Full script options: [references/send-email.md](references/send-email.md).
-
-## Skill layout (like YouTube Shorts automation)
-
-- **scripts/send_email.py** — runnable script: `--token`, `--to`, `--subject`, `--body` or `--body-file`.
-- **references/send-email.md** — how to run the script and get the token.
-- **SKILL.md** — this file: overview, get token, send via exec + script.
-
-No separate config: the Sulala Portal skill provides the gateway and token; this skill adds the script and docs.

package/data/skills/gmail/references/send-email.md

@@ -1,54 +0,0 @@
-# Send email script
-
-The Gmail skill includes a script that sends email using the Gmail API with an OAuth2 access token. Use it when you have a token (e.g. from Sulala Portal) and want to send from the command line or from automation.
-
-## Prerequisites
-
-- **Access token**: Obtain from Sulala Portal (`POST connections/{connection_id}/use` with your Gmail connection), or from your own OAuth flow. Token must have `https://www.googleapis.com/auth/gmail.send` scope.
-- **Python 3.6+**: No extra pip packages; script uses only the standard library.
-
-## Usage
-
-From the skill directory (or with paths adjusted):
-
-```bash
-python3 scripts/send_email.py \
-  --token "YOUR_ACCESS_TOKEN" \
-  --to "recipient@example.com" \
-  --subject "Subject line" \
-  --body "Email body text."
-```
-
-With body from a file:
-
-```bash
-python3 scripts/send_email.py \
-  --token "YOUR_ACCESS_TOKEN" \
-  --to "recipient@example.com" \
-  --subject "Subject" \
-  --body-file path/to/body.txt
-```
-
-## Options
-
-| Option       | Required | Description                          |
-|-------------|----------|--------------------------------------|
-| `--token`   | Yes      | OAuth2 access token (Bearer).        |
-| `--to`      | Yes      | Recipient email address.             |
-| `--subject` | Yes      | Email subject line.                  |
-| `--body`    | One of   | Email body as a string.              |
-| `--body-file` | One of | Path to file containing body text.  |
-
-## Getting the token (Sulala Portal)
-
-1. Call the Portal API to list connections: `GET connections` (filter for `provider === "gmail"`).
-2. Call `POST connections/{connection_id}/use` with the Gmail connection’s `connection_id` (e.g. `conn_gmail_...`; use `connection_id` if `id` returns 404).
-3. Use the `accessToken` from the response as `--token`.
-
-## Troubleshooting
-
-| Problem              | Cause                    | Action                          |
-|----------------------|--------------------------|---------------------------------|
-| 401 Unauthorized      | Token expired or invalid | Refresh or re-issue token.      |
-| Recipient required   | Missing/invalid To       | Ensure `--to` is a valid email. |
-| Invalid To header    | Bad To format            | Use plain email, no extra text. |

package/data/skills/gmail/scripts/send_email.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""Send email via Gmail API using an OAuth access token.
-
-Use when you have a token from Sulala Portal (connections/:id/use) or another source.
-No local OAuth files required; pass the token on the command line.
-
-Usage:
-  python3 send_email.py --token TOKEN --to recipient@example.com --subject "Subject" --body "Body text"
-  python3 send_email.py --token TOKEN --to recipient@example.com --subject "Subject" --body-file body.txt
-
-Requires: Python 3.6+. No extra pip packages (uses urllib and base64 from stdlib).
-"""
-
-import argparse
-import base64
-import json
-import sys
-import urllib.request
-import urllib.error
-
-GMAIL_SEND_URL = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
-
-
-def base64url_encode(data: bytes) -> str:
-    """Encode bytes to base64url (RFC 4648): no +/ padding, use -_."""
-    b64 = base64.b64encode(data).decode("ascii")
-    return b64.replace("+", "-").replace("/", "_").rstrip("=")
-
-
-def build_rfc2822(to: str, subject: str, body: str) -> str:
-    """Build a minimal RFC 2822 message (CRLF line endings)."""
-    lines = [
-        f"To: {to}",
-        f"Subject: {subject}",
-        "Content-Type: text/plain; charset=UTF-8",
-        "",
-        body,
-    ]
-    return "\r\n".join(lines)
-
-
-def send(token: str, to: str, subject: str, body: str) -> None:
-    rfc2822 = build_rfc2822(to, subject, body)
-    raw = base64url_encode(rfc2822.encode("utf-8"))
-    body_json = json.dumps({"raw": raw}).encode("utf-8")
-
-    req = urllib.request.Request(
-        GMAIL_SEND_URL,
-        data=body_json,
-        headers={
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json",
-        },
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req) as resp:
-            if resp.status != 200:
-                sys.stderr.write(f"Unexpected status: {resp.status}\n")
-                sys.exit(1)
-            print("Email sent successfully.")
-    except urllib.error.HTTPError as e:
-        sys.stderr.write(f"Gmail API error: {e.code} {e.reason}\n")
-        if e.fp:
-            body = e.fp.read().decode("utf-8", errors="replace")
-            sys.stderr.write(body)
-            sys.stderr.write("\n")
-        sys.exit(1)
-    except OSError as e:
-        sys.stderr.write(f"Request failed: {e}\n")
-        sys.exit(1)
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description="Send email via Gmail API with an access token.")
-    ap.add_argument("--token", required=True, help="OAuth2 access token (e.g. from Sulala Portal)")
-    ap.add_argument("--to", required=True, help="Recipient email address")
-    ap.add_argument("--subject", required=True, help="Email subject")
-    group = ap.add_mutually_exclusive_group(required=True)
-    group.add_argument("--body", help="Email body (plain text)")
-    group.add_argument("--body-file", help="Path to file containing email body")
-    args = ap.parse_args()
-
-    if args.body is not None:
-        body = args.body
-    else:
-        with open(args.body_file, "r", encoding="utf-8") as f:
-            body = f.read()
-
-    send(args.token, args.to, args.subject, body)
-
-
-if __name__ == "__main__":
-    main()