claude-threads 0.12.0

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+/** Check if any .env config file exists */
+export declare function configExists(): boolean;
+export type WorktreeMode = 'off' | 'prompt' | 'require';
+/** CLI arguments that can override config */
+export interface CliArgs {
+    url?: string;
+    token?: string;
+    channel?: string;
+    botName?: string;
+    allowedUsers?: string;
+    skipPermissions?: boolean;
+    chrome?: boolean;
+    worktreeMode?: WorktreeMode;
+}
+export interface Config {
+    mattermost: {
+        url: string;
+        token: string;
+        channelId: string;
+        botName: string;
+    };
+    allowedUsers: string[];
+    skipPermissions: boolean;
+    chrome: boolean;
+    worktreeMode: WorktreeMode;
+}
+export declare function loadConfig(cliArgs?: CliArgs): Config;

package/dist/config.js

@@ -0,0 +1,94 @@
+import { config } from 'dotenv';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+let envLoaded = false;
+// Paths to search for .env files (in order of priority)
+const ENV_PATHS = [
+    resolve(process.cwd(), '.env'), // Current directory
+    resolve(homedir(), '.config', 'claude-threads', '.env'), // ~/.config/claude-threads/.env
+    resolve(homedir(), '.claude-threads.env'), // ~/.claude-threads.env
+];
+function loadEnv() {
+    if (envLoaded)
+        return;
+    envLoaded = true;
+    for (const envPath of ENV_PATHS) {
+        if (existsSync(envPath)) {
+            if (process.env.DEBUG === '1' || process.argv.includes('--debug')) {
+                console.log(`  [config] Loading from: ${envPath}`);
+            }
+            config({ path: envPath });
+            break;
+        }
+    }
+}
+/** Check if any .env config file exists */
+export function configExists() {
+    return ENV_PATHS.some(p => existsSync(p));
+}
+function getRequired(cliValue, envName, name) {
+    const value = cliValue || process.env[envName];
+    if (!value) {
+        throw new Error(`Missing required config: ${name}. Set ${envName} in .env or use --${name.toLowerCase().replace(/ /g, '-')} flag.`);
+    }
+    return value;
+}
+export function loadConfig(cliArgs) {
+    loadEnv();
+    // CLI args take priority over env vars
+    const url = getRequired(cliArgs?.url, 'MATTERMOST_URL', 'url');
+    const token = getRequired(cliArgs?.token, 'MATTERMOST_TOKEN', 'token');
+    const channelId = getRequired(cliArgs?.channel, 'MATTERMOST_CHANNEL_ID', 'channel');
+    const botName = cliArgs?.botName || process.env.MATTERMOST_BOT_NAME || 'claude-code';
+    const allowedUsersStr = cliArgs?.allowedUsers || process.env.ALLOWED_USERS || '';
+    const allowedUsers = allowedUsersStr
+        .split(',')
+        .map(u => u.trim())
+        .filter(u => u.length > 0);
+    // CLI --skip-permissions or --no-skip-permissions takes priority
+    // Then env SKIP_PERMISSIONS, then legacy flag
+    let skipPermissions;
+    if (cliArgs?.skipPermissions !== undefined) {
+        // CLI explicitly set (--skip-permissions or --no-skip-permissions)
+        skipPermissions = cliArgs.skipPermissions;
+    }
+    else {
+        skipPermissions = process.env.SKIP_PERMISSIONS === 'true' ||
+            process.argv.includes('--dangerously-skip-permissions');
+    }
+    // Chrome integration: CLI flag or env var
+    let chrome;
+    if (cliArgs?.chrome !== undefined) {
+        chrome = cliArgs.chrome;
+    }
+    else {
+        chrome = process.env.CLAUDE_CHROME === 'true';
+    }
+    // Worktree mode: CLI flag or env var, default to 'prompt'
+    let worktreeMode;
+    if (cliArgs?.worktreeMode !== undefined) {
+        worktreeMode = cliArgs.worktreeMode;
+    }
+    else {
+        const envValue = process.env.WORKTREE_MODE?.toLowerCase();
+        if (envValue === 'off' || envValue === 'prompt' || envValue === 'require') {
+            worktreeMode = envValue;
+        }
+        else {
+            worktreeMode = 'prompt'; // Default
+        }
+    }
+    return {
+        mattermost: {
+            url: url.replace(/\/$/, ''), // Remove trailing slash
+            token,
+            channelId,
+            botName,
+        },
+        allowedUsers,
+        skipPermissions,
+        chrome,
+        worktreeMode,
+    };
+}

