intent-hub 0.1.0

package/packages/hub/src/server/smart-hub-server.ts

@@ -0,0 +1,374 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import type { 
+  AgentMessage,
+  HubConnectedMessage,
+  HubIntentReceivedMessage,
+  HubIntentAnalyzedMessage,
+  HubLockAcquiredMessage,
+  HubLockBlockedMessage,
+  HubNegotiationStartMessage,
+  HubNegotiationResolvedMessage,
+  HubDecisionRequiredMessage,
+  BroadcastUserJoinedMessage,
+  BroadcastUserLeftMessage,
+  BroadcastLockUpdateMessage,
+} from '@anthropic-for-korea/intent-hub-shared';
+import { 
+  parseMessage, 
+  serializeMessage, 
+  createMessage,
+  generateSessionId,
+} from '@anthropic-for-korea/intent-hub-shared';
+import { SessionManager } from '../state/session-manager.js';
+import { Orchestrator, type OrchestratorConfig, type IntentResponse } from '../core/orchestrator.js';
+import type { LLMProvider } from '../llm/provider.js';
+
+export interface SmartHubServerOptions {
+  port: number;
+  host?: string;
+  llmProvider: LLMProvider;
+  orchestratorConfig?: Partial<OrchestratorConfig>;
+}
+
+export interface ConnectedClient {
+  socket: WebSocket;
+  sessionId: string;
+  userId: string;
+  username: string;
+  projectPath: string;
+  connectedAt: number;
+}
+
+export class SmartHubServer {
+  private wss: WebSocketServer | null = null;
+  private clients: Map<string, ConnectedClient> = new Map();
+  private sessionManager: SessionManager;
+  private orchestrator: Orchestrator;
+
+  constructor(private options: SmartHubServerOptions) {
+    this.sessionManager = new SessionManager();
+    
+    const orchestratorConfig: OrchestratorConfig = {
+      useLLMAnalysis: options.orchestratorConfig?.useLLMAnalysis ?? true,
+      autoNegotiate: options.orchestratorConfig?.autoNegotiate ?? true,
+      conflictThreshold: options.orchestratorConfig?.conflictThreshold ?? 'medium',
+    };
+
+    this.orchestrator = new Orchestrator(
+      options.llmProvider,
+      orchestratorConfig,
+      this.sendNotification.bind(this)
+    );
+  }
+
+  start(): void {
+    this.wss = new WebSocketServer({ 
+      port: this.options.port,
+      host: this.options.host ?? '0.0.0.0',
+    });
+
+    this.wss.on('connection', (socket) => {
+      this.handleConnection(socket);
+    });
+
+    this.wss.on('error', (error) => {
+      console.error('[SmartHub] Server error:', error);
+    });
+
+    console.log(`[SmartHub] Server started on ${this.options.host ?? '0.0.0.0'}:${this.options.port}`);
+  }
+
+  stop(): void {
+    if (this.wss) {
+      for (const client of this.clients.values()) {
+        client.socket.close();
+      }
+      this.clients.clear();
+      this.wss.close();
+      this.wss = null;
+      console.log('[SmartHub] Server stopped');
+    }
+  }
+
+  private handleConnection(socket: WebSocket): void {
+    const tempSessionId = generateSessionId();
+    
+    socket.on('message', async (data) => {
+      const message = parseMessage(data.toString());
+      if (!message) {
+        console.warn('[SmartHub] Invalid message received');
+        return;
+      }
+
+      await this.handleMessage(socket, tempSessionId, message as AgentMessage);
+    });
+
+    socket.on('close', () => {
+      this.handleDisconnection(socket);
+    });
+
+    socket.on('error', (error) => {
+      console.error(`[SmartHub] Socket error:`, error);
+    });
+  }
+
+  private async handleMessage(socket: WebSocket, tempSessionId: string, message: AgentMessage): Promise<void> {
+    if (message.type === 'agent:connect') {
+      const sessionId = generateSessionId();
+      const client: ConnectedClient = {
+        socket,
+        sessionId,
+        userId: message.payload.userId,
+        username: message.payload.username,
+        projectPath: message.payload.projectPath,
+        connectedAt: Date.now(),
+      };
+
+      this.clients.set(sessionId, client);
+      this.sessionManager.addSession(sessionId, client.userId, client.username);
+
+      const status = this.orchestrator.getStatus();
+      const response = createMessage<HubConnectedMessage>('hub:connected', {
+        payload: {
+          sessionId,
+          activeLocks: [],
+        },
+      });
+      this.sendToClient(sessionId, response);
+
+      const joinBroadcast = createMessage<BroadcastUserJoinedMessage>('broadcast:user:joined', {
+        payload: {
+          userId: client.userId,
+          username: client.username,
+        },
+      });
+      this.broadcastExcept(sessionId, joinBroadcast);
+
+      console.log(`[SmartHub] Client connected: ${client.username} (${sessionId})`);
+      return;
+    }
+
+    const client = this.findClientBySocket(socket);
+    if (!client) {
+      console.warn('[SmartHub] Message from unknown client');
+      return;
+    }
+
+    if (message.type === 'agent:intent:submit') {
+      await this.handleIntentSubmit(client, message.payload.prompt);
+    } else if (message.type === 'agent:decision') {
+      console.log(`[SmartHub] Decision from ${client.username}: ${message.payload.choice}`);
+    }
+  }
+
+  private async handleIntentSubmit(client: ConnectedClient, prompt: string): Promise<void> {
+    const receivedMsg = createMessage<HubIntentReceivedMessage>('hub:intent:received', {
+      payload: { intentId: 'pending' },
+    });
+    this.sendToClient(client.sessionId, receivedMsg);
+
+    try {
+      const response = await this.orchestrator.processIntent({
+        sessionId: client.sessionId,
+        userId: client.userId,
+        username: client.username,
+        prompt,
+      });
+
+      this.sendIntentResponse(client, response);
+      this.broadcastLockUpdate();
+
+    } catch (error) {
+      console.error('[SmartHub] Error processing intent:', error);
+    }
+  }
+
+  private sendIntentResponse(client: ConnectedClient, response: IntentResponse): void {
+    const analyzedMsg = createMessage<HubIntentAnalyzedMessage>('hub:intent:analyzed', {
+      payload: {
+        intentId: response.intentId,
+        analysis: {
+          domain: response.analysis.domain,
+          subdomain: response.analysis.subdomain,
+          affectedFiles: response.analysis.affectedFiles,
+          semanticTags: response.analysis.semanticTags,
+        },
+      },
+    });
+    this.sendToClient(client.sessionId, analyzedMsg);
+
+    if (response.status === 'approved') {
+      const acquiredMsg = createMessage<HubLockAcquiredMessage>('hub:lock:acquired', {
+        payload: {
+          intentId: response.intentId,
+          domains: response.domains,
+        },
+      });
+      this.sendToClient(client.sessionId, acquiredMsg);
+      console.log(`[SmartHub] ${client.username} acquired lock on ${response.domains.join(', ')}`);
+    } 
+    else if (response.status === 'blocked') {
+      const blockedMsg = createMessage<HubLockBlockedMessage>('hub:lock:blocked', {
+        payload: {
+          intentId: response.intentId,
+          blockedBy: (response.blockedBy || []).map(b => ({
+            domain: b.domain,
+            username: b.username,
+            intentSummary: b.reason,
+          })),
+        },
+      });
+      this.sendToClient(client.sessionId, blockedMsg);
+      console.log(`[SmartHub] ${client.username} blocked: ${response.blockedBy?.map(b => b.reason).join(', ')}`);
+    }
+    else if (response.status === 'negotiating' && response.negotiation) {
+      if (response.negotiation.status === 'agreed') {
+        const resolvedMsg = createMessage<HubNegotiationResolvedMessage>('hub:negotiation:resolved', {
+          payload: {
+            conflictId: response.negotiation.conflictId,
+            resolution: {
+              type: 'auto',
+              summary: response.negotiation.proposals.map(p => p.proposal).join(' / '),
+              yourPhase: response.negotiation.plan?.phases.findIndex(p => p.userId === client.userId) ?? 0,
+            },
+          },
+        });
+        this.sendToClient(client.sessionId, resolvedMsg);
+      }
+    }
+    else if (response.status === 'pending_decision' && response.negotiation) {
+      const decisionMsg = createMessage<HubDecisionRequiredMessage>('hub:decision:required', {
+        payload: {
+          conflictId: response.negotiation.conflictId,
+          question: response.negotiation.disagreementReason || 'How should this conflict be resolved?',
+          options: response.negotiation.options || [],
+        },
+      });
+      this.sendToClient(client.sessionId, decisionMsg);
+    }
+  }
+
+  private sendNotification(sessionId: string, event: string, data: any): void {
+    const client = this.clients.get(sessionId);
+    if (!client) {
+      for (const [sid, c] of this.clients) {
+        if (c.sessionId === sessionId || c.userId === sessionId) {
+          this.sendNotificationToClient(c, event, data);
+          return;
+        }
+      }
+      return;
+    }
+    this.sendNotificationToClient(client, event, data);
+  }
+
+  private sendNotificationToClient(client: ConnectedClient, event: string, data: any): void {
+    if (event === 'negotiation:start') {
+      const msg = createMessage<HubNegotiationStartMessage>('hub:negotiation:start', {
+        payload: {
+          conflictId: data.conflictId,
+          participants: [data.withUser],
+          domains: [],
+        },
+      });
+      this.sendToClient(client.sessionId, msg);
+    } else if (event === 'negotiation:resolved') {
+      const msg = createMessage<HubNegotiationResolvedMessage>('hub:negotiation:resolved', {
+        payload: {
+          conflictId: data.conflictId,
+          resolution: {
+            type: 'auto',
+            summary: data.message,
+            yourPhase: data.result === 'proceed' ? 1 : 2,
+          },
+        },
+      });
+      this.sendToClient(client.sessionId, msg);
+    } else if (event === 'decision:required') {
+      const msg = createMessage<HubDecisionRequiredMessage>('hub:decision:required', {
+        payload: {
+          conflictId: data.conflictId,
+          question: data.reason,
+          options: data.options,
+        },
+      });
+      this.sendToClient(client.sessionId, msg);
+    }
+  }
+
+  private broadcastLockUpdate(): void {
+    const status = this.orchestrator.getStatus();
+    const msg = createMessage<BroadcastLockUpdateMessage>('broadcast:lock:update', {
+      payload: {
+        locks: [],
+      },
+    });
+    this.broadcast(msg);
+  }
+
+  private handleDisconnection(socket: WebSocket): void {
+    for (const [sessionId, client] of this.clients) {
+      if (client.socket === socket) {
+        this.sessionManager.removeSession(sessionId);
+        this.clients.delete(sessionId);
+
+        const leaveBroadcast = createMessage<BroadcastUserLeftMessage>('broadcast:user:left', {
+          payload: {
+            userId: client.userId,
+            username: client.username,
+          },
+        });
+        this.broadcast(leaveBroadcast);
+
+        console.log(`[SmartHub] Client disconnected: ${client.username} (${sessionId})`);
+        return;
+      }
+    }
+  }
+
+  private findClientBySocket(socket: WebSocket): ConnectedClient | undefined {
+    for (const client of this.clients.values()) {
+      if (client.socket === socket) {
+        return client;
+      }
+    }
+    return undefined;
+  }
+
+  private sendToClient(sessionId: string, message: any): void {
+    const client = this.clients.get(sessionId);
+    if (client && client.socket.readyState === WebSocket.OPEN) {
+      client.socket.send(serializeMessage(message));
+    }
+  }
+
+  private broadcast(message: any): void {
+    const serialized = serializeMessage(message);
+    for (const client of this.clients.values()) {
+      if (client.socket.readyState === WebSocket.OPEN) {
+        client.socket.send(serialized);
+      }
+    }
+  }
+
+  private broadcastExcept(excludeSessionId: string, message: any): void {
+    const serialized = serializeMessage(message);
+    for (const [sessionId, client] of this.clients) {
+      if (sessionId !== excludeSessionId && client.socket.readyState === WebSocket.OPEN) {
+        client.socket.send(serialized);
+      }
+    }
+  }
+
+  getConnectedClients(): ConnectedClient[] {
+    return Array.from(this.clients.values());
+  }
+
+  getClientCount(): number {
+    return this.clients.size;
+  }
+
+  getOrchestratorStatus(): ReturnType<Orchestrator['getStatus']> {
+    return this.orchestrator.getStatus();
+  }
+}

