@thesammykins/tether 1.0.0

package/src/spawner.ts

@@ -0,0 +1,110 @@
+/**
+ * Spawner - The Claude CLI integration
+ *
+ * THIS IS THE CORE OF THE SYSTEM.
+ *
+ * Key flags:
+ * - `--print`: Non-interactive mode, returns output
+ * - `--session-id UUID`: Set session ID for new sessions
+ * - `--resume UUID`: Resume an existing session (for follow-ups)
+ * - `--append-system-prompt`: Inject context that survives compaction
+ * - `-p "prompt"`: The actual prompt to send
+ */
+
+const log = (msg: string) => process.stdout.write(`[spawner] ${msg}\n`);
+
+// Timezone for datetime injection (set via TZ env var)
+const TIMEZONE = process.env.TZ || 'UTC';
+
+interface SpawnOptions {
+    prompt: string;
+    sessionId: string;
+    resume: boolean;
+    systemPrompt?: string;
+    workingDir?: string;
+}
+
+/**
+ * Get current datetime in user's timezone
+ * Claude Code doesn't know the time - we inject it
+ */
+function getDatetimeContext(): string {
+    const now = new Date();
+    return now.toLocaleString('en-US', {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true,
+        timeZone: TIMEZONE,
+    });
+}
+
+/**
+ * Spawn Claude CLI and return the response
+ */
+export async function spawnClaude(options: SpawnOptions): Promise<string> {
+    const { prompt, sessionId, resume, systemPrompt, workingDir } = options;
+
+    const cwd = workingDir || process.env.CLAUDE_WORKING_DIR || process.cwd();
+    log(`Spawning Claude - Session: ${sessionId}, Resume: ${resume}`);
+    log(`Working directory: ${cwd}`);
+
+    // Build CLI arguments
+    const args = ['claude'];
+
+    // Non-interactive mode
+    args.push('--print');
+
+    // Session handling
+    if (resume) {
+        // Resume existing session for follow-up messages
+        args.push('--resume', sessionId);
+    } else {
+        // New session - set the ID upfront
+        args.push('--session-id', sessionId);
+    }
+
+    // Inject datetime context (survives session compaction)
+    const datetimeContext = `Current date/time: ${getDatetimeContext()}`;
+    const fullSystemPrompt = systemPrompt
+        ? `${datetimeContext}\n\n${systemPrompt}`
+        : datetimeContext;
+
+    args.push('--append-system-prompt', fullSystemPrompt);
+
+    // The actual prompt
+    args.push('-p', prompt);
+
+    log(`Command: ${args.join(' ').slice(0, 100)}...`);
+
+    // Spawn the process
+    const proc = Bun.spawn(args, {
+        cwd,
+        env: {
+            ...process.env,
+            TZ: TIMEZONE,
+        },
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+
+    // Wait for process to exit
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+        log(`Claude exited with code ${exitCode}`);
+        log(`stderr: ${stderr}`);
+        throw new Error(`Claude failed: ${stderr || 'Unknown error'}`);
+    }
+
+    log(`Claude responded (${stdout.length} chars)`);
+
+    return stdout.trim();
+}

package/src/worker.ts

@@ -0,0 +1,97 @@
+/**
+ * Worker - Processes Claude jobs from the queue
+ *
+ * This is where the magic happens:
+ * 1. Pulls jobs from the queue
+ * 2. Spawns the configured agent adapter (Claude/OpenCode/Codex)
+ * 3. Posts the response back to Discord
+ */
+
+import { Worker, Job } from 'bullmq';
+import IORedis from 'ioredis';
+import { getAdapter } from './adapters/registry.js';
+import { sendToThread } from './discord.js';
+import { isAway } from './features/brb.js';
+import type { ClaudeJob } from './queue.js';
+
+const log = (msg: string) => process.stdout.write(`[worker] ${msg}\n`);
+
+const connection = new IORedis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    maxRetriesPerRequest: null,
+});
+
+const worker = new Worker<ClaudeJob>(
+    'claude',
+    async (job: Job<ClaudeJob>) => {
+        const { prompt, threadId, sessionId, resume, username, workingDir } = job.data;
+
+        log(`Processing job ${job.id} for ${username}`);
+        log(`Session: ${sessionId}, Resume: ${resume}`);
+
+        try {
+            // Get the configured adapter and spawn
+            const adapter = getAdapter();
+            log(`Using adapter: ${adapter.name}`);
+
+            // If user is away (BRB mode), prepend guidance to use tether ask CLI
+            let effectivePrompt = prompt;
+            if (isAway(threadId)) {
+                const brbPrefix = [
+                    '[IMPORTANT: The user is currently away from this conversation.',
+                    'If you need to ask them a question or get their input, DO NOT use your built-in question/approval tools.',
+                    'Instead, use the tether CLI:',
+                    '',
+                    `  tether ask ${threadId} "Your question here" --option "Option A" --option "Option B"`,
+                    '',
+                    'This will send interactive buttons to Discord and block until the user responds.',
+                    'The selected option will be printed to stdout.',
+                    `Thread ID for this conversation: ${threadId}]`,
+                ].join('\n');
+                effectivePrompt = `${brbPrefix}\n\n${prompt}`;
+                log(`BRB mode active for thread ${threadId} — injected tether ask guidance`);
+            }
+
+            const result = await adapter.spawn({
+                prompt: effectivePrompt,
+                sessionId,
+                resume,
+                workingDir,
+            });
+
+            // Send response to Discord thread
+            await sendToThread(threadId, result.output);
+
+            log(`Job ${job.id} completed`);
+            return { success: true, responseLength: result.output.length };
+
+        } catch (error) {
+            log(`Job ${job.id} failed: ${error}`);
+
+            // Send error message to thread
+            await sendToThread(
+                threadId,
+                `Something went wrong. Try again?\n\`\`\`${error}\`\`\``
+            );
+
+            throw error; // Re-throw for BullMQ retry logic
+        }
+    },
+    {
+        connection,
+        concurrency: 2, // Process up to 2 jobs at once
+    }
+);
+
+worker.on('completed', (job) => {
+    log(`Job ${job?.id} completed`);
+});
+
+worker.on('failed', (job, err) => {
+    log(`Job ${job?.id} failed: ${err.message}`);
+});
+
+log('Worker started, waiting for jobs...');
+
+export { worker };