@siftd/connect-agent 0.1.0

package/dist/agent.d.ts

@@ -0,0 +1,3 @@
+import { Message } from './api.js';
+export declare function processMessage(message: Message): Promise<string>;
+export declare function runAgent(pollInterval?: number): Promise<void>;

package/dist/agent.js

@@ -0,0 +1,90 @@
+import { spawn } from 'child_process';
+import { pollMessages, sendResponse } from './api.js';
+// Strip ANSI escape codes for clean output
+function stripAnsi(str) {
+    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+/**
+ * Send a message to Claude Code and get the response
+ * Uses --continue to maintain conversation context
+ */
+async function sendToClaude(input) {
+    return new Promise((resolve, reject) => {
+        console.log(`\n[CLAUDE] Sending: ${input.substring(0, 80)}...`);
+        // Use -p (print mode) with --continue to maintain context
+        const claude = spawn('claude', ['-p', '--continue'], {
+            cwd: process.env.HOME,
+            env: process.env,
+            shell: true,
+        });
+        let output = '';
+        let errorOutput = '';
+        claude.stdout?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            process.stdout.write(text);
+        });
+        claude.stderr?.on('data', (data) => {
+            const text = data.toString();
+            errorOutput += text;
+            // Only print stderr if it's not just status info
+            if (!text.includes('Checking') && !text.includes('Connected')) {
+                process.stderr.write(text);
+            }
+        });
+        claude.on('close', (code) => {
+            if (code === 0) {
+                const response = stripAnsi(output).trim();
+                console.log(`\n[CLAUDE] Response: ${response.substring(0, 80)}...`);
+                resolve(response || 'No response from Claude');
+            }
+            else {
+                const error = errorOutput || `Claude exited with code ${code}`;
+                console.error(`\n[CLAUDE] Error: ${error}`);
+                resolve(`Error: ${stripAnsi(error).trim()}`);
+            }
+        });
+        claude.on('error', (err) => {
+            console.error(`\n[CLAUDE] Failed to start: ${err.message}`);
+            resolve(`Error: Failed to start Claude - ${err.message}`);
+        });
+        // Send the input to claude's stdin
+        if (claude.stdin) {
+            claude.stdin.write(input);
+            claude.stdin.end();
+        }
+    });
+}
+export async function processMessage(message) {
+    console.log(`\n[WEB] >>> ${message.content}`);
+    try {
+        const response = await sendToClaude(message.content);
+        return response;
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return `Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
+    }
+}
+export async function runAgent(pollInterval = 2000) {
+    console.log('╔══════════════════════════════════════════╗');
+    console.log('║  Connect Agent - Claude Code Relay       ║');
+    console.log('╚══════════════════════════════════════════╝\n');
+    console.log('[AGENT] Polling for web messages...\n');
+    while (true) {
+        try {
+            const { messages } = await pollMessages();
+            for (const msg of messages) {
+                const response = await processMessage(msg);
+                await sendResponse(msg.id, response);
+                console.log(`[AGENT] Response sent (${response.length} chars)`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && !error.message.includes('ECONNREFUSED')) {
+                console.error('[AGENT] Poll error:', error.message);
+            }
+        }
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+}

package/dist/api.d.ts

@@ -0,0 +1,22 @@
+export interface Message {
+    id: string;
+    content: string;
+    timestamp: number;
+}
+export interface ConnectResponse {
+    success: boolean;
+    agentToken?: string;
+    userId?: string;
+    error?: string;
+}
+export interface MessagesResponse {
+    messages: Message[];
+}
+export interface RespondResponse {
+    success: boolean;
+    error?: string;
+}
+export declare function connectWithPairingCode(code: string): Promise<ConnectResponse>;
+export declare function pollMessages(): Promise<MessagesResponse>;
+export declare function sendResponse(messageId: string, response: string): Promise<RespondResponse>;
+export declare function checkConnection(): Promise<boolean>;

package/dist/api.js

@@ -0,0 +1,48 @@
+import { getServerUrl, getAgentToken } from './config.js';
+async function fetchWithAuth(path, options = {}) {
+    const serverUrl = getServerUrl();
+    const agentToken = getAgentToken();
+    const headers = {
+        'Content-Type': 'application/json',
+        ...options.headers,
+    };
+    if (agentToken) {
+        headers['Authorization'] = `Bearer ${agentToken}`;
+    }
+    return fetch(`${serverUrl}${path}`, {
+        ...options,
+        headers,
+    });
+}
+export async function connectWithPairingCode(code) {
+    const serverUrl = getServerUrl();
+    const res = await fetch(`${serverUrl}/api/agent/connect`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ pairingCode: code }),
+    });
+    return res.json();
+}
+export async function pollMessages() {
+    const res = await fetchWithAuth('/api/agent/messages');
+    if (!res.ok) {
+        throw new Error(`Failed to poll messages: ${res.status}`);
+    }
+    return res.json();
+}
+export async function sendResponse(messageId, response) {
+    const res = await fetchWithAuth('/api/agent/respond', {
+        method: 'POST',
+        body: JSON.stringify({ messageId, response }),
+    });
+    return res.json();
+}
+export async function checkConnection() {
+    try {
+        const res = await fetchWithAuth('/api/agent/messages');
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import ora from 'ora';
+import { getServerUrl, setServerUrl, setAgentToken, setUserId, isConfigured, clearConfig, getConfigPath, } from './config.js';
+import { connectWithPairingCode, checkConnection } from './api.js';
+import { runAgent } from './agent.js';
+program
+    .name('connect-agent')
+    .description('Local agent for Connect web app')
+    .version('0.1.0');
+program
+    .command('pair')
+    .description('Pair with Connect web app using a pairing code')
+    .argument('<code>', 'The 6-character pairing code from the web app')
+    .option('-s, --server <url>', 'Server URL', getServerUrl())
+    .action(async (code, options) => {
+    const spinner = ora('Connecting to server...').start();
+    try {
+        if (options.server !== getServerUrl()) {
+            setServerUrl(options.server);
+        }
+        const result = await connectWithPairingCode(code.toUpperCase());
+        if (!result.success) {
+            spinner.fail(`Pairing failed: ${result.error}`);
+            process.exit(1);
+        }
+        setAgentToken(result.agentToken);
+        setUserId(result.userId);
+        spinner.succeed('Paired successfully!');
+        console.log(`\nAgent is now connected to ${getServerUrl()}`);
+        console.log('Run "connect-agent start" to begin processing messages.');
+    }
+    catch (error) {
+        spinner.fail(`Connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+program
+    .command('start')
+    .description('Start the agent and begin processing messages')
+    .option('-i, --interval <ms>', 'Poll interval in milliseconds', '2000')
+    .action(async (options) => {
+    if (!isConfigured()) {
+        console.error('Agent not configured. Run "connect-agent pair <code>" first.');
+        process.exit(1);
+    }
+    const spinner = ora('Checking connection...').start();
+    const connected = await checkConnection();
+    if (!connected) {
+        spinner.fail('Cannot connect to server. Check your configuration.');
+        process.exit(1);
+    }
+    spinner.succeed('Connected to server');
+    console.log(`\nServer: ${getServerUrl()}`);
+    console.log(`Poll interval: ${options.interval}ms`);
+    console.log('\nPress Ctrl+C to stop.\n');
+    await runAgent(parseInt(options.interval, 10));
+});
+program
+    .command('status')
+    .description('Show agent configuration status')
+    .action(async () => {
+    console.log('Connect Agent Status\n');
+    console.log(`Config file: ${getConfigPath()}`);
+    console.log(`Server URL: ${getServerUrl()}`);
+    console.log(`Configured: ${isConfigured() ? 'Yes' : 'No'}`);
+    if (isConfigured()) {
+        const spinner = ora('Checking connection...').start();
+        const connected = await checkConnection();
+        if (connected) {
+            spinner.succeed('Server connection: OK');
+        }
+        else {
+            spinner.fail('Server connection: Failed');
+        }
+    }
+});
+program
+    .command('logout')
+    .description('Clear agent configuration')
+    .action(() => {
+    clearConfig();
+    console.log('Agent configuration cleared.');
+});
+program
+    .command('server')
+    .description('Set the server URL')
+    .argument('<url>', 'The server URL')
+    .action((url) => {
+    setServerUrl(url);
+    console.log(`Server URL set to: ${url}`);
+});
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+export declare function getServerUrl(): string;
+export declare function setServerUrl(url: string): void;
+export declare function getAgentToken(): string | null;
+export declare function setAgentToken(token: string | null): void;
+export declare function getUserId(): string | null;
+export declare function setUserId(id: string | null): void;
+export declare function isConfigured(): boolean;
+export declare function clearConfig(): void;
+export declare function getConfigPath(): string;

package/dist/config.js

@@ -0,0 +1,45 @@
+import Conf from 'conf';
+const config = new Conf({
+    projectName: 'connect-agent',
+    defaults: {
+        serverUrl: 'https://connect.siftd.app',
+    },
+});
+export function getServerUrl() {
+    return config.get('serverUrl');
+}
+export function setServerUrl(url) {
+    config.set('serverUrl', url);
+}
+export function getAgentToken() {
+    return config.get('agentToken') ?? null;
+}
+export function setAgentToken(token) {
+    if (token === null) {
+        config.delete('agentToken');
+    }
+    else {
+        config.set('agentToken', token);
+    }
+}
+export function getUserId() {
+    return config.get('userId') ?? null;
+}
+export function setUserId(id) {
+    if (id === null) {
+        config.delete('userId');
+    }
+    else {
+        config.set('userId', id);
+    }
+}
+export function isConfigured() {
+    return !!getAgentToken() && !!getUserId();
+}
+export function clearConfig() {
+    config.delete('agentToken');
+    config.delete('userId');
+}
+export function getConfigPath() {
+    return config.path;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config.js';
+export * from './api.js';
+export * from './agent.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './config.js';
+export * from './api.js';
+export * from './agent.js';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@siftd/connect-agent",
+  "version": "0.1.0",
+  "description": "Local agent that connects to Connect web app - control Claude Code remotely",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "connect-agent": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "agent",
+    "cli",
+    "connect",
+    "claude",
+    "remote",
+    "terminal"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/james-m-jordan/connect-app.git",
+    "directory": "packages/agent"
+  },
+  "author": "Jim Jordan",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}