zubo 0.1.0

package/src/tools/builtin-integrations/twitter/twitter_posts/handler.ts

@@ -0,0 +1,133 @@
+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.twitter.com/2";
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const bearer = (globalThis as any).Zubo?.getSecret?.("twitter_bearer_token");
+  if (!bearer) {
+    return JSON.stringify({ error: "Twitter bearer token not configured. Use secret_set to store 'twitter_bearer_token'." });
+  }
+
+  const { action, text, query, tweet_id, max_results } = input as {
+    action: string; text?: string; query?: string; tweet_id?: string; max_results?: number;
+  };
+
+  const readHeaders: Record<string, string> = {
+    Authorization: `Bearer ${bearer}`,
+  };
+
+  try {
+    switch (action) {
+      case "timeline": {
+        // Get authenticated user's timeline (home timeline requires user context)
+        const meRes = await fetch(`${API}/users/me`, { headers: readHeaders });
+        if (!meRes.ok) return await safeApiError(meRes, "Twitter");
+        const me = (await meRes.json()) as any;
+        const res = await fetch(`${API}/users/${me.data.id}/tweets?max_results=${max_results || 10}&tweet.fields=created_at,public_metrics`, { headers: readHeaders });
+        if (!res.ok) return await safeApiError(res, "Twitter");
+        const data = (await res.json()) as any;
+        return JSON.stringify(data.data?.map((t: any) => ({ id: t.id, text: t.text, created_at: t.created_at, metrics: t.public_metrics })) ?? []);
+      }
+      case "search": {
+        if (!query) return JSON.stringify({ error: "query required" });
+        const res = await fetch(`${API}/tweets/search/recent?query=${encodeURIComponent(query)}&max_results=${max_results || 10}&tweet.fields=created_at,author_id,public_metrics`, { headers: readHeaders });
+        if (!res.ok) return await safeApiError(res, "Twitter");
+        const data = (await res.json()) as any;
+        return JSON.stringify(data.data?.map((t: any) => ({ id: t.id, text: t.text, author_id: t.author_id, created_at: t.created_at })) ?? []);
+      }
+      case "post": {
+        if (!text) return JSON.stringify({ error: "text required" });
+        const apiKey = (globalThis as any).Zubo?.getSecret?.("twitter_api_key");
+        const apiSecret = (globalThis as any).Zubo?.getSecret?.("twitter_api_secret");
+        const accessToken = (globalThis as any).Zubo?.getSecret?.("twitter_access_token");
+        const accessSecret = (globalThis as any).Zubo?.getSecret?.("twitter_access_secret");
+        if (!apiKey || !apiSecret || !accessToken || !accessSecret) {
+          return JSON.stringify({ error: "Twitter OAuth credentials not configured. Need twitter_api_key, twitter_api_secret, twitter_access_token, twitter_access_secret." });
+        }
+        // Use OAuth 1.0a -- simplified via fetch with pre-computed header
+        const oauthHeader = computeOAuth1Header("POST", `${API}/tweets`, {}, apiKey, apiSecret, accessToken, accessSecret);
+        const res = await fetch(`${API}/tweets`, {
+          method: "POST",
+          headers: { Authorization: oauthHeader, "Content-Type": "application/json" },
+          body: JSON.stringify({ text }),
+        });
+        if (!res.ok) return await safeApiError(res, "Twitter");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ posted: true, id: data.data?.id, text: data.data?.text });
+      }
+      case "reply": {
+        if (!text || !tweet_id) return JSON.stringify({ error: "text and tweet_id required" });
+        const apiKey = (globalThis as any).Zubo?.getSecret?.("twitter_api_key");
+        const apiSecret = (globalThis as any).Zubo?.getSecret?.("twitter_api_secret");
+        const accessToken = (globalThis as any).Zubo?.getSecret?.("twitter_access_token");
+        const accessSecret = (globalThis as any).Zubo?.getSecret?.("twitter_access_secret");
+        if (!apiKey || !apiSecret || !accessToken || !accessSecret) {
+          return JSON.stringify({ error: "Twitter OAuth credentials not configured." });
+        }
+        const oauthHeader = computeOAuth1Header("POST", `${API}/tweets`, {}, apiKey, apiSecret, accessToken, accessSecret);
+        const res = await fetch(`${API}/tweets`, {
+          method: "POST",
+          headers: { Authorization: oauthHeader, "Content-Type": "application/json" },
+          body: JSON.stringify({ text, reply: { in_reply_to_tweet_id: tweet_id } }),
+        });
+        if (!res.ok) return await safeApiError(res, "Twitter");
+        const data = (await res.json()) as any;
+        return JSON.stringify({ replied: true, id: data.data?.id });
+      }
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "Twitter");
+  }
+}
+
+// Minimal OAuth 1.0a header computation
+function computeOAuth1Header(
+  method: string, url: string, params: Record<string, string>,
+  consumerKey: string, consumerSecret: string,
+  tokenKey: string, tokenSecret: string
+): string {
+  const timestamp = Math.floor(Date.now() / 1000).toString();
+  const nonce = crypto.randomUUID().replace(/-/g, "");
+
+  const oauthParams: Record<string, string> = {
+    oauth_consumer_key: consumerKey,
+    oauth_nonce: nonce,
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: timestamp,
+    oauth_token: tokenKey,
+    oauth_version: "1.0",
+  };
+
+  const allParams = { ...params, ...oauthParams };
+  const sortedKeys = Object.keys(allParams).sort();
+  const paramString = sortedKeys.map(k => `${encodeURIComponent(k)}=${encodeURIComponent(allParams[k])}`).join("&");
+
+  const baseString = `${method}&${encodeURIComponent(url)}&${encodeURIComponent(paramString)}`;
+  const signingKey = `${encodeURIComponent(consumerSecret)}&${encodeURIComponent(tokenSecret)}`;
+
+  // Use Web Crypto for HMAC-SHA1
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(signingKey);
+  const msgData = encoder.encode(baseString);
+
+  // Sync HMAC-SHA1 using Bun's crypto
+  const hmac = new Bun.CryptoHasher("sha1", keyData);
+  hmac.update(msgData);
+  const signature = Buffer.from(hmac.digest()).toString("base64");
+
+  oauthParams.oauth_signature = signature;
+
+  const headerParts = Object.keys(oauthParams).sort().map(k => `${encodeURIComponent(k)}="${encodeURIComponent(oauthParams[k])}"`);
+  return `OAuth ${headerParts.join(", ")}`;
+}

