zubo 0.1.0

package/src/tools/builtin-integrations/github/github_repos/handler.ts

@@ -0,0 +1,88 @@
+async function safeApiError(res: Response, service: string): Promise<string> {
+  const body = await res.text().catch(() => "");
+  console.error(`[${service}] API error ${res.status}: ${body.slice(0, 500)}`);
+  return JSON.stringify({ error: `${service} API error: ${res.status} ${res.statusText}` });
+}
+
+function safeExceptionError(err: any, service: string): string {
+  console.error(`[${service}] Request failed: ${err.message}`);
+  return JSON.stringify({ error: `${service} request failed. Check logs for details.` });
+}
+
+const API = "https://api.github.com";
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const token = (globalThis as any).Zubo?.getSecret?.("github_token");
+  if (!token) {
+    return JSON.stringify({
+      error: "GitHub token not configured. Use secret_set to store a 'github_token' or connect_service to set up GitHub.",
+    });
+  }
+
+  const { action, owner, repo, type, sort } = input as {
+    action: string;
+    owner?: string;
+    repo?: string;
+    type?: string;
+    sort?: string;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "User-Agent": "Zubo-Agent",
+  };
+
+  try {
+    switch (action) {
+      case "list": {
+        const endpoint = owner ? `${API}/users/${owner}/repos` : `${API}/user/repos`;
+        const qs = new URLSearchParams({
+          type: type || "owner",
+          sort: sort || "updated",
+          per_page: "30",
+        });
+        const res = await fetch(`${endpoint}?${qs}`, { headers });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const repos = (await res.json()) as any[];
+        return JSON.stringify(
+          repos.map((r) => ({
+            full_name: r.full_name,
+            description: r.description,
+            language: r.language,
+            stars: r.stargazers_count,
+            forks: r.forks_count,
+            private: r.private,
+            updated_at: r.updated_at,
+            url: r.html_url,
+          }))
+        );
+      }
+
+      case "get": {
+        if (!owner || !repo) return JSON.stringify({ error: "owner and repo are required for get" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}`, { headers });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const r = (await res.json()) as any;
+        return JSON.stringify({
+          full_name: r.full_name,
+          description: r.description,
+          language: r.language,
+          stars: r.stargazers_count,
+          forks: r.forks_count,
+          open_issues: r.open_issues_count,
+          private: r.private,
+          default_branch: r.default_branch,
+          created_at: r.created_at,
+          updated_at: r.updated_at,
+          url: r.html_url,
+        });
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "GitHub");
+  }
+}

package/src/tools/builtin-integrations/google/gmail/SKILL.md

@@ -0,0 +1,51 @@
+# gmail
+
+Manage Gmail: list, read, send, search, and reply to emails. Requires Google OAuth 2.0 connection (use google_oauth tool to connect).
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["list", "read", "send", "search", "reply"],
+      "description": "Action to perform"
+    },
+    "message_id": {
+      "type": "string",
+      "description": "Message ID (for read and reply)"
+    },
+    "to": {
+      "type": "string",
+      "description": "Recipient email (for send)"
+    },
+    "subject": {
+      "type": "string",
+      "description": "Email subject (for send)"
+    },
+    "body": {
+      "type": "string",
+      "description": "Email body (for send and reply)"
+    },
+    "query": {
+      "type": "string",
+      "description": "Search query (for search)"
+    },
+    "max_results": {
+      "type": "number",
+      "description": "Max results (default 10)"
+    }
+  },
+  "required": ["action"]
+}
+```
+
+## Usage Hints
+
+- Use "list" to see recent emails.
+- Use "read" with message_id to view full email content.
+- Use "send" with to, subject, and body to send an email.
+- Use "search" with Gmail search query syntax.
+- Use "reply" with message_id and body to reply.

package/src/tools/builtin-integrations/google/gmail/handler.ts

@@ -0,0 +1,125 @@
+const API = "https://gmail.googleapis.com/gmail/v1/users/me";
+
+async function getToken(): Promise<string> {
+  const Zubo = (globalThis as any).Zubo;
+  if (Zubo?.getGoogleToken) return Zubo.getGoogleToken();
+  throw new Error("Google is NOT connected. Use google_oauth with action 'start' to set up Google.");
+}
+
+async function safeApiErr(res: Response, service: string): Promise<string> {
+  const body = await res.text().catch(() => "");
+  console.error(`[${service}] API error ${res.status}: ${body.slice(0, 500)}`);
+  // Parse Google error for actionable info
+  let hint = "";
+  if (res.status === 403) {
+    if (body.includes("Gmail API has not been used") || body.includes("accessNotConfigured")) {
+      hint = " The Gmail API is not enabled in your Google Cloud Console. Go to console.cloud.google.com > APIs & Services > Library > search 'Gmail API' > Enable it.";
+    } else if (body.includes("insufficientPermissions") || body.includes("Insufficient Permission")) {
+      hint = " The access token does not have Gmail permissions. You may need to disconnect and reconnect Google (use google_oauth action 'disconnect' then 'start') to re-authorize with Gmail scope.";
+    }
+  }
+  return JSON.stringify({ error: `${service} API error: ${res.status} ${res.statusText}.${hint}` });
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  let token: string;
+  try {
+    token = await getToken();
+  } catch (err: any) {
+    return JSON.stringify({
+      error: err.message,
+      action_required: "Google is NOT connected. The user needs to complete the OAuth 2.0 flow. " +
+        "Ask the user for their Google OAuth client_id (ends with .apps.googleusercontent.com) " +
+        "and client_secret (starts with GOCSPX-), then use google_oauth tool with action 'start'.",
+    });
+  }
+
+  const { action, message_id, to, subject, body, query, max_results } = input as {
+    action: string; message_id?: string; to?: string; subject?: string;
+    body?: string; query?: string; max_results?: number;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+  };
+
+  try {
+    switch (action) {
+      case "list": {
+        const res = await fetch(`${API}/messages?maxResults=${max_results || 10}`, { headers });
+        if (!res.ok) return await safeApiErr(res, "Gmail");
+        const data = (await res.json()) as any;
+        const summaries = [];
+        for (const msg of (data.messages || []).slice(0, 10)) {
+          const detail = await fetch(`${API}/messages/${msg.id}?format=metadata&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=Date`, { headers });
+          if (detail.ok) {
+            const d = (await detail.json()) as any;
+            const getHeader = (name: string) => d.payload?.headers?.find((h: any) => h.name === name)?.value ?? "";
+            summaries.push({ id: msg.id, subject: getHeader("Subject"), from: getHeader("From"), date: getHeader("Date"), snippet: d.snippet });
+          }
+        }
+        return JSON.stringify(summaries);
+      }
+      case "read": {
+        if (!message_id) return JSON.stringify({ error: "message_id required" });
+        const res = await fetch(`${API}/messages/${message_id}?format=full`, { headers });
+        if (!res.ok) return await safeApiErr(res, "Gmail");
+        const data = (await res.json()) as any;
+        const getHeader = (name: string) => data.payload?.headers?.find((h: any) => h.name === name)?.value ?? "";
+        let emailBody = data.snippet || "";
+        const parts = data.payload?.parts || [data.payload];
+        for (const part of parts) {
+          if (part?.mimeType === "text/plain" && part?.body?.data) {
+            emailBody = Buffer.from(part.body.data, "base64url").toString("utf-8");
+            break;
+          }
+        }
+        return JSON.stringify({ id: data.id, subject: getHeader("Subject"), from: getHeader("From"), date: getHeader("Date"), body: emailBody });
+      }
+      case "send": {
+        if (!to) return JSON.stringify({ error: "to is required" });
+        if (!subject) return JSON.stringify({ error: "subject is required" });
+        const raw = Buffer.from(`To: ${to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body || ""}`).toString("base64url");
+        const res = await fetch(`${API}/messages/send`, {
+          method: "POST", headers,
+          body: JSON.stringify({ raw }),
+        });
+        if (!res.ok) return await safeApiErr(res, "Gmail");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ sent: true, id: data.id });
+      }
+      case "search": {
+        if (!query) return JSON.stringify({ error: "query is required" });
+        const res = await fetch(`${API}/messages?q=${encodeURIComponent(query)}&maxResults=${max_results || 10}`, { headers });
+        if (!res.ok) return await safeApiErr(res, "Gmail");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ resultCount: data.resultSizeEstimate, messages: data.messages?.map((m: any) => m.id) ?? [] });
+      }
+      case "reply": {
+        if (!message_id) return JSON.stringify({ error: "message_id required" });
+        if (!body) return JSON.stringify({ error: "body required" });
+        const orig = await fetch(`${API}/messages/${message_id}?format=metadata&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=Message-ID`, { headers });
+        if (!orig.ok) return await safeApiErr(orig, "Gmail");
+        const origData = (await orig.json()) as any;
+        const getHeader = (name: string) => origData.payload?.headers?.find((h: any) => h.name === name)?.value ?? "";
+        const replyTo = getHeader("From");
+        const subj = getHeader("Subject").startsWith("Re:") ? getHeader("Subject") : `Re: ${getHeader("Subject")}`;
+        const msgId = getHeader("Message-ID");
+        const raw = Buffer.from(`To: ${replyTo}\r\nSubject: ${subj}\r\nIn-Reply-To: ${msgId}\r\nReferences: ${msgId}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body}`).toString("base64url");
+        const res = await fetch(`${API}/messages/send`, {
+          method: "POST", headers,
+          body: JSON.stringify({ raw, threadId: origData.threadId }),
+        });
+        if (!res.ok) return await safeApiErr(res, "Gmail");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ replied: true, id: data.id });
+      }
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    console.error(`[Gmail] Request failed: ${err.message}`);
+    return JSON.stringify({ error: "Gmail request failed. Check logs for details." });
+  }
+}