package/packages/hub/src/state/index.ts

@@ -0,0 +1 @@
+export { SessionManager } from './session-manager.js';

package/packages/hub/src/state/session-manager.ts

@@ -0,0 +1,59 @@
+export interface Session {
+  sessionId: string;
+  userId: string;
+  username: string;
+  connectedAt: number;
+  lastActiveAt: number;
+}
+
+export class SessionManager {
+  private sessions: Map<string, Session> = new Map();
+
+  addSession(sessionId: string, userId: string, username: string): Session {
+    const session: Session = {
+      sessionId,
+      userId,
+      username,
+      connectedAt: Date.now(),
+      lastActiveAt: Date.now(),
+    };
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+
+  removeSession(sessionId: string): boolean {
+    return this.sessions.delete(sessionId);
+  }
+
+  getSession(sessionId: string): Session | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  getSessionByUserId(userId: string): Session | undefined {
+    for (const session of this.sessions.values()) {
+      if (session.userId === userId) {
+        return session;
+      }
+    }
+    return undefined;
+  }
+
+  getAllSessions(): Session[] {
+    return Array.from(this.sessions.values());
+  }
+
+  updateLastActive(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.lastActiveAt = Date.now();
+    }
+  }
+
+  getActiveUserCount(): number {
+    return this.sessions.size;
+  }
+
+  getActiveUsernames(): string[] {
+    return Array.from(this.sessions.values()).map(s => s.username);
+  }
+}

