Start http service earlier and add /ready http route

docker-compose.yml

@@ -1,9 +1,9 @@
 services:
   subql-ai:
-    image: subquerynetwork/subql-ai-app
-    # build:
-    #   context: .
-    #   dockerfile: ./Dockerfile
+    # image: subquerynetwork/subql-ai-app
+    build:
+      context: .
+      dockerfile: ./Dockerfile
     ports:
       - 7827:7827
     restart: unless-stopped
@@ -14,24 +14,27 @@ services:
       # - -p=/app/index.ts # TODO this doesn't work because dependencies are not copied
       - -p=ipfs://QmNaNBhXJoFpRJeNQcnTH8Yh6Rf4pzJy6VSnfnQSZHysdZ
       - -h=http://host.docker.internal:11434
-    # healthcheck:
-    #   test: ["CMD", "curl", "-f", "http://subql-ai:7827/health"]
-    #   interval: 3s
-    #   timeout: 5s
-    #   retries: 10
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://subql-ai:7827/ready"]
+      interval: 3s
+      timeout: 5s
+      retries: 10
 
   # A simple chat UI
   ui:
     image: ghcr.io/open-webui/open-webui:main
     ports:
       - 8080:8080
     restart: always
+    depends_on:
+      "subql-ai":
+        condition: service_healthy
     environment:
-      - 'OPENAI_API_BASE_URLS=http://subql-ai:7827/v1'
-      - 'OPENAI_API_KEYS=foobar'
-      - 'WEBUI_AUTH=false'
+      - "OPENAI_API_BASE_URLS=http://subql-ai:7827/v1"
+      - "OPENAI_API_KEYS=foobar"
+      - "WEBUI_AUTH=false"
     volumes:
-     - open-webui:/app/backend/data
+      - open-webui:/app/backend/data
 
 volumes:
   open-webui:

src/app.ts

