tarsk 0.6.87 → 0.6.88

package/dist/bundled-skills/tarsk-bash/scripts/bash.js

@@ -0,0 +1,248 @@
+/**
+ * bash — truncation / background / ignored-flag copy in the Skill.
+ * Host: permissions, seatbelt, exec, compress/truncate prepare.
+ */
+
+export const description =
+  "Run shell from the repo root (optional `workdir` relative to root). Non-interactive. Use read/edit/write/find/grep for files — not bash; create/overwrite files with write (not shell heredocs like `cat > file <<EOF`). For builds, package managers, git, docker, and process control. Quote paths: repo-root, app-data, and temp absolute paths can contain spaces. Output: last 1000 lines / 32KB; page truncation with get_observation (tool_search first). select.fields, select.level, and select.range.path need JSON output: use them only when the command prints JSON (for example `cat file.json`, `curl`, `jq`). For text output, window in the command (`sed -n '10,40p'`, `head`, `tail`, `grep`) or use read. If direct bash invocation requires a select field despite plain-text output, call bash through run_js with the command and no select. select.range.path is a dot-path string such as `items[].name`; omit path for a line window. A call returns when its command exits, so a long build or test run in the foreground is waited for; never run `sleep` to wait for a command. For a process that does not exit on its own (dev server, watcher), `run_in_background` returns a job id at once: read it with job_output (it returns at once too — do other work and call it again for what is new, never `sleep` between reads), list with job_list, kill with job_kill. Never use timeout for long-lived servers. Git write actions only when the user asked.";
+
+export const parameters = {
+  type: "object",
+  required: ["command"],
+  properties: {
+    command: {
+      description: "Bash command",
+      type: "string",
+    },
+    workdir: {
+      description:
+        "Optional directory (relative to the repo root) to run the command in. Must stay within the repo.",
+      type: "string",
+    },
+    timeout: {
+      description:
+        "Hard timeout in seconds. When reached, the command and its entire process tree are killed. Do not use this to launch a long-running dev server.",
+      type: "number",
+    },
+    run_in_background: {
+      description:
+        "Start the command as a background job and return immediately with a job id. For long-running processes (dev servers, watchers, test runners) whose output you read later with job_output. A timeout set alongside run_in_background is ignored. Only one background flag per call.",
+      type: "boolean",
+    },
+  },
+};
+
+const BACKGROUND_IGNORED_NOTICE =
+  "[run_in_background ignored: this command keeps its foreground redirect semantics, so no job was started. Run the command to background on its own.]";
+
+function describeStartedBackgroundJob(jobId, resolvedCommand) {
+  return [
+    `Started background job ${jobId}: ${resolvedCommand}`,
+    `Read its output with job_output (jobId: ${jobId}), list jobs with job_list, and stop it with job_kill.`,
+  ].join("\n");
+}
+
+function buildTruncationNotice(truncation, tempFilePath, contentHash, formatSize, maxBytes) {
+  const suffix = `(sha:${contentHash}). Full output: ${tempFilePath}. Use read on the path or get_observation on this result to page output; do not re-run the command.`;
+  if (!truncation || !truncation.truncated) return "";
+  if (truncation.observationFromHead) {
+    return `\n\n[Showing first ${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)} ${suffix}]`;
+  }
+  const startLine = truncation.totalLines - truncation.outputLines + 1;
+  const endLine = truncation.totalLines;
+  if (truncation.lastLinePartial) {
+    return `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} ${suffix}]`;
+  }
+  if (truncation.truncatedBy === "lines") {
+    return `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} ${suffix}]`;
+  }
+  return `\n\n[Showing lines ${startLine}-${endLine} (${formatSize(maxBytes)} limit) ${suffix}]`;
+}
+
+function formatPrepared(prepared, context) {
+  if (prepared.suppressSelectionCompaction) {
+    return {
+      outputText: prepared.fullOutput,
+      details: prepared.tempFilePath ? { fullOutputPath: prepared.tempFilePath } : undefined,
+    };
+  }
+  let outputText = prepared.body;
+  let details;
+  if (prepared.truncated && prepared.truncation) {
+    details = { truncation: prepared.truncation, fullOutputPath: prepared.tempFilePath };
+    outputText += buildTruncationNotice(
+      prepared.truncation,
+      prepared.tempFilePath,
+      prepared.contentHash ?? "",
+      context.util.formatSize,
+      context.util.maxBytes,
+    );
+  } else if (prepared.jsonDigestApplied && prepared.tempFilePath) {
+    details = { fullOutputPath: prepared.tempFilePath };
+    outputText += `\n\n[Full raw output (sha:${prepared.contentHash}): ${prepared.tempFilePath}. Use read on the path or get_observation on this result to page output; do not re-run the command.]`;
+  }
+  if (prepared.partialBlockedNotice) {
+    outputText += `\n\n${prepared.partialBlockedNotice}`;
+  }
+  return { outputText, details };
+}
+
+const SELECT_PATH_SEGMENT = /^[A-Za-z0-9_$-]+$/;
+
+/** Mirrors the host dot-path grammar: `.`-separated segments, `*` and `[]` wildcards. */
+function isValidSelectPath(path) {
+  for (const segment of path.split(".")) {
+    if (segment === "*" || segment === "[]") continue;
+    if (segment.length === 0) return false;
+    if (segment.endsWith("[]")) {
+      const key = segment.slice(0, -2);
+      if (key.length === 0 || !SELECT_PATH_SEGMENT.test(key)) return false;
+      continue;
+    }
+    if (!SELECT_PATH_SEGMENT.test(segment)) return false;
+  }
+  return true;
+}
+
+function sanitizeSelectRange(value, dropped) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    dropped.push("select.range");
+    return undefined;
+  }
+  const range = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (key === "path") {
+      if (typeof raw === "string" && raw.trim() !== "" && isValidSelectPath(raw)) range.path = raw;
+      else dropped.push("select.range.path");
+    } else if (key === "offset" || key === "limit") {
+      if (typeof raw === "number" && Number.isInteger(raw) && raw >= 1) range[key] = raw;
+      else dropped.push(`select.range.${key}`);
+    } else {
+      dropped.push(`select.range.${key}`);
+    }
+  }
+  if (range.offset === undefined && range.limit === undefined) {
+    dropped.push("select.range");
+    return undefined;
+  }
+  return range;
+}
+
+/**
+ * The host rejects a malformed `select` before the command runs, which loses the
+ * whole result over a stray argument (most often a non-string `range.path`).
+ * Drop the offending axis, keep the call, and say what was dropped.
+ */
+function withSanitizedSelect(args) {
+  const select = args.select;
+  if (select === undefined) return { args, note: undefined };
+  const dropped = [];
+  let next;
+  if (select === null || typeof select !== "object" || Array.isArray(select)) {
+    dropped.push("select");
+  } else {
+    next = {};
+    for (const [key, value] of Object.entries(select)) {
+      if (key === "range") {
+        const range = sanitizeSelectRange(value, dropped);
+        if (range) next.range = range;
+      } else {
+        dropped.push(`select.${key}`);
+      }
+    }
+  }
+  if (dropped.length === 0) return { args, note: undefined };
+  const rest = Object.fromEntries(Object.entries(args).filter(([key]) => key !== "select"));
+  const kept = next && Object.keys(next).length > 0 ? next : undefined;
+  return {
+    args: kept ? { ...rest, select: kept } : rest,
+    note: `[select adjusted: dropped invalid ${dropped.join(", ")} — the host rejects the whole call, so that axis was ignored. Window text in the command (sed -n/head/tail) or read the stored output.]`,
+  };
+}
+
+/** Prepend a notice to the first text content item. */
+function withNote(result, note) {
+  if (!note || !Array.isArray(result.content)) return result;
+  const first = result.content[0];
+  if (first?.type !== "text") {
+    return { ...result, content: [{ type: "text", text: note }, ...result.content] };
+  }
+  return {
+    ...result,
+    content: [{ ...first, text: `${note}\n\n${first.text}` }, ...result.content.slice(1)],
+  };
+}
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context @param {{ signal?: AbortSignal, onUpdate?: Function, toolCallId?: string }} [options] */
+export async function execute(args, context, options) {
+  const sanitized = withSanitizedSelect(args);
+  const result = await runBash(sanitized.args, context, options);
+  return withNote(result, sanitized.note);
+}
+
+async function runBash(args, context, options) {
+  if (args.run_in_background && args.timeout !== undefined) {
+    // A background job returns immediately, so a timeout would have nothing to
+    // bound. Drop it instead of failing the call; the host still validates this
+    // for direct context.shell.run use.
+    args = { ...args, timeout: undefined };
+  }
+  const structured = await context.shell.run(args, options);
+
+  if (structured.status === "background") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: describeStartedBackgroundJob(structured.jobId, structured.command),
+        },
+      ],
+      details: { backgroundJobId: structured.jobId },
+    };
+  }
+
+  if (structured.status === "preformatted") {
+    const text = structured.backgroundIgnored
+      ? [structured.text, BACKGROUND_IGNORED_NOTICE].filter(Boolean).join("\n\n")
+      : structured.text;
+    return {
+      content: [{ type: "text", text }],
+      details: structured.commandFailed
+        ? { ...structured.details, commandFailed: true, exitCode: structured.exitCode }
+        : structured.details,
+    };
+  }
+
+  let { outputText, details } = formatPrepared(structured.prepared, context);
+  if (structured.dedicatedAppend) {
+    outputText = outputText
+      ? `${outputText}\n\n${structured.dedicatedAppend}`
+      : structured.dedicatedAppend;
+  }
+  if (structured.authHint) {
+    outputText = `${outputText}\n\n${structured.authHint}`;
+  }
+  if (structured.supersession) {
+    details = { ...details, supersession: structured.supersession };
+  }
+
+  const exitCode = structured.exitCode;
+  if (exitCode === 0 || exitCode === null) {
+    return { content: [{ type: "text", text: outputText }], details };
+  }
+
+  const outcome = context.shell.resolveExit({
+    exitCode,
+    executionCommand: structured.executionCommand,
+    outputText,
+    fullOutput: structured.prepared.fullOutput,
+    threadId: structured.threadId,
+  });
+  if (outcome.kind === "reject") {
+    throw new Error(outcome.outputText);
+  }
+  return {
+    content: [{ type: "text", text: outcome.outputText }],
+    details: outcome.commandFailed ? { ...details, commandFailed: true, exitCode } : details,
+  };
+}

