veryfront 0.1.324 → 0.1.326

package/src/src/sandbox/shell-tools.ts

@@ -0,0 +1,242 @@
+import type { Tool, ToolExecutionContext } from "../tool/index.js";
+import type { JsonSchema } from "../tool/schema/json-schema.js";
+
+const SANDBOX_WORKING_DIRECTORY = "/workspace";
+const SANDBOX_TOOL_PROMPT =
+  "Available tools: agent-browser, awk, cat, column, comm, curl, cut, diff, expand, find, fold, grep, head, iconv, join, jq, nl, node, od, paste, printf, python3, rev, sed, sort, split, strings, tail, tee, tr, unexpand, uniq, veryfront, wc, xargs, xxd, yq, and more";
+
+const JSON_SCHEMA_TYPES: ReadonlySet<string> = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null",
+]);
+
+type SandboxShellToolExecute = {
+  bivarianceHack: (input: unknown, options?: ToolExecutionContext) => Promise<unknown> | unknown;
+}["bivarianceHack"];
+
+export type SandboxShellToolDefinition = {
+  id?: string;
+  type?: Tool["type"];
+  title?: string;
+  description?: string;
+  inputSchema?: unknown;
+  inputSchemaJson?: JsonSchema;
+  parameters?: unknown;
+  providerOptions?: unknown;
+  execute?: Tool["execute"] | SandboxShellToolExecute;
+  mcp?: Tool["mcp"];
+};
+
+export type SandboxShellToolSet = Record<string, SandboxShellToolDefinition>;
+
+export type BashToolSandboxLike = {
+  ensure?: () => Promise<void> | void;
+  executeCommand: (command: string, options?: unknown) => Promise<unknown>;
+  readFile?: (path: string) => Promise<unknown> | unknown;
+  writeFiles?: (files: unknown[]) => Promise<unknown> | unknown;
+};
+
+type CreateBashToolInput = {
+  sandbox: BashToolSandboxLike;
+  destination: string;
+  promptOptions: {
+    toolPrompt: string;
+  };
+};
+
+export type CreateSandboxBashTool = (
+  input: CreateBashToolInput,
+) => Promise<{ tools: Record<string, unknown> }>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeJsonSchemaType(value: unknown): JsonSchema["type"] | undefined {
+  if (typeof value !== "string" || !JSON_SCHEMA_TYPES.has(value)) {
+    return undefined;
+  }
+
+  switch (value) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "object":
+    case "array":
+    case "null":
+      return value;
+  }
+}
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    return undefined;
+  }
+
+  return value.map(String);
+}
+
+function normalizeJsonSchemaArray(value: unknown): JsonSchema[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const schemas = value.map(normalizeJsonSchema).filter((schema) => schema !== undefined);
+  return schemas.length === value.length ? schemas : undefined;
+}
+
+function normalizeJsonSchemaProperties(value: unknown): Record<string, JsonSchema> | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const properties: Record<string, JsonSchema> = {};
+  for (const [key, propertyValue] of Object.entries(value)) {
+    const schema = normalizeJsonSchema(propertyValue);
+    if (schema === undefined) {
+      return undefined;
+    }
+    properties[key] = schema;
+  }
+  return properties;
+}
+
+function normalizeJsonSchema(value: unknown): JsonSchema | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const schema: JsonSchema = {};
+  const type = normalizeJsonSchemaType(value.type);
+  const description = typeof value.description === "string" ? value.description : undefined;
+  const required = normalizeStringArray(value.required);
+  const properties = normalizeJsonSchemaProperties(value.properties);
+  const items = normalizeJsonSchema(value.items);
+  const anyOf = normalizeJsonSchemaArray(value.anyOf);
+  const prefixItems = normalizeJsonSchemaArray(value.prefixItems);
+
+  if (type !== undefined) schema.type = type;
+  if (description !== undefined) schema.description = description;
+  if (Array.isArray(value.enum)) schema.enum = [...value.enum];
+  if ("const" in value) schema.const = value.const;
+  if ("default" in value) schema.default = value.default;
+  if (properties !== undefined) schema.properties = properties;
+  if (required !== undefined) schema.required = required;
+  if (items !== undefined) schema.items = items;
+  if (typeof value.additionalProperties === "boolean") {
+    schema.additionalProperties = value.additionalProperties;
+  } else {
+    const additionalProperties = normalizeJsonSchema(value.additionalProperties);
+    if (additionalProperties !== undefined) schema.additionalProperties = additionalProperties;
+  }
+  if (anyOf !== undefined) schema.anyOf = anyOf;
+  if (prefixItems !== undefined) schema.prefixItems = prefixItems;
+  if (typeof value.minItems === "number") schema.minItems = value.minItems;
+  if (typeof value.maxItems === "number") schema.maxItems = value.maxItems;
+
+  return schema;
+}
+
+function normalizeBashTool(toolDefinition: unknown): SandboxShellToolDefinition {
+  if (!isRecord(toolDefinition)) {
+    return {};
+  }
+
+  const normalized: SandboxShellToolDefinition = {};
+  const id = toolDefinition.id;
+  const type = toolDefinition.type;
+  const description = toolDefinition.description;
+  const inputSchema = toolDefinition.inputSchema;
+  const inputSchemaJson = normalizeJsonSchema(toolDefinition.inputSchemaJson);
+  const executeCandidate = toolDefinition.execute;
+  const mcp = toolDefinition.mcp;
+
+  if (typeof id === "string") {
+    normalized.id = id;
+  }
+  if (type === "function" || type === "dynamic") {
+    normalized.type = type;
+  }
+  if (typeof description === "string") {
+    normalized.description = description;
+  }
+  if (inputSchema !== undefined) {
+    normalized.inputSchema = inputSchema;
+  }
+  if (inputSchemaJson !== undefined) {
+    normalized.inputSchemaJson = inputSchemaJson;
+  }
+  if (typeof executeCandidate === "function") {
+    normalized.execute = async (input: unknown, options?: ToolExecutionContext) =>
+      executeCandidate(input, options);
+  }
+  if (isRecord(mcp)) {
+    normalized.mcp = Object.fromEntries(Object.entries(mcp));
+  }
+
+  return normalized;
+}
+
+export function normalizeBashToolSet(bashTools: Record<string, unknown>): SandboxShellToolSet {
+  return Object.fromEntries(
+    Object.entries(bashTools).map((
+      [name, toolDefinition],
+    ) => [name, normalizeBashTool(toolDefinition)]),
+  );
+}
+
+export function renameSandboxFileTools(bashTools: SandboxShellToolSet): SandboxShellToolSet {
+  const tools: SandboxShellToolSet = { ...bashTools };
+
+  const sandboxReadFile = tools.readFile;
+  if (sandboxReadFile) {
+    tools.sandbox_read_file = {
+      ...sandboxReadFile,
+      description:
+        "Read a file from the sandbox /workspace filesystem only. This does NOT read project files stored in Veryfront. Use project file tools like get_file/get_files for real project source.",
+    };
+    delete tools.readFile;
+  }
+
+  const sandboxWriteFile = tools.writeFile;
+  if (sandboxWriteFile) {
+    tools.sandbox_write_file = {
+      ...sandboxWriteFile,
+      description:
+        "Write a file inside the sandbox /workspace filesystem only. This does NOT update project files stored in Veryfront. Use project file tools like create_file/update_file for real project source.",
+    };
+    delete tools.writeFile;
+  }
+
+  const sandboxBash = tools.bash;
+  if (sandboxBash) {
+    tools.bash = {
+      ...sandboxBash,
+      description:
+        "Run shell commands in the sandbox /workspace environment. This is for temporary shell work only and does NOT provide direct access to Veryfront project files.",
+    };
+  }
+
+  return tools;
+}
+
+export async function createSandboxShellTools(
+  sandbox: BashToolSandboxLike,
+  createBashTool: CreateSandboxBashTool,
+): Promise<SandboxShellToolSet> {
+  const { tools: bashTools } = await createBashTool({
+    sandbox,
+    destination: SANDBOX_WORKING_DIRECTORY,
+    promptOptions: {
+      toolPrompt: SANDBOX_TOOL_PROMPT,
+    },
+  });
+
+  return renameSandboxFileTools(normalizeBashToolSet(bashTools));
+}

