@tyvm/knowhow 0.0.71 → 0.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.71",
+  "version": "0.0.72",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {

package/src/agents/tools/startAgentTask.ts

@@ -139,12 +139,12 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
 
     const syncFsNote = syncFs
       ? `\nTask ID: ${taskId}\nAgent dir: ${agentTaskDir}\n` +
-        `To send follow-up messages, write to: ${agentTaskDir}/input.txt\n` +
+        `To send agent messages, write to: ${agentTaskDir}/input.txt\n` +
         `To check status, read: ${agentTaskDir}/status.txt\n`
       : "";
 
-    // Give the agent 30 seconds to finish before detaching
-    const detachTime = 30 * 1000; // 30 seconds
+    // Give the agent 5 seconds to finish before detaching
+    const detachTime = 5 * 1000;
     const tid = setTimeout(() => {
       try { child.unref(); } catch {}
       done(

package/src/ai.ts

@@ -25,9 +25,19 @@ export function readPromptFile(promptFile: string, input: string) {
     if (fs.existsSync(promptFile)) {
       const promptTemplate = fs.readFileSync(promptFile, "utf-8");
       if (promptTemplate.includes("{text}")) {
-        return promptTemplate.replaceAll("{text}", input);
+        // Only replace if input is provided
+        if (input) {
+          return promptTemplate.replaceAll("{text}", input);
+        }
+        // If no input provided but template expects it, return template as-is
+        // This allows the calling code to handle the missing input
+        return promptTemplate;
       } else {
-        return `${promptTemplate}\n\n${input}`;
+        // Template doesn't have {text}, so input is optional
+        if (input) {
+          return `${promptTemplate}\n\n${input}`;
+        }
+        return promptTemplate;
       }
     }
   }

package/src/chat/modules/AgentModule.ts

@@ -528,6 +528,10 @@ Please continue from where you left off and complete the original request.
       // Save initial session
       this.saveSession(taskId, taskInfo, []);
 
+      // Reset sync services before setting up new task (removes old listeners)
+      this.webSync.reset();
+      this.fsSync.reset();
+
       // Create Knowhow chat task if messageId provided
       if (
         options.messageId &&
@@ -566,13 +570,11 @@ Please continue from where you left off and complete the original request.
       }
 
       // Set up session update listener
-      agent.agentEvents.on(
-        agent.eventTypes.threadUpdate,
-        async (threadState) => {
-          this.updateSession(taskId, threadState);
-          taskInfo.totalCost = agent.getTotalCostUsd();
-        }
-      );
+      const threadUpdateHandler = async (threadState: any) => {
+        this.updateSession(taskId, threadState);
+        taskInfo.totalCost = agent.getTotalCostUsd();
+      };
+      agent.agentEvents.on(agent.eventTypes.threadUpdate, threadUpdateHandler);
 
       console.log(
         Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`)
@@ -665,6 +667,8 @@ Please continue from where you left off and complete the original request.
           console.log("🎯 [AgentModule] Task Completed");
           done = true;
           output = doneMsg || "No response from the AI";
+          // Remove threadUpdate listener to prevent cost sharing across tasks
+          agent.agentEvents.removeListener(agent.eventTypes.threadUpdate, threadUpdateHandler);
           // Update task info
           taskInfo = this.taskRegistry.get(taskId);
 

package/src/cli.ts

@@ -15,6 +15,7 @@ import * as allTools from "./agents/tools";
 import { LazyToolsService, services } from "./services";
 import { login } from "./login";
 import { worker } from "./worker";
+import { fileSync } from "./fileSync";
 import {
   startAllWorkers,
   listWorkerPaths,
@@ -211,18 +212,23 @@ async function main() {
       try {
         await setupServices();
         let input = options.input;
-        if (!input) {
+
+        // Only read from stdin if we don't have input and don't have a standalone prompt file
+        if (!input && !options.promptFile) {
           input = await readStdin();
-          if (!input) {
-            console.error(
-              "Error: No input provided. Use --input flag or pipe input via stdin."
-            );
-            process.exit(1);
-          }
         }
 
+        // Read prompt file - it will handle cases where input is empty
         input = readPromptFile(options.promptFile, input);
 
+        // Only error if we have no prompt file and no input
+        if (!input) {
+          console.error(
+            "Error: No input provided. Use --input flag, pipe input via stdin, or provide --prompt-file."
+          );
+          process.exit(1);
+        }
+
         const agentModule = new AgentModule();
         await agentModule.initialize(chatService);
         const { taskCompleted } = await agentModule.setupAgent({
@@ -250,18 +256,23 @@ async function main() {
       try {
         await setupServices();
         let input = options.input;
-        if (!input) {
+
+        // Only read from stdin if we don't have input and don't have a standalone prompt file
+        if (!input && !options.promptFile) {
           input = await readStdin();
-          if (!input) {
-            console.error(
-              "Error: No question provided. Use --input flag or pipe input via stdin."
-            );
-            process.exit(1);
-          }
         }
 
+        // Read prompt file - it will handle cases where input is empty
         input = readPromptFile(options.promptFile, input);
 
+        // Only error if we have no prompt file and no input
+        if (!input) {
+          console.error(
+            "Error: No question provided. Use --input flag, pipe input via stdin, or provide --prompt-file."
+          );
+          process.exit(1);
+        }
+
         const askModule = new AskModule();
         await askModule.initialize(chatService);
         await askModule.processAIQuery(input, {
@@ -358,6 +369,22 @@ async function main() {
       await worker(options);
     });
 
+  program
+    .command("files")
+    .description("Sync files between local filesystem and Knowhow FS (uses fileMounts config)")
+    .option("--upload", "Force upload direction for all mounts")
+    .option("--download", "Force download direction for all mounts")
+    .option("--config <path>", "Path to knowhow.json", "./knowhow.json")
+    .option("--dry-run", "Print what would be synced without doing it")
+    .action(async (options) => {
+      try {
+        await fileSync(options);
+      } catch (error) {
+        console.error("Error syncing files:", error);
+        process.exit(1);
+      }
+    });
+
   program
     .command("workers")
     .description("Manage and start all registered workers")

package/src/fileSync.ts

@@ -0,0 +1,165 @@
+import * as fs from "fs";
+import * as path from "path";
+import { KnowhowSimpleClient, KNOWHOW_API_URL } from "./services/KnowhowClient";
+import { loadJwt } from "./login";
+import { getConfig } from "./config";
+import { services } from "./services";
+import { S3Service } from "./services/S3";
+
+export interface FileSyncOptions {
+  upload?: boolean;
+  download?: boolean;
+  apiUrl?: string;
+  configPath?: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Sync files between local filesystem and Knowhow FS
+ */
+export async function fileSync(options: FileSyncOptions = {}) {
+  const {
+    upload = false,
+    download = false,
+    apiUrl = KNOWHOW_API_URL,
+    configPath = "./knowhow.json",
+    dryRun = false,
+  } = options;
+
+  // Load configuration
+  const config = await getConfig();
+
+  // Check if files is configured
+  if (!config.files || config.files.length === 0) {
+    console.log("✓ No files configured, skipping sync");
+    return;
+  }
+
+  // Load JWT token
+  const jwt = await loadJwt();
+  if (!jwt) {
+    console.error("❌ No JWT token found. Please run 'knowhow login' first.");
+    process.exit(1);
+  }
+
+  // Create API client
+  const client = new KnowhowSimpleClient(apiUrl, jwt);
+
+  // Get S3 service for presigned URL operations
+  const { AwsS3 } = services();
+
+  console.log(`🔄 Starting file sync (${config.files.length} mounts)...`);
+
+  let successCount = 0;
+  let failCount = 0;
+
+  // Process each file mount
+  for (const mount of config.files) {
+    const { remotePath, localPath, direction = "download" } = mount;
+
+    // Determine actual direction based on flags and config
+    let actualDirection = direction;
+    if (upload) {
+      actualDirection = "upload";
+    } else if (download) {
+      actualDirection = "download";
+    }
+
+    try {
+      if (actualDirection === "download") {
+        await downloadFile(client, AwsS3, remotePath, localPath, dryRun);
+        successCount++;
+      } else if (actualDirection === "upload") {
+        await uploadFile(client, AwsS3, remotePath, localPath, dryRun);
+        successCount++;
+      }
+    } catch (error) {
+      console.error(`❌ Failed to sync ${remotePath}: ${error.message}`);
+      failCount++;
+    }
+  }
+
+  console.log(
+    `\n✓ Sync complete: ${successCount} succeeded, ${failCount} failed`
+  );
+
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Download a file from Knowhow FS to local filesystem
+ */
+async function downloadFile(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  remotePath: string,
+  localPath: string,
+  dryRun: boolean
+): Promise<void> {
+  console.log(`⬇️  Downloading ${remotePath} → ${localPath}`);
+
+  if (dryRun) {
+    console.log(`   [DRY RUN] Would download to ${localPath}`);
+    return;
+  }
+
+  try {
+    // Get presigned download URL
+    const presignedUrl = await client.getOrgFilePresignedDownloadUrl(
+      remotePath
+    );
+
+    // Ensure parent directory exists
+    const dir = path.dirname(localPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Download file using presigned URL
+    await s3Service.downloadFromPresignedUrl(presignedUrl, localPath);
+
+    // Get file size for logging
+    const stats = fs.statSync(localPath);
+    console.log(`   ✓ Downloaded ${stats.size} bytes`);
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Upload a file from local filesystem to Knowhow FS
+ */
+async function uploadFile(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  remotePath: string,
+  localPath: string,
+  dryRun: boolean
+): Promise<void> {
+  console.log(`⬆️  Uploading ${localPath} → ${remotePath}`);
+
+  if (dryRun) {
+    console.log(`   [DRY RUN] Would upload from ${localPath}`);
+    return;
+  }
+
+  // Check if local file exists
+  if (!fs.existsSync(localPath)) {
+    console.warn(`   ⚠️  Local file not found: ${localPath}`);
+    return;
+  }
+
+  // Get presigned upload URL
+  const presignedUrl = await client.getOrgFilePresignedUploadUrl(remotePath);
+
+  // Upload file using presigned URL
+  await s3Service.uploadToPresignedUrl(presignedUrl, localPath);
+
+  // Notify backend that upload is complete to update the updatedAt timestamp
+  await client.markOrgFileUploadComplete(remotePath);
+
+  const stats = fs.statSync(localPath);
+  console.log(`   ✓ Uploaded ${stats.size} bytes`);
+}

package/src/services/AgentSyncFs.ts

@@ -25,6 +25,9 @@ export class AgentSyncFs {
   private lastInputContent: string = "";
   private cleanupInterval: NodeJS.Timeout | null = null;
   private finalizationPromise: Promise<void> | null = null;
+  private agent: BaseAgent | undefined;
+  private threadUpdateHandler: ((...args: any[]) => void) | undefined;
+  private doneHandler: ((...args: any[]) => void) | undefined;
 
   constructor() {
     // Start cleanup process when created
@@ -281,8 +284,10 @@ export class AgentSyncFs {
    * Set up event handlers for automatic synchronization
    */
   private setupEventHandlers(agent: BaseAgent): void {
-    // Listen to thread updates to sync state
-    agent.agentEvents.on(agent.eventTypes.threadUpdate, async () => {
+    this.agent = agent;
+
+    // Listen to thread updates to sync state (store reference for cleanup)
+    this.threadUpdateHandler = async () => {
       if (!this.taskId) return;
 
       try {
@@ -291,10 +296,11 @@ export class AgentSyncFs {
       } catch (error) {
         console.error(`❌ Error during threadUpdate sync:`, error);
       }
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.threadUpdate, this.threadUpdateHandler);
 
-    // Listen to completion event to finalize task
-    agent.agentEvents.on(agent.eventTypes.done, (result: string) => {
+    // Listen to completion event to finalize task (store reference for cleanup)
+    this.doneHandler = (result: string) => {
       if (!this.taskId) {
         console.warn(`⚠️ [AgentSyncFs] Cannot finalize: taskId=${this.taskId}`);
         return;
@@ -313,7 +319,8 @@ export class AgentSyncFs {
           throw error;
         }
       })();
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.done, this.doneHandler);
   }
 
   /**
@@ -407,6 +414,18 @@ export class AgentSyncFs {
    * Reset synchronization state
    */
   reset(): void {
+    // Remove old event listeners from the agent before resetting
+    if (this.agent) {
+      if (this.threadUpdateHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+        this.threadUpdateHandler = undefined;
+      }
+      if (this.doneHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.done, this.doneHandler);
+        this.doneHandler = undefined;
+      }
+      this.agent = undefined;
+    }
     this.cleanup();
     this.taskId = undefined;
     this.taskPath = undefined;

package/src/services/AgentSyncKnowhowWeb.ts

@@ -33,6 +33,9 @@ export class AgentSyncKnowhowWeb {
   private knowhowTaskId: string | undefined;
   private eventHandlersSetup: boolean = false;
   private finalizationPromise: Promise<void> | null = null;
+  private agent: BaseAgent | undefined;
+  private threadUpdateHandler: ((...args: any[]) => void) | undefined;
+  private doneHandler: ((...args: any[]) => void) | undefined;
 
   constructor(baseUrl: string = KNOWHOW_API_URL) {
     this.baseUrl = baseUrl;
@@ -228,8 +231,10 @@ export class AgentSyncKnowhowWeb {
    * Set up event handlers for automatic synchronization
    */
   private setupEventHandlers(agent: BaseAgent): void {
-    // Listen to thread updates to sync state and check for pending messages
-    agent.agentEvents.on(agent.eventTypes.threadUpdate, async () => {
+    this.agent = agent;
+
+    // Listen to thread updates to sync state and check for pending messages (store reference for cleanup)
+    this.threadUpdateHandler = async () => {
       if (!this.knowhowTaskId || !this.baseUrl) {
         return;
       }
@@ -244,10 +249,11 @@ export class AgentSyncKnowhowWeb {
         console.error(`❌ Error during threadUpdate sync:`, error);
         // Continue execution even if synchronization fails
       }
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.threadUpdate, this.threadUpdateHandler);
 
-    // Listen to completion event to finalize task
-    agent.agentEvents.on(agent.eventTypes.done, async (result: string) => {
+    // Listen to completion event to finalize task (store reference for cleanup)
+    this.doneHandler = async (result: string) => {
       if (!this.knowhowTaskId || !this.baseUrl) {
         console.warn(`⚠️ [AgentSync] Cannot finalize: knowhowTaskId=${this.knowhowTaskId}, baseUrl=${this.baseUrl}`);
         return;
@@ -268,7 +274,8 @@ export class AgentSyncKnowhowWeb {
           throw error; // Re-throw so CLI can handle it
         }
       })();
-    });
+    };
+    agent.agentEvents.on(agent.eventTypes.done, this.doneHandler);
   }
 
   /**
@@ -284,6 +291,18 @@ export class AgentSyncKnowhowWeb {
    * Reset synchronization state (useful for reusing the service)
    */
   reset(): void {
+    // Remove old event listeners from the agent before resetting
+    if (this.agent) {
+      if (this.threadUpdateHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+        this.threadUpdateHandler = undefined;
+      }
+      if (this.doneHandler) {
+        this.agent.agentEvents.removeListener(this.agent.eventTypes.done, this.doneHandler);
+        this.doneHandler = undefined;
+      }
+      this.agent = undefined;
+    }
     this.knowhowTaskId = undefined;
     this.eventHandlersSetup = false;
     this.finalizationPromise = null;

package/src/services/KnowhowClient.ts

@@ -221,15 +221,21 @@ export class KnowhowSimpleClient {
     const formData = new FormData();
     // options.file can be a Buffer, ReadStream, Blob, or File
     if (Buffer.isBuffer(options.file)) {
-      formData.append("file", new Blob([options.file]), options["fileName"] || "audio.mp3");
+      formData.append(
+        "file",
+        new Blob([options.file]),
+        options.fileName || "audio.mp3"
+      );
     } else {
       formData.append("file", options.file);
     }
     if (options.model) formData.append("model", options.model);
     if (options.language) formData.append("language", options.language);
     if (options.prompt) formData.append("prompt", options.prompt);
-    if (options.response_format) formData.append("response_format", options.response_format);
-    if (options.temperature != null) formData.append("temperature", String(options.temperature));
+    if (options.response_format)
+      formData.append("response_format", options.response_format);
+    if (options.temperature != null)
+      formData.append("temperature", String(options.temperature));
 
     return axios.post<AudioTranscriptionResponse>(
       `${this.baseUrl}/api/proxy/v1/audio/transcriptions`,
@@ -377,7 +383,11 @@ export class KnowhowSimpleClient {
   /**
    * Send a message to a running agent task
    */
-  async sendMessageToAgent(taskId: string, message: string, role: "user" | "system" = "user") {
+  async sendMessageToAgent(
+    taskId: string,
+    message: string,
+    role: "user" | "system" = "user"
+  ) {
     await this.checkJwt();
     return axios.post<SendMessageResponse>(
       `${this.baseUrl}/api/org-agent-tasks/${taskId}/messages`,
@@ -429,4 +439,166 @@ export class KnowhowSimpleClient {
       }
     );
   }
+
+  // ============================================
+  // File Sync Methods
+  // Uses existing org-files endpoints: list, text GET/PUT, and create
+  // ============================================
+
+  /**
+   * List all org files for the current user's org
+   */
+  async listOrgFiles() {
+    await this.checkJwt();
+    return axios.get<
+      { id: string; fileName: string; folderPath: string; name: string }[]
+    >(`${this.baseUrl}/api/org-files`, { headers: this.headers });
+  }
+
+  /**
+   * Create a new org file record
+   */
+  async createOrgFile(fileName: string, folderPath: string) {
+    await this.checkJwt();
+    return axios.post<{
+      id: string;
+      fileName: string;
+      folderPath: string;
+      name: string;
+    }>(
+      `${this.baseUrl}/api/org-files`,
+      { fileName, folderPath, name: fileName },
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Get text content of an org file by id (returns streaming JSON array of strings)
+   */
+  async getOrgFileText(fileId: string) {
+    await this.checkJwt();
+    return axios.get<string>(`${this.baseUrl}/api/org-files/${fileId}/text`, {
+      headers: this.headers,
+      params: { reading: "true" },
+    });
+  }
+
+  /**
+   * Update text content of an org file by id
+   */
+  async updateOrgFileText(fileId: string, text: string) {
+    await this.checkJwt();
+    return axios.put(
+      `${this.baseUrl}/api/org-files/${fileId}/text`,
+      { text },
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Find an org file by its full remote path (e.g. /test.md or /docs/readme.md)
+   * Returns null if not found
+   */
+  async findOrgFileByPath(
+    remotePath: string
+  ): Promise<{ id: string; fileName: string; folderPath: string } | null> {
+    const lastSlash = remotePath.lastIndexOf("/");
+    const rawFolder =
+      lastSlash >= 0 ? remotePath.substring(0, lastSlash + 1) : "/";
+    // Normalize: "/" and "" both mean root
+    const folderPath = rawFolder === "/" ? rawFolder : rawFolder;
+    const fileName =
+      lastSlash >= 0 ? remotePath.substring(lastSlash + 1) : remotePath;
+
+    const response = await this.listOrgFiles();
+    const files = response.data;
+    // DB may store root as "" or "/" - match both
+    const isRoot = folderPath === "/" || folderPath === "";
+    return (
+      files.find(
+        (f) =>
+          f.fileName === fileName &&
+          (f.folderPath === folderPath ||
+            (isRoot && (f.folderPath === "/" || f.folderPath === "")))
+      ) || null
+    );
+  }
+
+  /**
+   * Find or create an org file by path, returns the file record
+   */
+  async findOrCreateOrgFileByPath(
+    remotePath: string
+  ): Promise<{ id: string; fileName: string; folderPath: string }> {
+    const existing = await this.findOrgFileByPath(remotePath);
+    if (existing) return existing;
+
+    const lastSlash = remotePath.lastIndexOf("/");
+    const folderPath =
+      lastSlash >= 0 ? remotePath.substring(0, lastSlash + 1) || "/" : "/";
+    const fileName =
+      lastSlash >= 0 ? remotePath.substring(lastSlash + 1) : remotePath;
+
+    const response = await this.createOrgFile(fileName, folderPath);
+    return response.data;
+  }
+
+  /**
+   * Get presigned S3 URL for downloading a file from Knowhow FS.
+   * First finds or creates the file by path, then gets its download URL.
+   */
+  async getOrgFilePresignedDownloadUrl(filePath: string): Promise<string> {
+    await this.checkJwt();
+    
+    // Find the file by path
+    const file = await this.findOrgFileByPath(filePath);
+    if (!file) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    
+    // Get download URL using the file ID
+    const response = await axios.post<{ downloadUrl: string }>(
+      `${this.baseUrl}/api/org-files/download/${file.id}`,
+      {},
+      { headers: this.headers }
+    );
+    return response.data.downloadUrl;
+  }
+
+  /**
+   * Notify the backend that a file upload is complete, updating its updatedAt timestamp.
+   */
+  async markOrgFileUploadComplete(filePath: string): Promise<void> {
+    await this.checkJwt();
+    
+    const file = await this.findOrgFileByPath(filePath);
+    if (!file) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    
+    await axios.post(`${this.baseUrl}/api/org-files/upload/${file.id}/complete`, {}, { headers: this.headers });
+  }
+
+  /**
+   * Get presigned S3 URL for uploading a file to Knowhow FS.
+   * First finds or creates the file by path, then gets its upload URL.
+   */
+  async getOrgFilePresignedUploadUrl(filePath: string): Promise<string> {
+    await this.checkJwt();
+    
+    // Find or create the file by path
+    const file = await this.findOrCreateOrgFileByPath(filePath);
+    
+    // Extract just the filename from the path
+    const lastSlash = filePath.lastIndexOf("/");
+    const fileName = lastSlash >= 0 ? filePath.substring(lastSlash + 1) : filePath;
+    
+    // Get upload URL using the file ID
+    const response = await axios.post<{ uploadUrl: string }>(
+      `${this.baseUrl}/api/org-files/upload/${file.id}`,
+      { fileName },
+      { headers: this.headers }
+    );
+    return response.data.uploadUrl;
+  }
 }

package/src/services/SessionManager.ts

@@ -151,7 +151,7 @@ export class SessionManager {
               ).toLocaleString()})`
             );
             session.status = "failed";
-            session.lastUpdated = Date.now();
+            // Preserve original lastUpdated so sessions don't all get the same timestamp
             // Update the session file with failed status
             fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
           }