@thesammykins/tether 1.6.0 → 1.7.0

package/src/config.ts

@@ -57,7 +57,8 @@ const CONFIG_KEYS: Record<string, ConfigKeyMeta> = {
 
     // Agent
     AGENT_TYPE: { section: 'agent', default: 'claude', description: 'Agent type (claude, opencode, codex)' },
-    CLAUDE_WORKING_DIR: { section: 'agent', default: '', description: 'Default working directory for agent sessions' },
+    /** @deprecated Use named projects instead (tether project add). Kept for backward compatibility. */
+    CLAUDE_WORKING_DIR: { section: 'agent', default: '', description: 'Default working directory for agent sessions (deprecated: use projects)' },
     CLAUDE_BIN: { section: 'agent', default: '', description: 'Override path to Claude CLI binary' },
     OPENCODE_BIN: { section: 'agent', default: '', description: 'Override path to OpenCode CLI binary' },
     CODEX_BIN: { section: 'agent', default: '', description: 'Override path to Codex CLI binary' },
@@ -402,3 +403,34 @@ export const CONFIG_PATHS = {
     get CONFIG_PATH() { return getConfigPath(); },
     get SECRETS_PATH() { return getSecretsPath(); },
 } as const;
+
+/**
+ * Migrate CLAUDE_WORKING_DIR to a named project.
+ *
+ * If CLAUDE_WORKING_DIR is set and no projects exist in the DB,
+ * creates a default project from the directory name and path.
+ * Safe to call multiple times — no-ops when projects already exist.
+ */
+export function migrateWorkingDirToProject(): void {
+    // Lazy-import to avoid circular dependency at module load time
+    const { listProjects, createProject, db } = require('./db.js');
+    const { resolve: resolvePath, basename } = require('path');
+
+    const workingDir = resolve('CLAUDE_WORKING_DIR');
+    if (!workingDir) return;
+
+    // Use a transaction to prevent TOCTOU race: concurrent calls could both
+    // see 0 projects and create duplicates without atomic check-and-insert.
+    db.transaction(() => {
+        const existing = listProjects() as { name: string }[];
+        if (existing.length > 0) {
+            console.log('[config] CLAUDE_WORKING_DIR is deprecated. Use named projects instead (tether project add).');
+            return;
+        }
+
+        const resolvedPath = resolvePath(workingDir);
+        const dirName = basename(resolvedPath);
+        createProject(dirName, resolvedPath, true);
+        console.log(`[config] Migrated CLAUDE_WORKING_DIR to project "${dirName}"`);
+    })();
+}

package/src/db.ts

@@ -18,7 +18,7 @@ import { mkdirSync } from 'fs';
 import { dirname } from 'path';
 try {
     mkdirSync(dirname(DB_PATH), { recursive: true });
-} catch {}
+} catch { /* Directory already exists or permission issue */ }
 
 // Open database
 export const db = new Database(DB_PATH);
@@ -72,6 +72,26 @@ db.run(`
     )
 `);
 
+// Create projects table
+db.run(`
+    CREATE TABLE IF NOT EXISTS projects (
+        name TEXT PRIMARY KEY,
+        path TEXT NOT NULL,
+        is_default INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+`);
+
+// Add project_name column to channels table (migration)
+try {
+    db.run(`ALTER TABLE channels ADD COLUMN project_name TEXT REFERENCES projects(name)`);
+} catch { /* Column may already exist */ }
+
+// Add project_name column to threads table (migration)
+try {
+    db.run(`ALTER TABLE threads ADD COLUMN project_name TEXT REFERENCES projects(name)`);
+} catch { /* Column may already exist */ }
+
 // Note: rate limiting is handled in-memory, see src/middleware/rate-limiter.ts
 
 console.log(`[db] SQLite database ready at ${DB_PATH}`);