package/src/src/server/shared/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Server Shared
+ *
+ * @module server/shared
+ */
+
+export {
+  destroyRendererAdapter,
+  getRendererForProject,
+  type RendererAdapter,
+  shouldRejectDueToMemory,
+} from "./renderer-factory.js";

package/src/src/testing/assert.ts

@@ -0,0 +1,352 @@
+import "../../_dnt.polyfills.js";
+import "./init.js";
+import { isDeno } from "../platform/compat/runtime.js";
+import { deepEquals, safeStringify } from "./utils.js";
+
+// deno-lint-ignore no-explicit-any -- any[] required: constructor params are contravariant
+type ErrorClass = new (...args: any[]) => Error;
+
+interface AssertImpl {
+  assertEquals<T>(actual: T, expected: T, msg?: string): void;
+  assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+  assertStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+  assert(expr: unknown, msg?: string): void;
+  assertExists<T>(actual: T, msg?: string): void;
+  assertThrows(
+    fn: () => unknown,
+    errorClassOrMsg?: ErrorClass | string,
+    msgIncludesOrMsg?: string,
+    msg?: string,
+  ): void;
+  assertRejects(
+    fn: () => Promise<unknown>,
+    errorClassOrMsg?: ErrorClass | string,
+    msgIncludesOrMsg?: string,
+    msg?: string,
+  ): Promise<unknown>;
+  assertStringIncludes(actual: string, expected: string, msg?: string): void;
+  assertMatch(actual: string, expected: RegExp, msg?: string): void;
+  assertInstanceOf<T>(
+    actual: unknown,
+    // deno-lint-ignore no-explicit-any -- any[] required: constructor params are contravariant
+    expectedType: abstract new (...args: any[]) => T,
+    msg?: string,
+  ): void;
+  fail(msg?: string): never;
+  assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+  assertObjectMatch(
+    actual: Record<string, unknown>,
+    expected: Record<string, unknown>,
+    msg?: string,
+  ): void;
+  assertGreater(actual: number, expected: number, msg?: string): void;
+  assertGreaterOrEqual(actual: number, expected: number, msg?: string): void;
+  assertLess(actual: number, expected: number, msg?: string): void;
+  assertLessOrEqual(actual: number, expected: number, msg?: string): void;
+}
+
+function createNodeAssertImpl(): AssertImpl {
+  function assertErrorMessageIncludes(error: unknown, includes?: string): void {
+    if (!includes) return;
+    if (!(error instanceof Error)) return;
+
+    if (error.message.includes(includes)) return;
+    throw new Error(`Expected error message to include "${includes}", got "${error.message}"`);
+  }
+
+  function assertThrowsOrRejects(
+    threw: boolean,
+    error: unknown,
+    errorClassOrMsg?: ErrorClass | string,
+    msgIncludesOrMsg?: string,
+    defaultMsg?: string,
+  ): void {
+    if (!threw) {
+      throw new Error(typeof errorClassOrMsg === "string" ? errorClassOrMsg : defaultMsg);
+    }
+
+    if (typeof errorClassOrMsg !== "function") return;
+
+    if (!(error instanceof errorClassOrMsg)) {
+      throw new Error(
+        `Expected error to be instance of ${errorClassOrMsg.name}, got ${
+          (error as Error | undefined)?.name ?? typeof error
+        }`,
+      );
+    }
+
+    assertErrorMessageIncludes(error, msgIncludesOrMsg);
+  }
+
+  function assertObjectMatch(
+    actual: Record<string, unknown>,
+    expected: Record<string, unknown>,
+    msg?: string,
+  ): void {
+    for (const key of Object.keys(expected)) {
+      const actualVal = actual[key];
+      const expectedVal = expected[key];
+
+      if (typeof expectedVal === "object" && expectedVal !== null) {
+        if (typeof actualVal !== "object" || actualVal === null) {
+          throw new Error(msg || `Expected ${key} to be an object`);
+        }
+
+        assertObjectMatch(
+          actualVal as Record<string, unknown>,
+          expectedVal as Record<string, unknown>,
+          msg,
+        );
+        continue;
+      }
+
+      if (actualVal === expectedVal) continue;
+
+      throw new Error(
+        msg ||
+          `Expected ${key} to be ${JSON.stringify(expectedVal)}, got ${JSON.stringify(actualVal)}`,
+      );
+    }
+  }
+
+  return {
+    assertEquals<T>(actual: T, expected: T, msg?: string): void {
+      if (deepEquals(actual, expected)) return;
+      throw new Error(msg || `Expected ${safeStringify(expected)}, got ${safeStringify(actual)}`);
+    },
+
+    assertNotEquals<T>(actual: T, expected: T, msg?: string): void {
+      if (!deepEquals(actual, expected)) return;
+      throw new Error(msg || `Expected values to not be equal: ${safeStringify(actual)}`);
+    },
+
+    assertStrictEquals<T>(actual: T, expected: T, msg?: string): void {
+      if (actual === expected) return;
+      throw new Error(msg || `Expected ${expected}, got ${actual}`);
+    },
+
+    assert(expr: unknown, msg?: string): void {
+      if (expr) return;
+      throw new Error(msg || "Assertion failed: expected truthy value");
+    },
+
+    assertExists<T>(actual: T, msg?: string): void {
+      if (actual !== null && actual !== undefined) return;
+      throw new Error(msg || `Expected value to exist, but got ${actual}`);
+    },
+
+    assertThrows(
+      fn: () => unknown,
+      errorClassOrMsg?: ErrorClass | string,
+      msgIncludesOrMsg?: string,
+      _msg?: string,
+    ): void {
+      let threw = false;
+      let error: unknown;
+
+      try {
+        fn();
+      } catch (e) {
+        threw = true;
+        error = e;
+      }
+
+      assertThrowsOrRejects(
+        threw,
+        error,
+        errorClassOrMsg,
+        msgIncludesOrMsg,
+        "Expected function to throw",
+      );
+    },
+
+    async assertRejects(
+      fn: () => Promise<unknown>,
+      errorClassOrMsg?: ErrorClass | string,
+      msgIncludesOrMsg?: string,
+      _msg?: string,
+    ): Promise<void> {
+      let threw = false;
+      let error: unknown;
+
+      try {
+        await fn();
+      } catch (e) {
+        threw = true;
+        error = e;
+      }
+
+      assertThrowsOrRejects(
+        threw,
+        error,
+        errorClassOrMsg,
+        msgIncludesOrMsg,
+        "Expected function to reject",
+      );
+    },
+
+    assertStringIncludes(actual: string, expected: string, msg?: string): void {
+      if (actual.includes(expected)) return;
+      throw new Error(msg || `Expected "${actual}" to include "${expected}"`);
+    },
+
+    assertMatch(actual: string, expected: RegExp, msg?: string): void {
+      if (expected.test(actual)) return;
+      throw new Error(msg || `Expected "${actual}" to match ${expected}`);
+    },
+
+    assertInstanceOf<T>(
+      actual: unknown,
+      expectedType: new (...args: unknown[]) => T,
+      msg?: string,
+    ): void {
+      if (actual instanceof expectedType) return;
+      throw new Error(msg || `Expected instance of ${expectedType.name}, got ${typeof actual}`);
+    },
+
+    fail(msg?: string): never {
+      throw new Error(msg || "Test failed");
+    },
+
+    assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void {
+      if (actual !== expected) return;
+      throw new Error(msg || "Expected values to not be strictly equal");
+    },
+
+    assertObjectMatch,
+
+    assertGreater(actual: number, expected: number, msg?: string): void {
+      if (actual > expected) return;
+      throw new Error(msg || `Expected ${actual} to be greater than ${expected}`);
+    },
+
+    assertGreaterOrEqual(actual: number, expected: number, msg?: string): void {
+      if (actual >= expected) return;
+      throw new Error(msg || `Expected ${actual} to be greater than or equal to ${expected}`);
+    },
+
+    assertLess(actual: number, expected: number, msg?: string): void {
+      if (actual < expected) return;
+      throw new Error(msg || `Expected ${actual} to be less than ${expected}`);
+    },
+
+    assertLessOrEqual(actual: number, expected: number, msg?: string): void {
+      if (actual <= expected) return;
+      throw new Error(msg || `Expected ${actual} to be less than or equal to ${expected}`);
+    },
+  };
+}
+
+let impl: AssertImpl;
+
+if (isDeno) {
+  const denoAssert = await import("../../deps/jsr.io/@std/assert/1.0.19/mod.js");
+  impl = {
+    assertEquals: denoAssert.assertEquals,
+    assertNotEquals: denoAssert.assertNotEquals,
+    assertStrictEquals: denoAssert.assertStrictEquals,
+    assert: denoAssert.assert,
+    assertExists: denoAssert.assertExists,
+    assertThrows: denoAssert.assertThrows,
+    assertRejects: denoAssert.assertRejects,
+    assertStringIncludes: denoAssert.assertStringIncludes,
+    assertMatch: denoAssert.assertMatch,
+    assertInstanceOf: denoAssert.assertInstanceOf,
+    fail: denoAssert.fail,
+    assertNotStrictEquals: denoAssert.assertNotStrictEquals,
+    assertObjectMatch: denoAssert.assertObjectMatch,
+    assertGreater: denoAssert.assertGreater,
+    assertGreaterOrEqual: denoAssert.assertGreaterOrEqual,
+    assertLess: denoAssert.assertLess,
+    assertLessOrEqual: denoAssert.assertLessOrEqual,
+  };
+} else {
+  impl = createNodeAssertImpl();
+}
+
+export function assertEquals<T>(actual: T, expected: T, msg?: string): void {
+  impl.assertEquals(actual, expected, msg);
+}
+
+export function assertNotEquals<T>(actual: T, expected: T, msg?: string): void {
+  impl.assertNotEquals(actual, expected, msg);
+}
+
+export function assertStrictEquals<T>(actual: T, expected: T, msg?: string): void {
+  impl.assertStrictEquals(actual, expected, msg);
+}
+
+export function assert(expr: unknown, msg?: string): asserts expr {
+  impl.assert(expr, msg);
+}
+
+export function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T> {
+  impl.assertExists(actual, msg);
+}
+
+export function assertThrows(
+  fn: () => unknown,
+  errorClassOrMsg?: ErrorClass | string,
+  msgIncludesOrMsg?: string,
+  msg?: string,
+): void {
+  impl.assertThrows(fn, errorClassOrMsg, msgIncludesOrMsg, msg);
+}
+
+export function assertRejects(
+  fn: () => Promise<unknown>,
+  errorClassOrMsg?: ErrorClass | string,
+  msgIncludesOrMsg?: string,
+  msg?: string,
+): Promise<unknown> {
+  return impl.assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg);
+}
+
+export function assertStringIncludes(actual: string, expected: string, msg?: string): void {
+  impl.assertStringIncludes(actual, expected, msg);
+}
+
+export function assertMatch(actual: string, expected: RegExp, msg?: string): void {
+  impl.assertMatch(actual, expected, msg);
+}
+
+export function assertInstanceOf<T>(
+  actual: unknown,
+  // deno-lint-ignore no-explicit-any -- any[] required: constructor params are contravariant
+  expectedType: abstract new (...args: any[]) => T,
+  msg?: string,
+): asserts actual is T {
+  impl.assertInstanceOf(actual, expectedType, msg);
+}
+
+export function fail(msg?: string): never {
+  impl.fail(msg);
+}
+
+export function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void {
+  impl.assertNotStrictEquals(actual, expected, msg);
+}
+
+export function assertObjectMatch(
+  actual: Record<string, unknown>,
+  expected: Record<string, unknown>,
+  msg?: string,
+): void {
+  impl.assertObjectMatch(actual, expected, msg);
+}
+
+export function assertGreater(actual: number, expected: number, msg?: string): void {
+  impl.assertGreater(actual, expected, msg);
+}
+
+export function assertGreaterOrEqual(actual: number, expected: number, msg?: string): void {
+  impl.assertGreaterOrEqual(actual, expected, msg);
+}
+
+export function assertLess(actual: number, expected: number, msg?: string): void {
+  impl.assertLess(actual, expected, msg);
+}
+
+export function assertLessOrEqual(actual: number, expected: number, msg?: string): void {
+  impl.assertLessOrEqual(actual, expected, msg);
+}