package/src/tools/builtin-skills/file-read/SKILL.md

@@ -0,0 +1,26 @@
+# file_read
+
+Read the contents of a file from the local filesystem.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "Absolute or ~ path to the file to read."
+    },
+    "maxLength": {
+      "type": "number",
+      "description": "Maximum characters to return (default 50000)."
+    }
+  },
+  "required": ["path"]
+}
+```
+
+## Usage Hints
+
+Use this tool when the user asks you to read, view, or check the contents of a file on their machine. Supports text files. Use ~ for home directory paths.

package/src/tools/builtin-skills/file-read/handler.ts

@@ -0,0 +1,66 @@
+import { homedir } from "os";
+import { resolve } from "path";
+
+const BLOCKED_PATHS = [
+  "/.ssh/",
+  "/.gnupg/",
+  "/.aws/credentials",
+  "/.zubo/config.json",
+  "/.zubo/zubo.db",
+  "/id_rsa",
+  "/id_ed25519",
+  "/.env",
+  "/.npmrc",
+  "/.netrc",
+  "/.docker/config.json",
+];
+
+function validatePath(rawPath: string): string {
+  let p = rawPath;
+
+  // Expand ~
+  if (p.startsWith("~/")) {
+    p = p.replace("~", homedir());
+  }
+
+  // Resolve to absolute, eliminating .. traversals
+  p = resolve(p);
+
+  // Must be under home directory
+  const home = homedir();
+  if (!p.startsWith(home + "/") && p !== home) {
+    throw new Error(`Access denied: reads are restricted to your home directory`);
+  }
+
+  // Block sensitive paths
+  for (const blocked of BLOCKED_PATHS) {
+    if (p.includes(blocked)) {
+      throw new Error(`Access denied: cannot read sensitive path (${blocked})`);
+    }
+  }
+
+  return p;
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const rawPath = input.path as string;
+  const maxLength = (input.maxLength as number) || 50000;
+
+  const path = validatePath(rawPath);
+
+  const file = Bun.file(path);
+  const exists = await file.exists();
+
+  if (!exists) {
+    throw new Error(`File not found: ${path}`);
+  }
+
+  let content = await file.text();
+  const size = content.length;
+
+  if (content.length > maxLength) {
+    content = content.slice(0, maxLength) + "\n\n[Truncated]";
+  }
+
+  return JSON.stringify({ path, size, contentLength: content.length, content });
+}

package/src/tools/builtin-skills/file-write/SKILL.md

@@ -0,0 +1,30 @@
+# file_write
+
+Write content to a file on the local filesystem.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "Absolute or ~ path to the file to write."
+    },
+    "content": {
+      "type": "string",
+      "description": "The content to write to the file."
+    },
+    "append": {
+      "type": "boolean",
+      "description": "If true, append to file instead of overwriting (default false)."
+    }
+  },
+  "required": ["path", "content"]
+}
+```
+
+## Usage Hints
+
+Use this tool when the user asks you to create, write, or save content to a file. Use ~ for home directory paths. Set append=true to add to existing files.

