@mobileaidev/ai-app-bridge 0.3.7 → 0.4.0

package/bin/script/node-runtime-adapter.js

@@ -38,174 +38,190 @@ function createChildRuntimeAdapter({
   onSpawnFailure,
 } = {}) {
   let channel = null;
+  let child = null;
   let exited = Promise.resolve();
   let readControl = () => ({ status: 'running', pauseReason: null });
 
   async function terminate() {
     if (channel) channel.stop();
     await exited;
+    child?.stdin?.destroy(); child?.stdout?.destroy(); child?.stderr?.destroy();
   }
 
-  function start(args) {
-    return inRequestDirectory(args.spec.cwd ?? requestDirectory(), () => startInDirectory(args));
+  async function start(args) {
+    const result = await inRequestDirectory(args.spec.cwd ?? requestDirectory(), () => startInDirectory(args));
+    if (!result.ok && channel) {
+      const diagnostics = { ...channel.diagnostics(), ...result.diagnostics };
+      if (Object.keys(diagnostics).length) result.diagnostics = diagnostics;
+    }
+    return result;
   }
 
   async function startInDirectory({ spec, host, agent, emit, control }) {
     readControl = typeof control === 'function' ? control : () => control || { status: 'running', pauseReason: null };
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'aab-script-'));
-    const artifact = path.join(directory, `main${extension}`);
-    fs.writeFileSync(artifact, spec.source);
-    const sdk = path.join(__dirname, sdkFile);
-    const child = spawn(executable, argsPrefix.concat([sdk, artifact]), {
-      shell: false,
-      cwd: requestDirectory(),
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    channel = createScriptSessionChannel(child, {
-      maxFrameBytes: Math.max(spec.policy.maxOutputBytes, spec.policy.maxProgressBytes, 1024 * 1024) + 64 * 1024,
-    });
-    exited = childExitPromise(child, onSpawnFailure);
-    const finished = exited;
+    let directory;
     let timer = null;
-    const timedOut = new Promise((resolve) => {
-      timer = setTimeout(() => resolve({ type: 'timeout' }), spec.policy.timeoutMs);
-    });
-    const rpc = pending => Promise.race([pending, timedOut, finished.then(() => { throw new Error('child_crashed'); })]);
+    channel = null;
+    exited = Promise.resolve();
     try {
-    const ready = await Promise.race([
-      channel.nextMessage(),
-      finished,
-      timedOut,
-    ]);
-    if (ready && ready.type === 'timeout') {
-      await terminate();
-      return { ok: false, error: 'timeout' };
-    }
-    if (!ready || ready.type !== 'ready') {
-      await terminate();
-      return { ok: false, error: ready && ready.type === 'fail' && ready.error === 'handshake_failed' ? 'handshake_failed' : 'child_crashed' };
-    }
-    emit('child_started', { kind });
-    channel.send({
-      type: 'start',
-      inputs: spec.inputs,
-      entrypoint: spec.entrypoint,
-      control: control(),
-    });
-    while (true) {
-      const message = await Promise.race([
+      directory = fs.mkdtempSync(path.join(os.tmpdir(), 'aab-script-'));
+      const artifact = path.join(directory, `main${extension}`);
+      fs.writeFileSync(artifact, spec.source);
+      const sdk = path.join(__dirname, sdkFile);
+      child = spawn(executable, argsPrefix.concat([sdk, artifact]), {
+        shell: false,
+        cwd: requestDirectory(),
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      channel = createScriptSessionChannel(child, {
+        maxFrameBytes: Math.max(spec.policy.maxOutputBytes, spec.policy.maxProgressBytes, 1024 * 1024) + 64 * 1024,
+      });
+      exited = childExitPromise(child, onSpawnFailure);
+      const finished = exited;
+      const timedOut = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ type: 'timeout' }), spec.policy.timeoutMs);
+      });
+      const rpc = pending => Promise.race([pending, timedOut, finished.then(() => { throw new Error('child_crashed'); })]);
+      const ready = await Promise.race([
         channel.nextMessage(),
         finished,
         timedOut,
       ]);
-      if (message.type === 'timeout') {
+      if (ready && ready.type === 'timeout') {
         await terminate();
-        emit('script_failed', { error: 'timeout' });
         return { ok: false, error: 'timeout' };
       }
-      if (message.type === 'call') {
-        const value = await rpc(host.call(message.command, message.args, message.options));
-        if (value && value.type === 'timeout') {
-          await terminate();
-          emit('script_failed', { error: 'timeout' });
-          return { ok: false, error: 'timeout' };
-        }
-        channel.send({ type: 'result', id: message.id, value, control: readControl() });
-        continue;
+      if (!ready || ready.type !== 'ready') {
+        await terminate();
+        return { ok: false, error: ready && ready.type === 'fail' && ready.error === 'handshake_failed' ? 'handshake_failed' : 'child_crashed' };
       }
-      if (message.type === 'assert') {
-        const value = await rpc(host.assert(message.assertion));
-        if (value && value.type === 'timeout') {
+      emit('child_started', { kind });
+      channel.send({
+        type: 'start',
+        inputs: spec.inputs,
+        entrypoint: spec.entrypoint,
+        sourceName: spec.sourcePath || artifact,
+        control: control(),
+      });
+      while (true) {
+        const message = await Promise.race([
+          channel.nextMessage(),
+          finished,
+          timedOut,
+        ]);
+        if (message.type === 'timeout') {
           await terminate();
           emit('script_failed', { error: 'timeout' });
           return { ok: false, error: 'timeout' };
         }
-        channel.send({ type: 'verdict', id: message.id, value, control: readControl() });
-        continue;
-      }
-      if (message.type === 'control-point') {
-        channel.send({ type: 'control-state', id: message.id, control: readControl() });
-        continue;
-      }
-      if (message.type === 'progress') {
-        if (jsonBytes(message.event) > spec.policy.maxProgressBytes) {
-          await terminate();
-          emit('script_failed', { error: 'progress_too_large' });
-          return { ok: false, error: 'progress_too_large' };
+        if (message.type === 'call') {
+          const value = await rpc(host.call(message.command, message.args, message.options));
+          if (value && value.type === 'timeout') {
+            await terminate();
+            emit('script_failed', { error: 'timeout' });
+            return { ok: false, error: 'timeout' };
+          }
+          channel.send({ type: 'result', id: message.id, value, control: readControl() });
+          continue;
         }
-        emit('progress', message.event);
-        continue;
-      }
-      if (message.type === 'checkpoint') {
-        if (jsonBytes(message.state) > spec.policy.maxOutputBytes) {
-          await terminate();
-          emit('script_failed', { error: 'checkpoint_too_large' });
-          return { ok: false, error: 'checkpoint_too_large' };
+        if (message.type === 'assert') {
+          const value = await rpc(host.assert(message.assertion));
+          if (value && value.type === 'timeout') {
+            await terminate();
+            emit('script_failed', { error: 'timeout' });
+            return { ok: false, error: 'timeout' };
+          }
+          channel.send({ type: 'verdict', id: message.id, value, control: readControl() });
+          continue;
         }
-        const receipt = await rpc(Promise.resolve(emit('checkpoint', { name: message.name, state: message.state })));
-        if (receipt && receipt.type === 'timeout') {
-          await terminate();
-          emit('script_failed', { error: 'timeout' });
-          return { ok: false, error: 'timeout' };
+        if (message.type === 'control-point') {
+          channel.send({ type: 'control-state', id: message.id, control: readControl() });
+          continue;
         }
-        if (receipt && receipt.ok === false) {
-          await terminate();
-          const error = receipt.error || 'checkpoint_not_persisted';
-          emit('script_failed', { error });
-          return { ok: false, error };
+        if (message.type === 'progress') {
+          if (jsonBytes(message.event) > spec.policy.maxProgressBytes) {
+            await terminate();
+            emit('script_failed', { error: 'progress_too_large' });
+            return { ok: false, error: 'progress_too_large' };
+          }
+          emit('progress', message.event);
+          continue;
         }
-        channel.send({ type: 'checkpoint-receipt', id: message.id, value: receipt, control: readControl() });
-        continue;
-      }
-      if (message.type === 'ask') {
-        const value = await rpc(agent.askAgent(message.request));
-        if (value && value.type === 'timeout') {
-          await terminate();
-          emit('script_failed', { error: 'timeout' });
-          return { ok: false, error: 'timeout' };
+        if (message.type === 'checkpoint') {
+          if (jsonBytes(message.state) > spec.policy.maxOutputBytes) {
+            await terminate();
+            emit('script_failed', { error: 'checkpoint_too_large' });
+            return { ok: false, error: 'checkpoint_too_large' };
+          }
+          const receipt = await rpc(Promise.resolve(emit('checkpoint', { name: message.name, state: message.state })));
+          if (receipt && receipt.type === 'timeout') {
+            await terminate();
+            emit('script_failed', { error: 'timeout' });
+            return { ok: false, error: 'timeout' };
+          }
+          if (receipt && receipt.ok === false) {
+            await terminate();
+            const error = receipt.error || 'checkpoint_not_persisted';
+            emit('script_failed', { error });
+            return { ok: false, error };
+          }
+          channel.send({ type: 'checkpoint-receipt', id: message.id, value: receipt, control: readControl() });
+          continue;
         }
-        channel.send({ type: 'decision', id: message.id, value, control: readControl() });
-        continue;
-      }
-      if (message.type === 'return') {
-        if (jsonBytes(message.result) > spec.policy.maxOutputBytes) {
+        if (message.type === 'ask') {
+          const value = await rpc(agent.askAgent(message.request));
+          if (value && value.type === 'timeout') {
+            await terminate();
+            emit('script_failed', { error: 'timeout' });
+            return { ok: false, error: 'timeout' };
+          }
+          channel.send({ type: 'decision', id: message.id, value, control: readControl() });
+          continue;
+        }
+        if (message.type === 'return') {
+          if (jsonBytes(message.result) > spec.policy.maxOutputBytes) {
+            await terminate();
+            emit('script_failed', { error: 'output_too_large' });
+            return { ok: false, error: 'output_too_large' };
+          }
+          child.stdin.end();
+          const ended = await Promise.race([finished, timedOut]);
+          if (ended && ended.type === 'timeout') {
+            await terminate();
+          } else {
+            await finished;
+          }
+          emit('script_completed', { result: message.result });
+          return { ok: true, result: message.result };
+        }
+        if (message.type === 'fail') {
           await terminate();
-          emit('script_failed', { error: 'output_too_large' });
-          return { ok: false, error: 'output_too_large' };
+          const error = message.error === 'channel_closed' || message.error === 'stopped'
+            ? 'child_crashed'
+            : (message.error || 'script_failed');
+          const captured = channel.diagnostics();
+          const diagnostics = { ...captured, ...(message.diagnostic ? { error: message.diagnostic } : {}) };
+          const extra = Object.keys(diagnostics).length ? { diagnostics } : {};
+          emit('script_failed', { error, ...extra });
+          return { ok: false, error, ...extra };
         }
-        child.stdin.end();
-        const ended = await Promise.race([finished, timedOut]);
-        if (ended && ended.type === 'timeout') {
+        if (message.type === 'exit') {
           await terminate();
-        } else {
-          await finished;
+          emit('script_failed', { error: 'child_crashed' });
+          return { ok: false, error: 'child_crashed' };
         }
-        emit('script_completed', { result: message.result });
-        return { ok: true, result: message.result };
-      }
-      if (message.type === 'fail') {
-        await terminate();
-        const error = message.error === 'channel_closed' || message.error === 'stopped'
-          ? 'child_crashed'
-          : (message.error || 'script_failed');
-        emit('script_failed', { error });
-        return { ok: false, error };
-      }
-      if (message.type === 'exit') {
         await terminate();
         emit('script_failed', { error: 'child_crashed' });
         return { ok: false, error: 'child_crashed' };
       }
-      await terminate();
-      emit('script_failed', { error: 'child_crashed' });
-      return { ok: false, error: 'child_crashed' };
-    }
     } catch {
       await terminate();
       emit('script_failed', { error: 'child_crashed' });
       return { ok: false, error: 'child_crashed' };
     } finally {
       if (timer) clearTimeout(timer);
+      await terminate();
+      if (directory) fs.rmSync(directory, { recursive: true, force: true });
     }
   }
 

package/bin/script/python-runtime-adapter.js

@@ -35,7 +35,7 @@ function pythonCandidates({ pythonPath, env = process.env } = {}) {
 }
 
 function probePython(executable, env) {
-  const options = { encoding: 'utf8', shell: false };
+  const options = { encoding: 'utf8', shell: false, timeout: 5000, killSignal: 'SIGKILL', maxBuffer: 16384 };
   if (env) options.env = env;
   const probe = spawnSync(executable, ['-c', 'import sys; print("%d.%d" % sys.version_info[:2])'], options);
   if (probe.status !== 0 || !probe.stdout) {

package/bin/script/script-diagnostics.js

@@ -0,0 +1,21 @@
+'use strict';
+
+function boundedText(value, maxBytes) {
+  return Buffer.from(String(value)).subarray(0, maxBytes).toString('utf8').replace(/\uFFFD$/, '');
+}
+
+function errorDiagnostic(error) {
+  const stack = typeof error?.stack === 'string' ? error.stack : '';
+  let frameCount = 0;
+  const limitedStack = stack.split('\n').filter(line => !/^\s*at /.test(line) || ++frameCount <= 20).join('\n');
+  const frame = stack.split('\n').find(line => /:(\d+):(\d+)\)?$/.test(line));
+  const location = frame?.match(/(?:at .*?\(|at )(.*):(\d+):(\d+)\)?$/);
+  const syntaxLocation = error?.name === 'SyntaxError' ? stack.split('\n')[0].match(/^(.*):(\d+)$/) : null;
+  return { type: boundedText(error?.name || 'Error', 128), message: boundedText(error?.message ?? error, 2048),
+    ...(stack ? { stack: boundedText(limitedStack, 8192), stackTruncated: frameCount > 20 || Buffer.byteLength(limitedStack) > 8192 } : {}),
+    ...(syntaxLocation ? { location: { file: boundedText(syntaxLocation[1], 1024), line: Number(syntaxLocation[2]) } }
+      : location ? { location: { file: boundedText(location[1], 1024), line: Number(location[2]), column: Number(location[3]) } } : {}),
+    ...(typeof error?.valuePath === 'string' ? { valuePath: boundedText(error.valuePath, 1024) } : {}) };
+}
+
+module.exports = { boundedText, errorDiagnostic };

package/bin/script/script-durable-restore.js

@@ -157,6 +157,7 @@ async function restoreUnknownOperation(args = {}) {
       operationId,
       status: terminal ? checkpoint.status : 'failed',
       error: terminal ? checkpoint.error || null : 'runtime_lost',
+      ...(checkpoint.diagnostics ? { diagnostics: checkpoint.diagnostics } : {}),
       persisted: true,
       restored: true,
       resumeMode: gate.ok ? 'checkpoint' : 'none',

package/bin/script/script-host-port.js

@@ -229,7 +229,7 @@ async function mutationResult(command, args, options, ctx) {
   const actionId = options.dispatchActionId || mutationActionId(ctx.executionId, ctx.callId);
   const bound = dispatchArgs(args, actionId);
   try {
-    return await admitExecutionMutation(ctx.target, ctx.mutationLease, async () => {
+    const execute = async () => {
       try { return await actionOnce(command, bound, options, {
       actions: ctx.actions,
       target: ctx.target,
@@ -238,7 +238,8 @@ async function mutationResult(command, args, options, ctx) {
       actionId,
       onAction: ctx.onAction,
       }); } finally { ctx.onSettled(); }
-    });
+    };
+    return command === 'executor-prepare' ? await execute() : await admitExecutionMutation(ctx.target, ctx.mutationLease, execute);
   } catch (error) {
     return unavailableEnvelope({ command, error: error.code || error.message, executionId: ctx.executionId, callId: ctx.callId });
   }

package/bin/script/script-sdk.js

@@ -2,8 +2,9 @@
 
 const fs = require('node:fs');
 const readline = require('node:readline');
+const { boundedText, errorDiagnostic } = require('./script-diagnostics');
 
-const artifactPath = process.argv[2];
+const artifactPath = fs.realpathSync(process.argv[2]);
 const replies = new Map();
 const controlWaiters = [];
 let nextId = 0;
@@ -37,6 +38,7 @@ function waitReply(id) {
 rl.on('line', (line) => {
   if (!line) return;
   let message;
+  const parseStarted = performance.now();
   try {
     message = JSON.parse(line);
   } catch {
@@ -44,10 +46,21 @@ rl.on('line', (line) => {
     process.exit(1);
     return;
   }
+  const inputParseMs = performance.now() - parseStarted;
   if (message.type === 'start') {
     applyControl(message.control);
-    run(message).catch((error) => {
-      send({ type: 'fail', error: error.message || String(error) });
+    run(message, inputParseMs).catch((error) => {
+      const diagnostic = errorDiagnostic(error);
+      if (message.sourceName && message.sourceName !== artifactPath) {
+        if (diagnostic.stack) {
+          const mapped = diagnostic.stack.replaceAll(artifactPath, message.sourceName);
+          diagnostic.stack = boundedText(mapped, 8192);
+          diagnostic.stackTruncated ||= Buffer.byteLength(mapped) > 8192;
+        }
+        if (diagnostic.location?.file === artifactPath) diagnostic.location.file = boundedText(message.sourceName, 1024);
+      }
+      send({ type: 'fail', error: message.extraction ? (error.code || 'extraction_failed') : diagnostic.message,
+        message: diagnostic.message, diagnostic });
       process.exit(1);
     });
     return;
@@ -92,7 +105,29 @@ function holdIfPaused() {
   });
 }
 
-async function run(start) {
+async function run(start, inputParseMs) {
+  if (start.extraction) {
+    const executionStarted = performance.now();
+    let result;
+    if (start.extraction.mode === 'regex') result = require('../extraction/regex').extractRegex(start.inputs.response, start.extraction);
+    else {
+      const Module = require('node:module');
+      const path = require('node:path');
+      const filename = path.resolve(start.sourceName || artifactPath);
+      const loaded = new Module(filename, module);
+      loaded.filename = filename;
+      loaded.paths = Module._nodeModulePaths(path.dirname(filename));
+      loaded._compile(fs.readFileSync(artifactPath, 'utf8'), filename);
+      const main = typeof loaded.exports === 'function' ? loaded.exports : loaded.exports.main;
+      if (typeof main !== 'function') throw new TypeError('Extraction source must export main(ctx).');
+      result = await main({ inputs: start.inputs });
+    }
+    require('../extraction/json-value').validateJsonValue(result);
+    if (Buffer.byteLength(JSON.stringify(result)) > 256 * 1024) throw Object.assign(new Error('Extraction result exceeds 256 KiB.'), { code: 'extraction_output_too_large' });
+    send({ type: 'return', result, timings: { inputParseMs, executionMs: performance.now() - executionStarted } });
+    process.exit(0);
+    return;
+  }
   const loaded = require(artifactPath);
   const entry = start.entrypoint || 'main';
   const main = typeof loaded === 'function' && entry === 'main' ? loaded : loaded[entry];

package/bin/script/script-sdk.py

@@ -1,9 +1,14 @@
 import asyncio
 import json
 import sys
+import math
+import traceback
+import time
+from types import SimpleNamespace
 
 
 _real_stdout = sys.stdout
+_input_parse_ms = 0
 HELD = {
     "pause_requested",
     "paused_manual",
@@ -20,10 +25,14 @@ def send(message):
 
 
 def read_message():
+    global _input_parse_ms
     line = sys.stdin.readline()
     if not line:
         return None
-    return json.loads(line)
+    started = time.perf_counter()
+    message = json.loads(line)
+    _input_parse_ms = (time.perf_counter() - started) * 1000
+    return message
 
 
 class HostContext:
@@ -120,22 +129,74 @@ class HostContext:
         return checkpoint["state"]
 
 
-def load_namespace(path):
+def load_namespace(path, source_name=None):
     namespace = {}
     with open(path, "r", encoding="utf-8") as handle:
-        exec(handle.read(), namespace, namespace)
+        exec(compile(handle.read(), source_name or path, "exec"), namespace, namespace)
     return namespace
 
 
+def validate_json(value, location="", parents=None):
+    parents = set() if parents is None else parents
+
+    def invalid(reason):
+        error = TypeError(f"{location or '/'}: {reason}")
+        error.code = "extraction_type_error"
+        error.value_path = location
+        raise error
+
+    if value is None or isinstance(value, (str, bool)):
+        return
+    if isinstance(value, (int, float)):
+        if (isinstance(value, int) and abs(value) > 9007199254740991) or (isinstance(value, float) and
+                (not math.isfinite(value) or value.is_integer() and abs(value) > 9007199254740991)):
+            invalid("expected a finite number in the safe integer range")
+        return
+    if type(value) not in (list, dict):
+        invalid(f"unsupported JSON type: {type(value).__name__}")
+    if id(value) in parents:
+        invalid("cyclic value")
+    parents.add(id(value))
+    entries = enumerate(value) if isinstance(value, list) else value.items()
+    for key, item in entries:
+        if isinstance(value, dict) and not isinstance(key, str):
+            invalid("object keys must be strings")
+        suffix = str(key).replace("~", "~0").replace("/", "~1")
+        validate_json(item, f"{location}/{suffix}", parents)
+    parents.remove(id(value))
+
+
+def bounded(value, size):
+    return str(value).encode("utf-8", errors="replace")[:size].decode("utf-8", errors="ignore")
+
+
+def diagnostic(error):
+    frames = traceback.extract_tb(error.__traceback__)
+    stack = "Traceback (most recent call last):\n" + "".join(traceback.format_list(frames[-20:])) + "".join(traceback.format_exception_only(type(error), error))
+    result = {"type": type(error).__name__, "message": bounded(error, 2048),
+              "stack": bounded(stack, 8192), "stackTruncated": len(frames) > 20 or len(stack.encode("utf-8")) > 8192}
+    if isinstance(error, SyntaxError) and error.filename:
+        result["location"] = {"file": bounded(error.filename, 1024), "line": error.lineno, "column": error.offset}
+    elif frames:
+        frame = frames[-1]
+        result["location"] = {"file": bounded(frame.filename, 1024), "line": frame.lineno}
+    if hasattr(error, "value_path"):
+        result["valuePath"] = bounded(error.value_path, 1024)
+    return result
+
+
 def main():
     artifact_path = sys.argv[1]
     send({"type": "ready"})
     start = read_message()
     sys.stdout = sys.stderr
-    ctx = HostContext(start.get("inputs") or {}, start.get("control") or {"status": "running", "pauseReason": None})
+    extraction = start.get("extraction") is not None
+    ctx = SimpleNamespace(inputs=start["inputs"]) if extraction else HostContext(start.get("inputs") or {}, start.get("control") or {"status": "running", "pauseReason": None})
     entry = start.get("entrypoint") or "main"
     try:
-        namespace = load_namespace(artifact_path)
+        execution_started = time.perf_counter()
+        input_parse_ms = _input_parse_ms
+        namespace = load_namespace(artifact_path, start.get("sourceName"))
         loaded = namespace.get(entry)
         if not callable(loaded):
             send({"type": "fail", "error": "unsupported_entrypoint"})
@@ -143,9 +204,20 @@ def main():
         result = loaded(ctx)
         if asyncio.iscoroutine(result):
             result = asyncio.run(result)
-        send({"type": "return", "result": result})
+        if extraction:
+            validate_json(result)
+            if len(json.dumps(result, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")) > 256 * 1024:
+                error = ValueError("Extraction result exceeds 256 KiB.")
+                error.code = "extraction_output_too_large"
+                raise error
+        frame = {"type": "return", "result": result}
+        if extraction:
+            frame["timings"] = {"inputParseMs": input_parse_ms, "executionMs": (time.perf_counter() - execution_started) * 1000}
+        send(frame)
     except Exception as error:
-        send({"type": "fail", "error": str(error)})
+        detail = diagnostic(error)
+        send({"type": "fail", "error": getattr(error, "code", "extraction_failed") if extraction else detail["message"],
+              "message": detail["message"], "diagnostic": detail})
         sys.exit(1)