@oxygen-agent/cli 1.353.2 → 1.365.3

package/node_modules/@oxygen/shared/dist/index.js

@@ -8,16 +8,19 @@ export * from "./cli-envelope.js";
 export * from "./cli-login-code.js";
 export * from "./cli-result.js";
 export * from "./column-types.js";
+export * from "./copilot-journeys.js";
 export * from "./credit-guidance.js";
 export * from "./directory.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./error-redaction.js";
+export * from "./hosted-ai.js";
 export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";
+export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";

package/node_modules/@oxygen/shared/dist/linkedin-mentions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Compile LinkedIn post text + stored mention state into Unipile's post
+ * contract: the outgoing text carries `{{i}}` placeholders and `mentions[i]`
+ * is `{ name, profile_id }`. Anything else (raw `@handle` text next to a
+ * mentions array, Oxygen mention-preview snapshots, unresolved handles) is
+ * NOT a tagged mention on LinkedIn — the provider either posts it literally
+ * or, worse, name-matches entries into the wrong span of text.
+ *
+ * Accepted inputs per entry (both arrays are optional):
+ * - Unipile-shaped: `{ name, profile_id }` (already the wire contract).
+ * - Oxygen preview-shaped (publishing mentions resolve output): uses
+ *   `displayName`/`providerId` (or snake_case), and is only eligible when
+ *   `status === "resolved"` and `semantics` is `"mention"` (links and plain
+ *   references stay as typed).
+ *
+ * Placement: an entry becomes a tagged mention only when its span can be
+ * anchored in the text — an existing `{{i}}` placeholder, the entry's `raw`
+ * occurrence, or `@name`/`@identifier`. Entries that cannot be anchored are
+ * dropped from the outgoing array so the provider can never guess a span.
+ */
+export type UnipileLinkedInMention = {
+    name: string;
+    profile_id: string;
+};
+export type CompiledLinkedInMentions = {
+    text: string;
+    mentions: UnipileLinkedInMention[];
+    dropped: Array<{
+        name: string | null;
+        reason: "unresolved" | "not_in_text" | "invalid";
+    }>;
+};
+export declare function compileLinkedInMentions(input: {
+    text: string;
+    mentions?: unknown;
+    mentionPreviews?: unknown;
+}): CompiledLinkedInMentions;

package/node_modules/@oxygen/shared/dist/linkedin-mentions.js

