replicas-engine 0.1.309 → 0.1.313

package/dist/src/index.js

@@ -14,21 +14,6 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// ../shared/src/result.ts
-function createSuccessResult(data) {
-  return { ok: true, data };
-}
-function createErrorResult(error) {
-  return {
-    ok: false,
-    error: {
-      message: error.message,
-      code: error.code,
-      details: error.details
-    }
-  };
-}
-
 // ../shared/src/agent.ts
 var CODEX_REASONING_EFFORT_BY_THINKING_LEVEL = {
   low: "low",
@@ -132,9 +117,9 @@ var EXT_TO_LANGUAGE = {
 function detectLanguageByPath(filePath) {
   const dot = filePath.lastIndexOf(".");
   if (dot === -1) {
-    const basename3 = filePath.split("/").pop() ?? "";
-    if (basename3 === "Dockerfile") return "dockerfile";
-    if (basename3 === "Makefile") return "makefile";
+    const basename2 = filePath.split("/").pop() ?? "";
+    if (basename2 === "Dockerfile") return "dockerfile";
+    if (basename2 === "Makefile") return "makefile";
     return null;
   }
   const ext = filePath.slice(dot).toLowerCase();
@@ -302,7 +287,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-13-v5";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-13-v9";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -2091,6 +2076,35 @@ var MODEL_LABELS = {
   "gpt-5.2": "GPT-5.2"
 };
 var IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var MAX_CANVAS_FILE_BYTES = 5 * 1024 * 1024;
+function isCanvasTextKind(kind) {
+  return kind === "markdown" || kind === "html";
+}
+function sanitizeCanvasFilename(filename) {
+  const safe = filename.split(/[\\/]/).pop() ?? "";
+  if (!safe || safe !== filename || safe.startsWith(".")) return null;
+  return safe;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+  }
+  return btoa(binary);
+}
+function serializeCanvasContentResponse(input) {
+  const base = {
+    filename: input.filename,
+    kind: input.kind,
+    sizeBytes: input.sizeBytes,
+    mimeType: input.mimeType
+  };
+  if (isCanvasTextKind(input.kind)) {
+    return { ...base, content: new TextDecoder().decode(input.bytes) };
+  }
+  return { ...base, base64: bytesToBase64(input.bytes) };
+}
 var CANVAS_KIND_BY_EXTENSION = {
   ".md": { kind: "markdown", mimeType: "text/markdown; charset=utf-8" },
   ".markdown": { kind: "markdown", mimeType: "text/markdown; charset=utf-8" },
@@ -2925,6 +2939,32 @@ function upsertCredentialFileLines(filePath, hosts, lines) {
   credentialFileQueue = task.catch(() => void 0);
   return task;
 }
+function removeCredentialFileLines(filePath, shouldRemove) {
+  const task = credentialFileQueue.then(async () => {
+    let existing = [];
+    try {
+      existing = (await readFile(filePath, "utf-8")).split("\n").filter(Boolean);
+    } catch {
+      return;
+    }
+    const kept = existing.filter((line) => !shouldRemove(line));
+    await writeSecureCredentialFile(filePath, [...kept, ""].join("\n"));
+  });
+  credentialFileQueue = task.catch(() => void 0);
+  return task;
+}
+
+// src/utils/git-identity.ts
+async function updateGitIdentity(identity, tag) {
+  try {
+    const [nameArgs, emailArgs] = gitIdentityConfigCommands(identity);
+    await execFileAsync("git", nameArgs);
+    await execFileAsync("git", emailArgs);
+    console.log(`[${tag}] Updated git identity to ${identity.name} <${identity.email}>`);
+  } catch (error) {
+    console.error(`[${tag}] Failed to update git identity:`, error);
+  }
+}
 
 // src/managers/github-token-manager.ts
 var GitHubTokenManager = class extends BaseRefreshManager {
@@ -2935,6 +2975,9 @@ var GitHubTokenManager = class extends BaseRefreshManager {
     console.log("[GitHubTokenManager] Refreshing GitHub token...");
     const response = await monolithRequest("/v1/engine/github/refresh-token");
     if (!response.ok) {
+      if (response.status === 403) {
+        await this.clearGitHubCredentials();
+      }
       const errorText = await response.text();
       throw new Error(`Token refresh failed: ${response.status} ${errorText}`);
     }
@@ -2944,7 +2987,7 @@ var GitHubTokenManager = class extends BaseRefreshManager {
     await this.updateGitCredentials(ghToken);
     await this.updateGhHostsFile(ghToken, ghUsername);
     if (data.gitIdentity) {
-      await this.updateGitIdentity(data.gitIdentity);
+      await updateGitIdentity(data.gitIdentity, "GitHubTokenManager");
     }
     if (data.userToken) {
       console.log(`[GitHubTokenManager] Token refreshed with user token for PR attribution, installation token expires at ${data.expiresAt}, user token expires at ${data.userToken.expiresAt}`);
@@ -2977,15 +3020,12 @@ var GitHubTokenManager = class extends BaseRefreshManager {
       console.error("[GitHubTokenManager] Failed to update gh hosts file:", error);
     }
   }
-  async updateGitIdentity(identity) {
-    try {
-      const [nameArgs, emailArgs] = gitIdentityConfigCommands(identity);
-      await execFileAsync("git", nameArgs);
-      await execFileAsync("git", emailArgs);
-      console.log(`[GitHubTokenManager] Updated git identity to ${identity.name} <${identity.email}>`);
-    } catch (error) {
-      console.error("[GitHubTokenManager] Failed to update git identity:", error);
-    }
+  async clearGitHubCredentials() {
+    const credentialsPath = path.join(ENGINE_ENV.HOME_DIR, ".git-credentials");
+    await removeCredentialFileLines(
+      credentialsPath,
+      (line) => line.endsWith("@github.com")
+    );
   }
 };
 var githubTokenManager = new GitHubTokenManager();
@@ -2997,12 +3037,16 @@ var GitLabTokenManager = class extends BaseRefreshManager {
     super("GitLabTokenManager");
   }
   async doRefresh(_config) {
-    const result = await this.fetchRefresh();
-    if (!result.ok) {
-      throw new Error(`Token refresh failed: ${result.error.message}`);
+    const response = await monolithRequest("/v1/engine/gitlab/refresh-token");
+    if (!response.ok) {
+      if (response.status === 403) {
+        await this.clearGitLabCredentials();
+      }
+      throw new Error(`Token refresh failed: ${response.status} ${await response.text()}`);
     }
-    const data = result.data;
+    const data = await response.json();
     if (!data.token) {
+      await this.clearGitLabCredentials(data.hosts);
       console.log(`[GitLabTokenManager] No GitLab token to install: ${data.reason}`);
       return;
     }
@@ -3015,25 +3059,15 @@ var GitLabTokenManager = class extends BaseRefreshManager {
     );
     console.log(`[GitLabTokenManager] Updated ${credentialsPath} for ${hosts.join(", ")}`);
     if (data.gitIdentity) {
-      await this.updateGitIdentity(data.gitIdentity);
-    }
-  }
-  async fetchRefresh() {
-    const response = await monolithRequest("/v1/engine/gitlab/refresh-token");
-    if (!response.ok) {
-      return createErrorResult({ message: `${response.status} ${await response.text()}` });
+      await updateGitIdentity(data.gitIdentity, "GitLabTokenManager");
     }
-    return createSuccessResult(await response.json());
   }
-  async updateGitIdentity(identity) {
-    try {
-      const [nameArgs, emailArgs] = gitIdentityConfigCommands(identity);
-      await execFileAsync("git", nameArgs);
-      await execFileAsync("git", emailArgs);
-      console.log(`[GitLabTokenManager] Updated git identity to ${identity.name} <${identity.email}>`);
-    } catch (error) {
-      console.error("[GitLabTokenManager] Failed to update git identity:", error);
-    }
+  async clearGitLabCredentials(hosts = []) {
+    const credentialsPath = path2.join(ENGINE_ENV.HOME_DIR, ".git-credentials");
+    await removeCredentialFileLines(
+      credentialsPath,
+      (line) => line.startsWith("https://oauth2:") && (hosts.length === 0 || hosts.some((host) => line.endsWith(`@${host}`)))
+    );
   }
 };
 var gitlabTokenManager = new GitLabTokenManager();
@@ -4899,9 +4933,9 @@ async function registerDesktopPreview() {
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile4, copyFile, mkdir as mkdir11, readFile as readFile11, rename as rename2, rm } from "fs/promises";
-import { homedir as homedir13 } from "os";
-import { join as join15 } from "path";
+import { appendFile as appendFile4, copyFile, mkdir as mkdir11, readFile as readFile12, rename as rename2, rm } from "fs/promises";
+import { homedir as homedir14 } from "os";
+import { join as join16 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/managers/claude-manager.ts
@@ -6846,7 +6880,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.309";
+var ENGINE_PACKAGE_VERSION = "0.1.313";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -9149,15 +9183,190 @@ var KeepAliveService = class _KeepAliveService {
 };
 var keepAliveService = new KeepAliveService();
 
-// src/services/upload-chat-transcripts.ts
-import { readdir as readdir3, readFile as readFile10 } from "fs/promises";
-import { basename, join as join14 } from "path";
+// src/services/canvas-service.ts
+import { readdir as readdir3, readFile as readFile10, stat as stat2 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-var ENGINE_DIR2 = join14(homedir12(), ".replicas", "engine");
+import { join as join14 } from "path";
+var CANVAS_DIRECTORIES = [
+  join14(homedir12(), ".claude", "plans"),
+  join14(homedir12(), ".replicas", "canvas")
+];
+var CanvasService = class {
+  async listItems() {
+    const items = /* @__PURE__ */ new Map();
+    for (const directory of CANVAS_DIRECTORIES) {
+      let entries;
+      try {
+        entries = await readdir3(directory, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (entry.name.startsWith(".")) continue;
+        if (items.has(entry.name)) continue;
+        const { kind } = classifyCanvasFilename(entry.name);
+        let sizeBytes = 0;
+        try {
+          const s = await stat2(join14(directory, entry.name));
+          sizeBytes = s.size;
+        } catch {
+          continue;
+        }
+        items.set(entry.name, { filename: entry.name, kind, sizeBytes });
+      }
+    }
+    return Array.from(items.values()).sort((a, b) => a.filename.localeCompare(b.filename));
+  }
+  async getItemFile(filename) {
+    const safe = sanitizeCanvasFilename(filename);
+    if (!safe) return null;
+    const { kind, mimeType } = classifyCanvasFilename(safe);
+    for (const directory of CANVAS_DIRECTORIES) {
+      const filePath = join14(directory, safe);
+      let sizeBytes = 0;
+      let updatedAt = "";
+      try {
+        const s = await stat2(filePath);
+        sizeBytes = s.size;
+        updatedAt = s.mtime.toISOString();
+      } catch {
+        continue;
+      }
+      if (sizeBytes > MAX_CANVAS_FILE_BYTES) {
+        return {
+          filename: safe,
+          kind,
+          sizeBytes,
+          mimeType,
+          updatedAt,
+          tooLarge: true
+        };
+      }
+      try {
+        const bytes = await readFile10(filePath);
+        return { filename: safe, kind, sizeBytes, mimeType, updatedAt, bytes };
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  async getItem(filename) {
+    const item = await this.getItemFile(filename);
+    if (!item) return null;
+    if (item.tooLarge || !item.bytes) {
+      return {
+        filename: item.filename,
+        kind: item.kind,
+        sizeBytes: item.sizeBytes,
+        mimeType: item.mimeType,
+        tooLarge: true
+      };
+    }
+    return serializeCanvasContentResponse({
+      filename: item.filename,
+      kind: item.kind,
+      sizeBytes: item.sizeBytes,
+      mimeType: item.mimeType,
+      bytes: item.bytes
+    });
+  }
+};
+var canvasService = new CanvasService();
+
+// src/services/upload-canvas-items.ts
+var uploadedCanvasItems = /* @__PURE__ */ new Map();
+function isReconcileCanvasItemsResponse(value) {
+  return typeof value === "object" && value !== null && "deleted" in value && typeof value.deleted === "number" && (!("skipped" in value) || typeof value.skipped === "string");
+}
+async function flushAllCanvasItems() {
+  let flushed = 0;
+  let skipped = 0;
+  let failed = 0;
+  let deleted = 0;
+  const filenames = [];
+  const items = await canvasService.listItems();
+  await Promise.all(items.map(async (item) => {
+    if (item.sizeBytes > MAX_CANVAS_FILE_BYTES) {
+      skipped++;
+      return;
+    }
+    try {
+      const file = await canvasService.getItemFile(item.filename);
+      if (!file?.bytes || file.tooLarge) {
+        skipped++;
+        return;
+      }
+      const uploaded = uploadedCanvasItems.get(file.filename);
+      if (uploaded?.sizeBytes === file.sizeBytes && uploaded.updatedAt === file.updatedAt) {
+        filenames.push(file.filename);
+        skipped++;
+        return;
+      }
+      await uploadCanvasItem(file);
+      uploadedCanvasItems.set(file.filename, { sizeBytes: file.sizeBytes, updatedAt: file.updatedAt });
+      filenames.push(file.filename);
+      flushed++;
+    } catch (err) {
+      failed++;
+      console.error("[CanvasUploader] upload failed:", { filename: item.filename, err });
+    }
+  }));
+  if (failed === 0) {
+    try {
+      deleted = await reconcileCanvasItems(filenames);
+      const currentFilenames = new Set(filenames);
+      for (const filename of uploadedCanvasItems.keys()) {
+        if (!currentFilenames.has(filename)) uploadedCanvasItems.delete(filename);
+      }
+    } catch (err) {
+      failed++;
+      console.error("[CanvasUploader] reconcile failed:", err);
+    }
+  }
+  return { flushed, skipped, failed, deleted };
+}
+async function uploadCanvasItem(item) {
+  if (!item.bytes || item.tooLarge) return;
+  const form = new FormData();
+  form.append("filename", item.filename);
+  form.append("updated_at", item.updatedAt);
+  form.append(
+    "file",
+    new Blob([item.bytes], { type: item.mimeType }),
+    item.filename
+  );
+  const response = await monolithRequest("/v1/engine/canvas", { body: form });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`upload failed: ${response.status} ${errorText}`);
+  }
+}
+async function reconcileCanvasItems(filenames) {
+  const response = await monolithRequest("/v1/engine/canvas/reconcile", {
+    body: { filenames }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`reconcile failed: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  if (!isReconcileCanvasItemsResponse(data)) {
+    throw new Error("Invalid response from reconcile endpoint");
+  }
+  return data.deleted;
+}
+
+// src/services/upload-chat-transcripts.ts
+import { readdir as readdir4, readFile as readFile11 } from "fs/promises";
+import { basename, join as join15 } from "path";
+import { homedir as homedir13 } from "os";
+var ENGINE_DIR2 = join15(homedir13(), ".replicas", "engine");
 var HISTORY_DIRS = [
-  join14(ENGINE_DIR2, "claude-histories"),
-  join14(ENGINE_DIR2, "relay-histories"),
-  join14(ENGINE_DIR2, "codex-histories")
+  join15(ENGINE_DIR2, "claude-histories"),
+  join15(ENGINE_DIR2, "relay-histories"),
+  join15(ENGINE_DIR2, "codex-histories")
 ];
 async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   let flushed = 0;
@@ -9166,7 +9375,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   for (const dir of HISTORY_DIRS) {
     let entries;
     try {
-      entries = await readdir3(dir);
+      entries = await readdir4(dir);
     } catch {
       continue;
     }
@@ -9174,7 +9383,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
       if (!entry.endsWith(".jsonl")) continue;
       const chatId = basename(entry, ".jsonl");
       tasks.push(
-        uploadChatTranscript(chatId, join14(dir, entry), chatsById.get(chatId)).then(() => {
+        uploadChatTranscript(chatId, join15(dir, entry), chatsById.get(chatId)).then(() => {
           flushed++;
         }).catch((err) => {
           failed++;
@@ -9187,7 +9396,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   return { flushed, failed };
 }
 async function uploadChatTranscript(chatId, filePath, chat) {
-  const bytes = await readFile10(filePath);
+  const bytes = await readFile11(filePath);
   if (bytes.byteLength === 0) return;
   const form = new FormData();
   form.append("chat_id", chatId);
@@ -9244,18 +9453,18 @@ var DuplicateDefaultChatError = class extends Error {
 };
 
 // src/services/chat/chat-service.ts
-var ENGINE_DIR3 = join15(homedir13(), ".replicas", "engine");
-var CHATS_FILE = join15(ENGINE_DIR3, "chats.json");
-var CLAUDE_HISTORY_DIR = join15(ENGINE_DIR3, "claude-histories");
-var RELAY_HISTORY_DIR = join15(ENGINE_DIR3, "relay-histories");
-var CODEX_HISTORY_DIR = join15(ENGINE_DIR3, "codex-histories");
+var ENGINE_DIR3 = join16(homedir14(), ".replicas", "engine");
+var CHATS_FILE = join16(ENGINE_DIR3, "chats.json");
+var CLAUDE_HISTORY_DIR = join16(ENGINE_DIR3, "claude-histories");
+var RELAY_HISTORY_DIR = join16(ENGINE_DIR3, "relay-histories");
+var CODEX_HISTORY_DIR = join16(ENGINE_DIR3, "codex-histories");
 var HISTORY_DIR_BY_PROVIDER = {
   claude: CLAUDE_HISTORY_DIR,
   relay: RELAY_HISTORY_DIR,
   codex: CODEX_HISTORY_DIR
 };
-var CHAT_SENDERS_DIR = join15(ENGINE_DIR3, "chat-senders");
-var CODEX_AUTH_PATH2 = join15(homedir13(), ".codex", "auth.json");
+var CHAT_SENDERS_DIR = join16(ENGINE_DIR3, "chat-senders");
+var CODEX_AUTH_PATH2 = join16(homedir14(), ".codex", "auth.json");
 var CHATS_BACKUP_FILE = `${CHATS_FILE}.bak`;
 function isChatMessageSender(value) {
   if (!isRecord4(value)) return false;
@@ -9453,7 +9662,7 @@ var ChatService = class {
     };
   }
   senderFilePath(chatId) {
-    return join15(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
+    return join16(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
   }
   async appendSender(chatId, sender) {
     try {
@@ -9464,7 +9673,7 @@ var ChatService = class {
   }
   async readSenders(chatId) {
     try {
-      const content = await readFile11(this.senderFilePath(chatId), "utf-8");
+      const content = await readFile12(this.senderFilePath(chatId), "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       const senders = [];
       for (const line of lines) {
@@ -9609,7 +9818,7 @@ var ChatService = class {
     return descendants;
   }
   async deleteHistoryFile(persisted) {
-    await rm(join15(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
+    await rm(join16(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
     await rm(this.senderFilePath(persisted.id), { force: true });
   }
   async getChatHistory(chatId) {
@@ -9647,6 +9856,16 @@ var ChatService = class {
       [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
     ));
   }
+  async flushAllWorkspaceArtifacts() {
+    const chatsById = new Map(
+      [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
+    );
+    const [chatTranscripts, canvas] = await Promise.all([
+      flushAllChatTranscripts(chatsById),
+      flushAllCanvasItems()
+    ]);
+    return { chatTranscripts, canvas };
+  }
   createRuntimeChat(persisted) {
     const saveSession = async (sessionId) => {
       persisted.providerSessionId = sessionId;
@@ -9670,7 +9889,7 @@ var ChatService = class {
     if (persisted.provider === "claude") {
       provider = new ClaudeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join15(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join16(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -9679,7 +9898,7 @@ var ChatService = class {
     } else if (persisted.provider === "relay") {
       provider = new RelayManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join15(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join16(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -9690,7 +9909,7 @@ var ChatService = class {
     } else {
       provider = new CodexAspManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join15(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join16(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -9828,11 +10047,14 @@ var ChatService = class {
     });
     uploadChatTranscript(
       chatId,
-      join15(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
+      join16(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
       this.toSummary(chat)
     ).catch((err) => {
       console.error("[ChatService] Failed to upload chat transcript:", { chatId, err });
     });
+    flushAllCanvasItems().catch((err) => {
+      console.error("[ChatService] Failed to upload canvas items:", { chatId, err });
+    });
     await this.publishAgentTurnCompleteWebhook(chat);
   }
   getRuntimeChat(chatId) {
@@ -9840,7 +10062,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile11(CHATS_FILE, "utf-8");
+      const content = await readFile12(CHATS_FILE, "utf-8");
       return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -9855,7 +10077,7 @@ var ChatService = class {
         console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
       }
       try {
-        const backupContent = await readFile11(CHATS_BACKUP_FILE, "utf-8");
+        const backupContent = await readFile12(CHATS_BACKUP_FILE, "utf-8");
         return parsePersistedChatsContent(backupContent);
       } catch (backupError) {
         if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
@@ -9940,8 +10162,8 @@ var ChatService = class {
 
 // src/services/repo-file-service.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile12, realpath, stat as stat2 } from "fs/promises";
-import { join as join16, resolve, extname } from "path";
+import { readFile as readFile13, realpath, stat as stat3 } from "fs/promises";
+import { join as join17, resolve, extname } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
 var MAX_CONTENT_BYTES = 256 * 1024;
@@ -10001,11 +10223,11 @@ function scoreMatch(query2, filePath) {
   const lowerQuery = query2.toLowerCase();
   const lowerPath = filePath.toLowerCase();
   const segments = lowerPath.split("/");
-  const basename3 = segments[segments.length - 1] ?? "";
-  if (basename3 === lowerQuery) return 100;
-  if (basename3.startsWith(lowerQuery)) return 90;
+  const basename2 = segments[segments.length - 1] ?? "";
+  if (basename2 === lowerQuery) return 100;
+  if (basename2.startsWith(lowerQuery)) return 90;
   if (segments.some((seg) => seg === lowerQuery)) return 80;
-  if (basename3.includes(lowerQuery)) return 70;
+  if (basename2.includes(lowerQuery)) return 70;
   if (segments.some((seg) => seg.includes(lowerQuery))) return 60;
   if (lowerPath.includes(lowerQuery)) return 50;
   return 0;
@@ -10101,11 +10323,11 @@ var RepoFileService = class {
     const repo = repos.find((r) => r.name === repoName);
     if (!repo) return null;
     try {
-      const fullPath = await realpath(resolve(join16(repo.path, filePath)));
+      const fullPath = await realpath(resolve(join17(repo.path, filePath)));
       const repoRoot = await realpath(repo.path);
       const repoPrefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
       if (!fullPath.startsWith(repoPrefix) && fullPath !== repoRoot) return null;
-      const fileStat = await stat2(fullPath);
+      const fileStat = await stat3(fullPath);
       if (!fileStat.isFile()) return null;
       const sizeBytes = fileStat.size;
       if (isBinaryExtension(filePath)) {
@@ -10130,7 +10352,7 @@ var RepoFileService = class {
           tooLarge: true
         };
       }
-      const content = await readFile12(fullPath, "utf-8");
+      const content = await readFile13(fullPath, "utf-8");
       return {
         repoName,
         path: filePath,
@@ -10211,86 +10433,6 @@ import { z as z2 } from "zod";
 import { readdir as readdir6, stat as stat4, readFile as readFile16 } from "fs/promises";
 import { join as join20, resolve as resolve2 } from "path";
 
-// src/services/canvas-service.ts
-import { readdir as readdir4, readFile as readFile13, stat as stat3 } from "fs/promises";
-import { homedir as homedir14 } from "os";
-import { basename as basename2, join as join17 } from "path";
-var CANVAS_DIRECTORIES = [
-  join17(homedir14(), ".claude", "plans"),
-  join17(homedir14(), ".replicas", "canvas")
-];
-var MAX_CANVAS_FILE_BYTES = 5 * 1024 * 1024;
-function isTextKind(kind) {
-  return kind === "markdown" || kind === "html";
-}
-function sanitizeFilename(filename) {
-  return basename2(filename);
-}
-var CanvasService = class {
-  async listItems() {
-    const items = /* @__PURE__ */ new Map();
-    for (const directory of CANVAS_DIRECTORIES) {
-      let entries;
-      try {
-        entries = await readdir4(directory, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        if (!entry.isFile()) continue;
-        if (entry.name.startsWith(".")) continue;
-        if (items.has(entry.name)) continue;
-        const { kind } = classifyCanvasFilename(entry.name);
-        let sizeBytes = 0;
-        try {
-          const s = await stat3(join17(directory, entry.name));
-          sizeBytes = s.size;
-        } catch {
-          continue;
-        }
-        items.set(entry.name, { filename: entry.name, kind, sizeBytes });
-      }
-    }
-    return Array.from(items.values()).sort((a, b) => a.filename.localeCompare(b.filename));
-  }
-  async getItem(filename) {
-    const safe = sanitizeFilename(filename);
-    if (!safe || safe !== filename || safe.startsWith(".")) return null;
-    const { kind, mimeType } = classifyCanvasFilename(safe);
-    for (const directory of CANVAS_DIRECTORIES) {
-      const filePath = join17(directory, safe);
-      let sizeBytes = 0;
-      try {
-        const s = await stat3(filePath);
-        sizeBytes = s.size;
-      } catch {
-        continue;
-      }
-      if (sizeBytes > MAX_CANVAS_FILE_BYTES) {
-        return {
-          filename: safe,
-          kind,
-          sizeBytes,
-          mimeType,
-          tooLarge: true
-        };
-      }
-      try {
-        if (isTextKind(kind)) {
-          const content = await readFile13(filePath, "utf-8");
-          return { filename: safe, kind, sizeBytes, mimeType, content };
-        }
-        const buf = await readFile13(filePath);
-        return { filename: safe, kind, sizeBytes, mimeType, base64: buf.toString("base64") };
-      } catch {
-        continue;
-      }
-    }
-    return null;
-  }
-};
-var canvasService = new CanvasService();
-
 // src/services/warm-hooks-service.ts
 import { spawn as spawn4 } from "child_process";
 import { readFile as readFile15 } from "fs/promises";
@@ -10907,6 +11049,17 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.post("/workspace-artifacts/flush-all", async (c) => {
+    try {
+      const result = await deps.chatService.flushAllWorkspaceArtifacts();
+      return c.json(result);
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to flush workspace artifacts", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
   app2.get("/chats/:chatId/queue", (c) => {
     try {
       const result = deps.chatService.getChatQueue(c.req.param("chatId"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.309",
+  "version": "0.1.313",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",