salt-agent-sdk 0.1.0

package/dist/crypto.js

@@ -0,0 +1,124 @@
+"use strict";
+// PGP message crypto, wallet-payload crypto, and attachment decryption.
+// Ported from salt-claude-agent/src/{pgp,walletCrypto,attachments}.js --
+// zero LLM/agent-loop dependency in the original, moved verbatim with types.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = decrypt;
+exports.encryptFor = encryptFor;
+exports.generateKeypair = generateKeypair;
+exports.encryptWalletPayload = encryptWalletPayload;
+exports.decryptAttachment = decryptAttachment;
+const openpgp = __importStar(require("openpgp"));
+const nodeCrypto = __importStar(require("node:crypto"));
+/**
+ * Decrypt an armored PGP message with the agent's private key. Salt
+ * encrypts each message to every chat member's public key, so the agent's
+ * own key is among the recipients and can read the ciphertext directly.
+ */
+async function decrypt(armoredMessage, armoredPrivateKey, passphrase) {
+    const privateKey = await openpgp.decryptKey({
+        privateKey: await openpgp.readPrivateKey({ armoredKey: armoredPrivateKey }),
+        passphrase,
+    });
+    const { data } = await openpgp.decrypt({
+        message: await openpgp.readMessage({ armoredMessage }),
+        decryptionKeys: [privateKey],
+    });
+    return data;
+}
+/**
+ * Encrypt plaintext to one or more armored public keys. Passing every
+ * non-agent member's key produces a single ciphertext all of them can read
+ * -- what Salt stores in a message's `message` field.
+ */
+async function encryptFor(plaintext, armoredPublicKeys) {
+    const keys = await Promise.all(armoredPublicKeys.map((k) => openpgp.readKey({ armoredKey: k })));
+    const result = await openpgp.encrypt({
+        message: await openpgp.createMessage({ text: plaintext }),
+        encryptionKeys: keys,
+    });
+    return result;
+}
+/**
+ * Generate a fresh agent keypair -- same curve/format the Salt frontend
+ * uses (salt-fe's src/utilities/encrypt.jsx generateKeys()), so a key
+ * minted here is indistinguishable from one a human created through the UI.
+ */
+async function generateKeypair(passphrase) {
+    const { privateKey, publicKey, revocationCertificate } = await openpgp.generateKey({
+        type: "ecc",
+        curve: "curve25519",
+        userIDs: [{}],
+        passphrase,
+        format: "armored",
+    });
+    const fingerprint = await (await openpgp.readKey({ armoredKey: publicKey })).getFingerprint();
+    return { publicKey, privateKey, revocationCertificate, fingerprint };
+}
+/**
+ * Encrypt a wallet's secrets for upload via client.createWallet. Byte
+ * compatible with salt-fe's walletVault.js wire format: base64 of a
+ * 12-byte random IV || AES-256-GCM ciphertext || 16-byte auth tag. AAD
+ * binds the ciphertext to the wallet's public_address (same as the browser
+ * vault), so a payload can't be replayed onto a different wallet row.
+ * There is no human-memorable recovery phrase here -- the master key
+ * (WALLET_MASTER_KEY) is the only key, held by this process alone.
+ */
+function encryptWalletPayload(masterKeyHex, secrets, publicAddress) {
+    const key = Buffer.from(masterKeyHex, "hex");
+    const iv = nodeCrypto.randomBytes(12);
+    const cipher = nodeCrypto.createCipheriv("aes-256-gcm", key, iv, { authTagLength: 16 });
+    cipher.setAAD(Buffer.from(publicAddress, "utf8"));
+    const plaintext = Buffer.from(JSON.stringify({ private_key: secrets.private_key, mnemonic: secrets.mnemonic || null }), "utf8");
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    return Buffer.concat([iv, ciphertext, cipher.getAuthTag()]).toString("base64");
+}
+/**
+ * Decrypt a message attachment's ciphertext bytes (see client.getAttachment).
+ * Mirrors salt-fe's src/utilities/attachments.js: Web Crypto AES-256-GCM
+ * output is ciphertext with the 16-byte auth tag appended, so Node's crypto
+ * module needs that tag split off and set explicitly via setAuthTag.
+ */
+function decryptAttachment(ciphertextBuffer, keyB64, ivB64) {
+    const key = Buffer.from(keyB64, "base64");
+    const iv = Buffer.from(ivB64, "base64");
+    const tag = ciphertextBuffer.subarray(ciphertextBuffer.length - 16);
+    const encrypted = ciphertextBuffer.subarray(0, ciphertextBuffer.length - 16);
+    const decipher = nodeCrypto.createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
+//# sourceMappingURL=crypto.js.map

package/dist/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":";AAAA,wEAAwE;AACxE,yEAAyE;AACzE,6EAA6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiB7E,0BAcC;AAOD,gCAOC;AAOD,0CAUC;AAgBD,oDAQC;AAQD,8CASC;AArGD,iDAAmC;AACnC,wDAA0C;AAS1C;;;;GAIG;AACI,KAAK,UAAU,OAAO,CAC3B,cAAsB,EACtB,iBAAyB,EACzB,UAAkB;IAElB,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC;QAC1C,UAAU,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;QAC3E,UAAU;KACX,CAAC,CAAC;IACH,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC;QACrC,OAAO,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;QACtD,cAAc,EAAE,CAAC,UAAU,CAAC;KAC7B,CAAC,CAAC;IACH,OAAO,IAAc,CAAC;AACxB,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,UAAU,CAAC,SAAiB,EAAE,iBAA2B;IAC7E,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjG,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC;QACnC,OAAO,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QACzD,cAAc,EAAE,IAAI;KACrB,CAAC,CAAC;IACH,OAAO,MAAgB,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,eAAe,CAAC,UAAkB;IACtD,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,qBAAqB,EAAE,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC;QACjF,IAAI,EAAE,KAAK;QACX,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,CAAC,EAAE,CAAC;QACb,UAAU;QACV,MAAM,EAAE,SAAS;KAClB,CAAC,CAAC;IACH,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC;IAC9F,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,qBAAqB,EAAE,WAAW,EAAE,CAAC;AACvE,CAAC;AAOD;;;;;;;;GAQG;AACH,SAAgB,oBAAoB,CAAC,YAAoB,EAAE,OAAsB,EAAE,aAAqB;IACtG,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IAC7C,MAAM,EAAE,GAAG,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,UAAU,CAAC,cAAc,CAAC,aAAa,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC;IACxF,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;IAChI,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC7E,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AACjF,CAAC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,gBAAwB,EAAE,MAAc,EAAE,KAAa;IACvF,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1C,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACxC,MAAM,GAAG,GAAG,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IACpE,MAAM,SAAS,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC,EAAE,gBAAgB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAE7E,MAAM,QAAQ,GAAG,UAAU,CAAC,gBAAgB,CAAC,aAAa,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;IACrE,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACzB,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACvE,CAAC"}

package/dist/delegations.d.ts

@@ -0,0 +1,58 @@
+/** depth counts hops already taken; a call at depth >= this is refused, so a
+ *  chain reaches at most MAX_DELEGATION_DEPTH+1 agents before the last one
+ *  is forced to answer directly instead of delegating further. */
+export declare const MAX_DELEGATION_DEPTH = 3;
+/** observed single search-heavy replies take up to ~30s; a delegate's own
+ *  reply can itself involve tool rounds (including one more delegation
+ *  hop), so this gives ~3x headroom per hop. */
+export declare const DELEGATION_TIMEOUT_MS = 90000;
+/**
+ * Prefixes an outbound delegation message with its hop depth. Stripped by
+ * parseIncoming on the receiving end before the task text ever reaches that
+ * identity's agent logic -- the marker is wire protocol, not conversational
+ * content.
+ */
+export declare function wrap(depth: number, text: string): string;
+/**
+ * Splits an incoming plaintext into { depth, text }. Ordinary,
+ * non-delegated messages (the overwhelming majority -- anything from a
+ * human, or an agent message with no marker) have no prefix and come back
+ * as { depth: 0, text: plaintext } unchanged, so this is a no-op on the
+ * existing message path.
+ */
+export declare function parseIncoming(plaintext: string): {
+    depth: number;
+    text: string;
+};
+export declare function hasPending(chatId: number): boolean;
+/**
+ * Registers a wait for the next reply in `chatId` from `targetId`, and
+ * returns a Promise that resolves with the reply's plaintext, or rejects if
+ * `timeoutMs` elapses first. Throws synchronously (before any network call)
+ * if this chat already has a pending wait.
+ */
+export declare function register(chatId: number, targetId: number, timeoutMs: number): Promise<string>;
+/**
+ * Clears a pending wait without settling its promise -- used when sending
+ * the delegation message itself fails after register() already ran, so the
+ * registry entry doesn't leak (the caller throws its own error instead).
+ */
+export declare function cancel(chatId: number): void;
+/**
+ * Call right after decrypting an inbound message, before deciding whether
+ * to run a fresh reply cycle. If `chatId` has a pending wait AND `senderId`
+ * is the identity it's waiting on, resolves that wait with `plaintext` and
+ * returns true (caller should stop processing this message as a new
+ * prompt). Returns false for everything else -- including a delegation
+ * TARGET's very first inbound request, which by definition has no pending
+ * entry on its own server.
+ */
+export declare function resolveIfPending(chatId: number, senderId: number, plaintext: string): boolean;
+export interface DelegationTrailEntry {
+    agent_id: number;
+    chat_id: number;
+    username: string;
+}
+export declare function recordTrail(identityId: number, mainChatId: number, entry: DelegationTrailEntry): void;
+export declare function drainTrail(identityId: number, mainChatId: number): DelegationTrailEntry[];
+//# sourceMappingURL=delegations.d.ts.map

package/dist/delegations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegations.d.ts","sourceRoot":"","sources":["../src/delegations.ts"],"names":[],"mappings":"AAmBA;;kEAEkE;AAClE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;gDAEgD;AAChD,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAI5C;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAIhF;AAeD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAW7F;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAK3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAO7F;AAID,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAeD,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAIrG;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAKzF"}

package/dist/delegations.js

@@ -0,0 +1,140 @@
+"use strict";
+// Lets one hosted identity ask another Salt agent for help and wait for its
+// reply, entirely over real Salt chat messages. Ported from
+// salt-claude-agent/src/delegations.js. Two problems only this module solves:
+//
+// 1. The target's reply comes back through the exact same webhook path as
+//    any ordinary inbound message. In a 1:1 chat, Salt webhooks EVERY member
+//    for EVERY message (no @mention gating -- that's group-chat only), so
+//    without this registry the delegator would treat the target's reply as a
+//    brand-new prompt and answer it back into the same chat, which the
+//    target would then also treat as new, forever. `register`/`resolveIfPending`
+//    let a webhook handler recognize "this inbound message is the reply I'm
+//    waiting on" and resolve it before the agent's own reply logic ever
+//    sees it.
+// 2. Nothing else bounds how many hops a delegation chain can take (an agent
+//    asked could itself try to delegate further) or how long one hop can
+//    take. `wrap`/`parseIncoming` carry a hop counter across the wire (the
+//    only channel available between two separately-hosted agents is the
+//    message text itself), and `register`'s timeout bounds each hop.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELEGATION_TIMEOUT_MS = exports.MAX_DELEGATION_DEPTH = void 0;
+exports.wrap = wrap;
+exports.parseIncoming = parseIncoming;
+exports.hasPending = hasPending;
+exports.register = register;
+exports.cancel = cancel;
+exports.resolveIfPending = resolveIfPending;
+exports.recordTrail = recordTrail;
+exports.drainTrail = drainTrail;
+/** depth counts hops already taken; a call at depth >= this is refused, so a
+ *  chain reaches at most MAX_DELEGATION_DEPTH+1 agents before the last one
+ *  is forced to answer directly instead of delegating further. */
+exports.MAX_DELEGATION_DEPTH = 3;
+/** observed single search-heavy replies take up to ~30s; a delegate's own
+ *  reply can itself involve tool rounds (including one more delegation
+ *  hop), so this gives ~3x headroom per hop. */
+exports.DELEGATION_TIMEOUT_MS = 90_000;
+const MARKER_RE = /^\[\[SALT-DELEGATION depth=(\d+)\]\]\n/;
+/**
+ * Prefixes an outbound delegation message with its hop depth. Stripped by
+ * parseIncoming on the receiving end before the task text ever reaches that
+ * identity's agent logic -- the marker is wire protocol, not conversational
+ * content.
+ */
+function wrap(depth, text) {
+    return `[[SALT-DELEGATION depth=${depth}]]\n${text}`;
+}
+/**
+ * Splits an incoming plaintext into { depth, text }. Ordinary,
+ * non-delegated messages (the overwhelming majority -- anything from a
+ * human, or an agent message with no marker) have no prefix and come back
+ * as { depth: 0, text: plaintext } unchanged, so this is a no-op on the
+ * existing message path.
+ */
+function parseIncoming(plaintext) {
+    const match = MARKER_RE.exec(plaintext);
+    if (!match)
+        return { depth: 0, text: plaintext };
+    return { depth: parseInt(match[1], 10), text: plaintext.slice(match[0].length) };
+}
+// chatId -> pending wait. One pending wait per chat at a time -- a second
+// concurrent delegation call into the same chat is a clean error (see
+// register below) rather than an ambiguous race over which reply belongs
+// to which caller.
+const pending = new Map();
+function hasPending(chatId) {
+    return pending.has(chatId);
+}
+/**
+ * Registers a wait for the next reply in `chatId` from `targetId`, and
+ * returns a Promise that resolves with the reply's plaintext, or rejects if
+ * `timeoutMs` elapses first. Throws synchronously (before any network call)
+ * if this chat already has a pending wait.
+ */
+function register(chatId, targetId, timeoutMs) {
+    if (pending.has(chatId)) {
+        throw new Error("Already waiting on a reply from this agent in this chat -- wait for that to finish first.");
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(chatId);
+            reject(new Error(`No reply within ${Math.round(timeoutMs / 1000)}s -- the agent may be offline or slow.`));
+        }, timeoutMs);
+        pending.set(chatId, { targetId, resolve, reject, timer });
+    });
+}
+/**
+ * Clears a pending wait without settling its promise -- used when sending
+ * the delegation message itself fails after register() already ran, so the
+ * registry entry doesn't leak (the caller throws its own error instead).
+ */
+function cancel(chatId) {
+    const entry = pending.get(chatId);
+    if (!entry)
+        return;
+    clearTimeout(entry.timer);
+    pending.delete(chatId);
+}
+/**
+ * Call right after decrypting an inbound message, before deciding whether
+ * to run a fresh reply cycle. If `chatId` has a pending wait AND `senderId`
+ * is the identity it's waiting on, resolves that wait with `plaintext` and
+ * returns true (caller should stop processing this message as a new
+ * prompt). Returns false for everything else -- including a delegation
+ * TARGET's very first inbound request, which by definition has no pending
+ * entry on its own server.
+ */
+function resolveIfPending(chatId, senderId, plaintext) {
+    const entry = pending.get(chatId);
+    if (!entry || entry.targetId !== senderId)
+        return false;
+    clearTimeout(entry.timer);
+    pending.delete(chatId);
+    entry.resolve(plaintext);
+    return true;
+}
+// While an identity is composing ONE reply, each successful delegation
+// records who was consulted here. When the reply is posted back to the
+// originating chat, the caller drains this and attaches it as the
+// message's `delegations` metadata -- powering the "consulted @agent"
+// expander a human sees on that reply. Keyed by identity + originating
+// chat so concurrent replies (different chats, or different hosted
+// identities) never mix their trails.
+const trails = new Map();
+function trailKey(identityId, mainChatId) {
+    return `${identityId}:${mainChatId}`;
+}
+function recordTrail(identityId, mainChatId, entry) {
+    const key = trailKey(identityId, mainChatId);
+    if (!trails.has(key))
+        trails.set(key, []);
+    trails.get(key).push(entry);
+}
+function drainTrail(identityId, mainChatId) {
+    const key = trailKey(identityId, mainChatId);
+    const entries = trails.get(key) || [];
+    trails.delete(key);
+    return entries;
+}
+//# sourceMappingURL=delegations.js.map

