zubo 0.1.0

package/src/tools/builtin/run-workflow.ts

@@ -0,0 +1,36 @@
+import { registerTool } from "../registry";
+import type { LlmProvider } from "../../llm/provider";
+import { executeWorkflow } from "../../agent/workflow-executor";
+
+export function registerRunWorkflowTool(llm: LlmProvider) {
+  registerTool({
+    definition: {
+      name: "run_workflow",
+      description:
+        "Execute a multi-agent workflow by name. Provide the workflow name and an input string. Steps execute respecting dependencies.",
+      input_schema: {
+        type: "object",
+        properties: {
+          workflow: {
+            type: "string",
+            description: "Name of the workflow to execute",
+          },
+          input: {
+            type: "string",
+            description: "Input text for the workflow (available as $input in step tasks)",
+          },
+        },
+        required: ["workflow", "input"],
+      },
+    },
+    async execute(input) {
+      const workflowName = input.workflow as string;
+      const workflowInput = input.input as string;
+
+      if (!workflowName) return JSON.stringify({ error: "workflow name is required" });
+
+      const result = await executeWorkflow(llm, workflowName, workflowInput);
+      return JSON.stringify(result);
+    },
+  });
+}

package/src/tools/builtin/secrets.ts

@@ -0,0 +1,122 @@
+import { registerTool } from "../registry";
+import { setSecret, listSecrets, deleteSecret } from "../../secrets/store";
+
+export function registerSecretTools() {
+  registerTool({
+    definition: {
+      name: "secret_set",
+      description:
+        "Store a secret (API key, token, credential). The value is saved securely and never shown in conversation. Use this when the user provides credentials.",
+      input_schema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description:
+              "Secret name (e.g., 'github_token', 'google_api_key'). Use lowercase with underscores.",
+          },
+          value: {
+            type: "string",
+            description: "The secret value (API key, token, etc.)",
+          },
+          service: {
+            type: "string",
+            description:
+              "Optional service name this secret belongs to (e.g., 'github', 'google', 'notion')",
+          },
+        },
+        required: ["name", "value"],
+      },
+    },
+    execute: async (input) => {
+      const { name, value, service } = input as {
+        name: string;
+        value: string;
+        service?: string;
+      };
+
+      if (!name || !/^[a-z0-9_]+$/.test(name)) {
+        return JSON.stringify({ error: "Invalid name. Must match [a-z0-9_]+" });
+      }
+      if (!value) {
+        return JSON.stringify({ error: "Value is required." });
+      }
+
+      setSecret(name, value, service);
+      return JSON.stringify({
+        success: true,
+        name,
+        service: service ?? null,
+        message: `Secret "${name}" stored securely.`,
+      });
+    },
+  });
+
+  registerTool({
+    definition: {
+      name: "secret_list",
+      description:
+        "List stored secret names (never shows values). Use this to check what credentials are available.",
+      input_schema: {
+        type: "object",
+        properties: {
+          service: {
+            type: "string",
+            description: "Optional: filter by service name (e.g., 'github')",
+          },
+        },
+      },
+    },
+    execute: async (input) => {
+      const { service } = input as { service?: string };
+      const secrets = listSecrets(service);
+
+      if (secrets.length === 0) {
+        return service
+          ? `No secrets found for service "${service}".`
+          : "No secrets stored yet.";
+      }
+
+      return JSON.stringify({
+        secrets: secrets.map((s) => ({
+          name: s.name,
+          service: s.service,
+          updated_at: s.updated_at,
+        })),
+        count: secrets.length,
+      });
+    },
+  });
+
+  registerTool({
+    definition: {
+      name: "secret_delete",
+      description: "Delete a stored secret by name.",
+      input_schema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "The name of the secret to delete",
+          },
+        },
+        required: ["name"],
+      },
+    },
+    execute: async (input) => {
+      const { name } = input as { name: string };
+      if (!name) {
+        return JSON.stringify({ error: "Secret name is required." });
+      }
+
+      const deleted = deleteSecret(name);
+      if (deleted) {
+        return JSON.stringify({
+          success: true,
+          message: `Secret "${name}" deleted.`,
+        });
+      }
+      return JSON.stringify({ error: `No secret found with name "${name}".` });
+    },
+  });
+}