package/src/tools/builtin-integrations/google/google_calendar/SKILL.md

@@ -0,0 +1,35 @@
+# google_calendar
+
+Manage Google Calendar events: list, create, get, update, delete. Requires a Google Calendar token stored as `google_calendar_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["list", "create", "get", "update", "delete"],
+      "description": "Action to perform"
+    },
+    "event_id": { "type": "string", "description": "Event ID (for get, update, delete)" },
+    "summary": { "type": "string", "description": "Event title" },
+    "description": { "type": "string", "description": "Event description" },
+    "start": { "type": "string", "description": "Start datetime (ISO 8601)" },
+    "end": { "type": "string", "description": "End datetime (ISO 8601)" },
+    "time_min": { "type": "string", "description": "Filter start (ISO 8601, for list)" },
+    "time_max": { "type": "string", "description": "Filter end (ISO 8601, for list)" },
+    "calendar_id": { "type": "string", "description": "Calendar ID (default: primary)" }
+  },
+  "required": ["action"]
+}
+```
+
+## Usage Hints
+
+- Use "list" to see upcoming events. Defaults to next 7 days.
+- Use "create" with summary, start, and end to create an event.
+- Use "get" with event_id to see event details.
+- Use "update" with event_id and fields to modify.
+- Use "delete" with event_id to remove an event.

