@thesammykins/tether 1.6.0 → 1.7.0

package/bin/tether.ts

@@ -42,7 +42,7 @@ import {
     deleteKey as deleteConfigKey, resolve as resolveConfig, resolveAll,
     isKnownKey, isSecret, getKeyMeta, getKnownKeys, hasSecrets, hasConfig,
     importDotEnv, CONFIG_PATHS,
-} from '../src/config';
+} from '../src/config.js';
 
 const PID_FILE = join(process.cwd(), '.tether.pid');
 const API_BASE = process.env.TETHER_API_URL || 'http://localhost:2643';
@@ -674,6 +674,164 @@ async function updateState() {
 
 // ============ Management Commands ============
 
+async function projectCommand() {
+    const subcommand = args[0];
+
+    switch (subcommand) {
+        case 'add': {
+            const name = args[1];
+            const rawPath = args[2];
+            if (!name || !rawPath) {
+                console.error('Usage: tether project add <name> <path>');
+                process.exit(1);
+            }
+
+            const { resolve: resolvePath } = await import('path');
+            const resolvedPath = resolvePath(rawPath);
+
+            if (!existsSync(resolvedPath)) {
+                console.error(`Error: Path does not exist: ${resolvedPath}`);
+                process.exit(1);
+            }
+
+            try {
+                const response = await fetch(`${API_BASE}/projects`, {
+                    method: 'POST',
+                    headers: buildApiHeaders(),
+                    body: JSON.stringify({ name, path: resolvedPath }),
+                });
+                const data = await response.json() as Record<string, unknown>;
+                if (!response.ok || data.error) {
+                    console.error('Error:', data.error || 'Request failed');
+                    process.exit(1);
+                }
+                console.log(`Project "${name}" added: ${resolvedPath}`);
+            } catch (error: unknown) {
+                const err = error as { code?: string; message?: string };
+                if (err.code === 'ECONNREFUSED') {
+                    console.error('Error: Cannot connect to Tether API. Is the bot running? (tether start)');
+                } else {
+                    console.error('Error:', err.message);
+                }
+                process.exit(1);
+            }
+            break;
+        }
+
+        case 'list': {
+            try {
+                const response = await fetch(`${API_BASE}/projects`, {
+                    headers: buildApiHeaders(),
+                });
+                const projects = await response.json() as Array<{
+                    name: string;
+                    path: string;
+                    is_default: number;
+                }>;
+                if (!response.ok) {
+                    console.error('Error: Failed to list projects');
+                    process.exit(1);
+                }
+                if (projects.length === 0) {
+                    console.log('No projects registered. Add one with: tether project add <name> <path>');
+                    return;
+                }
+                console.log('\nProjects:\n');
+                for (const p of projects) {
+                    const marker = p.is_default ? ' (default)' : '';
+                    console.log(`  ${p.name}${marker}`);
+                    console.log(`    ${p.path}\n`);
+                }
+            } catch (error: unknown) {
+                const err = error as { code?: string; message?: string };
+                if (err.code === 'ECONNREFUSED') {
+                    console.error('Error: Cannot connect to Tether API. Is the bot running? (tether start)');
+                } else {
+                    console.error('Error:', err.message);
+                }
+                process.exit(1);
+            }
+            break;
+        }
+
+        case 'remove': {
+            const name = args[1];
+            if (!name) {
+                console.error('Usage: tether project remove <name>');
+                process.exit(1);
+            }
+
+            try {
+                const response = await fetch(`${API_BASE}/projects/${encodeURIComponent(name)}`, {
+                    method: 'DELETE',
+                    headers: buildApiHeaders(),
+                });
+                const data = await response.json() as Record<string, unknown>;
+                if (!response.ok || data.error) {
+                    console.error('Error:', data.error || 'Request failed');
+                    process.exit(1);
+                }
+                console.log(`Project "${name}" removed.`);
+            } catch (error: unknown) {
+                const err = error as { code?: string; message?: string };
+                if (err.code === 'ECONNREFUSED') {
+                    console.error('Error: Cannot connect to Tether API. Is the bot running? (tether start)');
+                } else {
+                    console.error('Error:', err.message);
+                }
+                process.exit(1);
+            }
+            break;
+        }
+
+        case 'set-default': {
+            const name = args[1];
+            if (!name) {
+                console.error('Usage: tether project set-default <name>');
+                process.exit(1);
+            }
+
+            try {
+                const response = await fetch(`${API_BASE}/projects/${encodeURIComponent(name)}/default`, {
+                    method: 'POST',
+                    headers: buildApiHeaders(),
+                });
+                const data = await response.json() as Record<string, unknown>;
+                if (!response.ok || data.error) {
+                    console.error('Error:', data.error || 'Request failed');
+                    process.exit(1);
+                }
+                console.log(`Project "${name}" set as default.`);
+            } catch (error: unknown) {
+                const err = error as { code?: string; message?: string };
+                if (err.code === 'ECONNREFUSED') {
+                    console.error('Error: Cannot connect to Tether API. Is the bot running? (tether start)');
+                } else {
+                    console.error('Error:', err.message);
+                }
+                process.exit(1);
+            }
+            break;
+        }
+
+        default:
+            console.log(`
+Usage: tether project <subcommand>
+
+Subcommands:
+  add <name> <path>       Register a project (validates path exists)
+  list                    List all registered projects
+  remove <name>           Remove a project
+  set-default <name>      Set a project as the default
+`);
+            if (subcommand) {
+                console.error(`Unknown project subcommand: ${subcommand}`);
+                process.exit(1);
+            }
+            break;
+    }
+}
+
 async function setup() {
     console.log('\n🔌 Tether Setup\n');
 
@@ -1268,6 +1426,7 @@ Management Commands:
   health             Check Distether connection
   setup              Interactive setup wizard
   config             Manage configuration and encrypted secrets
+  project            Manage named projects
   help               Show this help
 
 Distether Commands:
@@ -1349,6 +1508,12 @@ Config Commands:
    config import [path]         Import from .env file (default: ./.env)
    config path                  Show config file locations
 
+Project Commands:
+   project add <name> <path>    Register a named project directory
+   project list                 List all registered projects
+   project remove <name>        Remove a project
+   project set-default <name>   Set a project as the default
+
 Examples:
    tether send 123456789 "Hello world!"
    tether embed 123456789 "Status update" --title "Daily Report" --color green --field "Tasks:5 done:inline"
@@ -1439,6 +1604,9 @@ switch (command) {
     case 'config':
         configCommand();
         break;
+    case 'project':
+        projectCommand();
+        break;
 
     default:
         console.log(`Unknown command: ${command}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thesammykins/tether",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Discord bot that bridges messages to AI agent sessions (Claude, OpenCode, Codex)",
   "license": "MIT",
   "author": "thesammykins",

package/src/adapters/codex.ts

@@ -10,9 +10,12 @@ import { debugLog, debugBlock } from '../debug.js';
  * 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
+ * - `codex exec`: Execute a new prompt (reads from stdin)
+ * - `codex exec resume <sessionId>`: Resume existing session
  * - `--json`: Structured output
+ * 
+ * The prompt is piped via stdin to handle multi-line content with
+ * XML tags and special characters safely.
  */
 
 // Cache resolved binary path
@@ -106,17 +109,15 @@ export class CodexAdapter implements AgentAdapter {
 
     // Session handling
     if (resume) {
-      // Resume existing session
       args.push('resume', sessionId);
     }
 
     // JSON output format
     args.push('--json');
 
-    // The prompt (always last)
-    args.push(prompt);
+    // Prompt is piped via stdin to avoid shell escaping issues with
+    // multi-line prompts containing XML tags, angle brackets, etc.
 
-    // Spawn the process
     const cwd = workingDir || process.cwd();
 
     debugBlock('codex', 'Spawn', {
@@ -124,6 +125,7 @@ export class CodexAdapter implements AgentAdapter {
       args: args.join(' '),
       cwd,
       resume: String(resume),
+      promptLength: String(prompt.length),
     });
 
     let proc: ReturnType<typeof Bun.spawn>;
@@ -131,6 +133,7 @@ export class CodexAdapter implements AgentAdapter {
       proc = Bun.spawn(args, {
         cwd,
         env: process.env,
+        stdin: 'pipe',
         stdout: 'pipe',
         stderr: 'pipe',
       });
@@ -146,6 +149,19 @@ export class CodexAdapter implements AgentAdapter {
       });
     }
 
+    // Write prompt to stdin then close the stream.
+    // Bun.spawn with stdin:'pipe' returns a FileSink.
+    const stdin = proc.stdin;
+    if (!stdin || typeof stdin === 'number') {
+      throw new Error('Failed to get writable stdin from Codex process');
+    }
+    try {
+      stdin.write(prompt);
+      stdin.end();
+    } catch (error) {
+      throw new Error(`Failed to write prompt to Codex stdin: ${error}`);
+    }
+
     // Collect output and handle async spawn failures
     let stdout: string;
     let stderr: string;

package/src/adapters/opencode.ts

@@ -10,10 +10,12 @@ import { debugLog, debugBlock } from '../debug.js';
  * Wraps the OpenCode CLI with session handling and JSON output parsing.
  * 
  * Key flags:
- * - `run "<prompt>"`: Execute a prompt
+ * - `run`: Execute a prompt (reads from stdin or positional args)
  * - `--session <id>` or `--continue`: Resume existing session
- * - `--format json`: Structured output
- * - `--cwd <path>`: Set working directory
+ * - `--format json`: NDJSON event stream output
+ * 
+ * The prompt is piped via stdin to handle multi-line content with
+ * XML tags and special characters safely.
  */
 
 // Cache resolved binary path
@@ -26,6 +28,45 @@ export function _resetBinaryCache(): void {
   cachedBinarySource = 'unknown';
 }
 
+/**
+ * Parse NDJSON event stream from `opencode run --format json`.
+ *
+ * Each line is a JSON object like:
+ *   {"type":"text","sessionID":"ses_xxx","part":{"text":"Hello",...}}
+ *   {"type":"step_start","sessionID":"ses_xxx","part":{...}}
+ *   {"type":"step_finish","sessionID":"ses_xxx","part":{...}}
+ *
+ * We concatenate all "text" event parts and extract the sessionID.
+ */
+function parseNdjsonEvents(raw: string): { text: string; eventSessionId: string | null } {
+  const lines = raw.trim().split('\n').filter(Boolean);
+  const textParts: string[] = [];
+  let eventSessionId: string | null = null;
+
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line) as Record<string, unknown>;
+
+      // Extract sessionID from any event
+      if (!eventSessionId && typeof event.sessionID === 'string') {
+        eventSessionId = event.sessionID;
+      }
+
+      // Collect text content
+      if (event.type === 'text') {
+        const part = event.part as Record<string, unknown> | undefined;
+        if (part && typeof part.text === 'string') {
+          textParts.push(part.text);
+        }
+      }
+    } catch {
+      // Skip non-JSON lines (shouldn't happen with --format json)
+    }
+  }
+
+  return { text: textParts.join(''), eventSessionId };
+}
+
 export class OpenCodeAdapter implements AgentAdapter {
   readonly name = 'opencode';
 
@@ -105,24 +146,20 @@ export class OpenCodeAdapter implements AgentAdapter {
     const binaryPath = await this.getBinaryPath();
     const args = [binaryPath, 'run'];
 
-    // Format as JSON for structured output
+    // Format as JSON for structured output (NDJSON event stream)
     args.push('--format', 'json');
 
     // Session handling
     if (resume) {
-      // Resume existing session
       args.push('--session', sessionId);
     }
 
-    // Working directory
-    if (workingDir) {
-      args.push('--cwd', workingDir);
-    }
+    // Note: opencode has no --cwd flag; working directory is set via
+    // Bun.spawn's cwd option below.
 
-    // The prompt (always last)
-    args.push(prompt);
+    // Prompt is piped via stdin to avoid shell escaping issues with
+    // multi-line prompts containing XML tags, angle brackets, etc.
 
-    // Spawn the process
     const cwd = workingDir || process.cwd();
 
     debugBlock('opencode', 'Spawn', {
@@ -130,6 +167,7 @@ export class OpenCodeAdapter implements AgentAdapter {
       args: args.join(' '),
       cwd,
       resume: String(resume),
+      promptLength: String(prompt.length),
     });
 
     let proc: ReturnType<typeof Bun.spawn>;
@@ -137,6 +175,7 @@ export class OpenCodeAdapter implements AgentAdapter {
       proc = Bun.spawn(args, {
         cwd,
         env: process.env,
+        stdin: 'pipe',
         stdout: 'pipe',
         stderr: 'pipe',
       });
@@ -152,6 +191,19 @@ export class OpenCodeAdapter implements AgentAdapter {
       });
     }
 
+    // Write prompt to stdin then close the stream.
+    // Bun.spawn with stdin:'pipe' returns a FileSink.
+    const stdin = proc.stdin;
+    if (!stdin || typeof stdin === 'number') {
+      throw new Error('Failed to get writable stdin from OpenCode process');
+    }
+    try {
+      stdin.write(prompt);
+      stdin.end();
+    } catch (error) {
+      throw new Error(`Failed to write prompt to OpenCode stdin: ${error}`);
+    }
+
     // Collect output and handle async spawn failures
     let stdout: string;
     let stderr: string;
@@ -178,24 +230,13 @@ export class OpenCodeAdapter implements AgentAdapter {
       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();
-    }
+    // Parse NDJSON event stream from --format json output.
+    // Each line is a JSON object with a "type" field. We extract:
+    // - sessionID from any event (they all carry it)
+    // - text content from "text" type events
+    const { text, eventSessionId } = parseNdjsonEvents(stdout);
+    const output = text || stdout.trim();
+    const finalSessionId = eventSessionId || sessionId;
 
     return {
       output,

package/src/api.ts

@@ -7,6 +7,12 @@
 
 import { Client, TextChannel, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
 import { timingSafeEqual, createHmac } from 'crypto';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import {
+    listProjects, createProject, deleteProject, setProjectDefault,
+    getProject,
+} from './db.js';
 
 const log = (msg: string) => process.stdout.write(`[api] ${msg}\n`);
 
@@ -559,6 +565,110 @@ export function startApiServer(client: Client, port: number = 2643) {
                 }), { headers });
             }
 
+            // --- Project management endpoints ---
+
+            // GET /projects — list all projects
+            if (url.pathname === '/projects' && req.method === 'GET') {
+                const projects = listProjects();
+                return new Response(JSON.stringify(projects), { headers });
+            }
+
+            // POST /projects — create a project
+            if (url.pathname === '/projects' && req.method === 'POST') {
+                try {
+                    const body = await req.json() as {
+                        name?: string;
+                        path?: string;
+                        isDefault?: boolean;
+                    };
+
+                    if (!body.name || !body.path) {
+                        return new Response(JSON.stringify({ error: 'name and path are required' }), {
+                            status: 400,
+                            headers,
+                        });
+                    }
+
+                    // Validate path exists on disk
+                    const resolvedPath = resolve(body.path);
+                    if (!existsSync(resolvedPath)) {
+                        return new Response(JSON.stringify({ error: `Path does not exist: ${resolvedPath}` }), {
+                            status: 400,
+                            headers,
+                        });
+                    }
+
+                    createProject(body.name, resolvedPath, body.isDefault);
+                    const project = getProject(body.name);
+                    log(`Project created: ${body.name} → ${resolvedPath}`);
+                    return new Response(JSON.stringify({ success: true, project }), {
+                        status: 201,
+                        headers,
+                    });
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    // Surface unique constraint violations as 409 Conflict
+                    if (message.includes('UNIQUE constraint')) {
+                        return new Response(JSON.stringify({ error: `Project already exists` }), {
+                            status: 409,
+                            headers,
+                        });
+                    }
+                    log(`Create project error: ${error instanceof Error ? error.stack : message}`);
+                    return new Response(JSON.stringify({ error: 'Internal server error' }), {
+                        status: 500,
+                        headers,
+                    });
+                }
+            }
+
+            // DELETE /projects/:name — delete a project
+            if (url.pathname.startsWith('/projects/') && req.method === 'DELETE') {
+                const name = decodeURIComponent(url.pathname.slice('/projects/'.length).split('/')[0] || '');
+                if (!name) {
+                    return new Response(JSON.stringify({ error: 'Project name is required' }), {
+                        status: 400,
+                        headers,
+                    });
+                }
+
+                const existing = getProject(name);
+                if (!existing) {
+                    return new Response(JSON.stringify({ error: `Project "${name}" not found` }), {
+                        status: 404,
+                        headers,
+                    });
+                }
+
+                deleteProject(name);
+                log(`Project deleted: ${name}`);
+                return new Response(JSON.stringify({ success: true }), { headers });
+            }
+
+            // POST /projects/:name/default — set project as default
+            if (url.pathname.match(/^\/projects\/[^/]+\/default$/) && req.method === 'POST') {
+                const parts = url.pathname.split('/');
+                const name = decodeURIComponent(parts[2] || '');
+                if (!name) {
+                    return new Response(JSON.stringify({ error: 'Project name is required' }), {
+                        status: 400,
+                        headers,
+                    });
+                }
+
+                const existing = getProject(name);
+                if (!existing) {
+                    return new Response(JSON.stringify({ error: `Project "${name}" not found` }), {
+                        status: 404,
+                        headers,
+                    });
+                }
+
+                setProjectDefault(name);
+                log(`Project set as default: ${name}`);
+                return new Response(JSON.stringify({ success: true }), { headers });
+            }
+
             // 404 for unknown routes
             return new Response(JSON.stringify({ error: 'Not found' }), {
                 status: 404,