@chronicle.app/slack 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# @chronicle.app/slack
+
+Chronicle plugin for Slack message history, read from a [slackdump](https://github.com/rusq/slackdump) export directory.
+
+## Exporting your data
+
+Slack's own export supports public channels on all plans, including Free. Business+ and Enterprise also support private-channel and DM exports with the appropriate access; see [Slack's export documentation](https://slack.com/help/articles/201658943-Export-your-workspace-data). [slackdump](https://github.com/rusq/slackdump) exports conversations your account can access — public and private channels, DMs, and group DMs (mpims) — to a local directory.
+
+```bash
+# Authenticate and export in Slack-export layout
+slackdump export -o my-slack-export
+```
+
+This produces a directory like:
+
+```
+my-slack-export/
+├── channels.json          # public/private channels
+├── dms.json               # direct messages
+├── mpims.json             # group DMs
+├── users.json             # workspace members
+├── <channel-name>/        # one dir per conversation
+│   ├── 2024-03-13.json     #   messages, one file per day
+│   └── attachments/        #   downloaded files (if exported)
+└── attachments/           # top-level aggregate of all files
+```
+
+Attachments are only present on disk if you exported them with slackdump. Chronicle includes attachment metadata only when `--attachments` is enabled; otherwise attachments are omitted entirely. With that flag, extraction includes a `contentPath` for files found locally. Files not found locally are recorded as metadata only. Extraction does not store attachment bytes.
+
+## Usage
+
+```bash
+# Extract to stdout (Chronicle JSON-LD)
+chronicle extract slack --input ./my-slack-export
+
+# Include file attachments (with a contentPath for downloaded files)
+chronicle extract slack --input ./my-slack-export --attachments
+```
+
+Use `--since` / `--until` for incremental or windowed extraction:
+
+```bash
+chronicle extract slack --input ./my-slack-export --since 2024-01-01
+```
+
+## Configuration
+
+- `--input` (required): path to the slackdump export directory
+- `--attachments`: include file attachments (default: false)
+- `--since`: only extract messages on or after this date
+- `--until`: only extract messages on or before this date
+- `--limit`: maximum number of records to extract (default 100; 0 for no limit)
+
+## Schema
+
+This plugin maps Slack data onto the following Chronicle types:
+
+- **Messages** → `MessageAction` whose `object` is a `Message` (`source: slack`, `body`, `author`, `recipient`)
+- **Users** → `Agent` (resolved to a `handle` and `name` from `users.json`, group-DM metadata, and message profiles)
+- **File attachments** → `ImageObject` / `AudioObject` / `VideoObject` / `DocumentObject` (by MIME type), with `contentPath` to the locally exported file when available
+
+Recipients are inferred from the conversation type: a DM addresses the other person, a group DM addresses every other member, a small private channel addresses its members, and a public/large channel is treated as a broadcast (no recipients).
+
+## Development
+
+```bash
+# Build the plugin
+npm run build -w @chronicle.app/slack
+
+# Typecheck and lint
+npm run typecheck -w @chronicle.app/slack
+npm run lint -w @chronicle.app/slack
+
+# Run tests
+npm run test -w @chronicle.app/slack
+```
+
+Tests build a small synthetic slackdump export (made-up users, channels, DMs,
+and a group DM) in a temporary directory, so they never read the host's Slack
+data or accounts and never touch the network.

package/dist/UserResolver.d.ts

@@ -0,0 +1,17 @@
+import type { ResolvedUser } from './types/slack.js';
+/**
+ * Resolves Slack user IDs to names/handles by combining multiple data sources:
+ * 1. users.json - workspace members with full profiles
+ * 2. mpims.json - co-occurrence of member IDs with @usernames in purpose field
+ * 3. Message user_profile fields and file author metadata
+ */
+export declare class UserResolver {
+    private users;
+    get(userId: string): ResolvedUser | undefined;
+    getOrStub(userId: string, teamId?: string): ResolvedUser;
+    resolve(basePath: string): Promise<Map<string, ResolvedUser>>;
+    private loadUsersJson;
+    private loadMpimCoOccurrence;
+    private scanMessagesForProfiles;
+}
+//# sourceMappingURL=UserResolver.d.ts.map

package/dist/UserResolver.js

@@ -0,0 +1,141 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Resolves Slack user IDs to names/handles by combining multiple data sources:
+ * 1. users.json - workspace members with full profiles
+ * 2. mpims.json - co-occurrence of member IDs with @usernames in purpose field
+ * 3. Message user_profile fields and file author metadata
+ */
+export class UserResolver {
+    users = new Map();
+    get(userId) {
+        return this.users.get(userId);
+    }
+    getOrStub(userId, teamId) {
+        const existing = this.users.get(userId);
+        if (existing)
+            return existing;
+        return { id: userId, teamId };
+    }
+    async resolve(basePath) {
+        // Phase 1: Load users.json (most complete source)
+        await this.loadUsersJson(basePath);
+        // Phase 2: Co-occurrence from mpims.json purpose fields
+        await this.loadMpimCoOccurrence(basePath);
+        // Phase 3: Scan messages for user_profile fields
+        await this.scanMessagesForProfiles(basePath);
+        return this.users;
+    }
+    async loadUsersJson(basePath) {
+        try {
+            const raw = await readFile(join(basePath, 'users.json'), 'utf-8');
+            const users = JSON.parse(raw);
+            for (const u of users) {
+                const name = u.profile?.display_name || u.profile?.real_name || u.real_name || undefined;
+                this.users.set(u.id, {
+                    id: u.id,
+                    handle: u.name || undefined,
+                    name,
+                    teamId: u.team_id,
+                });
+            }
+        }
+        catch {
+            // users.json may not exist
+        }
+    }
+    async loadMpimCoOccurrence(basePath) {
+        try {
+            const raw = await readFile(join(basePath, 'mpims.json'), 'utf-8');
+            const mpims = JSON.parse(raw);
+            // Iterate until stable: match member IDs to @usernames in purpose field
+            for (const mpim of mpims) {
+                const purpose = mpim.purpose?.value;
+                if (!purpose || !mpim.members)
+                    continue;
+                // Extract @usernames from purpose like "Group messaging with: @user1 @user2 @user3"
+                const usernameMatches = purpose.match(/@([\w.]+)/g);
+                if (!usernameMatches)
+                    continue;
+                const usernames = usernameMatches.map(m => m.slice(1));
+                // Also extract from mpim name like "mpdm-pat.example--alex.example--sam-1"
+                const nameMatches = mpim.name.match(/^mpdm-(.+)-\d+$/);
+                const nameUsernames = nameMatches ? nameMatches[1].split('--') : [];
+                const allUsernames = [...new Set([...usernames, ...nameUsernames])];
+                // For each member, try to match to a username
+                for (const memberId of mpim.members) {
+                    const existing = this.users.get(memberId);
+                    // If we already have a handle, skip
+                    if (existing?.handle)
+                        continue;
+                    // Try to match this member to an unmatched username
+                    // Check if any username matches the existing name
+                    if (existing?.name) {
+                        const matched = allUsernames.find(u => u.toLowerCase() === existing.name?.toLowerCase() ||
+                            existing.name?.toLowerCase().includes(u.toLowerCase()));
+                        if (matched) {
+                            existing.handle = matched;
+                            this.users.set(memberId, existing);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // mpims.json may not exist
+        }
+    }
+    async scanMessagesForProfiles(basePath) {
+        try {
+            const entries = await readdir(basePath, { withFileTypes: true });
+            const dirs = entries.filter(e => e.isDirectory() && e.name !== 'attachments');
+            for (const dir of dirs) {
+                const dirPath = join(basePath, dir.name);
+                const files = await readdir(dirPath).catch(() => []);
+                const jsonFiles = (typeof files[0] === 'string' ? files : []);
+                for (const file of jsonFiles) {
+                    if (!file.endsWith('.json'))
+                        continue;
+                    try {
+                        const raw = await readFile(join(dirPath, file), 'utf-8');
+                        const messages = JSON.parse(raw);
+                        for (const msg of messages) {
+                            if (!msg.user)
+                                continue;
+                            // Extract from user_profile field
+                            if (msg.user_profile) {
+                                const existing = this.users.get(msg.user);
+                                if (!existing || (!existing.name && !existing.handle)) {
+                                    const profile = msg.user_profile;
+                                    this.users.set(msg.user, {
+                                        id: msg.user,
+                                        handle: existing?.handle || profile.name || profile.display_name || undefined,
+                                        name: existing?.name || profile.real_name || profile.display_name || undefined,
+                                        teamId: existing?.teamId || msg.team,
+                                    });
+                                }
+                            }
+                            // Extract from files' user field (associates file author with user ID)
+                            if (msg.files) {
+                                for (const file of msg.files) {
+                                    if (file.user && !this.users.has(file.user)) {
+                                        this.users.set(file.user, {
+                                            id: file.user,
+                                            teamId: msg.team,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip unreadable message files
+                    }
+                }
+            }
+        }
+        catch {
+            // Can't read directory
+        }
+    }
+}

package/dist/connectors/SlackExtractor.d.ts

@@ -0,0 +1,43 @@
+import { Extractor, Record } from '@chronicle.app/etl';
+import { z } from 'zod';
+import SlackTransformer from './SlackTransformer.js';
+export declare class SlackExtractor extends Extractor<typeof SlackExtractor> {
+    static source: string;
+    static description: string;
+    static delivery: "export";
+    static strategy: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static defaultTransformer: typeof SlackTransformer;
+    static schema: z.ZodObject<{
+        since: z.ZodOptional<z.ZodDate>;
+        until: z.ZodOptional<z.ZodDate>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    } & {
+        input: z.ZodString;
+        attachments: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        attachments: boolean;
+        input: string;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        attachments?: boolean | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    private conversations;
+    private userMap;
+    private teamId;
+    setup(): Promise<void>;
+    extract(): AsyncGenerator<Record>;
+    /** Yield a single conversation's messages newest-first, applying filters. */
+    private extractConversation;
+    determineCount(): Promise<number | null>;
+    private loadConversations;
+    private tsToDate;
+}
+//# sourceMappingURL=SlackExtractor.d.ts.map

package/dist/connectors/SlackExtractor.js

@@ -0,0 +1,226 @@
+import { Extractor } from '@chronicle.app/etl';
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { UserResolver } from '../UserResolver.js';
+import SlackTransformer from './SlackTransformer.js';
+export class SlackExtractor extends Extractor {
+    static source = 'slack';
+    static description = 'Messages from a slackdump export';
+    static delivery = 'export';
+    static strategy = 'archive';
+    static recordTypes = ['messages'];
+    static default = true;
+    static defaultTransformer = SlackTransformer;
+    static schema = Extractor.schema.extend({
+        input: z.string().describe('Path to slackdump export directory'),
+        attachments: z.boolean().optional().default(false).describe('Include file attachments'),
+    });
+    conversations = [];
+    userMap = new Map();
+    teamId;
+    async setup() {
+        const config = this.config;
+        const basePath = config.input;
+        // Resolve users
+        const resolver = new UserResolver();
+        this.userMap = await resolver.resolve(basePath);
+        // Extract teamId from first user that has one
+        for (const user of this.userMap.values()) {
+            if (user.teamId) {
+                this.teamId = user.teamId;
+                break;
+            }
+        }
+        // Load conversation metadata
+        await this.loadConversations(basePath);
+    }
+    async *extract() {
+        const config = this.config;
+        const basePath = config.input;
+        const userMap = Object.fromEntries(this.userMap);
+        let count = 0;
+        // Each conversation yields its messages newest-first; merge those streams
+        // by timestamp (descending) so the output is globally reverse-chronological
+        // — `--limit 1` is the single latest message across the whole workspace.
+        const heads = [];
+        for (const conversation of this.conversations) {
+            const iterator = this.extractConversation(conversation, config);
+            const next = await iterator.next();
+            if (!next.done) {
+                heads.push({
+                    iterator,
+                    value: next.value,
+                    ts: Number.parseFloat(next.value.msg.ts),
+                });
+            }
+        }
+        while (heads.length > 0) {
+            if (this.shouldStopExtracting(count))
+                return;
+            // Pick the head with the latest timestamp.
+            let maxIndex = 0;
+            for (let i = 1; i < heads.length; i++) {
+                if (heads[i].ts > heads[maxIndex].ts)
+                    maxIndex = i;
+            }
+            const head = heads[maxIndex];
+            const { msg, conversation } = head.value;
+            yield this.createRecord({
+                type: 'message',
+                message: msg,
+                includeAttachments: config.attachments,
+            }, { conversation, userMap, teamId: this.teamId, basePath });
+            count++;
+            // Advance the chosen stream; drop it once exhausted.
+            const next = await head.iterator.next();
+            if (next.done) {
+                heads.splice(maxIndex, 1);
+            }
+            else {
+                head.value = next.value;
+                head.ts = Number.parseFloat(next.value.msg.ts);
+            }
+        }
+    }
+    /** Yield a single conversation's messages newest-first, applying filters. */
+    async *extractConversation(conversation, config) {
+        const dirPath = join(config.input, conversation.dirName);
+        let files;
+        try {
+            files = await readdir(dirPath);
+        }
+        catch {
+            return;
+        }
+        // Dated JSON files, newest first.
+        const jsonFiles = files
+            .filter(f => /^\d{4}-\d{2}-\d{2}\.json$/.test(f))
+            .sort()
+            .reverse();
+        for (const file of jsonFiles) {
+            // Quick date range check using filename
+            const fileDate = file.replace('.json', '');
+            if (config.until && new Date(fileDate) > config.until)
+                continue;
+            if (config.since && new Date(fileDate + 'T23:59:59.999Z') < config.since) {
+                continue;
+            }
+            let messages;
+            try {
+                const raw = await readFile(join(dirPath, file), 'utf-8');
+                messages = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            // Keep real messages in range, then sort newest-first so the merge across
+            // conversations stays correct even if a day file isn't perfectly ordered.
+            const valid = messages.filter(msg => {
+                if (msg.type !== 'message')
+                    return false;
+                if (msg.subtype && !['bot_message', 'thread_broadcast'].includes(msg.subtype)) {
+                    return false;
+                }
+                const msgDate = this.tsToDate(msg.ts);
+                if (config.since && msgDate < config.since)
+                    return false;
+                if (config.until && msgDate > config.until)
+                    return false;
+                return true;
+            });
+            valid.sort((a, b) => Number.parseFloat(b.ts) - Number.parseFloat(a.ts));
+            for (const msg of valid) {
+                yield { msg, conversation };
+            }
+        }
+    }
+    async determineCount() {
+        const config = this.config;
+        const basePath = config.input;
+        let total = 0;
+        for (const conversation of this.conversations) {
+            const dirPath = join(basePath, conversation.dirName);
+            let files;
+            try {
+                files = await readdir(dirPath);
+            }
+            catch {
+                continue;
+            }
+            const jsonFiles = files.filter(f => /^\d{4}-\d{2}-\d{2}\.json$/.test(f));
+            for (const file of jsonFiles) {
+                try {
+                    const raw = await readFile(join(dirPath, file), 'utf-8');
+                    const messages = JSON.parse(raw);
+                    total += messages.filter(m => m.type === 'message' &&
+                        (!m.subtype || ['bot_message', 'thread_broadcast'].includes(m.subtype))).length;
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return total;
+    }
+    async loadConversations(basePath) {
+        // Load channels
+        try {
+            const raw = await readFile(join(basePath, 'channels.json'), 'utf-8');
+            const channels = JSON.parse(raw);
+            for (const ch of channels) {
+                this.conversations.push({
+                    id: ch.id,
+                    name: ch.name,
+                    type: 'channel',
+                    members: ch.members ?? undefined,
+                    isPrivate: ch.is_private,
+                    dirName: ch.name,
+                });
+            }
+        }
+        catch {
+            // channels.json may not exist
+        }
+        // Load DMs
+        try {
+            const raw = await readFile(join(basePath, 'dms.json'), 'utf-8');
+            const dms = JSON.parse(raw);
+            for (const dm of dms) {
+                this.conversations.push({
+                    id: dm.id,
+                    type: 'dm',
+                    members: dm.members,
+                    dirName: dm.id,
+                });
+            }
+        }
+        catch {
+            // dms.json may not exist
+        }
+        // Load MPIMs
+        try {
+            const raw = await readFile(join(basePath, 'mpims.json'), 'utf-8');
+            const mpims = JSON.parse(raw);
+            for (const mpim of mpims) {
+                this.conversations.push({
+                    id: mpim.id,
+                    name: mpim.name,
+                    type: 'mpim',
+                    members: mpim.members,
+                    dirName: mpim.name,
+                });
+            }
+        }
+        catch {
+            // mpims.json may not exist
+        }
+        // Filter to only conversations that have directories on disk
+        const entries = await readdir(basePath, { withFileTypes: true }).catch(() => []);
+        const dirNames = new Set(entries.filter(e => e.isDirectory()).map(e => e.name));
+        this.conversations = this.conversations.filter(c => dirNames.has(c.dirName));
+    }
+    tsToDate(ts) {
+        return new Date(Number.parseFloat(ts) * 1000);
+    }
+}

package/dist/connectors/SlackTransformer.d.ts

@@ -0,0 +1,18 @@
+import { ChronicleTransformer, Record as EtlRecord } from '@chronicle.app/etl';
+import type { ActionAndChildren } from '@chronicle.app/schema';
+export default class SlackTransformer extends ChronicleTransformer {
+    transform(record: EtlRecord): Promise<ActionAndChildren[]>;
+    private buildMessageActions;
+    private buildAgent;
+    private buildRecipients;
+    private buildAttachments;
+    /** Listings of attachment dirs, memoized for the run (one instance per run). */
+    private attachmentDirCache;
+    /**
+     * Resolve a Slack file id to the absolute path of its downloaded bytes, or
+     * undefined if slackdump did not export the file locally. Matches by id
+     * prefix (`<fileId>-...`) so a sanitized on-disk name still resolves.
+     */
+    private resolveAttachmentPath;
+}
+//# sourceMappingURL=SlackTransformer.d.ts.map

package/dist/connectors/SlackTransformer.js

@@ -0,0 +1,165 @@
+import { ChronicleTransformer, createMediaObject } from '@chronicle.app/etl';
+import { readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+const SMALL_CHANNEL_THRESHOLD = 10;
+export default class SlackTransformer extends ChronicleTransformer {
+    async transform(record) {
+        if (record.data.type === 'message') {
+            return this.buildMessageActions(record);
+        }
+        return [];
+    }
+    buildMessageActions(record) {
+        const msg = record.data.message;
+        const { conversation } = record.context;
+        const { userMap } = record.context;
+        const { teamId } = record.context;
+        const { includeAttachments } = record.data;
+        const senderId = msg.user || msg.bot_id;
+        if (!senderId)
+            return [];
+        const sender = this.buildAgent(senderId, userMap[senderId], teamId);
+        // Build Message entity
+        const message = {
+            '@type': 'Message',
+            '@key': ['@type', 'source', 'body', 'author'],
+            source: 'slack',
+            body: msg.text,
+            author: [sender],
+        };
+        // Add recipients based on conversation type
+        const recipients = this.buildRecipients(conversation, senderId, userMap, teamId);
+        if (recipients.length > 0) {
+            message.recipient = recipients;
+        }
+        // Add attachments if enabled and present
+        if (includeAttachments && msg.files && msg.files.length > 0) {
+            const attachments = this.buildAttachments(msg.files, record.context.basePath, conversation.dirName);
+            if (attachments.length > 0) {
+                message.contains = attachments;
+            }
+        }
+        // Build MessageAction
+        const messageAction = {
+            '@type': 'MessageAction',
+            '@key': ['@type', 'source', 'timestamp', 'agent'],
+            source: 'slack',
+            timestamp: new Date(Number.parseFloat(msg.ts) * 1000),
+            agent: sender,
+            object: message,
+        };
+        return [messageAction];
+    }
+    buildAgent(userId, resolved, teamId) {
+        const agent = {
+            '@type': 'Agent',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: 'slack',
+            sourceId: userId,
+        };
+        if (resolved?.handle) {
+            agent.handle = resolved.handle;
+        }
+        if (resolved?.name) {
+            agent.name = resolved.name;
+        }
+        // The workspace as a real Realm the agent is a member of — replaces the old
+        // `handleNamespace: teamId` scalar with a traversable edge to a keyed
+        // workspace node. A Realm (a bounded account domain), not an Organization:
+        // the workspace may itself belong to a company.
+        const workspaceId = resolved?.teamId || teamId;
+        if (workspaceId) {
+            agent.memberOf = [
+                {
+                    '@type': 'Realm',
+                    '@key': ['@type', 'source', 'sourceId'],
+                    source: 'slack',
+                    sourceId: workspaceId,
+                },
+            ];
+        }
+        return agent;
+    }
+    buildRecipients(conversation, senderId, userMap, teamId) {
+        const { members } = conversation;
+        switch (conversation.type) {
+            case 'dm':
+                // DMs: recipient is the other person
+                if (members && members.length === 2) {
+                    const otherId = members.find(m => m !== senderId);
+                    if (otherId) {
+                        return [this.buildAgent(otherId, userMap[otherId], teamId)];
+                    }
+                }
+                return [];
+            case 'mpim':
+                // MPIMs: recipients are all other members
+                if (members) {
+                    return members
+                        .filter(m => m !== senderId)
+                        .map(m => this.buildAgent(m, userMap[m], teamId));
+                }
+                return [];
+            case 'channel':
+                // Small private channels: recipients are other members
+                if (conversation.isPrivate && members && members.length <= SMALL_CHANNEL_THRESHOLD) {
+                    return members
+                        .filter(m => m !== senderId)
+                        .map(m => this.buildAgent(m, userMap[m], teamId));
+                }
+                // Large/public channels: no recipients (broadcast)
+                return [];
+            default:
+                return [];
+        }
+    }
+    buildAttachments(files, basePath, dirName) {
+        const attachments = [];
+        for (const file of files) {
+            // slackdump writes downloaded files to disk as `<fileId>-<name>`, in the
+            // conversation's own `attachments/` dir (and a top-level aggregate one).
+            // When the bytes are on disk we emit a contentPath so ingest captures
+            // them; otherwise the node stays metadata-only (the url-gated Slack file
+            // would need an auth token to fetch).
+            const localPath = this.resolveAttachmentPath(basePath, dirName, file.id);
+            const mediaObject = createMediaObject({
+                mimeType: file.mimetype,
+                source: 'slack',
+                sourceId: file.id,
+                '@key': ['@type', 'source', 'sourceId'],
+                name: file.name,
+                ...(localPath && { path: localPath }),
+                ...(file.original_w && file.original_w > 0 && { width: file.original_w }),
+                ...(file.original_h && file.original_h > 0 && { height: file.original_h }),
+            });
+            attachments.push(mediaObject);
+        }
+        return attachments;
+    }
+    /** Listings of attachment dirs, memoized for the run (one instance per run). */
+    attachmentDirCache = new Map();
+    /**
+     * Resolve a Slack file id to the absolute path of its downloaded bytes, or
+     * undefined if slackdump did not export the file locally. Matches by id
+     * prefix (`<fileId>-...`) so a sanitized on-disk name still resolves.
+     */
+    resolveAttachmentPath(basePath, dirName, fileId) {
+        const candidateDirs = [join(basePath, dirName, 'attachments'), join(basePath, 'attachments')];
+        for (const dir of candidateDirs) {
+            let entries = this.attachmentDirCache.get(dir);
+            if (entries === undefined) {
+                try {
+                    entries = readdirSync(dir);
+                }
+                catch {
+                    entries = [];
+                }
+                this.attachmentDirCache.set(dir, entries);
+            }
+            const match = entries.find(entry => entry.startsWith(`${fileId}-`));
+            if (match)
+                return resolve(dir, match);
+        }
+        return undefined;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { SlackExtractor } from './connectors/SlackExtractor.js';
+export { default as SlackTransformer } from './connectors/SlackTransformer.js';
+export { UserResolver } from './UserResolver.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export { SlackExtractor } from './connectors/SlackExtractor.js';
+export { default as SlackTransformer } from './connectors/SlackTransformer.js';
+export { UserResolver } from './UserResolver.js';

package/dist/types/slack.d.ts

@@ -0,0 +1,143 @@
+/** Slack user profile from users.json */
+export interface SlackUserProfile {
+    title?: string;
+    phone?: string;
+    real_name?: string;
+    real_name_normalized?: string;
+    display_name?: string;
+    display_name_normalized?: string;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    image_24?: string;
+    image_32?: string;
+    image_48?: string;
+    image_72?: string;
+    image_192?: string;
+    image_512?: string;
+    bot_id?: string;
+    api_app_id?: string;
+}
+/** Slack user from users.json */
+export interface SlackUser {
+    id: string;
+    team_id: string;
+    name: string;
+    deleted: boolean;
+    real_name?: string;
+    tz?: string;
+    tz_label?: string;
+    tz_offset?: number;
+    profile: SlackUserProfile;
+    is_bot: boolean;
+    is_admin?: boolean;
+    is_owner?: boolean;
+    is_primary_owner?: boolean;
+    updated: number;
+}
+/** Topic or purpose field on channels */
+export interface SlackTopicOrPurpose {
+    value: string;
+    creator: string;
+    last_set: number;
+}
+/** Channel from channels.json */
+export interface SlackChannel {
+    id: string;
+    name: string;
+    name_normalized?: string;
+    created: number;
+    creator: string;
+    is_channel: boolean;
+    is_private: boolean;
+    is_archived: boolean;
+    is_general: boolean;
+    is_shared?: boolean;
+    is_ext_shared?: boolean;
+    num_members?: number;
+    members?: string[] | null;
+    topic?: SlackTopicOrPurpose;
+    purpose?: SlackTopicOrPurpose;
+}
+/** DM conversation from dms.json */
+export interface SlackDm {
+    id: string;
+    created: number;
+    members: [string, string];
+}
+/** Multi-party IM from mpims.json */
+export interface SlackMpim {
+    id: string;
+    name: string;
+    created: number;
+    creator?: string;
+    is_mpim: boolean;
+    members: string[];
+    topic?: SlackTopicOrPurpose;
+    purpose?: SlackTopicOrPurpose;
+}
+/** Slack file attachment on a message */
+export interface SlackFile {
+    id: string;
+    name: string;
+    title?: string;
+    mimetype: string;
+    filetype: string;
+    pretty_type?: string;
+    user: string;
+    size: number;
+    url_private?: string;
+    url_private_download?: string;
+    permalink?: string;
+    created: number;
+    timestamp: number;
+    mode?: string;
+    is_external?: boolean;
+    original_h?: number;
+    original_w?: number;
+}
+/** Slack message from dated JSON files */
+export interface SlackMessage {
+    client_msg_id?: string;
+    type: string;
+    subtype?: string;
+    user?: string;
+    text: string;
+    ts: string;
+    team?: string;
+    thread_ts?: string;
+    parent_user_id?: string;
+    edited?: {
+        user: string;
+        ts: string;
+    };
+    reactions?: Array<{
+        name: string;
+        count: number;
+        users: string[];
+    }>;
+    files?: SlackFile[];
+    blocks?: any[];
+    user_profile?: SlackUserProfile & {
+        name?: string;
+    };
+    username?: string;
+    bot_id?: string;
+}
+/** Resolved user info for the user map */
+export interface ResolvedUser {
+    id: string;
+    name?: string;
+    handle?: string;
+    teamId?: string;
+}
+/** Metadata about a conversation (channel, DM, or MPIM) */
+export interface ConversationMeta {
+    id: string;
+    name?: string;
+    type: 'channel' | 'dm' | 'mpim';
+    members?: string[];
+    isPrivate?: boolean;
+    dirName: string;
+}
+//# sourceMappingURL=slack.d.ts.map

package/dist/types/slack.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@chronicle.app/slack",
+  "version": "0.3.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js"
+  },
+  "keywords": [
+    "chronicle",
+    "slack"
+  ],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle plugin for Slack message history via slackdump export",
+  "devDependencies": {
+    "@chronicle.app/etl": "0.3.0",
+    "@chronicle.app/schema": "0.3.0",
+    "@chronicle.app/tsconfig": "0.3.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/slack"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@chronicle.app/etl": ">=0.1.0 <1.0.0",
+    "@chronicle.app/schema": ">=0.1.0 <1.0.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true,
+    "sources": {
+      "slack": {
+        "strategies": {
+          "archive": {
+            "delivery": "export",
+            "recordTypes": [
+              "messages"
+            ],
+            "default": true
+          }
+        }
+      }
+    }
+  }
+}