@myapihq/sdk 2.9.0 → 2.11.0

package/dist/client.d.ts

@@ -34,6 +34,7 @@ export interface RequestOptions {
      */
     onReplay?: () => void;
 }
+export declare function toError(err: any, status: number): MyApiError;
 export declare function request<T>(method: string, url: string, apiKey?: string, body?: unknown, extraHeaders?: Record<string, string>, opts?: RequestOptions): Promise<T>;
 export interface Page<T> {
     data: T[];

package/dist/client.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MyApiError = void 0;
 exports.setUserAgent = setUserAgent;
+exports.toError = toError;
 exports.request = request;
 exports.requestPage = requestPage;
 const version_1 = require("./version");
@@ -267,11 +268,31 @@ async function parseResponse(method, url, response) {
     }
     return apiResponse;
 }
+// Build a MyApiError from a backend error object.
+//
+// The backend sends BOTH `message` and `detail`, and they carry different
+// weight: `message` is the short generic line, `detail` is the specific
+// reason. This used to read `message` only, so the specific reason was parsed,
+// stored on `body`, and never shown. A customer lost a diagnosis to exactly
+// that — outbound email answered
+//
+//   { code: "SEND_FAILED", message: "relay failed",
+//     detail: "this account is not provisioned for outbound email" }
+//
+// and the CLI printed "relay failed", which sends you to DNS, SPF and the
+// mailbox. The six words that named an account-level state they could not fix
+// themselves were in the response the whole time.
+//
+// So: prefer `detail`, fall back to `message`. `body` still carries the full
+// object for callers that want both. Exported because three call sites
+// (here, function.uploadBundle, storage.uploadAsset) each hand-rolled this
+// and each had the same bug.
 function toError(err, status) {
-    const code = typeof err === 'object' && err !== null ? (err?.code || 'unknown_error') : (err || 'unknown_error');
-    const detail = typeof err === 'object' && err !== null ? (err?.message || undefined) : undefined;
-    const errBody = typeof err === 'object' && err !== null ? err : undefined;
-    return new MyApiError(code, status, detail, errBody);
+    const obj = typeof err === 'object' && err !== null ? err : undefined;
+    const code = obj ? (obj.code || 'unknown_error') : (err || 'unknown_error');
+    const pick = (v) => (typeof v === 'string' && v.trim() !== '' ? v : undefined);
+    const detail = obj ? (pick(obj.detail) ?? pick(obj.message)) : undefined;
+    return new MyApiError(code, status, detail, obj);
 }
 // Returns the unwrapped `data` payload — the common case.
 async function request(method, url, apiKey, body, extraHeaders, opts) {

package/dist/container.js

@@ -78,6 +78,11 @@ async function deployContainerSource(apiKey, orgId, containerId, tarball, filena
     // dropped here: the options never reached this function at all.
     if (opts.promote === false)
         formData.append('promote', 'false');
+    // Multipart takes the assertion as a JSON string. Wired here as well as on
+    // the JSON path, because the outage this exists to prevent was a source
+    // build and the first version of this flag reached only the image path.
+    if (opts.smoke)
+        formData.append('smoke', JSON.stringify(opts.smoke));
     const response = await fetch(`${config_1.CONTAINER_BASE}/container/orgs/${encodeURIComponent(orgId)}/containers/${encodeURIComponent(containerId)}/deploy`, { method: 'POST', headers: { Authorization: `Bearer ${apiKey}` }, body: formData });
     let result;
     try {

package/dist/function.js

@@ -50,10 +50,9 @@ async function uploadBundle(apiKey, orgId, fnId, bundle, filename = 'bundle.js')
         throw new client_1.MyApiError('invalid_json_response', response.status);
     }
     if (!response.ok || !result?.success) {
-        const err = result?.error;
-        const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
-        const detail = typeof err === 'object' ? err?.message : undefined;
-        throw new client_1.MyApiError(code, response.status, detail, typeof err === 'object' ? err : undefined);
+        // Shared with client.ts so this path cannot drift back to reading
+        // `message` and dropping the specific `detail` — see toError.
+        throw (0, client_1.toError)(result?.error, response.status);
     }
     return result.data;
 }

package/dist/services.js

@@ -118,6 +118,22 @@ exports.SERVICES = [
         status: 'preview',
         keywords: k('pixel', 'analytics', 'tracking', 'visit', 'identity'),
     },
+    {
+        // CLI top-level command + SDK namespace are both `feedback`; skill
+        // directory is `my-feedback-api`. Inbound like webhook/pixel, but the
+        // sender is a person rather than a system.
+        //
+        // Not ga: classification and duplicate-grouping are designed and not
+        // built, so `kind` is the reporter's own label rather than a processed
+        // signal. The CLI surface itself is stable.
+        module: 'feedback',
+        skill: 'my-feedback-api',
+        domain: 'myfeedbackapi.com',
+        description: 'Collect feedback from the people using what you built. A public widget key lets a page submit without a credential; you list, filter, and resolve the results.',
+        category: 'capture',
+        status: 'preview',
+        keywords: k('feedback', 'bug-report', 'feature-request', 'widget', 'support'),
+    },
     // ── data ────────────────────────────────────────────────────────────
     {
         // Goldfox-backed people search is gated pre-launch — 503 SERVICE_NOT_LAUNCHED.

package/dist/storage.d.ts

@@ -1,14 +1,38 @@
 import type { Exposes } from './exposes';
 export declare const EXPOSES: Exposes;
+/** `public` is the backend default and means readable by anyone holding the
+ *  URL, forever, with no credential. */
+export type Visibility = 'public' | 'private';
 export interface Asset {
     asset_id: string;
-    url: string;
+    url?: string;
     name: string;
     created_at: string;
+    visibility?: Visibility;
 }
 export declare function ingestAsset(apiKey: string, orgId: string, url: string, name?: string): Promise<Asset>;
 export type UploadContentType = 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp' | 'image/svg+xml' | 'application/pdf' | 'video/mp4' | 'video/webm';
 export type UploadContentTypeInput = UploadContentType | (string & {});
-export declare function uploadAsset(apiKey: string, orgId: string, file: Blob | Buffer, contentType: UploadContentTypeInput, name?: string): Promise<Asset>;
+export declare function uploadAsset(apiKey: string, orgId: string, file: Blob | Buffer, contentType: UploadContentTypeInput, name?: string, visibility?: Visibility): Promise<Asset>;
+/** Flip an existing asset between public and private. Making it private takes
+ *  effect at once — the plain URL stops serving and only signed links work. */
+export declare function setAssetVisibility(apiKey: string, orgId: string, assetId: string, visibility: Visibility): Promise<Asset>;
+/** A time-limited link to a private asset. The link carries its own
+ *  authorisation, so it can go to someone with no MyAPI account.
+ *  `expiresIn` is seconds — backend default 900, maximum 86400.
+ *  Signing is billable; a 402 here means the wallet, not the asset. */
+export declare function createSignedUrl(apiKey: string, orgId: string, assetId: string, expiresIn?: number): Promise<SignedUrl>;
+/** Kill every signed link for an asset, including ones that had not expired.
+ *  Does nothing for a public asset — anyone with the plain URL still reads it. */
+export declare function revokeAssetLinks(apiKey: string, orgId: string, assetId: string): Promise<void>;
+export interface SignedUrl {
+    signed_url?: string;
+    url?: string;
+    expires_at?: string;
+    expires_in?: number;
+    [key: string]: unknown;
+}
+/** The URL out of a signed-url response, whichever field carries it. */
+export declare function signedUrlOf(res: SignedUrl): string | undefined;
 export declare function listAssets(apiKey: string, orgId: string): Promise<Asset[]>;
 export declare function deleteAsset(apiKey: string, orgId: string, assetId: string): Promise<void>;

package/dist/storage.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXPOSES = void 0;
 exports.ingestAsset = ingestAsset;
 exports.uploadAsset = uploadAsset;
+exports.setAssetVisibility = setAssetVisibility;
+exports.createSignedUrl = createSignedUrl;
+exports.revokeAssetLinks = revokeAssetLinks;
+exports.signedUrlOf = signedUrlOf;
 exports.listAssets = listAssets;
 exports.deleteAsset = deleteAsset;
 const client_1 = require("./client");
@@ -12,11 +16,14 @@ exports.EXPOSES = [
     'POST /storage/orgs/{org_id}/assets/upload',
     'GET /storage/orgs/{org_id}/assets',
     'DELETE /storage/orgs/{org_id}/assets/{asset_id}',
+    'PATCH /storage/orgs/{org_id}/assets/{asset_id}',
+    'POST /storage/orgs/{org_id}/assets/{asset_id}/signed-url',
+    'POST /storage/orgs/{org_id}/assets/{asset_id}/revoke-links',
 ];
 async function ingestAsset(apiKey, orgId, url, name) {
     return (0, client_1.request)('POST', `${config_1.STORAGE_BASE}/storage/orgs/${encodeURIComponent(orgId)}/assets/ingest`, apiKey, { url, name });
 }
-async function uploadAsset(apiKey, orgId, file, contentType, name) {
+async function uploadAsset(apiKey, orgId, file, contentType, name, visibility) {
     const headers = {
         'Authorization': `Bearer ${apiKey}`
     };
@@ -25,6 +32,11 @@ async function uploadAsset(apiKey, orgId, file, contentType, name) {
     if (name) {
         formData.append('name', name);
     }
+    // Omitted entirely when not asked for, so the backend's own default applies
+    // rather than this client pinning one it would then have to track.
+    if (visibility) {
+        formData.append('visibility', visibility);
+    }
     const response = await fetch(`${config_1.STORAGE_BASE}/storage/orgs/${encodeURIComponent(orgId)}/assets/upload`, {
         method: 'POST',
         headers,
@@ -37,19 +49,47 @@ async function uploadAsset(apiKey, orgId, file, contentType, name) {
     catch {
         throw new client_1.MyApiError('invalid_json_response', response.status);
     }
-    // Mirror client.ts error handling: the backend's modern error shape is an
-    // object {code, message, ...}. The old string-only handling here made
-    // err.code an object, so e.g. funds.isInsufficientFunds could never match
-    // a 402 on a billable upload.
+    // Shared with client.ts so this path cannot drift back to reading `message`
+    // and dropping the specific `detail` — see toError. (It previously also
+    // made err.code an object, so funds.isInsufficientFunds never matched a 402
+    // on a billable upload; the shared helper fixes both.)
     if (!response.ok || !result.success) {
-        const err = result?.error;
-        const code = typeof err === 'object' && err !== null ? (err?.code || 'unknown_error') : (err || 'unknown_error');
-        const detail = typeof err === 'object' && err !== null ? (err?.message || undefined) : undefined;
-        const errBody = typeof err === 'object' && err !== null ? err : undefined;
-        throw new client_1.MyApiError(code, response.status, detail, errBody);
+        throw (0, client_1.toError)(result?.error, response.status);
     }
     return result.data;
 }
+// ---------------------------------------------------------------------------
+// Private assets
+// ---------------------------------------------------------------------------
+// These three endpoints shipped on the backend on 2026-07-28 and had no client
+// surface until now. The cost of that gap is on record: a team storing signed
+// Swiss leases built AES-256-GCM envelope encryption instead, and ended up
+// holding a master key with no backup path — `fn env` encrypts it at rest and
+// never returns it, so losing it destroys every document. They asked for
+// exactly `storage upload --private` and `storage sign <id> --ttl 300`, which
+// had existed for a week behind an undocumented HTTP route.
+/** Flip an existing asset between public and private. Making it private takes
+ *  effect at once — the plain URL stops serving and only signed links work. */
+async function setAssetVisibility(apiKey, orgId, assetId, visibility) {
+    return (0, client_1.request)('PATCH', `${config_1.STORAGE_BASE}/storage/orgs/${encodeURIComponent(orgId)}/assets/${encodeURIComponent(assetId)}`, apiKey, { visibility });
+}
+/** A time-limited link to a private asset. The link carries its own
+ *  authorisation, so it can go to someone with no MyAPI account.
+ *  `expiresIn` is seconds — backend default 900, maximum 86400.
+ *  Signing is billable; a 402 here means the wallet, not the asset. */
+async function createSignedUrl(apiKey, orgId, assetId, expiresIn) {
+    const body = expiresIn === undefined ? {} : { expires_in: expiresIn };
+    return (0, client_1.request)('POST', `${config_1.STORAGE_BASE}/storage/orgs/${encodeURIComponent(orgId)}/assets/${encodeURIComponent(assetId)}/signed-url`, apiKey, body);
+}
+/** Kill every signed link for an asset, including ones that had not expired.
+ *  Does nothing for a public asset — anyone with the plain URL still reads it. */
+async function revokeAssetLinks(apiKey, orgId, assetId) {
+    return (0, client_1.request)('POST', `${config_1.STORAGE_BASE}/storage/orgs/${encodeURIComponent(orgId)}/assets/${encodeURIComponent(assetId)}/revoke-links`, apiKey, {});
+}
+/** The URL out of a signed-url response, whichever field carries it. */
+function signedUrlOf(res) {
+    return res.signed_url ?? res.url;
+}
 async function listAssets(apiKey, orgId) {
     return (0, client_1.request)('GET', `${config_1.STORAGE_BASE}/storage/orgs/${encodeURIComponent(orgId)}/assets`, apiKey);
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "2.9.0";
+export declare const SDK_VERSION = "2.11.0";

package/dist/version.js

@@ -8,4 +8,4 @@ exports.SDK_VERSION = void 0;
 // Why a constant and not a package.json read: the SDK runs inside edge
 // functions (Cloudflare Workers), so it must not import node:fs. A literal
 // is the only version source that works in every runtime we ship to.
-exports.SDK_VERSION = '2.9.0';
+exports.SDK_VERSION = '2.11.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/sdk",
   "license": "Apache-2.0",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "TypeScript SDK for the MyAPI ecosystem",
   "repository": {
     "type": "git",