zubo 0.1.0

package/src/tools/builtin-integrations/linear/linear_projects/handler.ts

@@ -0,0 +1,43 @@
+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.linear.app/graphql";
+
+async function gql(token: string, query: string, variables?: any): Promise<any> {
+  const res = await fetch(API, {
+    method: "POST",
+    headers: { Authorization: token, "Content-Type": "application/json" },
+    body: JSON.stringify({ query, variables }),
+  });
+  if (!res.ok) throw new Error(`Linear API error: ${res.status}`);
+  const data = (await res.json()) as any;
+  if (data.errors?.length) throw new Error(data.errors[0].message);
+  return data.data;
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const token = (globalThis as any).Zubo?.getSecret?.("linear_token");
+  if (!token) return JSON.stringify({ error: "Linear token not configured. Use secret_set to store 'linear_token'." });
+
+  const { action, project_id } = input as { action: string; project_id?: string };
+
+  try {
+    switch (action) {
+      case "list": {
+        const data = await gql(token, `{ projects(first: 25) { nodes { id name state progress startDate targetDate } } }`);
+        return JSON.stringify(data.projects.nodes);
+      }
+      case "get": {
+        if (!project_id) return JSON.stringify({ error: "project_id required" });
+        const data = await gql(token, `query($id: String!) { project(id: $id) { id name description state progress startDate targetDate teams { nodes { name } } members { nodes { name } } } }`, { id: project_id });
+        return JSON.stringify(data.project);
+      }
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "Linear");
+  }
+}

package/src/tools/builtin-integrations/notion/notion_databases/SKILL.md

@@ -0,0 +1,39 @@
+# notion_databases
+
+Query and create entries in Notion databases. Requires a Notion integration token stored as `notion_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["query", "create_entry"],
+      "description": "The action to perform"
+    },
+    "database_id": {
+      "type": "string",
+      "description": "The database ID"
+    },
+    "filter": {
+      "type": "object",
+      "description": "Notion filter object (for query)"
+    },
+    "sorts": {
+      "type": "array",
+      "description": "Sort criteria (for query)"
+    },
+    "properties": {
+      "type": "object",
+      "description": "Properties for the new entry (for create_entry)"
+    },
+    "page_size": {
+      "type": "number",
+      "description": "Number of results (for query, default: 20)"
+    }
+  },
+  "required": ["action", "database_id"]
+}
+```

package/src/tools/builtin-integrations/notion/notion_databases/handler.ts

@@ -0,0 +1,83 @@
+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.notion.com/v1";
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const token = (globalThis as any).Zubo?.getSecret?.("notion_token");
+  if (!token) {
+    return JSON.stringify({
+      error: "Notion token not configured. Use secret_set to store a 'notion_token' or connect_service to set up Notion.",
+    });
+  }
+
+  const { action, database_id, filter, sorts, properties, page_size } = input as {
+    action: string;
+    database_id: string;
+    filter?: Record<string, unknown>;
+    sorts?: unknown[];
+    properties?: Record<string, unknown>;
+    page_size?: number;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": "2022-06-28",
+  };
+
+  try {
+    switch (action) {
+      case "query": {
+        const body: any = { page_size: page_size || 20 };
+        if (filter) body.filter = filter;
+        if (sorts) body.sorts = sorts;
+
+        const res = await fetch(`${API}/databases/${database_id}/query`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+        });
+        if (!res.ok) return await safeApiError(res, "Notion");
+        const data = (await res.json()) as any;
+        return JSON.stringify({
+          results: (data.results || []).map((r: any) => ({
+            id: r.id,
+            url: r.url,
+            properties: r.properties,
+            created_time: r.created_time,
+          })),
+          has_more: data.has_more,
+        });
+      }
+
+      case "create_entry": {
+        if (!properties) return JSON.stringify({ error: "properties are required for create_entry" });
+        const res = await fetch(`${API}/pages`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            parent: { database_id },
+            properties,
+          }),
+        });
+        if (!res.ok) return await safeApiError(res, "Notion");
+        const page = (await res.json()) as any;
+        return JSON.stringify({ id: page.id, url: page.url, created_time: page.created_time });
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "Notion");
+  }
+}

