@gigaai/newton 0.3.0 → 0.4.1

package/dist/sandbox.js

@@ -0,0 +1,157 @@
+import * as vm from "node:vm";
+export function createRealm(consoleLog) {
+    const context = vm.createContext({}, { codeGeneration: { strings: false, wasm: false } });
+    const hostCallables = new Map();
+    let nextCallableId = 1;
+    let makeRealmCallable;
+    let makeRealmArray;
+    let makeRealmObject;
+    vm.runInContext(`
+{
+const RealmDate = Date;
+const dateNowUnavailable = () => {
+  throw new Error("Date.now() is unavailable in workflows (breaks resume); pass timestamps via --args");
+};
+const mathRandomUnavailable = () => {
+  throw new Error("Math.random() is unavailable in workflows (breaks resume); vary prompts by index instead");
+};
+
+const GuardedDate = new Proxy(RealmDate, {
+  get(target, prop, receiver) {
+    if (prop === "now") return dateNowUnavailable;
+    return Reflect.get(target, prop, receiver);
+  },
+  construct(target, argArray) {
+    if (argArray.length === 0) {
+      throw new Error("new Date() without arguments is unavailable in workflows (breaks resume)");
+    }
+    return Reflect.construct(target, argArray);
+  },
+});
+globalThis.Date = GuardedDate;
+Object.defineProperty(RealmDate.prototype, "constructor", {
+  value: GuardedDate,
+  writable: true,
+  configurable: true,
+});
+
+Math.random = mathRandomUnavailable;
+}
+`, context);
+    const bridge = (id, args) => {
+        const callable = hostCallables.get(id);
+        if (!callable)
+            throw new Error(`unknown workflow host function ${id}`);
+        return callable(...args);
+    };
+    context.__newtonBridge = bridge;
+    const helpers = vm.runInContext(`
+(() => {
+  const bridge = globalThis.__newtonBridge;
+  delete globalThis.__newtonBridge;
+
+  const importValue = (value, seen = new WeakMap()) => {
+    if (value === null || value === undefined) return value;
+    const kind = typeof value;
+    if (kind !== "object") return kind === "function" ? undefined : value;
+    const existing = seen.get(value);
+    if (existing) return existing;
+    if (Array.isArray(value)) {
+      const copy = [];
+      seen.set(value, copy);
+      for (let i = 0; i < value.length; i++) copy[i] = importValue(value[i], seen);
+      return copy;
+    }
+    const copy = {};
+    seen.set(value, copy);
+    for (const key of Object.keys(value)) copy[key] = importValue(value[key], seen);
+    return copy;
+  };
+
+  const importError = (error) =>
+    new Error(error && typeof error === "object" && typeof error.message === "string" ? error.message : String(error));
+
+  const makeCallable = (id) => (...args) => {
+    try {
+      const result = bridge(id, args);
+      if (result && typeof result === "object" && typeof result.then === "function") {
+        return Promise.resolve(result).then(
+          (value) => importValue(value),
+          (error) => {
+            throw importError(error);
+          },
+        );
+      }
+      return importValue(result);
+    } catch (error) {
+      throw importError(error);
+    }
+  };
+
+  return {
+    makeCallable,
+    makeArray: (items) => Array.from(items),
+    makeObject: (entries) => {
+      const object = {};
+      for (const [key, value] of entries) object[key] = value;
+      return object;
+    },
+  };
+})()
+`, context);
+    makeRealmCallable = helpers.makeCallable;
+    makeRealmArray = helpers.makeArray;
+    makeRealmObject = helpers.makeObject;
+    const wrapHostCallable = (callable) => {
+        const id = nextCallableId++;
+        hostCallables.set(id, callable);
+        return makeRealmCallable(id);
+    };
+    const toRealmValue = (value) => {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value === "function")
+            return wrapHostCallable(value);
+        if (typeof value !== "object")
+            return value;
+        if (Array.isArray(value))
+            return makeRealmArray(value.map((item) => toRealmValue(item)));
+        return makeRealmObject(Object.entries(value).map(([key, entry]) => [key, toRealmValue(entry)]));
+    };
+    const writeConsole = (...args) => {
+        consoleLog(args.map(formatConsoleArg).join(" "));
+    };
+    context.__newtonConsole = makeRealmObject([
+        ["log", wrapHostCallable(writeConsole)],
+        ["info", wrapHostCallable(writeConsole)],
+        ["warn", wrapHostCallable(writeConsole)],
+        ["error", wrapHostCallable(writeConsole)],
+        ["debug", wrapHostCallable(writeConsole)],
+    ]);
+    vm.runInContext(`
+globalThis.console = globalThis.__newtonConsole;
+delete globalThis.__newtonConsole;
+`, context);
+    return {
+        compile(params, body, filename) {
+            const scriptFn = vm.runInContext(`(async function(${params.join(",")}) {"use strict";\n${body}\n})`, context, {
+                filename,
+            });
+            return (...args) => scriptFn(...args.map((arg) => toRealmValue(arg)));
+        },
+    };
+}
+export function checkCompile(params, body) {
+    new vm.Script('(async function(' + params.join(",") + ') {"use strict";\n' + body + "\n})");
+}
+function formatConsoleArg(arg) {
+    if (typeof arg === "string")
+        return arg;
+    try {
+        const json = JSON.stringify(arg);
+        return json === undefined ? String(arg) : json;
+    }
+    catch {
+        return String(arg);
+    }
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.3.0";
+export const VERSION = "0.4.1";

package/dist/worktree.js

@@ -0,0 +1,51 @@
+import { execFile } from "node:child_process";
+import { mkdirSync, rmdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function createWorktree(workspace, runId, agentId) {
+    const path = join(workspace, ".newton", "worktrees", runId, `agent-${agentId}`);
+    mkdirSync(dirname(path), { recursive: true });
+    try {
+        // Detached HEAD avoids branch-name coordination across parallel agents.
+        await git(["-C", workspace, "worktree", "add", "--detach", path, "HEAD"]);
+        const baseHead = (await git(["-C", path, "rev-parse", "HEAD"])).trim();
+        return { path, baseHead };
+    }
+    catch (error) {
+        throw new Error(`worktree setup failed: ${gitStderr(error)}`);
+    }
+}
+export async function finishWorktree(workspace, wt) {
+    try {
+        const status = await git(["-C", wt.path, "status", "--porcelain"]);
+        const head = (await git(["-C", wt.path, "rev-parse", "HEAD"])).trim();
+        const dirty = status.trim().length > 0 || head !== wt.baseHead;
+        if (dirty)
+            return { dirty: true, removed: false };
+        // Force is intentional after the clean check: this is disposable isolation.
+        await git(["-C", workspace, "worktree", "remove", "--force", wt.path]);
+        try {
+            rmdirSync(dirname(wt.path));
+        }
+        catch {
+            // Best-effort cleanup of the per-run directory.
+        }
+        return { dirty: false, removed: true };
+    }
+    catch {
+        return { dirty: true, removed: false };
+    }
+}
+async function git(args) {
+    const { stdout } = await execFileAsync("git", args);
+    return stdout.toString();
+}
+function gitStderr(error) {
+    if (typeof error === "object" && error !== null && "stderr" in error) {
+        const stderr = String(error.stderr ?? "").trim();
+        if (stderr)
+            return stderr;
+    }
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gigaai/newton",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Deterministic multi-agent workflow executor. Write workflows in plain JavaScript; Newton drives coding agents over the Agent Client Protocol.",
   "license": "Apache-2.0",
   "repository": {