package/dist/delegations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegations.js","sourceRoot":"","sources":["../src/delegations.ts"],"names":[],"mappings":"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"}

package/dist/identities.d.ts

@@ -0,0 +1,25 @@
+export interface AgentIdentity {
+    saltAppId: number;
+    username: string;
+    displayName?: string;
+    apiKey: string;
+    publicKey: string;
+    privateKey: string;
+    /** Free-form per-identity state a consumer's own agent loop may want to stash (e.g. a system prompt). */
+    [key: string]: unknown;
+}
+export interface IdentityStore {
+    register(identity: AgentIdentity): void;
+    get(saltAppId: number): AgentIdentity | undefined;
+    all(): AgentIdentity[];
+}
+/**
+ * Creates a JSON-file-backed identity store. Loads synchronously at
+ * creation time so a spawned agent's keys survive a process restart --
+ * without this, restarting to pick up a code change would silently orphan
+ * every agent the process had ever spawned (their identity would only have
+ * lived in memory, so they'd stop being able to decrypt anything sent to
+ * them).
+ */
+export declare function createIdentityStore(storePath?: string): IdentityStore;
+//# sourceMappingURL=identities.d.ts.map

package/dist/identities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identities.d.ts","sourceRoot":"","sources":["../src/identities.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,yGAAyG;IACzG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;IACxC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;IAClD,GAAG,IAAI,aAAa,EAAE,CAAC;CACxB;AAID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,GAAE,MAA2B,GAAG,aAAa,CA6CzF"}