package/dist/git/worktree.d.ts

@@ -0,0 +1,50 @@
+export interface WorktreeInfo {
+    path: string;
+    branch: string;
+    commit: string;
+    isMain: boolean;
+    isBare: boolean;
+}
+/**
+ * Check if a directory is inside a git repository
+ */
+export declare function isGitRepository(dir: string): Promise<boolean>;
+/**
+ * Get the root directory of the git repository
+ */
+export declare function getRepositoryRoot(dir: string): Promise<string>;
+/**
+ * Check if there are uncommitted changes (staged or unstaged)
+ */
+export declare function hasUncommittedChanges(dir: string): Promise<boolean>;
+/**
+ * List all worktrees for a repository
+ */
+export declare function listWorktrees(repoRoot: string): Promise<WorktreeInfo[]>;
+/**
+ * Check if a branch exists (local or remote)
+ */
+export declare function branchExists(repoRoot: string, branch: string): Promise<boolean>;
+/**
+ * Generate the worktree directory path
+ * Creates path like: /path/to/repo-worktrees/branch-name-abc123
+ */
+export declare function getWorktreeDir(repoRoot: string, branch: string): string;
+/**
+ * Create a new worktree for a branch
+ * If the branch doesn't exist, creates it from the current HEAD
+ */
+export declare function createWorktree(repoRoot: string, branch: string, targetDir: string): Promise<string>;
+/**
+ * Remove a worktree
+ */
+export declare function removeWorktree(repoRoot: string, worktreePath: string): Promise<void>;
+/**
+ * Find a worktree by branch name
+ */
+export declare function findWorktreeByBranch(repoRoot: string, branch: string): Promise<WorktreeInfo | null>;
+/**
+ * Validate a git branch name
+ * Based on git-check-ref-format rules
+ */
+export declare function isValidBranchName(name: string): boolean;

package/dist/git/worktree.js