@@ -116,3 +136,89 @@ export function updateSessionId(threadId: string, sessionId: string): void {
         UPDATE threads SET session_id = ? WHERE thread_id = ?
     `, [sessionId, threadId]);
 }
+
+// --- Project types and helpers ---
+
+export interface Project {
+    name: string;
+    path: string;
+    is_default: number;
+    created_at: string;
+}
+
+export function createProject(name: string, path: string, isDefault?: boolean): void {
+    db.transaction(() => {
+        if (isDefault) {
+            db.run(`UPDATE projects SET is_default = 0 WHERE is_default = 1`);
+        }
+        db.run(`
+            INSERT INTO projects (name, path, is_default) VALUES (?, ?, ?)
+            ON CONFLICT(name) DO UPDATE SET path = ?, is_default = ?
+        `, [name, path, isDefault ? 1 : 0, path, isDefault ? 1 : 0]);
+    })();
+}
+
+export function getProject(name: string): Project | null {
+    return db.query('SELECT * FROM projects WHERE name = ?')
+        .get(name) as Project | null;
+}
+
+export function getDefaultProject(): Project | null {
+    return db.query('SELECT * FROM projects WHERE is_default = 1')
+        .get() as Project | null;
+}
+
+export function listProjects(): Project[] {
+    return db.query('SELECT * FROM projects ORDER BY name')
+        .all() as Project[];
+}
+
+export function deleteProject(name: string): void {
+    db.transaction(() => {
+        db.run(`UPDATE channels SET project_name = NULL WHERE project_name = ?`, [name]);
+        db.run(`UPDATE threads SET project_name = NULL WHERE project_name = ?`, [name]);
+        db.run(`DELETE FROM projects WHERE name = ?`, [name]);
+    })();
+}
+
+export function setProjectDefault(name: string): void {
+    db.transaction(() => {
+        db.run(`UPDATE projects SET is_default = 0 WHERE is_default = 1`);
+        db.run(`UPDATE projects SET is_default = 1 WHERE name = ?`, [name]);
+    })();
+}
+
+export function getChannelProject(channelId: string): Project | null {
+    const row = db.query(`
+        SELECT p.* FROM projects p
+        JOIN channels c ON c.project_name = p.name
+        WHERE c.channel_id = ?
+    `).get(channelId) as Project | null;
+    return row;
+}
+
+export function setChannelProject(channelId: string, projectName: string): void {
+    // Look up project path to keep working_dir in sync for legacy code paths
+    const project = db.query('SELECT path FROM projects WHERE name = ?')
+        .get(projectName) as { path: string } | null;
+    const workingDir = project?.path ?? null;
+    db.run(`
+        INSERT INTO channels (channel_id, project_name, working_dir) VALUES (?, ?, ?)
+        ON CONFLICT(channel_id) DO UPDATE SET project_name = ?, working_dir = COALESCE(?, working_dir), updated_at = CURRENT_TIMESTAMP
+    `, [channelId, projectName, workingDir, projectName, workingDir]);
+}
+
+export function getThreadProject(threadId: string): Project | null {
+    const row = db.query(`
+        SELECT p.* FROM projects p
+        JOIN threads t ON t.project_name = p.name
+        WHERE t.thread_id = ?
+    `).get(threadId) as Project | null;
+    return row;
+}
+
+export function setThreadProject(threadId: string, projectName: string): void {
+    db.run(`
+        UPDATE threads SET project_name = ? WHERE thread_id = ?
+    `, [projectName, threadId]);
+}

package/src/features/projects.ts

@@ -0,0 +1,219 @@
+/**
+ * Project management feature - shared handlers for slash and text commands.
+ *
+ * Both /cord project ... and !project ... dispatch into these functions
+ * so the business logic lives in one place.
+ */
+
+import { existsSync, realpathSync } from 'fs';
+import { resolve } from 'path';
+import {
+    createProject,
+    getProject,
+    listProjects,
+    setProjectDefault,
+    setChannelProject,
+    db,
+} from '../db.js';
+import type { Project } from '../db.js';
+
+const log = (msg: string) => process.stdout.write(`[projects] ${msg}\n`);
+
+// Allowed working directories (read once, shared with bot.ts logic)
+const ALLOWED_DIRS = process.env.CORD_ALLOWED_DIRS
+    ? process.env.CORD_ALLOWED_DIRS.split(',').map(d => resolve(d.trim()))
+    : null;
+
+/**
+ * Validate a directory path exists and is within CORD_ALLOWED_DIRS.
+ * Returns null when valid, or an error string.
+ */
+function validatePath(dir: string): string | null {
+    const resolved = resolve(dir);
+
+    if (!existsSync(resolved)) {
+        return `Directory not found: \`${dir}\``;
+    }
+
+    let realPath: string;
+    try {
+        realPath = realpathSync(resolved);
+    } catch (error) {
+        return `Cannot resolve path: \`${dir}\` (${error instanceof Error ? error.message : String(error)})`;
+    }
+
+    if (!ALLOWED_DIRS) {
+        return null;
+    }
+
+    const isAllowed = ALLOWED_DIRS.some(allowed => {
+        let allowedReal: string;
+        try {
+            allowedReal = realpathSync(allowed);
+        } catch {
+            return false;
+        }
+        return realPath === allowedReal || realPath.startsWith(allowedReal + '/');
+    });
+
+    if (!isAllowed) {
+        return `Directory not in allowed list. Allowed: ${ALLOWED_DIRS.join(', ')}`;
+    }
+
+    return null;
+}
+
+export interface CommandResult {
+    success: boolean;
+    message: string;
+}
+
+/**
+ * Register a new project.
+ */
+export function handleProjectAdd(name: string, path: string): CommandResult {
+    const validationError = validatePath(path);
+    if (validationError) {
+        return { success: false, message: validationError };
+    }
+
+    const resolvedPath = resolve(path);
+
+    try {
+        createProject(name, resolvedPath);
+        log(`Project '${name}' registered at ${resolvedPath}`);
+        return { success: true, message: `Project **${name}** registered at \`${resolvedPath}\`` };
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log(`Failed to create project '${name}': ${msg}`);
+        return { success: false, message: `Failed to register project: ${msg}` };
+    }
+}
+
+/**
+ * List all registered projects, returning both raw data and a formatted string.
+ */
+export function handleProjectList(): { projects: Project[]; formatted: string } {
+    const projects = listProjects();
+
+    if (projects.length === 0) {
+        return { projects, formatted: 'No projects registered. Use `/cord project add` or `!project add <name> <path>` to add one.' };
+    }
+
+    const lines = projects.map(p => {
+        const def = p.is_default ? ' **(default)**' : '';
+        return `- **${p.name}**${def} — \`${p.path}\``;
+    });
+
+    return { projects, formatted: `**Registered Projects**\n${lines.join('\n')}` };
+}
+
+/**
+ * Set a project as the global default.
+ */
+export function handleProjectDefault(name: string): CommandResult {
+    const project = getProject(name);
+    if (!project) {
+        return { success: false, message: `Project **${name}** not found.` };
+    }
+
+    try {
+        setProjectDefault(name);
+        log(`Project '${name}' set as default`);
+        return { success: true, message: `Project **${name}** set as default.` };
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to set default: ${msg}` };
+    }
+}
+
+/**
+ * Bind a project to a specific channel.
+ */
+export function handleProjectUse(channelId: string, name: string): CommandResult {
+    const project = getProject(name);
+    if (!project) {
+        return { success: false, message: `Project **${name}** not found.` };
+    }
+
+    try {
+        setChannelProject(channelId, name);
+        log(`Channel ${channelId} bound to project '${name}'`);
+        return {
+            success: true,
+            message: `Channel now uses project **${name}** (\`${project.path}\`).`,
+        };
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, message: `Failed to set channel project: ${msg}` };
+    }
+}
+
+/**
+ * Validate that a session ID exists in the threads table.
+ * Returns the thread row if found, or null.
+ */
+export function findSession(sessionId: string): { thread_id: string; session_id: string; working_dir: string | null; project_name: string | null } | null {
+    // Try exact match first
+    const exact = db.query('SELECT thread_id, session_id, working_dir, project_name FROM threads WHERE session_id = ?')
+        .get(sessionId) as { thread_id: string; session_id: string; working_dir: string | null; project_name: string | null } | null;
+    if (exact) return exact;
+
+    // Try prefix match (user may supply truncated ID)
+    // Escape SQL LIKE wildcards in user input to prevent unintended matches
+    const escaped = sessionId.replace(/[%_]/g, '\\$&');
+    const prefix = db.query("SELECT thread_id, session_id, working_dir, project_name FROM threads WHERE session_id LIKE ? ESCAPE '\\'")
+        .get(`${escaped}%`) as { thread_id: string; session_id: string; working_dir: string | null; project_name: string | null } | null;
+    return prefix;
+}
+
+/**
+ * Handle session attach - validate the session exists and return info.
+ * Thread creation happens in bot.ts since it needs Discord API.
+ */
+export function handleSessionAttach(sessionId: string): CommandResult & { session?: { thread_id: string; session_id: string; working_dir: string | null; project_name: string | null } } {
+    const session = findSession(sessionId);
+    if (!session) {
+        return { success: false, message: `Session \`${sessionId}\` not found.` };
+    }
+
+    log(`Attach requested for session ${session.session_id}`);
+    return {
+        success: true,
+        message: `Attaching to session \`${session.session_id.slice(0, 8)}...\``,
+        session,
+    };
+}
+
+/**
+ * List recent sessions for autocomplete. Returns session IDs with age info.
+ */
+export function getRecentSessions(filter: string, limit = 25): Array<{ name: string; value: string }> {
+    const rows = db.query(`
+        SELECT session_id, created_at FROM threads
+        ORDER BY created_at DESC
+        LIMIT 50
+    `).all() as Array<{ session_id: string; created_at: string }>;
+
+    const now = Date.now();
+    return rows
+        .filter(r => r.session_id.toLowerCase().includes(filter.toLowerCase()))
+        .slice(0, limit)
+        .map(r => {
+            const age = formatRelativeTime(r.created_at, now);
+            const short = r.session_id.slice(0, 8);
+            return { name: `${short}... (${age})`, value: r.session_id };
+        });
+}
+
+function formatRelativeTime(dateStr: string, now: number): string {
+    const ms = now - new Date(dateStr).getTime();
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60) return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/src/queue.ts