@@ -0,0 +1,157 @@
+/**
+ * Compile LinkedIn post text + stored mention state into Unipile's post
+ * contract: the outgoing text carries `{{i}}` placeholders and `mentions[i]`
+ * is `{ name, profile_id }`. Anything else (raw `@handle` text next to a
+ * mentions array, Oxygen mention-preview snapshots, unresolved handles) is
+ * NOT a tagged mention on LinkedIn — the provider either posts it literally
+ * or, worse, name-matches entries into the wrong span of text.
+ *
+ * Accepted inputs per entry (both arrays are optional):
+ * - Unipile-shaped: `{ name, profile_id }` (already the wire contract).
+ * - Oxygen preview-shaped (publishing mentions resolve output): uses
+ *   `displayName`/`providerId` (or snake_case), and is only eligible when
+ *   `status === "resolved"` and `semantics` is `"mention"` (links and plain
+ *   references stay as typed).
+ *
+ * Placement: an entry becomes a tagged mention only when its span can be
+ * anchored in the text — an existing `{{i}}` placeholder, the entry's `raw`
+ * occurrence, or `@name`/`@identifier`. Entries that cannot be anchored are
+ * dropped from the outgoing array so the provider can never guess a span.
+ */
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+const PLACEHOLDER_RE = /\{\{(\d+)\}\}/g;
+function normalizeEntry(value) {
+    if (!isRecord(value))
+        return "invalid";
+    const status = readString(value, "status");
+    const semantics = readString(value, "semantics");
+    // Preview-shaped entries: only resolved, mention-semantics entries qualify.
+    // Links (full LinkedIn URLs) and plain references stay as typed text.
+    if (semantics === "link" || semantics === "plain")
+        return "skip";
+    if (status && status !== "resolved")
+        return "unresolved";
+    const name = readString(value, "name", "displayName", "display_name");
+    const profileId = readString(value, "profile_id", "providerId", "provider_id");
+    if (!name || !profileId)
+        return status || semantics ? "unresolved" : "invalid";
+    return {
+        name,
+        profileId,
+        raw: readString(value, "raw"),
+        identifier: readString(value, "identifier", "publicIdentifier", "public_identifier"),
+    };
+}
+/**
+ * True when the text already uses `{{i}}` placeholders that all resolve to a
+ * valid `{ name, profile_id }` entry — the caller pre-compiled the contract,
+ * so text and mentions pass through unchanged.
+ */
+function isPrecompiled(text, entries) {
+    const indexes = [...text.matchAll(PLACEHOLDER_RE)].map((match) => Number(match[1]));
+    if (indexes.length === 0)
+        return false;
+    return indexes.every((index) => {
+        const normalized = normalizeEntry(entries[index]);
+        return typeof normalized === "object";
+    });
+}
+export function compileLinkedInMentions(input) {
+    const explicit = Array.isArray(input.mentions) ? input.mentions : [];
+    const previews = Array.isArray(input.mentionPreviews) ? input.mentionPreviews : [];
+    if (isPrecompiled(input.text, explicit)) {
+        // Compact the array and renumber placeholders together: a non-object
+        // entry at an unreferenced index below a referenced one would otherwise
+        // shift later entries down while `{{i}}` numbers stay fixed, pointing a
+        // placeholder at the wrong (or missing) identity.
+        const mentions = [];
+        const remap = new Map();
+        explicit.forEach((value, oldIndex) => {
+            const entry = normalizeEntry(value);
+            if (typeof entry !== "object")
+                return;
+            remap.set(oldIndex, mentions.length);
+            mentions.push({ name: entry.name, profile_id: entry.profileId });
+        });
+        const text = input.text.replace(PLACEHOLDER_RE, (whole, digits) => {
+            const next = remap.get(Number(digits));
+            return next === undefined ? whole : `{{${next}}}`;
+        });
+        return { text, mentions, dropped: [] };
+    }
+    const dropped = [];
+    const placed = [];
+    let text = input.text;
+    const seenProfileIds = new Set();
+    for (const value of [...explicit, ...previews]) {
+        const entry = normalizeEntry(value);
+        if (entry === "skip")
+            continue;
+        if (entry === "invalid") {
+            dropped.push({ name: isRecord(value) ? readString(value, "name", "displayName", "display_name") : null, reason: "invalid" });
+            continue;
+        }
+        if (entry === "unresolved") {
+            dropped.push({ name: isRecord(value) ? readString(value, "name", "displayName", "display_name", "raw") : null, reason: "unresolved" });
+            continue;
+        }
+        if (seenProfileIds.has(entry.profileId))
+            continue;
+        const anchor = findAnchor(text, entry);
+        if (!anchor) {
+            dropped.push({ name: entry.name, reason: "not_in_text" });
+            continue;
+        }
+        const index = placed.length;
+        text = text.slice(0, anchor.start) + `{{${index}}}` + text.slice(anchor.end);
+        placed.push({ name: entry.name, profile_id: entry.profileId });
+        seenProfileIds.add(entry.profileId);
+    }
+    return { text, mentions: placed, dropped };
+}
+/**
+ * Find the span the mention replaces. Candidates are tried most-specific
+ * first: the exact raw capture from resolve time (`@handle`, URN, …), then
+ * `@identifier`, then `@name`. Bare names are never matched — replacing an
+ * un-prefixed word is how mentions end up covering the wrong text.
+ */
+function findAnchor(text, entry) {
+    const candidates = [
+        entry.raw,
+        entry.identifier ? `@${entry.identifier}` : null,
+        `@${entry.name}`,
+    ].filter((candidate) => Boolean(candidate && candidate.trim()));
+    const lowerText = text.toLowerCase();
+    for (const candidate of candidates) {
+        const lowerCandidate = candidate.toLowerCase();
+        // Reject matches that continue into more handle characters so `@acme`
+        // can never anchor inside `@acme-labs` — a partial span is exactly the
+        // wrong-mention rendering this compiler exists to prevent. A dot only
+        // continues the handle when an identifier character follows it
+        // (`@acme.io`); a sentence period (`@n8n. Next…`) is a boundary.
+        let from = 0;
+        while (from <= lowerText.length - lowerCandidate.length) {
+            const start = lowerText.indexOf(lowerCandidate, from);
+            if (start < 0)
+                break;
+            const end = start + candidate.length;
+            const next = text[end];
+            const continues = next !== undefined && (/[a-z0-9_-]/i.test(next)
+                || (next === "." && text[end + 1] !== undefined && /[a-z0-9_-]/i.test(text[end + 1])));
+            if (!continues)
+                return { start, end };
+            from = start + 1;
+        }
+    }
+    return null;
+}

package/node_modules/@oxygen/shared/dist/tags.d.ts

@@ -1,5 +1,5 @@
 /** Primitive kinds that participate in the workspace tag union today. */
-export declare const TAG_KINDS: readonly ["knowledge_page", "sequence", "table", "workflow", "recipe"];
+export declare const TAG_KINDS: readonly ["knowledge_page", "publishing_post", "sequence", "table", "workflow", "recipe"];
 export type TagKind = (typeof TAG_KINDS)[number];
 export declare function isTagKind(value: unknown): value is TagKind;
 /** Hard cap per tagged item — matches the wiki's long-standing limit. */

package/node_modules/@oxygen/shared/dist/tags.js

@@ -7,6 +7,7 @@
 /** Primitive kinds that participate in the workspace tag union today. */
 export const TAG_KINDS = [
     "knowledge_page",
+    "publishing_post",
     "sequence",
     "table",
     "workflow",

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,3 +1,3 @@
-export declare const OXYGEN_VERSION = "1.353.2";
+export declare const OXYGEN_VERSION = "1.365.3";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.353.2";
+export const OXYGEN_VERSION = "1.365.3";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.353.2",
+  "version": "1.365.3",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",