replicas-engine 0.1.50 → 0.1.52

package/dist/src/index.js

@@ -44,35 +44,36 @@ function requireValidURL(value, name) {
     throw new Error(`Invalid engine environment: ${name} must be a valid URL`);
   }
 }
+var IS_WARMING_MODE = process.argv.includes("--warming");
 function loadEngineEnv() {
-  const HOME_DIR = readEnv("HOME") ?? homedir();
-  return {
-    // Required boot env.
+  const HOME_DIR = homedir();
+  const env = {
+    // Defined: always available
     REPLICAS_ENGINE_SECRET: requireDefined(readEnv("REPLICAS_ENGINE_SECRET"), "REPLICAS_ENGINE_SECRET"),
-    WORKSPACE_ID: requireDefined(readEnv("WORKSPACE_ID"), "WORKSPACE_ID"),
-    MONOLITH_URL: requireValidURL(requireDefined(readEnv("MONOLITH_URL"), "MONOLITH_URL"), "MONOLITH_URL"),
-    // Engine config defaults.
     REPLICAS_ENGINE_PORT: parsePort(readEnv("REPLICAS_ENGINE_PORT")),
+    MONOLITH_URL: requireValidURL(requireDefined(readEnv("MONOLITH_URL"), "MONOLITH_URL"), "MONOLITH_URL"),
+    GH_TOKEN: readEnv("GH_TOKEN"),
     HOME_DIR,
     WORKSPACE_ROOT: join(HOME_DIR, "workspaces"),
-    // Engine-consumed optional values.
+    // Runtime: may not be set during warming
+    WORKSPACE_ID: readEnv("WORKSPACE_ID"),
     WORKSPACE_NAME: readEnv("WORKSPACE_NAME"),
     LINEAR_SESSION_ID: readEnv("LINEAR_SESSION_ID"),
     LINEAR_ACCESS_TOKEN: readEnv("LINEAR_ACCESS_TOKEN"),
     SLACK_BOT_TOKEN: readEnv("SLACK_BOT_TOKEN"),
-    GH_TOKEN: readEnv("GH_TOKEN"),
-    // Ambient runtime values
-    // not directly used by the engine code, but are required in the VM
-    // for use by the agent or SDKs (e.g claude/codex)
+    SLACK_CHANNEL_ID: readEnv("SLACK_CHANNEL_ID"),
+    SLACK_THREAD_TS: readEnv("SLACK_THREAD_TS"),
     ANTHROPIC_API_KEY: readEnv("ANTHROPIC_API_KEY"),
     OPENAI_API_KEY: readEnv("OPENAI_API_KEY"),
     CLAUDE_CODE_USE_BEDROCK: readEnv("CLAUDE_CODE_USE_BEDROCK"),
     AWS_ACCESS_KEY_ID: readEnv("AWS_ACCESS_KEY_ID"),
     AWS_SECRET_ACCESS_KEY: readEnv("AWS_SECRET_ACCESS_KEY"),
-    AWS_REGION: readEnv("AWS_REGION"),
-    SLACK_CHANNEL_ID: readEnv("SLACK_CHANNEL_ID"),
-    SLACK_THREAD_TS: readEnv("SLACK_THREAD_TS")
+    AWS_REGION: readEnv("AWS_REGION")
   };
+  if (!IS_WARMING_MODE && !env.WORKSPACE_ID) {
+    console.error("WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
+  }
+  return env;
 }
 var ENGINE_ENV = loadEngineEnv();
 
@@ -96,7 +97,7 @@ var BaseRefreshManager = class {
     if (this.intervalHandle) {
       return;
     }
-    const skipReason = this.getSkipReasonForRun();
+    const skipReason = this.getSkipReason();
     if (skipReason) {
       console.log(`[${this.managerName}] Skipping: ${skipReason}`);
       return;
@@ -127,21 +128,17 @@ var BaseRefreshManager = class {
     return null;
   }
   getRuntimeConfig() {
+    if (!ENGINE_ENV.WORKSPACE_ID) {
+      return null;
+    }
     return {
       monolithUrl: ENGINE_ENV.MONOLITH_URL,
       workspaceId: ENGINE_ENV.WORKSPACE_ID,
       engineSecret: ENGINE_ENV.REPLICAS_ENGINE_SECRET
     };
   }
-  getSkipReasonForRun() {
-    const skipReason = this.getSkipReason();
-    if (skipReason) {
-      return skipReason;
-    }
-    return null;
-  }
   async refreshOnce() {
-    if (this.getSkipReasonForRun()) {
+    if (this.getSkipReason()) {
       return;
     }
     const config = this.getRuntimeConfig();
@@ -830,10 +827,12 @@ var EngineLogger = class {
 var engineLogger = new EngineLogger();
 
 // src/services/environment-details-service.ts
-import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
 
 // ../shared/src/sandbox.ts
 var SANDBOX_LIFECYCLE = {
@@ -842,6 +841,14 @@ var SANDBOX_LIFECYCLE = {
   AUTO_DELETE_MINUTES: -1,
   SSH_TOKEN_EXPIRATION_MINUTES: 3 * 60
 };
+var SANDBOX_PATHS = {
+  HOME_DIR: "/home/ubuntu",
+  WORKSPACES_DIR: "/home/ubuntu/workspaces",
+  REPLICAS_DIR: "/home/ubuntu/.replicas",
+  REPLICAS_FILES_DIR: "/home/ubuntu/.replicas/files",
+  REPLICAS_FILES_DISPLAY_DIR: "~/.replicas/files",
+  REPLICAS_RUNTIME_ENV_FILE: "/home/ubuntu/.replicas/runtime-env.sh"
+};
 
 // ../shared/src/warm-hooks.ts
 var DEFAULT_WARM_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -911,137 +918,190 @@ var WORKSPACE_FILE_UPLOAD_MAX_SIZE_BYTES = 20 * 1024 * 1024;
 var WORKSPACE_FILE_CONTENT_MAX_SIZE_BYTES = 1 * 1024 * 1024;
 
 // src/services/environment-details-service.ts
-var REPLICAS_DIR = join5(homedir4(), ".replicas");
-var ENVIRONMENT_DETAILS_FILE = join5(REPLICAS_DIR, "environment-details.json");
-function createExecutionItem(status, details) {
-  return { status, details: details ?? null };
+var execFileAsync = promisify(execFile);
+var REPLICAS_DIR = SANDBOX_PATHS.REPLICAS_DIR;
+var RUNTIME_ENV_FILE = SANDBOX_PATHS.REPLICAS_RUNTIME_ENV_FILE;
+var FILES_DIR = SANDBOX_PATHS.REPLICAS_FILES_DIR;
+var PERSISTED_STATE_FILE = join5(REPLICAS_DIR, "environment-details.json");
+var CLAUDE_CREDENTIALS_PATH = join5(homedir4(), ".claude", ".credentials.json");
+var CODEX_AUTH_PATH = join5(homedir4(), ".codex", "auth.json");
+function detectClaudeAuthMethod() {
+  if (existsSync3(CLAUDE_CREDENTIALS_PATH)) {
+    return "oauth";
+  }
+  if (ENGINE_ENV.CLAUDE_CODE_USE_BEDROCK && ENGINE_ENV.AWS_ACCESS_KEY_ID && ENGINE_ENV.AWS_SECRET_ACCESS_KEY) {
+    return "bedrock";
+  }
+  if (ENGINE_ENV.ANTHROPIC_API_KEY) {
+    return "api_key";
+  }
+  return "none";
+}
+function detectCodexAuthMethod() {
+  if (existsSync3(CODEX_AUTH_PATH)) {
+    return "oauth";
+  }
+  if (ENGINE_ENV.OPENAI_API_KEY) {
+    return "api_key";
+  }
+  return "none";
+}
+async function detectGitIdentityConfigured() {
+  try {
+    const { stdout } = await execFileAsync("git", ["config", "--global", "user.name"]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function parseRuntimeEnvKeys() {
+  try {
+    if (!existsSync3(RUNTIME_ENV_FILE)) {
+      return [];
+    }
+    const content = await readFile2(RUNTIME_ENV_FILE, "utf-8");
+    const keys = [];
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("export ")) {
+        continue;
+      }
+      const assignment = trimmed.slice("export ".length);
+      const eqIndex = assignment.indexOf("=");
+      if (eqIndex > 0) {
+        const key = assignment.slice(0, eqIndex).trim();
+        if (key) {
+          keys.push(key);
+        }
+      }
+    }
+    return keys;
+  } catch {
+    return [];
+  }
 }
-function createDefaultDetails() {
+async function detectStaticState() {
+  const [repositories, gitIdentityConfigured, runtimeEnvKeys] = await Promise.all([
+    gitService.listRepositories(),
+    detectGitIdentityConfigured(),
+    parseRuntimeEnvKeys()
+  ]);
   return {
-    engineVersion: REPLICAS_ENGINE_VERSION,
-    globalWarmHookCompleted: createExecutionItem("n/a"),
-    repositories: [],
-    filesUploaded: [],
-    envVarsSet: [],
-    skillsInstalled: [],
-    runtimeEnvVarsSet: [],
-    repositoriesCloned: [],
-    gitIdentityConfigured: false,
-    githubCredentialsConfigured: false,
-    codexAuthConfigured: false,
-    claudeAuthConfigured: false,
-    bedrockAuthConfigured: false,
-    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    repositoriesCloned: repositories.map((repo) => repo.name),
+    gitIdentityConfigured,
+    envVarsSet: runtimeEnvKeys,
+    runtimeEnvVarsSet: runtimeEnvKeys,
+    claudeAuthMethod: detectClaudeAuthMethod(),
+    codexAuthMethod: detectCodexAuthMethod(),
+    githubAccessConfigured: Boolean(ENGINE_ENV.GH_TOKEN),
+    githubCredentialsConfigured: Boolean(ENGINE_ENV.GH_TOKEN),
+    linearAccessConfigured: Boolean(ENGINE_ENV.LINEAR_SESSION_ID || ENGINE_ENV.LINEAR_ACCESS_TOKEN),
+    slackAccessConfigured: Boolean(ENGINE_ENV.SLACK_BOT_TOKEN)
   };
 }
-function mergeUnique(current, incoming) {
-  if (!incoming || incoming.length === 0) {
-    return current;
+async function detectUploadedFiles() {
+  try {
+    if (!existsSync3(FILES_DIR)) {
+      return [];
+    }
+    const entries = await readdir2(FILES_DIR);
+    return entries.filter((entry) => !entry.startsWith(".")).map((entry) => `${SANDBOX_PATHS.REPLICAS_FILES_DISPLAY_DIR}/${entry}`);
+  } catch {
+    return [];
   }
-  return Array.from(/* @__PURE__ */ new Set([...current, ...incoming]));
+}
+function createDefaultPersistedState() {
+  return {
+    globalWarmHookCompleted: { status: "n/a", details: null },
+    repositories: [],
+    skillsInstalled: []
+  };
 }
 function upsertRepositoryStatus(current, incoming) {
-  const byName = new Map(current.map((repository) => [repository.repositoryName, repository]));
-  for (const repository of incoming) {
-    const existing = byName.get(repository.repositoryName);
-    byName.set(repository.repositoryName, {
-      repositoryName: repository.repositoryName,
-      warmHookCompleted: repository.warmHookCompleted !== "n/a" ? repository.warmHookCompleted : existing?.warmHookCompleted ?? "n/a",
-      startHookCompleted: repository.startHookCompleted !== "n/a" ? repository.startHookCompleted : existing?.startHookCompleted ?? "n/a"
+  const byName = new Map(current.map((r) => [r.repositoryName, r]));
+  for (const repo of incoming) {
+    const existing = byName.get(repo.repositoryName);
+    byName.set(repo.repositoryName, {
+      repositoryName: repo.repositoryName,
+      warmHookCompleted: repo.warmHookCompleted !== "n/a" ? repo.warmHookCompleted : existing?.warmHookCompleted ?? "n/a",
+      startHookCompleted: repo.startHookCompleted !== "n/a" ? repo.startHookCompleted : existing?.startHookCompleted ?? "n/a"
     });
   }
   return [...byName.values()].sort((a, b) => a.repositoryName.localeCompare(b.repositoryName));
 }
+async function readPersistedState() {
+  try {
+    if (!existsSync3(PERSISTED_STATE_FILE)) {
+      return createDefaultPersistedState();
+    }
+    const raw = await readFile2(PERSISTED_STATE_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...createDefaultPersistedState(), ...parsed };
+  } catch {
+    return createDefaultPersistedState();
+  }
+}
+async function writePersistedState(state) {
+  await mkdir3(REPLICAS_DIR, { recursive: true });
+  await writeFile3(PERSISTED_STATE_FILE, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
 var EnvironmentDetailsService = class {
+  staticState = null;
   async initialize() {
-    const current = await this.readDetails();
-    const repositories = await gitService.listRepositories();
-    const merged = upsertRepositoryStatus(
-      current.repositories,
-      repositories.map((repository) => ({
-        repositoryName: repository.name,
+    this.staticState = await detectStaticState();
+    const persisted = await readPersistedState();
+    persisted.repositories = upsertRepositoryStatus(
+      persisted.repositories,
+      this.staticState.repositoriesCloned.map((name) => ({
+        repositoryName: name,
         warmHookCompleted: "n/a",
         startHookCompleted: "n/a"
       }))
     );
-    await this.writeDetails({
-      ...current,
-      engineVersion: REPLICAS_ENGINE_VERSION,
-      repositories: merged,
-      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
+    await writePersistedState(persisted);
   }
   async getDetails() {
-    const current = await this.readDetails();
+    const staticState = this.staticState ?? await detectStaticState();
+    const [persisted, filesUploaded] = await Promise.all([
+      readPersistedState(),
+      detectUploadedFiles()
+    ]);
     return {
-      ...current,
-      engineVersion: REPLICAS_ENGINE_VERSION
-    };
-  }
-  async track(update) {
-    const current = await this.readDetails();
-    const next = {
-      ...current,
       engineVersion: REPLICAS_ENGINE_VERSION,
-      globalWarmHookCompleted: update.globalWarmHookCompleted ?? current.globalWarmHookCompleted,
-      repositories: update.repositories ? upsertRepositoryStatus(current.repositories, update.repositories) : current.repositories,
-      filesUploaded: mergeUnique(current.filesUploaded, update.filesUploaded),
-      envVarsSet: mergeUnique(current.envVarsSet, update.envVarsSet),
-      skillsInstalled: mergeUnique(current.skillsInstalled, update.skillsInstalled),
-      runtimeEnvVarsSet: mergeUnique(current.runtimeEnvVarsSet, update.runtimeEnvVarsSet),
-      repositoriesCloned: mergeUnique(current.repositoriesCloned, update.repositoriesCloned),
-      gitIdentityConfigured: update.gitIdentityConfigured ?? current.gitIdentityConfigured,
-      githubCredentialsConfigured: update.githubCredentialsConfigured ?? current.githubCredentialsConfigured,
-      codexAuthConfigured: update.codexAuthConfigured ?? current.codexAuthConfigured,
-      claudeAuthConfigured: update.claudeAuthConfigured ?? current.claudeAuthConfigured,
-      bedrockAuthConfigured: update.bedrockAuthConfigured ?? current.bedrockAuthConfigured,
+      ...staticState,
+      ...persisted,
+      filesUploaded,
       lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await this.writeDetails(next);
-    return next;
+  }
+  async trackSkillsInstalled(skills) {
+    const persisted = await readPersistedState();
+    persisted.skillsInstalled = Array.from(/* @__PURE__ */ new Set([...persisted.skillsInstalled, ...skills]));
+    await writePersistedState(persisted);
   }
   async setGlobalWarmHook(status, details) {
-    await this.track({
-      globalWarmHookCompleted: createExecutionItem(status, details)
-    });
+    const persisted = await readPersistedState();
+    persisted.globalWarmHookCompleted = { status, details: details ?? null };
+    await writePersistedState(persisted);
   }
   async setRepositoryWarmHook(repositoryName, status) {
-    await this.track({
-      repositories: [{
-        repositoryName,
-        warmHookCompleted: status,
-        startHookCompleted: "n/a"
-      }]
-    });
+    const persisted = await readPersistedState();
+    persisted.repositories = upsertRepositoryStatus(persisted.repositories, [{
+      repositoryName,
+      warmHookCompleted: status,
+      startHookCompleted: "n/a"
+    }]);
+    await writePersistedState(persisted);
   }
   async setRepositoryStartHook(repositoryName, status) {
-    await this.track({
-      repositories: [{
-        repositoryName,
-        warmHookCompleted: "n/a",
-        startHookCompleted: status
-      }]
-    });
-  }
-  async readDetails() {
-    try {
-      if (!existsSync3(ENVIRONMENT_DETAILS_FILE)) {
-        return createDefaultDetails();
-      }
-      const raw = await readFile2(ENVIRONMENT_DETAILS_FILE, "utf-8");
-      return {
-        ...createDefaultDetails(),
-        ...JSON.parse(raw),
-        engineVersion: REPLICAS_ENGINE_VERSION
-      };
-    } catch {
-      return createDefaultDetails();
-    }
-  }
-  async writeDetails(details) {
-    await mkdir3(REPLICAS_DIR, { recursive: true });
-    await writeFile3(ENVIRONMENT_DETAILS_FILE, `${JSON.stringify(details, null, 2)}
-`, "utf-8");
+    const persisted = await readPersistedState();
+    persisted.repositories = upsertRepositoryStatus(persisted.repositories, [{
+      repositoryName,
+      warmHookCompleted: "n/a",
+      startHookCompleted: status
+    }]);
+    await writePersistedState(persisted);
   }
 };
 var environmentDetailsService = new EnvironmentDetailsService();
@@ -1052,8 +1112,8 @@ import { existsSync as existsSync4 } from "fs";
 import { join as join6 } from "path";
 import { homedir as homedir5 } from "os";
 import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
+import { promisify as promisify2 } from "util";
+var execAsync = promisify2(exec);
 var START_HOOKS_LOG = join6(homedir5(), ".replicas", "startHooks.log");
 var START_HOOKS_RUNNING_PROMPT = `IMPORTANT - Start Hooks Running:
 Start hooks are shell commands/scripts set by repository owners that run on workspace startup.
@@ -1398,6 +1458,9 @@ async function readJSONL(filePath) {
 // src/services/monolith-service.ts
 var MonolithService = class {
   async sendEvent(event) {
+    if (!ENGINE_ENV.WORKSPACE_ID) {
+      return;
+    }
     try {
       const response = await fetch(`${ENGINE_ENV.MONOLITH_URL}/v1/engine/webhook`, {
         method: "POST",
@@ -2289,7 +2352,7 @@ var ClaudeManager = class extends CodingAgentManager {
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
 import { randomUUID as randomUUID2 } from "crypto";
-import { readdir as readdir2, stat as stat2, writeFile as writeFile5, mkdir as mkdir7, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir3, stat as stat2, writeFile as writeFile5, mkdir as mkdir7, readFile as readFile5 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir8 } from "os";
@@ -2531,7 +2594,7 @@ var CodexManager = class extends CodingAgentManager {
   }
   async findFileInDirectory(directory, threadId) {
     try {
-      const files = await readdir2(directory);
+      const files = await readdir3(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
           const fullPath = join9(directory, file);
@@ -2933,7 +2996,7 @@ import { Hono } from "hono";
 import { z } from "zod";
 
 // src/services/plan-service.ts
-import { readdir as readdir3, readFile as readFile7 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile7 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { basename, join as join11 } from "path";
 var PLAN_DIRECTORIES = [
@@ -2951,7 +3014,7 @@ var PlanService = class {
     const planNames = /* @__PURE__ */ new Set();
     for (const directory of PLAN_DIRECTORIES) {
       try {
-        const entries = await readdir3(directory, { withFileTypes: true });
+        const entries = await readdir4(directory, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isFile()) {
             continue;
@@ -2985,15 +3048,15 @@ var PlanService = class {
 var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
-import { execFile } from "child_process";
-import { promisify as promisify2 } from "util";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify3 } from "util";
 import { readFile as readFile8 } from "fs/promises";
 import { join as join12 } from "path";
-var execFileAsync = promisify2(execFile);
+var execFileAsync2 = promisify3(execFile2);
 async function installSkill(params) {
   const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
   try {
-    const { stdout, stderr } = await execFileAsync(
+    const { stdout, stderr } = await execFileAsync2(
       "npx",
       ["skills", "add", params.source, "--all", "--global"],
       {
@@ -3029,7 +3092,7 @@ async function installSkill(params) {
 async function executeHookScript(params) {
   const timeout = clampWarmHookTimeoutMs(params.timeoutMs);
   try {
-    const { stdout, stderr } = await execFileAsync("bash", ["-lc", params.content], {
+    const { stdout, stderr } = await execFileAsync2("bash", ["-lc", params.content], {
       cwd: params.cwd,
       timeout,
       maxBuffer: 1024 * 1024,
@@ -3100,7 +3163,7 @@ async function runWarmHooks(params) {
     });
     outputBlocks.push(installResult.output);
     if (installResult.exitCode === 0) {
-      await environmentDetailsService.track({ skillsInstalled: [source] });
+      await environmentDetailsService.trackSkillsInstalled([source]);
     }
     if (installResult.exitCode !== 0) {
       await environmentDetailsService.setGlobalWarmHook("no", installResult.output);
@@ -3418,18 +3481,6 @@ function createV1Routes(deps) {
       );
     }
   });
-  app2.post("/environment/track", async (c) => {
-    try {
-      const body = await c.req.json();
-      const details = await environmentDetailsService.track(body);
-      return c.json(details);
-    } catch (error) {
-      return c.json(
-        jsonError("Failed to track environment details", error instanceof Error ? error.message : "Unknown error"),
-        500
-      );
-    }
-  });
   app2.post("/warm-hooks/run", async (c) => {
     try {
       const body = await c.req.json();
@@ -3642,7 +3693,11 @@ serve(
     port
   },
   async (info) => {
-    console.log(`Replicas Engine running on port ${info.port}`);
+    if (IS_WARMING_MODE) {
+      console.log(`Replicas Engine running on port ${info.port} (warming mode)`);
+    } else {
+      console.log(`Replicas Engine running on port ${info.port}`);
+    }
     const gitResult = await gitService.initializeGitRepository();
     if (!gitResult.success) {
       console.warn(`Git initialization warning: ${gitResult.error}`);
@@ -3650,9 +3705,11 @@ serve(
     await replicasConfigService.initialize();
     await chatService.initialize();
     engineReady = true;
-    await githubTokenManager.start();
-    await claudeTokenManager.start();
-    await codexTokenManager.start();
+    if (!IS_WARMING_MODE) {
+      await githubTokenManager.start();
+      await claudeTokenManager.start();
+      await codexTokenManager.start();
+    }
     const repos = await gitService.listRepos();
     await eventService.publish({
       id: randomUUID4(),

package/package.json

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

package/dist/tsup.config.js

@@ -1,28 +0,0 @@
-import { defineConfig } from 'tsup';
-export default defineConfig({
-    entry: ['src/index.ts'],
-    format: ['esm'],
-    bundle: true,
-    // Bundle @replicas/shared inline, all other dependencies are automatically external
-    noExternal: ['@replicas/shared'],
-    dts: false, // We don't need type definitions for the published package
-    clean: true,
-    // Output to dist/src to match existing structure
-    outDir: 'dist/src',
-    // Add shebang for the bin script
-    banner: {
-        js: '#!/usr/bin/env node',
-    },
-    // Preserve the directory structure
-    outExtension() {
-        return {
-            js: '.js',
-        };
-    },
-    // Resolve path mappings from tsconfig
-    esbuildOptions(options) {
-        options.alias = {
-            '@replicas/shared': '../shared/src',
-        };
-    },
-});