@myapihq/sdk 1.2.8 → 1.3.0

package/dist/task.d.ts

@@ -0,0 +1,78 @@
+import type { Exposes } from './exposes';
+export declare const EXPOSES: Exposes;
+export type TaskStatus = 'open' | 'claimed' | 'blocked' | 'resolved' | 'failed' | 'cancelled';
+export type TaskImportance = 'low' | 'normal' | 'high' | 'critical';
+export interface ResolveOn {
+    event_type: string;
+    field?: string;
+    value?: string;
+}
+export interface TaskRef {
+    id: string;
+    description: string;
+    score: number;
+}
+export interface Task {
+    id: string;
+    org_id: string;
+    description: string;
+    status: TaskStatus;
+    importance: TaskImportance;
+    score: number;
+    tags: string[];
+    source: string;
+    depends_on: string[];
+    payload_url: string;
+    assignee?: string;
+    resolve_on?: ResolveOn;
+    dedup_key?: string;
+    claimed_by?: string;
+    lease_expires_at?: string;
+    due_at?: string;
+    fail_reason?: string;
+    resolved_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface TaskListMeta {
+    shown: number;
+    total_open: number;
+}
+export interface TaskListResult {
+    tasks: TaskRef[];
+    meta: TaskListMeta;
+}
+export interface CreateTaskOptions {
+    description: string;
+    body?: string;
+    importance?: TaskImportance;
+    dueAt?: string;
+    assignee?: string;
+    tags?: string[];
+    dependsOn?: string[];
+    dedupKey?: string;
+    resolveOn?: ResolveOn;
+    source?: string;
+}
+export interface ListTaskOptions {
+    status?: string;
+    tag?: string;
+    importance?: string;
+    assignee?: string;
+    source?: string;
+    limit?: number;
+}
+export declare function createTask(apiKey: string, orgId: string, opts: CreateTaskOptions): Promise<Task>;
+export declare function listTasks(apiKey: string, orgId: string, opts?: ListTaskOptions): Promise<TaskListResult>;
+export declare function getTask(apiKey: string, orgId: string, id: string): Promise<Task>;
+export declare function getTaskBody(apiKey: string, orgId: string, id: string): Promise<string>;
+export declare function claimTask(apiKey: string, orgId: string, id: string, opts?: {
+    leaseSeconds?: number;
+    worker?: string;
+}): Promise<Task>;
+export declare function extendTask(apiKey: string, orgId: string, id: string, opts?: {
+    leaseSeconds?: number;
+}): Promise<Task>;
+export declare function resolveTask(apiKey: string, orgId: string, id: string): Promise<Task>;
+export declare function failTask(apiKey: string, orgId: string, id: string, reason: string): Promise<Task>;
+export declare function cancelTask(apiKey: string, orgId: string, id: string): Promise<void>;

package/dist/task.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPOSES = void 0;
+exports.createTask = createTask;
+exports.listTasks = listTasks;
+exports.getTask = getTask;
+exports.getTaskBody = getTaskBody;
+exports.claimTask = claimTask;
+exports.extendTask = extendTask;
+exports.resolveTask = resolveTask;
+exports.failTask = failTask;
+exports.cancelTask = cancelTask;
+const client_1 = require("./client");
+const config_1 = require("./config");
+// Backend: my-task-api per myapi-hq/internal/routes/task/. An agent-task
+// queue — the agent-loop hot path. Tasks are created, ranked by score,
+// claimed under a lease, then resolved/failed/cancelled. A task with
+// unresolved depends_on starts blocked; lease expiry auto-reverts a claimed
+// task to open.
+exports.EXPOSES = [
+    'POST /task/orgs/{org_id}/tasks',
+    'GET /task/orgs/{org_id}/tasks',
+    'GET /task/orgs/{org_id}/tasks/{id}',
+    'DELETE /task/orgs/{org_id}/tasks/{id}',
+    'GET /task/orgs/{org_id}/tasks/{id}/body',
+    'POST /task/orgs/{org_id}/tasks/{id}/claim',
+    'POST /task/orgs/{org_id}/tasks/{id}/extend',
+    'POST /task/orgs/{org_id}/tasks/{id}/fail',
+    'POST /task/orgs/{org_id}/tasks/{id}/resolve',
+];
+function tasksBase(orgId) {
+    return `${config_1.TASK_BASE}/task/orgs/${encodeURIComponent(orgId)}/tasks`;
+}
+function taskBase(orgId, id) {
+    return `${tasksBase(orgId)}/${encodeURIComponent(id)}`;
+}
+// createTask is idempotent on (org_id, dedup_key). A task with unresolved
+// depends_on starts blocked; one with an assignee emails them a magic link.
+async function createTask(apiKey, orgId, opts) {
+    const body = { description: opts.description };
+    if (opts.body !== undefined)
+        body.body = opts.body;
+    if (opts.importance !== undefined)
+        body.importance = opts.importance;
+    if (opts.dueAt !== undefined)
+        body.due_at = opts.dueAt;
+    if (opts.assignee !== undefined)
+        body.assignee = opts.assignee;
+    if (opts.tags !== undefined)
+        body.tags = opts.tags;
+    if (opts.dependsOn !== undefined)
+        body.depends_on = opts.dependsOn;
+    if (opts.dedupKey !== undefined)
+        body.dedup_key = opts.dedupKey;
+    if (opts.resolveOn !== undefined)
+        body.resolve_on = opts.resolveOn;
+    if (opts.source !== undefined)
+        body.source = opts.source;
+    return (0, client_1.request)('POST', tasksBase(orgId), apiKey, body);
+}
+// listTasks returns the ranked open queue (projected to TaskRef) plus the
+// backlog counts. Default: top 20 open tasks by score. The backend nests
+// {shown, total_open} inside the response `data.meta` (not the envelope meta).
+async function listTasks(apiKey, orgId, opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.status)
+        q.set('status', opts.status);
+    if (opts.tag)
+        q.set('tag', opts.tag);
+    if (opts.importance)
+        q.set('importance', opts.importance);
+    if (opts.assignee)
+        q.set('assignee', opts.assignee);
+    if (opts.source)
+        q.set('source', opts.source);
+    if (opts.limit !== undefined)
+        q.set('limit', String(opts.limit));
+    const qs = q.toString();
+    const res = await (0, client_1.request)('GET', `${tasksBase(orgId)}${qs ? `?${qs}` : ''}`, apiKey);
+    const tasks = res?.tasks ?? [];
+    const m = res?.meta ?? {};
+    return {
+        tasks,
+        meta: {
+            shown: typeof m.shown === 'number' ? m.shown : tasks.length,
+            total_open: typeof m.total_open === 'number' ? m.total_open : tasks.length,
+        },
+    };
+}
+// getTask returns the full task object. It deliberately does NOT fetch the
+// Markdown body tier — call getTaskBody for that, once, on commit.
+async function getTask(apiKey, orgId, id) {
+    return (0, client_1.request)('GET', taskBase(orgId, id), apiKey);
+}
+// getTaskBody fetches the body tier — the full Markdown context. Separate
+// call by design: it keeps the list/get path token-cheap. The endpoint
+// returns { task_id, body }.
+async function getTaskBody(apiKey, orgId, id) {
+    const res = await (0, client_1.request)('GET', `${taskBase(orgId, id)}/body`, apiKey);
+    return res?.body ?? '';
+}
+// claimTask takes an atomic lease (default 10 min) and returns the full
+// updated task — lease state is on `lease_expires_at` / `claimed_by`.
+async function claimTask(apiKey, orgId, id, opts = {}) {
+    const body = {};
+    if (opts.leaseSeconds !== undefined)
+        body.lease_seconds = opts.leaseSeconds;
+    if (opts.worker !== undefined)
+        body.worker = opts.worker;
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/claim`, apiKey, body);
+}
+// extendTask is a heartbeat for long work — extends a live claim.
+async function extendTask(apiKey, orgId, id, opts = {}) {
+    const body = {};
+    if (opts.leaseSeconds !== undefined)
+        body.lease_seconds = opts.leaseSeconds;
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/extend`, apiKey, body);
+}
+// resolveTask resolves a task (terminal) — unblocks any dependents.
+async function resolveTask(apiKey, orgId, id) {
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/resolve`, apiKey, {});
+}
+// failTask fails a task (terminal, with a reason). Does not auto-retry;
+// dependents that can never proceed are auto-failed.
+async function failTask(apiKey, orgId, id, reason) {
+    return (0, client_1.request)('POST', `${taskBase(orgId, id)}/fail`, apiKey, { reason });
+}
+// cancelTask cancels a task (terminal, distinct from fail).
+async function cancelTask(apiKey, orgId, id) {
+    return (0, client_1.request)('DELETE', taskBase(orgId, id), apiKey);
+}

package/dist/workflow.d.ts

@@ -28,6 +28,12 @@ export type WorkflowStep = {
     method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
     body?: string;
     headers?: Record<string, string>;
+} | {
+    type: 'enqueue_job' | 'enqueue';
+    queue: string;
+    payload?: string;
+    dedup_key?: string;
+    delay_seconds?: number;
 };
 export interface Workflow {
     id: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/sdk",
   "license": "Apache-2.0",
-  "version": "1.2.8",
+  "version": "1.3.0",
   "description": "TypeScript SDK for the MyAPI ecosystem",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -72,8 +72,8 @@ export async function request<T>(
     const err = result?.error;
     const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
     const detail = typeof err === 'object' ? (err?.message || undefined) : undefined;
-    const body = typeof err === 'object' ? err : undefined;
-    throw new MyApiError(code, response.status, detail, body);
+    const errBody = typeof err === 'object' ? err : undefined;
+    throw new MyApiError(code, response.status, detail, errBody);
   }
 
   const apiResponse = result as ApiResponse<T>;
@@ -81,8 +81,8 @@ export async function request<T>(
     const err = apiResponse.error as any;
     const code = typeof err === 'object' ? (err?.code || 'unknown_error') : (err || 'unknown_error');
     const detail = typeof err === 'object' ? (err?.message || undefined) : undefined;
-    const body = typeof err === 'object' ? err : undefined;
-    throw new MyApiError(code, response.status, detail, body);
+    const errBody = typeof err === 'object' ? err : undefined;
+    throw new MyApiError(code, response.status, detail, errBody);
   }
 
   return apiResponse.data as T;

package/src/config.ts

@@ -17,6 +17,9 @@ export const FUNNEL_BASE  = process.env.MYAPI_FUNNEL_URL  ?? 'https://api.myfunn
 export const FUNCTION_BASE= process.env.MYAPI_FUNCTION_URL?? GATEWAY;
 export const PAYMENTS_BASE= process.env.MYAPI_PAYMENTS_URL?? GATEWAY;
 export const CONTAINER_BASE=process.env.MYAPI_CONTAINER_URL?? GATEWAY;
+export const GIT_BASE     = process.env.MYAPI_GIT_URL     ?? GATEWAY;
+export const QUEUE_BASE   = process.env.MYAPI_QUEUE_URL   ?? GATEWAY;
+export const TASK_BASE    = process.env.MYAPI_TASK_URL    ?? GATEWAY;
 export const IMAGE_BASE   = process.env.MYAPI_IMAGE_URL   ?? 'https://api.myimageapi.com';
 export const WEBHOOK_BASE = process.env.MYAPI_WEBHOOK_URL ?? 'https://api.mywebhookapi.com';
 export const WORKFLOW_BASE= process.env.MYAPI_WORKFLOW_URL?? 'https://api.myworkflowapi.com';

package/src/email.ts

@@ -6,6 +6,8 @@ export const EXPOSES: Exposes = [
   // Mailbox / sending activation
   'POST /email/mailboxes/create',
   'GET /email/mailboxes',
+  'PUT /email/mailboxes/{address}/forwarding',
+  'DELETE /email/mailboxes/{address}/forwarding',
   'POST /email/sending/activate',
   // Send + read
   'POST /email/send',
@@ -43,6 +45,8 @@ export const EXPOSES: Exposes = [
   'GET /email/orgs/{org_id}/campaigns/{campaign_id}/stats',
   // Verify
   'POST /email/orgs/{org_id}/verify',
+  'POST /email/orgs/{org_id}/verify-bulk',
+  'GET /email/orgs/{org_id}/verify-jobs/{id}',
 ];
 
 export interface EmailMessage { message_id: string; from: string; subject: string; body?: string; received_at: string }
@@ -90,6 +94,43 @@ export async function verifyEmail(apiKey: string, orgId: string, email: string):
   return request('POST', `${BASE_URL}/email/orgs/${encodeURIComponent(orgId)}/verify`, apiKey, { email });
 }
 
+// One address's outcome in a bulk-verification job.
+export interface BulkVerifyResult {
+  email: string;
+  verdict: string;          // deliverable | undeliverable | risky | unknown
+  confidence: number;
+  source: string;           // phase1 | strategist | smtp
+  classification?: string;
+  mx?: string;
+  rcpt_code?: number;
+  catch_all?: boolean;
+  detail?: string;
+}
+
+export interface VerifyJob {
+  job_id: string;
+  status: string;           // pending | running | done | failed
+  total: number;
+  completed?: number;
+  catch_all?: boolean;
+  results?: BulkVerifyResult[];
+  error?: string;
+}
+
+// verifyBulk kicks off an asynchronous bulk verification (1-500 addresses)
+// and returns immediately with a job_id. `catchAll` toggles the catch-all
+// check on SMTP-probed addresses (default true). Poll getVerifyJob for
+// status + results.
+export async function verifyBulk(apiKey: string, orgId: string, emails: string[], catchAll?: boolean): Promise<VerifyJob> {
+  const body: { emails: string[]; catch_all?: boolean } = { emails };
+  if (catchAll !== undefined) body.catch_all = catchAll;
+  return request('POST', `${BASE_URL}/email/orgs/${encodeURIComponent(orgId)}/verify-bulk`, apiKey, body);
+}
+
+export async function getVerifyJob(apiKey: string, orgId: string, jobId: string): Promise<VerifyJob> {
+  return request('GET', `${BASE_URL}/email/orgs/${encodeURIComponent(orgId)}/verify-jobs/${encodeURIComponent(jobId)}`, apiKey);
+}
+
 // ── Mailbox ops (account-scoped) ─────────────────────────────────────────────
 
 export async function createMailbox(apiKey: string, domain: string, username: string, displayName?: string): Promise<{ address: string; created_at: string }> {
@@ -112,6 +153,18 @@ export async function activateSending(apiKey: string, address: string): Promise<
   return request('POST', `${BASE_URL}/email/sending/activate`, apiKey, { address });
 }
 
+// setForwarding redirects a copy of every incoming message to an external
+// address (server-side; the original is kept in the mailbox). `forwardTo`
+// must be a valid address and cannot equal the mailbox itself.
+export async function setForwarding(apiKey: string, address: string, forwardTo: string): Promise<{ address: string; forward_to: string }> {
+  return request('PUT', `${BASE_URL}/email/mailboxes/${encodeURIComponent(address)}/forwarding`, apiKey, { forward_to: forwardTo });
+}
+
+// deleteForwarding stops forwarding for a mailbox.
+export async function deleteForwarding(apiKey: string, address: string): Promise<void> {
+  return request('DELETE', `${BASE_URL}/email/mailboxes/${encodeURIComponent(address)}/forwarding`, apiKey);
+}
+
 // ── Sending and reading (account-scoped) ─────────────────────────────────────
 
 export async function sendEmail(apiKey: string, payload: { from: string; to: string[]; subject: string; html?: string; text?: string; template_id?: string; template_vars?: Record<string, string> }): Promise<{ message_id: string }> {

package/src/git.ts

@@ -0,0 +1,171 @@
+import { request } from './client';
+import { GIT_BASE as BASE_URL } from './config';
+import type { Exposes } from './exposes';
+
+// Backend: my-git-api per myapi-hq/internal/routes/git/. A stateless
+// git-over-HTTP surface — repositories, refs, commits, and history served
+// by a go-git engine (objects in GCS packfiles, refs in Postgres).
+export const EXPOSES: Exposes = [
+  'POST /git/orgs/{org_id}/repos',
+  'GET /git/orgs/{org_id}/repos',
+  'GET /git/orgs/{org_id}/repos/{repo}',
+  'DELETE /git/orgs/{org_id}/repos/{repo}',
+  'GET /git/orgs/{org_id}/repos/{repo}/refs',
+  'GET /git/orgs/{org_id}/repos/{repo}/tree/{ref}',
+  'GET /git/orgs/{org_id}/repos/{repo}/blob/{ref}/{path}',
+  'GET /git/orgs/{org_id}/repos/{repo}/commits',
+  'GET /git/orgs/{org_id}/repos/{repo}/commits/{sha}',
+  'GET /git/orgs/{org_id}/repos/{repo}/diff',
+  'POST /git/orgs/{org_id}/repos/{repo}/commits',
+  'POST /git/orgs/{org_id}/repos/{repo}/branches',
+  'DELETE /git/orgs/{org_id}/repos/{repo}/branches/{branch}',
+  'POST /git/orgs/{org_id}/repos/{repo}/tags',
+  'POST /git/orgs/{org_id}/repos/{repo}/merges',
+  'POST /git/orgs/{org_id}/repos/{repo}/repack',
+];
+
+export interface RepoSummary { name: string }
+export interface Repo {
+  name: string;
+  default_branch: string;
+  branches: number;
+  tags: number;
+}
+export interface RefInfo { name: string; sha: string }
+export interface Refs {
+  head: string;            // symbolic HEAD target, e.g. "refs/heads/main"
+  branches: RefInfo[];
+  tags: RefInfo[];
+}
+export interface TreeEntry {
+  name: string;
+  path: string;
+  type: 'file' | 'dir';
+  mode: string;
+  sha: string;
+  size: number;
+}
+export interface CommitInfo {
+  sha: string;
+  message: string;
+  author: string;
+  email: string;
+  when: string;
+  parents: string[];
+}
+export interface CommitResult { sha: string; tree: string; branch: string }
+export interface RepackResult { packs_before: number; packs_after: number; objects: number }
+export interface Blob { path: string; size: number; content_base64: string }
+
+// One file edit in an atomic commit. Either `content` (UTF-8 text) or
+// `content_base64` (binary); set `delete` to remove the path instead.
+export interface FileChange {
+  path: string;
+  content?: string;
+  content_base64?: string;
+  delete?: boolean;
+  mode?: string;            // "100644" (default), "100755" (exec), "120000" (symlink)
+}
+export interface CommitPayload {
+  branch: string;                          // required — short name or full ref
+  base?: string;                           // expected branch tip; "" => branch must not exist
+  message: string;
+  author?: { name: string; email: string };
+  changes: FileChange[];
+}
+
+function repoBase(orgId: string, repo: string): string {
+  return `${BASE_URL}/git/orgs/${encodeURIComponent(orgId)}/repos/${encodeURIComponent(repo)}`;
+}
+
+// ── Repos ────────────────────────────────────────────────────────────────────
+
+export async function createRepo(apiKey: string, orgId: string, name: string, defaultBranch?: string): Promise<{ name: string; default_branch: string }> {
+  const body: Record<string, string> = { name };
+  if (defaultBranch) body.default_branch = defaultBranch;
+  return request('POST', `${BASE_URL}/git/orgs/${encodeURIComponent(orgId)}/repos`, apiKey, body);
+}
+
+export async function listRepos(apiKey: string, orgId: string): Promise<RepoSummary[]> {
+  const res = await request<{ repos?: RepoSummary[] }>('GET', `${BASE_URL}/git/orgs/${encodeURIComponent(orgId)}/repos`, apiKey);
+  return res?.repos ?? [];
+}
+
+export async function getRepo(apiKey: string, orgId: string, repo: string): Promise<Repo> {
+  return request('GET', repoBase(orgId, repo), apiKey);
+}
+
+export async function deleteRepo(apiKey: string, orgId: string, repo: string): Promise<void> {
+  return request('DELETE', repoBase(orgId, repo), apiKey);
+}
+
+// ── Refs / history ───────────────────────────────────────────────────────────
+
+export async function listRefs(apiKey: string, orgId: string, repo: string): Promise<Refs> {
+  return request('GET', `${repoBase(orgId, repo)}/refs`, apiKey);
+}
+
+// listCommits walks history from `ref` (default HEAD); `limit` is 1-500.
+export async function listCommits(apiKey: string, orgId: string, repo: string, opts: { ref?: string; limit?: number } = {}): Promise<CommitInfo[]> {
+  const q = new URLSearchParams();
+  if (opts.ref) q.set('ref', opts.ref);
+  if (opts.limit !== undefined) q.set('limit', String(opts.limit));
+  const qs = q.toString();
+  const res = await request<{ commits?: CommitInfo[] }>('GET', `${repoBase(orgId, repo)}/commits${qs ? `?${qs}` : ''}`, apiKey);
+  return res?.commits ?? [];
+}
+
+export async function getCommit(apiKey: string, orgId: string, repo: string, sha: string): Promise<CommitInfo> {
+  return request('GET', `${repoBase(orgId, repo)}/commits/${encodeURIComponent(sha)}`, apiKey);
+}
+
+// getDiff returns the unified diff text between two refs.
+export async function getDiff(apiKey: string, orgId: string, repo: string, base: string, head: string): Promise<string> {
+  const q = new URLSearchParams({ base, head });
+  const res = await request<{ diff?: string }>('GET', `${repoBase(orgId, repo)}/diff?${q}`, apiKey);
+  return res?.diff ?? '';
+}
+
+// listTree lists a ref's tree; `path` scopes it to a subdirectory.
+export async function listTree(apiKey: string, orgId: string, repo: string, ref: string, path?: string): Promise<TreeEntry[]> {
+  const qs = path ? `?path=${encodeURIComponent(path)}` : '';
+  const res = await request<{ entries?: TreeEntry[] }>('GET', `${repoBase(orgId, repo)}/tree/${encodeURIComponent(ref)}${qs}`, apiKey);
+  return res?.entries ?? [];
+}
+
+// readBlob returns a file's content (base64-encoded — safe for binary).
+export async function readBlob(apiKey: string, orgId: string, repo: string, ref: string, path: string): Promise<Blob> {
+  // The backend route is /blob/{ref}/{path...} — a catch-all — so slashes
+  // in the path must survive; encode each segment, not the separators.
+  const encPath = path.split('/').map(encodeURIComponent).join('/');
+  return request('GET', `${repoBase(orgId, repo)}/blob/${encodeURIComponent(ref)}/${encPath}`, apiKey);
+}
+
+// ── Writes ───────────────────────────────────────────────────────────────────
+
+// commit applies all `changes` atomically onto `branch`.
+export async function commit(apiKey: string, orgId: string, repo: string, payload: CommitPayload): Promise<CommitResult> {
+  return request('POST', `${repoBase(orgId, repo)}/commits`, apiKey, payload);
+}
+
+export async function createBranch(apiKey: string, orgId: string, repo: string, name: string, from: string): Promise<{ name: string }> {
+  return request('POST', `${repoBase(orgId, repo)}/branches`, apiKey, { name, from });
+}
+
+export async function deleteBranch(apiKey: string, orgId: string, repo: string, branch: string): Promise<void> {
+  return request('DELETE', `${repoBase(orgId, repo)}/branches/${encodeURIComponent(branch)}`, apiKey);
+}
+
+export async function createTag(apiKey: string, orgId: string, repo: string, name: string, ref: string): Promise<{ name: string }> {
+  return request('POST', `${repoBase(orgId, repo)}/tags`, apiKey, { name, ref });
+}
+
+// merge fast-forwards `target` to `source` (fast-forward only).
+export async function merge(apiKey: string, orgId: string, repo: string, target: string, source: string): Promise<{ sha: string }> {
+  return request('POST', `${repoBase(orgId, repo)}/merges`, apiKey, { target, source });
+}
+
+// repack compacts the repository's incremental packfiles into one.
+export async function repack(apiKey: string, orgId: string, repo: string): Promise<RepackResult> {
+  return request('POST', `${repoBase(orgId, repo)}/repack`, apiKey);
+}

package/src/index.ts

@@ -25,3 +25,6 @@ export * as crm from './crm';
 export * as fn from './function';
 export * as payments from './payments';
 export * as container from './container';
+export * as git from './git';
+export * as queue from './queue';
+export * as task from './task';

package/src/pixel.ts

@@ -66,8 +66,10 @@ export async function getEvents(apiKey: string, orgId: string, params: { campaig
   return request('GET', url, apiKey);
 }
 
-export async function getIdentity(apiKey: string, orgId: string, pixelId: string): Promise<{ uuid: string; is_resolved: boolean; nodes: Record<string, { type: string; probability: number }>; latency_ms: number }> {
-  return request('GET', `${BASE_URL}/pixel/orgs/${encodeURIComponent(orgId)}/identity/${encodeURIComponent(pixelId)}`, apiKey);
+// getIdentity resolves a pixel's identity graph. `website` is required —
+// the backend scopes the lookup to a domain the org owns.
+export async function getIdentity(apiKey: string, orgId: string, pixelId: string, website: string): Promise<{ uuid: string; is_resolved: boolean; nodes: Record<string, { type: string; probability: number }>; latency_ms: number }> {
+  return request('GET', `${BASE_URL}/pixel/orgs/${encodeURIComponent(orgId)}/identity/${encodeURIComponent(pixelId)}?website=${encodeURIComponent(website)}`, apiKey);
 }
 
 // Sample of geographic distribution of the org's pixel audience. Backend

package/src/queue.ts

@@ -0,0 +1,110 @@
+import { request } from './client';
+import { QUEUE_BASE as BASE_URL } from './config';
+import type { Exposes } from './exposes';
+
+// Backend: my-queue-api per myapi-hq/internal/routes/queue/. A durable
+// HTTP-consumer job queue — each named queue POSTs its jobs to a configured
+// consumer_url, with retry/backoff to max_attempts, a concurrency cap, and a
+// dependency DAG (a job with unsucceeded depends_on starts blocked).
+export const EXPOSES: Exposes = [
+  'POST /queue/orgs/{org_id}/queues',
+  'GET /queue/orgs/{org_id}/queues',
+  'GET /queue/orgs/{org_id}/queues/{name}',
+  'POST /queue/orgs/{org_id}/queues/{name}/jobs',
+  'GET /queue/orgs/{org_id}/queues/{name}/jobs',
+  'GET /queue/orgs/{org_id}/jobs/{id}',
+];
+
+export interface Queue {
+  id: string;
+  org_id: string;
+  name: string;
+  consumer_url: string;
+  max_attempts: number;
+  max_concurrency: number;
+  created_at: string;
+}
+
+// A job that exhausts max_attempts goes straight to `dead` — there is no
+// separate `failed` state.
+export type JobStatus = 'pending' | 'blocked' | 'running' | 'succeeded' | 'dead';
+
+export interface Job {
+  id: string;
+  queue_id: string;
+  org_id: string;
+  payload: unknown;
+  status: JobStatus;
+  attempt: number;
+  max_attempts: number;
+  not_before: string;
+  depends_on: string[];
+  dedup_key?: string;
+  last_error?: string;
+  started_at?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CreateQueueOptions {
+  name: string;
+  consumerUrl: string;
+  maxAttempts?: number;
+  maxConcurrency?: number;
+}
+
+export interface EnqueueOptions {
+  payload?: unknown;
+  dedupKey?: string;
+  delaySeconds?: number;
+  // Job ids this job waits on. Immutable — the DAG is declared at enqueue.
+  // Same shape as task.create's depends_on.
+  dependsOn?: string[];
+}
+
+function queuesBase(orgId: string): string {
+  return `${BASE_URL}/queue/orgs/${encodeURIComponent(orgId)}/queues`;
+}
+
+// createQueue registers a named queue with its retry + concurrency policy
+// and the HTTP consumer that runs its jobs.
+export async function createQueue(apiKey: string, orgId: string, opts: CreateQueueOptions): Promise<Queue> {
+  const body: Record<string, unknown> = { name: opts.name, consumer_url: opts.consumerUrl };
+  if (opts.maxAttempts !== undefined) body.max_attempts = opts.maxAttempts;
+  if (opts.maxConcurrency !== undefined) body.max_concurrency = opts.maxConcurrency;
+  return request('POST', queuesBase(orgId), apiKey, body);
+}
+
+export async function listQueues(apiKey: string, orgId: string): Promise<Queue[]> {
+  const res = await request<{ queues?: Queue[] }>('GET', queuesBase(orgId), apiKey);
+  return res?.queues ?? [];
+}
+
+export async function getQueue(apiKey: string, orgId: string, name: string): Promise<Queue> {
+  return request('GET', `${queuesBase(orgId)}/${encodeURIComponent(name)}`, apiKey);
+}
+
+// enqueueJob is idempotent on (queue, dedup_key). A job with unsucceeded
+// depends_on starts blocked.
+export async function enqueueJob(apiKey: string, orgId: string, name: string, opts: EnqueueOptions = {}): Promise<Job> {
+  const body: Record<string, unknown> = {};
+  if (opts.payload !== undefined) body.payload = opts.payload;
+  if (opts.dedupKey !== undefined) body.dedup_key = opts.dedupKey;
+  if (opts.delaySeconds !== undefined) body.delay_seconds = opts.delaySeconds;
+  if (opts.dependsOn !== undefined) body.depends_on = opts.dependsOn;
+  return request('POST', `${queuesBase(orgId)}/${encodeURIComponent(name)}/jobs`, apiKey, body);
+}
+
+// listJobs lists a queue's jobs, newest first. `limit` is 1-200.
+export async function listJobs(apiKey: string, orgId: string, name: string, opts: { status?: string; limit?: number } = {}): Promise<Job[]> {
+  const q = new URLSearchParams();
+  if (opts.status) q.set('status', opts.status);
+  if (opts.limit !== undefined) q.set('limit', String(opts.limit));
+  const qs = q.toString();
+  const res = await request<{ jobs?: Job[] }>('GET', `${queuesBase(orgId)}/${encodeURIComponent(name)}/jobs${qs ? `?${qs}` : ''}`, apiKey);
+  return res?.jobs ?? [];
+}
+
+export async function getJob(apiKey: string, orgId: string, jobId: string): Promise<Job> {
+  return request('GET', `${BASE_URL}/queue/orgs/${encodeURIComponent(orgId)}/jobs/${encodeURIComponent(jobId)}`, apiKey);
+}