package/src/tools/builtin-skills/file-write/handler.ts

@@ -0,0 +1,64 @@
+import { homedir } from "os";
+import { resolve } from "path";
+import { appendFileSync } from "fs";
+
+const BLOCKED_PATHS = [
+  "/.ssh/",
+  "/.gnupg/",
+  "/.aws/credentials",
+  "/.zubo/config.json",
+  "/id_rsa",
+  "/id_ed25519",
+  "/.env",
+  "/.bashrc",
+  "/.bash_profile",
+  "/.zshrc",
+  "/.profile",
+];
+
+function validatePath(rawPath: string): string {
+  let p = rawPath;
+
+  // Expand ~
+  if (p.startsWith("~/")) {
+    p = p.replace("~", homedir());
+  }
+
+  // Resolve to absolute, eliminating .. traversals
+  p = resolve(p);
+
+  // Must be under home directory
+  const home = homedir();
+  if (!p.startsWith(home + "/") && p !== home) {
+    throw new Error(`Access denied: writes are restricted to your home directory`);
+  }
+
+  // Block sensitive paths
+  for (const blocked of BLOCKED_PATHS) {
+    if (p.includes(blocked)) {
+      throw new Error(`Access denied: cannot write to sensitive path (${blocked})`);
+    }
+  }
+
+  return p;
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const rawPath = input.path as string;
+  const content = input.content as string;
+  const append = (input.append as boolean) || false;
+
+  const path = validatePath(rawPath);
+
+  if (append) {
+    appendFileSync(path, content);
+  } else {
+    await Bun.write(path, content);
+  }
+
+  return JSON.stringify({
+    path,
+    bytesWritten: content.length,
+    mode: append ? "append" : "write",
+  });
+}

package/src/tools/builtin-skills/http-request/SKILL.md

