@tyvm/knowhow 0.0.100 → 0.0.102

package/jest.manual.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts?$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },
+  testEnvironment: 'node',
+  testRegex: '/tests/manual/.*\.(test|spec)\.(ts|tsx|js)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  modulePathIgnorePatterns: ["ts_build", "benchmarks"],
+  testPathIgnorePatterns: [],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.100",
+  "version": "0.0.102",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -9,6 +9,7 @@
   "scripts": {
     "test": "jest --testTimeout 300000",
     "test:debug": "node --inspect-brk ../../node_modules/jest/bin/jest.js --detectOpenHandles --forceExit --testTimeout 300000",
+    "build": "npm run compile",
     "compile": "npm run clean && tsc",
     "clean": "rm -rf ts_build",
     "node:build": "bash scripts/build-for-node.sh",

package/src/agents/base/base.ts

@@ -64,7 +64,13 @@ export abstract class BaseAgent implements IAgent {
   protected compressMinMessages = 30;
 
   protected threads = [] as Message[][];
+
+  // Message from users
   protected pendingUserMessages = [] as Message[];
+
+  // Internal messages
+  protected pendingMessages = [] as Message[];
+
   protected taskBreakdown = "";
   protected summaries = [] as string[];
   protected currentTaskId: string | null = null;
@@ -538,10 +544,14 @@ export abstract class BaseAgent implements IAgent {
 
   async kill() {
     this.log("Killing agent");
+    if (this.status === this.eventTypes.kill || this.status === this.eventTypes.done) {
+      this.log("Agent is already being killed or done, ignoring duplicate kill()", "warn");
+      return;
+    }
     this.agentEvents.emit(this.eventTypes.kill, this);
     this.status = this.eventTypes.kill;
 
-    this.addPendingUserMessage({
+    this.addPendingMessage({
       role: "user",
       content: `<Workflow>The user has requested the task to end, please call ${this.requiredToolNames} with a report of your ending state</Workflow>`,
     } as Message);
@@ -599,6 +609,11 @@ export abstract class BaseAgent implements IAgent {
         this.pendingUserMessages = [];
       }
 
+      if (this.pendingMessages.length) {
+        messages.push(...this.pendingMessages);
+        this.pendingMessages = [];
+      }
+
       messages = this.formatInputMessages(messages);
       this.updateCurrentThread(messages);
       const isMissingTool = this.isRequiredToolMissing();
@@ -619,6 +634,17 @@ export abstract class BaseAgent implements IAgent {
         tool_choice: "auto",
       });
 
+      // If the agent was paused while the completion was in-flight, wait here
+      // before processing tool calls. This allows the user to send messages
+      // (via addPendingUserMessage) and prevents the agent from proceeding to
+      // tool calls (e.g. finalAnswer) without seeing those interactions.
+      if (this.status === this.eventTypes.pause) {
+        this.log(
+          "Agent was paused after completion, waiting before processing tool calls"
+        );
+        await this.unpaused();
+      }
+
       if (response?.usd_cost === undefined) {
         this.log(
           `Response cost is undefined: ${JSON.stringify(response, null, 2)}`,
@@ -662,6 +688,13 @@ export abstract class BaseAgent implements IAgent {
           this.updateCurrentThread(messages);
 
           for (const toolCall of toolCalls) {
+            if (this.status === this.eventTypes.pause) {
+              this.log(
+                "Agent was paused before tool call, waiting before processing tool calls"
+              );
+              await this.unpaused();
+            }
+
             const toolMessages = await this.processToolMessages(toolCall);
             // Add the tool responses to the thread
             messages.push(...(toolMessages as Message[]));
@@ -676,6 +709,18 @@ export abstract class BaseAgent implements IAgent {
             );
 
             if (finalMessage) {
+              // If user added pending messages after finalAnswer was called,
+              // continue running to respond to that feedback instead of returning
+              if (this.pendingUserMessages.length > 0) {
+                this.log(
+                  "finalAnswer called but pending user messages exist, continuing to respond to feedback"
+                );
+                messages.push(...this.pendingUserMessages);
+                this.pendingUserMessages = [];
+                this.updateCurrentThread(messages);
+                return this.call(userInput, messages);
+              }
+
               // Emit task completion event for plugins (like GitPlugin)
               this.events.emit(this.eventTypes.agentTaskComplete, {
                 taskId:
@@ -685,6 +730,7 @@ export abstract class BaseAgent implements IAgent {
                 result: finalMessage.content || "Done",
               });
               const doneMsg = finalMessage.content || "Done";
+
               this.agentEvents.emit(this.eventTypes.done, doneMsg);
               this.status = this.eventTypes.done;
               return doneMsg;
@@ -876,21 +922,32 @@ export abstract class BaseAgent implements IAgent {
     });
   }
 
+  // A new message from system, non blocking
   addPendingMessage(message: Message) {
     if (this.status === this.eventTypes.done) {
       this.log("Agent is done, cannot take more messages", "warn");
     } else {
-      const pendingMessages = this.pendingUserMessages.map((m) => m.content);
+      const pendingMessages = this.pendingMessages.map((m) => m.content);
       if (pendingMessages.includes(message.content)) {
         // Ignore messages we already have queue'd up
         return;
       }
-      this.pendingUserMessages.push(message);
+      this.pendingMessages.push(message);
     }
   }
 
+  // A new message from users, blocks completion
   addPendingUserMessage(message: Message) {
-    this.addPendingMessage(message);
+    if (this.status === this.eventTypes.done) {
+      this.log("Agent is done, cannot take more messages", "warn");
+    } else {
+      const pendingMessages = this.pendingUserMessages.map((m) => m.content);
+      if (pendingMessages.includes(message.content)) {
+        // Ignore messages we already have queue'd up
+        return;
+      }
+      this.pendingUserMessages.push(message);
+    }
     this.events.emit(this.eventTypes.userSay, message.content);
   }
 

package/src/cli.ts

@@ -38,6 +38,20 @@ import { readPromptFile } from "./ai";
 import { SetupModule } from "./chat/modules/SetupModule";
 import { CliChatService } from "./chat/CliChatService";
 
+// Handle unhandled promise rejections gracefully — particularly from MCP SDK
+// which fires errors via event emitters that can bypass Promise.allSettled.
+// Without this, a single failing MCP server (e.g. expired Notion token) will
+// crash the entire CLI with an unhandled rejection.
+process.on("unhandledRejection", (reason: unknown) => {
+  const message =
+    reason instanceof Error ? reason.message : String(reason);
+  // Only warn — don't exit. The MCP connect errors are recoverable;
+  // the server will simply be unavailable but others continue working.
+  console.warn(
+    `⚠ Unhandled MCP/async error (non-fatal): ${message}`
+  );
+});
+
 async function setupServices() {
   const { Agents, Mcp, Clients, Tools: OldTools } = services();
   const Tools = new LazyToolsService(); // eslint-disable-line no-shadow
@@ -74,7 +88,14 @@ async function setupServices() {
   Agents.setAgentContext(agentContext);
 
   console.log("🔌 Connecting to MCP...");
-  await Mcp.connectToConfigured(Tools);
+  try {
+    await Mcp.connectToConfigured(Tools);
+  } catch (mcpError) {
+    const msg = mcpError instanceof Error ? mcpError.message : String(mcpError);
+    console.warn(
+      `⚠ Some MCP servers failed to connect (continuing without them): ${msg}`
+    );
+  }
   console.log("Connecting to clients...");
   await Clients.registerConfiguredModels();
   console.log("✓ Services are set up and ready to go!");

package/src/clients/contextLimits.ts

@@ -52,7 +52,6 @@ export const ContextLimits: Record<string, number> = {
   [Models.anthropic.Haiku4_5]: 200_000,
   [Models.anthropic.Sonnet3_7]: 200_000,
   [Models.anthropic.Sonnet3_5]: 200_000,
-  [Models.anthropic.Haiku3_5]: 200_000,
   [Models.anthropic.Opus3]: 200_000,
   [Models.anthropic.Haiku3]: 200_000,
 
@@ -74,7 +73,6 @@ export const ContextLimits: Record<string, number> = {
   [Models.google.Gemini_25_Pro_TTS]: 1_000_000,
   [Models.google.Gemini_20_Flash]: 1_000_000,
   [Models.google.Gemini_20_Flash_Preview_Image_Generation]: 1_000_000,
-  [Models.google.Gemini_20_Flash_Lite]: 1_000_000,
   [Models.google.Gemini_20_Flash_Live]: 1_000_000,
   [Models.google.Gemini_20_Flash_TTS]: 1_000_000,
   [Models.google.Gemini_15_Flash]: 1_000_000,

package/src/clients/pricing/anthropic.ts

@@ -65,12 +65,6 @@ export const AnthropicTextPricing = {
     cache_hit: 0.3,
     output: 15.0,
   },
-  [Models.anthropic.Haiku3_5]: {
-    input: 0.8,
-    cache_write: 1.0,
-    cache_hit: 0.08,
-    output: 4.0,
-  },
   [Models.anthropic.Opus3]: {
     input: 15.0,
     cache_write: 18.75,

package/src/clients/pricing/google.ts

@@ -174,10 +174,6 @@ export const GeminiPricing: Record<string, GeminiModelPricing> = {
     output: 0.4,
     image_generation: 0.039,
   },
-  [Models.google.Gemini_20_Flash_Lite]: {
-    input: 0.075,
-    output: 0.3,
-  },
 
   // ── Gemini 1.5 (legacy) ───────────────────────────────────────────────────
   [Models.google.Gemini_15_Flash]: {

package/src/clients/pricing/xai.ts

@@ -1,6 +1,17 @@
 import { Models } from "../../types";
 
 export const XaiTextPricing = {
+
+  [Models.xai.Grok_4_20_Reasoning]: {
+    input: 2.0,
+    cache_hit: 0.20,
+    output: 6.0,
+  },
+  [Models.xai.Grok_4_20_NonReasoning]: {
+    input: 2.0,
+    cache_hit: 0.20,
+    output: 6.0,
+  },
   [Models.xai.Grok4_1_Fast_NonReasoning]: {
     input: 0.2,
     cache_hit: 0.05,

package/src/cloudWorker.ts

@@ -1,6 +1,5 @@
 import * as fs from "fs";
 import * as path from "path";
-import { glob } from "glob";
 import { KnowhowSimpleClient, KNOWHOW_API_URL } from "./services/KnowhowClient";
 import { loadJwt } from "./login";
 import { getConfig, updateConfig, getLanguageConfig } from "./config";
@@ -23,6 +22,26 @@ interface FileToSync {
   localPath: string;
   remotePath: string;
   downloadLocalPath?: string; // override localPath used when worker downloads the file
+  isDirectory?: boolean; // true if this represents a whole directory
+}
+
+/**
+ * Recursively list all files in a local directory, returning relative paths
+ */
+function listFilesRecursively(dir: string): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      listFilesRecursively(path.join(dir, entry.name)).forEach((f) =>
+        results.push(entry.name + "/" + f)
+      );
+    } else {
+      results.push(entry.name);
+    }
+  }
+  return results;
 }
 
 /**
@@ -48,6 +67,8 @@ function buildWorkerConfigJson(config: Config, files: { remotePath: string; loca
 
 /**
  * Collect all files from the .knowhow directory that should be synced
+ * Uses directory-level entries where possible so the worker config stays compact
+ * and the folder upload/download feature handles individual files automatically.
  */
 async function collectFilesToSync(projectName: string): Promise<FileToSync[]> {
   const filesToSync: FileToSync[] = [];
@@ -59,39 +80,24 @@ async function collectFilesToSync(projectName: string): Promise<FileToSync[]> {
     }
   };
 
+  // Helper to add a directory entry if it exists (trailing slash = directory mode)
+  const addDirIfExists = (localPath: string, remotePath: string) => {
+    if (fs.existsSync(localPath)) {
+      filesToSync.push({ localPath: localPath + "/", remotePath: remotePath + "/", isDirectory: true });
+    }
+  };
+
   // .knowhow/language.json
   addIfExists(".knowhow/language.json", `${projectName}/.knowhow/language.json`);
 
   // .knowhow/hashes.json
   addIfExists(".knowhow/hashes.json", `${projectName}/.knowhow/hashes.json`);
 
-  // .knowhow/prompts/**/*
-  const promptFiles = await glob(".knowhow/prompts/**/*", { nodir: true });
-  for (const filePath of promptFiles) {
-    const relativeToDotKnowhow = filePath.replace(/^\.knowhow\//, "");
-    const remotePath = `${projectName}/.knowhow/${relativeToDotKnowhow}`;
-    filesToSync.push({ localPath: filePath, remotePath });
-  }
-
-  // .knowhow/scripts/**/* (if exists)
-  if (fs.existsSync(".knowhow/scripts")) {
-    const scriptFiles = await glob(".knowhow/scripts/**/*", { nodir: true });
-    for (const filePath of scriptFiles) {
-      const relativeToDotKnowhow = filePath.replace(/^\.knowhow\//, "");
-      const remotePath = `${projectName}/.knowhow/${relativeToDotKnowhow}`;
-      filesToSync.push({ localPath: filePath, remotePath });
-    }
-  }
-
-  // .knowhow/skills/**/* (if exists)
-  if (fs.existsSync(".knowhow/skills")) {
-    const skillFiles = await glob(".knowhow/skills/**/*", { nodir: true });
-    for (const filePath of skillFiles) {
-      const relativeToDotKnowhow = filePath.replace(/^\.knowhow\//, "");
-      const remotePath = `${projectName}/.knowhow/${relativeToDotKnowhow}`;
-      filesToSync.push({ localPath: filePath, remotePath });
-    }
-  }
+  // Directories — use trailing-slash entries so folder upload/download handles them
+  addDirIfExists(".knowhow/prompts", `${projectName}/.knowhow/prompts`);
+  addDirIfExists(".knowhow/scripts", `${projectName}/.knowhow/scripts`);
+  addDirIfExists(".knowhow/skills", `${projectName}/.knowhow/skills`);
+  addDirIfExists(".knowhow/tasks", `${projectName}/.knowhow/tasks`);
 
   return filesToSync;
 }
@@ -264,8 +270,20 @@ export async function cloudWorker(options: CloudWorkerOptions) {
 
   for (const file of allFiles) {
     try {
-      await uploadSingleFile(client, AwsS3, file.localPath, file.remotePath, dryRun);
-      successCount++;
+      if (file.isDirectory) {
+        // Upload all files recursively in the local directory
+        const localDir = file.localPath.endsWith("/") ? file.localPath : file.localPath + "/";
+        const remoteDir = file.remotePath.endsWith("/") ? file.remotePath : file.remotePath + "/";
+        const relFiles = listFilesRecursively(localDir);
+        console.log(`  📁 Uploading directory ${localDir} → ${remoteDir} (${relFiles.length} files)`);
+        for (const relFile of relFiles) {
+          await uploadSingleFile(client, AwsS3, localDir + relFile, remoteDir + relFile, dryRun);
+          successCount++;
+        }
+      } else {
+        await uploadSingleFile(client, AwsS3, file.localPath, file.remotePath, dryRun);
+        successCount++;
+      }
     } catch (error) {
       console.error(`  ❌ Failed to upload ${file.localPath}: ${error.message}`);
       failCount++;

package/src/fileSync.ts

@@ -5,6 +5,7 @@ import { loadJwt } from "./login";
 import { getConfig } from "./config";
 import { services } from "./services";
 import { S3Service } from "./services/S3";
+import { getHashes, hasFileChangedSinceUpload, saveUploadHash, isLocalFileMatchingRemote } from "./hashes";
 
 export interface FileSyncOptions {
   upload?: boolean;
@@ -14,6 +15,33 @@ export interface FileSyncOptions {
   dryRun?: boolean;
 }
 
+/**
+ * Returns true if the path looks like a directory (ends with /)
+ */
+function isDirectoryPath(p: string): boolean {
+  return p.endsWith("/");
+}
+
+/**
+ * Recursively list all files in a local directory, returning relative paths
+ */
+function listFilesRecursively(dir: string): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const subFiles = listFilesRecursively(path.join(dir, entry.name));
+      for (const f of subFiles) {
+        results.push(entry.name + "/" + f);
+      }
+    } else {
+      results.push(entry.name);
+    }
+  }
+  return results;
+}
+
 /**
  * Sync files between local filesystem and Knowhow FS
  */
@@ -67,11 +95,21 @@ export async function fileSync(options: FileSyncOptions = {}) {
 
     try {
       if (actualDirection === "download") {
-        await downloadFile(client, AwsS3, remotePath, localPath, dryRun);
-        successCount++;
+        if (isDirectoryPath(remotePath) || isDirectoryPath(localPath)) {
+          const count = await downloadDirectory(client, AwsS3, remotePath, localPath, dryRun);
+          successCount += count;
+        } else {
+          await downloadFile(client, AwsS3, remotePath, localPath, dryRun);
+          successCount++;
+        }
       } else if (actualDirection === "upload") {
-        await uploadFile(client, AwsS3, remotePath, localPath, dryRun);
-        successCount++;
+        if (isDirectoryPath(remotePath) || isDirectoryPath(localPath)) {
+          const count = await uploadDirectory(client, AwsS3, remotePath, localPath, dryRun);
+          successCount += count;
+        } else {
+          await uploadFile(client, AwsS3, remotePath, localPath, dryRun);
+          successCount++;
+        }
       }
     } catch (error) {
       console.error(`❌ Failed to sync ${remotePath}: ${error.message}`);
@@ -88,6 +126,7 @@ export async function fileSync(options: FileSyncOptions = {}) {
   }
 }
 
+
 /**
  * Download a file from Knowhow FS to local filesystem
  */
@@ -106,10 +145,14 @@ async function downloadFile(
   }
 
   try {
-    // Get presigned download URL
-    const presignedUrl = await client.getOrgFilePresignedDownloadUrl(
-      remotePath
-    );
+    // Get presigned download URL + remote checksum
+    const { downloadUrl, checksumSHA256 } = await client.getOrgFilePresignedDownloadUrl(remotePath);
+
+    // Skip if local file matches remote checksum
+    if (isLocalFileMatchingRemote(localPath, checksumSHA256)) {
+      console.log(`   ✓ Skipping ${localPath} (matches remote checksum)`);
+      return;
+    }
 
     // Ensure parent directory exists
     const dir = path.dirname(localPath);
@@ -118,7 +161,7 @@ async function downloadFile(
     }
 
     // Download file using presigned URL
-    await s3Service.downloadFromPresignedUrl(presignedUrl, localPath);
+    await s3Service.downloadFromPresignedUrl(downloadUrl, localPath);
 
     // Get file size for logging
     const stats = fs.statSync(localPath);
@@ -151,6 +194,14 @@ async function uploadFile(
     return;
   }
 
+  // Skip upload if file hasn't changed since last upload
+  const hashes = await getHashes();
+  const changed = await hasFileChangedSinceUpload(localPath, hashes);
+  if (!changed) {
+    console.log(`   ✓ Skipping ${localPath} (unchanged since last upload)`);
+    return;
+  }
+
   // Get presigned upload URL
   const presignedUrl = await client.getOrgFilePresignedUploadUrl(remotePath);
 
@@ -160,6 +211,99 @@ async function uploadFile(
   // Notify backend that upload is complete to update the updatedAt timestamp
   await client.markOrgFileUploadComplete(remotePath);
 
+  // Save upload hash so we can skip unchanged files next time
+  await saveUploadHash(localPath);
+
   const stats = fs.statSync(localPath);
   console.log(`   ✓ Uploaded ${stats.size} bytes`);
 }
+
+/**
+ * Upload all files from a local directory to a remote directory path
+ */
+export async function uploadDirectory(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  remotePath: string,
+  localPath: string,
+  dryRun: boolean
+): Promise<number> {
+  // Normalize paths to end with /
+  const remoteDir = remotePath.endsWith("/") ? remotePath : remotePath + "/";
+  const localDir = localPath.endsWith("/") ? localPath : localPath + "/";
+
+  console.log(`⬆️  Uploading directory ${localDir} → ${remoteDir}`);
+
+  if (!fs.existsSync(localDir)) {
+    console.warn(`   ⚠️  Local directory not found: ${localDir}`);
+    return 0;
+  }
+
+  // Find all files recursively in the local directory
+  const localFiles = listFilesRecursively(localDir);
+
+  if (localFiles.length === 0) {
+    console.log(`   ⚠️  No local files found under ${localDir}`);
+    return 0;
+  }
+
+  console.log(`   Found ${localFiles.length} local file(s)`);
+
+  let count = 0;
+  for (const relFile of localFiles) {
+    const localFilePath = localDir + relFile;
+    const remoteFilePath = remoteDir + relFile;
+    await uploadFile(client, s3Service, remoteFilePath, localFilePath, dryRun);
+    count++;
+  }
+  return count;
+}
+
+/**
+ * Download all files from a remote directory path to a local directory
+ */
+async function downloadDirectory(
+  client: KnowhowSimpleClient,
+  s3Service: S3Service,
+  remotePath: string,
+  localPath: string,
+  dryRun: boolean
+): Promise<number> {
+  // Normalize paths to end with /
+  const remoteDir = remotePath.endsWith("/") ? remotePath : remotePath + "/";
+  const localDir = localPath.endsWith("/") ? localPath : localPath + "/";
+
+  console.log(`⬇️  Downloading directory ${remoteDir} → ${localDir}`);
+
+  // List all org files and find those in the remote directory
+  const response = await client.listOrgFiles();
+  const allFiles = response.data;
+
+  // Find files where the full path starts with remoteDir
+  const matchingFiles = allFiles.filter((f) => {
+    const fullPath = f.folderPath.endsWith("/")
+      ? f.folderPath + f.fileName
+      : f.folderPath + "/" + f.fileName;
+    return fullPath.startsWith(remoteDir);
+  });
+
+  if (matchingFiles.length === 0) {
+    console.log(`   ⚠️  No remote files found under ${remoteDir}`);
+    return 0;
+  }
+
+  console.log(`   Found ${matchingFiles.length} remote file(s)`);
+
+  let count = 0;
+  for (const f of matchingFiles) {
+    const fullRemotePath = f.folderPath.endsWith("/")
+      ? f.folderPath + f.fileName
+      : f.folderPath + "/" + f.fileName;
+    // Strip the base remote dir prefix to get relative path
+    const relativePath = fullRemotePath.slice(remoteDir.length);
+    const localFilePath = localDir + relativePath;
+    await downloadFile(client, s3Service, fullRemotePath, localFilePath, dryRun);
+    count++;
+  }
+  return count;
+}

package/src/hashes.ts

@@ -70,3 +70,55 @@ export async function saveAllFileHashes(files: string[], promptHash: string) {
 
   await saveHashes(hashes);
 }
+
+const UPLOAD_KEY = "upload";
+
+/**
+ * Returns true if the file has changed since the last successful upload
+ * (or if it has never been uploaded before)
+ */
+export async function hasFileChangedSinceUpload(
+  localPath: string,
+  hashes: any
+): Promise<boolean> {
+  if (!fs.existsSync(localPath)) return true;
+  const content = fs.readFileSync(localPath);
+  const currentHash = crypto.createHash("md5").update(content).digest("hex");
+  return hashes[localPath]?.[UPLOAD_KEY] !== currentHash;
+}
+
+/**
+ * Saves the hash of the file at the time of a successful upload
+ */
+export async function saveUploadHash(localPath: string) {
+  const hashes = await getHashes();
+  const content = fs.readFileSync(localPath);
+  const currentHash = crypto.createHash("md5").update(content).digest("hex");
+  if (!hashes[localPath]) {
+    hashes[localPath] = { fileHash: currentHash, promptHash: "" };
+  }
+  hashes[localPath][UPLOAD_KEY] = currentHash;
+  await saveHashes(hashes);
+}
+
+/**
+ * Compute SHA-256 of a local file, returned as base64 (matches S3 encoding)
+ */
+export function computeSHA256Base64(filePath: string): string {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash("sha256").update(content).digest("base64");
+}
+
+/**
+ * Returns true if the local file's SHA-256 matches the remote checksum,
+ * meaning the file is up-to-date and download can be skipped.
+ */
+export function isLocalFileMatchingRemote(
+  localPath: string,
+  remoteChecksumSHA256: string | null
+): boolean {
+  if (!remoteChecksumSHA256) return false;
+  if (!fs.existsSync(localPath)) return false;
+  const localChecksum = computeSHA256Base64(localPath);
+  return localChecksum === remoteChecksumSHA256;
+}

package/src/login.ts

@@ -49,20 +49,17 @@ export async function login(jwtFlag?: boolean): Promise<void> {
     );
 
     const config = await getConfig();
-    const proxyUrl = KNOWHOW_API_URL + "/api/proxy";
 
     if (!config.modelProviders) {
       config.modelProviders = [];
     }
 
     const hasProvider = config.modelProviders.find(
-      (provider) => provider.provider === "knowhow" && provider.url === proxyUrl
+      (provider) => provider.provider === "knowhow"
     );
     if (!hasProvider) {
       config.modelProviders.push({
         provider: "knowhow",
-        url: proxyUrl,
-        jwtFile: ".knowhow/.jwt",
       });
 
       await updateConfig(config);