@thesammykins/tether 1.0.0

package/index.ts

@@ -0,0 +1,32 @@
+/**
+ * @thesammykins/tether
+ *
+ * Discord bot that bridges messages to AI agent sessions.
+ * Supports Claude Code, OpenCode, and Codex CLI.
+ *
+ * Usage:
+ *   bunx @thesammykins/tether start   # Start bot + worker
+ *   bunx @thesammykins/tether setup   # Interactive setup
+ *
+ * Or programmatically:
+ *   import { adapters, features } from '@thesammykins/tether'
+ */
+
+// Adapters
+export { ClaudeAdapter } from './src/adapters/claude.ts';
+export { OpenCodeAdapter } from './src/adapters/opencode.ts';
+export { CodexAdapter } from './src/adapters/codex.ts';
+export { getAdapter } from './src/adapters/registry.ts';
+export type { AgentAdapter, SpawnResult } from './src/adapters/types.ts';
+
+// Features
+export { acknowledgeMessage } from './src/features/ack.ts';
+export { getChannelContext } from './src/features/channel-context.ts';
+export { generateThreadName } from './src/features/thread-naming.ts';
+export { checkSessionLimits } from './src/features/session-limits.ts';
+export { handlePauseResume, isThreadPausedExport } from './src/features/pause-resume.ts';
+export { isAway, setBrb, setBack, isBrbMessage, isBackMessage } from './src/features/brb.ts';
+
+// Infrastructure
+export { claudeQueue } from './src/queue.ts';
+export { db, getChannelConfigCached, setChannelConfig } from './src/db.ts';

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@thesammykins/tether",
+  "version": "1.0.0",
+  "description": "Discord bot that bridges messages to AI agent sessions (Claude, OpenCode, Codex)",
+  "license": "MIT",
+  "author": "thesammykins",
+  "homepage": "https://github.com/thesammykins/tether#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thesammykins/tether"
+  },
+  "bugs": {
+    "url": "https://github.com/thesammykins/tether/issues"
+  },
+  "keywords": [
+    "discord",
+    "bot",
+    "ai",
+    "claude",
+    "opencode",
+    "codex",
+    "agent",
+    "bridge",
+    "bun"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "module": "index.ts",
+  "main": "index.ts",
+  "bin": {
+    "tether": "bin/tether.ts"
+  },
+  "files": [
+    "src/",
+    "bin/tether.ts",
+    "index.ts",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "scripts": {
+    "start": "bun run bin/tether.ts start",
+    "bot": "bun run src/bot.ts",
+    "worker": "bun run src/worker.ts",
+    "setup": "bun run bin/tether.ts setup",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "bullmq": "^5.67.1",
+    "discord.js": "^14.25.1",
+    "ioredis": "^5.9.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "engines": {
+    "bun": ">=1.1.0"
+  }
+}

package/src/adapters/claude.ts

@@ -0,0 +1,107 @@
+import type { AgentAdapter, SpawnOptions, SpawnResult } from './types.js';
+
+/**
+ * Claude CLI Adapter
+ * 
+ * Wraps the Claude Code CLI with proper session handling and output parsing.
+ * 
+ * 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
+ * - `--output-format json`: Structured output (if supported)
+ */
+
+const TIMEZONE = process.env.TZ || 'UTC';
+
+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,
+  });
+}
+
+export class ClaudeAdapter implements AgentAdapter {
+  readonly name = 'claude';
+
+  async spawn(options: SpawnOptions): Promise<SpawnResult> {
+    const { prompt, sessionId, resume, systemPrompt, workingDir } = options;
+
+    const cwd = workingDir || process.env.CLAUDE_WORKING_DIR || process.cwd();
+
+    // Build CLI arguments
+    const args = ['claude'];
+
+    // Non-interactive mode
+    args.push('--print');
+
+    // Output format
+    args.push('--output-format', 'json');
+
+    // 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);
+
+    // 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) {
+      throw new Error(`Claude CLI failed (exit ${exitCode}): ${stderr || 'Unknown error'}`);
+    }
+
+    // Parse JSON output or fall back to raw text
+    let output = stdout.trim();
+    try {
+      const parsed = JSON.parse(stdout);
+      output = parsed.response || parsed.output || stdout.trim();
+    } catch {
+      // Not JSON, use raw output
+      output = stdout.trim();
+    }
+
+    return {
+      output,
+      sessionId,
+    };
+  }
+}

package/src/adapters/codex.ts

