claude-threads 0.12.1 → 0.14.0

package/dist/platform/permission-api-factory.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Permission API Factory
+ *
+ * Creates platform-specific permission API implementations based on platform type.
+ * This isolates platform selection logic to the platform layer.
+ */
+import type { PermissionApi, PermissionApiConfig } from './permission-api.js';
+/**
+ * Create a permission API instance for the specified platform type
+ */
+export declare function createPermissionApi(platformType: string, config: PermissionApiConfig): PermissionApi;

package/dist/platform/permission-api-factory.js

@@ -0,0 +1,21 @@
+/**
+ * Permission API Factory
+ *
+ * Creates platform-specific permission API implementations based on platform type.
+ * This isolates platform selection logic to the platform layer.
+ */
+import { createMattermostPermissionApi } from './mattermost/permission-api.js';
+/**
+ * Create a permission API instance for the specified platform type
+ */
+export function createPermissionApi(platformType, config) {
+    switch (platformType) {
+        case 'mattermost':
+            return createMattermostPermissionApi(config);
+        // TODO: Add Slack support
+        // case 'slack':
+        //   return createSlackPermissionApi(config);
+        default:
+            throw new Error(`Unsupported platform type: ${platformType}`);
+    }
+}

package/dist/platform/permission-api.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Permission API interface for MCP permission server
+ *
+ * This interface defines the operations needed by the permission server
+ * to post permission requests and receive user responses via reactions.
+ * Each platform implements this interface with its specific API.
+ */
+import type { PlatformFormatter } from './formatter.js';
+/**
+ * Reaction event from WebSocket
+ */
+export interface ReactionEvent {
+    postId: string;
+    userId: string;
+    emojiName: string;
+}
+/**
+ * Posted message with ID
+ */
+export interface PostedMessage {
+    id: string;
+}
+/**
+ * Platform-specific permission API
+ */
+export interface PermissionApi {
+    /**
+     * Get the markdown formatter for this platform
+     */
+    getFormatter(): PlatformFormatter;
+    /**
+     * Get the bot's user ID
+     */
+    getBotUserId(): Promise<string>;
+    /**
+     * Get a username from a user ID
+     */
+    getUsername(userId: string): Promise<string | null>;
+    /**
+     * Check if a username is in the allowed users list
+     */
+    isUserAllowed(username: string): boolean;
+    /**
+     * Create a post with reaction options
+     */
+    createInteractivePost(message: string, reactions: string[], threadId?: string): Promise<PostedMessage>;
+    /**
+     * Update an existing post
+     */
+    updatePost(postId: string, message: string): Promise<void>;
+    /**
+     * Wait for a reaction on a post
+     * Returns the reaction event or null on timeout
+     */
+    waitForReaction(postId: string, botUserId: string, timeoutMs: number): Promise<ReactionEvent | null>;
+}
+/**
+ * Configuration for permission API
+ */
+export interface PermissionApiConfig {
+    url: string;
+    token: string;
+    channelId: string;
+    threadId?: string;
+    allowedUsers: string[];
+    debug?: boolean;
+}

package/dist/platform/permission-api.js

@@ -0,0 +1,8 @@
+/**
+ * Permission API interface for MCP permission server
+ *
+ * This interface defines the operations needed by the permission server
+ * to post permission requests and receive user responses via reactions.
+ * Each platform implements this interface with its specific API.
+ */
+export {};