package/src/tools/builtin-integrations/google/google_calendar/handler.ts

@@ -0,0 +1,105 @@
+const API = "https://www.googleapis.com/calendar/v3";
+
+async function getToken(): Promise<string> {
+  const Zubo = (globalThis as any).Zubo;
+  if (Zubo?.getGoogleToken) return Zubo.getGoogleToken();
+  throw new Error("Google is NOT connected. Use google_oauth with action 'start' to set up Google.");
+}
+
+function safeApiErr(status: number, statusText: string, service: string): string {
+  return JSON.stringify({ error: `${service} API error: ${status} ${statusText}` });
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  let token: string;
+  try {
+    token = await getToken();
+  } catch (err: any) {
+    return JSON.stringify({
+      error: err.message,
+      action_required: "Google is NOT connected. The user needs to complete the OAuth 2.0 flow. " +
+        "Ask the user for their Google OAuth client_id (ends with .apps.googleusercontent.com) " +
+        "and client_secret (starts with GOCSPX-), then use google_oauth tool with action 'start'.",
+    });
+  }
+
+  const { action, event_id, summary, description, start, end, time_min, time_max, calendar_id } = input as {
+    action: string; event_id?: string; summary?: string; description?: string;
+    start?: string; end?: string; time_min?: string; time_max?: string; calendar_id?: string;
+  };
+
+  const calId = calendar_id || "primary";
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+  };
+
+  try {
+    switch (action) {
+      case "list": {
+        const now = new Date();
+        const tMin = time_min || now.toISOString();
+        const tMax = time_max || new Date(now.getTime() + 7 * 86400_000).toISOString();
+        const qs = `timeMin=${encodeURIComponent(tMin)}&timeMax=${encodeURIComponent(tMax)}&singleEvents=true&orderBy=startTime&maxResults=20`;
+        const res = await fetch(`${API}/calendars/${calId}/events?${qs}`, { headers });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Calendar");
+        const data = (await res.json()) as any;
+        return JSON.stringify(data.items?.map((e: any) => ({
+          id: e.id, summary: e.summary, start: e.start?.dateTime || e.start?.date,
+          end: e.end?.dateTime || e.end?.date, status: e.status,
+        })) ?? []);
+      }
+      case "create": {
+        if (!summary) return JSON.stringify({ error: "summary required" });
+        if (!start || !end) return JSON.stringify({ error: "start and end required" });
+        const res = await fetch(`${API}/calendars/${calId}/events`, {
+          method: "POST", headers,
+          body: JSON.stringify({
+            summary, description: description || "",
+            start: { dateTime: start }, end: { dateTime: end },
+          }),
+        });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Calendar");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ created: true, id: data.id, summary: data.summary, htmlLink: data.htmlLink });
+      }
+      case "get": {
+        if (!event_id) return JSON.stringify({ error: "event_id required" });
+        const res = await fetch(`${API}/calendars/${calId}/events/${event_id}`, { headers });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Calendar");
+        const e = (await res.json()) as any;
+        return JSON.stringify({
+          id: e.id, summary: e.summary, description: e.description,
+          start: e.start?.dateTime || e.start?.date, end: e.end?.dateTime || e.end?.date,
+          status: e.status, attendees: e.attendees?.map((a: any) => a.email),
+        });
+      }
+      case "update": {
+        if (!event_id) return JSON.stringify({ error: "event_id required" });
+        const patch: any = {};
+        if (summary) patch.summary = summary;
+        if (description) patch.description = description;
+        if (start) patch.start = { dateTime: start };
+        if (end) patch.end = { dateTime: end };
+        const res = await fetch(`${API}/calendars/${calId}/events/${event_id}`, {
+          method: "PATCH", headers,
+          body: JSON.stringify(patch),
+        });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Calendar");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ updated: true, id: data.id, summary: data.summary });
+      }
+      case "delete": {
+        if (!event_id) return JSON.stringify({ error: "event_id required" });
+        const res = await fetch(`${API}/calendars/${calId}/events/${event_id}`, { method: "DELETE", headers });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Calendar");
+        return JSON.stringify({ deleted: true });
+      }
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    console.error(`[Google Calendar] Request failed: ${err.message}`);
+    return JSON.stringify({ error: "Google Calendar request failed. Check logs for details." });
+  }
+}

