@hasna/connectors 1.3.45 → 1.3.46

package/connectors/zymbly/src/api/client.ts

@@ -0,0 +1,166 @@
+import type {
+  HttpMethod,
+  JsonObject,
+  QueryParams,
+  RequestOptions,
+  ZymblyConfig,
+} from "../types";
+import { ZymblyApiError } from "../types";
+
+const DEFAULT_BASE_URL = "https://api.zymbly.com/v1";
+
+function normalizePath(path: string): string {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    throw new Error("Zymbly API path is required");
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    throw new Error("Zymbly API paths must be relative, not absolute URLs");
+  }
+  const normalized = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  if (normalized.split("/").some((part) => part === "..")) {
+    throw new Error("Zymbly API paths cannot contain parent-directory segments");
+  }
+  return normalized;
+}
+
+function encodePath(value: string | number): string {
+  return encodeURIComponent(String(value));
+}
+
+function appendQuery(url: URL, query?: QueryParams): void {
+  if (!query) {
+    return;
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== undefined && item !== null) {
+          url.searchParams.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    if (value !== undefined && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+}
+
+function parseResponse(text: string, contentType: string | null): unknown {
+  if (!text) {
+    return {};
+  }
+  if (contentType?.includes("json") || text.startsWith("{") || text.startsWith("[")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { raw: text };
+    }
+  }
+  return text;
+}
+
+function extractErrorMessage(data: unknown, fallback: string): string {
+  if (typeof data === "string" && data.trim()) {
+    return data.slice(0, 500);
+  }
+  if (data && typeof data === "object") {
+    const record = data as Record<string, unknown>;
+    const message = record.message ?? record.error ?? record.detail ?? record.title;
+    if (typeof message === "string" && message.trim()) {
+      return message;
+    }
+  }
+  return fallback;
+}
+
+export class ZymblyClient {
+  private readonly apiKey?: string;
+  private readonly baseUrl: string;
+
+  constructor(config: ZymblyConfig = {}) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  }
+
+  async request<T = unknown>(path: string, options: RequestOptions = {}): Promise<T> {
+    const method = options.method || (options.body ? "POST" : "GET");
+    const url = this.buildUrl(path, options.query);
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      ...options.headers,
+    };
+    const body = this.prepareBody(method, options);
+    if (body !== undefined && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (options.auth !== false) {
+      headers.Authorization = `Bearer ${this.requireApiKey()}`;
+    }
+    const response = await fetch(url.toString(), { method, headers, body });
+    const text = await response.text();
+    const data = parseResponse(text, response.headers.get("content-type"));
+    if (!response.ok) {
+      throw new ZymblyApiError(
+        extractErrorMessage(data, response.statusText || `Zymbly request failed with ${response.status}`),
+        response.status,
+        data,
+      );
+    }
+    return data as T;
+  }
+
+  listWorkOrders<T = unknown>(query?: QueryParams): Promise<T> {
+    return this.request<T>("/work-orders", { query });
+  }
+
+  getWorkOrder<T = unknown>(workOrderId: string): Promise<T> {
+    return this.request<T>(`/work-orders/${encodePath(workOrderId)}`);
+  }
+
+  searchParts<T = unknown>(query?: QueryParams): Promise<T> {
+    return this.request<T>("/parts", { query });
+  }
+
+  createMaintenanceNote<T = unknown>(workOrderId: string, note: string): Promise<T> {
+    return this.request<T>(`/work-orders/${encodePath(workOrderId)}/notes`, {
+      method: "POST",
+      body: { note },
+    });
+  }
+
+  createMaintenanceNoteWithBody<T = unknown>(workOrderId: string, body: JsonObject): Promise<T> {
+    return this.request<T>(`/work-orders/${encodePath(workOrderId)}/notes`, {
+      method: "POST",
+      body,
+    });
+  }
+
+  rawRequest<T = unknown>(method: HttpMethod, path: string, options: Omit<RequestOptions, "method"> = {}): Promise<T> {
+    return this.request<T>(path, { ...options, method });
+  }
+
+  private buildUrl(path: string, query?: QueryParams): URL {
+    const url = new URL(`${this.baseUrl}${normalizePath(path)}`);
+    appendQuery(url, query);
+    return url;
+  }
+
+  private prepareBody(method: HttpMethod, options: RequestOptions): string | undefined {
+    if (method === "GET") {
+      return undefined;
+    }
+    if (options.body === undefined) {
+      return undefined;
+    }
+    return typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+  }
+
+  private requireApiKey(): string {
+    if (!this.apiKey) {
+      throw new Error("Zymbly API key is required. Use config set-key or set ZYMBLY_API_KEY.");
+    }
+    return this.apiKey;
+  }
+}