@@ -0,0 +1,34 @@
+# http_request
+
+Make an HTTP request to any URL with full control over method, headers, and body.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "url": {
+      "type": "string",
+      "description": "The URL to send the request to."
+    },
+    "method": {
+      "type": "string",
+      "description": "HTTP method (GET, POST, PUT, DELETE, PATCH). Default GET."
+    },
+    "headers": {
+      "type": "object",
+      "description": "Key-value pairs for request headers."
+    },
+    "body": {
+      "type": "string",
+      "description": "Request body (for POST, PUT, PATCH)."
+    }
+  },
+  "required": ["url"]
+}
+```
+
+## Usage Hints
+
+Use this tool when the user needs to call an API, make HTTP requests, or interact with web services. More flexible than url_fetch — supports all methods and custom headers.

package/src/tools/builtin-skills/http-request/handler.ts

@@ -0,0 +1,87 @@
+const BLOCKED_HOST_PATTERNS = [
+  /^localhost$/i,
+  /^127\.\d+\.\d+\.\d+$/,
+  /^10\.\d+\.\d+\.\d+$/,
+  /^172\.(1[6-9]|2\d|3[01])\.\d+\.\d+$/,
+  /^192\.168\.\d+\.\d+$/,
+  /^169\.254\.\d+\.\d+$/,
+  /^\[?::1\]?$/,
+  /^0\.0\.0\.0$/,
+  /^metadata\.google\.internal$/i,
+  /^metadata\.azure\.com$/i,
+  /^fe80:/i,
+  /^fc00:/i,
+];
+
+function isBlockedHost(hostname: string): boolean {
+  const normalized = hostname.replace(/^\[|\]$/g, "");
+  for (const pattern of BLOCKED_HOST_PATTERNS) {
+    if (pattern.test(normalized)) return true;
+  }
+  return false;
+}
+
+function validateUrl(raw: string): void {
+  let parsed: URL;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`Invalid URL: ${raw}`);
+  }
+
+  if (isBlockedHost(parsed.hostname)) {
+    throw new Error(`Blocked: requests to internal/private addresses are not allowed`);
+  }
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const url = input.url as string;
+  const method = ((input.method as string) || "GET").toUpperCase();
+  const headers = (input.headers as Record<string, string>) || {};
+  const body = input.body as string | undefined;
+
+  validateUrl(url);
+
+  const opts: RequestInit = {
+    method,
+    headers: {
+      "User-Agent": "Zubo/1.0",
+      ...headers,
+    },
+    redirect: "manual",
+    signal: AbortSignal.timeout(30000),
+  };
+
+  if (body && ["POST", "PUT", "PATCH"].includes(method)) {
+    opts.body = body;
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      (opts.headers as Record<string, string>)["Content-Type"] = "application/json";
+    }
+  }
+
+  let res = await fetch(url, opts);
+  let redirectCount = 0;
+  const MAX_REDIRECTS = 5;
+
+  while (res.status >= 300 && res.status < 400 && redirectCount < MAX_REDIRECTS) {
+    const location = res.headers.get("location");
+    if (!location) break;
+
+    const redirectUrl = new URL(location, url);
+    if (isBlockedHost(redirectUrl.hostname)) {
+      return JSON.stringify({ error: "Redirect to blocked host", status: 0 });
+    }
+
+    res = await fetch(redirectUrl.toString(), { ...opts, redirect: "manual" });
+    redirectCount++;
+  }
+
+  const responseText = await res.text();
+
+  return JSON.stringify({
+    status: res.status,
+    statusText: res.statusText,
+    headers: Object.fromEntries(res.headers.entries()),
+    body: responseText.slice(0, 50000),
+  });
+}

package/src/tools/builtin-skills/shell/SKILL.md

@@ -0,0 +1,26 @@
+# shell
+
+Execute a shell command and return its output.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "command": {
+      "type": "string",
+      "description": "The shell command to execute."
+    },
+    "timeout": {
+      "type": "number",
+      "description": "Timeout in milliseconds (default 30000)."
+    }
+  },
+  "required": ["command"]
+}
+```
+
+## Usage Hints
+
+Use this tool when the user asks you to run a command, check system info, list files, or perform any shell operation. Be cautious with destructive commands.

package/src/tools/builtin-skills/shell/handler.ts

