agentchannel 0.8.2 → 0.9.2

package/dist/local-store.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, appendFileSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const MESSAGES_DIR = join(homedir(), "agentchannel", "messages");
+function channelDir(channel, subchannel) {
+    const name = subchannel ? `${channel}.${subchannel}` : channel;
+    return join(MESSAGES_DIR, name);
+}
+function monthFile(channel, subchannel, date) {
+    const yyyy = date.getFullYear();
+    const mm = String(date.getMonth() + 1).padStart(2, "0");
+    const name = subchannel ? `${channel}.${subchannel}` : channel;
+    return join(channelDir(channel, subchannel), `${name}.${yyyy}-${mm}.jsonl`);
+}
+export class LocalStore {
+    written = new Set(); // dedup by msg id
+    appendMessage(msg) {
+        if (this.written.has(msg.id))
+            return;
+        const dir = channelDir(msg.channel, msg.subchannel);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const file = monthFile(msg.channel, msg.subchannel, new Date(msg.timestamp));
+        appendFileSync(file, JSON.stringify(msg) + "\n");
+        this.written.add(msg.id);
+    }
+    readMessages(channel, subchannel, since, limit) {
+        const dir = channelDir(channel, subchannel);
+        if (!existsSync(dir))
+            return [];
+        const files = readdirSync(dir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .sort(); // chronological by YYYY-MM
+        const msgs = [];
+        for (const file of files) {
+            const lines = readFileSync(join(dir, file), "utf8").split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const msg = JSON.parse(line);
+                    if (since && msg.timestamp <= since)
+                        continue;
+                    msgs.push(msg);
+                }
+                catch { }
+            }
+        }
+        msgs.sort((a, b) => a.timestamp - b.timestamp);
+        return limit ? msgs.slice(-limit) : msgs;
+    }
+    hasMessage(id) {
+        return this.written.has(id);
+    }
+}
+//# sourceMappingURL=local-store.js.map

package/dist/local-store.js.map

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

package/dist/mqtt-client.d.ts

@@ -1,4 +1,5 @@
 import { MessageStore } from "./store.js";