package/src/tools/builtin-integrations/notion/notion_pages/SKILL.md

@@ -0,0 +1,43 @@
+# notion_pages
+
+Manage Notion pages: create, read, and update pages. Requires a Notion integration token stored as `notion_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["create", "read", "update"],
+      "description": "The action to perform"
+    },
+    "page_id": {
+      "type": "string",
+      "description": "Page ID (required for read and update)"
+    },
+    "parent_page_id": {
+      "type": "string",
+      "description": "Parent page ID (required for create)"
+    },
+    "parent_database_id": {
+      "type": "string",
+      "description": "Parent database ID (alternative to parent_page_id for create)"
+    },
+    "title": {
+      "type": "string",
+      "description": "Page title (required for create)"
+    },
+    "content": {
+      "type": "string",
+      "description": "Page content as plain text (for create and update)"
+    },
+    "properties": {
+      "type": "object",
+      "description": "Properties to set (for create in database, or update)"
+    }
+  },
+  "required": ["action"]
+}
+```

package/src/tools/builtin-integrations/notion/notion_pages/handler.ts

@@ -0,0 +1,130 @@
+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.notion.com/v1";
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const token = (globalThis as any).Zubo?.getSecret?.("notion_token");
+  if (!token) {
+    return JSON.stringify({
+      error: "Notion token not configured. Use secret_set to store a 'notion_token' or connect_service to set up Notion.",
+    });
+  }
+
+  const { action, page_id, parent_page_id, parent_database_id, title, content, properties } =
+    input as {
+      action: string;
+      page_id?: string;
+      parent_page_id?: string;
+      parent_database_id?: string;
+      title?: string;
+      content?: string;
+      properties?: Record<string, unknown>;
+    };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": "2022-06-28",
+  };
+
+  try {
+    switch (action) {
+      case "create": {
+        if (!title) return JSON.stringify({ error: "title is required for create" });
+        const parent = parent_database_id
+          ? { database_id: parent_database_id }
+          : parent_page_id
+            ? { page_id: parent_page_id }
+            : null;
+        if (!parent) return JSON.stringify({ error: "parent_page_id or parent_database_id is required" });
+
+        const body: any = {
+          parent,
+          properties: properties || {
+            title: { title: [{ text: { content: title } }] },
+          },
+        };
+
+        if (content) {
+          body.children = [
+            {
+              object: "block",
+              type: "paragraph",
+              paragraph: {
+                rich_text: [{ type: "text", text: { content } }],
+              },
+            },
+          ];
+        }
+
+        const res = await fetch(`${API}/pages`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+        });
+        if (!res.ok) return await safeApiError(res, "Notion");
+        const page = (await res.json()) as any;
+        return JSON.stringify({ id: page.id, url: page.url, created_time: page.created_time });
+      }
+
+      case "read": {
+        if (!page_id) return JSON.stringify({ error: "page_id is required for read" });
+        // Get page properties
+        const pageRes = await fetch(`${API}/pages/${page_id}`, { headers });
+        if (!pageRes.ok) return await safeApiError(pageRes, "Notion");
+        const page = (await pageRes.json()) as any;
+
+        // Get page content (blocks)
+        const blocksRes = await fetch(`${API}/blocks/${page_id}/children?page_size=100`, { headers });
+        let blocks: any[] = [];
+        if (blocksRes.ok) {
+          const blocksData = (await blocksRes.json()) as any;
+          blocks = blocksData.results || [];
+        }
+
+        // Extract text from blocks
+        const textParts: string[] = [];
+        for (const block of blocks) {
+          const richText = block[block.type]?.rich_text;
+          if (richText) {
+            textParts.push(richText.map((t: any) => t.plain_text).join(""));
+          }
+        }
+
+        return JSON.stringify({
+          id: page.id,
+          url: page.url,
+          properties: page.properties,
+          content: textParts.join("\n"),
+        });
+      }
+
+      case "update": {
+        if (!page_id) return JSON.stringify({ error: "page_id is required for update" });
+        if (!properties) return JSON.stringify({ error: "properties are required for update" });
+        const res = await fetch(`${API}/pages/${page_id}`, {
+          method: "PATCH",
+          headers,
+          body: JSON.stringify({ properties }),
+        });
+        if (!res.ok) return await safeApiError(res, "Notion");
+        const page = (await res.json()) as any;
+        return JSON.stringify({ id: page.id, url: page.url, message: "Page updated." });
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "Notion");
+  }
+}