package/dist/identities.js

@@ -0,0 +1,107 @@
+"use strict";
+// Registry of every Salt agent identity a process can act as: a primary
+// one from the consumer's own config, plus any it spawns at runtime (e.g.
+// via an actions.createSaltAgent call). Spawned agents share the same
+// webhook server as their parent, so incoming requests get routed to the
+// right identity by trying each one's private key against the ciphertext
+// (see webhook.ts's resolveIdentity).
+//
+// Ported from salt-claude-agent/src/identities.js, restructured from a
+// module-level singleton into a factory: the original hardcoded its store
+// path relative to its own __dirname, which only works when the file lives
+// in the top-level app -- once this is a node_modules dependency,
+// __dirname points inside node_modules/salt-agent-sdk/dist instead of the
+// consumer's own project, silently breaking persistence. Callers now pass
+// an explicit path (or accept the process.cwd()-relative default).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentityStore = createIdentityStore;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const DEFAULT_STORE_PATH = path.join(process.cwd(), "data", "identities.json");
+/**
+ * Creates a JSON-file-backed identity store. Loads synchronously at
+ * creation time so a spawned agent's keys survive a process restart --
+ * without this, restarting to pick up a code change would silently orphan
+ * every agent the process had ever spawned (their identity would only have
+ * lived in memory, so they'd stop being able to decrypt anything sent to
+ * them).
+ */
+function createIdentityStore(storePath = DEFAULT_STORE_PATH) {
+    const identities = new Map();
+    function load() {
+        let raw;
+        try {
+            raw = fs.readFileSync(storePath, "utf8");
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                console.error("[identities] failed to read store:", err.message);
+            }
+            return;
+        }
+        try {
+            for (const identity of JSON.parse(raw)) {
+                identities.set(identity.saltAppId, identity);
+            }
+        }
+        catch (err) {
+            console.error("[identities] failed to parse store:", err.message);
+        }
+    }
+    function persist() {
+        try {
+            fs.mkdirSync(path.dirname(storePath), { recursive: true });
+            fs.writeFileSync(storePath, JSON.stringify(Array.from(identities.values()), null, 2));
+        }
+        catch (err) {
+            console.error("[identities] failed to persist store:", err.message);
+        }
+    }
+    load();
+    return {
+        register(identity) {
+            identities.set(identity.saltAppId, identity);
+            persist();
+        },
+        get(saltAppId) {
+            return identities.get(saltAppId);
+        },
+        all() {
+            return Array.from(identities.values());
+        },
+    };
+}
+//# sourceMappingURL=identities.js.map