package/dist/bundled-skills/tarsk-browser/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: tarsk-browser
+description: >-
+  Tarsk Tool skill publishing: browser.
+version: 3.0.0
+tools:
+  - browser
+disable-model-invocation: true
+---
+
+# tarsk-browser
+
+Publishes: browser.
+
+Model JSON / screenshot strip copy in `scripts/browser.js`. Host
+`context.browser.run` returns structured payload (Electrobun + RPC circuit +
+webview actions). Operational error throws stay in the host.

package/dist/bundled-skills/tarsk-browser/scripts/browser.js

@@ -0,0 +1,252 @@
+/** Auto-generated Tool skill script for browser */
+
+export const description =
+  "In-app Browser: screenshot the page to a PNG/JPEG file (capture what the dev server renders; returns savedPath + imageUrl). " +
+  "Read: open_url→snapshot for @eN refs, get_state, inspect_element (one element), find_in_page, evaluate_javascript, get_console_logs. " +
+  "Act: click, fill, press, hover, wait_for. Prefer webmcp_call when snapshot lists webmcp_tools. " +
+  "Call directly — never via run_js: the tab only opens for the conversation's own browser calls. " +
+  "Start the dev server first with bash run_in_background (servers ignore the bash timeout), then open_url its printed localhost URL.";
+
+export const parameters = {
+  type: "object",
+  required: ["action"],
+  properties: {
+    action: {
+      description:
+        "Browser action. Navigation: open_url, reload, go_back, go_forward, get_state. Inspection: inspect_element, snapshot, screenshot, get_console_logs, find_in_page, stop_find_in_page. Interaction: click, fill, press, hover, wait_for, evaluate_javascript. WebMCP (pages that register document.modelContext tools): webmcp_list_tools, webmcp_call. Layout: set_viewport.",
+      anyOf: [
+        {
+          const: "open_url",
+          type: "string",
+        },
+        {
+          const: "evaluate_javascript",
+          type: "string",
+        },
+        {
+          const: "find_in_page",
+          type: "string",
+        },
+        {
+          const: "stop_find_in_page",
+          type: "string",
+        },
+        {
+          const: "reload",
+          type: "string",
+        },
+        {
+          const: "go_back",
+          type: "string",
+        },
+        {
+          const: "go_forward",
+          type: "string",
+        },
+        {
+          const: "get_state",
+          type: "string",
+        },
+        {
+          const: "screenshot",
+          type: "string",
+        },
+        {
+          const: "set_viewport",
+          type: "string",
+        },
+        {
+          const: "snapshot",
+          type: "string",
+        },
+        {
+          const: "inspect_element",
+          type: "string",
+        },
+        {
+          const: "click",
+          type: "string",
+        },
+        {
+          const: "fill",
+          type: "string",
+        },
+        {
+          const: "press",
+          type: "string",
+        },
+        {
+          const: "hover",
+          type: "string",
+        },
+        {
+          const: "wait_for",
+          type: "string",
+        },
+        {
+          const: "get_console_logs",
+          type: "string",
+        },
+        {
+          const: "webmcp_list_tools",
+          type: "string",
+        },
+        {
+          const: "webmcp_call",
+          type: "string",
+        },
+      ],
+    },
+    url: {
+      description: "URL to open; required for `open_url`.",
+      type: "string",
+    },
+    script: {
+      description:
+        "JavaScript to execute in the preview page context (required for evaluate_javascript).",
+      type: "string",
+    },
+    text: {
+      description: "Text to find; required for `find_in_page`.",
+      type: "string",
+    },
+    forward: {
+      description: "Search direction for `find_in_page`; defaults to forward.",
+      type: "boolean",
+    },
+    match_case: {
+      description: "Case-sensitive search; defaults to false.",
+      type: "boolean",
+    },
+    wait_for_load_ms: {
+      description:
+        "Milliseconds to wait for the dom-ready event after navigation (default 5000, max 30000).",
+      type: "number",
+    },
+    preset: {
+      description: "Viewport preset for `set_viewport`.",
+      anyOf: [
+        {
+          const: "desktop",
+          type: "string",
+        },
+        {
+          const: "tablet",
+          type: "string",
+        },
+        {
+          const: "mobile",
+          type: "string",
+        },
+      ],
+    },
+    format: {
+      description: "Screenshot format; defaults to png.",
+      anyOf: [
+        {
+          const: "png",
+          type: "string",
+        },
+        {
+          const: "jpeg",
+          type: "string",
+        },
+      ],
+    },
+    ref: {
+      description: "Snapshot element ref for click, fill, hover, or inspect_element, e.g. `@e1`.",
+      type: "string",
+    },
+    value: {
+      description: "Value to type with `fill`.",
+      type: "string",
+    },
+    key: {
+      description: "Key to press, e.g. `Enter`, `Tab`, or `Escape`.",
+      type: "string",
+    },
+    selector: {
+      description: "CSS selector for `wait_for` and `inspect_element`.",
+      type: "string",
+    },
+    timeout_ms: {
+      description: "`wait_for` timeout in milliseconds; default 10000, max 60000.",
+      type: "number",
+    },
+    interactive_only: {
+      description: "Include only interactive snapshot elements; defaults to false.",
+      type: "boolean",
+    },
+    max_depth: {
+      description: "Maximum snapshot DOM depth; default 15.",
+      type: "number",
+    },
+    since_ms: {
+      description: "Return console logs from the last N milliseconds.",
+      type: "number",
+    },
+    levels: {
+      description: 'Console levels to include for get_console_logs (e.g. ["error", "warn"]).',
+      type: "array",
+      items: {
+        type: "string",
+      },
+    },
+    clear: {
+      description:
+        "Clear buffered console logs after reading for get_console_logs (default false).",
+      type: "boolean",
+    },
+    tool: {
+      description:
+        "WebMCP tool name from snapshot `webmcp_tools` or `webmcp_list_tools`; required for `webmcp_call`.",
+      type: "string",
+    },
+    input: {
+      description: "Object matching the WebMCP tool's inputSchema (optional for `webmcp_call`).",
+      type: "object",
+      patternProperties: {
+        "^(.*)$": {},
+      },
+    },
+    origin: {
+      description:
+        "Page origin that registered the WebMCP tool. Pass when `webmcp_list_tools` shows the same name on more than one origin.",
+      type: "string",
+    },
+  },
+};
+
+function stripScreenshotPayload(payload) {
+  const display = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (key === "image_data") continue;
+    if (typeof value === "string" || typeof value === "number") {
+      display[key] = value;
+    }
+  }
+  if (typeof display.imageUrl === "string" && display.imageUrl.startsWith("data:")) {
+    delete display.imageUrl;
+  }
+  return display;
+}
+
+function formatBrowserText(payload) {
+  if (payload.action === "screenshot") {
+    return JSON.stringify(stripScreenshotPayload(payload));
+  }
+  return JSON.stringify(payload);
+}
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context @param {{ signal?: AbortSignal, toolCallId?: string }} [options] */
+export async function execute(args, context, options) {
+  const structured = await context.browser.run(args, options);
+  const details =
+    typeof structured.details.imageUrl === "string"
+      ? { imageUrl: structured.details.imageUrl }
+      : structured.details;
+  return {
+    content: [{ type: "text", text: formatBrowserText(structured.payload) }],
+    details,
+  };
+}