@@ -0,0 +1,77 @@
+import type { AgentAdapter, SpawnOptions, SpawnResult } from './types.js';
+
+/**
+ * Codex CLI Adapter
+ * 
+ * Wraps the Codex CLI with session handling and JSON output parsing.
+ * 
+ * Key commands:
+ * - `codex exec "<prompt>"`: Execute a new prompt
+ * - `codex exec resume <sessionId> "<prompt>"`: Resume existing session
+ * - `--json`: Structured output
+ */
+
+export class CodexAdapter implements AgentAdapter {
+  readonly name = 'codex';
+
+  async spawn(options: SpawnOptions): Promise<SpawnResult> {
+    const { prompt, sessionId, resume, workingDir } = options;
+
+    const args = ['codex', 'exec'];
+
+    // Session handling
+    if (resume) {
+      // Resume existing session
+      args.push('resume', sessionId);
+    }
+
+    // JSON output format
+    args.push('--json');
+
+    // The prompt (always last)
+    args.push(prompt);
+
+    // Spawn the process
+    const proc = Bun.spawn(args, {
+      cwd: workingDir || process.cwd(),
+      env: process.env,
+      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) {
+      throw new Error(`Codex CLI failed (exit ${exitCode}): ${stderr || 'Unknown error'}`);
+    }
+
+    // Parse JSON output
+    let output = stdout.trim();
+    let finalSessionId = sessionId;
+
+    try {
+      const parsed = JSON.parse(stdout);
+      output = parsed.output || parsed.response || parsed.result || stdout.trim();
+      
+      // Extract session ID from output (Codex auto-assigns)
+      if (parsed.sessionId) {
+        finalSessionId = parsed.sessionId;
+      } else if (parsed.session_id) {
+        finalSessionId = parsed.session_id;
+      }
+    } catch {
+      // Not JSON, use raw output
+      output = stdout.trim();
+    }
+
+    return {
+      output,
+      sessionId: finalSessionId,
+    };
+  }
+}

package/src/adapters/opencode.ts

@@ -0,0 +1,83 @@
+import type { AgentAdapter, SpawnOptions, SpawnResult } from './types.js';
+
+/**
+ * OpenCode CLI Adapter
+ * 
+ * Wraps the OpenCode CLI with session handling and JSON output parsing.
+ * 
+ * Key flags:
+ * - `run "<prompt>"`: Execute a prompt
+ * - `--session <id>` or `--continue`: Resume existing session
+ * - `--format json`: Structured output
+ * - `--cwd <path>`: Set working directory
+ */
+
+export class OpenCodeAdapter implements AgentAdapter {
+  readonly name = 'opencode';
+
+  async spawn(options: SpawnOptions): Promise<SpawnResult> {
+    const { prompt, sessionId, resume, workingDir } = options;
+
+    const args = ['opencode', 'run'];
+
+    // Format as JSON for structured output
+    args.push('--format', 'json');
+
+    // Session handling
+    if (resume) {
+      // Resume existing session
+      args.push('--session', sessionId);
+    }
+
+    // Working directory
+    if (workingDir) {
+      args.push('--cwd', workingDir);
+    }
+
+    // The prompt (always last)
+    args.push(prompt);
+
+    // Spawn the process
+    const proc = Bun.spawn(args, {
+      cwd: workingDir || process.cwd(),
+      env: process.env,
+      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) {
+      throw new Error(`OpenCode CLI failed (exit ${exitCode}): ${stderr || 'Unknown error'}`);
+    }
+
+    // Parse JSON output
+    let output = stdout.trim();
+    let finalSessionId = sessionId;
+
+    try {
+      const parsed = JSON.parse(stdout);
+      output = parsed.output || parsed.response || parsed.result || stdout.trim();
+      
+      // Extract session ID from output if not resuming
+      if (!resume && parsed.sessionId) {
+        finalSessionId = parsed.sessionId;
+      } else if (!resume && parsed.session_id) {
+        finalSessionId = parsed.session_id;
+      }
+    } catch {
+      // Not JSON, use raw output
+      output = stdout.trim();
+    }
+
+    return {
+      output,
+      sessionId: finalSessionId,
+    };
+  }
+}

package/src/adapters/registry.ts

@@ -0,0 +1,23 @@
+import type { AgentAdapter } from './types.js';
+import { ClaudeAdapter } from './claude.js';
+import { OpenCodeAdapter } from './opencode.js';
+import { CodexAdapter } from './codex.js';
+
+export function getAdapter(type?: string): AgentAdapter {
+  const adapterType = type || process.env.AGENT_TYPE || 'claude';
+  
+  switch (adapterType.toLowerCase()) {
+    case 'claude':
+      return new ClaudeAdapter();
+    case 'opencode':
+      return new OpenCodeAdapter();
+    case 'codex':
+      return new CodexAdapter();
+    default:
+      throw new Error(`Unknown adapter type: ${adapterType}`);
+  }
+}
+
+export function getSupportedAdapters(): string[] {
+  return ['claude', 'opencode', 'codex'];
+}

package/src/adapters/types.ts

@@ -0,0 +1,17 @@
+export interface SpawnOptions {
+  prompt: string;
+  sessionId: string;
+  resume: boolean;
+  systemPrompt?: string;
+  workingDir?: string;
+}
+
+export interface SpawnResult {
+  output: string;
+  sessionId: string;
+}
+
+export interface AgentAdapter {
+  readonly name: string;
+  spawn(options: SpawnOptions): Promise<SpawnResult>;
+}