package/dist/identities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identities.js","sourceRoot":"","sources":["../src/identities.ts"],"names":[],"mappings":";AAAA,wEAAwE;AACxE,0EAA0E;AAC1E,sEAAsE;AACtE,yEAAyE;AACzE,yEAAyE;AACzE,sCAAsC;AACtC,EAAE;AACF,uEAAuE;AACvE,0EAA0E;AAC1E,2EAA2E;AAC3E,kEAAkE;AAClE,0EAA0E;AAC1E,0EAA0E;AAC1E,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCnE,kDA6CC;AA3ED,4CAA8B;AAC9B,gDAAkC;AAmBlC,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAE/E;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAC,YAAoB,kBAAkB;IACxE,MAAM,UAAU,GAAG,IAAI,GAAG,EAAyB,CAAC;IAEpD,SAAS,IAAI;QACX,IAAI,GAAW,CAAC;QAChB,IAAI,CAAC;YACH,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAK,GAA6B,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrD,OAAO,CAAC,KAAK,CAAC,oCAAoC,EAAG,GAAa,CAAC,OAAO,CAAC,CAAC;YAC9E,CAAC;YACD,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAoB,EAAE,CAAC;gBAC1D,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAG,GAAa,CAAC,OAAO,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAED,SAAS,OAAO;QACd,IAAI,CAAC;YACH,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC3D,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QACxF,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAG,GAAa,CAAC,OAAO,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED,IAAI,EAAE,CAAC;IAEP,OAAO;QACL,QAAQ,CAAC,QAAuB;YAC9B,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC7C,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,GAAG,CAAC,SAAiB;YACnB,OAAO,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnC,CAAC;QACD,GAAG;YACD,OAAO,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./client";
+export * from "./crypto";
+export * from "./identities";
+export * from "./delegations";
+export * from "./webhook";
+export * from "./actions";
+export * from "./config";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./crypto"), exports);
+__exportStar(require("./identities"), exports);
+__exportStar(require("./delegations"), exports);
+__exportStar(require("./webhook"), exports);
+__exportStar(require("./actions"), exports);
+__exportStar(require("./config"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,2CAAyB;AACzB,+CAA6B;AAC7B,gDAA8B;AAC9B,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB"}

package/dist/webhook.d.ts

@@ -0,0 +1,127 @@
+import { type Express } from "express";
+import type { SaltClient } from "./client";
+import type { AgentIdentity, IdentityStore } from "./identities";
+/** The exact marker a hand-off briefing must start with, so the incoming
+ *  agent's polling loop (below) can detect it arrived. Consumers building
+ *  the outgoing briefing prompt must instruct their model to emit this
+ *  exact line first. */
+export declare const HANDOFF_BRIEFING_MARKER = "[[SALT-HANDOFF-BRIEFING]]";
+export interface RawChatMeta {
+    active_agent_id?: number | string;
+    mediator_agent_id?: number | string;
+    coaching_for_chat_id?: number | string;
+    mode?: "auto" | "manual";
+    [key: string]: unknown;
+}
+export interface RawSender {
+    id: number | string;
+    display_name?: string;
+    account_type?: "User" | "Agent";
+    [key: string]: unknown;
+}
+export interface DecryptedAttachment {
+    filename: string;
+    contentType: string;
+    size: number;
+    /** Present only when contentType starts with "image/" -- the SDK doesn't
+     *  know how to represent other file types beyond a note in `unsupportedNote`. */
+    data?: Buffer;
+    unsupportedNote?: string;
+}
+export interface MessageContext {
+    identity: AgentIdentity;
+    chatId: number;
+    senderId: number;
+    sender: RawSender;
+    /** Delegation-marker-stripped plaintext (see delegations.parseIncoming). */
+    text: string;
+    /** Delegation hop depth this message arrived at; pass through to any further delegate call. */
+    delegationDepth: number;
+    chatMeta?: RawChatMeta;
+    /** Set when this identity is the configured Mediator privately coaching
+     *  someone about a shared chat it also observes -- the generic decrypted
+     *  transcript of that shared chat (not yet wrapped in any prompt framing). */
+    mediatorSharedContext?: string;
+    /** Set when the inbound message was an Attachment with decryptable metadata. */
+    attachment?: DecryptedAttachment;
+    /** Encrypts `text` for every current chat member (+ this identity's own
+     *  copy), posts it, drains this reply's delegation trail onto it, and
+     *  emits an agent_reply_sent metric. Handles a typing-indicator heartbeat
+     *  for the duration of the call automatically. */
+    reply(text: string): Promise<void>;
+}
+export interface CardInteractionContext {
+    identity: AgentIdentity;
+    chatId: number;
+    cardId: number | string;
+    actionId: string;
+    user: RawSender;
+    blocks: unknown;
+}
+export interface InvoicePaidContext {
+    identity: AgentIdentity;
+    chatId: number;
+    buyer: RawSender;
+    lineItems: Array<{
+        name: string;
+        qty: number;
+        [key: string]: unknown;
+    }>;
+    amount: string | number;
+    /** True for a "Credits top-up" invoice -- no delivery owed, the credit already landed server-side. */
+    isTopUp: boolean;
+    transferRequestId: number | string;
+    reply(text: string): Promise<void>;
+}
+export interface HandoffConfirmedContext {
+    identity: AgentIdentity;
+    chatId: number;
+    reason?: string;
+    reply(text: string): Promise<void>;
+}
+export interface HandoffReceivedContext {
+    identity: AgentIdentity;
+    chatId: number;
+    reason?: string;
+    /** The shared chat's decrypted transcript, polled for up to ~20s until
+     *  the outgoing agent's HANDOFF_BRIEFING_MARKER shows up (or timeout). */
+    context: string;
+    reply(text: string): Promise<void>;
+}
+export interface Logger {
+    info(msg: string): void;
+    error(msg: string): void;
+}
+export interface WebhookServerOptions {
+    client: SaltClient;
+    identities: IdentityStore;
+    pgpPassphrase: string;
+    /** Required in production: must match the X-Salt-Webhook-Secret header
+     *  salt-api's jobs send. Unset (local dev) skips the check entirely --
+     *  encrypted-message webhooks fail safe regardless (forged ciphertext
+     *  never decrypts), but card_interaction/invoice_paid payloads are
+     *  plaintext and would otherwise be actable by anyone who can reach this server. */
+    webhookSharedSecret?: string;
+    /** This process's configured Mediator identity, if any -- enables the
+     *  "observe the shared chat silently, only speak in private coaching
+     *  chats" gate. */
+    mediatorAgentId?: number;
+    logger?: Logger;
+    onMessage?: (ctx: MessageContext) => Promise<void> | void;
+    onCardInteraction?: (ctx: CardInteractionContext) => Promise<void> | void;
+    onInvoicePaid?: (ctx: InvoicePaidContext) => Promise<void> | void;
+    onHandoffConfirmed?: (ctx: HandoffConfirmedContext) => Promise<void> | void;
+    onHandoffReceived?: (ctx: HandoffReceivedContext) => Promise<void> | void;
+    /** Extra fields to merge into the /health JSON response (e.g. which model is configured). */
+    healthExtra?: () => Record<string, unknown>;
+}
+/**
+ * Creates the Express app for a Salt agent's webhook endpoint. Mount it
+ * yourself (e.g. `createWebhookServer(opts).listen(port)`, or grab `.app`
+ * to compose it into a bigger server).
+ */
+export declare function createWebhookServer(options: WebhookServerOptions): {
+    app: Express;
+    listen: (port: number) => void;
+};
+//# sourceMappingURL=webhook.d.ts.map