package/src/tools/builtin-integrations/notion/notion_search/SKILL.md

@@ -0,0 +1,27 @@
+# notion_search
+
+Search across your Notion workspace for pages and databases. Requires a Notion integration token stored as `notion_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "query": {
+      "type": "string",
+      "description": "Search query text"
+    },
+    "filter_type": {
+      "type": "string",
+      "enum": ["page", "database"],
+      "description": "Filter results by object type"
+    },
+    "page_size": {
+      "type": "number",
+      "description": "Number of results (default: 20)"
+    }
+  },
+  "required": ["query"]
+}
+```

package/src/tools/builtin-integrations/notion/notion_search/handler.ts

@@ -0,0 +1,69 @@
+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.notion.com/v1";
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const token = (globalThis as any).Zubo?.getSecret?.("notion_token");
+  if (!token) {
+    return JSON.stringify({
+      error: "Notion token not configured. Use secret_set to store a 'notion_token' or connect_service to set up Notion.",
+    });
+  }
+
+  const { query, filter_type, page_size } = input as {
+    query: string;
+    filter_type?: string;
+    page_size?: number;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": "2022-06-28",
+  };
+
+  try {
+    const body: any = {
+      query,
+      page_size: page_size || 20,
+    };
+    if (filter_type) {
+      body.filter = { value: filter_type, property: "object" };
+    }
+
+    const res = await fetch(`${API}/search`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) return await safeApiError(res, "Notion");
+    const data = (await res.json()) as any;
+
+    return JSON.stringify({
+      results: (data.results || []).map((r: any) => ({
+        id: r.id,
+        type: r.object,
+        url: r.url,
+        title:
+          r.properties?.title?.title?.[0]?.plain_text ||
+          r.properties?.Name?.title?.[0]?.plain_text ||
+          r.title?.[0]?.plain_text ||
+          "(untitled)",
+        created_time: r.created_time,
+        last_edited_time: r.last_edited_time,
+      })),
+      has_more: data.has_more,
+    });
+  } catch (err: any) {
+    return safeExceptionError(err, "Notion");
+  }
+}

package/src/tools/builtin-integrations/slack/slack_messages/SKILL.md

@@ -0,0 +1,42 @@
+# slack_messages
+
+Send and read Slack messages, list channels, and search messages. Requires a Slack bot token stored as `slack_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["send", "read", "list_channels", "search"],
+      "description": "Action to perform"
+    },
+    "channel": {
+      "type": "string",
+      "description": "Channel ID (for send and read)"
+    },
+    "text": {
+      "type": "string",
+      "description": "Message text (for send)"
+    },
+    "query": {
+      "type": "string",
+      "description": "Search query (for search)"
+    },
+    "limit": {
+      "type": "number",
+      "description": "Max results (default 20)"
+    }
+  },
+  "required": ["action"]
+}
+```
+
+## Usage Hints
+
+- Use "list_channels" to see available channels.
+- Use "send" with channel and text to post a message.
+- Use "read" with channel to see recent messages.
+- Use "search" with query to search message history.