package/dist/bundled-skills/tarsk-chat-title/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: tarsk-chat-title
+description: >-
+  Renames the chat label in the Chats list. Publishes the chat_title Tool.
+version: 3.0.0
+tools:
+  - chat_title
+disable-model-invocation: true
+---
+
+# Chat title
+
+Publishes `chat_title`. Implementation: `scripts/chat_title.js`. Runtime:
+`context.chat` (see `tarsk-agent`).

package/dist/bundled-skills/tarsk-chat-title/scripts/chat_title.js

@@ -0,0 +1,37 @@
+/**
+ * chat_title Tool — logic in the Skill; normalize via context.chat (host).
+ */
+
+export const description = `Rename the chat — the label above the chat and in the Chats list — when asked to title, name, rename, or label it, including a literal \`/chat-title\` in the prompt, which stays as typed.
+
+Title the work, not the sentence: 100 characters or fewer, plain sentence case, no surrounding quotes, no trailing punctuation, no emoji. Call once per request with the final title, then carry on with any other work the prompt asked for; don't announce the title in your reply.
+
+- Good: "Fix flaky auth test"
+- Bad: "Please set the chat title"`;
+
+export const parameters = {
+  type: "object",
+  properties: {
+    title: {
+      type: "string",
+      description: 'Short chat title, for example "Fix flaky auth test"',
+    },
+  },
+  required: ["title"],
+};
+
+function textResult(text) {
+  return {
+    content: [{ type: "text", text }],
+    details: undefined,
+  };
+}
+
+/** @param {{ title?: string }} args @param {{ chat: { normalizeTitle(title: string): string } }} context */
+export async function execute(args, context) {
+  const title = context.chat.normalizeTitle(String(args.title ?? ""));
+  if (!title) {
+    return textResult("Error: title is required");
+  }
+  return textResult(`Chat title set to "${title}".`);
+}