@@ -0,0 +1,228 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+/**
+ * Execute a git command and return stdout
+ */
+async function execGit(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('git', args, { cwd });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`git ${args.join(' ')} failed: ${stderr || stdout}`));
+            }
+        });
+        proc.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Check if a directory is inside a git repository
+ */
+export async function isGitRepository(dir) {
+    try {
+        await execGit(['rev-parse', '--git-dir'], dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the root directory of the git repository
+ */
+export async function getRepositoryRoot(dir) {
+    return execGit(['rev-parse', '--show-toplevel'], dir);
+}
+/**
+ * Check if there are uncommitted changes (staged or unstaged)
+ */
+export async function hasUncommittedChanges(dir) {
+    try {
+        // Check for staged changes
+        const staged = await execGit(['diff', '--cached', '--quiet'], dir).catch(() => 'changes');
+        if (staged === 'changes')
+            return true;
+        // Check for unstaged changes
+        const unstaged = await execGit(['diff', '--quiet'], dir).catch(() => 'changes');
+        if (unstaged === 'changes')
+            return true;
+        // Check for untracked files
+        const untracked = await execGit(['ls-files', '--others', '--exclude-standard'], dir);
+        return untracked.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List all worktrees for a repository
+ */
+export async function listWorktrees(repoRoot) {
+    const output = await execGit(['worktree', 'list', '--porcelain'], repoRoot);
+    const worktrees = [];
+    if (!output)
+        return worktrees;
+    // Parse porcelain output
+    // Format:
+    // worktree /path/to/worktree
+    // HEAD <commit>
+    // branch refs/heads/branch-name
+    // <blank line>
+    const blocks = output.split('\n\n').filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        const worktree = {};
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                worktree.path = line.slice(9);
+            }
+            else if (line.startsWith('HEAD ')) {
+                worktree.commit = line.slice(5);
+            }
+            else if (line.startsWith('branch ')) {
+                // refs/heads/branch-name -> branch-name
+                worktree.branch = line.slice(7).replace('refs/heads/', '');
+            }
+            else if (line === 'bare') {
+                worktree.isBare = true;
+            }
+            else if (line === 'detached') {
+                worktree.branch = '(detached)';
+            }
+        }
+        if (worktree.path) {
+            worktrees.push({
+                path: worktree.path,
+                branch: worktree.branch || '(unknown)',
+                commit: worktree.commit || '',
+                isMain: worktrees.length === 0, // First worktree is the main one
+                isBare: worktree.isBare || false,
+            });
+        }
+    }
+    return worktrees;
+}
+/**
+ * Check if a branch exists (local or remote)
+ */
+export async function branchExists(repoRoot, branch) {
+    try {
+        // Check local branches
+        await execGit(['rev-parse', '--verify', `refs/heads/${branch}`], repoRoot);
+        return true;
+    }
+    catch {
+        try {
+            // Check remote branches
+            await execGit(['rev-parse', '--verify', `refs/remotes/origin/${branch}`], repoRoot);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Generate the worktree directory path
+ * Creates path like: /path/to/repo-worktrees/branch-name-abc123
+ */
+export function getWorktreeDir(repoRoot, branch) {
+    const repoName = path.basename(repoRoot);
+    const parentDir = path.dirname(repoRoot);
+    const worktreesDir = path.join(parentDir, `${repoName}-worktrees`);
+    // Sanitize branch name for filesystem
+    const sanitizedBranch = branch
+        .replace(/\//g, '-')
+        .replace(/[^a-zA-Z0-9-_]/g, '');
+    const shortUuid = randomUUID().slice(0, 8);
+    return path.join(worktreesDir, `${sanitizedBranch}-${shortUuid}`);
+}
+/**
+ * Create a new worktree for a branch
+ * If the branch doesn't exist, creates it from the current HEAD
+ */
+export async function createWorktree(repoRoot, branch, targetDir) {
+    // Ensure the parent directory exists
+    const parentDir = path.dirname(targetDir);
+    await fs.mkdir(parentDir, { recursive: true });
+    // Check if branch exists
+    const exists = await branchExists(repoRoot, branch);
+    if (exists) {
+        // Use existing branch
+        await execGit(['worktree', 'add', targetDir, branch], repoRoot);
+    }
+    else {
+        // Create new branch from HEAD
+        await execGit(['worktree', 'add', '-b', branch, targetDir], repoRoot);
+    }
+    return targetDir;
+}
+/**
+ * Remove a worktree
+ */
+export async function removeWorktree(repoRoot, worktreePath) {
+    // First try to remove cleanly
+    try {
+        await execGit(['worktree', 'remove', worktreePath], repoRoot);
+    }
+    catch {
+        // If that fails, try force remove
+        await execGit(['worktree', 'remove', '--force', worktreePath], repoRoot);
+    }
+    // Prune any stale worktree references
+    await execGit(['worktree', 'prune'], repoRoot);
+}
+/**
+ * Find a worktree by branch name
+ */
+export async function findWorktreeByBranch(repoRoot, branch) {
+    const worktrees = await listWorktrees(repoRoot);
+    return worktrees.find((wt) => wt.branch === branch) || null;
+}
+/**
+ * Validate a git branch name
+ * Based on git-check-ref-format rules
+ */
+export function isValidBranchName(name) {
+    if (!name || name.length === 0)
+        return false;
+    // Cannot start or end with /
+    if (name.startsWith('/') || name.endsWith('/'))
+        return false;
+    // Cannot contain ..
+    if (name.includes('..'))
+        return false;
+    // Cannot contain special characters
+    if (/[\s~^:?*[\]\\]/.test(name))
+        return false;
+    // Cannot start with -
+    if (name.startsWith('-'))
+        return false;
+    // Cannot end with .lock
+    if (name.endsWith('.lock'))
+        return false;
+    // Cannot contain @{
+    if (name.includes('@{'))
+        return false;
+    // Cannot be @
+    if (name === '@')
+        return false;
+    // Cannot contain consecutive dots
+    if (/\.\./.test(name))
+        return false;
+    return true;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};