package/src/tools/builtin-integrations/slack/slack_messages/handler.ts

@@ -0,0 +1,72 @@
+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://slack.com/api";
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const token = (globalThis as any).Zubo?.getSecret?.("slack_token");
+  if (!token) {
+    return JSON.stringify({ error: "Slack token not configured. Use secret_set to store 'slack_token'." });
+  }
+
+  const { action, channel, text, query, limit } = input as {
+    action: string; channel?: string; text?: string; query?: string; limit?: number;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json; charset=utf-8",
+  };
+
+  try {
+    switch (action) {
+      case "list_channels": {
+        const res = await fetch(`${API}/conversations.list?types=public_channel,private_channel&limit=${limit || 50}`, { headers });
+        if (!res.ok) return await safeApiError(res, "Slack");
+        const data = (await res.json()) as any;
+        if (!data.ok) return JSON.stringify({ error: `Slack API error: ${data.error}` });
+        return JSON.stringify(data.channels?.map((c: any) => ({ id: c.id, name: c.name, topic: c.topic?.value })) ?? []);
+      }
+      case "send": {
+        if (!channel) return JSON.stringify({ error: "channel is required" });
+        if (!text) return JSON.stringify({ error: "text is required" });
+        const res = await fetch(`${API}/chat.postMessage`, {
+          method: "POST", headers,
+          body: JSON.stringify({ channel, text }),
+        });
+        if (!res.ok) return await safeApiError(res, "Slack");
+        const data = (await res.json()) as any;
+        if (!data.ok) return JSON.stringify({ error: `Slack API error: ${data.error}` });
+        return JSON.stringify({ ok: true, ts: data.ts, channel: data.channel });
+      }
+      case "read": {
+        if (!channel) return JSON.stringify({ error: "channel is required" });
+        const res = await fetch(`${API}/conversations.history?channel=${channel}&limit=${limit || 20}`, { headers });
+        if (!res.ok) return await safeApiError(res, "Slack");
+        const data = (await res.json()) as any;
+        if (!data.ok) return JSON.stringify({ error: `Slack API error: ${data.error}` });
+        return JSON.stringify(data.messages?.map((m: any) => ({ user: m.user, text: m.text, ts: m.ts })) ?? []);
+      }
+      case "search": {
+        if (!query) return JSON.stringify({ error: "query is required" });
+        const res = await fetch(`${API}/search.messages?query=${encodeURIComponent(query)}&count=${limit || 20}`, { headers });
+        if (!res.ok) return await safeApiError(res, "Slack");
+        const data = (await res.json()) as any;
+        if (!data.ok) return JSON.stringify({ error: `Slack API error: ${data.error}` });
+        return JSON.stringify(data.messages?.matches?.map((m: any) => ({ text: m.text, user: m.user, channel: m.channel?.name, ts: m.ts })) ?? []);
+      }
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "Slack");
+  }
+}

package/src/tools/builtin-integrations/twitter/twitter_posts/SKILL.md

@@ -0,0 +1,24 @@
+# twitter_posts
+
+Post tweets, read timeline, search, and reply on Twitter/X. Requires `twitter_bearer_token` for reading. For posting also needs `twitter_api_key`, `twitter_api_secret`, `twitter_access_token`, `twitter_access_secret`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": { "type": "string", "enum": ["post", "timeline", "search", "reply"], "description": "Action to perform" },
+    "text": { "type": "string", "description": "Tweet text (for post and reply)" },
+    "query": { "type": "string", "description": "Search query" },
+    "tweet_id": { "type": "string", "description": "Tweet ID (for reply)" },
+    "max_results": { "type": "number", "description": "Max results (default 10)" }
+  },
+  "required": ["action"]
+}
+```
+
+## Usage Hints
+
+- "post" and "reply" require OAuth credentials and user confirmation.
+- "timeline" and "search" only need the bearer token.