package/src/tools/builtin-integrations/google/google_docs/SKILL.md

@@ -0,0 +1,35 @@
+# google_docs
+
+Manage Google Docs: create, read, and update documents. Requires a Google API key stored as `google_api_key`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["create", "read", "update"],
+      "description": "The action to perform"
+    },
+    "document_id": {
+      "type": "string",
+      "description": "The document ID (required for read, update)"
+    },
+    "title": {
+      "type": "string",
+      "description": "Document title (required for create)"
+    },
+    "text": {
+      "type": "string",
+      "description": "Text to insert (for update)"
+    },
+    "index": {
+      "type": "number",
+      "description": "Insert position index (for update, default: 1 = start)"
+    }
+  },
+  "required": ["action"]
+}
+```

package/src/tools/builtin-integrations/google/google_docs/handler.ts

@@ -0,0 +1,108 @@
+const API = "https://docs.googleapis.com/v1/documents";
+
+async function getToken(): Promise<string> {
+  const Zubo = (globalThis as any).Zubo;
+  if (Zubo?.getGoogleToken) return Zubo.getGoogleToken();
+  throw new Error("Google is NOT connected. Use google_oauth with action 'start' to set up Google.");
+}
+
+function safeApiErr(status: number, statusText: string, service: string): string {
+  return JSON.stringify({ error: `${service} API error: ${status} ${statusText}` });
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  let token: string;
+  try {
+    token = await getToken();
+  } catch (err: any) {
+    return JSON.stringify({
+      error: err.message,
+      action_required: "Google is NOT connected. The user needs to complete the OAuth 2.0 flow. " +
+        "Ask the user for their Google OAuth client_id (ends with .apps.googleusercontent.com) " +
+        "and client_secret (starts with GOCSPX-), then use google_oauth tool with action 'start'.",
+    });
+  }
+
+  const { action, document_id, title, text, index } = input as {
+    action: string;
+    document_id?: string;
+    title?: string;
+    text?: string;
+    index?: number;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+  };
+
+  try {
+    switch (action) {
+      case "create": {
+        if (!title) return JSON.stringify({ error: "title is required for create" });
+        const res = await fetch(API, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ title }),
+        });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Docs");
+        const doc = (await res.json()) as any;
+        return JSON.stringify({
+          document_id: doc.documentId,
+          title: doc.title,
+          url: `https://docs.google.com/document/d/${doc.documentId}/edit`,
+        });
+      }
+
+      case "read": {
+        if (!document_id) return JSON.stringify({ error: "document_id is required for read" });
+        const res = await fetch(`${API}/${document_id}`, { headers });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Docs");
+        const doc = (await res.json()) as any;
+        // Extract plain text from doc body
+        let content = "";
+        if (doc.body?.content) {
+          for (const element of doc.body.content) {
+            if (element.paragraph?.elements) {
+              for (const e of element.paragraph.elements) {
+                if (e.textRun?.content) content += e.textRun.content;
+              }
+            }
+          }
+        }
+        return JSON.stringify({
+          document_id: doc.documentId,
+          title: doc.title,
+          content: content.trim(),
+        });
+      }
+
+      case "update": {
+        if (!document_id) return JSON.stringify({ error: "document_id is required for update" });
+        if (!text) return JSON.stringify({ error: "text is required for update" });
+        const res = await fetch(`${API}/${document_id}:batchUpdate`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            requests: [
+              {
+                insertText: {
+                  text,
+                  location: { index: index ?? 1 },
+                },
+              },
+            ],
+          }),
+        });
+        if (!res.ok) return safeApiErr(res.status, res.statusText, "Google Docs");
+        return JSON.stringify({ success: true, message: "Document updated." });
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    console.error(`[Google Docs] Request failed: ${err.message}`);
+    return JSON.stringify({ error: "Google Docs request failed. Check logs for details." });
+  }
+}

package/src/tools/builtin-integrations/google/google_drive/SKILL.md

@@ -0,0 +1,39 @@
+# google_drive
+
+Manage Google Drive: list files, create folders, and get file info. Requires a Google API key stored as `google_api_key`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["list", "create_folder", "get"],
+      "description": "The action to perform"
+    },
+    "file_id": {
+      "type": "string",
+      "description": "File or folder ID (required for get)"
+    },
+    "name": {
+      "type": "string",
+      "description": "Folder name (required for create_folder)"
+    },
+    "parent_id": {
+      "type": "string",
+      "description": "Parent folder ID (optional for create_folder)"
+    },
+    "query": {
+      "type": "string",
+      "description": "Search query (for list, uses Google Drive query syntax)"
+    },
+    "page_size": {
+      "type": "number",
+      "description": "Number of results (for list, default: 20)"
+    }
+  },
+  "required": ["action"]
+}
+```