@@ -40,5 +40,6 @@ export interface ClaudeJob {
     userId: string;
     username: string;
     workingDir?: string;
+    projectName?: string;
     channelContext?: string;
 }

package/src/worker.ts

@@ -9,15 +9,28 @@
 
 import { Worker, Job } from 'bullmq';
 import IORedis from 'ioredis';
+import { existsSync } from 'fs';
 import { getAdapter } from './adapters/registry.js';
 import { sendToThread } from './discord.js';
 import { isAway } from './features/brb.js';
-import { updateSessionId } from './db.js';
+import { updateSessionId, getProject, getDefaultProject } from './db.js';
 import type { ClaudeJob } from './queue.js';
 import { debugLog, debugBlock } from './debug.js';
 
 const log = (msg: string) => process.stdout.write(`[worker] ${msg}\n`);
 
+/** Resolve default working directory: default project > env > cwd. */
+function getDefaultWorkingDir(): string {
+    const defaultProject = getDefaultProject();
+    if (defaultProject && existsSync(defaultProject.path)) {
+        return defaultProject.path;
+    }
+    const envDir = process.env.CLAUDE_WORKING_DIR;
+    if (envDir && existsSync(envDir)) return envDir;
+    if (envDir) log(`WARNING: CLAUDE_WORKING_DIR="${envDir}" does not exist, using cwd`);
+    return process.cwd();
+}
+
 const connection = new IORedis({
     host: process.env.REDIS_HOST || 'localhost',
     port: parseInt(process.env.REDIS_PORT || '6379'),
@@ -27,9 +40,23 @@ const connection = new IORedis({
 const worker = new Worker<ClaudeJob>(
     'claude',
     async (job: Job<ClaudeJob>) => {
-        const { prompt, threadId, sessionId, resume, username, workingDir, channelContext } = job.data;
+        const { prompt, threadId, sessionId, resume, username, workingDir: jobWorkingDir, projectName, channelContext } = job.data;
+
+        // Resolve working directory: project DB > job workingDir > default
+        let workingDir = jobWorkingDir;
+        if (projectName) {
+            const project = getProject(projectName);
+            if (project && existsSync(project.path)) {
+                workingDir = project.path;
+            } else if (project) {
+                log(`WARNING: Project "${projectName}" path not found: ${project.path}, using job workingDir`);
+            }
+        }
+        if (!workingDir) {
+            workingDir = getDefaultWorkingDir();
+        }
 
-        log(`Processing job ${job.id} for ${username}`);
+        log(`Processing job ${job.id} for ${username}${projectName ? ` [project: ${projectName}]` : ''}`);
         log(`Session: ${sessionId}, Resume: ${resume}`);
 
         // Debug: Log full job details
@@ -186,7 +213,7 @@ debugBlock('worker', 'Worker Environment', {
     agentType: process.env.AGENT_TYPE || 'claude (default)',
     redisHost: process.env.REDIS_HOST || 'localhost',
     redisPort: process.env.REDIS_PORT || '6379',
-    workingDir: process.env.CLAUDE_WORKING_DIR || process.cwd(),
+    workingDir: getDefaultWorkingDir(),
     tetherDebug: process.env.TETHER_DEBUG || 'false',
 });