Update to Corezoid

{
  "description": "Corezoid Git Call node specialist — run custom code (Python, Go, Java, PHP, JavaScript, Clojure, Lisp, Prolog, or a custom Dockerfile) as a step inside a process. Use when the user needs logic that plain nodes cannot do: parsing files, using external libraries, cryptography, building email/attachments, or any custom runtime. Activate on \"git call\", \"gitcall\", \"run my code\", \"parse a file\", \"use a library\", \"custom code node\", \"python/go/php in a process\", or \"why does push-process hang on git_call\". Load this skill only when the task is actually about git_call — it is not needed for ordinary flows.\n",
  "included_files": [],
  "name": "corezoid-gitcall",
  "skill_md_contents": "---\nname: corezoid-gitcall\ndescription: >\n  Corezoid Git Call node specialist — run custom code (Python, Go, Java, PHP,\n  JavaScript, Clojure, Lisp, Prolog, or a custom Dockerfile) as a step inside a\n  process. Use when the user needs logic that plain nodes cannot do: parsing\n  files, using external libraries, cryptography, building email/attachments, or\n  any custom runtime. Activate on \"git call\", \"gitcall\", \"run my code\",\n  \"parse a file\", \"use a library\", \"custom code node\", \"python/go/php in a\n  process\", or \"why does push-process hang on git_call\". Load this skill only\n  when the task is actually about git_call — it is not needed for ordinary flows.\n---\n\n# Corezoid Git Call\n\nA Git Call node runs your code (9 built-in languages, or a custom Docker image)\nin an isolated container as one step of a process. Each task is delivered to a\n`handle` function over JSON-RPC 2.0; the value you return becomes the payload of\nthe next node.\n\n## 1. When to use it — the selection rule\n\nGit Call is one of the most constrained nodes on the platform. Use it **only**\nwhen a step needs a capability that native nodes and a Code (`api_code`) node\ncannot provide — parsing a file, an external library, cryptography, or a custom\nruntime — **and** the work finishes comfortably within the observed runtime\nbudget. For everything else use the native alternative. \"One code block is\neasier to write\" is not one of those capabilities.\n\n### Runtime and resource constraints\n\n- **Observed execution deadline:** hosted sandbox measurements terminated the\n  handler at approximately 60 s, wall-clock from the moment the task entered the\n  node. Keep handler work comfortably below 50 s rather than relying on the exact\n  cutoff, which is an observed platform behavior rather than a portable contract.\n  On overrun the task was killed and routed to the error path\n  (`__conveyor_git_call_return_type_tag__ = git_call_executing_error`, description\n  `usercode: timeout`). In those measurements, inline cold and warm runs ended at\n  the same point; custom images may have different startup overhead.\n- **Default resource allocation:** 50 MB RAM and 0.1 CPU from a pool shared by\n  Git Call nodes. These are defaults, not immutable hard limits: a super-admin can\n  change the allocation. Shared capacity can still cause contention under\n  concurrency; one live concurrent probe observed a starved task.\n- **No persistent local storage:** runtime-local files, including writable\n  `/tmp`, are ephemeral and must not be used as state between runs.\n- **Build-time network dependency:** Git-repo mode and dependency installation\n  need network access. Runtime network access is required only when the handler\n  itself calls an external service.\n\nFor work that waits, polls, or retries over time, model progress as process state\ntransitions (`condition`+`delay`) or resume through a callback. Those patterns do\nnot hold one Git Call handler open, but they remain subject to normal\nplatform/process limits.\n\n### Decision gate — before adding a Git Call, confirm ALL of these\n\n1. It genuinely cannot be done with native nodes (`set_param`, `condition`, `delay`,\n   `api`/`api_rpc`, `api_code`, `db_call`, `api_sum`, `api_copy`).\n2. It cannot be done in a **Code (`api_code`)** node (JS with the platform's\n   built-ins) — try this first for any transform/parse/compute.\n3. It comfortably finishes below the observed ~50 s working budget and the\n   surrounding flow does not require tighter, predictable latency under load.\n4. It is **not** a long-running loop, poll, or wait — those belong in\n   process state transitions (`condition`+`delay`) or a callback, never in one\n   Git Call invocation.\n5. It fits the configured resource allocation and does **not** need persistent\n   local state.\n\nIf any answer is \"no\", do **not** use Git Call.\n\n### Use Git Call ONLY for (native nodes truly cannot):\n\n- Parse a file (download a URL and read a 1C `.1CD`, XML, PDF, QR, image, …).\n- Use an external library the platform lacks (crypto, moment, pandas, okhttp, …).\n- Cryptography / bespoke binary formats the platform can't express.\n- A custom runtime (custom Dockerfile) for something none of the above covers.\n\n### NEVER use Git Call for:\n\n- Work that might approach the observed ~50 s budget, or a latency-critical path\n  that requires predictable execution time under concurrency.\n- **Long-running** work — loops, polling, ret/backoff, waiting on an external\n  system (→ process state with `condition`+`delay`, or a callback).\n- Plain HTTP calls (→ `api`/`api_rpc`).\n- Simple transforms, JSON shaping, math, string work (→ `api_code`).\n- Large-data / high-memory processing that does not fit the configured shared\n  resource allocation.\n\n| Aspect        | Native nodes / `api_code` | Git Call |\n|---------------|---------------------------|----------|\n| Runtime model | Platform node execution | Container handler; ~60 s deadline observed in hosted tests |\n| Warm-up       | None for ordinary native nodes | Container build + dispatch |\n| Memory / CPU  | Platform-managed | 50 MB / 0.1 CPU defaults from a shared, configurable pool |\n| Concurrency   | Node-specific | Shared capacity can introduce contention |\n| State/storage | Task/process state | No persistent local storage; `/tmp` is ephemeral |\n| External deps | Built-in capabilities | External libraries and custom runtimes supported |\n\nSelection rule: **default to native nodes + `api_code`. Use Git Call only when a\nfile to parse, an external library, cryptography, or a custom runtime leaves no\nnative way to do it, and keep each invocation short, bounded, and within the\nconfigured resource allocation.**\n\n## 2. Supported languages and runtimes\n\n| Language   | Version       | Package manager | OS               |\n|------------|---------------|-----------------|------------------|\n| JavaScript | node v20      | yarn, npm       | alpine 3.17      |\n| Go         | v1.23         | go mod          | alpine 3.20      |\n| Python     | v3.12         | pip             | alpine 3.17      |\n| Java       | v22           | gradle          | alpine 3.15      |\n| PHP        | v8.3          | composer 2.5.4  | alpine 3.17      |\n| Clojure    | v1.11.1       | lein 2.10       | alpine 3.17      |\n| Lisp       | v2.4.8        | roswell         | Ubuntu 18.04     |\n| Prolog     | swipl v9.2.7  | swipl           | debian bullseye  |\n| Dockerfile | any           | —               | your own image   |\n\nGit Call requests originate from `54.171.15.37`, `108.128.68.222`,\n`63.33.226.230`. Whitelist these if a private repo or resource blocks access.\n\n## 3. Handler contract (per language)\n\nThe handler receives the task payload and returns the next payload (or throws to\nproduce an error). In Git-Repo mode the entry file is `usercode.<ext>`.\n\n```python\n# python — usercode.py\ndef handle(data):\n    data['result'] = 'ok'\n    return data\n```\n```javascript\n// js — usercode.js  (CommonJS; for ESM use import/export default, .mjs, or \"type\":\"module\")\nmodule.exports = (data) => { data.result = 'ok'; return data; };\n```\n```go\n// go — usercode.go\npackage main\nimport (\"context\"; \"github.com/corezoid/gitcall-go-runner/gitcall\")\nfunc usercode(_ context.Context, data map[string]interface{}) error { data[\"result\"]=\"ok\"; return nil }\nfunc main() { gitcall.Handle(usercode) }\n```\n```php\n// php — usercode.php\n<?php\nfunction handle($data) { $data['result']=\"ok\"; return $data; }\n```\n```java\n// java — Usercode.java  (fully-qualified name com.corezoid.usercode.Usercode is mandatory)\npackage com.corezoid.usercode;\nimport com.corezoid.gitcall.runner.api.UsercodeHandler;\nimport java.util.Map;\npublic class Usercode implements UsercodeHandler<Map<String,String>,Map<String,String>> {\n  public Map<String,String> handle(Map<String,String> data) throws Exception { data.put(\"result\",\"ok\"); return data; }\n}\n```\n```prolog\n% prolog — usercode.pl\n:- module(usercode, [handle/2]).\nhandle(Data, Result) :- put_dict(result, Data, \"ok\", Result).\n```\n```lisp\n;; lisp — usercode.lisp\n(defpackage #:usercode (:use #:cl) (:export :handle))\n(in-package #:usercode)\n(defun handle (data) (setf (gethash 'result data) 'ok) data)\n```\n```clojure\n;; clojure — usercode.clj\n(ns usercode.usercode)\n(defn handle [data] (assoc data :result \"ok\"))\n```\n\nRunnable examples (`hello_world`, `http_request`, `user_error`, dependency demos)\nfor every language: <https://github.com/corezoid/gitcall-examples>.\n\n## 4. Two modes\n\n- **Code editor (inline)** — paste the code straight into the node.\n- **Git Repo** — set the repo URL, the branch/tag/commit, the path (leave empty\n  if the entry file is in the repo root), and the entry file. Use an SSH key on\n  the node for private repos.\n\n## 5. Dependencies (Build command)\n\nInstall dependencies with a Build command (Code editor) or a manifest file\n(Git Repo):\n\n| Language | Build command (Code editor)                              | Manifest (Git Repo) |\n|----------|----------------------------------------------------------|---------------------|\n| JS       | `npm install crypto-js@4.1.1 moment@2.29.4`              | `package.json`      |\n| Python   | `pip install 'pycryptodomex==3.20'`                      | `requirements.txt`  |\n| Go       | (latest versions resolved automatically)                | `go.mod`            |\n| Java     | a gradle command                                         | `build.gradle` (+ `./gradlew build`) |\n| PHP      | `composer require guzzlehttp/guzzle:^7.0`                | `composer.json`     |\n| Clojure  | `lein change :dependencies conj '[...]' && lein install` | `project.clj`       |\n| Lisp     | none — `(ql:quickload '(:cl-mustache) :silent t)` in code | —                  |\n| Prolog   | `swipl -g \"pack_install(matrix,[interactive(false)]).\"`  | (same command)      |\n\nNo dependencies → empty Build command.\n\n## 6. Deploy with the MCP\n\n`push-process` deploys Git Call nodes automatically (as of the git_call build\nsupport in this plugin). Just author the node like any other and push:\n\n1. Add a node whose logic `type` is `git_call`, set `lang` and either `code`\n   (inline) or `repo`/`commit`/`path`/`script` (Git Repo).\n2. `push-process` — it uploads the source, builds the container on the build\n   service, and commits. Every runtime (JavaScript included) is built before the\n   commit; JavaScript just builds fastest (a few seconds) since it installs no\n   compiler toolchain.\n\nBuilds take ~5 s (JavaScript) to ~20–120 s (compiled runtimes, first build with\ndependency install), then build from cache. `run-task` reports the task settling\non a non-final node while the build runs — that is expected; the result merges\ninto the task payload asynchronously.\n\nOverride the build endpoint for on-prem installs with `COREZOID_WS_URL`.\n\n### What push-process does under the hood\nThe container build runs on Corezoid's build service and is driven over a\nWebSocket (`wss://ws.<host>/api/1/sock_json`), authenticated with the same\nSimulator access token as the HTTP API. `push-process` opens the socket after\nuploading the source, sends a `monitor_show`/`function_build`/`status:\"on\"`\nframe to start the build, keeps the socket alive (client sends `\"0\"`, server\nanswers `\"1\"`), waits for `log:{\"type\":\"done\"}`, then commits. You do not need to\ndo any of this by hand — it is only useful to know when debugging a build.\n\n## 7. JSON-RPC 2.0 protocol\n\nRequest to your code: `{\"jsonrpc\":\"2.0\",\"method\":\"handle\",\"id\":\"…\",\"params\":{…}}`.\nSuccess: `{\"jsonrpc\":\"2.0\",\"id\":\"…\",\"result\":{…}}`. Error:\n`{\"jsonrpc\":\"2.0\",\"id\":\"…\",\"error\":{\"code\":…,\"message\":\"…\"}}`.\n\nFor a **custom Dockerfile**, run an HTTP server on `$GIT_CALL_PORT`, handle POST\nrequests per JSON-RPC 2.0, run as user `501:501`, and treat the container as\nread-only (`/tmp` is writable).\n\n## 8. Errors and troubleshooting\n\nOn failure the task carries these fields (routed to the auxiliary condition\noutput): `__conveyor_git_call_return_type_error__` (`Hardware` = system, retry;\n`Software` = code/settings), `__conveyor_git_call_return_type_tag__`\n(`git_call_return_format_error`, `git_call_executing_error`,\n`git_call_is_not_supported` = the node is v1, use v2, `code_return_size_overflow`,\n`git_call_fatal_error`), and `__conveyor_git_call_return_type_description__`.\n\nCommon issues:\n\n- **push-process hangs / `no response from server`** — an older plugin without\n  git_call build support. Upgrade the plugin.\n- **`source has to be built`** — the container was not built before commit\n  (should not happen via push-process; if authoring by hand, build first).\n- **`usercode module has no handle function`** — the entry `handle` is missing,\n  or a stale build instance — rebuild.\n- **Build fails on root access** — Corezoid forbids root; keep to allowed dirs.\n- **No internet** — Git Call needs network to fetch the repo/dependencies.\n\n## 9. Resources\n\nEach container defaults to 100 millicpu (0.1 CPU) and 50 MB RAM from a resource\npool shared by Git Call nodes. The exact scope and allocation are\ndeployment-specific; ask a super-admin to inspect or adjust them before relying\non Git Call for heavier or highly concurrent workloads.\n\n## Reference\n\n- Examples (all languages + custom Dockerfiles): <https://github.com/corezoid/gitcall-examples>\n- Go runner: <https://github.com/corezoid/gitcall-go-runner>\n"
}