@siftd/connect-agent 0.2.36 → 0.2.38

package/dist/agent.js

@@ -1,6 +1,11 @@
 import { spawn, execSync } from 'child_process';
+import { createWriteStream } from 'fs';
+import { mkdir, stat } from 'fs/promises';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { basename, join, parse } from 'path';
 import { pollMessages, sendResponse } from './api.js';
-import { getUserId, getAnthropicApiKey, isCloudMode, getDeploymentInfo } from './config.js';
+import { getUserId, getOrgId, getAnthropicApiKey, isCloudMode, getDeploymentInfo, getInstanceMode, getUserOrgIds } from './config.js';
 import { MasterOrchestrator } from './orchestrator.js';
 import { AgentWebSocket } from './websocket.js';
 import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js';
@@ -11,6 +16,97 @@ import { startPreviewWorker, stopPreviewWorker } from './core/preview-worker.js'
 function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
 }
+function parseAttachments(content) {
+    const marker = '📎 Attached files:';
+    const index = content.indexOf(marker);
+    if (index === -1)
+        return [];
+    const lines = content
+        .slice(index + marker.length)
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const attachments = [];
+    for (const line of lines) {
+        const match = line.match(/^(.+?):\s*(https?:\/\/\S+)$/);
+        if (!match)
+            continue;
+        attachments.push({ name: match[1].trim(), url: match[2].trim() });
+    }
+    return attachments;
+}
+function stripAttachmentBlock(content) {
+    const marker = '📎 Attached files:';
+    const index = content.indexOf(marker);
+    if (index === -1)
+        return content;
+    return content.slice(0, index).trim();
+}
+function isSaveIntent(text) {
+    const lower = text.toLowerCase();
+    if (!lower)
+        return true;
+    const analysis = /(analy|summarize|review|explain|inspect|diff|lint|test|build|run)/;
+    if (analysis.test(lower))
+        return false;
+    return /(save|store|archive|upload|attach|add|file|keep)/.test(lower);
+}
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getUniquePath(dir, filename) {
+    const safeName = basename(filename).replace(/[\\/:*?"<>|]/g, '_');
+    const parsed = parse(safeName);
+    let candidate = join(dir, safeName);
+    let counter = 1;
+    while (await fileExists(candidate)) {
+        candidate = join(dir, `${parsed.name}-${counter}${parsed.ext}`);
+        counter += 1;
+    }
+    return candidate;
+}
+function humanizePath(path) {
+    const home = process.env.HOME;
+    if (home && path.startsWith(home)) {
+        return `~${path.slice(home.length)}`;
+    }
+    return path;
+}
+async function saveAttachments(attachments, onProgress) {
+    const home = process.env.HOME || '/tmp';
+    const targetDir = join(home, 'Lia-Hub', 'shared', 'outputs', 'safe-files');
+    await mkdir(targetDir, { recursive: true });
+    const results = [];
+    for (const attachment of attachments) {
+        const targetPath = await getUniquePath(targetDir, attachment.name);
+        onProgress?.(`Saving ${attachment.name}...`);
+        try {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status} ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('Empty response body');
+            }
+            const stream = Readable.fromWeb(response.body);
+            await pipeline(stream, createWriteStream(targetPath));
+            results.push({ name: attachment.name, path: targetPath });
+            onProgress?.(`Saved ${attachment.name} → ${humanizePath(targetPath)}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({ name: attachment.name, path: targetPath, error: message });
+            onProgress?.(`Failed ${attachment.name}: ${message}`);
+        }
+    }
+    return results;
+}
 /**
  * Self-update: npm install latest and auto-restart
  * Called from webapp banner or update command
@@ -62,6 +158,9 @@ function initOrchestrator() {
     // Check env first, then stored config
     const apiKey = process.env.ANTHROPIC_API_KEY || getAnthropicApiKey();
     const userId = getUserId();
+    const orgId = getOrgId();
+    const instanceMode = getInstanceMode();
+    const userOrgIds = getUserOrgIds();
     if (!apiKey) {
         console.log('[AGENT] No API key - using simple relay mode');
         console.log('[AGENT] To enable orchestrator: pair with --api-key flag');
@@ -71,12 +170,21 @@ function initOrchestrator() {
         console.log('[AGENT] No userId configured - using simple relay mode');
         return null;
     }
-    console.log('[AGENT] Initializing Master Orchestrator...');
+    console.log(`[AGENT] Initializing Master Orchestrator (mode: ${instanceMode})...`);
+    if (instanceMode === 'personal' && userOrgIds.length > 0) {
+        console.log(`[AGENT] Personal mode with access to ${userOrgIds.length} team(s): ${userOrgIds.join(', ')}`);
+    }
+    if (instanceMode === 'team' && orgId) {
+        console.log(`[AGENT] Team mode for org: ${orgId}`);
+    }
     return new MasterOrchestrator({
         apiKey,
         userId,
+        orgId: orgId || undefined,
         workspaceDir: process.env.HOME || '/tmp',
-        voyageApiKey: process.env.VOYAGE_API_KEY
+        voyageApiKey: process.env.VOYAGE_API_KEY,
+        instanceMode,
+        userOrgIds: instanceMode === 'personal' ? userOrgIds : undefined,
     });
 }
 /**
@@ -137,6 +245,17 @@ async function sendToOrchestrator(input, orch, messageId, apiKey) {
     if (wsClient?.connected()) {
         wsClient.sendTyping(true);
     }
+    const workerLogHandler = (workerId, line, stream) => {
+        if (!wsClient?.connected() || !messageId)
+            return;
+        const prefix = stream === 'stderr' ? `${workerId} stderr` : workerId;
+        const chunks = line.split(/\r?\n/).map(part => part.trim()).filter(Boolean);
+        for (const chunk of chunks) {
+            const trimmed = chunk.slice(0, 400);
+            wsClient.sendProgress(messageId, `[${prefix}] ${trimmed}`);
+        }
+    };
+    orch.setWorkerLogCallback(workerLogHandler);
     try {
         const response = await orch.processMessage(input, conversationHistory, async (msg) => {
             // Progress callback - log to console and send via WebSocket
@@ -172,6 +291,9 @@ async function sendToOrchestrator(input, orch, messageId, apiKey) {
         }
         return `Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
     }
+    finally {
+        orch.setWorkerLogCallback(null);
+    }
 }
 export async function processMessage(message) {
     console.log(`\n[WEB] >>> ${message.content}`);
@@ -200,6 +322,42 @@ export async function processMessage(message) {
         console.log('[AGENT] === SYSTEM UPDATE COMMAND ===');
         return await performSelfUpdate();
     }
+    const attachments = parseAttachments(message.content);
+    if (attachments.length > 0) {
+        const progress = (msgText) => {
+            if (wsClient?.connected() && message.id) {
+                wsClient.sendProgress(message.id, msgText);
+            }
+        };
+        const results = await saveAttachments(attachments, progress);
+        const saved = results.filter((entry) => !entry.error);
+        const failed = results.filter((entry) => entry.error);
+        const savedLines = saved.map((entry) => `- ${humanizePath(entry.path)}`).join('\n');
+        const failedLines = failed
+            .map((entry) => `- ${entry.name}: ${entry.error}`)
+            .join('\n');
+        const baseText = stripAttachmentBlock(message.content);
+        if (isSaveIntent(baseText)) {
+            const responseLines = [
+                saved.length > 0 ? `Saved ${saved.length} file${saved.length === 1 ? '' : 's'}:` : 'No files saved.',
+                savedLines,
+                failed.length > 0 ? `\nFailed ${failed.length} file${failed.length === 1 ? '' : 's'}:\n${failedLines}` : ''
+            ].filter(Boolean);
+            const response = responseLines.join('\n');
+            conversationHistory.push({ role: 'user', content: message.content });
+            conversationHistory.push({ role: 'assistant', content: response });
+            return response;
+        }
+        const savedNote = [
+            'Saved attachments locally:',
+            savedLines || '- (none)',
+            failed.length > 0 ? `Failed downloads:\n${failedLines}` : ''
+        ].filter(Boolean).join('\n');
+        message = {
+            ...message,
+            content: `${message.content}\n\n${savedNote}`
+        };
+    }
     try {
         if (orchestrator) {
             return await sendToOrchestrator(message.content, orchestrator, message.id, message.apiKey);
@@ -339,19 +497,21 @@ export async function runAgent(pollInterval = 2000) {
         });
         // Keep process alive - WebSocket handles messages
         console.log('[AGENT] Listening for WebSocket messages...\n');
-        // Always poll for messages (socket-store.ts stores messages that WebSocket doesn't see)
+        // Poll only if WebSocket is not connected (WS input is preferred for latency).
         while (true) {
             await new Promise(resolve => setTimeout(resolve, pollInterval));
-            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)`);
+            if (!wsClient?.connected()) {
+                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) {
+                    console.error('[AGENT] Poll error:', error.message);
                 }
-            }
-            catch (error) {
-                console.error('[AGENT] Poll error:', error.message);
             }
         }
     }

package/dist/api.d.ts

@@ -8,6 +8,8 @@ export interface ConnectResponse {
     success: boolean;
     agentToken?: string;
     userId?: string;
+    orgId?: string;
+    orgRole?: 'owner' | 'member';
     error?: string;
 }
 export interface MessagesResponse {

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { program } from 'commander';
 import ora from 'ora';
-import { getServerUrl, setServerUrl, setAgentToken, setUserId, setAnthropicApiKey, getAnthropicApiKey, isConfigured, clearConfig, getConfigPath, } from './config.js';
+import { getServerUrl, setServerUrl, setAgentToken, setUserId, setOrgId, setAnthropicApiKey, getAnthropicApiKey, isConfigured, clearConfig, getConfigPath, } from './config.js';
 import { connectWithPairingCode, checkConnection } from './api.js';
 import { runAgent } from './agent.js';
 import { ensureLiaHub, getLiaHubPaths } from './core/hub.js';
@@ -29,6 +29,9 @@ program
         }
         setAgentToken(result.agentToken);
         setUserId(result.userId);
+        if (result.orgId) {
+            setOrgId(result.orgId);
+        }
         // Store API key if provided
         if (options.apiKey) {
             setAnthropicApiKey(options.apiKey);

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+export type InstanceMode = 'personal' | 'team';
 /**
  * Check if running in cloud mode (environment variables take precedence)
  */
@@ -8,6 +9,12 @@ 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 getOrgId(): string | null;
+export declare function setOrgId(id: string | null): void;
+export declare function getInstanceMode(): InstanceMode;
+export declare function setInstanceMode(mode: InstanceMode | null): void;
+export declare function getUserOrgIds(): string[];
+export declare function setUserOrgIds(ids: string[] | null): void;
 export declare function getAnthropicApiKey(): string | null;
 export declare function setAnthropicApiKey(key: string | null): void;
 export declare function isConfigured(): boolean;

package/dist/config.js

@@ -42,6 +42,46 @@ export function setUserId(id) {
         config.set('userId', id);
     }
 }
+export function getOrgId() {
+    return process.env.CONNECT_ORG_ID || config.get('orgId') || null;
+}
+export function setOrgId(id) {
+    if (id === null) {
+        config.delete('orgId');
+    }
+    else {
+        config.set('orgId', id);
+    }
+}
+export function getInstanceMode() {
+    const mode = process.env.CONNECT_INSTANCE_MODE || config.get('instanceMode');
+    return mode === 'team' ? 'team' : 'personal';
+}
+export function setInstanceMode(mode) {
+    if (mode === null) {
+        config.delete('instanceMode');
+    }
+    else {
+        config.set('instanceMode', mode);
+    }
+}
+export function getUserOrgIds() {
+    // From env: comma-separated list
+    const envOrgIds = process.env.CONNECT_USER_ORG_IDS;
+    if (envOrgIds) {
+        return envOrgIds.split(',').map(id => id.trim()).filter(Boolean);
+    }
+    // From config
+    return config.get('userOrgIds') || [];
+}
+export function setUserOrgIds(ids) {
+    if (ids === null || ids.length === 0) {
+        config.delete('userOrgIds');
+    }
+    else {
+        config.set('userOrgIds', ids);
+    }
+}
 export function getAnthropicApiKey() {
     // Environment variable takes precedence (cloud mode)
     // Note: ANTHROPIC_API_KEY is also checked in orchestrator.ts
@@ -61,6 +101,7 @@ export function isConfigured() {
 export function clearConfig() {
     config.delete('agentToken');
     config.delete('userId');
+    config.delete('orgId');
     config.delete('anthropicApiKey');
 }
 export function getConfigPath() {

package/dist/core/assets.js

@@ -7,6 +7,11 @@
 import { createHash } from 'crypto';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, realpathSync } from 'fs';
 import { basename, extname, join, relative, sep } from 'path';
+const ASSET_MANIFEST_SUFFIX = '.asset.json';
+const ASSET_PREVIEW_SUFFIX = '.preview.json';
+function isAssetMetadataFile(filePath) {
+    return filePath.includes(ASSET_MANIFEST_SUFFIX) || filePath.includes(ASSET_PREVIEW_SUFFIX);
+}
 /**
  * Convert internal manifest to client-safe version (strips path)
  */
@@ -123,6 +128,8 @@ export function createAssetManifest(filePath, options = {}) {
  * Write asset manifest alongside the file
  */
 export function writeAssetManifest(manifest) {
+    if (isAssetMetadataFile(manifest.path))
+        return;
     const manifestPath = manifest.path + '.asset.json';
     writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
 }
@@ -130,7 +137,11 @@ export function writeAssetManifest(manifest) {
  * Read asset manifest for a file
  */
 export function readAssetManifest(filePath) {
-    const manifestPath = filePath + '.asset.json';
+    if (filePath.includes(ASSET_PREVIEW_SUFFIX))
+        return null;
+    const manifestPath = filePath.includes(ASSET_MANIFEST_SUFFIX)
+        ? filePath
+        : filePath + '.asset.json';
     if (!existsSync(manifestPath))
         return null;
     try {

package/dist/core/context-graph.d.ts

@@ -0,0 +1,94 @@
+type MemoryType = 'episodic' | 'semantic' | 'procedural' | 'working';
+type MemoryRecord = {
+    id: string;
+    content: string;
+    timestamp: string;
+    source: string;
+    tags: string[];
+};
+type MemoryStore = {
+    remember: (content: string, options?: {
+        type?: MemoryType;
+        source?: string;
+        importance?: number;
+        tags?: string[];
+    }) => Promise<string>;
+    search: (query: string, options?: {
+        limit?: number;
+        type?: MemoryType;
+        minImportance?: number;
+    }) => Promise<MemoryRecord[]>;
+    findByTags?: (tags: string[], options?: {
+        limit?: number;
+        type?: MemoryType;
+        minImportance?: number;
+    }) => Promise<MemoryRecord[]>;
+};
+export type ContextEntityKind = 'person' | 'team' | 'project' | 'org' | 'role' | 'tool' | 'document' | 'task' | 'system' | 'topic';
+export type ContextRelationKind = 'member_of' | 'leads' | 'works_on' | 'owns' | 'depends_on' | 'blocked_by' | 'related_to' | 'uses' | 'reports_to' | 'supports' | 'delivers_to' | 'requested_by' | 'scheduled_for';
+export type ContextEntity = {
+    key: string;
+    kind: ContextEntityKind;
+    name: string;
+    description?: string;
+    attributes?: Record<string, string>;
+    source?: string;
+    updatedAt: string;
+};
+export type ContextRelation = {
+    from: string;
+    to: string;
+    type: ContextRelationKind;
+    description?: string;
+    source?: string;
+    updatedAt: string;
+};
+type EntityInput = {
+    key?: string;
+    kind: ContextEntityKind;
+    name: string;
+    description?: string;
+    attributes?: Record<string, string>;
+    tags?: string[];
+    source?: string;
+    importance?: number;
+};
+type RelationInput = {
+    from: string;
+    to: string;
+    type: ContextRelationKind;
+    description?: string;
+    source?: string;
+    fromKind?: ContextEntityKind;
+    toKind?: ContextEntityKind;
+};
+export declare class ContextGraph {
+    private memory;
+    private scope;
+    constructor(memory: MemoryStore, options?: {
+        scope?: string;
+    });
+    upsertEntity(input: EntityInput): Promise<ContextEntity>;
+    linkEntities(input: RelationInput): Promise<ContextRelation>;
+    searchEntities(query: string, options?: {
+        limit?: number;
+        kind?: ContextEntityKind;
+    }): Promise<ContextEntity[]>;
+    getRelationsForEntity(key: string, options?: {
+        limit?: number;
+    }): Promise<ContextRelation[]>;
+    getContextSummary(query: string, options?: {
+        limit?: number;
+    }): Promise<string | null>;
+    private normalizeKey;
+    private resolveEntity;
+    private inferKind;
+    private findEntityByKey;
+    private findByTags;
+    private pickMostRecent;
+}
+export declare const ContextGraphKinds: {
+    entities: ContextEntityKind[];
+    relations: ContextRelationKind[];
+};
+export {};