package/src/tools/builtin/skill-registry.ts

@@ -0,0 +1,75 @@
+import { registerTool } from "../registry";
+import { searchRegistry } from "../../registry/client";
+import { installFromRegistry } from "../../registry/installer";
+import { loadSkills } from "../skill-loader";
+import { paths } from "../../config/paths";
+import { logger } from "../../util/logger";
+
+export function registerSkillRegistryTool() {
+  registerTool({
+    definition: {
+      name: "skill_registry",
+      description:
+        "Search and install skills from the Zubo skill registry. Use action 'search' to find skills, 'install' to install one.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["search", "install"],
+            description: "Action to perform",
+          },
+          query: {
+            type: "string",
+            description: "Search query (for action=search)",
+          },
+          name: {
+            type: "string",
+            description: "Skill name to install (for action=install)",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    async execute(input) {
+      const action = input.action as string;
+
+      if (action === "search") {
+        const query = (input.query as string) ?? "";
+        if (!query) return JSON.stringify({ error: "query is required for search" });
+        const results = await searchRegistry(query);
+        if (results.length === 0) return JSON.stringify({ results: [], message: "No skills found" });
+        return JSON.stringify({
+          results: results.map((r) => ({
+            name: r.name,
+            description: r.description,
+            tags: r.tags,
+            secrets: r.secrets,
+          })),
+        });
+      }
+
+      if (action === "install") {
+        const name = (input.name as string) ?? "";
+        if (!name) return JSON.stringify({ error: "name is required for install" });
+        const result = await installFromRegistry(name);
+        if (result.success) {
+          // Reload skills so the new skill is available immediately
+          try {
+            await loadSkills(paths.skills);
+          } catch (err: any) {
+            logger.warn("Failed to reload skills after install", { error: (err as Error).message });
+          }
+          return JSON.stringify({
+            installed: true,
+            name: result.name,
+            requiredSecrets: result.requiredSecrets,
+          });
+        }
+        return JSON.stringify({ installed: false, error: result.error });
+      }
+
+      return JSON.stringify({ error: `Unknown action: ${action}` });
+    },
+  });
+}

package/src/tools/builtin-integrations/api-helpers.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared helpers for integration handlers.
+ * Prevents leaking secrets/tokens via API error responses or exception messages.
+ */
+
+/**
+ * Safely handle an API response error. Logs the full error but returns
+ * only the status code to the conversation — never the response body,
+ * which may echo tokens or internal details.
+ */
+export async function safeApiError(res: Response, service: string): Promise<string> {
+  // Read body once so it doesn't hang
+  const body = await res.text().catch(() => "");
+  // Log full details for debugging (goes to zubo.log, not conversation)
+  console.error(`[${service}] API error ${res.status}: ${body.slice(0, 500)}`);
+  return JSON.stringify({ error: `${service} API error: ${res.status} ${res.statusText}` });
+}
+
+/**
+ * Safely handle an exception. Never expose raw error messages which
+ * may contain tokens, URLs with credentials, or internal details.
+ */
+export 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.` });
+}

package/src/tools/builtin-integrations/github/github_issues/SKILL.md

@@ -0,0 +1,56 @@
+# github_issues
+
+Manage GitHub issues: list, create, get details, and add comments. Requires a GitHub personal access token stored as `github_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["list", "create", "get", "comment"],
+      "description": "The action to perform"
+    },
+    "owner": {
+      "type": "string",
+      "description": "Repository owner (user or org)"
+    },
+    "repo": {
+      "type": "string",
+      "description": "Repository name"
+    },
+    "issue_number": {
+      "type": "number",
+      "description": "Issue number (required for get and comment)"
+    },
+    "title": {
+      "type": "string",
+      "description": "Issue title (required for create)"
+    },
+    "body": {
+      "type": "string",
+      "description": "Issue body or comment text"
+    },
+    "labels": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Labels to apply (for create)"
+    },
+    "state": {
+      "type": "string",
+      "enum": ["open", "closed", "all"],
+      "description": "Filter by state (for list, default: open)"
+    }
+  },
+  "required": ["action", "owner", "repo"]
+}
+```
+
+## Usage Hints
+
+- Use action "list" to see open issues for a repo.
+- Use action "create" with title and body to open a new issue.
+- Use action "get" with issue_number to see issue details.
+- Use action "comment" with issue_number and body to add a comment.

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

@@ -0,0 +1,108 @@
+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, issue_number, title, body, labels, state } = input as {
+    action: string;
+    owner: string;
+    repo: string;
+    issue_number?: number;
+    title?: string;
+    body?: string;
+    labels?: string[];
+    state?: string;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "User-Agent": "Zubo-Agent",
+  };
+
+  try {
+    switch (action) {
+      case "list": {
+        const qs = new URLSearchParams({ state: state || "open", per_page: "30" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/issues?${qs}`, { headers });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const issues = (await res.json()) as any[];
+        return JSON.stringify(
+          issues.map((i) => ({
+            number: i.number,
+            title: i.title,
+            state: i.state,
+            user: i.user?.login,
+            labels: i.labels?.map((l: any) => l.name),
+            created_at: i.created_at,
+            comments: i.comments,
+          }))
+        );
+      }
+
+      case "create": {
+        if (!title) return JSON.stringify({ error: "title is required for create" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/issues`, {
+          method: "POST",
+          headers: { ...headers, "Content-Type": "application/json" },
+          body: JSON.stringify({ title, body: body || "", labels: labels || [] }),
+        });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const issue = (await res.json()) as any;
+        return JSON.stringify({ number: issue.number, title: issue.title, url: issue.html_url });
+      }
+
+      case "get": {
+        if (!issue_number) return JSON.stringify({ error: "issue_number is required for get" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/issues/${issue_number}`, { headers });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const issue = (await res.json()) as any;
+        return JSON.stringify({
+          number: issue.number,
+          title: issue.title,
+          state: issue.state,
+          body: issue.body,
+          user: issue.user?.login,
+          labels: issue.labels?.map((l: any) => l.name),
+          created_at: issue.created_at,
+          comments: issue.comments,
+          url: issue.html_url,
+        });
+      }
+
+      case "comment": {
+        if (!issue_number) return JSON.stringify({ error: "issue_number is required for comment" });
+        if (!body) return JSON.stringify({ error: "body is required for comment" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/issues/${issue_number}/comments`, {
+          method: "POST",
+          headers: { ...headers, "Content-Type": "application/json" },
+          body: JSON.stringify({ body }),
+        });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const comment = (await res.json()) as any;
+        return JSON.stringify({ id: comment.id, url: comment.html_url, created_at: comment.created_at });
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "GitHub");
+  }
+}

package/src/tools/builtin-integrations/github/github_prs/SKILL.md

@@ -0,0 +1,57 @@
+# github_prs
+
+Manage GitHub pull requests: list, create, get details, and review. Requires a GitHub personal access token stored as `github_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["list", "create", "get", "review"],
+      "description": "The action to perform"
+    },
+    "owner": {
+      "type": "string",
+      "description": "Repository owner (user or org)"
+    },
+    "repo": {
+      "type": "string",
+      "description": "Repository name"
+    },
+    "pr_number": {
+      "type": "number",
+      "description": "PR number (required for get and review)"
+    },
+    "title": {
+      "type": "string",
+      "description": "PR title (required for create)"
+    },
+    "body": {
+      "type": "string",
+      "description": "PR body or review comment"
+    },
+    "head": {
+      "type": "string",
+      "description": "Head branch (required for create)"
+    },
+    "base": {
+      "type": "string",
+      "description": "Base branch (required for create, default: main)"
+    },
+    "event": {
+      "type": "string",
+      "enum": ["APPROVE", "REQUEST_CHANGES", "COMMENT"],
+      "description": "Review event type (for review, default: COMMENT)"
+    },
+    "state": {
+      "type": "string",
+      "enum": ["open", "closed", "all"],
+      "description": "Filter by state (for list, default: open)"
+    }
+  },
+  "required": ["action", "owner", "repo"]
+}
+```

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

@@ -0,0 +1,113 @@
+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, pr_number, title, body, head, base, event, state } = input as {
+    action: string;
+    owner: string;
+    repo: string;
+    pr_number?: number;
+    title?: string;
+    body?: string;
+    head?: string;
+    base?: string;
+    event?: string;
+    state?: string;
+  };
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "User-Agent": "Zubo-Agent",
+  };
+
+  try {
+    switch (action) {
+      case "list": {
+        const qs = new URLSearchParams({ state: state || "open", per_page: "30" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/pulls?${qs}`, { headers });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const prs = (await res.json()) as any[];
+        return JSON.stringify(
+          prs.map((p) => ({
+            number: p.number,
+            title: p.title,
+            state: p.state,
+            user: p.user?.login,
+            head: p.head?.ref,
+            base: p.base?.ref,
+            created_at: p.created_at,
+            url: p.html_url,
+          }))
+        );
+      }
+
+      case "create": {
+        if (!title) return JSON.stringify({ error: "title is required for create" });
+        if (!head) return JSON.stringify({ error: "head branch is required for create" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/pulls`, {
+          method: "POST",
+          headers: { ...headers, "Content-Type": "application/json" },
+          body: JSON.stringify({ title, body: body || "", head, base: base || "main" }),
+        });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const pr = (await res.json()) as any;
+        return JSON.stringify({ number: pr.number, title: pr.title, url: pr.html_url });
+      }
+
+      case "get": {
+        if (!pr_number) return JSON.stringify({ error: "pr_number is required for get" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/pulls/${pr_number}`, { headers });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const pr = (await res.json()) as any;
+        return JSON.stringify({
+          number: pr.number,
+          title: pr.title,
+          state: pr.state,
+          body: pr.body,
+          user: pr.user?.login,
+          head: pr.head?.ref,
+          base: pr.base?.ref,
+          mergeable: pr.mergeable,
+          merged: pr.merged,
+          created_at: pr.created_at,
+          url: pr.html_url,
+        });
+      }
+
+      case "review": {
+        if (!pr_number) return JSON.stringify({ error: "pr_number is required for review" });
+        const res = await fetch(`${API}/repos/${owner}/${repo}/pulls/${pr_number}/reviews`, {
+          method: "POST",
+          headers: { ...headers, "Content-Type": "application/json" },
+          body: JSON.stringify({ body: body || "", event: event || "COMMENT" }),
+        });
+        if (!res.ok) return await safeApiError(res, "GitHub");
+        const review = (await res.json()) as any;
+        return JSON.stringify({ id: review.id, state: review.state, url: review.html_url });
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${action}` });
+    }
+  } catch (err: any) {
+    return safeExceptionError(err, "GitHub");
+  }
+}

package/src/tools/builtin-integrations/github/github_repos/SKILL.md

@@ -0,0 +1,37 @@
+# github_repos
+
+List and get information about GitHub repositories. Requires a GitHub personal access token stored as `github_token`.
+
+## Input Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": ["list", "get"],
+      "description": "The action to perform"
+    },
+    "owner": {
+      "type": "string",
+      "description": "Repository owner or user whose repos to list"
+    },
+    "repo": {
+      "type": "string",
+      "description": "Repository name (required for get)"
+    },
+    "type": {
+      "type": "string",
+      "enum": ["all", "owner", "member"],
+      "description": "Filter repos by type (for list, default: owner)"
+    },
+    "sort": {
+      "type": "string",
+      "enum": ["created", "updated", "pushed", "full_name"],
+      "description": "Sort field (for list, default: updated)"
+    }
+  },
+  "required": ["action"]
+}
+```