package/dist/platform/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Platform-agnostic types for multi-platform support
+ *
+ * These types normalize the differences between Mattermost, Slack, etc.
+ * into a common interface that SessionManager can work with.
+ */
+/**
+ * Normalized user representation across platforms
+ */
+export interface PlatformUser {
+    id: string;
+    username: string;
+    email?: string;
+}
+/**
+ * Normalized post/message representation across platforms
+ */
+export interface PlatformPost {
+    id: string;
+    platformId: string;
+    channelId: string;
+    userId: string;
+    message: string;
+    rootId?: string;
+    createAt?: number;
+    metadata?: {
+        files?: PlatformFile[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Normalized reaction representation across platforms
+ */
+export interface PlatformReaction {
+    userId: string;
+    postId: string;
+    emojiName: string;
+    createAt?: number;
+}
+/**
+ * Normalized file attachment representation across platforms
+ */
+export interface PlatformFile {
+    id: string;
+    name: string;
+    size: number;
+    mimeType: string;
+    extension?: string;
+}
+/**
+ * Request to create a new post
+ */
+export interface CreatePostRequest {
+    message: string;
+    threadId?: string;
+}
+/**
+ * Request to update an existing post
+ */
+export interface UpdatePostRequest {
+    postId: string;
+    message: string;
+}
+/**
+ * Request to add a reaction to a post
+ */
+export interface AddReactionRequest {
+    postId: string;
+    emojiName: string;
+}

package/dist/platform/types.js

@@ -0,0 +1,7 @@
+/**
+ * Platform-agnostic types for multi-platform support
+ *
+ * These types normalize the differences between Mattermost, Slack, etc.
+ * into a common interface that SessionManager can work with.
+ */
+export {};

package/dist/session/commands.d.ts

@@ -0,0 +1,52 @@
+/**
+ * User commands module
+ *
+ * Handles user commands like !cd, !invite, !kick, !permissions, !escape, !stop.
+ */
+import type { Session } from './types.js';
+import type { ClaudeEvent } from '../claude/cli.js';
+export interface CommandContext {
+    skipPermissions: boolean;
+    chromeEnabled: boolean;
+    maxSessions: number;
+    handleEvent: (sessionId: string, event: ClaudeEvent) => void;
+    handleExit: (sessionId: string, code: number) => Promise<void>;
+    flush: (session: Session) => Promise<void>;
+    startTyping: (session: Session) => void;
+    stopTyping: (session: Session) => void;
+    persistSession: (session: Session) => void;
+    killSession: (threadId: string) => void;
+    registerPost: (postId: string, threadId: string) => void;
+}
+/**
+ * Cancel a session completely (like !stop or ❌ reaction).
+ */
+export declare function cancelSession(session: Session, username: string, ctx: CommandContext): Promise<void>;
+/**
+ * Interrupt current processing but keep session alive (like !escape or ⏸️).
+ */
+export declare function interruptSession(session: Session, username: string): Promise<void>;
+/**
+ * Change working directory for a session (restarts Claude CLI).
+ */
+export declare function changeDirectory(session: Session, newDir: string, username: string, ctx: CommandContext): Promise<void>;
+/**
+ * Invite a user to participate in a session.
+ */
+export declare function inviteUser(session: Session, invitedUser: string, invitedBy: string, ctx: CommandContext): Promise<void>;
+/**
+ * Kick a user from a session.
+ */
+export declare function kickUser(session: Session, kickedUser: string, kickedBy: string, ctx: CommandContext): Promise<void>;
+/**
+ * Enable interactive permissions for a session.
+ */
+export declare function enableInteractivePermissions(session: Session, username: string, ctx: CommandContext): Promise<void>;
+/**
+ * Request approval for a message from an unauthorized user.
+ */
+export declare function requestMessageApproval(session: Session, username: string, message: string, ctx: CommandContext): Promise<void>;
+/**
+ * Update the session header post with current participants and status.
+ */
+export declare function updateSessionHeader(session: Session, ctx: CommandContext): Promise<void>;

package/dist/session/commands.js

@@ -0,0 +1,323 @@
+/**
+ * User commands module
+ *
+ * Handles user commands like !cd, !invite, !kick, !permissions, !escape, !stop.
+ */
+import { ClaudeCli } from '../claude/cli.js';
+import { randomUUID } from 'crypto';
+import { resolve } from 'path';
+import { existsSync, statSync } from 'fs';
+import { getUpdateInfo } from '../update-notifier.js';
+import { getReleaseNotes, getWhatsNewSummary } from '../changelog.js';
+import { getLogo } from '../logo.js';
+import { readFileSync } from 'fs';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { APPROVAL_EMOJIS, DENIAL_EMOJIS, ALLOW_ALL_EMOJIS, } from '../utils/emoji.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', '..', 'package.json'), 'utf-8'));
+// ---------------------------------------------------------------------------
+// Session control commands
+// ---------------------------------------------------------------------------
+/**
+ * Cancel a session completely (like !stop or ❌ reaction).
+ */
+export async function cancelSession(session, username, ctx) {
+    const shortId = session.threadId.substring(0, 8);
+    console.log(`  🛑 Session (${shortId}…) cancelled by @${username}`);
+    await session.platform.createPost(`🛑 **Session cancelled** by @${username}`, session.threadId);
+    ctx.killSession(session.threadId);
+}
+/**
+ * Interrupt current processing but keep session alive (like !escape or ⏸️).
+ */
+export async function interruptSession(session, username) {
+    if (!session.claude.isRunning()) {
+        await session.platform.createPost(`ℹ️ Session is idle, nothing to interrupt`, session.threadId);
+        return;
+    }
+    const shortId = session.threadId.substring(0, 8);
+    // Set flag BEFORE interrupt - if Claude exits due to SIGINT, we won't unpersist
+    session.wasInterrupted = true;
+    const interrupted = session.claude.interrupt();
+    if (interrupted) {
+        console.log(`  ⏸️ Session (${shortId}…) interrupted by @${username}`);
+        await session.platform.createPost(`⏸️ **Interrupted** by @${username}`, session.threadId);
+    }
+}
+// ---------------------------------------------------------------------------
+// Directory management
+// ---------------------------------------------------------------------------
+/**
+ * Change working directory for a session (restarts Claude CLI).
+ */
+export async function changeDirectory(session, newDir, username, ctx) {
+    // Only session owner or globally allowed users can change directory
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can change the working directory`, session.threadId);
+        return;
+    }
+    // Expand ~ to home directory
+    const expandedDir = newDir.startsWith('~')
+        ? newDir.replace('~', process.env.HOME || '')
+        : newDir;
+    // Resolve to absolute path
+    const absoluteDir = resolve(expandedDir);
+    // Check if directory exists
+    if (!existsSync(absoluteDir)) {
+        await session.platform.createPost(`❌ Directory does not exist: \`${newDir}\``, session.threadId);
+        return;
+    }
+    if (!statSync(absoluteDir).isDirectory()) {
+        await session.platform.createPost(`❌ Not a directory: \`${newDir}\``, session.threadId);
+        return;
+    }
+    const shortId = session.threadId.substring(0, 8);
+    const shortDir = absoluteDir.replace(process.env.HOME || '', '~');
+    console.log(`  📂 Session (${shortId}…) changing directory to ${shortDir}`);
+    // Stop the current Claude CLI
+    ctx.stopTyping(session);
+    session.isRestarting = true; // Suppress exit message during restart
+    session.claude.kill();
+    // Flush any pending content
+    await ctx.flush(session);
+    session.currentPostId = null;
+    session.pendingContent = '';
+    // Update session working directory
+    session.workingDir = absoluteDir;
+    // Generate new session ID for fresh start in new directory
+    const newSessionId = randomUUID();
+    session.claudeSessionId = newSessionId;
+    const cliOptions = {
+        workingDir: absoluteDir,
+        threadId: session.threadId,
+        skipPermissions: ctx.skipPermissions || !session.forceInteractivePermissions,
+        sessionId: newSessionId,
+        resume: false, // Fresh start - can't resume across directories
+        chrome: ctx.chromeEnabled,
+        platformConfig: session.platform.getMcpConfig(),
+    };
+    session.claude = new ClaudeCli(cliOptions);
+    // Rebind event handlers (use sessionId which is the composite key)
+    session.claude.on('event', (e) => ctx.handleEvent(session.sessionId, e));
+    session.claude.on('exit', (code) => ctx.handleExit(session.sessionId, code));
+    // Start the new Claude CLI
+    try {
+        session.claude.start();
+    }
+    catch (err) {
+        session.isRestarting = false;
+        console.error('  ❌ Failed to restart Claude:', err);
+        await session.platform.createPost(`❌ Failed to restart Claude: ${err}`, session.threadId);
+        return;
+    }
+    // Update session header with new directory
+    await updateSessionHeader(session, ctx);
+    // Post confirmation
+    await session.platform.createPost(`📂 **Working directory changed** to \`${shortDir}\`\n*Claude Code restarted in new directory*`, session.threadId);
+    // Update activity
+    session.lastActivityAt = new Date();
+    session.timeoutWarningPosted = false;
+    // Persist the updated session state
+    ctx.persistSession(session);
+}
+// ---------------------------------------------------------------------------
+// User collaboration commands
+// ---------------------------------------------------------------------------
+/**
+ * Invite a user to participate in a session.
+ */
+export async function inviteUser(session, invitedUser, invitedBy, ctx) {
+    // Only session owner or globally allowed users can invite
+    if (session.startedBy !== invitedBy && !session.platform.isUserAllowed(invitedBy)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can invite others`, session.threadId);
+        return;
+    }
+    session.sessionAllowedUsers.add(invitedUser);
+    await session.platform.createPost(`✅ @${invitedUser} can now participate in this session (invited by @${invitedBy})`, session.threadId);
+    console.log(`  👋 @${invitedUser} invited to session by @${invitedBy}`);
+    await updateSessionHeader(session, ctx);
+    ctx.persistSession(session);
+}
+/**
+ * Kick a user from a session.
+ */
+export async function kickUser(session, kickedUser, kickedBy, ctx) {
+    // Only session owner or globally allowed users can kick
+    if (session.startedBy !== kickedBy && !session.platform.isUserAllowed(kickedBy)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can kick others`, session.threadId);
+        return;
+    }
+    // Can't kick session owner
+    if (kickedUser === session.startedBy) {
+        await session.platform.createPost(`⚠️ Cannot kick session owner @${session.startedBy}`, session.threadId);
+        return;
+    }
+    // Can't kick globally allowed users
+    if (session.platform.isUserAllowed(kickedUser)) {
+        await session.platform.createPost(`⚠️ @${kickedUser} is globally allowed and cannot be kicked from individual sessions`, session.threadId);
+        return;
+    }
+    if (session.sessionAllowedUsers.delete(kickedUser)) {
+        await session.platform.createPost(`🚫 @${kickedUser} removed from this session by @${kickedBy}`, session.threadId);
+        console.log(`  🚫 @${kickedUser} kicked from session by @${kickedBy}`);
+        await updateSessionHeader(session, ctx);
+        ctx.persistSession(session);
+    }
+    else {
+        await session.platform.createPost(`⚠️ @${kickedUser} was not in this session`, session.threadId);
+    }
+}
+// ---------------------------------------------------------------------------
+// Permission management
+// ---------------------------------------------------------------------------
+/**
+ * Enable interactive permissions for a session.
+ */
+export async function enableInteractivePermissions(session, username, ctx) {
+    // Only session owner or globally allowed users can change permissions
+    if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
+        await session.platform.createPost(`⚠️ Only @${session.startedBy} or allowed users can change permissions`, session.threadId);
+        return;
+    }
+    // Can only downgrade, not upgrade
+    if (!ctx.skipPermissions) {
+        await session.platform.createPost(`ℹ️ Permissions are already interactive for this session`, session.threadId);
+        return;
+    }
+    // Already enabled for this session
+    if (session.forceInteractivePermissions) {
+        await session.platform.createPost(`ℹ️ Interactive permissions already enabled for this session`, session.threadId);
+        return;
+    }
+    // Set the flag
+    session.forceInteractivePermissions = true;
+    const shortId = session.threadId.substring(0, 8);
+    console.log(`  🔐 Session (${shortId}…) enabling interactive permissions`);
+    // Stop the current Claude CLI and restart with new permission setting
+    ctx.stopTyping(session);
+    session.isRestarting = true;
+    session.claude.kill();
+    // Flush any pending content
+    await ctx.flush(session);
+    session.currentPostId = null;
+    session.pendingContent = '';
+    // Create new CLI options with interactive permissions
+    const cliOptions = {
+        workingDir: session.workingDir,
+        threadId: session.threadId,
+        skipPermissions: false, // Force interactive permissions
+        sessionId: session.claudeSessionId,
+        resume: true, // Resume to keep conversation context
+        chrome: ctx.chromeEnabled,
+        platformConfig: session.platform.getMcpConfig(),
+    };
+    session.claude = new ClaudeCli(cliOptions);
+    // Rebind event handlers (use sessionId which is the composite key)
+    session.claude.on('event', (e) => ctx.handleEvent(session.sessionId, e));
+    session.claude.on('exit', (code) => ctx.handleExit(session.sessionId, code));
+    // Start the new Claude CLI
+    try {
+        session.claude.start();
+    }
+    catch (err) {
+        session.isRestarting = false;
+        console.error('  ❌ Failed to restart Claude:', err);
+        await session.platform.createPost(`❌ Failed to enable interactive permissions: ${err}`, session.threadId);
+        return;
+    }
+    // Update session header with new permission status
+    await updateSessionHeader(session, ctx);
+    // Post confirmation
+    await session.platform.createPost(`🔐 **Interactive permissions enabled** for this session by @${username}\n*Claude Code restarted with permission prompts*`, session.threadId);
+    console.log(`  🔐 Interactive permissions enabled for session by @${username}`);
+    // Update activity and persist
+    session.lastActivityAt = new Date();
+    session.timeoutWarningPosted = false;
+    ctx.persistSession(session);
+}
+// ---------------------------------------------------------------------------
+// Message approval
+// ---------------------------------------------------------------------------
+/**
+ * Request approval for a message from an unauthorized user.
+ */
+export async function requestMessageApproval(session, username, message, ctx) {
+    // If there's already a pending message approval, ignore
+    if (session.pendingMessageApproval) {
+        return;
+    }
+    // Truncate long messages for display
+    const displayMessage = message.length > 200 ? message.substring(0, 200) + '...' : message;
+    const approvalMessage = `🔒 **Message from @${username}** needs approval:\n\n` +
+        `> ${displayMessage}\n\n` +
+        `React: 👍 Allow once | ✅ Invite to session | 👎 Deny`;
+    const post = await session.platform.createInteractivePost(approvalMessage, [APPROVAL_EMOJIS[0], ALLOW_ALL_EMOJIS[0], DENIAL_EMOJIS[0]], session.threadId);
+    session.pendingMessageApproval = {
+        postId: post.id,
+        originalMessage: message,
+        fromUser: username,
+    };
+    // Register post for reaction routing
+    ctx.registerPost(post.id, session.threadId);
+}
+// ---------------------------------------------------------------------------
+// Session header
+// ---------------------------------------------------------------------------
+/**
+ * Update the session header post with current participants and status.
+ */
+export async function updateSessionHeader(session, ctx) {
+    if (!session.sessionStartPostId)
+        return;
+    // Use session's working directory
+    const shortDir = session.workingDir.replace(process.env.HOME || '', '~');
+    // Check session-level permission override
+    const isInteractive = !ctx.skipPermissions || session.forceInteractivePermissions;
+    const permMode = isInteractive ? '🔐 Interactive' : '⚡ Auto';
+    // Build participants list (excluding owner)
+    const otherParticipants = [...session.sessionAllowedUsers]
+        .filter((u) => u !== session.startedBy)
+        .map((u) => `@${u}`)
+        .join(', ');
+    const rows = [
+        `| 📂 **Directory** | \`${shortDir}\` |`,
+        `| 👤 **Started by** | @${session.startedBy} |`,
+    ];
+    // Show worktree info if active
+    if (session.worktreeInfo) {
+        const shortRepoRoot = session.worktreeInfo.repoRoot.replace(process.env.HOME || '', '~');
+        rows.push(`| 🌿 **Worktree** | \`${session.worktreeInfo.branch}\` (from \`${shortRepoRoot}\`) |`);
+    }
+    if (otherParticipants) {
+        rows.push(`| 👥 **Participants** | ${otherParticipants} |`);
+    }
+    rows.push(`| 🔢 **Session** | #${session.sessionNumber} of ${ctx.maxSessions} max |`);
+    rows.push(`| ${permMode.split(' ')[0]} **Permissions** | ${permMode.split(' ')[1]} |`);
+    if (ctx.chromeEnabled) {
+        rows.push(`| 🌐 **Chrome** | Enabled |`);
+    }
+    // Check for available updates
+    const updateInfo = getUpdateInfo();
+    const updateNotice = updateInfo
+        ? `\n> ⚠️ **Update available:** v${updateInfo.current} → v${updateInfo.latest} - Run \`npm install -g claude-threads\`\n`
+        : '';
+    // Get "What's new" from release notes
+    const releaseNotes = getReleaseNotes(pkg.version);
+    const whatsNew = releaseNotes ? getWhatsNewSummary(releaseNotes) : '';
+    const whatsNewLine = whatsNew ? `\n> ✨ **What's new:** ${whatsNew}\n` : '';
+    const msg = [
+        getLogo(pkg.version),
+        updateNotice,
+        whatsNewLine,
+        `| | |`,
+        `|:--|:--|`,
+        ...rows,
+    ].join('\n');
+    try {
+        await session.platform.updatePost(session.sessionStartPostId, msg);
+    }
+    catch (err) {
+        console.error('  ⚠️ Failed to update session header:', err);
+    }
+}

package/dist/session/events.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Claude event handling module
+ *
+ * Handles events from Claude CLI: assistant messages, tool use,
+ * tool results, tasks, questions, and plan approvals.
+ */
+import type { Session } from './types.js';
+import type { ClaudeEvent } from '../claude/cli.js';
+export interface EventContext {
+    debug: boolean;
+    registerPost: (postId: string, threadId: string) => void;
+    flush: (session: Session) => Promise<void>;
+    startTyping: (session: Session) => void;
+    stopTyping: (session: Session) => void;
+    appendContent: (session: Session, text: string) => void;
+}
+/**
+ * Handle a Claude event from the CLI stream.
+ * Routes to appropriate handler based on event type.
+ */
+export declare function handleEvent(session: Session, event: ClaudeEvent, ctx: EventContext): void;
+/**
+ * Post the current question in the question set.
+ */
+export declare function postCurrentQuestion(session: Session, ctx: EventContext): Promise<void>;