@thesammykins/tether 1.6.1 → 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.1",
+  "version": "1.7.0",
   "description": "Discord bot that bridges messages to AI agent sessions (Claude, OpenCode, Codex)",
   "license": "MIT",
   "author": "thesammykins",

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,