@@ -23,15 +23,15 @@ export async function runApp(config: {
   forceReload?: boolean;
 }): Promise<void> {
   const model = new Ollama({ host: config.host });
-  const projectPath = await loadProject(
+  const [projectPath, source] = await loadProject(
     config.projectPath,
     config.ipfs,
     undefined,
     config.forceReload,
   );
-  const sandbox = await getDefaultSandbox(resolve(projectPath));
+  const sandbox = await getDefaultSandbox(resolve(projectPath), source);
 
-  const ctx = await makeContext(
+  const pendingCtx = makeContext(
     sandbox,
     model,
     (dbPath) =>
@@ -44,7 +44,7 @@ export async function runApp(config: {
       ),
   );
 
-  const runnerHost = new RunnerHost(() => {
+  const runnerHost = new RunnerHost(async () => {
     const chatStorage = new MemoryChatStorage();
 
     chatStorage.append([{ role: "system", content: sandbox.systemPrompt }]);
@@ -53,20 +53,21 @@ export async function runApp(config: {
       sandbox,
       chatStorage,
       model,
-      ctx,
+      await pendingCtx,
     );
   });
 
   switch (config.interface) {
     case "cli":
+      await pendingCtx;
       if (sandbox.userMessage) {
         console.log(sandbox.userMessage);
       }
       await cli(runnerHost);
       break;
     case "http":
     default:
-      http(runnerHost, config.port);
+      http(runnerHost, config.port, pendingCtx);
   }
 }
 

src/bundle.ts

@@ -20,7 +20,11 @@ export async function publishProject(
   sandboxFactory = getDefaultSandbox,
 ): Promise<string> {
   projectPath = await Deno.realPath(projectPath);
-  const projectJson = await getProjectJson(projectPath, sandboxFactory);
+  const projectJson = await getProjectJson(
+    projectPath,
+    "local",
+    sandboxFactory,
+  );
   let code = await generateBundle(projectPath);
   const vectorDbPath = projectJson.vectorStorage?.path;
   if (vectorDbPath) {

src/http.ts

@@ -71,13 +71,22 @@ export type ChatChunkResponse = Static<typeof ChatChunkResponse>;
 export function http(
   runnerHost: RunnerHost,
   port: number,
+  onReady?: Promise<unknown>,
 ): Deno.HttpServer<Deno.NetAddr> {
   const app = new Hono();
 
+  // The ready status should change once the project is fully loaded, including the vector DB
+  let ready = false;
+  onReady?.then(() => ready = true);
+
   app.get("/health", (c) => {
     return c.text("ok");
   });
 
+  app.get("/ready", (c) => {
+    return c.text(ready.toString());
+  });
+
   app.get("/v1/models", (c) => {
     return c.json({
       object: "list",

src/info.ts

@@ -5,12 +5,14 @@ import type { IProject } from "./project/project.ts";
 import type { TSchema } from "@sinclair/typebox";
 import type { IPFSClient } from "./ipfs.ts";
 import { loadProject } from "./loader.ts";
+import type { ProjectSource } from "./util.ts";
 
 export async function getProjectJson(
   projectPath: string,
+  source: ProjectSource,
   sandboxFactory = getDefaultSandbox,
 ): Promise<Omit<IProject, "tools"> & { tools: string[]; config?: TSchema }> {
-  const sandbox = await sandboxFactory(resolve(projectPath));
+  const sandbox = await sandboxFactory(resolve(projectPath), source);
 
   return {
     model: sandbox.model,
@@ -26,8 +28,8 @@ export async function projectInfo(
   ipfs: IPFSClient,
   json = false,
 ): Promise<void> {
-  const loadedPath = await loadProject(projectPath, ipfs);
-  const projectJson = await getProjectJson(loadedPath);
+  const [loadedPath, source] = await loadProject(projectPath, ipfs);
+  const projectJson = await getProjectJson(loadedPath, source);
 
   if (json) {
     console.log(JSON.stringify(

src/loader.ts

@@ -3,7 +3,7 @@ import { CIDReg, type IPFSClient } from "./ipfs.ts";
 import { resolve } from "@std/path/resolve";
 import { UntarStream } from "@std/tar";
 import { ensureDir, exists } from "@std/fs";
-import { getSpinner } from "./util.ts";
+import { getSpinner, type ProjectSource } from "./util.ts";
 
 export const getOSTempDir = () =>
   Deno.env.get("TMPDIR") || Deno.env.get("TMP") || Deno.env.get("TEMP") ||
@@ -14,7 +14,7 @@ export async function loadProject(
   ipfs: IPFSClient,
   tmpDir?: string,
   forceReload?: boolean,
-): Promise<string> {
+): Promise<[string, ProjectSource]> {
   if (CIDReg.test(projectPath)) {
     const spinner = getSpinner().start("Loading project from IPFS");
     try {
@@ -25,7 +25,7 @@ export async function loadProject(
       // Early exit if the file has already been fetched
       if (!forceReload && (await exists(filePath))) {
         spinner.succeed("Loaded project from IPFS");
-        return filePath;
+        return [filePath, "ipfs"];
       }
       await ensureDir(tmp);
 
@@ -36,14 +36,14 @@ export async function loadProject(
 
       spinner.succeed("Loaded project from IPFS");
 
-      return filePath;
+      return [filePath, "ipfs"];
     } catch (e) {
       spinner.fail("Failed to load project");
       throw e;
     }
   }
 
-  return resolve(projectPath);
+  return [resolve(projectPath), "local"];
 }
 
 export async function loadVectorStoragePath(

src/project/project.ts

@@ -32,6 +32,11 @@ export const VectorConfig = Type.Object({
 });
 
 export const Project = Type.Object({
+  // Note: If a new spec version is introduced Type.TemplateLiteral could be used here
+  specVersion: Type.Literal(
+    "0.0.1",
+    { description: "The specification version of the project structure." },
+  ),
   model: Type.String({
     description: "The llm model to use",
   }),
@@ -71,8 +76,9 @@ export type IProjectEntrypoint<T extends TObject = TObject> = Static<
   IProjectEntry<T>
 >;
 
-export function validateProject(project: unknown): void {
-  return Value.Assert(Project, project);
+export function validateProject(project: unknown): project is IProject {
+  Value.Assert(Project, project);
+  return true;
 }
 
 function validateProjectEntry(entry: unknown): entry is IProjectEntry {
@@ -109,10 +115,9 @@ export async function getProjectFromEntrypoint(
     // Check that the constructed project is valid
     const project = await entrypoint.projectFactory(config);
 
-    validateProject(project);
-
-    return project;
-  } else {
-    throw new Error("Unable to validate project");
+    if (validateProject(project)) {
+      return project;
+    }
   }
+  throw new Error("Unable to validate project");
 }

src/sandbox/index.ts

@@ -1,13 +1,44 @@
+import type { ProjectSource } from "../util.ts";
 import type { ISandbox } from "./sandbox.ts";
-import { WebWorkerSandbox } from "./webWorker/webWorkerSandbox.ts";
+import {
+  type Permissions,
+  WebWorkerSandbox,
+} from "./webWorker/webWorkerSandbox.ts";
 
 export * from "./sandbox.ts";
 export * from "./mockSandbox.ts";
 export * from "./unsafeSandbox.ts";
 
-export function getDefaultSandbox(path: string): Promise<ISandbox> {
+const IPFS_PERMISSIONS: Permissions = {
+  allowRead: false,
+  allowFFI: false,
+};
+
+const LOCAL_PERMISSIONS: Permissions = {
+  allowRead: true,
+  allowFFI: true,
+};
+
+function getPermisionsForSource(source: ProjectSource): Permissions {
+  switch (source) {
+    case "local":
+      return LOCAL_PERMISSIONS;
+    case "ipfs":
+      return IPFS_PERMISSIONS;
+    default:
+      throw new Error(
+        `Unable to set permissions for unknown source: ${source}`,
+      );
+  }
+}
+
+export function getDefaultSandbox(
+  path: string,
+  source: ProjectSource,
+): Promise<ISandbox> {
   // return UnsafeSandbox.create(path);
-  return WebWorkerSandbox.create(path);
+  const permissions = getPermisionsForSource(source);
+  return WebWorkerSandbox.create(path, permissions);
 }
 
 export { WebWorkerSandbox };

src/sandbox/webWorker/webWorker.ts

@@ -19,6 +19,7 @@ import {
   type IProjectEntrypoint,
 } from "../../project/project.ts";
 import type { IContext } from "../../context/context.ts";
+import { PrettyTypeboxError } from "../../util.ts";
 
 const conn = rpc.createMessageConnection(
   new BrowserMessageReader(self),
@@ -52,9 +53,16 @@ conn.onRequest(Init, async (config) => {
     throw new Error("Please call `load` first");
   }
 
-  project ??= await getProjectFromEntrypoint(entrypoint, config);
+  try {
+    project ??= await getProjectFromEntrypoint(entrypoint, config);
 
-  return toJsonProject();
+    return toJsonProject();
+  } catch (e: unknown) {
+    if (e instanceof Error) {
+      throw PrettyTypeboxError(e, "Project validation failed");
+    }
+    throw e;
+  }
 });
 
 conn.onRequest(GetConfig, () => {

src/sandbox/webWorker/webWorkerSandbox.ts

@@ -18,24 +18,36 @@ import { loadConfigFromEnv } from "../../util.ts";
 import { FromSchema } from "../../fromSchema.ts";
 import type { IContext } from "../../context/context.ts";
 import type { IVectorConfig } from "../../project/project.ts";
+import { dirname } from "@std/path/dirname";
+
+export type Permissions = {
+  /**
+   * For local projects allow reading all locations for imports to work.
+   * TODO: This could be limited to the project dir + DENO_DIR cache but DENO_DIR doesn't provide the default currently
+   */
+  allowRead?: boolean;
+  allowFFI?: boolean;
+};
 
 export class WebWorkerSandbox implements ISandbox {
   #connection: rpc.MessageConnection;
   #config: TSchema | undefined;
   #tools: Tool[];
 
-  public static async create(path: string): Promise<WebWorkerSandbox> {
+  public static async create(
+    path: string,
+    permissions?: Permissions,
+  ): Promise<WebWorkerSandbox> {
     const w = new Worker(
-      import.meta.resolve("./webWorker.ts" /*path*/),
+      import.meta.resolve("./webWorker.ts"),
       {
         type: "module",
         deno: {
           permissions: {
             env: false, // Should be passed through in loadConfigFromEnv below
-            // hrtime: false,
             net: "inherit", // TODO remove localhost
-            ffi: true, // Needed for node js ffi
-            read: true, // Needed for imports to node modules
+            ffi: permissions?.allowFFI ?? false, // Needed for node js ffi, TODO this could be the same as read permissions
+            read: permissions?.allowRead ? true : [dirname(path)],
             run: false,
             write: false,
           },

src/util.ts

@@ -1,5 +1,5 @@
 import type { Static, TSchema } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import { AssertError, Value } from "@sinclair/typebox/value";
 import ora, { type Ora } from "ora";
 import { brightBlue } from "@std/fmt/colors";
 
@@ -32,3 +32,25 @@ export function getPrompt(): string | null {
 
   return response;
 }
+
+// Possible sources where projects can be loaded from
+export type ProjectSource = "local" | "ipfs";
+
+export function PrettyTypeboxError(
+  error: Error,
+  prefix = "Type Assertion Failed",
+): Error {
+  if (
+    error instanceof AssertError || error.constructor.name === "AssertError"
+  ) {
+    const errs = [...(error as AssertError).Errors()];
+
+    let msg = `${prefix}:\n`;
+    for (const e of errs) {
+      msg += `\t${e.path}: ${e.message}\n`;
+    }
+    return new Error(msg, { cause: error });
+  }
+
+  return error;
+}