@mobileaidev/ai-app-bridge 0.2.15 → 0.3.0-rc.2

package/bin/script/script-sdk.py

@@ -0,0 +1,153 @@
+import asyncio
+import json
+import sys
+
+
+_real_stdout = sys.stdout
+HELD = {
+    "pause_requested",
+    "paused_manual",
+    "paused_live",
+    "paused_ambiguous",
+}
+
+
+def send(message):
+    # Match the Host UTF-8 JSON byte budget; ASCII escaping can triple it.
+    frame = json.dumps(message, ensure_ascii=False, separators=(",", ":")) + "\n"
+    _real_stdout.buffer.write(frame.encode("utf-8", errors="backslashreplace"))
+    _real_stdout.buffer.flush()
+
+
+def read_message():
+    line = sys.stdin.readline()
+    if not line:
+        return None
+    return json.loads(line)
+
+
+class HostContext:
+    def __init__(self, inputs, control):
+        self.inputs = inputs
+        self._control = control
+        self._next_id = 0
+
+    def _id(self, prefix):
+        self._next_id += 1
+        return f"{prefix}{self._next_id}"
+
+    def _apply_control(self, payload):
+        if payload:
+            self._control = payload
+
+    def _hold_if_paused(self):
+        while self._control.get("status") in HELD:
+            message = read_message()
+            if message is None:
+                raise RuntimeError("channel_closed")
+            if message.get("type") == "control":
+                self._apply_control(message.get("control"))
+                continue
+            raise RuntimeError("unexpected_frame")
+
+    def _read_reply(self, message_id):
+        while True:
+            reply = read_message()
+            if reply is None:
+                raise RuntimeError("channel_closed")
+            if reply.get("type") == "control":
+                self._apply_control(reply.get("control"))
+                continue
+            if reply.get("id") == message_id:
+                self._apply_control(reply.get("control"))
+                return reply
+            raise RuntimeError("unexpected_frame")
+
+    def _sync_control(self):
+        message_id = self._id("s")
+        send({"type": "control-point", "id": message_id})
+        self._read_reply(message_id)
+
+    def _safe_point(self):
+        self._sync_control()
+        self._hold_if_paused()
+
+    def call(self, command, args=None, options=None):
+        self._safe_point()
+        message_id = self._id("c")
+        send({"type": "call", "id": message_id, "command": command, "args": args or {}, "options": options or {}})
+        reply = self._read_reply(message_id)
+        self._safe_point()
+        return reply["value"]
+
+    def assert_(self, assertion):
+        self._safe_point()
+        message_id = self._id("a")
+        send({"type": "assert", "id": message_id, "assertion": assertion})
+        reply = self._read_reply(message_id)
+        self._safe_point()
+        return reply["value"]
+
+    def progress(self, event):
+        self._safe_point()
+        send({"type": "progress", "event": event})
+        self._safe_point()
+
+    def checkpoint(self, name, state):
+        self._safe_point()
+        message_id = self._id("k")
+        send({"type": "checkpoint", "id": message_id, "name": name, "state": state})
+        reply = self._read_reply(message_id)
+        self._safe_point()
+        return reply["value"]
+
+    def askAgent(self, request):
+        self._safe_point()
+        message_id = self._id("q")
+        send({"type": "ask", "id": message_id, "request": request})
+        reply = self._read_reply(message_id)
+        self._safe_point()
+        return reply["value"]
+
+    def controlPoint(self):
+        self._sync_control()
+        return self._control
+
+    def resume(self):
+        checkpoint = self._control.get("checkpoint")
+        if not checkpoint:
+            return None
+        return checkpoint["state"]
+
+
+def load_namespace(path):
+    namespace = {}
+    with open(path, "r", encoding="utf-8") as handle:
+        exec(handle.read(), namespace, namespace)
+    return namespace
+
+
+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})
+    entry = start.get("entrypoint") or "main"
+    try:
+        namespace = load_namespace(artifact_path)
+        loaded = namespace.get(entry)
+        if not callable(loaded):
+            send({"type": "fail", "error": "unsupported_entrypoint"})
+            sys.exit(1)
+        result = loaded(ctx)
+        if asyncio.iscoroutine(result):
+            result = asyncio.run(result)
+        send({"type": "return", "result": result})
+    except Exception as error:
+        send({"type": "fail", "error": str(error)})
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/bin/script/script-session-channel.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const MAX_FRAME_BYTES = 1024 * 1024;
+
+function createScriptSessionChannel(child, { maxFrameBytes = MAX_FRAME_BYTES } = {}) {
+  let buffer = '';
+  let closed = false;
+  let failure = null;
+  let killTimer;
+  child.once('exit', () => clearTimeout(killTimer));
+  const waiters = [];
+  const pending = [];
+  const replies = new Map();
+  const maxPending = 32;
+
+  if (child.stderr) {
+    child.stderr.on('data', () => {});
+  }
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => {
+    if (closed) return;
+    buffer += chunk;
+    let index = buffer.indexOf('\n');
+    while (index >= 0) {
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      index = buffer.indexOf('\n');
+      if (Buffer.byteLength(line, 'utf8') > maxFrameBytes) {
+        fail(new Error('frame_too_large'));
+        return;
+      }
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        fail(new Error('malformed_frame'));
+        return;
+      }
+      if (message == null || typeof message !== 'object' || Array.isArray(message)) {
+        fail(new Error('malformed_frame'));
+        return;
+      }
+      if (message.id && replies.has(message.id)) {
+        const resolve = replies.get(message.id);
+        replies.delete(message.id);
+        resolve(message);
+        continue;
+      }
+      if (waiters.length > 0) {
+        waiters.shift()(message);
+        continue;
+      }
+      if (pending.length >= maxPending) {
+        fail(new Error('channel_backlog'));
+        return;
+      }
+      pending.push(message);
+    }
+    if (Buffer.byteLength(buffer, 'utf8') > maxFrameBytes) {
+      fail(new Error('frame_too_large'));
+    }
+  });
+  child.stdout.on('end', () => fail(new Error('channel_closed')));
+  child.on('error', (error) => fail(error));
+
+  function send(message) {
+    if (closed || !child.stdin.writable) return;
+    const line = `${JSON.stringify(message)}\n`;
+    if (Buffer.byteLength(line, 'utf8') > maxFrameBytes) {
+      fail(new Error('frame_too_large'));
+      return;
+    }
+    child.stdin.write(line);
+  }
+
+  function nextMessage() {
+    return new Promise((resolve) => {
+      if (closed) {
+        resolve(failure);
+        return;
+      }
+      if (pending.length > 0) {
+        resolve(pending.shift());
+        return;
+      }
+      waiters.push(resolve);
+    });
+  }
+
+  function waitReply(id) {
+    return new Promise((resolve) => {
+      if (closed) {
+        resolve(failure);
+        return;
+      }
+      if (replies.size >= maxPending) {
+        fail(new Error('channel_backlog'));
+        resolve({ type: 'fail', error: 'channel_backlog' });
+        return;
+      }
+      replies.set(id, resolve);
+    });
+  }
+
+  function fail(error) {
+    if (closed) return;
+    closed = true;
+    const frame = { type: 'fail', error: error.message || String(error) };
+    failure = frame;
+    pending.length = 0;
+    buffer = '';
+    while (waiters.length > 0) waiters.shift()(frame);
+    for (const resolve of replies.values()) resolve(frame);
+    replies.clear();
+  }
+
+  function stop() {
+    fail(new Error('stopped'));
+    if (!child.pid) return;
+    if (child.kill('SIGTERM') && !killTimer) killTimer = setTimeout(() => child.kill('SIGKILL'), 250);
+  }
+
+  return { send, nextMessage, waitReply, stop };
+}
+
+module.exports = { createScriptSessionChannel };

