runline 0.22.0 → 0.24.0

package/dist/plugins/steel/src/page/vendor/aria-snapshot/stringUtils.js

@@ -0,0 +1,194 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// NOTE: this function should not be used to escape any selectors.
+export function escapeWithQuotes(text, char = '\'') {
+    const stringified = JSON.stringify(text);
+    const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
+    if (char === '\'')
+        return char + escapedText.replace(/[']/g, '\\\'') + char;
+    if (char === '"')
+        return char + escapedText.replace(/["]/g, '\\"') + char;
+    if (char === '`')
+        return char + escapedText.replace(/[`]/g, '\\`') + char;
+    throw new Error('Invalid escape char');
+}
+export function escapeTemplateString(text) {
+    return text
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${');
+}
+export function isString(obj) {
+    return typeof obj === 'string' || obj instanceof String;
+}
+export function toTitleCase(name) {
+    return name.charAt(0).toUpperCase() + name.substring(1);
+}
+export function toSnakeCase(name) {
+    // E.g. ignoreHTTPSErrors => ignore_https_errors.
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/([A-Z])([A-Z][a-z])/g, '$1_$2').toLowerCase();
+}
+export function formatObject(value, indent = '  ', mode = 'multiline') {
+    if (typeof value === 'string')
+        return escapeWithQuotes(value, '\'');
+    if (Array.isArray(value))
+        return `[${value.map(o => formatObject(o)).join(', ')}]`;
+    if (typeof value === 'object') {
+        const keys = Object.keys(value).filter(key => key !== 'timeout' && value[key] !== undefined).sort();
+        if (!keys.length)
+            return '{}';
+        const tokens = [];
+        for (const key of keys)
+            tokens.push(`${key}: ${formatObject(value[key])}`);
+        if (mode === 'multiline')
+            return `{\n${tokens.map(t => indent + t).join(`,\n`)}\n}`;
+        return `{ ${tokens.join(', ')} }`;
+    }
+    return String(value);
+}
+export function formatObjectOrVoid(value, indent = '  ') {
+    const result = formatObject(value, indent);
+    return result === '{}' ? '' : result;
+}
+export function quoteCSSAttributeValue(text) {
+    return `"${text.replace(/["\\]/g, char => '\\' + char)}"`;
+}
+let normalizedWhitespaceCache;
+export function cacheNormalizedWhitespaces() {
+    normalizedWhitespaceCache = new Map();
+}
+export function normalizeWhiteSpace(text) {
+    let result = normalizedWhitespaceCache?.get(text);
+    if (result === undefined) {
+        result = text.replace(/[\u200b\u00ad]/g, '').trim().replace(/\s+/g, ' ');
+        normalizedWhitespaceCache?.set(text, result);
+    }
+    return result;
+}
+export function normalizeEscapedRegexQuotes(source) {
+    // This function reverses the effect of escapeRegexForSelector below.
+    // Odd number of backslashes followed by the quote -> remove unneeded backslash.
+    return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, '$1$2$3');
+}
+function escapeRegexForSelector(re) {
+    // Unicode mode does not allow "identity character escapes", so we do not escape and
+    // hope that it does not contain quotes and/or >> signs.
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Character_escape
+    // TODO: rework RE usages in internal selectors away from literal representation to json, e.g. {source,flags}.
+    if (re.unicode || re.unicodeSets)
+        return String(re);
+    // Even number of backslashes followed by the quote -> insert a backslash.
+    return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, '$1$2\\$3').replace(/>>/g, '\\>\\>');
+}
+export function escapeForTextSelector(text, exact) {
+    if (typeof text !== 'string')
+        return escapeRegexForSelector(text);
+    return `${JSON.stringify(text)}${exact ? 's' : 'i'}`;
+}
+export function escapeForAttributeSelector(value, exact) {
+    if (typeof value !== 'string')
+        return escapeRegexForSelector(value);
+    // TODO: this should actually be
+    //   cssEscape(value).replace(/\\ /g, ' ')
+    // However, our attribute selectors do not conform to CSS parsing spec,
+    // so we escape them differently.
+    return `"${value.replace(/\\/g, '\\\\').replace(/["]/g, '\\"')}"${exact ? 's' : 'i'}`;
+}
+export function trimString(input, cap, suffix = '') {
+    if (input.length <= cap)
+        return input;
+    const chars = [...input];
+    if (chars.length > cap)
+        return chars.slice(0, cap - suffix.length).join('') + suffix;
+    return chars.join('');
+}
+export function trimStringWithEllipsis(input, cap) {
+    return trimString(input, cap, '\u2026');
+}
+export function truncateDataUrl(url) {
+    // Data URLs can carry megabytes of base64 payload, which is never useful in
+    // human/AI-facing output. Keep the media type prefix for context, drop the data.
+    if (!url.startsWith('data:'))
+        return url;
+    const comma = url.indexOf(',');
+    if (comma === -1)
+        return url;
+    return url.slice(0, comma + 1) + '\u2026';
+}
+export function escapeRegExp(s) {
+    // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+const escaped = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', '\'': '&#39;' };
+export function escapeHTMLAttribute(s) {
+    return s.replace(/[&<>"']/ug, char => escaped[char]);
+}
+export function escapeHTML(s) {
+    return s.replace(/[&<]/ug, char => escaped[char]);
+}
+export function longestCommonSubstring(s1, s2) {
+    const n = s1.length;
+    const m = s2.length;
+    let maxLen = 0;
+    let endingIndex = 0;
+    // Initialize a 2D array with zeros
+    const dp = Array(n + 1)
+        .fill(null)
+        .map(() => Array(m + 1).fill(0));
+    // Build the dp table
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (s1[i - 1] === s2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+                if (dp[i][j] > maxLen) {
+                    maxLen = dp[i][j];
+                    endingIndex = i;
+                }
+            }
+        }
+    }
+    // Extract the longest common substring
+    return s1.slice(endingIndex - maxLen, endingIndex);
+}
+export function parseRegex(regex) {
+    if (regex[0] !== '/')
+        throw new Error(`Invalid regex, must start with '/': ${regex}`);
+    const lastSlash = regex.lastIndexOf('/');
+    if (lastSlash <= 0)
+        throw new Error(`Invalid regex, must end with '/' followed by optional flags: ${regex}`);
+    const source = regex.slice(1, lastSlash);
+    const flags = regex.slice(lastSlash + 1);
+    return new RegExp(source, flags);
+}
+export function tomlBasicString(value) {
+    // JSON.stringify produces a valid TOML basic string: escapes \", \\, \n, \r, \t and uses \uXXXX for control chars.
+    return JSON.stringify(value);
+}
+export function tomlArray(values) {
+    return `[${values.map(value => tomlBasicString(value)).join(', ')}]`;
+}
+export function tomlMultilineBasicString(value) {
+    // Triple-quoted basic string: escape backslashes first, then any literal """ sequences.
+    const escaped = value.replace(/\\/g, '\\\\').replace(/"""/g, '\\"\\"\\"');
+    return `"""\n${escaped}\n"""`;
+}
+// Semicolons removed from [[\]()#;?] to avoid polynomial backtracking
+// when both that group and (?:;...)* can match runs of semicolons.
+// \d{1,4} relaxed to \d{0,4} so empty params (e.g. ESC[;H) still match.
+export const ansiRegex = new RegExp('([\\u001B\\u009B][[\\]()#?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{0,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~])))', 'g');
+export function stripAnsiEscapes(str) {
+    return str.replace(ansiRegex, '');
+}

package/dist/plugins/steel/src/page/vendor/aria-snapshot/yaml.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function yamlEscapeKeyIfNeeded(str) {
+    if (!yamlStringNeedsQuotes(str))
+        return str;
+    return `'` + str.replace(/'/g, `''`) + `'`;
+}
+export function yamlEscapeValueIfNeeded(str) {
+    if (!yamlStringNeedsQuotes(str))
+        return str;
+    return '"' + str.replace(/[\\"\x00-\x1f\x7f-\x9f]/g, c => {
+        switch (c) {
+            case '\\':
+                return '\\\\';
+            case '"':
+                return '\\"';
+            case '\b':
+                return '\\b';
+            case '\f':
+                return '\\f';
+            case '\n':
+                return '\\n';
+            case '\r':
+                return '\\r';
+            case '\t':
+                return '\\t';
+            default:
+                const code = c.charCodeAt(0);
+                return '\\x' + code.toString(16).padStart(2, '0');
+        }
+    }) + '"';
+}
+function yamlStringNeedsQuotes(str) {
+    if (str.length === 0)
+        return true;
+    // Strings with leading or trailing whitespace need quotes
+    if (/^\s|\s$/.test(str))
+        return true;
+    // Strings containing control characters need quotes
+    if (/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/.test(str))
+        return true;
+    // Strings starting with '-' need quotes
+    if (/^-/.test(str))
+        return true;
+    // Strings containing ':' or '\n' followed by a space or at the end need quotes
+    if (/[\n:](\s|$)/.test(str))
+        return true;
+    // Strings containing '#' preceded by a space need quotes (comment indicator)
+    if (/\s#/.test(str))
+        return true;
+    // Strings that contain line breaks need quotes
+    if (/[\n\r]/.test(str))
+        return true;
+    // Strings starting with indicator characters or quotes need quotes
+    if (/^[&*\],?!>|@"'#%]/.test(str))
+        return true;
+    // Strings containing special characters that could cause ambiguity
+    if (/[{}`]/.test(str))
+        return true;
+    // YAML array starts with [
+    if (/^\[/.test(str))
+        return true;
+    // Non-string types recognized by YAML
+    if (!isNaN(Number(str)) || ['y', 'n', 'yes', 'no', 'true', 'false', 'on', 'off', 'null'].includes(str.toLowerCase()))
+        return true;
+    return false;
+}

package/dist/plugins/steel/src/page/wait-for.js

@@ -0,0 +1,30 @@
+export async function waitForPage(document, request, options = {}) {
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ??
+        (async (ms) => {
+            await new Promise((resolve) => setTimeout(resolve, ms));
+        });
+    const timeoutMs = Math.min(30, Math.max(0, request.time ?? 5)) * 1_000;
+    const started = now();
+    if (!request.text && !request.textGone) {
+        await sleep(timeoutMs);
+        return {
+            matched: true,
+            timedOut: false,
+            elapsedMs: Math.max(0, now() - started),
+        };
+    }
+    while (true) {
+        const text = document.body?.innerText ?? document.body?.textContent ?? "";
+        const found = !request.text || text.includes(request.text);
+        const gone = !request.textGone || !text.includes(request.textGone);
+        const elapsedMs = Math.max(0, now() - started);
+        if (found && gone) {
+            return { matched: true, timedOut: false, elapsedMs };
+        }
+        if (elapsedMs >= timeoutMs) {
+            return { matched: false, timedOut: true, elapsedMs };
+        }
+        await sleep(Math.min(100, timeoutMs - elapsedMs));
+    }
+}

package/dist/plugins/steel/src/sessions.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { LIST_INPUT_SCHEMA, SESSION_OPTIONS_SCHEMA, api, apiKey, compactRecord } from "./shared.js";
+import { LIST_INPUT_SCHEMA, SESSION_OPTIONS_SCHEMA, api, cdpUrl, compactRecord } from "./shared.js";
 export function registerSessionActions(rl) {
     rl.registerAction("session.create", {
         access: "write",
@@ -119,12 +119,7 @@ export function registerSessionActions(rl) {
         inputSchema: t.Object({ id: t.String({ description: "Session ID" }), websocketUrl: t.Optional(t.String({ description: "Optional websocketUrl returned by session.create. If omitted, uses wss://connect.steel.dev with sessionId." })) }),
         async execute(input, ctx) {
             const { id, websocketUrl } = input;
-            const key = encodeURIComponent(apiKey(ctx));
-            if (websocketUrl) {
-                const sep = websocketUrl.includes("?") ? "&" : "?";
-                return { cdpUrl: `${websocketUrl}${sep}apiKey=${key}` };
-            }
-            return { cdpUrl: `wss://connect.steel.dev?apiKey=${key}&sessionId=${encodeURIComponent(id)}` };
+            return { cdpUrl: cdpUrl(ctx, id, websocketUrl) };
         },
     });
 }

package/dist/plugins/steel/src/shared.js

@@ -45,6 +45,18 @@ export async function api(ctx, path, options = {}) {
         return JSON.parse(text);
     return text;
 }
+/**
+ * The CDP endpoint for a session. One definition: this URL carries the
+ * API key, so a second hand-written copy is a second place to leak it or
+ * to forget encoding.
+ */
+export function cdpUrl(ctx, sessionId, websocketUrl) {
+    const key = encodeURIComponent(apiKey(ctx));
+    if (websocketUrl) {
+        return `${websocketUrl}${websocketUrl.includes("?") ? "&" : "?"}apiKey=${key}`;
+    }
+    return `wss://connect.steel.dev?apiKey=${key}&sessionId=${encodeURIComponent(sessionId)}`;
+}
 export function compactRecord(input) {
     return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Code mode for agents \u2014 turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",