package/packages/hub/src/tunnel/index.ts

@@ -0,0 +1,153 @@
+import { spawn } from 'child_process';
+import { randomBytes } from 'crypto';
+
+export interface TunnelOptions {
+  port: number;
+  subdomain?: string;
+  provider?: 'localtunnel' | 'cloudflared' | 'auto';
+}
+
+export interface TunnelResult {
+  url: string;
+  wsUrl: string;
+  provider: string;
+  close: () => Promise<void>;
+}
+
+function generateSubdomain(): string {
+  const id = randomBytes(4).toString('hex');
+  return `intent-hub-${id}`;
+}
+
+async function commandExists(cmd: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const process = spawn('which', [cmd], { stdio: 'ignore' });
+    process.on('close', (code) => resolve(code === 0));
+    process.on('error', () => resolve(false));
+  });
+}
+
+async function createLocaltunnel(options: TunnelOptions): Promise<TunnelResult> {
+  const localtunnel = await import('localtunnel').then(m => m.default);
+  
+  const subdomain = options.subdomain ?? generateSubdomain();
+  
+  const tunnel = await localtunnel({
+    port: options.port,
+    subdomain,
+    allow_invalid_cert: true,
+  });
+
+  const url = tunnel.url;
+  const wsUrl = url.replace('https://', 'wss://').replace('http://', 'ws://');
+
+  return {
+    url,
+    wsUrl,
+    provider: 'localtunnel',
+    close: async () => {
+      tunnel.close();
+    },
+  };
+}
+
+async function createCloudflaredTunnel(options: TunnelOptions): Promise<TunnelResult> {
+  return new Promise((resolve, reject) => {
+    const process = spawn('cloudflared', [
+      'tunnel',
+      '--url',
+      `http://localhost:${options.port}`,
+      '--no-autoupdate',
+    ], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let resolved = false;
+
+    const handleOutput = (data: Buffer) => {
+      const output = data.toString();
+      const match = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+      if (match && !resolved) {
+        resolved = true;
+        const url = match[0];
+        const wsUrl = url.replace('https://', 'wss://');
+        resolve({
+          url,
+          wsUrl,
+          provider: 'cloudflared',
+          close: async () => {
+            process.kill('SIGTERM');
+          },
+        });
+      }
+    };
+
+    process.stdout?.on('data', handleOutput);
+    process.stderr?.on('data', handleOutput);
+
+    process.on('error', (err) => {
+      if (!resolved) {
+        reject(new Error(`Failed to start cloudflared: ${err.message}`));
+      }
+    });
+
+    process.on('close', (code) => {
+      if (!resolved) {
+        reject(new Error(`cloudflared exited with code ${code}`));
+      }
+    });
+
+    setTimeout(() => {
+      if (!resolved) {
+        process.kill('SIGTERM');
+        reject(new Error('Timeout waiting for cloudflared tunnel'));
+      }
+    }, 30000);
+  });
+}
+
+export async function createTunnel(options: TunnelOptions): Promise<TunnelResult> {
+  const provider = options.provider ?? 'auto';
+
+  if (provider === 'cloudflared' || provider === 'auto') {
+    const hasCloudflared = await commandExists('cloudflared');
+    if (hasCloudflared) {
+      try {
+        return await createCloudflaredTunnel(options);
+      } catch (err) {
+        if (provider === 'cloudflared') {
+          throw err;
+        }
+        console.log('[Tunnel] cloudflared failed, falling back to localtunnel');
+      }
+    }
+  }
+
+  if (provider === 'localtunnel' || provider === 'auto') {
+    try {
+      return await createLocaltunnel(options);
+    } catch (err) {
+      throw new Error(`Failed to create tunnel: ${err}`);
+    }
+  }
+
+  throw new Error(`Unknown tunnel provider: ${provider}`);
+}
+
+export function printShareInfo(tunnel: TunnelResult): void {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                    🔗 SHARE YOUR SESSION                      ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Team members can connect using:                              ║
+║                                                               ║
+║  ${tunnel.wsUrl.padEnd(61)}║
+║                                                               ║
+║  Provider: ${tunnel.provider.padEnd(52)}║
+║                                                               ║
+║  Copy and share this URL with your team!                      ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+}

package/packages/hub/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/shared/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+$ bun build ./src/index.ts --outdir ./dist --target node && tsc --emitDeclarationOnly
+Bundled 8 modules in 2ms
+
+  index.js  1.0 KB  (entry point)
+

package/packages/shared/.turbo/turbo-typecheck.log

@@ -0,0 +1 @@
+$ tsc --noEmit

package/packages/shared/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types/index.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/shared/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}

package/packages/shared/dist/index.js

@@ -0,0 +1,50 @@
+// src/utils/id.ts
+import { randomUUID } from "crypto";
+function generateId() {
+  return randomUUID();
+}
+function generateMessageId() {
+  return `msg_${randomUUID()}`;
+}
+function generateIntentId() {
+  return `int_${randomUUID()}`;
+}
+function generateConflictId() {
+  return `cnf_${randomUUID()}`;
+}
+function generateSessionId() {
+  return `ses_${randomUUID()}`;
+}
+// src/utils/message.ts
+function createMessage(type, payload) {
+  return {
+    type,
+    timestamp: Date.now(),
+    messageId: generateMessageId(),
+    ...payload
+  };
+}
+function parseMessage(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (typeof parsed.type === "string" && typeof parsed.timestamp === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function serializeMessage(message2) {
+  return JSON.stringify(message2);
+}
+export {
+  serializeMessage,
+  parseMessage,
+  generateSessionId,
+  generateMessageId,
+  generateIntentId,
+  generateId,
+  generateConflictId,
+  createMessage
+};