@zeph-to/cli 1.12.0

package/dist/zeph-hook.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZephHook = void 0;
+const errors_js_1 = require("./errors.js");
+const crypto_js_1 = require("./crypto.js");
+const DEFAULT_BASE_URL = 'https://api.zeph.to/v1';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const BODY_FILE_THRESHOLD = 512;
+const PREVIEW_LENGTH = 200;
+const inferMimeType = (fileName) => {
+    const ext = fileName.split('.').pop()?.toLowerCase();
+    const map = { md: 'text/markdown', txt: 'text/plain', json: 'application/json' };
+    return map[ext ?? ''] ?? 'text/plain';
+};
+class ZephHook {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    cryptoInitialized = false;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new errors_js_1.ZephError('apiKey is required', 'INVALID_OPTIONS', 400);
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, '');
+        this.timeoutMs = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    }
+    async ensureCrypto() {
+        if (this.cryptoInitialized)
+            return !!(0, crypto_js_1.getKeyPair)();
+        try {
+            await (0, crypto_js_1.initCrypto)(this.apiKey, this.baseUrl);
+            this.cryptoInitialized = true;
+            return !!(0, crypto_js_1.getKeyPair)();
+        }
+        catch {
+            this.cryptoInitialized = true;
+            return false;
+        }
+    }
+    async notify(payload) {
+        const canEncrypt = await this.ensureCrypto();
+        const body = payload.body;
+        const bodyBytes = body ? new TextEncoder().encode(body).byteLength : 0;
+        const isLongBody = bodyBytes > BODY_FILE_THRESHOLD;
+        if (isLongBody && body) {
+            return this.notifyWithFile(payload, body, bodyBytes, canEncrypt);
+        }
+        // Encrypt push body if possible
+        let sendPayload = { ...payload };
+        if (canEncrypt) {
+            try {
+                const enc = await (0, crypto_js_1.encryptPushBodyForSelf)({ title: payload.title, body: payload.body, url: payload.url });
+                sendPayload = { ...sendPayload, title: undefined, body: enc.body, isEncrypted: true, encryptedKey: enc.encryptedKey, senderPublicKey: enc.senderPublicKey };
+            }
+            catch (err) {
+                console.error('[Crypto] Push encryption failed, sending plaintext:', err);
+            }
+        }
+        const json = await this.request('POST', '/pushes/send', sendPayload);
+        const pushId = json.data?.pushId;
+        if (!pushId) {
+            throw new errors_js_1.ZephError('Server returned no pushId', 'INVALID_RESPONSE', 500);
+        }
+        return { pushId };
+    }
+    async notifyWithFile(payload, body, fileSize, canEncrypt) {
+        const fileName = 'response.md';
+        let fileType = inferMimeType(fileName);
+        // Encrypt file content if possible
+        let uploadContent = body;
+        let uploadSize = fileSize;
+        let fileIv;
+        let fileEncryptedKey;
+        if (canEncrypt) {
+            try {
+                const encrypted = await (0, crypto_js_1.encryptFileForSelf)(body);
+                uploadContent = encrypted.ciphertext;
+                uploadSize = encrypted.ciphertext.length;
+                fileType = 'application/octet-stream';
+                fileIv = encrypted.iv;
+                fileEncryptedKey = encrypted.encryptedKey;
+            }
+            catch (err) {
+                console.error('[Crypto] File encryption failed, sending plaintext:', err);
+            }
+        }
+        const upload = await this.requestUpload({ fileName, fileType, fileSize: uploadSize });
+        await this.uploadToS3(upload.uploadUrl, uploadContent, fileType);
+        const preview = body.length > PREVIEW_LENGTH ? body.slice(0, PREVIEW_LENGTH) + '...' : body;
+        // Encrypt push body
+        let sendPayload = {
+            ...payload,
+            body: preview,
+            type: payload.type ?? 'file',
+            files: [{ fileKey: upload.fileKey, fileName, fileSize, fileType: inferMimeType(fileName), iv: fileIv, encryptedKey: fileEncryptedKey }],
+        };
+        if (canEncrypt) {
+            try {
+                const enc = await (0, crypto_js_1.encryptPushBodyForSelf)({ title: payload.title, body: preview, url: payload.url });
+                sendPayload = { ...sendPayload, title: undefined, body: enc.body, isEncrypted: true, encryptedKey: enc.encryptedKey, senderPublicKey: enc.senderPublicKey };
+            }
+            catch (err) {
+                console.error('[Crypto] Push encryption failed, sending plaintext:', err);
+            }
+        }
+        const json = await this.request('POST', '/pushes/send', sendPayload);
+        const pushId = json.data?.pushId;
+        if (!pushId) {
+            throw new errors_js_1.ZephError('Server returned no pushId', 'INVALID_RESPONSE', 500);
+        }
+        return { pushId, fileKey: upload.fileKey, autoFile: true };
+    }
+    async requestUpload(params) {
+        const json = await this.request('POST', '/files/upload-request', params);
+        return json.data;
+    }
+    async uploadToS3(url, content, contentType) {
+        const isText = typeof content === 'string';
+        const body = isText ? content : new Uint8Array(content);
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: { 'Content-Type': isText ? `${contentType}; charset=utf-8` : contentType },
+            body,
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!response.ok) {
+            throw new errors_js_1.ZephError(`S3 upload failed with status ${response.status}`, 'UPLOAD_FAILED', response.status);
+        }
+    }
+    async list(params) {
+        const query = new URLSearchParams();
+        if (params?.limit)
+            query.set('limit', String(params.limit));
+        if (params?.type)
+            query.set('type', params.type);
+        const qs = query.toString();
+        const json = await this.request('GET', `/pushes${qs ? `?${qs}` : ''}`);
+        const pushes = json.data.map((p) => ({
+            pushId: p.pushId,
+            type: p.type,
+            title: p.title,
+            body: p.body?.slice(0, 100),
+            createdAt: p.createdAt,
+        }));
+        return { pushes, count: pushes.length, hasMore: json.pagination?.hasMore ?? false };
+    }
+    async dismiss(pushId) {
+        await this.request('POST', `/pushes/${encodeURIComponent(pushId)}/dismiss`);
+        return { dismissed: true };
+    }
+    async dismissAll() {
+        const json = await this.request('POST', '/pushes/dismiss-all');
+        return { dismissed: json.data?.dismissed ?? 0 };
+    }
+    async request(method, path, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        const headers = { 'X-API-Key': this.apiKey };
+        if (body)
+            headers['Content-Type'] = 'application/json';
+        let response;
+        try {
+            response = await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                throw new errors_js_1.ZephError(`Request timed out after ${this.timeoutMs}ms`, 'TIMEOUT', 408);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const json = await response.json();
+        if (!response.ok) {
+            throw this.parseError(response.status, json);
+        }
+        return json;
+    }
+    parseError(status, body) {
+        const message = body.error?.message ?? `Request failed with status ${status}`;
+        const code = body.error?.code ?? 'UNKNOWN_ERROR';
+        if (status === 401)
+            return new errors_js_1.AuthenticationError(message);
+        if (status === 403 && code === 'QUOTA_EXCEEDED')
+            return new errors_js_1.QuotaExceededError(message);
+        return new errors_js_1.ZephError(message, code, status);
+    }
+}
+exports.ZephHook = ZephHook;

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@zeph-to/cli",
+  "version": "1.12.0",
+  "description": "Zeph CLI + push notification SDK for AI agents",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "zeph": "./dist/cli.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.8.0",
+    "vitest": "^2.1.9"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github"
+    ]
+  },
+  "author": "Zeph <dev@zeph.to>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeph-to/cli"
+  },
+  "homepage": "https://github.com/zeph-to/cli",
+  "bugs": {
+    "url": "https://github.com/zeph-to/cli/issues"
+  },
+  "keywords": [
+    "zeph",
+    "push",
+    "notification",
+    "cli",
+    "webhook",
+    "ai-agent",
+    "mcp",
+    "claude",
+    "devtools"
+  ],
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.4.3",
+    "ws": "^8.21.0"
+  }
+}