package/bin/script/script-spec.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('node:fs');
+const { requestDirectory, resolveRequestPath } = require('../shared-kernel/request-context');
+const { checksumOf } = require('../shared-kernel/evidence-schema');
+const { scriptError } = require('./script-errors');
+const { DEFAULT_PERMISSIONS } = require('./script-catalog');
+const { scriptPermissions } = require('../command-registry');
+const { validateValue } = require('../shared-kernel/argument-schema');
+const { scriptSpecSchema } = require('../shared-kernel/execution-contracts');
+const { CommandError } = require('../command-errors');
+const { normalizeExecutionTarget } = require('../shared-kernel/execution-target');
+
+const SCHEMA = 'aab.code-script/v1';
+const SCRIPT_SDK_VERSION = 'aab.script-sdk/v1';
+
+function isCodeScript(input) {
+  return Boolean(input && typeof input === 'object' && input.schemaVersion === SCHEMA);
+}
+
+function compileScriptSpec(input = {}) {
+  if (!isCodeScript(input)) return scriptError('invalid_script', { field: 'schemaVersion' });
+  try { validateValue(input, scriptSpecSchema(Object.keys(scriptPermissions))); }
+  catch (error) {
+    if (!(error instanceof CommandError)) throw error;
+    return scriptError(error.code, { field: error.field, message: error.message,
+      ...(error.details ? { details: error.details } : {}), dispatched: false, ambiguous: false });
+  }
+  let target;
+  try { target = normalizeExecutionTarget(input.target ?? null, { nullable: true }); }
+  catch (error) { return scriptError(error.code, { field: error.field, message: error.message, dispatched: false, ambiguous: false }); }
+  const language = input.language;
+  const hasPath = Object.hasOwn(input, 'sourcePath');
+  let source = input.source;
+  if (hasPath) {
+    try {
+      source = fs.readFileSync(input.sourcePath, 'utf8');
+    } catch (error) {
+      return scriptError('source_read_failed', { field: 'sourcePath', message: error.message });
+    }
+    if (!source) return scriptError('invalid_script', { field: 'sourcePath' });
+  }
+  const spec = {
+    schemaVersion: SCHEMA,
+    name: input.name ?? 'script',
+    language,
+    cwd: resolveRequestPath(input.cwd ?? requestDirectory()),
+    source,
+    sourcePath: hasPath ? input.sourcePath : null,
+    entrypoint: input.entrypoint ?? 'main',
+    target,
+    inputs: structuredClone(input.inputs ?? {}),
+    permissions: [...(input.permissions ?? DEFAULT_PERMISSIONS)],
+    policy: {
+      timeoutMs: input.policy?.timeoutMs ?? 600_000,
+      restartPolicy: input.policy?.restartPolicy ?? 'none',
+      maxOutputBytes: input.policy?.maxOutputBytes ?? 1_048_576,
+      maxProgressBytes: input.policy?.maxProgressBytes ?? 1_048_576,
+    },
+  };
+  if (Buffer.byteLength(JSON.stringify(spec.inputs), 'utf8') > spec.policy.maxOutputBytes) {
+    return scriptError('invalid_script', { field: 'inputs' });
+  }
+  return {
+    ok: true,
+    spec,
+    hash: scriptHash(spec),
+  };
+}
+
+function scriptHash(spec) {
+  return checksumOf({
+      source: spec.source,
+      sourcePath: spec.sourcePath,
+      cwd: spec.cwd,
+      inputs: spec.inputs,
+      policy: spec.policy,
+      language: spec.language,
+      entrypoint: spec.entrypoint,
+      sdkVersion: SCRIPT_SDK_VERSION,
+      target: spec.target,
+      permissions: spec.permissions,
+    });
+}
+
+module.exports = { SCHEMA, SCRIPT_SDK_VERSION, isCodeScript, compileScriptSpec, scriptHash };