+import { LocalStore } from "./local-store.js";
 import type { ChatConfig, SingleChannelConfig, Message, ChannelMeta } from "./types.js";
 export declare class AgentChatClient {
     private client;
@@ -7,6 +8,7 @@ export declare class AgentChatClient {
     private name;
     private broker;
     readonly store: MessageStore;
+    readonly localStore: LocalStore;
     private onMessage?;
     private onMeta?;
     private channelMeta;
@@ -46,6 +48,13 @@ export declare class AgentChatClient {
     setOnMeta(handler: (channel: string, meta: ChannelMeta) => void): void;
     getMeta(channel: string): ChannelMeta | undefined;
     publishMeta(channelName: string, meta: ChannelMeta): Promise<void>;
+    private broadcastEpochBump;
+    removeMember(channelName: string, targetFingerprint: string, opts?: {
+        silent?: boolean;
+        reason?: string;
+    }): Promise<void>;
+    rotateChannel(channelName: string): Promise<void>;
+    retractMessage(messageId: string, channelName?: string, reason?: string): Promise<Message>;
     joinDm(theirFingerprint: string): Promise<string>;
     sendDm(theirFingerprint: string, content: string, opts?: {
         subject?: string;

package/dist/mqtt-client.js

@@ -4,10 +4,12 @@ import { userInfo } from "node:os";
 import { execSync } from "node:child_process";
 import { deriveKey, deriveSubKey, hashRoom, hashSub, deriveDmKey, hashDm, encrypt, decrypt } from "./crypto.js";
 import { MessageStore } from "./store.js";
+import { LocalStore } from "./local-store.js";
 import { storeMessage, fetchHistory, registerMember } from "./persistence.js";
 import { ensureIdentity, signMessage, verifySignature, getFingerprint } from "./identity.js";
 import { checkTrust } from "./trust-store.js";
-const DEFAULT_BROKER = "mqtt://broker.emqx.io:1883";
+import { getSyncEnabled, updateChannelEpoch, getChannelEpoch, removeChannel } from "./config.js";
+const DEFAULT_BROKER = "mqtt://35.238.24.59:1883";
 function getDefaultName() {
     // 1. OS username
     try {
@@ -28,7 +30,7 @@ function getDefaultName() {
     return `agent-${fp}`;
 }
 function displayName(state) {
-    return state.subchannel ? `##${state.subchannel}` : `#${state.channel}`;
+    return state.subchannel ? `#${state.channel}/${state.subchannel}` : `#${state.channel}`;
 }
 function fullId(state) {
     return state.subchannel ? `${state.channel}/${state.subchannel}` : state.channel;
@@ -40,6 +42,7 @@ export class AgentChatClient {
     name;
     broker;
     store;
+    localStore;
     onMessage;
     onMeta;
     channelMeta = new Map();
@@ -49,12 +52,15 @@ export class AgentChatClient {
         this.name = config.name || getDefaultName();
         this.broker = config.broker || DEFAULT_BROKER;
         this.store = new MessageStore();
+        this.localStore = new LocalStore();
         this.identity = ensureIdentity();
         this.silent = config.silent || false;
         for (const ch of config.channels) {
-            const key = ch.subchannel ? deriveSubKey(ch.key, ch.subchannel) : deriveKey(ch.key);
+            const epoch = ch.epoch ?? 0;
+            const key = ch.subchannel ? deriveSubKey(ch.key, ch.subchannel, epoch) : deriveKey(ch.key, epoch);
             const hash = ch.subchannel ? hashSub(ch.key, ch.subchannel) : hashRoom(ch.key);
-            this.channels.set(hash, { channel: ch.channel, subchannel: ch.subchannel, key, hash });
+            const channelHash = ch.channelHash || hash;
+            this.channels.set(hash, { channel: ch.channel, subchannel: ch.subchannel, key, hash, channelHash });
             if (!ch.subchannel)
                 this.channelKeys.set(ch.channel, ch.key);
         }
@@ -118,7 +124,7 @@ export class AgentChatClient {
                 this.client.subscribe(topics, { qos: 1 });
                 // Always register as member (even in silent mode)
                 for (const [_hash, state] of this.channels) {
-                    registerMember(state.hash, this.identity.fingerprint, this.name);
+                    registerMember(state.channelHash, this.identity.fingerprint, this.name);
                 }
                 // Only announce presence for long-lived connections (not silent)
                 if (!this.silent) {
@@ -171,6 +177,102 @@ export class AgentChatClient {
             else {
                 msg.trustLevel = "unsigned";
             }
+            // Handle retraction messages — self-only, verify signature
+            if (msg.type === "retraction") {
+                try {
+                    const retraction = JSON.parse(msg.content);
+                    // Verify: retraction sender must match original message sender
+                    const target = this.store.getMessageById(retraction.target_id);
+                    if (target && target.senderKey && msg.senderKey === target.senderKey) {
+                        this.store.addRetraction(retraction.target_id);
+                        // Surface retraction as a system message
+                        const sysMsg = {
+                            id: msg.id,
+                            channel: state.channel,
+                            subchannel: state.subchannel,
+                            sender: "system",
+                            content: `@${msg.sender} retracted message ${retraction.target_id}`,
+                            timestamp: Date.now(),
+                            type: "system",
+                        };
+                        this.store.addMessage(sysMsg);
+                        if (this.onMessage)
+                            this.onMessage(sysMsg);
+                    }
+                }
+                catch { }
+                return;
+            }
+            // Handle epoch_bump DM — owner rotated channel key
+            if (msg.type === "epoch_bump") {
+                try {
+                    const bump = JSON.parse(msg.content);
+                    // Verify sender is a channel owner
+                    const meta = this.channelMeta.get(bump.channel);
+                    if (meta && msg.senderKey && meta.owners.includes(msg.senderKey)) {
+                        // Apply epoch rotation: derive new key + hash, resubscribe
+                        const newKey = deriveKey(bump.new_seed, bump.new_epoch);
+                        const newHash = hashRoom(bump.new_seed);
+                        // Unsubscribe from old topic, preserve channelHash
+                        let preservedChannelHash = "";
+                        for (const [hash, s] of this.channels) {
+                            if (s.channel === bump.channel && !s.subchannel) {
+                                preservedChannelHash = s.channelHash;
+                                if (this.client) {
+                                    this.client.unsubscribe([this.msgTopic(hash), this.presTopic(hash)]);
+                                }
+                                this.channels.delete(hash);
+                                break;
+                            }
+                        }
+                        // Subscribe to new topic (channelHash stays the same)
+                        this.channels.set(newHash, { channel: bump.channel, key: newKey, hash: newHash, channelHash: preservedChannelHash });
+                        this.channelKeys.set(bump.channel, bump.new_seed);
+                        if (this.client) {
+                            this.client.subscribe([this.msgTopic(newHash), this.presTopic(newHash)], { qos: 1 });
+                        }
+                        // Update config
+                        updateChannelEpoch(bump.channel, bump.new_seed, bump.new_epoch);
+                        // System message
+                        const removalInfo = bump.removed_fps?.length
+                            ? `Members removed: ${bump.removed_fps.join(", ")}`
+                            : "Manual key rotation";
+                        const sysMsg = {
+                            id: randomBytes(4).toString("hex"),
+                            channel: bump.channel,
+                            sender: "system",
+                            content: `Channel key rotated to epoch ${bump.new_epoch}. ${removalInfo}`,
+                            timestamp: Date.now(),
+                            type: "system",
+                        };
+                        this.store.addMessage(sysMsg);
+                        if (this.onMessage)
+                            this.onMessage(sysMsg);
+                    }
+                }
+                catch { }
+                return;
+            }
+            // Handle removal_notice DM — you were removed from a channel
+            if (msg.type === "removal_notice") {
+                try {
+                    const notice = JSON.parse(msg.content);
+                    const reason = notice.reason ? ` Reason: ${notice.reason}` : "";
+                    const sysMsg = {
+                        id: randomBytes(4).toString("hex"),
+                        channel: notice.channel,
+                        sender: "system",
+                        content: `You were removed from #${notice.channel} by ${notice.removed_by}.${reason}`,
+                        timestamp: Date.now(),
+                        type: "system",
+                    };
+                    this.store.addMessage(sysMsg);
+                    if (this.onMessage)
+                        this.onMessage(sysMsg);
+                }
+                catch { }
+                return;
+            }
             // Handle channel_meta messages — only accept from owner
             if (msg.type === "channel_meta") {
                 try {
@@ -179,18 +281,28 @@ export class AgentChatClient {
                     // First meta (no existing) or sender is one of the owners
                     if (!existing || (msg.senderKey && existing.owners.includes(msg.senderKey))) {
                         this.channelMeta.set(state.channel, meta);
-                        // Auto-join subchannels listed in meta
-                        if (meta.subchannels && meta.subchannels.length > 0) {
-                            const parentConfig = Array.from(this.channels.values()).find((s) => s.channel === state.channel && !s.subchannel);
-                            if (parentConfig) {
-                                for (const sub of meta.subchannels) {
-                                    const subKey = deriveSubKey(this.getChannelKeyString(state.channel), sub);
-                                    const subHash = hashSub(this.getChannelKeyString(state.channel), sub);
-                                    if (!this.channels.has(subHash)) {
-                                        this.channels.set(subHash, { channel: state.channel, subchannel: sub, key: subKey, hash: subHash });
-                                        if (this.client) {
-                                            this.client.subscribe([this.msgTopic(subHash), this.presTopic(subHash)], { qos: 1 });
-                                        }
+                        // Sync subchannels: join new ones, leave removed ones
+                        const rawKey = this.getChannelKeyString(state.channel);
+                        if (rawKey) {
+                            const metaSubs = new Set(meta.subchannels || []);
+                            // Leave subchannels no longer in meta
+                            for (const [hash, s] of this.channels) {
+                                if (s.channel === state.channel && s.subchannel && !metaSubs.has(s.subchannel)) {
+                                    if (this.client) {
+                                        this.client.unsubscribe([this.msgTopic(hash), this.presTopic(hash)]);
+                                    }
+                                    this.channels.delete(hash);
+                                    removeChannel(state.channel, s.subchannel);
+                                }
+                            }
+                            // Join new subchannels
+                            for (const sub of metaSubs) {
+                                const subKey = deriveSubKey(rawKey, sub);
+                                const subHash = hashSub(rawKey, sub);
+                                if (!this.channels.has(subHash)) {
+                                    this.channels.set(subHash, { channel: state.channel, subchannel: sub, key: subKey, hash: subHash, channelHash: subHash });
+                                    if (this.client) {
+                                        this.client.subscribe([this.msgTopic(subHash), this.presTopic(subHash)], { qos: 1 });
                                     }
                                 }
                             }
@@ -206,7 +318,14 @@ export class AgentChatClient {
             this.store.updateMember(msg.sender, state.channel, state.subchannel, msg.senderKey);
             // Persist to cloud (best-effort)
             if (msg.type === "chat") {
-                storeMessage(msg.id, state.hash, raw, msg.timestamp);
+                storeMessage(msg.id, state.channelHash, raw, msg.timestamp);
+            }
+            // Persist locally (if sync enabled)
+            if (msg.type === "chat" && getSyncEnabled(state.channel, state.subchannel)) {
+                try {
+                    this.localStore.appendMessage(msg);
+                }
+                catch { }
             }
             if (this.onMessage) {
                 this.onMessage(msg);
@@ -229,7 +348,7 @@ export class AgentChatClient {
             // Skip own presence
             if (data.name === this.name)
                 return;
-            const label = subchannel ? `##${subchannel}` : `#${channel}`;
+            const label = subchannel ? `#${channel}/${subchannel}` : `#${channel}`;
             if (data.status === "online") {
                 this.store.updateMember(data.name, channel, subchannel);
                 const sysMsg = {
@@ -276,6 +395,11 @@ export class AgentChatClient {
         else {
             target = this.channels.values().next().value;
         }
+        // Announcement mode: only owners can send
+        const meta = this.channelMeta.get(target.channel);
+        if (meta?.mode === "announcement" && !meta.owners.includes(this.identity.fingerprint)) {
+            throw new Error(`#${target.channel} is an announcement channel — only owners can send messages`);
+        }
         const msg = {
             id: randomBytes(8).toString("hex"),
             channel: target.channel,
@@ -306,9 +430,10 @@ export class AgentChatClient {
             throw new Error("Not connected");
         const key = config.subchannel ? deriveSubKey(config.key, config.subchannel) : deriveKey(config.key);
         const hash = config.subchannel ? hashSub(config.key, config.subchannel) : hashRoom(config.key);
+        const channelHash = hash;
         if (this.channels.has(hash))
             return;
-        this.channels.set(hash, { channel: config.channel, subchannel: config.subchannel, key, hash });
+        this.channels.set(hash, { channel: config.channel, subchannel: config.subchannel, key, hash, channelHash });
         if (!config.subchannel)
             this.channelKeys.set(config.channel, config.key);
         this.client.subscribe([this.msgTopic(hash), this.presTopic(hash)], { qos: 1 });
@@ -366,6 +491,13 @@ export class AgentChatClient {
                             continue;
                         }
                         this.store.addMessage(msg);
+                        // Backfill local store from history
+                        if (msg.type === "chat" && getSyncEnabled(state.channel, state.subchannel)) {
+                            try {
+                                this.localStore.appendMessage(msg);
+                            }
+                            catch { }
+                        }
                     }
                     catch {
                         // Can't decrypt — wrong key or corrupted
@@ -419,13 +551,171 @@ export class AgentChatClient {
                 if (err)
                     reject(err);
                 else {
-                    storeMessage(msg.id, target.hash, raw, msg.timestamp);
+                    storeMessage(msg.id, target.channelHash, raw, msg.timestamp);
                     this.channelMeta.set(channelName, meta);
                     resolve();
                 }
             });
         });
     }
+    // ── Kick / Epoch Rotation ───────────────────────────
+    // Shared: broadcast epoch_bump DM to members + apply rotation locally
+    async broadcastEpochBump(channelName, recipients, bump) {
+        if (!this.client)
+            throw new Error("Not connected");
+        // DM epoch_bump to each recipient
+        for (const member of recipients) {
+            if (!member.fingerprint || member.fingerprint === this.identity.fingerprint)
+                continue;
+            const dmMsg = {
+                id: randomBytes(8).toString("hex"),
+                channel: `dm:${[this.identity.fingerprint, member.fingerprint].sort().join(":")}`,
+                sender: this.name,
+                content: JSON.stringify(bump),
+                timestamp: Date.now(),
+                type: "epoch_bump",
+                senderKey: this.identity.fingerprint,
+            };
+            const dataToSign = JSON.stringify(dmMsg);
+            dmMsg.signature = signMessage(dataToSign, this.identity.privateKeyPem);
+            const key = deriveDmKey(this.identity.fingerprint, member.fingerprint);
+            const hash = hashDm(this.identity.fingerprint, member.fingerprint);
+            const encrypted = encrypt(JSON.stringify(dmMsg), key);
+            this.client.publish(this.msgTopic(hash), JSON.stringify(encrypted), { qos: 1 });
+        }
+        // Apply rotation locally (channelHash preserved — D1 key never changes)
+        const newKey = deriveKey(bump.new_seed, bump.new_epoch);
+        const newHash = hashRoom(bump.new_seed);
+        let preservedChannelHash = "";
+        for (const [hash, s] of this.channels) {
+            if (s.channel === channelName && !s.subchannel) {
+                preservedChannelHash = s.channelHash;
+                this.client.unsubscribe([this.msgTopic(hash), this.presTopic(hash)]);
+                this.channels.delete(hash);
+                break;
+            }
+        }
+        this.channels.set(newHash, { channel: channelName, key: newKey, hash: newHash, channelHash: preservedChannelHash });
+        this.channelKeys.set(channelName, bump.new_seed);
+        this.client.subscribe([this.msgTopic(newHash), this.presTopic(newHash)], { qos: 1 });
+        updateChannelEpoch(channelName, bump.new_seed, bump.new_epoch);
+    }
+    async removeMember(channelName, targetFingerprint, opts) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const meta = this.channelMeta.get(channelName);
+        if (!meta || !meta.owners.includes(this.identity.fingerprint)) {
+            throw new Error("Only channel owners can remove members");
+        }
+        const newSeed = randomBytes(32).toString("base64");
+        const newEpoch = getChannelEpoch(channelName) + 1;
+        const members = this.store.getMembers(channelName);
+        const remaining = members.filter((m) => m.fingerprint && m.fingerprint !== targetFingerprint);
+        await this.broadcastEpochBump(channelName, remaining, {
+            channel: channelName,
+            new_seed: newSeed,
+            new_epoch: newEpoch,
+            removed_fps: [targetFingerprint],
+        });
+        // Send removal_notice DM (unless --silent)
+        if (!opts?.silent) {
+            const noticePayload = {
+                channel: channelName,
+                removed_at: Date.now(),
+                removed_by: this.identity.fingerprint,
+                reason: opts?.reason,
+            };
+            const noticeMsg = {
+                id: randomBytes(8).toString("hex"),
+                channel: `dm:${[this.identity.fingerprint, targetFingerprint].sort().join(":")}`,
+                sender: this.name,
+                content: JSON.stringify(noticePayload),
+                timestamp: Date.now(),
+                type: "removal_notice",
+                senderKey: this.identity.fingerprint,
+            };
+            const dataToSign = JSON.stringify(noticeMsg);
+            noticeMsg.signature = signMessage(dataToSign, this.identity.privateKeyPem);
+            const key = deriveDmKey(this.identity.fingerprint, targetFingerprint);
+            const hash = hashDm(this.identity.fingerprint, targetFingerprint);
+            const encrypted = encrypt(JSON.stringify(noticeMsg), key);
+            this.client.publish(this.msgTopic(hash), JSON.stringify(encrypted), { qos: 1 });
+        }
+    }
+    async rotateChannel(channelName) {
+        if (!this.client)
+            throw new Error("Not connected");
+        const meta = this.channelMeta.get(channelName);
+        if (!meta || !meta.owners.includes(this.identity.fingerprint)) {
+            throw new Error("Only channel owners can rotate channel keys");
+        }
+        const newSeed = randomBytes(32).toString("base64");
+        const newEpoch = getChannelEpoch(channelName) + 1;
+        const members = this.store.getMembers(channelName);
+        await this.broadcastEpochBump(channelName, members, {
+            channel: channelName,
+            new_seed: newSeed,
+            new_epoch: newEpoch,
+        });
+    }
+    // ── Retraction ──────────────────────────────────────
+    async retractMessage(messageId, channelName, reason) {
+        if (!this.client)
+            throw new Error("Not connected");
+        // Find the target message
+        const target = this.store.getMessageById(messageId);
+        if (!target)
+            throw new Error(`Message "${messageId}" not found`);
+        // Verify ownership
+        if (target.senderKey !== this.identity.fingerprint) {
+            throw new Error("You can only retract your own messages");
+        }
+        // Verify 24h window
+        const age = Date.now() - target.timestamp;
+        if (age > 24 * 60 * 60 * 1000) {
+            throw new Error("Retraction window expired (24h limit)");
+        }
+        const retraction = {
+            target_id: messageId,
+            retracted_at: Date.now(),
+            reason,
+        };
+        const ch = channelName || target.channel;
+        const targetChannel = target.subchannel ? `${target.channel}/${target.subchannel}` : target.channel;
+        const msg = {
+            id: randomBytes(8).toString("hex"),
+            channel: target.channel,
+            subchannel: target.subchannel,
+            sender: this.name,
+            content: JSON.stringify(retraction),
+            timestamp: Date.now(),
+            type: "retraction",
+            senderKey: this.identity.fingerprint,
+        };
+        const dataToSign = JSON.stringify(msg);
+        msg.signature = signMessage(dataToSign, this.identity.privateKeyPem);
+        // Find the channel state for encryption
+        let targetState;
+        for (const state of this.channels.values()) {
+            if (fullId(state) === targetChannel || state.channel === target.channel) {
+                targetState = state;
+                break;
+            }
+        }
+        if (!targetState)
+            throw new Error(`Channel not found for retraction`);
+        const encrypted = encrypt(JSON.stringify(msg), targetState.key);
+        return new Promise((resolve, reject) => {
+            this.client.publish(this.msgTopic(targetState.hash), JSON.stringify(encrypted), { qos: 1 }, (err) => {
+                if (err)
+                    reject(err);
+                else {
+                    this.store.addRetraction(messageId);
+                    resolve(msg);
+                }
+            });
+        });
+    }
     // ── DM (Direct Message) support ──────────────────────
     async joinDm(theirFingerprint) {
         if (!this.client)
@@ -435,7 +725,7 @@ export class AgentChatClient {
         const hash = hashDm(myFp, theirFingerprint);
         const dmChannel = `dm:${[myFp, theirFingerprint].sort().join(":")}`;
         if (!this.channels.has(hash)) {
-            this.channels.set(hash, { channel: dmChannel, key, hash });
+            this.channels.set(hash, { channel: dmChannel, key, hash, channelHash: hash });
             this.client.subscribe([this.msgTopic(hash)], { qos: 1 });
             // Load DM history
             try {