package/dist/bundled-skills/tarsk-connect-mcp/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: tarsk-connect-mcp
+description: >-
+  Connect a remote MCP server from chat. Ask for its name, URL, transport, and
+  whether it needs OAuth; save it to this project and discover its tools. Use
+  when the user asks to connect or configure a Model Context Protocol server.
+version: 1.0.0
+tools:
+  - connect_mcp
+deferred-tools:
+  - connect_mcp
+---
+
+# Connect an MCP server
+
+Use connect_mcp to ask the user for the remote MCP server details and connect
+it to the current project. The tool saves the server configuration, optionally
+runs browser-based OAuth, and discovers the server's tools. The current run's
+tool set is fixed. The discovered tools become available on the next message in
+the same conversation. Then search for the server name and call the selected tool.
+
+Do not ask the user to paste a bearer token or put credentials in the URL.
+Use OAuth or configure credentials through Settings.

package/dist/bundled-skills/tarsk-connect-mcp/scripts/__tests__/connect_mcp.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { description, execute, parameters } from "../connect_mcp.js";
+
+test("publishes a searchable no-argument MCP setup tool", () => {
+  assert.match(description, /connect a remote MCP server/i);
+  assert.deepEqual(parameters, { type: "object", properties: {} });
+});
+
+function runtime(answers, connectRemoteServer) {
+  return {
+    ask: {
+      wait: async function wait(questions, options) {
+        assert.equal(questions.length, 4);
+        assert.equal(options.toolCallId, "call-1");
+        return answers;
+      },
+    },
+    mcp: { connectRemoteServer },
+  };
+}
+
+test("asks for server settings, connects, and reports tools for the next message", async () => {
+  let connectArgs;
+  const result = await execute(
+    {},
+    runtime(
+      ["OWF", "https://mcp.example.com/mcp", "Streamable HTTP (Recommended)", "No OAuth"],
+      async function connect(input) {
+        connectArgs = input;
+        return {
+          serverName: "OWF",
+          state: "ok",
+          tools: ["search", "fetch"],
+          authenticated: false,
+        };
+      },
+    ),
+    { toolCallId: "call-1" },
+  );
+
+  assert.deepEqual(connectArgs, {
+    serverName: "OWF",
+    url: "https://mcp.example.com/mcp",
+    transport: "streamableHttp",
+    useOAuth: false,
+  });
+  assert.match(result.content[0].text, /search, fetch/);
+  assert.match(result.content[0].text, /next message in this conversation/);
+});
+
+test("does not save configuration when the user omits a required answer", async () => {
+  let connectCalled = false;
+  const result = await execute(
+    {},
+    runtime(
+      ["", "https://mcp.example.com/mcp", "Streamable HTTP", "No OAuth"],
+      async function connect() {
+        connectCalled = true;
+        return { serverName: "", state: "ok", tools: [], authenticated: false };
+      },
+    ),
+    { toolCallId: "call-1" },
+  );
+
+  assert.equal(connectCalled, false);
+  assert.match(result.content[0].text, /no configuration was saved/);
+});