package/connectors/zymbly/src/api/index.ts

@@ -0,0 +1 @@
+export { ZymblyClient } from "./client";

package/connectors/zymbly/src/cli/index.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { ZymblyClient } from "../api";
+import type { HttpMethod, JsonObject, JsonValue, OutputFormat, QueryParams, QueryValue } from "../types";
+import {
+  clearConfig,
+  getApiKey,
+  getBaseUrl,
+  getConfigPath,
+  setApiKey,
+  setBaseUrl,
+} from "../utils/config";
+import { error, print, success } from "../utils/output";
+
+const VERSION = "0.0.1";
+const DEFAULT_BASE_URL = "https://api.zymbly.com/v1";
+
+function parseJson(value: string | undefined, label: string): JsonValue {
+  if (!value) {
+    return {};
+  }
+  try {
+    return JSON.parse(value) as JsonValue;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid ${label}: ${message}`);
+  }
+}
+
+function parseObject(value: string | undefined, label: string): JsonObject {
+  const parsed = parseJson(value, label);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return parsed as JsonObject;
+}
+
+function parseQueryParams(value: string | undefined): QueryParams | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const parsed = parseObject(value, "query");
+  const query: QueryParams = {};
+  for (const [key, entry] of Object.entries(parsed)) {
+    if (Array.isArray(entry)) {
+      query[key] = entry.map((item) => {
+        if (typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === undefined) {
+          return item as QueryValue;
+        }
+        throw new Error(`query.${key} must contain only string, number, boolean, null, or undefined values`);
+      });
+      continue;
+    }
+    if (typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean" || entry === null || entry === undefined) {
+      query[key] = entry as QueryValue;
+      continue;
+    }
+    throw new Error(`query.${key} must be a string, number, boolean, null, or an array of those values`);
+  }
+  return query;
+}
+
+function getFormat(command: Command): OutputFormat {
+  return (command.optsWithGlobals().format || "pretty") as OutputFormat;
+}
+
+function getClient(command: Command): ZymblyClient {
+  const options = command.optsWithGlobals();
+  const apiKey = options.apiKey || getApiKey();
+  const baseUrl = options.baseUrl || getBaseUrl();
+  if (!apiKey) {
+    error("No Zymbly API key configured. Use config set-key or set ZYMBLY_API_KEY.");
+    process.exit(1);
+  }
+  return new ZymblyClient({ apiKey, baseUrl });
+}
+
+async function run(command: Command, action: (client: ZymblyClient) => Promise<unknown>): Promise<void> {
+  try {
+    print(await action(getClient(command)), getFormat(command));
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+const program = new Command()
+  .name("connect-zymbly")
+  .description("Zymbly aircraft maintenance API connector")
+  .version(VERSION)
+  .option("-k, --api-key <key>", "Zymbly API key")
+  .option("--base-url <url>", "API base URL", DEFAULT_BASE_URL)
+  .option("-f, --format <format>", "Output format: json or pretty", "pretty");
+
+const config = program.command("config").description("Manage local configuration");
+config.command("set-key <key>").description("Save API key").action((key: string) => {
+  setApiKey(key);
+  success("Zymbly API key saved");
+});
+config.command("set-base-url <url>").description("Save API base URL").action((url: string) => {
+  setBaseUrl(url);
+  success("Zymbly base URL saved");
+});
+config.command("show").description("Show current configuration").action(() => {
+  const key = getApiKey();
+  print({
+    configPath: getConfigPath(),
+    baseUrl: getBaseUrl() || DEFAULT_BASE_URL,
+    apiKey: key ? `${key.slice(0, 6)}...` : null,
+  });
+});
+config.command("clear").description("Clear local configuration").action(() => {
+  clearConfig();
+  success("Zymbly configuration cleared");
+});
+
+const workOrders = program.command("work-orders").description("Manage work orders");
+workOrders
+  .command("list")
+  .description("List work orders")
+  .option("-q, --query <json>", "Query params JSON object")
+  .action((opts, cmd) => run(cmd, (client) => client.listWorkOrders(parseQueryParams(opts.query))));
+workOrders
+  .command("get <workOrderId>")
+  .description("Get a work order by ID")
+  .action((workOrderId: string, _opts, cmd) => run(cmd, (client) => client.getWorkOrder(workOrderId)));
+
+const parts = program.command("parts").description("Search aircraft parts");
+parts
+  .command("search")
+  .description("Search parts catalog")
+  .option("-q, --query <json>", "Query params JSON object")
+  .action((opts, cmd) => run(cmd, (client) => client.searchParts(parseQueryParams(opts.query))));
+
+const notes = program.command("notes").description("Maintenance notes");
+notes
+  .command("create <workOrderId>")
+  .description("Create a maintenance note on a work order")
+  .requiredOption("-n, --note <text>", "Note text")
+  .action((workOrderId: string, opts, cmd) => run(cmd, (client) => client.createMaintenanceNote(workOrderId, opts.note)));
+
+program
+  .command("raw <method> <path>")
+  .description("Call a raw Zymbly API path")
+  .option("-b, --body <json>", "JSON body")
+  .option("-q, --query <json>", "Query params JSON object")
+  .action((method: string, path: string, opts, cmd) =>
+    run(cmd, (client) =>
+      client.rawRequest(method.toUpperCase() as HttpMethod, path, {
+        body: opts.body ? parseJson(opts.body, "body") : undefined,
+        query: parseQueryParams(opts.query),
+      }),
+    ),
+  );
+
+program.parse();

package/connectors/zymbly/src/index.ts

@@ -0,0 +1,12 @@
+export { ZymblyClient } from "./api";
+export type {
+  HttpMethod,
+  JsonObject,
+  JsonPrimitive,
+  JsonValue,
+  OutputFormat,
+  QueryParams,
+  RequestOptions,
+  ZymblyConfig,
+} from "./types";
+export { ZymblyApiError } from "./types";

package/connectors/zymbly/src/types/index.ts

@@ -0,0 +1,34 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+  [key: string]: JsonValue | undefined;
+}
+
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type OutputFormat = "json" | "pretty";
+export type QueryValue = string | number | boolean | null | undefined;
+export type QueryParams = Record<string, QueryValue | QueryValue[]>;
+
+export interface ZymblyConfig {
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+export interface RequestOptions {
+  method?: HttpMethod;
+  body?: JsonValue | string;
+  headers?: Record<string, string>;
+  query?: QueryParams;
+  auth?: boolean;
+}
+
+export class ZymblyApiError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+    public readonly details?: unknown,
+  ) {
+    super(message);
+    this.name = "ZymblyApiError";
+  }
+}

package/connectors/zymbly/src/utils/config.ts

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+interface StoredConfig {
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+const CONFIG_PATH = join(homedir(), ".config", "hasna-connectors", "zymbly.json");
+
+function readConfig(): StoredConfig {
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8")) as StoredConfig;
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config: StoredConfig): void {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function getConfigPath(): string {
+  return CONFIG_PATH;
+}
+
+export function getApiKey(): string | undefined {
+  return process.env.ZYMBLY_API_KEY || readConfig().apiKey;
+}
+
+export function getBaseUrl(): string | undefined {
+  return process.env.ZYMBLY_BASE_URL || readConfig().baseUrl;
+}
+
+export function setApiKey(apiKey: string): void {
+  writeConfig({ ...readConfig(), apiKey });
+}
+
+export function setBaseUrl(baseUrl: string): void {
+  writeConfig({ ...readConfig(), baseUrl });
+}
+
+export function clearConfig(): void {
+  if (existsSync(CONFIG_PATH)) {
+    rmSync(CONFIG_PATH);
+  }
+}

package/connectors/zymbly/src/utils/output.ts

@@ -0,0 +1,17 @@
+import type { OutputFormat } from "../types";
+
+export function print(data: unknown, format: OutputFormat = "pretty"): void {
+  if (format === "json") {
+    console.log(JSON.stringify(data));
+    return;
+  }
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function error(message: string): void {
+  console.error(message);
+}
+
+export function success(message: string): void {
+  console.log(message);
+}

package/connectors/zymbly/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist",
+    "skipLibCheck": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"]
+}

package/dist/index.js

@@ -5764,7 +5764,7 @@ function extractGoogleError(body) {
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.45",
+  version: "1.3.46",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -5796,11 +5796,12 @@ var package_default = {
     "build:dashboard": "cd dashboard && bun run build",
     postinstall: 'mkdir -p $HOME/.hasna/connectors 2>/dev/null || true; [ "$SKIP_DASHBOARD" = "1" ] || [ ! -f dashboard/package.json ] || [ -d dashboard/node_modules ] || (cd dashboard && bun install)',
     dev: "bun run ./src/cli/index.tsx",
+    "check:package-secrets": "bun run scripts/check-package-secrets.ts",
     typecheck: "tsc --noEmit && tsc -p tsconfig.social.json --noEmit",
     test: "bun test",
     "secrets:scan:npmrc": "bun run scripts/scan-npmrc-auth.mjs",
     "sdk:build": "cd sdk && bun run build",
-    prepublishOnly: "bun run secrets:scan:npmrc && bun run build && bun test"
+    prepublishOnly: "bun run secrets:scan:npmrc && bun run check:package-secrets && bun run build && bun test"
   },
   keywords: [
     "connectors",
@@ -18603,6 +18604,13 @@ var connectors = [
     category: "AI & ML",
     tags: ["transcription", "meetings", "ai"]
   },
+  {
+    name: "wandb",
+    displayName: "Weights & Biases",
+    description: "ML experiment tracking and run management via GraphQL",
+    category: "AI & ML",
+    tags: ["ml", "experiments", "tracking"]
+  },
   {
     name: "wato",
     displayName: "Wato",
@@ -18610,6 +18618,13 @@ var connectors = [
     category: "AI & ML",
     tags: ["ai", "agents", "memory", "workflows"]
   },
+  {
+    name: "weights-biases",
+    displayName: "Weights & Biases",
+    description: "ML experiment tracking (runs, events, search)",
+    category: "AI & ML",
+    tags: ["ai", "ml", "wandb", "experiment-tracking"]
+  },
   {
     name: "wavelineextract",
     displayName: "Waveline Extract",
@@ -20248,6 +20263,20 @@ var connectors3 = [
     description: "HR platform for employees, leave, attendance, and timesheets",
     category: "Business Tools",
     tags: ["hr", "employees", "zoho"]
+  },
+  {
+    name: "zymbly",
+    displayName: "Zymbly",
+    description: "Aircraft maintenance and CMMS platform for work orders, parts, and maintenance notes",
+    category: "Business Tools",
+    tags: ["maintenance", "aircraft", "work-orders", "cmms"]
+  },
+  {
+    name: "zotero",
+    displayName: "Zotero",
+    description: "Bibliography and reference library API for items, collections, and attachments",
+    category: "Business Tools",
+    tags: ["bibliography", "citations", "research", "library", "references"]
   }
 ];
 
@@ -22758,6 +22787,13 @@ var connectors9 = [
     category: "Developer Tools",
     tags: ["cdn", "dns", "edge"]
   },
+  {
+    name: "cloudflare-workers",
+    displayName: "Cloudflare Workers",
+    description: "Cloudflare Workers REST API connector for scripts, multipart uploads, routes, deployments, versions, secrets, cron schedules, tails, subdomains, beta Workers, and scoped raw account or zone requests",
+    category: "Developer Tools",
+    tags: ["cloudflare", "workers", "serverless", "edge", "deployments", "developer-tools"]
+  },
   {
     name: "googlecloud",
     displayName: "Google Cloud",
@@ -25150,6 +25186,13 @@ var connectors14 = [
     description: "Reviews and user-generated content platform for e-commerce",
     category: "Marketing & Sales",
     tags: ["reviews", "ugc", "ecommerce", "marketing"]
+  },
+  {
+    name: "zoominfo",
+    displayName: "ZoomInfo",
+    description: "ZoomInfo B2B sales intelligence API for contact and company search, enrichment, lookup, and output field discovery",
+    category: "Marketing & Sales",
+    tags: ["sales-intelligence", "enrichment", "contacts", "companies", "b2b"]
   }
 ];
 

package/dist/lib/compact-output.d.ts

@@ -0,0 +1,40 @@
+import type { ConnectorMeta } from "./registry.js";
+export declare const DEFAULT_COMPACT_LIMIT = 20;
+export declare const DEFAULT_MCP_LIMIT = 20;
+export declare const MAX_COMPACT_LIMIT = 100;
+export declare const DEFAULT_TEXT_WIDTH = 96;
+export declare const DEFAULT_OUTPUT_CHARS = 6000;
+export type ParseIntResult = {
+    value: number | undefined;
+    error?: string;
+};
+export declare function parseNonNegativeInt(raw: string | undefined, flag: string): ParseIntResult;
+export declare function normalizeLimit(value: number | undefined, fallback: number, max?: number): number;
+export declare function parseCursor(raw: string | undefined): ParseIntResult;
+export declare function pageItems<T>(items: T[], options: {
+    offset?: number;
+    limit?: number;
+}): {
+    items: T[];
+    total: number;
+    offset: number;
+    limit: number | null;
+    nextOffset: number | null;
+};
+export declare function truncateText(value: string | undefined, max?: number): string;
+export declare function firstNonEmptyLines(value: string | undefined, maxLines: number, maxWidth?: number): string[];
+export declare function compactConnector(connector: ConnectorMeta, descriptionWidth?: number): {
+    name: string;
+    displayName: string;
+    version: string | undefined;
+    category: string;
+    description: string;
+};
+export declare function maybeTruncateOutput(text: string, options?: {
+    maxChars?: number;
+    enabled?: boolean;
+    hint?: string;
+}): {
+    text: string;
+    truncated: boolean;
+};

package/dist/mcp/tools/jobs.d.ts

@@ -1,7 +1,39 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type WorkflowResult } from "../../lib/workflow-runner.js";
+import { triggerJob } from "../../lib/scheduler.js";
+type JobExecutionResult = Awaited<ReturnType<typeof triggerJob>>;
+type ExecutionCompactOptions = {
+    verbose?: boolean;
+    maxOutputChars?: number;
+};
+export declare function compactJobExecutionResult(result: JobExecutionResult, options?: ExecutionCompactOptions): {
+    output: string;
+    outputTruncated: boolean;
+    hint: string | undefined;
+    run_id: string;
+    exit_code: number;
+};
+export declare function compactWorkflowExecutionResult(result: WorkflowResult, options?: ExecutionCompactOptions): {
+    steps: {
+        output: string;
+        outputTruncated: boolean;
+        step: number;
+        connector: string;
+        command: string;
+        exit_code: number;
+    }[];
+    final_output: string;
+    finalOutputTruncated: boolean;
+    truncatedOutputs: number;
+    hint: string | undefined;
+    workflow_id: string;
+    workflow_name: string;
+    success: boolean;
+};
 export declare function registerJobsTools(server: McpServer, stripped: (text: string) => Promise<{
     content: {
         type: "text";
         text: string;
     }[];
 }>): void;
+export {};

package/dist/mcp/tools/jobs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "1.3.45",
+  "version": "1.3.46",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {
@@ -32,11 +32,12 @@
     "build:dashboard": "cd dashboard && bun run build",
     "postinstall": "mkdir -p $HOME/.hasna/connectors 2>/dev/null || true; [ \"$SKIP_DASHBOARD\" = \"1\" ] || [ ! -f dashboard/package.json ] || [ -d dashboard/node_modules ] || (cd dashboard && bun install)",
     "dev": "bun run ./src/cli/index.tsx",
+    "check:package-secrets": "bun run scripts/check-package-secrets.ts",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.social.json --noEmit",
     "test": "bun test",
     "secrets:scan:npmrc": "bun run scripts/scan-npmrc-auth.mjs",
     "sdk:build": "cd sdk && bun run build",
-    "prepublishOnly": "bun run secrets:scan:npmrc && bun run build && bun test"
+    "prepublishOnly": "bun run secrets:scan:npmrc && bun run check:package-secrets && bun run build && bun test"
   },
   "keywords": [
     "connectors",