@@ -0,0 +1,96 @@
+const BLOCKED_PATTERNS = [
+  /\brm\s+(-[a-zA-Z]*)?.*\s+\/\s*$/,   // rm -rf /
+  /\bmkfs\b/,
+  /\bdd\s+.*of=\/dev\//,
+  />\s*\/dev\/sd/,
+  /\bshutdown\b/,
+  /\breboot\b/,
+  /\b:(){ :\|:& };:/,                    // fork bomb
+  /\bkill\s+(-9\s+)?-1\b/,              // kill all processes
+  /\bchmod\s+0{3}\s+\//,                // chmod 000 /
+  /\bchown\s+.*\s+\/\s*$/,              // chown ... /
+  /\bfind\s+\/\s+.*-delete\b/,          // find / -delete
+  /\bcurl\s+.*\|\s*sh\b/,               // curl pipe to sh
+  /\bwget\s+.*\|\s*sh\b/,               // wget pipe to sh
+  /bash\s+-i\s+>&\s*\/dev\/tcp\//,      // reverse shell
+  /\b>\s*\/dev\/[sv]d/,                  // overwrite disk devices
+  /\bnc\s+(-[a-zA-Z]*\s+)*-e\b/,        // netcat reverse shell
+];
+
+const SENSITIVE_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "AWS_SECRET_ACCESS_KEY",
+  "GITHUB_TOKEN",
+  "NPM_TOKEN",
+  "DATABASE_URL",
+  "IFS",
+  "PS4",
+  "BASH_ENV",
+  "ENV",
+  "SHELLOPTS",
+  "BASHOPTS",
+  "CDPATH",
+  "GLOBIGNORE",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+];
+
+function sanitizeEnv(): Record<string, string | undefined> {
+  const env = { ...process.env };
+  for (const key of SENSITIVE_ENV_KEYS) {
+    delete env[key];
+  }
+  // Also strip any key containing SECRET, TOKEN, PASSWORD, CREDENTIAL
+  for (const key of Object.keys(env)) {
+    if (/SECRET|TOKEN|PASSWORD|CREDENTIAL|PRIVATE_KEY/i.test(key)) {
+      delete env[key];
+    }
+  }
+  return env;
+}
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const command = input.command as string;
+  const timeout = (input.timeout as number) || 30000;
+
+  // Block obviously destructive commands
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(command)) {
+      throw new Error(`Blocked: command matches dangerous pattern`);
+    }
+  }
+
+  const proc = Bun.spawn(["sh", "-c", command], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: sanitizeEnv(),
+  });
+
+  // Set up timeout that kills the process
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    try {
+      proc.kill();
+    } catch (err: any) {
+      // Process may have already exited
+    }
+  }, timeout);
+
+  // Read stdout and stderr in parallel to avoid deadlock
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+
+  clearTimeout(timer);
+
+  return JSON.stringify({
+    exitCode,
+    timedOut,
+    stdout: stdout.slice(0, 50000),
+    stderr: stderr.slice(0, 10000),
+  });
+}

package/src/tools/builtin-skills/url-fetch/SKILL.md

@@ -0,0 +1,26 @@
+# url_fetch
+
+Fetch the content of a URL and return the text body.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "url": {
+      "type": "string",
+      "description": "The URL to fetch."
+    },
+    "maxLength": {
+      "type": "number",
+      "description": "Maximum characters to return (default 10000)."
+    }
+  },
+  "required": ["url"]
+}
+```
+
+## Usage Hints
+
+Use this tool when the user asks you to read, fetch, or summarize a web page. Returns raw text content — useful for reading articles, docs, or API responses.

package/src/tools/builtin-skills/url-fetch/handler.ts

@@ -0,0 +1,37 @@
+export default async function (input: Record<string, unknown>): Promise<string> {
+  const url = input.url as string;
+  const maxLength = (input.maxLength as number) || 10000;
+
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": "Zubo/1.0",
+      Accept: "text/html, application/json, text/plain, */*",
+    },
+    redirect: "follow",
+    signal: AbortSignal.timeout(30000),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Fetch failed: ${res.status} ${res.statusText}`);
+  }
+
+  const contentType = res.headers.get("content-type") || "";
+  let text = await res.text();
+
+  // Strip HTML tags for HTML content
+  if (contentType.includes("text/html")) {
+    // Remove script and style blocks
+    text = text.replace(/<script[\s\S]*?<\/script>/gi, "");
+    text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+    // Remove all tags
+    text = text.replace(/<[^>]+>/g, " ");
+    // Collapse whitespace
+    text = text.replace(/\s+/g, " ").trim();
+  }
+
+  if (text.length > maxLength) {
+    text = text.slice(0, maxLength) + "\n\n[Truncated]";
+  }
+
+  return JSON.stringify({ url, contentType, length: text.length, content: text });
+}

package/src/tools/builtin-skills/web-search/SKILL.md

@@ -0,0 +1,26 @@
+# web_search
+
+Search the web using DuckDuckGo and return relevant results.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "query": {
+      "type": "string",
+      "description": "The search query."
+    },
+    "maxResults": {
+      "type": "number",
+      "description": "Maximum number of results to return (default 5)."
+    }
+  },
+  "required": ["query"]
+}
+```
+
+## Usage Hints
+
+Use this tool when the user asks you to search the web, look something up online, or find current information. Good for news, facts, documentation, and general knowledge queries.