@holon-run/agentinbox 1.7.2 → 1.8.0

package/README.md

@@ -176,9 +176,31 @@ cat filter.json | agentinbox subscription add <source_id> --filter-stdin
 agentinbox source event <source_id> --native-id demo-1 --event local.demo
 agentinbox inbox read
 agentinbox inbox read --agent-id <agent_id>
+agentinbox inbox read <entry_id> --agent-id <agent_id>
+agentinbox inbox attachment inspect <attachment_ref> --agent-id <agent_id>
+agentinbox inbox attachment get <attachment_ref> --agent-id <agent_id> --output ./attachment.bin
+agentinbox inbox attachment delete <attachment_ref> --agent-id <agent_id>
 agentinbox inbox ack --agent-id <agent_id> --through <last_entry_id>
 ```
 
+For an email entry, the positional form reads its normalized body using the
+`entryId` as the only message selector. It uses local content first and may ask
+UXC to retrieve missing content unless `--no-fetch` is set. The default page is
+32 KiB; use `--max-bytes <n>` to change the page budget and repeat the command
+with `--cursor <nextCursor>` when `body.hasMore` is true. Body reads do not ack
+the inbox entry, mark the provider message as read, download attachments, or
+expose the internal UXC message reference. Public attachment metadata uses an
+opaque `attachmentRef`; provider handles and credentials remain internal.
+Email sources default to `attachmentPolicy.mode=metadata`. Set the source
+policy to `store_reference` to allow explicit, bounded `attachment get`
+requests. AgentInbox stores the bytes under its managed data directory, while
+the CLI writes the returned binary response to `--output` without overwriting
+an existing file. Explicit `attachment delete` permanently tombstones that
+attachment reference for its owning agent and reclaims the managed object once
+no live attachment references remain. Retention and the global managed-byte
+limit are also enforced during inbox garbage collection; quarantined content
+remains unreadable and is subject to the same lifecycle rules.
+
 The HTTP `POST /subscriptions` endpoint always returns
 `{ "subscriptions": [...] }`, even when only one subscription is created. That
 keeps shortcut expansion consistent for external callers.

package/dist/src/cli.js

@@ -19,6 +19,7 @@ const service_1 = require("./service");
 const store_1 = require("./store");
 const terminal_1 = require("./terminal");
 const util_1 = require("./util");
+const email_attachment_1 = require("./email_attachment");
 async function main() {
     const rawArgs = process.argv.slice(2);
     const detectedArgs = normalizeHelpArgs(rawArgs);
@@ -747,11 +748,111 @@ async function main() {
         await printRemote(client, `/agents/${encodeURIComponent(agentId)}/inbox`, undefined, "GET");
         return;
     }
+    if (command === "inbox" && normalized[1] === "attachment" && normalized[2] === "inspect") {
+        const args = normalized.slice(3);
+        const positionals = positionalArgs(args, ["--agent-id"]);
+        const attachmentRef = positionals[0];
+        if (positionals.length !== 1
+            || unexpectedFlags(args, ["--agent-id"]).length > 0
+            || !attachmentRef) {
+            throw new Error("usage: agentinbox inbox attachment inspect <attachmentRef> [--agent-id ID]");
+        }
+        const selection = await selectAgentForCommand(client, {
+            explicitAgentId: takeFlagValue(normalized, "--agent-id"),
+            autoRegister: false,
+        });
+        const response = await requestRemote(client, `/agents/${encodeURIComponent(selection.agentId)}/inbox/attachments/${encodeURIComponent(attachmentRef)}`, undefined, "GET");
+        console.log((0, util_1.jsonResponse)(withCommandMetadata(response.data, selection)));
+        return;
+    }
+    if (command === "inbox" && normalized[1] === "attachment" && normalized[2] === "get") {
+        const args = normalized.slice(3);
+        const positionals = positionalArgs(args, ["--agent-id", "--output"]);
+        const attachmentRef = positionals[0];
+        const output = takeFlagValue(args, "--output");
+        if (positionals.length !== 1
+            || unexpectedFlags(args, ["--agent-id", "--output"]).length > 0
+            || !attachmentRef
+            || !output) {
+            throw new Error("usage: agentinbox inbox attachment get <attachmentRef> [--agent-id ID] --output PATH");
+        }
+        const selection = await selectAgentForCommand(client, {
+            explicitAgentId: takeFlagValue(args, "--agent-id"),
+            autoRegister: false,
+        });
+        const endpoint = `/agents/${encodeURIComponent(selection.agentId)}/inbox/attachments/${encodeURIComponent(attachmentRef)}`;
+        const materialized = await requestRemote(client, `${endpoint}/materialize`, {}, "POST");
+        const response = await client.requestBytes(`${endpoint}/content`);
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+            throw new Error(`request GET ${endpoint}/content failed with HTTP ${response.statusCode}: ${binaryErrorText(response.data)}`);
+        }
+        const contentLength = singleHeaderValue(response.headers["content-length"]);
+        if (contentLength != null && Number(contentLength) !== response.data.length) {
+            throw new Error(`attachment response length mismatch: expected ${contentLength} bytes, received ${response.data.length}`);
+        }
+        const outputPath = node_path_1.default.resolve(output);
+        writeExclusiveFile(outputPath, response.data);
+        console.log((0, util_1.jsonResponse)(withCommandMetadata({
+            attachment: materialized.data,
+            output: outputPath,
+            bytes: response.data.length,
+        }, selection)));
+        return;
+    }
+    if (command === "inbox" && normalized[1] === "attachment" && normalized[2] === "delete") {
+        const args = normalized.slice(3);
+        const positionals = positionalArgs(args, ["--agent-id"]);
+        const attachmentRef = positionals[0];
+        if (positionals.length !== 1
+            || unexpectedFlags(args, ["--agent-id"]).length > 0
+            || !attachmentRef) {
+            throw new Error("usage: agentinbox inbox attachment delete <attachmentRef> [--agent-id ID]");
+        }
+        const selection = await selectAgentForCommand(client, {
+            explicitAgentId: takeFlagValue(args, "--agent-id"),
+            autoRegister: false,
+        });
+        const response = await requestRemote(client, `/agents/${encodeURIComponent(selection.agentId)}/inbox/attachments/${encodeURIComponent(attachmentRef)}/content`, undefined, "DELETE");
+        console.log((0, util_1.jsonResponse)(withCommandMetadata(response.data, selection)));
+        return;
+    }
     if (command === "inbox" && normalized[1] === "read") {
         const args = normalized.slice(2);
-        const allowedFlags = ["--agent-id", "--after-entry", "--include-acked", "--limit", "--full"];
-        if (positionalArgs(args, ["--agent-id", "--after-entry", "--limit"]).length > 0 || unexpectedFlags(args, allowedFlags).length > 0) {
-            throw new Error("usage: agentinbox inbox read [--agent-id ID] [--after-entry ID] [--include-acked] [--limit N] [--full]");
+        const positionals = positionalArgs(args, ["--agent-id", "--after-entry", "--limit", "--max-bytes", "--cursor"]);
+        const allowedFlags = [
+            "--agent-id", "--after-entry", "--include-acked", "--limit", "--full",
+            "--max-bytes", "--no-fetch", "--cursor",
+        ];
+        if (positionals.length > 1 || unexpectedFlags(args, allowedFlags).length > 0) {
+            throw new Error("usage: agentinbox inbox read [<entryId> [--agent-id ID] [--max-bytes N] [--no-fetch] [--cursor TOKEN] [--full] | --agent-id ID [--after-entry ID] [--include-acked] [--limit N] [--full]]");
+        }
+        const entryId = positionals[0];
+        if (entryId) {
+            if (hasFlag(normalized, "--include-acked") ||
+                takeFlagValue(normalized, "--after-entry") !== undefined ||
+                takeFlagValue(normalized, "--limit") !== undefined) {
+                throw new Error("usage: agentinbox inbox read <entryId> [--agent-id ID] [--max-bytes N] [--no-fetch] [--cursor TOKEN] [--full]");
+            }
+            const selection = await selectAgentForCommand(client, {
+                explicitAgentId: takeFlagValue(normalized, "--agent-id"),
+                autoRegister: false,
+            });
+            const query = buildQuery({
+                max_bytes: takeFlagValue(normalized, "--max-bytes"),
+                fetch: hasFlag(normalized, "--no-fetch") ? "false" : undefined,
+                cursor: takeFlagValue(normalized, "--cursor"),
+            });
+            const response = await requestRemote(client, `/agents/${encodeURIComponent(selection.agentId)}/inbox/entries/${encodeURIComponent(entryId)}/body${query}`, undefined, "GET");
+            console.log((0, util_1.jsonResponse)(withCommandMetadata(response.data, selection)));
+            if (response.data.status === "unavailable") {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (takeFlagValue(normalized, "--max-bytes") !== undefined ||
+            takeFlagValue(normalized, "--cursor") !== undefined ||
+            hasFlag(normalized, "--no-fetch")) {
+            throw new Error("usage: agentinbox inbox read <entryId> [--agent-id ID] [--max-bytes N] [--no-fetch] [--cursor TOKEN] [--full]");
         }
         const selection = await selectAgentForCommand(client, {
             explicitAgentId: takeFlagValue(normalized, "--agent-id"),
@@ -764,8 +865,10 @@ async function main() {
         });
         const response = await requestRemote(client, `/agents/${encodeURIComponent(selection.agentId)}/inbox/entries${query}`, undefined, "GET");
         const data = response.data;
-        if (!hasFlag(normalized, "--full") && Array.isArray(data.entries)) {
-            data.entries = data.entries.map(compactInboxEntry);
+        if (Array.isArray(data.entries)) {
+            data.entries = data.entries.map((entry) => hasFlag(normalized, "--full")
+                ? (0, email_attachment_1.projectPublicInboxEntry)(entry)
+                : compactInboxEntry(entry));
         }
         console.log((0, util_1.jsonResponse)(withCommandMetadata(data, selection)));
         return;
@@ -811,9 +914,11 @@ async function main() {
             if (event.event !== "items") {
                 continue;
             }
-            const output = fullMode ? event : {
+            const output = {
                 ...event,
-                entries: event.entries.map((e) => compactInboxEntry(e)),
+                entries: event.entries.map((entry) => fullMode
+                    ? (0, email_attachment_1.projectPublicInboxEntry)(entry)
+                    : compactInboxEntry(entry)),
             };
             console.log((0, util_1.jsonResponse)(output));
         }
@@ -1248,6 +1353,39 @@ async function requestRemote(client, endpoint, body, method = "POST") {
     }
     return { data: response.data };
 }
+function binaryErrorText(data) {
+    const text = data.toString("utf8");
+    if (!text) {
+        return "{}";
+    }
+    try {
+        return (0, util_1.jsonResponse)(JSON.parse(text));
+    }
+    catch {
+        return text;
+    }
+}
+function singleHeaderValue(value) {
+    return Array.isArray(value) ? (value[0] ?? null) : (value ?? null);
+}
+function writeExclusiveFile(filePath, data) {
+    const fd = node_fs_1.default.openSync(filePath, "wx", 0o600);
+    let written = false;
+    try {
+        let offset = 0;
+        while (offset < data.length) {
+            offset += node_fs_1.default.writeSync(fd, data, offset, data.length - offset);
+        }
+        node_fs_1.default.fsyncSync(fd);
+        written = true;
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+        if (!written) {
+            node_fs_1.default.rmSync(filePath, { force: true });
+        }
+    }
+}
 function noCurrentAgentMessage() {
     return "no current agent is registered for this terminal/runtime context; run `agentinbox agent list` to inspect offline agents, then `agentinbox agent register` or `agentinbox agent register --force-rebind --agent-id <agentId>` to rebind one";
 }
@@ -1805,7 +1943,11 @@ Usage:
 Usage:
   agentinbox inbox list [--limit N]
   agentinbox inbox show <agentId>
-  agentinbox inbox read [--agent-id ID] [--after-entry ID] [--include-acked] [--limit N] [--full]  (aliases: inbox get, inbox entries, inbox peek)
+  agentinbox inbox read [--agent-id ID] [--after-entry ID] [--include-acked] [--limit N] [--full]  (list; aliases: inbox get, inbox entries, inbox peek)
+  agentinbox inbox read <entryId> [--agent-id ID] [--max-bytes N] [--no-fetch] [--cursor TOKEN] [--full]  (read one email body)
+  agentinbox inbox attachment inspect <attachmentRef> [--agent-id ID]
+  agentinbox inbox attachment get <attachmentRef> [--agent-id ID] --output PATH
+  agentinbox inbox attachment delete <attachmentRef> [--agent-id ID]
   agentinbox inbox send --agent-id ID --message TEXT [--sender SENDER]
   agentinbox inbox watch [--agent-id ID] [--after-entry ID] [--include-acked] [--heartbeat-ms N] [--full]
   agentinbox inbox ack [--agent-id ID] (--through <entryId> | --through-entry-id <entryId> | --entry <entryId> | --entry-id <entryId> | --all)

package/dist/src/client.js

@@ -17,6 +17,12 @@ class AgentInboxClient {
         }
         return requestViaUrl(this.transport.baseUrl, endpoint, body, method);
     }
+    async requestBytes(endpoint, method = "GET") {
+        if (this.transport.kind === "socket") {
+            return requestBytesViaSocket(this.transport.socketPath, endpoint, method);
+        }
+        return requestBytesViaUrl(this.transport.baseUrl, endpoint, method);
+    }
     watchInbox(agentId, options = {}) {
         const query = new URLSearchParams();
         if (options.afterEntryId) {
@@ -36,6 +42,36 @@ class AgentInboxClient {
     }
 }
 exports.AgentInboxClient = AgentInboxClient;
+function requestBytesViaSocket(socketPath, endpoint, method) {
+    return new Promise((resolve, reject) => {
+        const req = node_http_1.default.request({
+            socketPath,
+            path: normalizeEndpoint(endpoint),
+            method,
+        }, (res) => {
+            void collectBinaryResponse(res).then(resolve, reject);
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
+function requestBytesViaUrl(baseUrl, endpoint, method) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(normalizeEndpoint(endpoint), baseUrl);
+        const transport = url.protocol === "https:" ? node_https_1.default : node_http_1.default;
+        const req = transport.request({
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port,
+            path: `${url.pathname}${url.search}`,
+            method,
+        }, (res) => {
+            void collectBinaryResponse(res).then(resolve, reject);
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
 function requestViaSocket(socketPath, endpoint, body, method) {
     return new Promise((resolve, reject) => {
         const payload = body ? JSON.stringify(body) : undefined;
@@ -118,6 +154,22 @@ function watchViaUrl(baseUrl, endpoint) {
         return req;
     });
 }
+function collectBinaryResponse(res) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        res.on("end", () => {
+            resolve({
+                statusCode: res.statusCode ?? 500,
+                data: Buffer.concat(chunks),
+                headers: res.headers,
+            });
+        });
+        res.on("error", reject);
+    });
+}
 function collectResponse(res) {
     return new Promise((resolve, reject) => {
         const chunks = [];

package/dist/src/email_attachment.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicEmailAttachmentCollection = publicEmailAttachmentCollection;
+exports.findPublicEmailAttachment = findPublicEmailAttachment;
+exports.resolveEmailAttachment = resolveEmailAttachment;
+exports.parseEmailAttachmentRef = parseEmailAttachmentRef;
+exports.projectPublicInboxEntry = projectPublicInboxEntry;
+exports.redactInternalEmailRefs = redactInternalEmailRefs;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const ATTACHMENT_REF_PREFIX = "att_v1";
+const ATTACHMENT_SELECTOR_LENGTH = 22;
+const ATTACHMENT_REF_PATTERN = new RegExp(`^${ATTACHMENT_REF_PREFIX}\\.([A-Za-z0-9_-]+)\\.([A-Za-z0-9_-]{${ATTACHMENT_SELECTOR_LENGTH}})$`);
+function publicEmailAttachmentCollection(itemId, metadata, materializationLookup) {
+    const rawAttachments = Array.isArray(metadata?.attachments)
+        ? metadata.attachments.filter(isRecord)
+        : [];
+    const attachmentCount = optionalInteger(metadata?.attachmentCount ?? metadata?.attachment_count);
+    const hasAttachments = rawAttachments.length > 0
+        || (attachmentCount !== null && attachmentCount > 0)
+        || metadata?.hasAttachments === true
+        || metadata?.has_attachments === true;
+    const explicitCompleteness = optionalBoolean(metadata?.attachmentsComplete ?? metadata?.attachments_complete);
+    const attachmentsComplete = explicitCompleteness
+        ?? (attachmentCount !== null
+            ? attachmentCount === rawAttachments.length
+            : (metadata?.hasAttachments === false || metadata?.has_attachments === false)
+                && rawAttachments.length === 0);
+    return {
+        hasAttachments,
+        attachmentCount,
+        attachmentsComplete,
+        attachments: rawAttachments.map((attachment, ordinal) => {
+            const selector = selectorForPublicAttachment(itemId, attachment, ordinal);
+            return publicEmailAttachment(itemId, attachment, ordinal, materializationLookup?.(itemId, selector) ?? null);
+        }),
+    };
+}
+function findPublicEmailAttachment(item, attachmentRef) {
+    return resolveEmailAttachment(item, attachmentRef)?.attachment ?? null;
+}
+function resolveEmailAttachment(item, attachmentRef, materializationLookup) {
+    const parsed = parseEmailAttachmentRef(attachmentRef);
+    if (!parsed || parsed.itemId !== item.itemId) {
+        return null;
+    }
+    const rawAttachments = Array.isArray(item.metadata?.attachments)
+        ? item.metadata.attachments.filter(isRecord)
+        : [];
+    for (const [ordinal, rawAttachment] of rawAttachments.entries()) {
+        const selector = selectorForPublicAttachment(item.itemId, rawAttachment, ordinal);
+        if (selector !== parsed.selector) {
+            continue;
+        }
+        return {
+            attachmentSelector: selector,
+            attachment: publicEmailAttachment(item.itemId, rawAttachment, ordinal, materializationLookup?.(item.itemId, selector) ?? null),
+            handle: isEmailAttachmentHandle(rawAttachment.handle) ? rawAttachment.handle : null,
+        };
+    }
+    return null;
+}
+function parseEmailAttachmentRef(attachmentRef) {
+    const match = ATTACHMENT_REF_PATTERN.exec(attachmentRef);
+    return match ? { itemId: match[1], selector: match[2] } : null;
+}
+function projectPublicInboxEntry(value, materializationLookup) {
+    if (!isRecord(value)) {
+        return redactInternalEmailRefs(value);
+    }
+    const eventVariant = optionalString(value.eventVariant);
+    const itemId = optionalString(value.itemId);
+    const projected = redactInternalEmailRefs(value);
+    if (eventVariant !== "email.message.received" || !itemId) {
+        return projected;
+    }
+    projected.metadata = projectEmailMetadata(itemId, isRecord(value.metadata) ? value.metadata : {}, materializationLookup);
+    projected.rawPayload = projectEmailRawPayload(itemId, isRecord(value.rawPayload) ? value.rawPayload : {}, materializationLookup);
+    delete projected.providerRawPayload;
+    if (isRecord(value.item) && isRecord(projected.item)) {
+        projected.item.metadata = projectEmailMetadata(itemId, isRecord(value.item.metadata) ? value.item.metadata : {}, materializationLookup);
+        projected.item.rawPayload = projectEmailRawPayload(itemId, isRecord(value.item.rawPayload) ? value.item.rawPayload : {}, materializationLookup);
+        delete projected.item.providerRawPayload;
+    }
+    return projected;
+}
+function redactInternalEmailRefs(value) {
+    if (Array.isArray(value)) {
+        return value.map(redactInternalEmailRefs);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const result = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "message_ref" || key === "messageRef") {
+            continue;
+        }
+        if (key === "handle" && isEmailAttachmentHandle(child)) {
+            continue;
+        }
+        result[key] = redactInternalEmailRefs(child);
+    }
+    return result;
+}
+function projectEmailMetadata(itemId, metadata, materializationLookup) {
+    return {
+        ...redactInternalEmailRefs(metadata),
+        ...publicEmailAttachmentCollection(itemId, metadata, materializationLookup),
+    };
+}
+function projectEmailRawPayload(itemId, payload, materializationLookup) {
+    const projected = redactInternalEmailRefs(payload);
+    if (!isRecord(payload.message) || !isRecord(projected.message)) {
+        return projected;
+    }
+    const collection = publicEmailAttachmentCollection(itemId, {
+        attachments: payload.message.attachments,
+        has_attachments: payload.message.has_attachments,
+        attachment_count: payload.message.attachment_count,
+        attachments_complete: payload.message.attachments_complete,
+    }, materializationLookup);
+    projected.message.attachments = collection.attachments;
+    projected.message.attachments_complete = collection.attachmentsComplete;
+    return projected;
+}
+function publicEmailAttachment(itemId, attachment, ordinal, materialization) {
+    const attachmentSelector = selectorForPublicAttachment(itemId, attachment, ordinal);
+    const handleRetrievable = isEmailAttachmentHandle(attachment.handle);
+    const status = materialization?.status
+        ?? emailAttachmentStatus(attachment.status)
+        ?? (handleRetrievable ? "remote_only" : "metadata_only");
+    return {
+        attachmentRef: `${ATTACHMENT_REF_PREFIX}.${itemId}.${attachmentSelector}`,
+        filename: optionalString(attachment.filename),
+        contentType: optionalString(attachment.content_type) ?? optionalString(attachment.contentType),
+        detectedContentType: materialization?.detectedContentType
+            ?? optionalString(attachment.detectedContentType)
+            ?? optionalString(attachment.detected_content_type),
+        size: optionalInteger(attachment.size),
+        disposition: attachment.disposition === "attachment" || attachment.disposition === "inline"
+            ? attachment.disposition
+            : null,
+        contentId: optionalString(attachment.content_id) ?? optionalString(attachment.contentId),
+        status,
+        retrievable: handleRetrievable || status === "available",
+    };
+}
+function selectorForPublicAttachment(itemId, attachment, ordinal) {
+    const existingRef = optionalString(attachment.attachmentRef);
+    const parsed = existingRef ? parseEmailAttachmentRef(existingRef) : null;
+    return parsed?.itemId === itemId ? parsed.selector : attachmentSelector(attachment, ordinal);
+}
+function attachmentSelector(attachment, ordinal) {
+    const stableId = optionalString(attachment.id);
+    const identity = stableId
+        ? { id: stableId }
+        : {
+            ordinal,
+            filename: optionalString(attachment.filename),
+            contentType: optionalString(attachment.content_type) ?? optionalString(attachment.contentType),
+            size: optionalInteger(attachment.size),
+            disposition: optionalString(attachment.disposition),
+            contentId: optionalString(attachment.content_id) ?? optionalString(attachment.contentId),
+        };
+    return node_crypto_1.default.createHash("sha256")
+        .update(JSON.stringify(identity))
+        .digest("base64url")
+        .slice(0, ATTACHMENT_SELECTOR_LENGTH);
+}
+function isEmailAttachmentHandle(value) {
+    return isRecord(value) && value.type === "email_attachment";
+}
+function emailAttachmentStatus(value) {
+    return value === "metadata_only"
+        || value === "remote_only"
+        || value === "pending"
+        || value === "available"
+        || value === "quarantined"
+        || value === "rejected"
+        || value === "failed"
+        || value === "deleted"
+        ? value
+        : null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : null;
+}
+function optionalInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : null;
+}
+function optionalBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}